add: chats list page

src/routes/pages/chats.rs

@@ -0,0 +1,87 @@
+use crate::{
+    State, get_user_from_token,
+    routes::{
+        default_context,
+        pages::{PaginatedQuery, misc::render_error},
+    },
+};
+use axum::{
+    Extension,
+    extract::{Path, Query},
+    response::{Html, IntoResponse},
+};
+use axum_extra::extract::CookieJar;
+use tetratto_core::model::Error;
+
+pub async fn list_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Query(props): Query<PaginatedQuery>,
+) -> impl IntoResponse {
+    let (ref data, ref tera, ref build_code) = *data.read().await;
+    let user = match get_user_from_token!(jar, data.2) {
+        Some(x) => x,
+        None => {
+            return Err(render_error(Error::NotAllowed, tera, data.0.0.clone(), None).await);
+        }
+    };
+
+    let chats = match data.get_chats_by_member(user.id, 12, props.page).await {
+        Ok(x) => data.fill_chats(x).await,
+        Err(e) => {
+            return Err(render_error(e, tera, data.0.0.clone(), Some(user)).await);
+        }
+    };
+
+    let mut ctx = default_context(&data.0.0, &build_code, &Some(user));
+
+    ctx.insert("chats", &chats);
+    ctx.insert("page", &props.page);
+
+    Ok(Html(tera.render("chats.lisp", &ctx).unwrap()))
+}
+
+pub async fn chat_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Path(id): Path<usize>,
+    Query(props): Query<PaginatedQuery>,
+) -> impl IntoResponse {
+    let (ref data, ref tera, ref build_code) = *data.read().await;
+    let user = match get_user_from_token!(jar, data.2) {
+        Some(x) => x,
+        None => {
+            return Err(render_error(Error::NotAllowed, tera, data.0.0.clone(), None).await);
+        }
+    };
+
+    let (chat, members) = match data.get_chat_by_id(id).await {
+        Ok(x) => {
+            if !x.members.contains(&user.id) {
+                return Err(
+                    render_error(Error::NotAllowed, tera, data.0.0.clone(), Some(user)).await,
+                );
+            }
+
+            data.fill_chat(x).await
+        }
+        Err(e) => {
+            return Err(render_error(e, tera, data.0.0.clone(), Some(user)).await);
+        }
+    };
+
+    let messages = match data.get_messages_by_chat(id, 12, props.page).await {
+        Ok(x) => x,
+        Err(e) => {
+            return Err(render_error(e, tera, data.0.0.clone(), Some(user)).await);
+        }
+    };
+
+    let mut ctx = default_context(&data.0.0, &build_code, &Some(user));
+
+    ctx.insert("chat", &chat);
+    ctx.insert("members", &members);
+    ctx.insert("messages", &messages);
+
+    Ok(Html(tera.render("chat.lisp", &ctx).unwrap()))
+}

src/routes/pages/misc.rs

@@ -1,24 +1,30 @@
-use crate::{State, get_user_from_token, routes::default_context};
+use crate::{State, config::Config, get_user_from_token, routes::default_context};
 use axum::{
     Extension,
     response::{Html, IntoResponse},
 };
 use axum_extra::extract::CookieJar;
-use tetratto_core::model::Error;
+use tera::Tera;
+use tetratto_core::model::{Error, auth::User};
+
+pub async fn render_error(
+    e: Error,
+    tera: &Tera,
+    config: Config,
+    user: Option<User>,
+) -> impl IntoResponse + use<> {
+    let mut ctx = default_context(&config, "", &user);
+    ctx.insert("error", &e.to_string());
+    return Html(tera.render("error.lisp", &ctx).unwrap());
+}
 
 pub async fn not_found_request(
     jar: CookieJar,
     Extension(data): Extension<State>,
 ) -> impl IntoResponse {
-    let (ref data, ref tera, ref build_code) = *data.read().await;
+    let (ref data, ref tera, _) = *data.read().await;
     let user = get_user_from_token!(jar, data.2);
-
-    let mut ctx = default_context(&data.0.0, &build_code, &user);
-    ctx.insert(
-        "error",
-        &Error::GeneralNotFound("page".to_string()).to_string(),
-    );
-    return Html(tera.render("error.lisp", &ctx).unwrap());
+    render_error(Error::NotAllowed, tera, data.0.0.clone(), user).await
 }
 
 pub async fn index_request(jar: CookieJar, Extension(data): Extension<State>) -> impl IntoResponse {

src/routes/pages/mod.rs

@@ -1,9 +1,21 @@
+pub mod chats;
 pub mod misc;
 
 use axum::routing::{Router, get};
+use serde::Deserialize;
 
 pub fn routes() -> Router {
     Router::new()
         .route("/", get(misc::index_request))
+        // auth
         .route("/login", get(misc::login_request))
+        // chats
+        .route("/chats", get(chats::list_request))
+        .route("/chats/{id}", get(chats::chat_request))
+}
+
+#[derive(Deserialize)]
+pub struct PaginatedQuery {
+    #[serde(default)]
+    pub page: usize,
 }