basic csv loader, transaction list & half done stats page

lib/domains/account/account_bloc.dart

@@ -0,0 +1,221 @@
+import 'dart:convert';
+import 'dart:io';
+
+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';
+
+part 'account_event.dart';
+part 'account_state.dart';
+
+class AccountBloc extends Bloc<AccountEvent, AccountState> {
+  final AccountRepository _accountRepository;
+
+  AccountBloc({required AccountRepository accountRepository})
+      : _accountRepository = accountRepository,
+        super(const AccountState()) {
+    on<AccountAddTransaction>(_onTransactionAdd);
+    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);
+
+    _accountRepository
+        .getTransactionsStream()
+        .listen((transactions) => add(AccountLoad(transactions)));
+  }
+
+  _onTransactionAdd(AccountAddTransaction event, Emitter<AccountState> emit) {
+    state.transactions.add(event.transaction);
+    var computeResult = _computeTransactionLine(state.transactions);
+    
+    emit(state.copyWith(
+      transactionsLines: computeResult.list,
+      globalTotal: computeResult.globalTotal,
+      accountsTotals: computeResult.accountsTotals,
+    ));
+  }
+
+  _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
+    ));
+  }
+
+  _onAccountImportCSV(
+      AccountImportCSV event, Emitter<AccountState> emit) async {
+    FilePickerResult? result = await FilePicker.platform.pickFiles();
+
+    final csvPath = result?.files.first.path;
+    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 transactions = csvList
+          .map((line) => Transaction(
+              date: DateTime.parse(line[0]),
+              category: line[1],
+              description: line[2],
+              account: line[3],
+              value: double.parse(line[4]))
+            )
+          .toList();
+
+      await _accountRepository.saveTransactions(transactions);
+    }
+  }
+
+  _onAccountImportJSON(
+      AccountImportJSON event, Emitter<AccountState> emit) async {
+    FilePickerResult? result = await FilePicker.platform.pickFiles();
+
+    final jsonPath = result?.files.first.path;
+    if (jsonPath != null) {
+      final File json = File(jsonPath);
+      final String jsonString = await json.readAsString();
+      final List<dynamic> jsonList = jsonDecode(jsonString);
+      final List<Transaction> transactions = jsonList.map((transaction) => Transaction.fromJson(transaction)).toList();
+
+      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
+  ) {
+    if (state.isValid) {
+      state.transactions.add(Transaction(
+        date: state.transactionDate.value ?? DateTime.now(),
+        category: state.transactionCategory.value,
+        description: state.transactionDescription.value,
+        account: state.transactionAccount.value,
+        value: state.transactionValue.value
+      ));
+      var computeResult = _computeTransactionLine(state.transactions);
+      
+      emit(state.copyWith(
+        transactionsLines: computeResult.list,
+        globalTotal: computeResult.globalTotal,
+        accountsTotals: computeResult.accountsTotals,
+      ));
+    }
+  }
+}

lib/domains/account/account_event.dart

@@ -0,0 +1,89 @@
+part of 'account_bloc.dart';
+
+sealed class AccountEvent extends Equatable {
+  const AccountEvent();
+
+  @override
+  List<Object> get props => [];
+}
+
+final class AccountAddTransaction extends AccountEvent {
+  final Transaction transaction;
+  const AccountAddTransaction(this.transaction);
+
+  @override
+  List<Object> get props => [transaction];
+}
+
+final class AccountLoad extends AccountEvent {
+  final List<Transaction> transactions;
+  const AccountLoad(this.transactions);
+
+  @override
+  List<Object> get props => [transactions];
+}
+
+final class AccountImportCSV extends AccountEvent {
+  const AccountImportCSV();
+}
+
+final class AccountImportJSON extends AccountEvent {
+  const AccountImportJSON();
+}
+
+final class AccountExportJSON extends AccountEvent {
+  const AccountExportJSON();
+}
+
+final class AccountExportCSV extends AccountEvent {
+  const AccountExportCSV();
+}
+
+final class TransactionDateChange extends AccountEvent {
+  final DateTime? date;
+  const TransactionDateChange(this.date);
+}
+
+final class TransactionCategoryChange extends AccountEvent {
+  final String category;
+  const TransactionCategoryChange(this.category);
+
+  @override
+  List<Object> get props => [category];
+}
+
+final class TransactionDescriptionChange extends AccountEvent {
+  final String description;
+  const TransactionDescriptionChange(this.description);
+
+  @override
+  List<Object> get props => [description];
+}
+
+final class TransactionAccountChange extends AccountEvent {
+  final String account;
+  const TransactionAccountChange(this.account);
+
+  @override
+  List<Object> get props => [account];
+}
+
+final class TransactionValueChange extends AccountEvent {
+  final String value;
+  const TransactionValueChange(this.value);
+
+  @override
+  List<Object> get props => [value];
+}
+
+final class TransactionAdd extends AccountEvent {
+  const TransactionAdd();
+}
+
+final class TransactionOpenAddDialog extends AccountEvent {
+  const TransactionOpenAddDialog();
+}
+
+final class TransactionHideAddDialog extends AccountEvent {
+  const TransactionHideAddDialog();
+}

lib/domains/account/account_state.dart

@@ -0,0 +1,79 @@
+part of 'account_bloc.dart';
+
+final class AccountState extends Equatable {
+  final List<Transaction> transactions;
+  final List<TransactionLine> transactionsLines;
+  final double globalTotal;
+  final Map<String, double> accountsTotals;
+
+  final List<String> categories;
+
+  final TransactionDate transactionDate;
+  final TransactionCategory transactionCategory;
+  final TransactionDescription transactionDescription;
+  final TransactionAccount transactionAccount;
+  final TransactionValue transactionValue;
+  final bool isValid;
+  final bool showAddDialog;
+
+  const AccountState({
+    this.transactions = const [],
+    this.transactionsLines = const [],
+    this.globalTotal = 0,
+    this.accountsTotals = const <String, double>{},
+    this.categories = const [],
+    this.transactionDate = const TransactionDate.pure(),
+    this.transactionCategory = const TransactionCategory.pure(),
+    this.transactionDescription = const TransactionDescription.pure(),
+    this.transactionAccount = const TransactionAccount.pure(),
+    this.transactionValue = const TransactionValue.pure(),
+    this.isValid = false,
+    this.showAddDialog = false,
+  });
+
+  AccountState copyWith({
+    List<Transaction>? transactions,
+    List<TransactionLine>? transactionsLines,
+    double? globalTotal,
+    Map<String, double>? accountsTotals,
+    List<String>? categories,
+    TransactionDate? transactionDate,
+    TransactionCategory? transactionCategory,
+    TransactionDescription? transactionDescription,
+    TransactionAccount? transactionAccount,
+    TransactionValue? transactionValue,
+    bool? isValid,
+    bool? showAddDialog,
+  }) {
+    return AccountState(
+      transactions: transactions ?? this.transactions,
+      transactionsLines: transactionsLines ?? this.transactionsLines,
+      globalTotal: globalTotal ?? this.globalTotal,
+      accountsTotals: accountsTotals ?? this.accountsTotals,
+      categories: categories ?? this.categories,
+      transactionDate: transactionDate ?? this.transactionDate,
+      transactionCategory: transactionCategory ?? this.transactionCategory,
+      transactionDescription: transactionDescription ?? this.transactionDescription,
+      transactionAccount: transactionAccount ?? this.transactionAccount,
+      transactionValue: transactionValue ?? this.transactionValue,
+      isValid: isValid ?? this.isValid,
+      showAddDialog: showAddDialog ?? this.showAddDialog,
+    );
+  }
+
+  @override
+  List<Object?> get props => [
+    transactions,
+    transactionsLines,
+    globalTotal,
+    accountsTotals,
+    categories,
+    transactionDate,
+    transactionCategory,
+    transactionDescription,
+    transactionAccount,
+    transactionValue,
+    isValid,
+    showAddDialog,
+  ];
+}

lib/domains/account/models/transaction_account.dart

@@ -0,0 +1,19 @@
+import 'package:formz/formz.dart';
+
+enum TransactionAccountValidationError {
+  empty('Account empty'),
+  invalid('Account invalid');
+
+  final String message;
+  const TransactionAccountValidationError(this.message);
+}
+
+class TransactionAccount extends FormzInput<String, TransactionAccountValidationError> {
+  const TransactionAccount.pure() : super.pure('');
+  const TransactionAccount.dirty([super.value = '']) : super.dirty();
+
+  @override
+  TransactionAccountValidationError? validator(String value) {
+    return value.isEmpty ? TransactionAccountValidationError.empty : null;
+  }
+}

lib/domains/account/models/transaction_category.dart

@@ -0,0 +1,19 @@
+import 'package:formz/formz.dart';
+
+enum TransactionCategoryValidationError {
+  empty('Category empty'),
+  invalid('Category invalid');
+
+  final String message;
+  const TransactionCategoryValidationError(this.message);
+}
+
+class TransactionCategory extends FormzInput<String, TransactionCategoryValidationError> {
+  const TransactionCategory.pure() : super.pure('');
+  const TransactionCategory.dirty([super.value = '']) : super.dirty();
+
+  @override
+  TransactionCategoryValidationError? validator(String value) {
+    return value.isEmpty ? TransactionCategoryValidationError.empty : null;
+  }
+}

lib/domains/account/models/transaction_date.dart

@@ -0,0 +1,19 @@
+import 'package:formz/formz.dart';
+
+enum TransactionDateValidationError {
+  empty('Date empty'),
+  invalid('Date invalid');
+
+  final String message;
+  const TransactionDateValidationError(this.message);
+}
+
+class TransactionDate extends FormzInput<DateTime?, TransactionDateValidationError> {
+  const TransactionDate.pure() : super.pure(null);
+  const TransactionDate.dirty([super.value]) : super.dirty();
+
+  @override
+  TransactionDateValidationError? validator(DateTime? value) {
+    return value == null ? TransactionDateValidationError.empty : null;
+  }
+}

lib/domains/account/models/transaction_description.dart

@@ -0,0 +1,19 @@
+import 'package:formz/formz.dart';
+
+enum TransactionDescriptionValidationError {
+  empty('Description empty'),
+  invalid('Description invalid');
+
+  final String message;
+  const TransactionDescriptionValidationError(this.message);
+}
+
+class TransactionDescription extends FormzInput<String, TransactionDescriptionValidationError> {
+  const TransactionDescription.pure() : super.pure('');
+  const TransactionDescription.dirty([super.value = '']) : super.dirty();
+
+  @override
+  TransactionDescriptionValidationError? validator(String value) {
+    return value.isEmpty ? TransactionDescriptionValidationError.empty : null;
+  }
+}

lib/domains/account/models/transaction_line.dart

@@ -0,0 +1,11 @@
+import 'package:tunas/repositories/account/models/transaction.dart';
+
+class TransactionLine {
+  Transaction transaction;
+  double subTotal;
+
+  TransactionLine({
+    required this.transaction,
+    required this.subTotal,
+  });
+}

lib/domains/account/models/transaction_value.dart

@@ -0,0 +1,23 @@
+import 'package:formz/formz.dart';
+
+enum TransactionValueValidationError {
+  empty('Value empty'),
+  invalid('Value invalid');
+
+  final String message;
+  const TransactionValueValidationError(this.message);
+}
+
+class TransactionValue extends FormzInput<double, TransactionValueValidationError> {
+  const TransactionValue.pure() : super.pure(0);
+  const TransactionValue.dirty([super.value = 0]) : super.dirty();
+
+  @override
+  TransactionValueValidationError? validator(double value) {
+    return value.isNaN
+      ? TransactionValueValidationError.empty
+      : value.isInfinite
+        ? TransactionValueValidationError.invalid
+        : null;
+  }
+}