Skip to main content

text_document_frontend/commands/
document_editing_commands.rs

1// Generated by Qleany v1.5.1 from frontend_feature_commands.tera
2
3//! DocumentEditing feature commands
4
5use crate::app_context::AppContext;
6use anyhow::{Context, Result};
7use document_editing::{
8    AddBlockToListDto, CreateListDto, CreateListResultDto, DeleteTextDto, DeleteTextResultDto,
9    InsertBlockDto, InsertBlockResultDto, InsertFormattedTextDto, InsertFormattedTextResultDto,
10    InsertFragmentDto, InsertFragmentResultDto, InsertFrameDto, InsertFrameResultDto,
11    InsertHtmlAtPositionDto, InsertHtmlAtPositionResultDto, InsertImageDto, InsertImageResultDto,
12    InsertListDto, InsertListResultDto, InsertMarkdownAtPositionDto,
13    InsertMarkdownAtPositionResultDto, InsertTableColumnDto, InsertTableColumnResultDto,
14    InsertTableDto, InsertTableResultDto, InsertTableRowDto, InsertTableRowResultDto,
15    InsertTextDto, InsertTextResultDto, MergeTableCellsDto, MergeTableCellsResultDto,
16    RemoveBlockFromListDto, RemoveTableColumnDto, RemoveTableColumnResultDto, RemoveTableDto,
17    RemoveTableRowDto, RemoveTableRowResultDto, SplitTableCellDto, SplitTableCellResultDto,
18    UnwrapBlockFromFrameDto, UnwrapBlockFromFrameResultDto, UnwrapFrameDto, UnwrapFrameResultDto,
19    WrapBlocksInFrameDto, WrapBlocksInFrameResultDto, document_editing_controller,
20};
21
22pub fn insert_text(
23    ctx: &AppContext,
24    stack_id: Option<u64>,
25    dto: &InsertTextDto,
26) -> Result<InsertTextResultDto> {
27    let mut undo_redo_manager = ctx.undo_redo_manager.lock();
28    document_editing_controller::insert_text(
29        &ctx.db_context,
30        &ctx.event_hub,
31        &mut undo_redo_manager,
32        stack_id,
33        dto,
34    )
35    .context("insert_text")
36}
37
38pub fn delete_text(
39    ctx: &AppContext,
40    stack_id: Option<u64>,
41    dto: &DeleteTextDto,
42) -> Result<DeleteTextResultDto> {
43    let mut undo_redo_manager = ctx.undo_redo_manager.lock();
44    document_editing_controller::delete_text(
45        &ctx.db_context,
46        &ctx.event_hub,
47        &mut undo_redo_manager,
48        stack_id,
49        dto,
50    )
51    .context("delete_text")
52}
53
54pub fn insert_block(
55    ctx: &AppContext,
56    stack_id: Option<u64>,
57    dto: &InsertBlockDto,
58) -> Result<InsertBlockResultDto> {
59    let mut undo_redo_manager = ctx.undo_redo_manager.lock();
60    document_editing_controller::insert_block(
61        &ctx.db_context,
62        &ctx.event_hub,
63        &mut undo_redo_manager,
64        stack_id,
65        dto,
66    )
67    .context("insert_block")
68}
69
70pub fn insert_image(
71    ctx: &AppContext,
72    stack_id: Option<u64>,
73    dto: &InsertImageDto,
74) -> Result<InsertImageResultDto> {
75    let mut undo_redo_manager = ctx.undo_redo_manager.lock();
76    document_editing_controller::insert_image(
77        &ctx.db_context,
78        &ctx.event_hub,
79        &mut undo_redo_manager,
80        stack_id,
81        dto,
82    )
83    .context("insert_image")
84}
85
86pub fn insert_frame(
87    ctx: &AppContext,
88    stack_id: Option<u64>,
89    dto: &InsertFrameDto,
90) -> Result<InsertFrameResultDto> {
91    let mut undo_redo_manager = ctx.undo_redo_manager.lock();
92    document_editing_controller::insert_frame(
93        &ctx.db_context,
94        &ctx.event_hub,
95        &mut undo_redo_manager,
96        stack_id,
97        dto,
98    )
99    .context("insert_frame")
100}
101
102pub fn insert_formatted_text(
103    ctx: &AppContext,
104    stack_id: Option<u64>,
105    dto: &InsertFormattedTextDto,
106) -> Result<InsertFormattedTextResultDto> {
107    let mut undo_redo_manager = ctx.undo_redo_manager.lock();
108    document_editing_controller::insert_formatted_text(
109        &ctx.db_context,
110        &ctx.event_hub,
111        &mut undo_redo_manager,
112        stack_id,
113        dto,
114    )
115    .context("insert_formatted_text")
116}
117
118pub fn create_list(
119    ctx: &AppContext,
120    stack_id: Option<u64>,
121    dto: &CreateListDto,
122) -> Result<CreateListResultDto> {
123    let mut undo_redo_manager = ctx.undo_redo_manager.lock();
124    document_editing_controller::create_list(
125        &ctx.db_context,
126        &ctx.event_hub,
127        &mut undo_redo_manager,
128        stack_id,
129        dto,
130    )
131    .context("create_list")
132}
133
134pub fn insert_list(
135    ctx: &AppContext,
136    stack_id: Option<u64>,
137    dto: &InsertListDto,
138) -> Result<InsertListResultDto> {
139    let mut undo_redo_manager = ctx.undo_redo_manager.lock();
140    document_editing_controller::insert_list(
141        &ctx.db_context,
142        &ctx.event_hub,
143        &mut undo_redo_manager,
144        stack_id,
145        dto,
146    )
147    .context("insert_list")
148}
149
150pub fn insert_fragment(
151    ctx: &AppContext,
152    stack_id: Option<u64>,
153    dto: &InsertFragmentDto,
154) -> Result<InsertFragmentResultDto> {
155    let mut undo_redo_manager = ctx.undo_redo_manager.lock();
156    document_editing_controller::insert_fragment(
157        &ctx.db_context,
158        &ctx.event_hub,
159        &mut undo_redo_manager,
160        stack_id,
161        dto,
162    )
163    .context("insert_fragment")
164}
165
166pub fn insert_html_at_position(
167    ctx: &AppContext,
168    stack_id: Option<u64>,
169    dto: &InsertHtmlAtPositionDto,
170) -> Result<InsertHtmlAtPositionResultDto> {
171    let mut undo_redo_manager = ctx.undo_redo_manager.lock();
172    document_editing_controller::insert_html_at_position(
173        &ctx.db_context,
174        &ctx.event_hub,
175        &mut undo_redo_manager,
176        stack_id,
177        dto,
178    )
179    .context("insert_html_at_position")
180}
181
182pub fn insert_markdown_at_position(
183    ctx: &AppContext,
184    stack_id: Option<u64>,
185    dto: &InsertMarkdownAtPositionDto,
186) -> Result<InsertMarkdownAtPositionResultDto> {
187    let mut undo_redo_manager = ctx.undo_redo_manager.lock();
188    document_editing_controller::insert_markdown_at_position(
189        &ctx.db_context,
190        &ctx.event_hub,
191        &mut undo_redo_manager,
192        stack_id,
193        dto,
194    )
195    .context("insert_markdown_at_position")
196}
197
198pub fn insert_table(
199    ctx: &AppContext,
200    stack_id: Option<u64>,
201    dto: &InsertTableDto,
202) -> Result<InsertTableResultDto> {
203    let mut undo_redo_manager = ctx.undo_redo_manager.lock();
204    document_editing_controller::insert_table(
205        &ctx.db_context,
206        &ctx.event_hub,
207        &mut undo_redo_manager,
208        stack_id,
209        dto,
210    )
211    .context("insert_table")
212}
213
214pub fn remove_table(ctx: &AppContext, stack_id: Option<u64>, dto: &RemoveTableDto) -> Result<()> {
215    let mut undo_redo_manager = ctx.undo_redo_manager.lock();
216    document_editing_controller::remove_table(
217        &ctx.db_context,
218        &ctx.event_hub,
219        &mut undo_redo_manager,
220        stack_id,
221        dto,
222    )
223    .context("remove_table")
224}
225
226pub fn insert_table_row(
227    ctx: &AppContext,
228    stack_id: Option<u64>,
229    dto: &InsertTableRowDto,
230) -> Result<InsertTableRowResultDto> {
231    let mut undo_redo_manager = ctx.undo_redo_manager.lock();
232    document_editing_controller::insert_table_row(
233        &ctx.db_context,
234        &ctx.event_hub,
235        &mut undo_redo_manager,
236        stack_id,
237        dto,
238    )
239    .context("insert_table_row")
240}
241
242pub fn insert_table_column(
243    ctx: &AppContext,
244    stack_id: Option<u64>,
245    dto: &InsertTableColumnDto,
246) -> Result<InsertTableColumnResultDto> {
247    let mut undo_redo_manager = ctx.undo_redo_manager.lock();
248    document_editing_controller::insert_table_column(
249        &ctx.db_context,
250        &ctx.event_hub,
251        &mut undo_redo_manager,
252        stack_id,
253        dto,
254    )
255    .context("insert_table_column")
256}
257
258pub fn remove_table_row(
259    ctx: &AppContext,
260    stack_id: Option<u64>,
261    dto: &RemoveTableRowDto,
262) -> Result<RemoveTableRowResultDto> {
263    let mut undo_redo_manager = ctx.undo_redo_manager.lock();
264    document_editing_controller::remove_table_row(
265        &ctx.db_context,
266        &ctx.event_hub,
267        &mut undo_redo_manager,
268        stack_id,
269        dto,
270    )
271    .context("remove_table_row")
272}
273
274pub fn remove_table_column(
275    ctx: &AppContext,
276    stack_id: Option<u64>,
277    dto: &RemoveTableColumnDto,
278) -> Result<RemoveTableColumnResultDto> {
279    let mut undo_redo_manager = ctx.undo_redo_manager.lock();
280    document_editing_controller::remove_table_column(
281        &ctx.db_context,
282        &ctx.event_hub,
283        &mut undo_redo_manager,
284        stack_id,
285        dto,
286    )
287    .context("remove_table_column")
288}
289
290pub fn merge_table_cells(
291    ctx: &AppContext,
292    stack_id: Option<u64>,
293    dto: &MergeTableCellsDto,
294) -> Result<MergeTableCellsResultDto> {
295    let mut undo_redo_manager = ctx.undo_redo_manager.lock();
296    document_editing_controller::merge_table_cells(
297        &ctx.db_context,
298        &ctx.event_hub,
299        &mut undo_redo_manager,
300        stack_id,
301        dto,
302    )
303    .context("merge_table_cells")
304}
305
306pub fn split_table_cell(
307    ctx: &AppContext,
308    stack_id: Option<u64>,
309    dto: &SplitTableCellDto,
310) -> Result<SplitTableCellResultDto> {
311    let mut undo_redo_manager = ctx.undo_redo_manager.lock();
312    document_editing_controller::split_table_cell(
313        &ctx.db_context,
314        &ctx.event_hub,
315        &mut undo_redo_manager,
316        stack_id,
317        dto,
318    )
319    .context("split_table_cell")
320}
321
322pub fn add_block_to_list(
323    ctx: &AppContext,
324    stack_id: Option<u64>,
325    dto: &AddBlockToListDto,
326) -> Result<()> {
327    let mut undo_redo_manager = ctx.undo_redo_manager.lock();
328    document_editing_controller::add_block_to_list(
329        &ctx.db_context,
330        &ctx.event_hub,
331        &mut undo_redo_manager,
332        stack_id,
333        dto,
334    )
335    .context("add_block_to_list")
336}
337
338pub fn remove_block_from_list(
339    ctx: &AppContext,
340    stack_id: Option<u64>,
341    dto: &RemoveBlockFromListDto,
342) -> Result<()> {
343    let mut undo_redo_manager = ctx.undo_redo_manager.lock();
344    document_editing_controller::remove_block_from_list(
345        &ctx.db_context,
346        &ctx.event_hub,
347        &mut undo_redo_manager,
348        stack_id,
349        dto,
350    )
351    .context("remove_block_from_list")
352}
353
354pub fn wrap_blocks_in_frame(
355    ctx: &AppContext,
356    stack_id: Option<u64>,
357    dto: &WrapBlocksInFrameDto,
358) -> Result<WrapBlocksInFrameResultDto> {
359    let mut undo_redo_manager = ctx.undo_redo_manager.lock();
360    document_editing_controller::wrap_blocks_in_frame(
361        &ctx.db_context,
362        &ctx.event_hub,
363        &mut undo_redo_manager,
364        stack_id,
365        dto,
366    )
367    .context("wrap_blocks_in_frame")
368}
369
370pub fn unwrap_frame(
371    ctx: &AppContext,
372    stack_id: Option<u64>,
373    dto: &UnwrapFrameDto,
374) -> Result<UnwrapFrameResultDto> {
375    let mut undo_redo_manager = ctx.undo_redo_manager.lock();
376    document_editing_controller::unwrap_frame(
377        &ctx.db_context,
378        &ctx.event_hub,
379        &mut undo_redo_manager,
380        stack_id,
381        dto,
382    )
383    .context("unwrap_frame")
384}
385
386pub fn unwrap_block_from_frame(
387    ctx: &AppContext,
388    stack_id: Option<u64>,
389    dto: &UnwrapBlockFromFrameDto,
390) -> Result<UnwrapBlockFromFrameResultDto> {
391    let mut undo_redo_manager = ctx.undo_redo_manager.lock();
392    document_editing_controller::unwrap_block_from_frame(
393        &ctx.db_context,
394        &ctx.event_hub,
395        &mut undo_redo_manager,
396        stack_id,
397        dto,
398    )
399    .context("unwrap_block_from_frame")
400}