Bring projects, wikis, and teams together with AI. AppFlowy is the AI collaborative workspace where you achieve more without losing control of your data. The leading open source Notion alternative.
Dart blogconfluence-alternativecontent-managementcontent-servicesdocumentationflutternote-takingnotion-alternativeproject-managementtask-managementteam-collaborationwiki
chore: reader and writter for group configuration
appflowy91b2917d603b
diff --git a/frontend/rust-lib/flowy-grid/src/entities/field_entities.rs b/frontend/rust-lib/flowy-grid/src/entities/field_entities.rsindex 0993853b8e..271cbcf424 100644--- a/frontend/rust-lib/flowy-grid/src/entities/field_entities.rs+++ b/frontend/rust-lib/flowy-grid/src/entities/field_entities.rs@@ -2,7 +2,6 @@ use flowy_derive::{ProtoBuf, ProtoBuf_Enum};use flowy_error::ErrorCode;use flowy_grid_data_model::parser::NotEmptyStr;use flowy_grid_data_model::revision::{FieldRevision, FieldTypeRevision};-use flowy_sync::entities::grid::FieldChangesetParams;use serde_repr::*;use std::sync::Arc;diff --git a/frontend/rust-lib/flowy-grid/src/entities/mod.rs b/frontend/rust-lib/flowy-grid/src/entities/mod.rsindex 96c7a9ba60..eb11d982a4 100644--- a/frontend/rust-lib/flowy-grid/src/entities/mod.rs+++ b/frontend/rust-lib/flowy-grid/src/entities/mod.rs@@ -6,7 +6,6 @@ mod grid_entities;mod group_entities;mod row_entities;mod setting_entities;-mod sort_entities;pub use block_entities::*;pub use cell_entities::*;@@ -16,4 +15,3 @@ pub use grid_entities::*;pub use group_entities::*;pub use row_entities::*;pub use setting_entities::*;-pub use sort_entities::*;diff --git a/frontend/rust-lib/flowy-grid/src/entities/setting_entities.rs b/frontend/rust-lib/flowy-grid/src/entities/setting_entities.rsindex 67fcc884e9..9c02a2c692 100644--- a/frontend/rust-lib/flowy-grid/src/entities/setting_entities.rs+++ b/frontend/rust-lib/flowy-grid/src/entities/setting_entities.rs@@ -1,13 +1,12 @@use crate::entities::{- CreatGroupParams, CreateFilterParams, CreateGridFilterPayloadPB, CreateGridGroupPayloadPB, CreateGridSortPayloadPB,- CreateSortParams, DeleteFilterParams, DeleteFilterPayloadPB, DeleteGroupParams, DeleteGroupPayloadPB,- RepeatedGridConfigurationFilterPB, RepeatedGridGroupConfigurationPB, RepeatedGridSortPB,+ CreatGroupParams, CreateFilterParams, CreateGridFilterPayloadPB, CreateGridGroupPayloadPB, DeleteFilterParams,+ DeleteFilterPayloadPB, DeleteGroupParams, DeleteGroupPayloadPB, RepeatedGridConfigurationFilterPB,+ RepeatedGridGroupConfigurationPB,};use flowy_derive::{ProtoBuf, ProtoBuf_Enum};use flowy_error::ErrorCode;use flowy_grid_data_model::parser::NotEmptyStr;use flowy_grid_data_model::revision::LayoutRevision;-use flowy_sync::entities::grid::GridSettingChangesetParams;use std::collections::HashMap;use std::convert::TryInto;use strum::IntoEnumIterator;@@ -27,9 +26,6 @@ pub struct GridSettingPB {#[pb(index = 4)]pub group_configuration_by_field_id: HashMap<String, RepeatedGridGroupConfigurationPB>,-- #[pb(index = 5)]- pub sorts_by_field_id: HashMap<String, RepeatedGridSortPB>,}#[derive(Eq, PartialEq, ProtoBuf, Debug, Default, Clone)]@@ -99,12 +95,6 @@ pub struct GridSettingChangesetPayloadPB {#[pb(index = 6, one_of)]pub delete_group: Option<DeleteGroupPayloadPB>,-- #[pb(index = 7, one_of)]- pub insert_sort: Option<CreateGridSortPayloadPB>,-- #[pb(index = 8, one_of)]- pub delete_sort: Option<String>,}impl TryInto<GridSettingChangesetParams> for GridSettingChangesetPayloadPB {@@ -135,16 +125,6 @@ impl TryInto<GridSettingChangesetParams> for GridSettingChangesetPayloadPB {None => None,};- let insert_sort = match self.insert_sort {- None => None,- Some(payload) => Some(payload.try_into()?),- };-- let delete_sort = match self.delete_sort {- None => None,- Some(filter_id) => Some(NotEmptyStr::parse(filter_id).map_err(|_| ErrorCode::FieldIdIsEmpty)?.0),- };-Ok(GridSettingChangesetParams {grid_id: view_id,layout_type: self.layout_type.into(),@@ -152,8 +132,6 @@ impl TryInto<GridSettingChangesetParams> for GridSettingChangesetPayloadPB {delete_filter,insert_group,delete_group,- insert_sort,- delete_sort,})}}@@ -165,8 +143,6 @@ pub struct GridSettingChangesetParams {pub delete_filter: Option<DeleteFilterParams>,pub insert_group: Option<CreatGroupParams>,pub delete_group: Option<DeleteGroupParams>,- pub insert_sort: Option<CreateSortParams>,- pub delete_sort: Option<String>,}impl GridSettingChangesetParams {diff --git a/frontend/rust-lib/flowy-grid/src/entities/sort_entities.rs b/frontend/rust-lib/flowy-grid/src/entities/sort_entities.rsdeleted file mode 100644index 28486a1ee6..0000000000--- a/frontend/rust-lib/flowy-grid/src/entities/sort_entities.rs+++ /dev/null@@ -1,68 +0,0 @@-use flowy_derive::ProtoBuf;-use flowy_error::ErrorCode;-use flowy_grid_data_model::parser::NotEmptyStr;-use flowy_grid_data_model::revision::SortConfigurationRevision;-use std::convert::TryInto;-use std::sync::Arc;--#[derive(Eq, PartialEq, ProtoBuf, Debug, Default, Clone)]-pub struct GridSort {- #[pb(index = 1)]- pub id: String,-- #[pb(index = 2, one_of)]- pub field_id: Option<String>,-}--impl std::convert::From<&SortConfigurationRevision> for GridSort {- fn from(rev: &SortConfigurationRevision) -> Self {- GridSort {- id: rev.id.clone(),-- field_id: rev.field_id.clone(),- }- }-}--#[derive(Eq, PartialEq, ProtoBuf, Debug, Default, Clone)]-pub struct RepeatedGridSortPB {- #[pb(index = 1)]- pub items: Vec<GridSort>,-}--impl std::convert::From<Vec<Arc<SortConfigurationRevision>>> for RepeatedGridSortPB {- fn from(revs: Vec<Arc<SortConfigurationRevision>>) -> Self {- RepeatedGridSortPB {- items: revs.into_iter().map(|rev| rev.as_ref().into()).collect(),- }- }-}--impl std::convert::From<Vec<GridSort>> for RepeatedGridSortPB {- fn from(items: Vec<GridSort>) -> Self {- Self { items }- }-}--#[derive(ProtoBuf, Debug, Default, Clone)]-pub struct CreateGridSortPayloadPB {- #[pb(index = 1, one_of)]- pub field_id: Option<String>,-}--impl TryInto<CreateSortParams> for CreateGridSortPayloadPB {- type Error = ErrorCode;-- fn try_into(self) -> Result<CreateSortParams, Self::Error> {- let field_id = match self.field_id {- None => None,- Some(field_id) => Some(NotEmptyStr::parse(field_id).map_err(|_| ErrorCode::FieldIdIsEmpty)?.0),- };-- Ok(CreateSortParams { field_id })- }-}--pub struct CreateSortParams {- pub field_id: Option<String>,-}diff --git a/frontend/rust-lib/flowy-grid/src/event_handler.rs b/frontend/rust-lib/flowy-grid/src/event_handler.rsindex f9f5e39399..47df88b976 100644--- a/frontend/rust-lib/flowy-grid/src/event_handler.rs+++ b/frontend/rust-lib/flowy-grid/src/event_handler.rs@@ -10,7 +10,6 @@ use crate::services::field::{use crate::services::row::make_row_from_row_rev;use flowy_error::{ErrorCode, FlowyError, FlowyResult};use flowy_grid_data_model::revision::FieldRevision;-use flowy_sync::entities::grid::{FieldChangesetParams, GridSettingChangesetParams};use lib_dispatch::prelude::{data_result, AppData, Data, DataResult};use std::sync::Arc;diff --git a/frontend/rust-lib/flowy-grid/src/services/filter/filter_service.rs b/frontend/rust-lib/flowy-grid/src/services/filter/filter_service.rsindex a2831c0ad9..8335a36fb2 100644--- a/frontend/rust-lib/flowy-grid/src/services/filter/filter_service.rs+++ b/frontend/rust-lib/flowy-grid/src/services/filter/filter_service.rs@@ -4,7 +4,7 @@#![allow(unused_imports)]#![allow(unused_results)]use crate::dart_notification::{send_dart_notification, GridNotification};-use crate::entities::{FieldType, GridBlockChangesetPB};+use crate::entities::{FieldType, GridBlockChangesetPB, GridSettingChangesetParams};use crate::services::block_manager::GridBlockManager;use crate::services::cell::{AnyCellData, CellFilterOperation};use crate::services::field::{@@ -20,7 +20,6 @@ use crate::services::tasks::{FilterTaskContext, Task, TaskContent};use flowy_error::FlowyResult;use flowy_grid_data_model::revision::{CellRevision, FieldId, FieldRevision, RowRevision};use flowy_sync::client_grid::GridRevisionPad;-use flowy_sync::entities::grid::GridSettingChangesetParams;use rayon::prelude::*;use std::collections::HashMap;use std::sync::Arc;diff --git a/frontend/rust-lib/flowy-grid/src/services/grid_editor.rs b/frontend/rust-lib/flowy-grid/src/services/grid_editor.rsindex 055501e117..0559cfa364 100644--- a/frontend/rust-lib/flowy-grid/src/services/grid_editor.rs+++ b/frontend/rust-lib/flowy-grid/src/services/grid_editor.rs@@ -15,7 +15,6 @@ use flowy_error::{ErrorCode, FlowyError, FlowyResult};use flowy_grid_data_model::revision::*;use flowy_revision::{RevisionCloudService, RevisionCompactor, RevisionManager, RevisionObjectBuilder};use flowy_sync::client_grid::{GridRevisionChangeset, GridRevisionPad, JsonDeserializer};-use flowy_sync::entities::grid::{FieldChangesetParams, GridSettingChangesetParams};use flowy_sync::entities::revision::Revision;use flowy_sync::errors::CollaborateResult;use flowy_sync::util::make_text_delta_from_revisions;@@ -101,14 +100,14 @@ impl GridRevisionEditor {grid_id,name: Some(field.name),desc: Some(field.desc),- field_type: Some(field.field_type.into()),+ field_type: Some(field.field_type.clone().into()),frozen: Some(field.frozen),visibility: Some(field.visibility),width: Some(field.width),type_option_data: Some(type_option_data),};- let _ = self.update_field_rev(changeset, field.field_type.clone()).await?;+ let _ = self.update_field_rev(changeset, field.field_type).await?;let _ = self.notify_did_update_grid_field(&field_id).await?;} else {let _ = self@@ -262,60 +261,59 @@ impl GridRevisionEditor {}async fn update_field_rev(&self, params: FieldChangesetParams, field_type: FieldType) -> FlowyResult<()> {- let _ = self- .modify(|grid| {- let deserializer = TypeOptionJsonDeserializer(field_type);-- let changeset = grid.modify_field(¶ms.field_id, |field| {- let mut is_changed = None;- if let Some(name) = changeset.name {- field.name = name;- is_changed = Some(())- }+ self.modify(|grid| {+ let deserializer = TypeOptionJsonDeserializer(field_type);++ let changeset = grid.modify_field(¶ms.field_id, |field| {+ let mut is_changed = None;+ if let Some(name) = params.name {+ field.name = name;+ is_changed = Some(())+ }- if let Some(desc) = changeset.desc {- field.desc = desc;- is_changed = Some(())- }+ if let Some(desc) = params.desc {+ field.desc = desc;+ is_changed = Some(())+ }- if let Some(field_type) = changeset.field_type {- field.ty = field_type;- is_changed = Some(())- }+ if let Some(field_type) = params.field_type {+ field.ty = field_type;+ is_changed = Some(())+ }- if let Some(frozen) = changeset.frozen {- field.frozen = frozen;- is_changed = Some(())- }+ if let Some(frozen) = params.frozen {+ field.frozen = frozen;+ is_changed = Some(())+ }- if let Some(visibility) = changeset.visibility {- field.visibility = visibility;- is_changed = Some(())- }+ if let Some(visibility) = params.visibility {+ field.visibility = visibility;+ is_changed = Some(())+ }- if let Some(width) = changeset.width {- field.width = width;- is_changed = Some(())- }+ if let Some(width) = params.width {+ field.width = width;+ is_changed = Some(())+ }- if let Some(type_option_data) = changeset.type_option_data {- match deserializer.deserialize(type_option_data) {- Ok(json_str) => {- let field_type = field.ty;- field.insert_type_option_str(&field_type, json_str);- is_changed = Some(())- }- Err(err) => {- tracing::error!("Deserialize data to type option json failed: {}", err);- }+ if let Some(type_option_data) = params.type_option_data {+ match deserializer.deserialize(type_option_data) {+ Ok(json_str) => {+ let field_type = field.ty;+ field.insert_type_option_str(&field_type, json_str);+ is_changed = Some(())+ }+ Err(err) => {+ tracing::error!("Deserialize data to type option json failed: {}", err);}}+ }- Ok(is_changed)- })?;- Ok(changeset)- })- .await?;+ Ok(is_changed)+ })?;+ Ok(changeset)+ })+ .await}pub async fn create_block(&self, block_meta_rev: GridBlockMetaRevision) -> FlowyResult<()> {diff --git a/frontend/rust-lib/flowy-grid/src/services/grid_view_editor.rs b/frontend/rust-lib/flowy-grid/src/services/grid_view_editor.rsindex ac1e905d8a..9a7173035a 100644--- a/frontend/rust-lib/flowy-grid/src/services/grid_view_editor.rs+++ b/frontend/rust-lib/flowy-grid/src/services/grid_view_editor.rs@@ -1,18 +1,23 @@use crate::dart_notification::{send_dart_notification, GridNotification};use crate::entities::{- CreateRowParams, GridFilterConfiguration, GridSettingPB, GroupPB, GroupRowsChangesetPB, InsertedRowPB, RowPB,+ CreateRowParams, GridFilterConfiguration, GridLayout, GridLayoutPB, GridSettingChangesetParams, GridSettingPB,+ GroupPB, GroupRowsChangesetPB, InsertedRowPB, RepeatedGridConfigurationFilterPB, RepeatedGridGroupConfigurationPB,+ RowPB,};use crate::services::grid_editor_task::GridServiceTaskScheduler;use crate::services::grid_view_manager::{GridViewFieldDelegate, GridViewRowDelegate};-use crate::services::group::{default_group_configuration, GroupConfigurationDelegate, GroupService};-use crate::services::setting::make_grid_setting;+use crate::services::group::{+ default_group_configuration, GroupConfigurationReader, GroupConfigurationWriter, GroupService,+};use flowy_error::{FlowyError, FlowyResult};-use flowy_grid_data_model::revision::{FieldRevision, GroupConfigurationRevision, RowChangeset, RowRevision};+use flowy_grid_data_model::revision::{+ FieldRevision, FieldTypeRevision, GroupConfigurationRevision, RowChangeset, RowRevision,+};use flowy_revision::{RevisionCloudService, RevisionManager, RevisionObjectBuilder};use flowy_sync::client_grid::{GridViewRevisionChangeset, GridViewRevisionPad};-use flowy_sync::entities::grid::GridSettingChangesetParams;use flowy_sync::entities::revision::Revision;use lib_infra::future::{wrap_future, AFFuture, FutureResult};+use std::collections::HashMap;use std::sync::atomic::{AtomicBool, Ordering};use std::sync::Arc;use tokio::sync::RwLock;@@ -46,7 +51,14 @@ impl GridViewRevisionEditor {let view_revision_pad = rev_manager.load::<GridViewRevisionPadBuilder>(Some(cloud)).await?;let pad = Arc::new(RwLock::new(view_revision_pad));let rev_manager = Arc::new(rev_manager);- let group_service = GroupService::new(Box::new(pad.clone())).await;++ let configuration_reader = GroupConfigurationReaderImpl(pad.clone());+ let configuration_writer = GroupConfigurationWriterImpl {+ user_id: user_id.to_owned(),+ rev_manager: rev_manager.clone(),+ view_pad: pad.clone(),+ };+ let group_service = GroupService::new(configuration_reader, configuration_writer).await;let user_id = user_id.to_owned();let did_load_group = AtomicBool::new(false);Ok(Self {@@ -167,7 +179,7 @@ impl GridViewRevisionEditor {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.get_setting_rev(), &field_revs);+ let grid_setting = make_grid_setting(&*self.pad.read().await, &field_revs);grid_setting}@@ -177,13 +189,9 @@ impl GridViewRevisionEditor {todo!()}- // pub(crate) async fn insert_group(&self, params: CreateGroupParams) -> FlowyResult<()> {- //- // }-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_setting_rev().get_all_filters(&field_revs) {+ match self.pad.read().await.get_all_filters(&field_revs) {None => vec![],Some(filters) => filters.into_values()@@ -207,28 +215,24 @@ impl GridViewRevisionEditor {match f(&mut *write_guard)? {None => {}Some(change) => {- let _ = self.apply_change(change).await?;+ let _ = apply_change(&self.user_id, self.rev_manager.clone(), change).await?;}}Ok(())}+}- async fn apply_change(&self, change: GridViewRevisionChangeset) -> FlowyResult<()> {- let GridViewRevisionChangeset { delta, md5 } = change;- let user_id = self.user_id.clone();- let (base_rev_id, rev_id) = self.rev_manager.next_rev_id_pair();- let delta_data = delta.json_bytes();- let revision = Revision::new(- &self.rev_manager.object_id,- base_rev_id,- rev_id,- delta_data,- &user_id,- md5,- );- let _ = self.rev_manager.add_local_revision(&revision).await?;- Ok(())- }+async fn apply_change(+ user_id: &str,+ rev_manager: Arc<RevisionManager>,+ change: GridViewRevisionChangeset,+) -> FlowyResult<()> {+ let GridViewRevisionChangeset { delta, md5 } = change;+ let (base_rev_id, rev_id) = rev_manager.next_rev_id_pair();+ let delta_data = delta.json_bytes();+ let revision = Revision::new(&rev_manager.object_id, base_rev_id, rev_id, delta_data, &user_id, md5);+ let _ = rev_manager.add_local_revision(&revision).await?;+ Ok(())}struct GridViewRevisionCloudService {@@ -253,19 +257,82 @@ impl RevisionObjectBuilder for GridViewRevisionPadBuilder {}}-impl GroupConfigurationDelegate for Arc<RwLock<GridViewRevisionPad>> {- fn get_group_configuration(&self, field_rev: Arc<FieldRevision>) -> AFFuture<GroupConfigurationRevision> {- let view_pad = self.clone();+struct GroupConfigurationReaderImpl(Arc<RwLock<GridViewRevisionPad>>);++impl GroupConfigurationReader for GroupConfigurationReaderImpl {+ fn get_group_configuration(&self, field_rev: Arc<FieldRevision>) -> AFFuture<Arc<GroupConfigurationRevision>> {+ let view_pad = self.0.clone();wrap_future(async move {- let grid_pad = view_pad.read().await;- let configurations = grid_pad.get_groups(&field_rev.id, &field_rev.ty);+ let view_pad = view_pad.read().await;+ let configurations = view_pad.get_groups(&field_rev.id, &field_rev.ty);match configurations {- None => default_group_configuration(&field_rev),- Some(mut configurations) => {- assert_eq!(configurations.len(), 1);- (&*configurations.pop().unwrap()).clone()+ None => {+ let default_configuration = default_group_configuration(&field_rev);+ Arc::new(default_configuration)}+ Some(configuration) => configuration,}})}}++struct GroupConfigurationWriterImpl {+ user_id: String,+ rev_manager: Arc<RevisionManager>,+ view_pad: Arc<RwLock<GridViewRevisionPad>>,+}++impl GroupConfigurationWriter for GroupConfigurationWriterImpl {+ fn save_group_configuration(+ &self,+ field_id: &str,+ field_type: FieldTypeRevision,+ configuration: Arc<GroupConfigurationRevision>,+ ) -> AFFuture<FlowyResult<()>> {+ let user_id = self.user_id.clone();+ let rev_manager = self.rev_manager.clone();+ let view_pad = self.view_pad.clone();+ let field_id = field_id.to_owned();++ wrap_future(async move {+ let configuration = (&*configuration).clone();+ match view_pad+ .write()+ .await+ .insert_group_configuration(&field_id, &field_type, configuration)?+ {+ None => Ok(()),+ Some(changeset) => apply_change(&user_id, rev_manager, changeset).await,+ }+ })+ }+}++pub fn make_grid_setting(view_pad: &GridViewRevisionPad, field_revs: &[Arc<FieldRevision>]) -> GridSettingPB {+ let current_layout_type: GridLayout = view_pad.layout.clone().into();+ let filters_by_field_id = view_pad+ .get_all_filters(field_revs)+ .map(|filters_by_field_id| {+ filters_by_field_id+ .into_iter()+ .map(|(k, v)| (k, v.into()))+ .collect::<HashMap<String, RepeatedGridConfigurationFilterPB>>()+ })+ .unwrap_or_default();+ let groups_by_field_id = view_pad+ .get_all_groups(field_revs)+ .map(|groups_by_field_id| {+ groups_by_field_id+ .into_iter()+ .map(|(k, v)| (k, v.into()))+ .collect::<HashMap<String, RepeatedGridGroupConfigurationPB>>()+ })+ .unwrap_or_default();++ GridSettingPB {+ layouts: GridLayoutPB::all(),+ current_layout_type,+ filter_configuration_by_field_id: filters_by_field_id,+ group_configuration_by_field_id: groups_by_field_id,+ }+}diff --git a/frontend/rust-lib/flowy-grid/src/services/grid_view_manager.rs b/frontend/rust-lib/flowy-grid/src/services/grid_view_manager.rsindex 178befc10a..42c4ff1c65 100644--- a/frontend/rust-lib/flowy-grid/src/services/grid_view_manager.rs+++ b/frontend/rust-lib/flowy-grid/src/services/grid_view_manager.rs@@ -1,4 +1,6 @@-use crate::entities::{CreateRowParams, GridFilterConfiguration, GridSettingPB, RepeatedGridGroupPB, RowPB};+use crate::entities::{+ CreateRowParams, GridFilterConfiguration, GridSettingChangesetParams, GridSettingPB, RepeatedGridGroupPB, RowPB,+};use crate::manager::GridUser;use crate::services::grid_editor_task::GridServiceTaskScheduler;use crate::services::grid_view_editor::GridViewRevisionEditor;@@ -8,7 +10,6 @@ use flowy_error::FlowyResult;use flowy_grid_data_model::revision::{FieldRevision, RowChangeset, RowRevision};use flowy_revision::disk::SQLiteGridViewRevisionPersistence;use flowy_revision::{RevisionCompactor, RevisionManager, RevisionPersistence, SQLiteRevisionSnapshotPersistence};-use flowy_sync::entities::grid::GridSettingChangesetParams;use flowy_sync::entities::revision::Revision;use flowy_sync::util::make_text_delta_from_revisions;use lib_infra::future::AFFuture;diff --git a/frontend/rust-lib/flowy-grid/src/services/group/action.rs b/frontend/rust-lib/flowy-grid/src/services/group/action.rsnew file mode 100644index 0000000000..a495fe0a1f--- /dev/null+++ b/frontend/rust-lib/flowy-grid/src/services/group/action.rs@@ -0,0 +1,23 @@+use crate::entities::GroupRowsChangesetPB;++use flowy_grid_data_model::revision::{FieldRevision, RowChangeset, RowRevision};++pub trait GroupAction: Send + Sync {+ type CellDataType;+ fn can_group(&self, content: &str, cell_data: &Self::CellDataType) -> bool;+ fn add_row_if_match(&mut self, row_rev: &RowRevision, cell_data: &Self::CellDataType) -> Vec<GroupRowsChangesetPB>;+ fn remove_row_if_match(+ &mut self,+ row_rev: &RowRevision,+ cell_data: &Self::CellDataType,+ ) -> Vec<GroupRowsChangesetPB>;++ fn move_row_if_match(+ &mut self,+ field_rev: &FieldRevision,+ row_rev: &RowRevision,+ row_changeset: &mut RowChangeset,+ cell_data: &Self::CellDataType,+ to_row_id: &str,+ ) -> Vec<GroupRowsChangesetPB>;+}diff --git a/frontend/rust-lib/flowy-grid/src/services/group/configuration.rs b/frontend/rust-lib/flowy-grid/src/services/group/configuration.rsnew file mode 100644index 0000000000..3d737c307f--- /dev/null+++ b/frontend/rust-lib/flowy-grid/src/services/group/configuration.rs@@ -0,0 +1,76 @@+use flowy_error::FlowyResult;+use flowy_grid_data_model::revision::{+ FieldRevision, FieldTypeRevision, GroupConfigurationContentSerde, GroupConfigurationRevision, GroupRecordRevision,+};+use lib_infra::future::AFFuture;+use std::sync::Arc;++pub trait GroupConfigurationReader: Send + Sync + 'static {+ fn get_group_configuration(&self, field_rev: Arc<FieldRevision>) -> AFFuture<Arc<GroupConfigurationRevision>>;+}++pub trait GroupConfigurationWriter: Send + Sync + 'static {+ fn save_group_configuration(+ &self,+ field_id: &str,+ field_type: FieldTypeRevision,+ configuration: Arc<GroupConfigurationRevision>,+ ) -> AFFuture<FlowyResult<()>>;+}++pub trait GroupConfigurationAction: Send + Sync {+ fn group_records(&self) -> &[GroupRecordRevision];+ fn save_groups(&self) -> FlowyResult<()>;+ fn hide_group(&self, group_id: &str) -> FlowyResult<()>;+ fn show_group(&self, group_id: &str) -> FlowyResult<()>;+}++pub struct GenericGroupConfiguration<C> {+ field_rev: Arc<FieldRevision>,+ reader: Arc<dyn GroupConfigurationReader>,+ writer: Arc<dyn GroupConfigurationWriter>,+ configuration: C,+}++impl<C> GenericGroupConfiguration<C>+where+ C: GroupConfigurationContentSerde,+{+ pub async fn new(+ field_rev: Arc<FieldRevision>,+ reader: Arc<dyn GroupConfigurationReader>,+ writer: Arc<dyn GroupConfigurationWriter>,+ ) -> FlowyResult<Self> {+ let configuration = reader.get_group_configuration(field_rev.clone()).await;+ let configuration = C::from_configuration(&configuration.content)?;+ Ok(Self {+ field_rev,+ reader,+ writer,+ configuration,+ })+ }+}++impl<T> GroupConfigurationReader for Arc<T>+where+ T: GroupConfigurationReader,+{+ fn get_group_configuration(&self, field_rev: Arc<FieldRevision>) -> AFFuture<Arc<GroupConfigurationRevision>> {+ (**self).get_group_configuration(field_rev)+ }+}++impl<T> GroupConfigurationWriter for Arc<T>+where+ T: GroupConfigurationWriter,+{+ fn save_group_configuration(+ &self,+ field_id: &str,+ field_type: FieldTypeRevision,+ configuration: Arc<GroupConfigurationRevision>,+ ) -> AFFuture<FlowyResult<()>> {+ (**self).save_group_configuration(field_id, field_type, configuration)+ }+}diff --git a/frontend/rust-lib/flowy-grid/src/services/group/controllers/checkbox_controller.rs b/frontend/rust-lib/flowy-grid/src/services/group/controller_impls/checkbox_controller.rssimilarity index 59%rename from frontend/rust-lib/flowy-grid/src/services/group/controllers/checkbox_controller.rsrename to frontend/rust-lib/flowy-grid/src/services/group/controller_impls/checkbox_controller.rsindex c1284dd659..fca49513c8 100644--- a/frontend/rust-lib/flowy-grid/src/services/group/controllers/checkbox_controller.rs+++ b/frontend/rust-lib/flowy-grid/src/services/group/controller_impls/checkbox_controller.rs@@ -1,20 +1,42 @@-use crate::entities::{CheckboxGroupConfigurationPB, GroupRowsChangesetPB};--use flowy_grid_data_model::revision::{FieldRevision, RowChangeset, RowRevision};-+use crate::entities::GroupRowsChangesetPB;use crate::services::field::{CheckboxCellData, CheckboxCellDataParser, CheckboxTypeOptionPB, CHECK, UNCHECK};-use crate::services::group::{GenericGroupController, Group, GroupController, GroupGenerator, Groupable};+use crate::services::group::action::GroupAction;+use crate::services::group::configuration::{GenericGroupConfiguration, GroupConfigurationAction};+use crate::services::group::entities::Group;+use crate::services::group::group_controller::{GenericGroupController, GroupController, GroupGenerator};+use flowy_error::FlowyResult;+use flowy_grid_data_model::revision::{+ CheckboxGroupConfigurationRevision, FieldRevision, GroupRecordRevision, RowChangeset, RowRevision,+};pub type CheckboxGroupController = GenericGroupController<- CheckboxGroupConfigurationPB,+ CheckboxGroupConfigurationRevision,CheckboxTypeOptionPB,CheckboxGroupGenerator,CheckboxCellDataParser,>;-impl Groupable for CheckboxGroupController {- type CellDataType = CheckboxCellData;+pub type CheckboxGroupConfiguration = GenericGroupConfiguration<CheckboxGroupConfigurationRevision>;+impl GroupConfigurationAction for CheckboxGroupConfiguration {+ fn group_records(&self) -> &[GroupRecordRevision] {+ todo!()+ }++ fn save_groups(&self) -> FlowyResult<()> {+ todo!()+ }+ fn hide_group(&self, group_id: &str) -> FlowyResult<()> {+ todo!()+ }++ fn show_group(&self, group_id: &str) -> FlowyResult<()> {+ todo!()+ }+}++impl GroupAction for CheckboxGroupController {+ type CellDataType = CheckboxCellData;fn can_group(&self, _content: &str, _cell_data: &Self::CellDataType) -> bool {false}@@ -55,13 +77,13 @@ impl GroupController for CheckboxGroupController {pub struct CheckboxGroupGenerator();impl GroupGenerator for CheckboxGroupGenerator {- type ConfigurationType = CheckboxGroupConfigurationPB;+ type ConfigurationType = CheckboxGroupConfiguration;type TypeOptionType = CheckboxTypeOptionPB;fn generate_groups(field_id: &str,- _configuration: &Option<Self::ConfigurationType>,- _type_option: &Option<Self::TypeOptionType>,+ configuration: &Self::ConfigurationType,+ type_option: &Option<Self::TypeOptionType>,) -> Vec<Group> {let check_group = Group::new("true".to_string(),diff --git a/frontend/rust-lib/flowy-grid/src/services/group/controllers/mod.rs b/frontend/rust-lib/flowy-grid/src/services/group/controller_impls/mod.rssimilarity index 71%rename from frontend/rust-lib/flowy-grid/src/services/group/controllers/mod.rsrename to frontend/rust-lib/flowy-grid/src/services/group/controller_impls/mod.rsindex 29ce5d091e..974f311a48 100644--- a/frontend/rust-lib/flowy-grid/src/services/group/controllers/mod.rs+++ b/frontend/rust-lib/flowy-grid/src/services/group/controller_impls/mod.rs@@ -1,7 +1,5 @@mod checkbox_controller;-mod group_controller;mod select_option_controller;pub use checkbox_controller::*;-pub use group_controller::*;pub use select_option_controller::*;diff --git a/frontend/rust-lib/flowy-grid/src/services/group/controller_impls/select_option_controller/mod.rs b/frontend/rust-lib/flowy-grid/src/services/group/controller_impls/select_option_controller/mod.rsnew file mode 100644index 0000000000..a2f393d093--- /dev/null+++ b/frontend/rust-lib/flowy-grid/src/services/group/controller_impls/select_option_controller/mod.rs@@ -0,0 +1,6 @@+mod multi_select_controller;+mod single_select_controller;+mod util;++pub use multi_select_controller::*;+pub use single_select_controller::*;diff --git a/frontend/rust-lib/flowy-grid/src/services/group/controller_impls/select_option_controller/multi_select_controller.rs b/frontend/rust-lib/flowy-grid/src/services/group/controller_impls/select_option_controller/multi_select_controller.rsnew file mode 100644index 0000000000..33cd0613cd--- /dev/null+++ b/frontend/rust-lib/flowy-grid/src/services/group/controller_impls/select_option_controller/multi_select_controller.rs@@ -0,0 +1,110 @@+use crate::entities::GroupRowsChangesetPB;+use crate::services::cell::insert_select_option_cell;+use crate::services::field::{MultiSelectTypeOptionPB, SelectOptionCellDataPB, SelectOptionCellDataParser};+use crate::services::group::action::GroupAction;++use crate::services::group::controller_impls::select_option_controller::util::*;+use crate::services::group::entities::Group;+use crate::services::group::group_controller::{GenericGroupController, GroupController, GroupGenerator};+use flowy_grid_data_model::revision::{+ FieldRevision, RowChangeset, RowRevision, SelectOptionGroupConfigurationRevision,+};++// MultiSelect+pub type MultiSelectGroupController = GenericGroupController<+ SelectOptionGroupConfigurationRevision,+ MultiSelectTypeOptionPB,+ MultiSelectGroupGenerator,+ SelectOptionCellDataParser,+>;++impl GroupAction for MultiSelectGroupController {+ type CellDataType = SelectOptionCellDataPB;++ fn can_group(&self, content: &str, cell_data: &SelectOptionCellDataPB) -> bool {+ cell_data.select_options.iter().any(|option| option.id == content)+ }++ fn add_row_if_match(&mut self, row_rev: &RowRevision, cell_data: &Self::CellDataType) -> Vec<GroupRowsChangesetPB> {+ let mut changesets = vec![];+ self.groups_map.iter_mut().for_each(|(_, group): (_, &mut Group)| {+ add_row(group, &mut changesets, cell_data, row_rev);+ });+ changesets+ }++ fn remove_row_if_match(+ &mut self,+ row_rev: &RowRevision,+ cell_data: &Self::CellDataType,+ ) -> Vec<GroupRowsChangesetPB> {+ let mut changesets = vec![];+ self.groups_map.iter_mut().for_each(|(_, group): (_, &mut Group)| {+ remove_row(group, &mut changesets, cell_data, row_rev);+ });+ changesets+ }++ fn move_row_if_match(+ &mut self,+ field_rev: &FieldRevision,+ row_rev: &RowRevision,+ row_changeset: &mut RowChangeset,+ cell_data: &Self::CellDataType,+ to_row_id: &str,+ ) -> Vec<GroupRowsChangesetPB> {+ let mut group_changeset = vec![];+ self.groups_map.iter_mut().for_each(|(_, group): (_, &mut Group)| {+ move_row(+ group,+ &mut group_changeset,+ field_rev,+ row_rev,+ row_changeset,+ cell_data,+ to_row_id,+ );+ });+ group_changeset+ }+}++impl GroupController for MultiSelectGroupController {+ fn will_create_row(&mut self, row_rev: &mut RowRevision, field_rev: &FieldRevision, group_id: &str) {+ let group: Option<&Group> = self.groups_map.get(group_id);+ match group {+ None => tracing::warn!("Can not find the group: {}", group_id),+ Some(group) => {+ let cell_rev = insert_select_option_cell(group.id.clone(), field_rev);+ row_rev.cells.insert(field_rev.id.clone(), cell_rev);+ }+ }+ }+}++pub struct MultiSelectGroupGenerator();+impl GroupGenerator for MultiSelectGroupGenerator {+ type ConfigurationType = SelectOptionGroupConfiguration;+ type TypeOptionType = MultiSelectTypeOptionPB;+ fn generate_groups(+ field_id: &str,+ configuration: &Self::ConfigurationType,+ type_option: &Option<Self::TypeOptionType>,+ ) -> Vec<Group> {+ match type_option {+ None => vec![],+ Some(type_option) => type_option+ .options+ .iter()+ .map(|option| {+ Group::new(+ option.id.clone(),+ field_id.to_owned(),+ option.name.clone(),+ option.id.clone(),+ )+ })+ .collect(),+ }+ }+}diff --git a/frontend/rust-lib/flowy-grid/src/services/group/controller_impls/select_option_controller/single_select_controller.rs b/frontend/rust-lib/flowy-grid/src/services/group/controller_impls/select_option_controller/single_select_controller.rsnew file mode 100644index 0000000000..4c8360f427--- /dev/null+++ b/frontend/rust-lib/flowy-grid/src/services/group/controller_impls/select_option_controller/single_select_controller.rs@@ -0,0 +1,111 @@+use crate::entities::{GroupRowsChangesetPB, RowPB};+use crate::services::cell::insert_select_option_cell;+use crate::services::field::{SelectOptionCellDataPB, SelectOptionCellDataParser, SingleSelectTypeOptionPB};+use crate::services::group::action::GroupAction;++use crate::services::group::controller_impls::select_option_controller::util::*;+use crate::services::group::entities::Group;+use crate::services::group::group_controller::{GenericGroupController, GroupController, GroupGenerator};++use flowy_grid_data_model::revision::{+ FieldRevision, RowChangeset, RowRevision, SelectOptionGroupConfigurationRevision,+};++// SingleSelect+pub type SingleSelectGroupController = GenericGroupController<+ SelectOptionGroupConfigurationRevision,+ SingleSelectTypeOptionPB,+ SingleSelectGroupGenerator,+ SelectOptionCellDataParser,+>;++impl GroupAction for SingleSelectGroupController {+ type CellDataType = SelectOptionCellDataPB;+ fn can_group(&self, content: &str, cell_data: &SelectOptionCellDataPB) -> bool {+ cell_data.select_options.iter().any(|option| option.id == content)+ }++ fn add_row_if_match(&mut self, row_rev: &RowRevision, cell_data: &Self::CellDataType) -> Vec<GroupRowsChangesetPB> {+ let mut changesets = vec![];+ self.groups_map.iter_mut().for_each(|(_, group): (_, &mut Group)| {+ add_row(group, &mut changesets, cell_data, row_rev);+ });+ changesets+ }++ fn remove_row_if_match(+ &mut self,+ row_rev: &RowRevision,+ cell_data: &Self::CellDataType,+ ) -> Vec<GroupRowsChangesetPB> {+ let mut changesets = vec![];+ self.groups_map.iter_mut().for_each(|(_, group): (_, &mut Group)| {+ remove_row(group, &mut changesets, cell_data, row_rev);+ });+ changesets+ }++ fn move_row_if_match(+ &mut self,+ field_rev: &FieldRevision,+ row_rev: &RowRevision,+ row_changeset: &mut RowChangeset,+ cell_data: &Self::CellDataType,+ to_row_id: &str,+ ) -> Vec<GroupRowsChangesetPB> {+ let mut group_changeset = vec![];+ self.groups_map.iter_mut().for_each(|(_, group): (_, &mut Group)| {+ move_row(+ group,+ &mut group_changeset,+ field_rev,+ row_rev,+ row_changeset,+ cell_data,+ to_row_id,+ );+ });+ group_changeset+ }+}++impl GroupController for SingleSelectGroupController {+ fn will_create_row(&mut self, row_rev: &mut RowRevision, field_rev: &FieldRevision, group_id: &str) {+ let group: Option<&mut Group> = self.groups_map.get_mut(group_id);+ match group {+ None => {}+ Some(group) => {+ let cell_rev = insert_select_option_cell(group.id.clone(), field_rev);+ row_rev.cells.insert(field_rev.id.clone(), cell_rev);+ group.add_row(RowPB::from(row_rev));+ }+ }+ }+}++pub struct SingleSelectGroupGenerator();+impl GroupGenerator for SingleSelectGroupGenerator {+ type ConfigurationType = SelectOptionGroupConfiguration;+ type TypeOptionType = SingleSelectTypeOptionPB;+ fn generate_groups(+ field_id: &str,+ configuration: &Self::ConfigurationType,+ type_option: &Option<Self::TypeOptionType>,+ ) -> Vec<Group> {+ match type_option {+ None => vec![],+ Some(type_option) => type_option+ .options+ .iter()+ .map(|option| {+ Group::new(+ option.id.clone(),+ field_id.to_owned(),+ option.name.clone(),+ option.id.clone(),+ )+ })+ .collect(),+ }+ }+}diff --git a/frontend/rust-lib/flowy-grid/src/services/group/controller_impls/select_option_controller/util.rs b/frontend/rust-lib/flowy-grid/src/services/group/controller_impls/select_option_controller/util.rsnew file mode 100644index 0000000000..d95a39f60c--- /dev/null+++ b/frontend/rust-lib/flowy-grid/src/services/group/controller_impls/select_option_controller/util.rs@@ -0,0 +1,108 @@+use crate::entities::{GroupRowsChangesetPB, InsertedRowPB, RowPB};+use crate::services::cell::insert_select_option_cell;+use crate::services::field::SelectOptionCellDataPB;+use crate::services::group::configuration::{GenericGroupConfiguration, GroupConfigurationAction};+use crate::services::group::Group;+use flowy_error::FlowyResult;+use flowy_grid_data_model::revision::{+ FieldRevision, GroupRecordRevision, RowChangeset, RowRevision, SelectOptionGroupConfigurationRevision,+};++pub type SelectOptionGroupConfiguration = GenericGroupConfiguration<SelectOptionGroupConfigurationRevision>;+impl GroupConfigurationAction for SelectOptionGroupConfiguration {+ fn group_records(&self) -> &[GroupRecordRevision] {+ todo!()+ }++ fn save_groups(&self) -> FlowyResult<()> {+ todo!()+ }++ fn hide_group(&self, group_id: &str) -> FlowyResult<()> {+ todo!()+ }++ fn show_group(&self, group_id: &str) -> FlowyResult<()> {+ todo!()+ }+}++pub fn add_row(+ group: &mut Group,+ changesets: &mut Vec<GroupRowsChangesetPB>,+ cell_data: &SelectOptionCellDataPB,+ row_rev: &RowRevision,+) {+ cell_data.select_options.iter().for_each(|option| {+ if option.id == group.id {+ if !group.contains_row(&row_rev.id) {+ let row_pb = RowPB::from(row_rev);+ changesets.push(GroupRowsChangesetPB::insert(+ group.id.clone(),+ vec![InsertedRowPB::new(row_pb.clone())],+ ));+ group.add_row(row_pb);+ }+ } else if group.contains_row(&row_rev.id) {+ changesets.push(GroupRowsChangesetPB::delete(group.id.clone(), vec![row_rev.id.clone()]));+ group.remove_row(&row_rev.id);+ }+ });+}++pub fn remove_row(+ group: &mut Group,+ changesets: &mut Vec<GroupRowsChangesetPB>,+ cell_data: &SelectOptionCellDataPB,+ row_rev: &RowRevision,+) {+ cell_data.select_options.iter().for_each(|option| {+ if option.id == group.id && group.contains_row(&row_rev.id) {+ changesets.push(GroupRowsChangesetPB::delete(group.id.clone(), vec![row_rev.id.clone()]));+ group.remove_row(&row_rev.id);+ }+ });+}++pub fn move_row(+ group: &mut Group,+ group_changeset: &mut Vec<GroupRowsChangesetPB>,+ field_rev: &FieldRevision,+ row_rev: &RowRevision,+ row_changeset: &mut RowChangeset,+ cell_data: &SelectOptionCellDataPB,+ to_row_id: &str,+) {+ cell_data.select_options.iter().for_each(|option| {+ // Remove the row in which group contains the row+ let is_group_contains = group.contains_row(&row_rev.id);+ let to_index = group.index_of_row(to_row_id);++ if option.id == group.id && is_group_contains {+ group_changeset.push(GroupRowsChangesetPB::delete(group.id.clone(), vec![row_rev.id.clone()]));+ group.remove_row(&row_rev.id);+ }++ // Find the inserted group+ if let Some(to_index) = to_index {+ let row_pb = RowPB::from(row_rev);+ let inserted_row = InsertedRowPB {+ row: row_pb.clone(),+ index: Some(to_index as i32),+ };+ group_changeset.push(GroupRowsChangesetPB::insert(group.id.clone(), vec![inserted_row]));+ if group.number_of_row() == to_index {+ group.add_row(row_pb);+ } else {+ group.insert_row(to_index, row_pb);+ }+ }++ // If the inserted row comes from other group, it needs to update the corresponding cell content.+ if to_index.is_some() && option.id != group.id {+ // Update the corresponding row's cell content.+ let cell_rev = insert_select_option_cell(group.id.clone(), field_rev);+ row_changeset.cell_by_field_id.insert(field_rev.id.clone(), cell_rev);+ }+ });+}diff --git a/frontend/rust-lib/flowy-grid/src/services/group/controllers/select_option_controller.rs b/frontend/rust-lib/flowy-grid/src/services/group/controllers/select_option_controller.rsdeleted file mode 100644index 29dc95891f..0000000000--- a/frontend/rust-lib/flowy-grid/src/services/group/controllers/select_option_controller.rs+++ /dev/null@@ -1,286 +0,0 @@-use crate::entities::{GroupRowsChangesetPB, InsertedRowPB, RowPB, SelectOptionGroupConfigurationPB};-use crate::services::cell::insert_select_option_cell;-use crate::services::field::{- MultiSelectTypeOptionPB, SelectOptionCellDataPB, SelectOptionCellDataParser, SingleSelectTypeOptionPB,-};-use crate::services::group::{GenericGroupController, Group, GroupController, GroupGenerator, Groupable};-use flowy_grid_data_model::revision::{FieldRevision, RowChangeset, RowRevision};--// SingleSelect-pub type SingleSelectGroupController = GenericGroupController<- SelectOptionGroupConfigurationPB,- SingleSelectTypeOptionPB,- SingleSelectGroupGenerator,- SelectOptionCellDataParser,->;--impl Groupable for SingleSelectGroupController {- type CellDataType = SelectOptionCellDataPB;- fn can_group(&self, content: &str, cell_data: &SelectOptionCellDataPB) -> bool {- cell_data.select_options.iter().any(|option| option.id == content)- }-- fn add_row_if_match(&mut self, row_rev: &RowRevision, cell_data: &Self::CellDataType) -> Vec<GroupRowsChangesetPB> {- let mut changesets = vec![];- self.groups_map.iter_mut().for_each(|(_, group): (_, &mut Group)| {- add_row(group, &mut changesets, cell_data, row_rev);- });- changesets- }-- fn remove_row_if_match(- &mut self,- row_rev: &RowRevision,- cell_data: &Self::CellDataType,- ) -> Vec<GroupRowsChangesetPB> {- let mut changesets = vec![];- self.groups_map.iter_mut().for_each(|(_, group): (_, &mut Group)| {- remove_row(group, &mut changesets, cell_data, row_rev);- });- changesets- }-- fn move_row_if_match(- &mut self,- field_rev: &FieldRevision,- row_rev: &RowRevision,- row_changeset: &mut RowChangeset,- cell_data: &Self::CellDataType,- to_row_id: &str,- ) -> Vec<GroupRowsChangesetPB> {- let mut group_changeset = vec![];- self.groups_map.iter_mut().for_each(|(_, group): (_, &mut Group)| {- move_row(- group,- &mut group_changeset,- field_rev,- row_rev,- row_changeset,- cell_data,- to_row_id,- );- });- group_changeset- }-}--impl GroupController for SingleSelectGroupController {- fn will_create_row(&mut self, row_rev: &mut RowRevision, field_rev: &FieldRevision, group_id: &str) {- let group: Option<&mut Group> = self.groups_map.get_mut(group_id);- match group {- None => {}- Some(group) => {- let cell_rev = insert_select_option_cell(group.id.clone(), field_rev);- row_rev.cells.insert(field_rev.id.clone(), cell_rev);- group.add_row(RowPB::from(row_rev));- }- }- }-}--pub struct SingleSelectGroupGenerator();-impl GroupGenerator for SingleSelectGroupGenerator {- type ConfigurationType = SelectOptionGroupConfigurationPB;- type TypeOptionType = SingleSelectTypeOptionPB;- fn generate_groups(- field_id: &str,- _configuration: &Option<Self::ConfigurationType>,- type_option: &Option<Self::TypeOptionType>,- ) -> Vec<Group> {- match type_option {- None => vec![],- Some(type_option) => type_option- .options- .iter()- .map(|option| {- Group::new(- option.id.clone(),- field_id.to_owned(),- option.name.clone(),- option.id.clone(),- )- })- .collect(),- }- }-}--// MultiSelect-pub type MultiSelectGroupController = GenericGroupController<- SelectOptionGroupConfigurationPB,- MultiSelectTypeOptionPB,- MultiSelectGroupGenerator,- SelectOptionCellDataParser,->;--impl Groupable for MultiSelectGroupController {- type CellDataType = SelectOptionCellDataPB;-- fn can_group(&self, content: &str, cell_data: &SelectOptionCellDataPB) -> bool {- cell_data.select_options.iter().any(|option| option.id == content)- }-- fn add_row_if_match(&mut self, row_rev: &RowRevision, cell_data: &Self::CellDataType) -> Vec<GroupRowsChangesetPB> {- let mut changesets = vec![];- self.groups_map.iter_mut().for_each(|(_, group): (_, &mut Group)| {- add_row(group, &mut changesets, cell_data, row_rev);- });- changesets- }-- fn remove_row_if_match(- &mut self,- row_rev: &RowRevision,- cell_data: &Self::CellDataType,- ) -> Vec<GroupRowsChangesetPB> {- let mut changesets = vec![];- self.groups_map.iter_mut().for_each(|(_, group): (_, &mut Group)| {- remove_row(group, &mut changesets, cell_data, row_rev);- });- changesets- }-- fn move_row_if_match(- &mut self,- field_rev: &FieldRevision,- row_rev: &RowRevision,- row_changeset: &mut RowChangeset,- cell_data: &Self::CellDataType,- to_row_id: &str,- ) -> Vec<GroupRowsChangesetPB> {- let mut group_changeset = vec![];- self.groups_map.iter_mut().for_each(|(_, group): (_, &mut Group)| {- move_row(- group,- &mut group_changeset,- field_rev,- row_rev,- row_changeset,- cell_data,- to_row_id,- );- });- group_changeset- }-}--impl GroupController for MultiSelectGroupController {- fn will_create_row(&mut self, row_rev: &mut RowRevision, field_rev: &FieldRevision, group_id: &str) {- let group: Option<&Group> = self.groups_map.get(group_id);- match group {- None => tracing::warn!("Can not find the group: {}", group_id),- Some(group) => {- let cell_rev = insert_select_option_cell(group.id.clone(), field_rev);- row_rev.cells.insert(field_rev.id.clone(), cell_rev);- }- }- }-}--pub struct MultiSelectGroupGenerator();-impl GroupGenerator for MultiSelectGroupGenerator {- type ConfigurationType = SelectOptionGroupConfigurationPB;- type TypeOptionType = MultiSelectTypeOptionPB;-- fn generate_groups(- field_id: &str,- _configuration: &Option<Self::ConfigurationType>,- type_option: &Option<Self::TypeOptionType>,- ) -> Vec<Group> {- match type_option {- None => vec![],- Some(type_option) => type_option- .options- .iter()- .map(|option| {- Group::new(- option.id.clone(),- field_id.to_owned(),- option.name.clone(),- option.id.clone(),- )- })- .collect(),- }- }-}--fn add_row(- group: &mut Group,- changesets: &mut Vec<GroupRowsChangesetPB>,- cell_data: &SelectOptionCellDataPB,- row_rev: &RowRevision,-) {- cell_data.select_options.iter().for_each(|option| {- if option.id == group.id {- if !group.contains_row(&row_rev.id) {- let row_pb = RowPB::from(row_rev);- changesets.push(GroupRowsChangesetPB::insert(- group.id.clone(),- vec![InsertedRowPB::new(row_pb.clone())],- ));- group.add_row(row_pb);- }- } else if group.contains_row(&row_rev.id) {- changesets.push(GroupRowsChangesetPB::delete(group.id.clone(), vec![row_rev.id.clone()]));- group.remove_row(&row_rev.id);- }- });-}--fn remove_row(- group: &mut Group,- changesets: &mut Vec<GroupRowsChangesetPB>,- cell_data: &SelectOptionCellDataPB,- row_rev: &RowRevision,-) {- cell_data.select_options.iter().for_each(|option| {- if option.id == group.id && group.contains_row(&row_rev.id) {- changesets.push(GroupRowsChangesetPB::delete(group.id.clone(), vec![row_rev.id.clone()]));- group.remove_row(&row_rev.id);- }- });-}--fn move_row(- group: &mut Group,- group_changeset: &mut Vec<GroupRowsChangesetPB>,- field_rev: &FieldRevision,- row_rev: &RowRevision,- row_changeset: &mut RowChangeset,- cell_data: &SelectOptionCellDataPB,- to_row_id: &str,-) {- cell_data.select_options.iter().for_each(|option| {- // Remove the row in which group contains the row- let is_group_contains = group.contains_row(&row_rev.id);- let to_index = group.index_of_row(to_row_id);-- if option.id == group.id && is_group_contains {- group_changeset.push(GroupRowsChangesetPB::delete(group.id.clone(), vec![row_rev.id.clone()]));- group.remove_row(&row_rev.id);- }-- // Find the inserted group- if let Some(to_index) = to_index {- let row_pb = RowPB::from(row_rev);- let inserted_row = InsertedRowPB {- row: row_pb.clone(),- index: Some(to_index as i32),- };- group_changeset.push(GroupRowsChangesetPB::insert(group.id.clone(), vec![inserted_row]));- if group.number_of_row() == to_index {- group.add_row(row_pb);- } else {- group.insert_row(to_index, row_pb);- }- }-- // If the inserted row comes from other group, it needs to update the corresponding cell content.- if to_index.is_some() && option.id != group.id {- // Update the corresponding row's cell content.- let cell_rev = insert_select_option_cell(group.id.clone(), field_rev);- row_changeset.cell_by_field_id.insert(field_rev.id.clone(), cell_rev);- }- });-}diff --git a/frontend/rust-lib/flowy-grid/src/services/group/entities.rs b/frontend/rust-lib/flowy-grid/src/services/group/entities.rsnew file mode 100644index 0000000000..dd4171afb0--- /dev/null+++ b/frontend/rust-lib/flowy-grid/src/services/group/entities.rs@@ -0,0 +1,73 @@+use crate::entities::{GroupPB, RowPB};++#[derive(Clone)]+pub struct Group {+ pub id: String,+ pub field_id: String,+ pub desc: String,+ rows: Vec<RowPB>,++ /// [content] is used to determine which group the cell belongs to.+ pub content: String,+}++impl std::convert::From<Group> for GroupPB {+ fn from(group: Group) -> Self {+ Self {+ field_id: group.field_id,+ group_id: group.id,+ desc: group.desc,+ rows: group.rows,+ }+ }+}++impl Group {+ pub fn new(id: String, field_id: String, desc: String, content: String) -> Self {+ Self {+ id,+ field_id,+ desc,+ rows: vec![],+ content,+ }+ }++ pub fn contains_row(&self, row_id: &str) -> bool {+ self.rows.iter().any(|row| row.id == row_id)+ }++ pub fn remove_row(&mut self, row_id: &str) {+ match self.rows.iter().position(|row| row.id == row_id) {+ None => {}+ Some(pos) => {+ self.rows.remove(pos);+ }+ }+ }++ pub fn add_row(&mut self, row_pb: RowPB) {+ match self.rows.iter().find(|row| row.id == row_pb.id) {+ None => {+ self.rows.push(row_pb);+ }+ Some(_) => {}+ }+ }++ pub fn insert_row(&mut self, index: usize, row_pb: RowPB) {+ if index < self.rows.len() {+ self.rows.insert(index, row_pb);+ } else {+ tracing::error!("Insert row index:{} beyond the bounds:{},", index, self.rows.len());+ }+ }++ pub fn index_of_row(&self, row_id: &str) -> Option<usize> {+ self.rows.iter().position(|row| row.id == row_id)+ }++ pub fn number_of_row(&self) -> usize {+ self.rows.len()+ }+}diff --git a/frontend/rust-lib/flowy-grid/src/services/group/controllers/group_controller.rs b/frontend/rust-lib/flowy-grid/src/services/group/group_controller.rssimilarity index 57%rename from frontend/rust-lib/flowy-grid/src/services/group/controllers/group_controller.rsrename to frontend/rust-lib/flowy-grid/src/services/group/group_controller.rsindex 07dcff3f77..fb2c0aaa6e 100644--- a/frontend/rust-lib/flowy-grid/src/services/group/controllers/group_controller.rs+++ b/frontend/rust-lib/flowy-grid/src/services/group/group_controller.rs@@ -1,54 +1,43 @@-use crate::entities::{GroupPB, GroupRowsChangesetPB, RowPB};+use crate::entities::{GroupRowsChangesetPB, RowPB};use crate::services::cell::{decode_any_cell_data, CellBytesParser};-use bytes::Bytes;+use crate::services::group::action::GroupAction;+use crate::services::group::configuration::{GenericGroupConfiguration, GroupConfigurationReader};+use crate::services::group::entities::Group;use flowy_error::FlowyResult;use flowy_grid_data_model::revision::{- FieldRevision, GroupConfigurationRevision, RowChangeset, RowRevision, TypeOptionDataDeserializer,+ FieldRevision, GroupConfigurationContentSerde, GroupConfigurationRevision, RowChangeset, RowRevision,+ TypeOptionDataDeserializer,};use indexmap::IndexMap;+use lib_infra::future::AFFuture;use std::marker::PhantomData;use std::sync::Arc;+const DEFAULT_GROUP_ID: &str = "default_group";++// Each kind of group must implement this trait to provide custom group+// operations. For example, insert cell data to the row_rev when creating+// a new row.+pub trait GroupController: GroupControllerSharedAction + Send + Sync {+ fn will_create_row(&mut self, row_rev: &mut RowRevision, field_rev: &FieldRevision, group_id: &str);+}+pub trait GroupGenerator {type ConfigurationType;type TypeOptionType;fn generate_groups(field_id: &str,- configuration: &Option<Self::ConfigurationType>,+ configuration: &Self::ConfigurationType,type_option: &Option<Self::TypeOptionType>,) -> Vec<Group>;}-pub trait Groupable: Send + Sync {- type CellDataType;- fn can_group(&self, content: &str, cell_data: &Self::CellDataType) -> bool;- fn add_row_if_match(&mut self, row_rev: &RowRevision, cell_data: &Self::CellDataType) -> Vec<GroupRowsChangesetPB>;- fn remove_row_if_match(- &mut self,- row_rev: &RowRevision,- cell_data: &Self::CellDataType,- ) -> Vec<GroupRowsChangesetPB>;-- fn move_row_if_match(- &mut self,- field_rev: &FieldRevision,- row_rev: &RowRevision,- row_changeset: &mut RowChangeset,- cell_data: &Self::CellDataType,- to_row_id: &str,- ) -> Vec<GroupRowsChangesetPB>;-}--pub trait GroupController: GroupControllerSharedAction + Send + Sync {- fn will_create_row(&mut self, row_rev: &mut RowRevision, field_rev: &FieldRevision, group_id: &str);-}-+// Defines the shared actions each group controller can perform.pub trait GroupControllerSharedAction: Send + Sync {// The field that is used for grouping the rowsfn field_id(&self) -> &str;- fn groups(&self) -> Vec<Group>;- fn group_rows(&mut self, row_revs: &[Arc<RowRevision>], field_rev: &FieldRevision) -> FlowyResult<()>;+ fn fill_groups(&mut self, row_revs: &[Arc<RowRevision>], field_rev: &FieldRevision) -> FlowyResult<Vec<Group>>;fn did_update_row(&mut self,row_rev: &RowRevision,@@ -70,105 +59,35 @@ pub trait GroupControllerSharedAction: Send + Sync {) -> FlowyResult<Vec<GroupRowsChangesetPB>>;}-const DEFAULT_GROUP_ID: &str = "default_group";--/// C: represents the group configuration structure+/// C: represents the group configuration that impl [GroupConfigurationSerde]/// T: the type option data deserializer that impl [TypeOptionDataDeserializer]/// G: the group generator, [GroupGenerator]/// P: the parser that impl [CellBytesParser] for the CellBytespub struct GenericGroupController<C, T, G, P> {pub field_id: String,pub groups_map: IndexMap<String, Group>,++ /// default_group is used to store the rows that don't belong to any groups.default_group: Group,pub type_option: Option<T>,- pub configuration: Option<C>,+ pub configuration: GenericGroupConfiguration<C>,group_action_phantom: PhantomData<G>,cell_parser_phantom: PhantomData<P>,}-#[derive(Clone)]-pub struct Group {- pub id: String,- pub field_id: String,- pub desc: String,- rows: Vec<RowPB>,- pub content: String,-}--impl std::convert::From<Group> for GroupPB {- fn from(group: Group) -> Self {- Self {- field_id: group.field_id,- group_id: group.id,- desc: group.desc,- rows: group.rows,- }- }-}--impl Group {- pub fn new(id: String, field_id: String, desc: String, content: String) -> Self {- Self {- id,- field_id,- desc,- rows: vec![],- content,- }- }-- pub fn contains_row(&self, row_id: &str) -> bool {- self.rows.iter().any(|row| row.id == row_id)- }-- pub fn remove_row(&mut self, row_id: &str) {- match self.rows.iter().position(|row| row.id == row_id) {- None => {}- Some(pos) => {- self.rows.remove(pos);- }- }- }-- pub fn add_row(&mut self, row_pb: RowPB) {- match self.rows.iter().find(|row| row.id == row_pb.id) {- None => {- self.rows.push(row_pb);- }- Some(_) => {}- }- }-- pub fn insert_row(&mut self, index: usize, row_pb: RowPB) {- if index < self.rows.len() {- self.rows.insert(index, row_pb);- } else {- tracing::error!("Insert row index:{} beyond the bounds:{},", index, self.rows.len());- }- }-- pub fn index_of_row(&self, row_id: &str) -> Option<usize> {- self.rows.iter().position(|row| row.id == row_id)- }-- pub fn number_of_row(&self) -> usize {- self.rows.len()- }-}-impl<C, T, G, P> GenericGroupController<C, T, G, P>where- C: TryFrom<Bytes, Error = protobuf::ProtobufError>,+ C: GroupConfigurationContentSerde,T: TypeOptionDataDeserializer,- G: GroupGenerator<ConfigurationType = C, TypeOptionType = T>,+ G: GroupGenerator<ConfigurationType = GenericGroupConfiguration<C>, TypeOptionType = T>,{- pub fn new(field_rev: &Arc<FieldRevision>, configuration: GroupConfigurationRevision) -> FlowyResult<Self> {- // let configuration = match configuration.content {- // None => None,- // Some(content) => Some(C::try_from(Bytes::from(content))?),- // };-- let configuration = None;+ pub async fn new(+ field_rev: &Arc<FieldRevision>,+ configuration_reader: Arc<dyn GroupConfigurationReader>,+ configuration_writer: Arc<dyn GroupConfigurationReader>,+ ) -> FlowyResult<Self> {+ let configuration =+ GenericGroupConfiguration::<C>::new(field_rev.clone(), configuration_reader, configuration_writer).await?;let field_type_rev = field_rev.ty;let type_option = field_rev.get_type_option_entry::<T>(field_type_rev);let groups = G::generate_groups(&field_rev.id, &configuration, &type_option);@@ -195,55 +114,52 @@ whereimpl<C, T, G, P> GroupControllerSharedAction for GenericGroupController<C, T, G, P>whereP: CellBytesParser,- Self: Groupable<CellDataType = P::Object>,+ Self: GroupAction<CellDataType = P::Object>,{fn field_id(&self) -> &str {&self.field_id}- fn groups(&self) -> Vec<Group> {- let default_group = self.default_group.clone();- let mut groups: Vec<Group> = self.groups_map.values().cloned().collect();- if !default_group.rows.is_empty() {- groups.push(default_group);- }- groups- }-- fn group_rows(&mut self, row_revs: &[Arc<RowRevision>], field_rev: &FieldRevision) -> FlowyResult<()> {- if self.configuration.is_none() {- return Ok(());- }+ fn fill_groups(&mut self, row_revs: &[Arc<RowRevision>], field_rev: &FieldRevision) -> FlowyResult<Vec<Group>> {+ // if self.configuration.is_none() {+ // return Ok(vec![]);+ // }for row_rev in row_revs {if let Some(cell_rev) = row_rev.cells.get(&self.field_id) {- let mut records: Vec<GroupRecord> = vec![];+ let mut group_rows: Vec<GroupRow> = vec![];let cell_bytes = decode_any_cell_data(cell_rev.data.clone(), field_rev);let cell_data = cell_bytes.parser::<P>()?;for group in self.groups_map.values() {if self.can_group(&group.content, &cell_data) {- records.push(GroupRecord {+ group_rows.push(GroupRow {row: row_rev.into(),group_id: group.id.clone(),});}}- if records.is_empty() {- self.default_group.rows.push(row_rev.into());+ if group_rows.is_empty() {+ self.default_group.add_row(row_rev.into());} else {- for record in records {- if let Some(group) = self.groups_map.get_mut(&record.group_id) {- group.rows.push(record.row);+ for group_row in group_rows {+ if let Some(group) = self.groups_map.get_mut(&group_row.group_id) {+ group.add_row(group_row.row);}}}} else {- self.default_group.rows.push(row_rev.into());+ self.default_group.add_row(row_rev.into());}}- Ok(())+ let default_group = self.default_group.clone();+ let mut groups: Vec<Group> = self.groups_map.values().cloned().collect();+ if !default_group.number_of_row() == 0 {+ groups.push(default_group);+ }++ Ok(groups)}fn did_update_row(@@ -292,7 +208,7 @@ where}}-struct GroupRecord {+struct GroupRow {row: RowPB,group_id: String,}diff --git a/frontend/rust-lib/flowy-grid/src/services/group/group_service.rs b/frontend/rust-lib/flowy-grid/src/services/group/group_service.rsindex c07b3acec4..42e687445d 100644--- a/frontend/rust-lib/flowy-grid/src/services/group/group_service.rs+++ b/frontend/rust-lib/flowy-grid/src/services/group/group_service.rs@@ -2,44 +2,48 @@ use crate::entities::{CheckboxGroupConfigurationPB, DateGroupConfigurationPB, FieldType, GroupRowsChangesetPB,NumberGroupConfigurationPB, SelectOptionGroupConfigurationPB, TextGroupConfigurationPB, UrlGroupConfigurationPB,};+use crate::services::group::configuration::GroupConfigurationReader;+use crate::services::group::group_controller::GroupController;use crate::services::group::{- CheckboxGroupController, Group, GroupController, MultiSelectGroupController, SingleSelectGroupController,+ CheckboxGroupController, Group, GroupConfigurationWriter, MultiSelectGroupController, SingleSelectGroupController,};-use bytes::Bytes;use flowy_error::FlowyResult;use flowy_grid_data_model::revision::{- gen_grid_group_id, CheckboxGroupConfigurationRevision, DateGroupConfigurationRevision, FieldRevision,- GroupConfigurationRevision, NumberGroupConfigurationRevision, RowChangeset, RowRevision,- SelectOptionGroupConfigurationRevision, TextGroupConfigurationRevision, UrlGroupConfigurationRevision,+ CheckboxGroupConfigurationRevision, DateGroupConfigurationRevision, FieldRevision, GroupConfigurationRevision,+ NumberGroupConfigurationRevision, RowChangeset, RowRevision, SelectOptionGroupConfigurationRevision,+ TextGroupConfigurationRevision, UrlGroupConfigurationRevision,};-use lib_infra::future::AFFuture;+use std::future::Future;use std::sync::Arc;use tokio::sync::RwLock;-pub trait GroupConfigurationDelegate: Send + Sync + 'static {- fn get_group_configuration(&self, field_rev: Arc<FieldRevision>) -> AFFuture<GroupConfigurationRevision>;-}-pub(crate) struct GroupService {- delegate: Box<dyn GroupConfigurationDelegate>,+ configuration_reader: Arc<dyn GroupConfigurationReader>,+ configuration_writer: Arc<dyn GroupConfigurationWriter>,group_controller: Option<Arc<RwLock<dyn GroupController>>>,}impl GroupService {- pub(crate) async fn new(delegate: Box<dyn GroupConfigurationDelegate>) -> Self {+ pub(crate) async fn new<R, W>(configuration_reader: R, configuration_writer: W) -> Self+ where+ R: GroupConfigurationReader,+ W: GroupConfigurationWriter,+ {Self {- delegate,+ configuration_reader: Arc::new(configuration_reader),+ configuration_writer: Arc::new(configuration_writer),group_controller: None,}}pub(crate) async fn groups(&self) -> Vec<Group> {- if let Some(group_action_handler) = self.group_controller.as_ref() {- group_action_handler.read().await.groups()- } else {- vec![]- }+ // if let Some(group_action_handler) = self.group_controller.as_ref() {+ // group_action_handler.read().await.groups()+ // } else {+ // vec![]+ // }+ todo!()}pub(crate) async fn load_groups(@@ -49,13 +53,25 @@ impl GroupService {) -> Option<Vec<Group>> {let field_rev = find_group_field(field_revs)?;let field_type: FieldType = field_rev.ty.into();- let configuration = self.delegate.get_group_configuration(field_rev.clone()).await;- match self- .build_groups(&field_type, &field_rev, row_revs, configuration)- .await- {- Ok(groups) => Some(groups),- Err(_) => None,+ match self.make_group_controller(&field_type, &field_rev).await {+ Ok(group_controller) => {+ self.group_controller = group_controller;+ let mut groups = vec![];+ if let Some(group_action_handler) = self.group_controller.as_ref() {+ let mut write_guard = group_action_handler.write().await;+ groups = match write_guard.fill_groups(&row_revs, &field_rev) {+ Ok(groups) => groups,+ Err(e) => {+ tracing::error!("Fill groups failed:{:?}", e);+ vec![]+ }+ };++ drop(write_guard);+ }+ Some(groups)+ }+ Err(_) => Some(vec![]),}}@@ -151,14 +167,13 @@ impl GroupService {}}- #[tracing::instrument(level = "trace", skip_all, err)]- async fn build_groups(+ #[tracing::instrument(level = "trace", skip_all)]+ async fn make_group_controller(&mut self,field_type: &FieldType,field_rev: &Arc<FieldRevision>,- row_revs: Vec<Arc<RowRevision>>,- configuration: GroupConfigurationRevision,- ) -> FlowyResult<Vec<Group>> {+ ) -> FlowyResult<Option<Arc<RwLock<dyn GroupController>>>> {+ let mut group_controller: Option<Arc<RwLock<dyn GroupController>>> = None;match field_type {FieldType::RichText => {// let generator = GroupGenerator::<TextGroupConfigurationPB>::from_configuration(configuration);@@ -170,31 +185,37 @@ impl GroupService {// let generator = GroupGenerator::<DateGroupConfigurationPB>::from_configuration(configuration);}FieldType::SingleSelect => {- let controller = SingleSelectGroupController::new(field_rev, configuration)?;- self.group_controller = Some(Arc::new(RwLock::new(controller)));+ let controller = SingleSelectGroupController::new(+ field_rev,+ self.configuration_reader.clone(),+ self.configuration_writer.clone(),+ )+ .await?;+ group_controller = Some(Arc::new(RwLock::new(controller)));}FieldType::MultiSelect => {- let controller = MultiSelectGroupController::new(field_rev, configuration)?;- self.group_controller = Some(Arc::new(RwLock::new(controller)));+ let controller = MultiSelectGroupController::new(+ field_rev,+ self.configuration_reader.clone(),+ self.configuration_writer.clone(),+ )+ .await?;+ group_controller = Some(Arc::new(RwLock::new(controller)));}FieldType::Checkbox => {- let controller = CheckboxGroupController::new(field_rev, configuration)?;- self.group_controller = Some(Arc::new(RwLock::new(controller)));+ let controller = CheckboxGroupController::new(+ field_rev,+ self.configuration_reader.clone(),+ self.configuration_writer.clone(),+ )+ .await?;+ group_controller = Some(Arc::new(RwLock::new(controller)))}FieldType::URL => {// let generator = GroupGenerator::<UrlGroupConfigurationPB>::from_configuration(configuration);}- };-- let mut groups = vec![];- if let Some(group_action_handler) = self.group_controller.as_ref() {- let mut write_guard = group_action_handler.write().await;- let _ = write_guard.group_rows(&row_revs, field_rev)?;- groups = write_guard.groups();- drop(write_guard);}-- Ok(groups)+ Ok(group_controller)}}diff --git a/frontend/rust-lib/flowy-grid/src/services/group/mod.rs b/frontend/rust-lib/flowy-grid/src/services/group/mod.rsindex f8b96c8bab..19536b8c5b 100644--- a/frontend/rust-lib/flowy-grid/src/services/group/mod.rs+++ b/frontend/rust-lib/flowy-grid/src/services/group/mod.rs@@ -1,5 +1,11 @@-mod controllers;+mod action;+mod configuration;+mod controller_impls;+mod entities;+mod group_controller;mod group_service;-pub(crate) use controllers::*;+pub(crate) use configuration::*;+pub(crate) use controller_impls::*;+pub(crate) use entities::*;pub(crate) use group_service::*;diff --git a/frontend/rust-lib/flowy-grid/src/services/setting/setting_builder.rs b/frontend/rust-lib/flowy-grid/src/services/setting/setting_builder.rsindex 1cc16f7da7..16ee630cc7 100644--- a/frontend/rust-lib/flowy-grid/src/services/setting/setting_builder.rs+++ b/frontend/rust-lib/flowy-grid/src/services/setting/setting_builder.rs@@ -1,11 +1,4 @@-use crate::entities::{- GridLayout, GridLayoutPB, GridSettingPB, RepeatedGridConfigurationFilterPB, RepeatedGridGroupConfigurationPB,- RepeatedGridSortPB,-};-use flowy_grid_data_model::revision::{FieldRevision, SettingRevision};-use flowy_sync::entities::grid::{CreateFilterParams, DeleteFilterParams, GridSettingChangesetParams};-use std::collections::HashMap;-use std::sync::Arc;+use crate::entities::{CreateFilterParams, DeleteFilterParams, GridLayout, GridSettingChangesetParams};pub struct GridSettingChangesetBuilder {params: GridSettingChangesetParams,@@ -20,8 +13,6 @@ impl GridSettingChangesetBuilder {delete_filter: None,insert_group: None,delete_group: None,- insert_sort: None,- delete_sort: None,};Self { params }}@@ -40,42 +31,3 @@ impl GridSettingChangesetBuilder {self.params}}--pub fn make_grid_setting(grid_setting_rev: &SettingRevision, field_revs: &[Arc<FieldRevision>]) -> GridSettingPB {- let current_layout_type: GridLayout = grid_setting_rev.layout.clone().into();- let filters_by_field_id = grid_setting_rev- .get_all_filters(field_revs)- .map(|filters_by_field_id| {- filters_by_field_id- .into_iter()- .map(|(k, v)| (k, v.into()))- .collect::<HashMap<String, RepeatedGridConfigurationFilterPB>>()- })- .unwrap_or_default();- let groups_by_field_id = grid_setting_rev- .get_all_groups(field_revs)- .map(|groups_by_field_id| {- groups_by_field_id- .into_iter()- .map(|(k, v)| (k, v.into()))- .collect::<HashMap<String, RepeatedGridGroupConfigurationPB>>()- })- .unwrap_or_default();- let sorts_by_field_id = grid_setting_rev- .get_all_sort()- .map(|sorts_by_field_id| {- sorts_by_field_id- .into_iter()- .map(|(k, v)| (k, v.into()))- .collect::<HashMap<String, RepeatedGridSortPB>>()- })- .unwrap_or_default();-- GridSettingPB {- layouts: GridLayoutPB::all(),- current_layout_type,- filter_configuration_by_field_id: filters_by_field_id,- group_configuration_by_field_id: groups_by_field_id,- sorts_by_field_id,- }-}diff --git a/shared-lib/flowy-grid-data-model/src/revision/filter_rev.rs b/shared-lib/flowy-grid-data-model/src/revision/filter_rev.rsnew file mode 100644index 0000000000..7079b52229--- /dev/null+++ b/shared-lib/flowy-grid-data-model/src/revision/filter_rev.rs@@ -0,0 +1,9 @@+use serde::{Deserialize, Serialize};++#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]+pub struct FilterConfigurationRevision {+ pub id: String,+ pub field_id: String,+ pub condition: u8,+ pub content: Option<String>,+}diff --git a/shared-lib/flowy-grid-data-model/src/revision/grid_setting_rev.rs b/shared-lib/flowy-grid-data-model/src/revision/grid_setting_rev.rsindex ff15170932..01ca80a380 100644--- a/shared-lib/flowy-grid-data-model/src/revision/grid_setting_rev.rs+++ b/shared-lib/flowy-grid-data-model/src/revision/grid_setting_rev.rs@@ -1,8 +1,7 @@-use crate::revision::{FieldRevision, FieldTypeRevision};+use crate::revision::{FieldRevision, FieldTypeRevision, FilterConfigurationRevision, GroupConfigurationRevision};use indexmap::IndexMap;use nanoid::nanoid;use serde::{Deserialize, Serialize};-use serde_repr::*;use std::collections::HashMap;use std::fmt::Debug;use std::sync::Arc;@@ -15,6 +14,7 @@ pub fn gen_grid_group_id() -> String {nanoid!(6)}+#[allow(dead_code)]pub fn gen_grid_sort_id() -> String {nanoid!(6)}@@ -24,114 +24,6 @@ pub type FilterConfigurationsByFieldId = HashMap<String, Vec<Arc<FilterConfigura//pub type GroupConfiguration = Configuration<GroupConfigurationRevision>;pub type GroupConfigurationsByFieldId = HashMap<String, Vec<Arc<GroupConfigurationRevision>>>;-//-pub type SortConfiguration = Configuration<SortConfigurationRevision>;-pub type SortConfigurationsByFieldId = HashMap<String, Vec<Arc<SortConfigurationRevision>>>;--#[derive(Debug, Clone, Serialize, Deserialize, Default, Eq, PartialEq)]-pub struct SettingRevision {- pub layout: LayoutRevision,-- pub filters: FilterConfiguration,-- #[serde(default)]- pub groups: GroupConfiguration,-- #[serde(skip)]- pub sorts: SortConfiguration,-}--#[derive(Debug, PartialEq, Eq, Hash, Clone, Serialize_repr, Deserialize_repr)]-#[repr(u8)]-pub enum LayoutRevision {- Table = 0,- Board = 1,-}--impl ToString for LayoutRevision {- fn to_string(&self) -> String {- let layout_rev = self.clone() as u8;- layout_rev.to_string()- }-}--impl std::default::Default for LayoutRevision {- fn default() -> Self {- LayoutRevision::Table- }-}--impl SettingRevision {- pub fn get_all_groups(&self, field_revs: &[Arc<FieldRevision>]) -> Option<GroupConfigurationsByFieldId> {- self.groups.get_all_objects(field_revs)- }-- pub fn get_groups(- &self,- field_id: &str,- field_type_rev: &FieldTypeRevision,- ) -> Option<Vec<Arc<GroupConfigurationRevision>>> {- self.groups.get_objects(field_id, field_type_rev)- }-- pub fn get_mut_groups(- &mut self,- field_id: &str,- field_type: &FieldTypeRevision,- ) -> Option<&mut Vec<Arc<GroupConfigurationRevision>>> {- self.groups.get_mut_objects(field_id, field_type)- }-- pub fn insert_group(- &mut self,- field_id: &str,- field_type: &FieldTypeRevision,- group_rev: GroupConfigurationRevision,- ) {- // only one group can be set- self.groups.remove_all();- self.groups.insert_object(field_id, field_type, group_rev);- }-- pub fn get_all_filters(&self, field_revs: &[Arc<FieldRevision>]) -> Option<FilterConfigurationsByFieldId> {- self.filters.get_all_objects(field_revs)- }-- pub fn get_filters(- &self,- field_id: &str,- field_type_rev: &FieldTypeRevision,- ) -> Option<Vec<Arc<FilterConfigurationRevision>>> {- self.filters.get_objects(field_id, field_type_rev)- }-- pub fn get_mut_filters(- &mut self,- field_id: &str,- field_type: &FieldTypeRevision,- ) -> Option<&mut Vec<Arc<FilterConfigurationRevision>>> {- self.filters.get_mut_objects(field_id, field_type)- }-- pub fn insert_filter(- &mut self,- field_id: &str,- field_type: &FieldTypeRevision,- filter_rev: FilterConfigurationRevision,- ) {- self.filters.insert_object(field_id, field_type, filter_rev);- }-- pub fn get_all_sort(&self) -> Option<SortConfigurationsByFieldId> {- None- }-}--#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq)]-pub struct SortConfigurationRevision {- pub id: String,- pub field_id: Option<String>,-}#[derive(Debug, Clone, Serialize, Deserialize, Default, Eq, PartialEq)]#[serde(transparent)]@@ -239,38 +131,3 @@ where&mut self.object_by_field_type}}--pub trait GroupConfigurationSerde {- fn from_configuration(s: &str) -> Result<Self, serde_json::Error>;-}--#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq)]-pub struct GroupConfigurationRevision {- pub id: String,- pub field_id: String,- pub field_type_rev: FieldTypeRevision,- pub content: String,-}--impl GroupConfigurationRevision {- pub fn new<T>(field_id: String, field_type: FieldTypeRevision, content: T) -> Result<Self, serde_json::Error>- where- T: serde::Serialize,- {- let content = serde_json::to_string(&content)?;- Ok(Self {- id: gen_grid_group_id(),- field_id,- field_type_rev: field_type,- content,- })- }-}--#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]-pub struct FilterConfigurationRevision {- pub id: String,- pub field_id: String,- pub condition: u8,- pub content: Option<String>,-}diff --git a/shared-lib/flowy-grid-data-model/src/revision/grid_view.rs b/shared-lib/flowy-grid-data-model/src/revision/grid_view.rsindex 2fcc2fc4eb..9d4df3067e 100644--- a/shared-lib/flowy-grid-data-model/src/revision/grid_view.rs+++ b/shared-lib/flowy-grid-data-model/src/revision/grid_view.rs@@ -1,19 +1,49 @@-use crate::revision::SettingRevision;+use crate::revision::{+ FieldRevision, FieldTypeRevision, FilterConfiguration, FilterConfigurationRevision, FilterConfigurationsByFieldId,+ GroupConfiguration, GroupConfigurationRevision, GroupConfigurationsByFieldId,+};use nanoid::nanoid;use serde::{Deserialize, Serialize};+use serde_repr::*;+use std::sync::Arc;#[allow(dead_code)]pub fn gen_grid_view_id() -> String {nanoid!(6)}+#[derive(Debug, PartialEq, Eq, Hash, Clone, Serialize_repr, Deserialize_repr)]+#[repr(u8)]+pub enum LayoutRevision {+ Table = 0,+ Board = 1,+}++impl ToString for LayoutRevision {+ fn to_string(&self) -> String {+ let layout_rev = self.clone() as u8;+ layout_rev.to_string()+ }+}++impl std::default::Default for LayoutRevision {+ fn default() -> Self {+ LayoutRevision::Table+ }+}+#[derive(Debug, Clone, Default, Serialize, Deserialize)]pub struct GridViewRevision {pub view_id: String,pub grid_id: String,- pub setting: SettingRevision,+ pub layout: LayoutRevision,++ pub filters: FilterConfiguration,++ #[serde(default)]+ pub groups: GroupConfiguration,// For the moment, we just use the order returned from the GridRevision#[allow(dead_code)]@@ -26,10 +56,78 @@ impl GridViewRevision {GridViewRevision {view_id,grid_id,- setting: Default::default(),+ layout: Default::default(),+ filters: Default::default(),+ groups: Default::default(),row_orders: vec![],}}++ pub fn get_all_groups(&self, field_revs: &[Arc<FieldRevision>]) -> Option<GroupConfigurationsByFieldId> {+ self.groups.get_all_objects(field_revs)+ }++ pub fn get_groups(+ &self,+ field_id: &str,+ field_type_rev: &FieldTypeRevision,+ ) -> Option<Arc<GroupConfigurationRevision>> {+ let mut groups = self.groups.get_objects(field_id, field_type_rev)?;+ if groups.is_empty() {+ debug_assert_eq!(groups.len(), 1);+ Some(groups.pop().unwrap())+ } else {+ None+ }+ }++ pub fn get_mut_groups(+ &mut self,+ field_id: &str,+ field_type: &FieldTypeRevision,+ ) -> Option<&mut Vec<Arc<GroupConfigurationRevision>>> {+ self.groups.get_mut_objects(field_id, field_type)+ }++ pub fn insert_group(+ &mut self,+ field_id: &str,+ field_type: &FieldTypeRevision,+ group_rev: GroupConfigurationRevision,+ ) {+ // only one group can be set+ self.groups.remove_all();+ self.groups.insert_object(field_id, field_type, group_rev);+ }++ pub fn get_all_filters(&self, field_revs: &[Arc<FieldRevision>]) -> Option<FilterConfigurationsByFieldId> {+ self.filters.get_all_objects(field_revs)+ }++ pub fn get_filters(+ &self,+ field_id: &str,+ field_type_rev: &FieldTypeRevision,+ ) -> Option<Vec<Arc<FilterConfigurationRevision>>> {+ self.filters.get_objects(field_id, field_type_rev)+ }++ pub fn get_mut_filters(+ &mut self,+ field_id: &str,+ field_type: &FieldTypeRevision,+ ) -> Option<&mut Vec<Arc<FilterConfigurationRevision>>> {+ self.filters.get_mut_objects(field_id, field_type)+ }++ pub fn insert_filter(+ &mut self,+ field_id: &str,+ field_type: &FieldTypeRevision,+ filter_rev: FilterConfigurationRevision,+ ) {+ self.filters.insert_object(field_id, field_type, filter_rev);+ }}#[derive(Debug, Clone, Default, Serialize, Deserialize)]diff --git a/shared-lib/flowy-grid-data-model/src/revision/group_rev.rs b/shared-lib/flowy-grid-data-model/src/revision/group_rev.rsindex 932cc60033..83deeb2735 100644--- a/shared-lib/flowy-grid-data-model/src/revision/group_rev.rs+++ b/shared-lib/flowy-grid-data-model/src/revision/group_rev.rs@@ -1,32 +1,91 @@+use crate::revision::{gen_grid_group_id, FieldTypeRevision};use serde::{Deserialize, Serialize};+use serde_json::Error;use serde_repr::*;+pub trait GroupConfigurationContentSerde: Sized {+ fn from_configuration(s: &str) -> Result<Self, serde_json::Error>;+}++#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq)]+pub struct GroupConfigurationRevision {+ pub id: String,+ pub field_id: String,+ pub field_type_rev: FieldTypeRevision,+ pub content: String,+}++impl GroupConfigurationRevision {+ pub fn new<T>(field_id: String, field_type: FieldTypeRevision, content: T) -> Result<Self, serde_json::Error>+ where+ T: serde::Serialize,+ {+ let content = serde_json::to_string(&content)?;+ Ok(Self {+ id: gen_grid_group_id(),+ field_id,+ field_type_rev: field_type,+ content,+ })+ }+}+#[derive(Default, Serialize, Deserialize)]pub struct TextGroupConfigurationRevision {pub hide_empty: bool,}+impl GroupConfigurationContentSerde for TextGroupConfigurationRevision {+ fn from_configuration(s: &str) -> Result<Self, Error> {+ serde_json::from_str(s)+ }+}+#[derive(Default, Serialize, Deserialize)]pub struct NumberGroupConfigurationRevision {pub hide_empty: bool,}+impl GroupConfigurationContentSerde for NumberGroupConfigurationRevision {+ fn from_configuration(s: &str) -> Result<Self, Error> {+ serde_json::from_str(s)+ }+}+#[derive(Default, Serialize, Deserialize)]pub struct UrlGroupConfigurationRevision {pub hide_empty: bool,}+impl GroupConfigurationContentSerde for UrlGroupConfigurationRevision {+ fn from_configuration(s: &str) -> Result<Self, Error> {+ serde_json::from_str(s)+ }+}+#[derive(Default, Serialize, Deserialize)]pub struct CheckboxGroupConfigurationRevision {pub hide_empty: bool,}+impl GroupConfigurationContentSerde for CheckboxGroupConfigurationRevision {+ fn from_configuration(s: &str) -> Result<Self, Error> {+ serde_json::from_str(s)+ }+}+#[derive(Default, Serialize, Deserialize)]pub struct SelectOptionGroupConfigurationRevision {pub hide_empty: bool,pub groups: Vec<GroupRecordRevision>,}+impl GroupConfigurationContentSerde for SelectOptionGroupConfigurationRevision {+ fn from_configuration(s: &str) -> Result<Self, Error> {+ serde_json::from_str(s)+ }+}+#[derive(Default, Serialize, Deserialize)]pub struct GroupRecordRevision {pub group_id: String,@@ -42,6 +101,12 @@ pub struct DateGroupConfigurationRevision {pub condition: DateCondition,}+impl GroupConfigurationContentSerde for DateGroupConfigurationRevision {+ fn from_configuration(s: &str) -> Result<Self, Error> {+ serde_json::from_str(s)+ }+}+#[derive(Serialize_repr, Deserialize_repr)]#[repr(u8)]pub enum DateCondition {diff --git a/shared-lib/flowy-grid-data-model/src/revision/mod.rs b/shared-lib/flowy-grid-data-model/src/revision/mod.rsindex d9df0910bd..460370b86b 100644--- a/shared-lib/flowy-grid-data-model/src/revision/mod.rs+++ b/shared-lib/flowy-grid-data-model/src/revision/mod.rs@@ -1,9 +1,11 @@+mod filter_rev;mod grid_block;mod grid_rev;mod grid_setting_rev;mod grid_view;mod group_rev;+pub use filter_rev::*;pub use grid_block::*;pub use grid_rev::*;pub use grid_setting_rev::*;diff --git a/shared-lib/flowy-sync/src/client_grid/view_revision_pad.rs b/shared-lib/flowy-sync/src/client_grid/view_revision_pad.rsindex db52d0b38b..5ec4a87ef9 100644--- a/shared-lib/flowy-sync/src/client_grid/view_revision_pad.rs+++ b/shared-lib/flowy-sync/src/client_grid/view_revision_pad.rs@@ -3,7 +3,7 @@ use crate::errors::{internal_error, CollaborateError, CollaborateResult};use crate::util::{cal_diff, make_text_delta_from_revisions};use flowy_grid_data_model::revision::{FieldRevision, FieldTypeRevision, FilterConfigurationRevision, FilterConfigurationsByFieldId, GridViewRevision,- GroupConfigurationRevision, GroupConfigurationsByFieldId, SettingRevision, SortConfigurationsByFieldId,+ GroupConfigurationRevision, GroupConfigurationsByFieldId,};use lib_ot::core::{OperationTransform, PhantomAttributes, TextDelta, TextDeltaBuilder};use std::sync::Arc;@@ -48,23 +48,11 @@ impl GridViewRevisionPad {Self::from_delta(delta)}- pub fn get_setting_rev(&self) -> &SettingRevision {- &self.view.setting- }-pub fn get_all_groups(&self, field_revs: &[Arc<FieldRevision>]) -> Option<GroupConfigurationsByFieldId> {- self.setting.groups.get_all_objects(field_revs)+ self.groups.get_all_objects(field_revs)}- pub fn get_groups(- &self,- field_id: &str,- field_type_rev: &FieldTypeRevision,- ) -> Option<Vec<Arc<GroupConfigurationRevision>>> {- self.setting.groups.get_objects(field_id, field_type_rev)- }-- pub fn insert_group(+ pub fn insert_group_configuration(&mut self,field_id: &str,field_type: &FieldTypeRevision,@@ -72,8 +60,8 @@ impl GridViewRevisionPad {) -> CollaborateResult<Option<GridViewRevisionChangeset>> {self.modify(|view| {// only one group can be set- view.setting.groups.remove_all();- view.setting.groups.insert_object(field_id, field_type, group_rev);+ view.groups.remove_all();+ view.groups.insert_object(field_id, field_type, group_rev);Ok(Some(()))})}@@ -85,7 +73,7 @@ impl GridViewRevisionPad {group_id: &str,) -> CollaborateResult<Option<GridViewRevisionChangeset>> {self.modify(|view| {- if let Some(groups) = view.setting.groups.get_mut_objects(field_id, field_type) {+ if let Some(groups) = view.groups.get_mut_objects(field_id, field_type) {groups.retain(|group| group.id != group_id);Ok(Some(()))} else {@@ -95,7 +83,7 @@ impl GridViewRevisionPad {}pub fn get_all_filters(&self, field_revs: &[Arc<FieldRevision>]) -> Option<FilterConfigurationsByFieldId> {- self.setting.filters.get_all_objects(field_revs)+ self.filters.get_all_objects(field_revs)}pub fn get_filters(@@ -103,7 +91,7 @@ impl GridViewRevisionPad {field_id: &str,field_type_rev: &FieldTypeRevision,) -> Option<Vec<Arc<FilterConfigurationRevision>>> {- self.setting.filters.get_objects(field_id, field_type_rev)+ self.filters.get_objects(field_id, field_type_rev)}pub fn insert_filter(@@ -113,7 +101,7 @@ impl GridViewRevisionPad {filter_rev: FilterConfigurationRevision,) -> CollaborateResult<Option<GridViewRevisionChangeset>> {self.modify(|view| {- view.setting.filters.insert_object(field_id, field_type, filter_rev);+ view.filters.insert_object(field_id, field_type, filter_rev);Ok(Some(()))})}@@ -125,7 +113,7 @@ impl GridViewRevisionPad {filter_id: &str,) -> CollaborateResult<Option<GridViewRevisionChangeset>> {self.modify(|view| {- if let Some(filters) = view.setting.filters.get_mut_objects(field_id, field_type) {+ if let Some(filters) = view.filters.get_mut_objects(field_id, field_type) {filters.retain(|filter| filter.id != filter_id);Ok(Some(()))} else {@@ -134,10 +122,6 @@ impl GridViewRevisionPad {})}- pub fn get_all_sort(&self) -> Option<SortConfigurationsByFieldId> {- None- }-pub fn json_str(&self) -> CollaborateResult<String> {make_grid_view_rev_json_str(&self.view)}