reworked operation (#12)

Reviewed-on: #12
Co-authored-by: Mark M2 Macbook <marco@catelli.it>
Co-committed-by: Mark M2 Macbook <marco@catelli.it>

lib/features/home/latest_store_operations/bloc/latest_store_operations_bloc.dart

@@ -0,0 +1,66 @@
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:equatable/equatable.dart';
+import 'package:flux/features/operations/data/operations_repository.dart';
+import 'package:flux/features/operations/models/operation_model.dart';
+import 'package:get_it/get_it.dart';
+
+part '../../latest_store_operations/bloc/latest_store_operations_events.dart';
+part '../../latest_store_operations/bloc/latest_store_operations_state.dart';
+
+class LatestStoreOperationsBloc
+    extends Bloc<LatestStoreOperationsEvent, LatestStoreOperationsState> {
+  final _repository = GetIt.I.get<OperationsRepository>();
+
+  LatestStoreOperationsBloc()
+    : super(
+        const LatestStoreOperationsState(
+          status: LatestStoreOperationsStatus.initial,
+        ),
+      ) {
+    on<InitLastStoreOperationsEvent>((event, emit) async {
+      emit(state.copyWith(status: LatestStoreOperationsStatus.loading));
+      try {
+        // 1. Creiamo uno stream "intermedio" che idrata i dati
+        final hydratedStream = _repository
+            .getLastStoreOperationsStream(storeId: event.storeId, limit: 5)
+            .asyncMap((List<OperationModel> rawOperations) async {
+              // Questo gira ad ogni "scatto" dello stream di Supabase
+              List<OperationModel> fullyHydratedOperations = [];
+
+              for (OperationModel operation in rawOperations) {
+                // Peschiamo i dati completi (incluso il cliente)
+                OperationModel fullOperation = await _repository
+                    .fetchOperationById(operation.id!);
+                fullyHydratedOperations.add(fullOperation);
+              }
+
+              // Passiamo la lista completa allo step successivo
+              return fullyHydratedOperations;
+            });
+
+        // 2. Ora passiamo lo stream idratato all'emit.forEach
+        await emit.forEach(
+          hydratedStream, // Usiamo lo stream modificato!
+          onData: (List<OperationModel> fullyHydratedOperations) {
+            // Qui ora è tutto sincrono e bellissimo
+            return state.copyWith(
+              operations: fullyHydratedOperations,
+              status: LatestStoreOperationsStatus.success,
+            );
+          },
+          onError: (error, stackTrace) => state.copyWith(
+            status: LatestStoreOperationsStatus.failure,
+            error: error.toString(),
+          ),
+        );
+      } catch (e) {
+        emit(
+          state.copyWith(
+            status: LatestStoreOperationsStatus.failure,
+            error: e.toString(),
+          ),
+        );
+      }
+    });
+  }
+}

lib/features/home/latest_store_operations/bloc/latest_store_operations_events.dart

@@ -0,0 +1,17 @@
+part of 'latest_store_operations_bloc.dart';
+
+sealed class LatestStoreOperationsEvent extends Equatable {
+  const LatestStoreOperationsEvent();
+
+  @override
+  List<Object> get props => [];
+}
+
+class InitLastStoreOperationsEvent extends LatestStoreOperationsEvent {
+  final String storeId;
+
+  const InitLastStoreOperationsEvent(this.storeId);
+
+  @override
+  List<Object> get props => [storeId];
+}

lib/features/home/latest_store_operations/bloc/latest_store_operations_state.dart

@@ -0,0 +1,30 @@
+part of 'latest_store_operations_bloc.dart';
+
+enum LatestStoreOperationsStatus { initial, loading, success, failure }
+
+class LatestStoreOperationsState extends Equatable {
+  final LatestStoreOperationsStatus status;
+  final String? error;
+  final List<OperationModel> operations;
+
+  const LatestStoreOperationsState({
+    required this.status,
+    this.error,
+    this.operations = const [],
+  });
+
+  @override
+  List<Object?> get props => [status, error, operations];
+
+  LatestStoreOperationsState copyWith({
+    LatestStoreOperationsStatus? status,
+    String? error,
+    List<OperationModel>? operations,
+  }) {
+    return LatestStoreOperationsState(
+      status: status ?? this.status,
+      error: error,
+      operations: operations ?? this.operations,
+    );
+  }
+}