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;
+  }
+}

lib/domains/charts/chart_bloc.dart

@@ -0,0 +1,207 @@
+import 'package:equatable/equatable.dart';
+import 'package:fl_chart/fl_chart.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:tunas/domains/account/models/transaction_line.dart';
+import 'package:tunas/domains/charts/models/chart_item.dart';
+import 'package:tunas/repositories/account/account_repository.dart';
+import 'package:tunas/repositories/account/models/transaction.dart';
+
+part 'chart_event.dart';
+part 'chart_state.dart';
+
+class ChartBloc extends Bloc<ChartEvent, ChartState> {
+  final AccountRepository _accountRepository;
+
+  ChartBloc({required AccountRepository accountRepository}) : 
+    _accountRepository = accountRepository, super(const ChartState()) {
+
+    on<ChartAccountLoad>(_onAccountLoad);
+    on<ChartNextYear>(_onNextYear);
+    on<ChartPreviousYear>(_onPreviousYear);
+
+    _accountRepository
+      .getTransactionsStream()
+      .listen((transactions) => add(ChartAccountLoad(transactions)));
+  }
+
+  _onAccountLoad(ChartAccountLoad event, Emitter<ChartState> emit) {
+    ChartState localState = state.copyWith(transactions: event.transactions);
+    emit(_computeStateStats(localState));
+  }
+
+  _onNextYear(ChartNextYear event, Emitter<ChartState> emit) {
+    ChartState localState = state.copyWith(currentYear: state.currentYear + 1);
+    emit(_computeStateScopedStats(localState));
+  }
+
+  _onPreviousYear(ChartPreviousYear event, Emitter<ChartState> emit) {
+    ChartState localState = state.copyWith(currentYear: state.currentYear - 1);
+    emit(_computeStateScopedStats(localState));
+  }
+
+  ChartState _computeStateStats(ChartState state) {
+    double globalTotal = 0;
+    Map<String, double> accountsTotals = <String, double>{};
+    List<TransactionLine> transactionsLines = [];
+
+    Map<String, double> categoriesTotals = {};
+    List<FlSpot> monthlyTotals = [];
+    Map<String, Map<String, double>> categoriesMonthlyTotals = {};
+
+    DateTime firstDate = DateTime.now();
+    DateTime lastDate = DateTime.fromMicrosecondsSinceEpoch(0);
+
+    for(var transaction in state.transactions) {
+      double subTotal = globalTotal + transaction.value;
+      globalTotal = subTotal;
+
+      double accountTotal = accountsTotals[transaction.account] ?? 0;
+      accountTotal += transaction.value;
+      accountsTotals[transaction.account] = accountTotal;
+
+      TransactionLine transactionLine = TransactionLine(transaction: transaction, subTotal: subTotal);
+
+      transactionsLines.add(transactionLine);
+      monthlyTotals.add(FlSpot(transactionLine.transaction.date.microsecondsSinceEpoch.toDouble(), transactionLine.subTotal));
+
+      if (firstDate.compareTo(transaction.date) < 0) {
+        firstDate = transaction.date;
+      }
+
+      if (lastDate.compareTo(transaction.date) > 0) {
+        lastDate = transaction.date;
+      }
+
+      double categoryTotal = categoriesTotals[transaction.category] ?? 0;
+      categoryTotal += transaction.value;
+      categoriesTotals[transaction.category] = categoryTotal;
+    }
+
+    return _computeStateScopedStats(state.copyWith(
+      transactionsLines: transactionsLines,
+      globalTotal: globalTotal,
+      accountsTotals: accountsTotals,
+      categoriesTotals: categoriesTotals,
+      monthlyTotals: monthlyTotals,
+      categoriesMonthlyTotals: categoriesMonthlyTotals,
+      firstDate: firstDate,
+      lastDate: lastDate,
+      currentYear: DateTime.now().year,
+    ));
+  }
+
+  ChartState _computeStateScopedStats(ChartState state) {
+    double globalTotal = 0;
+    List<ChartItem> scopedCategoriesPositiveTotals = [];
+    List<ChartItem> scopedCategoriesNegativeTotals = [];
+    Map<int, FlSpot> scopedMonthlyTotals = {};
+    Map<String, Map<String, double>> scopedCategoriesMonthlyTotals = {};
+
+    for(var transaction in state.transactions) {
+      double subTotal = globalTotal + transaction.value;
+      globalTotal = subTotal;
+
+      if (transaction.date.year != state.currentYear) {
+        continue;
+      }
+
+      if (state.accountsTotals.containsKey(transaction.category)) {
+        continue;
+      }
+
+      TransactionLine transactionLine = TransactionLine(transaction: transaction, subTotal: subTotal);
+
+      DateTime transactionDate = transactionLine.transaction.date;
+      int transactionDateDay = transactionDate.difference(DateTime(transactionDate.year,1,1)).inDays + 1;
+
+      scopedMonthlyTotals[transactionDateDay] = FlSpot(transactionDateDay.toDouble(), transactionLine.subTotal);
+
+      if (transaction.category.isEmpty) {
+        continue;
+      }
+
+      if (transaction.value >= 0) {
+        ChartItem? chartItem = scopedCategoriesPositiveTotals.firstWhere(
+          (item) => item.label == transaction.category,
+          orElse: () {
+            ChartItem newChartItem = ChartItem(label: transaction.category, value: 0);
+            scopedCategoriesPositiveTotals.add(newChartItem);
+            return newChartItem;
+          }
+        );
+        chartItem.value += transaction.value;
+      }
+
+      if (transaction.value < 0) {
+        ChartItem? chartItem = scopedCategoriesNegativeTotals.firstWhere(
+          (item) => item.label == transaction.category,
+          orElse: () {
+            ChartItem newChartItem = ChartItem(label: transaction.category, value: 0);
+            scopedCategoriesNegativeTotals.add(newChartItem);
+            return newChartItem;
+          }
+        );
+        chartItem.value += transaction.value;
+      }
+    }
+
+    List<ChartItem> scopedCategoriesPositiveTotalsPercents = [];
+    List<ChartItem> scopedCategoriesNegativeTotalsPercents = [];
+    List<ChartItem> scopedSimplifiedCategoriesPositiveTotalsPercents = [];
+    List<ChartItem> scopedSimplifiedCategoriesNegativeTotalsPercents = [];
+    if (scopedCategoriesPositiveTotals.isNotEmpty) {
+      double catergoriesTotal = scopedCategoriesPositiveTotals.map((item) => item.value).reduce((value, element) => value + element);
+      scopedCategoriesPositiveTotalsPercents = scopedCategoriesPositiveTotals.map((item) => ChartItem(label: item.label, value: item.value / catergoriesTotal * 100)).toList();
+
+      double otherPercentTotal = 0;
+      for (var item in scopedCategoriesPositiveTotalsPercents) {
+        if (item.value > 1) {
+          scopedSimplifiedCategoriesPositiveTotalsPercents.add(ChartItem(label: item.label, value: item.value));
+        } else {
+          otherPercentTotal += item.value;
+        }
+      }
+      scopedSimplifiedCategoriesPositiveTotalsPercents.add(ChartItem(label: 'Autre', value: otherPercentTotal));
+    }
+
+    if (scopedCategoriesNegativeTotals.isNotEmpty) {
+      double catergoriesTotal = scopedCategoriesNegativeTotals.map((item) => item.value).reduce((value, element) => value + element);
+      scopedCategoriesNegativeTotalsPercents = scopedCategoriesNegativeTotals.map((item) => ChartItem(label: item.label, value: item.value / catergoriesTotal * 100)).toList();
+
+      double otherPercentTotal = 0;
+      for (var item in scopedCategoriesNegativeTotalsPercents) {
+        if (item.value > 1) {
+          scopedSimplifiedCategoriesNegativeTotalsPercents.add(ChartItem(label: item.label, value: item.value));
+        } else {
+          otherPercentTotal += item.value;
+        }
+      }
+      scopedSimplifiedCategoriesNegativeTotalsPercents.add(ChartItem(label: 'Autre', value: otherPercentTotal));
+    }
+
+    List<ChartItem> scopedSimplifiedCategoriesPositiveTotals = [];
+    List<ChartItem> scopedSimplifiedCategoriesNegativeTotals = [];
+
+    scopedCategoriesPositiveTotals.sort((a, b) => a.value.compareTo(b.value));
+    scopedCategoriesPositiveTotalsPercents.sort((a, b) => a.value.compareTo(b.value));
+    scopedCategoriesNegativeTotals.sort((a, b) => a.value.compareTo(b.value));
+    scopedCategoriesNegativeTotalsPercents.sort((a, b) => a.value.compareTo(b.value));
+    scopedSimplifiedCategoriesPositiveTotals.sort((a, b) => a.value.compareTo(b.value));
+    scopedSimplifiedCategoriesPositiveTotalsPercents.sort((a, b) => a.value.compareTo(b.value));
+    scopedSimplifiedCategoriesNegativeTotals.sort((a, b) => a.value.compareTo(b.value));
+    scopedSimplifiedCategoriesNegativeTotalsPercents.sort((a, b) => a.value.compareTo(b.value));
+
+    return state.copyWith(
+      scopedCategoriesPositiveTotals: scopedCategoriesPositiveTotals,
+      scopedCategoriesPositiveTotalsPercents: scopedCategoriesPositiveTotalsPercents,
+      scopedCategoriesNegativeTotals: scopedCategoriesNegativeTotals,
+      scopedCategoriesNegativeTotalsPercents: scopedCategoriesNegativeTotalsPercents,
+      scopedSimplifiedCategoriesPositiveTotals: scopedSimplifiedCategoriesPositiveTotals,
+      scopedSimplifiedCategoriesPositiveTotalsPercents: scopedSimplifiedCategoriesPositiveTotalsPercents,
+      scopedSimplifiedCategoriesNegativeTotals: scopedSimplifiedCategoriesNegativeTotals,
+      scopedSimplifiedCategoriesNegativeTotalsPercents: scopedSimplifiedCategoriesNegativeTotalsPercents,
+      scopedMonthlyTotals: scopedMonthlyTotals.values.toList(),
+      scopedCategoriesMonthlyTotals: scopedCategoriesMonthlyTotals,
+    );
+  }
+}

lib/domains/charts/chart_event.dart

@@ -0,0 +1,19 @@
+part of 'chart_bloc.dart';
+
+sealed class ChartEvent extends Equatable {
+  const ChartEvent();
+
+  @override
+  List<Object> get props => [];
+}
+
+final class ChartAccountLoad extends ChartEvent {
+  final List<Transaction> transactions;
+  const ChartAccountLoad(this.transactions);
+
+  @override
+  List<Object> get props => [transactions];
+}
+
+final class ChartNextYear extends ChartEvent {}
+final class ChartPreviousYear extends ChartEvent {}

lib/domains/charts/chart_state.dart

@@ -0,0 +1,123 @@
+part of 'chart_bloc.dart';
+
+final class ChartState extends Equatable {
+  final List<Transaction> transactions;
+  final List<TransactionLine> transactionsLines;
+
+  final double globalTotal;
+  final Map<String, double> accountsTotals;
+
+  final DateTime? firstDate;
+  final DateTime? lastDate;
+
+  final num currentYear;
+
+  final Map<String, double> categoriesTotals;
+  final List<FlSpot> monthlyTotals;
+  final Map<String, Map<String, double>> categoriesMonthlyTotals;
+
+  final List<ChartItem> scopedCategoriesPositiveTotals;
+  final List<ChartItem> scopedCategoriesPositiveTotalsPercents;
+  final List<ChartItem> scopedCategoriesNegativeTotals;
+  final List<ChartItem> scopedCategoriesNegativeTotalsPercents;
+
+  final List<ChartItem> scopedSimplifiedCategoriesPositiveTotals;
+  final List<ChartItem> scopedSimplifiedCategoriesPositiveTotalsPercents;
+  final List<ChartItem> scopedSimplifiedCategoriesNegativeTotals;
+  final List<ChartItem> scopedSimplifiedCategoriesNegativeTotalsPercents;
+
+  final List<FlSpot> scopedMonthlyTotals;
+  final Map<String, Map<String, double>> scopedCategoriesMonthlyTotals;
+
+  const ChartState({
+    this.transactions = const [],
+    this.transactionsLines = const [],
+    this.globalTotal = 0,
+    this.accountsTotals = const {},
+    this.firstDate,
+    this.lastDate,
+    this.currentYear = 2000,
+    this.categoriesTotals = const {},
+    this.monthlyTotals = const [],
+    this.categoriesMonthlyTotals = const {},
+    this.scopedCategoriesPositiveTotals = const [],
+    this.scopedCategoriesPositiveTotalsPercents = const [],
+    this.scopedCategoriesNegativeTotals = const [],
+    this.scopedCategoriesNegativeTotalsPercents = const [],
+    this.scopedSimplifiedCategoriesPositiveTotals = const [],
+    this.scopedSimplifiedCategoriesPositiveTotalsPercents = const [],
+    this.scopedSimplifiedCategoriesNegativeTotals = const [],
+    this.scopedSimplifiedCategoriesNegativeTotalsPercents = const [],
+    this.scopedMonthlyTotals = const [],
+    this.scopedCategoriesMonthlyTotals = const {},
+  });
+
+  ChartState copyWith({
+    List<Transaction>? transactions,
+    List<TransactionLine>? transactionsLines,
+    double? globalTotal,
+    Map<String, double>? accountsTotals,
+    DateTime? firstDate,
+    DateTime? lastDate,
+    num? currentYear,
+    Map<String, double>? categoriesTotals,
+    List<FlSpot>? monthlyTotals,
+    Map<String, Map<String, double>>? categoriesMonthlyTotals,
+    List<ChartItem>? scopedCategoriesPositiveTotals,
+    List<ChartItem>? scopedCategoriesPositiveTotalsPercents,
+    List<ChartItem>? scopedCategoriesNegativeTotals,
+    List<ChartItem>? scopedCategoriesNegativeTotalsPercents,
+    List<ChartItem>? scopedSimplifiedCategoriesPositiveTotals,
+    List<ChartItem>? scopedSimplifiedCategoriesPositiveTotalsPercents,
+    List<ChartItem>? scopedSimplifiedCategoriesNegativeTotals,
+    List<ChartItem>? scopedSimplifiedCategoriesNegativeTotalsPercents,
+    List<FlSpot>? scopedMonthlyTotals,
+    Map<String, Map<String, double>>? scopedCategoriesMonthlyTotals,
+  }) {
+    return ChartState(
+      transactions: transactions ?? this.transactions,
+      transactionsLines: transactionsLines ?? this.transactionsLines,
+      globalTotal: globalTotal ?? this.globalTotal,
+      accountsTotals: accountsTotals ?? this.accountsTotals,
+      firstDate: firstDate ?? this.firstDate,
+      lastDate: lastDate ?? this.lastDate,
+      currentYear: currentYear ?? this.currentYear,
+      categoriesTotals: categoriesTotals ?? this.categoriesTotals,
+      monthlyTotals: monthlyTotals ?? this.monthlyTotals,
+      categoriesMonthlyTotals: categoriesMonthlyTotals ?? this.categoriesMonthlyTotals,
+      scopedCategoriesPositiveTotals: scopedCategoriesPositiveTotals ?? this.scopedCategoriesPositiveTotals,
+      scopedCategoriesPositiveTotalsPercents: scopedCategoriesPositiveTotalsPercents ?? this.scopedCategoriesPositiveTotalsPercents,
+      scopedCategoriesNegativeTotals: scopedCategoriesNegativeTotals ?? this.scopedCategoriesNegativeTotals,
+      scopedCategoriesNegativeTotalsPercents: scopedCategoriesNegativeTotalsPercents ?? this.scopedCategoriesNegativeTotalsPercents,
+      scopedSimplifiedCategoriesPositiveTotals: scopedSimplifiedCategoriesPositiveTotals ?? this.scopedSimplifiedCategoriesPositiveTotals,
+      scopedSimplifiedCategoriesPositiveTotalsPercents: scopedSimplifiedCategoriesPositiveTotalsPercents ?? this.scopedSimplifiedCategoriesPositiveTotalsPercents,
+      scopedSimplifiedCategoriesNegativeTotals: scopedSimplifiedCategoriesNegativeTotals ?? this.scopedSimplifiedCategoriesNegativeTotals,
+      scopedSimplifiedCategoriesNegativeTotalsPercents: scopedSimplifiedCategoriesNegativeTotalsPercents ?? this.scopedSimplifiedCategoriesNegativeTotalsPercents,
+      scopedMonthlyTotals: scopedMonthlyTotals ?? this.scopedMonthlyTotals,
+      scopedCategoriesMonthlyTotals: scopedCategoriesMonthlyTotals ?? this.scopedCategoriesMonthlyTotals,
+    );
+  }
+  
+  @override
+  List<Object> get props => [
+    transactions,
+    transactionsLines,
+    globalTotal,
+    accountsTotals,
+    currentYear,
+    categoriesTotals,
+    monthlyTotals,
+    categoriesMonthlyTotals,
+    scopedCategoriesPositiveTotals,
+    scopedCategoriesPositiveTotalsPercents,
+    scopedCategoriesNegativeTotals,
+    scopedCategoriesNegativeTotalsPercents,
+    scopedSimplifiedCategoriesPositiveTotals,
+    scopedSimplifiedCategoriesPositiveTotalsPercents,
+    scopedSimplifiedCategoriesNegativeTotals,
+    scopedSimplifiedCategoriesNegativeTotalsPercents,
+    scopedMonthlyTotals,
+    scopedCategoriesMonthlyTotals,
+  ];
+}
+

lib/domains/charts/models/chart_item.dart

@@ -0,0 +1,9 @@
+class ChartItem {
+  String label;
+  double value;
+
+  ChartItem({
+    required this.label,
+    required this.value,
+  });
+}