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::pg::PgConnection;
use diesel::prelude::*;
use uuid::Uuid;

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

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

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

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

pub fn update(
    conn: &mut PgConnection,
    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)
}

pub fn delete(conn: &mut PgConnection, id: Uuid) -> Result<(), diesel::result::Error> {
    let num_deleted =
        diesel::delete(schema::items::table.filter(schema::items::id.eq(id))).execute(conn)?;
    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 fn get_parents(conn: &mut PgConnection, 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)
        .map(|itm| itm.parents)
}

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