|
@@ -1,12 +1,13 @@
|
|
|
+use crate::entities::{GroupPB, GroupViewChangesetPB, InsertedGroupPB};
|
|
|
use crate::services::group::{default_group_configuration, Group};
|
|
|
use flowy_error::{FlowyError, FlowyResult};
|
|
|
use flowy_grid_data_model::revision::{
|
|
|
- FieldRevision, FieldTypeRevision, GroupConfigurationContentSerde, GroupConfigurationRevision, GroupRecordRevision,
|
|
|
+ FieldRevision, FieldTypeRevision, GroupConfigurationContentSerde, GroupConfigurationRevision, GroupRevision,
|
|
|
};
|
|
|
-use std::marker::PhantomData;
|
|
|
-
|
|
|
use indexmap::IndexMap;
|
|
|
use lib_infra::future::AFFuture;
|
|
|
+use std::fmt::Formatter;
|
|
|
+use std::marker::PhantomData;
|
|
|
use std::sync::Arc;
|
|
|
|
|
|
pub trait GroupConfigurationReader: Send + Sync + 'static {
|
|
@@ -25,7 +26,17 @@ pub trait GroupConfigurationWriter: Send + Sync + 'static {
|
|
|
) -> AFFuture<FlowyResult<()>>;
|
|
|
}
|
|
|
|
|
|
+impl<T> std::fmt::Display for GenericGroupConfiguration<T> {
|
|
|
+ fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
|
|
|
+ self.groups_map.iter().for_each(|(_, group)| {
|
|
|
+ let _ = f.write_fmt(format_args!("Group:{} has {} rows \n", group.id, group.rows.len()));
|
|
|
+ });
|
|
|
+ Ok(())
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
pub struct GenericGroupConfiguration<C> {
|
|
|
+ view_id: String,
|
|
|
pub configuration: Arc<GroupConfigurationRevision>,
|
|
|
configuration_content: PhantomData<C>,
|
|
|
field_rev: Arc<FieldRevision>,
|
|
@@ -39,6 +50,7 @@ where
|
|
|
{
|
|
|
#[tracing::instrument(level = "trace", skip_all, err)]
|
|
|
pub async fn new(
|
|
|
+ view_id: String,
|
|
|
field_rev: Arc<FieldRevision>,
|
|
|
reader: Arc<dyn GroupConfigurationReader>,
|
|
|
writer: Arc<dyn GroupConfigurationWriter>,
|
|
@@ -56,6 +68,7 @@ where
|
|
|
|
|
|
// let configuration = C::from_configuration_content(&configuration_rev.content)?;
|
|
|
Ok(Self {
|
|
|
+ view_id,
|
|
|
field_rev,
|
|
|
groups_map: IndexMap::new(),
|
|
|
writer,
|
|
@@ -72,17 +85,53 @@ where
|
|
|
self.groups_map.values().cloned().collect()
|
|
|
}
|
|
|
|
|
|
- pub(crate) async fn merge_groups(&mut self, groups: Vec<Group>) -> FlowyResult<()> {
|
|
|
- let (group_revs, groups) = merge_groups(&self.configuration.groups, groups);
|
|
|
+ pub(crate) fn merge_groups(&mut self, groups: Vec<Group>) -> FlowyResult<Option<GroupViewChangesetPB>> {
|
|
|
+ let MergeGroupResult {
|
|
|
+ groups,
|
|
|
+ inserted_groups,
|
|
|
+ updated_groups,
|
|
|
+ } = merge_groups(&self.configuration.groups, groups);
|
|
|
+
|
|
|
+ let group_revs = groups
|
|
|
+ .iter()
|
|
|
+ .map(|group| GroupRevision::new(group.id.clone(), group.name.clone()))
|
|
|
+ .collect::<Vec<GroupRevision>>();
|
|
|
+
|
|
|
self.mut_configuration(move |configuration| {
|
|
|
- configuration.groups = group_revs;
|
|
|
- true
|
|
|
+ let mut is_changed = false;
|
|
|
+ for new_group_rev in group_revs {
|
|
|
+ match configuration
|
|
|
+ .groups
|
|
|
+ .iter()
|
|
|
+ .position(|group_rev| group_rev.id == new_group_rev.id)
|
|
|
+ {
|
|
|
+ None => {
|
|
|
+ configuration.groups.push(new_group_rev);
|
|
|
+ is_changed = true;
|
|
|
+ }
|
|
|
+ Some(pos) => {
|
|
|
+ let removed_group = configuration.groups.remove(pos);
|
|
|
+ if removed_group != new_group_rev {
|
|
|
+ is_changed = true;
|
|
|
+ }
|
|
|
+ configuration.groups.insert(pos, new_group_rev);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ is_changed
|
|
|
})?;
|
|
|
|
|
|
groups.into_iter().for_each(|group| {
|
|
|
self.groups_map.insert(group.id.clone(), group);
|
|
|
});
|
|
|
- Ok(())
|
|
|
+
|
|
|
+ let changeset = make_group_view_changeset(self.view_id.clone(), inserted_groups, updated_groups);
|
|
|
+ tracing::trace!("Group changeset: {:?}", changeset);
|
|
|
+ if changeset.is_empty() {
|
|
|
+ Ok(None)
|
|
|
+ } else {
|
|
|
+ Ok(Some(changeset))
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
#[allow(dead_code)]
|
|
@@ -101,7 +150,7 @@ where
|
|
|
Ok(())
|
|
|
}
|
|
|
|
|
|
- pub(crate) fn with_mut_groups(&mut self, mut each: impl FnMut(&mut Group)) {
|
|
|
+ pub(crate) fn iter_mut_groups(&mut self, mut each: impl FnMut(&mut Group)) {
|
|
|
self.groups_map.iter_mut().for_each(|(_, group)| {
|
|
|
each(group);
|
|
|
})
|
|
@@ -119,8 +168,8 @@ where
|
|
|
self.groups_map.swap_indices(from_index, to_index);
|
|
|
|
|
|
self.mut_configuration(|configuration| {
|
|
|
- let from_index = configuration.groups.iter().position(|group| group.group_id == from_id);
|
|
|
- let to_index = configuration.groups.iter().position(|group| group.group_id == to_id);
|
|
|
+ let from_index = configuration.groups.iter().position(|group| group.id == from_id);
|
|
|
+ let to_index = configuration.groups.iter().position(|group| group.id == to_id);
|
|
|
if let (Some(from), Some(to)) = (from_index, to_index) {
|
|
|
configuration.groups.swap(from, to);
|
|
|
}
|
|
@@ -163,10 +212,10 @@ where
|
|
|
fn mut_configuration_group(
|
|
|
&mut self,
|
|
|
group_id: &str,
|
|
|
- mut_groups_fn: impl Fn(&mut GroupRecordRevision),
|
|
|
+ mut_groups_fn: impl Fn(&mut GroupRevision),
|
|
|
) -> FlowyResult<()> {
|
|
|
self.mut_configuration(|configuration| {
|
|
|
- match configuration.groups.iter_mut().find(|group| group.group_id == group_id) {
|
|
|
+ match configuration.groups.iter_mut().find(|group| group.id == group_id) {
|
|
|
None => false,
|
|
|
Some(group_rev) => {
|
|
|
mut_groups_fn(group_rev);
|
|
@@ -189,33 +238,82 @@ where
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-fn merge_groups(old_group_revs: &[GroupRecordRevision], groups: Vec<Group>) -> (Vec<GroupRecordRevision>, Vec<Group>) {
|
|
|
- if old_group_revs.is_empty() {
|
|
|
- let new_groups = groups
|
|
|
- .iter()
|
|
|
- .map(|group| GroupRecordRevision::new(group.id.clone()))
|
|
|
- .collect();
|
|
|
- return (new_groups, groups);
|
|
|
+fn merge_groups(old_groups: &[GroupRevision], groups: Vec<Group>) -> MergeGroupResult {
|
|
|
+ let mut merge_result = MergeGroupResult::new();
|
|
|
+ if old_groups.is_empty() {
|
|
|
+ merge_result.groups = groups;
|
|
|
+ return merge_result;
|
|
|
}
|
|
|
|
|
|
+ // group_map is a helper map is used to filter out the new groups.
|
|
|
let mut group_map: IndexMap<String, Group> = IndexMap::new();
|
|
|
groups.into_iter().for_each(|group| {
|
|
|
group_map.insert(group.id.clone(), group);
|
|
|
});
|
|
|
|
|
|
- // Inert
|
|
|
- let mut sorted_groups: Vec<Group> = vec![];
|
|
|
- for group_rev in old_group_revs {
|
|
|
- if let Some(group) = group_map.remove(&group_rev.group_id) {
|
|
|
- sorted_groups.push(group);
|
|
|
+ // The group is ordered in old groups. Add them before adding the new groups
|
|
|
+ for group_rev in old_groups {
|
|
|
+ if let Some(group) = group_map.remove(&group_rev.id) {
|
|
|
+ if group.name == group_rev.name {
|
|
|
+ merge_result.add_group(group);
|
|
|
+ } else {
|
|
|
+ merge_result.add_updated_group(group);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Find out the new groups
|
|
|
+ let new_groups = group_map.into_values().collect::<Vec<Group>>();
|
|
|
+ for (index, group) in new_groups.into_iter().enumerate() {
|
|
|
+ merge_result.add_insert_group(index, group);
|
|
|
+ }
|
|
|
+ merge_result
|
|
|
+}
|
|
|
+
|
|
|
+struct MergeGroupResult {
|
|
|
+ groups: Vec<Group>,
|
|
|
+ inserted_groups: Vec<InsertedGroupPB>,
|
|
|
+ updated_groups: Vec<Group>,
|
|
|
+}
|
|
|
+
|
|
|
+impl MergeGroupResult {
|
|
|
+ fn new() -> Self {
|
|
|
+ Self {
|
|
|
+ groups: vec![],
|
|
|
+ inserted_groups: vec![],
|
|
|
+ updated_groups: vec![],
|
|
|
}
|
|
|
}
|
|
|
- sorted_groups.extend(group_map.into_values().collect::<Vec<Group>>());
|
|
|
- let new_group_revs = sorted_groups
|
|
|
- .iter()
|
|
|
- .map(|group| GroupRecordRevision::new(group.id.clone()))
|
|
|
- .collect::<Vec<GroupRecordRevision>>();
|
|
|
|
|
|
- tracing::trace!("group revs: {}, groups: {}", new_group_revs.len(), sorted_groups.len());
|
|
|
- (new_group_revs, sorted_groups)
|
|
|
+ fn add_updated_group(&mut self, group: Group) {
|
|
|
+ self.groups.push(group.clone());
|
|
|
+ self.updated_groups.push(group);
|
|
|
+ }
|
|
|
+
|
|
|
+ fn add_group(&mut self, group: Group) {
|
|
|
+ self.groups.push(group.clone());
|
|
|
+ }
|
|
|
+
|
|
|
+ fn add_insert_group(&mut self, index: usize, group: Group) {
|
|
|
+ self.groups.push(group.clone());
|
|
|
+ let inserted_group = InsertedGroupPB {
|
|
|
+ group: GroupPB::from(group),
|
|
|
+ index: index as i32,
|
|
|
+ };
|
|
|
+ self.inserted_groups.push(inserted_group);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+fn make_group_view_changeset(
|
|
|
+ view_id: String,
|
|
|
+ inserted_groups: Vec<InsertedGroupPB>,
|
|
|
+ updated_group: Vec<Group>,
|
|
|
+) -> GroupViewChangesetPB {
|
|
|
+ let changeset = GroupViewChangesetPB {
|
|
|
+ view_id,
|
|
|
+ inserted_groups,
|
|
|
+ deleted_groups: vec![],
|
|
|
+ update_groups: updated_group.into_iter().map(GroupPB::from).collect(),
|
|
|
+ };
|
|
|
+ changeset
|
|
|
}
|