ci: fix unit test

Author: appflowy

frontend/rust-lib/flowy-grid/src/dart_notification.rs

@@ -11,7 +11,8 @@ pub enum GridNotification {
     DidUpdateRow = 30,
     DidUpdateCell = 40,
     DidUpdateField = 50,
-    DidUpdateGroup = 60,
+    DidUpdateGroupView = 60,
+    DidUpdateGroup = 61,
 }
 
 impl std::default::Default for GridNotification {

frontend/rust-lib/flowy-grid/src/entities/group_entities/group_changeset.rs

@@ -104,7 +104,7 @@ impl TryInto<MoveGroupParams> for MoveGroupPayloadPB {
 }
 
 #[derive(Debug, Default, ProtoBuf)]
-pub struct GroupsChangesetPB {
+pub struct GroupViewChangesetPB {
     #[pb(index = 1)]
     pub view_id: String,
 
@@ -115,4 +115,4 @@ pub struct GroupsChangesetPB {
     pub deleted_groups: Vec<String>,
 }
 
-impl GroupsChangesetPB {}
+impl GroupViewChangesetPB {}

frontend/rust-lib/flowy-grid/src/event_handler.rs

@@ -35,17 +35,6 @@ pub(crate) async fn get_grid_setting_handler(
     data_result(grid_setting)
 }
 
-#[tracing::instrument(level = "trace", skip(data, manager), err)]
-pub(crate) async fn update_grid_setting_handler(
-    data: Data<GridSettingChangesetPayloadPB>,
-    manager: AppData<Arc<GridManager>>,
-) -> Result<(), FlowyError> {
-    let params: GridSettingChangesetParams = data.into_inner().try_into()?;
-    let editor = manager.open_grid(&params.grid_id).await?;
-    let _ = editor.update_grid_setting(params).await?;
-    Ok(())
-}
-
 #[tracing::instrument(level = "debug", skip(data, manager), err)]
 pub(crate) async fn get_grid_blocks_handler(
     data: Data<QueryBlocksPayloadPB>,
@@ -441,9 +430,9 @@ pub(crate) async fn create_board_card_handler(
 pub(crate) async fn move_group_handler(
     data: Data<MoveGroupPayloadPB>,
     manager: AppData<Arc<GridManager>>,
-) -> DataResult<GroupsChangesetPB, FlowyError> {
+) -> FlowyResult<()> {
     let params: MoveGroupParams = data.into_inner().try_into()?;
     let editor = manager.get_grid_editor(params.view_id.as_ref())?;
-    let changeset = editor.move_group(params).await?;
-    data_result(changeset)
+    let _ = editor.move_group(params).await?;
+    Ok(())
 }

frontend/rust-lib/flowy-grid/src/event_map.rs

@@ -11,7 +11,7 @@ pub fn create(grid_manager: Arc<GridManager>) -> Module {
         .event(GridEvent::GetGrid, get_grid_handler)
         .event(GridEvent::GetGridBlocks, get_grid_blocks_handler)
         .event(GridEvent::GetGridSetting, get_grid_setting_handler)
-        .event(GridEvent::UpdateGridSetting, update_grid_setting_handler)
+        // .event(GridEvent::UpdateGridSetting, update_grid_setting_handler)
         // Field
         .event(GridEvent::GetFields, get_fields_handler)
         .event(GridEvent::UpdateField, update_field_handler)
@@ -219,6 +219,6 @@ pub enum GridEvent {
     #[event(input = "CreateBoardCardPayloadPB", output = "RowPB")]
     CreateBoardCard = 110,
 
-    #[event(input = "MoveGroupPayloadPB", output = "GroupsChangesetPB")]
+    #[event(input = "MoveGroupPayloadPB")]
     MoveGroup = 111,
 }

frontend/rust-lib/flowy-grid/src/services/grid_editor.rs

@@ -343,9 +343,9 @@ impl GridRevisionEditor {
         Ok(row_pb)
     }
 
-    pub async fn move_group(&self, _params: MoveGroupParams) -> FlowyResult<GroupsChangesetPB> {
-        //
-        todo!()
+    pub async fn move_group(&self, params: MoveGroupParams) -> FlowyResult<()> {
+        let _ = self.view_manager.move_group(params).await?;
+        Ok(())
     }
 
     pub async fn insert_rows(&self, row_revs: Vec<RowRevision>) -> FlowyResult<Vec<RowPB>> {
@@ -514,8 +514,13 @@ impl GridRevisionEditor {
         self.view_manager.get_filters().await
     }
 
-    pub async fn update_grid_setting(&self, params: GridSettingChangesetParams) -> FlowyResult<()> {
-        let _ = self.view_manager.update_setting(params).await?;
+    pub async fn update_filter(&self, params: CreateFilterParams) -> FlowyResult<()> {
+        let _ = self.view_manager.update_filter(params).await?;
+        Ok(())
+    }
+
+    pub async fn delete_filter(&self, params: DeleteFilterParams) -> FlowyResult<()> {
+        let _ = self.view_manager.delete_filter(params).await?;
         Ok(())
     }
 

frontend/rust-lib/flowy-grid/src/services/grid_view_editor.rs

@@ -1,8 +1,8 @@
 use crate::dart_notification::{send_dart_notification, GridNotification};
 use crate::entities::{
-    CreateRowParams, GridFilterConfiguration, GridLayout, GridLayoutPB, GridSettingChangesetParams, GridSettingPB,
-    GroupPB, GroupRowsChangesetPB, InsertedRowPB, RepeatedGridConfigurationFilterPB, RepeatedGridGroupConfigurationPB,
-    RowPB,
+    CreateFilterParams, CreateRowParams, DeleteFilterParams, GridFilterConfiguration, GridLayout, GridLayoutPB,
+    GridSettingChangesetParams, GridSettingPB, GroupPB, GroupRowsChangesetPB, GroupViewChangesetPB, InsertedRowPB,
+    MoveGroupParams, RepeatedGridConfigurationFilterPB, RepeatedGridGroupConfigurationPB, RowPB,
 };
 use crate::services::grid_editor_task::GridServiceTaskScheduler;
 use crate::services::grid_view_manager::{GridViewFieldDelegate, GridViewRowDelegate};
@@ -11,7 +11,8 @@ use crate::services::group::{
 };
 use flowy_error::{FlowyError, FlowyResult};
 use flowy_grid_data_model::revision::{
-    FieldRevision, FieldTypeRevision, GroupConfigurationRevision, RowChangeset, RowRevision,
+    gen_grid_filter_id, FieldRevision, FieldTypeRevision, FilterConfigurationRevision, GroupConfigurationRevision,
+    RowChangeset, RowRevision,
 };
 use flowy_revision::{RevisionCloudService, RevisionManager, RevisionObjectBuilder};
 use flowy_sync::client_grid::{GridViewRevisionChangeset, GridViewRevisionPad};
@@ -99,7 +100,7 @@ impl GridViewRevisionEditor {
                     index: None,
                 };
                 let changeset = GroupRowsChangesetPB::insert(group_id.clone(), vec![inserted_row]);
-                self.notify_did_update_group(changeset).await;
+                self.notify_did_update_group_rows(changeset).await;
             }
         }
     }
@@ -114,7 +115,7 @@ impl GridViewRevisionEditor {
             .await
         {
             for changeset in changesets {
-                self.notify_did_update_group(changeset).await;
+                self.notify_did_update_group_rows(changeset).await;
             }
         }
     }
@@ -128,7 +129,7 @@ impl GridViewRevisionEditor {
             .await
         {
             for changeset in changesets {
-                self.notify_did_update_group(changeset).await;
+                self.notify_did_update_group_rows(changeset).await;
             }
         }
     }
@@ -150,7 +151,7 @@ impl GridViewRevisionEditor {
         {
             for changeset in changesets {
                 tracing::trace!("Group: {} changeset: {}", changeset.group_id, changeset);
-                self.notify_did_update_group(changeset).await;
+                self.notify_did_update_group_rows(changeset).await;
             }
         }
     }
@@ -173,22 +174,19 @@ impl GridViewRevisionEditor {
         } else {
             self.group_service.read().await.groups().await
         };
-
         Ok(groups.into_iter().map(GroupPB::from).collect())
     }
 
+    pub(crate) async fn move_group(&self, params: MoveGroupParams) -> FlowyResult<()> {
+        todo!()
+    }
+
     pub(crate) async fn get_setting(&self) -> GridSettingPB {
         let field_revs = self.field_delegate.get_field_revs().await;
         let grid_setting = make_grid_setting(&*self.pad.read().await, &field_revs);
         grid_setting
     }
 
-    pub(crate) async fn update_setting(&self, _changeset: GridSettingChangesetParams) -> FlowyResult<()> {
-        // let _ = self.modify(|pad| Ok(pad.update_setting(changeset)?)).await;
-        // Ok(())
-        todo!()
-    }
-
     pub(crate) async fn get_filters(&self) -> Vec<GridFilterConfiguration> {
         let field_revs = self.field_delegate.get_field_revs().await;
         match self.pad.read().await.get_all_filters(&field_revs) {
@@ -201,12 +199,44 @@ impl GridViewRevisionEditor {
         }
     }
 
-    async fn notify_did_update_group(&self, changeset: GroupRowsChangesetPB) {
+    pub(crate) async fn insert_filter(&self, insert_filter: CreateFilterParams) -> FlowyResult<()> {
+        self.modify(|pad| {
+            let filter_rev = FilterConfigurationRevision {
+                id: gen_grid_filter_id(),
+                field_id: insert_filter.field_id.clone(),
+                condition: insert_filter.condition,
+                content: insert_filter.content,
+            };
+            let changeset = pad.insert_filter(&insert_filter.field_id, &insert_filter.field_type_rev, filter_rev)?;
+            Ok(changeset)
+        })
+        .await
+    }
+
+    pub(crate) async fn delete_filter(&self, delete_filter: DeleteFilterParams) -> FlowyResult<()> {
+        self.modify(|pad| {
+            let changeset = pad.delete_filter(
+                &delete_filter.field_id,
+                &delete_filter.field_type_rev,
+                &delete_filter.filter_id,
+            )?;
+            Ok(changeset)
+        })
+        .await
+    }
+
+    async fn notify_did_update_group_rows(&self, changeset: GroupRowsChangesetPB) {
         send_dart_notification(&changeset.group_id, GridNotification::DidUpdateGroup)
             .payload(changeset)
             .send();
     }
 
+    async fn notify_did_update_view(&self, changeset: GroupViewChangesetPB) {
+        send_dart_notification(&self.view_id, GridNotification::DidUpdateGroupView)
+            .payload(changeset)
+            .send();
+    }
+
     #[allow(dead_code)]
     async fn modify<F>(&self, f: F) -> FlowyResult<()>
     where

frontend/rust-lib/flowy-grid/src/services/grid_view_manager.rs

@@ -1,5 +1,6 @@
 use crate::entities::{
-    CreateRowParams, GridFilterConfiguration, GridSettingChangesetParams, GridSettingPB, RepeatedGridGroupPB, RowPB,
+    CreateFilterParams, CreateRowParams, DeleteFilterParams, GridFilterConfiguration, GridSettingChangesetParams,
+    GridSettingPB, MoveGroupParams, RepeatedGridGroupPB, RowPB,
 };
 use crate::manager::GridUser;
 use crate::services::grid_editor_task::GridServiceTaskScheduler;
@@ -98,15 +99,19 @@ impl GridViewManager {
         Ok(view_editor.get_setting().await)
     }
 
-    pub(crate) async fn update_setting(&self, params: GridSettingChangesetParams) -> FlowyResult<()> {
+    pub(crate) async fn get_filters(&self) -> FlowyResult<Vec<GridFilterConfiguration>> {
         let view_editor = self.get_default_view_editor().await?;
-        let _ = view_editor.update_setting(params).await?;
-        Ok(())
+        Ok(view_editor.get_filters().await)
     }
 
-    pub(crate) async fn get_filters(&self) -> FlowyResult<Vec<GridFilterConfiguration>> {
+    pub(crate) async fn update_filter(&self, insert_filter: CreateFilterParams) -> FlowyResult<()> {
         let view_editor = self.get_default_view_editor().await?;
-        Ok(view_editor.get_filters().await)
+        view_editor.insert_filter(insert_filter).await
+    }
+
+    pub(crate) async fn delete_filter(&self, delete_filter: DeleteFilterParams) -> FlowyResult<()> {
+        let view_editor = self.get_default_view_editor().await?;
+        view_editor.delete_filter(delete_filter).await
     }
 
     pub(crate) async fn load_groups(&self) -> FlowyResult<RepeatedGridGroupPB> {
@@ -115,6 +120,12 @@ impl GridViewManager {
         Ok(RepeatedGridGroupPB { items: groups })
     }
 
+    pub(crate) async fn move_group(&self, params: MoveGroupParams) -> FlowyResult<()> {
+        let view_editor = self.get_default_view_editor().await?;
+        let _s = view_editor.move_group(params).await?;
+        Ok(())
+    }
+
     /// It may generate a RowChangeset when the Row was moved from one group to another.
     /// The return value, [RowChangeset], contains the changes made by the groups.
     ///
@@ -131,9 +142,6 @@ impl GridViewManager {
         }
     }
 
-    #[allow(dead_code)]
-    pub(crate) async fn move_group(&self) {}
-
     pub(crate) async fn get_view_editor(&self, view_id: &str) -> FlowyResult<Arc<GridViewRevisionEditor>> {
         debug_assert!(!view_id.is_empty());
         match self.view_editors.get(view_id) {