qleany 1.7.3

// Generated by Qleany v1.7.0 from frontend_entity_commands.tera

//! UseCase entity commands
#![allow(unused_imports, dead_code)]

use crate::app_context::AppContext;
use anyhow::{Context, Result};
use common::direct_access::use_case::UseCaseRelationshipField;
use common::types::EntityId;
use direct_access::UseCaseRelationshipDto;
use direct_access::{CreateUseCaseDto, UpdateUseCaseDto, UseCaseDto, use_case_controller};

/// Create a new use_case entity (orphan, no parent)
pub fn create_orphan_use_case(
    ctx: &AppContext,
    stack_id: Option<u64>,
    dto: &CreateUseCaseDto,
) -> Result<UseCaseDto> {
    let mut undo_redo_manager = ctx.undo_redo_manager.lock().unwrap();
    use_case_controller::create_orphan(
        &ctx.db_context,
        &ctx.event_hub,
        &mut undo_redo_manager,
        stack_id,
        dto,
    )
    .context("creating use_case")
}
/// Create a new use_case entity as child of owner
pub fn create_use_case(
    ctx: &AppContext,
    stack_id: Option<u64>,
    dto: &CreateUseCaseDto,
    owner_id: EntityId,
    index: i32,
) -> Result<UseCaseDto> {
    let mut undo_redo_manager = ctx.undo_redo_manager.lock().unwrap();
    use_case_controller::create(
        &ctx.db_context,
        &ctx.event_hub,
        &mut undo_redo_manager,
        stack_id,
        dto,
        owner_id,
        index,
    )
    .context("creating use_case")
}
/// Create multiple use_case entities (orphan, no parent)
pub fn create_orphan_use_case_multi(
    ctx: &AppContext,
    stack_id: Option<u64>,
    dtos: &[CreateUseCaseDto],
) -> Result<Vec<UseCaseDto>> {
    let mut undo_redo_manager = ctx.undo_redo_manager.lock().unwrap();
    use_case_controller::create_orphan_multi(
        &ctx.db_context,
        &ctx.event_hub,
        &mut undo_redo_manager,
        stack_id,
        dtos,
    )
    .context("creating use_case entities")
}
/// Create multiple use_case entities as children of owner
pub fn create_use_case_multi(
    ctx: &AppContext,
    stack_id: Option<u64>,
    dtos: &[CreateUseCaseDto],
    owner_id: EntityId,
    index: i32,
) -> Result<Vec<UseCaseDto>> {
    let mut undo_redo_manager = ctx.undo_redo_manager.lock().unwrap();
    use_case_controller::create_multi(
        &ctx.db_context,
        &ctx.event_hub,
        &mut undo_redo_manager,
        stack_id,
        dtos,
        owner_id,
        index,
    )
    .context("creating use_case entities")
}
/// Get a use_case entity by ID
pub fn get_use_case(ctx: &AppContext, id: &EntityId) -> Result<Option<UseCaseDto>> {
    use_case_controller::get(&ctx.db_context, id).context("getting use_case")
}

/// Get multiple use_case entities by IDs
pub fn get_use_case_multi(ctx: &AppContext, ids: &[EntityId]) -> Result<Vec<Option<UseCaseDto>>> {
    use_case_controller::get_multi(&ctx.db_context, ids).context("getting use_case entities")
}

/// Get all use_case entities.
/// Note: returns entities in database key order (by EntityId), not insertion order
/// or any user-defined sort. For ordered collections, use relationship-based
/// retrieval (e.g. get_*_relationship for ordered_one_to_many fields).
pub fn get_all_use_case(ctx: &AppContext) -> Result<Vec<UseCaseDto>> {
    use_case_controller::get_all(&ctx.db_context).context("getting all use_case entities")
}

/// Update a use_case entity
pub fn update_use_case(
    ctx: &AppContext,
    stack_id: Option<u64>,
    dto: &UpdateUseCaseDto,
) -> Result<UseCaseDto> {
    let mut undo_redo_manager = ctx.undo_redo_manager.lock().unwrap();
    use_case_controller::update(
        &ctx.db_context,
        &ctx.event_hub,
        &mut undo_redo_manager,
        stack_id,
        dto,
    )
    .context("updating use_case")
}

/// Update multiple use_case entities
pub fn update_use_case_multi(
    ctx: &AppContext,
    stack_id: Option<u64>,
    dtos: &[UpdateUseCaseDto],
) -> Result<Vec<UseCaseDto>> {
    let mut undo_redo_manager = ctx.undo_redo_manager.lock().unwrap();
    use_case_controller::update_multi(
        &ctx.db_context,
        &ctx.event_hub,
        &mut undo_redo_manager,
        stack_id,
        dtos,
    )
    .context("updating use_case entities")
}

/// Update a use_case entity with relationships
pub fn update_use_case_with_relationships(
    ctx: &AppContext,
    stack_id: Option<u64>,
    dto: &UseCaseDto,
) -> Result<UseCaseDto> {
    let mut undo_redo_manager = ctx.undo_redo_manager.lock().unwrap();
    use_case_controller::update_with_relationships(
        &ctx.db_context,
        &ctx.event_hub,
        &mut undo_redo_manager,
        stack_id,
        dto,
    )
    .context("updating use_case with relationships")
}

/// Update multiple use_case entities with relationships
pub fn update_use_case_with_relationships_multi(
    ctx: &AppContext,
    stack_id: Option<u64>,
    dtos: &[UseCaseDto],
) -> Result<Vec<UseCaseDto>> {
    let mut undo_redo_manager = ctx.undo_redo_manager.lock().unwrap();
    use_case_controller::update_with_relationships_multi(
        &ctx.db_context,
        &ctx.event_hub,
        &mut undo_redo_manager,
        stack_id,
        dtos,
    )
    .context("updating use_case entities with relationships")
}

/// Remove a use_case entity by ID
pub fn remove_use_case(ctx: &AppContext, stack_id: Option<u64>, id: &EntityId) -> Result<()> {
    let mut undo_redo_manager = ctx.undo_redo_manager.lock().unwrap();
    use_case_controller::remove(
        &ctx.db_context,
        &ctx.event_hub,
        &mut undo_redo_manager,
        stack_id,
        id,
    )
    .context("removing use_case")
}

/// Remove multiple use_case entities by IDs
pub fn remove_use_case_multi(
    ctx: &AppContext,
    stack_id: Option<u64>,
    ids: &[EntityId],
) -> Result<()> {
    let mut undo_redo_manager = ctx.undo_redo_manager.lock().unwrap();
    use_case_controller::remove_multi(
        &ctx.db_context,
        &ctx.event_hub,
        &mut undo_redo_manager,
        stack_id,
        ids,
    )
    .context("removing use_case entities")
}

/// Get a use_case relationship
pub fn get_use_case_relationship(
    ctx: &AppContext,
    id: &EntityId,
    field: &UseCaseRelationshipField,
) -> Result<Vec<EntityId>> {
    use_case_controller::get_relationship(&ctx.db_context, id, field)
        .context("getting use_case relationship")
}

/// Get relationship IDs for multiple use_case entities at once
pub fn get_use_case_relationship_many(
    ctx: &AppContext,
    ids: &[EntityId],
    field: &UseCaseRelationshipField,
) -> Result<std::collections::HashMap<EntityId, Vec<EntityId>>> {
    use_case_controller::get_relationship_many(&ctx.db_context, ids, field)
        .context("getting use_case relationships (many)")
}

/// Get relationship count for a use_case entity
pub fn get_use_case_relationship_count(
    ctx: &AppContext,
    id: &EntityId,
    field: &UseCaseRelationshipField,
) -> Result<usize> {
    use_case_controller::get_relationship_count(&ctx.db_context, id, field)
        .context("getting use_case relationship count")
}

/// Get relationship IDs for a use_case entity with pagination
pub fn get_use_case_relationship_in_range(
    ctx: &AppContext,
    id: &EntityId,
    field: &UseCaseRelationshipField,
    offset: usize,
    limit: usize,
) -> Result<Vec<EntityId>> {
    use_case_controller::get_relationship_in_range(&ctx.db_context, id, field, offset, limit)
        .context("getting use_case relationship range")
}

/// Set a use_case relationship
pub fn set_use_case_relationship(
    ctx: &AppContext,
    stack_id: Option<u64>,
    dto: &UseCaseRelationshipDto,
) -> Result<()> {
    let mut undo_redo_manager = ctx.undo_redo_manager.lock().unwrap();
    use_case_controller::set_relationship(
        &ctx.db_context,
        &ctx.event_hub,
        &mut undo_redo_manager,
        stack_id,
        dto,
    )
    .context("setting use_case relationship")
}

/// Move (reorder) IDs within a use_case relationship
pub fn move_use_case_relationship(
    ctx: &AppContext,
    stack_id: Option<u64>,
    id: &EntityId,
    field: &UseCaseRelationshipField,
    ids_to_move: &[EntityId],
    new_index: i32,
) -> Result<Vec<EntityId>> {
    let mut undo_redo_manager = ctx.undo_redo_manager.lock().unwrap();
    use_case_controller::move_relationship(
        &ctx.db_context,
        &ctx.event_hub,
        &mut undo_redo_manager,
        stack_id,
        id,
        field,
        ids_to_move,
        new_index,
    )
    .context("moving use_case relationship")
}