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

refactor: different TypeOption between DateTime and LastModified/CreatedAt (#3356)

Browse Source 
* fix: stringify date cell includes time if true

* refactor: LastModified and CreatedAt type option

* chore: frontend implementation

* chore: some adjustments and fix tests

* fix: integration tests

* chore: timestamp type option ui
This commit is contained in:
Richard Shiue 2023-09-08 10:07:24 +08:00 committed by GitHub
parent a0fc4b86b0
commit 8bcc6384f2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
42 changed files with 1256 additions and 289 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
frontend/appflowy_flutter/integration_test/database_cell_test.dart
View File

@ -218,7 +218,6 @@ void main() {
await tester.assertDateCellInGrid(
rowIndex: 0,
fieldType: fieldType,
content: DateFormat('MMM dd, y').format(today),
);
@ -233,7 +232,6 @@ void main() {
await tester.assertDateCellInGrid(
rowIndex: 0,
fieldType: fieldType,
content: DateFormat('MMM dd, y HH:mm').format(now),
);
@ -247,7 +245,6 @@ void main() {
await tester.assertDateCellInGrid(
rowIndex: 0,
fieldType: fieldType,
content: DateFormat('dd/MM/y HH:mm').format(now),
);
@ -261,7 +258,6 @@ void main() {
await tester.assertDateCellInGrid(
rowIndex: 0,
fieldType: fieldType,
content: DateFormat('dd/MM/y hh:mm a').format(now),
);
@ -273,7 +269,6 @@ void main() {
await tester.assertDateCellInGrid(
rowIndex: 0,
fieldType: fieldType,
content: '',
);

1
frontend/appflowy_flutter/integration_test/database_share_test.dart
View File

@ -157,7 +157,6 @@ void main() {
for (final (index, content) in dateCells.indexed) {
await tester.assertDateCellInGrid(
rowIndex: index,
fieldType: FieldType.DateTime,
content: content,
);
}

8
frontend/appflowy_flutter/integration_test/util/database_test_op.dart
View File

@ -43,6 +43,7 @@ import 'package:appflowy/plugins/database_view/widgets/row/cells/date_cell/date_
import 'package:appflowy/plugins/database_view/widgets/row/cells/select_option_cell/extension.dart';
import 'package:appflowy/plugins/database_view/widgets/row/cells/select_option_cell/select_option_editor.dart';
import 'package:appflowy/plugins/database_view/widgets/row/cells/select_option_cell/text_field.dart';
import 'package:appflowy/plugins/database_view/widgets/row/cells/timestamp_cell/timestamp_cell.dart';
import 'package:appflowy/plugins/database_view/widgets/row/row_action.dart';
import 'package:appflowy/plugins/database_view/widgets/row/row_banner.dart';
import 'package:appflowy/plugins/database_view/widgets/row/row_detail.dart';
@ -262,15 +263,12 @@ extension AppFlowyDatabaseTest on WidgetTester {
Future<void> assertDateCellInGrid({
required int rowIndex,
required FieldType fieldType,
required String content,
}) async {
final findRow = find.byType(GridRow, skipOffstage: false);
final findCell = find.descendant(
of: findRow.at(rowIndex),
matching: find.byWidgetPredicate(
(widget) => widget is GridDateCell && widget.fieldType == fieldType,
),
matching: find.byType(GridDateCell),
skipOffstage: false,
);
@ -1287,7 +1285,7 @@ Finder finderForFieldType(FieldType fieldType) {
return find.byType(GridDateCell, skipOffstage: false);
case FieldType.LastEditedTime:
case FieldType.CreatedTime:
return find.byType(GridDateCell, skipOffstage: false);
return find.byType(GridTimestampCell, skipOffstage: false);
case FieldType.SingleSelect:
return find.byType(GridSingleSelectCell, skipOffstage: false);
case FieldType.MultiSelect:

19
frontend/appflowy_flutter/lib/plugins/database_view/application/cell/cell_controller_builder.dart
View File

@ -2,6 +2,7 @@ import 'package:appflowy_backend/protobuf/flowy-database2/checklist_entities.pb.
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/protobuf/flowy-database2/timestamp_entities.pb.dart';
import 'package:appflowy_backend/protobuf/flowy-database2/url_entities.pb.dart';
import 'cell_controller.dart';
@ -14,6 +15,7 @@ typedef SelectOptionCellController
= CellController<SelectOptionCellDataPB, String>;
typedef ChecklistCellController = CellController<ChecklistCellDataPB, String>;
typedef DateCellController = CellController<DateCellDataPB, String>;
typedef TimestampCellController = CellController<TimestampCellDataPB, String>;
typedef URLCellController = CellController<URLCellDataPB, String>;
class CellControllerBuilder {
@ -41,14 +43,11 @@ class CellControllerBuilder {
TextCellDataPersistence(cellContext: _cellContext),
);
case FieldType.DateTime:
case FieldType.LastEditedTime:
case FieldType.CreatedTime:
final cellDataLoader = CellDataLoader(
cellContext: _cellContext,
parser: DateCellDataParser(),
reloadOnFieldChanged: true,
);
return DateCellController(
cellContext: _cellContext,
cellCache: _cellCache,
@ -56,6 +55,20 @@ class CellControllerBuilder {
cellDataPersistence:
TextCellDataPersistence(cellContext: _cellContext),
);
case FieldType.LastEditedTime:
case FieldType.CreatedTime:
final cellDataLoader = CellDataLoader(
cellContext: _cellContext,
parser: TimestampCellDataParser(),
reloadOnFieldChanged: true,
);
return TimestampCellController(
cellContext: _cellContext,
cellCache: _cellCache,
cellDataLoader: cellDataLoader,
cellDataPersistence:
TextCellDataPersistence(cellContext: _cellContext),
);
case FieldType.Number:
final cellDataLoader = CellDataLoader(
cellContext: _cellContext,

10
frontend/appflowy_flutter/lib/plugins/database_view/application/cell/cell_data_loader.dart
View File

@ -73,6 +73,16 @@ class DateCellDataParser implements CellDataParser<DateCellDataPB> {
}
}
class TimestampCellDataParser implements CellDataParser<TimestampCellDataPB> {
@override
TimestampCellDataPB? parserData(List<int> data) {
if (data.isEmpty) {
return null;
}
return TimestampCellDataPB.fromBuffer(data);
}
}
class SelectOptionCellDataParser
implements CellDataParser<SelectOptionCellDataPB> {
@override

1
frontend/appflowy_flutter/lib/plugins/database_view/application/cell/cell_service.dart
View File

@ -4,6 +4,7 @@ import 'package:appflowy_backend/protobuf/flowy-database2/checklist_entities.pb.
import 'package:appflowy_backend/protobuf/flowy-database2/date_entities.pb.dart';
import 'package:appflowy_backend/protobuf/flowy-database2/row_entities.pb.dart';
import 'package:appflowy_backend/protobuf/flowy-database2/select_option.pb.dart';
import 'package:appflowy_backend/protobuf/flowy-database2/timestamp_entities.pb.dart';
import 'package:appflowy_backend/protobuf/flowy-database2/url_entities.pb.dart';
import 'package:dartz/dartz.dart';
import 'package:appflowy_backend/dispatch/dispatch.dart';

10
frontend/appflowy_flutter/lib/plugins/database_view/application/field/type_option/date_bloc.dart
View File

@ -27,13 +27,6 @@ class DateTypeOptionBloc
),
);
},
includeTime: (_IncludeTime value) {
emit(
state.copyWith(
typeOption: _updateTypeOption(includeTime: value.includeTime),
),
);
},
);
},
);
@ -42,7 +35,6 @@ class DateTypeOptionBloc
DateTypeOptionPB _updateTypeOption({
DateFormatPB? dateFormat,
TimeFormatPB? timeFormat,
bool? includeTime,
}) {
state.typeOption.freeze();
return state.typeOption.rebuild((typeOption) {
@ -63,8 +55,6 @@ class DateTypeOptionEvent with _$DateTypeOptionEvent {
_DidSelectDateFormat;
const factory DateTypeOptionEvent.didSelectTimeFormat(TimeFormatPB format) =
_DidSelectTimeFormat;
const factory DateTypeOptionEvent.includeTime(bool includeTime) =
_IncludeTime;
}
@freezed

76
frontend/appflowy_flutter/lib/plugins/database_view/application/field/type_option/timestamp_bloc.dart Normal file
View File

@ -0,0 +1,76 @@
import 'package:appflowy_backend/protobuf/flowy-database2/date_entities.pb.dart';
import 'package:appflowy_backend/protobuf/flowy-database2/timestamp_entities.pb.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:freezed_annotation/freezed_annotation.dart';
import 'package:protobuf/protobuf.dart';
import 'type_option_context.dart';
part 'timestamp_bloc.freezed.dart';
class TimestampTypeOptionBloc
extends Bloc<TimestampTypeOptionEvent, TimestampTypeOptionState> {
TimestampTypeOptionBloc({
required TimestampTypeOptionContext typeOptionContext,
}) : super(TimestampTypeOptionState.initial(typeOptionContext.typeOption)) {
on<TimestampTypeOptionEvent>(
(event, emit) async {
event.map(
didSelectDateFormat: (_DidSelectDateFormat value) {
_updateTypeOption(dateFormat: value.format, emit: emit);
},
didSelectTimeFormat: (_DidSelectTimeFormat value) {
_updateTypeOption(timeFormat: value.format, emit: emit);
},
includeTime: (_IncludeTime value) {
_updateTypeOption(includeTime: value.includeTime, emit: emit);
},
);
},
);
}
void _updateTypeOption({
DateFormatPB? dateFormat,
TimeFormatPB? timeFormat,
bool? includeTime,
required Emitter<TimestampTypeOptionState> emit,
}) {
state.typeOption.freeze();
final newTypeOption = state.typeOption.rebuild((typeOption) {
if (dateFormat != null) {
typeOption.dateFormat = dateFormat;
}
if (timeFormat != null) {
typeOption.timeFormat = timeFormat;
}
if (includeTime != null) {
typeOption.includeTime = includeTime;
}
});
emit(state.copyWith(typeOption: newTypeOption));
}
}
@freezed
class TimestampTypeOptionEvent with _$TimestampTypeOptionEvent {
const factory TimestampTypeOptionEvent.didSelectDateFormat(
DateFormatPB format,
) = _DidSelectDateFormat;
const factory TimestampTypeOptionEvent.didSelectTimeFormat(
TimeFormatPB format,
) = _DidSelectTimeFormat;
const factory TimestampTypeOptionEvent.includeTime(bool includeTime) =
_IncludeTime;
}
@freezed
class TimestampTypeOptionState with _$TimestampTypeOptionState {
const factory TimestampTypeOptionState({
required TimestampTypeOptionPB typeOption,
}) = _TimestampTypeOptionState;
factory TimestampTypeOptionState.initial(TimestampTypeOptionPB typeOption) =>
TimestampTypeOptionState(typeOption: typeOption);
}

14
frontend/appflowy_flutter/lib/plugins/database_view/application/field/type_option/type_option_context.dart
View File

@ -4,6 +4,7 @@ import 'package:appflowy_backend/protobuf/flowy-database2/date_entities.pb.dart'
import 'package:appflowy_backend/protobuf/flowy-database2/number_entities.pb.dart';
import 'package:appflowy_backend/protobuf/flowy-database2/select_option.pb.dart';
import 'package:appflowy_backend/protobuf/flowy-database2/text_entities.pb.dart';
import 'package:appflowy_backend/protobuf/flowy-database2/timestamp_entities.pb.dart';
import 'package:appflowy_backend/protobuf/flowy-database2/url_entities.pb.dart';
import 'package:appflowy_backend/protobuf/flowy-error/errors.pb.dart';
import 'package:appflowy_backend/protobuf/flowy-database2/field_entities.pb.dart';
@ -58,7 +59,7 @@ class URLTypeOptionWidgetDataParser extends TypeOptionParser<URLTypeOptionPB> {
}
}
// Date
// DateTime
typedef DateTypeOptionContext = TypeOptionContext<DateTypeOptionPB>;
class DateTypeOptionDataParser extends TypeOptionParser<DateTypeOptionPB> {
@ -68,6 +69,17 @@ class DateTypeOptionDataParser extends TypeOptionParser<DateTypeOptionPB> {
}
}
// LastModified and CreatedAt
typedef TimestampTypeOptionContext = TypeOptionContext<TimestampTypeOptionPB>;
class TimestampTypeOptionDataParser
extends TypeOptionParser<TimestampTypeOptionPB> {
@override
TimestampTypeOptionPB fromBuffer(List<int> buffer) {
return TimestampTypeOptionPB.fromBuffer(buffer);
}
}
// SingleSelect
typedef SingleSelectTypeOptionContext
= TypeOptionContext<SingleSelectTypeOptionPB>;

22
frontend/appflowy_flutter/lib/plugins/database_view/grid/presentation/widgets/header/type_option/builder.dart
View File

@ -8,6 +8,7 @@ import 'package:appflowy_backend/protobuf/flowy-database2/date_entities.pb.dart'
import 'package:appflowy_backend/protobuf/flowy-database2/number_entities.pb.dart';
import 'package:appflowy_backend/protobuf/flowy-database2/select_option.pb.dart';
import 'package:appflowy_backend/protobuf/flowy-database2/text_entities.pb.dart';
import 'package:appflowy_backend/protobuf/flowy-database2/timestamp_entities.pb.dart';
import 'package:appflowy_backend/protobuf/flowy-database2/url_entities.pb.dart';
import 'package:appflowy_popover/appflowy_popover.dart';
import 'package:protobuf/protobuf.dart' hide FieldInfo;
@ -20,6 +21,7 @@ import 'multi_select.dart';
import 'number.dart';
import 'rich_text.dart';
import 'single_select.dart';
import 'timestamp.dart';
import 'url.dart';
typedef TypeOptionData = Uint8List;
@ -73,8 +75,6 @@ TypeOptionWidgetBuilder makeTypeOptionWidgetBuilder({
),
);
case FieldType.DateTime:
case FieldType.LastEditedTime:
case FieldType.CreatedTime:
return DateTypeOptionWidgetBuilder(
makeTypeOptionContextWithDataController<DateTypeOptionPB>(
viewId: viewId,
@ -83,6 +83,16 @@ TypeOptionWidgetBuilder makeTypeOptionWidgetBuilder({
),
popoverMutex,
);
case FieldType.LastEditedTime:
case FieldType.CreatedTime:
return TimestampTypeOptionWidgetBuilder(
makeTypeOptionContextWithDataController<TimestampTypeOptionPB>(
viewId: viewId,
fieldType: fieldType,
dataController: dataController,
),
popoverMutex,
);
case FieldType.SingleSelect:
return SingleSelectTypeOptionWidgetBuilder(
makeTypeOptionContextWithDataController<SingleSelectTypeOptionPB>(
@ -203,12 +213,16 @@ TypeOptionContext<T>
dataParser: CheckboxTypeOptionWidgetDataParser(),
) as TypeOptionContext<T>;
case FieldType.DateTime:
case FieldType.LastEditedTime:
case FieldType.CreatedTime:
return DateTypeOptionContext(
dataController: dataController,
dataParser: DateTypeOptionDataParser(),
) as TypeOptionContext<T>;
case FieldType.LastEditedTime:
case FieldType.CreatedTime:
return TimestampTypeOptionContext(
dataController: dataController,
dataParser: TimestampTypeOptionDataParser(),
) as TypeOptionContext<T>;
case FieldType.SingleSelect:
return SingleSelectTypeOptionContext(
dataController: dataController,

179
frontend/appflowy_flutter/lib/plugins/database_view/grid/presentation/widgets/header/type_option/timestamp.dart Normal file
View File

@ -0,0 +1,179 @@
import 'package:appflowy/generated/flowy_svgs.g.dart';
import 'package:appflowy/generated/locale_keys.g.dart';
import 'package:appflowy/plugins/database_view/application/field/type_option/timestamp_bloc.dart';
import 'package:appflowy/plugins/database_view/application/field/type_option/type_option_context.dart';
import 'package:appflowy/plugins/database_view/grid/presentation/layout/sizes.dart';
import 'package:appflowy/plugins/database_view/grid/presentation/widgets/common/type_option_separator.dart';
import 'package:appflowy/plugins/database_view/grid/presentation/widgets/header/field_type_option_editor.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.pb.dart';
import 'package:appflowy_popover/appflowy_popover.dart';
import 'package:easy_localization/easy_localization.dart';
import 'package:flowy_infra_ui/flowy_infra_ui.dart';
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'builder.dart';
import 'date.dart';
class TimestampTypeOptionWidgetBuilder extends TypeOptionWidgetBuilder {
final TimestampTypeOptionWidget _widget;
TimestampTypeOptionWidgetBuilder(
TimestampTypeOptionContext typeOptionContext,
PopoverMutex popoverMutex,
) : _widget = TimestampTypeOptionWidget(
typeOptionContext: typeOptionContext,
popoverMutex: popoverMutex,
);
@override
Widget? build(BuildContext context) {
return _widget;
}
}
class TimestampTypeOptionWidget extends TypeOptionWidget {
final TimestampTypeOptionContext typeOptionContext;
final PopoverMutex popoverMutex;
const TimestampTypeOptionWidget({
required this.typeOptionContext,
required this.popoverMutex,
Key? key,
}) : super(key: key);
@override
Widget build(BuildContext context) {
return BlocProvider(
create: (context) =>
TimestampTypeOptionBloc(typeOptionContext: typeOptionContext),
child: BlocConsumer<TimestampTypeOptionBloc, TimestampTypeOptionState>(
listener: (context, state) =>
typeOptionContext.typeOption = state.typeOption,
builder: (context, state) {
final List<Widget> children = [
const TypeOptionSeparator(),
_renderDateFormatButton(context, state.typeOption.dateFormat),
_renderTimeFormatButton(context, state.typeOption.timeFormat),
Padding(
padding: const EdgeInsets.symmetric(horizontal: 12.0),
child: IncludeTimeButton(
onChanged: (value) => context
.read<TimestampTypeOptionBloc>()
.add(TimestampTypeOptionEvent.includeTime(!value)),
value: state.typeOption.includeTime,
),
),
];
return ListView.separated(
shrinkWrap: true,
separatorBuilder: (context, index) {
if (index == 0) {
return const SizedBox();
} else {
return VSpace(GridSize.typeOptionSeparatorHeight);
}
},
itemCount: children.length,
itemBuilder: (BuildContext context, int index) => children[index],
);
},
),
);
}
Widget _renderDateFormatButton(
BuildContext context,
DateFormatPB dataFormat,
) {
return AppFlowyPopover(
mutex: popoverMutex,
asBarrier: true,
triggerActions: PopoverTriggerFlags.hover | PopoverTriggerFlags.click,
offset: const Offset(8, 0),
constraints: BoxConstraints.loose(const Size(460, 440)),
popupBuilder: (popoverContext) {
return DateFormatList(
selectedFormat: dataFormat,
onSelected: (format) {
context
.read<TimestampTypeOptionBloc>()
.add(TimestampTypeOptionEvent.didSelectDateFormat(format));
PopoverContainer.of(popoverContext).close();
},
);
},
child: const Padding(
padding: EdgeInsets.symmetric(horizontal: 12.0),
child: DateFormatButton(),
),
);
}
Widget _renderTimeFormatButton(
BuildContext context,
TimeFormatPB timeFormat,
) {
return AppFlowyPopover(
mutex: popoverMutex,
asBarrier: true,
triggerActions: PopoverTriggerFlags.hover | PopoverTriggerFlags.click,
offset: const Offset(8, 0),
constraints: BoxConstraints.loose(const Size(460, 440)),
popupBuilder: (BuildContext popoverContext) {
return TimeFormatList(
selectedFormat: timeFormat,
onSelected: (format) {
context
.read<TimestampTypeOptionBloc>()
.add(TimestampTypeOptionEvent.didSelectTimeFormat(format));
PopoverContainer.of(popoverContext).close();
},
);
},
child: Padding(
padding: const EdgeInsets.symmetric(horizontal: 12.0),
child: TimeFormatButton(timeFormat: timeFormat),
),
);
}
}
class IncludeTimeButton extends StatelessWidget {
final bool value;
final Function(bool value) onChanged;
const IncludeTimeButton({
super.key,
required this.onChanged,
required this.value,
});
@override
Widget build(BuildContext context) {
return SizedBox(
height: GridSize.popoverItemHeight,
child: Padding(
padding: GridSize.typeOptionContentInsets,
child: Row(
children: [
FlowySvg(
FlowySvgs.clock_alarm_s,
color: Theme.of(context).iconTheme.color,
),
const HSpace(6),
FlowyText.medium(LocaleKeys.grid_field_includeTime.tr()),
const Spacer(),
Toggle(
value: value,
onChanged: onChanged,
style: ToggleStyle.big,
padding: EdgeInsets.zero,
),
],
),
),
);
}
}

80
frontend/appflowy_flutter/lib/plugins/database_view/widgets/card/bloc/timestamp_card_cell_bloc.dart Normal file
View File

@ -0,0 +1,80 @@
import 'package:appflowy/plugins/database_view/application/cell/cell_controller_builder.dart';
import 'package:appflowy/plugins/database_view/application/field/field_info.dart';
import 'package:appflowy_backend/protobuf/flowy-database2/timestamp_entities.pb.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:freezed_annotation/freezed_annotation.dart';
import 'dart:async';
part 'timestamp_card_cell_bloc.freezed.dart';
class TimestampCardCellBloc
extends Bloc<TimestampCardCellEvent, TimestampCardCellState> {
final TimestampCellController cellController;
void Function()? _onCellChangedFn;
TimestampCardCellBloc({required this.cellController})
: super(TimestampCardCellState.initial(cellController)) {
on<TimestampCardCellEvent>(
(event, emit) async {
event.when(
initial: () => _startListening(),
didReceiveCellUpdate: (TimestampCellDataPB? cellData) {
emit(
state.copyWith(
data: cellData,
dateStr: cellData?.dateTime ?? "",
),
);
},
);
},
);
}
@override
Future<void> close() async {
if (_onCellChangedFn != null) {
cellController.removeListener(_onCellChangedFn!);
_onCellChangedFn = null;
}
await cellController.dispose();
return super.close();
}
void _startListening() {
_onCellChangedFn = cellController.startListening(
onCellChanged: ((data) {
if (!isClosed) {
add(TimestampCardCellEvent.didReceiveCellUpdate(data));
}
}),
);
}
}
@freezed
class TimestampCardCellEvent with _$TimestampCardCellEvent {
const factory TimestampCardCellEvent.initial() = _InitialCell;
const factory TimestampCardCellEvent.didReceiveCellUpdate(
TimestampCellDataPB? data,
) = _DidReceiveCellUpdate;
}
@freezed
class TimestampCardCellState with _$TimestampCardCellState {
const factory TimestampCardCellState({
required TimestampCellDataPB? data,
required String dateStr,
required FieldInfo fieldInfo,
}) = _TimestampCardCellState;
factory TimestampCardCellState.initial(TimestampCellController context) {
final cellData = context.getCellData();
return TimestampCardCellState(
fieldInfo: context.fieldInfo,
data: cellData,
dateStr: cellData?.dateTime ?? "",
);
}
}

15
frontend/appflowy_flutter/lib/plugins/database_view/widgets/card/card_cell_builder.dart
View File

@ -10,6 +10,7 @@ import 'cells/date_card_cell.dart';
import 'cells/number_card_cell.dart';
import 'cells/select_option_card_cell.dart';
import 'cells/text_card_cell.dart';
import 'cells/timestamp_card_cell.dart';
import 'cells/url_card_cell.dart';
// T represents as the Generic card data
@ -39,13 +40,23 @@ class CardCellBuilder<CustomCardData> {
key: key,
);
case FieldType.DateTime:
case FieldType.LastEditedTime:
case FieldType.CreatedTime:
return DateCardCell<CustomCardData>(
renderHook: renderHook?.renderHook[FieldType.DateTime],
cellControllerBuilder: cellControllerBuilder,
key: key,
);
case FieldType.LastEditedTime:
return TimestampCardCell<CustomCardData>(
renderHook: renderHook?.renderHook[FieldType.LastEditedTime],
cellControllerBuilder: cellControllerBuilder,
key: key,
);
case FieldType.CreatedTime:
return TimestampCardCell<CustomCardData>(
renderHook: renderHook?.renderHook[FieldType.CreatedTime],
cellControllerBuilder: cellControllerBuilder,
key: key,
);
case FieldType.SingleSelect:
return SelectOptionCardCell<CustomCardData>(
renderHook: renderHook?.renderHook[FieldType.SingleSelect],

79
frontend/appflowy_flutter/lib/plugins/database_view/widgets/card/cells/timestamp_card_cell.dart Normal file
View File

@ -0,0 +1,79 @@
import 'package:appflowy/plugins/database_view/application/cell/cell_controller_builder.dart';
import 'package:appflowy/plugins/database_view/widgets/card/bloc/timestamp_card_cell_bloc.dart';
import 'package:flowy_infra_ui/style_widget/text.dart';
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import '../define.dart';
import 'card_cell.dart';
class TimestampCardCell<CustomCardData> extends CardCell {
final CellControllerBuilder cellControllerBuilder;
final CellRenderHook<dynamic, CustomCardData>? renderHook;
const TimestampCardCell({
required this.cellControllerBuilder,
this.renderHook,
Key? key,
}) : super(key: key);
@override
State<TimestampCardCell> createState() => _TimestampCardCellState();
}
class _TimestampCardCellState extends State<TimestampCardCell> {
late TimestampCardCellBloc _cellBloc;
@override
void initState() {
final cellController =
widget.cellControllerBuilder.build() as TimestampCellController;
_cellBloc = TimestampCardCellBloc(cellController: cellController)
..add(const TimestampCardCellEvent.initial());
super.initState();
}
@override
Widget build(BuildContext context) {
return BlocProvider.value(
value: _cellBloc,
child: BlocBuilder<TimestampCardCellBloc, TimestampCardCellState>(
buildWhen: (previous, current) => previous.dateStr != current.dateStr,
builder: (context, state) {
if (state.dateStr.isEmpty) {
return const SizedBox.shrink();
}
final Widget? custom = widget.renderHook?.call(
state.data,
widget.cardData,
context,
);
if (custom != null) {
return custom;
}
return Align(
alignment: Alignment.centerLeft,
child: Padding(
padding: EdgeInsets.symmetric(
vertical: CardSizes.cardCellVPadding,
),
child: FlowyText.regular(
state.dateStr,
fontSize: 13,
color: Theme.of(context).hintColor,
),
),
);
},
),
);
}
@override
Future<void> dispose() async {
_cellBloc.close();
super.dispose();
}
}

5
frontend/appflowy_flutter/lib/plugins/database_view/widgets/row/cell_builder.dart
View File

@ -11,6 +11,7 @@ import 'cells/date_cell/date_cell.dart';
import 'cells/number_cell/number_cell.dart';
import 'cells/select_option_cell/select_option_cell.dart';
import 'cells/text_cell/text_cell.dart';
import 'cells/timestamp_cell/timestamp_cell.dart';
import 'cells/url_cell/url_cell.dart';
/// Build the cell widget in Grid style.
@ -41,14 +42,12 @@ class GridCellBuilder {
cellControllerBuilder: cellControllerBuilder,
key: key,
style: style,
fieldType: cellContext.fieldType,
);
case FieldType.LastEditedTime:
case FieldType.CreatedTime:
return GridDateCell(
return GridTimestampCell(
cellControllerBuilder: cellControllerBuilder,
key: key,
editable: false,
style: style,
fieldType: cellContext.fieldType,
);

60
frontend/appflowy_flutter/lib/plugins/database_view/widgets/row/cells/date_cell/date_cell.dart
View File

@ -1,5 +1,4 @@
import 'package:appflowy/plugins/database_view/application/cell/cell_controller_builder.dart';
import 'package:appflowy_backend/protobuf/flowy-database2/field_entities.pbenum.dart';
import 'package:appflowy_popover/appflowy_popover.dart';
import 'package:flowy_infra_ui/flowy_infra_ui.dart';
import 'package:flutter/widgets.dart';
@ -22,20 +21,12 @@ abstract class GridCellDelegate {
}
class GridDateCell extends GridCellWidget {
final bool editable;
/// The [GridDateCell] is used by Field Type [FieldType.DateTime],
/// [FieldType.CreatedTime], [FieldType.LastEditedTime]. So it needs
/// to know the field type.
final FieldType fieldType;
final CellControllerBuilder cellControllerBuilder;
late final DateCellStyle? cellStyle;
GridDateCell({
GridCellStyle? style,
required this.fieldType,
required this.cellControllerBuilder,
this.editable = true,
Key? key,
}) : super(key: key) {
if (style != null) {
@ -72,33 +63,27 @@ class _DateCellState extends GridCellState<GridDateCell> {
value: _cellBloc,
child: BlocBuilder<DateCellBloc, DateCellState>(
builder: (context, state) {
Widget dateTextWidget = GridDateCellText(
dateStr: state.dateStr,
alignment: alignment,
return AppFlowyPopover(
controller: _popover,
triggerActions: PopoverTriggerFlags.none,
direction: PopoverDirection.bottomWithLeftAligned,
constraints: BoxConstraints.loose(const Size(260, 520)),
margin: EdgeInsets.zero,
child: GridDateCellText(
dateStr: state.dateStr,
alignment: alignment,
),
popupBuilder: (BuildContext popoverContent) {
return DateCellEditor(
cellController:
widget.cellControllerBuilder.build() as DateCellController,
onDismissed: () => widget.onCellFocus.value = false,
);
},
onClose: () {
widget.onCellFocus.value = false;
},
);
// If the cell is editable, wrap it in a popover.
if (widget.editable) {
dateTextWidget = AppFlowyPopover(
controller: _popover,
triggerActions: PopoverTriggerFlags.none,
direction: PopoverDirection.bottomWithLeftAligned,
constraints: BoxConstraints.loose(const Size(260, 520)),
margin: EdgeInsets.zero,
child: dateTextWidget,
popupBuilder: (BuildContext popoverContent) {
return DateCellEditor(
cellController: widget.cellControllerBuilder.build()
as DateCellController,
onDismissed: () => widget.onCellFocus.value = false,
);
},
onClose: () {
widget.onCellFocus.value = false;
},
);
}
return dateTextWidget;
},
),
);
@ -113,10 +98,7 @@ class _DateCellState extends GridCellState<GridDateCell> {
@override
void requestBeginFocus() {
_popover.show();
if (widget.editable) {
widget.onCellFocus.value = true;
}
widget.onCellFocus.value = true;
}
@override

32
frontend/appflowy_flutter/lib/plugins/database_view/widgets/row/cells/date_cell/date_editor.dart
View File

@ -2,8 +2,7 @@ import 'package:appflowy/generated/flowy_svgs.g.dart';
import 'package:appflowy/generated/locale_keys.g.dart';
import 'package:appflowy/plugins/database_view/application/cell/cell_controller_builder.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/plugins/database_view/grid/presentation/widgets/header/type_option/timestamp.dart';
import 'package:appflowy_backend/log.dart';
import 'package:appflowy_backend/protobuf/flowy-database2/date_entities.pb.dart';
import 'package:appflowy_backend/protobuf/flowy-error/errors.pbserver.dart';
@ -241,30 +240,11 @@ class _IncludeTimeButton extends StatelessWidget {
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: [
FlowySvg(
FlowySvgs.clock_alarm_s,
color: Theme.of(context).iconTheme.color,
),
const HSpace(6),
FlowyText.medium(LocaleKeys.grid_field_includeTime.tr()),
const Spacer(),
Toggle(
value: includeTime,
onChanged: (value) => context
.read<DateCellCalendarBloc>()
.add(DateCellCalendarEvent.setIncludeTime(!value)),
style: ToggleStyle.big,
padding: EdgeInsets.zero,
),
],
),
),
child: IncludeTimeButton(
onChanged: (value) => context
.read<DateCellCalendarBloc>()
.add(DateCellCalendarEvent.setIncludeTime(!value)),
value: includeTime,
),
);
},

109
frontend/appflowy_flutter/lib/plugins/database_view/widgets/row/cells/timestamp_cell/timestamp_cell.dart Normal file
View File

@ -0,0 +1,109 @@
import 'package:appflowy/plugins/database_view/application/cell/cell_controller_builder.dart';
import 'package:appflowy/plugins/database_view/grid/presentation/layout/sizes.dart';
import 'package:appflowy/plugins/database_view/widgets/row/cell_builder.dart';
import 'package:appflowy/plugins/database_view/widgets/row/cells/timestamp_cell/timestamp_cell_bloc.dart';
import 'package:appflowy_backend/protobuf/flowy-database2/field_entities.pbenum.dart';
import 'package:flowy_infra_ui/flowy_infra_ui.dart';
import 'package:flutter/widgets.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
class TimestampCellStyle extends GridCellStyle {
Alignment alignment;
TimestampCellStyle({this.alignment = Alignment.center});
}
class GridTimestampCell extends GridCellWidget {
/// The [GridTimestampCell] is used by both [FieldType.CreatedTime]
/// and [FieldType.LastEditedTime]. So it needs to know the field type.
final FieldType fieldType;
final CellControllerBuilder cellControllerBuilder;
late final TimestampCellStyle? cellStyle;
GridTimestampCell({
GridCellStyle? style,
required this.fieldType,
required this.cellControllerBuilder,
Key? key,
}) : super(key: key) {
if (style != null) {
cellStyle = (style as TimestampCellStyle);
} else {
cellStyle = null;
}
}
@override
GridCellState<GridTimestampCell> createState() => _TimestampCellState();
}
class _TimestampCellState extends GridCellState<GridTimestampCell> {
late TimestampCellBloc _cellBloc;
@override
void initState() {
final cellController =
widget.cellControllerBuilder.build() as TimestampCellController;
_cellBloc = TimestampCellBloc(cellController: cellController)
..add(const TimestampCellEvent.initial());
super.initState();
}
@override
Widget build(BuildContext context) {
final alignment = widget.cellStyle != null
? widget.cellStyle!.alignment
: Alignment.centerLeft;
return BlocProvider.value(
value: _cellBloc,
child: BlocBuilder<TimestampCellBloc, TimestampCellState>(
builder: (context, state) {
return GridTimestampCellText(
dateStr: state.dateStr,
alignment: alignment,
);
},
),
);
}
@override
Future<void> dispose() async {
_cellBloc.close();
super.dispose();
}
@override
String? onCopy() => _cellBloc.state.dateStr;
@override
void requestBeginFocus() {
return;
}
}
class GridTimestampCellText extends StatelessWidget {
final String dateStr;
final Alignment alignment;
const GridTimestampCellText({
required this.dateStr,
required this.alignment,
super.key,
});
@override
Widget build(BuildContext context) {
return SizedBox.expand(
child: Align(
alignment: alignment,
child: Padding(
padding: GridSize.cellContentInsets,
child: FlowyText.medium(
dateStr,
maxLines: null,
),
),
),
);
}
}

80
frontend/appflowy_flutter/lib/plugins/database_view/widgets/row/cells/timestamp_cell/timestamp_cell_bloc.dart Normal file
View File

@ -0,0 +1,80 @@
import 'dart:async';
import 'package:appflowy/plugins/database_view/application/cell/cell_controller_builder.dart';
import 'package:appflowy/plugins/database_view/application/field/field_info.dart';
import 'package:appflowy_backend/protobuf/flowy-database2/timestamp_entities.pb.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:freezed_annotation/freezed_annotation.dart';
part 'timestamp_cell_bloc.freezed.dart';
class TimestampCellBloc extends Bloc<TimestampCellEvent, TimestampCellState> {
final TimestampCellController cellController;
void Function()? _onCellChangedFn;
TimestampCellBloc({required this.cellController})
: super(TimestampCellState.initial(cellController)) {
on<TimestampCellEvent>(
(event, emit) async {
event.when(
initial: () => _startListening(),
didReceiveCellUpdate: (TimestampCellDataPB? cellData) {
emit(
state.copyWith(
data: cellData,
dateStr: cellData?.dateTime ?? "",
),
);
},
);
},
);
}
@override
Future<void> close() async {
if (_onCellChangedFn != null) {
cellController.removeListener(_onCellChangedFn!);
_onCellChangedFn = null;
}
await cellController.dispose();
return super.close();
}
void _startListening() {
_onCellChangedFn = cellController.startListening(
onCellChanged: ((data) {
if (!isClosed) {
add(TimestampCellEvent.didReceiveCellUpdate(data));
}
}),
);
}
}
@freezed
class TimestampCellEvent with _$TimestampCellEvent {
const factory TimestampCellEvent.initial() = _InitialCell;
const factory TimestampCellEvent.didReceiveCellUpdate(
TimestampCellDataPB? data,
) = _DidReceiveCellUpdate;
}
@freezed
class TimestampCellState with _$TimestampCellState {
const factory TimestampCellState({
required TimestampCellDataPB? data,
required String dateStr,
required FieldInfo fieldInfo,
}) = _TimestampCellState;
factory TimestampCellState.initial(TimestampCellController context) {
final cellData = context.getCellData();
return TimestampCellState(
fieldInfo: context.fieldInfo,
data: cellData,
dateStr: cellData?.dateTime ?? "",
);
}
}

6
frontend/appflowy_flutter/lib/plugins/database_view/widgets/row/row_property.dart
View File

@ -18,6 +18,7 @@ import 'cell_builder.dart';
import 'cells/date_cell/date_cell.dart';
import 'cells/select_option_cell/select_option_cell.dart';
import 'cells/text_cell/text_cell.dart';
import 'cells/timestamp_cell/timestamp_cell.dart';
import 'cells/url_cell/url_cell.dart';
/// Display the row properties in a list. Only use this widget in the
@ -156,9 +157,12 @@ GridCellStyle? _customCellStyle(FieldType fieldType) {
case FieldType.Checkbox:
return null;
case FieldType.DateTime:
return DateCellStyle(
alignment: Alignment.centerLeft,
);
case FieldType.LastEditedTime:
case FieldType.CreatedTime:
return DateCellStyle(
return TimestampCellStyle(
alignment: Alignment.centerLeft,
);
case FieldType.MultiSelect:

7
frontend/rust-lib/flowy-database2/src/entities/type_option_entities/date_entities.rs
View File

@ -4,7 +4,7 @@ use strum_macros::EnumIter;
use flowy_derive::{ProtoBuf, ProtoBuf_Enum};
use crate::entities::{CellIdPB, FieldType};
use crate::entities::CellIdPB;
use crate::services::field::{DateFormat, DateTypeOption, TimeFormat};
#[derive(Clone, Debug, Default, ProtoBuf)]
@ -51,9 +51,6 @@ pub struct DateTypeOptionPB {
#[pb(index = 3)]
pub timezone_id: String,
#[pb(index = 4)]
pub field_type: FieldType,
}
impl From<DateTypeOption> for DateTypeOptionPB {
@ -62,7 +59,6 @@ impl From<DateTypeOption> for DateTypeOptionPB {
date_format: data.date_format.into(),
time_format: data.time_format.into(),
timezone_id: data.timezone_id,
field_type: data.field_type,
}
}
}
@ -73,7 +69,6 @@ impl From<DateTypeOptionPB> for DateTypeOption {
date_format: data.date_format.into(),
time_format: data.time_format.into(),
timezone_id: data.timezone_id,
field_type: data.field_type,
}
}
}

2
frontend/rust-lib/flowy-database2/src/entities/type_option_entities/mod.rs
View File

@ -4,6 +4,7 @@ mod date_entities;
mod number_entities;
mod select_option;
mod text_entities;
mod timestamp_entities;
mod url_entities;
pub use checkbox_entities::*;
@ -12,4 +13,5 @@ pub use date_entities::*;
pub use number_entities::*;
pub use select_option::*;
pub use text_entities::*;
pub use timestamp_entities::*;
pub use url_entities::*;

50
frontend/rust-lib/flowy-database2/src/entities/type_option_entities/timestamp_entities.rs Normal file
View File

@ -0,0 +1,50 @@
use flowy_derive::ProtoBuf;
use crate::entities::{DateFormatPB, FieldType, TimeFormatPB};
use crate::services::field::TimestampTypeOption;
#[derive(Clone, Debug, Default, ProtoBuf)]
pub struct TimestampCellDataPB {
#[pb(index = 1)]
pub date_time: String,
#[pb(index = 2, one_of)]
pub timestamp: Option<i64>,
}
#[derive(Clone, Debug, Default, ProtoBuf)]
pub struct TimestampTypeOptionPB {
#[pb(index = 1)]
pub date_format: DateFormatPB,
#[pb(index = 2)]
pub time_format: TimeFormatPB,
#[pb(index = 3)]
pub include_time: bool,
#[pb(index = 4)]
pub field_type: FieldType,
}
impl From<TimestampTypeOption> for TimestampTypeOptionPB {
fn from(data: TimestampTypeOption) -> Self {
Self {
date_format: data.date_format.into(),
time_format: data.time_format.into(),
include_time: data.include_time,
field_type: data.field_type,
}
}
}
impl From<TimestampTypeOptionPB> for TimestampTypeOption {
fn from(data: TimestampTypeOptionPB) -> Self {
Self {
date_format: data.date_format.into(),
time_format: data.time_format.into(),
include_time: data.include_time,
field_type: data.field_type,
}
}
}

12
frontend/rust-lib/flowy-database2/src/services/database/database_editor.rs
View File

@ -24,8 +24,8 @@ use crate::services::database_view::{DatabaseViewChanged, DatabaseViewData, Data
use crate::services::field::checklist_type_option::{ChecklistCellChangeset, ChecklistCellData};
use crate::services::field::{
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, DateCellData, SelectOptionCellChangeset,
SelectOptionIds, TypeOptionCellDataHandler, TypeOptionCellExt,
type_option_data_from_pb_or_default, type_option_to_pb, SelectOptionCellChangeset,
SelectOptionIds, TimestampCellData, TypeOptionCellDataHandler, TypeOptionCellExt,
};
use crate::services::field_settings::{
default_field_settings_by_layout_map, FieldSettings, FieldSettingsChangesetParams,
@ -614,9 +614,9 @@ impl DatabaseEditor {
FieldType::LastEditedTime | FieldType::CreatedTime => {
let row = database.get_row(row_id);
let cell_data = if field_type.is_created_time() {
DateCellData::new(row.created_at, true)
TimestampCellData::new(row.created_at)
} else {
DateCellData::new(row.modified_at, true)
TimestampCellData::new(row.modified_at)
};
Some(Cell::from(cell_data))
},
@ -651,9 +651,9 @@ impl DatabaseEditor {
.into_iter()
.map(|row| {
let data = if field_type.is_created_time() {
DateCellData::new(row.created_at, true)
TimestampCellData::new(row.created_at)
} else {
DateCellData::new(row.modified_at, true)
TimestampCellData::new(row.modified_at)
};
RowCell {
row_id: row.id,

24
frontend/rust-lib/flowy-database2/src/services/field/type_options/date_type_option/date_tests.rs
View File

@ -10,7 +10,6 @@ mod tests {
use crate::services::cell::{CellDataChangeset, CellDataDecoder};
use crate::services::field::{
DateCellChangeset, DateFormat, DateTypeOption, FieldBuilder, TimeFormat,
TypeOptionCellDataSerde,
};
#[test]
@ -409,33 +408,18 @@ mod tests {
old_cell_data: Option<Cell>,
expected_str: &str,
) {
let (cell, cell_data) = type_option
let (cell, _) = type_option
.apply_changeset(changeset, old_cell_data)
.unwrap();
assert_eq!(
decode_cell_data(&cell, type_option, cell_data.include_time, field),
expected_str,
);
assert_eq!(decode_cell_data(&cell, type_option, field), expected_str,);
}
fn decode_cell_data(
cell: &Cell,
type_option: &DateTypeOption,
include_time: bool,
field: &Field,
) -> String {
fn decode_cell_data(cell: &Cell, type_option: &DateTypeOption, field: &Field) -> String {
let decoded_data = type_option
.decode_cell(cell, &FieldType::DateTime, field)
.unwrap();
let decoded_data = type_option.protobuf_encode(decoded_data);
if include_time {
format!("{} {}", decoded_data.date, decoded_data.time)
.trim_end()
.to_owned()
} else {
decoded_data.date
}
type_option.stringify_cell_data(decoded_data)
}
fn initialize_date_cell(type_option: &DateTypeOption, changeset: DateCellChangeset) -> Cell {

121
frontend/rust-lib/flowy-database2/src/services/field/type_options/date_type_option/date_type_option.rs
View File

@ -13,8 +13,8 @@ use flowy_error::{ErrorCode, FlowyError, FlowyResult};
use crate::entities::{DateCellDataPB, DateFilterPB, FieldType};
use crate::services::cell::{CellDataChangeset, CellDataDecoder};
use crate::services::field::{
default_order, DateCellChangeset, DateCellData, DateCellDataWrapper, DateFormat, TimeFormat,
TypeOption, TypeOptionCellDataCompare, TypeOptionCellDataFilter, TypeOptionCellDataSerde,
default_order, DateCellChangeset, DateCellData, DateFormat, TimeFormat, TypeOption,
TypeOptionCellDataCompare, TypeOptionCellDataFilter, TypeOptionCellDataSerde,
TypeOptionTransform,
};
use crate::services::sort::SortCondition;
@ -27,7 +27,6 @@ pub struct DateTypeOption {
pub date_format: DateFormat,
pub time_format: TimeFormat,
pub timezone_id: String,
pub field_type: FieldType,
}
impl Default for DateTypeOption {
@ -36,7 +35,6 @@ impl Default for DateTypeOption {
date_format: Default::default(),
time_format: Default::default(),
timezone_id: Default::default(),
field_type: FieldType::DateTime,
}
}
}
@ -59,15 +57,10 @@ impl From<TypeOptionData> for DateTypeOption {
.map(TimeFormat::from)
.unwrap_or_default();
let timezone_id = data.get_str_value("timezone_id").unwrap_or_default();
let field_type = data
.get_i64_value("field_type")
.map(FieldType::from)
.unwrap_or(FieldType::DateTime);
Self {
date_format,
time_format,
timezone_id,
field_type,
}
}
}
@ -78,7 +71,6 @@ impl From<DateTypeOption> for TypeOptionData {
.insert_i64_value("date_format", data.date_format.value())
.insert_i64_value("time_format", data.time_format.value())
.insert_str_value("timezone_id", data.timezone_id)
.insert_i64_value("field_type", data.field_type.value())
.build()
}
}
@ -88,7 +80,16 @@ impl TypeOptionCellDataSerde for DateTypeOption {
&self,
cell_data: <Self as TypeOption>::CellData,
) -> <Self as TypeOption>::CellProtobufType {
self.today_desc_from_timestamp(cell_data)
let timestamp = cell_data.timestamp;
let include_time = cell_data.include_time;
let (date, time) = self.formatted_date_time_from_timestamp(&timestamp);
DateCellDataPB {
date,
time,
timestamp: timestamp.unwrap_or_default(),
include_time,
}
}
fn parse_cell(&self, cell: &Cell) -> FlowyResult<<Self as TypeOption>::CellData> {
@ -97,46 +98,50 @@ impl TypeOptionCellDataSerde for DateTypeOption {
}
impl DateTypeOption {
pub fn new(field_type: FieldType) -> Self {
Self {
field_type,
..Default::default()
}
pub fn new() -> Self {
Self::default()
}
pub fn test() -> Self {
Self {
timezone_id: "Etc/UTC".to_owned(),
field_type: FieldType::DateTime,
..Self::default()
}
}
fn today_desc_from_timestamp(&self, cell_data: DateCellData) -> DateCellDataPB {
let timestamp = cell_data.timestamp.unwrap_or_default();
let include_time = cell_data.include_time;
fn formatted_date_time_from_timestamp(&self, timestamp: &Option<i64>) -> (String, String) {
if let Some(timestamp) = timestamp {
let naive = chrono::NaiveDateTime::from_timestamp_opt(*timestamp, 0).unwrap();
let offset = self.get_timezone_offset(naive);
let date_time = DateTime::<Local>::from_utc(naive, offset);
let (date, time) = match cell_data.timestamp {
Some(timestamp) => {
let naive = chrono::NaiveDateTime::from_timestamp_opt(timestamp, 0).unwrap();
let offset = self.get_timezone_offset(naive);
let date_time = DateTime::<Local>::from_utc(naive, offset);
let fmt = self.date_format.format_str();
let date = format!("{}", date_time.format(fmt));
let fmt = self.time_format.format_str();
let time = format!("{}", date_time.format(fmt));
(date, time)
} else {
("".to_owned(), "".to_owned())
}
}
let fmt = self.date_format.format_str();
let date = format!("{}", date_time.format(fmt));
let fmt = self.time_format.format_str();
let time = format!("{}", date_time.format(fmt));
(date, time)
fn naive_time_from_time_string(
&self,
include_time: bool,
time_str: Option<String>,
) -> FlowyResult<Option<NaiveTime>> {
match (include_time, time_str) {
(true, Some(time_str)) => {
let result = NaiveTime::parse_from_str(&time_str, self.time_format.format_str());
match result {
Ok(time) => Ok(Some(time)),
Err(_e) => {
let msg = format!("Parse {} failed", time_str);
Err(FlowyError::new(ErrorCode::InvalidDateTimeFormat, msg))
},
}
},
None => ("".to_owned(), "".to_owned()),
};
DateCellDataPB {
date,
time,
include_time,
timestamp,
_ => Ok(None),
}
}
@ -211,7 +216,14 @@ impl CellDataDecoder for DateTypeOption {
}
fn stringify_cell_data(&self, cell_data: <Self as TypeOption>::CellData) -> String {
self.today_desc_from_timestamp(cell_data).date
let timestamp = cell_data.timestamp;
let include_time = cell_data.include_time;
let (date_string, time_string) = self.formatted_date_time_from_timestamp(&timestamp);
if include_time && timestamp.is_some() {
format!("{} {}", date_string, time_string)
} else {
date_string
}
}
fn stringify_cell(&self, cell: &Cell) -> String {
@ -236,15 +248,12 @@ impl CellDataChangeset for DateTypeOption {
};
if changeset.clear_flag == Some(true) {
let (timestamp, include_time) = (None, include_time);
let cell_data = DateCellData {
timestamp,
timestamp: None,
include_time,
};
let cell_wrapper: DateCellDataWrapper = (self.field_type.clone(), cell_data.clone()).into();
return Ok((Cell::from(cell_wrapper), cell_data));
return Ok((Cell::from(&cell_data), cell_data));
}
// update include_time if necessary
@ -256,27 +265,12 @@ impl CellDataChangeset for DateTypeOption {
// order to change the day without changing the time, the old time string
// should be passed in as well.
let changeset_timestamp = changeset.date;
// parse the time string, which is in the local timezone
let parsed_time = match (include_time, changeset.time) {
(true, Some(time_str)) => {
let result = NaiveTime::parse_from_str(&time_str, self.time_format.format_str());
match result {
Ok(time) => Ok(Some(time)),
Err(_e) => {
let msg = format!("Parse {} failed", time_str);
Err(FlowyError::new(ErrorCode::InvalidDateTimeFormat, msg))
},
}
},
_ => Ok(None),
}?;
let parsed_time = self.naive_time_from_time_string(include_time, changeset.time)?;
let timestamp = self.timestamp_from_parsed_time_previous_and_new_timestamp(
parsed_time,
previous_timestamp,
changeset_timestamp,
changeset.date,
);
let cell_data = DateCellData {
@ -284,8 +278,7 @@ impl CellDataChangeset for DateTypeOption {
include_time,
};
let cell_wrapper: DateCellDataWrapper = (self.field_type.clone(), cell_data.clone()).into();
Ok((Cell::from(cell_wrapper), cell_data))
Ok((Cell::from(&cell_data), cell_data))
}
}

33
frontend/rust-lib/flowy-database2/src/services/field/type_options/date_type_option/date_type_option_entities.rs
View File

@ -83,42 +83,19 @@ impl From<&DateCellDataPB> for DateCellData {
}
}
/// Wrapper for DateCellData that also contains the field type.
/// Handy struct to use when you need to convert a DateCellData to a Cell.
pub struct DateCellDataWrapper {
data: DateCellData,
field_type: FieldType,
}
impl From<(FieldType, DateCellData)> for DateCellDataWrapper {
fn from((field_type, data): (FieldType, DateCellData)) -> Self {
Self { data, field_type }
}
}
impl From<DateCellDataWrapper> for Cell {
fn from(wrapper: DateCellDataWrapper) -> Self {
let (field_type, data) = (wrapper.field_type, wrapper.data);
let timestamp_string = match data.timestamp {
impl From<&DateCellData> for Cell {
fn from(cell_data: &DateCellData) -> Self {
let timestamp_string = match cell_data.timestamp {
Some(timestamp) => timestamp.to_string(),
None => "".to_owned(),
};
// Most of the case, don't use these keys in other places. Otherwise, we should define
// constants for them.
new_cell_builder(field_type)
new_cell_builder(FieldType::DateTime)
.insert_str_value(CELL_DATA, timestamp_string)
.insert_bool_value("include_time", data.include_time)
.insert_bool_value("include_time", cell_data.include_time)
.build()
}
}
impl From<DateCellData> for Cell {
fn from(data: DateCellData) -> Self {
let data: DateCellDataWrapper = (FieldType::DateTime, data).into();
Cell::from(data)
}
}
impl<'de> serde::Deserialize<'de> for DateCellData {
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where

2
frontend/rust-lib/flowy-database2/src/services/field/type_options/mod.rs
View File

@ -4,6 +4,7 @@ pub mod date_type_option;
pub mod number_type_option;
pub mod selection_type_option;
pub mod text_type_option;
pub mod timestamp_type_option;
mod type_option;
mod type_option_cell;
mod url_type_option;
@ -14,6 +15,7 @@ pub use date_type_option::*;
pub use number_type_option::*;
pub use selection_type_option::*;
pub use text_type_option::*;
pub use timestamp_type_option::*;
pub use type_option::*;
pub use type_option_cell::*;
pub use url_type_option::*;

4
frontend/rust-lib/flowy-database2/src/services/field/type_options/text_type_option/text_tests.rs
View File

@ -30,8 +30,8 @@ mod tests {
};
assert_eq!(
stringify_cell_data(&data.into(), &FieldType::RichText, &field_type, &field),
"Mar 14, 2022"
stringify_cell_data(&(&data).into(), &FieldType::RichText, &field_type, &field),
"Mar 14, 2022 09:56"
);
}

4
frontend/rust-lib/flowy-database2/src/services/field/type_options/text_type_option/text_type_option.rs
View File

@ -238,14 +238,14 @@ impl TypeOptionCellData for StrCellData {
impl From<&Cell> for StrCellData {
fn from(cell: &Cell) -> Self {
Self(cell.get_str_value("data").unwrap_or_default())
Self(cell.get_str_value(CELL_DATA).unwrap_or_default())
}
}
impl From<StrCellData> for Cell {
fn from(data: StrCellData) -> Self {
new_cell_builder(FieldType::RichText)
.insert_str_value("data", data.0)
.insert_str_value(CELL_DATA, data.0)
.build()
}
}

6
frontend/rust-lib/flowy-database2/src/services/field/type_options/timestamp_type_option/mod.rs Normal file
View File

@ -0,0 +1,6 @@
#![allow(clippy::module_inception)]
mod timestamp_type_option;
mod timestamp_type_option_entities;
pub use timestamp_type_option::*;
pub use timestamp_type_option_entities::*;

205
frontend/rust-lib/flowy-database2/src/services/field/type_options/timestamp_type_option/timestamp_type_option.rs Normal file
View File

@ -0,0 +1,205 @@
use std::cmp::Ordering;
use chrono::{DateTime, Local, Offset};
use collab::core::any_map::AnyMapExtension;
use collab_database::fields::{Field, TypeOptionData, TypeOptionDataBuilder};
use collab_database::rows::Cell;
use flowy_error::{ErrorCode, FlowyError, FlowyResult};
use serde::{Deserialize, Serialize};
use crate::entities::{DateFilterPB, FieldType, TimestampCellDataPB};
use crate::services::cell::{CellDataChangeset, CellDataDecoder};
use crate::services::field::{
default_order, DateFormat, TimeFormat, TimestampCellData, TypeOption, TypeOptionCellDataCompare,
TypeOptionCellDataFilter, TypeOptionCellDataSerde, TypeOptionTransform,
};
use crate::services::sort::SortCondition;
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct TimestampTypeOption {
pub date_format: DateFormat,
pub time_format: TimeFormat,
pub include_time: bool,
pub field_type: FieldType,
}
impl Default for TimestampTypeOption {
fn default() -> Self {
Self {
date_format: Default::default(),
time_format: Default::default(),
include_time: true,
field_type: FieldType::LastEditedTime,
}
}
}
impl TypeOption for TimestampTypeOption {
type CellData = TimestampCellData;
type CellChangeset = String;
type CellProtobufType = TimestampCellDataPB;
type CellFilter = DateFilterPB;
}
impl From<TypeOptionData> for TimestampTypeOption {
fn from(data: TypeOptionData) -> Self {
let date_format = data
.get_i64_value("date_format")
.map(DateFormat::from)
.unwrap_or_default();
let time_format = data
.get_i64_value("time_format")
.map(TimeFormat::from)
.unwrap_or_default();
let include_time = data.get_bool_value("include_time").unwrap_or_default();
let field_type = data
.get_i64_value("field_type")
.map(FieldType::from)
.unwrap_or(FieldType::LastEditedTime);
Self {
date_format,
time_format,
include_time,
field_type,
}
}
}
impl From<TimestampTypeOption> for TypeOptionData {
fn from(option: TimestampTypeOption) -> Self {
TypeOptionDataBuilder::new()
.insert_i64_value("date_format", option.date_format.value())
.insert_i64_value("time_format", option.time_format.value())
.insert_bool_value("include_time", option.include_time)
.insert_i64_value("field_type", option.field_type.value())
.build()
}
}
impl TypeOptionCellDataSerde for TimestampTypeOption {
fn protobuf_encode(
&self,
cell_data: <Self as TypeOption>::CellData,
) -> <Self as TypeOption>::CellProtobufType {
let timestamp = cell_data.timestamp;
let date_time = self.stringify_cell_data(cell_data);
TimestampCellDataPB {
date_time,
timestamp,
}
}
fn parse_cell(&self, cell: &Cell) -> FlowyResult<<Self as TypeOption>::CellData> {
Ok(TimestampCellData::from(cell))
}
}
impl TimestampTypeOption {
pub fn new(field_type: FieldType) -> Self {
Self {
field_type,
include_time: true,
..Default::default()
}
}
fn formatted_date_time_from_timestamp(&self, timestamp: &Option<i64>) -> (String, String) {
if let Some(timestamp) = timestamp {
let naive = chrono::NaiveDateTime::from_timestamp_opt(*timestamp, 0).unwrap();
let offset = Local::now().offset().fix();
let date_time = DateTime::<Local>::from_utc(naive, offset);
let fmt = self.date_format.format_str();
let date = format!("{}", date_time.format(fmt));
let fmt = self.time_format.format_str();
let time = format!("{}", date_time.format(fmt));
(date, time)
} else {
("".to_owned(), "".to_owned())
}
}
}
impl TypeOptionTransform for TimestampTypeOption {}
impl CellDataDecoder for TimestampTypeOption {
fn decode_cell(
&self,
cell: &Cell,
decoded_field_type: &FieldType,
_field: &Field,
) -> FlowyResult<<Self as TypeOption>::CellData> {
// Return default data if the type_option_cell_data is not FieldType::DateTime.
// It happens when switching from one field to another.
// For example:
// FieldType::RichText -> FieldType::DateTime, it will display empty content on the screen.
if !decoded_field_type.is_date() {
return Ok(Default::default());
}
self.parse_cell(cell)
}
fn stringify_cell_data(&self, cell_data: <Self as TypeOption>::CellData) -> String {
let timestamp = cell_data.timestamp;
let (date_string, time_string) = self.formatted_date_time_from_timestamp(&timestamp);
if self.include_time {
format!("{} {}", date_string, time_string)
} else {
date_string
}
}
fn stringify_cell(&self, cell: &Cell) -> String {
let cell_data = Self::CellData::from(cell);
self.stringify_cell_data(cell_data)
}
}
impl CellDataChangeset for TimestampTypeOption {
fn apply_changeset(
&self,
_changeset: <Self as TypeOption>::CellChangeset,
_cell: Option<Cell>,
) -> FlowyResult<(Cell, <Self as TypeOption>::CellData)> {
Err(FlowyError::new(
ErrorCode::FieldInvalidOperation,
"Cells of this field type cannot be edited",
))
}
}
impl TypeOptionCellDataFilter for TimestampTypeOption {
fn apply_filter(
&self,
filter: &<Self as TypeOption>::CellFilter,
field_type: &FieldType,
cell_data: &<Self as TypeOption>::CellData,
) -> bool {
if !field_type.is_date() {
return true;
}
filter.is_visible(cell_data.timestamp)
}
}
impl TypeOptionCellDataCompare for TimestampTypeOption {
fn apply_cmp(
&self,
cell_data: &<Self as TypeOption>::CellData,
other_cell_data: &<Self as TypeOption>::CellData,
sort_condition: SortCondition,
) -> Ordering {
match (cell_data.timestamp, other_cell_data.timestamp) {
(Some(left), Some(right)) => {
let order = left.cmp(&right);
sort_condition.evaluate_order(order)
},
(Some(_), None) => Ordering::Less,
(None, Some(_)) => Ordering::Greater,
(None, None) => default_order(),
}
}
}

69
frontend/rust-lib/flowy-database2/src/services/field/type_options/timestamp_type_option/timestamp_type_option_entities.rs Normal file
View File

@ -0,0 +1,69 @@
use collab::core::any_map::AnyMapExtension;
use collab_database::rows::{new_cell_builder, Cell};
use serde::Serialize;
use crate::{
entities::FieldType,
services::field::{TypeOptionCellData, CELL_DATA},
};
#[derive(Clone, Debug, Default, Serialize)]
pub struct TimestampCellData {
pub timestamp: Option<i64>,
}
impl TimestampCellData {
pub fn new(timestamp: i64) -> Self {
Self {
timestamp: Some(timestamp),
}
}
}
impl From<&Cell> for TimestampCellData {
fn from(cell: &Cell) -> Self {
let timestamp = cell
.get_str_value(CELL_DATA)
.and_then(|data| data.parse::<i64>().ok());
Self { timestamp }
}
}
/// Wrapper for DateCellData that also contains the field type.
/// Handy struct to use when you need to convert a DateCellData to a Cell.
pub struct TimestampCellDataWrapper {
data: TimestampCellData,
field_type: FieldType,
}
impl From<(FieldType, TimestampCellData)> for TimestampCellDataWrapper {
fn from((field_type, data): (FieldType, TimestampCellData)) -> Self {
Self { data, field_type }
}
}
impl From<TimestampCellDataWrapper> for Cell {
fn from(wrapper: TimestampCellDataWrapper) -> Self {
let (field_type, data) = (wrapper.field_type, wrapper.data);
let timestamp_string = data.timestamp.unwrap_or_default();
new_cell_builder(field_type)
.insert_str_value(CELL_DATA, timestamp_string)
.build()
}
}
impl From<TimestampCellData> for Cell {
fn from(data: TimestampCellData) -> Self {
let data: TimestampCellDataWrapper = (FieldType::LastEditedTime, data).into();
Cell::from(data)
}
}
impl TypeOptionCellData for TimestampCellData {}
impl ToString for TimestampCellData {
fn to_string(&self) -> String {
serde_json::to_string(self).unwrap()
}
}

21
frontend/rust-lib/flowy-database2/src/services/field/type_options/type_option.rs
View File

@ -11,13 +11,13 @@ use flowy_error::FlowyResult;
use crate::entities::{
CheckboxTypeOptionPB, ChecklistTypeOptionPB, DateTypeOptionPB, FieldType,
MultiSelectTypeOptionPB, NumberTypeOptionPB, RichTextTypeOptionPB, SingleSelectTypeOptionPB,
URLTypeOptionPB,
TimestampTypeOptionPB, URLTypeOptionPB,
};
use crate::services::cell::{CellDataDecoder, FromCellChangeset, ToCellChangeset};
use crate::services::field::checklist_type_option::ChecklistTypeOption;
use crate::services::field::{
CheckboxTypeOption, DateFormat, DateTypeOption, MultiSelectTypeOption, NumberTypeOption,
RichTextTypeOption, SingleSelectTypeOption, TimeFormat, URLTypeOption,
RichTextTypeOption, SingleSelectTypeOption, TimeFormat, TimestampTypeOption, URLTypeOption,
};
use crate::services::filter::FromFilterString;
use crate::services::sort::SortCondition;
@ -179,9 +179,12 @@ pub fn type_option_data_from_pb_or_default<T: Into<Bytes>>(
FieldType::Number => {
NumberTypeOptionPB::try_from(bytes).map(|pb| NumberTypeOption::from(pb).into())
},
FieldType::DateTime | FieldType::LastEditedTime | FieldType::CreatedTime => {
FieldType::DateTime => {
DateTypeOptionPB::try_from(bytes).map(|pb| DateTypeOption::from(pb).into())
},
FieldType::LastEditedTime | FieldType::CreatedTime => {
TimestampTypeOptionPB::try_from(bytes).map(|pb| TimestampTypeOption::from(pb).into())
},
FieldType::SingleSelect => {
SingleSelectTypeOptionPB::try_from(bytes).map(|pb| SingleSelectTypeOption::from(pb).into())
},
@ -214,10 +217,16 @@ pub fn type_option_to_pb(type_option: TypeOptionData, field_type: &FieldType) ->
.try_into()
.unwrap()
},
FieldType::DateTime | FieldType::LastEditedTime | FieldType::CreatedTime => {
FieldType::DateTime => {
let date_type_option: DateTypeOption = type_option.into();
DateTypeOptionPB::from(date_type_option).try_into().unwrap()
},
FieldType::LastEditedTime | FieldType::CreatedTime => {
let timestamp_type_option: TimestampTypeOption = type_option.into();
TimestampTypeOptionPB::from(timestamp_type_option)
.try_into()
.unwrap()
},
FieldType::SingleSelect => {
let single_select_type_option: SingleSelectTypeOption = type_option.into();
SingleSelectTypeOptionPB::from(single_select_type_option)
@ -254,14 +263,14 @@ pub fn default_type_option_data_from_type(field_type: &FieldType) -> TypeOptionD
FieldType::RichText => RichTextTypeOption::default().into(),
FieldType::Number => NumberTypeOption::default().into(),
FieldType::DateTime => DateTypeOption {
field_type: field_type.clone(),
..Default::default()
}
.into(),
FieldType::LastEditedTime | FieldType::CreatedTime => DateTypeOption {
FieldType::LastEditedTime | FieldType::CreatedTime => TimestampTypeOption {
field_type: field_type.clone(),
date_format: DateFormat::Friendly,
time_format: TimeFormat::TwelveHour,
include_time: true,
..Default::default()
}
.into(),

25
frontend/rust-lib/flowy-database2/src/services/field/type_options/type_option_cell.rs
View File

@ -16,8 +16,8 @@ use crate::services::cell::{
use crate::services::field::checklist_type_option::ChecklistTypeOption;
use crate::services::field::{
CheckboxTypeOption, DateTypeOption, MultiSelectTypeOption, NumberTypeOption, RichTextTypeOption,
SingleSelectTypeOption, TypeOption, TypeOptionCellDataCompare, TypeOptionCellDataFilter,
TypeOptionCellDataSerde, TypeOptionTransform, URLTypeOption,
SingleSelectTypeOption, TimestampTypeOption, TypeOption, TypeOptionCellDataCompare,
TypeOptionCellDataFilter, TypeOptionCellDataSerde, TypeOptionTransform, URLTypeOption,
};
use crate::services::sort::SortCondition;
@ -407,7 +407,7 @@ impl<'a> TypeOptionCellExt<'a> {
self.cell_data_cache.clone(),
)
}),
FieldType::DateTime | FieldType::LastEditedTime | FieldType::CreatedTime => self
FieldType::DateTime => self
.field
.get_type_option::<DateTypeOption>(field_type)
.map(|type_option| {
@ -417,6 +417,16 @@ impl<'a> TypeOptionCellExt<'a> {
self.cell_data_cache.clone(),
)
}),
FieldType::LastEditedTime | FieldType::CreatedTime => self
.field
.get_type_option::<TimestampTypeOption>(field_type)
.map(|type_option| {
TypeOptionCellDataHandlerImpl::new_with_boxed(
type_option,
self.cell_filter_cache.clone(),
self.cell_data_cache.clone(),
)
}),
FieldType::SingleSelect => self
.field
.get_type_option::<SingleSelectTypeOption>(field_type)
@ -527,9 +537,12 @@ fn get_type_option_transform_handler(
FieldType::Number => {
Box::new(NumberTypeOption::from(type_option_data)) as Box<dyn TypeOptionTransformHandler>
},
FieldType::DateTime | FieldType::LastEditedTime | FieldType::CreatedTime => {
FieldType::DateTime => {
Box::new(DateTypeOption::from(type_option_data)) as Box<dyn TypeOptionTransformHandler>
},
FieldType::LastEditedTime | FieldType::CreatedTime => {
Box::new(TimestampTypeOption::from(type_option_data)) as Box<dyn TypeOptionTransformHandler>
},
FieldType::SingleSelect => Box::new(SingleSelectTypeOption::from(type_option_data))
as Box<dyn TypeOptionTransformHandler>,
FieldType::MultiSelect => {
@ -590,6 +603,10 @@ impl RowSingleCellData {
into_date_field_cell_data,
<DateTypeOption as TypeOption>::CellData
);
into_cell_data!(
into_timestamp_field_cell_data,
<TimestampTypeOption as TypeOption>::CellData
);
into_cell_data!(
into_check_list_field_cell_data,
<CheckboxTypeOption as TypeOption>::CellData

5
frontend/rust-lib/flowy-database2/src/services/group/controller_impls/date_controller.rs
View File

@ -455,7 +455,6 @@ mod tests {
use chrono::{offset, Days, Duration, NaiveDateTime};
use crate::entities::FieldType;
use crate::services::{
field::{date_type_option::DateTypeOption, DateCellData},
group::controller_impls::date_controller::{
@ -481,9 +480,9 @@ mod tests {
let today = offset::Local::now();
let three_days_before = today.checked_add_signed(Duration::days(-3)).unwrap();
let mut local_date_type_option = DateTypeOption::new(FieldType::DateTime);
let mut local_date_type_option = DateTypeOption::new();
local_date_type_option.timezone_id = today.offset().to_string();
let mut default_date_type_option = DateTypeOption::new(FieldType::DateTime);
let mut default_date_type_option = DateTypeOption::new();
default_date_type_option.timezone_id = "".to_string();
let tests = vec![

8
frontend/rust-lib/flowy-database2/tests/database/cell_test/test.rs
View File

@ -22,12 +22,13 @@ async fn grid_cell_update() {
for (_, row_detail) in rows.iter().enumerate() {
for field in &fields {
let field_type = FieldType::from(field.field_type);
if field_type == FieldType::LastEditedTime || field_type == FieldType::CreatedTime {
continue;
}
let cell_changeset = match field_type {
FieldType::RichText => "".to_string(),
FieldType::Number => "123".to_string(),
FieldType::DateTime | FieldType::LastEditedTime | FieldType::CreatedTime => {
make_date_cell_string(123)
},
FieldType::DateTime => make_date_cell_string(123),
FieldType::SingleSelect => {
let type_option = field
.get_type_option::<SingleSelectTypeOption>(field.field_type)
@ -49,6 +50,7 @@ async fn grid_cell_update() {
.to_cell_changeset_str(),
FieldType::Checkbox => "1".to_string(),
FieldType::URL => "1".to_string(),
_ => "".to_string(),
};
scripts.push(UpdateCell {

2
frontend/rust-lib/flowy-database2/tests/database/field_test/test.rs
View File

@ -31,7 +31,7 @@ async fn grid_create_field() {
];
test.run_scripts(scripts).await;
let (params, field) = create_date_field(&test.view_id(), FieldType::CreatedTime);
let (params, field) = create_timestamp_field(&test.view_id(), FieldType::CreatedTime);
let scripts = vec![
CreateField { params },
AssertFieldTypeOptionEqual {

46
frontend/rust-lib/flowy-database2/tests/database/field_test/util.rs
View File

@ -2,7 +2,7 @@ use collab_database::fields::Field;
use flowy_database2::entities::{CreateFieldParams, FieldType};
use flowy_database2::services::field::{
type_option_to_pb, DateCellChangeset, DateFormat, DateTypeOption, FieldBuilder,
RichTextTypeOption, SelectOption, SingleSelectTypeOption, TimeFormat,
RichTextTypeOption, SelectOption, SingleSelectTypeOption, TimeFormat, TimestampTypeOption,
};
pub fn create_text_field(grid_id: &str) -> (CreateFieldParams, Field) {
@ -41,32 +41,52 @@ pub fn create_single_select_field(grid_id: &str) -> (CreateFieldParams, Field) {
};
(params, single_select_field)
}
pub fn create_date_field(grid_id: &str, field_type: FieldType) -> (CreateFieldParams, Field) {
#[allow(dead_code)]
pub fn create_date_field(grid_id: &str) -> (CreateFieldParams, Field) {
let date_type_option = DateTypeOption {
date_format: DateFormat::US,
time_format: TimeFormat::TwentyFourHour,
timezone_id: "Etc/UTC".to_owned(),
};
let field = FieldBuilder::new(FieldType::DateTime, date_type_option.clone())
.name("Date")
.visibility(true)
.build();
let type_option_data = type_option_to_pb(date_type_option.into(), &FieldType::DateTime).to_vec();
let params = CreateFieldParams {
view_id: grid_id.to_owned(),
field_type: FieldType::DateTime,
type_option_data: Some(type_option_data),
};
(params, field)
}
pub fn create_timestamp_field(grid_id: &str, field_type: FieldType) -> (CreateFieldParams, Field) {
let timestamp_type_option = TimestampTypeOption {
date_format: DateFormat::US,
time_format: TimeFormat::TwentyFourHour,
include_time: true,
field_type: field_type.clone(),
};
let field: Field = match field_type {
FieldType::DateTime => FieldBuilder::new(field_type.clone(), date_type_option.clone())
.name("Date")
.visibility(true)
.build(),
FieldType::LastEditedTime => FieldBuilder::new(field_type.clone(), date_type_option.clone())
.name("Updated At")
.visibility(true)
.build(),
FieldType::CreatedTime => FieldBuilder::new(field_type.clone(), date_type_option.clone())
FieldType::LastEditedTime => {
FieldBuilder::new(field_type.clone(), timestamp_type_option.clone())
.name("Updated At")
.visibility(true)
.build()
},
FieldType::CreatedTime => FieldBuilder::new(field_type.clone(), timestamp_type_option.clone())
.name("Created At")
.visibility(true)
.build(),
_ => panic!("Unsupported group field type"),
};
let type_option_data = type_option_to_pb(date_type_option.into(), &field_type).to_vec();
let type_option_data = type_option_to_pb(timestamp_type_option.into(), &field_type).to_vec();
let params = CreateFieldParams {
view_id: grid_id.to_owned(),

31
frontend/rust-lib/flowy-database2/tests/database/mock_data/board_mock_data.rs
View File

@ -7,7 +7,7 @@ use flowy_database2::entities::FieldType;
use flowy_database2::services::field::checklist_type_option::ChecklistTypeOption;
use flowy_database2::services::field::{
DateFormat, DateTypeOption, FieldBuilder, MultiSelectTypeOption, SelectOption, SelectOptionColor,
SingleSelectTypeOption, TimeFormat,
SingleSelectTypeOption, TimeFormat, TimestampTypeOption,
};
use crate::database::database_editor::TestRowBuilder;
@ -36,17 +36,30 @@ pub fn make_test_board() -> DatabaseData {
.build();
fields.push(number_field);
},
FieldType::DateTime | FieldType::LastEditedTime | FieldType::CreatedTime => {
FieldType::DateTime => {
// Date
let date_type_option = DateTypeOption {
date_format: DateFormat::US,
time_format: TimeFormat::TwentyFourHour,
timezone_id: "Etc/UTC".to_owned(),
};
let name = "Time";
let date_field = FieldBuilder::new(field_type.clone(), date_type_option)
.name(name)
.visibility(true)
.build();
fields.push(date_field);
},
FieldType::LastEditedTime | FieldType::CreatedTime => {
// LastEditedTime and CreatedTime
let date_type_option = TimestampTypeOption {
date_format: DateFormat::US,
time_format: TimeFormat::TwentyFourHour,
include_time: true,
field_type: field_type.clone(),
};
let name = match field_type {
FieldType::DateTime => "Time",
FieldType::LastEditedTime => "Updated At",
FieldType::LastEditedTime => "Last Modified",
FieldType::CreatedTime => "Created At",
_ => "",
};
@ -128,7 +141,7 @@ pub fn make_test_board() -> DatabaseData {
FieldType::RichText => row_builder.insert_text_cell("A"),
FieldType::Number => row_builder.insert_number_cell("1"),
// 1647251762 => Mar 14,2022
FieldType::DateTime | FieldType::LastEditedTime | FieldType::CreatedTime => {
FieldType::DateTime => {
row_builder.insert_date_cell(1647251762, None, None, &field_type)
},
FieldType::SingleSelect => {
@ -148,7 +161,7 @@ pub fn make_test_board() -> DatabaseData {
FieldType::RichText => row_builder.insert_text_cell("B"),
FieldType::Number => row_builder.insert_number_cell("2"),
// 1647251762 => Mar 14,2022
FieldType::DateTime | FieldType::LastEditedTime | FieldType::CreatedTime => {
FieldType::DateTime => {
row_builder.insert_date_cell(1647251762, None, None, &field_type)
},
FieldType::SingleSelect => {
@ -167,7 +180,7 @@ pub fn make_test_board() -> DatabaseData {
FieldType::RichText => row_builder.insert_text_cell("C"),
FieldType::Number => row_builder.insert_number_cell("3"),
// 1647251762 => Mar 14,2022
FieldType::DateTime | FieldType::LastEditedTime | FieldType::CreatedTime => {
FieldType::DateTime => {
row_builder.insert_date_cell(1647251762, None, None, &field_type)
},
FieldType::SingleSelect => {
@ -189,7 +202,7 @@ pub fn make_test_board() -> DatabaseData {
match field_type {
FieldType::RichText => row_builder.insert_text_cell("DA"),
FieldType::Number => row_builder.insert_number_cell("4"),
FieldType::DateTime | FieldType::LastEditedTime | FieldType::CreatedTime => {
FieldType::DateTime => {
row_builder.insert_date_cell(1668704685, None, None, &field_type)
},
FieldType::SingleSelect => {
@ -206,7 +219,7 @@ pub fn make_test_board() -> DatabaseData {
match field_type {
FieldType::RichText => row_builder.insert_text_cell("AE"),
FieldType::Number => row_builder.insert_number_cell(""),
FieldType::DateTime | FieldType::LastEditedTime | FieldType::CreatedTime => {
FieldType::DateTime => {
row_builder.insert_date_cell(1668359085, None, None, &field_type)
},
FieldType::SingleSelect => {

43
frontend/rust-lib/flowy-database2/tests/database/mock_data/grid_mock_data.rs
View File

@ -7,7 +7,7 @@ use flowy_database2::entities::FieldType;
use flowy_database2::services::field::checklist_type_option::ChecklistTypeOption;
use flowy_database2::services::field::{
DateFormat, DateTypeOption, FieldBuilder, MultiSelectTypeOption, NumberFormat, NumberTypeOption,
SelectOption, SelectOptionColor, SingleSelectTypeOption, TimeFormat,
SelectOption, SelectOptionColor, SingleSelectTypeOption, TimeFormat, TimestampTypeOption,
};
use crate::database::database_editor::TestRowBuilder;
@ -39,26 +39,39 @@ pub fn make_test_grid() -> DatabaseData {
.build();
fields.push(number_field);
},
FieldType::DateTime | FieldType::LastEditedTime | FieldType::CreatedTime => {
FieldType::DateTime => {
// Date
let date_type_option = DateTypeOption {
date_format: DateFormat::US,
time_format: TimeFormat::TwentyFourHour,
timezone_id: "Etc/UTC".to_owned(),
field_type: field_type.clone(),
};
let name = match field_type {
FieldType::DateTime => "Time",
FieldType::LastEditedTime => "Updated At",
FieldType::CreatedTime => "Created At",
_ => "",
};
let name = "Time";
let date_field = FieldBuilder::new(field_type.clone(), date_type_option)
.name(name)
.visibility(true)
.build();
fields.push(date_field);
},
FieldType::LastEditedTime | FieldType::CreatedTime => {
// LastEditedTime and CreatedTime
let timestamp_type_option = TimestampTypeOption {
date_format: DateFormat::US,
time_format: TimeFormat::TwentyFourHour,
include_time: true,
field_type: field_type.clone(),
};
let name = match field_type {
FieldType::LastEditedTime => "Last Modified",
FieldType::CreatedTime => "Created At",
_ => "",
};
let timestamp_field = FieldBuilder::new(field_type.clone(), timestamp_type_option)
.name(name)
.visibility(true)
.build();
fields.push(timestamp_field);
},
FieldType::SingleSelect => {
// Single Select
let option1 = SelectOption::with_color(COMPLETED, SelectOptionColor::Purple);
@ -129,7 +142,7 @@ pub fn make_test_grid() -> DatabaseData {
match field_type {
FieldType::RichText => row_builder.insert_text_cell("A"),
FieldType::Number => row_builder.insert_number_cell("1"),
FieldType::DateTime | FieldType::LastEditedTime | FieldType::CreatedTime => {
FieldType::DateTime => {
row_builder.insert_date_cell(1647251762, None, None, &field_type)
},
FieldType::MultiSelect => row_builder
@ -150,7 +163,7 @@ pub fn make_test_grid() -> DatabaseData {
match field_type {
FieldType::RichText => row_builder.insert_text_cell(""),
FieldType::Number => row_builder.insert_number_cell("2"),
FieldType::DateTime | FieldType::LastEditedTime | FieldType::CreatedTime => {
FieldType::DateTime => {
row_builder.insert_date_cell(1647251762, None, None, &field_type)
},
FieldType::MultiSelect => row_builder
@ -165,7 +178,7 @@ pub fn make_test_grid() -> DatabaseData {
match field_type {
FieldType::RichText => row_builder.insert_text_cell("C"),
FieldType::Number => row_builder.insert_number_cell("3"),
FieldType::DateTime | FieldType::LastEditedTime | FieldType::CreatedTime => {
FieldType::DateTime => {
row_builder.insert_date_cell(1647251762, None, None, &field_type)
},
FieldType::SingleSelect => {
@ -184,7 +197,7 @@ pub fn make_test_grid() -> DatabaseData {
match field_type {
FieldType::RichText => row_builder.insert_text_cell("DA"),
FieldType::Number => row_builder.insert_number_cell("14"),
FieldType::DateTime | FieldType::LastEditedTime | FieldType::CreatedTime => {
FieldType::DateTime => {
row_builder.insert_date_cell(1668704685, None, None, &field_type)
},
FieldType::SingleSelect => {
@ -200,7 +213,7 @@ pub fn make_test_grid() -> DatabaseData {
match field_type {
FieldType::RichText => row_builder.insert_text_cell("AE"),
FieldType::Number => row_builder.insert_number_cell(""),
FieldType::DateTime | FieldType::LastEditedTime | FieldType::CreatedTime => {
FieldType::DateTime => {
row_builder.insert_date_cell(1668359085, None, None, &field_type)
},
FieldType::SingleSelect => {
@ -218,7 +231,7 @@ pub fn make_test_grid() -> DatabaseData {
match field_type {
FieldType::RichText => row_builder.insert_text_cell("AE"),
FieldType::Number => row_builder.insert_number_cell("5"),
FieldType::DateTime | FieldType::LastEditedTime | FieldType::CreatedTime => {
FieldType::DateTime => {
row_builder.insert_date_cell(1671938394, None, None, &field_type)
},
FieldType::SingleSelect => {

14
frontend/rust-lib/flowy-database2/tests/database/share_test/export_test.rs
View File

@ -27,13 +27,13 @@ async fn export_csv_test() {
let test = DatabaseEditorTest::new_grid().await;
let database = test.editor.clone();
let s = database.export_csv(CSVFormat::Original).await.unwrap();
let expected = r#"Name,Price,Time,Status,Platform,is urgent,link,TODO,Updated At,Created At
A,$1,2022/03/14,,"Google,Facebook",Yes,AppFlowy website - https://www.appflowy.io,,2022/03/14,2022/03/14
,$2,2022/03/14,,"Google,Twitter",Yes,,,2022/03/14,2022/03/14
C,$3,2022/03/14,Completed,"Facebook,Google,Twitter",No,,,2022/03/14,2022/03/14
DA,$14,2022/11/17,Completed,,No,,,2022/11/17,2022/11/17
AE,,2022/11/13,Planned,"Facebook,Twitter",No,,,2022/11/13,2022/11/13
AE,$5,2022/12/25,Planned,Facebook,Yes,,,2022/12/25,2022/12/25
let expected = r#"Name,Price,Time,Status,Platform,is urgent,link,TODO,Last Modified,Created At
A,$1,2022/03/14,,"Google,Facebook",Yes,AppFlowy website - https://www.appflowy.io,,,
,$2,2022/03/14,,"Google,Twitter",Yes,,,,
C,$3,2022/03/14,Completed,"Facebook,Google,Twitter",No,,,,
DA,$14,2022/11/17,Completed,,No,,,,
AE,,2022/11/13,Planned,"Facebook,Twitter",No,,,,
AE,$5,2022/12/25,Planned,Facebook,Yes,,,,
CB,,,,,,,,,
"#;
println!("{}", s);