Mirrored_Repos/AppFlowy
1
0
Fork 0
mirror of https://github.com/AppFlowy-IO/AppFlowy.git synced 2024-08-30 18:12:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: fetch block data

Browse Source
This commit is contained in:
appflowy
2022-06-24 15:23:39 +08:00
parent a08590bcba
commit 0f868f48f3
19 changed files with 245 additions and 164 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
frontend/rust-lib/flowy-grid/src/event_handler.rs
View File

@ -48,12 +48,7 @@ pub(crate) async fn get_grid_blocks_handler(
) -> DataResult<RepeatedGridBlock, FlowyError> {
let params: QueryGridBlocksParams = data.into_inner().try_into()?;
let editor = manager.get_grid_editor(&params.grid_id)?;
let block_ids = params
.block_orders
.into_iter()
.map(|block| block.block_id)
.collect::<Vec<String>>();
let repeated_grid_block = editor.get_blocks(Some(block_ids)).await?;
let repeated_grid_block = editor.get_blocks(Some(params.block_ids)).await?;
data_result(repeated_grid_block)
}
@ -220,13 +215,13 @@ async fn get_type_option_data(field_rev: &FieldRevision, field_type: &FieldType)
pub(crate) async fn get_row_handler(
data: Data<RowIdentifierPayload>,
manager: AppData<Arc<GridManager>>,
) -> DataResult<Row, FlowyError> {
) -> DataResult<OptionalRow, FlowyError> {
let params: RowIdentifier = data.into_inner().try_into()?;
let editor = manager.get_grid_editor(&params.grid_id)?;
match editor.get_row(&params.row_id).await? {
None => Err(FlowyError::record_not_found().context("Can not find the row")),
Some(row) => data_result(row),
}
let row = OptionalRow {
row: editor.get_row(&params.row_id).await?,
};
data_result(row)
}
#[tracing::instrument(level = "debug", skip(data, manager), err)]

2
frontend/rust-lib/flowy-grid/src/event_map.rs
View File

@ -99,7 +99,7 @@ pub enum GridEvent {
#[event(input = "CreateRowPayload", output = "Row")]
CreateRow = 50,
#[event(input = "RowIdentifierPayload", output = "Row")]
#[event(input = "RowIdentifierPayload", output = "OptionalRow")]
GetRow = 51,
#[event(input = "RowIdentifierPayload")]

26
frontend/rust-lib/flowy-grid/src/services/block_manager.rs
View File

@ -2,7 +2,7 @@ use crate::dart_notification::{send_dart_notification, GridNotification};
use crate::manager::GridUser;
use crate::services::block_revision_editor::GridBlockRevisionEditor;
use crate::services::persistence::block_index::BlockIndexCache;
use crate::services::row::{group_row_orders, GridBlockSnapshot};
use crate::services::row::{block_from_row_orders, GridBlockSnapshot};
use dashmap::DashMap;
use flowy_error::FlowyResult;
use flowy_grid_data_model::entities::{
@ -77,7 +77,7 @@ impl GridBlockManager {
index_row_order.index = row_index;
let _ = self
.notify_did_update_block(GridRowsChangeset::insert(block_id, vec![index_row_order]))
.notify_did_update_block(block_id, GridRowsChangeset::insert(block_id, vec![index_row_order]))
.await?;
Ok(row_count)
}
@ -102,7 +102,7 @@ impl GridBlockManager {
changesets.push(GridBlockRevisionChangeset::from_row_count(&block_id, row_count));
let _ = self
.notify_did_update_block(GridRowsChangeset::insert(&block_id, inserted_row_orders))
.notify_did_update_block(&block_id, GridRowsChangeset::insert(&block_id, inserted_row_orders))
.await?;
}
@ -121,7 +121,9 @@ impl GridBlockManager {
if let Some(row) = row_builder(row_rev.clone()) {
let row_order = UpdatedRowOrder::new(&row_rev, row);
let block_order_changeset = GridRowsChangeset::update(&editor.block_id, vec![row_order]);
let _ = self.notify_did_update_block(block_order_changeset).await?;
let _ = self
.notify_did_update_block(&editor.block_id, block_order_changeset)
.await?;
}
}
}
@ -137,7 +139,7 @@ impl GridBlockManager {
Some(row_order) => {
let _ = editor.delete_rows(vec![Cow::Borrowed(&row_id)]).await?;
let _ = self
.notify_did_update_block(GridRowsChangeset::delete(&block_id, vec![row_order]))
.notify_did_update_block(&block_id, GridRowsChangeset::delete(&block_id, vec![row_order]))
.await?;
}
}
@ -147,15 +149,15 @@ impl GridBlockManager {
pub(crate) async fn delete_rows(&self, row_orders: Vec<RowOrder>) -> FlowyResult<Vec<GridBlockRevisionChangeset>> {
let mut changesets = vec![];
for block_order in group_row_orders(row_orders) {
let editor = self.get_editor(&block_order.block_id).await?;
for block_order in block_from_row_orders(row_orders) {
let editor = self.get_editor(&block_order.id).await?;
let row_ids = block_order
.row_orders
.into_iter()
.map(|row_order| Cow::Owned(row_order.row_id))
.collect::<Vec<Cow<String>>>();
let row_count = editor.delete_rows(row_ids).await?;
let changeset = GridBlockRevisionChangeset::from_row_count(&block_order.block_id, row_count);
let changeset = GridBlockRevisionChangeset::from_row_count(&block_order.id, row_count);
changesets.push(changeset);
}
@ -181,7 +183,9 @@ impl GridBlockManager {
updated_rows: vec![],
};
let _ = self.notify_did_update_block(notified_changeset).await?;
let _ = self
.notify_did_update_block(&editor.block_id, notified_changeset)
.await?;
}
}
@ -241,8 +245,8 @@ impl GridBlockManager {
Ok(block_cell_revs)
}
async fn notify_did_update_block(&self, changeset: GridRowsChangeset) -> FlowyResult<()> {
send_dart_notification(&self.grid_id, GridNotification::DidUpdateGridRow)
async fn notify_did_update_block(&self, block_id: &str, changeset: GridRowsChangeset) -> FlowyResult<()> {
send_dart_notification(block_id, GridNotification::DidUpdateGridRow)
.payload(changeset)
.send();
Ok(())

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

@ -424,8 +424,8 @@ impl GridRevisionEditor {
let mut block_orders = vec![];
for block_order in pad_read_guard.get_block_revs() {
let row_orders = self.block_manager.get_row_orders(&block_order.block_id).await?;
let block_order = GridBlockOrder {
block_id: block_order.block_id,
let block_order = GridBlock {
id: block_order.block_id,
row_orders,
};
block_orders.push(block_order);
@ -434,7 +434,7 @@ impl GridRevisionEditor {
Ok(Grid {
id: self.grid_id.clone(),
field_orders,
block_orders,
blocks: block_orders,
})
}

8
frontend/rust-lib/flowy-grid/src/services/row/row_loader.rs
View File

@ -1,6 +1,6 @@
use crate::services::row::decode_cell_data_from_type_option_cell_data;
use flowy_error::FlowyResult;
use flowy_grid_data_model::entities::{Cell, GridBlock, GridBlockOrder, RepeatedGridBlock, Row, RowOrder};
use flowy_grid_data_model::entities::{Cell, GridBlock, RepeatedGridBlock, Row, RowOrder};
use flowy_grid_data_model::revision::{CellRevision, FieldRevision, RowRevision};
use std::collections::HashMap;
use std::sync::Arc;
@ -10,13 +10,13 @@ pub struct GridBlockSnapshot {
pub row_revs: Vec<Arc<RowRevision>>,
}
pub(crate) fn group_row_orders(row_orders: Vec<RowOrder>) -> Vec<GridBlockOrder> {
let mut map: HashMap<String, GridBlockOrder> = HashMap::new();
pub(crate) fn block_from_row_orders(row_orders: Vec<RowOrder>) -> Vec<GridBlock> {
let mut map: HashMap<String, GridBlock> = HashMap::new();
row_orders.into_iter().for_each(|row_order| {
// Memory Optimization: escape clone block_id
let block_id = row_order.block_id.clone();
map.entry(block_id)
.or_insert_with(|| GridBlockOrder::new(&row_order.block_id))
.or_insert_with(|| GridBlock::new(&row_order.block_id, vec![]))
.row_orders
.push(row_order);
});

8
frontend/rust-lib/flowy-grid/tests/grid/filter_test.rs
View File

@ -6,7 +6,7 @@ use flowy_grid_data_model::entities::{
};
#[tokio::test]
async fn grid_setting_create_text_filter_test() {
async fn grid_filter_create_test() {
let test = GridEditorTest::new().await;
let field_rev = test.text_field();
let payload = CreateGridFilterPayload::new(field_rev, TextFilterCondition::TextIsEmpty, Some("abc".to_owned()));
@ -16,7 +16,7 @@ async fn grid_setting_create_text_filter_test() {
#[tokio::test]
#[should_panic]
async fn grid_setting_create_text_filter_panic_test() {
async fn grid_filter_invalid_condition_panic_test() {
let test = GridEditorTest::new().await;
let field_rev = test.text_field();
@ -27,7 +27,7 @@ async fn grid_setting_create_text_filter_panic_test() {
}
#[tokio::test]
async fn grid_setting_delete_text_filter_test() {
async fn grid_filter_delete_test() {
let mut test = GridEditorTest::new().await;
let field_rev = test.text_field();
let payload = CreateGridFilterPayload::new(field_rev, 100, Some("abc".to_owned()));
@ -43,4 +43,4 @@ async fn grid_setting_delete_text_filter_test() {
}
#[tokio::test]
async fn grid_setting_sort_test() {}
async fn grid_filter_get_rows_test() {}

45
frontend/rust-lib/flowy-grid/tests/grid/row_util.rs
View File

@ -1,4 +1,5 @@
use crate::grid::script::GridEditorTest;
use flowy_grid::services::field::DateCellContentChangeset;
use flowy_grid::services::row::{CreateRowRevisionBuilder, CreateRowRevisionPayload};
use flowy_grid_data_model::entities::FieldType;
use flowy_grid_data_model::revision::FieldRevision;
@ -17,13 +18,47 @@ impl<'a> GridRowTestBuilder<'a> {
Self { test, inner_builder }
}
pub fn update_text_cell(&mut self) -> Self {
let text_field = self
.test
pub fn update_text_cell(mut self, data: String) -> Self {
let text_field = self.field_rev_with_type(&FieldType::DateTime);
self.inner_builder.add_cell(&text_field.id, data).unwrap();
self
}
pub fn update_number_cell(mut self, data: String) -> Self {
let number_field = self.field_rev_with_type(&FieldType::DateTime);
self.inner_builder.add_cell(&number_field.id, data).unwrap();
self
}
pub fn update_date_cell(mut self, value: i64) -> Self {
let value = serde_json::to_string(&DateCellContentChangeset {
date: Some(value.to_string()),
time: None,
})
.unwrap();
let date_field = self.field_rev_with_type(&FieldType::DateTime);
self.inner_builder.add_cell(&date_field.id, value).unwrap();
self
}
pub fn update_checkbox_cell(mut self, data: bool) -> Self {
let number_field = self.field_rev_with_type(&FieldType::Checkbox);
self.inner_builder.add_cell(&number_field.id, data.to_string()).unwrap();
self
}
pub fn update_url_cell(mut self, data: String) -> Self {
let number_field = self.field_rev_with_type(&FieldType::Checkbox);
self.inner_builder.add_cell(&number_field.id, data).unwrap();
self
}
pub fn field_rev_with_type(&self, field_type: &FieldType) -> &FieldRevision {
self.test
.field_revs
.iter()
.find(|field_rev| field_rev.field_type == FieldType::RichText);
// self.inner_builder
.find(|field_rev| field_rev.field_type == &field_type)
.unwrap()
}
pub fn build(self) -> CreateRowRevisionPayload {