Feat/sort after change (#1607)

* chore: generate task after row was changed

* chore: config task

* chore: add task test

Co-authored-by: nathan <[email protected]>

Author: appflowy

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

@@ -17,6 +17,8 @@ pub enum GridDartNotification {
     DidGroupByNewField = 62,
     DidUpdateFilter = 63,
     DidUpdateSort = 64,
+    DidReorderRows = 65,
+    DidReorderSingleRow = 66,
     DidUpdateGridSetting = 70,
 }
 

frontend/rust-lib/flowy-grid/src/entities/sort_entities.rs

@@ -4,7 +4,7 @@ use crate::services::sort::SortType;
 
 use flowy_derive::{ProtoBuf, ProtoBuf_Enum};
 use flowy_error::ErrorCode;
-use grid_rev_model::FieldTypeRevision;
+use grid_rev_model::{FieldTypeRevision, SortCondition, SortRevision};
 
 #[derive(Eq, PartialEq, ProtoBuf, Debug, Default, Clone)]
 pub struct GridSortPB {
@@ -21,6 +21,17 @@ pub struct GridSortPB {
     pub condition: GridSortConditionPB,
 }
 
+impl std::convert::From<&SortRevision> for GridSortPB {
+    fn from(sort_rev: &SortRevision) -> Self {
+        Self {
+            id: sort_rev.id.clone(),
+            field_id: sort_rev.field_id.clone(),
+            field_type: sort_rev.field_type.into(),
+            condition: sort_rev.condition.clone().into(),
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, ProtoBuf_Enum)]
 #[repr(u8)]
 pub enum GridSortConditionPB {
@@ -32,6 +43,16 @@ impl std::default::Default for GridSortConditionPB {
         Self::Ascending
     }
 }
+
+impl std::convert::From<SortCondition> for GridSortConditionPB {
+    fn from(condition: SortCondition) -> Self {
+        match condition {
+            SortCondition::Ascending => GridSortConditionPB::Ascending,
+            SortCondition::Descending => GridSortConditionPB::Descending,
+        }
+    }
+}
+
 #[derive(ProtoBuf, Debug, Default, Clone)]
 pub struct AlterSortPayloadPB {
     #[pb(index = 1)]
@@ -151,3 +172,30 @@ pub struct SortChangesetNotificationPB {
     #[pb(index = 4)]
     pub update_sorts: Vec<GridSortPB>,
 }
+
+impl SortChangesetNotificationPB {
+    pub fn extend(&mut self, other: SortChangesetNotificationPB) {
+        self.insert_sorts.extend(other.insert_sorts);
+        self.delete_sorts.extend(other.delete_sorts);
+        self.update_sorts.extend(other.update_sorts);
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.insert_sorts.is_empty() && self.delete_sorts.is_empty() && self.update_sorts.is_empty()
+    }
+}
+
+#[derive(Debug, Default, ProtoBuf)]
+pub struct ReorderAllRowsPB {
+    #[pb(index = 1)]
+    pub row_orders: Vec<String>,
+}
+
+#[derive(Debug, Default, ProtoBuf)]
+pub struct ReorderSingleRowPB {
+    #[pb(index = 1)]
+    pub old_index: i32,
+
+    #[pb(index = 2)]
+    pub new_index: i32,
+}

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

@@ -1,6 +1,6 @@
 use crate::entities::*;
 use crate::manager::GridManager;
-use crate::services::cell::{FromCellString, TypeCellData};
+use crate::services::cell::{FromCellString, ToCellChangesetString, TypeCellData};
 use crate::services::field::{
     default_type_option_builder_from_type, select_type_option_from_field_rev, type_option_builder_from_json_str,
     DateCellChangeset, DateChangesetPB, SelectOptionCellChangeset, SelectOptionCellChangesetPB,
@@ -317,7 +317,9 @@ pub(crate) async fn update_cell_handler(
 ) -> Result<(), FlowyError> {
     let changeset: CellChangesetPB = data.into_inner();
     let editor = manager.get_grid_editor(&changeset.grid_id).await?;
-    let _ = editor.update_cell_with_changeset(changeset).await?;
+    let _ = editor
+        .update_cell_with_changeset(&changeset.row_id, &changeset.field_id, changeset.type_cell_data)
+        .await?;
     Ok(())
 }
 
@@ -344,16 +346,17 @@ pub(crate) async fn update_select_option_handler(
     manager: AFPluginState<Arc<GridManager>>,
 ) -> Result<(), FlowyError> {
     let changeset: SelectOptionChangeset = data.into_inner().try_into()?;
-    let editor = manager.get_grid_editor(&changeset.cell_identifier.view_id).await?;
-
+    let editor = manager.get_grid_editor(&changeset.cell_path.view_id).await?;
+    let field_id = changeset.cell_path.field_id.clone();
     let _ = editor
-        .modify_field_rev(&changeset.cell_identifier.field_id, |field_rev| {
+        .modify_field_rev(&field_id, |field_rev| {
             let mut type_option = select_type_option_from_field_rev(field_rev)?;
-            let mut cell_content_changeset = None;
+            let mut cell_changeset_str = None;
             let mut is_changed = None;
 
             for option in changeset.insert_options {
-                cell_content_changeset = Some(SelectOptionCellChangeset::from_insert_option_id(&option.id).to_str());
+                cell_changeset_str =
+                    Some(SelectOptionCellChangeset::from_insert_option_id(&option.id).to_cell_changeset_str());
                 type_option.insert_option(option);
                 is_changed = Some(());
             }
@@ -364,7 +367,8 @@ pub(crate) async fn update_select_option_handler(
             }
 
             for option in changeset.delete_options {
-                cell_content_changeset = Some(SelectOptionCellChangeset::from_delete_option_id(&option.id).to_str());
+                cell_changeset_str =
+                    Some(SelectOptionCellChangeset::from_delete_option_id(&option.id).to_cell_changeset_str());
                 type_option.delete_option(option);
                 is_changed = Some(());
             }
@@ -373,16 +377,17 @@ pub(crate) async fn update_select_option_handler(
                 field_rev.insert_type_option(&*type_option);
             }
 
-            if let Some(cell_content_changeset) = cell_content_changeset {
-                let changeset = CellChangesetPB {
-                    grid_id: changeset.cell_identifier.view_id,
-                    row_id: changeset.cell_identifier.row_id,
-                    field_id: changeset.cell_identifier.field_id.clone(),
-                    type_cell_data: cell_content_changeset,
-                };
+            if let Some(cell_changeset_str) = cell_changeset_str {
                 let cloned_editor = editor.clone();
                 tokio::spawn(async move {
-                    match cloned_editor.update_cell_with_changeset(changeset).await {
+                    match cloned_editor
+                        .update_cell_with_changeset(
+                            &changeset.cell_path.row_id,
+                            &changeset.cell_path.field_id,
+                            cell_changeset_str,
+                        )
+                        .await
+                    {
                         Ok(_) => {}
                         Err(e) => tracing::error!("{}", e),
                     }
@@ -432,7 +437,18 @@ pub(crate) async fn update_select_option_cell_handler(
 ) -> Result<(), FlowyError> {
     let params: SelectOptionCellChangesetParams = data.into_inner().try_into()?;
     let editor = manager.get_grid_editor(&params.cell_identifier.view_id).await?;
-    let _ = editor.update_cell_with_changeset(params.into()).await?;
+    let changeset = SelectOptionCellChangeset {
+        insert_option_ids: params.insert_option_ids,
+        delete_option_ids: params.delete_option_ids,
+    };
+
+    let _ = editor
+        .update_cell_with_changeset(
+            &params.cell_identifier.row_id,
+            &params.cell_identifier.field_id,
+            changeset,
+        )
+        .await?;
     Ok(())
 }
 
@@ -443,15 +459,15 @@ pub(crate) async fn update_date_cell_handler(
 ) -> Result<(), FlowyError> {
     let data = data.into_inner();
     let cell_path: CellPathParams = data.cell_path.try_into()?;
-    let content = DateCellChangeset {
+    let cell_changeset = DateCellChangeset {
         date: data.date,
         time: data.time,
         is_utc: data.is_utc,
     };
 
     let editor = manager.get_grid_editor(&cell_path.view_id).await?;
     let _ = editor
-        .update_cell(cell_path.view_id, cell_path.row_id, cell_path.field_id, content)
+        .update_cell(cell_path.row_id, cell_path.field_id, cell_changeset)
         .await?;
     Ok(())
 }

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

@@ -118,8 +118,13 @@ impl GridBlockRevisionEditor {
     }
 
     pub async fn get_row_rev(&self, row_id: &str) -> FlowyResult<Option<(usize, Arc<RowRevision>)>> {
-        let row_rev = self.pad.read().await.get_row_rev(row_id);
-        Ok(row_rev)
+        if self.pad.try_read().is_err() {
+            tracing::error!("Required GridBlockRevisionPad's read lock failed");
+            Ok(None)
+        } else {
+            let row_rev = self.pad.read().await.get_row_rev(row_id);
+            Ok(row_rev)
+        }
     }
 
     pub async fn get_row_revs<T>(&self, row_ids: Option<Vec<Cow<'_, T>>>) -> FlowyResult<Vec<Arc<RowRevision>>>

frontend/rust-lib/flowy-grid/src/services/cell/cell_operation.rs

@@ -34,7 +34,7 @@ pub trait CellDataDecoder: TypeOption {
 
 pub trait CellDataChangeset: TypeOption {
     /// The changeset is able to parse into the concrete data struct if `TypeOption::CellChangeset`
-    /// implements the `FromCellChangeset` trait.
+    /// implements the `FromCellChangesetString` trait.
     /// For example,the SelectOptionCellChangeset,DateCellChangeset. etc.
     ///  
     fn apply_changeset(
@@ -50,14 +50,14 @@ pub trait CellDataChangeset: TypeOption {
 ///         FieldType::SingleSelect => SelectOptionChangeset
 ///
 /// cell_rev: It will be None if the cell does not contain any data.
-pub fn apply_cell_data_changeset<C: ToString, T: AsRef<FieldRevision>>(
+pub fn apply_cell_data_changeset<C: ToCellChangesetString, T: AsRef<FieldRevision>>(
     changeset: C,
     cell_rev: Option<CellRevision>,
     field_rev: T,
     cell_data_cache: Option<AtomicCellDataCache>,
 ) -> Result<String, FlowyError> {
     let field_rev = field_rev.as_ref();
-    let changeset = changeset.to_string();
+    let changeset = changeset.to_cell_changeset_str();
     let field_type: FieldType = field_rev.ty.into();
 
     let type_cell_data = cell_rev.and_then(|cell_rev| match TypeCellData::try_from(cell_rev) {
@@ -108,7 +108,8 @@ pub fn decode_type_cell_data<T: TryInto<TypeCellData, Error = FlowyError> + Debu
 ///
 /// # Arguments
 ///
-/// * `cell_str`: the opaque cell string
+/// * `cell_str`: the opaque cell string that can be decoded by corresponding structs that implement the
+/// `FromCellString` trait.
 /// * `from_field_type`: the original field type of the passed-in cell data. Check the `TypeCellData`
 /// that is used to save the origin field type of the cell data.
 /// * `to_field_type`: decode the passed-in cell data to this field type. It will use the to_field_type's
@@ -155,7 +156,7 @@ pub fn insert_text_cell(s: String, field_rev: &FieldRevision) -> CellRevision {
 }
 
 pub fn insert_number_cell(num: i64, field_rev: &FieldRevision) -> CellRevision {
-    let data = apply_cell_data_changeset(num, None, field_rev, None).unwrap();
+    let data = apply_cell_data_changeset(num.to_string(), None, field_rev, None).unwrap();
     CellRevision::new(data)
 }
 
@@ -186,14 +187,14 @@ pub fn insert_date_cell(timestamp: i64, field_rev: &FieldRevision) -> CellRevisi
 }
 
 pub fn insert_select_option_cell(option_ids: Vec<String>, field_rev: &FieldRevision) -> CellRevision {
-    let cell_data = SelectOptionCellChangeset::from_insert_options(option_ids).to_str();
-    let data = apply_cell_data_changeset(cell_data, None, field_rev, None).unwrap();
+    let changeset = SelectOptionCellChangeset::from_insert_options(option_ids).to_cell_changeset_str();
+    let data = apply_cell_data_changeset(changeset, None, field_rev, None).unwrap();
     CellRevision::new(data)
 }
 
 pub fn delete_select_option_cell(option_ids: Vec<String>, field_rev: &FieldRevision) -> CellRevision {
-    let cell_data = SelectOptionCellChangeset::from_delete_options(option_ids).to_str();
-    let data = apply_cell_data_changeset(cell_data, None, field_rev, None).unwrap();
+    let changeset = SelectOptionCellChangeset::from_delete_options(option_ids).to_cell_changeset_str();
+    let data = apply_cell_data_changeset(changeset, None, field_rev, None).unwrap();
     CellRevision::new(data)
 }
 
@@ -252,13 +253,13 @@ impl std::convert::From<IntoCellData<String>> for String {
 
 /// If the changeset applying to the cell is not String type, it should impl this trait.
 /// Deserialize the string into cell specific changeset.
-pub trait FromCellChangeset {
+pub trait FromCellChangesetString {
     fn from_changeset(changeset: String) -> FlowyResult<Self>
     where
         Self: Sized;
 }
 
-impl FromCellChangeset for String {
+impl FromCellChangesetString for String {
     fn from_changeset(changeset: String) -> FlowyResult<Self>
     where
         Self: Sized,
@@ -267,6 +268,16 @@ impl FromCellChangeset for String {
     }
 }
 
+pub trait ToCellChangesetString: Debug {
+    fn to_cell_changeset_str(&self) -> String;
+}
+
+impl ToCellChangesetString for String {
+    fn to_cell_changeset_str(&self) -> String {
+        self.clone()
+    }
+}
+
 pub struct AnyCellChangeset<T>(pub Option<T>);
 
 impl<T> AnyCellChangeset<T> {
@@ -280,7 +291,7 @@ impl<T> AnyCellChangeset<T> {
 
 impl<T, C: ToString> std::convert::From<C> for AnyCellChangeset<T>
 where
-    T: FromCellChangeset,
+    T: FromCellChangesetString,
 {
     fn from(changeset: C) -> Self {
         match T::from_changeset(changeset.to_string()) {

frontend/rust-lib/flowy-grid/src/services/field/type_options/date_type_option/date_filter.rs

@@ -1,5 +1,4 @@
 use crate::entities::{DateFilterConditionPB, DateFilterPB};
-
 use chrono::NaiveDateTime;
 
 impl DateFilterPB {

frontend/rust-lib/flowy-grid/src/services/field/type_options/date_type_option/date_type_option_entities.rs

@@ -1,5 +1,7 @@
 use crate::entities::CellPathPB;
-use crate::services::cell::{CellProtobufBlobParser, DecodedCellData, FromCellChangeset, FromCellString};
+use crate::services::cell::{
+    CellProtobufBlobParser, DecodedCellData, FromCellChangesetString, FromCellString, ToCellChangesetString,
+};
 use bytes::Bytes;
 use flowy_derive::{ProtoBuf, ProtoBuf_Enum};
 use flowy_error::{internal_error, FlowyResult};
@@ -33,7 +35,7 @@ pub struct DateChangesetPB {
     pub is_utc: bool,
 }
 
-#[derive(Clone, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct DateCellChangeset {
     pub date: Option<String>,
     pub time: Option<String>,
@@ -53,7 +55,7 @@ impl DateCellChangeset {
     }
 }
 
-impl FromCellChangeset for DateCellChangeset {
+impl FromCellChangesetString for DateCellChangeset {
     fn from_changeset(changeset: String) -> FlowyResult<Self>
     where
         Self: Sized,
@@ -62,9 +64,9 @@ impl FromCellChangeset for DateCellChangeset {
     }
 }
 
-impl ToString for DateCellChangeset {
-    fn to_string(&self) -> String {
-        serde_json::to_string(self).unwrap_or_else(|_| "".to_string())
+impl ToCellChangesetString for DateCellChangeset {
+    fn to_cell_changeset_str(&self) -> String {
+        serde_json::to_string(self).unwrap_or_default()
     }
 }