refactor: CellCalendar with bloc

Author: appflowy

frontend/app_flowy/lib/startup/deps_resolver.dart

@@ -153,13 +153,13 @@ void _resolveGridDeps(GetIt getIt) {
   getIt.registerFactoryParam<FieldActionSheetBloc, GridFieldCellContext, void>(
     (data, _) => FieldActionSheetBloc(
       field: data.field,
-      service: FieldService(gridId: data.gridId),
+      fieldService: FieldService(gridId: data.gridId, fieldId: data.field.id),
     ),
   );
 
   getIt.registerFactoryParam<FieldEditorBloc, String, EditFieldContextLoader>(
     (gridId, fieldLoader) => FieldEditorBloc(
-      service: FieldService(gridId: gridId),
+      gridId: gridId,
       fieldLoader: fieldLoader,
     ),
   );

frontend/app_flowy/lib/workspace/application/grid/cell/cell_service.dart

@@ -2,6 +2,7 @@ import 'dart:async';
 import 'dart:collection';
 
 import 'package:app_flowy/workspace/application/grid/cell/select_option_service.dart';
+import 'package:app_flowy/workspace/application/grid/field/field_service.dart';
 import 'package:dartz/dartz.dart';
 import 'package:equatable/equatable.dart';
 import 'package:flowy_sdk/dispatch/dispatch.dart';
@@ -12,7 +13,6 @@ import 'package:flowy_sdk/protobuf/flowy-grid/cell_entities.pb.dart';
 import 'package:flowy_sdk/protobuf/flowy-grid/selection_type_option.pb.dart';
 import 'package:flutter/foundation.dart';
 import 'package:freezed_annotation/freezed_annotation.dart';
-
 import 'package:app_flowy/workspace/application/grid/cell/cell_listener.dart';
 
 part 'cell_service.freezed.dart';
@@ -59,15 +59,16 @@ class GridCellContextBuilder {
 }
 
 // ignore: must_be_immutable
-class GridCellContext<C> extends Equatable {
+class GridCellContext<T> extends Equatable {
   final GridCell gridCell;
   final GridCellCache cellCache;
   final GridCellCacheKey _cacheKey;
-  final GridCellDataLoader<C> cellDataLoader;
+  final GridCellDataLoader<T> cellDataLoader;
   final CellService _cellService = CellService();
+  final FieldService _fieldService;
 
   late final CellListener _cellListener;
-  late final ValueNotifier<C?> _cellDataNotifier;
+  late final ValueNotifier<T?> _cellDataNotifier;
   bool isListening = false;
   VoidCallback? _onFieldChangedFn;
   Timer? _delayOperation;
@@ -76,9 +77,10 @@ class GridCellContext<C> extends Equatable {
     required this.gridCell,
     required this.cellCache,
     required this.cellDataLoader,
-  }) : _cacheKey = GridCellCacheKey(objectId: gridCell.rowId, fieldId: gridCell.field.id);
+  })  : _fieldService = FieldService(gridId: gridCell.gridId, fieldId: gridCell.field.id),
+        _cacheKey = GridCellCacheKey(objectId: gridCell.rowId, fieldId: gridCell.field.id);
 
-  GridCellContext<C> clone() {
+  GridCellContext<T> clone() {
     return GridCellContext(
       gridCell: gridCell,
       cellDataLoader: cellDataLoader,
@@ -98,16 +100,14 @@ class GridCellContext<C> extends Equatable {
 
   FieldType get fieldType => gridCell.field.fieldType;
 
-  GridCellCacheKey get cacheKey => _cacheKey;
-
-  VoidCallback? startListening({required void Function(C) onCellChanged}) {
+  VoidCallback? startListening({required void Function(T) onCellChanged}) {
     if (isListening) {
       Log.error("Already started. It seems like you should call clone first");
       return null;
     }
 
     isListening = true;
-    _cellDataNotifier = ValueNotifier(cellCache.get(cacheKey));
+    _cellDataNotifier = ValueNotifier(cellCache.get(_cacheKey));
     _cellListener = CellListener(rowId: gridCell.rowId, fieldId: gridCell.field.id);
     _cellListener.start(onCellChanged: (result) {
       result.fold(
@@ -120,12 +120,12 @@ class GridCellContext<C> extends Equatable {
       _onFieldChangedFn = () {
         _loadData();
       };
-      cellCache.addListener(cacheKey, _onFieldChangedFn!);
+      cellCache.addListener(_cacheKey, _onFieldChangedFn!);
     }
 
     onCellChangedFn() {
       final value = _cellDataNotifier.value;
-      if (value is C) {
+      if (value is T) {
         onCellChanged(value);
       }
 
@@ -142,14 +142,18 @@ class GridCellContext<C> extends Equatable {
     _cellDataNotifier.removeListener(fn);
   }
 
-  C? getCellData() {
-    final data = cellCache.get(cacheKey);
+  T? getCellData() {
+    final data = cellCache.get(_cacheKey);
     if (data == null) {
       _loadData();
     }
     return data;
   }
 
+  Future<Either<List<int>, FlowyError>> getTypeOptionData() {
+    return _fieldService.getTypeOptionData(fieldType: fieldType);
+  }
+
   void saveCellData(String data) {
     _cellService.updateCell(gridId: gridId, fieldId: field.id, rowId: rowId, data: data).then((result) {
       result.fold((l) => null, (err) => Log.error(err));
@@ -161,7 +165,7 @@ class GridCellContext<C> extends Equatable {
     _delayOperation = Timer(const Duration(milliseconds: 10), () {
       cellDataLoader.loadData().then((data) {
         _cellDataNotifier.value = data;
-        cellCache.insert(GridCellCacheData(key: cacheKey, object: data));
+        cellCache.insert(GridCellCacheData(key: _cacheKey, object: data));
       });
     });
   }
@@ -170,13 +174,13 @@ class GridCellContext<C> extends Equatable {
     _delayOperation?.cancel();
 
     if (_onFieldChangedFn != null) {
-      cellCache.removeListener(cacheKey, _onFieldChangedFn!);
+      cellCache.removeListener(_cacheKey, _onFieldChangedFn!);
       _onFieldChangedFn = null;
     }
   }
 
   @override
-  List<Object> get props => [cellCache.get(cacheKey) ?? "", cellId];
+  List<Object> get props => [cellCache.get(_cacheKey) ?? "", cellId];
 }
 
 abstract class GridCellDataLoader<T> {

frontend/app_flowy/lib/workspace/application/grid/cell/date_cal_bloc.dart

@@ -0,0 +1,95 @@
+import 'package:flowy_sdk/protobuf/flowy-grid-data-model/grid.pb.dart' show Cell, Field;
+import 'package:flowy_sdk/protobuf/flowy-grid/date_type_option.pb.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:freezed_annotation/freezed_annotation.dart';
+import 'package:table_calendar/table_calendar.dart';
+import 'dart:async';
+import 'cell_service.dart';
+import 'package:dartz/dartz.dart';
+part 'date_cal_bloc.freezed.dart';
+
+class DateCalBloc extends Bloc<DateCalEvent, DateCalState> {
+  final GridDefaultCellContext cellContext;
+  void Function()? _onCellChangedFn;
+
+  DateCalBloc({required this.cellContext}) : super(DateCalState.initial(cellContext)) {
+    on<DateCalEvent>(
+      (event, emit) async {
+        event.map(
+          initial: (_Initial value) {
+            _startListening();
+          },
+          selectDay: (_SelectDay value) {
+            if (!isSameDay(state.selectedDay, value.day)) {
+              _updateCellData(value.day);
+              emit(state.copyWith(selectedDay: value.day));
+            }
+          },
+          setFormat: (_CalendarFormat value) {
+            emit(state.copyWith(format: value.format));
+          },
+          setFocusedDay: (_FocusedDay value) {
+            emit(state.copyWith(focusedDay: value.day));
+          },
+          didReceiveCellUpdate: (_DidReceiveCellUpdate value) {},
+          didReceiveFieldUpdate: (_DidReceiveFieldUpdate value) {
+            emit(state.copyWith(field: value.field));
+          },
+        );
+      },
+    );
+  }
+
+  @override
+  Future<void> close() async {
+    if (_onCellChangedFn != null) {
+      cellContext.removeListener(_onCellChangedFn!);
+      _onCellChangedFn = null;
+    }
+    cellContext.dispose();
+    return super.close();
+  }
+
+  void _startListening() {
+    _onCellChangedFn = cellContext.startListening(
+      onCellChanged: ((cell) {
+        if (!isClosed) {
+          add(DateCalEvent.didReceiveCellUpdate(cell));
+        }
+      }),
+    );
+  }
+
+  void _updateCellData(DateTime day) {
+    final data = day.millisecondsSinceEpoch ~/ 1000;
+    cellContext.saveCellData(data.toString());
+  }
+}
+
+@freezed
+class DateCalEvent with _$DateCalEvent {
+  const factory DateCalEvent.initial() = _Initial;
+  const factory DateCalEvent.selectDay(DateTime day) = _SelectDay;
+  const factory DateCalEvent.setFormat(CalendarFormat format) = _CalendarFormat;
+  const factory DateCalEvent.setFocusedDay(DateTime day) = _FocusedDay;
+  const factory DateCalEvent.didReceiveCellUpdate(Cell cell) = _DidReceiveCellUpdate;
+  const factory DateCalEvent.didReceiveFieldUpdate(Field field) = _DidReceiveFieldUpdate;
+}
+
+@freezed
+class DateCalState with _$DateCalState {
+  const factory DateCalState({
+    required Field field,
+    required Option<DateTypeOption> typeOptinoData,
+    required CalendarFormat format,
+    required DateTime focusedDay,
+    DateTime? selectedDay,
+  }) = _DateCalState;
+
+  factory DateCalState.initial(GridCellContext context) => DateCalState(
+        field: context.field,
+        typeOptinoData: none(),
+        format: CalendarFormat.month,
+        focusedDay: DateTime.now(),
+      );
+}

frontend/app_flowy/lib/workspace/application/grid/cell/date_cell_bloc.dart

@@ -3,7 +3,6 @@ import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:freezed_annotation/freezed_annotation.dart';
 import 'dart:async';
 import 'cell_service.dart';
-
 part 'date_cell_bloc.freezed.dart';
 
 class DateCellBloc extends Bloc<DateCellEvent, DateCellState> {
@@ -72,7 +71,6 @@ class DateCellState with _$DateCellState {
   const factory DateCellState({
     required String content,
     required Field field,
-    DateTime? selectedDay,
   }) = _DateCellState;
 
   factory DateCellState.initial(GridCellContext context) => DateCellState(

frontend/app_flowy/lib/workspace/application/grid/field/field_action_sheet_bloc.dart

@@ -8,36 +8,36 @@ import 'field_service.dart';
 part 'field_action_sheet_bloc.freezed.dart';
 
 class FieldActionSheetBloc extends Bloc<FieldActionSheetEvent, FieldActionSheetState> {
-  final FieldService service;
+  final FieldService fieldService;
 
-  FieldActionSheetBloc({required Field field, required this.service})
+  FieldActionSheetBloc({required Field field, required this.fieldService})
       : super(FieldActionSheetState.initial(EditFieldContext.create()..gridField = field)) {
     on<FieldActionSheetEvent>(
       (event, emit) async {
         await event.map(
           updateFieldName: (_UpdateFieldName value) async {
-            final result = await service.updateField(fieldId: field.id, name: value.name);
+            final result = await fieldService.updateField(name: value.name);
             result.fold(
               (l) => null,
               (err) => Log.error(err),
             );
           },
           hideField: (_HideField value) async {
-            final result = await service.updateField(fieldId: field.id, visibility: false);
+            final result = await fieldService.updateField(visibility: false);
             result.fold(
               (l) => null,
               (err) => Log.error(err),
             );
           },
           deleteField: (_DeleteField value) async {
-            final result = await service.deleteField(fieldId: field.id);
+            final result = await fieldService.deleteField();
             result.fold(
               (l) => null,
               (err) => Log.error(err),
             );
           },
           duplicateField: (_DuplicateField value) async {
-            final result = await service.duplicateField(fieldId: field.id);
+            final result = await fieldService.duplicateField();
             result.fold(
               (l) => null,
               (err) => Log.error(err),

frontend/app_flowy/lib/workspace/application/grid/field/field_cell_bloc.dart

@@ -15,7 +15,7 @@ class FieldCellBloc extends Bloc<FieldCellEvent, FieldCellState> {
   FieldCellBloc({
     required GridFieldCellContext cellContext,
   })  : _fieldListener = SingleFieldListener(fieldId: cellContext.field.id),
-        _fieldService = FieldService(gridId: cellContext.gridId),
+        _fieldService = FieldService(gridId: cellContext.gridId, fieldId: cellContext.field.id),
         super(FieldCellState.initial(cellContext)) {
     on<FieldCellEvent>(
       (event, emit) async {
@@ -30,7 +30,7 @@ class FieldCellBloc extends Bloc<FieldCellEvent, FieldCellState> {
             final defaultWidth = state.field.width.toDouble();
             final width = defaultWidth + value.offset;
             if (width > defaultWidth && width < 300) {
-              _fieldService.updateField(fieldId: state.field.id, width: width);
+              _fieldService.updateField(width: width);
             }
           },
         );

frontend/app_flowy/lib/workspace/application/grid/field/field_editor_bloc.dart

@@ -11,14 +11,14 @@ import 'package:protobuf/protobuf.dart';
 part 'field_editor_bloc.freezed.dart';
 
 class FieldEditorBloc extends Bloc<FieldEditorEvent, FieldEditorState> {
-  final FieldService service;
+  final String gridId;
   final EditFieldContextLoader _loader;
 
   FieldEditorBloc({
-    required this.service,
+    required this.gridId,
     required EditFieldContextLoader fieldLoader,
   })  : _loader = fieldLoader,
-        super(FieldEditorState.initial(service.gridId)) {
+        super(FieldEditorState.initial(gridId)) {
     on<FieldEditorEvent>(
       (event, emit) async {
         await event.map(
@@ -73,7 +73,9 @@ class FieldEditorBloc extends Bloc<FieldEditorEvent, FieldEditorState> {
             newContext.typeOptionData = typeOptionData;
           }
         });
-        service.insertField(
+
+        FieldService.insertField(
+          gridId: gridId,
           field: newContext.gridField,
           typeOptionData: newContext.typeOptionData,
         );
@@ -87,7 +89,8 @@ class FieldEditorBloc extends Bloc<FieldEditorEvent, FieldEditorState> {
     await state.editFieldContext.fold(
       () async => null,
       (context) async {
-        final result = await service.insertField(
+        final result = await FieldService.insertField(
+          gridId: gridId,
           field: context.gridField,
           typeOptionData: context.typeOptionData,
         );