Système d'Amis

Cette section détaille le système de gestion des amis, permettant aux utilisateurs de créer des liens, d'envoyer des demandes, et de recevoir des notifications en temps réel.

FriendsService (friends.service.ts)

Service qui gère la logique métier des relations d'amitié.

Méthodes principales

`async searchUsers(searchTerm: string, currentUserFirebaseUid: string)`

Description : Recherche des utilisateurs par nom d'utilisateur.
Paramètres :

searchTerm : Terme de recherche (min 2 caractères)
currentUserFirebaseUid : UID de l'utilisateur effectuant la recherche

Validation :

Minimum 2 caractères
Recherche insensible à la casse
Exclut l'utilisateur actuel des résultats

Retour : Promise<UserSearchResult[]> (username, avatarUrl, firebaseUid, friendshipStatus)

`async sendFriendRequest(senderUid: string, receiverUid: string)`

Description : Envoie une demande d'ami.
Paramètres :

senderUid : Firebase UID de l'expéditeur
receiverUid : Firebase UID du destinataire

Validations :

Pas déjà amis
Pas de demande en attente
Utilisateurs existent
Pas s'envoyer à soi-même

Actions :

Ajout à pendingFriendsRequest du destinataire
Notification temps réel via FriendsNotificationService
Notification push FCM si mobile

Retour : Promise<void>

`async acceptFriendRequest(accepterUid: string, requesterUid: string)`

Description : Accepte une demande d'ami.
Paramètres :

accepterUid : Firebase UID qui accepte
requesterUid : Firebase UID qui a demandé

Actions :

Ajout mutuel dans friends[] des deux utilisateurs
Retrait de pendingFriendsRequest
Notifications aux deux utilisateurs

Retour : Promise<void>

`async rejectFriendRequest(rejecterUid: string, requesterUid: string)`

Description : Refuse une demande d'ami.
Actions :

Retrait de pendingFriendsRequest
Notification au demandeur

Retour : Promise<void>

`async getFriendsList(firebaseUid: string)`

Description : Récupère la liste des amis avec leurs informations.
Retour : Promise<FriendInfo[]> (username, avatarUrl, isOnline, etc.)

`async getPendingRequests(firebaseUid: string)`

Description : Récupère les demandes d'amis reçues.
Retour : Promise<FriendRequestInfo[]>

`async getSentRequests(firebaseUid: string)`

Description : Récupère les demandes d'amis envoyées.
Retour : Promise<FriendRequestInfo[]>

`async removeFriend(userUid: string, friendUid: string)`

Description : Supprime une relation d'amitié.
Actions :

Retrait mutuel de friends[]
Notifications aux deux utilisateurs

Retour : Promise<void>

FriendsController (friends.controller.ts)

Contrôleur REST pour les endpoints d'amis.

Endpoints

`GET /api/friends/search?username=X`

Description : Recherche des utilisateurs.
Query params :

username : Terme de recherche (min 2 caractères)

Réponse :

{
    users: [{
        firebaseUid: string,
        username: string,
        avatarUrl: string,
        friendshipStatus: 'none' | 'friend' | 'pending_sent' | 'pending_received'
    }]
}

`POST /api/friends/request`

Description : Envoie une demande d'ami.
Body :

{ receiverFirebaseUid: string }

Réponse :

{ success: true, message: string }

`POST /api/friends/accept`

Description : Accepte une demande d'ami.
Body :

{ requesterFirebaseUid: string }

`POST /api/friends/reject`

Description : Refuse une demande d'ami.
Body :

{ requesterFirebaseUid: string }

`GET /api/friends/list`

Description : Liste des amis.
Réponse :

{
    friends: [{
        firebaseUid: string,
        username: string,
        avatarUrl: string,
        isOnline: boolean
    }]
}

`GET /api/friends/pending`

Description : Demandes d'amis reçues.

`GET /api/friends/sent`

Description : Demandes d'amis envoyées.

`DELETE /api/friends/:friendFirebaseUid`

Description : Supprime un ami.
Params :

friendFirebaseUid : Firebase UID de l'ami à supprimer

FriendsSocketService (friends-socket.service.ts)

Service qui gère les événements Socket.IO pour les amis.

Méthodes

`handleSocket(socket: Socket): void`

Description : Configure les écouteurs d'événements pour les amis.
Événements : Aucun event reçu directement, service utilisé pour émettre les notifications

FriendsNotificationService (friends-notification.service.ts)

Service qui envoie les notifications en temps réel pour les événements d'amis.

Méthodes

`notifyFriendRequest(senderUid: string, receiverUid: string): void`

Description : Notifie un utilisateur d'une nouvelle demande d'ami.
Event émis : FriendRequestReceived à la room user:{receiverUid}
Retour : void

`notifyFriendRequestAccepted(accepterUid: string, requesterUid: string): void`

Description : Notifie les deux utilisateurs de l'acceptation.
Events émis : FriendRequestAccepted aux deux rooms
Retour : void

`notifyFriendRequestRejected(rejecterUid: string, requesterUid: string): void`

Description : Notifie le demandeur du refus.
Event émis : FriendRequestRejected à la room user:{requesterUid}
Retour : void

`notifyFriendRemoved(userUid: string, friendUid: string): void`

Description : Notifie les deux utilisateurs de la suppression de l'amitié.
Events émis : FriendRemoved aux deux rooms
Retour : void

Events Socket.IO

Events émis

Event	Description	Destinataire
`FriendRequestReceived`	Nouvelle demande d'ami	Room `user:{receiverUid}`
`FriendRequestAccepted`	Demande acceptée	Rooms des deux utilisateurs
`FriendRequestRejected`	Demande refusée	Room `user:{requesterUid}`
`FriendRemoved`	Ami supprimé	Rooms des deux utilisateurs

Intégration avec UserService

Le système d'amis modifie directement les propriétés de la classe User :

friends: string[] : Liste des Firebase UIDs des amis
pendingFriendsRequest: string[] : Liste des demandes en attente

Notifications Push (FCM)

Le système d'amis s'intègre avec FirebaseMessagingService pour envoyer des notifications push aux utilisateurs mobiles :

Notification lors de réception de demande d'ami
Notification lors d'acceptation de demande

Statut de relation

Lors de la recherche d'utilisateurs, le serveur calcule le statut de la relation :

Statut	Description
`none`	Aucune relation
`friend`	Déjà amis
`pending_sent`	Demande envoyée (en attente)
`pending_received`	Demande reçue (en attente)

Ce statut permet au client d'afficher les actions appropriées (envoyer demande, accepter, déjà ami, etc.).