added more blocs

lib/domains/account/account_bloc.dart

@@ -5,13 +5,6 @@ import 'package:csv/csv.dart';
 import 'package:equatable/equatable.dart';
 import 'package:file_picker/file_picker.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
-import 'package:formz/formz.dart';
-import 'package:tunas/domains/account/models/transaction_account.dart';
-import 'package:tunas/domains/account/models/transaction_category.dart';
-import 'package:tunas/domains/account/models/transaction_date.dart';
-import 'package:tunas/domains/account/models/transaction_description.dart';
-import 'package:tunas/domains/account/models/transaction_line.dart';
-import 'package:tunas/domains/account/models/transaction_value.dart';
 import 'package:tunas/repositories/account/account_repository.dart';
 import 'package:tunas/repositories/account/models/transaction.dart';
 import 'package:uuid/uuid.dart';
@@ -25,36 +18,22 @@ class AccountBloc extends Bloc<AccountEvent, AccountState> {
   AccountBloc({required AccountRepository accountRepository})
       : _accountRepository = accountRepository,
         super(const AccountState()) {
-    on<AccountLoad>(_onAccountLoad);
     on<AccountImportJSON>(_onAccountImportJSON);
     on<AccountImportCSV>(_onAccountImportCSV);
     // on<AccountExportJSON>(_onAccountImportJSON);
     // on<AccountExportCSV>(_onAccountImportJSON);
-    on<TransactionDateChange>(_onTransactionDateChange);
-    on<TransactionCategoryChange>(_onTransactionCategoryChange);
-    on<TransactionDescriptionChange>(_onTransactionDescriptionChange);
-    on<TransactionAccountChange>(_onTransactionAccountChange);
-    on<TransactionValueChange>(_onTransactionValueChange);
-    on<TransactionOpenAddDialog>(_onTransactionOpenAddDialog);
-    on<TransactionHideAddDialog>(_onTransactionHideAddDialog);
-    on<TransactionAdd>(_onTransactionAddDialog);
-    on<TransactionSetCurrent>(_onTransactionSetCurrent);
-    on<TransactionDeleteCurrent>(_onTransactionDeleteCurrent);
-
-    _accountRepository
-        .getTransactionsStream()
-        .listen((transactions) => add(AccountLoad(transactions)));
   }
 
-  _onAccountLoad(AccountLoad event, Emitter<AccountState> emit) {
-    var computeResult = _computeTransactionLine(event.transactions);
-    emit(state.copyWith(
-      transactions: event.transactions,
-      transactionsLines: computeResult.list,
-      globalTotal: computeResult.globalTotal,
-      accountsTotals: computeResult.accountsTotals,
-      categories: computeResult.categories
-    ));
+  double _universalConvertToDouble(dynamic value) {
+    if (value is String) {
+      return double.parse(value);
+    } else if (value is int) {
+      return value.toDouble();
+    } else if (value is double) {
+      return value;
+    } else {
+      throw Error();
+    }
   }
 
   _onAccountImportCSV(
@@ -65,7 +44,7 @@ class AccountBloc extends Bloc<AccountEvent, AccountState> {
     if (csvPath != null) {
       final File csv = File(csvPath);
       final String csvFileContent = await csv.readAsString();
-      final List<List<dynamic>> csvList = const CsvToListConverter(fieldDelimiter: '|').convert(csvFileContent);
+      final List<List<dynamic>> csvList = const CsvToListConverter(fieldDelimiter: '|', eol: '\n').convert(csvFileContent);
 
       final transactions = csvList
           .map((line) => Transaction(
@@ -74,10 +53,11 @@ class AccountBloc extends Bloc<AccountEvent, AccountState> {
               category: line[1],
               description: line[2],
               account: line[3],
-              value: double.parse(line[4]))
+              value: _universalConvertToDouble(line[4]))
             )
           .toList();
-
+      
+      await _accountRepository.deleteAccount();
       await _accountRepository.saveTransactions(transactions);
     }
   }
@@ -93,186 +73,8 @@ class AccountBloc extends Bloc<AccountEvent, AccountState> {
       final List<dynamic> jsonList = jsonDecode(jsonString);
       final List<Transaction> transactions = jsonList.map((transaction) => Transaction.fromJson(transaction)).toList();
 
+      await _accountRepository.deleteAccount();
       await _accountRepository.saveTransactions(transactions);
     }
   }
-
-  ({List<TransactionLine> list, double globalTotal, Map<String, double> accountsTotals, List<String> categories}) _computeTransactionLine(List<Transaction> transactions) {
-    double globalTotal = 0;
-    Map<String, double> accountsTotals = <String, double>{};
-    List<TransactionLine> output = [];
-    Set<String> categories = {};
-
-    for(var transaction in transactions) {
-      double subTotal = globalTotal + transaction.value;
-      globalTotal = subTotal;
-
-      double accountTotal = accountsTotals[transaction.account] ?? 0;
-      accountTotal += transaction.value;
-      accountsTotals[transaction.account] = accountTotal;
-      categories.add(transaction.category);
-
-      output.add(TransactionLine(transaction: transaction, subTotal: subTotal));
-    }
-
-    output.sort((a, b) => b.transaction.date.compareTo(a.transaction.date));
-
-    return (list: output, globalTotal: globalTotal, accountsTotals: accountsTotals, categories: categories.toList());
-  }
-
-  _onTransactionDateChange(
-    TransactionDateChange event, Emitter<AccountState> emit
-  ) {
-    final transactionDate = TransactionDate.dirty(event.date);
-    emit(state.copyWith(
-      transactionDate: transactionDate,
-      isValid: Formz.validate([transactionDate, state.transactionCategory, state.transactionDescription, state.transactionAccount, state.transactionValue]),
-    ));
-  }
-
-  _onTransactionCategoryChange(
-    TransactionCategoryChange event, Emitter<AccountState> emit
-  ) {
-    final transactionCategory = TransactionCategory.dirty(event.category);
-    emit(state.copyWith(
-      transactionCategory: transactionCategory,
-      isValid: Formz.validate([state.transactionDate, transactionCategory, state.transactionDescription, state.transactionAccount, state.transactionValue]),
-    ));
-  }
-
-  _onTransactionDescriptionChange(
-    TransactionDescriptionChange event, Emitter<AccountState> emit
-  ) {
-    final transactionDescription = TransactionDescription.dirty(event.description);
-    emit(state.copyWith(
-      transactionDescription: transactionDescription,
-      isValid: Formz.validate([state.transactionDate, state.transactionCategory, transactionDescription, state.transactionAccount, state.transactionValue]),
-    ));
-  }
-
-  _onTransactionAccountChange(
-    TransactionAccountChange event, Emitter<AccountState> emit
-  ) {
-    final transactionAccount = TransactionAccount.dirty(event.account);
-    emit(state.copyWith(
-      transactionAccount: transactionAccount,
-      isValid: Formz.validate([state.transactionDate, state.transactionCategory, state.transactionDescription, transactionAccount, state.transactionValue]),
-    ));
-  }
-
-  _onTransactionValueChange(
-    TransactionValueChange event, Emitter<AccountState> emit
-  ) {
-    try {
-      final transactionValue = TransactionValue.dirty(double.parse(event.value));
-      emit(state.copyWith(
-        transactionValue: transactionValue,
-        isValid: Formz.validate([state.transactionDate, state.transactionCategory, state.transactionDescription, state.transactionAccount, transactionValue]),
-      ));
-    } catch (e) {
-      const transactionValue = TransactionValue.dirty(double.infinity);
-      emit(state.copyWith(
-        transactionValue: transactionValue,
-        isValid: Formz.validate([state.transactionDate, state.transactionCategory, state.transactionDescription, state.transactionAccount, transactionValue]),
-      ));
-    }
-  }
-
-  _onTransactionOpenAddDialog(
-    TransactionOpenAddDialog event, Emitter<AccountState> emit
-  ) {
-    emit(state.copyWith(showAddDialog: true));
-  }
-
-  _onTransactionHideAddDialog(
-    TransactionHideAddDialog event, Emitter<AccountState> emit
-  ) {
-    emit(state.copyWith(showAddDialog: false));
-  }
-
-  _onTransactionAddDialog(
-    TransactionAdd event, Emitter<AccountState> emit
-  ) async {
-    if (state.isValid) {
-      List<Transaction> transactions = state.transactions;
-      Transaction? currentTransaction = state.currentTransaction;
-      if (currentTransaction != null) {
-        transactions.removeWhere((transaction) => transaction.uuid == currentTransaction.uuid);
-      }
-
-      transactions.add(Transaction(
-        uuid: const Uuid().v8(),
-        date: state.transactionDate.value ?? DateTime.now(),
-        category: state.transactionCategory.value,
-        description: state.transactionDescription.value,
-        account: state.transactionAccount.value,
-        value: state.transactionValue.value
-      ));
-      final computeResult = _computeTransactionLine(transactions);
-
-      await _accountRepository.saveTransactions(transactions);
-      
-      emit(state.copyWith(
-        currentTransaction: null,
-        transactionDate: const TransactionDate.pure(),
-        transactionCategory: const TransactionCategory.pure(),
-        transactionDescription: const TransactionDescription.pure(),
-        transactionAccount: const TransactionAccount.pure(),
-        transactionValue: const TransactionValue.pure(),
-        transactions: transactions,
-        transactionsLines: computeResult.list,
-        globalTotal: computeResult.globalTotal,
-        accountsTotals: computeResult.accountsTotals,
-      ));
-    }
-  }
-
-  _onTransactionSetCurrent(
-    TransactionSetCurrent event, Emitter<AccountState> emit
-  ) {
-    Transaction? transaction = event.transaction;
-    if (transaction == null) {
-      emit(state.copyWith(
-        currentTransaction: event.transaction,
-        transactionDate: const TransactionDate.pure(),
-        transactionCategory: const TransactionCategory.pure(),
-        transactionDescription: const TransactionDescription.pure(),
-        transactionAccount: const TransactionAccount.pure(),
-        transactionValue: const TransactionValue.pure(),
-      ));
-    } else {
-      emit(state.copyWith(
-        currentTransaction: transaction,
-        transactionDate: TransactionDate.dirty(transaction.date),
-        transactionCategory: TransactionCategory.dirty(transaction.category),
-        transactionDescription: TransactionDescription.dirty(transaction.description),
-        transactionAccount: TransactionAccount.dirty(transaction.account),
-        transactionValue: TransactionValue.dirty(transaction.value),
-      ));
-    }
-  }
-
-  _onTransactionDeleteCurrent(
-    TransactionDeleteCurrent event, Emitter<AccountState> emit
-  ) async {
-    Transaction? currentTransaction = state.currentTransaction;
-    if (currentTransaction != null) {
-      List<Transaction> transactions = state.transactions;
-      transactions.removeWhere((transaction) => transaction.uuid == currentTransaction.uuid);
-      final computeResult = _computeTransactionLine(transactions);
-      await _accountRepository.saveTransactions(transactions);
-      emit(state.copyWith(
-        currentTransaction: null,
-        transactionDate: const TransactionDate.pure(),
-        transactionCategory: const TransactionCategory.pure(),
-        transactionDescription: const TransactionDescription.pure(),
-        transactionAccount: const TransactionAccount.pure(),
-        transactionValue: const TransactionValue.pure(),
-        transactions: transactions,
-        transactionsLines: computeResult.list,
-        globalTotal: computeResult.globalTotal,
-        accountsTotals: computeResult.accountsTotals,
-      ));
-    }
-  }
 }