Update

backend/src/web/mod.rs

@@ -0,0 +1,176 @@
+use actix_web::{get, http, web, HttpResponse};
+use actix_web_static_files::ResourceFiles;
+use askama_actix::TemplateToResponse;
+use diesel::prelude::*;
+use r2d2_redis::redis;
+use std::ops::DerefMut;
+
+use crate::{cache, config, db, markdown};
+
+pub mod templates;
+
+pub mod static_dir {
+    include!(concat!(env!("OUT_DIR"), "/generated.rs"));
+}
+
+async fn not_found() -> HttpResponse {
+    let mut resp = templates::StatusCode {
+        status_code: http::StatusCode::NOT_FOUND,
+        message: Some("maybe try a correct url?".to_string()),
+    }
+    .to_response();
+    *resp.status_mut() = http::StatusCode::NOT_FOUND;
+
+    resp
+}
+
+#[get("/posts")]
+async fn posts(db_pool: web::Data<db::DbPool>) -> HttpResponse {
+    let db_conn = &mut match db_pool.get() {
+        Ok(x) => x,
+        Err(e) => return HttpResponse::InternalServerError().body(format!("{:?}", e)),
+    };
+
+    let posts = match db::schema::posts::table
+        .filter(db::schema::posts::active)
+        .order(db::schema::posts::published_at.desc())
+        .load::<db::models::Post>(db_conn)
+    {
+        Ok(x) => x,
+        Err(e) => {
+            return HttpResponse::InternalServerError().body(format!("{:?}", e));
+        }
+    };
+
+    templates::Posts { posts }.to_response()
+}
+
+#[get("/")]
+async fn index() -> HttpResponse {
+    templates::Index.to_response()
+}
+
+#[get("/about")]
+async fn about() -> HttpResponse {
+    templates::About.to_response()
+}
+
+#[get("/posts/{slug}")]
+async fn post_by_slug(
+    db_pool: web::Data<db::DbPool>,
+    redis_pool: web::Data<cache::RedisPool>,
+    path: web::Path<String>,
+) -> HttpResponse {
+    let slug = path.into_inner();
+
+    let db_conn = &mut match db_pool.get() {
+        Ok(x) => x,
+        Err(e) => return HttpResponse::InternalServerError().body(format!("{:?}", e)),
+    };
+    let redis_conn = &mut match redis_pool.get() {
+        Ok(x) => x,
+        Err(e) => return HttpResponse::InternalServerError().body(format!("{:?}", e)),
+    };
+
+    let post_stripped: Option<(i32, String)> = match db::schema::posts::table
+        .select((db::schema::posts::id, db::schema::posts::name))
+        .filter(db::schema::posts::slug.eq(&slug))
+        .filter(db::schema::posts::active)
+        .get_result::<(i32, String)>(db_conn)
+        .optional()
+    {
+        Ok(x) => x,
+        Err(e) => {
+            return HttpResponse::InternalServerError().body(format!("{:?}", e));
+        }
+    };
+
+    match post_stripped {
+        Some(stripped) => {
+            let (stripped_id, stripped_name) = stripped;
+
+            let key = cache::keys::post_content(stripped_id);
+
+            match match redis::cmd("GET")
+                .arg(&key)
+                .query::<Option<String>>(redis_conn.deref_mut())
+            {
+                Ok(x) => x,
+                Err(e) => return HttpResponse::InternalServerError().body(format!("{:?}", e)),
+            } {
+                Some(s) => templates::PostBySlug {
+                    name: stripped_name,
+                    slug,
+                    content: s,
+                }
+                .to_response(),
+                None => {
+                    let post = match db::schema::posts::table
+                        .filter(db::schema::posts::id.eq(stripped_id))
+                        .first::<db::models::Post>(db_conn)
+                    {
+                        Ok(x) => x,
+                        Err(e) => {
+                            return HttpResponse::InternalServerError().body(format!("{:?}", e));
+                        }
+                    };
+
+                    let html = markdown::to_html(&post.content);
+
+                    match redis::cmd("SET")
+                        .arg(&key)
+                        .arg(&html)
+                        .query::<Option<String>>(redis_conn.deref_mut())
+                    {
+                        Ok(x) => x,
+                        Err(e) => {
+                            return HttpResponse::InternalServerError().body(format!("{:?}", e))
+                        }
+                    };
+                    if let Err(e) = redis::cmd("EXPIRE")
+                        .arg(key)
+                        .arg(config::CONFIG.cache_post_content_ttl)
+                        .query::<()>(redis_conn.deref_mut())
+                    {
+                        return HttpResponse::InternalServerError().body(format!("{:?}", e));
+                    }
+
+                    templates::PostBySlug {
+                        name: post.name,
+                        slug: post.slug,
+                        content: html,
+                    }
+                    .to_response()
+                }
+            }
+        }
+        None => {
+            let mut resp = templates::StatusCode {
+                status_code: http::StatusCode::NOT_FOUND,
+                message: Some("this post does not exists... yet".to_string()),
+            }
+            .to_response();
+            *resp.status_mut() = http::StatusCode::NOT_FOUND;
+
+            resp
+        }
+    }
+}
+
+fn setup_routes(cfg: &mut web::ServiceConfig) {
+    let generated = static_dir::generate();
+
+    cfg.service(index)
+        .service(about)
+        .service(posts)
+        .service(ResourceFiles::new("/static", generated))
+        .service(post_by_slug)
+        .default_service(web::route().to(not_found));
+}
+
+pub fn init(cfg: &mut web::ServiceConfig) {
+    cfg.app_data(web::Data::new(db::pool().unwrap()))
+        .app_data(web::Data::new(cache::pool().unwrap()));
+
+    setup_routes(cfg);
+}