static template context for errors

Cargo.lock

@@ -1455,6 +1455,7 @@ name = "qchgk_web"
 version = "0.2.0"
 dependencies = [
  "chgk_ledb_lib",
+ "lazy_static",
  "mini-moka",
  "rand",
  "rocket",

Cargo.toml

@@ -15,6 +15,7 @@ rocket = { version = "=0.5.0-rc.3", features = ["json"] }
 rocket_dyn_templates = { version = "=0.1.0-rc.3", features = ["tera"] }
 chgk_ledb_lib = {git = "https://gitea.b4tman.ru/b4tman/chgk_ledb.git", rev="699478f85e", package="chgk_ledb_lib", features=["async"]}
 mini-moka = "0.10.0"
+lazy_static = "1.4.0"
 
 [profile.release]
 opt-level = 3

src/main.rs

@@ -2,7 +2,11 @@
 extern crate rocket;
 
 use rocket::fs::FileServer;
+use rocket::fs::Options;
+use rocket::http::ContentType;
+use rocket::request::Request;
 use rocket::response::Redirect;
+use rocket::response::{self, Responder, Response};
 use rocket::State;
 use rocket_dyn_templates::tera;
 use rocket_dyn_templates::Template;
@@ -10,6 +14,8 @@ use rocket_dyn_templates::Template;
 use rand::distributions::Uniform;
 use rand::Rng;
 
+use lazy_static::lazy_static;
+use std::collections::HashMap;
 use std::ops::Deref;
 use std::sync::Arc;
 
@@ -21,6 +27,10 @@ use std::time::Duration;
 
 const DB_FILENAME: &str = "db.dat";
 
+lazy_static! {
+    static ref EMPTY_MAP: HashMap<String, String> = HashMap::new();
+}
+
 trait ErrorEmpty {
     type Output;
     fn err_empty(self) -> Result<Self::Output, ()>;
@@ -33,11 +43,38 @@ impl<T, E> ErrorEmpty for Result<T, E> {
     }
 }
 
+#[derive(Debug, Responder)]
+enum WebError {
+    #[response(status = 404)]
+    NotFound(Template),
+    #[response(status = 500)]
+    ServerError(Template),
+}
+
+impl WebError {
+    fn not_found() -> Self {
+        WebError::NotFound(Template::render("404", EMPTY_MAP.deref()))
+    }
+    fn server_error() -> Self {
+        WebError::ServerError(Template::render("500", EMPTY_MAP.deref()))
+    }
+}
+
+/// wrapper for terra:Value (json, context), to cache values by ref
+/// implements Responder as json content type
 #[derive(Clone)]
 struct ArcTemplateData {
     value: Arc<tera::Value>,
 }
 
+impl Deref for ArcTemplateData {
+    type Target = tera::Value;
+
+    fn deref(&self) -> &Self::Target {
+        self.value.deref()
+    }
+}
+
 impl ArcTemplateData {
     fn new(value: tera::Value) -> ArcTemplateData {
         ArcTemplateData {
@@ -45,7 +82,15 @@ impl ArcTemplateData {
         }
     }
     fn render(&self, name: &'static str) -> Template {
-        Template::render(name, self.value.deref())
+        Template::render(name, self.deref())
+    }
+}
+
+impl<'r> Responder<'r, 'static> for ArcTemplateData {
+    fn respond_to(self, req: &'r Request<'_>) -> response::Result<'static> {
+        Response::build_from(self.to_string().respond_to(req)?)
+            .header(ContentType::JSON)
+            .ok()
     }
 }
 
@@ -80,14 +125,13 @@ async fn get_question(db: &DataBase, id: usize) -> Result<Question, ()> {
     db.get(id - 1).await.err_empty()
 }
 
-async fn show_question_details(
+async fn get_question_data(
-    template_name: &'static str,
     data: &AppState,
     cache: &TemplateCache,
     id: usize,
-) -> Template {
+) -> Option<ArcTemplateData> {
     if let Some(value) = cache.get(&id) {
-        return value.render(template_name);
+        return Some(value);
     }
 
     match get_question(&data.db, id).await {
@@ -98,18 +142,32 @@ async fn show_question_details(
                 context["next"] = tera::to_value(next_id).expect("question id serialize");
             }
 
-            let value = ArcTemplateData::new(context);
+            let data = ArcTemplateData::new(context);
-            let result = value.render(template_name);
+            cache.insert(id, data.clone());
-            cache.insert(id, value);
+            Some(data)
+        }
+        Err(_) => None,
+    }
+}
 
-            result
+async fn show_question_details(
-        }
+    template_name: &'static str,
-        Err(_) => {
+    data: &AppState,
-            use std::collections::HashMap;
+    cache: &TemplateCache,
-            let context: HashMap<String, String> = HashMap::new();
+    id: usize,
-            Template::render("404", context)
+) -> Option<Template> {
-        }
+    get_question_data(data, cache, id)
+        .await
+        .map(|data| data.render(template_name))
 }
+
+#[get("/q/<id>/json")]
+async fn json_question(
+    data: &State<AppState>,
+    cache: &State<TemplateCache>,
+    id: usize,
+) -> Option<ArcTemplateData> {
+    get_question_data(data.inner(), cache.inner(), id).await
 }
 
 #[get("/q/<id>")]
@@ -117,12 +175,16 @@ async fn show_question(
     data: &State<AppState>,
     cache: &State<TemplateCache>,
     id: usize,
-) -> Template {
+) -> Option<Template> {
     show_question_details("question", data.inner(), cache.inner(), id).await
 }
 
 #[get("/q/<id>/a")]
-async fn show_answer(data: &State<AppState>, cache: &State<TemplateCache>, id: usize) -> Template {
+async fn show_answer(
+    data: &State<AppState>,
+    cache: &State<TemplateCache>,
+    id: usize,
+) -> Option<Template> {
     show_question_details("answer", data.inner(), cache.inner(), id).await
 }
 
@@ -136,6 +198,12 @@ fn answer0() -> Redirect {
     Redirect::to("/")
 }
 
+#[get("/q/0/json")]
+fn json0(data: &State<AppState>) -> Redirect {
+    let id = random_question_id(&data.database_distribution);
+    Redirect::temporary(format!("/q/{}/json", id))
+}
+
 #[get("/")]
 fn index(data: &State<AppState>) -> Redirect {
     let id = random_question_id(&data.database_distribution);
@@ -143,10 +211,13 @@ fn index(data: &State<AppState>) -> Redirect {
 }
 
 #[catch(404)]
-fn not_found(_req: &rocket::Request) -> Template {
+fn not_found(_req: &rocket::Request) -> WebError {
-    use std::collections::HashMap;
+    WebError::not_found()
-    let context: HashMap<String, String> = HashMap::new();
+}
-    Template::render("404", context)
+
+#[catch(500)]
+fn server_error(_req: &rocket::Request) -> WebError {
+    WebError::server_error()
 }
 
 #[launch]
@@ -163,12 +234,20 @@ async fn rocket() -> _ {
     rocket::build()
         .manage(state)
         .manage(cache)
-        .register("/", catchers![not_found])
+        .register("/", catchers![not_found, server_error])
         .mount(
             "/",
-            routes![index, show_question, show_answer, question0, answer0],
+            routes![
+                index,
+                json_question,
+                show_question,
+                show_answer,
+                question0,
+                answer0,
+                json0
+            ],
         )
         .mount("/q", routes![index])
-        .mount("/q/static", FileServer::from("static/"))
+        .mount("/q/static", FileServer::new("static/", Options::None))
         .attach(Template::fairing())
 }

templates/404.html.tera

@@ -1,5 +1,13 @@
 {% extends "base" %}
 {% block title %}404{% endblock title %}
+{% block nav %} 
+{% endblock nav %}
 {% block content %}
-  <h1>404 - Could not find that page</h1>
+  <div class="content-block">
+    <div class="content-block-inner mt-4 px-4 py-2 fs-1 top-50 start-50 translate-middle">
+  <h1 class="display-4 d-flex justify-content-center text-center fw-bold">404</h1>
+  <br/>
+  <p>Нет такой страницы &#128532;</p>
+  </div>
+  </div>
 {% endblock content %}

templates/500.html.tera

@@ -0,0 +1,13 @@
+{% extends "base" %}
+{% block title %}404{% endblock title %}
+{% block nav %} 
+{% endblock nav %}
+{% block content %}
+  <div class="content-block">
+    <div class="content-block-inner mt-4 px-4 py-2 fs-1 top-50 start-50 translate-middle">
+  <h1 class="display-4 d-flex justify-content-center text-center fw-bold">500</h1>
+  <br/>
+  <p>&#128558; Ой, кажется у нас тут что то сломалось...</p>
+  </div>
+  </div>
+{% endblock content %}