Create JSON helper

src/middleware.rs

             let body: String = routes::render_template("error.html", &context)?;
             res.set_body(body);
             res.set_status(status);
+            res.set_content_type(mime::HTML);
         }
         None => match res.status() {
             StatusCode::NotFound => {
                 context.insert("error", "Page not found");
                 res.set_body(routes::render_template("error.html", &context)?);
+                res.set_content_type(mime::HTML);
             }
             _ => {}
         },
     };
 
-    res.set_content_type(mime::HTML);
     Ok(res)
 }

src/routes.rs

 use chrono::prelude::Local;
 use serde::{Deserialize, Serialize};
 use tera::{Context, Tera};
+use tide::convert::json;
 use tide::http::mime;
 use tide::{Redirect, Request, Response, Result, StatusCode};
 use uuid::Uuid;
     let posts: Vec<Post> = fs::get_all_posts().await?;
     let mut context = Context::new();
     context.insert("posts", &posts);
-    render_response("index.html", &context, req)
+    render_html_response("index.html", &context, req)
 }
 
 pub async fn single_post(req: Request<State>) -> Result {
     let post_id = req.param("id")?;
     let post = fs::get_one_post(post_id).await?;
     context.insert("post", &post);
-    render_response("single.html", &context, req)
+    render_html_response("single.html", &context, req)
 }
 
 pub async fn edit_post(req: Request<State>) -> Result {
     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, req)
+    render_html_response("edit.html", &context, req)
 }
 
 pub async fn create_post(mut req: Request<State>) -> Result {
     let id: String = req.param("id")?;
     fs::delete_post(id)?;
     req.session_mut().insert("flash_success", String::from("Post deleted successfully"))?;
-    let mut res = Response::new(StatusCode::Ok);
-    res.set_body("{\"success\": \"true\"}");
-    res.set_content_type(mime::JSON);
-    Ok(res)
+    render_json_response(json!({ "success": "true" }))
 }
 
 pub async fn login_page(req: Request<State>) -> Result {
-    render_response("login.html", &Context::new(), req)
+    render_html_response("login.html", &Context::new(), req)
 }
 
 pub async fn login(mut req: Request<State>) -> Result {
     Ok(Redirect::new("/").into())
 }
 
-pub fn render_response(
+pub fn render_html_response(
     template: &str,
     context: &Context,
     req: Request<State>,
     Ok(res)
 }
 
+pub fn render_json_response(json: serde_json::Value) -> Result<Response> {
+    let res = Response::builder(StatusCode::Ok)
+        .body(json)
+        .content_type(mime::JSON)
+        .build();
+
+    Ok(res)
+}
+
+fn redirect(path: &str) -> Result<Response> {
+    Ok(Redirect::new(path).into())
+}
+
 pub fn render_template(template: &str, context: &Context) -> Result<String> {
     let tera = Tera::new("templates/**/*.html")?;
     let html = tera.render(template, &context)?;
     Ok(html)
 }
 
-fn redirect(path: &str) -> Result<Response> {
-    Ok(Redirect::new(path).into())
-}
 
 fn prepare_flash_messages(mut req: Request<State>) -> Context {
     let mut context = Context::new();