direct_access/user_interface/
user_interface_controller.rs

1// Generated by Qleany v1.7.0 from entity_controller.tera
2
3use super::{
4    dtos::{CreateUserInterfaceDto, UpdateUserInterfaceDto, UserInterfaceDto},
5    units_of_work::{UserInterfaceReadUoWFactory, UserInterfaceWriteUoWFactory},
6};
7use anyhow::{Ok, Result};
8use common::direct_access::use_cases;
9use common::undo_redo::UndoRedoManager;
10use common::{database::db_context::DbContext, event::EventHub, types::EntityId};
11use std::sync::Arc;
12
13pub fn create_orphan(
14    db_context: &DbContext,
15    event_hub: &Arc<EventHub>,
16    undo_redo_manager: &mut UndoRedoManager,
17    stack_id: Option<u64>,
18    entity: &CreateUserInterfaceDto,
19) -> Result<UserInterfaceDto> {
20    let uow_factory = UserInterfaceWriteUoWFactory::new(db_context, event_hub);
21    let mut uc = use_cases::UndoableCreateOrphanUseCase::new(uow_factory);
22    let entity_in: common::entities::UserInterface = entity.into();
23    let result = uc.execute(&entity_in)?;
24    undo_redo_manager.add_command_to_stack(Box::new(uc), stack_id)?;
25    Ok(result.into())
26}
27
28pub fn create_orphan_multi(
29    db_context: &DbContext,
30    event_hub: &Arc<EventHub>,
31    undo_redo_manager: &mut UndoRedoManager,
32    stack_id: Option<u64>,
33    entities: &[CreateUserInterfaceDto],
34) -> Result<Vec<UserInterfaceDto>> {
35    let uow_factory = UserInterfaceWriteUoWFactory::new(db_context, event_hub);
36    let entities_in: Vec<common::entities::UserInterface> =
37        entities.iter().map(|dto| dto.into()).collect();
38    let mut uc = use_cases::UndoableCreateOrphanUseCase::new(uow_factory);
39    let result = uc.execute_multi(&entities_in)?;
40    undo_redo_manager.add_command_to_stack(Box::new(uc), stack_id)?;
41    Ok(result.into_iter().map(|e| e.into()).collect())
42}
43
44pub fn create(
45    db_context: &DbContext,
46    event_hub: &Arc<EventHub>,
47    undo_redo_manager: &mut UndoRedoManager,
48    stack_id: Option<u64>,
49    entity: &CreateUserInterfaceDto,
50    owner_id: EntityId,
51    index: i32,
52) -> Result<UserInterfaceDto> {
53    let uow_factory = UserInterfaceWriteUoWFactory::new(db_context, event_hub);
54    let entity_in: common::entities::UserInterface = entity.into();
55    let strategy = use_cases::OwnerStrategy::Replacing;
56    let mut uc = use_cases::UndoableCreateUseCase::new(uow_factory, strategy);
57    let result = uc.execute(&entity_in, owner_id, index)?;
58    undo_redo_manager.add_command_to_stack(Box::new(uc), stack_id)?;
59    Ok(result.into())
60}
61
62pub fn create_multi(
63    db_context: &DbContext,
64    event_hub: &Arc<EventHub>,
65    undo_redo_manager: &mut UndoRedoManager,
66    stack_id: Option<u64>,
67    entities: &[CreateUserInterfaceDto],
68    owner_id: EntityId,
69    index: i32,
70) -> Result<Vec<UserInterfaceDto>> {
71    let uow_factory = UserInterfaceWriteUoWFactory::new(db_context, event_hub);
72    let entities_in: Vec<common::entities::UserInterface> =
73        entities.iter().map(|dto| dto.into()).collect();
74    let strategy = use_cases::OwnerStrategy::Replacing;
75    let mut uc = use_cases::UndoableCreateUseCase::new(uow_factory, strategy);
76    let result = uc.execute_multi(&entities_in, owner_id, index)?;
77    undo_redo_manager.add_command_to_stack(Box::new(uc), stack_id)?;
78    Ok(result.into_iter().map(|e| e.into()).collect())
79}
80
81pub fn get(db_context: &DbContext, id: &EntityId) -> Result<Option<UserInterfaceDto>> {
82    let uow_factory = UserInterfaceReadUoWFactory::new(db_context);
83    let uc = use_cases::GetUseCase::new(uow_factory);
84    Ok(uc.execute(id)?.map(|e| e.into()))
85}
86
87pub fn get_all(db_context: &DbContext) -> Result<Vec<UserInterfaceDto>> {
88    let uow_factory = UserInterfaceReadUoWFactory::new(db_context);
89    let uc = use_cases::GetUseCase::new(uow_factory);
90    Ok(uc.execute_all()?.into_iter().map(|e| e.into()).collect())
91}
92
93pub fn get_multi(
94    db_context: &DbContext,
95    ids: &[EntityId],
96) -> Result<Vec<Option<UserInterfaceDto>>> {
97    let uow_factory = UserInterfaceReadUoWFactory::new(db_context);
98    let uc = use_cases::GetUseCase::new(uow_factory);
99    Ok(uc
100        .execute_multi(ids)?
101        .into_iter()
102        .map(|o| o.map(|e| e.into()))
103        .collect())
104}
105
106pub fn update(
107    db_context: &DbContext,
108    event_hub: &Arc<EventHub>,
109    undo_redo_manager: &mut UndoRedoManager,
110    stack_id: Option<u64>,
111    entity: &UpdateUserInterfaceDto,
112) -> Result<UserInterfaceDto> {
113    let uow_factory = UserInterfaceWriteUoWFactory::new(db_context, event_hub);
114    let entity_in: common::entities::UserInterface = entity.into();
115    let mut uc = use_cases::UndoableUpdateUseCase::new(uow_factory);
116    let result = uc.execute(&entity_in)?;
117    undo_redo_manager.add_command_to_stack(Box::new(uc), stack_id)?;
118    Ok(result.into())
119}
120
121pub fn update_multi(
122    db_context: &DbContext,
123    event_hub: &Arc<EventHub>,
124    undo_redo_manager: &mut UndoRedoManager,
125    stack_id: Option<u64>,
126    entities: &[UpdateUserInterfaceDto],
127) -> Result<Vec<UserInterfaceDto>> {
128    let uow_factory = UserInterfaceWriteUoWFactory::new(db_context, event_hub);
129    let entities_in: Vec<common::entities::UserInterface> =
130        entities.iter().map(|dto| dto.into()).collect();
131    let mut uc = use_cases::UndoableUpdateUseCase::new(uow_factory);
132    let result = uc.execute_multi(&entities_in)?;
133    undo_redo_manager.add_command_to_stack(Box::new(uc), stack_id)?;
134    Ok(result.into_iter().map(|e| e.into()).collect())
135}
136
137pub fn update_with_relationships(
138    db_context: &DbContext,
139    event_hub: &Arc<EventHub>,
140    undo_redo_manager: &mut UndoRedoManager,
141    stack_id: Option<u64>,
142    entity: &UserInterfaceDto,
143) -> Result<UserInterfaceDto> {
144    let uow_factory = UserInterfaceWriteUoWFactory::new(db_context, event_hub);
145    let entity_in: common::entities::UserInterface = entity.into();
146    let mut uc = use_cases::UndoableUpdateWithRelationshipsUseCase::new(uow_factory);
147    let result = uc.execute(&entity_in)?;
148    undo_redo_manager.add_command_to_stack(Box::new(uc), stack_id)?;
149    Ok(result.into())
150}
151
152pub fn update_with_relationships_multi(
153    db_context: &DbContext,
154    event_hub: &Arc<EventHub>,
155    undo_redo_manager: &mut UndoRedoManager,
156    stack_id: Option<u64>,
157    entities: &[UserInterfaceDto],
158) -> Result<Vec<UserInterfaceDto>> {
159    let uow_factory = UserInterfaceWriteUoWFactory::new(db_context, event_hub);
160    let entities_in: Vec<common::entities::UserInterface> =
161        entities.iter().map(|dto| dto.into()).collect();
162    let mut uc = use_cases::UndoableUpdateWithRelationshipsUseCase::new(uow_factory);
163    let result = uc.execute_multi(&entities_in)?;
164    undo_redo_manager.add_command_to_stack(Box::new(uc), stack_id)?;
165    Ok(result.into_iter().map(|e| e.into()).collect())
166}
167
168pub fn remove(
169    db_context: &DbContext,
170    event_hub: &Arc<EventHub>,
171    undo_redo_manager: &mut UndoRedoManager,
172    stack_id: Option<u64>,
173    id: &EntityId,
174) -> Result<()> {
175    let uow_factory = UserInterfaceWriteUoWFactory::new(db_context, event_hub);
176    let mut uc = use_cases::UndoableRemoveUseCase::new(uow_factory);
177    uc.execute(id)?;
178    undo_redo_manager.add_command_to_stack(Box::new(uc), stack_id)?;
179    Ok(())
180}
181
182pub fn remove_multi(
183    db_context: &DbContext,
184    event_hub: &Arc<EventHub>,
185    undo_redo_manager: &mut UndoRedoManager,
186    stack_id: Option<u64>,
187    ids: &[EntityId],
188) -> Result<()> {
189    let uow_factory = UserInterfaceWriteUoWFactory::new(db_context, event_hub);
190    let mut uc = use_cases::UndoableRemoveUseCase::new(uow_factory);
191    uc.execute_multi(ids)?;
192    undo_redo_manager.add_command_to_stack(Box::new(uc), stack_id)?;
193    Ok(())
194}
195
196#[cfg(test)]
197mod tests {
198    #![allow(dead_code)]
199    #![allow(unused_imports)]
200
201    use super::*;
202    use crate::root::dtos::CreateRootDto;
203    use crate::root::root_controller;
204    use crate::workspace::dtos::CreateWorkspaceDto;
205    use crate::workspace::workspace_controller;
206    use common::database::db_context::DbContext;
207    use common::event::EventHub;
208    use common::types::EntityId;
209    use common::undo_redo::UndoRedoManager;
210    use std::sync::Arc;
211
212    struct TestContext {
213        db: DbContext,
214        hub: Arc<EventHub>,
215        undo: UndoRedoManager,
216    }
217
218    impl TestContext {
219        fn new() -> Self {
220            let db = DbContext::new().expect("Failed to create in-memory DB");
221            let hub = Arc::new(EventHub::new());
222            let mut undo = UndoRedoManager::new();
223            undo.set_event_hub(&hub);
224            TestContext { db, hub, undo }
225        }
226    }
227
228    /// Build the ownership chain and return the direct owner's id.
229    fn create_owner_chain(ctx: &mut TestContext) -> EntityId {
230        let root =
231            root_controller::create_orphan(&ctx.db, &ctx.hub, &CreateRootDto::default()).unwrap();
232        let workspace = workspace_controller::create(
233            &ctx.db,
234            &ctx.hub,
235            &mut ctx.undo,
236            None,
237            &CreateWorkspaceDto::default(),
238            root.id,
239            -1,
240        )
241        .unwrap();
242        workspace.id
243    }
244
245    /// Create an entity using create_orphan.
246    fn create_one(ctx: &mut TestContext) -> UserInterfaceDto {
247        create_orphan(
248            &ctx.db,
249            &ctx.hub,
250            &mut ctx.undo,
251            None,
252            &CreateUserInterfaceDto::default(),
253        )
254        .unwrap()
255    }
256
257    // -----------------------------------------------------------------------
258    // create_orphan + get
259    // -----------------------------------------------------------------------
260
261    #[test]
262    fn test_create_orphan_and_get() {
263        let mut ctx = TestContext::new();
264        let created = create_one(&mut ctx);
265        assert!(created.id > 0);
266
267        let fetched = get(&ctx.db, &created.id).unwrap();
268        assert!(fetched.is_some());
269        assert_eq!(fetched.unwrap().id, created.id);
270    }
271
272    // -----------------------------------------------------------------------
273    // get nonexistent
274    // -----------------------------------------------------------------------
275
276    #[test]
277    fn test_get_nonexistent() {
278        let ctx = TestContext::new();
279        assert!(get(&ctx.db, &999999).unwrap().is_none());
280    }
281
282    // -----------------------------------------------------------------------
283    // get_all
284    // -----------------------------------------------------------------------
285
286    #[test]
287    fn test_get_all() {
288        let mut ctx = TestContext::new();
289        create_one(&mut ctx);
290        let all = get_all(&ctx.db).unwrap();
291        assert!(!all.is_empty());
292    }
293
294    // -----------------------------------------------------------------------
295    // get_multi
296    // -----------------------------------------------------------------------
297
298    #[test]
299    fn test_get_multi() {
300        let mut ctx = TestContext::new();
301        let a = create_one(&mut ctx);
302        let results = get_multi(&ctx.db, &[a.id, 999999]).unwrap();
303        assert_eq!(results.len(), 2);
304        assert!(results[0].is_some());
305        assert!(results[1].is_none());
306    }
307
308    // -----------------------------------------------------------------------
309    // update
310    // -----------------------------------------------------------------------
311
312    #[test]
313    fn test_update() {
314        let mut ctx = TestContext::new();
315        let created = create_one(&mut ctx);
316        let update_dto: UpdateUserInterfaceDto = created.into();
317        let updated = update(&ctx.db, &ctx.hub, &mut ctx.undo, None, &update_dto).unwrap();
318        assert_eq!(updated.id, update_dto.id);
319    }
320
321    // -----------------------------------------------------------------------
322    // remove
323    // -----------------------------------------------------------------------
324
325    #[test]
326    fn test_remove() {
327        let mut ctx = TestContext::new();
328        let created = create_one(&mut ctx);
329        remove(&ctx.db, &ctx.hub, &mut ctx.undo, None, &created.id).unwrap();
330        assert!(get(&ctx.db, &created.id).unwrap().is_none());
331    }
332
333    // -----------------------------------------------------------------------
334    // remove_multi
335    // -----------------------------------------------------------------------
336
337    #[test]
338    fn test_remove_multi() {
339        let mut ctx = TestContext::new();
340        let a = create_one(&mut ctx);
341        remove_multi(&ctx.db, &ctx.hub, &mut ctx.undo, None, &[a.id]).unwrap();
342        assert!(get(&ctx.db, &a.id).unwrap().is_none());
343    }
344
345    // -----------------------------------------------------------------------
346    // create with owner
347    // -----------------------------------------------------------------------
348
349    #[test]
350    fn test_create_with_owner() {
351        let mut ctx = TestContext::new();
352        let owner_id = create_owner_chain(&mut ctx);
353        let created = create(
354            &ctx.db,
355            &ctx.hub,
356            &mut ctx.undo,
357            None,
358            &CreateUserInterfaceDto::default(),
359            owner_id,
360            -1,
361        )
362        .unwrap();
363        assert!(created.id > 0);
364        let fetched = get(&ctx.db, &created.id).unwrap();
365        assert!(fetched.is_some());
366    }
367
368    // -----------------------------------------------------------------------
369    // undo create_orphan
370    // -----------------------------------------------------------------------
371
372    #[test]
373    fn test_create_orphan_undo() {
374        let mut ctx = TestContext::new();
375        let created = create_one(&mut ctx);
376        assert!(get(&ctx.db, &created.id).unwrap().is_some());
377        ctx.undo.undo(None).unwrap();
378        assert!(get(&ctx.db, &created.id).unwrap().is_none());
379    }
380
381    // -----------------------------------------------------------------------
382    // undo remove
383    // -----------------------------------------------------------------------
384
385    #[test]
386    fn test_remove_undo() {
387        let mut ctx = TestContext::new();
388        let created = create_one(&mut ctx);
389        remove(&ctx.db, &ctx.hub, &mut ctx.undo, None, &created.id).unwrap();
390        assert!(get(&ctx.db, &created.id).unwrap().is_none());
391        ctx.undo.undo(None).unwrap();
392        assert!(get(&ctx.db, &created.id).unwrap().is_some());
393    }
394}
direct_access/user_interface/user_interface_controller.rs

direct_access/user_interface/
user_interface_controller.rs
