refined document sequence management

lib/features/settings/document_sequence/blocs/document_sequence_cubit.dart

@@ -1,68 +1,93 @@
+import 'package:equatable/equatable.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:flux/features/settings/document_sequence/data/document_sequence_repository.dart';
 import 'package:flux/features/settings/document_sequence/models/document_sequence_model.dart';
-import 'package:supabase_flutter/supabase_flutter.dart';
+import 'package:get_it/get_it.dart';
 
-class DocumentSequenceState {
+enum DocumentSequenceStatus { initial, loading, success, failure }
+
+class DocumentSequenceState extends Equatable {
+  final DocumentSequenceStatus status;
   final List<DocumentSequence> sequences;
-  final bool isLoading;
   final String? error;
 
-  DocumentSequenceState({
+  const DocumentSequenceState({
     this.sequences = const [],
-    this.isLoading = false,
     this.error,
+    this.status = DocumentSequenceStatus.initial,
   });
+
+  DocumentSequenceState copyWith({
+    List<DocumentSequence>? sequences,
+    String? error,
+    DocumentSequenceStatus? status,
+  }) {
+    return DocumentSequenceState(
+      sequences: sequences ?? this.sequences,
+      error: error ?? this.error,
+      status: status ?? this.status,
+    );
+  }
+
+  @override
+  List<Object?> get props => [sequences, error, status];
 }
 
 class DocumentSequenceCubit extends Cubit<DocumentSequenceState> {
   final String companyId;
-  final _supabase = Supabase.instance.client;
+  final _repository = GetIt.I.get<DocumentSequenceRepository>();
 
   DocumentSequenceCubit(this.companyId) : super(DocumentSequenceState());
 
   Future<void> loadSequences() async {
-    emit(DocumentSequenceState(isLoading: true));
+    emit(state.copyWith(status: DocumentSequenceStatus.loading));
     try {
-      final data = await _supabase
-          .from('document_sequences')
-          .select()
-          .eq('company_id', companyId);
-
-      final list = (data as List)
-          .map((e) => DocumentSequence.fromMap(e))
-          .toList();
-      emit(DocumentSequenceState(sequences: list));
+      final list = await _repository.getDocumentSequences();
+      emit(
+        state.copyWith(sequences: list, status: DocumentSequenceStatus.success),
+      );
     } catch (e) {
-      emit(DocumentSequenceState(error: e.toString()));
+      emit(
+        state.copyWith(
+          error: e.toString(),
+          status: DocumentSequenceStatus.failure,
+        ),
+      );
     }
   }
 
   void updateLocalSequence(String docType, {String? prefix, int? nextValue}) {
+    bool found = false;
     final newList = state.sequences.map((s) {
       if (s.docType == docType) {
+        found = true;
         return s.copyWith(prefix: prefix, nextValue: nextValue);
       }
       return s;
     }).toList();
-    emit(DocumentSequenceState(sequences: newList));
+    if (!found) {
+      newList.add(
+        DocumentSequence(
+          docType: docType,
+          prefix: prefix ?? '',
+          nextValue: nextValue ?? 1,
+        ),
+      );
+    }
+    emit(state.copyWith(sequences: newList));
   }
 
   Future<void> saveSequences() async {
     try {
       for (var seq in state.sequences) {
-        await _supabase.from('document_sequences').upsert({
-          'company_id': companyId,
-          'doc_type': seq.docType,
-          'next_value': seq.nextValue,
-          'prefix': seq.prefix,
-        });
+        await _repository.createOrUpdateSequence(sequence: seq);
       }
       // Opzionale: mostra un feedback di successo
     } catch (e) {
       emit(
-        DocumentSequenceState(
-          sequences: state.sequences,
+        state.copyWith(
           error: "Errore nel salvataggio",
+          status: DocumentSequenceStatus.failure,
         ),
       );
     }