Merge pull request #352 from DevKor-github/feat/show-prep-time-between-move

Match swipe action height to expanded schedule tiles

Author: jjoonleo

lib/domain/use-cases/stream_preparations_use_case.dart

@@ -0,0 +1,14 @@
+import 'package:injectable/injectable.dart';
+import 'package:on_time_front/domain/entities/preparation_entity.dart';
+import 'package:on_time_front/domain/repositories/preparation_repository.dart';
+
+@Injectable()
+class StreamPreparationsUseCase {
+  final PreparationRepository _preparationRepository;
+
+  StreamPreparationsUseCase(this._preparationRepository);
+
+  Stream<Map<String, PreparationEntity>> call() {
+    return _preparationRepository.preparationStream;
+  }
+}

lib/l10n/app_en.arb

@@ -143,6 +143,10 @@
     "@travelTime": {
         "description": "Label for the travel time text field"
     },
+    "preparationTime": "Preparation Time",
+    "@preparationTime": {
+        "description": "Label for preparation time"
+    },
     "hours": "hours",
     "@hours": {
         "description": "Unit of time"

lib/l10n/app_ko.arb

@@ -35,6 +35,7 @@
     "appointmentNameHint": "예) 영화 보기",
     "appointmentPlace": "약속 장소",
     "travelTime": "이동시간",
+    "preparationTime": "준비시간",
     "hours": "시간",
     "minutes": "분",
     "selectTime": "시간을 선택해 주세요",

lib/l10n/app_localizations.dart

@@ -314,6 +314,12 @@ abstract class AppLocalizations {
   /// **'Travel Time'**
   String get travelTime;
 
+  /// Label for preparation time
+  ///
+  /// In en, this message translates to:
+  /// **'Preparation Time'**
+  String get preparationTime;
+
   /// Unit of time
   ///
   /// In en, this message translates to:

lib/l10n/app_localizations_en.dart

@@ -124,6 +124,9 @@ class AppLocalizationsEn extends AppLocalizations {
   @override
   String get travelTime => 'Travel Time';
 
+  @override
+  String get preparationTime => 'Preparation Time';
+
   @override
   String get hours => 'hours';
 

lib/l10n/app_localizations_ko.dart

@@ -119,6 +119,9 @@ class AppLocalizationsKo extends AppLocalizations {
   @override
   String get travelTime => '이동시간';
 
+  @override
+  String get preparationTime => '준비시간';
+
   @override
   String get hours => '시간';
 

lib/presentation/calendar/bloc/monthly_schedules_bloc.dart

@@ -1,11 +1,17 @@
+import 'dart:async';
+
 import 'package:equatable/equatable.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:injectable/injectable.dart';
+import 'package:on_time_front/domain/entities/preparation_entity.dart';
 import 'package:on_time_front/domain/entities/schedule_entity.dart';
 import 'package:on_time_front/domain/use-cases/delete_schedule_use_case.dart';
+import 'package:on_time_front/domain/use-cases/get_preparation_by_schedule_id_use_case.dart';
 import 'package:on_time_front/domain/use-cases/get_schedules_by_date_use_case.dart';
+import 'package:on_time_front/domain/use-cases/load_preparation_by_schedule_id_use_case.dart';
 import 'package:on_time_front/domain/use-cases/load_schedules_for_month_use_case.dart';
+import 'package:on_time_front/domain/use-cases/stream_preparations_use_case.dart';
 
 part 'monthly_schedules_event.dart';
 part 'monthly_schedules_state.dart';
@@ -17,15 +23,40 @@ class MonthlySchedulesBloc
     this._loadSchedulesForMonthUseCase,
     this._getSchedulesByDateUseCase,
     this._deleteScheduleUseCase,
+    this._loadPreparationByScheduleIdUseCase,
+    this._getPreparationByScheduleIdUseCase,
+    this._streamPreparationsUseCase,
   ) : super(MonthlySchedulesState()) {
     on<MonthlySchedulesSubscriptionRequested>(_onSubscriptionRequested);
     on<MonthlySchedulesMonthAdded>(_onMonthAdded);
     on<MonthlySchedulesScheduleDeleted>(_onScheduleDeleted);
+    on<MonthlySchedulesVisibleDateChanged>(_onVisibleDateChanged);
+    on<MonthlySchedulesPreparationsPrefetchRequested>(
+      _onPreparationsPrefetchRequested,
+    );
+    on<MonthlySchedulesPreparationsStreamChanged>(
+      _onPreparationsStreamChanged,
+    );
+
+    _preparationSubscription = _streamPreparationsUseCase().listen(
+      (preparations) {
+        add(
+          MonthlySchedulesPreparationsStreamChanged(
+            preparations: preparations,
+          ),
+        );
+      },
+    );
   }
 
   final LoadSchedulesForMonthUseCase _loadSchedulesForMonthUseCase;
   final GetSchedulesByDateUseCase _getSchedulesByDateUseCase;
   final DeleteScheduleUseCase _deleteScheduleUseCase;
+  final LoadPreparationByScheduleIdUseCase _loadPreparationByScheduleIdUseCase;
+  final GetPreparationByScheduleIdUseCase _getPreparationByScheduleIdUseCase;
+  final StreamPreparationsUseCase _streamPreparationsUseCase;
+
+  StreamSubscription<Map<String, PreparationEntity>>? _preparationSubscription;
 
   Future<void> _onSubscriptionRequested(
     MonthlySchedulesSubscriptionRequested event,
@@ -37,27 +68,17 @@ class MonthlySchedulesBloc
 
     await emit.forEach(
       _getSchedulesByDateUseCase(event.startDate, event.endDate),
-      onData: (schedules) => state.copyWith(
-        status: () => MonthlySchedulesStatus.success,
-        schedules: () => schedules.fold<Map<DateTime, List<ScheduleEntity>>>(
-          {},
-          (previousValue, element) {
-            final scheduleTime = DateTime(
-              element.scheduleTime.year,
-              element.scheduleTime.month,
-              element.scheduleTime.day,
-            );
-            if (previousValue.containsKey(scheduleTime)) {
-              previousValue[scheduleTime]!.add(element);
-            } else {
-              previousValue[scheduleTime] = [element];
-            }
-            return previousValue;
-          },
-        ),
-        startDate: () => event.startDate,
-        endDate: () => event.endDate,
-      ),
+      onData: (schedules) {
+        final groupedSchedules = _groupSchedulesByDate(schedules);
+        final nextState = state.copyWith(
+          status: () => MonthlySchedulesStatus.success,
+          schedules: () => groupedSchedules,
+          startDate: () => event.startDate,
+          endDate: () => event.endDate,
+        );
+        _requestVisibleDatePreparationPrefetch(nextState);
+        return nextState;
+      },
       onError: (error, stackTrace) => state.copyWith(
         status: () => MonthlySchedulesStatus.error,
       ),
@@ -106,27 +127,15 @@ class MonthlySchedulesBloc
     await emit.forEach(
       _getSchedulesByDateUseCase(startDate, endDate),
       onData: (schedules) {
-        return state.copyWith(
+        final groupedSchedules = _groupSchedulesByDate(schedules);
+        final nextState = state.copyWith(
           status: () => MonthlySchedulesStatus.success,
-          schedules: () => schedules.fold<Map<DateTime, List<ScheduleEntity>>>(
-            {},
-            (previousValue, element) {
-              final scheduleTime = DateTime(
-                element.scheduleTime.year,
-                element.scheduleTime.month,
-                element.scheduleTime.day,
-              );
-              if (previousValue.containsKey(scheduleTime)) {
-                previousValue[scheduleTime]!.add(element);
-              } else {
-                previousValue[scheduleTime] = [element];
-              }
-              return previousValue;
-            },
-          ),
+          schedules: () => groupedSchedules,
           startDate: () => startDate,
           endDate: () => endDate,
         );
+        _requestVisibleDatePreparationPrefetch(nextState);
+        return nextState;
       },
       onError: (error, stackTrace) {
         return state.copyWith(
@@ -141,8 +150,12 @@ class MonthlySchedulesBloc
     Emitter<MonthlySchedulesState> emit,
   ) async {
     try {
+      final updatedPreparationMap =
+          Map<String, Duration>.from(state.preparationDurationByScheduleId)
+            ..remove(event.schedule.id);
       emit(state.copyWith(
         lastDeletedSchedule: () => event.schedule,
+        preparationDurationByScheduleId: () => updatedPreparationMap,
       ));
       await _deleteScheduleUseCase(event.schedule);
     } catch (e) {
@@ -151,4 +164,160 @@ class MonthlySchedulesBloc
       ));
     }
   }
+
+  void _onVisibleDateChanged(
+    MonthlySchedulesVisibleDateChanged event,
+    Emitter<MonthlySchedulesState> emit,
+  ) {
+    final normalizedDate =
+        DateTime(event.date.year, event.date.month, event.date.day);
+    final nextState = state.copyWith(visibleDate: () => normalizedDate);
+    emit(nextState);
+    _requestVisibleDatePreparationPrefetch(nextState);
+  }
+
+  Future<void> _onPreparationsPrefetchRequested(
+    MonthlySchedulesPreparationsPrefetchRequested event,
+    Emitter<MonthlySchedulesState> emit,
+  ) async {
+    final missingIds = event.scheduleIds
+        .where((id) => !state.preparationDurationByScheduleId.containsKey(id))
+        .toSet();
+    if (missingIds.isEmpty) {
+      return;
+    }
+
+    final fetchedDurations = <String, Duration>{};
+    var hasUpdates = false;
+
+    for (final scheduleId in missingIds) {
+      try {
+        await _loadPreparationByScheduleIdUseCase(scheduleId);
+        if (state.preparationDurationByScheduleId.containsKey(scheduleId)) {
+          // Stream update already has fresher data.
+          continue;
+        }
+        final preparation =
+            await _getPreparationByScheduleIdUseCase(scheduleId);
+        fetchedDurations[scheduleId] = preparation.totalDuration;
+        hasUpdates = true;
+      } catch (_) {
+        // Keep fallback UI when loading fails.
+      }
+    }
+
+    if (hasUpdates) {
+      final updatedMap = Map<String, Duration>.from(
+        state.preparationDurationByScheduleId,
+      )..addAll(fetchedDurations);
+      emit(
+        state.copyWith(
+          preparationDurationByScheduleId: () => updatedMap,
+        ),
+      );
+    }
+  }
+
+  void _onPreparationsStreamChanged(
+    MonthlySchedulesPreparationsStreamChanged event,
+    Emitter<MonthlySchedulesState> emit,
+  ) {
+    final cachedScheduleIds = _getCachedScheduleIds(state.schedules);
+    if (cachedScheduleIds.isEmpty) {
+      return;
+    }
+
+    final nextDurations = Map<String, Duration>.from(
+      state.preparationDurationByScheduleId,
+    );
+    var hasChange = false;
+
+    for (final entry in event.preparations.entries) {
+      if (!cachedScheduleIds.contains(entry.key)) {
+        continue;
+      }
+
+      final nextDuration = entry.value.totalDuration;
+      if (nextDurations[entry.key] != nextDuration) {
+        nextDurations[entry.key] = nextDuration;
+        hasChange = true;
+      }
+    }
+
+    if (!hasChange) {
+      return;
+    }
+
+    emit(
+      state.copyWith(
+        preparationDurationByScheduleId: () => nextDurations,
+      ),
+    );
+  }
+
+  void _requestVisibleDatePreparationPrefetch(
+      MonthlySchedulesState sourceState) {
+    final visibleDate = sourceState.visibleDate;
+    if (visibleDate == null) {
+      return;
+    }
+    final scheduleIds = _getScheduleIdsForDate(
+      sourceState.schedules,
+      visibleDate,
+    );
+    if (scheduleIds.isEmpty) {
+      return;
+    }
+    add(MonthlySchedulesPreparationsPrefetchRequested(
+        scheduleIds: scheduleIds));
+  }
+
+  Map<DateTime, List<ScheduleEntity>> _groupSchedulesByDate(
+    List<ScheduleEntity> schedules,
+  ) {
+    return schedules.fold<Map<DateTime, List<ScheduleEntity>>>(
+      {},
+      (previousValue, element) {
+        final scheduleTime = DateTime(
+          element.scheduleTime.year,
+          element.scheduleTime.month,
+          element.scheduleTime.day,
+        );
+        if (previousValue.containsKey(scheduleTime)) {
+          previousValue[scheduleTime]!.add(element);
+        } else {
+          previousValue[scheduleTime] = [element];
+        }
+        return previousValue;
+      },
+    );
+  }
+
+  List<String> _getScheduleIdsForDate(
+    Map<DateTime, List<ScheduleEntity>> schedules,
+    DateTime date,
+  ) {
+    final normalizedDate = DateTime(date.year, date.month, date.day);
+    return schedules[normalizedDate]
+            ?.map((schedule) => schedule.id)
+            .toList(growable: false) ??
+        const <String>[];
+  }
+
+  Set<String> _getCachedScheduleIds(
+      Map<DateTime, List<ScheduleEntity>> schedules) {
+    final ids = <String>{};
+    for (final scheduleList in schedules.values) {
+      for (final schedule in scheduleList) {
+        ids.add(schedule.id);
+      }
+    }
+    return ids;
+  }
+
+  @override
+  Future<void> close() async {
+    await _preparationSubscription?.cancel();
+    return super.close();
+  }
 }