li7y/src/manage/item.rs

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

use std::collections::HashMap;

use diesel::prelude::*;
use diesel_async::pg::AsyncPgConnection;
use diesel_async::RunQueryDsl;
use uuid::Uuid;

use crate::{models::*, schema};

pub async fn add(
    conn: &mut AsyncPgConnection,
    new_item: NewItem,
) -> Result<Item, diesel::result::Error> {
    diesel::insert_into(schema::items::table)
        .values(new_item)
        .returning(Item::as_returning())
        .get_result(conn)
        .await
}

pub async fn get(conn: &mut AsyncPgConnection, id: Uuid) -> Result<Item, diesel::result::Error> {
    schema::items::table
        .filter(schema::items::id.eq(id))
        .select(Item::as_select())
        .first(conn)
        .await
}

pub async fn get_all(conn: &mut AsyncPgConnection) -> Result<Vec<Item>, diesel::result::Error> {
    schema::items::table
        .select(Item::as_select())
        .load(conn)
        .await
}

pub async fn update(
    conn: &mut AsyncPgConnection,
    id: Uuid,
    modified_item: NewItem,
) -> Result<Item, diesel::result::Error> {
    diesel::update(schema::items::table.filter(schema::items::id.eq(id)))
        .set(modified_item)
        .returning(Item::as_returning())
        .get_result(conn)
        .await
}

pub async fn delete(conn: &mut AsyncPgConnection, id: Uuid) -> Result<(), diesel::result::Error> {
    let num_deleted = diesel::delete(schema::items::table.filter(schema::items::id.eq(id)))
        .execute(conn)
        .await?;
    assert_eq!(num_deleted, 1);
    Ok(())
}

/// Helper type for querying parents of items
#[derive(Debug, Queryable, Selectable)]
#[diesel(table_name = schema::item_tree)]
#[diesel(check_for_backend(diesel::pg::Pg))]
struct ItemTreeMapping {
    pub id: Uuid,
    pub parents: Vec<Uuid>,
}

pub async fn get_parents(
    conn: &mut AsyncPgConnection,
    id: Uuid,
) -> Result<Vec<Uuid>, diesel::result::Error> {
    schema::item_tree::table
        .filter(schema::item_tree::id.eq(id))
        .select(ItemTreeMapping::as_select())
        .first(conn)
        .await
        .map(|itm| itm.parents)
}

pub async fn get_all_parents(
    conn: &mut AsyncPgConnection,
) -> Result<HashMap<Uuid, Vec<Uuid>>, diesel::result::Error> {
    schema::item_tree::table
        .select(ItemTreeMapping::as_select())
        .load(conn)
        .await
        .map(|itms| {
            itms.into_iter()
                .map(|ItemTreeMapping { id, parents }| (id, parents))
                .collect::<HashMap<Uuid, Vec<Uuid>>>()
        })
}