feat(frontend): Séparation des demandes d'amitié envoyées et reçues

- Ajout de deux endpoints distincts dans Urls: getSentFriendRequestsWithUserId et getReceivedFriendRequestsWithUserId
- Ajout de méthodes dans FriendsRepository et FriendsRepositoryImpl pour récupérer séparément les demandes envoyées et reçues
- Ajout de la méthode cancelFriendRequest pour annuler une demande envoyée
- Modification de FriendsProvider pour gérer deux listes distinctes: sentRequests et receivedRequests
- Mise à jour de FriendsScreen pour afficher deux sections:
  - Demandes reçues: avec boutons Accepter/Rejeter
  - Demandes envoyées: avec bouton Annuler uniquement
- Correction du mapping JSON dans FriendRequest.fromJson (userNom/userPrenoms correctement mappés)
- Amélioration de FriendRequestCard pour gérer les deux types de demandes
- Correction de la validation d'URL d'image dans FriendDetailScreen
- Support du champ uuid dans UserModel.fromJson pour compatibilité backend

lib/presentation/widgets/add_friend_dialog.dart

@@ -0,0 +1,448 @@
+import 'package:flutter/material.dart';
+import 'package:http/http.dart' as http;
+import 'package:provider/provider.dart';
+
+import '../../core/constants/env_config.dart';
+import '../../core/constants/urls.dart';
+import '../../data/datasources/user_remote_data_source.dart';
+import '../../data/models/user_model.dart';
+import '../../data/providers/friends_provider.dart';
+import '../../data/services/secure_storage.dart';
+import '../../domain/entities/friend.dart';
+
+/// Dialogue pour rechercher et ajouter un nouvel ami.
+///
+/// Ce widget permet de rechercher des utilisateurs par email ou nom,
+/// puis d'envoyer une demande d'ami.
+class AddFriendDialog extends StatefulWidget {
+  const AddFriendDialog({
+    required this.onFriendAdded,
+    super.key,
+  });
+
+  /// Callback appelé lorsqu'un ami est ajouté avec succès
+  final VoidCallback onFriendAdded;
+
+  @override
+  State<AddFriendDialog> createState() => _AddFriendDialogState();
+}
+
+class _AddFriendDialogState extends State<AddFriendDialog> {
+  final TextEditingController _searchController = TextEditingController();
+  final SecureStorage _secureStorage = SecureStorage();
+  late final UserRemoteDataSource _userDataSource;
+
+  List<UserModel> _searchResults = [];
+  bool _isSearching = false;
+  String? _errorMessage;
+  String? _currentUserId;
+
+  @override
+  void initState() {
+    super.initState();
+    _userDataSource = UserRemoteDataSource(http.Client());
+    _loadCurrentUserId();
+  }
+
+  @override
+  void dispose() {
+    _searchController.dispose();
+    super.dispose();
+  }
+
+  /// Charge l'ID de l'utilisateur actuel
+  Future<void> _loadCurrentUserId() async {
+    final userId = await _secureStorage.getUserId();
+    setState(() {
+      _currentUserId = userId;
+    });
+  }
+
+  /// Recherche des utilisateurs par email
+  Future<void> _searchUsers(String query) async {
+    if (query.trim().isEmpty) {
+      setState(() {
+        _searchResults = [];
+        _errorMessage = null;
+      });
+      return;
+    }
+
+    final email = query.trim().toLowerCase();
+    
+    if (!_isValidEmail(email)) {
+      setState(() {
+        _searchResults = [];
+        _errorMessage = 'Veuillez entrer un email valide';
+        _isSearching = false;
+      });
+      return;
+    }
+
+    setState(() {
+      _isSearching = true;
+      _errorMessage = null;
+      _searchResults = [];
+    });
+
+    try {
+      // Rechercher l'utilisateur par email via l'API
+      final user = await _userDataSource.searchUserByEmail(email);
+      
+      setState(() {
+        _searchResults = [user];
+        _isSearching = false;
+      });
+    } catch (e) {
+      if (EnvConfig.enableDetailedLogs) {
+        debugPrint('[AddFriendDialog] Erreur de recherche: $e');
+      }
+      
+      String errorMessage;
+      if (e.toString().contains('UserNotFoundException') || e.toString().contains('non trouvé')) {
+        errorMessage = 'Aucun utilisateur trouvé avec cet email';
+      } else {
+        errorMessage = 'Erreur lors de la recherche: ${e.toString()}';
+      }
+      
+      setState(() {
+        _errorMessage = errorMessage;
+        _isSearching = false;
+        _searchResults = [];
+      });
+    }
+  }
+
+  /// Vérifie si l'email est valide
+  bool _isValidEmail(String email) {
+    return RegExp(r'^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$').hasMatch(email);
+  }
+
+  /// Ajoute un ami par son UUID
+  Future<void> _addFriend(String friendId) async {
+    if (_currentUserId == null || _currentUserId!.isEmpty) {
+      _showError('Vous devez être connecté pour ajouter un ami');
+      return;
+    }
+
+    if (friendId.trim().isEmpty) {
+      _showError('ID utilisateur invalide');
+      return;
+    }
+
+    String? friendEmail;
+
+    try {
+      setState(() {
+        _isSearching = true;
+        _errorMessage = null;
+      });
+
+      // Récupérer les informations de l'utilisateur par son ID pour affichage
+      try {
+        final user = await _userDataSource.getUser(friendId);
+        friendEmail = user.email;
+      } catch (e) {
+        // Si l'utilisateur n'est pas trouvé, on continue quand même avec l'ID
+        if (EnvConfig.enableDetailedLogs) {
+          debugPrint('[AddFriendDialog] Impossible de récupérer les infos utilisateur: $e');
+        }
+      }
+
+      // Envoyer la demande d'ami via le provider (seulement l'UUID est nécessaire)
+      final friendsProvider = Provider.of<FriendsProvider>(context, listen: false);
+      await friendsProvider.addFriend(friendId);
+
+      if (mounted) {
+        Navigator.of(context).pop();
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(
+            content: Text('Demande d\'ami envoyée${friendEmail != null ? ' à $friendEmail' : ''}'),
+            behavior: SnackBarBehavior.floating,
+            backgroundColor: Colors.green,
+          ),
+        );
+        widget.onFriendAdded();
+      }
+    } catch (e) {
+      if (EnvConfig.enableDetailedLogs) {
+        debugPrint('[AddFriendDialog] Erreur lors de l\'ajout: $e');
+        debugPrint('[AddFriendDialog] Type d\'erreur: ${e.runtimeType}');
+      }
+      
+      // Extraire un message d'erreur plus clair
+      String errorMessage;
+      if (e.toString().contains('ValidationException')) {
+        // Extraire le message après "ValidationException: "
+        final parts = e.toString().split('ValidationException: ');
+        errorMessage = parts.length > 1 ? parts[1] : 'Données invalides';
+      } else if (e.toString().contains('ServerException')) {
+        final parts = e.toString().split('ServerException: ');
+        errorMessage = parts.length > 1 ? parts[1] : 'Erreur serveur';
+      } else if (e.toString().contains('ConflictException')) {
+        final parts = e.toString().split('ConflictException: ');
+        errorMessage = parts.length > 1 ? parts[1] : 'Cet utilisateur est déjà votre ami';
+      } else {
+        errorMessage = e.toString().replaceAll(RegExp(r'^[A-Za-z]+Exception: '), '');
+        if (errorMessage.isEmpty || errorMessage == e.toString()) {
+          errorMessage = 'Erreur lors de l\'ajout de l\'ami. Veuillez réessayer.';
+        }
+      }
+      
+      _showError(errorMessage);
+    } finally {
+      if (mounted) {
+        setState(() {
+          _isSearching = false;
+        });
+      }
+    }
+  }
+
+  /// Affiche une erreur
+  void _showError(String message) {
+    if (mounted) {
+      setState(() {
+        _errorMessage = message;
+      });
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+
+    return Dialog(
+      shape: RoundedRectangleBorder(
+        borderRadius: BorderRadius.circular(16),
+      ),
+      child: Container(
+        constraints: const BoxConstraints(maxWidth: 400, maxHeight: 600),
+        padding: const EdgeInsets.all(24),
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
+          crossAxisAlignment: CrossAxisAlignment.stretch,
+          children: [
+            _buildHeader(theme),
+            const SizedBox(height: 16),
+            _buildSearchField(theme),
+            const SizedBox(height: 16),
+            if (_errorMessage != null) _buildErrorMessage(theme),
+            if (_isSearching) _buildLoadingIndicator(theme),
+            if (!_isSearching && _searchResults.isNotEmpty)
+              _buildSearchResults(theme),
+            const SizedBox(height: 16),
+            _buildActions(theme),
+          ],
+        ),
+      ),
+    );
+  }
+
+  /// Construit l'en-tête du dialogue
+  Widget _buildHeader(ThemeData theme) {
+    return Row(
+      children: [
+        Icon(
+          Icons.person_add,
+          color: theme.colorScheme.primary,
+          size: 28,
+        ),
+        const SizedBox(width: 12),
+        Expanded(
+          child: Text(
+            'Ajouter un ami',
+            style: theme.textTheme.titleLarge?.copyWith(
+              fontWeight: FontWeight.bold,
+            ),
+          ),
+        ),
+        IconButton(
+          icon: const Icon(Icons.close),
+          onPressed: () => Navigator.of(context).pop(),
+          padding: EdgeInsets.zero,
+          constraints: const BoxConstraints(),
+        ),
+      ],
+    );
+  }
+
+      /// Construit le champ de recherche
+  Widget _buildSearchField(ThemeData theme) {
+    return TextField(
+      controller: _searchController,
+      decoration: InputDecoration(
+        hintText: 'Entrez l\'email de l\'ami',
+        prefixIcon: const Icon(Icons.person_search),
+        suffixIcon: _searchController.text.isNotEmpty
+            ? IconButton(
+                icon: const Icon(Icons.clear),
+                onPressed: () {
+                  _searchController.clear();
+                  setState(() {
+                    _searchResults = [];
+                    _errorMessage = null;
+                  });
+                },
+              )
+            : null,
+        helperText: 'Recherchez un utilisateur par son adresse email',
+        border: OutlineInputBorder(
+          borderRadius: BorderRadius.circular(12),
+        ),
+      ),
+      onChanged: (value) {
+        setState(() {
+          _errorMessage = null;
+        });
+        // Recherche automatique après un délai
+        if (value.trim().isNotEmpty && _isValidEmail(value.trim())) {
+          Future.delayed(const Duration(milliseconds: 500), () {
+            if (_searchController.text == value) {
+              _searchUsers(value.trim());
+            }
+          });
+        } else {
+          setState(() {
+            _searchResults = [];
+          });
+        }
+      },
+      textInputAction: TextInputAction.search,
+      keyboardType: TextInputType.emailAddress,
+      onSubmitted: (value) {
+        if (value.trim().isNotEmpty) {
+          _searchUsers(value.trim());
+        }
+      },
+    );
+  }
+
+  /// Construit le message d'erreur
+  Widget _buildErrorMessage(ThemeData theme) {
+    return Container(
+      padding: const EdgeInsets.all(12),
+      decoration: BoxDecoration(
+        color: theme.colorScheme.errorContainer,
+        borderRadius: BorderRadius.circular(8),
+      ),
+      child: Row(
+        children: [
+          Icon(
+            Icons.error_outline,
+            color: theme.colorScheme.error,
+            size: 20,
+          ),
+          const SizedBox(width: 8),
+          Expanded(
+            child: Text(
+              _errorMessage!,
+              style: theme.textTheme.bodySmall?.copyWith(
+                color: theme.colorScheme.onErrorContainer,
+              ),
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  /// Construit l'indicateur de chargement
+  Widget _buildLoadingIndicator(ThemeData theme) {
+    return const Padding(
+      padding: EdgeInsets.all(24),
+      child: Center(
+        child: CircularProgressIndicator(),
+      ),
+    );
+  }
+
+  /// Construit les résultats de recherche
+  Widget _buildSearchResults(ThemeData theme) {
+    if (_isSearching) {
+      return const Padding(
+        padding: EdgeInsets.all(24),
+        child: Center(
+          child: CircularProgressIndicator(),
+        ),
+      );
+    }
+
+    if (_searchResults.isEmpty) {
+      return const SizedBox.shrink();
+    }
+
+    return Padding(
+      padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
+      child: ListView.builder(
+        shrinkWrap: true,
+        physics: const NeverScrollableScrollPhysics(),
+        itemCount: _searchResults.length,
+        itemBuilder: (context, index) {
+          final user = _searchResults[index];
+          return _buildUserTile(theme, user);
+        },
+      ),
+    );
+  }
+
+  /// Construit une tuile d'utilisateur
+  Widget _buildUserTile(ThemeData theme, UserModel user) {
+    return Card(
+      margin: const EdgeInsets.only(bottom: 8),
+      child: ListTile(
+        leading: CircleAvatar(
+          backgroundColor: theme.colorScheme.primaryContainer,
+          backgroundImage: user.profileImageUrl.isNotEmpty &&
+                  user.profileImageUrl.startsWith('http')
+              ? NetworkImage(user.profileImageUrl)
+              : null,
+          onBackgroundImageError: (exception, stackTrace) {
+            // Ignorer les erreurs de chargement d'image
+            if (EnvConfig.enableDetailedLogs) {
+              debugPrint('[AddFriendDialog] Erreur de chargement d\'image: $exception');
+            }
+          },
+          child: user.profileImageUrl.isEmpty ||
+                  !user.profileImageUrl.startsWith('http')
+              ? Text(
+                  user.userFirstName.isNotEmpty
+                      ? user.userFirstName[0].toUpperCase()
+                      : '?',
+                  style: TextStyle(
+                    color: theme.colorScheme.onPrimaryContainer,
+                  ),
+                )
+              : null,
+        ),
+        title: Text(
+          '${user.userFirstName} ${user.userLastName}'.trim(),
+          style: theme.textTheme.titleMedium,
+        ),
+        subtitle: Text(
+          user.email,
+          style: theme.textTheme.bodySmall,
+        ),
+        trailing: IconButton(
+          icon: const Icon(Icons.person_add),
+          onPressed: _isSearching ? null : () => _addFriend(user.userId),
+          tooltip: 'Ajouter comme ami',
+        ),
+      ),
+    );
+  }
+
+  /// Construit les actions du dialogue
+  Widget _buildActions(ThemeData theme) {
+    return Row(
+      mainAxisAlignment: MainAxisAlignment.end,
+      children: [
+        TextButton(
+          onPressed: () => Navigator.of(context).pop(),
+          child: const Text('Annuler'),
+        ),
+      ],
+    );
+  }
+}
+

lib/presentation/widgets/friend_detail_screen.dart

@@ -7,6 +7,11 @@ import '../../domain/entities/friend.dart';
 /// et une option pour envoyer un message.
 /// Utilisé lorsque l'utilisateur clique sur un ami pour voir plus de détails.
 class FriendDetailScreen extends StatelessWidget {
+
+  /// Constructeur de la classe [FriendDetailScreen].
+  FriendDetailScreen({
+    required this.friendFirstName, required this.friendLastName, required this.imageUrl, required this.friendId, required this.status, required this.lastInteraction, required this.dateAdded, super.key,
+  });
   final String friendFirstName; // Nom de l'ami
   final String friendLastName;
   final String imageUrl; // URL de l'image de profil de l'ami
@@ -16,18 +21,6 @@ class FriendDetailScreen extends StatelessWidget {
   final String lastInteraction;
   final String dateAdded;
 
-  /// Constructeur de la classe [FriendDetailScreen].
-  FriendDetailScreen({
-    Key? key,
-    required this.friendFirstName,
-    required this.friendLastName,
-    required this.imageUrl,
-    required this.friendId,
-    required this.status,
-    required this.lastInteraction,
-    required this.dateAdded,
-  }) : super(key: key);
-
   /// Méthode statique pour lancer l'écran des détails d'un ami.
   static void open(
       BuildContext context,
@@ -37,7 +30,7 @@ class FriendDetailScreen extends StatelessWidget {
       String imageUrl,
       FriendStatus status,
       String lastInteraction,
-      String dateAdded) {
+      String dateAdded,) {
     Navigator.push(
       context,
       MaterialPageRoute(
@@ -54,16 +47,44 @@ class FriendDetailScreen extends StatelessWidget {
     );
   }
 
+  /// Vérifie si une URL est valide pour le chargement d'image réseau.
+  bool _isValidImageUrl(String? url) {
+    if (url == null || url.isEmpty) {
+      return false;
+    }
+    
+    try {
+      final uri = Uri.tryParse(url);
+      if (uri == null) {
+        return false;
+      }
+      
+      // Vérifier que c'est une URL HTTP/HTTPS valide
+      if (!uri.hasScheme || (!uri.scheme.startsWith('http'))) {
+        return false;
+      }
+      
+      // Vérifier qu'il y a un host
+      if (uri.host.isEmpty) {
+        return false;
+      }
+      
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
   @override
   Widget build(BuildContext context) {
     _logger.i('[LOG] Affichage des détails de l\'ami : $friendFirstName (ID: $friendId)');
 
-    // Utilise `AssetImage` si `imageUrl` est vide ou ne contient pas d'URL valide.
-    final imageProvider =
-    imageUrl.isNotEmpty && Uri.tryParse(imageUrl)?.hasAbsolutePath == true
+    // Vérifier si l'URL est valide avant de créer le NetworkImage
+    final bool hasValidImageUrl = _isValidImageUrl(imageUrl);
+    final ImageProvider imageProvider = hasValidImageUrl
         ? NetworkImage(imageUrl)
         : const AssetImage('lib/assets/images/default_avatar.png')
-    as ImageProvider;
+        as ImageProvider;
 
     return Scaffold(
       appBar: AppBar(
@@ -72,10 +93,9 @@ class FriendDetailScreen extends StatelessWidget {
         elevation: 6, // Ombre sous l'app bar pour plus de profondeur
       ),
       body: Padding(
-        padding: const EdgeInsets.all(16.0), // Espacement autour du contenu
+        padding: const EdgeInsets.all(16), // Espacement autour du contenu
         child: SingleChildScrollView(
           child: Column(
-            crossAxisAlignment: CrossAxisAlignment.center,
             children: [
               // Animation Hero pour une transition fluide lors de la navigation
               Hero(
@@ -85,12 +105,12 @@ class FriendDetailScreen extends StatelessWidget {
                   curve: Curves.easeInOut,
                   child: CircleAvatar(
                     radius: 80,
-                    backgroundImage: imageProvider,
+                    backgroundImage: hasValidImageUrl ? imageProvider : null,
                     backgroundColor: Colors.grey.shade800,
                     onBackgroundImageError: (error, stackTrace) {
                       _logger.e('[ERROR] Erreur lors du chargement de l\'image pour $friendFirstName (ID: $friendId): $error');
                     },
-                    child: imageUrl.isEmpty
+                    child: !hasValidImageUrl
                         ? const Icon(Icons.person, size: 60, color: Colors.white)
                         : null,
                   ),
@@ -156,9 +176,8 @@ class FriendDetailScreen extends StatelessWidget {
   /// Widget réutilisable pour afficher une ligne d'information avec un texte d'introduction et une valeur.
   Widget _buildInfoRow(String label, String value) {
     return Padding(
-      padding: const EdgeInsets.only(bottom: 12.0),
+      padding: const EdgeInsets.only(bottom: 12),
       child: Row(
-        mainAxisAlignment: MainAxisAlignment.start,
         children: [
           Text(
             label,

lib/presentation/widgets/friend_request_card.dart

@@ -0,0 +1,114 @@
+import 'package:flutter/material.dart';
+
+import '../../domain/entities/friend_request.dart';
+
+/// Widget pour afficher une demande d'amitié en attente.
+/// Permet d'accepter ou de rejeter la demande (reçue) ou d'annuler (envoyée).
+class FriendRequestCard extends StatelessWidget {
+  const FriendRequestCard({
+    required this.request,
+    required this.onAccept,
+    required this.onReject,
+    this.isSentRequest = false,
+    super.key,
+  });
+
+  final FriendRequest request;
+  final VoidCallback? onAccept;
+  final VoidCallback onReject;
+  final bool isSentRequest;
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    
+    return Card(
+      margin: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
+      child: Padding(
+        padding: const EdgeInsets.all(16),
+        child: Row(
+          children: [
+            // Avatar
+            CircleAvatar(
+              radius: 28,
+              backgroundColor: theme.colorScheme.primaryContainer,
+              child: Text(
+                (isSentRequest ? request.friendFullName : request.userFullName).isNotEmpty
+                    ? (isSentRequest ? request.friendFullName : request.userFullName)[0].toUpperCase()
+                    : '?',
+                style: TextStyle(
+                  color: theme.colorScheme.onPrimaryContainer,
+                  fontSize: 20,
+                  fontWeight: FontWeight.bold,
+                ),
+              ),
+            ),
+            const SizedBox(width: 16),
+            
+            // Informations
+            Expanded(
+              child: Column(
+                crossAxisAlignment: CrossAxisAlignment.start,
+                children: [
+                  Text(
+                    isSentRequest
+                        ? (request.friendFullName.isNotEmpty
+                            ? request.friendFullName
+                            : 'Utilisateur inconnu')
+                        : (request.userFullName.isNotEmpty
+                            ? request.userFullName
+                            : 'Utilisateur inconnu'),
+                    style: theme.textTheme.titleMedium?.copyWith(
+                      fontWeight: FontWeight.bold,
+                    ),
+                  ),
+                  const SizedBox(height: 4),
+                  Text(
+                    isSentRequest
+                        ? 'Demande envoyée'
+                        : 'Demande d\'amitié',
+                    style: theme.textTheme.bodySmall?.copyWith(
+                      color: theme.colorScheme.onSurface.withOpacity(0.6),
+                    ),
+                  ),
+                ],
+              ),
+            ),
+            
+            // Boutons d'action
+            if (isSentRequest)
+              // Pour les demandes envoyées : seulement bouton Annuler
+              IconButton(
+                icon: const Icon(Icons.close),
+                color: Colors.orange,
+                onPressed: onReject,
+                tooltip: 'Annuler la demande',
+              )
+            else
+              // Pour les demandes reçues : Accepter et Rejeter
+              Row(
+                mainAxisSize: MainAxisSize.min,
+                children: [
+                  // Bouton Accepter
+                  IconButton(
+                    icon: const Icon(Icons.check_circle),
+                    color: Colors.green,
+                    onPressed: onAccept,
+                    tooltip: 'Accepter',
+                  ),
+                  // Bouton Rejeter
+                  IconButton(
+                    icon: const Icon(Icons.cancel),
+                    color: Colors.red,
+                    onPressed: onReject,
+                    tooltip: 'Rejeter',
+                  ),
+                ],
+              ),
+          ],
+        ),
+      ),
+    );
+  }
+}
+