Web/Documents/Diagramme/DiagrammeDeClasses/README_issue022.md

[retour au README.md](../../../README.md)  
[Retour aux Documents](../../README_DOCUMENTS.md)  
[Retour au diagramme de classes](../README_DIAGRAMMES.md) 

# Diagramme de Classes : Gestion des Utilisateurs et Notifications

Bienvenue dans le cœur de notre système, où la gestion des utilisateurs et des notifications prend vie à travers ce diagramme de classes. Explorez les relations et les fonctionnalités essentielles qui orchestrent l'interaction entre les utilisateurs, les demandes d'amis, et les notifications.

**Entités Principales :**

- **Utilisateur (User) :** Représente les individus inscrits sur notre plateforme, caractérisés par leur nom et établissant des liens d'amitié avec d'autres utilisateurs.
  
- **Notification (Notification) :** Contient le texte informatif des notifications qui peuvent être émises par le système.

- **Demande d'Ami (Ask) :** Modélise une demande d'amitié émise par un utilisateur en direction d'un autre.

**Interfaces et Classes Abstraites :**

- **INotifier :** Interface définissant la méthode `notify()`, implémentée par des classes concrètes pour gérer la notification aux observateurs.

- **Observer :** Interface définissant la méthode `update()`, implémentée par les classes qui souhaitent être informées des changements dans un sujet observé.

- **UserManager :** Classe abstraite gérant la logique métier liée aux utilisateurs, tels que l'ajout ou la suppression d'amis, la réponse aux demandes d'amis, et la récupération de la liste d'amis.

- **IUserRepository :** Interface définissant les méthodes pour la recherche d'utilisateurs et l'ajout d'un nouvel utilisateur.

**Relations Clés :**

- Les utilisateurs peuvent avoir plusieurs amis et plusieurs notifications.

- La classe UserManager est connectée à IUserRepository pour gérer les opérations liées aux utilisateurs.

- Observer et Subject sont des composants du modèle de conception "Observer", permettant la notification efficace des changements dans le système.

Plongez-vous dans ce diagramme pour découvrir comment notre application crée un écosystème social dynamique, permettant aux utilisateurs d'interagir, de rester informés et de développer des liens significatifs au sein de la communauté.


- Ajout d'amis
```plantuml
class User {
    + name : string
}

User "1" --> "*" User: friends
User "1" --> "*" Notification: notifications
User "1" --> "*" Ask: friendRequests
class Notification {
    - text : string
}

interface INotifier {
 + notify() : void
}

INotifier --|> Observer

abstract class UserManager {
    - currentUser : User
    + deleteFriend(userId : int) : void
    + addFriend(userId : int) : void
    + respondToFriendRequest(requestId : int, choice : bool) : void
    + getFriends(userId : int) : User[]
}

class Ask {
    - fromUser : int
    - toUser : int
}

Ask --|> Subject

abstract class Subject {
    + attach(o : Observer) : void
    + detach(o : Observer) : void
    + notify() : void
}

Subject "1" --> "*" Observer
interface Observer {
    + update() : void
}

UserManager ..> User
UserManager o-- IUserRepository
UserManager o-- INotifier

interface IUserRepository {
    + findByUsername(username : string) : User
    + addUser(user : User) : bool
}

IUserRepository ..> User
```

## Diagrammes de séquence
- Envoi de demande d'ami :
```plantuml
actor User as u
boundary View as v
control Controller as c
entity Model as m

u->v:/Friend
v->c:Get : /Friends
c->m:getFriends(userId)
m-->c::friends : User[]
c-->v:renderView(Friends)
v-->u:
u->v:input : name
v->c:Get : searchFriends? pseudo=name
c->m:searchUser(name:string)
m->m:notify(from : user, to : user, action : action)
m-->c:OK
c-->v:OK
v-->u:OK
```
- Accepter une demande d'ami :
```plantuml
actor User as u
boundary View as v
control Controller as c
entity Model as m

m->c:RecevoirDemandeAmi(idUser)
c->v:AfficherDemandeAmi(idUser)
v->u:PageDemandeAmi(idUser)
u-->v:RepondreDemandeAmi(bool)
v-->c:EnregistrerReponse(bool)
c-->m:EnvoyerReponse(bool)
```

- Supprimer un ami :
```plantuml
actor User as u
boundary View as v
control Controller as c
entity Model as m

u->v: Request Friends Page
v->c: Get /Friends
c->m: getFriends(userId)
alt successful retrieval
    m-->c: friendsList: User[]
else retrieval failed
    m-->c: error
end
c-->v: renderView(friendsList)
v-->u: Display Friends

u->v: clickDeleteFriend(idUser)
v->c: Post: deleteFriend(idUser)
c->m: deleteFriend(idUser)
alt successful deletion
    m-->c: updatedFriendsList: User[]
else deletion failed
    m-->c: error
end
c-->v: renderView(updatedFriendsList)
v-->u: Display Updated Friends
```

## Diagrammes de cas d'utilisation
- Gestion du compte et des amitiés
```plantuml
left to right direction
:Athlete: as a

a --> (Ajouter un ami)
a --> (Supprimer un ami)
a --> (Voir mes amis)
a --> (Modifier mes informations)
(Ajouter un ami)->(Saisir le nom de l'ami)
(Supprimer un ami)..>(S'authentifier) : <<include>>
(Ajouter un ami)..>(S'authentifier) : <<include>>
(Voir mes amis)..>(S'authentifier) : <<include>>
(Voir mes amis)..>(Lister les amis) : <<include>>
(Modifier mes informations)..>(Informations personnelles) : <<extends>>
(Modifier mes informations)..>(Informations de connexion) : <<extends>>
(Lister les amis)..>(Voir son profil) : <<include>>
(Voir son profil)..>(Voir ses activités) : <<extends>>
(Voir son profil)..>(Voir ses statistiques) : <<extends>>
(S'authentifier)..>(S'inscrire) : <<extends>>
(S'authentifier)..>(Se connecter) : <<include>>
(S'inscrire)..>(Inscription Athlète) : <<include>>
```