Feat/read cell data for field (#1695)

appflowy · vedon · web-flow · commit fe4e28b57623 · 2023-01-12T07:56:46.000+08:00
* chore: read cells for field

* feat: enable read cells for specific field

* ci: fix tests

Co-authored-by: vedon &lt;vedon.fu@gmail.com&gt;
Co-authored-by: nathan &lt;nathan@appflowy.io&gt;
diff --git a/frontend/app_flowy/pubspec.lock b/frontend/app_flowy/pubspec.lock
@@ -42,7 +42,7 @@ packages:
       path: "packages/appflowy_editor"
       relative: true
     source: path
-    version: "0.0.7"
+    version: "0.0.9"
   appflowy_editor_plugins:
     dependency: "direct main"
     description:
diff --git a/frontend/app_flowy/test/bloc_test/home_test/view_bloc_test.dart b/frontend/app_flowy/test/bloc_test/home_test/view_bloc_test.dart
@@ -1,67 +1,73 @@
 import 'package:app_flowy/plugins/document/document.dart';
 import 'package:app_flowy/workspace/application/app/app_bloc.dart';
 import 'package:app_flowy/workspace/application/view/view_bloc.dart';
-import 'package:bloc_test/bloc_test.dart';
 import 'package:flutter_test/flutter_test.dart';
 
 import '../../util.dart';
 
 void main() {
-  late AppFlowyUnitTest test;
+  late AppFlowyUnitTest testContext;
   setUpAll(() async {
-    test = await AppFlowyUnitTest.ensureInitialized();
+    testContext = await AppFlowyUnitTest.ensureInitialized();
   });
 
-  group('$ViewBloc', () {
-    late AppBloc appBloc;
+  test('rename view test', () async {
+    final app = await testContext.createTestApp();
+    final appBloc = AppBloc(app: app)..add(const AppEvent.initial());
+    appBloc.add(AppEvent.createView(
+      "Test document",
+      DocumentPluginBuilder(),
+    ));
+    await blocResponseFuture();
 
-    setUpAll(() async {
-      final app = await test.createTestApp();
-      appBloc = AppBloc(app: app)..add(const AppEvent.initial());
-      appBloc.add(AppEvent.createView(
-        "Test document",
-        DocumentPluginBuilder(),
-      ));
-      await blocResponseFuture();
-    });
+    final viewBloc = ViewBloc(view: appBloc.state.views.first)
+      ..add(const ViewEvent.initial());
+    viewBloc.add(const ViewEvent.rename('Hello world'));
+    await blocResponseFuture();
 
-    blocTest<ViewBloc, ViewState>(
-      "rename view",
-      build: () => ViewBloc(view: appBloc.state.views.first)
-        ..add(const ViewEvent.initial()),
-      act: (bloc) {
-        bloc.add(const ViewEvent.rename('Hello world'));
-      },
-      wait: blocResponseDuration(),
-      verify: (bloc) {
-        assert(bloc.state.view.name == "Hello world");
-      },
-    );
+    assert(viewBloc.state.view.name == "Hello world");
+  });
+
+  test('duplicate view test', () async {
+    final app = await testContext.createTestApp();
+    final appBloc = AppBloc(app: app)..add(const AppEvent.initial());
+    await blocResponseFuture();
+
+    appBloc.add(AppEvent.createView(
+      "Test document",
+      DocumentPluginBuilder(),
+    ));
+    await blocResponseFuture();
+
+    final viewBloc = ViewBloc(view: appBloc.state.views.first)
+      ..add(const ViewEvent.initial());
+    await blocResponseFuture();
+
+    viewBloc.add(const ViewEvent.duplicate());
+    await blocResponseFuture();
+
+    assert(appBloc.state.views.length == 2);
+  });
+
+  test('delete view test', () async {
+    final app = await testContext.createTestApp();
+    final appBloc = AppBloc(app: app)..add(const AppEvent.initial());
+    await blocResponseFuture();
+
+    appBloc.add(AppEvent.createView(
+      "Test document",
+      DocumentPluginBuilder(),
+    ));
+    await blocResponseFuture();
+    assert(appBloc.state.views.length == 1);
+
+    final viewBloc = ViewBloc(view: appBloc.state.views.first)
+      ..add(const ViewEvent.initial());
+    await blocResponseFuture();
 
-    blocTest<ViewBloc, ViewState>(
-      "duplicate view",
-      build: () => ViewBloc(view: appBloc.state.views.first)
-        ..add(const ViewEvent.initial()),
-      act: (bloc) {
-        bloc.add(const ViewEvent.duplicate());
-      },
-      wait: blocResponseDuration(),
-      verify: (bloc) {
-        assert(appBloc.state.views.length == 2);
-      },
-    );
+    viewBloc.add(const ViewEvent.delete());
+    await blocResponseFuture();
 
-    blocTest<ViewBloc, ViewState>(
-      "delete view",
-      build: () => ViewBloc(view: appBloc.state.views.first)
-        ..add(const ViewEvent.initial()),
-      act: (bloc) {
-        bloc.add(const ViewEvent.delete());
-      },
-      wait: blocResponseDuration(),
-      verify: (bloc) {
-        assert(appBloc.state.views.length == 1);
-      },
-    );
+    assert(appBloc.state.views.isEmpty);
   });
 }
diff --git a/frontend/rust-lib/flowy-grid/src/services/block_manager.rs b/frontend/rust-lib/flowy-grid/src/services/block_manager.rs
@@ -228,6 +228,7 @@ impl GridBlockManager {
         editor.get_row_rev(row_id).await
     }
 
+    #[allow(dead_code)]
     pub async fn get_row_revs(&self) -> FlowyResult<Vec<Arc<RowRevision>>> {
         let mut row_revs = vec![];
         for iter in self.block_editors.iter() {
diff --git a/frontend/rust-lib/flowy-grid/src/services/grid_editor.rs b/frontend/rust-lib/flowy-grid/src/services/grid_editor.rs
@@ -9,7 +9,7 @@ use crate::services::cell::{
 };
 use crate::services::field::{
     default_type_option_builder_from_type, transform_type_option, type_option_builder_from_bytes, FieldBuilder,
-    RowSingleCellData, TypeOptionCellExt,
+    RowSingleCellData,
 };
 
 use crate::services::filter::FilterType;
@@ -76,6 +76,7 @@ impl GridRevisionEditor {
             pad: grid_pad.clone(),
             block_manager: block_manager.clone(),
             task_scheduler,
+            cell_data_cache: cell_data_cache.clone(),
         });
 
         // View manager
@@ -496,31 +497,10 @@ impl GridRevisionEditor {
         }
     }
 
-    pub async fn get_cell_data_for_field(&self, field_id: &str) -> FlowyResult<Vec<RowSingleCellData>> {
-        let row_revs = self.block_manager.get_row_revs().await?;
-        let field_rev = self.get_field_rev(field_id).await.unwrap();
-        let field_type: FieldType = field_rev.ty.into();
-        let mut cells = vec![];
-        if let Some(handler) =
-            TypeOptionCellExt::new_with_cell_data_cache(&field_rev, Some(self.cell_data_cache.clone()))
-                .get_type_option_cell_data_handler(&field_type)
-        {
-            for row_rev in row_revs {
-                if let Some(cell_rev) = row_rev.cells.get(field_id) {
-                    if let Ok(type_cell_data) = TypeCellData::try_from(cell_rev) {
-                        if let Ok(cell_data) = handler.get_cell_data(type_cell_data.cell_str, &field_type, &field_rev) {
-                            cells.push(RowSingleCellData {
-                                row_id: row_rev.id.clone(),
-                                field_id: field_rev.id.clone(),
-                                field_type: field_type.clone(),
-                                cell_data,
-                            })
-                        }
-                    }
-                }
-            }
-        }
-        Ok(cells)
+    /// Returns the list of cells corresponding to the given field.
+    pub async fn get_cells_for_field(&self, view_id: &str, field_id: &str) -> FlowyResult<Vec<RowSingleCellData>> {
+        let view_editor = self.view_manager.get_view_editor(view_id).await?;
+        view_editor.get_cells_for_field(field_id).await
     }
 
     #[tracing::instrument(level = "trace", skip_all, err)]
diff --git a/frontend/rust-lib/flowy-grid/src/services/grid_editor_trait_impl.rs b/frontend/rust-lib/flowy-grid/src/services/grid_editor_trait_impl.rs
@@ -1,6 +1,10 @@
+use crate::entities::FieldType;
 use crate::services::block_manager::GridBlockManager;
+use crate::services::cell::AtomicCellDataCache;
+use crate::services::field::{TypeOptionCellDataHandler, TypeOptionCellExt};
 use crate::services::row::GridBlockRowRevision;
 use crate::services::view_editor::GridViewEditorDelegate;
+
 use flowy_sync::client_grid::GridRevisionPad;
 use flowy_task::TaskDispatcher;
 use grid_rev_model::{FieldRevision, RowRevision};
@@ -12,6 +16,7 @@ pub(crate) struct GridViewEditorDelegateImpl {
     pub(crate) pad: Arc<RwLock<GridRevisionPad>>,
     pub(crate) block_manager: Arc<GridBlockManager>,
     pub(crate) task_scheduler: Arc<RwLock<TaskDispatcher>>,
+    pub(crate) cell_data_cache: AtomicCellDataCache,
 }
 
 impl GridViewEditorDelegate for GridViewEditorDelegateImpl {
@@ -27,7 +32,6 @@ impl GridViewEditorDelegate for GridViewEditorDelegateImpl {
             }
         })
     }
-
     fn get_field_rev(&self, field_id: &str) -> Fut<Option<Arc<FieldRevision>>> {
         let pad = self.pad.clone();
         let field_id = field_id.to_owned();
@@ -63,6 +67,10 @@ impl GridViewEditorDelegate for GridViewEditorDelegateImpl {
         })
     }
 
+    // /// Returns the list of cells corresponding to the given field.
+    // pub async fn get_cells_for_field(&self, field_id: &str) -> FlowyResult<Vec<RowSingleCellData>> {
+    // }
+
     fn get_blocks(&self) -> Fut<Vec<GridBlockRowRevision>> {
         let block_manager = self.block_manager.clone();
         to_fut(async move { block_manager.get_blocks(None).await.unwrap_or_default() })
@@ -71,4 +79,13 @@ impl GridViewEditorDelegate for GridViewEditorDelegateImpl {
     fn get_task_scheduler(&self) -> Arc<RwLock<TaskDispatcher>> {
         self.task_scheduler.clone()
     }
+
+    fn get_type_option_cell_handler(
+        &self,
+        field_rev: &FieldRevision,
+        field_type: &FieldType,
+    ) -> Option<Box<dyn TypeOptionCellDataHandler>> {
+        TypeOptionCellExt::new_with_cell_data_cache(field_rev, Some(self.cell_data_cache.clone()))
+            .get_type_option_cell_data_handler(field_type)
+    }
 }
diff --git a/frontend/rust-lib/flowy-grid/src/services/group/configuration.rs b/frontend/rust-lib/flowy-grid/src/services/group/configuration.rs
@@ -1,4 +1,5 @@
 use crate::entities::{GroupPB, GroupViewChangesetPB};
+use crate::services::field::RowSingleCellData;
 use crate::services::group::{default_group_configuration, GeneratedGroupContext, Group};
 use flowy_error::{FlowyError, FlowyResult};
 use grid_rev_model::{
@@ -13,6 +14,7 @@ use std::sync::Arc;
 
 pub trait GroupConfigurationReader: Send + Sync + 'static {
     fn get_configuration(&self) -> Fut<Option<Arc<GroupConfigurationRevision>>>;
+    fn get_configuration_cells(&self, field_id: &str) -> Fut<FlowyResult<Vec<RowSingleCellData>>>;
 }
 
 pub trait GroupConfigurationWriter: Send + Sync + 'static {
@@ -53,6 +55,11 @@ pub struct GroupContext<C> {
     /// Cache all the groups
     groups_map: IndexMap<String, Group>,
 
+    /// A reader that implement the [GroupConfigurationReader] trait
+    ///
+    #[allow(dead_code)]
+    reader: Arc<dyn GroupConfigurationReader>,
+
     /// A writer that implement the [GroupConfigurationWriter] trait is used to save the
     /// configuration to disk  
     ///
@@ -85,6 +92,7 @@ where
             view_id,
             field_rev,
             groups_map: IndexMap::new(),
+            reader,
             writer,
             configuration,
             configuration_phantom: PhantomData,
diff --git a/frontend/rust-lib/flowy-grid/src/services/view_editor/editor.rs b/frontend/rust-lib/flowy-grid/src/services/view_editor/editor.rs
diff --git a/frontend/rust-lib/flowy-grid/src/services/view_editor/trait_impl.rs b/frontend/rust-lib/flowy-grid/src/services/view_editor/trait_impl.rs
diff --git a/frontend/rust-lib/flowy-grid/tests/grid/cell_test/test.rs b/frontend/rust-lib/flowy-grid/tests/grid/cell_test/test.rs

Original file line number	Diff line number	Diff line change
`@@ -228,6 +228,7 @@ impl GridBlockManager {`
`228`	`228`	`editor.get_row_rev(row_id).await`
`229`	`229`	`}`
`230`	`230`
	`231`	`+ #[allow(dead_code)]`
`231`	`232`	`pub async fn get_row_revs(&self) -> FlowyResult<Vec<Arc<RowRevision>>> {`
`232`	`233`	`let mut row_revs = vec![];`
`233`	`234`	`for iter in self.block_editors.iter() {`