oslo/src/main.rs

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

use dotenv;
use serde::{Deserialize, Serialize};
use serde_json;
use tide::utils::After;

mod fs;
mod middleware;
mod routes;

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

impl Post {
    async fn save(&mut self) -> std::io::Result<()> {
        let mut path: PathBuf = fs::get_posts_directory_path().await?;
        let filename = format!("{}.json", self.id);
        path = path.join(&filename);
        let mut file = File::create(&path)?;
        file.write_all(serde_json::to_string(&self)?.as_bytes())?;
        Ok(())
    }

    fn from_str(blob: &str) -> Result<Post, Error> {
        let mut post: Post = match serde_json::from_str(blob) {
            Ok(p) => Ok(p),
            Err(_) => Err(Error::new(
                ErrorKind::Other,
                format!("Error deserializing post"),
            )),
        }?;
        post.body = post.body.replace("\n", "<br>");
        Ok(post)
    }
}

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

    app.with(After(middleware::errors));
    app.with(middleware::session());

    app.at("/").get(routes::index);
    app.at("/posts").post(routes::create_post);
    app.at("/posts/:id").get(routes::single_post);
    app.at("/posts/:id/edit").get(routes::edit_post);
    app.at("/login").get(routes::login_page).post(routes::login);
    app.at("/logout").post(routes::logout);

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

    Ok(())
}