Refactor - Pisahkan business logic antara cron track dan sync manual

lib/feature/presentation/bloc/cron_tracking/cron_tracking_bloc.dart

@@ -0,0 +1,64 @@
+import 'dart:async';
+
+import 'package:bloc/bloc.dart';
+import 'package:bloc_concurrency/bloc_concurrency.dart';
+import 'package:dipantau_desktop_client/core/util/helper.dart';
+import 'package:dipantau_desktop_client/feature/data/model/create_track/bulk_create_track_data_body.dart';
+import 'package:dipantau_desktop_client/feature/data/model/create_track/bulk_create_track_image_body.dart';
+import 'package:dipantau_desktop_client/feature/domain/usecase/bulk_create_track_data/bulk_create_track_data.dart';
+import 'package:dipantau_desktop_client/feature/domain/usecase/bulk_create_track_image/bulk_create_track_image.dart';
+
+part 'cron_tracking_event.dart';
+
+part 'cron_tracking_state.dart';
+
+class CronTrackingBloc extends Bloc<CronTrackingEvent, CronTrackingState> {
+  final Helper helper;
+  final BulkCreateTrackData bulkCreateTrackData;
+  final BulkCreateTrackImage bulkCreateTrackImage;
+
+  CronTrackingBloc({
+    required this.helper,
+    required this.bulkCreateTrackData,
+    required this.bulkCreateTrackImage,
+  }) : super(InitialCronTrackingState()) {
+    on<RunCronTrackingEvent>(_onRunCronTrackingEvent, transformer: restartable());
+  }
+
+  FutureOr<void> _onRunCronTrackingEvent(
+    RunCronTrackingEvent event,
+    Emitter<CronTrackingState> emit,
+  ) async {
+    final bodyData = event.bodyData;
+    final ids = <int>[];
+    if (bodyData != null) {
+      final result = await bulkCreateTrackData(
+        ParamsBulkCreateTrackData(
+          body: bodyData,
+        ),
+      );
+      if (result.response != null) {
+        ids.addAll(bodyData.data.where((element) => element.id != null).map((e) => e.id!));
+      }
+    }
+
+    final bodyImage = event.bodyImage;
+    final files = <String>[];
+    if (bodyImage != null) {
+      final result = await bulkCreateTrackImage(
+        ParamsBulkCreateTrackImage(
+          body: bodyImage,
+        ),
+      );
+      if (result.response != null) {
+        files.addAll(bodyImage.files);
+      }
+    }
+    emit(
+      SuccessRunCronTrackingState(
+        ids: ids,
+        files: files,
+      ),
+    );
+  }
+}

lib/feature/presentation/bloc/cron_tracking/cron_tracking_event.dart

@@ -0,0 +1,18 @@
+part of 'cron_tracking_bloc.dart';
+
+abstract class CronTrackingEvent {}
+
+class RunCronTrackingEvent extends CronTrackingEvent {
+  final BulkCreateTrackDataBody? bodyData;
+  final BulkCreateTrackImageBody? bodyImage;
+
+  RunCronTrackingEvent({
+    required this.bodyData,
+    required this.bodyImage,
+  });
+
+  @override
+  String toString() {
+    return 'RunCronTrackingEvent{bodyData: $bodyData, bodyImage: $bodyImage}';
+  }
+}

lib/feature/presentation/bloc/cron_tracking/cron_tracking_state.dart

@@ -0,0 +1,35 @@
+part of 'cron_tracking_bloc.dart';
+
+abstract class CronTrackingState {}
+
+class InitialCronTrackingState extends CronTrackingState {}
+
+class LoadingCronTrackingState extends CronTrackingState {}
+
+class FailureCronTrackingState extends CronTrackingState {
+  final String errorMessage;
+
+  FailureCronTrackingState({
+    required this.errorMessage,
+  });
+
+  @override
+  String toString() {
+    return 'FailureCronTrackingState{errorMessage: $errorMessage}';
+  }
+}
+
+class SuccessRunCronTrackingState extends CronTrackingState {
+  final List<int> ids;
+  final List<String> files;
+
+  SuccessRunCronTrackingState({
+    required this.ids,
+    required this.files,
+  });
+
+  @override
+  String toString() {
+    return 'SuccessRunCronTrackingState{ids: $ids, files: $files}';
+  }
+}

lib/feature/presentation/bloc/sync_manual/sync_manual_bloc.dart

@@ -0,0 +1,43 @@
+import 'dart:async';
+
+import 'package:bloc/bloc.dart';
+import 'package:bloc_concurrency/bloc_concurrency.dart';
+import 'package:dipantau_desktop_client/core/util/helper.dart';
+import 'package:dipantau_desktop_client/feature/data/model/create_track/bulk_create_track_data_body.dart';
+import 'package:dipantau_desktop_client/feature/domain/usecase/bulk_create_track_data/bulk_create_track_data.dart';
+
+part 'sync_manual_event.dart';
+
+part 'sync_manual_state.dart';
+
+class SyncManualBloc extends Bloc<SyncManualEvent, SyncManualState> {
+  final Helper helper;
+  final BulkCreateTrackData bulkCreateTrackData;
+
+  SyncManualBloc({
+    required this.helper,
+    required this.bulkCreateTrackData,
+  }) : super(InitialSyncManualState()) {
+    on<RunSyncManualEvent>(_onRunSyncManualEvent, transformer: restartable());
+  }
+
+  FutureOr<void> _onRunSyncManualEvent(
+    RunSyncManualEvent event,
+    Emitter<SyncManualState> emit,
+  ) async {
+    emit(LoadingSyncManualState());
+    await Future.delayed(const Duration(milliseconds: 2500));
+    final (:response, :failure) = await bulkCreateTrackData(
+      ParamsBulkCreateTrackData(
+        body: event.body,
+      ),
+    );
+    if (response != null) {
+      emit(SuccessRunSyncManualState());
+      return;
+    }
+
+    final errorMessage = helper.getErrorMessageFromFailure(failure);
+    emit(FailureSyncManualState(errorMessage: errorMessage));
+  }
+}

lib/feature/presentation/bloc/sync_manual/sync_manual_event.dart

@@ -0,0 +1,14 @@
+part of 'sync_manual_bloc.dart';
+
+abstract class SyncManualEvent {}
+
+class RunSyncManualEvent extends SyncManualEvent {
+  final BulkCreateTrackDataBody body;
+
+  RunSyncManualEvent({required this.body});
+
+  @override
+  String toString() {
+    return 'RunSyncManualEvent{body: $body}';
+  }
+}

lib/feature/presentation/bloc/sync_manual/sync_manual_state.dart

@@ -0,0 +1,20 @@
+part of 'sync_manual_bloc.dart';
+
+abstract class SyncManualState {}
+
+class InitialSyncManualState extends SyncManualState {}
+
+class LoadingSyncManualState extends SyncManualState {}
+
+class FailureSyncManualState extends SyncManualState {
+  final String errorMessage;
+
+  FailureSyncManualState({required this.errorMessage});
+
+  @override
+  String toString() {
+    return 'FailureSyncManualState{errorMessage: $errorMessage}';
+  }
+}
+
+class SuccessRunSyncManualState extends SyncManualState {}

lib/feature/presentation/bloc/tracking/tracking_bloc.dart

@@ -3,11 +3,7 @@ import 'dart:async';
 import 'package:bloc/bloc.dart';
 import 'package:bloc_concurrency/bloc_concurrency.dart';
 import 'package:dipantau_desktop_client/core/util/helper.dart';
-import 'package:dipantau_desktop_client/feature/data/model/create_track/bulk_create_track_data_body.dart';
-import 'package:dipantau_desktop_client/feature/data/model/create_track/bulk_create_track_image_body.dart';
 import 'package:dipantau_desktop_client/feature/data/model/create_track/create_track_body.dart';
-import 'package:dipantau_desktop_client/feature/domain/usecase/bulk_create_track_data/bulk_create_track_data.dart';
-import 'package:dipantau_desktop_client/feature/domain/usecase/bulk_create_track_image/bulk_create_track_image.dart';
 import 'package:dipantau_desktop_client/feature/domain/usecase/create_track/create_track.dart';
 
 part 'tracking_event.dart';
@@ -16,21 +12,13 @@ part 'tracking_state.dart';
 
 class TrackingBloc extends Bloc<TrackingEvent, TrackingState> {
   final CreateTrack createTrack;
-  final BulkCreateTrackData bulkCreateTrackData;
   final Helper helper;
-  final BulkCreateTrackImage bulkCreateTrackImage;
 
   TrackingBloc({
     required this.createTrack,
-    required this.bulkCreateTrackData,
     required this.helper,
-    required this.bulkCreateTrackImage,
   }) : super(InitialTrackingState()) {
     on<CreateTimeTrackingEvent>(_onCreateTimeTrackingEvent, transformer: sequential());
-
-    on<SyncManualTrackingEvent>(_onSyncManualTrackingEvent, transformer: sequential());
-
-    on<CronTrackingEvent>(_onCronTrackingEvent, transformer: sequential());
   }
 
   FutureOr<void> _onCreateTimeTrackingEvent(
@@ -54,57 +42,4 @@ class TrackingBloc extends Bloc<TrackingEvent, TrackingState> {
     final errorMessage = helper.getErrorMessageFromFailure(failure);
     emit(FailureTrackingState(errorMessage: errorMessage));
   }
-
-  FutureOr<void> _onSyncManualTrackingEvent(
-    SyncManualTrackingEvent event,
-    Emitter<TrackingState> emit,
-  ) async {
-    emit(LoadingTrackingState());
-    await Future.delayed(const Duration(milliseconds: 2500));
-    final (:response, :failure) = await bulkCreateTrackData(ParamsBulkCreateTrackData(body: event.body));
-    if (response != null) {
-      emit(SuccessSyncManualTrackingState());
-      return;
-    }
-
-    final errorMessage = helper.getErrorMessageFromFailure(failure);
-    emit(FailureTrackingState(errorMessage: errorMessage));
-  }
-
-  FutureOr<void> _onCronTrackingEvent(
-    CronTrackingEvent event,
-    Emitter<TrackingState> emit,
-  ) async {
-    final bodyData = event.bodyData;
-    final ids = <int>[];
-    if (bodyData != null) {
-      final result = await bulkCreateTrackData(
-        ParamsBulkCreateTrackData(
-          body: bodyData,
-        ),
-      );
-      if (result.response != null) {
-        ids.addAll(bodyData.data.where((element) => element.id != null).map((e) => e.id!));
-      }
-    }
-
-    final bodyImage = event.bodyImage;
-    final files = <String>[];
-    if (bodyImage != null) {
-      final result = await bulkCreateTrackImage(
-        ParamsBulkCreateTrackImage(
-          body: bodyImage,
-        ),
-      );
-      if (result.response != null) {
-        files.addAll(bodyImage.files);
-      }
-    }
-    emit(
-      SuccessCronTrackingState(
-        ids: ids,
-        files: files,
-      ),
-    );
-  }
 }

lib/feature/presentation/bloc/tracking/tracking_event.dart

@@ -17,30 +17,4 @@ class CreateTimeTrackingEvent extends TrackingEvent {
   String toString() {
     return 'CreateTimeTrackingEvent{body: $body, trackEntityId: $trackEntityId}';
   }
-}
-
-class SyncManualTrackingEvent extends TrackingEvent {
-  final BulkCreateTrackDataBody body;
-
-  SyncManualTrackingEvent({required this.body});
-
-  @override
-  String toString() {
-    return 'SyncManualTrackingEvent{body: $body}';
-  }
-}
-
-class CronTrackingEvent extends TrackingEvent {
-  final BulkCreateTrackDataBody? bodyData;
-  final BulkCreateTrackImageBody? bodyImage;
-
-  CronTrackingEvent({
-    required this.bodyData,
-    required this.bodyImage,
-  });
-
-  @override
-  String toString() {
-    return 'CronTrackingEvent{bodyData: $bodyData, bodyImage: $bodyImage}';
-  }
-}
+}

lib/feature/presentation/bloc/tracking/tracking_state.dart

@@ -32,21 +32,4 @@ class SuccessCreateTimeTrackingState extends TrackingState {
   String toString() {
     return 'SuccessCreateTimeTrackingState{files: $files, trackEntityId: $trackEntityId}';
   }
-}
-
-class SuccessSyncManualTrackingState extends TrackingState {}
-
-class SuccessCronTrackingState extends TrackingState {
-  final List<int> ids;
-  final List<String> files;
-
-  SuccessCronTrackingState({
-    required this.ids,
-    required this.files,
-  });
-
-  @override
-  String toString() {
-    return 'SuccessCronTrackingState{ids: $ids, files: $files}';
-  }
-}
+}