feat: 데일리 루틴 (반복 할 일) 지원

toondo/lib/main.dart

@@ -20,6 +20,7 @@ import 'package:data/models/todo_model.dart';
 import 'package:data/models/user_model.dart';
 import 'package:data/models/goal_model.dart';
 import 'package:data/models/goal_status_enum.dart';
+import 'package:data/models/recurrence_rule_model.dart';
 import 'package:data/models/custom_icon_model.dart';
 import 'package:toondo/injection/di.dart';
 import 'package:flutter_screenutil/flutter_screenutil.dart';
@@ -117,6 +118,10 @@ class _AppBootstrapperState extends State<AppBootstrapper> {
       Hive.registerAdapter(UserModelAdapter());
       Hive.registerAdapter(GoalStatusEnumAdapter());
       Hive.registerAdapter(CustomIconModelAdapter());
+      Hive.registerAdapter(RecurrenceFrequencyModelAdapter());
+      Hive.registerAdapter(RecurrenceEndKindAdapter());
+      Hive.registerAdapter(RecurrenceEndModelAdapter());
+      Hive.registerAdapter(RecurrenceRuleModelAdapter());
 
       if (mounted) {
         setState(() => _loadingStatus = '데이터 불러오는 중...');

toondo/packages/data/lib/datasources/local/todo_local_datasource.dart

@@ -65,4 +65,43 @@ class TodoLocalDatasource {
       await todoBox.put(updatedModel.id, updatedModel);
     }
   }
+
+  List<Todo> getRecurringSeries() {
+    return todoBox.values
+        .where((m) => m.recurrence != null && m.seriesId == null)
+        .map((m) => m.toEntity())
+        .toList();
+  }
+
+  Todo? findOccurrence({
+    required String seriesId,
+    required DateTime occurrenceDate,
+  }) {
+    final dayOnly = DateTime(
+      occurrenceDate.year,
+      occurrenceDate.month,
+      occurrenceDate.day,
+    );
+    for (final m in todoBox.values) {
+      if (m.seriesId != seriesId) continue;
+      final occ = m.occurrenceDate;
+      if (occ == null) continue;
+      if (DateTime(occ.year, occ.month, occ.day) == dayOnly) {
+        return m.toEntity();
+      }
+    }
+    return null;
+  }
+
+  Future<void> deleteSeriesAndUnfinishedOccurrences(String seriesId) async {
+    await todoBox.delete(seriesId);
+    final unfinishedKeys = todoBox.values
+        .where((m) =>
+            m.seriesId == seriesId && (m.status < 1.0))
+        .map((m) => m.id)
+        .toList();
+    for (final id in unfinishedKeys) {
+      await todoBox.delete(id);
+    }
+  }
 }

toondo/packages/data/lib/models/recurrence_rule_model.dart

@@ -0,0 +1,117 @@
+import 'package:hive/hive.dart';
+import 'package:domain/entities/recurrence_rule.dart';
+
+part 'recurrence_rule_model.g.dart';
+
+@HiveType(typeId: 5)
+enum RecurrenceFrequencyModel {
+  @HiveField(0)
+  daily,
+  @HiveField(1)
+  weekly,
+  @HiveField(2)
+  monthly,
+  @HiveField(3)
+  yearly,
+}
+
+@HiveType(typeId: 6)
+enum RecurrenceEndKind {
+  @HiveField(0)
+  never,
+  @HiveField(1)
+  onDate,
+  @HiveField(2)
+  afterCount,
+}
+
+@HiveType(typeId: 7)
+class RecurrenceEndModel {
+  @HiveField(0)
+  final RecurrenceEndKind kind;
+
+  @HiveField(1)
+  final DateTime? date;
+
+  @HiveField(2)
+  final int? count;
+
+  RecurrenceEndModel({required this.kind, this.date, this.count});
+
+  factory RecurrenceEndModel.fromEntity(RecurrenceEnd end) {
+    return switch (end) {
+      EndNever() => RecurrenceEndModel(kind: RecurrenceEndKind.never),
+      EndOnDate(date: final d) =>
+        RecurrenceEndModel(kind: RecurrenceEndKind.onDate, date: d),
+      EndAfterCount(count: final c) =>
+        RecurrenceEndModel(kind: RecurrenceEndKind.afterCount, count: c),
+    };
+  }
+
+  RecurrenceEnd toEntity() {
+    switch (kind) {
+      case RecurrenceEndKind.never:
+        return const EndNever();
+      case RecurrenceEndKind.onDate:
+        return EndOnDate(date!);
+      case RecurrenceEndKind.afterCount:
+        return EndAfterCount(count!);
+    }
+  }
+}
+
+@HiveType(typeId: 8)
+class RecurrenceRuleModel {
+  @HiveField(0)
+  final RecurrenceFrequencyModel frequency;
+
+  @HiveField(1)
+  final int interval;
+
+  @HiveField(2)
+  final List<int> byWeekdays;
+
+  @HiveField(3)
+  final int? byMonthDay;
+
+  @HiveField(4)
+  final RecurrenceEndModel end;
+
+  RecurrenceRuleModel({
+    required this.frequency,
+    this.interval = 1,
+    this.byWeekdays = const [],
+    this.byMonthDay,
+    required this.end,
+  });
+
+  factory RecurrenceRuleModel.fromEntity(RecurrenceRule rule) {
+    return RecurrenceRuleModel(
+      frequency: switch (rule.frequency) {
+        RecurrenceFrequency.daily => RecurrenceFrequencyModel.daily,
+        RecurrenceFrequency.weekly => RecurrenceFrequencyModel.weekly,
+        RecurrenceFrequency.monthly => RecurrenceFrequencyModel.monthly,
+        RecurrenceFrequency.yearly => RecurrenceFrequencyModel.yearly,
+      },
+      interval: rule.interval,
+      byWeekdays: List<int>.from(rule.byWeekdays),
+      byMonthDay: rule.byMonthDay,
+      end: RecurrenceEndModel.fromEntity(rule.end),
+    );
+  }
+
+  RecurrenceRule toEntity() {
+    return RecurrenceRule(
+      frequency: switch (frequency) {
+        RecurrenceFrequencyModel.daily => RecurrenceFrequency.daily,
+        RecurrenceFrequencyModel.weekly => RecurrenceFrequency.weekly,
+        RecurrenceFrequencyModel.monthly => RecurrenceFrequency.monthly,
+        RecurrenceFrequencyModel.yearly => RecurrenceFrequency.yearly,
+      },
+      interval: interval,
+      byWeekdays: List<int>.from(byWeekdays),
+      byMonthDay: byMonthDay,
+      end: end.toEntity(),
+    );
+  }
+}