chore: delete/create filter

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

@@ -27,7 +27,7 @@ pub(crate) async fn get_grid_setting_handler(
     let grid_id: GridId = data.into_inner();
     let editor = manager.open_grid(grid_id).await?;
     let grid_setting = editor.get_grid_setting().await?;
-    data_result(grid_setting.into())
+    data_result(grid_setting)
 }
 
 #[tracing::instrument(level = "trace", skip(data, manager), err)]

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

@@ -438,10 +438,19 @@ impl GridRevisionEditor {
         })
     }
 
-    pub async fn get_grid_setting(&self) -> FlowyResult<GridSettingRevision> {
-        let pad_read_guard = self.grid_pad.read().await;
-        let grid_setting_rev = pad_read_guard.get_grid_setting_rev();
-        Ok(grid_setting_rev)
+    pub async fn get_grid_setting(&self) -> FlowyResult<GridSetting> {
+        let read_guard = self.grid_pad.read().await;
+        let grid_setting_rev = read_guard.get_grid_setting_rev();
+        Ok(grid_setting_rev.into())
+    }
+
+    pub async fn get_grid_filter(&self, layout_type: &GridLayoutType) -> FlowyResult<Vec<GridFilter>> {
+        let layout_type: GridLayoutRevision = layout_type.clone().into();
+        let read_guard = self.grid_pad.read().await;
+        match read_guard.get_grid_setting_rev().filter.get(&layout_type) {
+            Some(filter_revs) => Ok(filter_revs.iter().map(GridFilter::from).collect::<Vec<GridFilter>>()),
+            None => Ok(vec![]),
+        }
     }
 
     pub async fn update_grid_setting(&self, params: GridSettingChangesetParams) -> FlowyResult<()> {

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

@@ -6,3 +6,4 @@ pub mod field;
 pub mod grid_editor;
 pub mod persistence;
 pub mod row;
+pub mod setting;

frontend/rust-lib/flowy-grid/src/services/setting/mod.rs

@@ -0,0 +1,3 @@
+mod setting_builder;
+
+pub use setting_builder::*;

frontend/rust-lib/flowy-grid/src/services/setting/setting_builder.rs

@@ -0,0 +1,35 @@
+use flowy_grid_data_model::entities::{CreateGridFilterParams, GridLayoutType, GridSettingChangesetParams};
+
+pub struct GridSettingChangesetBuilder {
+    params: GridSettingChangesetParams,
+}
+
+impl GridSettingChangesetBuilder {
+    pub fn new(grid_id: &str, layout_type: &GridLayoutType) -> Self {
+        let params = GridSettingChangesetParams {
+            grid_id: grid_id.to_string(),
+            layout_type: layout_type.clone(),
+            insert_filter: None,
+            delete_filter: None,
+            insert_group: None,
+            delete_group: None,
+            insert_sort: None,
+            delete_sort: None,
+        };
+        Self { params }
+    }
+
+    pub fn insert_filter(mut self, params: CreateGridFilterParams) -> Self {
+        self.params.insert_filter = Some(params);
+        self
+    }
+
+    pub fn delete_filter(mut self, filter_id: &str) -> Self {
+        self.params.delete_filter = Some(filter_id.to_string());
+        self
+    }
+
+    pub fn build(self) -> GridSettingChangesetParams {
+        self.params
+    }
+}

frontend/rust-lib/flowy-grid/tests/grid/script.rs

@@ -2,6 +2,7 @@ use bytes::Bytes;
 use flowy_grid::services::field::*;
 use flowy_grid::services::grid_editor::{GridPadBuilder, GridRevisionEditor};
 use flowy_grid::services::row::CreateRowRevisionPayload;
+use flowy_grid::services::setting::GridSettingChangesetBuilder;
 use flowy_grid_data_model::entities::*;
 use flowy_grid_data_model::revision::*;
 use flowy_revision::REVISION_WRITE_INTERVAL_IN_MILLIS;
@@ -66,8 +67,17 @@ pub enum EditorScript {
     UpdateGridSetting {
         params: GridSettingChangesetParams,
     },
+    InsertGridTableFilter {
+        payload: CreateGridFilterPayload,
+    },
+    AssertTableFilterCount {
+        count: i32,
+    },
+    DeleteGridTableFilter {
+        filter_id: String,
+    },
     AssertGridSetting {
-        expected_setting: GridSettingRevision,
+        expected_setting: GridSetting,
     },
     AssertGridRevisionPad,
 }
@@ -239,6 +249,26 @@ impl GridEditorTest {
             EditorScript::UpdateGridSetting { params } => {
                 let _ = self.editor.update_grid_setting(params).await.unwrap();
             }
+            EditorScript::InsertGridTableFilter { payload } => {
+                let params: CreateGridFilterParams = payload.try_into().unwrap();
+                let layout_type = GridLayoutType::Table;
+                let params = GridSettingChangesetBuilder::new(&self.grid_id, &layout_type)
+                    .insert_filter(params)
+                    .build();
+                let _ = self.editor.update_grid_setting(params).await.unwrap();
+            }
+            EditorScript::AssertTableFilterCount { count } => {
+                let layout_type = GridLayoutType::Table;
+                let filters = self.editor.get_grid_filter(&layout_type).await.unwrap();
+                assert_eq!(count as usize, filters.len());
+            }
+            EditorScript::DeleteGridTableFilter { filter_id } => {
+                let layout_type = GridLayoutType::Table;
+                let params = GridSettingChangesetBuilder::new(&self.grid_id, &layout_type)
+                    .delete_filter(&filter_id)
+                    .build();
+                let _ = self.editor.update_grid_setting(params).await.unwrap();
+            }
             EditorScript::AssertGridSetting { expected_setting } => {
                 let setting = self.editor.get_grid_setting().await.unwrap();
                 assert_eq!(expected_setting, setting);
@@ -262,8 +292,18 @@ impl GridEditorTest {
             .row_revs
     }
 
-    pub(crate) async fn get_grid_setting(&self) -> GridSettingRevision {
-        self.editor.get_grid_setting().await.unwrap()
+    pub async fn grid_filters(&self) -> Vec<GridFilter> {
+        let layout_type = GridLayoutType::Table;
+        self.editor.get_grid_filter(&layout_type).await.unwrap()
+    }
+
+    pub fn text_field(&self) -> &FieldRevision {
+        self.field_revs
+            .iter()
+            .filter(|field_rev| field_rev.field_type == FieldType::RichText)
+            .collect::<Vec<_>>()
+            .pop()
+            .unwrap()
     }
 }
 

frontend/rust-lib/flowy-grid/tests/grid/setting_test.rs

@@ -1,29 +1,72 @@
 use crate::grid::script::EditorScript::*;
 use crate::grid::script::*;
+
 use flowy_grid_data_model::entities::{
-    CreateGridFilterParams, CreateGridFilterPayload, GridLayoutType, GridSettingChangesetParams,
+    CreateGridFilterParams, CreateGridFilterPayload, GridLayoutType, GridSettingChangesetParams, TextFilterCondition,
 };
-use flowy_grid_data_model::revision::GridSettingRevision;
 
 #[tokio::test]
-async fn grid_setting_create_filter_test() {
+async fn grid_setting_create_text_filter_test() {
     let test = GridEditorTest::new().await;
+    let field_rev = test.text_field();
+    let condition = TextFilterCondition::TextIsEmpty as i32;
 
-    let layout_type = GridLayoutType::Table;
-    let field_rev = test.field_revs.last().unwrap();
-    let create_params: CreateGridFilterParams = CreateGridFilterPayload {
-        field_id: field_rev.id.clone(),
-        field_type: field_rev.field_type.clone(),
-    }
-    .try_into()
-    .unwrap();
-    let params = GridSettingChangesetParams::from_insert_filter(&test.grid_id, layout_type, create_params);
-
-    let scripts = vec![UpdateGridSetting { params }];
+    let scripts = vec![
+        InsertGridTableFilter {
+            payload: CreateGridFilterPayload {
+                field_id: field_rev.id.clone(),
+                field_type: field_rev.field_type.clone(),
+                condition,
+                content: Some("abc".to_owned()),
+            },
+        },
+        AssertTableFilterCount { count: 1 },
+    ];
     GridEditorTest::new().await.run_scripts(scripts).await;
-
-    // let mut expected_grid_setting = test.get_grid_setting().await;
 }
 
+#[tokio::test]
+#[should_panic]
+async fn grid_setting_create_text_filter_panic_test() {
+    let test = GridEditorTest::new().await;
+    let field_rev = test.text_field();
+    let scripts = vec![InsertGridTableFilter {
+        payload: CreateGridFilterPayload {
+            field_id: field_rev.id.clone(),
+            field_type: field_rev.field_type.clone(),
+            condition: 20, // Invalid condition type
+            content: Some("abc".to_owned()),
+        },
+    }];
+    GridEditorTest::new().await.run_scripts(scripts).await;
+}
+
+#[tokio::test]
+async fn grid_setting_delete_text_filter_test() {
+    let mut test = GridEditorTest::new().await;
+    let field_rev = test.text_field();
+    let condition = TextFilterCondition::TextIsEmpty as i32;
+
+    let scripts = vec![
+        InsertGridTableFilter {
+            payload: CreateGridFilterPayload {
+                field_id: field_rev.id.clone(),
+                field_type: field_rev.field_type.clone(),
+                condition,
+                content: Some("abc".to_owned()),
+            },
+        },
+        AssertTableFilterCount { count: 1 },
+    ];
+
+    test.run_scripts(scripts).await;
+    let filter = test.grid_filters().await.pop().unwrap();
+
+    test.run_scripts(vec![
+        DeleteGridTableFilter { filter_id: filter.id },
+        AssertTableFilterCount { count: 0 },
+    ])
+    .await;
+}
 #[tokio::test]
 async fn grid_setting_sort_test() {}