1use 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}