tawny/src/routes/pages/chats.rs

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()))
}

pub async fn single_message_request(
    jar: CookieJar,
    Extension(data): Extension<State>,
    Path(id): Path<usize>,
) -> 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 message = match data.get_message_by_id(id).await {
        Ok(x) => x,
        Err(e) => {
            return Err(render_error(e, tera, data.0.0.clone(), Some(user)).await);
        }
    };

    let mut chat = match data.get_chat_by_id(message.chat).await {
        Ok(x) => x,
        Err(e) => {
            return Err(render_error(e, tera, data.0.0.clone(), Some(user)).await);
        }
    };

    if !chat.last_message_read_by.contains(&user.id) {
        // update chat
        chat.last_message_read_by.push(user.id);
        if let Err(e) = data
            .update_chat_last_message_read_by(user.id, chat.last_message_read_by)
            .await
        {
            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("message", &message);
    Ok(Html(tera.render("message.lisp", &ctx).unwrap()))
}

pub async fn messages_request(
    jar: CookieJar,
    Extension(data): Extension<State>,
    Path((id, before)): Path<(usize, usize)>,
) -> 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 messages = match data.get_messages_by_chat_before(id, before, 12, 0).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("messages", &messages);
    Ok(Html(tera.render("messages.lisp", &ctx).unwrap()))
}