Web/Documents/Diagramme/Analyse/Besoins/UseCase.plantuml

@startuml Diagramme de cas d'utilisation Clients
left to right direction

actor Coach as c
actor Sportif as s
s <|-- c

    actor "Professionnel de la Santé" as HealthProfessional
package "Applications d'Analyse de Fréquence Cardiaque" {

    package Web {
        ' ---------------------------------- Sportif ----------------------------------

        usecase "Analyser Données de Fréquence Cardiaque" as UC1
        usecase "Statistiques de Condition Physique" as UC2
        usecase "Gestion Sociale" as UC3
        usecase "Gérer Mes Informations de Compte" as UC4
        usecase "Personnaliser Mon Profil Public" as UC19
        usecase "Rechercher des Utilisateurs" as UC5
        usecase "CRUD Amis" as UC6
        usecase "Visualiser Analyse Fréquence Cardiaque" as UC26
        usecase "Visualiser Activités" as UC7
        usecase "Partager Mes Adnalyses" as UC8
        usecase "Partager Mes Analyses avec Mon Coach" as UC9
        usecase "Gérer la Visibilité de Mes Activités" as UC10
        usecase "Synchroniser un Appareil d'Analyse de Fréquence Cardiaque" as UC11
        usecase "Fournir un Fichier Contenant Mes Activités de Fréquence Cardiaque" as UC12
        usecase "Synchroniser l'App Mobile" as UC13
        usecase "Importer Données FIT/GPX/TCX" as UC14
        usecase "Entrer à la Main Mes Informations de Fréquence Cardiaque" as UC15
        usecase "Fournir Mes Données de Fréquence Cardiaque" as UC16
        usecase "S'Inscrire" as UC17
        usecase "Gérer Mes États de Connexion" as UC18
        usecase "Supprimer Mon Compte" as UC19
        usecase "Configurer Alertes" as UC20
        usecase "Recevoir Alertes Anomalies" as UC21
        usecase "Être Alerté en Cas de Problème de Santé" as UC22

        ' ---------------------------------- Coach ----------------------------------

        usecase "Consulter les Statistiques de Ses Athlètes" as UC23
        usecase "CRUD sur les Athlètes" as UC24
        usecase "Alerter un Athlète en Cas de Problème de Santé" as UC25
        usecase "Visualiser Analyse Fréquence Cardiaque Équipe" as UC26
        usecase "Visualiser Activités Équipe" as UC27

        ' ---------------------------------- HealthProfessional ----------------------------------

        usecase "Configurer Alertes Équipe" as UC28
        usecase "Recevoir Alertes Anomalies Équipe" as UC29
    }
}

s --> UC1
s --> UC2
s --> UC3
s --> UC4
s --> UC5
s --> UC6
s --> UC7
s --> UC8
s --> UC9
s --> UC10
s --> UC11
s --> UC12
s --> UC13
s --> UC14
s --> UC15
s --> UC16
s --> UC17
s --> UC18
s --> UC19
s --> UC20
s --> UC21
s --> UC22

c --> UC23
c --> UC24
c --> UC25
c --> UC26
c --> UC27


HealthProfessional --> UC28
HealthProfessional --> UC29

UC5 --> UC6 : include
UC7 --> UC8 : include
UC8 --> UC9 : include
UC9 --> UC10 : include
UC10 --> UC11 : include
UC11 --> UC12 : include
UC13 --> UC14 : include
UC15 --> UC16 : include
UC18 --> UC19 : include
UC20 --> UC21 : include
UC21 --> UC22 : include
UC24 --> UC25 : include
UC26 --> UC27 : include
@enduml

@startuml

skinparam {
    BackgroundColor LightYellow
    ArrowColor Black
    Shadowing false
    BorderColor Black
}

package "Models" {

    class "Athlete" {
        + ID_Athlete : int
        + Name : string
        + Email : string
        + Password : string
        + PublicProfile : text
        + WeightHistory : string
        + Goals : text
    }

    class "Coach" extends Athlete {
        + Specialization : string
    }

    class "SourceData" {
        + ID_Source : int
        + Type : string
        + Model : string
        + Precision : enum
        + PurchaseDate : date
        + LastUseDate : date
    }

    class "Activity" {
        + ID_Activity : int
        + Type : string
        + Date : date
        + StartTime : time
        + EndTime : time
        + GPS_Position : string
        + Altitude : float
        + File : file
    }

    class "HeartRate" {
        + ID_HR : int
        + Time : time
        + BPM : int
        + Variability : float
        + Variance : float
        + StandardDeviation : float
        + Average : float
        + Max : int
        + Min : int
    }

    class "Statistic" {
        + ID_Statistic : int
        + TotalDistance : float
        + TotalTime : time
        + AverageHR : int
        + MaxHR : int
        + CaloriesBurned : float
        + PersonalRecords : string
    }

    class "Training" {
        + ID_Training : int
        + Date : date
        + Description : text
        + Exercises : text
        + Feedback : text
    }

    class "Notification" {
        + ID_Notification : int
        + Message : text
        + Date : date
        + Status : enum
        + Type : string
        + Urgency : enum
    }

    class "Event" {
        + ID_Event : int
        + Name : string
        + Description : text
        + Date : date
        + Location : string
    }
}

package "Repositories" {

    interface "IRepository<T>" {
        + find(id : int) : T
        + findAll() : List<T>
        + save(entity : T)
        + delete(entity : T)
    }

    class "AthleteRepository" implements "IRepository<Athlete>" {
    }

    class "ActivityRepository" implements "IRepository<Activity>" {
    }

    // ... and so on for other entities ...

}

package "Services" {

    class "AthleteService" {
        + athleteRepo : AthleteRepository
        + findAll() : List<Athlete>
        + findById(id: int) : Athlete
        + save(athlete: Athlete) : bool
        + delete(athlete: Athlete) : bool
    }

    class "ActivityService" {
        + activityRepo : ActivityRepository
        + findAll() : List<Activity>
        + findByAthlete(athlete: Athlete) : List<Activity>
        // ... and so on ...
    }

    // ... Additional services for other entities ...
}

package "Controllers" {

    abstract class "BaseController" {
        // Common controller methods and attributes
    }

    class "AthleteController" extends "BaseController" {
        + athleteService : AthleteService
        + showProfile(athleteId: int)
        + editProfile(athlete: Athlete)
        + listAthletes()
    }

    class "ActivityController" extends "BaseController" {
        + activityService : ActivityService
        + showActivities(athleteId: int)
        + addActivity(activity: Activity)
        // ... and so on ...
    }

    // ... Additional controllers for other entities ...
}

BaseController <|-- AthleteController
BaseController <|-- ActivityController

Athlete --> Activity : "performs ->"
Coach --> Training : "assigns ->"
Activity --> HeartRate : "contains ->"
Athlete --> Notification : "receives ->"
Coach --> Event : "organizes ->"
Athlete --> Event : "participates in ->"

AthleteController --> AthleteService
ActivityController --> ActivityService

AthleteService --> AthleteRepository
ActivityService --> ActivityRepository

@enduml