add: mail ui

crates/app/src/routes/api/v1/letters.rs

@@ -1,16 +1,27 @@
-use axum::{response::IntoResponse, Extension, Json, extract::Path};
+use axum::{
+    extract::{Path, Query},
+    response::IntoResponse,
+    Extension, Json,
+};
 use tetratto_core::model::{auth::Notification, mail::Letter, oauth, ApiReturn, Error};
-use crate::{get_user_from_token, State, cookie::CookieJar};
+use crate::{cookie::CookieJar, get_user_from_token, routes::pages::PaginatedQuery, State};
 use super::CreateLetter;
 
-pub async fn list_received_request(jar: CookieJar, data: Extension<State>) -> impl IntoResponse {
+pub async fn list_received_request(
+    jar: CookieJar,
+    data: Extension<State>,
+    Query(props): Query<PaginatedQuery>,
+) -> impl IntoResponse {
     let data = &(data.read().await).0;
     let user = match get_user_from_token!(jar, data, oauth::AppScope::UserReadLetters) {
         Some(ua) => ua,
         None => return Json(Error::NotAllowed.into()),
     };
 
-    let letters = match data.get_received_letters_by_user(user.id).await {
+    let letters = match data
+        .get_received_letters_by_user(user.id, 12, props.page)
+        .await
+    {
         Ok(l) => l,
         Err(e) => return Json(e.into()),
     };
@@ -22,14 +33,18 @@ pub async fn list_received_request(jar: CookieJar, data: Extension<State>) -> im
     })
 }
 
-pub async fn list_sent_request(jar: CookieJar, data: Extension<State>) -> impl IntoResponse {
+pub async fn list_sent_request(
+    jar: CookieJar,
+    data: Extension<State>,
+    Query(props): Query<PaginatedQuery>,
+) -> impl IntoResponse {
     let data = &(data.read().await).0;
     let user = match get_user_from_token!(jar, data, oauth::AppScope::UserReadLetters) {
         Some(ua) => ua,
         None => return Json(Error::NotAllowed.into()),
     };
 
-    let letters = match data.get_letters_by_user(user.id).await {
+    let letters = match data.get_letters_by_user(user.id, 12, props.page).await {
         Ok(l) => l,
         Err(e) => return Json(e.into()),
     };
@@ -92,7 +107,7 @@ pub async fn delete_request(
 pub async fn create_request(
     jar: CookieJar,
     data: Extension<State>,
-    Json(props): Json<CreateLetter>,
+    Json(mut props): Json<CreateLetter>,
 ) -> impl IntoResponse {
     let data = &(data.read().await).0;
     let user = match get_user_from_token!(jar, data, oauth::AppScope::UserCreateLetters) {
@@ -100,10 +115,51 @@ pub async fn create_request(
         None => return Json(Error::NotAllowed.into()),
     };
 
+    // check receivers
+    props.receivers.dedup();
+    let mut receivers = Vec::new();
+
+    if props.receivers.len() < 1 {
+        return Json(Error::DataTooShort("receivers".to_string()).into());
+    } else if props.receivers.len() > 10 {
+        return Json(Error::DataTooLong("receivers".to_string()).into());
+    }
+
+    for receiver in &props.receivers {
+        let other_user = match if receiver.starts_with("id:") {
+            data.get_user_by_id(match receiver.replace("id:", "").parse() {
+                Ok(x) => x,
+                Err(_) => continue,
+            })
+            .await
+        } else {
+            data.get_user_by_username(receiver).await
+        } {
+            Ok(ua) => ua,
+            Err(e) => return Json(e.into()),
+        };
+
+        if crate::check_user_is_blocked!(data, user, other_user) {
+            continue;
+        }
+
+        if other_user.settings.private_mails
+            && data
+                .get_userfollow_by_initiator_receiver(other_user.id, user.id)
+                .await
+                .is_err()
+        {
+            continue;
+        }
+
+        receivers.push(other_user.id);
+    }
+
+    // ...
     match data
         .create_letter(Letter::new(
             user.id,
-            props.receivers,
+            receivers,
             props.subject,
             props.content,
             match props.replying_to.parse() {
@@ -120,7 +176,7 @@ pub async fn create_request(
                     .create_notification(Notification::new(
                         "You've got mail!".to_string(),
                         format!(
-                            "[@{}](/api/v1/auth/user/find/{}) has sent you a [letter](/mail/{}).",
+                            "[@{}](/api/v1/auth/user/find/{}) has sent you a [letter](/mail/letter/{}).",
                             user.username, user.id, l.id
                         ),
                         *x,
@@ -135,7 +191,7 @@ pub async fn create_request(
             Json(ApiReturn {
                 ok: true,
                 message: "Success".to_string(),
-                payload: Some(l),
+                payload: Some(l.id.to_string()),
             })
         }
         Err(e) => return Json(e.into()),
@@ -163,7 +219,11 @@ pub async fn add_read_request(
     }
 
     if letter.read_by.contains(&user.id) {
-        return Json(Error::MiscError("Already marked as read".to_string()).into());
+        return Json(ApiReturn {
+            ok: true,
+            message: "Already marked as read".to_string(),
+            payload: (),
+        });
     }
 
     letter.read_by.push(user.id);

crates/app/src/routes/api/v1/mod.rs

@@ -1219,7 +1219,7 @@ pub struct QueryAppData {
 
 #[derive(Deserialize)]
 pub struct CreateLetter {
-    pub receivers: Vec<usize>,
+    pub receivers: Vec<String>,
     pub subject: String,
     pub content: String,
     pub replying_to: String,

crates/app/src/routes/pages/mail.rs

@@ -0,0 +1,156 @@
+use axum::{
+    extract::{Query, Path},
+    response::{Html, IntoResponse},
+    Extension,
+};
+use crate::cookie::CookieJar;
+use tetratto_core::model::Error;
+use crate::{assets::initial_context, get_lang, get_user_from_token, State};
+use super::{render_error, PaginatedQuery};
+
+/// `/mail`
+pub async fn received_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Query(props): Query<PaginatedQuery>,
+) -> impl IntoResponse {
+    let data = data.read().await;
+    let user = match get_user_from_token!(jar, data.0) {
+        Some(ua) => ua,
+        None => {
+            return Err(Html(
+                render_error(Error::NotAllowed, &jar, &data, &None).await,
+            ));
+        }
+    };
+
+    let list = match data
+        .0
+        .get_received_letters_by_user(user.id, 12, props.page)
+        .await
+    {
+        Ok(x) => match data.0.fill_letters(x).await {
+            Ok(x) => x,
+            Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
+        },
+        Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
+    };
+
+    let lang = get_lang!(jar, data.0);
+    let mut context = initial_context(&data.0.0.0, lang, &Some(user)).await;
+
+    context.insert("list", &list);
+    context.insert("page", &props.page);
+
+    // return
+    Ok(Html(data.1.render("mail/received.html", &context).unwrap()))
+}
+
+/// `/mail/sent`
+pub async fn sent_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Query(props): Query<PaginatedQuery>,
+) -> impl IntoResponse {
+    let data = data.read().await;
+    let user = match get_user_from_token!(jar, data.0) {
+        Some(ua) => ua,
+        None => {
+            return Err(Html(
+                render_error(Error::NotAllowed, &jar, &data, &None).await,
+            ));
+        }
+    };
+
+    let list = match data.0.get_letters_by_user(user.id, 12, props.page).await {
+        Ok(x) => match data.0.fill_letters(x).await {
+            Ok(x) => x,
+            Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
+        },
+        Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
+    };
+
+    let lang = get_lang!(jar, data.0);
+    let mut context = initial_context(&data.0.0.0, lang, &Some(user)).await;
+
+    context.insert("list", &list);
+    context.insert("page", &props.page);
+
+    // return
+    Ok(Html(data.1.render("mail/sent.html", &context).unwrap()))
+}
+
+/// `/mail/compose`
+pub async fn compose_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+) -> impl IntoResponse {
+    let data = data.read().await;
+    let user = match get_user_from_token!(jar, data.0) {
+        Some(ua) => ua,
+        None => {
+            return Err(Html(
+                render_error(Error::NotAllowed, &jar, &data, &None).await,
+            ));
+        }
+    };
+
+    let lang = get_lang!(jar, data.0);
+    let context = initial_context(&data.0.0.0, lang, &Some(user)).await;
+
+    // return
+    Ok(Html(data.1.render("mail/compose.html", &context).unwrap()))
+}
+
+/// `/mail/letter`
+pub async fn letter_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Path(id): Path<usize>,
+    Query(props): Query<PaginatedQuery>,
+) -> impl IntoResponse {
+    let data = data.read().await;
+    let user = match get_user_from_token!(jar, data.0) {
+        Some(ua) => ua,
+        None => {
+            return Err(Html(
+                render_error(Error::NotAllowed, &jar, &data, &None).await,
+            ));
+        }
+    };
+
+    let letter = match data.0.get_letter_by_id(id).await {
+        Ok(l) => l,
+        Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
+    };
+
+    if !letter.can_read(&user) {
+        return Err(Html(
+            render_error(Error::NotAllowed, &jar, &data, &None).await,
+        ));
+    }
+
+    let owner = match data.0.get_user_by_id(letter.owner).await {
+        Ok(l) => l,
+        Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
+    };
+
+    let replies = match data.0.get_letters_by_replying_to(id, 12, props.page).await {
+        Ok(x) => match data.0.fill_letters(x).await {
+            Ok(x) => x,
+            Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
+        },
+        Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
+    };
+
+    let lang = get_lang!(jar, data.0);
+    let mut context = initial_context(&data.0.0.0, lang, &Some(user)).await;
+
+    context.insert("letter", &letter);
+    context.insert("owner", &owner);
+    context.insert("replies", &replies);
+    context.insert("page", &props.page);
+
+    // return
+    Ok(Html(data.1.render("mail/letter.html", &context).unwrap()))
+}

crates/app/src/routes/pages/mod.rs

@@ -5,6 +5,7 @@ pub mod developer;
 pub mod forge;
 pub mod journals;
 pub mod littleweb;
+pub mod mail;
 pub mod marketplace;
 pub mod misc;
 pub mod mod_panel;
@@ -17,10 +18,7 @@ use axum::{
 };
 use crate::cookie::CookieJar;
 use serde::Deserialize;
-use tetratto_core::{
-    model::{Error, auth::User},
-};
-
+use tetratto_core::model::{Error, auth::User};
 use crate::{assets::initial_context, get_lang, InnerState};
 
 pub fn routes() -> Router {
@@ -160,6 +158,11 @@ pub fn routes() -> Router {
             "/settings/seller",
             get(marketplace::seller_settings_request),
         )
+        // mail
+        .route("/mail", get(mail::received_request))
+        .route("/mail/sent", get(mail::sent_request))
+        .route("/mail/compose", get(mail::compose_request))
+        .route("/mail/letter/{id}", get(mail::letter_request))
 }
 
 pub fn lw_routes() -> Router {