Refactor signup page to use BLoC pattern and implement authentication repository

- Updated signup.dart to replace Provider with BLoC for state management.
- Created AuthRepository to handle authentication logic and Firestore user management.
- Added TripRepository and UserRepository for trip and user data management.
- Implemented methods for user sign-in, sign-up, and data retrieval in repositories.
- Enhanced trip management with create, update, delete, and participant management functionalities.
- Updated AuthService to include new methods for sign-in and sign-up.
- Removed unnecessary print statements from TripService for cleaner code.
- Added dependencies for flutter_bloc and equatable in pubspec.yaml.

Not tested yet

lib/blocs/auth/auth_bloc.dart

@@ -0,0 +1,150 @@
+import 'package:flutter_bloc/flutter_bloc.dart';
+import '../../repositories/auth_repository.dart';
+import 'auth_event.dart';
+import 'auth_state.dart';
+
+class AuthBloc extends Bloc<AuthEvent, AuthState> {
+  final AuthRepository _authRepository;
+
+  AuthBloc({required AuthRepository authRepository})
+      : _authRepository = authRepository,
+        super(AuthInitial()) {
+    on<AuthCheckRequested>(_onAuthCheckRequested);
+    on<AuthSignInRequested>(_onSignInRequested);
+    on<AuthSignUpRequested>(_onSignUpRequested);
+    on<AuthGoogleSignInRequested>(_onGoogleSignInRequested);
+    on<AuthAppleSignInRequested>(_onAppleSignInRequested);
+    on<AuthSignOutRequested>(_onSignOutRequested);
+    on<AuthPasswordResetRequested>(_onPasswordResetRequested);
+  }
+
+  Future<void> _onAuthCheckRequested(
+    AuthCheckRequested event,
+    Emitter<AuthState> emit,
+  ) async {
+    emit(AuthLoading());
+    
+    try {
+      final currentUser = _authRepository.currentUser;
+      
+      if (currentUser != null) {
+        // Récupérer les données utilisateur depuis Firestore
+        final user = await _authRepository.getUserFromFirestore(currentUser.uid);
+        
+        if (user != null) {
+          emit(AuthAuthenticated(user: user));
+        } else {
+          emit(AuthUnauthenticated());
+        }
+      } else {
+        emit(AuthUnauthenticated());
+      }
+    } catch (e) {
+      emit(AuthError(message: e.toString()));
+    }
+  }
+
+  Future<void> _onSignInRequested(
+    AuthSignInRequested event,
+    Emitter<AuthState> emit,
+  ) async {
+    emit(AuthLoading());
+    
+    try {
+      final user = await _authRepository.signInWithEmailAndPassword(
+        email: event.email,
+        password: event.password,
+      );
+
+      if (user != null) {
+        emit(AuthAuthenticated(user: user));
+      } else {
+        emit(const AuthError(message: 'Email ou mot de passe incorrect'));
+      }
+    } catch (e) {
+      emit(AuthError(message: e.toString()));
+    }
+  }
+
+  Future<void> _onSignUpRequested(
+    AuthSignUpRequested event,
+    Emitter<AuthState> emit,
+  ) async {
+    emit(AuthLoading());
+    
+    try {
+      final user = await _authRepository.signUpWithEmailAndPassword(
+        email: event.email,
+        password: event.password,
+        nom: event.nom,
+        prenom: event.prenom,
+      );
+
+      if (user != null) {
+        emit(AuthAuthenticated(user: user));
+      } else {
+        emit(const AuthError(message: 'Erreur lors de l\'inscription'));
+      }
+    } catch (e) {
+      emit(AuthError(message: e.toString()));
+    }
+  }
+
+  Future<void> _onGoogleSignInRequested(
+    AuthGoogleSignInRequested event,
+    Emitter<AuthState> emit,
+  ) async {
+    emit(AuthLoading());
+    
+    try {
+      final user = await _authRepository.signInWithGoogle();
+
+      if (user != null) {
+        emit(AuthAuthenticated(user: user));
+      } else {
+        emit(const AuthError(message: 'Connexion Google annulée'));
+      }
+    } catch (e) {
+      emit(AuthError(message: e.toString()));
+    }
+  }
+
+  Future<void> _onAppleSignInRequested(
+    AuthAppleSignInRequested event,
+    Emitter<AuthState> emit,
+  ) async {
+    emit(AuthLoading());
+    
+    try {
+      final user = await _authRepository.signInWithApple();
+
+      if (user != null) {
+        emit(AuthAuthenticated(user: user));
+      } else {
+        emit(const AuthError(message: 'Connexion Apple annulée'));
+      }
+    } catch (e) {
+      emit(AuthError(message: e.toString()));
+    }
+  }
+
+  Future<void> _onSignOutRequested(
+    AuthSignOutRequested event,
+    Emitter<AuthState> emit,
+  ) async {
+    await _authRepository.signOut();
+    emit(AuthUnauthenticated());
+  }
+
+  Future<void> _onPasswordResetRequested(
+    AuthPasswordResetRequested event,
+    Emitter<AuthState> emit,
+  ) async {
+    try {
+      await _authRepository.resetPassword(event.email);
+      emit(AuthPasswordResetSent(email: event.email));
+    } catch (e) {
+      emit(AuthError(message: e.toString()));
+    }
+  }
+}

lib/blocs/auth/auth_event.dart

@@ -0,0 +1,55 @@
+import 'package:equatable/equatable.dart';
+
+abstract class AuthEvent extends Equatable {
+  const AuthEvent();
+
+  @override
+  List<Object?> get props => [];
+}
+
+class AuthCheckRequested extends AuthEvent {}
+
+class AuthSignInRequested extends AuthEvent {
+  final String email;
+  final String password;
+
+  const AuthSignInRequested({
+    required this.email,
+    required this.password,
+  });
+
+  @override
+  List<Object?> get props => [email, password];
+}
+
+class AuthSignUpRequested extends AuthEvent {
+  final String email;
+  final String password;
+  final String nom;
+  final String prenom;
+
+  const AuthSignUpRequested({
+    required this.email,
+    required this.password,
+    required this.nom,
+    required this.prenom,
+  });
+
+  @override
+  List<Object?> get props => [email, password, nom, prenom];
+}
+
+class AuthGoogleSignInRequested extends AuthEvent {}
+
+class AuthAppleSignInRequested extends AuthEvent {}
+
+class AuthSignOutRequested extends AuthEvent {}
+
+class AuthPasswordResetRequested extends AuthEvent {
+  final String email;
+
+  const AuthPasswordResetRequested({required this.email});
+
+  @override
+  List<Object?> get props => [email];
+}

lib/blocs/auth/auth_state.dart

@@ -0,0 +1,42 @@
+import 'package:equatable/equatable.dart';
+import '../../data/models/user.dart';
+
+abstract class AuthState extends Equatable {
+  const AuthState();
+
+  @override
+  List<Object?> get props => [];
+}
+
+class AuthInitial extends AuthState {}
+
+class AuthLoading extends AuthState {}
+
+class AuthAuthenticated extends AuthState {
+  final User user;
+
+  const AuthAuthenticated({required this.user});
+
+  @override
+  List<Object?> get props => [user];
+}
+
+class AuthUnauthenticated extends AuthState {}
+
+class AuthError extends AuthState {
+  final String message;
+
+  const AuthError({required this.message});
+
+  @override
+  List<Object?> get props => [message];
+}
+
+class AuthPasswordResetSent extends AuthState {
+  final String email;
+
+  const AuthPasswordResetSent({required this.email});
+
+  @override
+  List<Object?> get props => [email];
+}

lib/blocs/theme/theme_bloc.dart

@@ -0,0 +1,46 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'theme_event.dart';
+import 'theme_state.dart';
+
+class ThemeBloc extends Bloc<ThemeEvent, ThemeState> {
+  ThemeBloc() : super(const ThemeState()) {
+    on<ThemeChanged>(_onThemeChanged);
+    on<ThemeLoadRequested>(_onThemeLoadRequested);
+  }
+
+  Future<void> _onThemeChanged(
+    ThemeChanged event,
+    Emitter<ThemeState> emit,
+  ) async {
+    emit(state.copyWith(themeMode: event.themeMode));
+    
+    // Sauvegarder la préférence
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString('themeMode', event.themeMode.toString());
+  }
+
+  Future<void> _onThemeLoadRequested(
+    ThemeLoadRequested event,
+    Emitter<ThemeState> emit,
+  ) async {
+    final prefs = await SharedPreferences.getInstance();
+    final themeModeString = prefs.getString('themeMode');
+
+    if (themeModeString != null) {
+      ThemeMode themeMode;
+      switch (themeModeString) {
+        case 'ThemeMode.light':
+          themeMode = ThemeMode.light;
+          break;
+        case 'ThemeMode.dark':
+          themeMode = ThemeMode.dark;
+          break;
+        default:
+          themeMode = ThemeMode.system;
+      }
+      emit(state.copyWith(themeMode: themeMode));
+    }
+  }
+}

lib/blocs/theme/theme_event.dart

@@ -0,0 +1,20 @@
+import 'package:equatable/equatable.dart';
+import 'package:flutter/material.dart';
+
+abstract class ThemeEvent extends Equatable {
+  const ThemeEvent();
+
+  @override
+  List<Object?> get props => [];
+}
+
+class ThemeChanged extends ThemeEvent {
+  final ThemeMode themeMode;
+
+  const ThemeChanged({required this.themeMode});
+
+  @override
+  List<Object?> get props => [themeMode];
+}
+
+class ThemeLoadRequested extends ThemeEvent {}

lib/blocs/theme/theme_state.dart

@@ -0,0 +1,21 @@
+import 'package:equatable/equatable.dart';
+import 'package:flutter/material.dart';
+
+class ThemeState extends Equatable {
+  final ThemeMode themeMode;
+
+  const ThemeState({this.themeMode = ThemeMode.system});
+
+  bool get isDarkMode {
+    return themeMode == ThemeMode.dark;
+  }
+
+  ThemeState copyWith({ThemeMode? themeMode}) {
+    return ThemeState(
+      themeMode: themeMode ?? this.themeMode,
+    );
+  }
+
+  @override
+  List<Object?> get props => [themeMode];
+}

lib/blocs/trip/trip_bloc.dart

@@ -0,0 +1,118 @@
+import 'dart:async';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import '../../repositories/trip_repository.dart';
+import 'trip_event.dart';
+import 'trip_state.dart';
+import '../../data/models/trip.dart';
+
+class TripBloc extends Bloc<TripEvent, TripState> {
+  final TripRepository _tripRepository;
+  StreamSubscription? _tripsSubscription;
+
+  TripBloc({required TripRepository tripRepository})
+      : _tripRepository = tripRepository,
+        super(TripInitial()) {
+    on<TripLoadRequested>(_onLoadRequested);
+    on<TripCreateRequested>(_onCreateRequested);
+    on<TripUpdateRequested>(_onUpdateRequested);
+    on<TripDeleteRequested>(_onDeleteRequested);
+    on<TripParticipantAddRequested>(_onParticipantAddRequested);
+    on<TripParticipantRemoveRequested>(_onParticipantRemoveRequested);
+  }
+
+  Future<void> _onLoadRequested(
+    TripLoadRequested event,
+    Emitter<TripState> emit,
+  ) async {
+    emit(TripLoading());
+
+    await _tripsSubscription?.cancel();
+    
+    _tripsSubscription = _tripRepository.getUserTrips(event.userId).listen(
+      (trips) => add(const _TripUpdated(trips: [])), // Sera géré par un événement interne
+      onError: (error) => emit(TripError(message: error.toString())),
+    );
+  }
+
+  Future<void> _onCreateRequested(
+    TripCreateRequested event,
+    Emitter<TripState> emit,
+  ) async {
+    try {
+      await _tripRepository.createTrip(event.trip);
+      emit(const TripOperationSuccess(message: 'Voyage créé avec succès'));
+    } catch (e) {
+      emit(TripError(message: e.toString()));
+    }
+  }
+
+  Future<void> _onUpdateRequested(
+    TripUpdateRequested event,
+    Emitter<TripState> emit,
+  ) async {
+    try {
+      await _tripRepository.updateTrip(event.trip);
+      emit(const TripOperationSuccess(message: 'Voyage mis à jour'));
+    } catch (e) {
+      emit(TripError(message: e.toString()));
+    }
+  }
+
+  Future<void> _onDeleteRequested(
+    TripDeleteRequested event,
+    Emitter<TripState> emit,
+  ) async {
+    try {
+      await _tripRepository.deleteTrip(event.tripId);
+      emit(const TripOperationSuccess(message: 'Voyage supprimé'));
+    } catch (e) {
+      emit(TripError(message: e.toString()));
+    }
+  }
+
+  Future<void> _onParticipantAddRequested(
+    TripParticipantAddRequested event,
+    Emitter<TripState> emit,
+  ) async {
+    try {
+      await _tripRepository.addParticipant(
+        event.tripId,
+        event.participantEmail,
+      );
+      emit(const TripOperationSuccess(message: 'Participant ajouté'));
+    } catch (e) {
+      emit(TripError(message: e.toString()));
+    }
+  }
+
+  Future<void> _onParticipantRemoveRequested(
+    TripParticipantRemoveRequested event,
+    Emitter<TripState> emit,
+  ) async {
+    try {
+      await _tripRepository.removeParticipant(
+        event.tripId,
+        event.participantEmail,
+      );
+      emit(const TripOperationSuccess(message: 'Participant retiré'));
+    } catch (e) {
+      emit(TripError(message: e.toString()));
+    }
+  }
+
+  @override
+  Future<void> close() {
+    _tripsSubscription?.cancel();
+    return super.close();
+  }
+}
+
+// Événement interne pour les mises à jour du stream
+class _TripUpdated extends TripEvent {
+  final List<Trip> trips;
+
+  const _TripUpdated({required this.trips});
+
+  @override
+  List<Object?> get props => [trips];
+}

lib/blocs/trip/trip_event.dart

@@ -0,0 +1,71 @@
+import 'package:equatable/equatable.dart';
+import '../../data/models/trip.dart';
+
+abstract class TripEvent extends Equatable {
+  const TripEvent();
+
+  @override
+  List<Object?> get props => [];
+}
+
+class TripLoadRequested extends TripEvent {
+  final String userId;
+
+  const TripLoadRequested({required this.userId});
+
+  @override
+  List<Object?> get props => [userId];
+}
+
+class TripCreateRequested extends TripEvent {
+  final Trip trip;
+
+  const TripCreateRequested({required this.trip});
+
+  @override
+  List<Object?> get props => [trip];
+}
+
+class TripUpdateRequested extends TripEvent {
+  final Trip trip;
+
+  const TripUpdateRequested({required this.trip});
+
+  @override
+  List<Object?> get props => [trip];
+}
+
+class TripDeleteRequested extends TripEvent {
+  final String tripId;
+
+  const TripDeleteRequested({required this.tripId});
+
+  @override
+  List<Object?> get props => [tripId];
+}
+
+class TripParticipantAddRequested extends TripEvent {
+  final String tripId;
+  final String participantEmail;
+
+  const TripParticipantAddRequested({
+    required this.tripId,
+    required this.participantEmail,
+  });
+
+  @override
+  List<Object?> get props => [tripId, participantEmail];
+}
+
+class TripParticipantRemoveRequested extends TripEvent {
+  final String tripId;
+  final String participantEmail;
+
+  const TripParticipantRemoveRequested({
+    required this.tripId,
+    required this.participantEmail,
+  });
+
+  @override
+  List<Object?> get props => [tripId, participantEmail];
+}

lib/blocs/trip/trip_state.dart

@@ -0,0 +1,40 @@
+import 'package:equatable/equatable.dart';
+import '../../data/models/trip.dart';
+
+abstract class TripState extends Equatable {
+  const TripState();
+
+  @override
+  List<Object?> get props => [];
+}
+
+class TripInitial extends TripState {}
+
+class TripLoading extends TripState {}
+
+class TripLoaded extends TripState {
+  final List<Trip> trips;
+
+  const TripLoaded({required this.trips});
+
+  @override
+  List<Object?> get props => [trips];
+}
+
+class TripOperationSuccess extends TripState {
+  final String message;
+
+  const TripOperationSuccess({required this.message});
+
+  @override
+  List<Object?> get props => [message];
+}
+
+class TripError extends TripState {
+  final String message;
+
+  const TripError({required this.message});
+
+  @override
+  List<Object?> get props => [message];
+}