Refactor routes into module

src/main.rs

@@ -1,19 +1,17 @@
-use std::env;
 use std::fs::File;
 use std::io::prelude::*;
 use std::io::{Error, ErrorKind};
 use std::path::PathBuf;
 
-use chrono::prelude::Local;
 use dotenv;
 use serde::{Deserialize, Serialize};
 use serde_json;
-use tera::{Context, Tera};
+use tera::Context;
 use tide::utils::After;
-use tide::{Body, Response, StatusCode};
-use uuid::Uuid;
+use tide::{Response, StatusCode};
 
 mod fs;
+mod routes;
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Post {
@@ -23,12 +21,6 @@ pub struct Post {
     date: String,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-struct User {
-    username: String,
-    password: String,
-}
-
 impl Post {
     async fn save(&mut self) -> std::io::Result<()> {
         let mut path: PathBuf = fs::get_posts_directory_path().await?;
@@ -52,12 +44,6 @@ impl Post {
     }
 }
 
-fn render(template: &str, context: &Context) -> Result<Body, tide::Error> {
-    let tera = Tera::new("templates/**/*.html")?;
-    let html = tera.render(template, &context)?;
-    Ok(Body::from_string(html))
-}
-
 #[async_std::main]
 async fn main() -> std::io::Result<()> {
     dotenv::dotenv().ok();
@@ -75,13 +61,13 @@ async fn main() -> std::io::Result<()> {
                 } else {
                     StatusCode::InternalServerError
                 };
-                res.set_body(render("error.html", &context)?);
+                res.set_body(routes::render_template("error.html", &context)?);
                 res.set_status(status);
             }
             None => match res.status() {
                 StatusCode::NotFound => {
                     context.insert("error", "Page not found");
-                    res.set_body(render("error.html", &context)?);
+                    res.set_body(routes::render_template("error.html", &context)?);
                 }
                 _ => {}
             },
@@ -105,82 +91,12 @@ async fn main() -> std::io::Result<()> {
             .as_bytes(),
     ));
 
-    app.at("/").get(|req: tide::Request<()>| async move {
-        let posts: Vec<Post> = fs::get_all_posts().await?;
-        let mut context = Context::new();
-        context.insert("posts", &posts);
-        let logged_in: bool = req.session().get("logged_in").unwrap_or(false);
-        context.insert("logged_in", &logged_in);
-        render("index.html", &context)
-    });
-
-    app.at("/posts")
-        .post(|mut req: tide::Request<()>| async move {
-            let logged_in: bool = req.session().get("logged_in").unwrap_or(false);
-            if !logged_in {
-                Ok(tide::Redirect::new("/login"))
-            } else {
-                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().await?;
-                Ok(tide::Redirect::new("/"))
-            }
-        });
-
-    app.at("/posts/:id")
-        .get(|req: tide::Request<()>| async move {
-            let mut context = Context::new();
-            let logged_in: bool = req.session().get("logged_in").unwrap_or(false);
-            context.insert("logged_in", &logged_in);
-            let post_id = req.param("id")?;
-            let post = fs::get_one_post(post_id).await?;
-            context.insert("post", &post);
-            render("single.html", &context)
-        });
-
-    app.at("/login")
-        .get(|mut req: tide::Request<()>| async move {
-            let mut context = Context::new();
-            let logged_in: bool = req.session().get("logged_in").unwrap_or(false);
-            context.insert("logged_in", &logged_in);
-            match req.session_mut().get::<String>("flash_error") {
-                Some(error) => {
-                    req.session_mut().remove("flash_error");
-                    &context.insert("error", &error);
-                }
-                None => {}
-            }
-            render("login.html", &context)
-        })
-        .post(|mut req: tide::Request<()>| async move {
-            let logged_in: bool = req.session().get("logged_in").unwrap_or(false);
-            if logged_in {
-                return Ok(tide::Redirect::new("/"));
-            }
-
-            let username = env::var("ADMIN_USERNAME")?;
-            let password = env::var("ADMIN_PASSWORD")?;
-            let user: User = req.body_form().await?;
-            if user.username == username && user.password == password {
-                req.session_mut().remove("logged_in");
-                req.session_mut().insert("logged_in", true)?;
-                Ok(tide::Redirect::new("/"))
-            } else {
-                req.session_mut().remove("logged_in");
-                req.session_mut()
-                    .insert("flash_error", "Invalid credentials")?;
-                Ok(tide::Redirect::new("/login"))
-            }
-        });
-
-    app.at("/logout")
-        .post(|mut req: tide::Request<()>| async move {
-            req.session_mut().remove("logged_in");
-            req.session_mut().insert("logged_in", false)?;
-            Ok(tide::Redirect::new("/"))
-        });
+    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?;
 

src/routes.rs

@@ -0,0 +1,119 @@
+use chrono::prelude::Local;
+use serde::{Deserialize, Serialize};
+use tera::{Context, Tera};
+use tide::http::mime;
+use tide::{Request, Response, Result, StatusCode};
+use uuid::Uuid;
+
+use std::env;
+
+use crate::{fs, Post};
+
+#[derive(Debug, Serialize, Deserialize)]
+struct User {
+    username: String,
+    password: String,
+}
+
+pub async fn index(req: Request<()>) -> Result {
+    let posts: Vec<Post> = fs::get_all_posts().await?;
+    let mut context = Context::new();
+    context.insert("posts", &posts);
+    let logged_in: bool = req.session().get("logged_in").unwrap_or(false);
+    context.insert("logged_in", &logged_in);
+    render_response("index.html", &context)
+}
+
+pub async fn create_post(mut req: Request<()>) -> Result {
+    let logged_in: bool = req.session().get("logged_in").unwrap_or(false);
+    if !logged_in {
+        Ok(tide::Redirect::new("/login").into())
+    } else {
+        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().await?;
+        Ok(tide::Redirect::new("/").into())
+    }
+}
+
+pub async fn single_post(req: Request<()>) -> Result {
+    let mut context = Context::new();
+    let logged_in: bool = req.session().get("logged_in").unwrap_or(false);
+    context.insert("logged_in", &logged_in);
+    let post_id = req.param("id")?;
+    let post = fs::get_one_post(post_id).await?;
+    context.insert("post", &post);
+    render_response("single.html", &context)
+}
+
+pub async fn edit_post(req: Request<()>) -> Result {
+    let logged_in: bool = req.session().get("logged_in").unwrap_or(false);
+    if !logged_in {
+        Ok(tide::Redirect::new("/login").into())
+    } else {
+        let mut context = Context::new();
+        context.insert("logged_in", &logged_in);
+        let post_id = req.param("id")?;
+        let mut post = fs::get_one_post(post_id).await?;
+        post.body = post.body.replace("<br>", "\n");
+        context.insert("post", &post);
+        render_response("edit.html", &context)
+    }
+}
+
+pub async fn login_page(mut req: Request<()>) -> Result {
+    let mut context = Context::new();
+    let logged_in: bool = req.session().get("logged_in").unwrap_or(false);
+    context.insert("logged_in", &logged_in);
+    match req.session_mut().get::<String>("flash_error") {
+        Some(error) => {
+            req.session_mut().remove("flash_error");
+            &context.insert("error", &error);
+        }
+        None => {}
+    }
+    render_response("login.html", &context)
+}
+
+pub async fn login(mut req: Request<()>) -> Result {
+    let logged_in: bool = req.session().get("logged_in").unwrap_or(false);
+    if logged_in {
+        return Ok(tide::Redirect::new("/").into());
+    }
+
+    let username = env::var("ADMIN_USERNAME")?;
+    let password = env::var("ADMIN_PASSWORD")?;
+    let user: User = req.body_form().await?;
+    if user.username == username && user.password == password {
+        req.session_mut().remove("logged_in");
+        req.session_mut().insert("logged_in", true)?;
+        Ok(tide::Redirect::new("/").into())
+    } else {
+        req.session_mut().remove("logged_in");
+        req.session_mut()
+            .insert("flash_error", "Invalid credentials")?;
+        Ok(tide::Redirect::new("/login").into())
+    }
+}
+
+pub async fn logout(mut req: Request<()>) -> Result {
+    req.session_mut().remove("logged_in");
+    req.session_mut().insert("logged_in", false)?;
+    Ok(tide::Redirect::new("/").into())
+}
+
+pub fn render_response(template: &str, context: &Context) -> Result<Response> {
+    let html = render_template(template, context)?;
+    let mut res = Response::new(StatusCode::Ok);
+    res.set_body(html);
+    res.set_content_type(mime::HTML);
+    Ok(res)
+}
+
+pub fn render_template(template: &str, context: &Context) -> Result<String> {
+    let tera = Tera::new("templates/**/*.html")?;
+    let html = tera.render(template, &context)?;
+    Ok(html)
+}

templates/components.html

@@ -16,4 +16,36 @@
     {{ post.body | safe }}
   </div>
 </div>
+{% endmacro %} {% macro form(post=false, action, method) %}
+<form class="form" method="{{ method }}" action="{{ action }}">
+  <input
+    type="hidden"
+    name="id"
+    value="{% if post %}{{ post.id }}{% endif %}"
+  />
+  <input
+    type="hidden"
+    name="date"
+    value="{% if post %}{{ post.date }}{% endif %}"
+  />
+  <div class="form__field">
+    <label for="title" class="form__label">Title</label>
+    <input
+      class="form__text-field"
+      type="text"
+      name="title"
+      required
+      value="{% if post %}{{ post.title }}{% endif %}"
+    />
+  </div>
+  <div class="form__field">
+    <label for="body" class="form__label">Body</label>
+    <textarea class="form__textarea" name="body" required>
+{% if post %}{{ post.body }}{% endif %}</textarea
+    >
+  </div>
+  <div class="form__field">
+    <input class="btn" type="submit" value="Post" />
+  </div>
+</form>
 {% endmacro %}

templates/edit.html

@@ -0,0 +1,5 @@
+{% extends "layout.html" %} {% block content %}
+<div class="posts">
+  {{ components::form(post=post, action="/posts/{{ post.id }}", method="PUT") }}
+</div>
+{% endblock %}

templates/index.html

@@ -1,21 +1,6 @@
 {% extends "layout.html" %} {% block content %} {% if logged_in %}
 <h1 class="heading">New Post</h1>
-<form class="form" method="POST" action="/posts">
-  <input type="hidden" name="id" />
-  <input type="hidden" name="date" />
-  <div class="form__field">
-    <label for="title" class="form__label">Title</label>
-    <input class="form__text-field" type="text" name="title" required />
-  </div>
-  <div class="form__field">
-    <label for="body" class="form__label">Body</label>
-    <textarea class="form__textarea" name="body" required></textarea>
-  </div>
-  <div class="form__field">
-    <input class="btn" type="submit" value="Post" />
-  </div>
-</form>
-{% endif %}
+{{ components::form(action="/posts", method="POST") }} {% endif %}
 
 <div class="posts">
   {% for post in posts %} {{ components::post(post=post, type="index") }} {%