263 lines
12 KiB
Dart
263 lines
12 KiB
Dart
import 'package:equatable/equatable.dart';
|
|
import 'package:fl_chart/fl_chart.dart';
|
|
import 'package:flutter_bloc/flutter_bloc.dart';
|
|
import 'package:tunas/domains/charts/models/month_totals.dart';
|
|
import 'package:tunas/domains/transaction/models/transaction_line.dart';
|
|
import 'package:tunas/domains/charts/models/chart_item.dart';
|
|
import 'package:tunas/repositories/metadata/metadata_repository.dart';
|
|
import 'package:tunas/repositories/metadata/models/category.dart';
|
|
import 'package:tunas/repositories/transactions/models/transaction.dart';
|
|
import 'package:tunas/repositories/transactions/transactions_repository.dart';
|
|
|
|
part 'chart_event.dart';
|
|
part 'chart_state.dart';
|
|
|
|
class ChartBloc extends Bloc<ChartEvent, ChartState> {
|
|
final MetadataRepository _metadataRepository;
|
|
final TransactionsRepository _transactionsRepository;
|
|
|
|
ChartBloc({required MetadataRepository metadataRepository, required TransactionsRepository transactionsRepository}) :
|
|
_metadataRepository = metadataRepository, _transactionsRepository = transactionsRepository, super(const ChartState()) {
|
|
|
|
on<ChartTransactionsLoad>(_onChartTransactionsLoad);
|
|
on<ChartCategoriesLoad>(_onChartCategoriesLoad);
|
|
on<ChartNextYear>(_onNextYear);
|
|
on<ChartPreviousYear>(_onPreviousYear);
|
|
|
|
_transactionsRepository
|
|
.getTransactionsStream()
|
|
.listen((transactions) => add(ChartTransactionsLoad(transactions)));
|
|
|
|
_metadataRepository
|
|
.getCategoriesStream()
|
|
.listen((categories) => add(ChartCategoriesLoad(categories)));
|
|
}
|
|
|
|
_onChartTransactionsLoad(ChartTransactionsLoad event, Emitter<ChartState> emit) {
|
|
ChartState localState = state.copyWith(transactions: event.transactions);
|
|
emit(_computeStateStats(localState));
|
|
}
|
|
|
|
_onChartCategoriesLoad(ChartCategoriesLoad event, Emitter<ChartState> emit) {
|
|
ChartState localState = state.copyWith(categories: Map.fromEntries(event.categories.map((category) => MapEntry(category.label, category))));
|
|
emit(_computeStateStats(localState));
|
|
}
|
|
|
|
_onNextYear(ChartNextYear event, Emitter<ChartState> emit) {
|
|
if (state.lastDate!.year >= state.currentYear + 1) {
|
|
ChartState localState = state.copyWith(currentYear: state.currentYear + 1);
|
|
emit(_computeStateScopedStats(localState));
|
|
}
|
|
}
|
|
|
|
_onPreviousYear(ChartPreviousYear event, Emitter<ChartState> emit) {
|
|
if (state.firstDate!.year <= state.currentYear - 1) {
|
|
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;
|
|
double scoppedTotal = 0;
|
|
List<ChartItem> scopedCategoriesPositiveTotals = [];
|
|
List<ChartItem> scopedCategoriesNegativeTotals = [];
|
|
Map<int, FlSpot> scopedMonthlyTotalsMap = {};
|
|
Map<int, MonthTotals> scopedCategoriesMonthlyTotals = {};
|
|
|
|
Map<int, double> scopedMonthlyPostitiveTotals = {};
|
|
Map<int, double> scopedMonthlyNegativeTotals = {};
|
|
|
|
for(var transaction in state.transactions) {
|
|
globalTotal += transaction.value;
|
|
double subTotal = globalTotal;
|
|
|
|
if (transaction.date.year != state.currentYear) {
|
|
continue;
|
|
}
|
|
|
|
scoppedTotal += transaction.value;
|
|
|
|
TransactionLine transactionLine = TransactionLine(transaction: transaction, subTotal: subTotal);
|
|
|
|
DateTime transactionDate = transactionLine.transaction.date;
|
|
int transactionDateDay = transactionDate.difference(DateTime(transactionDate.year,1,1)).inDays + 1;
|
|
|
|
scopedMonthlyTotalsMap[transactionDateDay] = FlSpot(transactionDateDay.toDouble(), transactionLine.subTotal);
|
|
|
|
final category = state.categories[transaction.category];
|
|
if (category == null || category.transfert) {
|
|
continue;
|
|
}
|
|
|
|
MonthTotals? categoryMonthTotal = scopedCategoriesMonthlyTotals[transaction.date.month];
|
|
if (categoryMonthTotal == null) {
|
|
categoryMonthTotal = MonthTotals(negatives: {}, positives: {});
|
|
scopedCategoriesMonthlyTotals[transaction.date.month] = categoryMonthTotal;
|
|
}
|
|
|
|
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;
|
|
|
|
scopedMonthlyPostitiveTotals[transaction.date.month] = transaction.value + (scopedMonthlyPostitiveTotals[transaction.date.month] ?? 0);
|
|
categoryMonthTotal.positives[transaction.category] = transaction.value.abs() + (categoryMonthTotal.positives[transaction.category] ?? 0);
|
|
}
|
|
|
|
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;
|
|
|
|
scopedMonthlyNegativeTotals[transaction.date.month] = transaction.value + (scopedMonthlyPostitiveTotals[transaction.date.month] ?? 0);
|
|
categoryMonthTotal.negatives[transaction.category] = transaction.value.abs() + (categoryMonthTotal.negatives[transaction.category] ?? 0);
|
|
}
|
|
}
|
|
|
|
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) => b.value.compareTo(a.value));
|
|
scopedCategoriesPositiveTotalsPercents.sort((a, b) => b.value.compareTo(a.value));
|
|
scopedCategoriesNegativeTotals.sort((a, b) => a.value.compareTo(b.value));
|
|
scopedCategoriesNegativeTotalsPercents.sort((a, b) => a.value.compareTo(b.value));
|
|
scopedSimplifiedCategoriesPositiveTotals.sort((a, b) => b.value.compareTo(a.value));
|
|
scopedSimplifiedCategoriesPositiveTotalsPercents.sort((a, b) => b.value.compareTo(a.value));
|
|
scopedSimplifiedCategoriesNegativeTotals.sort((a, b) => a.value.compareTo(b.value));
|
|
scopedSimplifiedCategoriesNegativeTotalsPercents.sort((a, b) => a.value.compareTo(b.value));
|
|
|
|
for (var monthTotals in scopedCategoriesMonthlyTotals.values) {
|
|
_sortMapByValues(monthTotals.positives);
|
|
_sortMapByValues(monthTotals.negatives);
|
|
}
|
|
|
|
List<FlSpot> scopedMonthlyTotals = scopedMonthlyTotalsMap.values.toList();
|
|
scopedMonthlyTotals.sort((a, b) => a.x.compareTo(b.x));
|
|
|
|
return state.copyWith(
|
|
scoppedProfit: scoppedTotal,
|
|
scopedCategoriesPositiveTotals: scopedCategoriesPositiveTotals,
|
|
scopedCategoriesPositiveTotalsPercents: scopedCategoriesPositiveTotalsPercents,
|
|
scopedCategoriesNegativeTotals: scopedCategoriesNegativeTotals,
|
|
scopedCategoriesNegativeTotalsPercents: scopedCategoriesNegativeTotalsPercents,
|
|
scopedSimplifiedCategoriesPositiveTotals: scopedSimplifiedCategoriesPositiveTotals,
|
|
scopedSimplifiedCategoriesPositiveTotalsPercents: scopedSimplifiedCategoriesPositiveTotalsPercents,
|
|
scopedSimplifiedCategoriesNegativeTotals: scopedSimplifiedCategoriesNegativeTotals,
|
|
scopedSimplifiedCategoriesNegativeTotalsPercents: scopedSimplifiedCategoriesNegativeTotalsPercents,
|
|
scopedMonthlyTotals: scopedMonthlyTotals,
|
|
scopedCategoriesMonthlyTotals: scopedCategoriesMonthlyTotals,
|
|
scopedMonthlyPostitiveTotals: scopedMonthlyPostitiveTotals,
|
|
scopedMonthlyNegativeTotals: scopedMonthlyNegativeTotals,
|
|
);
|
|
}
|
|
|
|
Map<dynamic, dynamic> _sortMapByValues(Map<dynamic, dynamic> map) {
|
|
final sortedEntries = map.entries.toList()..sort((a, b) {
|
|
var diff = b.value.compareTo(a.value);
|
|
return diff;
|
|
});
|
|
|
|
return map
|
|
..clear()
|
|
..addEntries(sortedEntries);
|
|
}
|
|
}
|