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: Merge branch 'main' into develop
nathanad99998d339b
diff --cc frontend/appflowy_flutter/lib/plugins/database_view/calendar/application/calendar_bloc.dartindex 8f0be57af8,b9ebb2c603..ececc2b392--- a/frontend/appflowy_flutter/lib/plugins/database_view/calendar/application/calendar_bloc.dart+++ b/frontend/appflowy_flutter/lib/plugins/database_view/calendar/application/calendar_bloc.dart@@@ -47,17 -46,28 +47,28 @@@ class CalendarBloc extends Bloc<Calendaemit(state.copyWith(database: Some(database)));},didLoadAllEvents: (events) {- emit(state.copyWith(initialEvents: events, allEvents: events));+ final calenderEvents = _calendarEventDataFromEventPBs(events);+ emit(+ state.copyWith(+ initialEvents: calenderEvents,+ allEvents: calenderEvents,+ ),+ );},- didReceiveNewLayoutField: (CalendarLayoutSettingsPB layoutSettings) {+ didReceiveNewLayoutField: (CalendarLayoutSettingPB layoutSettings) {_loadAllEvents();emit(state.copyWith(settings: Some(layoutSettings)));},createEvent: (DateTime date, String title) async {await _createEvent(date, title);},+ didCreateEvent: (CalendarEventData<CalendarDayEvent> event) {+ emit(+ state.copyWith(editEvent: event),+ );+ },updateCalendarLayoutSetting:- (CalendarLayoutSettingsPB layoutSetting) async {+ (CalendarLayoutSettingPB layoutSetting) async {await _updateCalendarLayoutSetting(layoutSetting);},didUpdateEvent: (CalendarEventData<CalendarDayEvent> eventData) {@@@ -74,19 -84,10 +85,10 @@@),);},- didDeleteEvents: (List<String> deletedRowIds) {+ didDeleteEvents: (List<RowId> deletedRowIds) {var events = [...state.allEvents];events.retainWhere(- (element) => !deletedRowIds.contains(element.event!.cellId.rowId),+ (element) => !deletedRowIds.contains(element.event!.eventId),);emit(state.copyWith(@@@ -140,10 -155,10 +156,10 @@@return state.settings.fold(() => null,(settings) async {- final dateField = _getCalendarFieldInfo(settings.layoutFieldId);+ final dateField = _getCalendarFieldInfo(settings.fieldId);final titleField = _getTitleFieldInfo();if (dateField != null && titleField != null) {- final result = await _databaseController.createRow(+ final newRow = await _databaseController.createRow(withCells: (builder) {builder.insertDate(dateField, date);builder.insertText(titleField, title);@@@ -323,8 -367,13 +368,13 @@@ class CalendarEvent with _$CalendarEvenCalendarEventData<CalendarDayEvent> event,) = _DidReceiveNewEvent;+ // Called when receive a new event+ const factory CalendarEvent.didReceiveEvent(+ CalendarEventData<CalendarDayEvent> event,+ ) = _DidReceiveEvent;+// Called when deleting events- const factory CalendarEvent.didDeleteEvents(List<String> rowIds) =+ const factory CalendarEvent.didDeleteEvents(List<RowId> rowIds) =_DidDeleteEvents;// Called when creating a new event@@@ -348,12 -397,13 +398,14 @@@class CalendarState with _$CalendarState {const factory CalendarState({required Option<DatabasePB> database,+ // events by row idrequired Events allEvents,required Events initialEvents,+ CalendarEventData<CalendarDayEvent>? editEvent,CalendarEventData<CalendarDayEvent>? newEvent,- required List<RowId> deleteEventIds,+ CalendarEventData<CalendarDayEvent>? updateEvent,+ required List<String> deleteEventIds,- required Option<CalendarLayoutSettingsPB> settings,+ required Option<CalendarLayoutSettingPB> settings,required DatabaseLoadingState loadingState,required Option<FlowyError> noneOrError,}) = _CalendarState;diff --cc frontend/appflowy_flutter/lib/plugins/database_view/calendar/presentation/calendar_day.dartindex ae137a40cb,3da4979752..2ce90e8abb--- a/frontend/appflowy_flutter/lib/plugins/database_view/calendar/presentation/calendar_day.dart+++ b/frontend/appflowy_flutter/lib/plugins/database_view/calendar/presentation/calendar_day.dart@@@ -1,10 -1,13 +1,13 @@@import 'package:appflowy/plugins/database_view/application/row/row_cache.dart';import 'package:appflowy/plugins/database_view/application/row/row_data_controller.dart';+ import 'package:appflowy/plugins/database_view/widgets/card/card.dart';import 'package:appflowy/plugins/database_view/widgets/card/card_cell_builder.dart';- import 'package:appflowy/plugins/database_view/widgets/card/cells/text_card_cell.dart';+ import 'package:appflowy/plugins/database_view/widgets/card/cells/card_cell.dart';+ import 'package:appflowy/plugins/database_view/widgets/card/cells/number_card_cell.dart';+ import 'package:appflowy/plugins/database_view/widgets/card/cells/url_card_cell.dart';import 'package:appflowy/plugins/database_view/widgets/row/cell_builder.dart';import 'package:appflowy/plugins/database_view/widgets/row/row_detail.dart';-import 'package:appflowy_backend/protobuf/flowy-database/field_entities.pbenum.dart';+import 'package:appflowy_backend/protobuf/flowy-database2/field_entities.pbenum.dart';import 'package:easy_localization/easy_localization.dart';import 'package:flowy_infra/image.dart';import 'package:flowy_infra/size.dart';diff --cc frontend/appflowy_flutter/lib/plugins/database_view/grid/presentation/widgets/header/field_type_list.dartindex b6c4be24e5,a9459ab5bb..81bc715015--- a/frontend/appflowy_flutter/lib/plugins/database_view/grid/presentation/widgets/header/field_type_list.dart+++ b/frontend/appflowy_flutter/lib/plugins/database_view/grid/presentation/widgets/header/field_type_list.dart@@@ -1,8 -1,7 +1,7 @@@import 'package:appflowy_popover/appflowy_popover.dart';import 'package:flowy_infra/image.dart';- import 'package:flowy_infra/theme_extension.dart';import 'package:flowy_infra_ui/flowy_infra_ui.dart';-import 'package:appflowy_backend/protobuf/flowy-database/field_entities.pb.dart';+import 'package:appflowy_backend/protobuf/flowy-database2/field_entities.pb.dart';import 'package:flutter/material.dart';import '../../layout/sizes.dart';import 'field_type_extension.dart';diff --cc frontend/appflowy_flutter/lib/plugins/database_view/grid/presentation/widgets/header/field_type_option_editor.dartindex b52d62aa67,5635955d73..c28595bb02--- a/frontend/appflowy_flutter/lib/plugins/database_view/grid/presentation/widgets/header/field_type_option_editor.dart+++ b/frontend/appflowy_flutter/lib/plugins/database_view/grid/presentation/widgets/header/field_type_option_editor.dart@@@ -4,10 -4,9 +4,9 @@@ import 'package:appflowy/plugins/databaimport 'package:appflowy_popover/appflowy_popover.dart';import 'package:dartz/dartz.dart' show Either;import 'package:flowy_infra/image.dart';- import 'package:flowy_infra/theme_extension.dart';import 'package:flowy_infra_ui/flowy_infra_ui.dart';import 'package:appflowy_backend/protobuf/flowy-error/errors.pb.dart';-import 'package:appflowy_backend/protobuf/flowy-database/field_entities.pb.dart';+import 'package:appflowy_backend/protobuf/flowy-database2/field_entities.pb.dart';import 'package:flutter/material.dart';import 'package:flutter_bloc/flutter_bloc.dart';import '../../layout/sizes.dart';diff --cc frontend/appflowy_flutter/lib/plugins/database_view/grid/presentation/widgets/header/type_option/date.dartindex dadf388203,e755a00381..0d24db12a7--- a/frontend/appflowy_flutter/lib/plugins/database_view/grid/presentation/widgets/header/type_option/date.dart+++ b/frontend/appflowy_flutter/lib/plugins/database_view/grid/presentation/widgets/header/type_option/date.dart@@@ -1,8 -1,5 +1,6 @@@import 'package:appflowy/plugins/database_view/application/field/type_option/date_bloc.dart';import 'package:appflowy/plugins/database_view/application/field/type_option/type_option_context.dart';- import 'package:appflowy/workspace/presentation/widgets/toggle/toggle.dart';- import 'package:appflowy/workspace/presentation/widgets/toggle/toggle_style.dart';+import 'package:appflowy_backend/protobuf/flowy-database2/date_entities.pbenum.dart';import 'package:easy_localization/easy_localization.dart' hide DateFormat;import 'package:appflowy/generated/locale_keys.g.dart';import 'package:flowy_infra/image.dart';@@@ -191,47 -182,9 +188,9 @@@ class TimeFormatButton extends Stateles}}- class _IncludeTimeButton extends StatelessWidget {- const _IncludeTimeButton({Key? key}) : super(key: key);-- @override- Widget build(BuildContext context) {- return BlocSelector<DateTypeOptionBloc, DateTypeOptionState, bool>(- selector: (state) => state.typeOption.includeTime,- builder: (context, includeTime) {- return Padding(- padding: const EdgeInsets.symmetric(horizontal: 12.0),- child: SizedBox(- height: GridSize.popoverItemHeight,- child: Padding(- padding: GridSize.typeOptionContentInsets,- child: Row(- children: [- FlowyText.medium(LocaleKeys.grid_field_includeTime.tr()),- const Spacer(),- Toggle(- value: includeTime,- onChanged: (value) {- context- .read<DateTypeOptionBloc>()- .add(DateTypeOptionEvent.includeTime(!value));- },- style: ToggleStyle.big,- padding: EdgeInsets.zero,- ),- ],- ),- ),- ),- );- },- );- }- }-class DateFormatList extends StatelessWidget {- final DateFormat selectedFormat;- final Function(DateFormat format) onSelected;+ final DateFormatPB selectedFormat;+ final Function(DateFormatPB format) onSelected;const DateFormatList({required this.selectedFormat,required this.onSelected,diff --cc frontend/appflowy_flutter/lib/plugins/database_view/grid/presentation/widgets/header/type_option/number.dartindex c6eabc3394,e341efca24..8bbfeaacbf--- a/frontend/appflowy_flutter/lib/plugins/database_view/grid/presentation/widgets/header/type_option/number.dart+++ b/frontend/appflowy_flutter/lib/plugins/database_view/grid/presentation/widgets/header/type_option/number.dart@@@ -1,14 -1,13 +1,13 @@@import 'package:appflowy/plugins/database_view/application/field/type_option/number_bloc.dart';import 'package:appflowy/plugins/database_view/application/field/type_option/number_format_bloc.dart';import 'package:appflowy/plugins/database_view/application/field/type_option/type_option_context.dart';+import 'package:appflowy_backend/protobuf/flowy-database2/number_entities.pbenum.dart';import 'package:appflowy_popover/appflowy_popover.dart';import 'package:flowy_infra/image.dart';- import 'package:flowy_infra/theme_extension.dart';import 'package:flowy_infra_ui/flowy_infra_ui.dart';-import 'package:appflowy_backend/protobuf/flowy-database/format.pbenum.dart';import 'package:flutter/material.dart';import 'package:flutter_bloc/flutter_bloc.dart';-import 'package:easy_localization/easy_localization.dart' hide NumberFormat;+import 'package:easy_localization/easy_localization.dart';import 'package:appflowy/generated/locale_keys.g.dart';import '../../../layout/sizes.dart';diff --cc frontend/appflowy_flutter/lib/plugins/database_view/widgets/card/card.dartindex 0926520275,78fa3ce976..8ddebafb11--- a/frontend/appflowy_flutter/lib/plugins/database_view/widgets/card/card.dart+++ b/frontend/appflowy_flutter/lib/plugins/database_view/widgets/card/card.dart@@@ -1,6 -1,7 +1,7 @@@+ import 'package:appflowy/plugins/database_view/application/cell/cell_service.dart';import 'package:appflowy/plugins/database_view/application/row/row_cache.dart';import 'package:appflowy/plugins/database_view/grid/presentation/widgets/row/action.dart';-import 'package:appflowy_backend/protobuf/flowy-database/row_entities.pb.dart';+import 'package:appflowy_backend/protobuf/flowy-database2/row_entities.pb.dart';import 'package:appflowy_popover/appflowy_popover.dart';import 'package:flowy_infra/image.dart';import 'package:flowy_infra_ui/flowy_infra_ui.dart';diff --cc frontend/appflowy_flutter/lib/plugins/database_view/widgets/card/card_bloc.dartindex 0514514f30,e7bf08a3c5..b33d0a9a9d--- a/frontend/appflowy_flutter/lib/plugins/database_view/widgets/card/card_bloc.dart+++ b/frontend/appflowy_flutter/lib/plugins/database_view/widgets/card/card_bloc.dart@@@ -1,6 -1,5 +1,5 @@@import 'dart:collection';- import 'package:equatable/equatable.dart';-import 'package:appflowy_backend/protobuf/flowy-database/row_entities.pb.dart';+import 'package:appflowy_backend/protobuf/flowy-database2/row_entities.pb.dart';import 'package:flutter/foundation.dart';import 'package:flutter_bloc/flutter_bloc.dart';import 'package:freezed_annotation/freezed_annotation.dart';diff --cc frontend/appflowy_flutter/lib/plugins/database_view/widgets/card/cells/card_cell.dartindex a9e88a7277,38f4fef2ba..38364fe8fb--- a/frontend/appflowy_flutter/lib/plugins/database_view/widgets/card/cells/card_cell.dart+++ b/frontend/appflowy_flutter/lib/plugins/database_view/widgets/card/cells/card_cell.dart@@@ -1,22 -1,67 +1,68 @@@import 'package:appflowy/plugins/database_view/application/cell/cell_service.dart';+import 'package:appflowy/plugins/database_view/application/row/row_service.dart';++import 'package:appflowy_backend/protobuf/flowy-database2/date_entities.pb.dart';+import 'package:appflowy_backend/protobuf/flowy-database2/field_entities.pbenum.dart';+import 'package:appflowy_backend/protobuf/flowy-database2/select_option.pb.dart';+ import 'package:appflowy_backend/log.dart';-import 'package:appflowy_backend/protobuf/flowy-database/date_type_option_entities.pb.dart';-import 'package:appflowy_backend/protobuf/flowy-database/field_entities.pbenum.dart';-import 'package:appflowy_backend/protobuf/flowy-database/select_type_option.pb.dart';import 'package:flutter/material.dart';- typedef CellRenderHook<C, T> = Widget? Function(C cellData, T cardData);+ typedef CellRenderHook<C, CustomCardData> = Widget? Function(+ C cellData,+ CustomCardData cardData,+ BuildContext buildContext,+ );typedef RenderHookByFieldType<C> = Map<FieldType, CellRenderHook<dynamic, C>>;- class CardConfiguration<CustomCardData> {+ /// The [RowCardRenderHook] is used to customize the rendering of the+ /// card cell. Each cell has itw own field type. So the [renderHook]+ /// is a map of [FieldType] to [CellRenderHook].+ class RowCardRenderHook<CustomCardData> {final RenderHookByFieldType<CustomCardData> renderHook = {};- CardConfiguration();+ RowCardRenderHook();+ /// Add render hook for the FieldType.SingleSelect and FieldType.MultiSelectvoid addSelectOptionHook(- CellRenderHook<List<SelectOptionPB>, CustomCardData> hook,+ CellRenderHook<List<SelectOptionPB>, CustomCardData?> hook,) {- selectOptionHook(cellData, cardData) {- if (cellData is List<SelectOptionPB>) {- hook(cellData, cardData);+ final hookFn = _typeSafeHook<List<SelectOptionPB>>(hook);+ renderHook[FieldType.SingleSelect] = hookFn;+ renderHook[FieldType.MultiSelect] = hookFn;+ }++ /// Add a render hook for the [FieldType.RichText]+ void addTextCellHook(+ CellRenderHook<String, CustomCardData?> hook,+ ) {+ renderHook[FieldType.RichText] = _typeSafeHook<String>(hook);+ }++ /// Add a render hook for the [FieldType.Number]+ void addNumberCellHook(+ CellRenderHook<String, CustomCardData?> hook,+ ) {+ renderHook[FieldType.Number] = _typeSafeHook<String>(hook);+ }++ /// Add a render hook for the [FieldType.Date]+ void addDateCellHook(+ CellRenderHook<DateCellDataPB, CustomCardData?> hook,+ ) {+ renderHook[FieldType.DateTime] = _typeSafeHook<DateCellDataPB>(hook);+ }++ CellRenderHook<dynamic, CustomCardData> _typeSafeHook<C>(+ CellRenderHook<C, CustomCardData?> hook,+ ) {+ hookFn(cellData, cardData, buildContext) {+ if (cellData == null) {+ return null;+ }++ if (cellData is C) {+ return hook(cellData, cardData, buildContext);+ } else {+ Log.debug("Unexpected cellData type: ${cellData.runtimeType}");+ return null;}}diff --cc frontend/appflowy_flutter/lib/plugins/document/document_page.dartindex d4b2cbe45d,cde164e88f..291b7cbd1a--- a/frontend/appflowy_flutter/lib/plugins/document/document_page.dart+++ b/frontend/appflowy_flutter/lib/plugins/document/document_page.dart@@@ -1,15 -1,6 +1,6 @@@- import 'package:appflowy/plugins/document/presentation/plugins/board/board_view_menu_item.dart';+ import 'package:appflowy/plugins/document/presentation/plugins/plugins.dart';-import 'package:appflowy_backend/protobuf/flowy-folder/view.pb.dart';+import 'package:appflowy_backend/protobuf/flowy-folder2/view.pb.dart';- import 'package:appflowy_editor_plugins/appflowy_editor_plugins.dart';import 'package:appflowy_editor/appflowy_editor.dart';- import 'package:appflowy/plugins/document/presentation/plugins/board/board_node_widget.dart';- import 'package:appflowy/plugins/document/presentation/plugins/cover/cover_node_widget.dart';- import 'package:appflowy/plugins/document/presentation/plugins/grid/grid_menu_item.dart';- import 'package:appflowy/plugins/document/presentation/plugins/grid/grid_node_widget.dart';- import 'package:appflowy/plugins/document/presentation/plugins/openai/widgets/auto_completion_node_widget.dart';- import 'package:appflowy/plugins/document/presentation/plugins/openai/widgets/auto_completion_plugins.dart';- import 'package:appflowy/plugins/document/presentation/plugins/openai/widgets/smart_edit_node_widget.dart';- import 'package:appflowy/plugins/document/presentation/plugins/openai/widgets/smart_edit_toolbar_item.dart';import 'package:dartz/dartz.dart' as dartz;import 'package:flowy_infra_ui/widget/error_page.dart';import 'package:flutter_bloc/flutter_bloc.dart';diff --cc frontend/rust-lib/dart-ffi/Cargo.tomlindex f0c9b6d006,66a919987b..d537b1a015--- a/frontend/rust-lib/dart-ffi/Cargo.toml+++ b/frontend/rust-lib/dart-ffi/Cargo.toml@@@ -7,8 -7,8 +7,8 @@@ edition = "2018[lib]name = "dart_ffi"# this value will change depending on the target os--# default static lib- crate-type = ["cdylib"]++# default staticlib+ crate-type = ["staticlib"][dependencies]diff --cc frontend/rust-lib/flowy-database2/src/entities/calendar_entities.rsindex 9d6077e351,0000000000..ddeba2eb2dmode 100644,000000..100644--- a/frontend/rust-lib/flowy-database2/src/entities/calendar_entities.rs+++ b/frontend/rust-lib/flowy-database2/src/entities/calendar_entities.rs@@@ -1,137 -1,0 +1,137 @@@+use flowy_derive::{ProtoBuf, ProtoBuf_Enum};+use flowy_error::ErrorCode;++use crate::entities::parser::NotEmptyStr;+use crate::services::setting::{CalendarLayout, CalendarLayoutSetting};++#[derive(Debug, Clone, Eq, PartialEq, Default, ProtoBuf)]+pub struct CalendarLayoutSettingPB {+ #[pb(index = 1)]+ pub field_id: String,++ #[pb(index = 2)]+ pub layout_ty: CalendarLayoutPB,++ #[pb(index = 3)]+ pub first_day_of_week: i32,++ #[pb(index = 4)]+ pub show_weekends: bool,++ #[pb(index = 5)]+ pub show_week_numbers: bool,+}++impl std::convert::From<CalendarLayoutSettingPB> for CalendarLayoutSetting {+ fn from(pb: CalendarLayoutSettingPB) -> Self {+ CalendarLayoutSetting {+ layout_ty: pb.layout_ty.into(),+ first_day_of_week: pb.first_day_of_week,+ show_weekends: pb.show_weekends,+ show_week_numbers: pb.show_week_numbers,+ field_id: pb.field_id,+ }+ }+}++impl std::convert::From<CalendarLayoutSetting> for CalendarLayoutSettingPB {+ fn from(params: CalendarLayoutSetting) -> Self {+ CalendarLayoutSettingPB {+ field_id: params.field_id,+ layout_ty: params.layout_ty.into(),+ first_day_of_week: params.first_day_of_week,+ show_weekends: params.show_weekends,+ show_week_numbers: params.show_week_numbers,+ }+ }+}++#[derive(Debug, Clone, Eq, PartialEq, Default, ProtoBuf_Enum)]+#[repr(u8)]+pub enum CalendarLayoutPB {+ #[default]+ MonthLayout = 0,+ WeekLayout = 1,+ DayLayout = 2,+}++impl std::convert::From<CalendarLayoutPB> for CalendarLayout {+ fn from(pb: CalendarLayoutPB) -> Self {+ match pb {+ CalendarLayoutPB::MonthLayout => CalendarLayout::Month,+ CalendarLayoutPB::WeekLayout => CalendarLayout::Week,+ CalendarLayoutPB::DayLayout => CalendarLayout::Day,+ }+ }+}+impl std::convert::From<CalendarLayout> for CalendarLayoutPB {+ fn from(layout: CalendarLayout) -> Self {+ match layout {+ CalendarLayout::Month => CalendarLayoutPB::MonthLayout,+ CalendarLayout::Week => CalendarLayoutPB::WeekLayout,+ CalendarLayout::Day => CalendarLayoutPB::DayLayout,+ }+ }+}++#[derive(Debug, Clone, Default, ProtoBuf)]+pub struct CalendarEventRequestPB {+ #[pb(index = 1)]+ pub view_id: String,++ // Currently, requesting the events within the specified month+ // is not supported+ #[pb(index = 2)]+ pub month: String,+}++#[derive(Debug, Clone, Default)]+pub struct CalendarEventRequestParams {+ pub view_id: String,+ pub month: String,+}++impl TryInto<CalendarEventRequestParams> for CalendarEventRequestPB {+ type Error = ErrorCode;++ fn try_into(self) -> Result<CalendarEventRequestParams, Self::Error> {+ let view_id = NotEmptyStr::parse(self.view_id).map_err(|_| ErrorCode::ViewIdIsInvalid)?;+ Ok(CalendarEventRequestParams {+ view_id: view_id.0,+ month: self.month,+ })+ }+}++#[derive(Debug, Clone, Default, ProtoBuf)]+pub struct CalendarEventPB {+ #[pb(index = 1)]+ pub row_id: String,++ #[pb(index = 2)]- pub title_field_id: String,++ pub date_field_id: String,++ #[pb(index = 3)]+ pub title: String,++ #[pb(index = 4)]+ pub timestamp: i64,+}++#[derive(Debug, Clone, Default, ProtoBuf)]+pub struct RepeatedCalendarEventPB {+ #[pb(index = 1)]+ pub items: Vec<CalendarEventPB>,+}++#[derive(Debug, Clone, Default, ProtoBuf)]+pub struct MoveCalendarEventPB {+ #[pb(index = 1)]+ pub row_id: String,++ #[pb(index = 2)]+ pub field_id: String,++ #[pb(index = 3)]+ pub timestamp: i64,+}diff --cc frontend/rust-lib/flowy-database2/src/services/database/database_editor.rsindex 08a00e278b,0000000000..94c15897d1mode 100644,000000..100644--- a/frontend/rust-lib/flowy-database2/src/services/database/database_editor.rs+++ b/frontend/rust-lib/flowy-database2/src/services/database/database_editor.rs@@@ -1,1018 -1,0 +1,1018 @@@+use std::collections::HashMap;+use std::ops::Deref;+use std::sync::Arc;++use bytes::Bytes;+use collab_database::database::{gen_row_id, timestamp, Database as InnerDatabase};+use collab_database::fields::{Field, TypeOptionData};+use collab_database::rows::{Cell, Cells, Row, RowCell, RowId};+use collab_database::views::{DatabaseLayout, DatabaseView, LayoutSetting, RowOrder};+use parking_lot::Mutex;+use tokio::sync::{broadcast, RwLock};++use flowy_error::{FlowyError, FlowyResult};+use flowy_task::TaskDispatcher;+use lib_infra::future::{to_fut, Fut};++use crate::entities::{+ AlterFilterParams, AlterSortParams, CalendarEventPB, CellChangesetNotifyPB, CellPB,+ CreateRowParams, DatabaseFieldChangesetPB, DatabasePB, DatabaseViewSettingPB, DeleteFilterParams,+ DeleteGroupParams, DeleteSortParams, FieldChangesetParams, FieldIdPB, FieldPB, FieldType,+ GroupPB, IndexFieldPB, InsertGroupParams, LayoutSettingParams, RepeatedFilterPB, RepeatedGroupPB,+ RepeatedSortPB, RowPB, SelectOptionCellDataPB, SelectOptionPB,+};+use crate::notification::{send_notification, DatabaseNotification};+use crate::services::cell::{+ apply_cell_data_changeset, get_type_cell_protobuf, AnyTypeCache, CellBuilder, CellCache,+ ToCellChangeset,+};+use crate::services::database::util::database_view_setting_pb_from_view;+use crate::services::database::{DatabaseRowEvent, InsertedRow, UpdatedRow};+use crate::services::database_view::{+ DatabaseViewChanged, DatabaseViewData, DatabaseViews, RowEventSender,+};+use crate::services::field::{+ default_type_option_data_for_type, default_type_option_data_from_type,+ select_type_option_from_field, transform_type_option, type_option_data_from_pb_or_default,+ type_option_to_pb, SelectOptionCellChangeset, SelectOptionIds, TypeOptionCellDataHandler,+ TypeOptionCellExt,+};+use crate::services::filter::Filter;+use crate::services::group::{default_group_setting, GroupSetting, RowChangeset};+use crate::services::sort::Sort;++#[derive(Clone)]+pub struct DatabaseEditor {+ database: MutexDatabase,+ pub cell_cache: CellCache,+ database_views: Arc<DatabaseViews>,+ row_event_tx: RowEventSender,+}++impl DatabaseEditor {+ pub async fn new(+ database: MutexDatabase,+ task_scheduler: Arc<RwLock<TaskDispatcher>>,+ ) -> FlowyResult<Self> {+ let cell_cache = AnyTypeCache::<u64>::new();+ let (row_event_tx, row_event_rx) = broadcast::channel(100);+ let database_view_data = Arc::new(DatabaseViewDataImpl {+ database: database.clone(),+ task_scheduler: task_scheduler.clone(),+ cell_cache: cell_cache.clone(),+ });++ let database_views = Arc::new(+ DatabaseViews::new(+ database.clone(),+ cell_cache.clone(),+ database_view_data,+ row_event_rx,+ )+ .await?,+ );+ Ok(Self {+ database,+ cell_cache,+ database_views,+ row_event_tx,+ })+ }++ #[tracing::instrument(level = "debug", skip_all)]+ pub async fn close_view_editor(&self, view_id: &str) -> bool {+ self.database_views.close_view(view_id).await+ }++ pub async fn close(&self) {}++ pub async fn subscribe_view_changed(+ &self,+ view_id: &str,+ ) -> FlowyResult<broadcast::Receiver<DatabaseViewChanged>> {+ let view_editor = self.database_views.get_view_editor(view_id).await?;+ Ok(view_editor.notifier.subscribe())+ }++ pub fn get_field(&self, field_id: &str) -> Option<Field> {+ self.database.lock().fields.get_field(field_id)+ }++ pub async fn insert_group(&self, params: InsertGroupParams) -> FlowyResult<()> {+ {+ let database = self.database.lock();+ let field = database.fields.get_field(¶ms.field_id);+ if let Some(field) = field {+ let group_setting = default_group_setting(&field);+ database.insert_group_setting(¶ms.view_id, group_setting);+ }+ }++ let view_editor = self.database_views.get_view_editor(¶ms.view_id).await?;+ view_editor.v_initialize_new_group(params).await?;+ Ok(())+ }++ pub async fn delete_group(&self, params: DeleteGroupParams) -> FlowyResult<()> {+ self+ .database+ .lock()+ .delete_group_setting(¶ms.view_id, ¶ms.group_id);+ let view_editor = self.database_views.get_view_editor(¶ms.view_id).await?;+ view_editor.v_delete_group(params).await?;++ Ok(())+ }++ #[tracing::instrument(level = "trace", skip_all, err)]+ pub async fn create_or_update_filter(&self, params: AlterFilterParams) -> FlowyResult<()> {+ let view_editor = self.database_views.get_view_editor(¶ms.view_id).await?;+ view_editor.v_insert_filter(params).await?;+ Ok(())+ }++ pub async fn delete_filter(&self, params: DeleteFilterParams) -> FlowyResult<()> {+ let view_editor = self.database_views.get_view_editor(¶ms.view_id).await?;+ view_editor.v_delete_filter(params).await?;+ Ok(())+ }++ pub async fn create_or_update_sort(&self, params: AlterSortParams) -> FlowyResult<Sort> {+ let view_editor = self.database_views.get_view_editor(¶ms.view_id).await?;+ let sort = view_editor.v_insert_sort(params).await?;+ Ok(sort)+ }++ pub async fn delete_sort(&self, params: DeleteSortParams) -> FlowyResult<()> {+ let view_editor = self.database_views.get_view_editor(¶ms.view_id).await?;+ view_editor.v_delete_sort(params).await?;+ Ok(())+ }++ pub async fn get_all_filters(&self, view_id: &str) -> RepeatedFilterPB {+ if let Ok(view_editor) = self.database_views.get_view_editor(view_id).await {+ view_editor.v_get_all_filters().await.into()+ } else {+ RepeatedFilterPB { items: vec![] }+ }+ }++ pub async fn get_filter(&self, view_id: &str, filter_id: &str) -> Option<Filter> {+ if let Ok(view_editor) = self.database_views.get_view_editor(view_id).await {+ Some(view_editor.v_get_filter(filter_id).await?)+ } else {+ None+ }+ }+ pub async fn get_all_sorts(&self, view_id: &str) -> RepeatedSortPB {+ if let Ok(view_editor) = self.database_views.get_view_editor(view_id).await {+ view_editor.v_get_all_sorts().await.into()+ } else {+ RepeatedSortPB { items: vec![] }+ }+ }++ pub async fn delete_all_sorts(&self, view_id: &str) {+ if let Ok(view_editor) = self.database_views.get_view_editor(view_id).await {+ let _ = view_editor.v_delete_all_sorts().await;+ }+ }++ pub fn get_fields(&self, view_id: &str, field_ids: Option<Vec<String>>) -> Vec<Field> {+ self.database.lock().get_fields(view_id, field_ids)+ }++ pub async fn update_field(&self, params: FieldChangesetParams) -> FlowyResult<()> {+ self+ .database+ .lock()+ .fields+ .update_field(¶ms.field_id, |update| {+ update+ .set_name_if_not_none(params.name)+ .set_field_type_if_not_none(params.field_type.map(|field_type| field_type.into()))+ .set_width_at_if_not_none(params.width.map(|value| value as i64))+ .set_visibility_if_not_none(params.visibility);+ });+ self+ .notify_did_update_database_field(¶ms.field_id)+ .await?;+ Ok(())+ }++ pub async fn delete_field(&self, field_id: &str) -> FlowyResult<()> {+ let database_id = {+ let database = self.database.lock();+ database.delete_field(field_id);+ database.get_database_id()+ };+ let notified_changeset =+ DatabaseFieldChangesetPB::delete(&database_id, vec![FieldIdPB::from(field_id)]);+ self.notify_did_update_database(notified_changeset).await?;+ Ok(())+ }++ pub async fn update_field_type_option(+ &self,+ view_id: &str,+ field_id: &str,+ type_option_data: TypeOptionData,+ old_field: Field,+ ) -> FlowyResult<()> {+ let field_type = FieldType::from(old_field.field_type);+ self+ .database+ .lock()+ .fields+ .update_field(field_id, |update| {+ update.update_type_options(|type_options_update| {+ type_options_update.insert(&field_type.to_string(), type_option_data);+ });+ });+ self+ .database_views+ .did_update_field_type_option(view_id, field_id, &old_field)+ .await?;+ let _ = self.notify_did_update_database_field(field_id).await;+ Ok(())+ }++ pub async fn switch_to_field_type(+ &self,+ field_id: &str,+ new_field_type: &FieldType,+ ) -> FlowyResult<()> {+ let field = self.database.lock().fields.get_field(field_id);+ match field {+ None => {},+ Some(field) => {+ let old_field_type = FieldType::from(field.field_type);+ let old_type_option = field.get_any_type_option(old_field_type.clone());+ let new_type_option = field+ .get_any_type_option(new_field_type)+ .unwrap_or_else(|| default_type_option_data_for_type(new_field_type));++ let transformed_type_option = transform_type_option(+ &new_type_option,+ new_field_type,+ old_type_option,+ old_field_type,+ );+ self+ .database+ .lock()+ .fields+ .update_field(field_id, |update| {+ update+ .set_field_type(new_field_type.into())+ .set_type_option(new_field_type.into(), Some(transformed_type_option));+ });+ },+ }++ self.notify_did_update_database_field(field_id).await?;+ Ok(())+ }++ pub async fn duplicate_field(&self, view_id: &str, field_id: &str) -> FlowyResult<()> {+ let value = self+ .database+ .lock()+ .duplicate_field(view_id, field_id, |field| format!("{} (copy)", field.name));+ if let Some((index, duplicated_field)) = value {+ let _ = self+ .notify_did_insert_database_field(duplicated_field, index)+ .await;+ }+ Ok(())+ }++ pub async fn duplicate_row(&self, view_id: &str, row_id: &RowId) {+ let _ = self.database.lock().duplicate_row(view_id, row_id);+ }++ pub async fn move_row(&self, _view_id: &str, _from: RowId, _to: RowId) {+ // self.database.lock().views.update_view(view_id, |view| {+ // view.move_row_order(from as u32, to as u32);+ // });+ // self.row_event_tx.send(DatabaseRowEvent::Move { from: _from, to: _to})+ }++ pub async fn create_row(&self, params: CreateRowParams) -> FlowyResult<Option<Row>> {+ let fields = self.database.lock().get_fields(¶ms.view_id, None);+ let mut cells =+ CellBuilder::with_cells(params.cell_data_by_field_id.unwrap_or_default(), fields).build();+ for view in self.database_views.editors().await {+ view.v_will_create_row(&mut cells, ¶ms.group_id).await;+ }++ let result = self.database.lock().create_row_in_view(+ ¶ms.view_id,+ collab_database::rows::CreateRowParams {+ id: gen_row_id(),+ cells,+ height: 60,+ visibility: true,+ prev_row_id: params.start_row_id,+ timestamp: timestamp(),+ },+ );++ if let Some((index, row_order)) = result {+ let _ = self+ .row_event_tx+ .send(DatabaseRowEvent::InsertRow(InsertedRow {+ row: row_order.clone(),+ index: Some(index as i32),+ is_new: true,+ }));++ let row = self.database.lock().get_row(&row_order.id);+ if let Some(row) = row {+ for view in self.database_views.editors().await {+ view.v_did_create_row(&row, ¶ms.group_id, index).await;+ }+ return Ok(Some(row));+ }+ }++ Ok(None)+ }++ pub async fn get_field_type_option_data(&self, field_id: &str) -> Option<(Field, Bytes)> {+ let field = self.database.lock().fields.get_field(field_id);+ field.map(|field| {+ let field_type = FieldType::from(field.field_type);+ let type_option = field+ .get_any_type_option(field_type.clone())+ .unwrap_or_else(|| default_type_option_data_from_type(&field_type));+ (field, type_option_to_pb(type_option, &field_type))+ })+ }++ pub async fn create_field_with_type_option(+ &self,+ view_id: &str,+ field_type: &FieldType,+ type_option_data: Option<Vec<u8>>,+ ) -> (Field, Bytes) {+ let name = field_type.default_name();+ let type_option_data = match type_option_data {+ None => default_type_option_data_for_type(field_type),+ Some(type_option_data) => type_option_data_from_pb_or_default(type_option_data, field_type),+ };+ let (index, field) =+ self+ .database+ .lock()+ .create_default_field(view_id, name, field_type.into(), |field| {+ field+ .type_options+ .insert(field_type.to_string(), type_option_data.clone());+ });++ let _ = self+ .notify_did_insert_database_field(field.clone(), index)+ .await;++ (field, type_option_to_pb(type_option_data, field_type))+ }++ pub async fn move_field(+ &self,+ view_id: &str,+ field_id: &str,+ from: i32,+ to: i32,+ ) -> FlowyResult<()> {+ let (database_id, field) = {+ let database = self.database.lock();+ database.views.update_view(view_id, |view_update| {+ view_update.move_field_order(from as u32, to as u32);+ });+ let field = database.fields.get_field(field_id);+ let database_id = database.get_database_id();+ (database_id, field)+ };++ if let Some(field) = field {+ let delete_field = FieldIdPB::from(field_id);+ let insert_field = IndexFieldPB::from_field(field, to as usize);+ let notified_changeset = DatabaseFieldChangesetPB {+ view_id: database_id,+ inserted_fields: vec![insert_field],+ deleted_fields: vec![delete_field],+ updated_fields: vec![],+ };++ self.notify_did_update_database(notified_changeset).await?;+ }+ Ok(())+ }++ pub async fn get_rows(&self, view_id: &str) -> FlowyResult<Vec<Arc<Row>>> {+ let view_editor = self.database_views.get_view_editor(view_id).await?;+ Ok(view_editor.v_get_rows().await)+ }++ pub fn get_row(&self, row_id: &RowId) -> Option<Row> {+ self.database.lock().get_row(row_id)+ }++ pub async fn delete_row(&self, row_id: &RowId) {+ let row = self.database.lock().remove_row(row_id);+ if let Some(row) = row {+ tracing::trace!("Did delete row:{:?}", row);+ let _ = self+ .row_event_tx+ .send(DatabaseRowEvent::DeleteRow(row.id.clone()));++ for view in self.database_views.editors().await {+ view.v_did_delete_row(&row).await;+ }+ }+ }++ pub async fn get_cell(&self, field_id: &str, row_id: RowId) -> CellPB {+ let (field, cell) = {+ let database = self.database.lock();+ let field = database.fields.get_field(field_id);+ let cell = database.get_cell(field_id, &row_id);+ (field, cell)+ };++ match (field, cell) {+ (Some(field), Some(cell)) => {+ let field_type = FieldType::from(field.field_type);+ let cell_bytes = get_type_cell_protobuf(&cell, &field, Some(self.cell_cache.clone()));+ CellPB {+ field_id: field_id.to_string(),+ row_id: row_id.into(),+ data: cell_bytes.to_vec(),+ field_type: Some(field_type),+ }+ },+ _ => CellPB::empty(field_id, row_id.into_inner()),+ }+ }++ pub async fn get_cells_for_field(&self, view_id: &str, field_id: &str) -> Vec<RowCell> {+ self.database.lock().get_cells_for_field(view_id, field_id)+ }++ pub async fn update_cell_with_changeset<T>(+ &self,+ view_id: &str,+ row_id: RowId,+ field_id: &str,+ cell_changeset: T,+ ) -> Option<()>+ where+ T: ToCellChangeset,+ {+ let (field, cell) = {+ let database = self.database.lock();+ (+ database.fields.get_field(field_id)?,+ database.get_cell(field_id, &row_id).map(|cell| cell.cell),+ )+ };+ let cell_changeset = cell_changeset.to_cell_changeset_str();+ let new_cell =+ apply_cell_data_changeset(cell_changeset, cell, &field, Some(self.cell_cache.clone()));+ self.update_cell(view_id, row_id, field_id, new_cell).await+ }++ pub async fn update_cell(+ &self,+ view_id: &str,+ row_id: RowId,+ field_id: &str,+ new_cell: Cell,+ ) -> Option<()> {+ let old_row = { self.database.lock().get_row(&row_id) };+ self.database.lock().update_row(&row_id, |row_update| {+ row_update.update_cells(|cell_update| {+ cell_update.insert(field_id, new_cell);+ });+ });++ let option_row = self.database.lock().get_row(&row_id);+ if let Some(new_row) = option_row {+ let _ = self+ .row_event_tx+ .send(DatabaseRowEvent::UpdateRow(UpdatedRow {+ row: RowOrder::from(&new_row),+ field_ids: vec![field_id.to_string()],+ }));+ for view in self.database_views.editors().await {+ view.v_did_update_row(&old_row, &new_row).await;+ }+ }++ notify_did_update_cell(vec![CellChangesetNotifyPB {+ view_id: view_id.to_string(),+ row_id: row_id.into_inner(),+ field_id: field_id.to_string(),+ }])+ .await;+ None+ }++ pub async fn create_select_option(+ &self,+ field_id: &str,+ option_name: String,+ ) -> Option<SelectOptionPB> {+ let field = self.database.lock().fields.get_field(field_id)?;+ let type_option = select_type_option_from_field(&field).ok()?;+ let select_option = type_option.create_option(&option_name);+ Some(SelectOptionPB::from(select_option))+ }++ pub async fn insert_select_options(+ &self,+ view_id: &str,+ field_id: &str,+ row_id: RowId,+ options: Vec<SelectOptionPB>,+ ) -> Option<()> {+ let field = self.database.lock().fields.get_field(field_id)?;+ let mut type_option = select_type_option_from_field(&field).ok()?;+ let cell_changeset = SelectOptionCellChangeset {+ insert_option_ids: options.iter().map(|option| option.id.clone()).collect(),+ ..Default::default()+ };++ for option in options {+ type_option.insert_option(option.into());+ }+ self+ .database+ .lock()+ .fields+ .update_field(field_id, |update| {+ update.set_type_option(field.field_type, Some(type_option.to_type_option_data()));+ });++ self+ .update_cell_with_changeset(view_id, row_id, field_id, cell_changeset)+ .await;+ None+ }++ pub async fn delete_select_options(+ &self,+ view_id: &str,+ field_id: &str,+ row_id: RowId,+ options: Vec<SelectOptionPB>,+ ) -> Option<()> {+ let field = self.database.lock().fields.get_field(field_id)?;+ let mut type_option = select_type_option_from_field(&field).ok()?;+ let cell_changeset = SelectOptionCellChangeset {+ delete_option_ids: options.iter().map(|option| option.id.clone()).collect(),+ ..Default::default()+ };++ for option in options {+ type_option.delete_option(option.into());+ }+ self+ .database+ .lock()+ .fields+ .update_field(field_id, |update| {+ update.set_type_option(field.field_type, Some(type_option.to_type_option_data()));+ });++ self+ .update_cell_with_changeset(view_id, row_id, field_id, cell_changeset)+ .await;+ None+ }++ pub async fn get_select_options(&self, row_id: RowId, field_id: &str) -> SelectOptionCellDataPB {+ let field = self.database.lock().fields.get_field(field_id);+ match field {+ None => SelectOptionCellDataPB::default(),+ Some(field) => {+ let row_cell = self.database.lock().get_cell(field_id, &row_id);+ let ids = match row_cell {+ None => SelectOptionIds::new(),+ Some(row_cell) => SelectOptionIds::from(&row_cell.cell),+ };+ match select_type_option_from_field(&field) {+ Ok(type_option) => type_option.get_selected_options(ids).into(),+ Err(_) => SelectOptionCellDataPB::default(),+ }+ },+ }+ }++ #[tracing::instrument(level = "trace", skip_all, err)]+ pub async fn load_groups(&self, view_id: &str) -> FlowyResult<RepeatedGroupPB> {+ let view = self.database_views.get_view_editor(view_id).await?;+ let groups = view.v_load_groups().await?;+ Ok(RepeatedGroupPB { items: groups })+ }++ #[tracing::instrument(level = "trace", skip_all, err)]+ pub async fn get_group(&self, view_id: &str, group_id: &str) -> FlowyResult<GroupPB> {+ let view = self.database_views.get_view_editor(view_id).await?;+ let group = view.v_get_group(group_id).await?;+ Ok(group)+ }++ #[tracing::instrument(level = "trace", skip_all, err)]+ pub async fn move_group(+ &self,+ view_id: &str,+ from_group: &str,+ to_group: &str,+ ) -> FlowyResult<()> {+ let view = self.database_views.get_view_editor(view_id).await?;+ view.v_move_group(from_group, to_group).await?;+ Ok(())+ }++ #[tracing::instrument(level = "trace", skip_all, err)]+ pub async fn move_group_row(+ &self,+ view_id: &str,+ to_group: &str,+ from_row: RowId,+ to_row: Option<RowId>,+ ) -> FlowyResult<()> {+ let row = self.database.lock().get_row(&from_row);+ match row {+ None => {+ tracing::warn!(+ "Move row between group failed, can not find the row:{}",+ from_row+ )+ },+ Some(row) => {+ let mut row_changeset = RowChangeset::new(row.id.clone());+ let view = self.database_views.get_view_editor(view_id).await?;+ view+ .v_move_group_row(&row, &mut row_changeset, to_group, to_row)+ .await;++ tracing::trace!("Row data changed: {:?}", row_changeset);+ self.database.lock().update_row(&row.id, |row| {+ row.set_cells(Cells::from(row_changeset.cell_by_field_id.clone()));+ });++ let cell_changesets = cell_changesets_from_cell_by_field_id(+ view_id,+ row_changeset.row_id,+ row_changeset.cell_by_field_id,+ );+ notify_did_update_cell(cell_changesets).await;+ },+ }++ Ok(())+ }++ pub async fn group_by_field(&self, view_id: &str, field_id: &str) -> FlowyResult<()> {+ let view = self.database_views.get_view_editor(view_id).await?;+ view.v_update_group_setting(field_id).await?;+ Ok(())+ }++ pub async fn set_layout_setting(+ &self,+ view_id: &str,+ layout_ty: DatabaseLayout,+ layout_setting: LayoutSettingParams,+ ) {+ if let Ok(view) = self.database_views.get_view_editor(view_id).await {+ let _ = view.v_set_layout_settings(&layout_ty, layout_setting).await;+ }+ }++ pub async fn get_layout_setting(+ &self,+ view_id: &str,+ layout_ty: DatabaseLayout,+ ) -> Option<LayoutSettingParams> {+ let view = self.database_views.get_view_editor(view_id).await.ok()?;+ let layout_setting = view.v_get_layout_settings(&layout_ty).await;+ Some(layout_setting)+ }++ #[tracing::instrument(level = "trace", skip_all)]+ pub async fn get_all_calendar_events(&self, view_id: &str) -> Vec<CalendarEventPB> {+ match self.database_views.get_view_editor(view_id).await {+ Ok(view) => view.v_get_all_calendar_events().await.unwrap_or_default(),+ Err(_) => {+ tracing::warn!("Can not find the view: {}", view_id);+ vec![]+ },+ }+ }++ #[tracing::instrument(level = "trace", skip_all)]+ pub async fn get_calendar_event(&self, view_id: &str, row_id: RowId) -> Option<CalendarEventPB> {+ let view = self.database_views.get_view_editor(view_id).await.ok()?;+ view.v_get_calendar_event(row_id).await+ }++ #[tracing::instrument(level = "trace", skip_all, err)]+ async fn notify_did_insert_database_field(&self, field: Field, index: usize) -> FlowyResult<()> {+ let database_id = self.database.lock().get_database_id();+ let index_field = IndexFieldPB::from_field(field, index);+ let notified_changeset = DatabaseFieldChangesetPB::insert(&database_id, vec![index_field]);+ let _ = self.notify_did_update_database(notified_changeset).await;+ Ok(())+ }++ #[tracing::instrument(level = "trace", skip_all, err)]+ async fn notify_did_update_database_field(&self, field_id: &str) -> FlowyResult<()> {+ let (database_id, field) = {+ let database = self.database.lock();+ let database_id = database.get_database_id();+ let field = database.fields.get_field(field_id);+ (database_id, field)+ };++ if let Some(field) = field {+ let updated_field = FieldPB::from(field);+ let notified_changeset =+ DatabaseFieldChangesetPB::update(&database_id, vec![updated_field.clone()]);+ self.notify_did_update_database(notified_changeset).await?;+ send_notification(field_id, DatabaseNotification::DidUpdateField)+ .payload(updated_field)+ .send();+ }++ Ok(())+ }++ async fn notify_did_update_database(+ &self,+ changeset: DatabaseFieldChangesetPB,+ ) -> FlowyResult<()> {+ let views = self.database.lock().get_all_views_description();+ for view in views {+ send_notification(&view.id, DatabaseNotification::DidUpdateFields)+ .payload(changeset.clone())+ .send();+ }++ Ok(())+ }++ pub async fn get_database_view_setting(+ &self,+ view_id: &str,+ ) -> FlowyResult<DatabaseViewSettingPB> {+ let view = self+ .database+ .lock()+ .get_view(view_id)+ .ok_or_else(|| FlowyError::record_not_found().context("Can't find the database view"))?;+ Ok(database_view_setting_pb_from_view(view))+ }++ pub async fn get_database_data(&self, view_id: &str) -> DatabasePB {+ let rows = self.get_rows(view_id).await.unwrap_or_default();+ let (database_id, fields) = {+ let database = self.database.lock();+ let database_id = database.get_database_id();+ let fields = database+ .fields+ .get_all_field_orders()+ .into_iter()+ .map(FieldIdPB::from)+ .collect();+ (database_id, fields)+ };++ let rows = rows+ .into_iter()+ .map(|row| RowPB::from(row.as_ref()))+ .collect::<Vec<RowPB>>();+ DatabasePB {+ id: database_id,+ fields,+ rows,+ }+ }+}++pub(crate) async fn notify_did_update_cell(changesets: Vec<CellChangesetNotifyPB>) {+ for changeset in changesets {+ let id = format!("{}:{}", changeset.row_id, changeset.field_id);+ send_notification(&id, DatabaseNotification::DidUpdateCell).send();+ }+}++fn cell_changesets_from_cell_by_field_id(+ view_id: &str,+ row_id: RowId,+ cell_by_field_id: HashMap<String, Cell>,+) -> Vec<CellChangesetNotifyPB> {+ let row_id = row_id.into_inner();+ cell_by_field_id+ .into_iter()+ .map(|(field_id, _cell)| CellChangesetNotifyPB {+ view_id: view_id.to_string(),+ row_id: row_id.clone(),+ field_id,+ })+ .collect()+}++#[derive(Clone)]+pub struct MutexDatabase(Arc<Mutex<Arc<InnerDatabase>>>);++impl MutexDatabase {+ pub(crate) fn new(database: Arc<InnerDatabase>) -> Self {+ Self(Arc::new(Mutex::new(database)))+ }+}++impl Deref for MutexDatabase {+ type Target = Arc<Mutex<Arc<InnerDatabase>>>;+ fn deref(&self) -> &Self::Target {+ &self.0+ }+}++unsafe impl Sync for MutexDatabase {}++unsafe impl Send for MutexDatabase {}++struct DatabaseViewDataImpl {+ database: MutexDatabase,+ task_scheduler: Arc<RwLock<TaskDispatcher>>,+ cell_cache: CellCache,+}++impl DatabaseViewData for DatabaseViewDataImpl {+ fn get_view_setting(&self, view_id: &str) -> Fut<Option<DatabaseView>> {+ let view = self.database.lock().get_view(view_id);+ to_fut(async move { view })+ }++ fn get_fields(&self, view_id: &str, field_ids: Option<Vec<String>>) -> Fut<Vec<Arc<Field>>> {+ let fields = self.database.lock().get_fields(view_id, field_ids);+ to_fut(async move { fields.into_iter().map(Arc::new).collect() })+ }++ fn get_field(&self, field_id: &str) -> Fut<Option<Arc<Field>>> {+ let field = self+ .database+ .lock()+ .fields+ .get_field(field_id)+ .map(Arc::new);+ to_fut(async move { field })+ }++ fn get_primary_field(&self) -> Fut<Option<Arc<Field>>> {+ let field = self+ .database+ .lock()+ .fields+ .get_primary_field()+ .map(Arc::new);+ to_fut(async move { field })+ }++ fn index_of_row(&self, view_id: &str, row_id: &RowId) -> Fut<Option<usize>> {+ let index = self.database.lock().index_of_row(view_id, row_id);+ to_fut(async move { index })+ }++ fn get_row(&self, view_id: &str, row_id: &RowId) -> Fut<Option<(usize, Arc<Row>)>> {+ let index = self.database.lock().index_of_row(view_id, row_id);- let row = self.database.lock().get_row(&row_id);++ let row = self.database.lock().get_row(row_id);+ to_fut(async move {+ match (index, row) {+ (Some(index), Some(row)) => Some((index, Arc::new(row))),+ _ => None,+ }+ })+ }++ fn get_rows(&self, view_id: &str) -> Fut<Vec<Arc<Row>>> {+ let rows = self.database.lock().get_rows_for_view(view_id);+ to_fut(async move { rows.into_iter().map(Arc::new).collect() })+ }++ fn get_cells_for_field(&self, view_id: &str, field_id: &str) -> Fut<Vec<Arc<RowCell>>> {+ let cells = self.database.lock().get_cells_for_field(view_id, field_id);+ to_fut(async move { cells.into_iter().map(Arc::new).collect() })+ }++ fn get_cell_in_row(&self, field_id: &str, row_id: &RowId) -> Fut<Option<Arc<RowCell>>> {+ let cell = self.database.lock().get_cell(field_id, row_id);+ to_fut(async move { cell.map(Arc::new) })+ }++ fn get_layout_for_view(&self, view_id: &str) -> DatabaseLayout {+ self+ .database+ .lock()+ .views+ .get_view_layout(view_id)+ .unwrap_or_default()+ }++ fn get_group_setting(&self, view_id: &str) -> Vec<GroupSetting> {+ self.database.lock().get_all_group_setting(view_id)+ }++ fn insert_group_setting(&self, view_id: &str, setting: GroupSetting) {+ self.database.lock().insert_group_setting(view_id, setting);+ }++ fn get_sort(&self, view_id: &str, sort_id: &str) -> Option<Sort> {+ self.database.lock().get_sort::<Sort>(view_id, sort_id)+ }++ fn insert_sort(&self, view_id: &str, sort: Sort) {+ self.database.lock().insert_sort(view_id, sort);+ }++ fn remove_sort(&self, view_id: &str, sort_id: &str) {+ self.database.lock().remove_sort(view_id, sort_id);+ }++ fn get_all_sorts(&self, view_id: &str) -> Vec<Sort> {+ self.database.lock().get_all_sorts::<Sort>(view_id)+ }++ fn remove_all_sorts(&self, view_id: &str) {+ self.database.lock().remove_all_sorts(view_id);+ }++ fn get_all_filters(&self, view_id: &str) -> Vec<Arc<Filter>> {+ self+ .database+ .lock()+ .get_all_filters(view_id)+ .into_iter()+ .map(Arc::new)+ .collect()+ }++ fn delete_filter(&self, view_id: &str, filter_id: &str) {+ self.database.lock().remove_filter(view_id, filter_id);+ }++ fn insert_filter(&self, view_id: &str, filter: Filter) {+ self.database.lock().insert_filter(view_id, filter);+ }++ fn get_filter(&self, view_id: &str, filter_id: &str) -> Option<Filter> {+ self+ .database+ .lock()+ .get_filter::<Filter>(view_id, filter_id)+ }++ fn get_filter_by_field_id(&self, view_id: &str, field_id: &str) -> Option<Filter> {+ self+ .database+ .lock()+ .get_filter_by_field_id::<Filter>(view_id, field_id)+ }++ fn get_layout_setting(&self, view_id: &str, layout_ty: &DatabaseLayout) -> Option<LayoutSetting> {+ self+ .database+ .lock()+ .views+ .get_layout_setting(view_id, layout_ty)+ }++ fn insert_layout_setting(+ &self,+ view_id: &str,+ layout_ty: &DatabaseLayout,+ layout_setting: LayoutSetting,+ ) {+ self+ .database+ .lock()+ .insert_layout_setting(view_id, layout_ty, layout_setting);+ }++ fn get_task_scheduler(&self) -> Arc<RwLock<TaskDispatcher>> {+ self.task_scheduler.clone()+ }++ fn get_type_option_cell_handler(+ &self,+ field: &Field,+ field_type: &FieldType,+ ) -> Option<Box<dyn TypeOptionCellDataHandler>> {+ TypeOptionCellExt::new_with_cell_data_cache(field, Some(self.cell_cache.clone()))+ .get_type_option_cell_data_handler(field_type)+ }+}diff --cc frontend/rust-lib/flowy-database2/src/services/database_view/view_editor.rsindex 3213144425,0000000000..2cb77632a5mode 100644,000000..100644--- a/frontend/rust-lib/flowy-database2/src/services/database_view/view_editor.rs+++ b/frontend/rust-lib/flowy-database2/src/services/database_view/view_editor.rs@@@ -1,793 -1,0 +1,793 @@@+use std::borrow::Cow;+use std::collections::HashMap;+use std::sync::Arc;++use collab_database::database::{gen_database_filter_id, gen_database_sort_id};+use collab_database::fields::Field;+use collab_database::rows::{Cells, Row, RowCell, RowId};+use collab_database::views::{DatabaseLayout, DatabaseView, LayoutSetting};+use tokio::sync::{broadcast, RwLock};++use flowy_error::{FlowyError, FlowyResult};+use flowy_task::TaskDispatcher;+use lib_infra::future::Fut;++use crate::entities::{+ AlterFilterParams, AlterSortParams, CalendarEventPB, DeleteFilterParams, DeleteGroupParams,+ DeleteSortParams, FieldType, GroupChangesetPB, GroupPB, GroupRowsNotificationPB,+ InsertGroupParams, InsertedGroupPB, InsertedRowPB, LayoutSettingPB, LayoutSettingParams, RowPB,+ RowsChangesetPB, SortChangesetNotificationPB, SortPB,+};+use crate::notification::{send_notification, DatabaseNotification};+use crate::services::cell::CellCache;+use crate::services::database::{database_view_setting_pb_from_view, DatabaseRowEvent};+use crate::services::database_view::view_filter::make_filter_controller;+use crate::services::database_view::view_group::{+ get_cell_for_row, get_cells_for_field, new_group_controller, new_group_controller_with_field,+};+use crate::services::database_view::view_sort::make_sort_controller;+use crate::services::database_view::{+ notify_did_update_filter, notify_did_update_group_rows, notify_did_update_groups,+ notify_did_update_setting, notify_did_update_sort, DatabaseViewChangedNotifier,+ DatabaseViewChangedReceiverRunner,+};+use crate::services::field::TypeOptionCellDataHandler;+use crate::services::filter::{+ Filter, FilterChangeset, FilterController, FilterType, UpdatedFilterType,+};+use crate::services::group::{GroupController, GroupSetting, MoveGroupRowContext, RowChangeset};+use crate::services::setting::CalendarLayoutSetting;+use crate::services::sort::{DeletedSortType, Sort, SortChangeset, SortController, SortType};++pub trait DatabaseViewData: Send + Sync + 'static {+ fn get_view_setting(&self, view_id: &str) -> Fut<Option<DatabaseView>>;+ /// If the field_ids is None, then it will return all the field revisions+ fn get_fields(&self, view_id: &str, field_ids: Option<Vec<String>>) -> Fut<Vec<Arc<Field>>>;++ /// Returns the field with the field_id+ fn get_field(&self, field_id: &str) -> Fut<Option<Arc<Field>>>;++ fn get_primary_field(&self) -> Fut<Option<Arc<Field>>>;++ /// Returns the index of the row with row_id+ fn index_of_row(&self, view_id: &str, row_id: &RowId) -> Fut<Option<usize>>;++ /// Returns the `index` and `RowRevision` with row_id+ fn get_row(&self, view_id: &str, row_id: &RowId) -> Fut<Option<(usize, Arc<Row>)>>;++ fn get_rows(&self, view_id: &str) -> Fut<Vec<Arc<Row>>>;++ fn get_cells_for_field(&self, view_id: &str, field_id: &str) -> Fut<Vec<Arc<RowCell>>>;++ fn get_cell_in_row(&self, field_id: &str, row_id: &RowId) -> Fut<Option<Arc<RowCell>>>;++ fn get_layout_for_view(&self, view_id: &str) -> DatabaseLayout;++ fn get_group_setting(&self, view_id: &str) -> Vec<GroupSetting>;++ fn insert_group_setting(&self, view_id: &str, setting: GroupSetting);++ fn get_sort(&self, view_id: &str, sort_id: &str) -> Option<Sort>;++ fn insert_sort(&self, view_id: &str, sort: Sort);++ fn remove_sort(&self, view_id: &str, sort_id: &str);++ fn get_all_sorts(&self, view_id: &str) -> Vec<Sort>;++ fn remove_all_sorts(&self, view_id: &str);++ fn get_all_filters(&self, view_id: &str) -> Vec<Arc<Filter>>;++ fn delete_filter(&self, view_id: &str, filter_id: &str);++ fn insert_filter(&self, view_id: &str, filter: Filter);++ fn get_filter(&self, view_id: &str, filter_id: &str) -> Option<Filter>;++ fn get_filter_by_field_id(&self, view_id: &str, field_id: &str) -> Option<Filter>;++ fn get_layout_setting(&self, view_id: &str, layout_ty: &DatabaseLayout) -> Option<LayoutSetting>;++ fn insert_layout_setting(+ &self,+ view_id: &str,+ layout_ty: &DatabaseLayout,+ layout_setting: LayoutSetting,+ );++ /// Returns a `TaskDispatcher` used to poll a `Task`+ fn get_task_scheduler(&self) -> Arc<RwLock<TaskDispatcher>>;++ fn get_type_option_cell_handler(+ &self,+ field: &Field,+ field_type: &FieldType,+ ) -> Option<Box<dyn TypeOptionCellDataHandler>>;+}++pub struct DatabaseViewEditor {+ pub view_id: String,+ delegate: Arc<dyn DatabaseViewData>,+ group_controller: Arc<RwLock<Box<dyn GroupController>>>,+ filter_controller: Arc<FilterController>,+ sort_controller: Arc<RwLock<SortController>>,+ pub notifier: DatabaseViewChangedNotifier,+}++impl Drop for DatabaseViewEditor {+ fn drop(&mut self) {+ tracing::trace!("Drop {}", std::any::type_name::<Self>());+ }+}++impl DatabaseViewEditor {+ pub async fn new(+ view_id: String,+ delegate: Arc<dyn DatabaseViewData>,+ cell_cache: CellCache,+ ) -> FlowyResult<Self> {+ let (notifier, _) = broadcast::channel(100);+ tokio::spawn(DatabaseViewChangedReceiverRunner(Some(notifier.subscribe())).run());+ let group_controller = new_group_controller(view_id.clone(), delegate.clone()).await?;+ let group_controller = Arc::new(RwLock::new(group_controller));++ let filter_controller = make_filter_controller(+ &view_id,+ delegate.clone(),+ notifier.clone(),+ cell_cache.clone(),+ )+ .await;++ let sort_controller = make_sort_controller(+ &view_id,+ delegate.clone(),+ notifier.clone(),+ filter_controller.clone(),+ cell_cache,+ )+ .await;++ Ok(Self {+ view_id,+ delegate,+ group_controller,+ filter_controller,+ sort_controller,+ notifier,+ })+ }++ pub async fn close(&self) {+ self.sort_controller.write().await.close().await;+ self.filter_controller.close().await;+ }++ pub async fn v_will_create_row(&self, cells: &mut Cells, group_id: &Option<String>) {+ if group_id.is_none() {+ return;+ }+ let group_id = group_id.as_ref().unwrap();+ let _ = self+ .mut_group_controller(|group_controller, field| {+ group_controller.will_create_row(cells, &field, group_id);+ Ok(())+ })+ .await;+ }++ pub async fn v_did_create_row(&self, row: &Row, group_id: &Option<String>, index: usize) {+ // Send the group notification if the current view has groups+ match group_id.as_ref() {+ None => {},+ Some(group_id) => {+ self+ .group_controller+ .write()+ .await+ .did_create_row(row, group_id);+ let inserted_row = InsertedRowPB {+ row: RowPB::from(row),+ index: Some(index as i32),+ is_new: true,+ };+ let changeset = GroupRowsNotificationPB::insert(group_id.clone(), vec![inserted_row]);+ notify_did_update_group_rows(changeset).await;+ },+ }+ }++ #[tracing::instrument(level = "trace", skip_all)]+ pub async fn v_did_delete_row(&self, row: &Row) {+ // Send the group notification if the current view has groups;+ let result = self+ .mut_group_controller(|group_controller, field| {+ group_controller.did_delete_delete_row(row, &field)+ })+ .await;++ if let Some(result) = result {+ tracing::trace!("Delete row in view changeset: {:?}", result.row_changesets);+ for changeset in result.row_changesets {+ notify_did_update_group_rows(changeset).await;+ }+ }+ }++ pub async fn v_did_update_row(&self, old_row: &Option<Row>, row: &Row) {+ let result = self+ .mut_group_controller(|group_controller, field| {+ Ok(group_controller.did_update_group_row(old_row, row, &field))+ })+ .await;++ if let Some(Ok(result)) = result {+ let mut changeset = GroupChangesetPB {+ view_id: self.view_id.clone(),+ ..Default::default()+ };+ if let Some(inserted_group) = result.inserted_group {+ tracing::trace!("Create group after editing the row: {:?}", inserted_group);+ changeset.inserted_groups.push(inserted_group);+ }+ if let Some(delete_group) = result.deleted_group {+ tracing::trace!("Delete group after editing the row: {:?}", delete_group);+ changeset.deleted_groups.push(delete_group.group_id);+ }+ notify_did_update_groups(&self.view_id, changeset).await;++ tracing::trace!(+ "Group changesets after editing the row: {:?}",+ result.row_changesets+ );+ for changeset in result.row_changesets {+ notify_did_update_group_rows(changeset).await;+ }+ }++ let filter_controller = self.filter_controller.clone();+ let sort_controller = self.sort_controller.clone();+ let row_id = row.id.clone();+ tokio::spawn(async move {+ filter_controller+ .did_receive_row_changed(row_id.clone())+ .await;+ sort_controller+ .read()+ .await+ .did_receive_row_changed(row_id)+ .await;+ });+ }++ pub async fn v_filter_rows(&self, rows: &mut Vec<Arc<Row>>) {+ self.filter_controller.filter_rows(rows).await+ }++ pub async fn v_sort_rows(&self, rows: &mut Vec<Arc<Row>>) {+ self.sort_controller.write().await.sort_rows(rows).await+ }++ pub async fn v_get_rows(&self) -> Vec<Arc<Row>> {+ let mut rows = self.delegate.get_rows(&self.view_id).await;+ self.v_filter_rows(&mut rows).await;+ self.v_sort_rows(&mut rows).await;+ rows+ }++ pub async fn v_move_group_row(+ &self,+ row: &Row,+ row_changeset: &mut RowChangeset,+ to_group_id: &str,+ to_row_id: Option<RowId>,+ ) {+ let result = self+ .mut_group_controller(|group_controller, field| {+ let move_row_context = MoveGroupRowContext {+ row,+ row_changeset,+ field: field.as_ref(),+ to_group_id,+ to_row_id,+ };+ group_controller.move_group_row(move_row_context)+ })+ .await;++ if let Some(result) = result {+ let mut changeset = GroupChangesetPB {+ view_id: self.view_id.clone(),+ ..Default::default()+ };+ if let Some(delete_group) = result.deleted_group {+ tracing::info!("Delete group after moving the row: {:?}", delete_group);+ changeset.deleted_groups.push(delete_group.group_id);+ }+ notify_did_update_groups(&self.view_id, changeset).await;++ for changeset in result.row_changesets {+ notify_did_update_group_rows(changeset).await;+ }+ }+ }+ /// Only call once after database view editor initialized+ #[tracing::instrument(level = "trace", skip(self))]+ pub async fn v_load_groups(&self) -> FlowyResult<Vec<GroupPB>> {+ let groups = self+ .group_controller+ .read()+ .await+ .groups()+ .into_iter()+ .map(|group_data| GroupPB::from(group_data.clone()))+ .collect::<Vec<_>>();+ tracing::trace!("Number of groups: {}", groups.len());+ Ok(groups)+ }++ #[tracing::instrument(level = "trace", skip(self))]+ pub async fn v_get_group(&self, group_id: &str) -> FlowyResult<GroupPB> {+ match self.group_controller.read().await.get_group(group_id) {+ None => Err(FlowyError::record_not_found().context("Can't find the group")),+ Some((_, group)) => Ok(GroupPB::from(group)),+ }+ }++ #[tracing::instrument(level = "trace", skip(self), err)]+ pub async fn v_move_group(&self, from_group: &str, to_group: &str) -> FlowyResult<()> {+ self+ .group_controller+ .write()+ .await+ .move_group(from_group, to_group)?;+ match self.group_controller.read().await.get_group(from_group) {+ None => tracing::warn!("Can not find the group with id: {}", from_group),+ Some((index, group)) => {+ let inserted_group = InsertedGroupPB {+ group: GroupPB::from(group),+ index: index as i32,+ };++ let changeset = GroupChangesetPB {+ view_id: self.view_id.clone(),+ inserted_groups: vec![inserted_group],+ deleted_groups: vec![from_group.to_string()],+ update_groups: vec![],+ initial_groups: vec![],+ };++ notify_did_update_groups(&self.view_id, changeset).await;+ },+ }+ Ok(())+ }++ pub async fn group_id(&self) -> String {+ self.group_controller.read().await.field_id().to_string()+ }++ pub async fn v_initialize_new_group(&self, params: InsertGroupParams) -> FlowyResult<()> {+ if self.group_controller.read().await.field_id() != params.field_id {+ self.v_update_group_setting(¶ms.field_id).await?;++ if let Some(view) = self.delegate.get_view_setting(&self.view_id).await {+ let setting = database_view_setting_pb_from_view(view);+ notify_did_update_setting(&self.view_id, setting).await;+ }+ }+ Ok(())+ }++ pub async fn v_delete_group(&self, _params: DeleteGroupParams) -> FlowyResult<()> {+ Ok(())+ }++ pub async fn v_get_all_sorts(&self) -> Vec<Sort> {+ self.delegate.get_all_sorts(&self.view_id)+ }++ #[tracing::instrument(level = "trace", skip(self), err)]+ pub async fn v_insert_sort(&self, params: AlterSortParams) -> FlowyResult<Sort> {+ let is_exist = params.sort_id.is_some();+ let sort_id = match params.sort_id {+ None => gen_database_sort_id(),+ Some(sort_id) => sort_id,+ };++ let sort = Sort {+ id: sort_id,+ field_id: params.field_id.clone(),+ field_type: params.field_type,+ condition: params.condition,+ };+ let sort_type = SortType::from(&sort);+ let mut sort_controller = self.sort_controller.write().await;+ self.delegate.insert_sort(&self.view_id, sort.clone());+ let changeset = if is_exist {+ sort_controller+ .did_receive_changes(SortChangeset::from_update(sort_type))+ .await+ } else {+ sort_controller+ .did_receive_changes(SortChangeset::from_insert(sort_type))+ .await+ };+ drop(sort_controller);+ notify_did_update_sort(changeset).await;+ Ok(sort)+ }++ pub async fn v_delete_sort(&self, params: DeleteSortParams) -> FlowyResult<()> {+ let notification = self+ .sort_controller+ .write()+ .await+ .did_receive_changes(SortChangeset::from_delete(DeletedSortType::from(+ params.clone(),+ )))+ .await;++ self.delegate.remove_sort(&self.view_id, ¶ms.sort_id);+ notify_did_update_sort(notification).await;+ Ok(())+ }++ pub async fn v_delete_all_sorts(&self) -> FlowyResult<()> {+ let all_sorts = self.v_get_all_sorts().await;+ self.delegate.remove_all_sorts(&self.view_id);++ let mut notification = SortChangesetNotificationPB::new(self.view_id.clone());+ notification.delete_sorts = all_sorts.into_iter().map(SortPB::from).collect();+ notify_did_update_sort(notification).await;+ Ok(())+ }++ pub async fn v_get_all_filters(&self) -> Vec<Arc<Filter>> {+ self.delegate.get_all_filters(&self.view_id)+ }++ #[tracing::instrument(level = "trace", skip(self), err)]+ pub async fn v_insert_filter(&self, params: AlterFilterParams) -> FlowyResult<()> {+ let is_exist = params.filter_id.is_some();+ let filter_id = match params.filter_id {+ None => gen_database_filter_id(),+ Some(filter_id) => filter_id,+ };+ let filter = Filter {+ id: filter_id.clone(),+ field_id: params.field_id.clone(),+ field_type: params.field_type,+ condition: params.condition,+ content: params.content,+ };+ let filter_type = FilterType::from(&filter);+ let filter_controller = self.filter_controller.clone();+ let changeset = if is_exist {+ let old_filter_type = self+ .delegate+ .get_filter(&self.view_id, &filter.id)+ .map(|field| FilterType::from(&field));++ self.delegate.insert_filter(&self.view_id, filter);+ filter_controller+ .did_receive_changes(FilterChangeset::from_update(UpdatedFilterType::new(+ old_filter_type,+ filter_type,+ )))+ .await+ } else {+ self.delegate.insert_filter(&self.view_id, filter);+ filter_controller+ .did_receive_changes(FilterChangeset::from_insert(filter_type))+ .await+ };+ drop(filter_controller);++ if let Some(changeset) = changeset {+ notify_did_update_filter(changeset).await;+ }+ Ok(())+ }++ #[tracing::instrument(level = "trace", skip(self), err)]+ pub async fn v_delete_filter(&self, params: DeleteFilterParams) -> FlowyResult<()> {+ let filter_type = params.filter_type;+ let changeset = self+ .filter_controller+ .did_receive_changes(FilterChangeset::from_delete(filter_type.clone()))+ .await;++ self+ .delegate+ .delete_filter(&self.view_id, &filter_type.filter_id);+ if changeset.is_some() {+ notify_did_update_filter(changeset.unwrap()).await;+ }+ Ok(())+ }++ pub async fn v_get_filter(&self, filter_id: &str) -> Option<Filter> {+ self.delegate.get_filter(&self.view_id, filter_id)+ }++ /// Returns the current calendar settings+ #[tracing::instrument(level = "debug", skip(self))]+ pub async fn v_get_layout_settings(&self, layout_ty: &DatabaseLayout) -> LayoutSettingParams {+ let mut layout_setting = LayoutSettingParams::default();+ match layout_ty {+ DatabaseLayout::Grid => {},+ DatabaseLayout::Board => {},+ DatabaseLayout::Calendar => {+ if let Some(value) = self.delegate.get_layout_setting(&self.view_id, layout_ty) {+ let calendar_setting = CalendarLayoutSetting::from(value);+ // Check the field exist or not+ if let Some(field) = self.delegate.get_field(&calendar_setting.field_id).await {+ let field_type = FieldType::from(field.field_type);++ // Check the type of field is Datetime or not+ if field_type == FieldType::DateTime {+ layout_setting.calendar = Some(calendar_setting);+ }+ }+ }+ },+ }++ tracing::debug!("{:?}", layout_setting);+ layout_setting+ }++ /// Update the calendar settings and send the notification to refresh the UI+ pub async fn v_set_layout_settings(+ &self,+ _layout_ty: &DatabaseLayout,+ params: LayoutSettingParams,+ ) -> FlowyResult<()> {+ // Maybe it needs no send notification to refresh the UI+ if let Some(new_calendar_setting) = params.calendar {+ if let Some(field) = self+ .delegate+ .get_field(&new_calendar_setting.field_id)+ .await+ {+ let field_type = FieldType::from(field.field_type);+ if field_type != FieldType::DateTime {+ return Err(FlowyError::unexpect_calendar_field_type());+ }++ let layout_ty = DatabaseLayout::Calendar;+ let old_calender_setting = self.v_get_layout_settings(&layout_ty).await.calendar;++ self.delegate.insert_layout_setting(+ &self.view_id,+ &layout_ty,+ new_calendar_setting.clone().into(),+ );+ let new_field_id = new_calendar_setting.field_id.clone();+ let layout_setting_pb: LayoutSettingPB = LayoutSettingParams {+ calendar: Some(new_calendar_setting),+ }+ .into();++ if let Some(old_calendar_setting) = old_calender_setting {+ // compare the new layout field id is equal to old layout field id+ // if not equal, send the DidSetNewLayoutField notification+ // if equal, send the DidUpdateLayoutSettings notification+ if old_calendar_setting.field_id != new_field_id {+ send_notification(&self.view_id, DatabaseNotification::DidSetNewLayoutField)+ .payload(layout_setting_pb)+ .send();+ } else {+ send_notification(&self.view_id, DatabaseNotification::DidUpdateLayoutSettings)+ .payload(layout_setting_pb)+ .send();+ }+ } else {+ tracing::warn!("Calendar setting should not be empty")+ }+ }+ }++ Ok(())+ }++ #[tracing::instrument(level = "trace", skip_all, err)]+ pub async fn v_did_update_field_type_option(+ &self,+ field_id: &str,+ old_field: &Field,+ ) -> FlowyResult<()> {+ if let Some(field) = self.delegate.get_field(field_id).await {+ self+ .sort_controller+ .read()+ .await+ .did_update_view_field_type_option(&field)+ .await;++ if let Some(filter) = self+ .delegate+ .get_filter_by_field_id(&self.view_id, field_id)+ {+ let mut old = FilterType::from(&filter);+ old.field_type = FieldType::from(old_field.field_type);+ let new = FilterType::from(&filter);+ let filter_type = UpdatedFilterType::new(Some(old), new);+ let filter_changeset = FilterChangeset::from_update(filter_type);+ let filter_controller = self.filter_controller.clone();+ let _ = tokio::spawn(async move {+ if let Some(notification) = filter_controller+ .did_receive_changes(filter_changeset)+ .await+ {+ notify_did_update_filter(notification).await;+ }+ });+ }+ }+ Ok(())+ }++ ///+ ///+ /// # Arguments+ ///+ /// * `field_id`:+ ///+ #[tracing::instrument(level = "debug", skip_all, err)]+ pub async fn v_update_group_setting(&self, field_id: &str) -> FlowyResult<()> {+ if let Some(field) = self.delegate.get_field(field_id).await {+ let new_group_controller =+ new_group_controller_with_field(self.view_id.clone(), self.delegate.clone(), field).await?;++ let new_groups = new_group_controller+ .groups()+ .into_iter()+ .map(|group| GroupPB::from(group.clone()))+ .collect();++ *self.group_controller.write().await = new_group_controller;+ let changeset = GroupChangesetPB {+ view_id: self.view_id.clone(),+ initial_groups: new_groups,+ ..Default::default()+ };++ debug_assert!(!changeset.is_empty());+ if !changeset.is_empty() {+ send_notification(&changeset.view_id, DatabaseNotification::DidGroupByField)+ .payload(changeset)+ .send();+ }+ }+ Ok(())+ }++ pub async fn v_get_calendar_event(&self, row_id: RowId) -> Option<CalendarEventPB> {+ let layout_ty = DatabaseLayout::Calendar;+ let calendar_setting = self.v_get_layout_settings(&layout_ty).await.calendar?;++ // Text+ let primary_field = self.delegate.get_primary_field().await?;+ let text_cell = get_cell_for_row(self.delegate.clone(), &primary_field.id, &row_id).await?;++ // Date+ let date_field = self.delegate.get_field(&calendar_setting.field_id).await?;++ let date_cell = get_cell_for_row(self.delegate.clone(), &date_field.id, &row_id).await?;+ let title = text_cell+ .into_text_field_cell_data()+ .unwrap_or_default()+ .into();++ let timestamp = date_cell+ .into_date_field_cell_data()+ .unwrap_or_default()+ .timestamp+ .unwrap_or_default();++ Some(CalendarEventPB {+ row_id: row_id.into_inner(),- title_field_id: primary_field.id.clone(),++ date_field_id: primary_field.id.clone(),+ title,+ timestamp,+ })+ }++ pub async fn v_get_all_calendar_events(&self) -> Option<Vec<CalendarEventPB>> {+ let layout_ty = DatabaseLayout::Calendar;+ let calendar_setting = self.v_get_layout_settings(&layout_ty).await.calendar?;++ // Text+ let primary_field = self.delegate.get_primary_field().await?;+ let text_cells =+ get_cells_for_field(self.delegate.clone(), &self.view_id, &primary_field.id).await;++ // Date+ let timestamp_by_row_id = get_cells_for_field(+ self.delegate.clone(),+ &self.view_id,+ &calendar_setting.field_id,+ )+ .await+ .into_iter()+ .map(|date_cell| {+ let row_id = date_cell.row_id.clone();++ // timestamp+ let timestamp = date_cell+ .into_date_field_cell_data()+ .map(|date_cell_data| date_cell_data.timestamp.unwrap_or_default())+ .unwrap_or_default();++ (row_id, timestamp)+ })+ .collect::<HashMap<RowId, i64>>();++ let mut events: Vec<CalendarEventPB> = vec![];+ for text_cell in text_cells {+ let title_field_id = text_cell.field_id.clone();+ let row_id = text_cell.row_id.clone();+ let timestamp = timestamp_by_row_id+ .get(&row_id)+ .cloned()+ .unwrap_or_default();++ let title = text_cell+ .into_text_field_cell_data()+ .unwrap_or_default()+ .into();++ let event = CalendarEventPB {+ row_id: row_id.into_inner(),- title_field_id,++ date_field_id: title_field_id,+ title,+ timestamp,+ };+ events.push(event);+ }+ Some(events)+ }++ pub async fn handle_block_event(&self, event: Cow<'_, DatabaseRowEvent>) {+ let changeset = match event.into_owned() {+ DatabaseRowEvent::InsertRow(row) => {+ RowsChangesetPB::from_insert(self.view_id.clone(), vec![row.into()])+ },+ DatabaseRowEvent::UpdateRow(row) => {+ RowsChangesetPB::from_update(self.view_id.clone(), vec![row.into()])+ },+ DatabaseRowEvent::DeleteRow(row_id) => {+ RowsChangesetPB::from_delete(self.view_id.clone(), vec![row_id.into_inner()])+ },+ DatabaseRowEvent::Move {+ deleted_row_id,+ inserted_row,+ } => RowsChangesetPB::from_move(+ self.view_id.clone(),+ vec![deleted_row_id.into_inner()],+ vec![inserted_row.into()],+ ),+ };++ send_notification(&self.view_id, DatabaseNotification::DidUpdateViewRows)+ .payload(changeset)+ .send();+ }++ async fn mut_group_controller<F, T>(&self, f: F) -> Option<T>+ where+ F: FnOnce(&mut Box<dyn GroupController>, Arc<Field>) -> FlowyResult<T>,+ {+ let group_field_id = self.group_controller.read().await.field_id().to_owned();+ match self.delegate.get_field(&group_field_id).await {+ None => None,+ Some(field) => {+ let mut write_guard = self.group_controller.write().await;+ f(&mut write_guard, field).ok()+ },+ }+ }+}diff --cc frontend/rust-lib/flowy-database2/src/services/database_view/view_group.rsindex 073bbd84ad,0000000000..69e64355f5mode 100644,000000..100644--- a/frontend/rust-lib/flowy-database2/src/services/database_view/view_group.rs+++ b/frontend/rust-lib/flowy-database2/src/services/database_view/view_group.rs@@@ -1,150 -1,0 +1,150 @@@+use std::sync::Arc;++use collab_database::fields::Field;+use collab_database::rows::RowId;++use flowy_error::FlowyResult;+use lib_infra::future::{to_fut, Fut};++use crate::entities::FieldType;+use crate::services::database_view::DatabaseViewData;+use crate::services::field::RowSingleCellData;+use crate::services::group::{+ find_new_grouping_field, make_group_controller, GroupController, GroupSetting,+ GroupSettingReader, GroupSettingWriter,+};++pub async fn new_group_controller_with_field(+ view_id: String,+ delegate: Arc<dyn DatabaseViewData>,+ grouping_field: Arc<Field>,+) -> FlowyResult<Box<dyn GroupController>> {+ let setting_reader = GroupSettingReaderImpl(delegate.clone());+ let rows = delegate.get_rows(&view_id).await;+ let setting_writer = GroupSettingWriterImpl(delegate.clone());+ make_group_controller(+ view_id,+ grouping_field,+ rows,+ setting_reader,+ setting_writer,+ )+ .await+}++pub async fn new_group_controller(+ view_id: String,+ delegate: Arc<dyn DatabaseViewData>,+) -> FlowyResult<Box<dyn GroupController>> {+ let setting_reader = GroupSettingReaderImpl(delegate.clone());+ let setting_writer = GroupSettingWriterImpl(delegate.clone());++ let fields = delegate.get_fields(&view_id, None).await;+ let rows = delegate.get_rows(&view_id).await;+ let layout = delegate.get_layout_for_view(&view_id);++ // Read the grouping field or find a new grouping field+ let grouping_field = setting_reader+ .get_group_setting(&view_id)+ .await+ .and_then(|setting| {+ fields+ .iter()+ .find(|field| field.id == setting.field_id)+ .cloned()+ })+ .unwrap_or_else(|| find_new_grouping_field(&fields, &layout).unwrap());++ make_group_controller(+ view_id,+ grouping_field,+ rows,+ setting_reader,+ setting_writer,+ )+ .await+}++pub(crate) struct GroupSettingReaderImpl(pub Arc<dyn DatabaseViewData>);++impl GroupSettingReader for GroupSettingReaderImpl {+ fn get_group_setting(&self, view_id: &str) -> Fut<Option<Arc<GroupSetting>>> {+ let mut settings = self.0.get_group_setting(view_id);+ to_fut(async move {+ if settings.is_empty() {+ None+ } else {+ Some(Arc::new(settings.remove(0)))+ }+ })+ }++ fn get_configuration_cells(&self, view_id: &str, field_id: &str) -> Fut<Vec<RowSingleCellData>> {+ let field_id = field_id.to_owned();+ let view_id = view_id.to_owned();+ let delegate = self.0.clone();+ to_fut(async move { get_cells_for_field(delegate, &view_id, &field_id).await })+ }+}++pub(crate) async fn get_cell_for_row(+ delegate: Arc<dyn DatabaseViewData>,+ field_id: &str,+ row_id: &RowId,+) -> Option<RowSingleCellData> {+ let field = delegate.get_field(field_id).await?;- let cell = delegate.get_cell_in_row(field_id, &row_id).await?;++ let cell = delegate.get_cell_in_row(field_id, row_id).await?;+ let field_type = FieldType::from(field.field_type);++ if let Some(handler) = delegate.get_type_option_cell_handler(&field, &field_type) {+ return match handler.get_cell_data(&cell, &field_type, &field) {+ Ok(cell_data) => Some(RowSingleCellData {+ row_id: cell.row_id.clone(),+ field_id: field.id.clone(),+ field_type: field_type.clone(),+ cell_data,+ }),+ Err(_) => None,+ };+ }+ None+}++// Returns the list of cells corresponding to the given field.+pub(crate) async fn get_cells_for_field(+ delegate: Arc<dyn DatabaseViewData>,+ view_id: &str,+ field_id: &str,+) -> Vec<RowSingleCellData> {+ if let Some(field) = delegate.get_field(field_id).await {+ let field_type = FieldType::from(field.field_type);+ if let Some(handler) = delegate.get_type_option_cell_handler(&field, &field_type) {+ let cells = delegate.get_cells_for_field(view_id, field_id).await;+ return cells+ .iter()+ .flat_map(+ |cell| match handler.get_cell_data(cell, &field_type, &field) {+ Ok(cell_data) => Some(RowSingleCellData {+ row_id: cell.row_id.clone(),+ field_id: field.id.clone(),+ field_type: field_type.clone(),+ cell_data,+ }),+ Err(_) => None,+ },+ )+ .collect();+ }+ }++ vec![]+}++struct GroupSettingWriterImpl(Arc<dyn DatabaseViewData>);++impl GroupSettingWriter for GroupSettingWriterImpl {+ fn save_configuration(&self, view_id: &str, group_setting: GroupSetting) -> Fut<FlowyResult<()>> {+ self.0.insert_group_setting(view_id, group_setting);+ to_fut(async move { Ok(()) })+ }+}