oslo/src/main.rs

use std::env;
use std::ffi::OsStr;
use std::fs::{read_dir, File};
use std::io::prelude::*;
use std::io::{Error, ErrorKind};
use std::path::PathBuf;

use async_std::fs::read_to_string;
use chrono::prelude::Local;
use dotenv;
use serde::{Deserialize, Serialize};
use serde_json;
use tera::{Context, Tera};
use tide::utils::After;
use tide::{Body, Response, StatusCode};
use uuid::Uuid;

#[derive(Debug, Serialize, Deserialize)]
struct Post {
    id: String,
    title: String,
    body: String,
    date: String,
}

impl Post {
    fn save(&mut self) -> std::io::Result<()> {
        let mut path: PathBuf = get_posts_directory()?;
        let filename = format!("{}.json", self.id);
        path = path.join(&filename);
        let mut file = match File::create(&path) {
            Err(why) => panic!("couldn't create {}: {}", self.id, why),
            Ok(file) => file,
        };
        match file.write_all(serde_json::to_string(&self)?.as_bytes()) {
            Err(why) => Err(Error::new(
                ErrorKind::Other,
                format!("couldn't write to {}.json: {}", self.id, why),
            )),
            Ok(_) => Ok(()),
        }
    }
}

fn get_posts_directory() -> Result<PathBuf, Error> {
    match env::var("POSTS_DIR") {
        Ok(dir) => Ok(dir.into()),
        Err(_) => Err(Error::new(
            ErrorKind::Other,
            "Posts directory environment variable not set",
        )),
    }
}

async fn read_all_posts() -> Result<Vec<Post>, Error> {
    let path = get_posts_directory()?;
    let mut posts: Vec<Post> = vec![];

    for file in read_dir(path)? {
        let file = file?;
        if let Some("json") = file.path().extension().and_then(OsStr::to_str) {
            let contents = read_to_string(file.path()).await?;
            let mut post: Post = serde_json::from_str(&contents)?;
            post.body = post.body.replace("\n", "<br>");
            posts.push(post);
        }
    }

    Ok(posts)
}

#[async_std::main]
async fn main() -> std::io::Result<()> {
    dotenv::dotenv().ok();
    tide::log::start();
    let mut app = tide::new();

    app.with(After(|mut res: Response| async {
        if let Some(err) = res.downcast_error::<async_std::io::Error>() {
            println!("{:?}", res);
            if let ErrorKind::NotFound = err.kind() {
                res.set_status(StatusCode::NotFound);
            }
        }

        Ok(res)
    }));

    app.with(After(|mut res: Response| async {
        res.set_content_type(tide::http::mime::HTML);
        Ok(res)
    }));

    app.at("/admin").get(|_| async {
        let tera = Tera::new("templates/**/*.html")?;
        let posts = read_all_posts().await?;
        let mut context = Context::new();
        context.insert("posts", &posts);
        let html = tera.render("admin/index.html", &context)?;
        Ok(Body::from_string(html))
    });

    app.at("/admin/posts")
        .post(|mut req: tide::Request<()>| async move {
            let mut post: Post = req.body_form().await?;
            post.id = Uuid::new_v4().to_string();
            post.date = Local::now().date().naive_local().to_string();
            post.body = post.body.trim().to_owned();
            post.save()?;
            Ok(tide::Redirect::new("/admin"))
        });

    app.listen("127.0.0.1:8080").await?;

    Ok(())
}