Xeewy/TravelMate
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Implement group balance and expense management with new navigation and data handling

Browse Source
This commit is contained in:
Dayron
2025-10-28 13:06:42 +01:00
parent 94f1abfbc7
commit df1bb6da4a
10 changed files with 390 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
lib/blocs/balance/balance_bloc.dart
View File

@@ -5,6 +5,7 @@ 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;
@@ -19,20 +20,28 @@ class BalanceBloc extends Bloc<BalanceEvent, BalanceState> {
_balanceService = balanceService ?? BalanceService(balanceRepository: balanceRepository, expenseRepository: expenseRepository),
_errorService = errorService ?? ErrorService(),
super(BalanceInitial()) {
on<LoadGroupBalance>(_onLoadGroupBalance);
on<LoadGroupBalances>(_onLoadGroupBalance);
on<RefreshBalance>(_onRefreshBalance);
on<MarkSettlementAsCompleted>(_onMarkSettlementAsCompleted);
}
Future<void> _onLoadGroupBalance(
LoadGroupBalance event,
LoadGroupBalances event,
Emitter<BalanceState> emit,
) async {
try {
emit(BalanceLoading());
final groupBalance = await _balanceRepository.calculateGroupBalance(event.groupId);
emit(BalanceLoaded(groupBalance));
// 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()));
@@ -45,12 +54,20 @@ class BalanceBloc extends Bloc<BalanceEvent, BalanceState> {
) async {
try {
// Garde l'état actuel pendant le refresh si possible
if (state is! BalanceLoaded) {
if (state is! GroupBalancesLoaded) {
emit(BalanceLoading());
}
final groupBalance = await _balanceRepository.calculateGroupBalance(event.groupId);
emit(BalanceLoaded(groupBalance));
// 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()));

10
lib/blocs/balance/balance_event.dart
View File

@@ -7,13 +7,13 @@ abstract class BalanceEvent extends Equatable {
List<Object?> get props => [];
}
class LoadGroupBalance extends BalanceEvent {
class LoadGroupBalances extends BalanceEvent {
final String groupId;
const LoadGroupBalance(this.groupId);
const LoadGroupBalances(this.groupId);
@override
List<Object?> get props => [groupId];
List<Object> get props => [groupId];
}
class RefreshBalance extends BalanceEvent {

19
lib/blocs/balance/balance_state.dart
View File

@@ -1,5 +1,6 @@
import 'package:equatable/equatable.dart';
import '../../models/group_balance.dart';
import '../../models/settlement.dart';
import '../../models/user_balance.dart';
abstract class BalanceState extends Equatable {
const BalanceState();
@@ -12,13 +13,17 @@ class BalanceInitial extends BalanceState {}
class BalanceLoading extends BalanceState {}
class BalanceLoaded extends BalanceState {
final GroupBalance groupBalance;
const BalanceLoaded(this.groupBalance);
class GroupBalancesLoaded extends BalanceState {
final List<UserBalance> balances;
final List<Settlement> settlements;
const GroupBalancesLoaded({
required this.balances,
required this.settlements,
});
@override
List<Object?> get props => [groupBalance];
List<Object> get props => [balances, settlements];
}
class BalanceOperationSuccess extends BalanceState {

49
lib/components/account/account_content.dart
View File

@@ -7,7 +7,8 @@ import '../../blocs/account/account_state.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:travel_mate/components/error/error_content.dart';
import '../../blocs/user/user_state.dart' as user_state;
import '../../repositories/group_repository.dart'; // Ajouter cet import
import 'group_expenses_page.dart'; // Ajouter cet import
class AccountContent extends StatefulWidget {
const AccountContent({super.key});
@@ -17,6 +18,8 @@ class AccountContent extends StatefulWidget {
}
class _AccountContentState extends State<AccountContent> {
final _groupRepository = GroupRepository(); // Ajouter cette ligne
@override
void initState() {
super.initState();
@@ -45,6 +48,44 @@ class _AccountContentState extends State<AccountContent> {
}
}
// Nouvelle méthode pour naviguer vers la page des dépenses de groupe
Future<void> _navigateToGroupExpenses(Account account) async {
try {
// Récupérer le groupe associé au compte
final group = await _groupRepository.getGroupByTripId(account.tripId);
if (group != null && mounted) {
Navigator.push(
context,
MaterialPageRoute(
builder: (context) => GroupExpensesPage(
account: account,
group: group,
),
),
);
} else {
if (mounted) {
ScaffoldMessenger.of(context).showSnackBar(
const SnackBar(
content: Text('Groupe non trouvé pour ce compte'),
backgroundColor: Colors.red,
),
);
}
}
} catch (e) {
if (mounted) {
ScaffoldMessenger.of(context).showSnackBar(
SnackBar(
content: Text('Erreur lors du chargement du groupe: $e'),
backgroundColor: Colors.red,
),
);
}
}
}
@override
Widget build(BuildContext context) {
return BlocBuilder<UserBloc, user_state.UserState>(
@@ -221,7 +262,7 @@ class _AccountContentState extends State<AccountContent> {
),
subtitle: Text(memberInfo),
trailing: const Icon(Icons.chevron_right),
onTap: () {},
onTap: () => _navigateToGroupExpenses(account), // Modifier cette ligne
),
);
} catch (e) {
@@ -234,6 +275,4 @@ class _AccountContentState extends State<AccountContent> {
);
}
}
}
}

264
lib/components/account/group_expenses_page.dart
View File

@@ -0,0 +1,264 @@
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import '../../blocs/expense/expense_bloc.dart';
import '../../blocs/expense/expense_event.dart';
import '../../blocs/expense/expense_state.dart';
import '../../blocs/balance/balance_bloc.dart';
import '../../blocs/balance/balance_event.dart';
import '../../blocs/balance/balance_state.dart';
import '../../blocs/user/user_bloc.dart';
import '../../blocs/user/user_state.dart' as user_state;
import '../../models/account.dart';
import '../../models/group.dart';
import 'add_expense_dialog.dart';
import 'balances_tab.dart';
import 'expenses_tab.dart';
import 'settlements_tab.dart';
class GroupExpensesPage extends StatefulWidget {
final Account account;
final Group group;
const GroupExpensesPage({
super.key,
required this.account,
required this.group,
});
@override
State<GroupExpensesPage> createState() => _GroupExpensesPageState();
}
class _GroupExpensesPageState extends State<GroupExpensesPage>
with SingleTickerProviderStateMixin {
late TabController _tabController;
@override
void initState() {
super.initState();
_tabController = TabController(length: 3, vsync: this);
_loadData();
}
@override
void dispose() {
_tabController.dispose();
super.dispose();
}
void _loadData() {
// Charger les dépenses du groupe
context.read<ExpenseBloc>().add(LoadExpensesByGroup(widget.group.id));
// Charger les balances du groupe
context.read<BalanceBloc>().add(LoadGroupBalances(widget.group.id));
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: Text(widget.account.name),
backgroundColor: Theme.of(context).primaryColor,
foregroundColor: Colors.white,
elevation: 0,
bottom: TabBar(
controller: _tabController,
indicatorColor: Colors.white,
labelColor: Colors.white,
unselectedLabelColor: Colors.white70,
tabs: const [
Tab(
icon: Icon(Icons.balance),
text: 'Balances',
),
Tab(
icon: Icon(Icons.receipt_long),
text: 'Dépenses',
),
Tab(
icon: Icon(Icons.payment),
text: 'Règlements',
),
],
),
),
body: MultiBlocListener(
listeners: [
BlocListener<ExpenseBloc, ExpenseState>(
listener: (context, state) {
if (state is ExpenseOperationSuccess) {
ScaffoldMessenger.of(context).showSnackBar(
SnackBar(
content: Text(state.message),
backgroundColor: Colors.green,
),
);
_loadData(); // Recharger les données après une opération
} else if (state is ExpenseError) {
ScaffoldMessenger.of(context).showSnackBar(
SnackBar(
content: Text(state.message),
backgroundColor: Colors.red,
),
);
}
},
),
],
child: TabBarView(
controller: _tabController,
children: [
// Onglet Balances
BlocBuilder<BalanceBloc, BalanceState>(
builder: (context, state) {
if (state is BalanceLoading) {
return const Center(child: CircularProgressIndicator());
} else if (state is GroupBalancesLoaded) {
return BalancesTab(balances: state.balances);
} else if (state is BalanceError) {
return _buildErrorState('Erreur lors du chargement des balances: ${state.message}');
}
return _buildEmptyState('Aucune balance disponible');
},
),
// Onglet Dépenses
BlocBuilder<ExpenseBloc, ExpenseState>(
builder: (context, state) {
if (state is ExpenseLoading) {
return const Center(child: CircularProgressIndicator());
} else if (state is ExpensesLoaded) {
return ExpensesTab(
expenses: state.expenses,
group: widget.group,
);
} else if (state is ExpenseError) {
return _buildErrorState('Erreur lors du chargement des dépenses: ${state.message}');
}
return _buildEmptyState('Aucune dépense trouvée');
},
),
// Onglet Règlements
BlocBuilder<BalanceBloc, BalanceState>(
builder: (context, state) {
if (state is BalanceLoading) {
return const Center(child: CircularProgressIndicator());
} else if (state is GroupBalancesLoaded) {
return SettlementsTab(settlements: state.settlements);
} else if (state is BalanceError) {
return _buildErrorState('Erreur lors du chargement des règlements: ${state.message}');
}
return _buildEmptyState('Aucun règlement nécessaire');
},
),
],
),
),
floatingActionButton: FloatingActionButton(
onPressed: _showAddExpenseDialog,
heroTag: "add_expense_fab",
tooltip: 'Ajouter une dépense',
child: const Icon(Icons.add),
),
);
}
Widget _buildErrorState(String message) {
return Center(
child: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: [
Icon(
Icons.error_outline,
size: 80,
color: Colors.red[300],
),
const SizedBox(height: 16),
Text(
'Erreur',
style: TextStyle(
fontSize: 20,
fontWeight: FontWeight.bold,
color: Colors.red[600],
),
),
const SizedBox(height: 8),
Padding(
padding: const EdgeInsets.symmetric(horizontal: 32),
child: Text(
message,
style: TextStyle(
fontSize: 16,
color: Colors.grey[600],
),
textAlign: TextAlign.center,
),
),
const SizedBox(height: 32),
ElevatedButton.icon(
onPressed: _loadData,
icon: const Icon(Icons.refresh),
label: const Text('Réessayer'),
),
],
),
);
}
Widget _buildEmptyState(String message) {
return Center(
child: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: [
Icon(
Icons.info_outline,
size: 80,
color: Colors.grey[400],
),
const SizedBox(height: 16),
Text(
'Aucune donnée',
style: TextStyle(
fontSize: 20,
fontWeight: FontWeight.bold,
color: Colors.grey[600],
),
),
const SizedBox(height: 8),
Text(
message,
style: TextStyle(
fontSize: 16,
color: Colors.grey[500],
),
textAlign: TextAlign.center,
),
],
),
);
}
void _showAddExpenseDialog() {
final userState = context.read<UserBloc>().state;
if (userState is user_state.UserLoaded) {
showDialog(
context: context,
builder: (context) => AddExpenseDialog(
group: widget.group,
currentUser: userState.user,
),
);
} else {
ScaffoldMessenger.of(context).showSnackBar(
const SnackBar(
content: Text('Erreur: utilisateur non connecté'),
backgroundColor: Colors.red,
),
);
}
}
}

12
lib/main.dart
View File

@@ -66,11 +66,23 @@ class MyApp extends StatelessWidget {
RepositoryProvider<ExpenseRepository>(
create: (context) => ExpenseRepository(),
),
// Provide service instances so BLoCs can read them with context.read<T>()
RepositoryProvider<ExpenseService>(
create: (context) => ExpenseService(
expenseRepository: context.read<ExpenseRepository>(),
),
),
RepositoryProvider<BalanceRepository>(
create: (context) => BalanceRepository(
expenseRepository: context.read<ExpenseRepository>(),
),
),
RepositoryProvider<BalanceService>(
create: (context) => BalanceService(
balanceRepository: context.read<BalanceRepository>(),
expenseRepository: context.read<ExpenseRepository>(),
),
),
],
child: MultiBlocProvider(

2
lib/models/trip.dart
View File

@@ -76,8 +76,6 @@ class Trip {
status: map['status'] as String? ?? 'draft',
);
} catch (e) {
print('❌ Erreur parsing Trip: $e');
print('Map reçue: $map');
rethrow;
}
}

13
lib/repositories/balance_repository.dart
View File

@@ -43,6 +43,19 @@ class BalanceRepository {
}
}
Future<List<UserBalance>> calculateGroupUserBalances(String groupId) async {
try {
final expenses = await _expenseRepository
.getExpensesStream(groupId)
.first;
return _calculateUserBalances(expenses);
} catch (e) {
_errorService.logError('BalanceRepository', 'Erreur calcul user balances: $e');
rethrow;
}
}
// Calculer les balances individuelles
List<UserBalance> _calculateUserBalances(List<Expense> expenses) {
final Map<String, Map<String, dynamic>> userBalanceMap = {};

30
lib/repositories/trip_repository.dart
View File

@@ -7,35 +7,26 @@ class TripRepository {
CollectionReference get _tripsCollection => _firestore.collection('trips');
// Récupérer tous les voyages d'un utilisateur
Stream<List<Trip>> getTripsByUserId(String userId) {
print('🔍 Chargement des trips pour userId: $userId');
Stream<List<Trip>> getTripsByUserId(String userId) {
try {
return _tripsCollection
.where('participants', arrayContains: userId)
.snapshots()
.map((snapshot) {
print('📦 Snapshot reçu: ${snapshot.docs.length} documents');
.map((snapshot) {
final trips = snapshot.docs
.map((doc) {
try {
final data = doc.data() as Map<String, dynamic>;
print('📄 Document ${doc.id}: ${data.keys.toList()}');
return Trip.fromMap(data, doc.id);
} catch (e) {
print('❌ Erreur parsing trip ${doc.id}: $e');
return null;
}
})
.whereType<Trip>()
.toList();
print('✅ ${trips.length} trips parsés avec succès');
return trips;
});
} catch (e) {
print('❌ Erreur getTripsByUserId: $e');
throw Exception('Erreur lors de la récupération des voyages: $e');
}
}
@@ -43,16 +34,11 @@ class TripRepository {
// Créer un voyage et retourner son ID
Future<String> createTrip(Trip trip) async {
try {
print('📝 Création du voyage: ${trip.title}');
final tripData = trip.toMap();
// Ne pas modifier les timestamps ici, ils sont déjà au bon format
final docRef = await _tripsCollection.add(tripData);
print('✅ Voyage créé avec ID: ${docRef.id}');
return docRef.id;
} catch (e) {
print('❌ Erreur création voyage: $e');
throw Exception('Erreur lors de la création du voyage: $e');
}
}
@@ -63,13 +49,11 @@ class TripRepository {
final doc = await _tripsCollection.doc(tripId).get();
if (!doc.exists) {
print('⚠️ Voyage $tripId non trouvé');
return null;
}
return Trip.fromMap(doc.data() as Map<String, dynamic>, doc.id);
} catch (e) {
print('❌ Erreur getTripById: $e');
throw Exception('Erreur lors de la récupération du voyage: $e');
}
}
@@ -77,17 +61,12 @@ class TripRepository {
// Mettre à jour un voyage
Future<void> updateTrip(String tripId, Trip trip) async {
try {
print('📝 Mise à jour du voyage: $tripId');
final tripData = trip.toMap();
// Mettre à jour le timestamp de modification
tripData['updatedAt'] = Timestamp.now();
await _tripsCollection.doc(tripId).update(tripData);
print('✅ Voyage $tripId mis à jour');
} catch (e) {
print('❌ Erreur mise à jour voyage: $e');
throw Exception('Erreur lors de la mise à jour du voyage: $e');
}
}
@@ -95,13 +74,8 @@ class TripRepository {
// Supprimer un voyage
Future<void> deleteTrip(String tripId) async {
try {
print('🗑️ Suppression du voyage: $tripId');
await _tripsCollection.doc(tripId).delete();
print('✅ Voyage $tripId supprimé');
} catch (e) {
print('❌ Erreur suppression voyage: $e');
throw Exception('Erreur lors de la suppression du voyage: $e');
}
}

14
lib/services/balance_service.dart
View File

@@ -30,6 +30,20 @@ class BalanceService {
}
}
Future<List<Settlement>> calculateOptimalSettlements(String groupId) async {
try {
final expenses = await _expenseRepository
.getExpensesStream(groupId)
.first;
final userBalances = calculateUserBalances(expenses);
return optimizeSettlements(userBalances);
} catch (e) {
_errorService.logError('BalanceService', 'Erreur calcul settlements: $e');
rethrow;
}
}
/// Stream de la balance en temps réel
Stream<GroupBalance> getGroupBalanceStream(String groupId) {
return _expenseRepository.getExpensesStream(groupId).asyncMap((expenses) async {