li7y/src/frontend/item_class.rs

// SPDX-FileCopyrightText: 2024 Simon Bruder <simon@sbruder.de>
//
// SPDX-License-Identifier: AGPL-3.0-or-later

use std::collections::HashMap;

use actix_web::{error, get, post, web, HttpRequest, Responder};
use askama_actix::Template;
use uuid::Uuid;

use crate::manage;
use crate::models::*;
use crate::DbPool;

pub fn config(cfg: &mut web::ServiceConfig) {
    cfg.service(show_item_class)
        .service(list_item_classes)
        .service(add_item_class)
        .service(add_item_class_post)
        .service(edit_item_class)
        .service(edit_item_class_post);
}

#[derive(Template)]
#[template(path = "item_class_details.html")]
struct ItemClassDetails {
    req: HttpRequest,
    item_class: ItemClass,
    parent: Option<ItemClass>,
}

#[get("/item-class/{id}")]
async fn show_item_class(
    req: HttpRequest,
    pool: web::Data<DbPool>,
    path: web::Path<Uuid>,
) -> actix_web::Result<impl Responder> {
    let id = path.into_inner();

    let item_class = manage::item_class::get(&mut pool.clone().get().await.unwrap(), id)
        .await
        .map_err(error::ErrorInternalServerError)?;

    // TODO: Once async closures are stable, use map_or on item_class.parent instead
    let parent = match item_class.parent {
        Some(id) => manage::item_class::get(&mut pool.get().await.unwrap(), id)
            .await
            .map(Some)
            .map_err(error::ErrorInternalServerError)?,
        None => None,
    };

    Ok(ItemClassDetails {
        req,
        item_class,
        parent,
    })
}

#[derive(Template)]
#[template(path = "item_class_list.html")]
struct ItemClassList {
    req: HttpRequest,
    item_classes: HashMap<Uuid, ItemClass>,
}

#[get("/item-classes")]
async fn list_item_classes(
    req: HttpRequest,
    pool: web::Data<DbPool>,
) -> actix_web::Result<impl Responder> {
    let item_classes = manage::item_class::get_all_as_map(&mut pool.get().await.unwrap())
        .await
        .map_err(error::ErrorInternalServerError)?;

    Ok(ItemClassList { req, item_classes })
}

#[derive(Template)]
#[template(path = "item_class_add.html")]
struct ItemClassAddForm {
    req: HttpRequest,
    data: Option<NewItemClass>,
}

#[get("/item-classes/add")]
async fn add_item_class(req: HttpRequest) -> actix_web::Result<impl Responder> {
    Ok(ItemClassAddForm { req, data: None })
}

#[post("/item-classes/add")]
async fn add_item_class_post(
    data: web::Form<NewItemClass>,
    pool: web::Data<DbPool>,
) -> actix_web::Result<impl Responder> {
    let item = manage::item_class::add(&mut pool.get().await.unwrap(), data.into_inner())
        .await
        .map_err(error::ErrorInternalServerError)?;
    Ok(web::Redirect::to("/item-class/".to_owned() + &item.id.to_string()).see_other())
}

#[derive(Template)]
#[template(path = "item_class_edit.html")]
struct ItemClassEditForm {
    req: HttpRequest,
    item_class: ItemClass,
}

#[get("/item-class/{id}/edit")]
async fn edit_item_class(
    req: HttpRequest,
    pool: web::Data<DbPool>,
    path: web::Path<Uuid>,
) -> actix_web::Result<impl Responder> {
    let id = path.into_inner();

    let item_class = manage::item_class::get(&mut pool.get().await.unwrap(), id)
        .await
        .map_err(error::ErrorInternalServerError)?;

    Ok(ItemClassEditForm { req, item_class })
}

#[post("/item-class/{id}/edit")]
async fn edit_item_class_post(
    pool: web::Data<DbPool>,
    path: web::Path<Uuid>,
    data: web::Form<NewItemClass>,
) -> actix_web::Result<impl Responder> {
    let id = path.into_inner();

    let item_class =
        manage::item_class::update(&mut pool.get().await.unwrap(), id, data.into_inner())
            .await
            .map_err(error::ErrorInternalServerError)?;

    Ok(web::Redirect::to("/item-class/".to_owned() + &item_class.id.to_string()).see_other())
}