98 lines
3.2 KiB
Dart
98 lines
3.2 KiB
Dart
import 'package:flutter_bloc/flutter_bloc.dart';
|
|
import '../../repositories/balance_repository.dart';
|
|
import '../../repositories/expense_repository.dart';
|
|
import '../../services/balance_service.dart';
|
|
import '../../services/error_service.dart';
|
|
import 'balance_event.dart';
|
|
import 'balance_state.dart';
|
|
|
|
class BalanceBloc extends Bloc<BalanceEvent, BalanceState> {
|
|
final BalanceRepository _balanceRepository;
|
|
final BalanceService _balanceService;
|
|
final ErrorService _errorService;
|
|
|
|
BalanceBloc({
|
|
required BalanceRepository balanceRepository,
|
|
required ExpenseRepository expenseRepository,
|
|
BalanceService? balanceService,
|
|
ErrorService? errorService,
|
|
}) : _balanceRepository = balanceRepository,
|
|
_balanceService = balanceService ?? BalanceService(balanceRepository: balanceRepository, expenseRepository: expenseRepository),
|
|
_errorService = errorService ?? ErrorService(),
|
|
super(BalanceInitial()) {
|
|
on<LoadGroupBalances>(_onLoadGroupBalance);
|
|
on<RefreshBalance>(_onRefreshBalance);
|
|
on<MarkSettlementAsCompleted>(_onMarkSettlementAsCompleted);
|
|
}
|
|
|
|
Future<void> _onLoadGroupBalance(
|
|
LoadGroupBalances event,
|
|
Emitter<BalanceState> emit,
|
|
) async {
|
|
try {
|
|
emit(BalanceLoading());
|
|
|
|
// Calculer les balances du groupe
|
|
final userBalances = await _balanceRepository.calculateGroupUserBalances(event.groupId);
|
|
|
|
// Calculer les règlements optimisés
|
|
final settlements = await _balanceService.calculateOptimalSettlements(event.groupId);
|
|
|
|
emit(GroupBalancesLoaded(
|
|
balances: userBalances,
|
|
settlements: settlements,
|
|
));
|
|
} catch (e) {
|
|
_errorService.logError('BalanceBloc', 'Erreur chargement balance: $e');
|
|
emit(BalanceError(e.toString()));
|
|
}
|
|
}
|
|
|
|
Future<void> _onRefreshBalance(
|
|
RefreshBalance event,
|
|
Emitter<BalanceState> emit,
|
|
) async {
|
|
try {
|
|
// Garde l'état actuel pendant le refresh si possible
|
|
if (state is! GroupBalancesLoaded) {
|
|
emit(BalanceLoading());
|
|
}
|
|
|
|
// Calculer les balances du groupe
|
|
final userBalances = await _balanceRepository.calculateGroupUserBalances(event.groupId);
|
|
|
|
// Calculer les règlements optimisés
|
|
final settlements = await _balanceService.calculateOptimalSettlements(event.groupId);
|
|
|
|
emit(GroupBalancesLoaded(
|
|
balances: userBalances,
|
|
settlements: settlements,
|
|
));
|
|
} catch (e) {
|
|
_errorService.logError('BalanceBloc', 'Erreur refresh balance: $e');
|
|
emit(BalanceError(e.toString()));
|
|
}
|
|
}
|
|
|
|
Future<void> _onMarkSettlementAsCompleted(
|
|
MarkSettlementAsCompleted event,
|
|
Emitter<BalanceState> emit,
|
|
) async {
|
|
try {
|
|
await _balanceService.markSettlementAsCompleted(
|
|
groupId: event.groupId,
|
|
fromUserId: event.fromUserId,
|
|
toUserId: event.toUserId,
|
|
amount: event.amount,
|
|
);
|
|
|
|
emit(const BalanceOperationSuccess('Règlement marqué comme effectué'));
|
|
|
|
// Recharger la balance après le règlement
|
|
add(RefreshBalance(event.groupId));
|
|
} catch (e) {
|
|
_errorService.logError('BalanceBloc', 'Erreur mark settlement: $e');
|
|
emit(BalanceError(e.toString()));
|
|
}
|
|
}
|
|
} |