event_handler.rs 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385
  1. use crate::manager::GridManager;
  2. use crate::services::entities::*;
  3. use crate::services::field::type_options::*;
  4. use crate::services::field::{default_type_option_builder_from_type, type_option_builder_from_json_str};
  5. use flowy_error::{ErrorCode, FlowyError, FlowyResult};
  6. use flowy_grid_data_model::entities::*;
  7. use lib_dispatch::prelude::{data_result, AppData, Data, DataResult};
  8. use std::sync::Arc;
  9. #[tracing::instrument(level = "debug", skip(data, manager), err)]
  10. pub(crate) async fn get_grid_data_handler(
  11. data: Data<GridId>,
  12. manager: AppData<Arc<GridManager>>,
  13. ) -> DataResult<Grid, FlowyError> {
  14. let grid_id: GridId = data.into_inner();
  15. let editor = manager.open_grid(grid_id).await?;
  16. let grid = editor.grid_data().await?;
  17. data_result(grid)
  18. }
  19. #[tracing::instrument(level = "debug", skip(data, manager), err)]
  20. pub(crate) async fn get_grid_blocks_handler(
  21. data: Data<QueryGridBlocksPayload>,
  22. manager: AppData<Arc<GridManager>>,
  23. ) -> DataResult<RepeatedGridBlock, FlowyError> {
  24. let params: QueryGridBlocksParams = data.into_inner().try_into()?;
  25. let editor = manager.get_grid_editor(&params.grid_id)?;
  26. let block_ids = params
  27. .block_orders
  28. .into_iter()
  29. .map(|block| block.block_id)
  30. .collect::<Vec<String>>();
  31. let repeated_grid_block = editor.get_blocks(Some(block_ids)).await?;
  32. data_result(repeated_grid_block)
  33. }
  34. #[tracing::instrument(level = "debug", skip(data, manager), err)]
  35. pub(crate) async fn get_fields_handler(
  36. data: Data<QueryFieldPayload>,
  37. manager: AppData<Arc<GridManager>>,
  38. ) -> DataResult<RepeatedField, FlowyError> {
  39. let params: QueryFieldParams = data.into_inner().try_into()?;
  40. let editor = manager.get_grid_editor(&params.grid_id)?;
  41. let field_orders = params.field_orders.items;
  42. let field_metas = editor.get_field_metas(Some(field_orders)).await?;
  43. let repeated_field: RepeatedField = field_metas.into_iter().map(Field::from).collect::<Vec<_>>().into();
  44. data_result(repeated_field)
  45. }
  46. #[tracing::instrument(level = "debug", skip(data, manager), err)]
  47. pub(crate) async fn update_field_handler(
  48. data: Data<FieldChangesetPayload>,
  49. manager: AppData<Arc<GridManager>>,
  50. ) -> Result<(), FlowyError> {
  51. let changeset: FieldChangesetParams = data.into_inner().try_into()?;
  52. let editor = manager.get_grid_editor(&changeset.grid_id)?;
  53. let _ = editor.update_field(changeset).await?;
  54. Ok(())
  55. }
  56. #[tracing::instrument(level = "debug", skip(data, manager), err)]
  57. pub(crate) async fn insert_field_handler(
  58. data: Data<InsertFieldPayload>,
  59. manager: AppData<Arc<GridManager>>,
  60. ) -> Result<(), FlowyError> {
  61. let params: InsertFieldParams = data.into_inner().try_into()?;
  62. let editor = manager.get_grid_editor(&params.grid_id)?;
  63. let _ = editor.insert_field(params).await?;
  64. Ok(())
  65. }
  66. #[tracing::instrument(level = "debug", skip(data, manager), err)]
  67. pub(crate) async fn update_field_type_option_handler(
  68. data: Data<UpdateFieldTypeOptionPayload>,
  69. manager: AppData<Arc<GridManager>>,
  70. ) -> Result<(), FlowyError> {
  71. let params: UpdateFieldTypeOptionParams = data.into_inner().try_into()?;
  72. let editor = manager.get_grid_editor(&params.grid_id)?;
  73. let _ = editor
  74. .update_field_type_option(&params.grid_id, &params.field_id, params.type_option_data)
  75. .await?;
  76. Ok(())
  77. }
  78. #[tracing::instrument(level = "debug", skip(data, manager), err)]
  79. pub(crate) async fn delete_field_handler(
  80. data: Data<FieldIdentifierPayload>,
  81. manager: AppData<Arc<GridManager>>,
  82. ) -> Result<(), FlowyError> {
  83. let params: FieldIdentifier = data.into_inner().try_into()?;
  84. let editor = manager.get_grid_editor(&params.grid_id)?;
  85. let _ = editor.delete_field(&params.field_id).await?;
  86. Ok(())
  87. }
  88. #[tracing::instrument(level = "debug", skip(data, manager), err)]
  89. pub(crate) async fn switch_to_field_handler(
  90. data: Data<EditFieldPayload>,
  91. manager: AppData<Arc<GridManager>>,
  92. ) -> DataResult<FieldTypeOptionData, FlowyError> {
  93. let params: EditFieldParams = data.into_inner().try_into()?;
  94. let editor = manager.get_grid_editor(&params.grid_id)?;
  95. editor
  96. .switch_to_field_type(&params.field_id, &params.field_type)
  97. .await?;
  98. // Get the FieldMeta with field_id, if it doesn't exist, we create the default FieldMeta from the FieldType.
  99. let field_meta = editor
  100. .get_field_meta(&params.field_id)
  101. .await
  102. .unwrap_or(editor.next_field_meta(&params.field_type).await?);
  103. let type_option_data = get_type_option_data(&field_meta, &params.field_type).await?;
  104. let data = FieldTypeOptionData {
  105. grid_id: params.grid_id,
  106. field: field_meta.into(),
  107. type_option_data,
  108. };
  109. data_result(data)
  110. }
  111. #[tracing::instrument(level = "debug", skip(data, manager), err)]
  112. pub(crate) async fn duplicate_field_handler(
  113. data: Data<FieldIdentifierPayload>,
  114. manager: AppData<Arc<GridManager>>,
  115. ) -> Result<(), FlowyError> {
  116. let params: FieldIdentifier = data.into_inner().try_into()?;
  117. let editor = manager.get_grid_editor(&params.grid_id)?;
  118. let _ = editor.duplicate_field(&params.field_id).await?;
  119. Ok(())
  120. }
  121. /// Return the FieldTypeOptionData if the Field exists otherwise return record not found error.
  122. #[tracing::instrument(level = "debug", skip(data, manager), err)]
  123. pub(crate) async fn get_field_type_option_data_handler(
  124. data: Data<EditFieldPayload>,
  125. manager: AppData<Arc<GridManager>>,
  126. ) -> DataResult<FieldTypeOptionData, FlowyError> {
  127. let params: EditFieldParams = data.into_inner().try_into()?;
  128. let editor = manager.get_grid_editor(&params.grid_id)?;
  129. match editor.get_field_meta(&params.field_id).await {
  130. None => Err(FlowyError::record_not_found()),
  131. Some(field_meta) => {
  132. let type_option_data = get_type_option_data(&field_meta, &field_meta.field_type).await?;
  133. let data = FieldTypeOptionData {
  134. grid_id: params.grid_id,
  135. field: field_meta.into(),
  136. type_option_data,
  137. };
  138. data_result(data)
  139. }
  140. }
  141. }
  142. /// Create FieldMeta and save it. Return the FieldTypeOptionData.
  143. #[tracing::instrument(level = "debug", skip(data, manager), err)]
  144. pub(crate) async fn create_field_type_option_data_handler(
  145. data: Data<EditFieldPayload>,
  146. manager: AppData<Arc<GridManager>>,
  147. ) -> DataResult<FieldTypeOptionData, FlowyError> {
  148. let params: CreateFieldParams = data.into_inner().try_into()?;
  149. let editor = manager.get_grid_editor(&params.grid_id)?;
  150. let field_meta = editor.create_next_field_meta(&params.field_type).await?;
  151. let type_option_data = get_type_option_data(&field_meta, &field_meta.field_type).await?;
  152. data_result(FieldTypeOptionData {
  153. grid_id: params.grid_id,
  154. field: field_meta.into(),
  155. type_option_data,
  156. })
  157. }
  158. #[tracing::instrument(level = "debug", skip(data, manager), err)]
  159. pub(crate) async fn move_item_handler(
  160. data: Data<MoveItemPayload>,
  161. manager: AppData<Arc<GridManager>>,
  162. ) -> Result<(), FlowyError> {
  163. let params: MoveItemParams = data.into_inner().try_into()?;
  164. let editor = manager.get_grid_editor(&params.grid_id)?;
  165. let _ = editor.move_item(params).await?;
  166. Ok(())
  167. }
  168. /// The FieldMeta contains multiple data, each of them belongs to a specific FieldType.
  169. async fn get_type_option_data(field_meta: &FieldMeta, field_type: &FieldType) -> FlowyResult<Vec<u8>> {
  170. let s = field_meta
  171. .get_type_option_str(field_type)
  172. .unwrap_or_else(|| default_type_option_builder_from_type(field_type).entry().json_str());
  173. let builder = type_option_builder_from_json_str(&s, &field_meta.field_type);
  174. let type_option_data = builder.entry().protobuf_bytes().to_vec();
  175. Ok(type_option_data)
  176. }
  177. #[tracing::instrument(level = "debug", skip(data, manager), err)]
  178. pub(crate) async fn get_row_handler(
  179. data: Data<RowIdentifierPayload>,
  180. manager: AppData<Arc<GridManager>>,
  181. ) -> DataResult<Row, FlowyError> {
  182. let params: RowIdentifier = data.into_inner().try_into()?;
  183. let editor = manager.get_grid_editor(&params.grid_id)?;
  184. match editor.get_row(&params.row_id).await? {
  185. None => Err(FlowyError::record_not_found().context("Can not find the row")),
  186. Some(row) => data_result(row),
  187. }
  188. }
  189. #[tracing::instrument(level = "debug", skip(data, manager), err)]
  190. pub(crate) async fn delete_row_handler(
  191. data: Data<RowIdentifierPayload>,
  192. manager: AppData<Arc<GridManager>>,
  193. ) -> Result<(), FlowyError> {
  194. let params: RowIdentifier = data.into_inner().try_into()?;
  195. let editor = manager.get_grid_editor(&params.grid_id)?;
  196. let _ = editor.delete_row(&params.row_id).await?;
  197. Ok(())
  198. }
  199. #[tracing::instrument(level = "debug", skip(data, manager), err)]
  200. pub(crate) async fn duplicate_row_handler(
  201. data: Data<RowIdentifierPayload>,
  202. manager: AppData<Arc<GridManager>>,
  203. ) -> Result<(), FlowyError> {
  204. let params: RowIdentifier = data.into_inner().try_into()?;
  205. let editor = manager.get_grid_editor(&params.grid_id)?;
  206. let _ = editor.duplicate_row(&params.row_id).await?;
  207. Ok(())
  208. }
  209. #[tracing::instrument(level = "debug", skip(data, manager), err)]
  210. pub(crate) async fn create_row_handler(
  211. data: Data<CreateRowPayload>,
  212. manager: AppData<Arc<GridManager>>,
  213. ) -> Result<(), FlowyError> {
  214. let params: CreateRowParams = data.into_inner().try_into()?;
  215. let editor = manager.get_grid_editor(params.grid_id.as_ref())?;
  216. let _ = editor.create_row(params.start_row_id).await?;
  217. Ok(())
  218. }
  219. // #[tracing::instrument(level = "debug", skip_all, err)]
  220. pub(crate) async fn get_cell_handler(
  221. data: Data<CellIdentifierPayload>,
  222. manager: AppData<Arc<GridManager>>,
  223. ) -> DataResult<Cell, FlowyError> {
  224. let params: CellIdentifier = data.into_inner().try_into()?;
  225. let editor = manager.get_grid_editor(&params.grid_id)?;
  226. match editor.get_cell(&params).await {
  227. None => data_result(Cell::empty(&params.field_id)),
  228. Some(cell) => data_result(cell),
  229. }
  230. }
  231. #[tracing::instrument(level = "debug", skip_all, err)]
  232. pub(crate) async fn update_cell_handler(
  233. data: Data<CellChangeset>,
  234. manager: AppData<Arc<GridManager>>,
  235. ) -> Result<(), FlowyError> {
  236. let changeset: CellChangeset = data.into_inner();
  237. let editor = manager.get_grid_editor(&changeset.grid_id)?;
  238. let _ = editor.update_cell(changeset).await?;
  239. Ok(())
  240. }
  241. #[tracing::instrument(level = "debug", skip(data, manager), err)]
  242. pub(crate) async fn get_date_cell_data_handler(
  243. data: Data<CellIdentifierPayload>,
  244. manager: AppData<Arc<GridManager>>,
  245. ) -> DataResult<DateCellData, FlowyError> {
  246. let params: CellIdentifier = data.into_inner().try_into()?;
  247. let editor = manager.get_grid_editor(&params.grid_id)?;
  248. match editor.get_field_meta(&params.field_id).await {
  249. None => {
  250. tracing::error!("Can't find the corresponding field with id: {}", params.field_id);
  251. data_result(DateCellData::default())
  252. }
  253. Some(field_meta) => {
  254. let cell_meta = editor.get_cell_meta(&params.row_id, &params.field_id).await?;
  255. let type_option = DateTypeOption::from(&field_meta);
  256. let date_cell_data = type_option.make_date_cell_data(&cell_meta)?;
  257. data_result(date_cell_data)
  258. }
  259. }
  260. }
  261. #[tracing::instrument(level = "debug", skip_all, err)]
  262. pub(crate) async fn new_select_option_handler(
  263. data: Data<CreateSelectOptionPayload>,
  264. manager: AppData<Arc<GridManager>>,
  265. ) -> DataResult<SelectOption, FlowyError> {
  266. let params: CreateSelectOptionParams = data.into_inner().try_into()?;
  267. let editor = manager.get_grid_editor(&params.grid_id)?;
  268. match editor.get_field_meta(&params.field_id).await {
  269. None => Err(ErrorCode::InvalidData.into()),
  270. Some(field_meta) => {
  271. let type_option = select_option_operation(&field_meta)?;
  272. let select_option = type_option.create_option(&params.option_name);
  273. data_result(select_option)
  274. }
  275. }
  276. }
  277. #[tracing::instrument(level = "debug", skip_all, err)]
  278. pub(crate) async fn update_select_option_handler(
  279. data: Data<SelectOptionChangesetPayload>,
  280. manager: AppData<Arc<GridManager>>,
  281. ) -> Result<(), FlowyError> {
  282. let changeset: SelectOptionChangeset = data.into_inner().try_into()?;
  283. let editor = manager.get_grid_editor(&changeset.cell_identifier.grid_id)?;
  284. if let Some(mut field_meta) = editor.get_field_meta(&changeset.cell_identifier.field_id).await {
  285. let mut type_option = select_option_operation(&field_meta)?;
  286. let mut cell_content_changeset = None;
  287. if let Some(option) = changeset.insert_option {
  288. cell_content_changeset = Some(SelectOptionCellContentChangeset::from_insert(&option.id).to_str());
  289. type_option.insert_option(option);
  290. }
  291. if let Some(option) = changeset.update_option {
  292. type_option.insert_option(option);
  293. }
  294. if let Some(option) = changeset.delete_option {
  295. cell_content_changeset = Some(SelectOptionCellContentChangeset::from_delete(&option.id).to_str());
  296. type_option.delete_option(option);
  297. }
  298. field_meta.insert_type_option_entry(&*type_option);
  299. let _ = editor.replace_field(field_meta).await?;
  300. let changeset = CellChangeset {
  301. grid_id: changeset.cell_identifier.grid_id,
  302. row_id: changeset.cell_identifier.row_id,
  303. field_id: changeset.cell_identifier.field_id,
  304. cell_content_changeset,
  305. };
  306. let _ = editor.update_cell(changeset).await?;
  307. }
  308. Ok(())
  309. }
  310. #[tracing::instrument(level = "debug", skip(data, manager), err)]
  311. pub(crate) async fn get_select_option_handler(
  312. data: Data<CellIdentifierPayload>,
  313. manager: AppData<Arc<GridManager>>,
  314. ) -> DataResult<SelectOptionCellData, FlowyError> {
  315. let params: CellIdentifier = data.into_inner().try_into()?;
  316. let editor = manager.get_grid_editor(&params.grid_id)?;
  317. match editor.get_field_meta(&params.field_id).await {
  318. None => {
  319. tracing::error!("Can't find the corresponding field with id: {}", params.field_id);
  320. data_result(SelectOptionCellData::default())
  321. }
  322. Some(field_meta) => {
  323. let cell_meta = editor.get_cell_meta(&params.row_id, &params.field_id).await?;
  324. let type_option = select_option_operation(&field_meta)?;
  325. let option_context = type_option.select_option_cell_data(&cell_meta);
  326. data_result(option_context)
  327. }
  328. }
  329. }
  330. #[tracing::instrument(level = "debug", skip_all, err)]
  331. pub(crate) async fn update_select_option_cell_handler(
  332. data: Data<SelectOptionCellChangesetPayload>,
  333. manager: AppData<Arc<GridManager>>,
  334. ) -> Result<(), FlowyError> {
  335. let params: SelectOptionCellChangesetParams = data.into_inner().try_into()?;
  336. let editor = manager.get_grid_editor(&params.cell_identifier.grid_id)?;
  337. let _ = editor.update_cell(params.into()).await?;
  338. Ok(())
  339. }
  340. #[tracing::instrument(level = "debug", skip_all, err)]
  341. pub(crate) async fn update_date_cell_handler(
  342. data: Data<DateChangesetPayload>,
  343. manager: AppData<Arc<GridManager>>,
  344. ) -> Result<(), FlowyError> {
  345. let params: DateChangesetParams = data.into_inner().try_into()?;
  346. let editor = manager.get_grid_editor(&params.cell_identifier.grid_id)?;
  347. let _ = editor.update_cell(params.into()).await?;
  348. Ok(())
  349. }