################################################################################
#                                                                              #
#     ██╗   ██╗███╗   ███╗██╗           ██████╗ ██╗   ██╗██╗██████╗ ███████╗   #
#     ██║   ██║████╗ ████║██║          ██╔════╝ ██║   ██║██║██╔══██╗██╔════╝   #
#     ██║   ██║██╔████╔██║██║          ██║  ███╗██║   ██║██║██║  ██║█████╗     #
#     ██║   ██║██║╚██╔╝██║██║          ██║   ██║██║   ██║██║██║  ██║██╔══╝     #
#     ╚██████╔╝██║ ╚═╝ ██║███████╗     ╚██████╔╝╚██████╔╝██║██████╔╝███████╗   #
#      ╚═════╝ ╚═╝     ╚═╝╚══════╝      ╚═════╝  ╚═════╝ ╚═╝╚═════╝ ╚══════╝   #
#                                                                              #
#                        GUIDE COMPLET ULTRA-DÉTAILLÉ                          #
#                              ÉDITION MASTER                                  #
#                                                                              #
################################################################################

Version      : 1.0
Date         : Janvier 2026
Auteur       : Guide créé avec méthodologie COMMENT/POURQUOI/QUAND
Niveau       : Débutant à Avancé
Langage      : Français
Chapitres    : 13 (Chapitre 0 à 13)
Diagrammes   : 9 types UML essentiels
Exercices    : 20+ exercices pratiques avec solutions
Pages        : ~500 pages équivalent
Taille       : ~700 KB de contenu pédagogique
Code         : Java, JavaScript, PlantUML


################################################################################
#                           TABLE DES MATIÈRES                                 #
################################################################################

SECTION I : DOCUMENTATION GÉNÉRALE
  ├─ README - Guide d'utilisation
  └─ INDEX COMPLET - Vue d'ensemble

SECTION II : PARTIE 1 - DIAGRAMMES STRUCTURELS (CE QUE contient le système)
  ├─ Chapitre 0  : Introduction à UML
  ├─ Chapitre 1  : Diagramme de Classes *** (FONDAMENTAL)
  ├─ Chapitre 2  : Diagramme d'Objets
  └─ Chapitre 3  : Diagramme de Composants **

SECTION III : PARTIE 2 - DIAGRAMMES COMPORTEMENTAUX (COMMENT fonctionne)
  ├─ Chapitre 4  : Diagramme de Cas d'Utilisation ***
  ├─ Chapitre 5  : Diagramme de Séquence ***
  ├─ Chapitre 6  : Diagramme d'Activités **
  └─ Chapitre 7  : Diagramme d'États-Transitions **

SECTION IV : PARTIE 3 - DIAGRAMMES AVANCÉS
  ├─ Chapitre 8  : Diagramme de Déploiement
  └─ Chapitre 9  : Diagramme de Paquetages

SECTION V : PARTIE 4 - PRATIQUE ET OUTILS
  ├─ Chapitre 10 : Outils UML (PlantUML, Draw.io, etc.)
  ├─ Chapitre 11 : Patterns de Conception (GoF)
  ├─ Chapitre 12 : UML et Méthodologies Agiles
  └─ Chapitre 13 : PROJET FINAL COMPLET (Streaming Platform)


################################################################################
#                         COMMENT UTILISER CE GUIDE                            #
################################################################################

[GUIDE] LECTURE LINÉAIRE (Recommandé pour débutants)
   -> Suivez l'ordre des sections I à V
   -> Faites tous les exercices
   -> Temps estimé : 60-80 heures

[OBJECTIF] LECTURE CIBLÉE (Développeurs expérimentés)
   -> Utilisez la table des matières
   -> Concentrez-vous sur chapitres spécifiques
   -> Temps estimé : 20-30 heures

[RECHERCHE] RECHERCHE RAPIDE
   -> Ctrl+F / Cmd+F pour trouver concepts
   -> Marques de section : #### ou ====

[FORCE] PRATIQUE INTENSIVE
   -> Lisez théorie + faites TOUS exercices
   -> Implémentez en code
   -> Temps estimé : 100+ heures


################################################################################
#                              CONVENTIONS                                     #
################################################################################

[IDEE] Info importante
[REFLEXION] Question à se poser
[OK] Bonne pratique
[X] Mauvaise pratique / Erreur à éviter
[ATTENTION] Attention / Point critique
[CLE] Point clé à retenir
[COURS] Exercice pratique
[DOCS] Résumé / Récapitulatif
[OBJECTIF] Objectif d'apprentissage
*** Très important (priorité haute)
** Important (priorité moyenne)


################################################################################


################################################################################
################################################################################
##                                                                            ##
##  SECTION I : DOCUMENTATION GÉNÉRALE
##                                                                            ##
################################################################################
################################################################################


# ============================================================================
# [LIVRE] GUIDE UML ULTRA-DÉTAILLÉ POUR DÉBUTANTS EN GÉNIE LOGICIEL
# ============================================================================

"""
[COURS] BIENVENUE DANS VOTRE GUIDE UML COMPLET !

Ce guide couvre les 7 diagrammes UML ESSENTIELS avec une méthodologie
pédagogique COMMENT/POURQUOI/QUAND et 14 exercices pratiques complets.

Niveau : Débutant à Intermédiaire
Public : Étudiants en génie logiciel, développeurs, analystes
Langage : Français
"""


# ============================================================================
# [DOCS] ORGANISATION DU GUIDE
# ============================================================================

"""
Le guide est organisé en 2 PARTIES principales :

PARTIE 1 : DIAGRAMMES STRUCTURELS
──────────────────────────────────
-> Montrent CE QUE contient le système (structure statique)

PARTIE 2 : DIAGRAMMES COMPORTEMENTAUX
──────────────────────────────────────
-> Montrent COMMENT le système fonctionne (comportement dynamique)
"""


# ============================================================================
# [GUIDE] CONTENU DÉTAILLÉ
# ============================================================================

"""
════════════════════════════════════════════════════════════════════════
PARTIE 1 : DIAGRAMMES STRUCTURELS
════════════════════════════════════════════════════════════════════════

[FICHIER] Fichier : uml_guide_partie1.txt (42 KB)
──────────────────────────────────────────
CHAPITRE 0 : Introduction à UML
  [OK] Histoire de UML (guerre des méthodes -> unification)
  [OK] Les 14 types de diagrammes UML 2.5.1
  [OK] Les 5 diagrammes essentiels pour débuter
  [OK] Quand utiliser UML (taille projet, méthodologie)

CHAPITRE 1 : Diagramme de Classes *** (LE PLUS IMPORTANT)
  [OK] Classes, attributs, méthodes
  [OK] Visibilité (public, private, protected)
  [OK] Relations :
     - Association (utilise/connaît)
     - Agrégation [WHITE_DIAMOND] (contenance faible)
     - Composition [BLACK_DIAMOND] (contenance forte)
     - Héritage [WHITE_UP-POINTING_TRIANGLE] (est-un)
     - Dépendance (usage temporaire)
     - Réalisation (implémente interface)
  [OK] Multiplicités (1, 0..1, *, 1..*)
  [OK] Classe d'association
  [OK] Classes abstraites et interfaces


[FICHIER] Fichier : uml_guide_partie1_suite.txt (33 KB)
──────────────────────────────────────────────────
CHAPITRE 1 (suite) : Exercices Diagramme de Classes
  [COURS] EXERCICE 1 : Système de Bibliothèque
     - Livres, Membres, Emprunts, Bibliothécaire
     - Relations complètes avec diagramme UML
     - Implémentation Java complète
  
  [COURS] EXERCICE 2 : Système Bancaire
     - CompteBancaire (abstrait), CompteCourant, CompteEpargne
     - Client, Transaction, Virement
     - Interface CarteBancaire
     - Implémentation Java avec héritage et interface


[FICHIER] Fichier : uml_chapitre2_objets.txt (38 KB)
───────────────────────────────────────────────
CHAPITRE 2 : Diagramme d'Objets
  [OK] Différence classe (template) vs objet (instance)
  [OK] Notation objet : nom souligné + valeurs concrètes
  [OK] Snapshots du système à un instant T
  [OK] Liens entre objets (instances d'associations)
  [OK] Validation de diagrammes de classes
  
  [COURS] EXERCICE 1 : Système Universitaire
     - Professeurs, Cours, Étudiants
     - Snapshot avec valeurs réelles
  
  [COURS] EXERCICE 2 : Réseau Social Simplifié
     - Utilisateurs, Posts, Commentaires
     - Relations "suit" et publications


[FICHIER] Fichier : uml_guide_chapitre3_complet.txt (44 KB)
──────────────────────────────────────────────────────
CHAPITRE 3 : Diagramme de Composants **
  [OK] Architecture logicielle (vue macro)
  [OK] Composants (modules, services, bibliothèques)
  [OK] Interfaces fournies [WHITE_CIRCLE] (lollipop)
  [OK] Interfaces requises [WHITE_LEFT-POINTING_TRIANGLE] (socket)
  [OK] Dépendances entre composants
  [OK] Organisation en couches (3-tiers)
  [OK] Architecture microservices
  
  [COURS] EXERCICE 1 : Plateforme E-Learning
     - Frontend, API Gateway, Services métier
     - Base de données, Cache, Services externes
     - Architecture 3-tiers complète
  
  [COURS] EXERCICE 2 : Système Bancaire
     - LoadBalancer, Auth, Services métier
     - FraudDetection, AuditLog, MessageQueue
     - Architecture sécurisée avec séparation OLTP/OLAP


════════════════════════════════════════════════════════════════════════
PARTIE 2 : DIAGRAMMES COMPORTEMENTAUX
════════════════════════════════════════════════════════════════════════

[FICHIER] Fichier : uml_partie2_chapitre4_use_case.txt (69 KB)
─────────────────────────────────────────────────────────
CHAPITRE 4 : Diagramme de Cas d'Utilisation ***
  [OK] Vue EXTERNE du système (point de vue utilisateur)
  [OK] Acteurs (humains, systèmes externes)
  [OK] Cas d'utilisation (objectifs utilisateur)
  [OK] Relations :
     - <<include>> : inclusion obligatoire (A inclut B)
     - <<extend>> : extension optionnelle (B étend A)
     - Généralisation : spécialisation (héritage)
  [OK] Frontière du système
  [OK] Descriptions textuelles détaillées
  
  [COURS] EXERCICE 1 : Système de Bibliothèque
     - Membres, Bibliothécaire, Administrateur
     - Emprunter, Réserver, Gérer livres
     - Généralisation d'acteurs
  
  [COURS] EXERCICE 2 : Plateforme E-Learning
     - Étudiants, Professeurs, Administrateur
     - S'inscrire (variantes), Acheter cours
     - Services externes (Paiement, Email)


[FICHIER] Fichier : uml_partie2_chapitre5_sequence.txt (65 KB)
─────────────────────────────────────────────────────────
CHAPITRE 5 : Diagramme de Séquence ***
  [OK] Vue TEMPORELLE des interactions (de haut en bas)
  [OK] Objets et lignes de vie
  [OK] Messages synchrones ──> (attend réponse)
  [OK] Messages asynchrones ──> (continue immédiatement)
  [OK] Messages de retour [BLACK_LEFT-POINTING_POINTER]─ ─ ─
  [OK] Barres d'activation (rectangles sur lignes)
  [OK] Création <<create>> et destruction X d'objets
  [OK] Fragments :
     - ALT (alternative) : if/else
     - OPT (optional) : if
     - LOOP (loop) : for/while
     - PAR (parallel) : threads parallèles
     - REF (reference) : appel autre diagramme
  
  [COURS] EXERCICE 1 : Réservation de Vol
     - Recherche, Sélection, Paiement
     - Fragments ALT imbriqués
     - Message asynchrone pour email
     - Service externe Stripe
  
  [COURS] EXERCICE 2 : Panier E-Commerce
     - Ajouter produits (LOOP)
     - Calculer total avec remise (OPT)
     - Traitement parallèle (FORK/JOIN)
     - Création d'objet Commande


[FICHIER] Fichier : uml_partie2_chapitre6_activites.txt (68 KB)
──────────────────────────────────────────────────────────
CHAPITRE 6 : Diagramme d'Activités **
  [OK] Vue des PROCESSUS et WORKFLOWS
  [OK] Actions (rectangles arrondis)
  [OK] Flux de contrôle (flèches)
  [OK] Décisions [WHITE_DIAMOND] (losanges) et fusions
  [OK] Fork ═══ (barre épaisse) : parallélisme
  [OK] Join ═══ : synchronisation
  [OK] Partitions (swimlanes) : qui fait quoi
  [OK] Boucles et structures de contrôle
  [OK] Signaux et événements
  
  [COURS] EXERCICE 1 : Processus Commande E-Commerce
     - Client, Système, Services (Paiement, Stock, Email)
     - Décisions multiples (connecté, stock, paiement)
     - Fork/Join pour vérifications parallèles
     - Swimlanes pour 5 acteurs
  
  [COURS] EXERCICE 2 : Processus de Recrutement
     - Candidat, RH, Manager, IT
     - Workflow complet (postulation -> embauche)
     - Tests parallèles (technique, psychologique)
     - Processus administratifs parallèles


[FICHIER] Fichier : uml_partie2_chapitre7_etats.txt (67 KB)
──────────────────────────────────────────────────────
CHAPITRE 7 : Diagramme d'États-Transitions **
  [OK] Cycle de VIE d'un objet
  [OK] États (rectangles arrondis)
  [OK] Transitions (flèches avec événements)
  [OK] Événements déclencheurs
  [OK] Gardes [condition] sur transitions
  [OK] Actions :
     - entry / : exécutée en entrant
     - do / : exécutée pendant l'état
     - exit / : exécutée en sortant
  [OK] Transitions internes (sans entry/exit)
  [OK] États composites (hiérarchie)
  [OK] États d'historique ⊙H (mémorise dernier sous-état)
  [OK] États parallèles (régions orthogonales)
  
  [COURS] EXERCICE 1 : Distributeur Automatique (ATM)
     - Inactif, AttentePIN, MenuPrincipal, Bloqué
     - État composite MenuPrincipal (Consultation, Retrait, Dépôt)
     - Sécurité (3 tentatives -> carte avalée)
     - État historique pour UX
  
  [COURS] EXERCICE 2 : Connexion TCP
     - 11 états du protocole TCP
     - 3-way handshake (établissement)
     - 4-way handshake (fermeture)
     - État composite "Établie" avec régions parallèles (Envoi/Réception)
     - Full-duplex
     - TIME_WAIT


════════════════════════════════════════════════════════════════════════
"""


# ============================================================================
# [GRAPHIQUE] STATISTIQUES DU GUIDE
# ============================================================================

"""
CONTENU TOTAL :
───────────────
[OK] 8 Chapitres (Chapitre 0 à 7)
[OK] 7 Types de diagrammes UML essentiels
[OK] 14 Exercices pratiques avec solutions détaillées
[OK] 50+ Exemples concrets
[OK] ~450 KB de contenu textuel
[OK] ~400 pages équivalent

MÉTHODOLOGIE :
──────────────
Chaque concept est expliqué avec :
[GUIDE] COMMENT : Notation et syntaxe UML
[?] POURQUOI : Raison d'être et contexte
[ALARM_CLOCK] QUAND : Cas d'usage appropriés
[OBJECTIF] PRATIQUE : Exercices avec solutions complètes

NIVEAU DE DÉTAIL :
──────────────────
Ultra-détaillé, adapté aux grands débutants
Aucune connaissance préalable d'UML requise
Progression pédagogique graduelle
Exemples visuels en ASCII art
Code d'implémentation (Java) fourni
"""


# ============================================================================
# [OBJECTIF] ORDRE DE LECTURE RECOMMANDÉ
# ============================================================================

"""
POUR DÉBUTANTS ABSOLUS :
────────────────────────
1. Chapitre 0 : Introduction (comprendre contexte)
2. Chapitre 1 : Classes *** (FONDAMENTAL)
3. Chapitre 4 : Cas d'Utilisation *** (vue externe)
4. Chapitre 5 : Séquence *** (interactions)
5. Chapitre 2 : Objets (compléter classes)
6. Chapitre 6 : Activités (processus métier)
7. Chapitre 3 : Composants (architecture)
8. Chapitre 7 : États (cycles de vie)

POUR PROJETS PRATIQUES :
─────────────────────────
Phase d'ANALYSE :
-> Cas d'Utilisation (Chapitre 4)

Phase de CONCEPTION :
-> Classes (Chapitre 1)
-> Séquence (Chapitre 5)
-> Composants (Chapitre 3)

Phase de DOCUMENTATION :
-> Activités (Chapitre 6) pour processus
-> États (Chapitre 7) pour cycles de vie
-> Objets (Chapitre 2) pour exemples

PAR DOMAINE D'APPLICATION :
───────────────────────────
Applications WEB :
-> Classes, Composants, Séquence

Processus MÉTIER :
-> Cas d'Utilisation, Activités, Séquence

Systèmes RÉACTIFS :
-> États, Séquence, Activités

Architecture LOGICIELLE :
-> Composants, Classes, Séquence
"""


# ============================================================================
# [IDEE] CONSEILS D'UTILISATION
# ============================================================================

"""
1. NE PAS TOUT LIRE D'UN COUP
   [OK] Progressez chapitre par chapitre
   [OK] Pratiquez les exercices avant de continuer
   [OK] Relisez si nécessaire

2. PRATIQUEZ ACTIVEMENT
   [OK] Dessinez les diagrammes vous-même
   [OK] Créez vos propres exemples
   [OK] Modélisez vos projets personnels

3. UTILISEZ DES OUTILS
   [OK] PlantUML (génération diagrammes depuis code)
   [OK] draw.io / diagrams.net (gratuit, en ligne)
   [OK] Lucidchart (professionnel)
   [OK] Visual Paradigm (complet)
   [OK] StarUML (open source)

4. RESTEZ PRAGMATIQUE
   [ATTENTION] UML est un OUTIL, pas une fin en soi
   [ATTENTION] Ne pas tout modéliser
   [ATTENTION] Choisir bons diagrammes selon besoin
   [ATTENTION] Adapter niveau de détail au contexte

5. RÉFÉRENCES OFFICIELLES
   [DOCS] OMG UML Specification : https://www.omg.org/spec/UML
   [DOCS] UML Distilled (Martin Fowler)
   [DOCS] Applying UML and Patterns (Craig Larman)
"""


# ============================================================================
# [COURS] COMPÉTENCES ACQUISES
# ============================================================================

"""
Après avoir terminé ce guide, vous serez capable de :

ANALYSE :
─────────
[OK] Identifier acteurs et cas d'utilisation d'un système
[OK] Analyser besoins fonctionnels
[OK] Définir périmètre d'un projet

CONCEPTION :
────────────
[OK] Modéliser structures de données (classes)
[OK] Concevoir interactions entre objets (séquence)
[OK] Organiser architecture logicielle (composants)
[OK] Modéliser cycles de vie d'objets (états)
[OK] Documenter workflows métier (activités)

COMMUNICATION :
───────────────
[OK] Communiquer avec équipes techniques
[OK] Expliquer systèmes à clients non-techniques
[OK] Documenter décisions architecturales
[OK] Faciliter onboarding nouveaux développeurs

IMPLÉMENTATION :
────────────────
[OK] Passer de diagrammes à code
[OK] Structurer applications
[OK] Identifier patterns de conception
[OK] Optimiser architectures
"""


# ============================================================================
# [RAPIDE] PROCHAINES ÉTAPES
# ============================================================================

"""
APRÈS CE GUIDE :
────────────────

1. PRATIQUER sur projets réels
   -> Modéliser applications existantes
   -> Créer diagrammes pour nouveaux projets
   -> Refactorer en utilisant patterns UML

2. APPROFONDIR patterns de conception
   -> Singleton, Factory, Observer en UML
   -> MVC, MVVM architectures
   -> Microservices patterns

3. EXPLORER diagrammes avancés (optionnel)
   -> Diagramme de Déploiement (infrastructure)
   -> Diagramme de Paquetages (organisation)
   -> Diagrammes de Timing (contraintes temporelles)

4. INTÉGRER dans méthodologies
   -> UML avec Agile/Scrum
   -> UML avec DevOps
   -> Documentation as Code

5. CERTIFICATIONS (optionnel)
   -> OMG Certified UML Professional (OCUP)
   -> IIBA Certification (analyse métier)
"""


# ============================================================================
# [TEL] SUPPORT ET RESSOURCES
# ============================================================================

"""
OUTILS RECOMMANDÉS :
────────────────────
[OUTIL] PlantUML : https://plantuml.com
   -> Génération diagrammes depuis texte
   -> Idéal pour versioning (Git)
   -> Intégration IDE

[OUTIL] Draw.io : https://app.diagrams.net
   -> Gratuit, en ligne
   -> Interface glisser-déposer
   -> Export multiples formats

[OUTIL] Visual Paradigm : https://www.visual-paradigm.com
   -> Professionnel
   -> Reverse engineering code -> UML
   -> Génération code depuis UML

RESSOURCES EN LIGNE :
──────────────────────
[DOCS] OMG UML : https://www.omg.org/spec/UML
[DOCS] UML Tutorials Point : https://www.tutorialspoint.com/uml
[DOCS] Lucidchart UML Guide : https://www.lucidchart.com/pages/uml
[DOCS] Martin Fowler : https://martinfowler.com/bliki/UmlMode.html

LIVRES RECOMMANDÉS :
────────────────────
[GUIDE] "UML Distilled" - Martin Fowler (version courte, pragmatique)
[GUIDE] "Applying UML and Patterns" - Craig Larman (complet)
[GUIDE] "UML 2 pour l'analyse d'un système d'information" - Joseph Gabay
[GUIDE] "Design Patterns" - Gang of Four (patterns avec UML)
"""


# ============================================================================
# * REMERCIEMENTS ET BONNE CHANCE !
# ============================================================================

"""
╔══════════════════════════════════════════════════════════════════════╗
║                                                                      ║
║           [COURS] FÉLICITATIONS D'AVOIR TERMINÉ CE GUIDE ! [COURS]             ║
║                                                                      ║
║  Vous avez maintenant une base SOLIDE en modélisation UML           ║
║  et êtes prêt(e) à l'appliquer dans vos projets !                   ║
║                                                                      ║
║  N'oubliez pas :                                                     ║
║  • UML est un OUTIL, pas une fin en soi                             ║
║  • PRATIQUEZ régulièrement                                           ║
║  • Restez PRAGMATIQUE                                                ║
║  • Continuez à APPRENDRE                                             ║
║                                                                      ║
║           Bon courage pour vos futurs projets ! [RAPIDE]                   ║
║                                                                      ║
╚══════════════════════════════════════════════════════════════════════╝


Version : 1.0
Date : Janvier 2026
Auteur : Guide créé avec méthodologie COMMENT/POURQUOI/QUAND
Licence : Éducatif - Libre utilisation pour apprentissage
"""


# ============================================================================
# FIN DU README
# ============================================================================


################################################################################
################################################################################
##                                                                            ##
##  INDEX COMPLET DU GUIDE
##                                                                            ##
################################################################################
################################################################################


# ============================================================================
# [LIVRE] GUIDE UML ULTRA-DÉTAILLÉ - INDEX COMPLET
# ============================================================================

"""
[COURS] GUIDE COMPLET UML POUR DÉBUTANTS EN GÉNIE LOGICIEL

Auteur : Guide créé avec méthodologie COMMENT/POURQUOI/QUAND
Version : 1.0 - Janvier 2026
Niveau : Débutant à Avancé
Langage : Français
"""


# ============================================================================
# [GRAPHIQUE] STATISTIQUES GLOBALES DU GUIDE
# ============================================================================

"""
CONTENU TOTAL :

[DOCS] CHAPITRES : 13 chapitres (0 à 13)
[GRAPHIQUE] DIAGRAMMES : 9 types UML essentiels
[COURS] EXERCICES : 20+ exercices pratiques complets
[CODE] CODE : Implémentations Java, JavaScript
[FICHIER] PAGES : ~500 pages équivalent
[SAUVEGARDE] TAILLE : ~700 KB de contenu textuel


TEMPS D'APPRENTISSAGE ESTIMÉ :

[GUIDE] Lecture complète : 40-50 heures
[COURS] Avec exercices : 60-80 heures
[CODE] Avec implémentation : 100+ heures


PRÉREQUIS :

[OK] Connaissance basique programmation (Java/Python/C++)
[OK] Compréhension concepts POO (classes, objets, héritage)
[OK] Motivation à apprendre modélisation
[X] AUCUNE connaissance UML préalable requise !
"""


# ============================================================================
# [DOSSIER] STRUCTURE COMPLÈTE DU GUIDE
# ============================================================================

"""
╔══════════════════════════════════════════════════════════════════════╗
║                    ORGANISATION DES FICHIERS                         ║
╚══════════════════════════════════════════════════════════════════════╝


[LISTE] README & INDEX
─────────────────
[FICHIER] UML_GUIDE_README.txt
   -> Guide d'utilisation, organisation, ordre de lecture recommandé
   -> Taille : ~15 KB

[FICHIER] CE FICHIER : INDEX COMPLET
   -> Vue d'ensemble complète du guide
   -> Résumés de chaque chapitre
   -> Liens vers fichiers


═══════════════════════════════════════════════════════════════════════

[LIVRE] PARTIE 1 : DIAGRAMMES STRUCTURELS
─────────────────────────────────────

[FICHIER] uml_guide_partie1.txt (42 KB)
   ├─ Chapitre 0 : Introduction à UML
   │  [OK] Histoire UML (guerre des méthodes)
   │  [OK] 14 types de diagrammes UML 2.5.1
   │  [OK] 5 diagrammes essentiels pour débuter
   │  [OK] Quand utiliser UML
   │
   └─ Chapitre 1 : Diagramme de Classes *** (FONDAMENTAL)
      [OK] Classes, attributs, méthodes
      [OK] Visibilité (+, -, #, ~)
      [OK] Relations : Association, Agrégation, Composition
      [OK] Héritage, Interfaces, Dépendance
      [OK] Multiplicités et navigabilité

[FICHIER] uml_guide_partie1_suite.txt (33 KB)
   └─ Chapitre 1 (suite) : Exercices Classes
      [COURS] EXERCICE 1 : Système Bibliothèque
         - Livres, Membres, Emprunts, Bibliothécaire
         - Diagramme complet + Implémentation Java
      [COURS] EXERCICE 2 : Système Bancaire
         - CompteBancaire (abstrait), CompteCourant, CompteEpargne
         - Interface CarteBancaire
         - Implémentation complète

[FICHIER] uml_chapitre2_objets.txt (38 KB)
   └─ Chapitre 2 : Diagramme d'Objets
      [OK] Instances vs Classes
      [OK] Notation objets (souligné + valeurs)
      [OK] Snapshots système
      [OK] Validation diagrammes classes
      [COURS] EXERCICE 1 : Système Universitaire
      [COURS] EXERCICE 2 : Réseau Social

[FICHIER] uml_guide_chapitre3_complet.txt (44 KB)
   └─ Chapitre 3 : Diagramme de Composants **
      [OK] Architecture logicielle
      [OK] Composants et interfaces
      [OK] Interfaces fournies [WHITE_CIRCLE] / requises [WHITE_LEFT-POINTING_TRIANGLE]
      [OK] Organisation en couches (3-tiers)
      [OK] Architecture microservices
      [COURS] EXERCICE 1 : Plateforme E-Learning
      [COURS] EXERCICE 2 : Système Bancaire Enterprise


═══════════════════════════════════════════════════════════════════════

[LIVRE] PARTIE 2 : DIAGRAMMES COMPORTEMENTAUX
──────────────────────────────────────────

[FICHIER] uml_partie2_chapitre4_use_case.txt (69 KB)
   └─ Chapitre 4 : Diagramme de Cas d'Utilisation ***
      [OK] Vue externe système
      [OK] Acteurs et cas d'utilisation
      [OK] Relations : <<include>>, <<extend>>, généralisation
      [OK] Frontière système
      [OK] Descriptions textuelles détaillées
      [COURS] EXERCICE 1 : Système Bibliothèque (acteurs multiples)
      [COURS] EXERCICE 2 : Plateforme E-Learning (services externes)

[FICHIER] uml_partie2_chapitre5_sequence.txt (65 KB)
   └─ Chapitre 5 : Diagramme de Séquence ***
      [OK] Vue temporelle interactions
      [OK] Messages synchrones / asynchrones
      [OK] Lignes de vie et activation
      [OK] Fragments : ALT, OPT, LOOP, PAR, REF
      [OK] Création et destruction objets
      [COURS] EXERCICE 1 : Réservation Vol (fragments imbriqués)
      [COURS] EXERCICE 2 : Panier E-Commerce (création objets)

[FICHIER] uml_partie2_chapitre6_activites.txt (68 KB)
   └─ Chapitre 6 : Diagramme d'Activités **
      [OK] Workflows et processus
      [OK] Décisions [WHITE_DIAMOND] et fusions
      [OK] Fork ═══ et Join (parallélisme)
      [OK] Partitions (swimlanes) : qui fait quoi
      [OK] Boucles et signaux
      [COURS] EXERCICE 1 : Commande E-Commerce (5 swimlanes)
      [COURS] EXERCICE 2 : Processus Recrutement (6 points décision)

[FICHIER] uml_partie2_chapitre7_etats.txt (67 KB)
   └─ Chapitre 7 : Diagramme d'États-Transitions **
      [OK] Cycle de vie objets
      [OK] États, transitions, événements
      [OK] Actions : entry / do / exit
      [OK] États composites (hiérarchie)
      [OK] États parallèles (régions orthogonales)
      [OK] État d'historique ⊙H
      [COURS] EXERCICE 1 : Distributeur ATM (sécurité 3 tentatives)
      [COURS] EXERCICE 2 : Connexion TCP (11 états, 3-way/4-way handshake)


═══════════════════════════════════════════════════════════════════════

[LIVRE] PARTIE 3 : DIAGRAMMES AVANCÉS
──────────────────────────────────

[FICHIER] uml_partie3_chapitre8_deploiement.txt (55 KB)
   └─ Chapitre 8 : Diagramme de Déploiement
      [OK] Infrastructure physique
      [OK] Nœuds matériels et logiciels
      [OK] Artefacts déployables (.jar, .war)
      [OK] Connexions réseau (protocoles)
      [OK] Zones de sécurité (DMZ, privé)
      [COURS] EXERCICE 1 : Application Web 3-Tiers classique
      [COURS] EXERCICE 2 : Mobile App + AWS Cloud (serverless)

[FICHIER] uml_partie3_chapitre9_paquetages.txt (36 KB)
   └─ Chapitre 9 : Diagramme de Paquetages
      [OK] Organisation logique code
      [OK] Paquetages et hiérarchies
      [OK] Dépendances : <<import>>, <<access>>
      [OK] Architecture en couches (3-tier, Clean, Hexagonal)
      [OK] Éviter cycles dépendances
      [OK] Principes SOLID appliqués
      [COURS] EXERCICE : E-Commerce Spring Boot (architecture complète)


═══════════════════════════════════════════════════════════════════════

[LIVRE] PARTIE 4 : PRATIQUE ET OUTILS
──────────────────────────────────

[FICHIER] uml_partie4_chapitres10-11.txt (48 KB)
   ├─ Chapitre 10 : Outils UML
   │  [OK] PlantUML (diagrammes as code)
   │  [OK] Draw.io (éditeur graphique)
   │  [OK] Comparatif outils (Lucidchart, Visual Paradigm, etc.)
   │  [OK] Forward engineering (UML -> Code)
   │  [OK] Reverse engineering (Code -> UML)
   │  [OK] Intégration CI/CD
   │  [COURS] EXERCICE : Système Bibliothèque avec PlantUML
   │
   └─ Chapitre 11 : Patterns de Conception en UML
      [OK] Gang of Four (23 patterns)
      [OK] Patterns Création : Singleton, Factory, Builder
      [OK] Patterns Structure : Adapter, Decorator, Facade
      [OK] Patterns Comportement : Observer, Strategy, Command
      [OK] Modélisation UML de patterns
      [OK] Implémentations Java complètes

[FICHIER] uml_partie4_chapitres12-13_final.txt (36 KB)
   ├─ Chapitre 12 : UML et Méthodologies Agiles
   │  [OK] UML dans Scrum (où et quand)
   │  [OK] Just Enough Modeling
   │  [OK] User Stories -> Use Cases/UML
   │  [OK] Continuous Modeling
   │  [OK] Living Documentation
   │  [OK] Architecture Decision Records (ADR)
   │
   └─ Chapitre 13 : PROJET FINAL COMPLET [OBJECTIF]
      [OK] Énoncé : Plateforme Streaming Vidéo (type Netflix)
      [OK] 8 diagrammes UML complets :
         1. Use Case (acteurs, hiérarchie)
         2. Classes (domain model complet)
         3. Composants (microservices)
         4. Séquence (flow streaming)
         5. Activités (processus abonnement)
         6. États (cycle abonnement)
         7. Déploiement (AWS Kubernetes)
         8. Paquetages (architecture couches)
      [OK] Implémentation code (Java + React)
      [OK] Architecture professionnelle
      [OK] CONCLUSION FINALE DU GUIDE [COURS]


═══════════════════════════════════════════════════════════════════════
"""


# ============================================================================
# [OBJECTIF] DIAGRAMMES UML COUVERTS
# ============================================================================

"""
DIAGRAMMES ESSENTIELS (7) :

1. *** DIAGRAMME DE CLASSES
   Le plus important !
   - Structure données et code
   - Relations entre classes
   - Fondation de tout projet OO

2. *** DIAGRAMME DE CAS D'UTILISATION
   Vue externe système
   - Besoins fonctionnels
   - Acteurs et objectifs
   - Communication avec stakeholders

3. *** DIAGRAMME DE SÉQUENCE
   Interactions temporelles
   - Flow de messages
   - Ordre d'exécution
   - Debugging et design

4. ** DIAGRAMME D'ACTIVITÉS
   Workflows et processus
   - Processus métier
   - Algorithmes
   - Décisions et parallélisme

5. ** DIAGRAMME D'ÉTATS-TRANSITIONS
   Cycle de vie objets
   - Machines à états
   - Protocoles
   - Workflows stateful

6. ** DIAGRAMME DE COMPOSANTS
   Architecture logicielle
   - Modules et services
   - Interfaces
   - Microservices

7. DIAGRAMME D'OBJETS
   Instances concrètes
   - Snapshots
   - Validation
   - Exemples


DIAGRAMMES AVANCÉS (2) :

8. DIAGRAMME DE DÉPLOIEMENT
   Infrastructure physique
   - Serveurs et nœuds
   - Réseau et protocoles
   - Cloud et DevOps

9. DIAGRAMME DE PAQUETAGES
   Organisation code
   - Modules et namespaces
   - Dépendances
   - Architecture en couches
"""


# ============================================================================
# [COURS] PARCOURS D'APPRENTISSAGE RECOMMANDÉS
# ============================================================================

"""
PARCOURS 1 : DÉBUTANT COMPLET (8-10 semaines)
────────────────────────────────────────────────

Semaine 1-2 : FONDATIONS
├─ Chapitre 0 : Introduction UML
├─ Chapitre 1 : Diagramme Classes (ESSENTIEL)
└─ Exercices Bibliothèque + Bancaire

Semaine 3 : VUE UTILISATEUR
├─ Chapitre 4 : Use Case
└─ Exercices Bibliothèque + E-Learning

Semaine 4-5 : INTERACTIONS
├─ Chapitre 5 : Séquence
└─ Exercices Réservation + E-Commerce

Semaine 6 : COMPLÉMENTS STRUCTURELS
├─ Chapitre 2 : Objets
└─ Chapitre 3 : Composants

Semaine 7 : PROCESSUS
├─ Chapitre 6 : Activités
└─ Exercices Commande + Recrutement

Semaine 8 : CYCLES DE VIE
├─ Chapitre 7 : États
└─ Exercices ATM + TCP

Semaine 9 : ARCHITECTURE
├─ Chapitre 8 : Déploiement
└─ Chapitre 9 : Paquetages

Semaine 10 : PRATIQUE
├─ Chapitre 10-11 : Outils + Patterns
├─ Chapitre 12-13 : Agile + Projet Final
└─ VOTRE PROPRE PROJET


PARCOURS 2 : DÉVELOPPEUR EXPÉRIMENTÉ (4-5 semaines)
──────────────────────────────────────────────────────

Semaine 1 : BASES RAPIDES
├─ Chapitres 0-1 : Intro + Classes (lecture rapide)
├─ Chapitre 4 : Use Case
└─ Chapitre 5 : Séquence (focus)

Semaine 2 : ARCHITECTURE
├─ Chapitre 3 : Composants
├─ Chapitre 8 : Déploiement
└─ Chapitre 9 : Paquetages (important)

Semaine 3 : PROCESSUS ET ÉTATS
├─ Chapitre 6 : Activités
└─ Chapitre 7 : États

Semaine 4 : PRATIQUE MODERNE
├─ Chapitre 10 : Outils (PlantUML focus)
├─ Chapitre 11 : Patterns (refresh)
└─ Chapitre 12 : Agile (très important)

Semaine 5 : PROJET FINAL
└─ Chapitre 13 : Projet Streaming complet


PARCOURS 3 : ARCHITECTE LOGICIEL (3 semaines)
────────────────────────────────────────────────

Semaine 1 : REFRESH + ARCHITECTURE
├─ Chapitres 0-1 : Survol rapide
├─ Chapitre 3 : Composants (focus)
├─ Chapitre 8 : Déploiement (focus)
└─ Chapitre 9 : Paquetages (focus)

Semaine 2 : PATTERNS + AGILE
├─ Chapitre 11 : Patterns (focus avancé)
├─ Chapitre 12 : Agile (architecture vision)
└─ ADR, C4 Model, Living Documentation

Semaine 3 : PROJET COMPLEXE
└─ Chapitre 13 : Streaming (architecture complète)
   + Adapter à votre domaine


PARCOURS 4 : PRÉPARATION ENTRETIEN (1 semaine intensive)
───────────────────────────────────────────────────────────

Jour 1 : Diagrammes Classes + Use Case
Jour 2 : Diagrammes Séquence + Activités
Jour 3 : Diagrammes Composants + Déploiement
Jour 4 : Patterns de Conception (GoF)
Jour 5 : Paquetages + Architecture
Jour 6 : Révision tous diagrammes
Jour 7 : Projet Final (practice)
"""


# ============================================================================
# [DOCS] RESSOURCES COMPLÉMENTAIRES
# ============================================================================

"""
LIVRES RECOMMANDÉS
──────────────────

[GUIDE] DÉBUTANT :
- "UML Distilled" - Martin Fowler
  -> Version courte, pragmatique (recommandé !)
- "Head First Object-Oriented Analysis and Design"
  -> Approche visuelle et ludique

[GUIDE] INTERMÉDIAIRE :
- "Applying UML and Patterns" - Craig Larman
  -> Complet, orienté pratique
- "UML 2 pour l'analyse d'un système d'information" - Joseph Gabay
  -> En français, très détaillé

[GUIDE] AVANCÉ :
- "Design Patterns" - Gang of Four
  -> La référence patterns
- "Domain-Driven Design" - Eric Evans
  -> Architecture et modélisation métier


OUTILS
──────

🆓 GRATUITS :
- PlantUML : https://plantuml.com
- Draw.io : https://app.diagrams.net
- Mermaid : https://mermaid.js.org
- StarUML : https://staruml.io (freemium)

[ARGENT] PAYANTS :
- Lucidchart : https://www.lucidchart.com
- Visual Paradigm : https://www.visual-paradigm.com
- Enterprise Architect : https://sparxsystems.com


SITES WEB
─────────

[DOCS] DOCUMENTATION OFFICIELLE :
- OMG UML : https://www.omg.org/spec/UML
- UML Diagrams : https://www.uml-diagrams.org

[DOCS] TUTORIELS :
- Tutorials Point UML : https://www.tutorialspoint.com/uml
- Lucidchart Guides : https://www.lucidchart.com/pages/uml

[DOCS] COMMUNAUTÉS :
- Stack Overflow (tag: uml)
- Reddit : r/softwaredevelopment
- Dev.to (articles UML)


VIDÉOS
──────

[MOVIE_CAMERA] YOUTUBE CHANNELS :
- Derek Banas (UML tutorials)
- Programming with Mosh (OOP + UML)
- Coursera / Udemy (cours complets)
"""


# ============================================================================
# [OK] CHECKLIST COMPÉTENCES
# ============================================================================

"""
APRÈS CE GUIDE, VOUS DEVRIEZ POUVOIR :

ANALYSE (Use Case)
[ ] Identifier acteurs système
[ ] Extraire cas d'utilisation depuis besoins
[ ] Utiliser relations include/extend
[ ] Écrire descriptions textuelles
[ ] Créer diagrammes use case complets

CONCEPTION (Classes)
[ ] Modéliser classes avec attributs/méthodes
[ ] Choisir visibilité appropriée (+, -, #)
[ ] Identifier relations entre classes
[ ] Utiliser héritage et interfaces
[ ] Définir multiplicités correctes
[ ] Créer diagrammes classes professionnels

INTERACTIONS (Séquence)
[ ] Modéliser flow de messages temporel
[ ] Distinguer messages sync/async
[ ] Utiliser fragments (alt, loop, opt)
[ ] Représenter création/destruction objets
[ ] Documenter scénarios complexes

PROCESSUS (Activités)
[ ] Modéliser workflows métier
[ ] Utiliser décisions et fusions
[ ] Représenter parallélisme (fork/join)
[ ] Organiser en swimlanes
[ ] Documenter processus complexes

COMPORTEMENT (États)
[ ] Identifier états objets
[ ] Modéliser transitions
[ ] Utiliser actions entry/exit/do
[ ] Créer états composites
[ ] Représenter concurrence

ARCHITECTURE (Composants, Déploiement, Paquetages)
[ ] Décomposer en composants
[ ] Définir interfaces
[ ] Organiser architecture en couches
[ ] Modéliser infrastructure physique
[ ] Gérer dépendances entre modules

PRATIQUE (Outils, Patterns, Agile)
[ ] Utiliser PlantUML
[ ] Utiliser Draw.io
[ ] Reconnaître patterns GoF
[ ] Implémenter patterns en code
[ ] Intégrer UML dans Agile
[ ] Pratiquer Just Enough modeling

PROJET COMPLET
[ ] Analyser cahier des charges
[ ] Créer tous diagrammes nécessaires
[ ] Concevoir architecture
[ ] Implémenter depuis diagrammes
[ ] Documenter décisions
"""


# ============================================================================
# [OBJECTIF] CONSEILS FINAUX
# ============================================================================

"""
POUR MAXIMISER APPRENTISSAGE :

1. PRATIQUEZ RÉGULIÈREMENT
   [OK] 30 min/jour > 3h/semaine
   [OK] Refaites exercices
   [OK] Créez vos propres exemples

2. APPLIQUEZ SUR PROJETS RÉELS
   [OK] Projets personnels
   [OK] Projets professionnels
   [OK] Contributions open source

3. ENSEIGNEZ AUX AUTRES
   [OK] Expliquez à collègues
   [OK] Écrivez articles
   [OK] Présentations équipe

4. RESTEZ PRAGMATIQUE
   [OK] UML = outil, pas objectif
   [OK] "Just Enough" modeling
   [OK] Valeur > Formalisme

5. CONTINUEZ À APPRENDRE
   [OK] Nouveaux patterns
   [OK] Nouvelles architectures
   [OK] Évolution pratiques


ERREURS À ÉVITER :

[X] Over-engineering avec UML
[X] Documentation exhaustive non maintenue
[X] Synchronisation parfaite Code <-> UML
[X] Diagrammes pour "faire joli"
[X] Ignorer feedback équipe
[X] Ne pas adapter au contexte
"""


# ============================================================================
# [BRAVO] FÉLICITATIONS !
# ============================================================================

"""
╔══════════════════════════════════════════════════════════════════════╗
║                                                                      ║
║                    VOUS ÊTES MAINTENANT PRÊT !                       ║
║                                                                      ║
║         Vous avez tous les outils pour créer des systèmes            ║
║         bien conçus et documentés professionnellement !              ║
║                                                                      ║
║                   BON COURAGE DANS VOS PROJETS ! [RAPIDE]                  ║
║                                                                      ║
╚══════════════════════════════════════════════════════════════════════╝


Maintenant, À VOUS DE JOUER ! [FORCE]

Choisissez un parcours, commencez par le Chapitre 0,
et progressez à votre rythme.

N'oubliez pas : LA PRATIQUE EST LA CLÉ !

Happy Modeling! [MESURE]*
"""


# ============================================================================
# FIN DE L'INDEX COMPLET
# ============================================================================


################################################################################
################################################################################
##                                                                            ##
##  SECTION II : PARTIE 1 - DIAGRAMMES STRUCTURELS
##                                                                            ##
################################################################################
################################################################################


# ============================================================================
# [LIVRE] UML - GUIDE ULTRA-DÉTAILLÉ POUR DÉBUTANTS
# ============================================================================
#
# [OBJECTIF] GUIDE COMPLET POUR MAÎTRISER UML DE ZÉRO À EXPERT
#
# Ce guide est organisé en 4 parties progressives :
#
# PARTIE 1 : INTRODUCTION ET DIAGRAMMES STRUCTURELS DE BASE
# - Chapitre 0 : Introduction à UML
# - Chapitre 1 : Diagramme de Classes
# - Chapitre 2 : Diagramme d'Objets
# - Chapitre 3 : Diagramme de Composants
#
# PARTIE 2 : DIAGRAMMES COMPORTEMENTAUX
# - Chapitre 4 : Diagramme de Cas d'Utilisation
# - Chapitre 5 : Diagramme de Séquence
# - Chapitre 6 : Diagramme d'Activités
# - Chapitre 7 : Diagramme d'États-Transitions
#
# PARTIE 3 : DIAGRAMMES AVANCÉS
# - Chapitre 8 : Diagramme de Communication
# - Chapitre 9 : Diagramme de Paquetages
# - Chapitre 10 : Diagramme de Déploiement
# - Chapitre 11 : Diagrammes de Temps et Interaction
#
# PARTIE 4 : PRATIQUE ET OUTILS
# - Chapitre 12 : Outils de Modélisation
# - Chapitre 13 : Bonnes Pratiques
# - Chapitre 14 : Projets Complets
# - Chapitre 15 : Anti-Patterns et Erreurs Courantes
#
# [TEMPS] TEMPS DE LECTURE TOTAL : ~20-25 heures
# [DOCS] PRÉREQUIS : Aucun (guide pour grands débutants)
#
# [IDEE] COMMENT UTILISER CE GUIDE :
# 1. Lisez les parties dans l'ordre
# 2. Dessinez TOUS les exemples
# 3. Faites les exercices pratiques (2 par diagramme)
# 4. Créez vos propres diagrammes
#
# ============================================================================

"""
[OBJECTIF] PHILOSOPHIE DE CE GUIDE

COMMENT ? -> Explications pas à pas avec exemples visuels
POURQUOI ? -> Raisons et contexte d'utilisation
QUAND ? -> Cas d'usage concrets et moments appropriés
PRATIQUE -> 2 exercices complets par diagramme

Ce guide vise à être VOTRE SEULE RÉFÉRENCE UML !
"""

# ============================================================================
# [NOTE] CONVENTIONS UTILISÉES DANS CE GUIDE
# ============================================================================

"""
[IDEE] Information importante
[REFLEXION] Question / Réflexion
[OK] Bonne pratique
[X] Mauvaise pratique / Erreur commune
[ATTENTION] Attention / Avertissement
[CLE] Point clé à retenir
[COURS] Exercice pratique
[DOCS] Résumé
[OBJECTIF] Objectif
[TEMPS] Temps estimé
[RAPIDE] Prêt pour la suite
[CONSTRUCTION] Exemple de structure
[GRAPHIQUE] Diagramme / Visualisation
"""

# ============================================================================
# [GUIDE] CHAPITRE 0 : INTRODUCTION COMPLÈTE À UML
# ============================================================================

"""
[OBJECTIF] OBJECTIFS D'APPRENTISSAGE

À la fin de ce chapitre, vous saurez :
[OK] Ce qu'est UML et pourquoi il existe
[OK] Les différents types de diagrammes UML
[OK] Quand utiliser chaque diagramme
[OK] L'histoire et l'évolution d'UML
[OK] Comment UML s'intègre dans le développement logiciel
"""


# ----------------------------------------------------------------------------
# [REFLEXION] QU'EST-CE QUE UML ?
# ----------------------------------------------------------------------------

"""
DÉFINITION SIMPLE

UML = Unified Modeling Language
     (Langage de Modélisation Unifié)

UML est un LANGAGE VISUEL pour :
- Spécifier
- Construire
- Visualiser
- Documenter

les artefacts d'un système logiciel.

[IDEE] UML N'EST PAS :
[X] Un langage de programmation
[X] Une méthodologie de développement
[X] Un outil logiciel

UML EST :
[OK] Un langage de notation standardisé
[OK] Un moyen de communication entre équipes
[OK] Un ensemble de règles et symboles
[OK] Indépendant des langages de programmation


ANALOGIE SIMPLE [CONSTRUCTION]

Imaginez la construction d'une maison :

PLANS D'ARCHITECTE = DIAGRAMMES UML
- Plan du rez-de-chaussée -> Diagramme de Classes
- Plan électrique -> Diagramme de Composants
- Schéma de plomberie -> Diagramme de Déploiement
- Planning des travaux -> Diagramme d'Activités

Architecte utilise ces plans pour :
[OK] Communiquer avec clients
[OK] Communiquer avec ouvriers
[OK] Vérifier faisabilité
[OK] Estimer coûts
[OK] Coordonner travaux

Développeur utilise UML pour :
[OK] Communiquer avec clients
[OK] Communiquer avec équipe
[OK] Concevoir architecture
[OK] Documenter système
[OK] Maintenir cohérence


POURQUOI UML EXISTE ?

PROBLÈME AVANT UML (années 1980-1990) :

Chaque méthodologie avait sa notation :
- Booch -> Notation Booch
- Rumbaugh -> OMT (Object Modeling Technique)
- Jacobson -> OOSE (Object-Oriented Software Engineering)

Conséquences :
[X] Confusion entre équipes
[X] Formations multiples nécessaires
[X] Incompatibilité des outils
[X] Difficultés de communication


SOLUTION : UML (1997)

Grady Booch + James Rumbaugh + Ivar Jacobson = "Les Trois Amigos"

Ont fusionné leurs notations pour créer UML :
[OK] Standard unique
[OK] Adopté par OMG (Object Management Group)
[OK] Supporté par tous les outils
[OK] Enseigné universellement


VERSIONS D'UML

UML 1.0 (1997) : Première version
UML 1.5 (2003) : Améliorations
UML 2.0 (2005) : Révision majeure (version actuelle de base)
UML 2.5.1 (2017) : Version la plus récente

[IDEE] Ce guide utilise UML 2.5.1 (version actuelle)
"""


# ----------------------------------------------------------------------------
# [GRAPHIQUE] LES 14 DIAGRAMMES UML
# ----------------------------------------------------------------------------

"""
UML 2.5 définit 14 TYPES DE DIAGRAMMES

Divisés en 2 grandes catégories :


═══════════════════════════════════════════════════════════════════════════
CATÉGORIE 1 : DIAGRAMMES STRUCTURELS (7 diagrammes)
═══════════════════════════════════════════════════════════════════════════

Ces diagrammes montrent la STRUCTURE STATIQUE du système
(ce que contient le système)

1. [PACKAGE] DIAGRAMME DE CLASSES (Class Diagram)
   ├─ QUOI : Structure des classes et leurs relations
   ├─ QUAND : Phase de conception orientée objet
   └─ IMPORTANCE : ***** (LE PLUS UTILISÉ)

2. [OBJECTIF] DIAGRAMME D'OBJETS (Object Diagram)
   ├─ QUOI : Instances concrètes à un moment donné
   ├─ QUAND : Illustrer exemples complexes
   └─ IMPORTANCE : ***

3. [MODULE] DIAGRAMME DE COMPOSANTS (Component Diagram)
   ├─ QUOI : Organisation des composants logiciels
   ├─ QUAND : Architecture système
   └─ IMPORTANCE : ****

4. [PACKAGE] DIAGRAMME DE PAQUETAGES (Package Diagram)
   ├─ QUOI : Organisation en packages/modules
   ├─ QUAND : Structurer gros projets
   └─ IMPORTANCE : ***

5. [CONSTRUCTION] DIAGRAMME DE STRUCTURE COMPOSITE (Composite Structure)
   ├─ QUOI : Structure interne d'une classe
   ├─ QUAND : Systèmes complexes embarqués
   └─ IMPORTANCE : **

6. [ECRAN] DIAGRAMME DE DÉPLOIEMENT (Deployment Diagram)
   ├─ QUOI : Architecture matérielle et déploiement
   ├─ QUAND : Infrastructure système
   └─ IMPORTANCE : ****

7. [SCENARIO] DIAGRAMME DE PROFIL (Profile Diagram)
   ├─ QUOI : Extensions UML personnalisées
   ├─ QUAND : Domaines très spécifiques
   └─ IMPORTANCE : *


═══════════════════════════════════════════════════════════════════════════
CATÉGORIE 2 : DIAGRAMMES COMPORTEMENTAUX (7 diagrammes)
═══════════════════════════════════════════════════════════════════════════

Ces diagrammes montrent le COMPORTEMENT DYNAMIQUE du système
(comment le système fonctionne)

8. [UTILISATEUR] DIAGRAMME DE CAS D'UTILISATION (Use Case Diagram)
   ├─ QUOI : Fonctionnalités du point de vue utilisateur
   ├─ QUAND : Début de projet, spécifications
   └─ IMPORTANCE : ***** (TRÈS UTILISÉ)

9. [MESSAGE] DIAGRAMME DE SÉQUENCE (Sequence Diagram)
   ├─ QUOI : Interactions temporelles entre objets
   ├─ QUAND : Décrire scénarios d'utilisation
   └─ IMPORTANCE : ***** (TRÈS UTILISÉ)

10. [SYNC] DIAGRAMME D'ACTIVITÉS (Activity Diagram)
    ├─ QUOI : Flux de contrôle et d'activités
    ├─ QUAND : Processus métier, algorithmes
    └─ IMPORTANCE : ****

11. [MELANGE] DIAGRAMME D'ÉTATS-TRANSITIONS (State Machine Diagram)
    ├─ QUOI : États d'un objet et transitions
    ├─ QUAND : Objets avec comportement complexe
    └─ IMPORTANCE : ****

12. [SPEECH_BALLOON] DIAGRAMME DE COMMUNICATION (Communication Diagram)
    ├─ QUOI : Messages entre objets (focus sur liens)
    ├─ QUAND : Alternative au diagramme de séquence
    └─ IMPORTANCE : ***

13. [SYNC] DIAGRAMME DE VUE D'ENSEMBLE D'INTERACTION (Interaction Overview)
    ├─ QUOI : Vue globale des interactions
    ├─ QUAND : Systèmes avec interactions complexes
    └─ IMPORTANCE : **

14. [TEMPS] DIAGRAMME DE TEMPS (Timing Diagram)
    ├─ QUOI : Contraintes temporelles précises
    ├─ QUAND : Systèmes temps réel
    └─ IMPORTANCE : **


[IDEE] LES 5 DIAGRAMMES ESSENTIELS (à maîtriser en priorité)

1. Diagramme de Classes *****
2. Diagramme de Cas d'Utilisation *****
3. Diagramme de Séquence *****
4. Diagramme d'Activités ****
5. Diagramme de Déploiement ****
"""


# ----------------------------------------------------------------------------
# [OBJECTIF] QUAND UTILISER UML ?
# ----------------------------------------------------------------------------

"""
PHASES DU CYCLE DE VIE LOGICIEL OÙ UML EST UTILE


1. ANALYSE DES BESOINS [LISTE]
   ├─ Diagrammes utilisés :
   │  ├─ Cas d'Utilisation (identifier fonctionnalités)
   │  └─ Activités (processus métier)
   └─ Objectif : Comprendre ce que le système doit faire


2. CONCEPTION (DESIGN) [CONSTRUCTION]
   ├─ Diagrammes utilisés :
   │  ├─ Classes (structure orientée objet)
   │  ├─ Séquence (interactions)
   │  ├─ États-Transitions (comportements)
   │  └─ Composants (architecture)
   └─ Objectif : Définir comment le système sera construit


3. IMPLÉMENTATION [CODE]
   ├─ Diagrammes utilisés :
   │  ├─ Classes (guide pour coder)
   │  └─ Composants (organisation code)
   └─ Objectif : Coder en suivant la conception


4. DÉPLOIEMENT [RAPIDE]
   ├─ Diagrammes utilisés :
   │  └─ Déploiement (infrastructure)
   └─ Objectif : Installer le système


5. MAINTENANCE [OUTIL]
   ├─ Diagrammes utilisés :
   │  └─ Tous (documentation)
   └─ Objectif : Comprendre système existant


TAILLE DU PROJET ET UML

PETIT PROJET (1-2 développeurs, <10,000 lignes)
├─ UML utile ? : Optionnel
├─ Diagrammes minimum :
│  └─ Classes (rapide, pour clarifier idées)
└─ Temps UML : ~5% du temps total

PROJET MOYEN (3-10 développeurs, 10k-100k lignes)
├─ UML utile ? : Recommandé
├─ Diagrammes minimum :
│  ├─ Cas d'Utilisation
│  ├─ Classes
│  └─ Séquence (scénarios importants)
└─ Temps UML : ~15% du temps total

GRAND PROJET (10+ développeurs, >100k lignes)
├─ UML utile ? : Essentiel
├─ Diagrammes minimum :
│  ├─ Cas d'Utilisation
│  ├─ Classes (détaillées)
│  ├─ Séquence (tous scénarios)
│  ├─ Composants
│  ├─ Déploiement
│  └─ États (objets complexes)
└─ Temps UML : ~25% du temps total


CONTEXTES D'UTILISATION

[OK] QUAND UTILISER UML :

1. COMMUNICATION D'ÉQUIPE
   - Expliquer architecture à nouveaux membres
   - Discussions de conception
   - Revues de code

2. DOCUMENTATION
   - Système complexe à maintenir
   - Transmission de connaissances
   - Onboarding nouveaux développeurs

3. ANALYSE AVANT CODAGE
   - Éviter erreurs de conception
   - Valider approche avec client
   - Estimer complexité

4. SYSTÈMES CRITIQUES
   - Médical, aéronautique, finance
   - Besoin de spécifications rigoureuses
   - Vérification formelle

5. ENSEIGNEMENT
   - Apprendre POO (Programmation Orientée Objet)
   - Comprendre patterns de conception
   - Analyser systèmes existants


[X] QUAND NE PAS UTILISER UML :

1. PROTOTYPE RAPIDE
   - Validation d'idée
   - POC (Proof of Concept)
   -> Coder directement plus rapide

2. PROJET TRÈS SIMPLE
   - Script de quelques lignes
   - Outil personnel
   -> Overhead inutile

3. MÉTHODOLOGIE AGILE STRICTE
   - Privilégier code comme documentation
   - Itérations très rapides
   -> UML peut ralentir

4. ÉQUIPE HOSTILE À UML
   - Résistance culturelle
   - Manque de formation
   -> Forcing contre-productif


[IDEE] RÈGLE D'OR

UML est un OUTIL, pas une obligation !
Utilisez-le quand il APPORTE DE LA VALEUR :
[OK] Clarté
[OK] Communication
[OK] Documentation
[OK] Qualité

N'utilisez PAS UML par dogmatisme !
"""


# ----------------------------------------------------------------------------
# [CLASSICAL_BUILDING] HISTOIRE ET ÉVOLUTION D'UML
# ----------------------------------------------------------------------------

"""
CHRONOLOGIE DÉTAILLÉE


1967-1980 : PRÉMICES
────────────────────
- Langages de modélisation divers (organigrammes, etc.)
- Pas de standard pour modélisation objet


1980-1994 : "GUERRE DES MÉTHODES"
──────────────────────────────────
Plus de 50 méthodes de modélisation objet !

Principales :
├─ Booch (Grady Booch) - 1991
│  └─ Focus : Conception détaillée
│
├─ OMT (James Rumbaugh) - 1991
│  └─ Focus : Analyse orientée objet
│
├─ OOSE (Ivar Jacobson) - 1992
│  └─ Focus : Cas d'utilisation
│
├─ Shlaer-Mellor - 1988
├─ Coad-Yourdon - 1990
└─ Wirfs-Brock - 1990

Problèmes :
[X] Incompatibilité entre méthodes
[X] Confusion dans l'industrie
[X] Outils non interopérables


1994-1995 : UNIFICATION
───────────────────────
- Octobre 1994 : Booch et Rumbaugh unissent leurs forces chez Rational
- Version 0.8 : "Unified Method" (Booch + OMT)
- 1995 : Ivar Jacobson rejoint Rational
- Naissance officielle d'UML


1996 : STANDARDISATION
──────────────────────
- Janvier 1996 : UML 0.9 publié
- Feedback de l'industrie (HP, Microsoft, Oracle, IBM...)
- Juin 1996 : UML 1.0 soumis à OMG


1997 : ADOPTION OMG
───────────────────
- Novembre 1997 : OMG adopte UML 1.1
- UML devient standard international
- Support massif de l'industrie


2000-2005 : MATURITÉ
────────────────────
- UML 1.3 (2000) : Corrections et clarifications
- UML 1.4 (2001) : Améliorations
- UML 1.5 (2003) : Version stable très utilisée


2005 : RÉVOLUTION UML 2.0
─────────────────────────
- Refonte majeure
- 13 diagrammes (vs 9 en UML 1.x)
- Meilleure précision sémantique
- Support interactions complexes


2007-2017 : ÉVOLUTIONS MINEURES
────────────────────────────────
- UML 2.1 (2007)
- UML 2.2 (2009)
- UML 2.3 (2010)
- UML 2.4 (2011)
- UML 2.5 (2015)
- UML 2.5.1 (2017) <- Version actuelle


2020+ : FUTUR D'UML
───────────────────
- UML reste standard de référence
- Concurrence : SysML (systèmes), ArchiMate (architecture)
- Intégration dans outils modernes (VS Code, IntelliJ)
- Génération de code depuis UML
- Ingénierie Dirigée par les Modèles (MDA)


[IDEE] IMPACT D'UML

Avant UML :
[X] 50+ notations différentes
[X] Confusion généralisée
[X] Pas de standard

Après UML :
[OK] Standard unique mondial
[OK] Enseigné partout
[OK] Outils compatibles
[OK] Communication facilitée
"""


# ----------------------------------------------------------------------------
# [OUTIL] COMMENT S'INTÈGRE UML DANS LE DÉVELOPPEMENT ?
# ----------------------------------------------------------------------------

"""
UML ET MÉTHODOLOGIES DE DÉVELOPPEMENT


1. UML + CYCLE EN CASCADE (Waterfall)
──────────────────────────────────────

Phases séquentielles :
1. Analyse -> Cas d'Utilisation, Activités
2. Conception -> Classes, Séquence, États
3. Implémentation -> Code basé sur diagrammes
4. Test -> Vérification vs spécifications UML
5. Maintenance -> UML comme documentation

Utilisation UML :
[OK] Diagrammes détaillés avant codage
[OK] Documentation exhaustive
[OK] Validation formelle

Avantages :
+ Spécifications rigoureuses
+ Documentation complète

Inconvénients :
- Rigide
- UML peut devenir obsolète si code change


2. UML + PROCESSUS UNIFIÉ (UP/RUP)
───────────────────────────────────

Processus itératif créé PAR les auteurs d'UML !

Phases :
├─ Inception -> Cas d'Utilisation
├─ Élaboration -> Classes, Séquence (architecture)
├─ Construction -> Tous diagrammes (itératif)
└─ Transition -> Déploiement

Utilisation UML :
[OK] UML central au processus
[OK] Itérations sur diagrammes
[OK] Refinement progressif

Avantages :
+ UML bien intégré
+ Itératif mais structuré

Inconvénients :
- Lourd pour petits projets
- Beaucoup de documentation


3. UML + MÉTHODES AGILES (Scrum, XP)
─────────────────────────────────────

Philosophie :
"Working software over comprehensive documentation"

Utilisation UML :
[ATTENTION] UML utilisé légèrement (Agile Modeling)

Approche :
├─ Diagrammes rapides (tableau blanc)
├─ Juste assez de modélisation
├─ Diagrammes jetés après (pas de maintenance)
└─ Focus sur quelques diagrammes clés

Diagrammes utilisés :
[OK] Cas d'Utilisation (User Stories visuelles)
[OK] Classes (design discussions)
[OK] Séquence (scénarios complexes)
[X] Pas de documentation exhaustive

Avantages :
+ Flexibilité
+ Rapidité

Inconvénients :
- Peu de documentation pérenne
- Risque de perte de connaissances


4. UML + DEVOPS
───────────────

Utilisation UML :
├─ Diagrammes de Déploiement (infrastructure as code)
├─ Diagrammes de Composants (microservices)
└─ Automatisation : Diagrammes -> Code -> Déploiement

Outils :
- PlantUML (diagrammes as code)
- Terraform + UML (infrastructure)


[IDEE] BONNE PRATIQUE MODERNE

APPROCHE PRAGMATIQUE :
1. Utiliser UML quand utile
2. Diagrammes légers et maintenables
3. Code = source de vérité
4. UML = communication et design

"Just enough modeling"
- Scott Ambler (Agile Modeling)
"""


# ----------------------------------------------------------------------------
# [DOCS] RÉCAPITULATIF CHAPITRE 0
# ----------------------------------------------------------------------------

"""
CE QUE VOUS AVEZ APPRIS

[OK] Définition d'UML : Langage visuel standardisé
[OK] Pourquoi UML existe : Unifier les notations
[OK] 14 types de diagrammes : 7 structurels + 7 comportementaux
[OK] Les 5 diagrammes essentiels à maîtriser
[OK] Quand utiliser UML : Taille projet, phases, contexte
[OK] Histoire d'UML : De la guerre des méthodes au standard
[OK] Intégration avec méthodologies : Waterfall, UP, Agile, DevOps


[CLE] POINTS CLÉS

1. UML n'est PAS un langage de programmation
2. UML est un OUTIL de communication et documentation
3. Tous les diagrammes ne sont pas toujours nécessaires
4. Les 5 diagrammes essentiels couvrent 80% des besoins
5. Utilisez UML de façon pragmatique, pas dogmatique


[OBJECTIF] AVANT DE CONTINUER

Assurez-vous de comprendre :
[OK] Ce qu'est UML et son but
[OK] Les 2 grandes catégories de diagrammes
[OK] Quand UML est utile (et quand il ne l'est pas)


-> PROCHAINE ÉTAPE : Chapitre 1 - Diagramme de Classes

Le diagramme de classes est LE diagramme le plus important !
Vous allez apprendre :
- Comment représenter classes et objets
- Les relations entre classes
- Les multiplicités
- La visibilité
- Et bien plus !

Prêt ? C'est parti ! [RAPIDE]
"""


# ============================================================================
# [GUIDE] CHAPITRE 1 : DIAGRAMME DE CLASSES
# ============================================================================

"""
[OBJECTIF] OBJECTIFS D'APPRENTISSAGE

À la fin de ce chapitre, vous saurez :
[OK] Représenter une classe en UML
[OK] Les 3 compartiments d'une classe
[OK] Visibilité des membres (public, private, protected)
[OK] Relations entre classes (association, agrégation, composition, héritage)
[OK] Multiplicités et cardinalités
[OK] Classes abstraites et interfaces
[OK] Attributs et méthodes statiques
[OK] Créer diagrammes de classes complets
"""


# ----------------------------------------------------------------------------
# [REFLEXION] QU'EST-CE QU'UN DIAGRAMME DE CLASSES ?
# ----------------------------------------------------------------------------

"""
DÉFINITION SIMPLE

Diagramme de Classes = Représentation visuelle de la STRUCTURE d'un système
                       orienté objet

Montre :
├─ Les CLASSES du système
├─ Les ATTRIBUTS de chaque classe
├─ Les MÉTHODES de chaque classe
└─ Les RELATIONS entre les classes


[IDEE] POURQUOI UTILISER ?

AVANT LE CODE :
[OK] Concevoir l'architecture
[OK] Valider la conception avec l'équipe
[OK] Identifier les problèmes tôt
[OK] Documenter les décisions

PENDANT LE CODE :
[OK] Guide pour l'implémentation
[OK] Référence pour les développeurs

APRÈS LE CODE :
[OK] Documentation du système
[OK] Onboarding nouveaux développeurs
[OK] Maintenance et évolution


[REFLEXION] QUAND L'UTILISER ?

[OK] UTILISEZ POUR :
- Systèmes orientés objet (Java, C#, Python, C++)
- Conception avant codage
- Refactoring de code existant
- Documentation d'architecture
- Communication d'équipe

[X] ÉVITEZ POUR :
- Scripts procéduraux simples
- Prototypes jetables
- Code déjà écrit et stable (sauf doc)


ANALOGIE [CONSTRUCTION]

Diagramme de Classes = Plan architectural d'une maison

Plan montre :
├─ Pièces (= Classes)
├─ Dimensions (= Attributs)
├─ Fonctionnalités (= Méthodes)
└─ Connexions entre pièces (= Relations)

Le plan ne construit PAS la maison,
mais guide la construction !
"""


# ----------------------------------------------------------------------------
# [PACKAGE] REPRÉSENTATION D'UNE CLASSE
# ----------------------------------------------------------------------------

"""
STRUCTURE DE BASE

Une classe UML = RECTANGLE divisé en 3 COMPARTIMENTS


┌─────────────────────────────┐
│       NomClasse             │  <- COMPARTIMENT 1 : Nom
├─────────────────────────────┤
│  - attribut1 : Type         │  <- COMPARTIMENT 2 : Attributs
│  - attribut2 : Type         │
├─────────────────────────────┤
│  + methode1() : ReturnType  │  <- COMPARTIMENT 3 : Méthodes
│  + methode2(param : Type)   │
└─────────────────────────────┘


COMPARTIMENT 1 : NOM DE LA CLASSE
──────────────────────────────────

Règles :
[OK] Commence par une MAJUSCULE
[OK] Nom singulier (Voiture, pas Voitures)
[OK] CamelCase si plusieurs mots (VoitureElectrique)
[OK] Centré et en gras


Exemples :
┌──────────────┐
│   Personne   │
└──────────────┘

┌──────────────┐
│    Compte    │
└──────────────┘

┌─────────────────┐
│VoitureElectrique│
└─────────────────┘


COMPARTIMENT 2 : ATTRIBUTS
──────────────────────────

Syntaxe complète :
visibilité nom : Type [multiplicité] = valeurParDéfaut {propriété}

Exemple :
- solde : Decimal = 0.0


Visibilité (symboles) :
+ public    : Accessible partout
- private   : Accessible seulement dans la classe
# protected : Accessible dans la classe et sous-classes
~ package   : Accessible dans le même package


Type :
- Types primitifs : Integer, String, Boolean, Float, Date
- Types personnalisés : NomAutreClasse
- Collections : List<Type>, Set<Type>, Map<Key, Value>


Exemples d'attributs :
┌─────────────────────────────┐
│          Personne           │
├─────────────────────────────┤
│  - nom : String             │  <- private
│  + age : Integer            │  <- public
│  # email : String           │  <- protected
│  ~ adresse : String         │  <- package
└─────────────────────────────┘


COMPARTIMENT 3 : MÉTHODES (OPÉRATIONS)
───────────────────────────────────────

Syntaxe complète :
visibilité nom(param1 : Type, param2 : Type) : TypeRetour

Exemple :
+ calculerSalaire(heures : Integer) : Decimal


Types de méthodes :
├─ Constructeur : <<constructor>> NomClasse()
├─ Getter/Setter : + getNom() : String / + setNom(n : String)
├─ Méthode normale : + faireCeci()
└─ Méthode abstraite : + methodeAbstraite() {abstract}


Exemples :
┌─────────────────────────────────────┐
│            Personne                 │
├─────────────────────────────────────┤
│  - nom : String                     │
│  - age : Integer                    │
├─────────────────────────────────────┤
│  + Personne(nom : String)           │  <- Constructeur
│  + getNom() : String                │  <- Getter
│  + setNom(n : String)               │  <- Setter
│  + anniversaire()                   │  <- Méthode
│  + estMajeur() : Boolean            │  <- Méthode avec retour
└─────────────────────────────────────┘


[IDEE] NIVEAUX DE DÉTAIL

Selon le contexte, on peut montrer plus ou moins de détails :

NIVEAU 1 : Nom seulement (vue d'ensemble)
┌──────────┐
│ Personne │
└──────────┘

NIVEAU 2 : Nom + Attributs (conception)
┌──────────────────────┐
│      Personne        │
├──────────────────────┤
│  - nom : String      │
│  - age : Integer     │
└──────────────────────┘

NIVEAU 3 : Complet (documentation détaillée)
┌─────────────────────────────┐
│         Personne            │
├─────────────────────────────┤
│  - nom : String             │
│  - age : Integer            │
├─────────────────────────────┤
│  + Personne(nom : String)   │
│  + getNom() : String        │
│  + setAge(a : Integer)      │
└─────────────────────────────┘


[CLE] RÈGLES DE NOMMAGE

Attributs :
[OK] Commence par minuscule
[OK] camelCase si plusieurs mots
[OK] Nom significatif
Exemples : nom, dateNaissance, numeroTelephone

Méthodes :
[OK] Commence par un VERBE
[OK] camelCase
[OK] Nom explicite
Exemples : calculer(), enregistrer(), afficherDetails()
"""


# ----------------------------------------------------------------------------
# [LIEN] RELATIONS ENTRE CLASSES
# ----------------------------------------------------------------------------

"""
UML définit plusieurs types de RELATIONS entre classes

═══════════════════════════════════════════════════════════════════════════
1. ASSOCIATION
═══════════════════════════════════════════════════════════════════════════

[IDEE] DÉFINITION
Relation la plus générale entre deux classes
"Une classe A utilise/connaît une classe B"


NOTATION :
─────────  (ligne simple)

Exemple :
┌──────────┐                    ┌──────────┐
│ Personne │────────────────────│ Voiture  │
└──────────┘                    └──────────┘
Une Personne possède une Voiture


AVEC RÔLE :
┌──────────┐  propriétaire     ┌──────────┐
│ Personne │───────────────────│ Voiture  │
└──────────┘                   └──────────┘


AVEC MULTIPLICITÉ :
┌──────────┐   1        1..*    ┌──────────┐
│ Personne │────────────────────│ Voiture  │
└──────────┘                    └──────────┘
Une Personne possède 1 ou plusieurs Voitures


DIRECTION (NAVIGABILITÉ) :
┌──────────┐                    ┌──────────┐
│ Personne │───────────────────>│ Voiture  │
└──────────┘                    └──────────┘
Personne connaît Voiture (mais pas l'inverse)


ASSOCIATION BIDIRECTIONNELLE :
┌──────────┐                    ┌──────────┐
│ Personne │<────────────────>  │ Voiture  │
└──────────┘                    └──────────┘
Les deux se connaissent mutuellement


[IDEE] MULTIPLICITÉS (CARDINALITÉS)

Indique combien d'instances peuvent être liées

Notations courantes :
1       : Exactement 1
0..1    : Zéro ou 1 (optionnel)
*       : Zéro ou plusieurs (0..*)
1..*    : Un ou plusieurs
n..m    : Entre n et m
2,4,6   : Exactement 2, 4 ou 6


Exemples :

┌──────────┐   1          0..*  ┌──────────┐
│ Étudiant │────────────────────│  Cours   │
└──────────┘                    └──────────┘
Un Étudiant suit 0 ou plusieurs Cours

┌──────────┐   1             1  ┌──────────┐
│ Personne │────────────────────│   Tête   │
└──────────┘                    └──────────┘
Une Personne a exactement 1 Tête


CLASSE D'ASSOCIATION :

Quand l'association elle-même a des attributs :

┌──────────┐   emploie     ┌────────────┐
│Entreprise│───────────────│  Employé   │
└──────────┘       │       └────────────┘
                   │
           ┌───────┴────────┐
           │   Contrat      │
           ├────────────────┤
           │- dateDebut     │
           │- salaire       │
           └────────────────┘


═══════════════════════════════════════════════════════════════════════════
2. AGRÉGATION
═══════════════════════════════════════════════════════════════════════════

[IDEE] DÉFINITION
Relation "a-un" (has-a) FAIBLE
Partie peut exister indépendamment du tout


NOTATION :
[WHITE_DIAMOND]─────────  (losange vide du côté du "tout")

Exemple :
┌─────────────┐               ┌──────────┐
│ Université  │[WHITE_DIAMOND]──────────────│ Étudiant │
└─────────────┘               └──────────┘
Une Université a des Étudiants
(Étudiant peut exister sans l'Université)


[IDEE] CARACTÉRISTIQUES
- Relation de contenance FAIBLE
- Les parties survivent à la destruction du tout
- Partage possible entre plusieurs "touts"


Exemple avec multiplicités :
┌──────────┐      1     0..*   ┌──────────┐
│  Équipe  │[WHITE_DIAMOND]──────────────────│  Joueur  │
└──────────┘                   └──────────┘
Une Équipe a 0 ou plusieurs Joueurs
Un Joueur peut changer d'Équipe


═══════════════════════════════════════════════════════════════════════════
3. COMPOSITION
═══════════════════════════════════════════════════════════════════════════

[IDEE] DÉFINITION
Relation "a-un" (has-a) FORTE
Partie ne peut PAS exister sans le tout


NOTATION :
[BLACK_DIAMOND]─────────  (losange plein du côté du "tout")

Exemple :
┌──────────┐                   ┌──────────┐
│  Maison  │[BLACK_DIAMOND]──────────────────│  Pièce   │
└──────────┘                   └──────────┘
Une Maison a des Pièces
(Pièce n'existe pas sans Maison)


[IDEE] CARACTÉRISTIQUES
- Relation de contenance FORTE
- Les parties sont détruites avec le tout
- Pas de partage (une partie appartient à UN SEUL tout)
- Cycle de vie dépendant


Exemple détaillé :
┌──────────┐      1      1..*   ┌──────────┐
│ Commande │[BLACK_DIAMOND]──────────────────-│LigneCommande│
└──────────┘                    └──────────┘
Une Commande a 1 ou plusieurs LignesCommande
Si Commande supprimée -> LignesCommande supprimées


[REFLEXION] AGRÉGATION vs COMPOSITION ?

Question à se poser : "Si je supprime le tout, que devient la partie ?"

AGRÉGATION ([WHITE_DIAMOND]) :
- Partie SURVIT
- Exemple : Université [WHITE_DIAMOND]─── Étudiant
  -> Étudiant existe sans Université

COMPOSITION ([BLACK_DIAMOND]) :
- Partie EST DÉTRUITE
- Exemple : Maison [BLACK_DIAMOND]─── Pièce
  -> Pièce n'existe pas sans Maison


═══════════════════════════════════════════════════════════════════════════
4. HÉRITAGE (GÉNÉRALISATION)
═══════════════════════════════════════════════════════════════════════════

[IDEE] DÉFINITION
Relation "est-un" (is-a)
Une classe hérite d'une autre


NOTATION :
───────[WHITE_RIGHT-POINTING_TRIANGLE]  (flèche vide vers la classe mère)

Exemple :
                ┌──────────┐
                │  Animal  │
                └──────────┘
                      [WHITE_UP-POINTING_TRIANGLE]
                      │
          ┌───────────┴───────────┐
          │                       │
    ┌──────────┐            ┌──────────┐
    │   Chat   │            │   Chien  │
    └──────────┘            └──────────┘

Chat EST-UN Animal
Chien EST-UN Animal


[IDEE] CARACTÉRISTIQUES
- Classe fille hérite de tous les attributs/méthodes publics/protégés
- Réutilisation de code
- Polymorphisme


Exemple détaillé :
┌─────────────────────────────┐
│         Véhicule            │
├─────────────────────────────┤
│  # marque : String          │
│  # vitesse : Integer        │
├─────────────────────────────┤
│  + démarrer()               │
│  + arrêter()                │
└─────────────────────────────┘
              [WHITE_UP-POINTING_TRIANGLE]
              │
    ┌─────────┴─────────┐
    │                   │
┌────────┐          ┌────────┐
│Voiture │          │  Moto  │
├────────┤          ├────────┤
│-nbPortes│          │-hasSidecar│
├────────┤          ├────────┤
│+klaxonner│         │+wheelie│
└────────┘          └────────┘


HÉRITAGE MULTIPLE :

UML supporte (mais éviter si possible) :

       ┌──────────┐      ┌──────────┐
       │Étudiant  │      │ Employé  │
       └──────────┘      └──────────┘
              [WHITE_UP-POINTING_TRIANGLE]              [WHITE_UP-POINTING_TRIANGLE]
              └──────┬───────┘
                     │
              ┌──────────────┐
              │ÉtudiantSalarié│
              └──────────────┘


═══════════════════════════════════════════════════════════════════════════
5. DÉPENDANCE
═══════════════════════════════════════════════════════════════════════════

[IDEE] DÉFINITION
Relation temporaire/faible
Une classe utilise une autre (paramètre, variable locale)


NOTATION :
- - - - - >  (flèche pointillée)

Exemple :
┌────────────┐                  ┌──────────┐
│Imprimante  │- - - - - - - - > │ Document │
└────────────┘                  └──────────┘

class Imprimante {
    public void imprimer(Document doc) {  // <- Dépendance
        // ...
    }
}


[IDEE] DIFFÉRENCE avec Association :
- Dépendance = Usage temporaire (paramètre, var locale)
- Association = Relation permanente (attribut)


═══════════════════════════════════════════════════════════════════════════
6. RÉALISATION (INTERFACE)
═══════════════════════════════════════════════════════════════════════════

[IDEE] DÉFINITION
Une classe implémente une interface


NOTATION :
- - - - - [WHITE_RIGHT-POINTING_TRIANGLE]  (flèche pointillée vide)

Exemple :
       ┌─────────────────┐
       │<<interface>>    │
       │   Drawable      │
       ├─────────────────┤
       │ + draw()        │
       └─────────────────┘
                [WHITE_UP-POINTING_TRIANGLE]
                ┆
                ┆
         ┌──────────┐
         │  Cercle  │
         ├──────────┤
         │+ draw()  │  <- Implémente draw()
         └──────────┘


[GRAPHIQUE] TABLEAU RÉCAPITULATIF DES RELATIONS

┌──────────────┬────────────┬─────────┬──────────────────────┐
│  Relation    │  Notation  │ Exemple │ Signification        │
├──────────────┼────────────┼─────────┼──────────────────────┤
│ Association  │ ─────────  │ A ──── B│ A utilise B          │
│ Agrégation   │ [WHITE_DIAMOND]─────────│ A [WHITE_DIAMOND]─── B│ A contient B (faible)│
│ Composition  │ [BLACK_DIAMOND]─────────│ A [BLACK_DIAMOND]─── B│ A contient B (fort)  │
│ Héritage     │ ─────────[WHITE_RIGHT-POINTING_TRIANGLE] │ A ───[WHITE_RIGHT-POINTING_TRIANGLE] B│ A est-un B           │
│ Dépendance   │ - - - - ->│ A ----> B│ A dépend de B        │
│ Réalisation  │ - - - - -[WHITE_RIGHT-POINTING_TRIANGLE]│ A ···[WHITE_RIGHT-POINTING_TRIANGLE] B│ A implémente B       │
└──────────────┴────────────┴─────────┴──────────────────────┘
"""


# Ce fichier continue... Le guide complet sera divisé en plusieurs parties
# pour respecter les limites de taille.

# ============================================================================
# FIN DE LA PARTIE 1 - CHAPITRE 1 (SUITE DANS PROCHAIN FICHIER)
# ============================================================================
# ============================================================================
# [LIVRE] UML - GUIDE PARTIE 1 (SUITE) : DIAGRAMME DE CLASSES - EXERCICES
# ============================================================================

# ----------------------------------------------------------------------------
# [DESIGN] CLASSES ABSTRAITES ET INTERFACES
# ----------------------------------------------------------------------------

"""
CLASSES ABSTRAITES

[IDEE] DÉFINITION
Classe qui ne peut PAS être instanciée directement
Sert de modèle pour les classes filles


NOTATION :
Nom en italique OU stéréotype <<abstract>>

┌─────────────────────────┐
│    FigureGeometrique    │  <- Nom en italique
│       <<abstract>>      │  <- OU stéréotype
├─────────────────────────┤
│ # couleur : String      │
├─────────────────────────┤
│ + calculerAire() : Float│  <- Peut être abstraite
│ + afficher()            │
└─────────────────────────┘

Méthode abstraite (nom en italique) :
+ calculerAire() : Float


Exemple complet :
┌──────────────────────────────┐
│      FigureGeometrique       │
│        <<abstract>>          │
├──────────────────────────────┤
│ # couleur : String           │
│ # position : Point           │
├──────────────────────────────┤
│ + calculerAire() : Float {abstract}│
│ + calculerPerimetre() : Float {abstract}│
│ + setCouleur(c : String)     │
└──────────────────────────────┘
                [WHITE_UP-POINTING_TRIANGLE]
                │
        ┌───────┴───────┐
        │               │
┌───────────┐     ┌───────────┐
│  Cercle   │     │ Rectangle │
├───────────┤     ├───────────┤
│-rayon     │     │-largeur   │
│           │     │-hauteur   │
├───────────┤     ├───────────┤
│+calculerAire()│  │+calculerAire()│
│+calculerPerimetre()│+calculerPerimetre()│
└───────────┘     └───────────┘


INTERFACES

[IDEE] DÉFINITION
Contrat que les classes doivent respecter
Uniquement des signatures de méthodes (pas d'implémentation)


NOTATION :
Stéréotype <<interface>>

┌─────────────────────────┐
│     <<interface>>       │
│      Comparable         │
├─────────────────────────┤
│ + compareTo(obj) : int  │
└─────────────────────────┘
                [WHITE_UP-POINTING_TRIANGLE]
                ┆ (réalisation)
                ┆
┌─────────────────────────┐
│        Produit          │
├─────────────────────────┤
│ - prix : Float          │
├─────────────────────────┤
│ + compareTo(obj) : int  │
└─────────────────────────┘


INTERFACE vs CLASSE ABSTRAITE

┌────────────────┬──────────────┬──────────────┐
│                │  Interface   │Classe Abstract│
├────────────────┼──────────────┼──────────────┤
│Instanciable?   │     NON      │     NON      │
│Attributs       │     NON*     │     OUI      │
│Implémentation  │     NON      │   PARTIELLE  │
│Héritage multiple│    OUI      │   NON (Java) │
│Usage           │   Contrat    │  Modèle      │
└────────────────┴──────────────┴──────────────┘

* Sauf constantes


Exemple concret :

┌────────────────────┐  ┌────────────────────┐
│  <<interface>>     │  │  <<interface>>     │
│    Volant          │  │     Nageant        │
├────────────────────┤  ├────────────────────┤
│ + voler() : void   │  │ + nager() : void   │
└────────────────────┘  └────────────────────┘
          [WHITE_UP-POINTING_TRIANGLE]                      [WHITE_UP-POINTING_TRIANGLE]
          ┆                      ┆
          └──────────┬───────────┘
                     ┆
              ┌──────────────┐
              │    Canard    │
              ├──────────────┤
              │ - nom        │
              ├──────────────┤
              │ + voler()    │
              │ + nager()    │
              └──────────────┘

Canard implémente Volant ET Nageant
"""


# ----------------------------------------------------------------------------
# [RAPIDE] MEMBRES STATIQUES ET CONSTANTES
# ----------------------------------------------------------------------------

"""
ATTRIBUTS STATIQUES

[IDEE] DÉFINITION
Attribut partagé par TOUTES les instances de la classe


NOTATION :
Souligné

┌─────────────────────────────┐
│         Compteur            │
├─────────────────────────────┤
│ - total : Integer           │  <- Souligné = statique
│ - valeur : Integer          │  <- Normal
├─────────────────────────────┤
│ + incrementer()             │
│ + getTotal() : Integer      │  <- Souligné = statique
└─────────────────────────────┘


Exemple :
class Compteur {
    private static int total = 0;  // Partagé par toutes les instances
    private int valeur;             // Spécifique à chaque instance
    
    public void incrementer() {
        total++;
        valeur++;
    }
    
    public static int getTotal() {  // Méthode statique
        return total;
    }
}


CONSTANTES

NOTATION :
Souligné + {readOnly}

┌─────────────────────────────┐
│          Cercle             │
├─────────────────────────────┤
│ + PI : Float = 3.14159 {readOnly}│  <- Constante
│ - rayon : Float             │
├─────────────────────────────┤
│ + calculerAire() : Float    │
└─────────────────────────────┘
"""


# ----------------------------------------------------------------------------
# [COURS] EXERCICE PRATIQUE 1 : SYSTÈME DE BIBLIOTHÈQUE
# ----------------------------------------------------------------------------

"""
[DOCS] ÉNONCÉ

Vous devez concevoir le diagramme de classes pour un système de gestion
de bibliothèque.

BESOINS :

1. LIVRES
   - Chaque livre a : titre, auteur, ISBN, année publication, nb pages
   - Un livre peut être disponible ou emprunté
   - Méthodes : afficher(), emprunter(), retourner()

2. MEMBRES (Adhérents)
   - Chaque membre a : nom, prénom, numéro adhérent, date inscription
   - Un membre peut emprunter maximum 5 livres
   - Méthodes : emprunter(livre), retourner(livre), afficherEmprunts()

3. EMPRUNT
   - Enregistre : date emprunt, date retour prévue, date retour réelle
   - Calcule les retards
   - Méthodes : calculerRetard(), estEnRetard()

4. BIBLIOTHÉCAIRE (hérite de Membre)
   - En plus des attributs de Membre : numéro employé, salaire
   - Peut gérer les emprunts
   - Méthodes : enregistrerEmprunt(), enregistrerRetour()

5. CATALOGUE
   - Gère la collection de tous les livres
   - Méthodes : ajouterLivre(), rechercherParTitre(), rechercherParAuteur()


RELATIONS :
- Un Membre peut emprunter plusieurs Livres (0..5)
- Un Livre peut être emprunté par un seul Membre à la fois (0..1)
- Un Emprunt concerne un Livre et un Membre
- Le Catalogue contient tous les Livres
- Bibliothécaire est un type spécial de Membre


[OBJECTIF] TÂCHES :

1. Dessinez le diagramme de classes complet
2. Incluez tous les attributs avec leur type et visibilité
3. Incluez toutes les méthodes avec leurs paramètres
4. Représentez correctement toutes les relations
5. Ajoutez les multiplicités


[IDEE] CONSEILS :
- Réfléchissez au type de chaque relation (association, composition, héritage)
- Une classe Emprunt peut servir de classe d'association
- Le Catalogue utilise composition pour les Livres


─────────────────────────────────────────────────────────────────────────
SOLUTION EXERCICE 1
─────────────────────────────────────────────────────────────────────────


                    ┌─────────────────────────────┐
                    │         Catalogue           │
                    ├─────────────────────────────┤
                    │ - nom : String              │
                    ├─────────────────────────────┤
                    │ + ajouterLivre(l:Livre)     │
                    │ + rechercherParTitre(t:String):List<Livre>│
                    │ + rechercherParAuteur(a:String):List<Livre>│
                    │ + afficherTous()            │
                    └─────────────────────────────┘
                                │
                                │ 1
                                │
                                [BLACK_DIAMOND] (composition)
                                │
                                │ 0..*
                    ┌─────────────────────────────┐
                    │           Livre             │
                    ├─────────────────────────────┤
                    │ - titre : String            │
                    │ - auteur : String           │
                    │ - isbn : String             │
                    │ - anneePublication : Integer│
                    │ - nbPages : Integer         │
                    │ - estDisponible : Boolean   │
                    ├─────────────────────────────┤
                    │ + afficher()                │
                    │ + emprunter() : Boolean     │
                    │ + retourner()               │
                    │ + getDetails() : String     │
                    └─────────────────────────────┘
                                [WHITE_UP-POINTING_TRIANGLE]
                                │
                                │ concerne
                                │ 1
                                │
                    ┌─────────────────────────────┐
                    │          Emprunt            │
                    ├─────────────────────────────┤
                    │ - dateEmprunt : Date        │
                    │ - dateRetourPrevue : Date   │
                    │ - dateRetourReelle : Date   │
                    ├─────────────────────────────┤
                    │ + calculerRetard() : Integer│
                    │ + estEnRetard() : Boolean   │
                    │ + prolonger(jours:Integer)  │
                    │ + cloture()                 │
                    └─────────────────────────────┘
                                │
                                │ effectué par
                                │ 1
                                │
                    ┌─────────────────────────────┐
                    │          Membre             │
                    ├─────────────────────────────┤
                    │ # nom : String              │
                    │ # prenom : String           │
                    │ # numeroAdherent : String   │
                    │ # dateInscription : Date    │
                    │ - empruntsEnCours : List<Emprunt> = []│
                    ├─────────────────────────────┤
                    │ + emprunter(l:Livre):Boolean│
                    │ + retourner(l:Livre)        │
                    │ + afficherEmprunts()        │
                    │ + peutEmprunter():Boolean   │
                    │ + getNbEmprunts():Integer   │
                    └─────────────────────────────┘
                                [WHITE_UP-POINTING_TRIANGLE]
                                │ (héritage)
                                │
                    ┌─────────────────────────────┐
                    │      Bibliothécaire         │
                    ├─────────────────────────────┤
                    │ - numeroEmploye : String    │
                    │ - salaire : Decimal         │
                    ├─────────────────────────────┤
                    │ + enregistrerEmprunt(m:Membre,l:Livre):Emprunt│
                    │ + enregistrerRetour(e:Emprunt)│
                    │ + calculerSalaire():Decimal │
                    └─────────────────────────────┘


RELATIONS DÉTAILLÉES :

1. Catalogue [BLACK_DIAMOND]──(1)──(0..*)── Livre
   COMPOSITION : Les livres appartiennent au catalogue
   Si catalogue supprimé -> livres supprimés

2. Membre ──(1)──(0..5)── Emprunt ──(1)──(1)── Livre
   ASSOCIATION : Un membre peut avoir 0 à 5 emprunts actifs
   Un emprunt concerne 1 livre et 1 membre

3. Bibliothécaire ───[WHITE_RIGHT-POINTING_TRIANGLE] Membre
   HÉRITAGE : Bibliothécaire est un type de Membre
   Hérite de tous les attributs et méthodes


[IDEE] POINTS CLÉS :

[OK] Composition Catalogue-Livre : Les livres n'existent pas sans catalogue
[OK] Emprunt = Classe d'association entre Membre et Livre
[OK] Multiplicité 0..5 sur emprunts (maximum 5 par membre)
[OK] Héritage pour Bibliothécaire (principe DRY)
[OK] Visibilité # (protected) pour attributs de Membre
   -> Accessibles dans Bibliothécaire


CODE JAVA CORRESPONDANT (extrait) :

public class Livre {
    private String titre;
    private String auteur;
    private String isbn;
    private int anneePublication;
    private int nbPages;
    private boolean estDisponible;
    
    public void afficher() {
        System.out.println(titre + " par " + auteur);
    }
    
    public boolean emprunter() {
        if (estDisponible) {
            estDisponible = false;
            return true;
        }
        return false;
    }
    
    public void retourner() {
        estDisponible = true;
    }
}

public class Membre {
    protected String nom;
    protected String prenom;
    protected String numeroAdherent;
    protected Date dateInscription;
    private List<Emprunt> empruntsEnCours = new ArrayList<>();
    
    public boolean emprunter(Livre livre) {
        if (empruntsEnCours.size() >= 5) {
            return false;  // Limite atteinte
        }
        if (livre.emprunter()) {
            Emprunt e = new Emprunt(this, livre);
            empruntsEnCours.add(e);
            return true;
        }
        return false;
    }
}

public class Bibliothécaire extends Membre {
    private String numeroEmploye;
    private BigDecimal salaire;
    
    public Emprunt enregistrerEmprunt(Membre membre, Livre livre) {
        // Logique spécifique du bibliothécaire
        Emprunt emprunt = new Emprunt(membre, livre);
        // Enregistrement en base...
        return emprunt;
    }
}
"""


# ----------------------------------------------------------------------------
# [COURS] EXERCICE PRATIQUE 2 : SYSTÈME BANCAIRE
# ----------------------------------------------------------------------------

"""
[BANQUE] ÉNONCÉ

Concevez le diagramme de classes pour un système bancaire simplifié.

BESOINS :

1. COMPTE BANCAIRE (Classe abstraite)
   - Attributs : numéro compte, solde, date ouverture, titulaire
   - Méthodes abstraites : calculerInterets(), appliquerFrais()
   - Méthodes concrètes : crediter(), debiter(), afficherSolde()

2. COMPTE COURANT (hérite de Compte)
   - Attributs supplémentaires : découvert autorisé, frais mensuels
   - Implémente : calculerInterets() (aucun intérêt)
   - Implémente : appliquerFrais() (frais fixes mensuels)
   - Méthode spécifique : émettreChequier()

3. COMPTE ÉPARGNE (hérite de Compte)
   - Attributs supplémentaires : taux intérêt, nombre retraits autorisés/mois
   - Implémente : calculerInterets() (selon taux)
   - Implémente : appliquerFrais() (pénalité si trop de retraits)

4. CLIENT
   - Attributs : nom, prénom, adresse, téléphone, email
   - Un client peut avoir plusieurs comptes (1..*)
   - Méthodes : afficherComptes(), ouvrirCompte()

5. TRANSACTION
   - Attributs : date, montant, type (débit/crédit), description
   - Chaque transaction concerne un compte
   - Méthodes : annuler(), valider(), afficher()

6. BANQUE
   - Attributs : nom, code, adresse
   - Gère tous les clients et tous les comptes
   - Méthodes : ajouterClient(), rechercherClient(), effectuerVirement()

7. CARTE BANCAIRE (Interface)
   - Méthodes : payer(montant), retirerCash(montant), verifierPIN()
   - Le Compte Courant implémente cette interface

8. VIREMENT
   - Hérite de Transaction
   - Attributs supplémentaires : compte source, compte destination
   - Méthodes : exécuter(), vérifierSoldeSource()


RELATIONS :
- Client possède plusieurs Comptes (composition)
- Compte a plusieurs Transactions (composition)
- Banque gère plusieurs Clients (agrégation)
- Compte Courant implémente Interface Carte Bancaire
- Virement est un type de Transaction
- Compte Courant et Compte Épargne héritent de Compte


[OBJECTIF] TÂCHES :

1. Dessinez le diagramme de classes complet
2. Marquez la classe abstraite Compte
3. Représentez l'interface Carte Bancaire
4. Incluez tous les types de relations
5. Ajoutez multiplicités et visibilités


─────────────────────────────────────────────────────────────────────────
SOLUTION EXERCICE 2
─────────────────────────────────────────────────────────────────────────


                         ┌─────────────────────────────┐
                         │          Banque             │
                         ├─────────────────────────────┤
                         │ - nom : String              │
                         │ - code : String             │
                         │ - adresse : String          │
                         ├─────────────────────────────┤
                         │ + ajouterClient(c:Client)   │
                         │ + rechercherClient(nom:String):Client│
                         │ + effectuerVirement(src:Compte,dest:Compte,m:Decimal)│
                         └─────────────────────────────┘
                                    │
                                    │ gère
                                    [WHITE_DIAMOND] (agrégation)
                                    │
                                    │ 0..*
                         ┌─────────────────────────────┐
                         │          Client             │
                         ├─────────────────────────────┤
                         │ - nom : String              │
                         │ - prenom : String           │
                         │ - adresse : String          │
                         │ - telephone : String        │
                         │ - email : String            │
                         ├─────────────────────────────┤
                         │ + afficherComptes()         │
                         │ + ouvrirCompte(type:String):Compte│
                         │ + getNbComptes():Integer    │
                         └─────────────────────────────┘
                                    │
                                    │ possède
                                    [BLACK_DIAMOND] (composition)
                                    │
                                    │ 1..*
                    ┌────────────────────────────────────┐
                    │       <<abstract>>                 │
                    │        CompteBancaire              │
                    ├────────────────────────────────────┤
                    │ # numeroCompte : String            │
                    │ # solde : Decimal                  │
                    │ # dateOuverture : Date             │
                    │ # titulaire : Client               │
                    ├────────────────────────────────────┤
                    │ + crediter(montant:Decimal)        │
                    │ + debiter(montant:Decimal):Boolean │
                    │ + afficherSolde()                  │
                    │ + calculerInterets():Decimal {abstract}│
                    │ + appliquerFrais() {abstract}      │
                    └────────────────────────────────────┘
                         [WHITE_UP-POINTING_TRIANGLE]                      │
                         │                      │ contient
                         │                      [BLACK_DIAMOND] (composition)
              ┌──────────┴──────────┐           │ 0..*
              │                     │           │
   ┌──────────────────┐  ┌──────────────────┐  │
   │  CompteCourant   │  │  CompteEpargne   │  │
   ├──────────────────┤  ├──────────────────┤  │
   │-decouvertAutorise│  │-tauxInteret:Float│  │
   │-fraisMensuels    │  │-nbRetraitsMax:Int│  │
   │                  │  │-nbRetraits:Int   │  │
   ├──────────────────┤  ├──────────────────┤  │
   │+calculerInterets()│ │+calculerInterets()│ │
   │+appliquerFrais() │  │+appliquerFrais() │  │
   │+émettreChequier()│  │+retirer():Boolean│  │
   └──────────────────┘  └──────────────────┘  │
           [WHITE_UP-POINTING_TRIANGLE]                                    │
           ┆                                    │
           ┆ (réalise)                          │
           ┆                          ┌─────────────────────┐
   ┌────────────────┐                 │    Transaction      │
   │ <<interface>>  │                 ├─────────────────────┤
   │ CarteBancaire  │                 │ # date : Date       │
   ├────────────────┤                 │ # montant : Decimal │
   │+payer(m:Decimal)│                │ # type : String     │
   │+retirerCash(m) │                 │ # description:String│
   │+verifierPIN()  │                 ├─────────────────────┤
   └────────────────┘                 │ + annuler()         │
                                      │ + valider()         │
                                      │ + afficher()        │
                                      └─────────────────────┘
                                               [WHITE_UP-POINTING_TRIANGLE]
                                               │ (héritage)
                                               │
                                      ┌─────────────────────┐
                                      │     Virement        │
                                      ├─────────────────────┤
                                      │ - compteSource      │
                                      │ - compteDestination │
                                      ├─────────────────────┤
                                      │ + exécuter():Boolean│
                                      │ + vérifierSolde():Boolean│
                                      └─────────────────────┘


RELATIONS DÉTAILLÉES :

1. Banque [WHITE_DIAMOND]──(0..*)── Client
   AGRÉGATION : Client peut exister sans la Banque

2. Client [BLACK_DIAMOND]──(1..*)── Compte
   COMPOSITION : Comptes appartiennent au Client
   Client supprimé -> Comptes supprimés
   Multiplicité 1..* : Client doit avoir au moins 1 compte

3. Compte [BLACK_DIAMOND]──(0..*)── Transaction
   COMPOSITION : Transactions appartiennent au Compte

4. CompteCourant ···[WHITE_RIGHT-POINTING_TRIANGLE] CarteBancaire
   RÉALISATION : CompteCourant implémente l'interface

5. CompteCourant ───[WHITE_RIGHT-POINTING_TRIANGLE] CompteBancaire
   CompteEpargne ───[WHITE_RIGHT-POINTING_TRIANGLE] CompteBancaire
   HÉRITAGE : Les deux types héritent de la classe abstraite

6. Virement ───[WHITE_RIGHT-POINTING_TRIANGLE] Transaction
   HÉRITAGE : Virement est un type spécial de Transaction


[IDEE] POINTS CLÉS :

[OK] CompteBancaire est abstraite : ne peut pas être instanciée
[OK] Méthodes abstraites calculerInterets() et appliquerFrais()
   -> Chaque type de compte les implémente différemment
[OK] Interface CarteBancaire : contrat pour les paiements
[OK] Composition Client-Compte : Comptes liés au cycle de vie du Client
[OK] Héritage Transaction->Virement : Réutilisation + Spécialisation


CODE JAVA CORRESPONDANT (extrait) :

public abstract class CompteBancaire {
    protected String numeroCompte;
    protected BigDecimal solde;
    protected Date dateOuverture;
    protected Client titulaire;
    
    public void crediter(BigDecimal montant) {
        solde = solde.add(montant);
        new Transaction(this, montant, "CREDIT").valider();
    }
    
    public boolean debiter(BigDecimal montant) {
        if (solde.compareTo(montant) >= 0) {
            solde = solde.subtract(montant);
            new Transaction(this, montant, "DEBIT").valider();
            return true;
        }
        return false;
    }
    
    public abstract BigDecimal calculerInterets();
    public abstract void appliquerFrais();
}

public class CompteCourant extends CompteBancaire implements CarteBancaire {
    private BigDecimal decouvertAutorise;
    private BigDecimal fraisMensuels;
    
    @Override
    public BigDecimal calculerInterets() {
        return BigDecimal.ZERO;  // Pas d'intérêts
    }
    
    @Override
    public void appliquerFrais() {
        debiter(fraisMensuels);
    }
    
    // Implémentation de l'interface CarteBancaire
    @Override
    public boolean payer(BigDecimal montant) {
        return debiter(montant);
    }
    
    @Override
    public boolean retirerCash(BigDecimal montant) {
        return debiter(montant);
    }
    
    @Override
    public boolean verifierPIN(String pin) {
        // Logique de vérification
        return true;
    }
}

public class CompteEpargne extends CompteBancaire {
    private float tauxInteret;
    private int nbRetraitsMax;
    private int nbRetraits;
    
    @Override
    public BigDecimal calculerInterets() {
        return solde.multiply(new BigDecimal(tauxInteret / 100));
    }
    
    @Override
    public void appliquerFrais() {
        if (nbRetraits > nbRetraitsMax) {
            BigDecimal penalite = new BigDecimal(5.00);
            debiter(penalite.multiply(new BigDecimal(nbRetraits - nbRetraitsMax)));
        }
    }
}

public interface CarteBancaire {
    boolean payer(BigDecimal montant);
    boolean retirerCash(BigDecimal montant);
    boolean verifierPIN(String pin);
}
"""


# ----------------------------------------------------------------------------
# [DOCS] RÉCAPITULATIF CHAPITRE 1 - DIAGRAMME DE CLASSES
# ----------------------------------------------------------------------------

"""
CE QUE VOUS AVEZ APPRIS

[OK] Structure d'une classe UML (3 compartiments)
[OK] Visibilité : + public, - private, # protected, ~ package
[OK] Types de relations :
   - Association (─────)
   - Agrégation ([WHITE_DIAMOND]────)
   - Composition ([BLACK_DIAMOND]────)
   - Héritage (────[WHITE_RIGHT-POINTING_TRIANGLE])
   - Dépendance (- - ->)
   - Réalisation (- - -[WHITE_RIGHT-POINTING_TRIANGLE])
[OK] Multiplicités (0..1, 1, *, 1..*, n..m)
[OK] Classes abstraites et interfaces
[OK] Membres statiques
[OK] 2 exercices pratiques complets


[CLE] POINTS CLÉS

1. Le diagramme de classes est le PLUS IMPORTANT
2. Bien choisir le type de relation (composition vs agrégation !)
3. Classes abstraites = modèles, Interfaces = contrats
4. Multiplicités toujours importantes pour la clarté
5. Visibilité appropriée pour l'encapsulation


[OK] CHECKLIST AVANT DE CONTINUER

Vous devez être capable de :
[ ] Dessiner une classe complète avec ses 3 compartiments
[ ] Utiliser correctement les visibilités +, -, #, ~
[ ] Choisir entre association, agrégation et composition
[ ] Représenter l'héritage et les interfaces
[ ] Ajouter les multiplicités correctement
[ ] Différencier classe abstraite et interface


[COURS] POUR S'ENTRAÎNER DAVANTAGE

Essayez de modéliser :
1. Un système de réservation d'hôtel
2. Un jeu de cartes (poker, bataille, etc.)
3. Un système de gestion d'université (cours, étudiants, profs)
4. Une boutique en ligne (produits, commandes, clients)
5. Un système de gestion de projet (tâches, équipes, ressources)


-> PROCHAINE ÉTAPE : Chapitre 2 - Diagramme d'Objets

Le diagramme d'objets montre des INSTANCES concrètes.
Vous apprendrez :
- Comment représenter des objets réels
- La différence entre classe et instance
- Quand utiliser ce diagramme
- Exemples concrets avec valeurs

Prêt ? Continuez ! [RAPIDE]
"""

# ============================================================================
# FIN DU CHAPITRE 1 - DIAGRAMME DE CLASSES
# Suite dans le prochain fichier : Chapitre 2 - Diagramme d'Objets
# ============================================================================
# ============================================================================
# [LIVRE] UML - PARTIE 1 (SUITE) : DIAGRAMMES D'OBJETS ET COMPOSANTS
# ============================================================================

# ============================================================================
# [GUIDE] CHAPITRE 2 : DIAGRAMME D'OBJETS
# ============================================================================

"""
[OBJECTIF] OBJECTIFS D'APPRENTISSAGE

À la fin de ce chapitre, vous saurez :
[OK] Qu'est-ce qu'un diagramme d'objets et quand l'utiliser
[OK] Différence entre diagramme de classes et diagramme d'objets
[OK] Comment représenter des instances concrètes
[OK] Représenter les liens entre objets
[OK] Afficher les valeurs des attributs
[OK] Créer des snapshots de systèmes
"""


# ----------------------------------------------------------------------------
# [REFLEXION] QU'EST-CE QU'UN DIAGRAMME D'OBJETS ?
# ----------------------------------------------------------------------------

"""
DÉFINITION SIMPLE

Diagramme d'Objets = Photo instantanée (snapshot) du système à un moment donné
                     Montre les INSTANCES CONCRÈTES avec leurs VALEURS


[IDEE] DIFFÉRENCE CLASSE vs OBJET

┌──────────────────────┬──────────────────────────────┐
│ DIAGRAMME DE CLASSES │   DIAGRAMME D'OBJETS         │
├──────────────────────┼──────────────────────────────┤
│ ABSTRACTION          │   INSTANCES CONCRÈTES        │
│ Modèle général       │   Exemples spécifiques       │
│ Plan architectural   │   Photo de la maison finie   │
│ Recette de cuisine   │   Plat cuisiné               │
│ Type (String, int)   │   Valeur ("Alice", 25)       │
│ À TOUT MOMENT        │   À UN INSTANT T             │
└──────────────────────┴──────────────────────────────┘


ANALOGIE [CONSTRUCTION]

DIAGRAMME DE CLASSES = Plan de construction
┌──────────┐
│ Voiture  │
├──────────┤
│-marque   │
│-couleur  │
│-vitesse  │
└──────────┘

DIAGRAMME D'OBJETS = Voitures réelles dans un parking
┌────────────────┐  ┌────────────────┐  ┌────────────────┐
│ voiture1:      │  │ voiture2:      │  │ voiture3:      │
│ Voiture        │  │ Voiture        │  │ Voiture        │
├────────────────┤  ├────────────────┤  ├────────────────┤
│marque = "BMW"  │  │marque = "Audi" │  │marque = "Tesla"│
│couleur = "noir"│  │couleur = "blanc│  │couleur = "rouge│
│vitesse = 0     │  │vitesse = 50    │  │vitesse = 80    │
└────────────────┘  └────────────────┘  └────────────────┘


[REFLEXION] POURQUOI UTILISER ?

[OK] UTILISER POUR :
1. ILLUSTRER EXEMPLES COMPLEXES
   - Montrer configuration concrète
   - Expliquer relations avec valeurs réelles

2. DOCUMENTER ÉTAT DU SYSTÈME
   - À un moment critique
   - État initial/final
   - Cas particuliers

3. VALIDER CONCEPTION
   - Vérifier que le modèle permet les scénarios souhaités
   - Tests de cohérence

4. COMMUNICATION
   - Plus facile à comprendre que classes abstraites
   - Exemples concrets pour clients

5. DEBUGGING/ANALYSE
   - Comprendre bug en visualisant état
   - Analyser comportement


[X] NE PAS UTILISER POUR :
- Documentation générale (classes mieux adaptées)
- Systèmes simples (overhead inutile)
- États changeants rapidement


[REFLEXION] QUAND L'UTILISER ?

PHASE D'ANALYSE :
- Exemples pour clients
- Scénarios d'utilisation

PHASE DE CONCEPTION :
- Valider modèle de classes
- Illustrer patterns complexes

PHASE DE TESTS :
- État attendu vs état réel
- Cas de test visuels

DOCUMENTATION :
- Exemples d'utilisation
- État initial du système
"""


# ----------------------------------------------------------------------------
# [PACKAGE] REPRÉSENTATION D'UN OBJET
# ----------------------------------------------------------------------------

"""
SYNTAXE DE BASE

Un OBJET = RECTANGLE avec :
1. Nom de l'objet : Nom de la classe (souligné)
2. Valeurs des attributs


NOTATION :

┌─────────────────────────────┐
│  nomObjet : NomClasse       │  <- Souligné
├─────────────────────────────┤
│  attribut1 = valeur1        │  <- Valeurs concrètes
│  attribut2 = valeur2        │
└─────────────────────────────┘


[IDEE] RÈGLES DE NOMMAGE

Format : nomObjet : NomClasse

Exemples valides :
- alice : Personne
- voiture1 : Voiture
- compte123 : CompteBancaire
- : Personne  (objet anonyme, sans nom)


EXEMPLES DÉTAILLÉS

Exemple 1 : Personne
┌─────────────────────────────┐
│  alice : Personne           │
├─────────────────────────────┤
│  nom = "Dupont"             │
│  prenom = "Alice"           │
│  age = 30                   │
│  email = "alice@mail.com"   │
└─────────────────────────────┘


Exemple 2 : Compte Bancaire
┌─────────────────────────────┐
│  compte123 : CompteCourant  │
├─────────────────────────────┤
│  numeroCompte = "FR123456"  │
│  solde = 1500.50            │
│  decouvert = 500.00         │
│  dateOuverture = 2024-01-15 │
└─────────────────────────────┘


Exemple 3 : Objet anonyme
┌─────────────────────────────┐
│  : Adresse                  │
├─────────────────────────────┤
│  rue = "5 rue de Paris"     │
│  ville = "Lyon"             │
│  codePostal = "69000"       │
└─────────────────────────────┘


[IDEE] NIVEAUX DE DÉTAIL

NIVEAU 1 : Nom seulement
┌──────────────┐
│alice:Personne│
└──────────────┘

NIVEAU 2 : Quelques attributs clés
┌──────────────────┐
│alice : Personne  │
├──────────────────┤
│nom = "Dupont"    │
│age = 30          │
└──────────────────┘

NIVEAU 3 : Tous les attributs
┌──────────────────────────┐
│alice : Personne          │
├──────────────────────────┤
│nom = "Dupont"            │
│prenom = "Alice"          │
│age = 30                  │
│email = "alice@mail.com"  │
│adresse = @adresse1       │ <- Référence à autre objet
└──────────────────────────┘


[IDEE] TYPES DE VALEURS

String : "texte entre guillemets"
Integer : 42, -10, 0
Float : 3.14, -0.5, 1500.50
Boolean : true, false
Date : 2024-01-15
Null : null ou ⊥
Référence : @nomObjet ou -> nomObjet


VISIBILITÉ

On peut montrer la visibilité (comme classes) :
┌──────────────────────────┐
│alice : Personne          │
├──────────────────────────┤
│+ nom = "Dupont"          │  <- public
│- age = 30                │  <- private
│# email = "alice@mail.com"│  <- protected
└──────────────────────────┘

Mais généralement omise (pour clarté)
"""


# ----------------------------------------------------------------------------
# [LIEN] LIENS ENTRE OBJETS
# ----------------------------------------------------------------------------

"""
REPRÉSENTATION DES LIENS

Lien = Instance d'une association entre classes


NOTATION :
────────  (ligne pleine, sans flèche)


CLASSE :
┌──────────┐           ┌──────────┐
│ Personne │───────────│ Voiture  │
└──────────┘  possède  └──────────┘

OBJETS :
┌──────────────┐           ┌──────────────┐
│alice:Personne│───────────│v1 : Voiture  │
└──────────────┘           └──────────────┘


AVEC RÔLES :

┌──────────────┐ propriétaire    ┌──────────────┐
│alice:Personne│─────────────────│v1 : Voiture  │
└──────────────┘                 └──────────────┘


EXEMPLE COMPLET

Classes :
┌──────────┐      1    0..*   ┌──────────┐
│ Personne │[WHITE_DIAMOND]──────────────────│ Voiture  │
└──────────┘                   └──────────┘

Objets (snapshot à l'instant T) :
┌────────────────┐           ┌────────────────┐
│alice : Personne│[WHITE_DIAMOND]──────────│v1 : Voiture    │
├────────────────┤           ├────────────────┤
│nom = "Dupont"  │           │marque = "BMW"  │
│age = 30        │           │couleur = "noir"│
└────────────────┘           └────────────────┘
        │
        │[WHITE_DIAMOND]
        │
┌────────────────┐
│v2 : Voiture    │
├────────────────┤
│marque = "Audi" │
│couleur = "blanc│
└────────────────┘

Alice possède 2 voitures : v1 et v2


COMPOSITION (losange plein)

Classes :
┌──────────┐      1    1..*   ┌──────────┐
│  Maison  │[BLACK_DIAMOND]──────────────────│   Pièce  │
└──────────┘                   └──────────┘

Objets :
┌────────────────────┐
│maison1 : Maison    │
├────────────────────┤
│adresse = "5 rue X" │
└────────────────────┘
         │
         │[BLACK_DIAMOND]
    ┌────┴────────┐
    │             │
┌─────────┐  ┌─────────┐  ┌─────────┐
│p1:Pièce │  │p2:Pièce │  │p3:Pièce │
├─────────┤  ├─────────┤  ├─────────┤
│nom="Salon"│ │nom="Cuisine"│ │nom="Chambre"│
│surface=20│  │surface=15│  │surface=12│
└─────────┘  └─────────┘  └─────────┘


HÉRITAGE (pas dans diagramme d'objets)

[ATTENTION] On ne montre PAS l'héritage dans diagramme d'objets
Car les objets sont instances de classes concrètes

Classes :
      ┌──────────┐
      │  Animal  │
      └──────────┘
            [WHITE_UP-POINTING_TRIANGLE]
            │
      ┌──────────┐
      │   Chat   │
      └──────────┘

Objets :
┌─────────────┐
│felix : Chat │  <- Instance de Chat (pas d'Animal)
├─────────────┤
│nom = "Felix"│
└─────────────┘


RÉFÉRENCES ENTRE OBJETS

Attribut référençant un autre objet :

┌──────────────────────┐           ┌──────────────────┐
│alice : Personne      │           │adr1 : Adresse    │
├──────────────────────┤           ├──────────────────┤
│nom = "Dupont"        │───────────│rue = "5 rue X"   │
│adresse = @adr1       │  vit à    │ville = "Lyon"    │
└──────────────────────┘           └──────────────────┘

Ou notation alternative :
┌──────────────────────┐
│alice : Personne      │
├──────────────────────┤
│nom = "Dupont"        │
│adresse = ──────────->┌──────────────────┐
└──────────────────────┘                │adr1 : Adresse    │
                                        ├──────────────────┤
                                        │rue = "5 rue X"   │
                                        └──────────────────┘


COLLECTIONS

Attribut contenant plusieurs objets :

┌──────────────────────────┐
│prof1 : Professeur        │
├──────────────────────────┤
│nom = "Martin"            │
│cours = {c1, c2, c3}      │ <- Liste de références
└──────────────────────────┘
           │
           │
    ┌──────┴─────────┬────────┐
    │                │        │
┌─────────┐    ┌─────────┐  ┌─────────┐
│c1:Cours │    │c2:Cours │  │c3:Cours │
├─────────┤    ├─────────┤  ├─────────┤
│nom="Math"│   │nom="Info"│ │nom="Physique"│
└─────────┘    └─────────┘  └─────────┘
"""


# ----------------------------------------------------------------------------
# [GRAPHIQUE] DIAGRAMME D'OBJETS COMPLET
# ----------------------------------------------------------------------------

"""
EXEMPLE COMPLET : SYSTÈME UNIVERSITAIRE

Classes :
┌──────────┐      enseigne    ┌──────────┐    suit      ┌──────────┐
│Professeur│[WHITE_DIAMOND]─────────────────│  Cours   │[WHITE_DIAMOND]─────────────│ Étudiant │
└──────────┘       1    0..*  └──────────┘  0..*    *   └──────────┘


Objets (snapshot au 15/01/2024) :

┌─────────────────────────┐
│prof1 : Professeur       │
├─────────────────────────┤
│nom = "Dupont"           │
│prenom = "Marie"         │
│specialite = "Math"      │
└─────────────────────────┘
            │
            │ enseigne
            │
    ┌───────┴────────┬──────────┐
    │                │          │
┌─────────────┐  ┌─────────────┐  ┌─────────────┐
│c1 : Cours   │  │c2 : Cours   │  │c3 : Cours   │
├─────────────┤  ├─────────────┤  ├─────────────┤
│code="MATH101"│ │code="MATH201"│ │code="STAT101"│
│nom="Algèbre"│  │nom="Analyse"│  │nom="Statistiques"│
│credits = 6  │  │credits = 6  │  │credits = 4  │
└─────────────┘  └─────────────┘  └─────────────┘
     │               │                  │
     │ suit          │ suit             │ suit
     │               │                  │
   ┌─┴───┐       ┌───┴─┐            ┌──┴──┐
   │     │       │     │            │     │
┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐
│e1:Étudiant││e2:Étudiant││e3:Étudiant││e4:Étudiant│
├────────┤ ├────────┤ ├────────┤ ├────────┤
│nom="Martin"││nom="Leroy"││nom="Bernard"││nom="Petit"│
│matricule="S1"││matricule="S2"││matricule="S3"││matricule="S4"│
└────────┘ └────────┘ └────────┘ └────────┘


[IDEE] INTERPRÉTATION :

- prof1 enseigne 3 cours : c1, c2, c3
- c1 (Algèbre) est suivi par e1 et e2
- c2 (Analyse) est suivi par e2 et e3
- c3 (Statistiques) est suivi par e1, e3 et e4
- e1 suit c1 et c3
- e2 suit c1 et c2
- e3 suit c2 et c3
- e4 suit seulement c3


VALEUR DU DIAGRAMME :
[OK] Montre exemple concret de configuration
[OK] Vérifie que multiplicités sont respectées
[OK] Facilite compréhension pour non-techniques
"""


# ----------------------------------------------------------------------------
# [COURS] EXERCICE PRATIQUE 1 : RÉSEAU SOCIAL
# ----------------------------------------------------------------------------

"""
[MOBILE] ÉNONCÉ

Modélisez un diagramme d'objets représentant un snapshot d'un réseau social
à un instant donné.

DIAGRAMME DE CLASSES DONNÉ :

┌──────────┐    suit      ┌──────────┐  publie    ┌──────────┐
│Utilisateur│[WHITE_DIAMOND]──────────────│Utilisateur│[WHITE_DIAMOND]───────────│   Post   │
└──────────┘    0..*   *  └──────────┘   1   0..*  └──────────┘
                                               │
                                               │ commente
                                               │ 0..*
                                          ┌──────────┐
                                          │Commentaire│
                                          └──────────┘


SITUATION À MODÉLISER (15 janvier 2024, 14h30) :

UTILISATEURS :
- Alice (id: U001, email: alice@mail.com)
  -> Suit : Bob, Charlie
  
- Bob (id: U002, email: bob@mail.com)
  -> Suit : Alice, Charlie, David
  
- Charlie (id: U003, email: charlie@mail.com)
  -> Suit : Alice

- David (id: U004, email: david@mail.com)
  -> Suit : Bob


POSTS :
- Post1 par Alice : "Bonjour tout le monde !" (10 likes)
  -> Commentaires : 
     - C1 par Bob : "Salut Alice !"
     - C2 par Charlie : "Hello !"

- Post2 par Bob : "Belle journée !" (5 likes)
  -> Commentaires :
     - C3 par Alice : "Absolument !"

- Post3 par Charlie : "Nouveau projet en cours" (15 likes)
  -> Pas de commentaires


[OBJECTIF] TÂCHES :

1. Dessinez le diagramme d'objets complet
2. Incluez tous les utilisateurs avec leurs attributs
3. Incluez tous les posts avec leurs valeurs
4. Montrez tous les liens (suit, publie, commente)
5. Ajoutez les commentaires avec leurs auteurs


─────────────────────────────────────────────────────────────────────────
SOLUTION EXERCICE 1
─────────────────────────────────────────────────────────────────────────


DIAGRAMME D'OBJETS - RÉSEAU SOCIAL (Snapshot 15/01/2024 14h30)


┌──────────────────────┐
│alice : Utilisateur   │
├──────────────────────┤
│id = "U001"           │
│nom = "Alice"         │
│email="alice@mail.com"│
└──────────────────────┘
   │        │
   │ suit   │ suit
   │        │
   │    ┌───┴───────────┐
   │    │               │
   │    [BLACK_DOWN-POINTING_TRIANGLE]               [BLACK_DOWN-POINTING_TRIANGLE]
   │  ┌──────────────────────┐  ┌──────────────────────┐
   │  │bob : Utilisateur     │  │charlie : Utilisateur │
   │  ├──────────────────────┤  ├──────────────────────┤
   │  │id = "U002"           │  │id = "U003"           │
   │  │nom = "Bob"           │  │nom = "Charlie"       │
   │  │email="bob@mail.com"  │  │email="charlie@mail.com"│
   │  └──────────────────────┘  └──────────────────────┘
   │         │     │                    │      │
   │         │suit │suit                │ suit │
   │         │     │                    │      │
   │         [BLACK_DOWN-POINTING_TRIANGLE]     │                    [BLACK_DOWN-POINTING_TRIANGLE]      │
   │         ┌─────┘              ┌─────┘      │
   │         │                    │            │
   │         │                    │            │
   │  ┌──────────────────────┐   │            │
   │  │david : Utilisateur   │   │            │
   │  ├──────────────────────┤   │            │
   │  │id = "U004"           │   │            │
   │  │nom = "David"         │   │            │
   │  │email="david@mail.com"│   │            │
   │  └──────────────────────┘   │            │
   │                              │            │
   │ publie                       │ publie     │ publie
   │                              │            │
   [BLACK_DOWN-POINTING_TRIANGLE]                              [BLACK_DOWN-POINTING_TRIANGLE]            [BLACK_DOWN-POINTING_TRIANGLE]
┌─────────────────┐    ┌─────────────────┐  ┌─────────────────┐
│post1 : Post     │    │post2 : Post     │  │post3 : Post     │
├─────────────────┤    ├─────────────────┤  ├─────────────────┤
│id = "P001"      │    │id = "P002"      │  │id = "P003"      │
│contenu="Bonjour │    │contenu="Belle   │  │contenu="Nouveau │
│ tout le monde !"│    │ journée !"      │  │ projet en cours"│
│date=15/01/2024  │    │date=15/01/2024  │  │date=15/01/2024  │
│nbLikes = 10     │    │nbLikes = 5      │  │nbLikes = 15     │
└─────────────────┘    └─────────────────┘  └─────────────────┘
   │         │              │
   │ a       │ a            │ a
   [BLACK_DOWN-POINTING_TRIANGLE]         [BLACK_DOWN-POINTING_TRIANGLE]              [BLACK_DOWN-POINTING_TRIANGLE]
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│c1:Commentaire│ │c2:Commentaire│ │c3:Commentaire│
├──────────────┤ ├──────────────┤ ├──────────────┤
│texte="Salut  │ │texte="Hello !"│ │texte="Absolument!"│
│ Alice !"     │ │date=15/01/2024│ │date=15/01/2024│
│date=15/01/2024│ │heure="14:15"│ │heure="14:25" │
│heure="14:10" │ └──────────────┘ └──────────────┘
└──────────────┘        │                │
      │                 │                │
      │ écrit par       │ écrit par      │ écrit par
      │                 │                │
      [BLACK_DOWN-POINTING_TRIANGLE]                 [BLACK_DOWN-POINTING_TRIANGLE]                [BLACK_DOWN-POINTING_TRIANGLE]
    (lien vers bob)  (lien vers charlie) (lien vers alice)


RELATIONS DE "SUIT" :

alice suit -> bob, charlie
bob suit -> alice, charlie, david
charlie suit -> alice
david suit -> bob


PUBLICATIONS :

alice a publié -> post1
bob a publié -> post2
charlie a publié -> post3


COMMENTAIRES :

post1 a les commentaires -> c1 (par bob), c2 (par charlie)
post2 a le commentaire -> c3 (par alice)
post3 n'a pas de commentaires


[IDEE] POINTS CLÉS :

[OK] Chaque objet a des valeurs concrètes
[OK] Relations "suit" sont des liens simples entre utilisateurs
[OK] Relations "publie" sont des compositions (post appartient à utilisateur)
[OK] Commentaires liés à la fois au post et à l'auteur
[OK] Le diagramme montre l'état exact à un instant T


[RECHERCHE] VÉRIFICATIONS :

Multiplicités respectées ?
- alice suit 2 utilisateurs (0..* [OK])
- bob suit 3 utilisateurs (0..* [OK])
- post1 a 2 commentaires (0..* [OK])
- c1 écrit par 1 utilisateur (1 [OK])

Structure cohérente ?
- Tous les commentaires ont un auteur [OK]
- Tous les posts ont un auteur [OK]
- Pas de cycles problématiques [OK]
"""


# ----------------------------------------------------------------------------
# [COURS] EXERCICE PRATIQUE 2 : SYSTÈME DE COMMANDE E-COMMERCE
# ----------------------------------------------------------------------------

"""
[SHOPPING_TROLLEY] ÉNONCÉ

Créez un diagramme d'objets pour un système de commande e-commerce.

DIAGRAMME DE CLASSES DONNÉ :

┌──────────┐  passe   ┌──────────┐  contient  ┌─────────────┐
│  Client  │[WHITE_DIAMOND]─────────│ Commande │[BLACK_DIAMOND]────────────│LigneCommande│
└──────────┘  1  0..* └──────────┘  1   1..*  └─────────────┘
                            │                        │
                            │ livré à                │ concerne
                            │ 1                      │ 1
                            [BLACK_DOWN-POINTING_TRIANGLE]                        [BLACK_DOWN-POINTING_TRIANGLE]
                      ┌──────────┐            ┌──────────┐
                      │ Adresse  │            │ Produit  │
                      └──────────┘            └──────────┘


SITUATION À MODÉLISER (20 janvier 2024) :

CLIENT :
- Marie Dubois (ID: C001, email: marie@mail.com)

ADRESSE DE LIVRAISON :
- 10 Avenue des Champs, Paris 75008

COMMANDE :
- Numéro : CMD001
- Date : 20/01/2024
- Statut : "En préparation"
- Total : 89.97€

LIGNES DE COMMANDE :
1. 2x Livre "UML pour débutants" à 19.99€ (sous-total: 39.98€)
2. 1x Cahier A4 à 4.99€ (sous-total: 4.99€)
3. 3x Stylo à 15.00€ (sous-total: 45.00€)

PRODUITS :
- P001 : Livre "UML pour débutants" (prix: 19.99€, stock: 48)
- P002 : Cahier A4 (prix: 4.99€, stock: 200)
- P003 : Stylo (prix: 15.00€, stock: 97)


[OBJECTIF] TÂCHES :

1. Dessinez le diagramme d'objets complet
2. Montrez le client, la commande, l'adresse
3. Incluez les 3 lignes de commande avec calculs
4. Montrez les produits référencés
5. Vérifiez que le total correspond à la somme des sous-totaux


─────────────────────────────────────────────────────────────────────────
SOLUTION EXERCICE 2
─────────────────────────────────────────────────────────────────────────


DIAGRAMME D'OBJETS - E-COMMERCE (Snapshot 20/01/2024)


┌──────────────────────────┐
│marie : Client            │
├──────────────────────────┤
│id = "C001"               │
│nom = "Dubois"            │
│prenom = "Marie"          │
│email = "marie@mail.com"  │
└──────────────────────────┘
            │
            │ passe
            │
            [WHITE_DIAMOND]
            │
┌──────────────────────────┐
│cmd001 : Commande         │
├──────────────────────────┤
│numero = "CMD001"         │
│date = 20/01/2024         │
│statut = "En préparation" │
│total = 89.97             │
└──────────────────────────┘
       │                │
       │ livré à        │ contient
       │                │
       │                [BLACK_DIAMOND]
       [BLACK_DOWN-POINTING_TRIANGLE]                │
┌──────────────────────┐  │
│adr1 : Adresse        │  │
├──────────────────────┤  │
│rue = "10 Avenue des  │  │
│      Champs"         │  │
│ville = "Paris"       │  │
│codePostal = "75008"  │  │
└──────────────────────┘  │
                          │
           ┌──────────────┼──────────────┐
           │              │              │
           [BLACK_DOWN-POINTING_TRIANGLE]              [BLACK_DOWN-POINTING_TRIANGLE]              [BLACK_DOWN-POINTING_TRIANGLE]
┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐
│lc1:LigneCommande │ │lc2:LigneCommande │ │lc3:LigneCommande │
├──────────────────┤ ├──────────────────┤ ├──────────────────┤
│quantite = 2      │ │quantite = 1      │ │quantite = 3      │
│prixUnitaire=19.99│ │prixUnitaire=4.99 │ │prixUnitaire=15.00│
│sousTotal = 39.98 │ │sousTotal = 4.99  │ │sousTotal = 45.00 │
└──────────────────┘ └──────────────────┘ └──────────────────┘
        │                   │                   │
        │ concerne          │ concerne          │ concerne
        │                   │                   │
        [BLACK_DOWN-POINTING_TRIANGLE]                   [BLACK_DOWN-POINTING_TRIANGLE]                   [BLACK_DOWN-POINTING_TRIANGLE]
┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐
│p001 : Produit    │ │p002 : Produit    │ │p003 : Produit    │
├──────────────────┤ ├──────────────────┤ ├──────────────────┤
│code = "P001"     │ │code = "P002"     │ │code = "P003"     │
│nom = "Livre UML  │ │nom = "Cahier A4" │ │nom = "Stylo"     │
│  pour débutants" │ │prix = 4.99       │ │prix = 15.00      │
│prix = 19.99      │ │stock = 200       │ │stock = 97        │
│stock = 48        │ └──────────────────┘ └──────────────────┘
└──────────────────┘


CALCULS VÉRIFIÉS :

lc1 : 2 × 19.99€ = 39.98€ [OK]
lc2 : 1 × 4.99€  = 4.99€  [OK]
lc3 : 3 × 15.00€ = 45.00€ [OK]
                  ─────────
TOTAL :            89.97€ [OK]


[IDEE] POINTS CLÉS :

[OK] Composition Commande[BLACK_DIAMOND]->LigneCommande :
   - LigneCommande n'existe pas sans Commande
   - Si commande supprimée -> lignes supprimées

[OK] Association LigneCommande->Produit :
   - Produit existe indépendamment
   - Plusieurs lignes peuvent référencer même produit

[OK] Agrégation Client[WHITE_DIAMOND]->Commande :
   - Commande pourrait survivre sans client (archives)
   - Relation plus faible

[OK] Valeurs calculées cohérentes :
   - Sous-totaux = quantité × prix unitaire
   - Total commande = somme des sous-totaux


[RECHERCHE] UTILITÉ DU DIAGRAMME :

Ce diagramme permet de :
1. Valider le modèle de classes avec exemple concret
2. Vérifier les calculs de prix
3. Montrer état typique d'une commande
4. Servir de cas de test
5. Documenter structure de données


CODE SQL CORRESPONDANT :

-- Table Client
INSERT INTO Client VALUES ('C001', 'Dubois', 'Marie', 'marie@mail.com');

-- Table Adresse
INSERT INTO Adresse VALUES (1, '10 Avenue des Champs', 'Paris', '75008');

-- Table Commande
INSERT INTO Commande VALUES ('CMD001', 'C001', '2024-01-20', 'En préparation', 89.97, 1);

-- Table Produit
INSERT INTO Produit VALUES ('P001', 'Livre UML pour débutants', 19.99, 48);
INSERT INTO Produit VALUES ('P002', 'Cahier A4', 4.99, 200);
INSERT INTO Produit VALUES ('P003', 'Stylo', 15.00, 97);

-- Table LigneCommande
INSERT INTO LigneCommande VALUES (1, 'CMD001', 'P001', 2, 19.99, 39.98);
INSERT INTO LigneCommande VALUES (2, 'CMD001', 'P002', 1, 4.99, 4.99);
INSERT INTO LigneCommande VALUES (3, 'CMD001', 'P003', 3, 15.00, 45.00);
"""


# ----------------------------------------------------------------------------
# [DOCS] RÉCAPITULATIF CHAPITRE 2 - DIAGRAMME D'OBJETS
# ----------------------------------------------------------------------------

"""
CE QUE VOUS AVEZ APPRIS

[OK] Diagramme d'objets = Snapshot d'instances à un instant T
[OK] Notation : nomObjet : NomClasse (souligné)
[OK] Afficher valeurs concrètes des attributs
[OK] Liens entre objets (instances d'associations)
[OK] Différence classe (abstraction) vs objet (concret)
[OK] Quand utiliser : exemples, validation, documentation
[OK] 2 exercices pratiques complets (réseau social, e-commerce)


[CLE] POINTS CLÉS

1. Objets = Instances CONCRÈTES avec VALEURS RÉELLES
2. Un diagramme d'objets illustre un diagramme de classes
3. Toujours souligner le nom des objets
4. Utile pour valider conception avec exemples
5. Complément du diagramme de classes (pas remplacement)


[OBJECTIF] DIFFÉRENCES CLASSE vs OBJET

┌──────────────────────┬──────────────────────┐
│ CLASSE               │ OBJET                │
├──────────────────────┼──────────────────────┤
│ Abstraction          │ Instance             │
│ Type                 │ Valeur               │
│ Modèle               │ Exemple              │
│ Intemporel           │ À un instant T       │
│ Relations            │ Liens                │
│ Multiplicités        │ Quantités exactes    │
└──────────────────────┴──────────────────────┘


[OK] CHECKLIST AVANT DE CONTINUER

Vous devez être capable de :
[ ] Distinguer diagramme de classes et diagramme d'objets
[ ] Représenter un objet avec ses valeurs
[ ] Montrer les liens entre objets
[ ] Créer un snapshot cohérent d'un système
[ ] Valider un modèle de classes avec des objets
[ ] Vérifier que multiplicités sont respectées


[COURS] POUR S'ENTRAÎNER DAVANTAGE

Créez des diagrammes d'objets pour :
1. Une partie d'échecs en cours (plateau, pièces, joueurs)
2. Un système de réservation de vol (passagers, vols, sièges)
3. Une bibliothèque (livres empruntés par membres)
4. Un jeu de rôle (personnages, inventaires, quêtes)


-> PROCHAINE ÉTAPE : Chapitre 3 - Diagramme de Composants

Le diagramme de composants montre l'ARCHITECTURE LOGICIELLE.
Vous apprendrez :
- Qu'est-ce qu'un composant
- Interfaces fournies et requises
- Dépendances entre composants
- Organisation en couches
- Architecture logicielle

Prêt pour l'architecture ? C'est parti ! [RAPIDE]
"""

# ============================================================================
# FIN DU CHAPITRE 2 - DIAGRAMME D'OBJETS
# Suite dans le prochain fichier : Chapitre 3 - Diagramme de Composants
# ============================================================================
# ============================================================================
# [LIVRE] UML - CHAPITRE 3 (SUITE ET FIN) : DIAGRAMME DE COMPOSANTS
# ============================================================================


# ----------------------------------------------------------------------------
# [PLUGIN] INTERFACES DE COMPOSANTS
# ----------------------------------------------------------------------------

"""
TYPES D'INTERFACES

Un composant communique via des INTERFACES :
1. Interface FOURNIE (Provided) -> Ce que le composant offre
2. Interface REQUISE (Required) -> Ce dont le composant a besoin


NOTATION "LOLLIPOP" ET "SOCKET"

INTERFACE FOURNIE (lollipop = sucette) :
┌─────────────────┐
│  ┌───┐          │
│  │   │ Service  │────[WHITE_CIRCLE] IService
│  └───┘          │
└─────────────────┘
    Le composant FOURNIT l'interface IService


INTERFACE REQUISE (socket = prise) :
┌─────────────────┐
│  ┌───┐          │  IDatabase
│  │   │ Service  │[BLACK_LEFT-POINTING_POINTER]────[WHITE_LEFT-POINTING_TRIANGLE]
│  └───┘          │
└─────────────────┘
    Le composant REQUIERT l'interface IDatabase


COMPOSANT COMPLET (fournit ET requiert) :
                ILogger
                   [WHITE_CIRCLE]
                   │
┌──────────────────┼────────┐
│  ┌───┐           │        │
│  │   │ UserService        │────[WHITE_CIRCLE] IUserService
│  └───┘                    │
└───────────────────────────┘
                    [WHITE_LEFT-POINTING_TRIANGLE]────
                  IDatabase


CONNEXION ENTRE COMPOSANTS

Lollipop (fourni) se connecte à Socket (requis) :

┌──────────────┐              ┌──────────────┐
│  ┌───┐       │  IPayment    │  ┌───┐       │
│  │   │Payment│────[WHITE_CIRCLE]───────[WHITE_LEFT-POINTING_TRIANGLE]─│  │   │ Order │
│  └───┘       │              │  └───┘       │
└──────────────┘              └──────────────┘

Order REQUIERT IPayment
Payment FOURNIT IPayment
-> Connexion compatible !


NOTATION ALTERNATIVE : RECTANGLE POUR INTERFACE
           ┌─────────────┐
           │<<interface>>│
           │  IService   │
           └─────────────┘
                 [WHITE_UP-POINTING_TRIANGLE]    │
    réalise      │    │ utilise
                 │    [WHITE_DOWN-POINTING_TRIANGLE]
           ┌───────────────┐      ┌──────────────┐
           │  ┌───┐        │      │  ┌───┐       │
           │  │   │Service │      │  │   │Client │
           │  └───┘        │      │  └───┘       │
           └───────────────┘      └──────────────┘


PORTS (Points de connexion)

Pour systèmes complexes :
┌─────────────────────────┐
│  ┌───┐                  │
│  │   │ ComplexService   │
│  └───┘                  │
│                         │
│  [WHITE_SQUARE]───────[WHITE_CIRCLE] HTTP API     │  Port avec interface fournie
│                         │
│  [WHITE_LEFT-POINTING_TRIANGLE]───────[WHITE_SQUARE] Database     │  Port avec interface requise
│                         │
└─────────────────────────┘
"""


# ----------------------------------------------------------------------------
# [LIEN] DÉPENDANCES ENTRE COMPOSANTS
# ----------------------------------------------------------------------------

"""
TYPES DE RELATIONS

1. DÉPENDANCE (- - - ->)
   Un composant UTILISE un autre

2. RÉALISATION (- - - [WHITE_RIGHT-POINTING_TRIANGLE])
   Un composant IMPLÉMENTE une interface

3. COMPOSITION ([BLACK_DIAMOND]────)
   Un composant CONTIENT d'autres composants


DÉPENDANCE

┌──────────────┐
│  ┌───┐       │
│  │   │WebApp │────────>┌──────────────┐
│  └───┘       │         │  ┌───┐       │
└──────────────┘         │  │   │AuthAPI│
                         │  └───┘       │
                         └──────────────┘
WebApp dépend de AuthAPI (l'utilise)


RÉALISATION

    ┌─────────────┐
    │<<interface>>│
    │  ILogger    │
    └─────────────┘
          [WHITE_UP-POINTING_TRIANGLE]
          │
          │ réalise
    ┌──────────────┐
    │  ┌───┐       │
    │  │   │FileLogger│
    │  └───┘       │
    └──────────────┘


COMPOSITION (Composant conteneur)

┌───────────────────────────────────────┐
│  ┌───┐                                │
│  │   │ ApplicationServer              │
│  └───┘                                │
│                                       │
│  [BLACK_DIAMOND]                                    │
│  ├───> ┌──────────────┐              │
│  │     │  ┌───┐       │              │
│  │     │  │   │WebUI  │              │
│  │     │  └───┘       │              │
│  │     └──────────────┘              │
│  │                                    │
│  ├───> ┌──────────────┐              │
│  │     │  ┌───┐       │              │
│  │     │  │   │API    │              │
│  │     │  └───┘       │              │
│  │     └──────────────┘              │
│  │                                    │
│  └───> ┌──────────────┐              │
│        │  ┌───┐       │              │
│        │  │   │Database│              │
│        │  └───┘       │              │
│        └──────────────┘              │
└───────────────────────────────────────┘


EXEMPLE COMPLET : Architecture 3-tiers

┌──────────────┐
│  ┌───┐       │ IPresentation
│  │   │WebUI  │────[WHITE_CIRCLE]─────────────────────[WHITE_LEFT-POINTING_TRIANGLE]┌──────────────┐
│  └───┘       │                           ││  ┌───┐       │ IBusiness
└──────────────┘                           ││  │   │BusinessLogic│────[WHITE_CIRCLE]──────[WHITE_LEFT-POINTING_TRIANGLE]┌──────────────┐
                                           ││  └───┘       │               ││  ┌───┐       │
                                           │└──────────────┘               ││  │   │Data   │
                                           │                               │└──────────────┘
                                           └───────────────────────────────┘

Flèches de dépendances :
WebUI ──────> BusinessLogic ──────> Data
"""


# ----------------------------------------------------------------------------
# [OBJECTIF] ORGANISATION EN COUCHES
# ----------------------------------------------------------------------------

"""
ARCHITECTURE EN COUCHES

Les composants sont souvent organisés en COUCHES (layers)


EXEMPLE : Application Web 3-tiers

┌─────────────────────────────────────────────────┐
│           COUCHE PRÉSENTATION                   │
├─────────────────────────────────────────────────┤
│  ┌──────────┐  ┌──────────┐  ┌──────────┐     │
│  │  ┌───┐   │  │  ┌───┐   │  │  ┌───┐   │     │
│  │  │   │Web│  │  │   │API│  │  │   │Mobile│  │
│  │  └───┘   │  │  └───┘   │  │  └───┘   │     │
│  └──────────┘  └──────────┘  └──────────┘     │
└─────────────────────────────────────────────────┘
              │
              [BLACK_DOWN-POINTING_TRIANGLE]
┌─────────────────────────────────────────────────┐
│           COUCHE MÉTIER (BUSINESS)              │
├─────────────────────────────────────────────────┤
│  ┌──────────┐  ┌──────────┐  ┌──────────┐     │
│  │  ┌───┐   │  │  ┌───┐   │  │  ┌───┐   │     │
│  │  │   │User│ │  │   │Order│ │  │   │Payment│ │
│  │  └───┘   │  │  └───┘   │  │  └───┘   │     │
│  └──────────┘  └──────────┘  └──────────┘     │
└─────────────────────────────────────────────────┘
              │
              [BLACK_DOWN-POINTING_TRIANGLE]
┌─────────────────────────────────────────────────┐
│           COUCHE DONNÉES (DATA)                 │
├─────────────────────────────────────────────────┤
│  ┌──────────┐  ┌──────────┐  ┌──────────┐     │
│  │  ┌───┐   │  │  ┌───┐   │  │  ┌───┐   │     │
│  │  │   │ORM│  │  │   │Cache│ │  │   │FileStorage│
│  │  └───┘   │  │  └───┘   │  │  └───┘   │     │
│  └──────────┘  └──────────┘  └──────────┘     │
└─────────────────────────────────────────────────┘


RÈGLES D'ARCHITECTURE EN COUCHES :

[OK] Une couche ne dépend que de la couche INFÉRIEURE
[OK] Pas de dépendance vers le haut
[OK] Pas de saut de couches (A->C sans passer par B)

Exemple CORRECT :
   Présentation -> Métier -> Données

Exemple INCORRECT :
   Présentation -> Données (saute Métier) [X]
   Données -> Métier (remonte) [X]


ARCHITECTURE MICROSERVICES

Chaque service = composant autonome

┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│  ┌───┐       │     │  ┌───┐       │     │  ┌───┐       │
│  │   │User   │────>│  │   │Auth   │<────│  │   │Order  │
│  └───┘Service│     │  └───┘Service│     │  └───┘Service│
└──────────────┘     └──────────────┘     └──────────────┘
       │                    │                     │
       [BLACK_DOWN-POINTING_TRIANGLE]                    [BLACK_DOWN-POINTING_TRIANGLE]                     [BLACK_DOWN-POINTING_TRIANGLE]
┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│  ┌───┐       │     │  ┌───┐       │     │  ┌───┐       │
│  │   │UserDB │     │  │   │TokenDB│     │  │   │OrderDB│
│  └───┘       │     │  └───┘       │     │  └───┘       │
└──────────────┘     └──────────────┘     └──────────────┘
"""


# ----------------------------------------------------------------------------
# [COURS] EXERCICE PRATIQUE 1 : APPLICATION E-LEARNING
# ----------------------------------------------------------------------------

"""
[COURS] ÉNONCÉ

Concevez un diagramme de composants pour une plateforme e-learning.

SYSTÈME :
Une application de formation en ligne avec les fonctionnalités :
- Gestion des utilisateurs (étudiants, professeurs)
- Catalogue de cours
- Système de paiement
- Streaming vidéo
- Quiz et évaluations
- Forum de discussion

COMPOSANTS IDENTIFIÉS :
1. FrontendWeb (interface utilisateur web)
2. MobileApp (application mobile)
3. APIGateway (point d'entrée unique)
4. UserService (gestion utilisateurs)
5. CourseService (gestion cours)
6. PaymentService (paiements)
7. VideoService (streaming)
8. QuizService (quiz et examens)
9. ForumService (discussions)
10. Database (base de données)
11. CacheRedis (cache)
12. StripeAPI (API externe paiement)
13. CloudStorage (stockage vidéos)

INTERFACES :
- IUserManagement (CRUD utilisateurs)
- ICourseManagement (CRUD cours)
- IPayment (traiter paiements)
- IVideoStreaming (diffuser vidéos)
- IQuiz (gérer quiz)
- IForum (gérer discussions)

CONTRAINTES :
1. Frontend et Mobile passent par l'API Gateway
2. Services métier sont indépendants
3. Tous les services utilisent Database et Cache
4. PaymentService utilise StripeAPI externe
5. VideoService utilise CloudStorage

Dessinez le diagramme de composants complet.


─────────────────────────────────────────────────────────────────────────
SOLUTION EXERCICE 1
─────────────────────────────────────────────────────────────────────────

DIAGRAMME DE COMPOSANTS - Plateforme E-Learning


COUCHE PRÉSENTATION
┌────────────────────────────────────────────────────────────┐
│                                                            │
│  ┌──────────────┐              ┌──────────────┐          │
│  │  ┌───┐       │              │  ┌───┐       │          │
│  │  │   │Frontend│             │  │   │Mobile │          │
│  │  └───┘Web    │              │  └───┘App    │          │
│  └──────────────┘              └──────────────┘          │
│         │                              │                  │
└─────────┼──────────────────────────────┼──────────────────┘
          │                              │
          │                              │
          └──────────────┬───────────────┘
                         │
                         [BLACK_DOWN-POINTING_TRIANGLE]
┌────────────────────────────────────────────────────────────┐
│                  COUCHE API                                │
├────────────────────────────────────────────────────────────┤
│                 ┌──────────────┐                          │
│                 │  ┌───┐       │                          │
│                 │  │   │API    │                          │
│                 │  └───┘Gateway│                          │
│                 └──────────────┘                          │
└────────────────────────────────────────────────────────────┘
                         │
          ┌──────────────┼──────────────┬─────────┬─────────┬─────────┐
          │              │              │         │         │         │
          [BLACK_DOWN-POINTING_TRIANGLE]              [BLACK_DOWN-POINTING_TRIANGLE]              [BLACK_DOWN-POINTING_TRIANGLE]         [BLACK_DOWN-POINTING_TRIANGLE]         [BLACK_DOWN-POINTING_TRIANGLE]         [BLACK_DOWN-POINTING_TRIANGLE]
┌────────────────────────────────────────────────────────────────────────────┐
│                        COUCHE SERVICES MÉTIER                              │
├────────────────────────────────────────────────────────────────────────────┤
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────┐│
│ │  ┌───┐   │ │  ┌───┐   │ │  ┌───┐   │ │  ┌───┐   │ │  ┌───┐   │ │┌───┐││
│ │  │   │User││ │  │   │Course││ │  │   │Payment││ │  │   │Video││ │  │   │Quiz││ │   │Forum││
│ │  └───┘   │ │  └───┘   │ │  └───┘   │ │  └───┘   │ │  └───┘   │ │└───┘││
│ │  Service │ │  Service │ │  Service │ │  Service │ │  Service │ │Service││
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ └──────────┘ └──────┘│
│      │           │             │             │             │         │    │
│      [WHITE_CIRCLE]           [WHITE_CIRCLE]             [WHITE_CIRCLE]             [WHITE_CIRCLE]             [WHITE_CIRCLE]         [WHITE_CIRCLE]    │
│   IUser      ICourse      IPayment      IVideo         IQuiz     IForum   │
│                                │                         │                │
│                                │                         │                │
│                                [BLACK_DOWN-POINTING_TRIANGLE]                         [BLACK_DOWN-POINTING_TRIANGLE]                │
└────────────────────────────────┼─────────────────────────┼────────────────┘
                                 │                         │
                      ┌──────────┘                         │
                      │                                    │
                      [BLACK_DOWN-POINTING_TRIANGLE]                                    [BLACK_DOWN-POINTING_TRIANGLE]
         ┌──────────────────┐               ┌──────────────────┐
         │  ┌───┐           │               │  ┌───┐           │
         │  │   │StripeAPI  │               │  │   │Cloud     │
         │  └───┘ (externe) │               │  └───┘Storage   │
         └──────────────────┘               └──────────────────┘
                  [WHITE_CIRCLE]                                   [WHITE_CIRCLE]
              IStripe                           ICloudStorage


          ┌──────────────┬──────────────┬─────────┬─────────┬─────────┐
          │              │              │         │         │         │
          [BLACK_DOWN-POINTING_TRIANGLE]              [BLACK_DOWN-POINTING_TRIANGLE]              [BLACK_DOWN-POINTING_TRIANGLE]         [BLACK_DOWN-POINTING_TRIANGLE]         [BLACK_DOWN-POINTING_TRIANGLE]         [BLACK_DOWN-POINTING_TRIANGLE]
┌────────────────────────────────────────────────────────────────────────────┐
│                        COUCHE DONNÉES                                      │
├────────────────────────────────────────────────────────────────────────────┤
│           ┌──────────────┐                    ┌──────────────┐            │
│           │  ┌───┐       │                    │  ┌───┐       │            │
│           │  │   │Database│                   │  │   │Redis  │            │
│           │  └───┘       │                    │  └───┘Cache  │            │
│           └──────────────┘                    └──────────────┘            │
│                  [WHITE_CIRCLE]                                   [WHITE_CIRCLE]                     │
│              IDatabase                           ICache                   │
└────────────────────────────────────────────────────────────────────────────┘


INTERFACES FOURNIES ([WHITE_CIRCLE]) :

UserService ────[WHITE_CIRCLE] IUserManagement
CourseService ──[WHITE_CIRCLE] ICourseManagement
PaymentService ─[WHITE_CIRCLE] IPayment
VideoService ───[WHITE_CIRCLE] IVideoStreaming
QuizService ────[WHITE_CIRCLE] IQuiz
ForumService ───[WHITE_CIRCLE] IForum
Database ───────[WHITE_CIRCLE] IDatabase
RedisCache ─────[WHITE_CIRCLE] ICache
StripeAPI ──────[WHITE_CIRCLE] IStripe
CloudStorage ───[WHITE_CIRCLE] ICloudStorage


DÉPENDANCES :

FrontendWeb ──────> APIGateway
MobileApp ────────> APIGateway
APIGateway ───────> tous les Services

PaymentService ───> StripeAPI
VideoService ─────> CloudStorage

Tous les Services > Database
Tous les Services > RedisCache


[IDEE] EXPLICATIONS :

1. ARCHITECTURE 3-TIERS
   - Présentation : FrontendWeb + MobileApp
   - API : APIGateway (point d'entrée unique)
   - Métier : 6 microservices indépendants
   - Données : Database + Cache

2. PATTERN API GATEWAY
   - Tous les clients passent par APIGateway
   - Évite couplage direct clients <-> services
   - Point central pour authentification, logging

3. MICROSERVICES
   - Chaque service = responsabilité unique
   - Peuvent évoluer indépendamment
   - Communiquent via interfaces bien définies

4. SERVICES EXTERNES
   - StripeAPI : paiement externalisé
   - CloudStorage : stockage vidéos scalable

5. CACHE
   - RedisCache améliore performances
   - Réduit charge sur Database

6. INTERFACES
   - Contrats clairs entre composants
   - Facilite tests et mocking
   - Permet remplacement d'implémentations


[IDEE] AVANTAGES DE CETTE ARCHITECTURE :

[OK] Scalabilité : Chaque service peut scaler indépendamment
[OK] Maintenabilité : Modifications isolées par service
[OK] Testabilité : Services testables séparément
[OK] Déploiement : Déploiement continu par service
[OK] Technologie : Chaque service peut utiliser tech adaptée
[OK] Résilience : Panne d'un service n'impacte pas les autres
"""


# ----------------------------------------------------------------------------
# [COURS] EXERCICE PRATIQUE 2 : SYSTÈME BANCAIRE
# ----------------------------------------------------------------------------

"""
[CARTE] ÉNONCÉ

Modélisez le diagramme de composants d'un système bancaire en ligne.

SYSTÈME :
Application bancaire permettant :
- Consultation de comptes
- Virements
- Paiements de factures
- Demandes de crédit
- Gestion de carte bancaire
- Notifications

COMPOSANTS :
1. WebPortal (portail web clients)
2. MobileBanking (app mobile)
3. AdminConsole (console agents)
4. LoadBalancer (répartition charge)
5. AuthenticationService (authentification 2FA)
6. AccountService (gestion comptes)
7. TransactionService (virements, paiements)
8. LoanService (crédits)
9. CardService (cartes bancaires)
10. NotificationService (emails, SMS, push)
11. FraudDetection (détection fraude)
12. AuditLog (journalisation)
13. Database (BDD principale)
14. ReportingDB (BDD analytique)
15. MessageQueue (RabbitMQ)
16. EmailProvider (SendGrid - externe)
17. SMSProvider (Twilio - externe)

CONTRAINTES :
1. Tous les clients passent par LoadBalancer
2. Authentification obligatoire pour tous les services
3. FraudDetection analyse toutes les transactions
4. AuditLog enregistre toutes les opérations
5. Notifications asynchrones via MessageQueue
6. Séparation Database (OLTP) et ReportingDB (OLAP)

Concevez le diagramme de composants.


─────────────────────────────────────────────────────────────────────────
SOLUTION EXERCICE 2
─────────────────────────────────────────────────────────────────────────

DIAGRAMME DE COMPOSANTS - Système Bancaire


COUCHE CLIENT
┌────────────────────────────────────────────────────────────────┐
│  ┌──────────┐    ┌──────────┐    ┌──────────┐                │
│  │  ┌───┐   │    │  ┌───┐   │    │  ┌───┐   │                │
│  │  │   │Web│    │  │   │Mobile│  │  │   │Admin│              │
│  │  └───┘Portal│ │  └───┘Banking││  └───┘Console│            │
│  └──────────┘    └──────────┘    └──────────┘                │
│       │               │                │                       │
└───────┼───────────────┼────────────────┼───────────────────────┘
        │               │                │
        └───────────────┴────────────────┘
                        │
                        [BLACK_DOWN-POINTING_TRIANGLE]
┌────────────────────────────────────────────────────────────────┐
│                    COUCHE INFRASTRUCTURE                       │
│               ┌──────────────┐                                │
│               │  ┌───┐       │                                │
│               │  │   │Load   │                                │
│               │  └───┘Balancer│                               │
│               └──────────────┘                                │
└────────────────────────────────────────────────────────────────┘
                        │
                        [BLACK_DOWN-POINTING_TRIANGLE]
┌────────────────────────────────────────────────────────────────┐
│                   COUCHE SÉCURITÉ                              │
│               ┌──────────────┐                                │
│               │  ┌───┐       │                                │
│               │  │   │Auth   │────[WHITE_CIRCLE] IAuthentication           │
│               │  └───┘Service│                                │
│               └──────────────┘                                │
└────────────────────────────────────────────────────────────────┘
                        │
          ┌─────────────┼─────────────┬─────────────┐
          │             │             │             │
          [BLACK_DOWN-POINTING_TRIANGLE]             [BLACK_DOWN-POINTING_TRIANGLE]             [BLACK_DOWN-POINTING_TRIANGLE]             [BLACK_DOWN-POINTING_TRIANGLE]
┌────────────────────────────────────────────────────────────────────┐
│                    COUCHE SERVICES MÉTIER                          │
├────────────────────────────────────────────────────────────────────┤
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐│
│ │  ┌───┐   │ │  ┌───┐   │ │  ┌───┐   │ │  ┌───┐   │ │  ┌───┐   ││
│ │  │   │Account││ │   │Transaction││ │   │Loan││ │   │Card││ │   │Notification││
│ │  └───┘Service││ └───┘Service││ └───┘Service││ └───┘Service││ └───┘Service││
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ └──────────┘│
│      [WHITE_CIRCLE]            [WHITE_CIRCLE]             [WHITE_CIRCLE]            [WHITE_CIRCLE]            [WHITE_CIRCLE]      │
│   IAccount    ITransaction   ILoan       ICard     INotification │
└────────────────────────────────────────────────────────────────────┘
          │             │             │            │
          │             │             │            │
          │             [BLACK_DOWN-POINTING_TRIANGLE]             │            │
          │      ┌──────────────┐    │            │
          │      │  ┌───┐       │    │            │
          │      │  │   │Fraud  │    │            │
          │      │  └───┘Detection    │            │
          │      └──────────────┘    │            │
          │             │             │            │
          │             [WHITE_CIRCLE]             │            │
          │        IFraudCheck        │            │
          │                           │            │
          └───────────┬───────────────┴────────────┘
                      │                            │
                      [BLACK_DOWN-POINTING_TRIANGLE]                            [BLACK_DOWN-POINTING_TRIANGLE]
┌─────────────────────────────────┐  ┌──────────────────────────┐
│  ┌───┐                          │  │  ┌───┐                   │
│  │   │ AuditLog                 │  │  │   │ MessageQueue      │
│  └───┘                          │  │  └───┘ (RabbitMQ)        │
└─────────────────────────────────┘  └──────────────────────────┘
          [WHITE_CIRCLE]                                      │
      IAuditLog                                  │
                                                 [BLACK_DOWN-POINTING_TRIANGLE]
                                    ┌──────────────────────┐
                                    │NotificationService   │
                                    │    (Consumer)        │
                                    └──────────────────────┘
                                         │         │
                                         │         │
                              ┌──────────┘         └──────────┐
                              [BLACK_DOWN-POINTING_TRIANGLE]                               [BLACK_DOWN-POINTING_TRIANGLE]
                   ┌──────────────────┐          ┌──────────────────┐
                   │  ┌───┐           │          │  ┌───┐           │
                   │  │   │Email      │          │  │   │SMS        │
                   │  └───┘Provider   │          │  └───┘Provider   │
                   │  (SendGrid)      │          │  (Twilio)        │
                   └──────────────────┘          └──────────────────┘
                          [WHITE_CIRCLE]                              [WHITE_CIRCLE]
                      IEmailSender                   ISMSSender


          ┌──────────────┬──────────────┬─────────┬─────────┐
          │              │              │         │         │
          [BLACK_DOWN-POINTING_TRIANGLE]              [BLACK_DOWN-POINTING_TRIANGLE]              [BLACK_DOWN-POINTING_TRIANGLE]         [BLACK_DOWN-POINTING_TRIANGLE]         [BLACK_DOWN-POINTING_TRIANGLE]
┌────────────────────────────────────────────────────────────────┐
│                      COUCHE DONNÉES                            │
├────────────────────────────────────────────────────────────────┤
│     ┌──────────────┐                  ┌──────────────┐        │
│     │  ┌───┐       │                  │  ┌───┐       │        │
│     │  │   │Database│                 │  │   │Reporting│       │
│     │  └───┘ (OLTP)│                  │  └───┘DB (OLAP)│      │
│     └──────────────┘                  └──────────────┘        │
│            [WHITE_CIRCLE]                                  [WHITE_CIRCLE]                │
│        IDatabase                         IReporting            │
└────────────────────────────────────────────────────────────────┘


FLUX DE DONNÉES :

1. AUTHENTIFICATION :
   Client -> LoadBalancer -> AuthService -> Database
   
2. TRANSACTION :
   AuthService -> TransactionService -> FraudDetection -> Database
                                    -> AuditLog
                                    -> MessageQueue -> NotificationService
   
3. NOTIFICATION :
   NotificationService -> EmailProvider (externe)
                      -> SMSProvider (externe)


INTERFACES :

IAuthentication : login(), logout(), validate2FA()
IAccount : getBalance(), getStatement(), createAccount()
ITransaction : transfer(), payBill(), getHistory()
ILoan : applyLoan(), getLoanStatus(), calculateRate()
ICard : activateCard(), blockCard(), setLimit()
INotification : sendEmail(), sendSMS(), sendPush()
IFraudCheck : analyzeTransaction(), reportFraud()
IAuditLog : logOperation(), getAuditTrail()
IDatabase : CRUD operations
IReporting : generateReport(), analytics()


[IDEE] ARCHITECTURE EXPLIQUÉE :

1. PATTERN LAYERED (en couches)
   - Client -> Infrastructure -> Sécurité -> Métier -> Données
   - Séparation claire des responsabilités

2. SÉCURITÉ FIRST
   - Toutes les requêtes passent par AuthService
   - Authentification 2FA obligatoire
   - AuditLog pour traçabilité complète

3. DÉTECTION FRAUDE
   - Analyse en temps réel des transactions
   - Peut bloquer transaction suspecte
   - Génère alertes automatiques

4. ARCHITECTURE ÉVÉNEMENTIELLE
   - MessageQueue pour notifications asynchrones
   - Découple NotificationService des autres services
   - Permet retry automatique en cas d'échec

5. SÉPARATION OLTP/OLAP
   - Database (OLTP) : opérations transactionnelles
   - ReportingDB (OLAP) : analyses et rapports
   - Évite impact des analyses sur performance

6. SERVICES EXTERNES
   - SendGrid pour emails (scalable, fiable)
   - Twilio pour SMS (spécialisé)
   - Évite développement in-house


[IDEE] AVANTAGES :

[OK] Sécurité : Authentification centralisée + Audit complet
[OK] Performance : LoadBalancer + Séparation OLTP/OLAP
[OK] Fiabilité : Détection fraude + Notifications asynchrones
[OK] Scalabilité : Microservices indépendants
[OK] Maintenabilité : Responsabilités bien séparées
[OK] Conformité : AuditLog pour régulations bancaires


[IDEE] PATTERNS UTILISÉS :

1. API Gateway (LoadBalancer)
2. Microservices (services métier)
3. Event-Driven (MessageQueue)
4. CQRS (Database vs ReportingDB)
5. Circuit Breaker (FraudDetection)
6. Audit Logging (AuditLog)
"""


# ----------------------------------------------------------------------------
# [DOCS] RÉCAPITULATIF CHAPITRE 3 - DIAGRAMME DE COMPOSANTS
# ----------------------------------------------------------------------------

"""
CE QUE VOUS AVEZ APPRIS

[OK] Qu'est-ce qu'un composant (module autonome et réutilisable)
[OK] Notation composant (rectangle avec icône)
[OK] Interfaces fournies (lollipop [WHITE_CIRCLE]) et requises (socket [WHITE_LEFT-POINTING_TRIANGLE])
[OK] Dépendances entre composants
[OK] Organisation en couches (layered architecture)
[OK] Patterns : API Gateway, Microservices, Event-Driven
[OK] 2 exercices pratiques (e-learning, système bancaire)


[CLE] POINTS CLÉS

1. Composant = Module logiciel avec interface claire
2. Lollipop ([WHITE_CIRCLE]) = Interface FOURNIE par le composant
3. Socket ([WHITE_LEFT-POINTING_TRIANGLE]) = Interface REQUISE par le composant
4. Architecture en couches = Présentation -> Métier -> Données
5. Microservices = Composants indépendants et spécialisés
6. API Gateway = Point d'entrée unique pour clients


[IDEE] DIFFÉRENCES CLÉS

┌──────────────────────┬──────────────────────────┐
│ CLASSE               │ COMPOSANT                │
├──────────────────────┼──────────────────────────┤
│ Niveau micro         │ Niveau macro             │
│ Unité de code        │ Module déployable        │
│ Attributs et méthodes│ Services et interfaces   │
│ Relations de classes │ Dépendances de modules   │
│ Design détaillé      │ Architecture système     │
└──────────────────────┴──────────────────────────┘


[OK] CHECKLIST

Vous devez être capable de :
[ ] Dessiner un composant avec interfaces
[ ] Distinguer interface fournie vs requise
[ ] Modéliser dépendances entre composants
[ ] Organiser architecture en couches
[ ] Identifier composants d'un système
[ ] Appliquer patterns architecturaux


[COURS] POUR S'ENTRAÎNER

Créez des diagrammes de composants pour :
1. Système de gestion d'hôtel (réservations, facturation, housekeeping)
2. Application de streaming musical (Spotify-like)
3. Plateforme de e-commerce (Amazon-like)
4. Système de santé (dossiers patients, rendez-vous, prescriptions)


[DOCS] PATTERNS ARCHITECTURAUX À CONNAÎTRE

[OK] Layered Architecture (3-tiers)
[OK] Microservices
[OK] API Gateway
[OK] Event-Driven Architecture
[OK] CQRS (Command Query Responsibility Segregation)
[OK] Service Mesh
[OK] Hexagonal Architecture (Ports & Adapters)


-> PROCHAINE ÉTAPE : PARTIE 2 - DIAGRAMMES COMPORTEMENTAUX

Vous avez terminé les diagrammes STRUCTURELS ! [BRAVO]

Dans la Partie 2, nous étudierons les diagrammes COMPORTEMENTAUX :
- Chapitre 4 : Diagramme de Cas d'Utilisation (Use Case)
- Chapitre 5 : Diagramme de Séquence
- Chapitre 6 : Diagramme d'Activités
- Chapitre 7 : Diagramme d'États-Transitions

Les diagrammes comportementaux montrent COMMENT le système fonctionne,
par opposition aux diagrammes structurels qui montrent CE QUE contient le système.

Prêt pour l'action ? Let's go! [RAPIDE]
"""


# ============================================================================
# FIN DE LA PARTIE 1 - DIAGRAMMES STRUCTURELS
# ============================================================================

"""
[COURS] RÉSUMÉ DE LA PARTIE 1

Vous avez appris 4 types de diagrammes STRUCTURELS :

[OK] CHAPITRE 0 : Introduction à UML
   - Histoire et contexte
   - Vue d'ensemble des 14 diagrammes
   - Quand utiliser UML

[OK] CHAPITRE 1 : Diagramme de Classes
   - Classes, attributs, méthodes
   - Relations (association, composition, héritage)
   - Interfaces et classes abstraites

[OK] CHAPITRE 2 : Diagramme d'Objets
   - Instances concrètes
   - Snapshot du système
   - Validation de conception

[OK] CHAPITRE 3 : Diagramme de Composants
   - Architecture logicielle
   - Interfaces et dépendances
   - Organisation en modules


[IDEE] RÉCAPITULATIF FINAL

DIAGRAMMES STRUCTURELS = "CE QUE contient le système"

Classes -> Vue détaillée (attributs, méthodes)
Objets -> Vue instanciée (valeurs concrètes)
Composants -> Vue architecturale (modules, services)
Déploiement -> Vue physique (serveurs, matériel) [Chapitre 11 à venir]


Vous êtes maintenant prêt pour les DIAGRAMMES COMPORTEMENTAUX ! [BRAVO]

Ces diagrammes montrent COMMENT le système FONCTIONNE :
- Interactions entre acteurs et système
- Séquences de messages entre objets
- Flux d'activités et processus
- Changements d'états

La suite arrive ! [RAPIDE]
"""


################################################################################
################################################################################
##                                                                            ##
##  SECTION III : PARTIE 2 - DIAGRAMMES COMPORTEMENTAUX
##                                                                            ##
################################################################################
################################################################################


# ============================================================================
# [LIVRE] UML - PARTIE 2 : DIAGRAMMES COMPORTEMENTAUX
# ============================================================================


# ============================================================================
# [GUIDE] CHAPITRE 4 : DIAGRAMME DE CAS D'UTILISATION (USE CASE DIAGRAM)
# ============================================================================

"""
[OBJECTIF] OBJECTIFS D'APPRENTISSAGE

À la fin de ce chapitre, vous saurez :
[OK] Qu'est-ce qu'un cas d'utilisation (use case)
[OK] Identifier les acteurs d'un système
[OK] Modéliser les interactions acteur-système
[OK] Utiliser les relations : include, extend, généralisation
[OK] Définir les frontières du système
[OK] Rédiger des descriptions de cas d'utilisation
[OK] Créer des diagrammes de cas d'utilisation complets
"""


# ----------------------------------------------------------------------------
# [REFLEXION] QU'EST-CE QU'UN DIAGRAMME DE CAS D'UTILISATION ?
# ----------------------------------------------------------------------------

"""
DÉFINITION SIMPLE

Diagramme de Cas d'Utilisation = Vue EXTERNE du système

Montre :
├─ QUI utilise le système (Acteurs)
├─ CE QUE fait le système (Cas d'utilisation)
└─ COMMENT ils interagissent (Relations)


[IDEE] CONCEPTS CLÉS

ACTEUR = Personne, système ou entité qui interagit avec notre système
        (externe au système)

CAS D'UTILISATION = Fonctionnalité offerte par le système
                    But qu'un acteur veut atteindre

SYSTÈME = Ce que nous développons (dans un rectangle)


ANALOGIE [CONSTRUCTION]

Système = Guichet automatique bancaire (ATM)

Acteurs :
- Client (personne qui retire de l'argent)
- Système bancaire (valide les transactions)

Cas d'utilisation :
- Retirer de l'argent
- Consulter le solde
- Déposer un chèque
- Changer le code PIN


Le diagramme montre QUI fait QUOI, sans détailler COMMENT


[REFLEXION] POURQUOI UTILISER ?

[OK] ANALYSE DES BESOINS
- Capturer les exigences fonctionnelles
- Comprendre ce que veulent les utilisateurs
- Vue d'ensemble du système

[OK] COMMUNICATION
- Langage commun entre technique et métier
- Documentation accessible à tous
- Support pour cahier des charges

[OK] CADRAGE PROJET
- Définir le périmètre (scope)
- Identifier les acteurs
- Prioriser les fonctionnalités

[OK] BASE POUR TESTS
- Chaque cas d'utilisation -> scénarios de test
- Validation avec utilisateurs
- Couverture fonctionnelle


[REFLEXION] QUAND L'UTILISER ?

[OK] UTILISEZ POUR :
- Début de projet (phase d'analyse)
- Recueil des besoins utilisateurs
- Communication avec le client
- Spécification fonctionnelle
- Définition MVP (Minimum Viable Product)

[X] ÉVITEZ POUR :
- Détails techniques d'implémentation (utilisez classes)
- Processus internes détaillés (utilisez activités)
- Séquences de messages (utilisez séquence)


RELATION AVEC AUTRES DIAGRAMMES

Use Case -> Vue EXTERNE (point de vue utilisateur)
         v
Séquence -> Vue TEMPORELLE (comment cas d'utilisation se déroule)
         v
Classes -> Vue STRUCTURELLE (comment c'est implémenté)
"""


# ----------------------------------------------------------------------------
# [UTILISATEUR] ACTEURS
# ----------------------------------------------------------------------------

"""
QU'EST-CE QU'UN ACTEUR ?

Acteur = Entité EXTERNE qui interagit avec le système

Types d'acteurs :
1. HUMAINS (utilisateurs)
2. SYSTÈMES externes
3. MATÉRIEL (capteurs, imprimantes)
4. TEMPS (horloge pour actions automatiques)


NOTATION

Acteur = Bonhomme bâton (stick figure) + Nom

    ┌─┐
    │ │     <- Tête
    └─┘
     │      <- Corps
    ─┼─     <- Bras
     │
    ╱ ╲     <- Jambes
  Client

Alternative : Rectangle avec <<actor>>
┌──────────────┐
│   <<actor>>  │
│    Client    │
└──────────────┘


TYPES D'ACTEURS

1. ACTEUR PRINCIPAL (Primary Actor)
   - Initie le cas d'utilisation
   - Bénéficie du résultat
   - Placé à GAUCHE du système

2. ACTEUR SECONDAIRE (Secondary Actor)
   - Fournit un service au système
   - Répond à une demande
   - Placé à DROITE du système


EXEMPLES :

Système bancaire :
    ┌─┐
    │ │  Client          <- Acteur principal (initie)
    └─┘
     │
    ─┼─
     │
    ╱ ╲

                                     ┌─┐
        Système bancaire central ->  │ │  <- Acteur secondaire (répond)
                                     └─┘
                                      │
                                     ─┼─
                                      │
                                     ╱ ╲


RÈGLES D'IDENTIFICATION DES ACTEURS

[OK] POSEZ-VOUS CES QUESTIONS :

1. Qui utilise les fonctionnalités principales ?
2. Qui a besoin du système pour son travail ?
3. Qui maintient et administre le système ?
4. Quels matériels externes le système utilise ?
5. Quels autres systèmes interagissent avec celui-ci ?
6. Qui reçoit les résultats du système ?


EXEMPLES D'ACTEURS PAR DOMAINE

E-COMMERCE :
- Client (achète)
- Vendeur (vend)
- Administrateur (gère)
- Système de paiement (traite paiements)
- Système de livraison (expédie)

HÔPITAL :
- Patient (reçoit soins)
- Médecin (prescrit)
- Infirmière (administre soins)
- Administratif (gère dossiers)
- Laboratoire (analyse)

UNIVERSITÉ :
- Étudiant (s'inscrit, consulte notes)
- Professeur (enseigne, évalue)
- Administrateur (gère système)
- Système de paiement (frais de scolarité)


GÉNÉRALISATION D'ACTEURS

Les acteurs peuvent avoir des relations d'héritage :

         ┌─┐
         │ │  Utilisateur
         └─┘
          │
         ─┼─
          │       <- Généralisation
         ╱ ╲
          [WHITE_UP-POINTING_TRIANGLE]
          │
    ┌─────┴──────┐
    │            │
  ┌─┐          ┌─┐
  │ │          │ │
  └─┘          └─┘
   │            │
  ─┼─          ─┼─
   │            │
  ╱ ╲          ╱ ╲
Client      Administrateur

Client et Administrateur héritent de Utilisateur
-> Peuvent utiliser les mêmes cas d'utilisation


[ATTENTION] ERREURS FRÉQUENTES

[X] Confondre acteur et rôle système
   - Acteur = EXTERNE au système
   - Système = ce qu'on développe

[X] Mettre trop de détails
   - Acteur = rôle, pas personne spécifique
   - "Client" pas "Jean Dupont"

[X] Oublier acteurs secondaires
   - Systèmes externes importants !
   - Ex : système de paiement, email service
"""


# ----------------------------------------------------------------------------
# [OBJECTIF] CAS D'UTILISATION (USE CASE)
# ----------------------------------------------------------------------------

"""
QU'EST-CE QU'UN CAS D'UTILISATION ?

Cas d'Utilisation = OBJECTIF qu'un acteur veut accomplir
                    avec l'aide du système


NOTATION

Ovale (ellipse) avec nom à l'intérieur

     ┌──────────────────┐
     │  Retirer Argent  │
     └──────────────────┘


RÈGLES DE NOMMAGE

[OK] Commencer par un VERBE (action)
[OK] Point de vue de l'ACTEUR (pas du système)
[OK] CLAIR et CONCIS
[OK] Décrire un OBJECTIF, pas une fonction technique


EXEMPLES :

[OK] BON :
- Retirer de l'argent
- Réserver un vol
- Consulter son solde
- Modifier profil
- Générer rapport mensuel

[X] MAUVAIS :
- Système (trop vague)
- Cliquer sur bouton (détail implémentation)
- Validation (pas un objectif utilisateur)
- Base de données (technique)


GRANULARITÉ

Un cas d'utilisation doit être :
- Ni trop gros (surchargé)
- Ni trop petit (atomique)


TROP GROS (à diviser) :
┌──────────────────────┐
│  Gérer les clients   │  <- Trop vague
└──────────────────────┘

MIEUX (divisé) :
┌──────────────────────┐  ┌──────────────────────┐
│  Créer un client     │  │  Modifier un client  │
└──────────────────────┘  └──────────────────────┘
┌──────────────────────┐  ┌──────────────────────┐
│  Supprimer un client │  │  Rechercher client   │
└──────────────────────┘  └──────────────────────┘


TROP PETIT (regrouper) :
┌──────────────────────┐
│  Saisir nom          │  <- Trop détaillé
└──────────────────────┘
┌──────────────────────┐
│  Saisir prénom       │
└──────────────────────┘
┌──────────────────────┐
│  Saisir email        │
└──────────────────────┘

MIEUX (regroupé) :
┌──────────────────────┐
│  Créer un client     │  <- Objectif complet
└──────────────────────┘


DESCRIPTION TEXTUELLE

Chaque cas d'utilisation doit avoir une description détaillée :

TEMPLATE STANDARD :

┌────────────────────────────────────────────────────┐
│ Nom : [Nom du cas d'utilisation]                   │
├────────────────────────────────────────────────────┤
│ Acteur principal : [Qui initie]                    │
├────────────────────────────────────────────────────┤
│ Acteurs secondaires : [Qui participe]              │
├────────────────────────────────────────────────────┤
│ Préconditions : [État du système avant]            │
├────────────────────────────────────────────────────┤
│ Postconditions : [État du système après]           │
├────────────────────────────────────────────────────┤
│ Scénario nominal :                                 │
│   1. [Étape 1]                                     │
│   2. [Étape 2]                                     │
│   3. ...                                           │
├────────────────────────────────────────────────────┤
│ Scénarios alternatifs :                            │
│   A1. [Cas particulier 1]                          │
│   A2. [Cas particulier 2]                          │
├────────────────────────────────────────────────────┤
│ Scénarios d'exception :                            │
│   E1. [Erreur 1]                                   │
│   E2. [Erreur 2]                                   │
└────────────────────────────────────────────────────┘


EXEMPLE CONCRET :

┌────────────────────────────────────────────────────┐
│ Nom : Retirer de l'argent                          │
├────────────────────────────────────────────────────┤
│ Acteur principal : Client                          │
├────────────────────────────────────────────────────┤
│ Acteurs secondaires : Système bancaire, Imprimante│
├────────────────────────────────────────────────────┤
│ Préconditions :                                    │
│   - Le client possède une carte valide            │
│   - Le DAB est en service                         │
├────────────────────────────────────────────────────┤
│ Postconditions :                                   │
│   - Montant débité du compte                      │
│   - Argent distribué                              │
│   - Reçu imprimé                                  │
├────────────────────────────────────────────────────┤
│ Scénario nominal :                                 │
│   1. Client insère sa carte                        │
│   2. Système demande le code PIN                   │
│   3. Client saisit son code PIN                    │
│   4. Système valide le code                        │
│   5. Système affiche menu principal                │
│   6. Client sélectionne "Retrait"                  │
│   7. Système demande le montant                    │
│   8. Client saisit le montant                      │
│   9. Système vérifie solde auprès de la banque     │
│   10. Système distribue l'argent                   │
│   11. Système imprime reçu                         │
│   12. Système restitue la carte                    │
├────────────────────────────────────────────────────┤
│ Scénarios alternatifs :                            │
│   A1. Au point 8, client annule l'opération       │
│       -> Retour au menu principal                   │
│   A2. Au point 10, client refuse le reçu          │
│       -> Pas d'impression                           │
├────────────────────────────────────────────────────┤
│ Scénarios d'exception :                            │
│   E1. Au point 4, code PIN incorrect (3 fois)     │
│       -> Carte avalée                               │
│   E2. Au point 9, solde insuffisant               │
│       -> Message d'erreur, retour menu              │
│   E3. Au point 10, plus de billets                │
│       -> Message d'erreur, annulation               │
└────────────────────────────────────────────────────┘
"""


# ----------------------------------------------------------------------------
# [LIEN] RELATIONS ENTRE CAS D'UTILISATION
# ----------------------------------------------------------------------------

"""
TYPES DE RELATIONS

UML définit 3 types de relations entre cas d'utilisation :
1. INCLUDE (inclusion obligatoire)
2. EXTEND (extension conditionnelle)
3. GÉNÉRALISATION (spécialisation)


1. RELATION <<include>> (INCLUT)

Usage : Un cas d'utilisation EN UTILISE un autre (TOUJOURS)

Notation : Flèche pointillée + <<include>>

     ┌──────────────┐         <<include>>        ┌──────────────┐
     │   Acheter    │─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─>│   Payer      │
     │   Produit    │                            └──────────────┘
     └──────────────┘

"Acheter Produit" INCLUT "Payer" (on ne peut acheter sans payer)


[IDEE] QUAND UTILISER <<include>> ?

[OK] Factoriser comportement COMMUN
[OK] Réutiliser un cas d'utilisation dans plusieurs autres
[OK] Séparer logique OBLIGATOIRE

Exemples :
- Réserver vol INCLUT Payer
- Commander INCLUT Vérifier stock
- Envoyer email INCLUT S'authentifier


EXEMPLE COMPLET :

     ┌──────────────┐
     │  Passer      │
     │  Commande    │──────┐
     └──────────────┘      │
                           │ <<include>>
     ┌──────────────┐      │
     │  Modifier    │      │
     │  Commande    │──────┤
     └──────────────┘      │
                           [BLACK_DOWN-POINTING_TRIANGLE]
                     ┌──────────────┐
                     │  Calculer    │
                     │  Total       │
                     └──────────────┘

"Passer Commande" et "Modifier Commande" INCLUENT tous deux "Calculer Total"


2. RELATION <<extend>> (ÉTEND)

Usage : Un cas d'utilisation PEUT être étendu (OPTIONNEL)

Notation : Flèche pointillée + <<extend>>

     ┌──────────────┐         <<extend>>         ┌──────────────┐
     │  Imprimer    │[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─│   Retirer    │
     │   Reçu       │                            │   Argent     │
     └──────────────┘                            └──────────────┘

"Retirer Argent" PEUT être étendu par "Imprimer Reçu" (optionnel)


[IDEE] QUAND UTILISER <<extend>> ?

[OK] Comportement OPTIONNEL
[OK] Cas EXCEPTIONNEL
[OK] Variante d'un cas de base

Exemples :
- Réserver vol PEUT ÊTRE ÉTENDU PAR Choisir siège
- Commander PEUT ÊTRE ÉTENDU PAR Ajouter note
- Consulter profil PEUT ÊTRE ÉTENDU PAR Modifier photo


[ATTENTION] ATTENTION : Direction de la flèche

<<include>> : A ───> B  (A utilise B)
<<extend>>  : B [BLACK_LEFT-POINTING_POINTER]─── A  (A étend B)


EXEMPLE COMPLET :

                     ┌──────────────┐
                     │  Effectuer   │
                     │  Achat       │ <- Cas de base
                     └──────────────┘
                            [WHITE_UP-POINTING_TRIANGLE]
                            │ <<extend>>
                ┌───────────┴───────────┬───────────────┐
                │                       │               │
         ┌──────────────┐        ┌──────────────┐ ┌─────────────┐
         │  Utiliser    │        │  Ajouter     │ │  Emballer   │
         │  Coupon      │        │  Cadeau      │ │  Cadeau     │
         └──────────────┘        └──────────────┘ └─────────────┘
         Optionnel               Optionnel         Optionnel


3. GÉNÉRALISATION (Héritage)

Usage : Un cas d'utilisation SPÉCIALISE un autre (IS-A)

Notation : Flèche pleine + triangle vide (comme classes)

                     ┌──────────────┐
                     │   Effectuer  │
                     │   Paiement   │ <- Cas général
                     └──────────────┘
                            [WHITE_UP-POINTING_TRIANGLE]
                            │
                    ┌───────┴───────┐
                    │               │
         ┌──────────────┐    ┌──────────────┐
         │  Payer par   │    │  Payer par   │
         │  Carte       │    │  Virement    │
         └──────────────┘    └──────────────┘
         Spécialisations


[IDEE] QUAND UTILISER Généralisation ?

[OK] Différentes VARIANTES d'un même cas
[OK] Comportement de base + variantes spécifiques
[OK] Éviter duplication

Exemples :
- "S'authentifier" <- "S'authentifier par email", "S'authentifier par SMS"
- "Chercher" <- "Chercher par nom", "Chercher par catégorie"
- "Notifier" <- "Notifier par email", "Notifier par SMS"


TABLEAU RÉCAPITULATIF

┌──────────────┬──────────────┬──────────────┬──────────────┐
│   RELATION   │   DIRECTION  │   NATURE     │   USAGE      │
├──────────────┼──────────────┼──────────────┼──────────────┤
│  <<include>> │  A ───> B    │  OBLIGATOIRE │  Réutiliser  │
│              │              │  Toujours    │  Factoriser  │
├──────────────┼──────────────┼──────────────┼──────────────┤
│  <<extend>>  │  A [BLACK_LEFT-POINTING_POINTER]─── B    │  OPTIONNEL   │  Variante    │
│              │              │  Conditionnel│  Exception   │
├──────────────┼──────────────┼──────────────┼──────────────┤
│Généralisation│  A [WHITE_UP-POINTING_TRIANGLE]─── B    │  VARIANTE    │  Spécialiser │
│              │              │  Choix       │  Alternatives│
└──────────────┴──────────────┴──────────────┴──────────────┘


EXEMPLES CONTRASTÉS

INCLUDE (toujours nécessaire) :
┌──────────────┐         <<include>>        ┌──────────────┐
│  S'inscrire  │─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─>│  Valider     │
│              │                            │  Email       │
└──────────────┘                            └──────────────┘
On NE PEUT PAS s'inscrire sans valider email


EXTEND (parfois nécessaire) :
┌──────────────┐         <<extend>>         ┌──────────────┐
│  Recevoir    │[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ │  S'inscrire  │
│  Newsletter  │                            │              │
└──────────────┘                            └──────────────┘
On PEUT s'inscrire avec ou sans newsletter


GÉNÉRALISATION (choix de variante) :
                     ┌──────────────┐
                     │  S'inscrire  │
                     └──────────────┘
                            [WHITE_UP-POINTING_TRIANGLE]
                            │
                    ┌───────┴───────┐
                    │               │
         ┌──────────────┐    ┌──────────────┐
         │  Inscription │    │  Inscription │
         │  Normale     │    │  via Google  │
         └──────────────┘    └──────────────┘
On s'inscrit SOIT normalement SOIT via Google
"""


# ----------------------------------------------------------------------------
# [WORLD_MAP] FRONTIÈRE DU SYSTÈME
# ----------------------------------------------------------------------------

"""
REPRÉSENTATION

Le système est entouré d'un RECTANGLE

Les cas d'utilisation sont À L'INTÉRIEUR
Les acteurs sont À L'EXTÉRIEUR


NOTATION :

        ┌─┐
        │ │  Client
        └─┘  (acteur)
         │
        ─┼─
         │
        ╱ ╲
          │
          │
┌─────────┼─────────────────────────────┐
│         │         SYSTÈME DAB         │
│         [BLACK_DOWN-POINTING_TRIANGLE]                             │
│   ┌──────────────┐                   │
│   │  Retirer     │                   │
│   │  Argent      │                   │
│   └──────────────┘                   │
│                                       │
│   ┌──────────────┐                   │
│   │  Consulter   │                   │
│   │  Solde       │                   │
│   └──────────────┘                   │
│                            ┌──────────┼─────┐
│                            │          │     │
│   ┌──────────────┐         │          [BLACK_DOWN-POINTING_TRIANGLE]     │
│   │  Déposer     │─────────┤      ┌─┐      │
│   │  Chèque      │         │      │ │      │
│   └──────────────┘         │      └─┘      │
│                            │       │       │
└────────────────────────────┘      ─┼─      │
                                     │       │
                                    ╱ ╲      │
                               Système       │
                               Bancaire      │
                              (acteur)       │
                                             │
                                             └──


UTILITÉ

[OK] Clarifier ce qui est DANS vs HORS du système
[OK] Séparer responsabilités
[OK] Définir périmètre du projet
[OK] Identifier interfaces externes


RÈGLES

1. Acteurs = TOUJOURS à l'extérieur
2. Cas d'utilisation = TOUJOURS à l'intérieur
3. Nom du système en haut du rectangle
4. Relations traversent la frontière
"""


# ----------------------------------------------------------------------------
# [COURS] EXERCICE PRATIQUE 1 : SYSTÈME DE BIBLIOTHÈQUE
# ----------------------------------------------------------------------------

"""
[DOCS] ÉNONCÉ

Créez un diagramme de cas d'utilisation pour un système de bibliothèque.

ACTEURS IDENTIFIÉS :
- Membre (emprunte des livres)
- Bibliothécaire (gère les livres et les membres)
- Administrateur (gère le système)
- Système de paiement (traite les amendes)

FONCTIONNALITÉS :
1. Membre peut :
   - Chercher un livre (par titre, auteur, ISBN)
   - Emprunter un livre (si disponible, max 5 livres)
   - Retourner un livre
   - Prolonger un emprunt (si pas de réservation)
   - Réserver un livre (si tous exemplaires empruntés)
   - Consulter son compte
   - Payer une amende

2. Bibliothécaire peut :
   - Tout ce qu'un membre peut faire
   - Inscrire un nouveau membre
   - Ajouter un nouveau livre
   - Retirer un livre (perdu ou abîmé)
   - Gérer les réservations
   - Envoyer rappel de retour

3. Administrateur peut :
   - Tout ce qu'un bibliothécaire peut faire
   - Générer des rapports statistiques
   - Sauvegarder la base de données
   - Gérer les comptes utilisateurs

RÈGLES MÉTIER :
- Emprunter livre INCLUT Vérifier disponibilité
- Emprunter livre INCLUT Enregistrer emprunt
- Retourner livre PEUT ÊTRE ÉTENDU PAR Calculer amende (si retard)
- Chercher livre a 3 variantes (titre, auteur, ISBN)
- Payer amende utilise Système de paiement

Dessinez le diagramme de cas d'utilisation complet.


─────────────────────────────────────────────────────────────────────────
SOLUTION EXERCICE 1
─────────────────────────────────────────────────────────────────────────

DIAGRAMME DE CAS D'UTILISATION - Système de Bibliothèque


ACTEURS (à gauche) :

    ┌─┐
    │ │  Membre
    └─┘
     │
    ─┼─
     │              ┌────────────────────────────────────────────────┐
    ╱ ╲             │                                                │
     │              │         SYSTÈME DE BIBLIOTHÈQUE               │
     │              │                                                │
     │              │   ┌──────────────┐                            │
     ├──────────────┼──>│  Consulter   │                            │
     │              │   │  Compte      │                            │
     │              │   └──────────────┘                            │
     │              │                                                │
     │              │   ┌──────────────┐                            │
     ├──────────────┼──>│  Chercher    │                            │
     │              │   │  Livre       │                            │
     │              │   └──────────────┘                            │
     │              │          [WHITE_UP-POINTING_TRIANGLE]                                    │
     │              │          │ généralisation                     │
     │              │   ┌──────┴───────┬───────────────┐           │
     │              │   │              │               │           │
     │              │ ┌─────────┐ ┌─────────┐  ┌─────────┐        │
     │              │ │ Chercher│ │Chercher │  │Chercher │        │
     │              │ │par Titre│ │par Auteur│ │par ISBN │        │
     │              │ └─────────┘ └─────────┘  └─────────┘        │
     │              │                                                │
     │              │   ┌──────────────┐                            │
     ├──────────────┼──>│  Emprunter   │                            │
     │              │   │  Livre       │                            │
     │              │   └──────────────┘                            │
     │              │          │ <<include>>                        │
     │              │          │                                    │
     │              │   ┌──────┴───────┬──────────────┐            │
     │              │   │              │              │            │
     │              │   [BLACK_DOWN-POINTING_TRIANGLE]              [BLACK_DOWN-POINTING_TRIANGLE]              │            │
     │              │ ┌─────────┐ ┌──────────┐       │            │
     │              │ │Vérifier │ │Enregistrer│      │            │
     │              │ │Disponib.│ │Emprunt   │       │            │
     │              │ └─────────┘ └──────────┘       │            │
     │              │                                 │            │
     │              │   ┌──────────────┐              │            │
     ├──────────────┼──>│  Retourner   │              │            │
     │              │   │  Livre       │[BLACK_LEFT-POINTING_POINTER]─────────────┘<<extend>>  │
     │              │   └──────────────┘                            │
     │              │          [WHITE_UP-POINTING_TRIANGLE]                                    │
     │              │          │ <<extend>>                         │
     │              │          │                                    │
     │              │   ┌──────────────┐                            │
     │              │   │  Calculer    │                            │
     │              │   │  Amende      │                            │
     │              │   └──────────────┘                            │
     │              │                                                │
     │              │   ┌──────────────┐                            │
     ├──────────────┼──>│  Prolonger   │                            │
     │              │   │  Emprunt     │                            │
     │              │   └──────────────┘                            │
     │              │                                                │
     │              │   ┌──────────────┐                            │
     ├──────────────┼──>│  Réserver    │                            │
     │              │   │  Livre       │                            │
     │              │   └──────────────┘                            │
     │              │                                                │
     │              │   ┌──────────────┐                            │
     ├──────────────┼──>│  Payer       │────────────────────────────┼──┐
     │              │   │  Amende      │                            │  │
     │              │   └──────────────┘                            │  │
                    │                                                │  │
    ┌─┐             │                                                │  │
    │ │             │   ┌──────────────┐                            │  │
    └─┘Bibliothécaire──>│  Inscrire    │                            │  │
     │              │   │  Membre      │                            │  │
    ─┼─             │   └──────────────┘                            │  │
     │              │                                                │  │
    ╱ ╲             │   ┌──────────────┐                            │  │
     │              │   │  Ajouter     │                            │  │
     ├──────────────┼──>│  Livre       │                            │  │
     │              │   └──────────────┘                            │  │
     │              │                                                │  │
     │              │   ┌──────────────┐                            │  │
     ├──────────────┼──>│  Retirer     │                            │  │
     │              │   │  Livre       │                            │  │
     │              │   └──────────────┘                            │  │
     │              │                                                │  │
     │              │   ┌──────────────┐                            │  │
     ├──────────────┼──>│  Gérer       │                            │  │
     │              │   │  Réservations│                            │  │
     │              │   └──────────────┘                            │  │
     │              │                                                │  │
     │              │   ┌──────────────┐                            │  │
     ├──────────────┼──>│  Envoyer     │                            │  │
     │              │   │  Rappel      │                            │  │
     │              │   └──────────────┘                            │  │
                    │                                                │  │
    ┌─┐             │                                                │  │
    │ │Administrateur  ┌──────────────┐                            │  │
    └─┘             │   │  Générer     │                            │  │
     │              │   │  Rapports    │                            │  │
    ─┼─             ├──>└──────────────┘                            │  │
     │              │                                                │  │
    ╱ ╲             │   ┌──────────────┐                            │  │
     ├──────────────┼──>│  Sauvegarder │                            │  │
     │              │   │  Base        │                            │  │
     │              │   └──────────────┘                            │  │
     │              │                                                │  │
     │              │   ┌──────────────┐                            │  │
     └──────────────┼──>│  Gérer       │                            │  │
                    │   │  Comptes     │                            │  │
                    │   └──────────────┘                            │  │
                    │                                                │  │
                    └────────────────────────────────────────────────┘  │
                                                                         │
ACTEURS (à droite) :                                                     │
                                                                         │
                                                              ┌─┐[BLACK_LEFT-POINTING_POINTER]───────┘
                                                              │ │ Système
                                                              └─┘ de
                                                               │  Paiement
                                                              ─┼─
                                                               │
                                                              ╱ ╲


GÉNÉRALISATION DES ACTEURS :

      ┌─┐
      │ │  Utilisateur (abstrait)
      └─┘
       │
      ─┼─
       │
      ╱ ╲
       [WHITE_UP-POINTING_TRIANGLE]
       │
  ┌────┴────┬────────────┐
  │         │            │
┌─┐       ┌─┐          ┌─┐
│ │       │ │          │ │
└─┘       └─┘          └─┘
 │         │            │
─┼─       ─┼─          ─┼─
 │         │            │
╱ ╲       ╱ ╲          ╱ ╲
Membre  Bibliothécaire Administrateur


RELATIONS CLÉS :

1. <<include>> (obligatoire) :
   - "Emprunter Livre" INCLUT "Vérifier Disponibilité"
   - "Emprunter Livre" INCLUT "Enregistrer Emprunt"

2. <<extend>> (optionnel) :
   - "Calculer Amende" ÉTEND "Retourner Livre"
     (seulement si retard)

3. Généralisation (variantes) :
   - "Chercher Livre" a 3 spécialisations :
     * Chercher par Titre
     * Chercher par Auteur
     * Chercher par ISBN

4. Généralisation d'acteurs :
   - Bibliothécaire hérite de Membre
     (peut faire tout ce qu'un membre fait + plus)
   - Administrateur hérite de Bibliothécaire
     (peut faire tout ce qu'un bibliothécaire fait + plus)

5. Acteur secondaire :
   - Système de Paiement (utilisé par "Payer Amende")


[IDEE] DESCRIPTIONS TEXTUELLES (exemples) :

┌────────────────────────────────────────────────────────────┐
│ Nom : Emprunter Livre                                      │
├────────────────────────────────────────────────────────────┤
│ Acteur principal : Membre                                  │
├────────────────────────────────────────────────────────────┤
│ Préconditions :                                            │
│   - Membre est authentifié                                 │
│   - Membre a moins de 5 livres empruntés                   │
│   - Membre n'a pas d'amendes impayées                      │
├────────────────────────────────────────────────────────────┤
│ Postconditions :                                           │
│   - Livre marqué comme emprunté                            │
│   - Date de retour enregistrée (21 jours)                  │
│   - Compteur d'emprunts membre incrémenté                  │
├────────────────────────────────────────────────────────────┤
│ Scénario nominal :                                         │
│   1. Membre recherche et sélectionne un livre             │
│   2. Système vérifie disponibilité                         │
│   3. Système vérifie limites du membre                     │
│   4. Système enregistre l'emprunt                          │
│   5. Système affiche date de retour                        │
│   6. Système envoie confirmation par email                 │
├────────────────────────────────────────────────────────────┤
│ Scénarios alternatifs :                                    │
│   A1. Au point 2, livre non disponible                    │
│       -> Proposer réservation                               │
│   A2. Au point 3, limite atteinte                         │
│       -> Message d'erreur                                   │
├────────────────────────────────────────────────────────────┤
│ Cas d'utilisation inclus :                                 │
│   - Vérifier Disponibilité                                 │
│   - Enregistrer Emprunt                                    │
└────────────────────────────────────────────────────────────┘
"""


# ----------------------------------------------------------------------------
# [COURS] EXERCICE PRATIQUE 2 : PLATEFORME E-LEARNING
# ----------------------------------------------------------------------------

"""
[COURS] ÉNONCÉ

Modélisez un diagramme de cas d'utilisation pour une plateforme e-learning.

ACTEURS :
- Étudiant (suit des cours en ligne)
- Professeur (crée et gère des cours)
- Administrateur (gère la plateforme)
- Système de paiement (Stripe)
- Service d'email (notifications)

FONCTIONNALITÉS :

1. ÉTUDIANT peut :
   - S'inscrire (normal ou via Google/Facebook)
   - S'authentifier (email ou réseaux sociaux)
   - Parcourir catalogue de cours
   - Acheter un cours (paiement par carte ou PayPal)
   - Suivre un cours (vidéos, quiz, ressources)
   - Passer un quiz
   - Télécharger certificat (après complétion 100%)
   - Laisser un avis sur un cours
   - Recevoir notifications (nouveaux cours, rappels)

2. PROFESSEUR peut :
   - Tout ce qu'un étudiant peut faire
   - Créer un cours (titre, description, prix)
   - Ajouter des leçons vidéo
   - Créer des quiz
   - Suivre statistiques de ses cours
   - Gérer prix et promotions
   - Répondre aux avis

3. ADMINISTRATEUR peut :
   - Tout ce qu'un professeur peut faire
   - Valider/rejeter nouveaux cours
   - Gérer utilisateurs
   - Générer rapports financiers
   - Configurer système

RÈGLES :
- S'inscrire a 3 variantes (email, Google, Facebook)
- S'authentifier a 2 variantes (email, social)
- Acheter cours INCLUT Traiter paiement
- Acheter cours INCLUT Envoyer confirmation
- Suivre cours PEUT ÊTRE ÉTENDU PAR Télécharger certificat (si complété)
- Télécharger certificat INCLUT Vérifier complétion
- Passer quiz PEUT ÊTRE ÉTENDU PAR Envoyer résultat par email

Créez le diagramme complet.


─────────────────────────────────────────────────────────────────────────
SOLUTION EXERCICE 2
─────────────────────────────────────────────────────────────────────────

DIAGRAMME DE CAS D'UTILISATION - Plateforme E-Learning


ACTEURS (à gauche) :

    ┌─┐
    │ │  Étudiant
    └─┘
     │
    ─┼─
     │              ┌────────────────────────────────────────────────┐
    ╱ ╲             │                                                │
     │              │         PLATEFORME E-LEARNING                 │
     │              │                                                │
     │              │   ┌──────────────┐                            │
     ├──────────────┼──>│  S'inscrire  │                            │
     │              │   └──────────────┘                            │
     │              │          [WHITE_UP-POINTING_TRIANGLE]                                    │
     │              │          │ généralisation                     │
     │              │   ┌──────┴───────┬───────────────┐           │
     │              │   │              │               │           │
     │              │ ┌─────────┐ ┌──────────┐  ┌──────────┐      │
     │              │ │Inscription││Inscription││Inscription│      │
     │              │ │par Email │ │via Google│ │via Facebook│     │
     │              │ └─────────┘ └──────────┘  └──────────┘      │
     │              │                                                │
     │              │   ┌──────────────┐                            │
     ├──────────────┼──>│ S'authentifier│                           │
     │              │   └──────────────┘                            │
     │              │          [WHITE_UP-POINTING_TRIANGLE]                                    │
     │              │          │ généralisation                     │
     │              │   ┌──────┴───────┐                           │
     │              │   │              │                           │
     │              │ ┌─────────┐ ┌──────────┐                    │
     │              │ │Auth par │ │ Auth via │                    │
     │              │ │ Email   │ │ Réseaux  │                    │
     │              │ └─────────┘ └──────────┘                    │
     │              │                                                │
     │              │   ┌──────────────┐                            │
     ├──────────────┼──>│  Parcourir   │                            │
     │              │   │  Catalogue   │                            │
     │              │   └──────────────┘                            │
     │              │                                                │
     │              │   ┌──────────────┐                            │
     ├──────────────┼──>│  Acheter     │──────┐                     │
     │              │   │  Cours       │      │ <<include>>         │
     │              │   └──────────────┘      │                     │
     │              │                         │                     │
     │              │                    ┌────┴────┬──────────┐     │
     │              │                    │         │          │     │
     │              │                    [BLACK_DOWN-POINTING_TRIANGLE]         [BLACK_DOWN-POINTING_TRIANGLE]          │     │
     │              │             ┌──────────┐ ┌──────────┐  │     │
     │              │             │ Traiter  │ │ Envoyer  │  │     │
     │              │             │ Paiement │─┤Confirmation│ │     │
     │              │             └──────────┘ └──────────┘  │     │
     │              │                    │                   │     │
     │              │                    └───────────────────┘     │
     │              │                                                │
     │              │   ┌──────────────┐                            │
     ├──────────────┼──>│  Suivre      │                            │
     │              │   │  Cours       │[BLACK_LEFT-POINTING_POINTER]────────┐                  │
     │              │   └──────────────┘         │ <<extend>>       │
     │              │                            │                  │
     │              │                      ┌──────────────┐         │
     │              │                      │ Télécharger  │         │
     │              │                      │ Certificat   │         │
     │              │                      └──────────────┘         │
     │              │                            │ <<include>>      │
     │              │                            [BLACK_DOWN-POINTING_TRIANGLE]                  │
     │              │                      ┌──────────────┐         │
     │              │                      │  Vérifier    │         │
     │              │                      │  Complétion  │         │
     │              │                      └──────────────┘         │
     │              │                                                │
     │              │   ┌──────────────┐                            │
     ├──────────────┼──>│  Passer      │[BLACK_LEFT-POINTING_POINTER]────────┐                  │
     │              │   │  Quiz        │         │ <<extend>>       │
     │              │   └──────────────┘         │                  │
     │              │                      ┌──────────────┐         │
     │              │                      │  Envoyer     │         │
     │              │                      │  Résultat    │         │
     │              │                      └──────────────┘         │
     │              │                                                │
     │              │   ┌──────────────┐                            │
     ├──────────────┼──>│  Laisser     │                            │
     │              │   │  Avis        │                            │
     │              │   └──────────────┘                            │
                    │                                                │
    ┌─┐             │                                                │
    │ │  Professeur │   ┌──────────────┐                            │
    └─┘             ├──>│  Créer       │                            │
     │              │   │  Cours       │                            │
    ─┼─             │   └──────────────┘                            │
     │              │                                                │
    ╱ ╲             │   ┌──────────────┐                            │
     │              │   │  Ajouter     │                            │
     ├──────────────┼──>│  Leçon Vidéo │                            │
     │              │   └──────────────┘                            │
     │              │                                                │
     │              │   ┌──────────────┐                            │
     ├──────────────┼──>│  Créer       │                            │
     │              │   │  Quiz        │                            │
     │              │   └──────────────┘                            │
     │              │                                                │
     │              │   ┌──────────────┐                            │
     ├──────────────┼──>│  Suivre      │                            │
     │              │   │  Statistiques│                            │
     │              │   └──────────────┘                            │
     │              │                                                │
     │              │   ┌──────────────┐                            │
     ├──────────────┼──>│  Gérer       │                            │
     │              │   │  Prix        │                            │
     │              │   └──────────────┘                            │
     │              │                                                │
     │              │   ┌──────────────┐                            │
     ├──────────────┼──>│  Répondre    │                            │
     │              │   │  aux Avis    │                            │
     │              │   └──────────────┘                            │
                    │                                                │
    ┌─┐             │                                                │
    │ │Administrateur  ┌──────────────┐                            │
    └─┘             │   │  Valider/    │                            │
     │              ├──>│  Rejeter     │                            │
    ─┼─             │   │  Cours       │                            │
     │              │   └──────────────┘                            │
    ╱ ╲             │                                                │
     │              │   ┌──────────────┐                            │
     ├──────────────┼──>│  Gérer       │                            │
     │              │   │  Utilisateurs│                            │
     │              │   └──────────────┘                            │
     │              │                                                │
     │              │   ┌──────────────┐                            │
     ├──────────────┼──>│  Générer     │                            │
     │              │   │  Rapports    │                            │
     │              │   └──────────────┘                            │
     │              │                                                │
     │              │   ┌──────────────┐                            │
     └──────────────┼──>│  Configurer  │                            │
                    │   │  Système     │                            │
                    │   └──────────────┘                            │
                    │                                                │
                    └────────────────────────────────────────────────┘
                                 │                       │
                                 │                       │
                                 [BLACK_DOWN-POINTING_TRIANGLE]                       [BLACK_DOWN-POINTING_TRIANGLE]
ACTEURS (à droite) :        ┌─┐                      ┌─┐
                            │ │  Système             │ │  Service
                            └─┘  de Paiement         └─┘  d'Email
                             │   (Stripe)             │
                            ─┼─                      ─┼─
                             │                        │
                            ╱ ╲                      ╱ ╲


GÉNÉRALISATION DES ACTEURS :

      ┌─┐
      │ │  Utilisateur (abstrait)
      └─┘
       │
      ─┼─
       │
      ╱ ╲
       [WHITE_UP-POINTING_TRIANGLE]
       │
  ┌────┴────┬──────────┐
  │         │          │
┌─┐       ┌─┐        ┌─┐
│ │       │ │        │ │
└─┘       └─┘        └─┘
 │         │          │
─┼─       ─┼─        ─┼─
 │         │          │
╱ ╱ ╲       ╱ ╱ ╲        ╱ ╱ ╲
Étudiant  Professeur Administrateur


[IDEE] RELATIONS DÉTAILLÉES :

1. GÉNÉRALISATION D'ACTEURS :
   Professeur hérite d'Étudiant
   -> Peut faire tout ce qu'un étudiant fait
   + Fonctionnalités supplémentaires
   
   Administrateur hérite de Professeur
   -> Peut tout faire
   + Administration système

2. GÉNÉRALISATION DE CAS D'UTILISATION :
   - "S'inscrire" a 3 variantes :
     * par Email (classique)
     * via Google (OAuth)
     * via Facebook (OAuth)
   
   - "S'authentifier" a 2 variantes :
     * par Email + Mot de passe
     * via Réseaux sociaux (Google, Facebook)

3. <<include>> (obligatoire) :
   - "Acheter Cours" INCLUT "Traiter Paiement"
     (impossible d'acheter sans payer)
   
   - "Acheter Cours" INCLUT "Envoyer Confirmation"
     (toujours envoyé après achat)
   
   - "Télécharger Certificat" INCLUT "Vérifier Complétion"
     (doit vérifier 100% avant certificat)

4. <<extend>> (optionnel) :
   - "Télécharger Certificat" ÉTEND "Suivre Cours"
     (seulement si cours terminé à 100%)
   
   - "Envoyer Résultat" ÉTEND "Passer Quiz"
     (si étudiant a activé notifications)

5. ACTEURS SECONDAIRES :
   - Système de Paiement (Stripe)
     Utilisé par "Traiter Paiement"
   
   - Service d'Email
     Utilisé par "Envoyer Confirmation" et "Envoyer Résultat"


[IDEE] DESCRIPTION TEXTUELLE EXEMPLE :

┌────────────────────────────────────────────────────────────┐
│ Nom : Acheter Cours                                        │
├────────────────────────────────────────────────────────────┤
│ Acteur principal : Étudiant                                │
├────────────────────────────────────────────────────────────┤
│ Acteurs secondaires : Système de Paiement, Service Email  │
├────────────────────────────────────────────────────────────┤
│ Préconditions :                                            │
│   - Étudiant est authentifié                               │
│   - Cours existe et est validé                             │
│   - Étudiant ne possède pas déjà le cours                  │
├────────────────────────────────────────────────────────────┤
│ Postconditions :                                           │
│   - Cours ajouté à la bibliothèque de l'étudiant           │
│   - Paiement traité                                        │
│   - Confirmation envoyée par email                         │
│   - Professeur notifié de la vente                         │
├────────────────────────────────────────────────────────────┤
│ Scénario nominal :                                         │
│   1. Étudiant sélectionne un cours                         │
│   2. Système affiche détails et prix                       │
│   3. Étudiant clique "Acheter"                             │
│   4. Système affiche formulaire de paiement                │
│   5. Étudiant entre infos carte bancaire                   │
│   6. [INCLUDE] Système traite paiement via Stripe          │
│   7. Système ajoute cours à bibliothèque étudiant          │
│   8. [INCLUDE] Système envoie confirmation email           │
│   9. Système affiche message de succès                     │
│   10. Système redirige vers le cours                       │
├────────────────────────────────────────────────────────────┤
│ Scénarios alternatifs :                                    │
│   A1. Au point 3, étudiant annule                         │
│       -> Retour au catalogue                                │
│   A2. Au point 5, coupon promo valide saisi              │
│       -> Réduction appliquée au prix                        │
├────────────────────────────────────────────────────────────┤
│ Scénarios d'exception :                                    │
│   E1. Au point 6, paiement refusé                         │
│       -> Message d'erreur, possibilité de réessayer         │
│   E2. Au point 6, timeout réseau                          │
│       -> Vérifier statut, ne pas facturer 2 fois            │
│   E3. Au point 8, email non livré                         │
│       -> Logger échec, retry automatique                    │
└────────────────────────────────────────────────────────────┘


[IDEE] AVANTAGES DE CE DIAGRAMME :

[OK] Vue claire des fonctionnalités par type d'utilisateur
[OK] Identification des services externes (paiement, email)
[OK] Hiérarchie d'acteurs évite duplication
[OK] Relations include/extend facilitent réutilisation
[OK] Base solide pour développement et tests
[OK] Communication efficace avec client non-technique
"""


# ----------------------------------------------------------------------------
# [DOCS] RÉCAPITULATIF CHAPITRE 4 - DIAGRAMME DE CAS D'UTILISATION
# ----------------------------------------------------------------------------

"""
CE QUE VOUS AVEZ APPRIS

[OK] Définition cas d'utilisation (objectif acteur avec système)
[OK] Identifier acteurs (humains, systèmes, matériel)
[OK] Distinction acteur principal vs secondaire
[OK] Relations : <<include>>, <<extend>>, généralisation
[OK] Frontière du système (rectangle)
[OK] Description textuelle détaillée
[OK] 2 exercices complets (bibliothèque, e-learning)


[CLE] POINTS CLÉS

1. Cas d'utilisation = Vue EXTERNE (point de vue utilisateur)
2. Acteur = EXTERNE au système (pas une classe !)
3. <<include>> = Toujours exécuté (A inclut B)
4. <<extend>> = Parfois exécuté (B étend A)
5. Généralisation = Variantes (A spécialise B)
6. Description textuelle ESSENTIELLE (diagramme insuffisant)


[IDEE] ERREURS FRÉQUENTES À ÉVITER

[X] Confondre cas d'utilisation et fonction technique
   [OK] "Acheter produit" (objectif utilisateur)
   [X] "Valider formulaire" (détail technique)

[X] Mettre trop de détails dans le diagramme
   [OK] Diagramme = vue d'ensemble
   [OK] Description = détails

[X] Oublier acteurs secondaires
   [OK] Systèmes externes importants !

[X] Confondre include et extend
   [OK] include = toujours (A ───> B)
   [OK] extend = parfois (A [BLACK_LEFT-POINTING_POINTER]─── B)

[X] Mettre des classes dans le diagramme
   [OK] Cas d'utilisation ≠ Classes
   [OK] Vue externe ≠ Vue interne


[OK] CHECKLIST

Vous devez être capable de :
[ ] Identifier acteurs d'un système
[ ] Lister les cas d'utilisation principaux
[ ] Distinguer acteur principal vs secondaire
[ ] Utiliser <<include>> correctement
[ ] Utiliser <<extend>> correctement
[ ] Créer hiérarchie d'acteurs et de cas d'utilisation
[ ] Dessiner frontière du système
[ ] Rédiger description textuelle complète


[COURS] BONNES PRATIQUES

1. COMMENCER SIMPLE
   - Lister acteurs
   - Lister objectifs par acteur
   - Dessiner relations de base
   - Ajouter include/extend si utile

2. NOM DES CAS D'UTILISATION
   - Verbe + Complément
   - Point de vue utilisateur
   - Clair et concis

3. NIVEAU DE DÉTAIL
   - Diagramme = 1 page maximum
   - Si trop complexe -> diviser en plusieurs diagrammes
   - Descriptions textuelles = détails

4. VALIDATION
   - Revoir avec utilisateurs
   - Vérifier complétude
   - Prioriser fonctionnalités


-> PROCHAINE ÉTAPE : Chapitre 5 - Diagramme de Séquence

Le diagramme de séquence montre COMMENT les cas d'utilisation
sont réalisés dans le TEMPS.

Vous apprendrez :
- Messages entre objets
- Lignes de vie
- Activation
- Fragments (loop, alt, opt)
- Interactions complexes

Les cas d'utilisation définissent QUOI
Les séquences définissent COMMENT

Prêt pour les interactions temporelles ? C'est parti ! [RAPIDE]
"""


# ============================================================================
# FIN DU CHAPITRE 4 - DIAGRAMME DE CAS D'UTILISATION
# Suite : Chapitre 5 - Diagramme de Séquence
# ============================================================================
# ============================================================================
# [LIVRE] UML - PARTIE 2 (SUITE) : DIAGRAMME DE SÉQUENCE
# ============================================================================


# ============================================================================
# [GUIDE] CHAPITRE 5 : DIAGRAMME DE SÉQUENCE (SEQUENCE DIAGRAM)
# ============================================================================

"""
[OBJECTIF] OBJECTIFS D'APPRENTISSAGE

À la fin de ce chapitre, vous saurez :
[OK] Qu'est-ce qu'un diagramme de séquence
[OK] Représenter objets et lignes de vie
[OK] Modéliser messages synchrones et asynchrones
[OK] Utiliser les fragments (loop, alt, opt, par)
[OK] Représenter création et destruction d'objets
[OK] Modéliser appels récursifs et retours
[OK] Créer des diagrammes de séquence complets
"""


# ----------------------------------------------------------------------------
# [REFLEXION] QU'EST-CE QU'UN DIAGRAMME DE SÉQUENCE ?
# ----------------------------------------------------------------------------

"""
DÉFINITION SIMPLE

Diagramme de Séquence = Vue TEMPORELLE des interactions

Montre :
├─ OBJETS qui participent (instances)
├─ MESSAGES échangés (appels de méthodes)
├─ ORDRE temporel (de haut en bas)
└─ LOGIQUE de contrôle (conditions, boucles)


[IDEE] AXES DU DIAGRAMME

HORIZONTAL (<-->) : Différents OBJETS/ACTEURS
VERTICAL (v)    : TEMPS (du haut vers le bas)

    Acteur    Objet1    Objet2    Objet3
      │         │         │         │
      │         │         │         │      <- Temps t1
      ├────────>│         │         │      
      │         ├────────>│         │      <- Temps t2
      │         │         ├────────>│      
      │         │         │<────────┤      <- Temps t3
      │<────────┤         │         │      
      │         │         │         │      <- Temps t4
      [BLACK_DOWN-POINTING_TRIANGLE]         [BLACK_DOWN-POINTING_TRIANGLE]         [BLACK_DOWN-POINTING_TRIANGLE]         [BLACK_DOWN-POINTING_TRIANGLE]


ANALOGIE [CONSTRUCTION]

Diagramme de Séquence = Chorégraphie de danse
- Chaque danseur = Objet
- Chaque mouvement = Message
- Ordre des mouvements = Séquence temporelle
- Musique = Ligne du temps


[REFLEXION] POURQUOI UTILISER ?

[OK] COMPRENDRE INTERACTIONS
- Comment objets collaborent
- Flux de contrôle
- Dépendances temporelles

[OK] CONCEPTION DÉTAILLÉE
- Détailler cas d'utilisation
- Identifier objets nécessaires
- Définir interfaces (méthodes)

[OK] DOCUMENTATION
- Algorithmes complexes
- Scénarios métier
- Processus asynchrones

[OK] DEBUGGING
- Comprendre bugs
- Optimiser performances
- Identifier goulots d'étranglement


[REFLEXION] QUAND L'UTILISER ?

[OK] UTILISEZ POUR :
- Implémenter un cas d'utilisation
- Scénarios complexes multi-objets
- Protocoles de communication
- Transactions distribuées
- Workflows asynchrones

[X] ÉVITEZ POUR :
- Vue d'ensemble système (utilisez composants)
- Structure statique (utilisez classes)
- Tous les scénarios possibles (trop lourd)


RELATION AVEC AUTRES DIAGRAMMES

Use Case -> Quoi faire (fonctionnalités)
         v
Séquence -> Comment faire (interactions détaillées)
         v
Classes -> Quoi implémenter (structure code)
"""


# ----------------------------------------------------------------------------
# [PERSONNE] PARTICIPANTS (OBJETS ET ACTEURS)
# ----------------------------------------------------------------------------

"""
TYPES DE PARTICIPANTS

1. ACTEUR (humain ou système externe)
2. OBJET (instance de classe)
3. ENTITÉ (base de données, fichier)


NOTATION

ACTEUR :
    ┌─┐
    │ │  Client
    └─┘
     │
    ─┼─
     │
    ╱ ╲
     │
     │ (ligne de vie)
     │


OBJET :
┌─────────────────┐
│ nom:Classe      │  <- Rectangle
└─────────────────┘
        │
        │ (ligne de vie)
        │


FORMATS POSSIBLES POUR OBJETS :

1. Anonyme : :Classe
   ┌─────────────┐
   │  :Panier    │
   └─────────────┘

2. Nommé : objet:Classe
   ┌─────────────┐
   │panier1:Panier│
   └─────────────┘

3. Sans classe : objet
   ┌─────────────┐
   │  database   │
   └─────────────┘


LIGNE DE VIE (Lifeline)

Ligne VERTICALE pointillée sous chaque participant

┌─────────────┐
│objet:Classe │
└─────────────┘
      │ <- Ligne pointillée
      │
      │
      │
      │
      [BLACK_DOWN-POINTING_TRIANGLE]


BARRE D'ACTIVATION (Execution Specification)

Rectangle sur ligne de vie = objet est ACTIF (exécute code)

┌─────────────┐
│objet:Classe │
└─────────────┘
      │
      │
      ┃ <- Barre d'activation (rectangle fin)
      ┃    Objet traite quelque chose
      ┃
      │
      │


EXEMPLE COMPLET :

    ┌─┐
    │ │  Client           ┌──────────────┐         ┌──────────────┐
    └─┘                   │panier:Panier │         │ bd:Database  │
     │                    └──────────────┘         └──────────────┘
    ─┼─                          │                        │
     │                           │                        │
    ╱ ╲                          │                        │
     │                           │                        │
     │    ajouter(prod)          │                        │
     ├─────────────────────────>┃│                        │
     │                          ┃│   sauvegarder()        │
     │                          ┃├──────────────────────>┃│
     │                          ┃│                       ┃│
     │                          ┃│      confirmation     ┃│
     │                          ┃│<──────────────────────┃│
     │        ok                ┃│                        │
     │<─────────────────────────┃│                        │
     │                           │                        │
     [BLACK_DOWN-POINTING_TRIANGLE]                           [BLACK_DOWN-POINTING_TRIANGLE]                        [BLACK_DOWN-POINTING_TRIANGLE]
"""


# ----------------------------------------------------------------------------
# [SPEECH_BALLOON] MESSAGES
# ----------------------------------------------------------------------------

"""
TYPES DE MESSAGES

1. MESSAGE SYNCHRONE (appel bloquant)
2. MESSAGE ASYNCHRONE (appel non-bloquant)
3. MESSAGE DE RETOUR (réponse)
4. MESSAGE VERS SOI-MÊME (auto-appel)


1. MESSAGE SYNCHRONE

Notation : Flèche PLEINE ->

A attend la réponse de B avant de continuer

  Objet A              Objet B
     │                    │
     │    methode()       │
     ├───────────────────>┃
     │                   ┃│ <- B exécute
     │                   ┃│
     │      retour       ┃│
     │<───────────────────┃
     │                    │
     [BLACK_DOWN-POINTING_TRIANGLE]                    [BLACK_DOWN-POINTING_TRIANGLE]

Exemples :
- Appel de fonction classique
- Requête HTTP synchrone
- Transaction base de données


2. MESSAGE ASYNCHRONE

Notation : Flèche OUVERTE ─>

A n'attend PAS la réponse de B

  Objet A              Objet B
     │                    │
     │    methode()       │
     ├───────────────────>│
     │                    ┃ <- B traite en parallèle
     │    continue        ┃
     │    ...             ┃
     [BLACK_DOWN-POINTING_TRIANGLE]                    [BLACK_DOWN-POINTING_TRIANGLE]

Exemples :
- Envoi d'email
- Message queue (RabbitMQ, Kafka)
- Événement UI
- Thread/Processus parallèle


3. MESSAGE DE RETOUR

Notation : Flèche POINTILLÉE [BLACK_LEFT-POINTING_POINTER]─ ─ ─

Réponse à un message

  Objet A              Objet B
     │                    │
     │    getTotal()      │
     ├───────────────────>┃
     │                   ┃│
     │    150.00         ┃│
     │[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ─ ─ ┃
     │                    │
     [BLACK_DOWN-POINTING_TRIANGLE]                    [BLACK_DOWN-POINTING_TRIANGLE]

Note : Retours souvent OMIS pour clarté (implicites)


4. MESSAGE VERS SOI-MÊME

Notation : Flèche qui revient sur même objet

  Objet A
     │
     │    methodePublique()
     ├────────────────────>┃
     │                    ┃│
     │  methodePrivee()  ┃│
     │  ┌────────────┐   ┃│
     │  │            [BLACK_DOWN-POINTING_TRIANGLE]   ┃│
     │  │           ┃┃   ┃│
     │  └────────────┘   ┃│
     │                   ┃│
     │                    │
     [BLACK_DOWN-POINTING_TRIANGLE]                    [BLACK_DOWN-POINTING_TRIANGLE]

Exemples :
- Méthode publique appelle méthode privée
- Récursion
- Validation interne


SYNTAXE DES MESSAGES

Format : nomMessage(paramètres) : typeRetour

Exemples :
- ajouter(produit)
- calculer() : float
- valider(email, mdp) : boolean
- envoyer()


MESSAGES AVEC CONDITIONS

On peut ajouter une GARDE (condition)

  Objet A              Objet B
     │                    │
     │ [solde > 0]        │
     │    debiter()       │
     ├───────────────────>┃
     │                    │
     [BLACK_DOWN-POINTING_TRIANGLE]                    [BLACK_DOWN-POINTING_TRIANGLE]

[condition] message()

La condition doit être vraie pour que message soit envoyé


NUMÉROTATION DES MESSAGES (optionnelle)

Pour clarifier l'ordre :

  Client           Panier          Database
     │               │                │
     │ 1: ajouter()  │                │
     ├──────────────>┃                │
     │              ┃│ 1.1: insert()  │
     │              ┃├───────────────>┃
     │              ┃│                │
     │              ┃│ 1.2: ok        │
     │              ┃[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ─┃
     │ 2: ok        ┃│                │
     [BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ┃                │
     │               │                │

Hiérarchie : 1, 1.1, 1.1.1, 1.2, 2, 2.1, etc.


TABLEAU RÉCAPITULATIF

┌──────────────┬──────────────┬──────────────────┐
│    TYPE      │  NOTATION    │     USAGE        │
├──────────────┼──────────────┼──────────────────┤
│ Synchrone    │  ────────>   │ Appel bloquant   │
│              │              │ Attend réponse   │
├──────────────┼──────────────┼──────────────────┤
│ Asynchrone   │  ────────>   │ Appel parallèle  │
│              │  (ouverte)   │ Continue direct  │
├──────────────┼──────────────┼──────────────────┤
│ Retour       │  [BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─  │ Réponse          │
│              │              │ (optionnel)      │
├──────────────┼──────────────┼──────────────────┤
│ Vers soi     │  (sync)           │ Auto-appel       │
│              │              │ Récursion        │
└──────────────┴──────────────┴──────────────────┘
"""


# ----------------------------------------------------------------------------
# [SCENARIO] CRÉATION ET DESTRUCTION D'OBJETS
# ----------------------------------------------------------------------------

"""
CRÉATION D'OBJET

Message pointant vers le HAUT du rectangle objet
Stéréotype <<create>> ou <<new>>

  Client              :Panier
     │                   
     │ <<create>>        
     ├──────────────────>┌─────────┐
     │                   │:Panier  │
     │                   └─────────┘
     │                       │
     │                       │
     [BLACK_DOWN-POINTING_TRIANGLE]                       [BLACK_DOWN-POINTING_TRIANGLE]

Alternative (plus courante) :
  Client              
     │                   
     │ new Panier()        
     ├──────────────────>┌─────────┐
     │                   │p:Panier │
     │                   └─────────┘
     │                       │


DESTRUCTION D'OBJET

Croix (X) à la fin de la ligne de vie

  Manager             :Temp
     │                   │
     │    terminer()     │
     ├──────────────────>┃
     │                  ┃│
     │                  ┃│
     │                   X  <- Objet détruit
     │                   
     [BLACK_DOWN-POINTING_TRIANGLE]                   

Exemples :
- delete en C++
- close() pour connexions
- Fin de scope
- Garbage collection


EXEMPLE COMPLET : Factory Pattern

  Client          Factory        :Produit
     │               │               
     │ creerProduit()│               
     ├──────────────>┃               
     │              ┃│ <<create>>    
     │              ┃├──────────────>┌────────┐
     │              ┃│               │:Produit│
     │              ┃│               └────────┘
     │              ┃│                   │
     │   produit    ┃│                   │
     [BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ┃                   │
     │               │                   │
     │    utiliser() │                   │
     ├───────────────┴──────────────────>┃
     │                                   ┃
     │                                   │
     │    terminer() │                   │
     ├───────────────┴──────────────────>┃
     │                                   X
     [BLACK_DOWN-POINTING_TRIANGLE]                                   
"""


# ----------------------------------------------------------------------------
# [SYNC] FRAGMENTS D'INTERACTION (COMBINED FRAGMENTS)
# ----------------------------------------------------------------------------

"""
FRAGMENTS = Structures de contrôle (if, loop, etc.)

Notation : RECTANGLE avec LABEL dans coin supérieur gauche


TYPES DE FRAGMENTS

1. ALT (alternative) = if/else
2. OPT (optional) = if
3. LOOP (loop) = for/while
4. PAR (parallel) = threads parallèles
5. REF (reference) = appel autre diagramme
6. BREAK = sortie de boucle


1. FRAGMENT ALT (Alternative) - IF/ELSE

┌─────────────────────────────────────────────────┐
│ alt                                             │
├─────────────────────────────────────────────────┤
│ [solde >= montant]                              │
│                                                 │
│  Client         Compte         Database        │
│    │               │               │            │
│    │  debiter()    │               │            │
│    ├──────────────>┃               │            │
│    │              ┃│  update()     │            │
│    │              ┃├──────────────>┃            │
│    │              ┃│               │            │
│    │   ok         ┃│               │            │
│    [BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ┃               │            │
│                                                 │
├─────[else]──────────────────────────────────────┤
│                                                 │
│    │  erreur      │               │            │
│    [BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ─               │            │
│                                                 │
└─────────────────────────────────────────────────┘


2. FRAGMENT OPT (Optional) - IF (sans else)

┌─────────────────────────────────────────────────┐
│ opt                                             │
├─────────────────────────────────────────────────┤
│ [client premium]                                │
│                                                 │
│  Client         Commande                        │
│    │               │                            │
│    │ appliquerRemise()                          │
│    ├──────────────>┃                            │
│    │              ┃│                            │
│    │   ok         ┃│                            │
│    [BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ┃                            │
│                                                 │
└─────────────────────────────────────────────────┘


3. FRAGMENT LOOP (Boucle) - FOR/WHILE

┌─────────────────────────────────────────────────┐
│ loop                                            │
├─────────────────────────────────────────────────┤
│ [pour chaque produit]                           │
│                                                 │
│  Panier        Produit        Database          │
│    │              │               │             │
│    │ getTotal()   │               │             │
│    ├─────────────>┃               │             │
│    │             ┃│ getPrix()     │             │
│    │             ┃├──────────────>┃             │
│    │             ┃│               │             │
│    │             ┃│  prix         │             │
│    │             ┃[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ┃             │
│    │   prix      ┃│               │             │
│    [BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ┃                │             │
│                                                 │
└─────────────────────────────────────────────────┘

Variantes :
- loop(n) : n fois
- loop(min, max) : entre min et max fois
- loop [condition] : tant que condition vraie


4. FRAGMENT PAR (Parallel) - Threads parallèles

┌─────────────────────────────────────────────────┐
│ par                                             │
├─────────────────────────────────────────────────┤
│  Thread1      ServiceA                          │
│    │              │                             │
│    │ process1()   │                             │
│    ├─────────────>┃                             │
│    │             ┃│                             │
│                                                 │
├─────────────────────────────────────────────────┤
│  Thread2      ServiceB                          │
│    │              │                             │
│    │ process2()   │                             │
│    ├─────────────>┃                             │
│    │             ┃│                             │
│                                                 │
└─────────────────────────────────────────────────┘

Les deux processus s'exécutent EN PARALLÈLE


5. FRAGMENT REF (Reference) - Appel autre diagramme

┌─────────────────────────────────────────────────┐
│ ref                                             │
├─────────────────────────────────────────────────┤
│    Authentification                             │
│                                                 │
│    (voir diagramme "Login Sequence")            │
│                                                 │
└─────────────────────────────────────────────────┘

Permet de ne pas dupliquer diagrammes complexes


6. FRAGMENT BREAK - Sortie anticipée

┌─────────────────────────────────────────────────┐
│ loop [pour chaque item]                         │
├─────────────────────────────────────────────────┤
│  Client        Panier                           │
│    │              │                             │
│    │ verifier()   │                             │
│    ├─────────────>┃                             │
│    │             ┃│                             │
│    │             ┃│                             │
│  ┌───────────────────────────────┐              │
│  │ break                         │              │
│  ├───────────────────────────────┤              │
│  │ [item invalide]               │              │
│  │   │   erreur   │              │              │
│  │   [BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ┃              │              │
│  │   SORTIE BOUCLE               │              │
│  └───────────────────────────────┘              │
│                                                 │
└─────────────────────────────────────────────────┘


FRAGMENTS IMBRIQUÉS

On peut imbriquer fragments :

┌──────────────────────────────────────────┐
│ loop [pour chaque commande]              │
├──────────────────────────────────────────┤
│   │                                      │
│   │                                      │
│  ┌────────────────────────────────┐     │
│  │ alt                            │     │
│  ├────────────────────────────────┤     │
│  │ [commande validée]             │     │
│  │   traiter()                    │     │
│  ├────[else]─────────────────────-┤     │
│  │   annuler()                    │     │
│  └────────────────────────────────┘     │
│                                          │
└──────────────────────────────────────────┘
"""


# ----------------------------------------------------------------------------
# [COURS] EXERCICE PRATIQUE 1 : SYSTÈME DE RÉSERVATION DE VOL
# ----------------------------------------------------------------------------

"""
[AIRPLANE] ÉNONCÉ

Créez un diagramme de séquence pour le cas d'utilisation :
"Réserver un vol"

SCÉNARIO :

1. Client recherche des vols (origine, destination, date)
2. Système interroge la base de données
3. Base de données retourne liste de vols disponibles
4. Client sélectionne un vol
5. SI le vol a des places disponibles :
     a. Système demande informations passager
     b. Client saisit informations
     c. Système demande paiement
     d. Client effectue paiement
     e. Système traite paiement via service externe (Stripe)
     f. SI paiement accepté :
          - Système réserve la place
          - Système génère billet électronique
          - Système envoie confirmation par email (asynchrone)
          - Système affiche confirmation
     g. SINON :
          - Système affiche erreur paiement
6. SINON :
     - Système affiche "vol complet"

OBJETS :
- :Client (acteur)
- :InterfaceWeb (UI)
- :ControleurVol (logique)
- :BaseDonnees
- :ServicePaiement (externe - Stripe)
- :ServiceEmail (asynchrone)

Dessinez le diagramme de séquence complet avec tous les fragments.


─────────────────────────────────────────────────────────────────────────
SOLUTION EXERCICE 1
─────────────────────────────────────────────────────────────────────────

DIAGRAMME DE SÉQUENCE - Réserver un Vol


  ┌─┐
  │ │Client    ┌────────────┐  ┌──────────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐
  └─┘          │:InterfaceWeb│  │:ControleurVol│  │:BaseDonnees│ │:ServicePmt│ │:ServiceEmail│
   │           └────────────┘  └──────────────┘  └──────────┘  └──────────┘  └──────────┘
  ─┼─                │                │                │              │              │
   │                 │                │                │              │              │
  ╱ ╲                │                │                │              │              │
   │                 │                │                │              │              │
   │ 1: rechercher   │                │                │              │              │
   │ Vols(origine,   │                │                │              │              │
   │ destination,date)                │                │              │              │
   ├────────────────>┃                │                │              │              │
   │                ┃│ 1.1: trouverVols()             │              │              │
   │                ┃├───────────────>┃                │              │              │
   │                ┃│               ┃│ 1.1.1: SELECT  │              │              │
   │                ┃│               ┃├───────────────>┃              │              │
   │                ┃│               ┃│               ┃│              │              │
   │                ┃│               ┃│ 1.1.2: listeVols│             │              │
   │                ┃│               ┃[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ─┃              │              │
   │                ┃│ 1.2: listeVols┃│                │              │              │
   │                ┃[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ─┃                │              │              │
   │ 2: afficherVols┃│                │                │              │              │
   [BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ─ ┃                │                │              │              │
   │                 │                │                │              │              │
   │ 3: selectionner │                │                │              │              │
   │    Vol(volID)   │                │                │              │              │
   ├────────────────>┃                │                │              │              │
   │                ┃│ 3.1: verifierDispo(volID)       │              │              │
   │                ┃├───────────────>┃                │              │              │
   │                ┃│               ┃│ 3.1.1: SELECT  │              │              │
   │                ┃│               ┃├───────────────>┃              │              │
   │                ┃│               ┃│ nbPlaces       │              │              │
   │                ┃│               ┃[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ─┃              │              │
   │                ┃│                │                │              │              │
   │  ┌────────────────────────────────────────────────────────────────────────────┐
   │  │ alt                                                                         │
   │  ├────────────────────────────────────────────────────────────────────────────┤
   │  │ [nbPlaces > 0]                                                              │
   │  │                ┃│                │                │              │          │
   │  │ 4: demanderInfo┃│                │                │              │          │
   │  │ Passager()     ┃│                │                │              │          │
   │  │[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ─┃                │                │              │          │
   │  │                 │                │                │              │          │
   │  │ 5: saisirInfo  │                │                │              │          │
   │  │   (nom,prenom, │                │                │              │          │
   │  │    passport)   │                │                │              │          │
   │  ├────────────────>┃                │                │              │          │
   │  │                ┃│ 5.1: sauverPassager()          │              │          │
   │  │                ┃├───────────────>┃                │              │          │
   │  │                ┃│               ┃│ INSERT         │              │          │
   │  │                ┃│               ┃├───────────────>┃              │          │
   │  │                ┃│               ┃│                │              │          │
   │  │                 │                │                │              │          │
   │  │ 6: demanderPmt()                │                │              │          │
   │  │[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ─┃                │                │              │          │
   │  │                 │                │                │              │          │
   │  │ 7: payer(carte, │                │                │              │          │
   │  │    montant)     │                │                │              │          │
   │  ├────────────────>┃                │                │              │          │
   │  │                ┃│ 7.1: traiterPmt(carte,montant) │              │          │
   │  │                ┃├───────────────>┃                │              │          │
   │  │                ┃│               ┃│ 7.1.1: charge()│              │          │
   │  │                ┃│               ┃├───────────────────────────────>┃         │
   │  │                ┃│               ┃│                │             ┃│         │
   │  │  ┌──────────────────────────────────────────────────────────────────────┐  │
   │  │  │ alt                                                                   │  │
   │  │  ├──────────────────────────────────────────────────────────────────────┤  │
   │  │  │ [paiement accepté]          ┃│                │             ┃│       │  │
   │  │  │                ┃│           ┃│ success        │             ┃│       │  │
   │  │  │                ┃│           ┃[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─┃       │  │
   │  │  │                ┃│ 7.2: reserverPlace(volID,passagerID)      │       │  │
   │  │  │                ┃├───────────>┃                │              │       │  │
   │  │  │                ┃│            ┃│ UPDATE         │              │       │  │
   │  │  │                ┃│            ┃├───────────────>┃              │       │  │
   │  │  │                ┃│            ┃│                │              │       │  │
   │  │  │                ┃│ 7.3: genererBillet()         │              │       │  │
   │  │  │                ┃├───────────>┃                │              │       │  │
   │  │  │                ┃│            ┃│ INSERT         │              │       │  │
   │  │  │                ┃│            ┃├───────────────>┃              │       │  │
   │  │  │                ┃│            ┃│  billetID      │              │       │  │
   │  │  │                ┃│            ┃[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ─┃              │       │  │
   │  │  │                ┃│            │                │              │       │  │
   │  │  │                ┃│ 7.4: envoyerConfirmation(email, billet)    │       │  │
   │  │  │                ┃├────────────────────────────────────────────────────>│  │
   │  │  │                ┃│            │                │              │       │  │
   │  │  │                ┃│  (asynchrone - ne bloque pas)              │       │  │
   │  │  │                ┃│            │                │              │       │  │
   │  │  │ 8: afficherConfirmation(billetID)            │              │       │  │
   │  │  │[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ─┃            │                │              │       │  │
   │  │  │                 │            │                │              │       │  │
   │  │  ├─────[else]──────────────────────────────────────────────────────────┤  │
   │  │  │                ┃│           ┃│ error          │              │       │  │
   │  │  │                ┃│           ┃[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─┃       │  │
   │  │  │                ┃│           │                │              │       │  │
   │  │  │ 9: afficherErreurPmt()      │                │              │       │  │
   │  │  │[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ─┃            │                │              │       │  │
   │  │  │                 │            │                │              │       │  │
   │  │  └──────────────────────────────────────────────────────────────────────┘  │
   │  │                                 │                │              │          │
   │  ├─────[else]────────────────────────────────────────────────────────────────┤
   │  │                                 │                │              │          │
   │  │ 10: afficherVolComplet()        │                │              │          │
   │  │[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ─ ─               │                │              │          │
   │  │                                 │                │              │          │
   │  └────────────────────────────────────────────────────────────────────────────┘
   │                 │                │                │              │              │
   [BLACK_DOWN-POINTING_TRIANGLE]                 [BLACK_DOWN-POINTING_TRIANGLE]                [BLACK_DOWN-POINTING_TRIANGLE]                [BLACK_DOWN-POINTING_TRIANGLE]              [BLACK_DOWN-POINTING_TRIANGLE]              [BLACK_DOWN-POINTING_TRIANGLE]


ANALYSE DU DIAGRAMME :

1. STRUCTURE TEMPORELLE :
   - Lecture de HAUT en BAS
   - Chaque message numéroté (1, 1.1, 1.1.1, etc.)
   - Hiérarchie claire des appels

2. FRAGMENTS UTILISÉS :
   
   a) ALT (alternative) niveau 1 : Places disponibles ?
      - [nbPlaces > 0] -> Processus de réservation
      - [else] -> Afficher "vol complet"
   
   b) ALT (alternative) niveau 2 : Paiement accepté ?
      - [paiement accepté] -> Réserver + Générer billet + Email
      - [else] -> Erreur paiement

3. MESSAGES SYNCHRONES vs ASYNCHRONES :
   
   SYNCHRONES (─────>) :
   - Tous les appels sauf email
   - Client attend réponse
   
   ASYNCHRONE (─────>) :
   - envoyerConfirmation() vers ServiceEmail
   - Ne bloque pas le flux principal
   - Email envoyé en arrière-plan

4. ACTEURS EXTERNES :
   - ServicePaiement (Stripe) : traite paiement
   - ServiceEmail : envoie confirmation (asynchrone)

5. BASE DE DONNÉES :
   - SELECT : recherche vols, vérifier dispo
   - INSERT : sauver passager, générer billet
   - UPDATE : réserver place

6. BARRES D'ACTIVATION :
   - Montrent quand objet est actif
   - Imbriquées pour appels synchrones


[IDEE] POINTS CLÉS :

[OK] Numérotation hiérarchique : 1, 1.1, 1.1.1
[OK] Fragments ALT imbriqués (2 niveaux)
[OK] Message asynchrone pour email (non-bloquant)
[OK] Acteurs externes clairement identifiés
[OK] Flux de contrôle complet et clair
[OK] Gestion des cas nominaux et d'erreur
"""


# ----------------------------------------------------------------------------
# [COURS] EXERCICE PRATIQUE 2 : SYSTÈME DE PANIER E-COMMERCE
# ----------------------------------------------------------------------------

"""
[SHOPPING_TROLLEY] ÉNONCÉ

Modélisez le diagramme de séquence pour :
"Passer une commande avec plusieurs produits"

SCÉNARIO :

1. Client ajoute produits au panier (boucle pour 3 produits)
   - Pour chaque produit :
     * Vérifier stock disponible
     * Si disponible : ajouter au panier
     * Si rupture : afficher message, ne pas ajouter

2. Client clique "Commander"

3. Système calcule total
   - Pour chaque ligne du panier :
     * Récupérer prix du produit
     * Calculer sous-total (quantité × prix)
   - Additionner tous les sous-totaux

4. SI client premium :
     - Appliquer remise 10%

5. Afficher récapitulatif commande

6. Client confirme

7. Système crée commande
   - Générer numéro commande
   - Pour chaque produit :
     * Décrémenter stock
     * Créer ligne commande

8. Système envoie notification par email (asynchrone)

9. Système affiche confirmation

OBJETS :
- :Client (acteur)
- :InterfaceWeb
- :Panier
- :Produit (plusieurs instances)
- :Commande (créée pendant séquence)
- :BaseDonnees
- :ServiceEmail

Utilisez les fragments : LOOP, ALT, OPT, et message <<create>>.


─────────────────────────────────────────────────────────────────────────
SOLUTION EXERCICE 2
─────────────────────────────────────────────────────────────────────────

DIAGRAMME DE SÉQUENCE - Passer Commande E-Commerce


  ┌─┐
  │ │Client   ┌────────────┐  ┌────────┐  ┌────────┐  ┌─────────┐  ┌──────────┐  ┌──────────┐
  └─┘         │:InterfaceWeb│  │:Panier │  │:Produit│  │:Commande│  │:BaseDonnees│ │:ServiceEmail│
   │          └────────────┘  └────────┘  └────────┘  └─────────┘  └──────────┘  └──────────┘
  ─┼─               │              │           │                          │              │
   │                │              │           │                          │              │
  ╱ ╲               │              │           │                          │              │
   │                │              │           │                          │              │
   │  ┌────────────────────────────────────────────────────────────────────────────────┐
   │  │ loop [pour 3 produits]                                                          │
   │  ├────────────────────────────────────────────────────────────────────────────────┤
   │  │                │              │           │                          │          │
   │  │ 1: ajouterProduit(produitID, qte)        │                          │          │
   │  ├────────────────>┃              │           │                          │          │
   │  │                ┃│ 1.1: verifierStock(produitID, qte)                │          │
   │  │                ┃├─────────────────────────────────────────────────>┃          │
   │  │                ┃│              │ 1.1.1: SELECT stock                │          │
   │  │                ┃│              │           │                        ┃│          │
   │  │                ┃│              │           │        stock           ┃│          │
   │  │                ┃│              │           │[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┃          │
   │  │                ┃│              │           │                          │          │
   │  │  ┌──────────────────────────────────────────────────────────────────────────┐  │
   │  │  │ alt                                                                       │  │
   │  │  ├──────────────────────────────────────────────────────────────────────────┤  │
   │  │  │ [stock >= qte]           │           │                          │        │  │
   │  │  │                ┃│ 1.2: ajouter(produit, qte)                    │        │  │
   │  │  │                ┃├─────────>┃           │                          │        │  │
   │  │  │                ┃│          ┃│          │                          │        │  │
   │  │  │                ┃│          ┃│ 1.2.1: creerLigne(produitID, qte) │        │  │
   │  │  │                ┃│          ┃├──────────────────────────────────>┃        │  │
   │  │  │                ┃│          ┃│          │                        ┃│        │  │
   │  │  │                ┃│ ok       ┃│          │                          │        │  │
   │  │  │                ┃[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─┃          │                          │        │  │
   │  │  │ ok             ┃│          │           │                          │        │  │
   │  │  │[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ─┃          │           │                          │        │  │
   │  │  │                 │          │           │                          │        │  │
   │  │  ├─────[else]──────────────────────────────────────────────────────────────┤  │
   │  │  │                 │          │           │                          │        │  │
   │  │  │ afficherRupture()│          │           │                          │        │  │
   │  │  │[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ─┃          │           │                          │        │  │
   │  │  │                 │          │           │                          │        │  │
   │  │  └──────────────────────────────────────────────────────────────────────────┘  │
   │  │                                │           │                          │          │
   │  └────────────────────────────────────────────────────────────────────────────────┘
   │                 │              │           │                          │              │
   │                 │              │           │                          │              │
   │ 2: commander() │              │           │                          │              │
   ├────────────────>┃              │           │                          │              │
   │                ┃│ 2.1: calculerTotal()    │                          │              │
   │                ┃├─────────────>┃           │                          │              │
   │                ┃│              ┃│          │                          │              │
   │  ┌──────────────────────────────────────────────────────────────────────────────┐  │
   │  │ loop [pour chaque ligne panier]                                               │  │
   │  ├──────────────────────────────────────────────────────────────────────────────┤  │
   │  │                ┃│              ┃│ 2.1.1: getPrix()                 │          │  │
   │  │                ┃│              ┃├─────────────────────────────────>┃          │  │
   │  │                ┃│              ┃│          │ SELECT prix           │          │  │
   │  │                ┃│              ┃│          │                        ┃│          │  │
   │  │                ┃│              ┃│          │        prix            ┃│          │  │
   │  │                ┃│              ┃│          │[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┃          │  │
   │  │                ┃│              ┃│ 2.1.2: calculerSousTotal()       │          │  │
   │  │                ┃│              ┃├────┐     │                          │          │  │
   │  │                ┃│              ┃│    │     │  sousTotal = qte × prix │          │  │
   │  │                ┃│              ┃│[BLACK_LEFT-POINTING_POINTER]───┘     │                          │          │  │
   │  │                ┃│              ┃│          │                          │          │  │
   │  └──────────────────────────────────────────────────────────────────────────────┘  │
   │                ┃│              ┃│ 2.1.3: additionner()                │              │
   │                ┃│              ┃├────┐     │                          │              │
   │                ┃│              ┃│    │     │  total = Σ sousTotal    │              │
   │                ┃│              ┃│[BLACK_LEFT-POINTING_POINTER]───┘     │                          │              │
   │                ┃│ total        ┃│          │                          │              │
   │                ┃[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─┃          │                          │              │
   │                ┃│              │           │                          │              │
   │  ┌──────────────────────────────────────────────────────────────────────────────┐  │
   │  │ opt [client premium]                                                          │  │
   │  ├──────────────────────────────────────────────────────────────────────────────┤  │
   │  │                ┃│ 2.2: appliquerRemise(10%)                       │          │  │
   │  │                ┃├─────────────>┃           │                          │          │  │
   │  │                ┃│              ┃│ total = total * 0.9              │          │  │
   │  │                ┃│ totalFinal   ┃│          │                          │          │  │
   │  │                ┃[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─┃          │                          │          │  │
   │  │                 │              │           │                          │          │  │
   │  └──────────────────────────────────────────────────────────────────────────────┘  │
   │                 │              │           │                          │              │
   │ 3: afficherRecap(total)        │           │                          │              │
   │[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ─┃              │           │                          │              │
   │                 │              │           │                          │              │
   │ 4: confirmer() │              │           │                          │              │
   ├────────────────>┃              │           │                          │              │
   │                ┃│ 4.1: creerCommande()    │     <<create>>           │              │
   │                ┃├─────────────────────────────────────────>┌──────────┐              │
   │                ┃│              │           │                │:Commande │              │
   │                ┃│              │           │                └──────────┘              │
   │                ┃│              │           │                     │                    │
   │                ┃│ 4.2: genererNumero()    │                     │                    │
   │                ┃├─────────────────────────────────────────────>┃                    │
   │                ┃│              │           │ 4.2.1: INSERT      ┃│                    │
   │                ┃│              │           │                   ┃├───────────────────>┃
   │                ┃│              │           │  numeroCommande   ┃│                    │
   │                ┃│              │           │                   ┃[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ─ ─ ─┃
   │                ┃│              │           │                    │                    │
   │  ┌──────────────────────────────────────────────────────────────────────────────┐  │
   │  │ loop [pour chaque ligne panier]                                               │  │
   │  ├──────────────────────────────────────────────────────────────────────────────┤  │
   │  │                ┃│              │           │ 4.3: decrementerStock()          │  │
   │  │                ┃├─────────────────────────────────────────────────────────────>┃ │
   │  │                ┃│              │           │                 UPDATE stock     ┃│ │
   │  │                ┃│              │           │                                   │  │
   │  │                ┃│              │           │ 4.4: creerLigneCommande()        │  │
   │  │                ┃├─────────────────────────────────────────>┃                    │
   │  │                ┃│              │           │               ┃│ INSERT           │  │
   │  │                ┃│              │           │               ┃├─────────────────>┃ │
   │  │                ┃│              │           │               ┃│                  │  │
   │  └──────────────────────────────────────────────────────────────────────────────┘  │
   │                 │              │           │                    │                    │
   │                ┃│ 4.5: envoyerConfirmation(email, commande)    │                    │
   │                ┃├───────────────────────────────────────────────────────────────────>│
   │                ┃│              │           │                    │  (asynchrone)      │
   │                 │              │           │                    │                    │
   │ 5: afficherConfirmation(numeroCommande)   │                    │                    │
   │[BLACK_LEFT-POINTING_POINTER]─ ─ ─ ─ ─ ─ ─ ─┃              │           │                    │                    │
   │                 │              │           │                    │                    │
   [BLACK_DOWN-POINTING_TRIANGLE]                 [BLACK_DOWN-POINTING_TRIANGLE]              [BLACK_DOWN-POINTING_TRIANGLE]           [BLACK_DOWN-POINTING_TRIANGLE]                    [BLACK_DOWN-POINTING_TRIANGLE]                    [BLACK_DOWN-POINTING_TRIANGLE]


ANALYSE DÉTAILLÉE :

1. FRAGMENTS UTILISÉS :

   a) LOOP (boucle) - 3 utilisations :
      - Ajouter 3 produits au panier
      - Calculer total (pour chaque ligne panier)
      - Créer lignes commande (pour chaque produit)

   b) ALT (alternative) :
      - Si stock disponible -> ajouter
      - Sinon -> afficher rupture

   c) OPT (optionnel) :
      - Si client premium -> appliquer remise 10%

2. CRÉATION D'OBJET :
   - :Commande est CRÉÉ pendant la séquence
   - Notation <<create>> ou flèche vers haut du rectangle

3. AUTO-APPELS :
   - Panier.calculerSousTotal() (appel interne)
   - Flèche qui revient sur même objet

4. MESSAGE ASYNCHRONE :
   - envoyerConfirmation() vers ServiceEmail
   - N'attend pas réponse
   - Système continue immédiatement

5. OPÉRATIONS BASE DE DONNÉES :
   - SELECT : vérifier stock, récupérer prix
   - INSERT : créer commande, créer lignes commande
   - UPDATE : décrémenter stock

6. NUMÉROTATION HIÉRARCHIQUE :
   1 -> 1.1 -> 1.1.1
   2 -> 2.1 -> 2.1.1, 2.1.2, 2.1.3
   etc.


[IDEE] POINTS CLÉS :

[OK] LOOP pour actions répétitives
[OK] ALT imbriqué dans LOOP (rupture stock)
[OK] OPT pour comportement conditionnel
[OK] <<create>> pour création objet
[OK] Auto-appel pour méthodes internes
[OK] Message asynchrone pour email
[OK] Gestion complète panier -> commande


[IDEE] SCÉNARIOS COUVERTS :

1. SCÉNARIO NOMINAL :
   - 3 produits en stock
   - Client non-premium
   - Paiement OK
   -> Commande créée, email envoyé

2. SCÉNARIO ALTERNATIF 1 :
   - 1 produit en rupture
   -> Message rupture, produit non ajouté
   -> Commande avec 2 produits seulement

3. SCÉNARIO ALTERNATIF 2 :
   - Client premium
   -> Remise 10% appliquée

4. COMBINAISONS :
   - Tous les scénarios peuvent se combiner
   - Diagramme unique couvre tous les cas !
"""


# ----------------------------------------------------------------------------
# [DOCS] RÉCAPITULATIF CHAPITRE 5 - DIAGRAMME DE SÉQUENCE
# ----------------------------------------------------------------------------

"""
CE QUE VOUS AVEZ APPRIS

[OK] Diagramme de séquence = vue temporelle des interactions
[OK] Objets avec lignes de vie (verticales pointillées)
[OK] Messages synchrones (──>) et asynchrones (──>)
[OK] Messages de retour ([BLACK_LEFT-POINTING_POINTER]─ ─ ─) optionnels
[OK] Barres d'activation (rectangles sur lignes de vie)
[OK] Création (<<create>>) et destruction (X) d'objets
[OK] Fragments : ALT, OPT, LOOP, PAR, REF, BREAK
[OK] Auto-appels (messages vers soi-même)
[OK] 2 exercices complets (réservation vol, e-commerce)


[CLE] POINTS CLÉS

1. TEMPS = AXE VERTICAL (de haut en bas)
2. OBJETS = AXE HORIZONTAL (participants)
3. Messages synchrones = ATTEND réponse
4. Messages asynchrones = CONTINUE immédiatement
5. Fragments = Structures de contrôle (if, loop, etc.)
6. Numérotation hiérarchique = Clarté de l'ordre


[IDEE] DIFFÉRENCES CLÉS

┌──────────────────────┬──────────────────────────┐
│ CAS D'UTILISATION    │ SÉQUENCE                 │
├──────────────────────┼──────────────────────────┤
│ Vue externe          │ Vue interne              │
│ QUOI faire           │ COMMENT faire            │
│ Acteur + système     │ Objets détaillés         │
│ Haut niveau          │ Bas niveau               │
│ Fonctionnalités      │ Messages/appels          │
└──────────────────────┴──────────────────────────┘


[OK] CHECKLIST

Vous devez être capable de :
[ ] Identifier objets participants
[ ] Dessiner lignes de vie
[ ] Représenter messages synchrones/asynchrones
[ ] Utiliser fragment ALT correctement
[ ] Utiliser fragment LOOP correctement
[ ] Utiliser fragment OPT correctement
[ ] Montrer création/destruction d'objets
[ ] Numéroter messages hiérarchiquement
[ ] Créer diagramme complet pour cas d'utilisation


[COURS] BONNES PRATIQUES

1. CLARTÉ :
   - Limiter nombre d'objets (5-7 max par diagramme)
   - Si trop complexe -> diviser en plusieurs diagrammes
   - Utiliser REF pour référencer autres diagrammes

2. NIVEAUX DE DÉTAIL :
   - Messages de retour souvent omis (implicites)
   - Numérotation optionnelle (utile si complexe)
   - Barres d'activation pas toujours nécessaires

3. ORGANISATION :
   - Acteurs à GAUCHE
   - Objets internes au CENTRE
   - Services externes à DROITE
   - Ordre logique de gauche à droite

4. FRAGMENTS :
   - ALT : 2 branches max (sinon illisible)
   - LOOP : préciser condition ou nombre itérations
   - Éviter imbrication > 3 niveaux


[ATTENTION] ERREURS FRÉQUENTES

[X] Mettre CLASSES au lieu d'OBJETS
   [OK] :Panier (objet)
   [X] Panier (classe)

[X] Oublier DIRECTION DU TEMPS
   [OK] Messages de haut en bas
   [X] Messages anarchiques

[X] Confondre SYNCHRONE et ASYNCHRONE
   [OK] Synchrone = attend
   [X] Asynchrone ≠ synchrone !

[X] Trop de DÉTAILS
   [OK] Messages essentiels
   [X] Chaque ligne de code


[COURS] POUR S'ENTRAÎNER

Créez des diagrammes de séquence pour :
1. Authentification 2FA (email + SMS)
2. Upload fichier avec progression
3. Chat en temps réel (WebSocket)
4. Processus de checkout e-commerce complet
5. Workflow d'approbation multi-niveaux


-> PROCHAINE ÉTAPE : Chapitre 6 - Diagramme d'Activités

Le diagramme d'activités montre les FLUX DE PROCESSUS.

Vous apprendrez :
- Activités et actions
- Flux de contrôle
- Décisions et boucles
- Partitions (swimlanes)
- Flux parallèles

Les séquences montrent INTERACTIONS entre objets
Les activités montrent PROCESSUS et WORKFLOWS

Prêt pour les workflows ? Allons-y ! [RAPIDE]
"""


# ============================================================================
# FIN DU CHAPITRE 5 - DIAGRAMME DE SÉQUENCE
# Suite : Chapitre 6 - Diagramme d'Activités
# ============================================================================
# ============================================================================
# [LIVRE] UML - PARTIE 2 (SUITE) : DIAGRAMME D'ACTIVITÉS
# ============================================================================


# ============================================================================
# [GUIDE] CHAPITRE 6 : DIAGRAMME D'ACTIVITÉS (ACTIVITY DIAGRAM)
# ============================================================================

"""
[OBJECTIF] OBJECTIFS D'APPRENTISSAGE

À la fin de ce chapitre, vous saurez :
[OK] Qu'est-ce qu'un diagramme d'activités
[OK] Modéliser flux de processus métier
[OK] Utiliser décisions et fusions
[OK] Représenter flux parallèles (fork/join)
[OK] Organiser avec partitions (swimlanes)
[OK] Modéliser boucles et conditions
[OK] Créer workflows complexes complets
"""


# ----------------------------------------------------------------------------
# [REFLEXION] QU'EST-CE QU'UN DIAGRAMME D'ACTIVITÉS ?
# ----------------------------------------------------------------------------

"""
DÉFINITION SIMPLE

Diagramme d'Activités = Vue des PROCESSUS et WORKFLOWS

Montre :
├─ ACTIVITÉS (actions à effectuer)
├─ FLUX de contrôle (ordre d'exécution)
├─ DÉCISIONS (branchements conditionnels)
├─ PARALLÉLISME (tâches simultanées)
└─ RESPONSABILITÉS (qui fait quoi)


[IDEE] CONCEPTS CLÉS

ACTIVITÉ = Ensemble d'actions formant un processus
ACTION = Étape élémentaire du processus
FLUX = Transition d'une action à une autre
DÉCISION = Choix entre plusieurs chemins
PARTITION = Responsable d'un groupe d'actions


ANALOGIE [CONSTRUCTION]

Diagramme d'Activités = Recette de cuisine
- Chaque étape = Action
- Ordre des étapes = Flux
- "Si pâte trop liquide, ajouter farine" = Décision
- "Pendant que four chauffe, préparer glaçage" = Parallélisme
- "Chef prépare, Apprenti nettoie" = Partitions


[REFLEXION] POURQUOI UTILISER ?

[OK] MODÉLISER PROCESSUS MÉTIER
- Workflows d'entreprise
- Procédures opérationnelles
- Circuits de validation

[OK] ANALYSE FONCTIONNELLE
- Comprendre processus existants
- Optimiser workflows
- Identifier goulots d'étranglement

[OK] SPÉCIFICATION ALGORITHMES
- Logique complexe
- Processus de décision
- Traitements par lots

[OK] DOCUMENTATION
- Procédures standard
- Guides opérationnels
- Formation utilisateurs


[REFLEXION] QUAND L'UTILISER ?

[OK] UTILISEZ POUR :
- Processus métier multi-acteurs
- Workflows avec décisions complexes
- Processus parallèles
- Circuits d'approbation
- Algorithmes de traitement

[X] ÉVITEZ POUR :
- Interactions entre objets (utilisez séquence)
- Structure système (utilisez classes/composants)
- Interface utilisateur (utilisez maquettes)


RELATION AVEC AUTRES DIAGRAMMES

Use Case -> Quoi faire (fonctionnalités)
         v
Activités -> Comment processus se déroule (workflow)
         v
Séquence -> Comment objets interagissent (messages)


[IDEE] DIFFÉRENCE ACTIVITÉS vs SÉQUENCE

┌──────────────────────┬──────────────────────────┐
│ ACTIVITÉS            │ SÉQUENCE                 │
├──────────────────────┼──────────────────────────┤
│ Vue PROCESSUS        │ Vue INTERACTIONS         │
│ Flux d'actions       │ Messages entre objets    │
│ Logique métier       │ Logique technique        │
│ Point de vue métier  │ Point de vue système     │
│ "Valider commande"   │ "commande.valider()"     │
└──────────────────────┴──────────────────────────┘
"""


# ----------------------------------------------------------------------------
# [OBJECTIF] ÉLÉMENTS DE BASE
# ----------------------------------------------------------------------------

"""
NOTATION UML POUR ACTIVITÉS


1. NŒUD INITIAL (Start)

Cercle plein noir

    [BLACK_CIRCLE]  <- Début du processus


2. ACTIVITÉ / ACTION

Rectangle aux coins arrondis

    ┌─────────────────┐
    │  Nom Activité   │
    └─────────────────┘


3. FLUX (Transition)

Flèche reliant actions

    ┌──────────┐
    │ Action A │
    └──────────┘
         │
         v
    ┌──────────┐
    │ Action B │
    └──────────┘


4. NŒUD FINAL (End)

Cercle avec point au centre

    [BULLSEYE]  <- Fin du processus


5. DÉCISION (Decision)

Losange avec condition

         ┌──────────┐
         │  Action  │
         └──────────┘
              │
              v
           [WHITE_DIAMOND]─────[WHITE_DIAMOND]  <- Losange
          /       \
    [oui]/         \[non]
        /           \
       v             v
  ┌────────┐    ┌────────┐
  │Action A│    │Action B│
  └────────┘    └────────┘


6. FUSION (Merge)

Losange qui regroupe flux

  ┌────────┐    ┌────────┐
  │Action A│    │Action B│
  └────────┘    └────────┘
       \           /
        \         /
         ->       <-
           [WHITE_DIAMOND]───[WHITE_DIAMOND]  <- Losange
              │
              v
         ┌──────────┐
         │ Suite... │
         └──────────┘


EXEMPLE SIMPLE COMPLET :

        [BLACK_CIRCLE]  Début
        │
        v
    ┌─────────────┐
    │  Démarrer   │
    └─────────────┘
        │
        v
     [WHITE_DIAMOND]─────[WHITE_DIAMOND]
    /       \
   / Prêt?  \
  /           \
[oui]         [non]
 │              │
 v              v
┌────┐      ┌──────┐
│Exec│      │Attend│
└────┘      └──────┘
 │              │
 │              │
 └──────┬───────┘
        v
       [BULLSEYE]  Fin
"""


# ----------------------------------------------------------------------------
# [MELANGE] DÉCISIONS ET FUSIONS
# ----------------------------------------------------------------------------

"""
DÉCISION (Decision Node)

Un flux ENTRE, plusieurs flux SORTENT
Losange avec conditions sur chaque branche


FORMAT :

         ┌──────────┐
         │  Action  │
         └──────────┘
              │
              v
           [WHITE_DIAMOND]─────[WHITE_DIAMOND]
          /       \
    [cond1]/       \[cond2]
          /         \
         v           v
    ┌────────┐  ┌────────┐
    │Action A│  │Action B│
    └────────┘  └────────┘


CONDITIONS :
- Entre crochets [condition]
- Mutuellement exclusives
- Couvrir tous les cas
- Souvent [oui]/[non] ou [vrai]/[faux]


DÉCISION MULTIPLE (> 2 branches)

              [WHITE_DIAMOND]─────[WHITE_DIAMOND]
             /   │   \
      [bas] /    │    \ [haut]
           /     │     \
          v   [moyen]   v
         ...     v     ...
                ...


FUSION (Merge Node)

Plusieurs flux ENTRENT, un flux SORT
Même symbole losange, mais inverse


FORMAT :

    ┌────────┐  ┌────────┐
    │Action A│  │Action B│
    └────────┘  └────────┘
         \         /
          \       /
           ->     <-
           [WHITE_DIAMOND]───[WHITE_DIAMOND]
              │
              v
         ┌──────────┐
         │ Suite... │
         └──────────┘


EXEMPLE COMPLET : VALIDATION DOCUMENT

        [BLACK_CIRCLE]
        │
        v
    ┌─────────────┐
    │  Soumettre  │
    │  Document   │
    └─────────────┘
        │
        v
     [WHITE_DIAMOND]─────[WHITE_DIAMOND]
    /       \
   / Valide?\
  /           \
[oui]         [non]
 │              │
 v              v
┌──────┐    ┌──────────┐
│Approuver│ │ Rejeter  │
└──────┘    └──────────┘
 │              │
 │              v
 │          ┌──────────┐
 │          │ Notifier │
 │          │ Auteur   │
 │          └──────────┘
 │              │
 └──────┬───────┘
        v
       [BULLSEYE]


[ATTENTION] RÈGLES IMPORTANTES

[OK] Décision : 1 entrée -> N sorties
[OK] Fusion : N entrées -> 1 sortie
[OK] Conditions mutuellement exclusives
[OK] [else] pour "sinon" (catch-all)
"""


# ----------------------------------------------------------------------------
# [RAPIDE] FLUX PARALLÈLES (FORK & JOIN)
# ----------------------------------------------------------------------------

"""
FORK (Séparation) - Lancer tâches PARALLÈLES

Barre horizontale ÉPAISSE
Un flux ENTRE, plusieurs flux SORTENT (simultanés)


NOTATION :

         ┌──────────┐
         │  Action  │
         └──────────┘
              │
              v
         ═════════  <- Barre épaisse
         │   │   │
         │   │   │  (Tous en PARALLÈLE)
         v   v   v
       ┌───┬───┬───┐
       │ A │ B │ C │
       └───┴───┴───┘


JOIN (Synchronisation) - Attendre fin de TOUTES les tâches

Barre horizontale ÉPAISSE
Plusieurs flux ENTRENT, un flux SORT
Attend que TOUTES les branches soient terminées


NOTATION :

       ┌───┬───┬───┐
       │ A │ B │ C │
       └───┴───┴───┘
         │   │   │
         │   │   │  (Attendre tous)
         v   v   v
         ═════════  <- Barre épaisse
              │
              v
         ┌──────────┐
         │  Suite   │
         └──────────┘


EXEMPLE COMPLET : PRÉPARATION REPAS

        [BLACK_CIRCLE]
        │
        v
    ┌─────────────┐
    │ Commencer   │
    │ Préparation │
    └─────────────┘
        │
        v
    ═════════  FORK
    │   │   │
    │   │   │
    v   v   v
┌──────┬──────┬──────┐
│Cuire │Laver │Mettre│
│Viande│Légumes│Table│
└──────┴──────┴──────┘
    │   │   │
    │   │   │
    v   v   v
    ═════════  JOIN (attendre tout)
        │
        v
    ┌─────────────┐
    │   Servir    │
    └─────────────┘
        │
        v
       [BULLSEYE]


FORK + JOIN + DÉCISION combinés

        [BLACK_CIRCLE]
        │
    ═════════  FORK
    │       │
    v       v
┌──────┐ ┌──────┐
│Task A│ │Task B│
└──────┘ └──────┘
    │       │
    │       v
    │    [WHITE_DIAMOND]─────[WHITE_DIAMOND]
    │   /       \
    │ [ok]     [ko]
    │  │         │
    │  v         v
    │ ┌──┐    ┌────┐
    │ │OK│    │Erreur│
    │ └──┘    └────┘
    │  │         │
    │  └────┬────┘
    │       │
    v       v
    ═════════  JOIN
        │
        v
       [BULLSEYE]


[IDEE] FORK vs DÉCISION

┌──────────────────┬──────────────────────┐
│ FORK             │ DÉCISION             │
├──────────────────┼──────────────────────┤
│ Barre épaisse    │ Losange              │
│ TOUTES exécutées │ UNE SEULE exécutée   │
│ En PARALLÈLE     │ Selon CONDITION      │
│ JOIN obligatoire │ MERGE optionnel      │
└──────────────────┴──────────────────────┘
"""


# ----------------------------------------------------------------------------
# [SWIMMER] PARTITIONS (SWIMLANES)
# ----------------------------------------------------------------------------

"""
QU'EST-CE QU'UNE PARTITION ?

Partition (Swimlane) = Colonne ou ligne représentant un ACTEUR

Organise le diagramme par RESPONSABILITÉ :
- Qui fait quoi
- Départements
- Rôles
- Systèmes


NOTATION VERTICALE (la plus courante)

┌────────────┬────────────┬────────────┐
│  Client    │ Serveur    │  Database  │
├────────────┼────────────┼────────────┤
│     [BLACK_CIRCLE]      │            │            │
│     │      │            │            │
│     v      │            │            │
│ ┌──────┐   │            │            │
│ │Demande│  │            │            │
│ └──────┘   │            │            │
│     │      │            │            │
│     │──────┼───────>    │            │
│            │  ┌──────┐  │            │
│            │  │Traiter│ │            │
│            │  └──────┘  │            │
│            │     │      │            │
│            │     │──────┼────────>   │
│            │            │ ┌──────┐   │
│            │            │ │Query │   │
│            │            │ └──────┘   │
│            │            │    │       │
│            │     [BLACK_LEFT-POINTING_POINTER]──────┼────┘       │
│            │  ┌──────┐  │            │
│            │  │Formater│ │            │
│            │  └──────┘  │            │
│     [BLACK_LEFT-POINTING_POINTER]──────┼────┘       │            │
│  ┌──────┐  │            │            │
│  │Afficher│ │            │            │
│  └──────┘  │            │            │
│     │      │            │            │
│     v      │            │            │
│     [BULLSEYE]      │            │            │
└────────────┴────────────┴────────────┘


NOTATION HORIZONTALE (moins courante)

┌────────────────────────────────────┐
│          Client                    │
├────────────────────────────────────┤
│  [BLACK_CIRCLE]->[Action1]->[Action2]->...         │
├────────────────────────────────────┤
│          Système                   │
├────────────────────────────────────┤
│     ->[Traiter]->[Valider]->...       │
├────────────────────────────────────┤
│         Database                   │
├────────────────────────────────────┤
│        ->[Sauver]->[BULLSEYE]                 │
└────────────────────────────────────┘


FLUX ENTRE PARTITIONS

Les flèches TRAVERSENT les partitions

Montre :
- Handoff (passage de responsabilité)
- Communication entre acteurs
- Synchronisation


EXEMPLE : PROCESSUS D'EMBAUCHE

┌─────────────┬─────────────┬─────────────┐
│  Candidat   │     RH      │  Manager    │
├─────────────┼─────────────┼─────────────┤
│      [BLACK_CIRCLE]      │             │             │
│      │      │             │             │
│ ┌────────┐  │             │             │
│ │Postuler│  │             │             │
│ └────────┘  │             │             │
│      │──────┼──────>      │             │
│             │ ┌────────┐  │             │
│             │ │Trier   │  │             │
│             │ │CV      │  │             │
│             │ └────────┘  │             │
│             │      │      │             │
│             │      v      │             │
│             │   [WHITE_DIAMOND]─────[WHITE_DIAMOND]   │             │
│             │  / Qualifié?\             │
│             │ /           \             │
│             │[oui]        [non]         │
│             │ │            │            │
│             │ │────────────┼──────>     │
│             │              │ ┌──────┐   │
│             │              │ │Interview│ │
│             │              │ └──────┘   │
│             │              │    │       │
│             │              │    v       │
│             │              │ [WHITE_DIAMOND]─────[WHITE_DIAMOND]    │
│             │              │/ Embaucher?\│
│             │              │[oui]  [non]│
│             │       [BLACK_LEFT-POINTING_POINTER]──────┼──┘    │    │
│             │  ┌────────┐ │       │    │
│             │  │Préparer│ │       │    │
│             │  │Contrat │ │       │    │
│             │  └────────┘ │       │    │
│      [BLACK_LEFT-POINTING_POINTER]──────┼──────┘      │       │    │
│  ┌────────┐│             │       │    │
│  │Signer  ││             │       │    │
│  └────────┘│             │       │    │
│      │     │             │       │    │
│      v     │             │       v    │
│      [BULLSEYE]     │             │      [BULLSEYE]     │
└─────────────┴─────────────┴─────────────┘


UTILITÉ DES PARTITIONS

[OK] CLARIFIER RESPONSABILITÉS
   Qui fait quelle action

[OK] IDENTIFIER HANDOFFS
   Passages entre départements/systèmes

[OK] DÉTECTER INEFFICACITÉS
   Trop d'allers-retours

[OK] SIMPLIFIER DIAGRAMMES COMPLEXES
   Organisation visuelle claire
"""


# ----------------------------------------------------------------------------
# [SYNC] BOUCLES ET STRUCTURES AVANCÉES
# ----------------------------------------------------------------------------

"""
BOUCLE (Loop)

Représentation : Flèche qui revient en arrière


MÉTHODE 1 : Flèche de retour

    ┌──────────┐
    │  Début   │
    └──────────┘
         │
         v
    ┌──────────┐  [BLACK_LEFT-POINTING_POINTER]───────┐
    │ Traiter  │          │
    │  Item    │          │
    └──────────┘          │
         │                │
         v                │
      [WHITE_DIAMOND]─────[WHITE_DIAMOND]             │
     / Autres \           │
    / Items?  \           │
   /           \          │
  [oui]        [non]      │
   │             │        │
   └─────────────┘        │
                          │
                          v
                     ┌──────────┐
                     │   Fin    │
                     └──────────┘


MÉTHODE 2 : Région d'activité avec note

    ┌────────────────────────┐
    │ ┌──────────────────┐   │
    │ │ LOOP             │   │
    │ │ [pour chaque X]  │   │
    │ ├──────────────────┤   │
    │ │                  │   │
    │ │  ┌──────────┐    │   │
    │ │  │ Traiter  │    │   │
    │ │  │    X     │    │   │
    │ │  └──────────┘    │   │
    │ │                  │   │
    │ └──────────────────┘   │
    └────────────────────────┘


BOUCLE AVEC CONDITION DE SORTIE

         [BLACK_CIRCLE]
         │
    ┌────┴────┐
    │         │  [BLACK_LEFT-POINTING_POINTER]───────┐
    │ Action  │          │
    └────┬────┘          │
         │               │
         v               │
      [WHITE_DIAMOND]─────[WHITE_DIAMOND]            │
     /Continuer\         │
    /  Boucle?  \        │
   /             \       │
  [oui]          [non]   │
   │               │     │
   └───────────────┘     │
                         │
                         v
                        [BULLSEYE]


WHILE vs DO-WHILE

WHILE (condition au début) :
         [BLACK_CIRCLE]
         │
         v
      [WHITE_DIAMOND]─────[WHITE_DIAMOND]  [BLACK_LEFT-POINTING_POINTER]───────┐
     /Condition\        │
    /           \       │
   [oui]        [non]   │
    │             │     │
    v             v     │
 ┌──────┐        [BULLSEYE]      │
 │Action│               │
 └──────┘               │
    │                   │
    └───────────────────┘


DO-WHILE (condition à la fin) :
         [BLACK_CIRCLE]
         │
    ┌────┴────┐  [BLACK_LEFT-POINTING_POINTER]───────┐
    │         │           │
    │ Action  │           │
    └────┬────┘           │
         │                │
         v                │
      [WHITE_DIAMOND]─────[WHITE_DIAMOND]             │
     /Condition\          │
    /           \         │
   [oui]        [non]     │
    │             │       │
    └─────────────┘       │
                          v
                         [BULLSEYE]


BOUCLES IMBRIQUÉES

         [BLACK_CIRCLE]
         │
    ┌────┴────┐  [BLACK_LEFT-POINTING_POINTER]───────────┐
    │ LOOP 1  │              │ Boucle externe
    │         │  [BLACK_LEFT-POINTING_POINTER]───────┐   │
    │  ┌──────┐│         │   │
    │  │LOOP 2││         │   │ Boucle interne
    │  │      ││         │   │
    │  │┌────┐││         │   │
    │  ││Act ││ │         │   │
    │  │└────┘││         │   │
    │  │      ││         │   │
    │  │ [WHITE_DIAMOND]──[WHITE_DIAMOND] ││         │   │
    │  │/    \││         │   │
    │  │      ││         │   │
    │  └──────┘│         │   │
    │    [WHITE_DIAMOND]──[WHITE_DIAMOND]  │         │   │
    │   /    \ │         │   │
    └─────────┘          │   │
         v               │   │
        [BULLSEYE]                │   │


SIGNAUX ET ÉVÉNEMENTS

SIGNAL ENVOYÉ (Send Signal) :

    ┌──────────┐
    │  Action  │
    └──────────┘
         │
         v
      ╱──────╲  <- Pentagone (pointe à droite)
     ╱ Signal ╲
     ╲  envoyé╱
      ╲──────╱


SIGNAL REÇU (Receive Signal) :

      ╱──────╲  <- Pentagone concave (pointe à gauche)
     ╱ Signal ╲
    ╱   reçu  ╲
    ╲─────────╱
         │
         v
    ┌──────────┐
    │  Action  │
    └──────────┘


ÉVÉNEMENT TEMPOREL (Time Event) :

    ┌──────────┐
    │  Action  │
    └──────────┘
         │
         v
     ┌────[WATCH]────┐  <- Sablier
     │Attendre  │
     │  5 min   │
     └──────────┘
         │
         v
    ┌──────────┐
    │  Suite   │
    └──────────┘
"""


# ----------------------------------------------------------------------------
# [COURS] EXERCICE PRATIQUE 1 : PROCESSUS DE COMMANDE EN LIGNE
# ----------------------------------------------------------------------------

"""
[SHOPPING_TROLLEY] ÉNONCÉ

Créez un diagramme d'activités pour le processus de commande e-commerce.

PROCESSUS :

1. Client ajoute produits au panier

2. Client clique "Commander"

3. Système vérifie si client connecté :
   - SI non connecté : 
     * Client s'authentifie
     * SI échec : Fin (abandonner)
     * SI succès : Continuer

4. Système calcule total

5. SI total > 0 :
   - Client choisit mode livraison
   - Client entre adresse livraison
   - Client choisit mode paiement

6. SINON (panier vide) :
   - Message erreur
   - Fin

7. Traitement PARALLÈLE :
   - Branche A : Vérifier stock pour chaque produit
     * SI rupture : Retirer du panier
   - Branche B : Réserver montant sur carte
     * SI refusé : Fin (paiement échoué)
   
8. JOIN (attendre les deux branches)

9. SI tout OK :
   - Créer commande
   - Décrémenter stock
   - Charger carte
   - Envoyer confirmation email (signal asynchrone)
   - Afficher confirmation

10. Fin

PARTITIONS (Swimlanes) :
- Client
- Système Web
- Service Paiement
- Service Stock
- Service Email

Dessinez le diagramme d'activités complet avec partitions.


─────────────────────────────────────────────────────────────────────────
SOLUTION EXERCICE 1
─────────────────────────────────────────────────────────────────────────

DIAGRAMME D'ACTIVITÉS - Processus Commande E-Commerce


┌─────────────┬─────────────┬─────────────┬─────────────┬─────────────┐
│   Client    │ Système Web │   Service   │   Service   │   Service   │
│             │             │  Paiement   │    Stock    │    Email    │
├─────────────┼─────────────┼─────────────┼─────────────┼─────────────┤
│      [BLACK_CIRCLE]      │             │             │             │             │
│      │      │             │             │             │             │
│ ┌────────┐  │             │             │             │             │
│ │ Ajouter│  │             │             │             │             │
│ │Produits│  │             │             │             │             │
│ └────────┘  │             │             │             │             │
│      │      │             │             │             │             │
│ ┌────────┐  │             │             │             │             │
│ │Cliquer │  │             │             │             │             │
│ │Commander│ │             │             │             │             │
│ └────────┘  │             │             │             │             │
│      │──────┼──────>      │             │             │             │
│             │ ┌────────┐  │             │             │             │
│             │ │Vérifier│  │             │             │             │
│             │ │Connexion│ │             │             │             │
│             │ └────────┘  │             │             │             │
│             │      │      │             │             │             │
│             │      v      │             │             │             │
│             │   [WHITE_DIAMOND]─────[WHITE_DIAMOND]   │             │             │             │
│             │  /Connecté?\│             │             │             │
│             │ /           \             │             │             │
│             │[non]        [oui]         │             │             │
│             │ │             │           │             │             │
│      [BLACK_LEFT-POINTING_POINTER]──────┼─┘             │           │             │             │
│ ┌────────┐  │               │           │             │             │
│ │S'authen-│ │               │           │             │             │
│ │tifier   │ │               │           │             │             │
│ └────────┘  │               │           │             │             │
│      │──────┼──────>        │           │             │             │
│             │ ┌────────┐    │           │             │             │
│             │ │Valider │    │           │             │             │
│             │ │Identité│    │           │             │             │
│             │ └────────┘    │           │             │             │
│             │      │        │           │             │             │
│             │      v        │           │             │             │
│             │   [WHITE_DIAMOND]─────[WHITE_DIAMOND]     │           │             │             │
│             │  / Valide?\   │           │             │             │
│             │ /           \  │           │             │             │
│             │[non]        [oui]         │             │             │
│             │ │             │           │             │             │
│             │ v             └───────────┼──────┐      │             │
│             │[BULLSEYE] (Abandon)                │      │      │             │
│             │                           │      │      │             │
│             │               ┌───────────┼──────┘      │             │
│             │               │           │             │             │
│             │               v           │             │             │
│             │          ┌────────┐       │             │             │
│             │          │Calculer│       │             │             │
│             │          │ Total  │       │             │             │
│             │          └────────┘       │             │             │
│             │               │           │             │             │
│             │               v           │             │             │
│             │            [WHITE_DIAMOND]─────[WHITE_DIAMOND]        │             │             │
│             │           /Total>0\       │             │             │
│             │          /         \      │             │             │
│             │        [oui]      [non]   │             │             │
│             │         │           │     │             │             │
│      [BLACK_LEFT-POINTING_POINTER]──────┼─────────┘           │     │             │             │
│ ┌────────┐  │                     │     │             │             │
│ │Choisir │  │                     v     │             │             │
│ │Livraison│ │              ┌──────────┐ │             │             │
│ └────────┘  │              │ Message  │ │             │             │
│      │      │              │  Erreur  │ │             │             │
│ ┌────────┐  │              └──────────┘ │             │             │
│ │Entrer  │  │                     │     │             │             │
│ │Adresse │  │                     v     │             │             │
│ └────────┘  │                     [BULLSEYE]     │             │             │
│      │      │                           │             │             │
│ ┌────────┐  │                           │             │             │
│ │Choisir │  │                           │             │             │
│ │Paiement│  │                           │             │             │
│ └────────┘  │                           │             │             │
│      │──────┼──────>                    │             │             │
│             │                           │             │             │
│             │  ═════════════════════════════════  FORK              │
│             │         │                 │             │             │
│             │         │                 │             │             │
│             │         v                 v             │             │
│             │    ┌─────────┐      ┌─────────┐        │             │
│             │    │Vérifier │      │ Réserver│        │             │
│             │    │Stock────┼──────┼──>Montant────────┼──────>      │
│             │    └─────────┘      └─────────┘        │ ┌─────────┐ │
│             │         │                 │            │ │Autoriser│ │
│             │    LOOP │                 │            │ │ Carte   │ │
│             │ [chaque │                 │            │ └─────────┘ │
│             │  produit]│                 │            │      │      │
│             │         v                 │            │      v      │
│             │    ┌─────────┐            │            │   [WHITE_DIAMOND]─────[WHITE_DIAMOND]   │
│             │    │ SELECT  │            │            │  / Accepté?\│
│             │    │ Stock───┼────────────┼────────────┼──>          │
│             │    └─────────┘            │            │ [oui]  [non]│
│             │         │                 │            │  │      │   │
│             │         v                 │            │  │      v   │
│             │      [WHITE_DIAMOND]─────[WHITE_DIAMOND]              │            │  │     [BULLSEYE]    │
│             │     /Dispo? \             │            │  │ (Échec)  │
│             │    /         \            │            │  │          │
│             │  [oui]      [non]         │            │  │          │
│             │   │           │           │            │  │          │
│             │   │      ┌────────┐       │            │  │          │
│             │   │      │ Retirer│       │            │  │          │
│             │   │      │ Produit│       │            │  │          │
│             │   │      └────────┘       │            │  │          │
│             │   │           │           │            │  │          │
│             │   └───────────┘           │            │  │          │
│             │         │                 │            │  │          │
│             │    (Fin LOOP)             │            │  │          │
│             │         │                 │            │  │          │
│             │         v                 v            │  v          │
│             │  ═════════════════════════════════  JOIN             │
│             │                 │                     │              │
│             │                 v                     │              │
│             │          ┌─────────────┐              │              │
│             │          │   Créer     │              │              │
│             │          │  Commande   │              │              │
│             │          └─────────────┘              │              │
│             │                 │                     │              │
│             │                 v                     │              │
│             │    LOOP  ┌─────────────┐              │              │
│             │  [chaque │ Décrémenter │──────────────┼───────>      │
│             │  produit]│    Stock    │              │ ┌─────────┐  │
│             │          └─────────────┘              │ │  UPDATE │  │
│             │                 │                     │ │  Stock  │  │
│             │          (Fin LOOP)                   │ └─────────┘  │
│             │                 │                     │              │
│             │                 v                     │              │
│             │          ┌─────────────┐              │              │
│             │          │  Charger────┼──────────────┼───────>      │
│             │          │   Carte     │              │ ┌─────────┐  │
│             │          └─────────────┘              │ │  Charge │  │
│             │                 │                     │ │  Carte  │  │
│             │                 │                     │ └─────────┘  │
│             │                 v                     │              │
│             │          ┌─────────────┐              │              │
│             │          │  Envoyer────┼──────────────┼──────────────┼───>│
│             │          │Confirmation │              │              │ ╱──╲│
│             │          └─────────────┘              │              │╱Email╲
│             │                 │                     │              │╲Signal╱
│             │                 │                     │              │ ╲──╱│
│      [BLACK_LEFT-POINTING_POINTER]──────┼─────────────────┘                     │              │  │  │
│ ┌────────┐  │                                       │              │  v  │
│ │Afficher│  │                                       │              │┌───┐│
│ │Confirm.│  │                                       │              ││Send││
│ └────────┘  │                                       │              │└───┘│
│      │      │                                       │              │     │
│      v      │                                       │              │     │
│      [BULLSEYE]      │                                       │              │     │
└─────────────┴─────────────────┴─────────────────┴─────────────┴─────────┘


ANALYSE DU DIAGRAMME :

1. PARTITIONS (5 swimlanes) :
   - Client : Actions utilisateur
   - Système Web : Logique principale
   - Service Paiement : Autorisation carte
   - Service Stock : Gestion inventaire
   - Service Email : Notifications

2. DÉCISIONS multiples :
   - Connecté ? (oui/non)
   - Authentification valide ? (oui/non -> abandon)
   - Total > 0 ? (oui/non -> erreur)
   - Stock disponible ? (oui/non -> retirer)
   - Paiement accepté ? (oui/non -> échec)

3. FORK + JOIN (traitement parallèle) :
   - Fork : Lance vérification stock ET réservation paiement
   - Join : Attend que les DEUX soient terminés
   - Si l'une échoue -> Fin (paiement échoué ou stock insuffisant)

4. BOUCLES :
   - LOOP pour vérifier stock de chaque produit
   - LOOP pour décrémenter stock de chaque produit

5. SIGNAL ASYNCHRONE :
   - Envoi email (pentagone)
   - Ne bloque pas le flux principal
   - Email envoyé en arrière-plan

6. FLUX ENTRE PARTITIONS :
   - Handoffs clairs (client -> système -> services)
   - Retours d'information (services -> système -> client)

7. POINTS DE FIN multiples :
   - Abandon (authentification échouée)
   - Erreur (panier vide)
   - Échec (paiement refusé)
   - Succès (confirmation affichée)


[IDEE] OPTIMISATIONS POSSIBLES :

1. GOULOT D'ÉTRANGLEMENT détecté :
   - Vérification stock APRÈS choix livraison
   - Mieux : vérifier AVANT pour éviter déception

2. POINTS D'ABANDON multiples :
   - Authentification
   - Panier vide
   - Stock insuffisant
   - Paiement refusé
   -> Implémenter récupération/retry

3. PARALLÉLISME efficace :
   - Stock et Paiement en parallèle
   - Réduit temps total


[IDEE] UTILITÉ DU DIAGRAMME :

[OK] Vue claire du processus complet
[OK] Identification des responsabilités (partitions)
[OK] Détection des points d'échec
[OK] Compréhension des dépendances
[OK] Base pour implémentation
[OK] Documentation pour formation
"""


# ----------------------------------------------------------------------------
# [COURS] EXERCICE PRATIQUE 2 : PROCESSUS DE RECRUTEMENT
# ----------------------------------------------------------------------------

"""
[PRO] ÉNONCÉ

Modélisez le processus de recrutement d'une entreprise.

PROCESSUS :

1. Candidat postule en ligne

2. RH reçoit candidature

3. RH trie CV :
   - SI qualifications insuffisantes : Rejeter (envoyer email rejet)
   - SI qualifié : Continuer

4. RH planifie entretien téléphonique

5. Entretien téléphonique (RH) :
   - SI négatif : Rejeter
   - SI positif : Continuer

6. FORK (tests parallèles) :
   - Branche A : Test technique (2h)
   - Branche B : Test psychologique (1h)

7. JOIN (attendre les deux tests)

8. RH évalue résultats :
   - SI échec à un test : Rejeter
   - SI réussite aux deux : Continuer

9. Manager planifie entretien final

10. Entretien final (Manager) :
    - SI non retenu : Rejeter
    - SI retenu : Continuer

11. FORK (processus administratif parallèle) :
    - Branche A : RH prépare contrat
    - Branche B : RH vérifie références
    - Branche C : IT prépare équipement

12. JOIN

13. SI références négatives :
    - Rejeter
    - SINON : Continuer

14. RH envoie offre d'emploi

15. Candidat reçoit offre :
    - SI refuse : Fin (offre refusée)
    - SI accepte : Continuer

16. Candidat signe contrat

17. RH enregistre nouvel employé

18. IT configure accès systèmes

19. Manager planifie onboarding

20. Fin (embauche réussie)

PARTITIONS :
- Candidat
- RH
- Manager
- IT
- Système (emails automatiques)

Créez le diagramme d'activités complet.


─────────────────────────────────────────────────────────────────────────
SOLUTION EXERCICE 2
─────────────────────────────────────────────────────────────────────────

DIAGRAMME D'ACTIVITÉS - Processus de Recrutement


┌──────────┬──────────┬──────────┬──────────┬──────────┐
│ Candidat │    RH    │ Manager  │    IT    │ Système  │
├──────────┼──────────┼──────────┼──────────┼──────────┤
│    [BLACK_CIRCLE]     │          │          │          │          │
│    │     │          │          │          │          │
│┌────────┐│          │          │          │          │
││Postuler││          │          │          │          │
││ en ligne│          │          │          │          │
│└────────┘│          │          │          │          │
│    │─────┼───────>  │          │          │          │
│          │┌────────┐│          │          │          │
│          ││Recevoir││          │          │          │
│          ││Candidat││          │          │          │
│          │└────────┘│          │          │          │
│          │    │     │          │          │          │
│          │    v     │          │          │          │
│          │┌────────┐│          │          │          │
│          ││ Trier  ││          │          │          │
│          ││   CV   ││          │          │          │
│          │└────────┘│          │          │          │
│          │    │     │          │          │          │
│          │    v     │          │          │          │
│          │ [WHITE_DIAMOND]─────[WHITE_DIAMOND]  │          │          │          │
│          │/Qualifié\│          │          │          │
│          │         \│          │          │          │
│          │[non]  [oui]         │          │          │
│          │ │      │ │          │          │          │
│          │ │      │ │          │          │          │
│          │ v      │ │          │          │          │
│          │┌──────┐│ │          │          │          │
│          ││Envoyer│─┼──────────┼──────────┼─────────>│
│          ││Rejet ││ │          │          │         ╱─╲
│          │└──────┘│ │          │          │        ╱Email╲
│          │ │      │ │          │          │        ╲Rejet╱
│          │ v      │ │          │          │         ╲─╱│
│          │[BULLSEYE]       │ │          │          │          │ │
│       [BLACK_LEFT-POINTING_POINTER]──┼────────┼─┼──────────┼──────────┼──────────┘ │
│ ┌──────┐ │        │ │          │          │  ┌──────┐  │
│ │Recevoir│        │ │          │          │  │ Send │  │
│ │ Rejet│ │        │ │          │          │  │Email │  │
│ └──────┘ │        │ │          │          │  └──────┘  │
│    │     │        │ │          │          │            │
│    v     │        │ │          │          │            │
│    [BULLSEYE]     │        │ │          │          │            │
│          │        v │          │          │            │
│          │   ┌──────┐          │          │            │
│          │   │Planif.│          │          │            │
│          │   │ Tel  │          │          │            │
│          │   └──────┘          │          │            │
│          │        │ │          │          │            │
│          │        v │          │          │            │
│          │   ┌──────┐          │          │            │
│          │   │Entret.│          │          │            │
│          │   │  Tel │          │          │            │
│          │   └──────┘          │          │            │
│          │        │ │          │          │            │
│          │        v │          │          │            │
│          │     [WHITE_DIAMOND]───[WHITE_DIAMOND]│          │          │            │
│          │    /Positif\        │          │            │
│          │   /        \        │          │            │
│          │ [non]    [oui]      │          │            │
│          │  │         │        │          │            │
│          │  v         │        │          │            │
│          │ [BULLSEYE]          │        │          │            │
│          │ (Rejet)    │        │          │            │
│          │            │        │          │            │
│          │            v        │          │            │
│          │   ═════════════════════  FORK  │            │
│          │            │        │          │            │
│          │      ┌─────┴─────┐  │          │            │
│          │      │           │  │          │            │
│          │      v           v  │          │            │
│          │ ┌────────┐  ┌────────┐         │            │
│          │ │  Test  │  │  Test  │         │            │
│          │ │Technique│ │Psycho  │         │            │
│ [BLACK_LEFT-POINTING_POINTER]────────┼─┤  (2h)  │  │ (1h)   │         │            │
│┌────────┐│ └────────┘  └────────┘         │            │
││Passer  ││      │           │   │          │            │
││ Tests  ││      │           │   │          │            │
│└────────┘│      │           │   │          │            │
│    │─────┼──────┴───────────┘   │          │            │
│          │            │          │          │            │
│          │            v          │          │            │
│          │   ═════════════════════  JOIN   │            │
│          │            │          │          │            │
│          │            v          │          │            │
│          │      ┌──────────┐     │          │            │
│          │      │ Évaluer  │     │          │            │
│          │      │Résultats │     │          │            │
│          │      └──────────┘     │          │            │
│          │            │          │          │            │
│          │            v          │          │            │
│          │         [WHITE_DIAMOND]───[WHITE_DIAMOND]         │          │            │
│          │        /Réussite\     │          │            │
│          │       / 2 tests \     │          │            │
│          │     [non]     [oui]   │          │            │
│          │      │          │     │          │            │
│          │      v          │─────┼────────> │            │
│          │     [BULLSEYE]           │     │┌──────┐  │            │
│          │  (Rejet)        │     ││Planif││  │            │
│          │                 │     ││Entret││  │            │
│          │                 │     ││Final ││  │            │
│          │                 │     │└──────┘  │            │
│          │                 │     │    │     │            │
│          │                 │     │    v     │            │
│          │                 │     │┌──────┐  │            │
│          │                 │     ││Entret││  │            │
│          │                 │     ││Final ││  │            │
│ [BLACK_LEFT-POINTING_POINTER]────────┼─────────────────┼─────┤└──────┘  │            │
│┌────────┐│                 │     │    │     │            │
││Entretien│                 │     │    v     │            │
││ Final  ││                 │     │ [WHITE_DIAMOND]─────[WHITE_DIAMOND]  │            │
│└────────┘│                 │     │/ Retenu \│            │
│    │─────┼─────────────────┼─────┤         \│            │
│          │                 │     │[non] [oui]            │
│          │                 │     │ │      │ │            │
│          │                 │     │ v      │ │            │
│          │                 │     │[BULLSEYE]       │ │            │
│          │                 │     │(Rejet) │ │            │
│          │                 │     │        │ │            │
│          │                 │     │        v │            │
│          │        ═════════════════════════════  FORK    │
│          │                 │     │        │ │            │
│          │           ┌─────┼─────┼────────┴─┴──┐         │
│          │           │     │     │              │         │
│          │           v     │     │     v        v         │
│          │      ┌────────┐│   ┌───────┐   ┌────────┐     │
│          │      │Préparer││   │Vérifier   │Préparer│     │
│          │      │Contrat ││   │Référen.   │Équipem.│────>│
│          │      └────────┘│   └───────┘   └────────┘┌───┐│
│          │           │     │        │           │   │Config│
│          │           │     │        │           │   │Poste│
│          │           │     │        │           │   └───┘│
│          │           │     │        │           │         │
│          │           v     │        v           v         │
│          │        ═════════════════════════════════  JOIN │
│          │                 │        │                     │
│          │                 │        v                     │
│          │                 │    [WHITE_DIAMOND]─────[WHITE_DIAMOND]                   │
│          │                 │   /Références\               │
│          │                 │  /   OK?     \               │
│          │                 │[non]       [oui]             │
│          │                 │ │            │               │
│          │                 │ v            │               │
│          │                 │[BULLSEYE]             │               │
│          │                 │(Rejet)       │               │
│          │                 │              v               │
│          │                 │        ┌──────────┐          │
│          │                 │        │  Envoyer │          │
│          │                 │        │  Offre   │          │
│          │                 │        └──────────┘          │
│       [BLACK_LEFT-POINTING_POINTER]──┼─────────────────┼────────────┘                 │
│ ┌──────┐ │                 │                              │
│ │Recevoir│                 │                              │
│ │ Offre│ │                 │                              │
│ └──────┘ │                 │                              │
│    │     │                 │                              │
│    v     │                 │                              │
│ [WHITE_DIAMOND]─────[WHITE_DIAMOND]  │                 │                              │
│/Accepter\│                 │                              │
│         \│                 │                              │
│[non] [oui]                 │                              │
│ │      │ │                 │                              │
│ v      │ │                 │                              │
│[BULLSEYE]       │ │                 │                              │
│(Refus) │ │                 │                              │
│        │ │                 │                              │
│        v │                 │                              │
│   ┌──────┐                 │                              │
│   │ Signer│────────────────┼─────────>                    │
│   │Contrat│                │        ┌──────────┐          │
│   └──────┘                 │        │Enregistrer│         │
│        │                   │        │  Nouvel  │          │
│        │                   │        │ Employé  │          │
│        │                   │        └──────────┘          │
│        │                   │             │                │
│        │                   │             │────────────────┼────>│
│        │                   │             │                │┌───┐│
│        │                   │             │                ││Config│
│        │                   │             │                ││Accès││
│        │                   │             │                │└───┘│
│        │                   │             │[BLACK_LEFT-POINTING_POINTER]───────────────┼─────┘
│        │                   │             │                │     │
│        │                   │             v                │     │
│        │                   │      ┌──────────┐            │     │
│        │                   │      │ Planif. ─┼────────>   │     │
│        │                   │      │Onboarding│  ┌──────┐  │     │
│        │                   │      └──────────┘  │Créer │  │     │
│        │                   │             │      │ Plan │  │     │
│        │                   │             │      └──────┘  │     │
│        │                   │             v                │     │
│        v                   │             [BULLSEYE]                │     │
│        [BULLSEYE]                   │        (Embauché)            │     │
└──────────┴──────────┴──────────┴──────────┴──────────┘


ANALYSE DU DIAGRAMME :

1. PARTITIONS (5 acteurs) :
   - Candidat : Postule, passe tests, signe
   - RH : Trie, entretiens, administration
   - Manager : Entretien final, onboarding
   - IT : Configuration équipement et accès
   - Système : Emails automatiques

2. DÉCISIONS multiples :
   - Qualifié ? (5 points de rejet possibles)
   - Entretien tel positif ?
   - Tests réussis ?
   - Entretien final retenu ?
   - Références OK ?
   - Accepte offre ?

3. FORK + JOIN (2 occurrences) :
   
   FORK 1 : Tests parallèles
   - Test technique (2h)
   - Test psychologique (1h)
   - JOIN avant évaluation
   
   FORK 2 : Processus admin parallèles
   - RH prépare contrat
   - RH vérifie références
   - IT prépare équipement
   - JOIN avant envoi offre

4. BOUCLES (implicites) :
   - Retour après rejet téléphonique
   - Reprise process si références négatives

5. SIGNAUX :
   - Email de rejet (asynchrone)
   - Notifications automatiques

6. FLUX COMPLEXES :
   - Handoffs multiples entre acteurs
   - Synchronisations (JOIN)
   - Processus séquentiels ET parallèles


[IDEE] STATISTIQUES DU PROCESSUS :

POINTS DE REJET (6) :
1. CV non qualifié
2. Entretien téléphonique négatif
3. Échec tests
4. Entretien final non retenu
5. Références négatives
6. Refus offre par candidat

TEMPS ESTIMÉ :
- Triage CV : 10 min
- Entretien tel : 30 min
- Tests : 3h (2h + 1h parallèle)
- Entretien final : 1h
- Admin : 2-3 jours
- TOTAL : ~1-2 semaines


[IDEE] OPTIMISATIONS IDENTIFIÉES :

1. FORK pour tests = Gain de temps
   - Séquentiel : 3h
   - Parallèle : 2h
   - Gain : 33%

2. FORK admin = Parallélisation
   - Contrat, Références, IT en simultané
   - Réduit délai embauche

3. GOULOTS D'ÉTRANGLEMENT :
   - Vérification références (peut prendre jours)
   - Entretien final (dispo manager)

4. POINTS D'AMÉLIORATION :
   - Tests AVANT entretien final ?
   - Vérif références plus tôt ?
   - Automatiser davantage (système)


[IDEE] UTILITÉ DU DIAGRAMME :

[OK] Vue complète processus recrutement
[OK] Identification responsabilités claires
[OK] Détection goulots d'étranglement
[OK] Optimisation temps (parallélisme)
[OK] Formation nouveaux RH
[OK] Documentation procédure
[OK] Conformité/Audit
"""


# ----------------------------------------------------------------------------
# [DOCS] RÉCAPITULATIF CHAPITRE 6 - DIAGRAMME D'ACTIVITÉS
# ----------------------------------------------------------------------------

"""
CE QUE VOUS AVEZ APPRIS

[OK] Diagramme d'activités = workflows et processus
[OK] Actions (rectangles arrondis) et flux (flèches)
[OK] Décisions (losanges) et fusions
[OK] Fork (barre épaisse) pour parallélisme
[OK] Join pour synchronisation
[OK] Partitions (swimlanes) pour responsabilités
[OK] Boucles et structures de contrôle
[OK] Signaux et événements
[OK] 2 exercices complets (e-commerce, recrutement)


[CLE] POINTS CLÉS

1. PROCESSUS métier, pas interactions techniques
2. FLUX de contrôle de haut en bas
3. DÉCISION = choix conditionnel (losange)
4. FORK = lancer tâches PARALLÈLES (barre)
5. JOIN = attendre TOUTES les tâches
6. PARTITIONS = qui fait quoi (swimlanes)
7. BOUCLE = retour en arrière


[IDEE] DIFFÉRENCES CLÉS

┌──────────────────────┬──────────────────────────┐
│ ACTIVITÉS            │ SÉQUENCE                 │
├──────────────────────┼──────────────────────────┤
│ Processus métier     │ Interactions objets      │
│ Vue workflow         │ Vue temporelle messages  │
│ Actions humaines     │ Appels méthodes          │
│ Qui fait quoi        │ Objets communiquent      │
│ "Valider commande"   │ "commande.valider()"     │
└──────────────────────┴──────────────────────────┘


[OK] CHECKLIST

Vous devez être capable de :
[ ] Identifier actions d'un processus
[ ] Modéliser flux séquentiel
[ ] Utiliser décisions et fusions
[ ] Représenter parallélisme (fork/join)
[ ] Organiser en partitions (swimlanes)
[ ] Modéliser boucles
[ ] Envoyer signaux/événements
[ ] Créer workflow complet


[COURS] BONNES PRATIQUES

1. CLARTÉ :
   - Limiter nombre d'actions par diagramme
   - Diviser processus complexes en sous-diagrammes
   - Nommer actions avec VERBES

2. PARTITIONS :
   - Organiser par acteur/rôle/système
   - Verticales (plus lisible)
   - 3-5 partitions maximum

3. FLUX :
   - De haut en bas (temps)
   - De gauche à droite (logique)
   - Éviter croisements

4. DÉCISIONS :
   - Conditions mutuellement exclusives
   - Couvrir TOUS les cas
   - [else] pour catch-all


[ATTENTION] ERREURS FRÉQUENTES

[X] Confondre FORK et DÉCISION
   [OK] Fork = TOUTES les branches
   [X] Décision = UNE SEULE branche

[X] Oublier JOIN après FORK
   [OK] Fork DOIT avoir Join correspondant
   [X] Fork sans Join = processus non synchronisé

[X] Trop de détails techniques
   [OK] Niveau métier/utilisateur
   [X] Niveau code/implémentation

[X] Conditions non exclusives
   [OK] [si A] vs [sinon]
   [X] [si A] vs [si B] (peuvent être vrais ensemble)


[COURS] POUR S'ENTRAÎNER

Créez des diagrammes d'activités pour :
1. Processus de réservation d'hôtel
2. Workflow d'approbation de congés
3. Circuit de validation de dépenses
4. Processus de livraison e-commerce
5. Procédure de traitement des réclamations


[GRAPHIQUE] QUAND UTILISER CHAQUE DIAGRAMME ?

Use Case -> QUOI (fonctionnalités du système)
Activités -> COMMENT (workflow processus métier)
Séquence -> COMMENT (interactions objets détaillées)
Classes -> AVEC QUOI (structure données/code)


-> PROCHAINE ÉTAPE : Chapitre 7 - Diagramme d'États-Transitions

Le diagramme d'états montre les ÉTATS d'un objet
et les TRANSITIONS entre ces états.

Vous apprendrez :
- États et transitions
- Événements déclencheurs
- Actions d'entrée/sortie
- États composites et parallèles
- Machines à états

Les activités montrent PROCESSUS généraux
Les états montrent CYCLE DE VIE d'un objet

Prêt pour les machines à états ? Let's go ! [RAPIDE]
"""


# ============================================================================
# FIN DU CHAPITRE 6 - DIAGRAMME D'ACTIVITÉS
# Suite : Chapitre 7 - Diagramme d'États-Transitions
# ============================================================================
# ============================================================================
# [LIVRE] UML - PARTIE 2 (FIN) : DIAGRAMME D'ÉTATS-TRANSITIONS
# ============================================================================


# ============================================================================
# [GUIDE] CHAPITRE 7 : DIAGRAMME D'ÉTATS-TRANSITIONS (STATE MACHINE DIAGRAM)
# ============================================================================

"""
[OBJECTIF] OBJECTIFS D'APPRENTISSAGE

À la fin de ce chapitre, vous saurez :
[OK] Qu'est-ce qu'un diagramme d'états-transitions
[OK] Modéliser cycle de vie d'un objet
[OK] Représenter états, transitions et événements
[OK] Utiliser actions d'entrée, sortie et internes
[OK] Créer états composites et sous-états
[OK] Modéliser états parallèles (régions orthogonales)
[OK] Concevoir machines à états complètes
"""


# ----------------------------------------------------------------------------
# [REFLEXION] QU'EST-CE QU'UN DIAGRAMME D'ÉTATS-TRANSITIONS ?
# ----------------------------------------------------------------------------

"""
DÉFINITION SIMPLE

Diagramme d'États-Transitions = Cycle de VIE d'un objet

Montre :
├─ ÉTATS dans lesquels l'objet peut être
├─ TRANSITIONS entre états
├─ ÉVÉNEMENTS qui déclenchent transitions
└─ ACTIONS exécutées lors des transitions


[IDEE] CONCEPTS CLÉS

ÉTAT = Condition/situation d'un objet à un instant donné
TRANSITION = Passage d'un état à un autre
ÉVÉNEMENT = Déclencheur d'une transition
ACTION = Comportement exécuté


ANALOGIE [CONSTRUCTION]

Diagramme d'États = Vie d'un feu tricolore
- États : Vert, Jaune, Rouge
- Transitions : Vert -> Jaune -> Rouge -> Vert
- Événements : Timer (délai écoulé)
- Actions : Allumer LED, émettre signal


[REFLEXION] POURQUOI UTILISER ?

[OK] MODÉLISER CYCLE DE VIE
- États d'une commande (créée, payée, expédiée, livrée)
- États d'une connexion (déconnectée, connectée, erreur)
- États d'un document (brouillon, validé, publié, archivé)

[OK] SPÉCIFIER COMPORTEMENT
- Réaction aux événements selon état actuel
- Actions à exécuter lors changement d'état
- Contraintes sur transitions possibles

[OK] PROTOCOLES ET WORKFLOWS
- États d'authentification
- États de transaction
- États de machine physique

[OK] VALIDATION ET TESTS
- Vérifier tous états couverts
- Identifier transitions manquantes
- Tester cas limites


[REFLEXION] QUAND L'UTILISER ?

[OK] UTILISEZ POUR :
- Objets avec cycle de vie clair
- Systèmes réactifs (événements)
- Protocoles de communication
- Workflows avec états métier
- Machines à états finies

[X] ÉVITEZ POUR :
- Objets sans états distincts
- Processus généraux (utilisez activités)
- Interactions multi-objets (utilisez séquence)
- Structure système (utilisez classes)


RELATION AVEC AUTRES DIAGRAMMES

Classes -> Structure de l'objet (attributs/méthodes)
         v
États -> Cycle de vie de l'objet (états possibles)
         v
Séquence -> Interactions de l'objet (messages)
         v
Activités -> Processus incluant l'objet (workflow)


[IDEE] DIFFÉRENCE ÉTATS vs ACTIVITÉS

┌──────────────────────┬──────────────────────────┐
│ ÉTATS                │ ACTIVITÉS                │
├──────────────────────┼──────────────────────────┤
│ Cycle de vie OBJET   │ Workflow PROCESSUS       │
│ Un objet spécifique  │ Processus général        │
│ États + Transitions  │ Actions + Flux           │
│ Réactif (événements) │ Proactif (séquence)      │
│ "Commande en transit"│ "Traiter commande"       │
└──────────────────────┴──────────────────────────┘
"""


# ----------------------------------------------------------------------------
# [PACKAGE] ÉTATS
# ----------------------------------------------------------------------------

"""
NOTATION D'UN ÉTAT

Rectangle aux coins arrondis avec nom

    ┌───────────────┐
    │   NomÉtat     │
    └───────────────┘


ÉTAT AVEC COMPARTIMENTS

    ┌───────────────────┐
    │   NomÉtat         │  <- Nom
    ├───────────────────┤
    │ entry / action1   │  <- Actions d'entrée
    │ do / action2      │  <- Activité continue
    │ exit / action3    │  <- Actions de sortie
    │ événement / action│  <- Transitions internes
    └───────────────────┘


TYPES D'ÉTATS SPÉCIAUX

1. ÉTAT INITIAL (Start)
   Cercle plein noir
   
   [BLACK_CIRCLE]  <- Début du cycle de vie


2. ÉTAT FINAL (End)
   Cercle avec point au centre
   
   [BULLSEYE]  <- Fin du cycle de vie


3. ÉTAT D'HISTORIQUE (History)
   Cercle avec H
   
   ⊙H  <- Se souvient du dernier sous-état


EXEMPLE SIMPLE : LAMPE

        [BLACK_CIRCLE]  Initial
        │
        v
    ┌───────┐
    │ Éteint│ [BLACK_LEFT-POINTING_POINTER]──────┐
    └───────┘        │
        │            │
        │ appuyer    │ appuyer
        │            │
        v            │
    ┌───────┐        │
    │Allumée│ ───────┘
    └───────┘


ÉTATS AVEC ACTIONS

    ┌──────────────────────┐
    │      Allumée         │
    ├──────────────────────┤
    │ entry / allumerLED() │  <- Exécutée EN ENTRANT
    │ do / consommer()     │  <- Exécutée PENDANT
    │ exit / éteindreLED() │  <- Exécutée EN SORTANT
    └──────────────────────┘


SIGNIFICATION DES ACTIONS

ENTRY (entrée) :
- Exécutée UNE FOIS en entrant dans l'état
- Initialisation, démarrage d'activité

DO (activité) :
- Exécutée EN CONTINU pendant l'état
- Peut être interrompue par transition
- Optionnelle

EXIT (sortie) :
- Exécutée UNE FOIS en sortant de l'état
- Nettoyage, arrêt d'activité


EXEMPLE : TÉLÉCHARGEMENT FICHIER

    ┌────────────────────────────┐
    │      EnCoursDeTéléchargement│
    ├────────────────────────────┤
    │ entry / démarrerConnexion()│
    │ entry / créerFichierTemp() │
    │ do / téléchargerDonnées()  │  <- Continue
    │ exit / fermerConnexion()   │
    │ exit / renommerFichier()   │
    └────────────────────────────┘


TRANSITIONS INTERNES

Actions sans changer d'état

    ┌────────────────────────────┐
    │      Connecté              │
    ├────────────────────────────┤
    │ entry / ouvrirSession()    │
    │ pingReçu / envoyerPong()   │  <- Reste dans "Connecté"
    │ données / traiterDonnées() │  <- Reste dans "Connecté"
    │ exit / fermerSession()     │
    └────────────────────────────┘

Avantage : Pas d'exit/entry lors transition interne
"""


# ----------------------------------------------------------------------------
# -> TRANSITIONS
# ----------------------------------------------------------------------------

"""
NOTATION TRANSITION

Flèche d'un état vers un autre

    ┌───────┐              ┌───────┐
    │ État A│──────────────│ État B│
    └───────┘              └───────┘


TRANSITION AVEC LABELS

Format : événement [garde] / action

    ┌───────┐  événement [garde] / action  ┌───────┐
    │ État A│──────────────────────────────│ État B│
    └───────┘                              └───────┘


COMPOSANTS D'UNE TRANSITION

1. ÉVÉNEMENT (trigger)
   - Déclencheur de la transition
   - Ex : boutonCliqué, timeout, messageReçu

2. GARDE (guard condition)
   - Condition entre crochets [condition]
   - Transition SEULEMENT si condition vraie
   - Ex : [solde > 0], [tentatives < 3]

3. ACTION (effect)
   - Comportement exécuté PENDANT transition
   - Après "/" : / action
   - Ex : / débiterCompte(), / logger()


EXEMPLES

Transition simple (événement seul) :
    ┌───────┐                    ┌───────┐
    │Inactif│──── clic ──────────│ Actif │
    └───────┘                    └───────┘


Transition avec garde :
    ┌───────┐  clic [x > 0]     ┌───────┐
    │Inactif│────────────────────│ Actif │
    └───────┘                    └───────┘


Transition avec action :
    ┌───────┐  clic / logger()  ┌───────┐
    │Inactif│────────────────────│ Actif │
    └───────┘                    └───────┘


Transition complète :
    ┌───────┐ valider [montant>0] / débiter() ┌───────┐
    │ Panier│────────────────────────────────│ Payé  │
    └───────┘                                └───────┘


TRANSITIONS MULTIPLES

Plusieurs transitions sortant du même état

    ┌───────────┐
    │  Attente  │
    └───────────┘
         │  │  │
         │  │  │
    ┌────┘  │  └────┐
    │       │       │
    │ [ok]  │ [ko]  │ [timeout]
    │       │       │
    v       v       v
┌───────┬───────┬───────┐
│Succès │ Erreur│Timeout│
└───────┴───────┴───────┘

Conditions mutuellement exclusives


AUTO-TRANSITION (Self-transition)

Retour sur même état (AVEC exit/entry)

    ┌───────────┐
    │  Attente  │ [BLACK_LEFT-POINTING_POINTER]──┐
    └───────────┘    │
         │           │
         └───────────┘
           retry


TRANSITION INTERNE (Internal transition)

Action sans changer état (SANS exit/entry)

    ┌────────────────────┐
    │     Attente        │
    ├────────────────────┤
    │ retry / incrémenter│  <- Pas de sortie/entrée
    └────────────────────┘


[IDEE] DIFFÉRENCE

Auto-transition :
- Sort de l'état (exit)
- Rentre dans l'état (entry)
- Réinitialise l'état

Transition interne :
- Reste dans l'état
- Pas de exit/entry
- Juste une action


TRANSITIONS AUTOMATIQUES

Sans événement (déclenchement automatique)

    ┌───────┐              ┌───────┐
    │ État A│──────────────│ État B│
    └───────┘              └───────┘

Dès que État A est complété, passe à État B


EXEMPLE COMPLET : AUTHENTIFICATION

        [BLACK_CIRCLE]
        │
        v
    ┌────────────┐
    │Déconnecté  │ [BLACK_LEFT-POINTING_POINTER]────────────────┐
    └────────────┘                  │
         │                          │
         │ login                    │
         v                          │
    ┌────────────┐                  │
    │Validation  │                  │
    ├────────────┤                  │
    │entry/      │                  │
    │vérifier()  │                  │
    └────────────┘                  │
         │  │                       │
         │  │                       │
    ┌────┘  └────┐                  │
    │            │                  │
[valide]      [invalide]            │
    │            │                  │
    v            v                  │
┌─────────┐  ┌─────────┐            │
│Connecté │  │ Erreur  │            │
└─────────┘  └─────────┘            │
    │            │                  │
    │logout      │ retour           │
    └────────────┴──────────────────┘
"""


# ----------------------------------------------------------------------------
# [CONSTRUCTION] ÉTATS COMPOSITES (HIERARCHICAL STATES)
# ----------------------------------------------------------------------------

"""
QU'EST-CE QU'UN ÉTAT COMPOSITE ?

État contenant d'autres états (sous-états)

Permet :
- Grouper états liés
- Factoriser comportement commun
- Simplifier diagramme


NOTATION

Rectangle avec sous-états à l'intérieur

    ┌──────────────────────────────────┐
    │       État Composite             │
    ├──────────────────────────────────┤
    │   [BLACK_CIRCLE]                              │
    │   │                              │
    │   v                              │
    │ ┌───────┐      ┌───────┐        │
    │ │Sous-  │──────│Sous-  │        │
    │ │État A │      │État B │        │
    │ └───────┘      └───────┘        │
    │                                  │
    └──────────────────────────────────┘


EXEMPLE : LECTEUR AUDIO

    ┌───────────────────────────────────────────┐
    │             Marche                        │
    ├───────────────────────────────────────────┤
    │ entry / allumerÉcran()                    │
    │ exit / éteidreÉcran()                     │
    │                                           │
    │   [BLACK_CIRCLE]                                       │
    │   │                                       │
    │   v                                       │
    │ ┌─────────┐  play   ┌─────────┐         │
    │ │ Arrêté  │─────────│ Lecture │         │
    │ └─────────┘         └─────────┘         │
    │   ^                     │   ^            │
    │   │ stop               │   │            │
    │   │                    v   │ pause      │
    │   │                 ┌─────────┐         │
    │   └─────────────────│  Pause  │         │
    │                     └─────────┘         │
    │                                           │
    └───────────────────────────────────────────┘
        │                           ^
        │ éteindre                  │ allumer
        v                           │
    ┌─────────┐                     │
    │  Éteint │─────────────────────┘
    └─────────┘


AVANTAGES :

1. FACTORISATION
   - entry/exit de "Marche" exécutés pour TOUS sous-états
   - Évite répétition

2. TRANSITION COMMUNE
   - "éteindre" depuis n'importe quel sous-état -> Éteint
   - Une seule transition au lieu de 3

3. CLARTÉ
   - Groupement logique
   - Hiérarchie claire


ÉTAT INITIAL DANS COMPOSITE

Indique premier sous-état

    ┌─────────────────────────┐
    │    Composite            │
    ├─────────────────────────┤
    │   [BLACK_CIRCLE]  <- État initial     │
    │   │                     │
    │   v                     │
    │ ┌───────┐               │
    │ │Défaut │               │
    │ └───────┘               │
    └─────────────────────────┘


ÉTAT D'HISTORIQUE (History State)

Se souvient du dernier sous-état actif

SHALLOW HISTORY (H) :
- Se souvient du dernier sous-état direct

DEEP HISTORY (H*) :
- Se souvient récursivement de tous niveaux


NOTATION :

    ┌────────────────────────────┐
    │      Composite             │
    ├────────────────────────────┤
    │  ⊙H  <- État historique     │
    │                            │
    │ ┌────────┐   ┌────────┐   │
    │ │Sous-   │   │Sous-   │   │
    │ │État A  │   │État B  │   │
    │ └────────┘   └────────┘   │
    └────────────────────────────┘


EXEMPLE : LECTEUR AVEC HISTORIQUE

    ┌────────────────────────────────┐
    │         En Marche              │
    ├────────────────────────────────┤
    │  ⊙H                            │
    │                                │
    │ ┌─────────┐   ┌─────────┐     │
    │ │ Lecture │   │  Pause  │     │
    │ └─────────┘   └─────────┘     │
    └────────────────────────────────┘
         ^                    │
         │ reprendre          │ suspendre
         │                    v
    ┌────────────┐
    │  Suspendu  │
    └────────────┘

Scénario :
1. Lecture -> Pause
2. Pause -> Suspendu (mémorise "Pause")
3. Suspendu -> reprendre -> Retour direct à "Pause" (grâce à H)


IMBRICATION MULTI-NIVEAUX

États composites dans états composites

    ┌───────────────────────────────────────┐
    │         Niveau 1                      │
    ├───────────────────────────────────────┤
    │  ┌──────────────────────────────┐    │
    │  │      Niveau 2                │    │
    │  ├──────────────────────────────┤    │
    │  │  ┌─────────────────────┐     │    │
    │  │  │    Niveau 3         │     │    │
    │  │  ├─────────────────────┤     │    │
    │  │  │ ┌───────┐ ┌───────┐│     │    │
    │  │  │ │État A │ │État B ││     │    │
    │  │  │ └───────┘ └───────┘│     │    │
    │  │  └─────────────────────┘     │    │
    │  └──────────────────────────────┘    │
    └───────────────────────────────────────┘


Limite recommandée : 2-3 niveaux maximum
"""


# ----------------------------------------------------------------------------
# [RAPIDE] ÉTATS PARALLÈLES (CONCURRENT STATES)
# ----------------------------------------------------------------------------

"""
RÉGIONS ORTHOGONALES

États actifs SIMULTANÉMENT
Ligne pointillée sépare régions


NOTATION :

    ┌─────────────────────────────────────┐
    │       État Composite                │
    ├─────────────────────────────────────┤
    │  RÉGION 1                           │
    │  ┌───────┐      ┌───────┐          │
    │  │État A │──────│État B │          │
    │  └───────┘      └───────┘          │
    │ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄   │
    │  RÉGION 2                           │
    │  ┌───────┐      ┌───────┐          │
    │  │État C │──────│État D │          │
    │  └───────┘      └───────┘          │
    └─────────────────────────────────────┘

Région 1 ET Région 2 actives EN MÊME TEMPS


EXEMPLE : TÉLÉPHONE MOBILE

    ┌─────────────────────────────────────────┐
    │           Téléphone Allumé              │
    ├─────────────────────────────────────────┤
    │ RÉSEAU                                  │
    │   [BLACK_CIRCLE]                                     │
    │   v                                     │
    │ ┌────────────┐     ┌────────────┐      │
    │ │Recherche   │─────│ Connecté   │      │
    │ │Réseau      │     │            │      │
    │ └────────────┘     └────────────┘      │
    │ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄  │
    │ APPEL                                   │
    │   [BLACK_CIRCLE]                                     │
    │   v                                     │
    │ ┌────────────┐     ┌────────────┐      │
    │ │  Inactif   │─────│ En Cours   │      │
    │ │            │     │            │      │
    │ └────────────┘     └────────────┘      │
    └─────────────────────────────────────────┘

Téléphone peut être :
- Recherche Réseau + Inactif
- Connecté + Inactif
- Connecté + En Cours
- etc.

Les deux régions évoluent INDÉPENDAMMENT


FORK ET JOIN

FORK : Entrer dans plusieurs régions parallèles

    ┌───────┐
    │ État  │
    └───────┘
        │
        v
    ═══════  <- Barre épaisse (fork)
        │
        ├──────────────┐
        │              │
    ┌────────────┐ ┌────────────┐
    │ Région 1   │ │ Région 2   │
    └────────────┘ └────────────┘


JOIN : Sortir des régions parallèles (synchronisation)

    ┌────────────┐ ┌────────────┐
    │ Région 1   │ │ Région 2   │
    └────────────┘ └────────────┘
        │              │
        └──────┬───────┘
               │
           ═══════  <- Barre épaisse (join)
               │
               v
          ┌───────┐
          │ État  │
          └───────┘


EXEMPLE : CUISINER REPAS

        [BLACK_CIRCLE]
        │
        v
    ┌────────────┐
    │ Préparer   │
    └────────────┘
        │
        v
    ═══════  FORK
        │
        ├──────────────────────┐
        │                      │
    ┌────────────┐      ┌────────────┐
    │ Cuire      │      │ Préparer   │
    │ Plat       │      │ Salade     │
    │ Principal  │      │            │
    │   [BLACK_CIRCLE]        │      │   [BLACK_CIRCLE]        │
    │   v        │      │   v        │
    │┌────────┐  │      │┌────────┐  │
    ││Chauffer│  │      ││ Laver  │  │
    │└────────┘  │      │└────────┘  │
    │   v        │      │   v        │
    │┌────────┐  │      │┌────────┐  │
    ││ Cuire  │  │      ││Couper  │  │
    │└────────┘  │      │└────────┘  │
    └────────────┘      └────────────┘
        │                      │
        └──────────┬───────────┘
                   │
               ═══════  JOIN (attendre les 2)
                   │
                   v
              ┌────────────┐
              │  Servir    │
              └────────────┘
                   │
                   v
                   [BULLSEYE]


UTILITÉ

[OK] Modéliser comportements INDÉPENDANTS
[OK] Réduire nombre d'états (combinatoire)
[OK] Clarifier concurrence

Sans régions parallèles, pour téléphone :
- Recherche+Inactif, Recherche+EnCours
- Connecté+Inactif, Connecté+EnCours
-> 4 états combinés

Avec régions : 2 + 2 = 4 états séparés
-> Plus clair, moins d'états
"""


# ----------------------------------------------------------------------------
# [COURS] EXERCICE PRATIQUE 1 : DISTRIBUTEUR AUTOMATIQUE (ATM)
# ----------------------------------------------------------------------------

"""
[AUTOMATED_TELLER_MACHINE] ÉNONCÉ

Créez un diagramme d'états-transitions pour un distributeur automatique.

CYCLE DE VIE :

1. ÉTAT INITIAL : Inactif

2. ÉVÉNEMENTS ET TRANSITIONS :

   De Inactif :
   - carteInsérée -> AttentePIN

   De AttentePIN :
   - pinSaisi [correct] -> MenuPrincipal
   - pinSaisi [incorrect ET tentatives < 3] / incrémenterTentatives -> reste AttentePIN
   - pinSaisi [incorrect ET tentatives >= 3] / avalerCarte -> Bloqué
   - annuler / éjecterCarte -> Inactif

   De MenuPrincipal (état composite avec sous-états) :
   Sous-états :
   - Consultation (consulter solde, historique)
   - Retrait (saisir montant)
   - Dépôt (insérer argent)
   
   - choisir Consultation -> Consultation
   - choisir Retrait -> Retrait
   - choisir Dépôt -> Dépôt
   - annuler -> Inactif

   De Consultation :
   - retour -> MenuPrincipal
   - timeout (30s) -> Inactif

   De Retrait :
   - montantSaisi [solde >= montant] / distribuerArgent -> Finalisation
   - montantSaisi [solde < montant] / afficherErreur -> MenuPrincipal
   - annuler -> MenuPrincipal

   De Dépôt :
   - argentInséré / compter -> Finalisation
   - annuler -> MenuPrincipal

   De Finalisation :
   - imprimerReçu [vouluReçu] -> Inactif
   - auto [!vouluReçu] -> Inactif

   De Bloqué :
   - réinitialisationAdmin -> Inactif

3. ACTIONS :
   - AttentePIN : entry / afficherClavierPIN
   - Consultation : entry / interrogerBanque, exit / fermerConnexion
   - Retrait : do / vérifierDisponibilité
   - Finalisation : entry / éjecterCarte

4. ÉTAT D'HISTORIQUE :
   Si timeout depuis MenuPrincipal, retourner au dernier sous-état actif

Dessinez le diagramme d'états-transitions complet.


─────────────────────────────────────────────────────────────────────────
SOLUTION EXERCICE 1
─────────────────────────────────────────────────────────────────────────

DIAGRAMME D'ÉTATS-TRANSITIONS - Distributeur Automatique (ATM)


                    [BLACK_CIRCLE]  État Initial
                    │
                    v
              ┌─────────────┐
              │  Inactif    │
              └─────────────┘
                    │          ^
                    │          │
         carteInsérée          │
                    │          │
                    v          │
              ┌──────────────────────────┐
              │    AttentePIN            │
              ├──────────────────────────┤
              │ entry / afficherClavierPIN│
              │ tentatives = 0            │
              └──────────────────────────┘
                 │    │    │
                 │    │    │
    ┌────────────┘    │    └────────────────┐
    │                 │                     │
    │ pinSaisi        │ pinSaisi            │ annuler /
    │ [correct]       │ [incorrect          │ éjecterCarte
    │                 │  ET tentatives<3]/  │
    │                 │ incrémenterTentatives│
    v                 │                     │
┌──────────┐          │  (auto-transition)  v
│  Menu    │          └──────────┐     ┌─────────┐
│Principal │                     v     │ Inactif │
└──────────┘              ┌──────────┐ └─────────┘
                          │ AttentePIN│
    v                     └──────────┘
                                │
                                │ pinSaisi [incorrect
                                │ ET tentatives>=3] /
                                │ avalerCarte
                                v
                          ┌──────────┐
                          │ Bloqué   │
                          └──────────┘
                                │
                                │ réinitialisationAdmin
                                │
                                v
                          ┌──────────┐
                          │ Inactif  │
                          └──────────┘


DÉTAIL : ÉTAT COMPOSITE "MenuPrincipal"

┌──────────────────────────────────────────────────────────────┐
│                    MenuPrincipal                             │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│  ⊙H  <- État historique                                      │
│   │                                                          │
│   │ [par défaut]                                            │
│   v                                                          │
│ ┌────────────────────────────────────────────┐              │
│ │         Consultation                       │              │
│ │ ─────────────────────────────────────────  │              │
│ │ entry / interrogerBanque()                 │              │
│ │ exit / fermerConnexion()                   │              │
│ │                                            │              │
│ │   [BLACK_CIRCLE]                                        │              │
│ │   v                                        │              │
│ │ ┌──────────┐      ┌──────────┐            │              │
│ │ │Consulter │──────│ Afficher │            │              │
│ │ │ Solde    │      │Historique│            │              │
│ │ └──────────┘      └──────────┘            │              │
│ └────────────────────────────────────────────┘              │
│         │   ^                      │    ^                   │
│         │   │ retour               │    │                   │
│         │   │                      │    │                   │
│  choisir│   └──────────────────────┘    │                   │
│ Retrait │         timeout (30s)         │ choisir Dépôt     │
│         v                               v                   │
│ ┌────────────────────┐         ┌────────────────────┐      │
│ │      Retrait       │         │       Dépôt        │      │
│ ├────────────────────┤         ├────────────────────┤      │
│ │ do / vérifier      │         │ entry / ouvrirSlot│      │
│ │   Disponibilité()  │         │                    │      │
│ └────────────────────┘         └────────────────────┘      │
│         │   │                          │  │                │
│         │   │                          │  │                │
│         │   │ annuler                  │  │ annuler        │
│         │   └──────────────┬───────────┘  │                │
│         │                  │              │                │
│         │ montantSaisi     │              │ argentInséré/  │
│         │ [solde<montant]/ │              │ compter        │
│         │ afficherErreur   │              │                │
│         │                  │              │                │
│         └──────────────────┘              │                │
│                                           │                │
│         montantSaisi [solde>=montant]/    │                │
│         distribuerArgent                  │                │
│         │                                 │                │
└─────────┼─────────────────────────────────┼────────────────┘
          │                                 │
          │                                 │
          └────────────┬────────────────────┘
                       │
                       v
                 ┌──────────────┐
                 │ Finalisation │
                 ├──────────────┤
                 │ entry /      │
                 │ éjecterCarte()│
                 └──────────────┘
                       │
                       v
                    [WHITE_DIAMOND]─────[WHITE_DIAMOND]
                   / vouluReçu\
                  /            \
            [oui]/              \[non]
                /                \
               v                  v
        ┌──────────┐         ┌─────────┐
        │Imprimer  │         │ auto    │
        │ Reçu     │         │transition│
        └──────────┘         └─────────┘
               │                  │
               │                  │
               └────────┬─────────┘
                        │
                        v
                  ┌─────────┐
                  │ Inactif │
                  └─────────┘
                        │
                        v
                        [BULLSEYE]


ANALYSE DÉTAILLÉE :

1. ÉTATS PRINCIPAUX :
   - Inactif (repos)
   - AttentePIN (authentification)
   - MenuPrincipal (composite)
     * Consultation
     * Retrait
     * Dépôt
   - Finalisation (clôture transaction)
   - Bloqué (sécurité)

2. TRANSITIONS CLÉS :

   AUTO-TRANSITION (AttentePIN) :
   - pinSaisi [incorrect ET tentatives<3] / incrémenterTentatives
   - Reste dans AttentePIN
   - Exécute entry/exit à chaque fois
   - Réaffiche clavier

   TRANSITION INTERNE (alternative possible) :
   Pourrait être modélisé comme :
   ┌──────────────────────────┐
   │    AttentePIN            │
   ├──────────────────────────┤
   │ pinIncorrect [tentatives<3] /│
   │ incrémenterTentatives    │  <- Interne
   └──────────────────────────┘

3. GARDES COMPLEXES :
   - [incorrect ET tentatives < 3]
   - [incorrect ET tentatives >= 3]
   - [solde >= montant]
   - [solde < montant]
   - [vouluReçu]

4. ACTIONS :
   
   ENTRY :
   - AttentePIN : afficherClavierPIN
   - Consultation : interrogerBanque
   - Dépôt : ouvrirSlot
   - Finalisation : éjecterCarte
   
   EXIT :
   - Consultation : fermerConnexion
   
   DO (activité continue) :
   - Retrait : vérifierDisponibilité (polling)
   
   EFFET (sur transition) :
   - / éjecterCarte
   - / incrémenterTentatives
   - / avalerCarte
   - / afficherErreur
   - / distribuerArgent
   - / compter

5. ÉTAT COMPOSITE "MenuPrincipal" :
   - Contient 3 sous-états
   - État historique ⊙H
   - Si timeout -> Inactif
   - Retour avec H -> dernier sous-état actif

6. ÉTAT D'HISTORIQUE (H) :
   Scénario :
   - Utilisateur dans "Retrait"
   - Timeout -> Inactif (éjecte carte)
   - Insère carte à nouveau
   - PIN correct -> MenuPrincipal
   - Grâce à H -> Retour direct à "Retrait"

7. SÉCURITÉ :
   - 3 tentatives max -> Bloqué
   - Carte avalée
   - Nécessite admin pour réinitialiser

8. TIMEOUT :
   - 30s depuis Consultation -> Inactif
   - Évite blocage distributeur


SCÉNARIOS COUVERTS :

SCÉNARIO NOMINAL :
1. Inactif -> carteInsérée -> AttentePIN
2. AttentePIN -> pinSaisi[correct] -> MenuPrincipal->Retrait
3. Retrait -> montantSaisi[ok]/distribuer -> Finalisation
4. Finalisation -> [vouluReçu]/imprimerReçu -> Inactif

SCÉNARIO ERREUR PIN :
1. Inactif -> AttentePIN
2. AttentePIN -> pinIncorrect[1] -> AttentePIN (auto)
3. AttentePIN -> pinIncorrect[2] -> AttentePIN (auto)
4. AttentePIN -> pinIncorrect[3]/avalerCarte -> Bloqué
5. Bloqué -> réinitialisationAdmin -> Inactif

SCÉNARIO ANNULATION :
1. Inactif -> AttentePIN
2. AttentePIN -> annuler/éjecterCarte -> Inactif

SCÉNARIO TIMEOUT :
1. MenuPrincipal->Consultation -> timeout(30s) -> Inactif


[IDEE] POINTS CLÉS :

[OK] États bien définis et distincts
[OK] Transitions avec gardes claires
[OK] Actions entry/exit/do appropriées
[OK] Gestion erreurs et sécurité
[OK] État composite pour menu
[OK] État historique pour UX
[OK] Tous chemins couverts (pas de blocage)
"""


# ----------------------------------------------------------------------------
# [COURS] EXERCICE PRATIQUE 2 : CONNEXION TCP
# ----------------------------------------------------------------------------

"""
[WEB] ÉNONCÉ

Modélisez le cycle de vie d'une connexion TCP (protocole réseau).

ÉTATS ET TRANSITIONS :

1. FERMÉE (Closed) - État initial

2. ÉCOUTE (Listen) - Serveur attend connexions
   - De Fermée : passive_open -> Écoute

3. SYN_ENVOYÉ (Syn Sent) - Client initie connexion
   - De Fermée : active_open / envoyerSYN -> SynEnvoyé
   - De SynEnvoyé : recevoir SYN+ACK / envoyerACK -> Établie

4. SYN_REÇU (Syn Received) - Serveur reçoit demande
   - De Écoute : recevoir SYN / envoyerSYN+ACK -> SynReçu
   - De SynReçu : recevoir ACK -> Établie

5. ÉTABLIE (Established) - Connexion active
   - État composite avec 2 régions parallèles :
     * RÉGION ENVOI :
       - Prêt
       - Envoi en cours
     * RÉGION RÉCEPTION :
       - Prêt
       - Réception en cours
   
   - De Établie : close / envoyerFIN -> FinAttente1

6. FIN_ATTENTE_1 (Fin Wait 1) - Fermeture initiée
   - De FinAttente1 : recevoir ACK -> FinAttente2
   - De FinAttente1 : recevoir FIN / envoyerACK -> Fermeture

7. FIN_ATTENTE_2 (Fin Wait 2) - Attente FIN distant
   - De FinAttente2 : recevoir FIN / envoyerACK -> TimeWait

8. FERMETURE (Closing) - Fermeture simultanée
   - De Fermeture : recevoir ACK -> TimeWait

9. FERMETURE_ATTENTE (Close Wait) - Attente fermeture locale
   - De Établie : recevoir FIN / envoyerACK -> FermetureAttente
   - De FermetureAttente : close / envoyerFIN -> DernierACK

10. DERNIER_ACK (Last Ack) - Attente dernier ACK
    - De DernierACK : recevoir ACK -> Fermée

11. TIME_WAIT - Attente timer avant fermeture finale
    - De TimeWait : timeout (2*MSL) -> Fermée

12. TIMEOUT sur plusieurs états -> Fermée

Créez le diagramme d'états-transitions complet avec état composite pour Établie.


─────────────────────────────────────────────────────────────────────────
SOLUTION EXERCICE 2
─────────────────────────────────────────────────────────────────────────

DIAGRAMME D'ÉTATS-TRANSITIONS - Connexion TCP


                            [BLACK_CIRCLE]
                            │
                            v
                      ┌──────────┐
             ┌────────│  Fermée  │[BLACK_LEFT-POINTING_POINTER]──────────────┐
             │        └──────────┘               │
             │              │  ^                 │
             │              │  │                 │
     passive_open    active_open │                 │
             │            / envoyerSYN            │
             │              │  │                 │
             v              │  │                 │
       ┌──────────┐         │  │           ┌──────────┐
       │  Écoute  │         │  │           │ TimeWait │
       └──────────┘         │  │           ├──────────┤
             │              │  │           │ entry/   │
             │              │  │ timeout   │démarrerTimer│
             │              │  │ (2*MSL)   │          │
     recevoir SYN           │  │           └──────────┘
     / envoyerSYN+ACK       │  │                 ^
             │              │  │                 │
             v              v  │                 │
       ┌──────────┐   ┌──────────┐              │
       │ SynReçu  │   │SynEnvoyé │              │
       └──────────┘   └──────────┘              │
             │              │                    │
             │              │                    │
  recevoir ACK│   recevoir SYN+ACK               │
             │   / envoyerACK                   │
             │              │                    │
             └──────┬───────┘                    │
                    │                            │
                    v                            │
          ┌──────────────────────────────────┐  │
          │        ÉTABLIE                   │  │
          ├──────────────────────────────────┤  │
          │ RÉGION ENVOI                     │  │
          │   [BLACK_CIRCLE]                              │  │
          │   v                              │  │
          │ ┌────────┐     ┌──────────┐     │  │
          │ │ Prêt   │─────│  Envoi   │     │  │
          │ │        │send │EnCours   │     │  │
          │ └────────┘     └──────────┘     │  │
          │   ^                 │            │  │
          │   └─────────────────┘ done      │  │
          │ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄  │  │
          │ RÉGION RÉCEPTION                 │  │
          │   [BLACK_CIRCLE]                              │  │
          │   v                              │  │
          │ ┌────────┐     ┌──────────┐     │  │
          │ │ Prêt   │─────│Réception │     │  │
          │ │        │recv │EnCours   │     │  │
          │ └────────┘     └──────────┘     │  │
          │   ^                 │            │  │
          │   └─────────────────┘ done      │  │
          └──────────────────────────────────┘  │
                    │            │              │
                    │            │              │
          close /   │            │ recevoir FIN │
          envoyerFIN│            │ / envoyerACK │
                    │            │              │
                    v            v              │
             ┌──────────┐  ┌──────────┐        │
             │FinAttente1│  │ Fermeture│        │
             │          │  │  Attente │        │
             └──────────┘  └──────────┘        │
                 │   │           │              │
                 │   │           │              │
  recevoir ACK   │   │ recevoir FIN     close / │
                 │   │ / envoyerACK  envoyerFIN │
                 │   │           │              │
                 v   │           v              │
          ┌──────────┐     ┌──────────┐        │
          │FinAttente2│     │DernierACK│        │
          └──────────┘     └──────────┘        │
                 │               │              │
                 │               │              │
    recevoir FIN │               │ recevoir ACK │
    / envoyerACK │               │              │
                 v               │              │
          ┌──────────┐           │              │
          │ TimeWait │[BLACK_LEFT-POINTING_POINTER]──────────┘              │
          └──────────┘                          │
                 │                              │
                 └──────────────────────────────┘


          ┌──────────┐
          │Fermeture │[BLACK_LEFT-POINTING_POINTER]─────────────────┐
          │          │                  │
          └──────────┘                  │
                 │                      │
                 │ recevoir ACK         │
                 │                      │
                 └──────────────────────┘


EXPLICATION DÉTAILLÉE :

1. ÉTABLISSEMENT CONNEXION (3-way handshake) :

   CLIENT :
   Fermée -> active_open/envoyerSYN -> SynEnvoyé
         -> recevoir SYN+ACK/envoyerACK -> Établie

   SERVEUR :
   Fermée -> passive_open -> Écoute
         -> recevoir SYN/envoyerSYN+ACK -> SynReçu
         -> recevoir ACK -> Établie


2. ÉTAT COMPOSITE "ÉTABLIE" :

   Deux régions PARALLÈLES :
   
   RÉGION ENVOI :
   - Prêt : peut envoyer données
   - Envoi en cours : transmission active
   - send -> Envoi -> done -> Prêt
   
   RÉGION RÉCEPTION :
   - Prêt : peut recevoir données
   - Réception en cours : réception active
   - recv -> Réception -> done -> Prêt

   Les deux régions sont INDÉPENDANTES :
   - Peut envoyer PENDANT réception
   - Peut recevoir PENDANT envoi
   - Full-duplex


3. FERMETURE CONNEXION (4-way handshake) :

   FERMETURE ACTIVE (qui initie) :
   Établie -> close/envoyerFIN -> FinAttente1
         -> recevoir ACK -> FinAttente2
         -> recevoir FIN/envoyerACK -> TimeWait
         -> timeout(2*MSL) -> Fermée

   FERMETURE PASSIVE (qui répond) :
   Établie -> recevoir FIN/envoyerACK -> FermetureAttente
         -> close/envoyerFIN -> DernierACK
         -> recevoir ACK -> Fermée


4. FERMETURE SIMULTANÉE :
   
   Les deux côtés envoient FIN simultanément :
   Établie -> close/envoyerFIN -> FinAttente1
         -> recevoir FIN/envoyerACK -> Fermeture
         -> recevoir ACK -> TimeWait
         -> timeout -> Fermée


5. TIME_WAIT :
   
   Attente de 2*MSL (Maximum Segment Lifetime)
   - MSL ≈ 30s-120s selon implémentation
   - 2*MSL ≈ 1-4 minutes
   
   POURQUOI ?
   - Permettre ACK final d'arriver
   - Éviter que paquets retardés affectent nouvelle connexion
   - Éviter réutilisation immédiate même port/adresse


6. ACTIONS ASSOCIÉES :

   ENTRY :
   - TimeWait : entry / démarrerTimer(2*MSL)
   - Établie : entry / notifierApplication
   
   EXIT :
   - Établie : exit / libérerRessources
   
   DO :
   - TimeWait : do / attendre (activité continue)
   
   EFFET (sur transitions) :
   - / envoyerSYN
   - / envoyerSYN+ACK
   - / envoyerACK
   - / envoyerFIN
   - / notifier


7. TIMEOUTS (non représentés pour clarté) :
   
   De presque tous états :
   - timeout -> Fermée
   
   Exemples :
   - SynEnvoyé : pas de réponse après N secondes -> Fermée
   - FinAttente2 : pas de FIN après timeout -> Fermée


COMPARAISON AVEC DIAGRAMME D'ACTIVITÉS :

┌──────────────────────────┬──────────────────────────┐
│ ÉTATS-TRANSITIONS (TCP)  │ ACTIVITÉS                │
├──────────────────────────┼──────────────────────────┤
│ États de la CONNEXION    │ Processus de connexion   │
│ Réagit aux ÉVÉNEMENTS    │ Séquence d'ACTIONS       │
│ Machine à états          │ Workflow                 │
│ "Établie"                │ "Établir connexion"      │
│ Objet : Connexion TCP    │ Processus général        │
└──────────────────────────┴──────────────────────────┘


SCÉNARIOS TYPIQUES :

SCÉNARIO 1 : Connexion normale
1. Client : Fermée -> SynEnvoyé -> Établie
2. Serveur : Écoute -> SynReçu -> Établie
3. Transfer données (régions parallèles actives)
4. Client ferme : Établie -> FinAttente1 -> FinAttente2 -> TimeWait -> Fermée
5. Serveur : Établie -> FermetureAttente -> DernierACK -> Fermée

SCÉNARIO 2 : Connexion refusée
1. Client : Fermée -> SynEnvoyé
2. Serveur pas en écoute -> RST reçu
3. Client : SynEnvoyé -> timeout -> Fermée

SCÉNARIO 3 : Fermeture simultanée
1. Les deux : Établie -> FinAttente1 -> Fermeture -> TimeWait -> Fermée


[IDEE] UTILITÉ DU DIAGRAMME :

[OK] Comprendre protocole TCP
[OK] Implémenter stack TCP/IP
[OK] Débugger problèmes réseau
[OK] Optimiser gestion connexions
[OK] Enseigner protocoles réseau
[OK] Documenter comportement


[IDEE] COMPLEXITÉ MODÉLISÉE :

- 11 états principaux
- 1 état composite (Établie) avec 2 régions parallèles
- ~20 transitions
- 3-way handshake (établissement)
- 4-way handshake (fermeture)
- Full-duplex (envoi/réception simultanés)
- Fermeture active vs passive
- Fermeture simultanée
- TIME_WAIT (attente sécurisée)
"""


# ----------------------------------------------------------------------------
# [DOCS] RÉCAPITULATIF CHAPITRE 7 - DIAGRAMME D'ÉTATS-TRANSITIONS
# ----------------------------------------------------------------------------

"""
CE QUE VOUS AVEZ APPRIS

[OK] Diagramme d'états = cycle de vie d'un objet
[OK] États (rectangles arrondis) et transitions (flèches)
[OK] Événements, gardes et actions
[OK] Actions entry/exit/do sur états
[OK] Transitions internes vs auto-transitions
[OK] États composites (hiérarchie)
[OK] États d'historique (H et H*)
[OK] États parallèles (régions orthogonales)
[OK] 2 exercices complets (ATM, TCP)


[CLE] POINTS CLÉS

1. ÉTAT = Situation de l'objet à un instant donné
2. TRANSITION = Passage d'un état à un autre
3. ÉVÉNEMENT = Déclencheur de transition
4. GARDE [condition] = Condition sur transition
5. ACTION = Comportement exécuté
6. entry/exit/do = Actions spéciales sur états
7. État COMPOSITE = Contient sous-états
8. Régions PARALLÈLES = États simultanés


[IDEE] DIFFÉRENCES CLÉS

┌──────────────────────────┬──────────────────────────┐
│ ÉTATS-TRANSITIONS        │ ACTIVITÉS                │
├──────────────────────────┼──────────────────────────┤
│ Cycle de vie OBJET       │ Workflow PROCESSUS       │
│ Réactif (événements)     │ Proactif (séquence)      │
│ États avec durée         │ Actions instantanées     │
│ Un objet spécifique      │ Processus général        │
│ "Commande.état = Livrée" │ "Livrer commande"        │
└──────────────────────────┴──────────────────────────┘


[OK] CHECKLIST

Vous devez être capable de :
[ ] Identifier états d'un objet
[ ] Modéliser transitions entre états
[ ] Utiliser événements et gardes
[ ] Placer actions entry/exit/do
[ ] Créer états composites
[ ] Utiliser état d'historique
[ ] Modéliser régions parallèles
[ ] Créer machine à états complète


[COURS] BONNES PRATIQUES

1. NOMMAGE :
   - États : Substantifs ou adjectifs (Actif, EnCours)
   - Événements : Verbes (cliquer, timeout)
   - Actions : Verbes (démarrer, arrêter)

2. COMPLÉTUDE :
   - Tous états ont transition sortante
   - Pas d'état "piège" (sauf états finaux)
   - Couvrir tous événements possibles

3. ORGANISATION :
   - Grouper états liés (composites)
   - Utiliser parallélisme si indépendant
   - Limiter hiérarchie (2-3 niveaux max)

4. CLARTÉ :
   - Ne pas surcharger transitions
   - Conditions mutuellement exclusives
   - Éviter croisements de flèches


[ATTENTION] ERREURS FRÉQUENTES

[X] Confondre ÉTAT et ACTIVITÉ
   [OK] État : "Connecté" (situation durable)
   [X] Activité : "Se connecter" (action temporaire)

[X] Trop d'états
   [OK] Regrouper en composite
   [X] Un état par valeur d'attribut

[X] Oublier transitions de sortie
   [OK] Tous états doivent pouvoir sortir
   [X] États "pièges" sans sortie

[X] Actions mal placées
   [OK] entry/exit pour initialisation/cleanup
   [X] Logique métier complexe dans actions


[COURS] POUR S'ENTRAÎNER

Créez des diagrammes d'états pour :
1. Porte automatique (fermée, ouverte, bloquée)
2. Ascenseur (arrêté, montée, descente, porte ouverte)
3. Commande e-commerce (créée, payée, expédiée, livrée)
4. Appel téléphonique (inactif, sonnerie, en cours, terminé)
5. Document (brouillon, en révision, validé, publié)


[GRAPHIQUE] QUAND UTILISER CHAQUE DIAGRAMME ?

Use Case -> QUOI faire (fonctionnalités)
Séquence -> COMMENT interagir (messages objets)
Activités -> COMMENT processus se déroule (workflow)
États -> COMMENT objet évolue (cycle de vie)
Classes -> AVEC QUOI (structure données)


[BRAVO] FÉLICITATIONS !

Vous avez terminé les DIAGRAMMES COMPORTEMENTAUX !

[OK] Cas d'Utilisation (vue externe)
[OK] Séquence (interactions temporelles)
[OK] Activités (workflows et processus)
[OK] États-Transitions (cycles de vie)


-> PROCHAINES ÉTAPES

Vous maîtrisez maintenant les 7 diagrammes ESSENTIELS :

STRUCTURELS :
1. Classes *** (le plus important)
2. Objets
3. Composants **

COMPORTEMENTAUX :
4. Cas d'Utilisation ***
5. Séquence ***
6. Activités **
7. États-Transitions **


Ces 7 diagrammes couvrent 90% des besoins en modélisation !

Pour aller plus loin, vous pourriez étudier :
- Diagramme de Déploiement (infrastructure)
- Diagramme de Paquetages (organisation code)
- Diagrammes d'interaction avancés
- Diagrammes de timing
- Patterns de conception en UML

Mais vous avez déjà une base SOLIDE pour :
[OK] Analyser et concevoir systèmes
[OK] Documenter architectures
[OK] Communiquer avec équipes
[OK] Passer à l'implémentation

Bravo ! [BRAVO][RAPIDE]
"""


# ============================================================================
# FIN DU CHAPITRE 7 - DIAGRAMME D'ÉTATS-TRANSITIONS
# FIN DE LA PARTIE 2 - DIAGRAMMES COMPORTEMENTAUX
# ============================================================================

"""
╔══════════════════════════════════════════════════════════════════════╗
║                                                                      ║
║           [COURS] GUIDE UML ULTRA-DÉTAILLÉ POUR DÉBUTANTS [COURS]              ║
║                                                                      ║
║                    [OK] PARTIE 2 TERMINÉE ! [OK]                         ║
║                                                                      ║
╚══════════════════════════════════════════════════════════════════════╝


[DOCS] RÉCAPITULATIF COMPLET

PARTIE 1 : DIAGRAMMES STRUCTURELS
─────────────────────────────────

Chapitre 0 : Introduction à UML
  [OK] Histoire et contexte
  [OK] 14 types de diagrammes UML
  [OK] Quand utiliser UML

Chapitre 1 : Diagramme de Classes ***
  [OK] Classes, attributs, méthodes
  [OK] Relations (association, agrégation, composition, héritage)
  [OK] Interfaces et classes abstraites
  [OK] Multiplicités et navigabilité
  [OK] 2 exercices (bibliothèque, système bancaire)

Chapitre 2 : Diagramme d'Objets
  [OK] Instances avec valeurs concrètes
  [OK] Snapshots du système
  [OK] Validation de conception
  [OK] 2 exercices (réseau social, e-commerce)

Chapitre 3 : Diagramme de Composants **
  [OK] Architecture logicielle
  [OK] Interfaces fournies et requises
  [OK] Dépendances entre modules
  [OK] Organisation en couches
  [OK] 2 exercices (e-learning, système bancaire)


PARTIE 2 : DIAGRAMMES COMPORTEMENTAUX
──────────────────────────────────────

Chapitre 4 : Diagramme de Cas d'Utilisation ***
  [OK] Acteurs et cas d'utilisation
  [OK] Relations include/extend/généralisation
  [OK] Frontière du système
  [OK] Descriptions textuelles
  [OK] 2 exercices (bibliothèque, e-learning)

Chapitre 5 : Diagramme de Séquence ***
  [OK] Interactions temporelles
  [OK] Messages synchrones et asynchrones
  [OK] Lignes de vie et activation
  [OK] Fragments (alt, loop, opt, par)
  [OK] Création et destruction d'objets
  [OK] 2 exercices (réservation vol, e-commerce)

Chapitre 6 : Diagramme d'Activités **
  [OK] Workflows et processus
  [OK] Décisions et fusions
  [OK] Fork et Join (parallélisme)
  [OK] Partitions (swimlanes)
  [OK] Boucles et structures
  [OK] 2 exercices (commande e-commerce, recrutement)

Chapitre 7 : Diagramme d'États-Transitions **
  [OK] Cycle de vie d'objets
  [OK] États, transitions, événements
  [OK] Actions entry/exit/do
  [OK] États composites
  [OK] États parallèles (régions orthogonales)
  [OK] 2 exercices (ATM, connexion TCP)


═══════════════════════════════════════════════════════════════════════

STATISTIQUES DU GUIDE :

[GRAPHIQUE] NOMBRE DE CHAPITRES : 8 (0-7)
[GRAPHIQUE] NOMBRE D'EXERCICES : 14 exercices complets avec solutions détaillées
[GRAPHIQUE] TYPES DE DIAGRAMMES : 7 diagrammes essentiels
[GRAPHIQUE] EXEMPLES : 50+ exemples concrets
[GRAPHIQUE] PAGES ESTIMÉES : 400+ pages de contenu
[GRAPHIQUE] MÉTHODOLOGIE : COMMENT/POURQUOI/QUAND pour chaque concept


═══════════════════════════════════════════════════════════════════════

[OBJECTIF] COMPÉTENCES ACQUISES

Après ce guide, vous êtes capable de :

[OK] ANALYSER systèmes et exigences
[OK] MODÉLISER structures de données (classes)
[OK] CONCEVOIR architectures logicielles (composants)
[OK] SPÉCIFIER fonctionnalités (cas d'utilisation)
[OK] DÉTAILLER interactions (séquence)
[OK] DOCUMENTER processus métier (activités)
[OK] MODÉLISER cycles de vie (états-transitions)
[OK] COMMUNIQUER avec équipes techniques et métier
[OK] PASSER à l'implémentation avec confiance


═══════════════════════════════════════════════════════════════════════

[PRO] APPLICATIONS PRATIQUES

Ces compétences UML sont utilisées pour :

[ENTREPRISE] ENTREPRISE
  - Analyse de besoins clients
  - Conception d'applications métier
  - Documentation de systèmes existants
  - Architecture de microservices

[COURS] ACADÉMIQUE
  - Projets de génie logiciel
  - Mémoires et thèses
  - Rapports techniques
  - Présentations

[RAPIDE] CARRIÈRE
  - Architecte logiciel
  - Analyste système
  - Chef de projet technique
  - Développeur senior


═══════════════════════════════════════════════════════════════════════

[DOCS] POUR ALLER PLUS LOIN (optionnel)

Diagrammes UML avancés non couverts :

[PACKAGE] STRUCTURELS AVANCÉS :
  - Diagramme de Paquetages (organisation modules)
  - Diagramme de Déploiement (infrastructure physique)
  - Diagramme de Profil (personnalisation UML)

[DIZZY_SYMBOL] COMPORTEMENTAUX AVANCÉS :
  - Diagramme de Communication (variante séquence)
  - Diagramme de Timing (contraintes temporelles)
  - Diagramme de Vue d'Ensemble (combinaison)

[DESIGN] PATTERNS DE CONCEPTION :
  - Singleton, Factory, Observer en UML
  - MVC, MVVM architectures
  - Microservices patterns


═══════════════════════════════════════════════════════════════════════

[COURS] CONSEILS FINAUX

1. PRATIQUEZ régulièrement
   - Modélisez vos propres projets
   - Refaites les exercices
   - Créez vos propres exemples

2. RESTEZ PRAGMATIQUE
   - UML = outil, pas objectif
   - Pas besoin de TOUT modéliser
   - Choisir bons diagrammes selon besoin

3. COMMUNIQUEZ
   - UML = langage commun
   - Expliquez vos diagrammes
   - Obtenez feedback

4. ADAPTEZ-VOUS
   - Différents outils UML
   - Différentes conventions d'équipe
   - Adaptez niveau de détail

5. CONTINUEZ À APPRENDRE
   - Nouveaux patterns
   - Nouvelles architectures
   - Évolution des pratiques


═══════════════════════════════════════════════════════════════════════

* FÉLICITATIONS ! *

Vous avez terminé ce guide UML ultra-détaillé !

Vous avez parcouru :
  [GUIDE] 8 chapitres complets
  [OBJECTIF] 14 exercices pratiques
  [IDEE] Centaines d'exemples
  [COURS] Méthodologie COMMENT/POURQUOI/QUAND

Vous maîtrisez maintenant les bases SOLIDES de la modélisation UML
et êtes prêt(e) à les appliquer dans vos projets !

Bon courage pour vos futurs projets de développement ! [RAPIDE]

═══════════════════════════════════════════════════════════════════════
"""


################################################################################
################################################################################
##                                                                            ##
##  SECTION IV : PARTIE 3 - DIAGRAMMES AVANCÉS
##                                                                            ##
################################################################################
################################################################################


# ============================================================================
# [LIVRE] UML - PARTIE 3 : DIAGRAMMES AVANCÉS
# ============================================================================


# ============================================================================
# [GUIDE] CHAPITRE 8 : DIAGRAMME DE DÉPLOIEMENT (DEPLOYMENT DIAGRAM)
# ============================================================================

"""
[OBJECTIF] OBJECTIFS D'APPRENTISSAGE

À la fin de ce chapitre, vous saurez :
[OK] Qu'est-ce qu'un diagramme de déploiement
[OK] Modéliser infrastructure physique
[OK] Représenter nœuds matériels et logiciels
[OK] Modéliser artefacts déployés
[OK] Représenter connexions réseau
[OK] Documenter architecture système distribuée
[OK] Créer diagrammes de déploiement complets
"""


# ----------------------------------------------------------------------------
# [REFLEXION] QU'EST-CE QU'UN DIAGRAMME DE DÉPLOIEMENT ?
# ----------------------------------------------------------------------------

"""
DÉFINITION SIMPLE

Diagramme de Déploiement = Vue de l'INFRASTRUCTURE PHYSIQUE

Montre :
├─ NŒUDS matériels (serveurs, PC, mobile)
├─ ARTEFACTS logiciels (fichiers exécutables, .jar, .war)
├─ DÉPLOIEMENT (quoi est déployé où)
└─ CONNEXIONS réseau (protocoles de communication)


[IDEE] CONCEPTS CLÉS

NŒUD = Ressource matérielle ou environnement d'exécution
ARTEFACT = Fichier physique déployable
DÉPLOIEMENT = Affectation artefact -> nœud
COMMUNICATION = Lien réseau entre nœuds


ANALOGIE [CONSTRUCTION]

Diagramme de Déploiement = Plan d'implantation d'un data center
- Serveurs physiques = Nœuds
- Applications installées = Artefacts
- Câbles réseau = Connexions
- Protocoles = Communications


[REFLEXION] POURQUOI UTILISER ?

[OK] PLANIFIER INFRASTRUCTURE
- Dimensionner serveurs
- Prévoir besoins réseau
- Estimer coûts matériels

[OK] DOCUMENTER ARCHITECTURE
- Architecture actuelle
- Migration vers cloud
- Topologie réseau

[OK] DÉPLOIEMENT
- Guide installation
- Configuration environnements
- Répartition de charge

[OK] SÉCURITÉ
- Identifier zones sécurisées
- Planifier pare-feu
- Isoler composants sensibles


[REFLEXION] QUAND L'UTILISER ?

[OK] UTILISEZ POUR :
- Applications distribuées (multi-serveurs)
- Architecture cloud (AWS, Azure, GCP)
- Systèmes embarqués (IoT)
- Applications mobile avec backend
- Infrastructure complexe

[X] ÉVITEZ POUR :
- Applications monolithiques simples
- Logique métier (utilisez classes)
- Processus (utilisez activités)
- Vue utilisateur (utilisez cas d'utilisation)


RELATION AVEC AUTRES DIAGRAMMES

Composants -> Vue LOGIQUE (modules logiciels)
         v
Déploiement -> Vue PHYSIQUE (où composants s'exécutent)
         v
Infrastructure -> Matériel + Réseau + Logiciel
"""


# ----------------------------------------------------------------------------
# [ECRAN] NŒUDS (NODES)
# ----------------------------------------------------------------------------

"""
QU'EST-CE QU'UN NŒUD ?

Nœud = Ressource de calcul physique ou virtuelle

Types :
1. DEVICE (appareil matériel)
2. EXECUTION ENVIRONMENT (environnement logiciel)


NOTATION

Cube 3D avec nom

    ┌─────────────────┐
   ╱                 ╱│
  ╱                 ╱ │
 ╱                 ╱  │
├─────────────────┤   │
│  NomNoeud       │   │
│                 │   │
│  <<device>>     │   ╱
│                 │  ╱
│                 │ ╱
└─────────────────┘╱


TYPES DE NŒUDS

1. DEVICE NODE (nœud matériel)

Stéréotypes courants :
- <<device>> : appareil générique
- <<server>> : serveur
- <<client>> : poste client
- <<mobile>> : appareil mobile
- <<embedded>> : système embarqué
- <<database>> : serveur de base de données

Exemples :
    ┌─────────────────┐
   ╱                 ╱│
  ╱   Web Server    ╱ │
 ╱                 ╱  │
├─────────────────┤   │
│  <<server>>     │   │
│                 │   ╱
│  Linux Ubuntu   │  ╱
│  8 CPU, 16GB    │ ╱
└─────────────────┘╱


    ┌─────────────────┐
   ╱                 ╱│
  ╱  Smartphone     ╱ │
 ╱                 ╱  │
├─────────────────┤   │
│  <<mobile>>     │   │
│                 │   ╱
│  iOS 16         │  ╱
│                 │ ╱
└─────────────────┘╱


2. EXECUTION ENVIRONMENT (environnement d'exécution)

Stéréotypes courants :
- <<execution environment>> : conteneur d'exécution
- <<container>> : Docker container
- <<JVM>> : Java Virtual Machine
- <<application server>> : serveur d'applications
- <<web server>> : serveur web

Exemples :
    ┌─────────────────────────┐
   ╱                         ╱│
  ╱  Tomcat                 ╱ │
 ╱                         ╱  │
├─────────────────────────┤   │
│  <<application server>> │   │
│                         │   ╱
│  Version 9.0            │  ╱
└─────────────────────────┘╱


NŒUDS IMBRIQUÉS

Un nœud peut contenir d'autres nœuds

    ┌────────────────────────────────────┐
   ╱  Physical Server                   ╱│
  ╱  <<server>>                        ╱ │
 ╱                                    ╱  │
├────────────────────────────────────┤   │
│  Linux Ubuntu 22.04                │   │
│  32 CPU, 128GB RAM                 │   │
│                                    │   │
│  ┌──────────────────────────────┐ │   │
│ ╱  Docker                       ╱│ │   │
│╱  <<container>>                ╱ │ │   ╱
├──────────────────────────────┤  │ │  ╱
││  Java Runtime Environment   │  │ │ ╱
││                             │  ╱ │╱
│└──────────────────────────────┘╱  │
│                                    │
└────────────────────────────────────┘


PROPRIÉTÉS DES NŒUDS

On peut spécifier :
- Système d'exploitation
- Processeur (CPU)
- Mémoire (RAM)
- Stockage
- Version logicielle
- Configuration


Exemple détaillé :
    ┌─────────────────────────────┐
   ╱  Database Server            ╱│
  ╱  <<database>>               ╱ │
 ╱                             ╱  │
├─────────────────────────────┤   │
│  OS: Windows Server 2022    │   │
│  CPU: 16 cores              │   │
│  RAM: 64 GB                 │   ╱
│  Storage: 2 TB SSD          │  ╱
│  DBMS: PostgreSQL 15        │ ╱
└─────────────────────────────┘╱
"""


# ----------------------------------------------------------------------------
# [PACKAGE] ARTEFACTS (ARTIFACTS)
# ----------------------------------------------------------------------------

"""
QU'EST-CE QU'UN ARTEFACT ?

Artefact = Fichier physique DÉPLOYABLE

Types :
- Fichiers exécutables (.exe, .app)
- Bibliothèques (.jar, .dll, .so)
- Archives (.war, .ear)
- Scripts (.sh, .bat)
- Fichiers de configuration (.xml, .json)
- Documents (.pdf, .html)


NOTATION

Rectangle avec icône document en coin

    ┌─────────────────┐
    │  ┌─┐            │
    │  └─┘ app.jar    │
    │                 │
    │  <<artifact>>   │
    └─────────────────┘


STÉRÉOTYPES D'ARTEFACTS

<<executable>> : fichier exécutable
<<library>> : bibliothèque
<<file>> : fichier générique
<<script>> : script
<<source>> : code source
<<document>> : documentation


EXEMPLES :

    ┌─────────────────┐
    │  ┌─┐            │
    │  └─┘ webapp.war │
    │                 │
    │  <<artifact>>   │
    │  <<library>>    │
    └─────────────────┘


    ┌─────────────────┐
    │  ┌─┐            │
    │  └─┘ deploy.sh  │
    │                 │
    │  <<artifact>>   │
    │  <<script>>     │
    └─────────────────┘


ARTEFACT MANIFESTANT COMPOSANT

Lien entre composant logique et fichier physique

    ┌──────────────┐  <<manifest>>   ┌─────────────────┐
    │  ┌───┐       │ ─ ─ ─ ─ ─ ─ ─> │  ┌─┐            │
    │  │   │UserAPI│                 │  └─┘ userapi.jar│
    │  └───┘       │                 │                 │
    │  Component   │                 │  <<artifact>>   │
    └──────────────┘                 └─────────────────┘

UserAPI (composant logique) se manifeste physiquement par userapi.jar


DÉPLOIEMENT D'ARTEFACT SUR NŒUD

Notation : artefact À L'INTÉRIEUR du nœud

    ┌─────────────────────────────┐
   ╱  Application Server         ╱│
  ╱  <<server>>                 ╱ │
 ╱                             ╱  │
├─────────────────────────────┤   │
│  Tomcat 9.0                 │   │
│                             │   │
│  ┌─────────────────┐        │   ╱
│  │  ┌─┐            │        │  ╱
│  │  └─┘ webapp.war │        │ ╱
│  │                 │        │╱
│  │  <<artifact>>   │        │
│  └─────────────────┘        │
│                             │
└─────────────────────────────┘


RELATION <<deploy>>

Alternative : flèche avec stéréotype

    ┌─────────────────┐
    │  ┌─┐            │
    │  └─┘ app.jar    │   <<deploy>>
    │                 │ ─ ─ ─ ─ ─ ─>  ┌─────────────────┐
    │  <<artifact>>   │               ╱  Server         ╱│
    └─────────────────┘              ╱  <<server>>     ╱ │
                                    ├─────────────────┤  │
                                    │                 │  ╱
                                    └─────────────────┘ ╱
"""


# ----------------------------------------------------------------------------
# [WEB] CONNEXIONS ET COMMUNICATIONS
# ----------------------------------------------------------------------------

"""
TYPES DE CONNEXIONS

1. ASSOCIATION simple (lien physique)
2. COMMUNICATION PATH (chemin de communication)


NOTATION

Ligne entre nœuds avec protocole/technologie

    ┌─────────────┐                    ┌─────────────┐
   ╱  Client     ╱│    <<HTTP>>       ╱  Server     ╱│
  ╱             ╱ │ ─ ─ ─ ─ ─ ─ ─ ─> ╱             ╱ │
 ├─────────────┤  │                  ├─────────────┤  │
 │             │  ╱                  │             │  ╱
 └─────────────┘ ╱                   └─────────────┘ ╱


STÉRÉOTYPES DE COMMUNICATION

<<HTTP>> : protocole HTTP
<<HTTPS>> : protocole HTTPS sécurisé
<<TCP/IP>> : protocole TCP/IP
<<JDBC>> : connexion base de données Java
<<RMI>> : Remote Method Invocation
<<REST>> : API REST
<<WebSocket>> : WebSocket
<<gRPC>> : Google RPC
<<MQTT>> : protocole IoT


PROPRIÉTÉS DE CONNEXION

On peut spécifier :
- Protocole
- Port
- Bande passante
- Latence
- Sécurité


Exemple :
    ┌─────────────┐                           ┌─────────────┐
   ╱  Web Client ╱│  <<HTTPS>>               ╱  API Server ╱│
  ╱             ╱ │  {port=443}             ╱             ╱ │
 ├─────────────┤  │  {encryption=TLS 1.3}  ├─────────────┤  │
 │             │  ╱ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─> │             │  ╱
 └─────────────┘ ╱                          └─────────────┘ ╱


CONNEXIONS BIDIRECTIONNELLES

    ┌─────────────┐                    ┌─────────────┐
   ╱  Service A  ╱│    <<REST>>       ╱  Service B  ╱│
  ╱             ╱ │ <-─ ─ ─ ─ ─ ─ ─ ─ ╱             ╱ │
 ├─────────────┤  │                  ├─────────────┤  │
 │             │  ╱ ─ ─ ─ ─ ─ ─ ─ ─> │             │  ╱
 └─────────────┘ ╱    <<gRPC>>       └─────────────┘ ╱


RÉSEAUX ET SOUS-RÉSEAUX

On peut grouper nœuds par réseau

    ┌────────────────────────────────────────────┐
    │  RÉSEAU INTERNE (10.0.0.0/24)             │
    │  ────────────────────────────────────────  │
    │                                            │
    │  ┌─────────────┐      ┌─────────────┐    │
    │ ╱  App Server ╱│     ╱  DB Server  ╱│    │
    │╱             ╱ │    ╱             ╱ │    │
    │─────────────┤  │   ├─────────────┤  │    │
    ││            │  ╱   │             │  ╱    │
    │└─────────────┘ ╱    └─────────────┘ ╱    │
    │                                            │
    └────────────────────────────────────────────┘
                      │
                      │ <<HTTPS>>
                      [BLACK_DOWN-POINTING_TRIANGLE]
    ┌────────────────────────────────────────────┐
    │  INTERNET                                  │
    └────────────────────────────────────────────┘
"""


# ----------------------------------------------------------------------------
# [COURS] EXERCICE PRATIQUE 1 : APPLICATION WEB 3-TIERS
# ----------------------------------------------------------------------------

"""
[WEB] ÉNONCÉ

Créez un diagramme de déploiement pour une application web e-commerce
classique en architecture 3-tiers.

ARCHITECTURE :

TIER 1 - PRÉSENTATION (DMZ) :
- Load Balancer (HAProxy)
  * 2 instances (haute disponibilité)
  * OS: Linux
- Web Servers (Nginx)
  * 3 instances
  * OS: Linux
  * Artefacts: frontend.html, app.js, styles.css

TIER 2 - APPLICATION (Réseau privé) :
- Application Servers (Tomcat)
  * 4 instances
  * OS: Linux
  * Artefact: backend.war
  * JVM 11

TIER 3 - DONNÉES (Réseau sécurisé) :
- Database Server (PostgreSQL)
  * 1 instance principale + 1 réplique
  * OS: Linux
  * 32 CPU, 128GB RAM
- Cache Server (Redis)
  * 1 instance
  * OS: Linux

CLIENTS :
- Web Browser (desktop)
- Mobile App (iOS/Android)

CONNEXIONS :
- Client -> Load Balancer : HTTPS (port 443)
- Load Balancer -> Web Servers : HTTP (port 80)
- Web Servers -> App Servers : HTTP (port 8080)
- App Servers -> Database : JDBC (port 5432)
- App Servers -> Redis : Redis Protocol (port 6379)
- Database -> Database Replica : Replication

Dessinez le diagramme de déploiement complet avec zones réseau.


─────────────────────────────────────────────────────────────────────────
SOLUTION EXERCICE 1
─────────────────────────────────────────────────────────────────────────

DIAGRAMME DE DÉPLOIEMENT - E-Commerce 3-Tiers


┌─────────────────────────────────────────────────────────────────────┐
│                        INTERNET                                     │
└─────────────────────────────────────────────────────────────────────┘
          │                              │
          │ HTTPS (443)                  │ HTTPS (443)
          [BLACK_DOWN-POINTING_TRIANGLE]                              [BLACK_DOWN-POINTING_TRIANGLE]
    ┌─────────────┐                ┌─────────────┐
   ╱  Desktop    ╱│               ╱  Mobile     ╱│
  ╱  Browser    ╱ │              ╱  Device     ╱ │
 ├─────────────┤  │             ├─────────────┤  │
 │ <<client>>  │  ╱             │ <<mobile>>  │  ╱
 │             │ ╱              │             │ ╱
 │ Chrome/     │╱               │ iOS/Android │╱
 │ Firefox     │                │             │
 └─────────────┘                └─────────────┘
          │                              │
          └──────────────┬───────────────┘
                         │ HTTPS (443)
                         [BLACK_DOWN-POINTING_TRIANGLE]
┌──────────────────────────────────────────────────────────────────────┐
│  DMZ (Zone Démilitarisée) - 192.168.1.0/24                          │
│  ────────────────────────────────────────────────────────────────    │
│                                                                      │
│     ┌────────────────────┐              ┌────────────────────┐     │
│    ╱  LB1               ╱│             ╱  LB2               ╱│     │
│   ╱  Load Balancer     ╱ │            ╱  Load Balancer     ╱ │     │
│  ├────────────────────┤  │           ├────────────────────┤  │     │
│  │ <<server>>         │  │           │ <<server>>         │  │     │
│  │ HAProxy 2.4        │  ╱           │ HAProxy 2.4        │  ╱     │
│  │ Linux Ubuntu       │ ╱            │ Linux Ubuntu       │ ╱      │
│  │ 4 CPU, 8GB         │╱ (failover)  │ 4 CPU, 8GB         │╱       │
│  └────────────────────┘ <-─ ─ ─ ─ ─ ─ └────────────────────┘        │
│           │                                   │                     │
│           └───────────────┬───────────────────┘                     │
│                           │ HTTP (80)                               │
│            ┌──────────────┼──────────────┐                          │
│            │              │              │                          │
│            [BLACK_DOWN-POINTING_TRIANGLE]              [BLACK_DOWN-POINTING_TRIANGLE]              [BLACK_DOWN-POINTING_TRIANGLE]                          │
│    ┌────────────┐  ┌────────────┐  ┌────────────┐                 │
│   ╱ WebSrv1    ╱│ ╱ WebSrv2    ╱│ ╱ WebSrv3    ╱│                 │
│  ╱            ╱ │╱            ╱ │╱            ╱ │                 │
│ ├────────────┤  ├────────────┤  ├────────────┤  │                 │
│ │ <<server>> │  │ <<server>> │  │ <<server>> │  │                 │
│ │ Nginx 1.20 │  │ Nginx 1.20 │  │ Nginx 1.20 │  ╱                 │
│ │ Linux      │ ╱│ Linux      │ ╱│ Linux      │ ╱                  │
│ │ 2CPU, 4GB  │╱ │ 2CPU, 4GB  │╱ │ 2CPU, 4GB  │╱                   │
│ │            │  │            │  │            │                     │
│ │┌──────────┐│  │┌──────────┐│  │┌──────────┐│                     │
│ ││ ┌─┐      ││  ││ ┌─┐      ││  ││ ┌─┐      ││                     │
│ ││ └─┘index ││  ││ └─┘index ││  ││ └─┘index ││                     │
│ ││  .html   ││  ││  .html   ││  ││  .html   ││                     │
│ ││<<artifact││  ││<<artifact││  ││<<artifact││                     │
│ │└──────────┘│  │└──────────┘│  │└──────────┘│                     │
│ └────────────┘  └────────────┘  └────────────┘                     │
└──────────────────────────────────────────────────────────────────────┘
          │              │              │
          └──────────────┼──────────────┘
                         │ HTTP (8080)
                         [BLACK_DOWN-POINTING_TRIANGLE]
┌──────────────────────────────────────────────────────────────────────┐
│  RÉSEAU PRIVÉ APPLICATION - 10.0.1.0/24                             │
│  ────────────────────────────────────────────────────────────────    │
│                                                                      │
│  ┌────────────┐ ┌────────────┐ ┌────────────┐ ┌────────────┐      │
│ ╱ AppSrv1    ╱│╱ AppSrv2    ╱│╱ AppSrv3    ╱│╱ AppSrv4    ╱│      │
│╱            ╱ ╱            ╱ ╱            ╱ ╱            ╱ │      │
├────────────┤ ├────────────┤ ├────────────┤ ├────────────┤  │      │
││<<server>> │ ││<<server>> │ ││<<server>> │ ││<<server>> │  │      │
││           │╱ ││           │╱ ││           │╱ ││           │  ╱      │
││ ┌───────────┐││ ┌───────────┐││ ┌───────────┐││ ┌───────────┐│      │
│││ Tomcat 9 ╱│││ │ Tomcat 9 ╱│││ │ Tomcat 9 ╱│││ │ Tomcat 9 ╱││      │
││╱  <<exec  ╱ │││╱  <<exec  ╱ │││╱  <<exec  ╱ │││╱  <<exec  ╱ ││      │
││  env>>   ╱  ││╱  env>>   ╱  ││╱  env>>   ╱  ││╱  env>>   ╱  ││      │
│├─────────┤   ├─────────┤   ├─────────┤   ├─────────┤   ││      │
││ JVM 11  │   ││ JVM 11  │   ││ JVM 11  │   ││ JVM 11  │   ││      │
││         │   ││         │   ││         │   ││         │   ││      │
││┌───────┐│   ││┌───────┐│   ││┌───────┐│   ││┌───────┐│   ││      │
│││ ┌─┐   ││   │││ ┌─┐   ││   │││ ┌─┐   ││   │││ ┌─┐   ││   ││      │
│││ └─┘   ││   │││ └─┘   ││   │││ └─┘   ││   │││ └─┘   ││   ││      │
│││backend││   │││backend││   │││backend││   │││backend││   ││      │
│││ .war  ││   │││ .war  ││   │││ .war  ││   │││ .war  ││   ││      │
│││<<art>>││   │││<<art>>││   │││<<art>>││   │││<<art>>││   ││      │
││└───────┘│   ││└───────┘│   ││└───────┘│   ││└───────┘│   ││      │
│└─────────┘   │└─────────┘   │└─────────┘   │└─────────┘   ││      │
│└───────────┘ │└───────────┘ │└───────────┘ │└───────────┘ ││      │
│└────────────┘╱└────────────┘╱└────────────┘╱└────────────┘╱│      │
│                                                              │      │
└──────────────────────────────────────────────────────────────────────┘
     │       │       │       │              │
     │       │       │       └──────────────┼───────────┐
     │       │       │                      │           │
     │       │       │ JDBC (5432)          │ Redis     │
     │       │       │                      │ (6379)    │
     [BLACK_DOWN-POINTING_TRIANGLE]       [BLACK_DOWN-POINTING_TRIANGLE]       [BLACK_DOWN-POINTING_TRIANGLE]                      [BLACK_DOWN-POINTING_TRIANGLE]           │
┌──────────────────────────────────────────────────────────────────────┐
│  RÉSEAU SÉCURISÉ DONNÉES - 10.0.2.0/24                              │
│  ────────────────────────────────────────────────────────────────    │
│                                                                      │
│    ┌──────────────────────────┐          ┌────────────────┐        │
│   ╱  DB-Primary               ╱│         ╱  Cache         ╱│        │
│  ╱  Database Server           ╱ │        ╱  Redis         ╱ │        │
│ ├──────────────────────────┤  │       ├────────────────┤  │        │
│ │ <<database>>             │  │       │ <<server>>     │  │        │
│ │ PostgreSQL 15            │  │       │ Redis 7.0      │  ╱        │
│ │ Linux Ubuntu 22.04       │  ╱       │ Linux          │ ╱         │
│ │ 32 CPU, 128GB RAM        │ ╱        │ 4 CPU, 16GB    │╱          │
│ │ Storage: 2TB SSD         │╱         └────────────────┘           │
│ └──────────────────────────┘                                        │
│         │  Replication                                              │
│         │  (Streaming)                                              │
│         [BLACK_DOWN-POINTING_TRIANGLE]                                                           │
│    ┌──────────────────────────┐                                    │
│   ╱  DB-Replica               ╱│                                    │
│  ╱  Database Server           ╱ │                                    │
│ ├──────────────────────────┤  │                                    │
│ │ <<database>>             │  │                                    │
│ │ PostgreSQL 15            │  ╱                                    │
│ │ Linux Ubuntu 22.04       │ ╱                                     │
│ │ 32 CPU, 128GB RAM        │╱                                      │
│ └──────────────────────────┘                                        │
│                                                                      │
└──────────────────────────────────────────────────────────────────────┘


ANALYSE DÉTAILLÉE :

1. ZONES RÉSEAU (3 tiers) :

   DMZ (192.168.1.0/24) :
   - Exposition Internet
   - Load Balancers (haute dispo)
   - Web Servers (Nginx)
   
   RÉSEAU PRIVÉ APP (10.0.1.0/24) :
   - Pas d'accès Internet direct
   - Application Servers (Tomcat)
   - Isolation tier présentation
   
   RÉSEAU SÉCURISÉ DATA (10.0.2.0/24) :
   - Maximum sécurité
   - Accès restreint (apps seulement)
   - Database + Cache


2. HAUTE DISPONIBILITÉ :

   Load Balancers :
   - 2 instances (LB1, LB2)
   - Failover automatique
   - Répartition charge
   
   Web Servers :
   - 3 instances (scalable)
   - Load balancé
   
   App Servers :
   - 4 instances (scalable)
   - Stateless (Redis pour sessions)
   
   Database :
   - Primary + Replica
   - Replication streaming
   - Failover possible


3. ARTEFACTS DÉPLOYÉS :

   Web Servers :
   - frontend.html, app.js, styles.css
   - Fichiers statiques
   
   App Servers :
   - backend.war (Java web app)
   - Déployé dans Tomcat
   - JVM 11 runtime


4. PROTOCOLES DE COMMUNICATION :

   Client -> LB : HTTPS (443, sécurisé)
   LB -> Web : HTTP (80, réseau interne)
   Web -> App : HTTP (8080, API REST)
   App -> DB : JDBC (5432, PostgreSQL)
   App -> Cache : Redis Protocol (6379)
   DB -> Replica : Streaming Replication


5. SÉCURITÉ :

   FIREWALL entre zones :
   - Internet <-> DMZ : ports 443 seulement
   - DMZ <-> App : port 8080 seulement
   - App <-> Data : ports 5432, 6379 seulement
   
   ISOLATION :
   - Database inaccessible depuis Internet
   - App servers inaccessibles depuis Internet
   - Principe du moindre privilège


6. SCALABILITÉ :

   HORIZONTAL (ajouter instances) :
   - Web servers : facile (stateless)
   - App servers : facile (stateless)
   - Read replicas : pour DB
   
   VERTICAL (augmenter ressources) :
   - Database : 32 CPU, 128GB (puissant)
   - Peut être upgradé si besoin


7. PERFORMANCES :

   CACHE :
   - Redis pour sessions utilisateur
   - Redis pour cache applicatif
   - Réduit charge DB
   
   LOAD BALANCING :
   - Répartition charge sur N instances
   - Pas de single point of failure
   
   REPLICATION :
   - Lecture sur replica
   - Écriture sur primary


[IDEE] POINTS CLÉS :

[OK] Architecture 3-tiers claire
[OK] Séparation réseau par fonction
[OK] Haute disponibilité multi-niveaux
[OK] Sécurité en profondeur (defense in depth)
[OK] Scalabilité horizontale
[OK] Performances optimisées (cache + réplication)
[OK] Documentation complète pour ops
"""


# ----------------------------------------------------------------------------
# [COURS] EXERCICE PRATIQUE 2 : APPLICATION MOBILE + CLOUD
# ----------------------------------------------------------------------------

"""
[MOBILE] ÉNONCÉ

Créez un diagramme de déploiement pour une application mobile moderne
déployée sur AWS (Amazon Web Services).

ARCHITECTURE :

CLIENTS :
- Application iOS (Swift)
  * Artefact: MyApp.ipa
- Application Android (Kotlin)
  * Artefact: MyApp.apk

AWS CLOUD :
- API Gateway (AWS Service)
  * Endpoint REST
  
- Lambda Functions (Serverless)
  * 3 fonctions: UserService, OrderService, PaymentService
  * Runtime: Node.js 18
  * Artefacts: .zip contenant code
  
- DynamoDB (NoSQL Database)
  * Tables: Users, Orders
  
- S3 (Object Storage)
  * Bucket: user-uploads
  * Stockage images/fichiers
  
- CloudFront (CDN)
  * Distribution globale
  * Cache statiques
  
- Cognito (Authentication)
  * User Pool
  * Gestion identités

SERVICES EXTERNES :
- Stripe API (paiement)
- SendGrid (emails)

CONNEXIONS :
- Mobile -> API Gateway : HTTPS
- API Gateway -> Lambda : Invocation
- Lambda -> DynamoDB : SDK
- Lambda -> S3 : SDK
- Lambda -> Stripe : HTTPS
- Lambda -> SendGrid : HTTPS
- Mobile -> Cognito : HTTPS (auth)
- CloudFront -> S3 : Cache

Créez le diagramme avec les services AWS et flux.


─────────────────────────────────────────────────────────────────────────
SOLUTION EXERCICE 2
─────────────────────────────────────────────────────────────────────────

DIAGRAMME DE DÉPLOIEMENT - Mobile App + AWS Cloud


┌──────────────────────────────────────────────────────────────────────┐
│                        UTILISATEURS                                  │
└──────────────────────────────────────────────────────────────────────┘
           │                                    │
           │                                    │
           [BLACK_DOWN-POINTING_TRIANGLE]                                    [BLACK_DOWN-POINTING_TRIANGLE]
    ┌─────────────┐                      ┌─────────────┐
   ╱  iPhone     ╱│                     ╱  Android    ╱│
  ╱             ╱ │                    ╱  Phone      ╱ │
 ├─────────────┤  │                   ├─────────────┤  │
 │ <<mobile>>  │  │                   │ <<mobile>>  │  │
 │ iOS 16+     │  ╱                   │ Android 12+ │  ╱
 │             │ ╱                    │             │ ╱
 │ ┌─────────┐ │╱                     │ ┌─────────┐ │╱
 │ │ ┌─┐     │ │                      │ │ ┌─┐     │ │
 │ │ └─┘MyApp│ │                      │ │ └─┘MyApp│ │
 │ │  .ipa   │ │                      │ │  .apk   │ │
 │ │<<artifact│ │                      │ │<<artifact│ │
 │ └─────────┘ │                      │ └─────────┘ │
 └─────────────┘                      └─────────────┘
       │    │                               │    │
       │    │ HTTPS                         │    │ HTTPS
       │    └───────────┬───────────────────┘    │
       │                │                        │
       │                [BLACK_DOWN-POINTING_TRIANGLE]                        │
       │    ┌────────────────────────┐           │
       │   ╱  AWS Cognito           ╱│           │
       │  ╱  <<AWS Service>>        ╱ │           │
       │ ├────────────────────────┤  │           │
       │ │ User Pool              │  │           │
       │ │ Authentication         │  ╱           │
       │ │                        │ ╱            │
       │ └────────────────────────┘╱             │
       │                                          │
       └──────────────────┬───────────────────────┘
                          │ HTTPS
                          [BLACK_DOWN-POINTING_TRIANGLE]
┌──────────────────────────────────────────────────────────────────────┐
│                    AWS CLOUD (us-east-1)                            │
│  ────────────────────────────────────────────────────────────────    │
│                                                                      │
│         ┌────────────────────────────┐                             │
│        ╱  API Gateway               ╱│                             │
│       ╱  <<AWS Service>>            ╱ │                             │
│      ├────────────────────────────┤  │                             │
│      │ REST API                   │  │                             │
│      │ /users, /orders, /payment  │  ╱                             │
│      │                            │ ╱                              │
│      └────────────────────────────┘╱                               │
│                │                                                    │
│                │ Invocation                                         │
│                │                                                    │
│     ┌──────────┼──────────┬──────────────┐                         │
│     │          │          │              │                         │
│     [BLACK_DOWN-POINTING_TRIANGLE]          [BLACK_DOWN-POINTING_TRIANGLE]          [BLACK_DOWN-POINTING_TRIANGLE]              │                         │
│  ┌──────────┬──────────┬──────────┐      │                         │
│ ╱UserService│OrderService│PaymentService│ │                         │
│╱  Lambda   ╱│ Lambda   ╱│ Lambda   ╱│   │                         │
├──────────┤ ├──────────┤ ├──────────┤│   │                         │
││<<exec    │ ││<<exec    │ ││<<exec    ││   │                         │
││ env>>    │╱ ││ env>>    │╱ ││ env>>    ││   │                         │
│├─────────┤  ├─────────┤  ├─────────┤│   │                         │
││Node.js 18│  ││Node.js 18│  ││Node.js 18││   │                         │
││          │  ││          │  ││          ││   │                         │
││┌────────┐│  ││┌────────┐│  ││┌────────┐││   │                         │
│││ ┌─┐    ││  │││ ┌─┐    ││  │││ ┌─┐    │││   │                         │
│││ └─┘user││  │││ └─┘order││ │││ └─┘pay ││││   │                         │
│││ .zip   ││  │││ .zip   ││  │││ .zip   ││││   │                         │
│││<<art>> ││  │││<<art>> ││  │││<<art>> ││││   │                         │
││└────────┘│  ││└────────┘│  ││└────────┘│││   │                         │
│└──────────┘  │└──────────┘  │└──────────┘││   │                         │
│└──────────┘╱ └──────────┘╱ └──────────┘╱│   │                         │
│    │  │           │            │         │   │                         │
│    │  │           │            │         │   │                         │
│    │  │   AWS SDK │    AWS SDK │         │   │ HTTPS                   │
│    │  │           │            │         │   │                         │
│    [BLACK_DOWN-POINTING_TRIANGLE]  [BLACK_DOWN-POINTING_TRIANGLE]           [BLACK_DOWN-POINTING_TRIANGLE]            │         │   │                         │
│  ┌──────────────────────┐      │         │   │                         │
│ ╱  DynamoDB             ╱│      │         │   │                         │
│╱  <<AWS Service>>       ╱ │      │         │   │                         │
├──────────────────────┤  │      │         │   │                         │
││ NoSQL Database       │  │      │         │   [BLACK_DOWN-POINTING_TRIANGLE]                         │
││                      │  ╱      │    ┌────────────────┐                │
││ Tables:              │ ╱       │   ╱  S3 Bucket     ╱│                │
││ - Users              │╱        │  ╱  <<AWS Service>>╱ │                │
││ - Orders             │         │ ├────────────────┤  │                │
│└──────────────────────┘         │ │ user-uploads   │  │                │
│                                  │ │ Object Storage │  ╱                │
│                                  │ │ Images/Files   │ ╱                 │
│                                  │ └────────────────┘╱                  │
│                                  │         [BLACK_UP-POINTING_TRIANGLE]                            │
│                                  │         │ Origin                     │
│                                  │         │                            │
│                                  │ ┌────────────────────┐               │
│                                  │╱  CloudFront         ╱│               │
│                                  ╱  <<AWS Service>>     ╱ │               │
│                                 ├────────────────────┤  │               │
│                                 │ CDN Distribution   │  │               │
│                                 │ Global Edge Locations ╱               │
│                                 │                    │ ╱                │
│                                 └────────────────────┘╱                 │
│                                         [BLACK_UP-POINTING_TRIANGLE]                               │
└─────────────────────────────────────────┼───────────────────────────────┘
                                          │ HTTPS (static assets)
                                          │
                                    (Mobile Clients)


SERVICES EXTERNES (hors AWS) :

                   ┌────────────────┐               ┌────────────────┐
                  ╱  Stripe API    ╱│              ╱  SendGrid      ╱│
                 ╱  <<external>>   ╱ │             ╱  <<external>>   ╱ │
                ├────────────────┤  │            ├────────────────┤  │
                │ Payment Gateway│  │            │ Email Service  │  │
                │                │  ╱            │                │  ╱
                └────────────────┘ ╱             └────────────────┘ ╱
                        [BLACK_UP-POINTING_TRIANGLE]                                [BLACK_UP-POINTING_TRIANGLE]
                        │ HTTPS                          │ HTTPS
                        │                                │
                        │                                │
                (PaymentService Lambda)      (All Lambda Functions)


ANALYSE DÉTAILLÉE :

1. ARCHITECTURE SERVERLESS :

   Avantages :
   - Pas de gestion serveur
   - Auto-scaling automatique
   - Paiement à l'usage
   - Haute disponibilité native AWS
   
   Composants serverless :
   - Lambda (compute)
   - API Gateway (API management)
   - DynamoDB (database)
   - S3 (storage)
   - CloudFront (CDN)
   - Cognito (auth)


2. CLIENTS MOBILES :

   iOS :
   - Artefact: MyApp.ipa
   - Swift natif
   - iOS 16+ requis
   
   Android :
   - Artefact: MyApp.apk
   - Kotlin natif
   - Android 12+ requis
   
   Communication :
   - HTTPS uniquement (sécurisé)
   - REST API via API Gateway
   - Authentication via Cognito


3. API GATEWAY :

   Rôle :
   - Point d'entrée unique
   - Routing vers Lambda
   - Rate limiting
   - API keys
   - CORS handling
   
   Endpoints :
   - /users -> UserService Lambda
   - /orders -> OrderService Lambda
   - /payment -> PaymentService Lambda


4. LAMBDA FUNCTIONS :

   UserService :
   - CRUD utilisateurs
   - Interroge DynamoDB Users table
   - Runtime Node.js 18
   
   OrderService :
   - Gestion commandes
   - Interroge DynamoDB Orders table
   - Upload images vers S3
   
   PaymentService :
   - Traitement paiements
   - Appelle Stripe API externe
   - Notifications via SendGrid


5. STOCKAGE DE DONNÉES :

   DynamoDB :
   - NoSQL serverless
   - Tables: Users, Orders
   - Auto-scaling
   - Haute disponibilité multi-AZ
   
   S3 :
   - Stockage objets
   - Images utilisateurs
   - Fichiers uploads
   - Versionning activé
   - Durabilité 99.999999999%


6. CDN ET PERFORMANCE :

   CloudFront :
   - Distribution globale
   - Cache fichiers statiques S3
   - Réduit latence
   - Edge locations worldwide
   
   Avantages :
   - Images servies depuis edge proche utilisateur
   - Bande passante réduite origine
   - HTTPS inclus


7. AUTHENTIFICATION :

   Cognito User Pool :
   - Gestion utilisateurs AWS
   - Sign up / Sign in
   - MFA optionnel
   - OAuth 2.0 / OpenID Connect
   - JWT tokens
   
   Flow :
   1. Mobile -> Cognito : Login
   2. Cognito -> Mobile : JWT token
   3. Mobile -> API Gateway : Request + JWT
   4. API Gateway : Valide JWT
   5. API Gateway -> Lambda : Invoque


8. SÉCURITÉ :

   HTTPS partout :
   - Mobile -> AWS : TLS 1.3
   - Lambda -> Services externes : TLS
   
   IAM :
   - Lambda execution roles
   - Least privilege principle
   
   Secrets :
   - Stripe API key dans AWS Secrets Manager
   - SendGrid key dans Secrets Manager


9. COÛTS SERVERLESS :

   Paiement à l'usage :
   - Lambda : par invocation + durée
   - API Gateway : par requête
   - DynamoDB : par lecture/écriture
   - S3 : par GB stocké + transfert
   - CloudFront : par GB transfert
   
   Pas de coût fixe serveur !


10. HAUTE DISPONIBILITÉ :

    AWS gère :
    - Multi-AZ automatique (DynamoDB, S3)
    - Auto-healing (Lambda)
    - Global distribution (CloudFront)
    
    SLA AWS :
    - Lambda : 99.95%
    - DynamoDB : 99.99%
    - S3 : 99.99%


[IDEE] DIFFÉRENCES ARCHITECTURE TRADITIONNELLE vs SERVERLESS :

┌──────────────────────┬──────────────────────────┐
│ TRADITIONNELLE       │ SERVERLESS (AWS)         │
├──────────────────────┼──────────────────────────┤
│ Serveurs à gérer     │ Pas de serveurs          │
│ Scaling manuel       │ Auto-scaling             │
│ Coût fixe (24/7)     │ Pay-per-use              │
│ Disponibilité à gérer│ HA native AWS            │
│ Patching OS          │ AWS gère tout            │
│ Load balancer        │ API Gateway inclus       │
└──────────────────────┴──────────────────────────┘


[IDEE] BONNES PRATIQUES AWS :

[OK] Un Lambda par fonction (microservices)
[OK] DynamoDB pour NoSQL serverless
[OK] S3 pour fichiers statiques
[OK] CloudFront pour CDN global
[OK] Cognito pour auth (pas custom)
[OK] Secrets Manager pour credentials
[OK] CloudWatch pour monitoring
[OK] X-Ray pour tracing distribué
"""


# ----------------------------------------------------------------------------
# [DOCS] RÉCAPITULATIF CHAPITRE 8 - DIAGRAMME DE DÉPLOIEMENT
# ----------------------------------------------------------------------------

"""
CE QUE VOUS AVEZ APPRIS

[OK] Diagramme de déploiement = infrastructure physique
[OK] Nœuds (cubes 3D) : devices et execution environments
[OK] Artefacts (documents) : fichiers déployables
[OK] Déploiement : artefact -> nœud
[OK] Connexions : protocoles de communication
[OK] Zones réseau et sécurité
[OK] 2 exercices (3-tiers classique, serverless AWS)


[CLE] POINTS CLÉS

1. NŒUD = Ressource de calcul (serveur, container)
2. ARTEFACT = Fichier physique déployable (.war, .jar)
3. Nœuds IMBRIQUÉS (serveur contient containers)
4. STÉRÉOTYPES : <<server>>, <<mobile>>, <<database>>
5. PROTOCOLES sur connexions (HTTP, JDBC, etc.)
6. ZONES RÉSEAU pour sécurité
7. Vue complémentaire au diagramme de composants


[IDEE] DIFFÉRENCES CLÉS

┌──────────────────────┬──────────────────────────┐
│ COMPOSANTS           │ DÉPLOIEMENT              │
├──────────────────────┼──────────────────────────┤
│ Vue LOGIQUE          │ Vue PHYSIQUE             │
│ Modules logiciels    │ Serveurs matériels       │
│ Interfaces           │ Protocoles réseau        │
│ Dépendances code     │ Connexions réseau        │
│ "UserService"        │ "userservice.war sur     │
│                      │  Tomcat sur Server1"     │
└──────────────────────┴──────────────────────────┘


[OK] CHECKLIST

Vous devez être capable de :
[ ] Identifier nœuds matériels et logiciels
[ ] Représenter artefacts déployés
[ ] Modéliser déploiement artefact sur nœud
[ ] Documenter connexions réseau
[ ] Organiser en zones réseau
[ ] Créer diagramme complet pour système distribué
[ ] Dimensionner infrastructure


[COURS] BONNES PRATIQUES

1. DÉTAIL APPROPRIÉ :
   - Production : très détaillé (CPU, RAM, OS)
   - Conception : modéré (types de serveurs)
   - Présentation client : simplifié

2. SÉCURITÉ :
   - Montrer zones DMZ, privé, sécurisé
   - Indiquer pare-feu
   - Spécifier protocoles sécurisés (HTTPS)

3. HAUTE DISPONIBILITÉ :
   - Redondance (N+1, N+N)
   - Load balancing
   - Failover

4. SCALABILITÉ :
   - Indiquer instances multiples
   - Auto-scaling groups (cloud)
   - Réplication données


[ATTENTION] ERREURS FRÉQUENTES

[X] Confondre composants LOGIQUES et PHYSIQUES
   [OK] Composant : UserService (logique)
   [OK] Déploiement : userservice.jar (physique)

[X] Oublier environnements d'exécution
   [OK] Montrer JVM, Tomcat, Docker

[X] Ne pas montrer réseau
   [OK] Indiquer protocoles et zones

[X] Trop ou pas assez de détails
   [OK] Adapter selon audience


[COURS] POUR S'ENTRAÎNER

Créez des diagrammes de déploiement pour :
1. Application IoT (capteurs, gateway, cloud)
2. Système de streaming (vidéo, CDN, storage)
3. Application microservices (Kubernetes)
4. Jeu multi-joueurs (game servers, matchmaking)
5. Application mobile + Firebase


-> PROCHAINE ÉTAPE : Chapitre 9 - Diagramme de Paquetages

Le diagramme de paquetages montre l'organisation du CODE SOURCE.

Vous apprendrez :
- Organiser code en paquetages
- Dépendances entre paquetages
- Namespaces et modules
- Architecture en couches
- Import et export

Prêt pour l'organisation du code ? Continuons ! [RAPIDE]
"""


# ============================================================================
# FIN DU CHAPITRE 8 - DIAGRAMME DE DÉPLOIEMENT
# Suite : Chapitre 9 - Diagramme de Paquetages
# ============================================================================
# ============================================================================
# [LIVRE] UML - PARTIE 3 (SUITE) : DIAGRAMMES AVANCÉS
# ============================================================================


# ============================================================================
# [GUIDE] CHAPITRE 9 : DIAGRAMME DE PAQUETAGES (PACKAGE DIAGRAM)
# ============================================================================

"""
[OBJECTIF] OBJECTIFS D'APPRENTISSAGE

À la fin de ce chapitre, vous saurez :
[OK] Qu'est-ce qu'un diagramme de paquetages
[OK] Organiser code en modules logiques
[OK] Modéliser dépendances entre paquetages
[OK] Créer hiérarchies de paquetages
[OK] Éviter dépendances cycliques
[OK] Documenter architecture en couches
[OK] Appliquer principes Clean Architecture
"""


# ----------------------------------------------------------------------------
# [REFLEXION] QU'EST-CE QU'UN DIAGRAMME DE PAQUETAGES ?
# ----------------------------------------------------------------------------

"""
DÉFINITION SIMPLE

Diagramme de Paquetages = Organisation LOGIQUE du code source

Montre :
├─ PAQUETAGES (groupes de classes)
├─ HIÉRARCHIE (paquetages imbriqués)
├─ DÉPENDANCES entre paquetages
└─ ORGANISATION en couches


[IDEE] CONCEPTS CLÉS

PAQUETAGE = Conteneur logique, équivalent à :
- Package (Java)
- Namespace (C++, C#)
- Module (Python)
- Folder/Directory structure


ANALOGIE [CONSTRUCTION]

Paquetage = Classeur à tiroirs
- Classeur = Projet
- Tiroirs = Paquetages
- Dossiers dans tiroirs = Sous-paquetages
- Documents = Classes
- Étiquettes = Noms paquetages


[REFLEXION] POURQUOI UTILISER ?

[OK] ORGANISATION CODE
- Structurer projets grands
- Grouper classes liées
- Navigation facilitée
- Réutilisabilité

[OK] MODULARITÉ
- Séparation des responsabilités
- Encapsulation modules
- Réduction couplage
- Testabilité

[OK] ARCHITECTURE
- Visualiser couches (layers)
- Patterns architecturaux
- Clean Architecture
- Hexagonal Architecture

[OK] GESTION DÉPENDANCES
- Identifier dépendances
- Détecter cycles
- Optimiser structure
- Éviter spaghetti code


[REFLEXION] QUAND L'UTILISER ?

[OK] UTILISEZ POUR :
- Projets moyens à grands (>20 classes)
- Architecture multi-couches
- Documentation structure
- Refactoring
- Design reviews

[X] ÉVITEZ POUR :
- Petits scripts (<10 classes)
- Prototypes rapides
- Détails d'implémentation
- Algorithmes spécifiques


RELATION AVEC AUTRES DIAGRAMMES

Use Case -> Fonctionnalités
         v
Paquetages -> Organisation modules
         v
Classes -> Structure détaillée
         v
Déploiement -> Artefacts physiques
"""


# ----------------------------------------------------------------------------
# [PACKAGE] NOTATION DE BASE
# ----------------------------------------------------------------------------

"""
PAQUETAGE SIMPLE

Rectangle avec onglet (dossier)

    ┌───────┐
    │  nom  │──────┐
    └───────┘      │
    │              │
    └──────────────┘


Notation alternative (simplifiée) :

    ┌──────────────┐
    │ <<package>>  │
    │     nom      │
    └──────────────┘


PAQUETAGE AVEC CONTENU

Classes listées à l'intérieur

    ┌────────────┐
    │ com.app    │──────────┐
    └────────────┘          │
    │                       │
    │  User                 │
    │  Product              │
    │  Order                │
    │                       │
    └───────────────────────┘


Ou avec détails classes :

    ┌────────────┐
    │ com.app    │──────────────┐
    └────────────┘              │
    │  ┌────────────────┐       │
    │  │  User          │       │
    │  ├────────────────┤       │
    │  │ - id: Long     │       │
    │  │ - name: String │       │
    │  └────────────────┘       │
    │                           │
    │  ┌────────────────┐       │
    │  │  Product       │       │
    │  └────────────────┘       │
    └───────────────────────────┘


HIÉRARCHIE DE PAQUETAGES

Paquetages imbriqués

    ┌───────────────────────────────┐
    │  com.myapp                    │──────┐
    └───────────────────────────────┘      │
    │  ┌──────────────────────┐            │
    │  │  model               │───┐        │
    │  └──────────────────────┘   │        │
    │  │  User                    │        │
    │  │  Product                 │        │
    │  └──────────────────────────┘        │
    │                                       │
    │  ┌──────────────────────┐            │
    │  │  service             │───┐        │
    │  └──────────────────────┘   │        │
    │  │  UserService             │        │
    │  │  ProductService          │        │
    │  └──────────────────────────┘        │
    └───────────────────────────────────────┘


Notation hiérarchique avec points :

    ┌──────────────────┐
    │ com.myapp.model  │
    └──────────────────┘

    ┌──────────────────┐
    │com.myapp.service │
    └──────────────────┘
"""


# ----------------------------------------------------------------------------
# -> DÉPENDANCES ENTRE PAQUETAGES
# ----------------------------------------------------------------------------

"""
TYPES DE DÉPENDANCES

1. <<import>> : Import public
2. <<access>> : Accès privé
3. <<use>> : Utilisation générale
4. <<merge>> : Fusion de paquetages


1. DÉPENDANCE <<import>>

Import PUBLIC - contenu accessible de l'extérieur

    ┌──────────────┐                  ┌──────────────┐
    │  Package A   │─────────────────>│  Package B   │
    └──────────────┘   <<import>>     └──────────────┘

A importe publiquement B
-> Les classes de B sont accessibles via A


2. DÉPENDANCE <<access>>

Accès PRIVÉ - usage interne seulement

    ┌──────────────┐                  ┌──────────────┐
    │  Package A   │─ ─ ─ ─ ─ ─ ─ ─ >│  Package B   │
    └──────────────┘   <<access>>     └──────────────┘

A utilise B en interne
-> B n'est PAS réexporté


3. DÉPENDANCE <<use>>

Utilisation générale

    ┌──────────────┐                  ┌──────────────┐
    │  Package A   │ ───────────────> │  Package B   │
    └──────────────┘                  └──────────────┘

Sans stéréotype = dépendance d'utilisation


4. FUSION <<merge>>

Deux paquetages fusionnés en un

    ┌──────────────┐
    │  Package A   │
    └──────────────┘
           [LOZENGE]
    ┌──────────────┐
    │  Package B   │
    └──────────────┘

Losange vide = merge
A et B forment un seul namespace logique


DIRECTION DES DÉPENDANCES

IMPORTANTE : flèche pointe vers le DÉPENDANT

    ┌──────────────┐                  ┌──────────────┐
    │    UI        │─────────────────>│  Business    │
    └──────────────┘                  └──────────────┘

UI dépend de Business
UI utilise Business
UI importe Business


TRANSITIVITÉ DES DÉPENDANCES

Si A -> B et B -> C, alors A dépend indirectement de C

    ┌────┐      ┌────┐      ┌────┐
    │ A  │─────>│ B  │─────>│ C  │
    └────┘      └────┘      └────┘

Mais éviter chaînes trop longues !


DÉPENDANCES CYCLIQUES (à ÉVITER [X])

Cycle = mauvais design

    ┌────┐
    │ A  │─────────┐
    └────┘         │
      [BLACK_UP-POINTING_TRIANGLE]            [BLACK_DOWN-POINTING_TRIANGLE]
      │          ┌────┐
      │          │ B  │
      │          └────┘
      │            │
      └────────────┘

PROBLÈMES :
- Couplage fort
- Difficile à tester
- Difficile à réutiliser
- Compilation complexe


SOLUTION CYCLES :

1. EXTRAIRE INTERFACE commune

    ┌────┐         ┌─────────┐         ┌────┐
    │ A  │────────>│Interface│<────────│ B  │
    └────┘         └─────────┘         └────┘

2. INTRODUIRE COUCHE INTERMÉDIAIRE

    ┌────┐         ┌────────┐         ┌────┐
    │ A  │────────>│ Common │<────────│ B  │
    └────┘         └────────┘         └────┘

3. INVERSER DÉPENDANCE (Dependency Inversion)

    ┌────┐         ┌────────┐
    │ A  │────────>│BInterface│
    └────┘         └────────┘
                       [BLACK_UP-POINTING_TRIANGLE]
                       │
                   ┌────┐
                   │ B  │ implements
                   └────┘
"""


# ----------------------------------------------------------------------------
# [CONSTRUCTION] ARCHITECTURE EN COUCHES
# ----------------------------------------------------------------------------

"""
PATTERN CLASSIQUE : 3 TIERS

    ┌──────────────────────────┐
    │     Presentation         │  (UI, Controllers)
    │     (Layer 1)            │
    └──────────────────────────┘
               │
               v <<import>>
    ┌──────────────────────────┐
    │      Business            │  (Services, Logic)
    │      (Layer 2)           │
    └──────────────────────────┘
               │
               v <<import>>
    ┌──────────────────────────┐
    │      Persistence         │  (DAO, Repositories)
    │      (Layer 3)           │
    └──────────────────────────┘
               │
               v
          Database

RÈGLES :
[OK] Couche N dépend seulement de N-1
[OK] Couche N+1 ne doit PAS dépendre de N
[OK] Aucune dépendance skip (1 -> 3 interdit)


EXEMPLE CONCRET : APPLICATION JAVA

    ┌──────────────────────────────────┐
    │  com.myapp.presentation          │──────┐
    └──────────────────────────────────┘      │
    │  UserController                         │
    │  ProductController                      │
    │  OrderController                        │
    └─────────────────────────────────────────┘
               │
               v <<import>>
    ┌──────────────────────────────────┐
    │  com.myapp.service               │──────┐
    └──────────────────────────────────┘      │
    │  UserService                            │
    │  ProductService                         │
    │  OrderService                           │
    └─────────────────────────────────────────┘
               │
               v <<import>>
    ┌──────────────────────────────────┐
    │  com.myapp.repository            │──────┐
    └──────────────────────────────────┘      │
    │  UserRepository                         │
    │  ProductRepository                      │
    │  OrderRepository                        │
    └─────────────────────────────────────────┘
               │
               v <<import>>
    ┌──────────────────────────────────┐
    │  com.myapp.model                 │──────┐
    └──────────────────────────────────┘      │
    │  User                                   │
    │  Product                                │
    │  Order                                  │
    └─────────────────────────────────────────┘


PATTERN AVANCÉ : CLEAN ARCHITECTURE (Uncle Bob)

    ┌─────────────────────────────────────────────┐
    │           External (Frameworks)             │
    │  ┌────────┐    ┌────────┐    ┌────────┐   │
    │  │  Web   │    │  DB    │    │ Devices│   │
    │  └────────┘    └────────┘    └────────┘   │
    └─────────────────────────────────────────────┘
                      │
                      v
    ┌─────────────────────────────────────────────┐
    │        Interface Adapters                   │
    │  ┌─────────────┐      ┌─────────────┐      │
    │  │ Controllers │      │ Presenters  │      │
    │  │ Gateways    │      │             │      │
    │  └─────────────┘      └─────────────┘      │
    └─────────────────────────────────────────────┘
                      │
                      v
    ┌─────────────────────────────────────────────┐
    │        Use Cases (Application Business)     │
    │  ┌─────────────┐      ┌─────────────┐      │
    │  │CreateOrder  │      │GetUserInfo  │      │
    │  │ProcessPayment│      │             │      │
    │  └─────────────┘      └─────────────┘      │
    └─────────────────────────────────────────────┘
                      │
                      v
    ┌─────────────────────────────────────────────┐
    │        Entities (Enterprise Business)       │
    │  ┌────────┐    ┌────────┐    ┌────────┐   │
    │  │  User  │    │Product │    │ Order  │   │
    │  └────────┘    └────────┘    └────────┘   │
    └─────────────────────────────────────────────┘

RÈGLE D'OR :
Les dépendances pointent vers l'INTÉRIEUR
Externes -> Adapters -> UseCases -> Entities
[X] JAMAIS dans l'autre sens !


PATTERN HEXAGONAL (Ports & Adapters)

              ┌──────────────────────┐
              │      Driving         │
              │      Adapters        │
              │  (UI, Controllers)   │
              └──────────────────────┘
                       │
                       v implements
    ┌──────────────────────────────────────────┐
    │            Ports (Interfaces)            │
    │   ┌────────┐              ┌────────┐    │
    │   │ Input  │              │ Output │    │
    │   │ Ports  │              │ Ports  │    │
    │   └────────┘              └────────┘    │
    └──────────────────────────────────────────┘
                   │          [BLACK_UP-POINTING_TRIANGLE]
                   v          │ implements
    ┌──────────────────────────────────────────┐
    │         Core Business Logic              │
    │  (Use Cases, Domain Logic, Entities)     │
    └──────────────────────────────────────────┘
                       [BLACK_UP-POINTING_TRIANGLE]
                       │ implements
              ┌──────────────────────┐
              │      Driven          │
              │      Adapters        │
              │  (DB, APIs, Queue)   │
              └──────────────────────┘


PRINCIPE : Dépendances vers DOMAINE uniquement
"""


# ----------------------------------------------------------------------------
# [COURS] EXERCICE PRATIQUE : APPLICATION E-COMMERCE
# ----------------------------------------------------------------------------

"""
[SHOPPING_TROLLEY] ÉNONCÉ

Créez un diagramme de paquetages pour une application e-commerce
Java Spring Boot.

STRUCTURE :

com.ecommerce
├── api (Controllers REST)
│   ├── UserController
│   ├── ProductController
│   └── OrderController
│
├── service (Business Logic)
│   ├── UserService
│   ├── ProductService
│   ├── OrderService
│   └── PaymentService
│
├── repository (Data Access)
│   ├── UserRepository
│   ├── ProductRepository
│   └── OrderRepository
│
├── model (Entities/DTOs)
│   ├── entity (JPA Entities)
│   │   ├── User
│   │   ├── Product
│   │   └── Order
│   └── dto (Data Transfer Objects)
│       ├── UserDTO
│       ├── ProductDTO
│       └── OrderDTO
│
├── config (Configuration)
│   ├── SecurityConfig
│   └── DatabaseConfig
│
└── util (Utilities)
    ├── ValidationUtil
    └── DateUtil

DÉPENDANCES :
- api -> service
- api -> model.dto
- service -> repository
- service -> model.entity
- service -> util
- repository -> model.entity
- config -> (configuration globale)

CONTRAINTES :
[X] api NE DOIT PAS accéder repository directement
[X] repository NE DOIT PAS connaître api
[X] Éviter cycles

Dessinez le diagramme avec paquetages et dépendances.


─────────────────────────────────────────────────────────────────────────
SOLUTION EXERCICE
─────────────────────────────────────────────────────────────────────────

DIAGRAMME DE PAQUETAGES - E-Commerce Spring Boot


┌─────────────────────────────────────────────────────────────────────┐
│                     com.ecommerce                                   │
│  ───────────────────────────────────────────────────────────────    │
│                                                                      │
│   ┌──────────────────────────────────────┐                         │
│   │  api                                 │────────┐                │
│   └──────────────────────────────────────┘        │                │
│   │  UserController                               │                │
│   │  ProductController                            │                │
│   │  OrderController                              │                │
│   └───────────────────────────────────────────────┘                │
│              │                      │                               │
│              │                      │                               │
│              │ <<import>>           │ <<import>>                    │
│              [BLACK_DOWN-POINTING_TRIANGLE]                      [BLACK_DOWN-POINTING_TRIANGLE]                               │
│   ┌────────────────────┐    ┌─────────────────┐                   │
│   │  service           │─┐  │  model.dto      │─┐                 │
│   └────────────────────┘ │  └─────────────────┘ │                 │
│   │  UserService        │  │  UserDTO           │                 │
│   │  ProductService     │  │  ProductDTO        │                 │
│   │  OrderService       │  │  OrderDTO          │                 │
│   │  PaymentService     │  └────────────────────┘                 │
│   └─────────────────────┘                                          │
│              │                                                      │
│              │ <<import>>                                           │
│              [BLACK_DOWN-POINTING_TRIANGLE]                                                      │
│   ┌────────────────────────┐                                       │
│   │  repository            │─┐                                     │
│   └────────────────────────┘ │                                     │
│   │  UserRepository          │                                     │
│   │  ProductRepository       │                                     │
│   │  OrderRepository         │                                     │
│   └──────────────────────────┘                                     │
│              │                                                      │
│              │ <<import>>                                           │
│              [BLACK_DOWN-POINTING_TRIANGLE]                                                      │
│   ┌────────────────────────┐                                       │
│   │  model.entity          │─┐                                     │
│   └────────────────────────┘ │                                     │
│   │  User                    │                                     │
│   │  Product                 │                                     │
│   │  Order                   │                                     │
│   └──────────────────────────┘                                     │
│                                                                      │
│                                                                      │
│   service ─────────> util    (<<import>>)                          │
│                                                                      │
│   ┌────────────────────────┐                                       │
│   │  util                  │─┐                                     │
│   └────────────────────────┘ │                                     │
│   │  ValidationUtil          │                                     │
│   │  DateUtil                │                                     │
│   └──────────────────────────┘                                     │
│                                                                      │
│                                                                      │
│   ┌────────────────────────┐                                       │
│   │  config                │─┐                                     │
│   └────────────────────────┘ │                                     │
│   │  SecurityConfig          │                                     │
│   │  DatabaseConfig          │                                     │
│   └──────────────────────────┘                                     │
│                                                                      │
└──────────────────────────────────────────────────────────────────────┘


GRAPHE DES DÉPENDANCES :

     config
       (configuration globale, pas de dépendances)

        api
         │
         ├──────┬─────────┐
         │      │         │
         v      v         v
      service  model.dto  (DTO pour API)
         │
         ├──────┬──────────┐
         │      │          │
         v      v          v
    repository  util  model.entity
         │
         v
    model.entity


FLUX DE DÉPENDANCES (Top-Down) :

NIVEAU 1 : api (couche présentation)
         v
NIVEAU 2 : service + model.dto
         v
NIVEAU 3 : repository + util + model.entity
         v
NIVEAU 4 : model.entity (entities pures)
         v
        Database

config : transversal (utilisé partout)


VALIDATION DES CONTRAINTES :

[OK] api -> service : OUI (passe par service)
[OK] api -> model.dto : OUI (DTOs pour API)
[X] api -> repository : NON (interdit, respecté)
[X] api -> model.entity : NON (passe par DTO)

[OK] service -> repository : OUI
[OK] service -> model.entity : OUI (business logic)
[OK] service -> util : OUI (utilities)
[X] service -> api : NON (pas de cycle)

[OK] repository -> model.entity : OUI (JPA)
[X] repository -> service : NON (pas de cycle)
[X] repository -> api : NON (pas de cycle)

[OK] model.entity : PAS de dépendances (POJOs)


SÉPARATION ENTITY vs DTO :

POURQUOI 2 modèles ?

model.entity :
- Entities JPA (annotations @Entity)
- Mapping base de données
- Business logic possible
- Utilisé par repository + service

model.dto :
- Data Transfer Objects
- Pas d'annotations JPA
- Sérialisation JSON
- Utilisé par API (requests/responses)

AVANTAGES :
[OK] Découplage API / Database
[OK] Exposition contrôlée (pas tous champs entity)
[OK] Versioning API indépendant schema DB
[OK] Sécurité (ne pas exposer IDs internes)


EXEMPLE MAPPING :

// Entity (model.entity)
@Entity
public class User {
    @Id private Long id;
    private String email;
    private String passwordHash;  // <- Sensible !
    private LocalDateTime createdAt;
}

// DTO (model.dto)
public class UserDTO {
    private String email;          // <- Pas d'ID
    private String displayName;    // <- Calculé
    // <- Pas de passwordHash !
}


PATTERN APPLIQUÉ : 3-TIER MODIFIÉ

TIER 1 - Presentation :
- api (Controllers)
- model.dto (contracts)

TIER 2 - Business :
- service (logic)
- util (helpers)

TIER 3 - Data :
- repository (persistence)
- model.entity (domain)

TIER 0 - Infrastructure :
- config (cross-cutting)


ÉVOLUTION POSSIBLE : CLEAN ARCHITECTURE

Pour passer en Clean Architecture :

1. Créer paquetage usecase
   com.ecommerce.usecase
   - CreateOrderUseCase
   - GetUserInfoUseCase
   
2. Créer paquetage ports (interfaces)
   com.ecommerce.ports
   - UserPort (interface)
   - OrderPort (interface)
   
3. repository implements ports
   
4. service utilise ports (pas repository direct)

DÉPENDANCES CLEAN :
api -> usecase -> ports <- repository
                ^
           model.entity


OUTILS D'ANALYSE :

Pour vérifier respect architecture :

JAVA :
- ArchUnit (tests architecture)
- JDepend (métriques dépendances)
- Structure101 (visualisation)

Exemple ArchUnit :
```java
@Test
public void apiShouldNotDependOnRepository() {
    classes()
        .that().resideInPackage("..api..")
        .should().onlyDependOnClassesThat()
        .resideOutsideOfPackage("..repository..")
        .check(importedClasses);
}
```


[IDEE] MÉTRIQUES QUALITÉ :

Complexité cyclomatique par package :
- api : faible (simple routing)
- service : moyenne (business logic)
- repository : faible (CRUD)

Stabilité :
- model.entity : haute (0 dépendances sortantes)
- util : haute (utilities réutilisables)
- api : faible (dépend de tout)

Instabilité = sortantes / (sortantes + entrantes)
- model.entity : 0 / (0 + 3) = 0 (stable)
- api : 2 / (2 + 0) = 1 (instable)


[IDEE] BONNES PRATIQUES :

[OK] Paquetages par COUCHE (layering)
[OK] model.entity sans dépendances
[OK] DTOs pour isolation API/DB
[OK] util réutilisable
[OK] config centralisé
[OK] Pas de cycles
[OK] Dépendances vers BAS (stable)
"""


# ----------------------------------------------------------------------------
# [DOCS] RÉCAPITULATIF CHAPITRE 9 - DIAGRAMME DE PAQUETAGES
# ----------------------------------------------------------------------------

"""
CE QUE VOUS AVEZ APPRIS

[OK] Diagramme de paquetages = organisation logique code
[OK] Paquetages = namespaces, modules
[OK] Hiérarchie de paquetages (imbrication)
[OK] Dépendances <<import>>, <<access>>, <<use>>
[OK] Architecture en couches (3-tier, Clean, Hexagonal)
[OK] Éviter cycles de dépendances
[OK] Patterns architecturaux en UML
[OK] Exercice e-commerce Spring Boot complet


[CLE] POINTS CLÉS

1. PAQUETAGE = Groupement logique de classes
2. HIÉRARCHIE = Paquetages imbriqués
3. DÉPENDANCES = Flèches vers ce dont on dépend
4. CYCLES = À éviter absolument (refactoring)
5. COUCHES = Organisation architecture (layers)
6. RÈGLE D'OR = Dépendances vers le stable/abstrait


[IDEE] PRINCIPES ARCHITECTURAUX

SOLID (Uncle Bob) :
- S : Single Responsibility -> 1 paquetage = 1 responsabilité
- O : Open/Closed -> Extension via interfaces
- L : Liskov Substitution -> Hiérarchies cohérentes
- I : Interface Segregation -> Interfaces ciblées
- D : Dependency Inversion -> Dépendre d'abstractions

PACKAGE PRINCIPLES :
- REP : Reuse/Release Equivalence
- CCP : Common Closure Principle
- CRP : Common Reuse Principle
- ADP : Acyclic Dependencies Principle [OK]
- SDP : Stable Dependencies Principle
- SAP : Stable Abstractions Principle


[OK] CHECKLIST

Vous devez être capable de :
[ ] Créer paquetages logiques
[ ] Organiser hiérarchie de paquetages
[ ] Modéliser dépendances
[ ] Identifier cycles (et les éviter)
[ ] Documenter architecture en couches
[ ] Appliquer patterns (3-tier, Clean, Hexagonal)
[ ] Valider respect architecture


[COURS] BONNES PRATIQUES

1. NOMMAGE :
   - Domaine inversé : com.company.project
   - Descriptif : api, service, repository
   - Cohérent : user, product (pas users, products)

2. ORGANISATION :
   - Par COUCHE (layer) [OK] recommandé
   - Par FEATURE (moins courant)
   - Hybride possible

3. TAILLE :
   - 5-10 classes par paquetage
   - Pas trop profond (3-4 niveaux max)
   - Cohésion forte dans paquetage

4. DÉPENDANCES :
   - Minimiser nombre dépendances
   - Éviter cycles ABSOLUMENT
   - Dépendances vers stable/abstrait


[ATTENTION] ERREURS FRÉQUENTES

[X] Tout dans un seul paquetage
   [OK] Organiser par responsabilité

[X] Cycles de dépendances
   [OK] Refactoring avec interfaces

[X] Dépendances vers l'instable
   [OK] Inverser avec Dependency Inversion

[X] Paquetages trop profonds
   [OK] Limiter à 3-4 niveaux

[X] Mélanger couches
   [OK] Respecter architecture


[COURS] POUR S'ENTRAÎNER

Créez des diagrammes de paquetages pour :
1. Application bancaire (comptes, transactions, clients)
2. Réseau social (users, posts, comments, likes)
3. Application de streaming (media, playlists, users)
4. Système de réservation (booking, rooms, customers)
5. Votre propre projet


-> PROCHAINE ÉTAPE : PARTIE 4 - PRATIQUE ET OUTILS

La partie finale couvrira :
- Chapitre 10 : Outils UML (PlantUML, etc.)
- Chapitre 11 : Patterns de Conception en UML
- Chapitre 12 : UML et Méthodologies Agiles
- Chapitre 13 : Projet Final Complet

Prêt pour la mise en pratique ? Let's go ! [RAPIDE]
"""


# ============================================================================
# FIN DU CHAPITRE 9 - DIAGRAMME DE PAQUETAGES
# FIN DE LA PARTIE 3 - DIAGRAMMES AVANCÉS
# Suite : PARTIE 4 - PRATIQUE ET OUTILS
# ============================================================================


################################################################################
################################################################################
##                                                                            ##
##  SECTION V : PARTIE 4 - PRATIQUE ET OUTILS
##                                                                            ##
################################################################################
################################################################################


# ============================================================================
# [LIVRE] UML - PARTIE 4 : PRATIQUE ET OUTILS
# ============================================================================


# ============================================================================
# [GUIDE] CHAPITRE 10 : OUTILS UML
# ============================================================================

"""
[OBJECTIF] OBJECTIFS D'APPRENTISSAGE

À la fin de ce chapitre, vous saurez :
[OK] Choisir le bon outil UML selon vos besoins
[OK] Utiliser PlantUML pour diagrammes textuels
[OK] Créer diagrammes avec Draw.io
[OK] Intégrer UML dans votre workflow
[OK] Générer code depuis UML (forward engineering)
[OK] Générer UML depuis code (reverse engineering)
[OK] Automatiser documentation avec UML
"""


# ----------------------------------------------------------------------------
# [REFLEXION] POURQUOI UTILISER UN OUTIL UML ?
# ----------------------------------------------------------------------------

"""
AVANTAGES DES OUTILS UML

[OK] PRODUCTIVITÉ
- Création rapide diagrammes
- Templates et modèles
- Bibliothèques de formes
- Copier/coller

[OK] QUALITÉ
- Notation UML correcte
- Validation syntaxe
- Cohérence visuelle
- Export haute résolution

[OK] COLLABORATION
- Partage facile
- Versioning (Git)
- Commentaires
- Édition temps réel

[OK] INTÉGRATION
- Export multi-formats (PNG, SVG, PDF)
- Génération code
- Reverse engineering
- Documentation automatique


TYPES D'OUTILS

1. ÉDITEURS GRAPHIQUES
   - Draw.io, Lucidchart, Visual Paradigm
   - Glisser-déposer
   - WYSIWYG
   - Faciles à apprendre

2. OUTILS TEXTUELS
   - PlantUML, Mermaid
   - Code -> Diagramme
   - Versionnable (Git)
   - Automatisable

3. OUTILS PROFESSIONNELS
   - Enterprise Architect, StarUML
   - Round-trip engineering
   - Gestion modèles complexes
   - Licence payante
"""


# ----------------------------------------------------------------------------
# [HERB] PLANTUML - DIAGRAMMES AS CODE
# ----------------------------------------------------------------------------

"""
QU'EST-CE QUE PLANTUML ?

PlantUML = Outil open source pour créer diagrammes UML depuis TEXTE

AVANTAGES :
[OK] Texte -> facile versioning Git
[OK] Génération automatique layout
[OK] Intégration CI/CD
[OK] Plugins IDE (VS Code, IntelliJ)
[OK] Gratuit et open source
[OK] Tous types diagrammes UML


INSTALLATION

Méthode 1 - En ligne (aucune installation) :
-> https://www.plantuml.com/plantuml/

Méthode 2 - Local (Java requis) :
```bash
# Télécharger JAR
wget https://sourceforge.net/projects/plantuml/files/plantuml.jar

# Générer diagramme
java -jar plantuml.jar diagram.puml
```

Méthode 3 - VS Code Extension :
-> Installer "PlantUML" extension
-> Aperçu en direct dans éditeur


SYNTAXE DE BASE

Tous diagrammes commencent par @startuml et finissent par @enduml

Format général :
```plantuml
@startuml
' Votre diagramme ici
@enduml
```


1. DIAGRAMME DE CLASSES

```plantuml
@startuml

class User {
  - id: Long
  - name: String
  - email: String
  + login(): boolean
  + logout(): void
}

class Order {
  - id: Long
  - date: Date
  - total: double
  + calculate(): double
}

User "1" --> "0..*" Order : places

@enduml
```

Génère :
    ┌─────────────────┐
    │     User        │
    ├─────────────────┤
    │- id: Long       │
    │- name: String   │
    │- email: String  │
    ├─────────────────┤
    │+ login()        │
    │+ logout()       │
    └─────────────────┘
           │ 1
           │ places
           │
           v 0..*
    ┌─────────────────┐
    │     Order       │
    ├─────────────────┤
    │- id: Long       │
    │- date: Date     │
    │- total: double  │
    ├─────────────────┤
    │+ calculate()    │
    └─────────────────┘


Relations PlantUML :
- Extension : <|--
- Composition : *--
- Agrégation : o--
- Association : -->
- Dépendance : ..>
- Réalisation : ..|>


Exemple complet :
```plantuml
@startuml

abstract class Animal {
  # name: String
  + {abstract} makeSound(): void
}

class Dog {
  + makeSound(): void
  + bark(): void
}

class Cat {
  + makeSound(): void
  + meow(): void
}

interface Pet {
  + play(): void
}

Dog --|> Animal
Cat --|> Animal
Dog ..|> Pet
Cat ..|> Pet

@enduml
```


2. DIAGRAMME DE SÉQUENCE

```plantuml
@startuml

actor User
participant "WebUI" as UI
participant "AuthService" as Auth
database "Database" as DB

User -> UI : login(email, password)
activate UI

UI -> Auth : authenticate(credentials)
activate Auth

Auth -> DB : query user
activate DB
DB --> Auth : user data
deactivate DB

alt successful auth
    Auth --> UI : token
    UI --> User : welcome page
else failed auth
    Auth --> UI : error
    UI --> User : error message
end

deactivate Auth
deactivate UI

@enduml
```

Fragments :
- alt/else : alternative
- opt : optionnel
- loop : boucle
- par : parallèle


3. DIAGRAMME D'ACTIVITÉS

```plantuml
@startuml

start

:User logs in;

if (Credentials valid?) then (yes)
  :Load user profile;
  
  fork
    :Check notifications;
  fork again
    :Load recent activity;
  end fork
  
  :Display dashboard;
else (no)
  :Show error;
  :Retry login;
endif

stop

@enduml
```


4. DIAGRAMME DE CAS D'UTILISATION

```plantuml
@startuml

left to right direction

actor Customer
actor Admin

rectangle "E-Commerce System" {
  Customer -- (Browse Products)
  Customer -- (Place Order)
  Customer -- (Track Delivery)
  
  Admin -- (Manage Products)
  Admin -- (View Orders)
  Admin -- (Generate Reports)
  
  (Place Order) ..> (Process Payment) : <<include>>
  (Place Order) ..> (Apply Discount) : <<extend>>
}

@enduml
```


5. DIAGRAMME D'ÉTATS

```plantuml
@startuml

[*] --> Idle

Idle --> Processing : start
Processing --> Success : complete
Processing --> Error : fail
Success --> [*]
Error --> Idle : retry
Error --> [*] : abort

Processing : entry / validateData()
Processing : do / processRequest()
Processing : exit / cleanup()

@enduml
```


PERSONNALISATION

Thèmes :
```plantuml
@startuml
!theme bluegray
' ou: cerulean, plain, toy, etc.

class Example
@enduml
```

Couleurs :
```plantuml
@startuml

class User #lightblue {
  - id: Long
}

class Admin #pink {
  - privileges: List
}

User <|-- Admin

@enduml
```

Notes :
```plantuml
@startuml

class User
note right: This is a registered user

class Admin
note left of Admin
  Administrators have
  full system access
end note

@enduml
```


INTÉGRATION CI/CD

Génération automatique dans pipeline :

```yaml
# .github/workflows/docs.yml
name: Generate UML Diagrams

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      
      - name: Setup Java
        uses: actions/setup-java@v2
        with:
          distribution: 'adopt'
          java-version: '11'
      
      - name: Generate diagrams
        run: |
          wget https://sourceforge.net/projects/plantuml/files/plantuml.jar
          find docs -name '*.puml' -exec java -jar plantuml.jar {} \;
      
      - name: Commit diagrams
        run: |
          git config user.name "GitHub Actions"
          git add docs/*.png
          git commit -m "Update UML diagrams" || true
          git push
```


PLANTUML DANS MARKDOWN

Intégration dans README.md :

```markdown
# Architecture

![Architecture Diagram](http://www.plantuml.com/plantuml/proxy?src=https://raw.githubusercontent.com/user/repo/main/docs/architecture.puml)
```

Ou avec GitLab/GitHub (si supporté) :
````markdown
```plantuml
@startuml
class Example
@enduml
```
````


AVANTAGES PLANTUML

[OK] VERSIONING
- Fichiers texte (.puml)
- Git diff lisible
- Historique changements
- Code review possible

[OK] AUTOMATISATION
- Génération batch
- CI/CD integration
- Documentation auto
- Scripts de build

[OK] CONSISTANCE
- Layout automatique
- Style uniforme
- Pas de désalignement manuel

[OK] COLLABORATION
- Pas de fichiers binaires
- Merge conflicts gérables
- Commentaires dans code


INCONVÉNIENTS

[X] Layout automatique parfois imparfait
[X] Personnalisation limitée
[X] Courbe d'apprentissage syntaxe
[X] Prévisualisation nécessite outil
"""


# ----------------------------------------------------------------------------
# [DESIGN] DRAW.IO (DIAGRAMS.NET) - ÉDITEUR GRAPHIQUE
# ----------------------------------------------------------------------------

"""
QU'EST-CE QUE DRAW.IO ?

Draw.io = Éditeur diagrammes GRAPHIQUE gratuit

URL : https://app.diagrams.net

AVANTAGES :
[OK] Gratuit et open source
[OK] Pas d'installation (web)
[OK] Desktop app disponible
[OK] Interface intuitive (drag & drop)
[OK] Bibliothèque formes UML
[OK] Export multi-formats
[OK] Intégration Google Drive, OneDrive


DÉMARRAGE RAPIDE

1. Ouvrir https://app.diagrams.net
2. Choisir stockage (Device, Google Drive, etc.)
3. Nouveau diagramme -> Templates UML
4. Glisser-déposer formes
5. Exporter (PNG, SVG, PDF)


BIBLIOTHÈQUES UML

Activer bibliothèques UML :
1. Menu "More Shapes..."
2. Cocher "UML"
3. Cocher "UML 2.5" si disponible

Formes disponibles :
- Classes
- Interfaces
- Use cases
- Acteurs
- États
- Activités
- Composants
- Déploiement


CRÉER DIAGRAMME DE CLASSES

1. Glisser forme "Class" depuis palette
2. Double-clic pour éditer nom
3. Ajouter attributs/méthodes :
   - Clic droit -> Edit Data
   - Ou double-clic sections

4. Connecter classes :
   - Sélectionner classe
   - Pointer vers autre classe
   - Choisir type relation dans menu


STYLE ET FORMATAGE

Personnalisation :
- Couleurs : panneau droite
- Polices : Format -> Text
- Alignement : Arrange -> Align
- Espacement : Arrange -> Layout


COLLABORATION

Partage :
1. File -> Share
2. Générer lien
3. Permissions : view/edit

Commentaires :
- Clic droit -> Add comment
- Discussions en temps réel


INTÉGRATION CONFLUENCE/JIRA

Draw.io s'intègre nativement :
1. Installer app Confluence
2. Insérer diagramme dans page
3. Édition in-place
4. Versioning automatique


EXPORT

Formats disponibles :
- PNG : images web
- SVG : vectoriel (scalable)
- PDF : documents
- XML : éditable (format natif)
- VSDX : Microsoft Visio

Options export :
- Résolution
- Transparence
- Zone sélectionnée


AVANTAGES DRAW.IO

[OK] FACILITÉ
- Interface visuelle
- Drag & drop
- Pas de syntaxe
- Apprentissage rapide

[OK] FLEXIBILITÉ
- Contrôle total layout
- Personnalisation poussée
- Formes custom
- Styles variés

[OK] INTÉGRATION
- Google Drive, OneDrive
- Confluence, Jira
- Notion, Obsidian (via plugin)


INCONVÉNIENTS

[X] Fichiers binaires (XML)
[X] Git diff illisible
[X] Layout manuel (fastidieux)
[X] Consistance difficile (grands projets)
"""


# ----------------------------------------------------------------------------
# [ENTREPRISE] AUTRES OUTILS POPULAIRES
# ----------------------------------------------------------------------------

"""
COMPARATIF OUTILS UML

┌──────────────┬────────┬──────────┬──────────┬────────────┐
│ Outil        │ Type   │ Prix     │ Niveau   │ Meilleur   │
│              │        │          │          │ pour       │
├──────────────┼────────┼──────────┼──────────┼────────────┤
│ PlantUML     │ Textuel│ Gratuit  │ Inter.   │ Dev, CI/CD │
│ Draw.io      │ Visual │ Gratuit  │ Débutant │ Tous       │
│ Lucidchart   │ Visual │ Payant   │ Tous     │ Équipes    │
│ Visual       │ Pro    │ Payant   │ Avancé   │ Archi.     │
│ Paradigm     │        │          │          │            │
│ StarUML      │ Pro    │ Freemium │ Inter.   │ Dev        │
│ Enterprise   │ Pro    │ Payant   │ Expert   │ Entreprise │
│ Architect    │        │          │          │            │
│ Mermaid      │ Textuel│ Gratuit  │ Débutant │ Markdown   │
│ ArgoUML      │ Pro    │ Gratuit  │ Inter.   │ Éduc.      │
└──────────────┴────────┴──────────┴──────────┴────────────┘


1. LUCIDCHART

URL : https://www.lucidchart.com

CARACTÉRISTIQUES :
[OK] Interface moderne
[OK] Collaboration temps réel
[OK] Templates professionnels
[OK] Intégration G Suite, MS Office
[OK] Version gratuite limitée

PRIX :
- Gratuit : 3 documents
- Individual : ~8€/mois
- Team : ~27€/mois

MEILLEUR POUR :
- Équipes en télétravail
- Présentation clients
- Collaboration temps réel


2. VISUAL PARADIGM

URL : https://www.visual-paradigm.com

CARACTÉRISTIQUES :
[OK] Très complet (tous diagrammes UML)
[OK] Round-trip engineering
[OK] Génération code (Java, C#, Python)
[OK] Reverse engineering
[OK] Gestion projets complexes

PRIX :
- Modeler : ~6€/mois
- Standard : ~19€/mois
- Professional : ~35€/mois

MEILLEUR POUR :
- Architectes logiciels
- Projets entreprise
- Model-driven development


3. STARUML

URL : https://staruml.io

CARACTÉRISTIQUES :
[OK] Interface élégante
[OK] Tous diagrammes UML
[OK] Génération code
[OK] Extensions disponibles
[OK] Multi-plateformes

PRIX :
- Gratuit : watermark
- Licence : ~89$ (lifetime)

MEILLEUR POUR :
- Développeurs individuels
- Projets moyens
- Budget limité


4. ENTERPRISE ARCHITECT

URL : https://sparxsystems.com

CARACTÉRISTIQUES :
[OK] Outil professionnel complet
[OK] Gestion modèles d'entreprise
[OK] Support TOGAF, ArchiMate
[OK] Collaboration équipe
[OK] Génération doc complète

PRIX :
- Desktop : ~225€
- Professional : ~450€
- Corporate : sur devis

MEILLEUR POUR :
- Grandes entreprises
- Architecture d'entreprise
- Projets critiques
- Conformité standards


5. MERMAID

URL : https://mermaid.js.org

CARACTÉRISTIQUES :
[OK] JavaScript (navigateur)
[OK] Syntaxe simple
[OK] Intégration Markdown native (GitHub)
[OK] Léger et rapide
[OK] Gratuit

EXEMPLE :
```mermaid
classDiagram
    Animal <|-- Duck
    Animal <|-- Fish
    Animal : +int age
    Animal : +String gender
    Animal: +isMammal()
```

MEILLEUR POUR :
- Documentation GitHub/GitLab
- README.md avec diagrammes
- Projets open source
- Wiki


6. ARGOUML

URL : https://argouml.tigris.org

CARACTÉRISTIQUES :
[OK] Open source (gratuit)
[OK] Java (multi-plateformes)
[OK] Support UML 1.4
[OK] Génération code Java
[OK] Académique

INCONVÉNIENTS :
[X] Interface datée
[X] Plus maintenu activement
[X] UML 2.x limité

MEILLEUR POUR :
- Enseignement
- Apprentissage UML
- Budget zéro
"""


# ----------------------------------------------------------------------------
# [OUTIL] ENGINEERING CODE <-> UML
# ----------------------------------------------------------------------------

"""
FORWARD ENGINEERING (UML -> Code)

Générer code depuis modèle UML

OUTILS SUPPORTANT :
- Visual Paradigm (Java, C#, Python, C++)
- Enterprise Architect (tous langages)
- StarUML (Java, C#, C++)
- Papyrus (Eclipse, Java)


EXEMPLE VISUAL PARADIGM :

UML -> Java :
```java
// Généré depuis diagramme classes
public class User {
    private Long id;
    private String name;
    private String email;
    
    public boolean login() {
        // TODO: Implement
        return false;
    }
    
    public void logout() {
        // TODO: Implement
    }
}
```


AVANTAGES FORWARD :
[OK] Structure code cohérente
[OK] Design-first approach
[OK] Documentation automatique
[OK] Réduction erreurs architecture


INCONVÉNIENTS :
[X] Code généré générique
[X] Logique métier manuelle
[X] Synchronisation complexe
[X] Vendor lock-in


REVERSE ENGINEERING (Code -> UML)

Générer diagrammes depuis code existant

OUTILS :

1. IntelliJ IDEA (intégré) :
   - Clic droit classe -> Diagrams -> Show UML
   - Support Java, Kotlin
   - Interactive, éditable

2. Visual Studio (extensions) :
   - Code Map
   - Class Designer
   - Architecture Explorer

3. Visual Paradigm :
   - Import code source
   - Génération automatique
   - Multiple langages

4. pyreverse (Python) :
   ```bash
   pyreverse -o png my_module
   ```
   
5. doxygen (C++, Java, etc.) :
   - Génération doc + UML
   - Graphes dépendances


EXEMPLE INTELLIJ :

Code Java :
```java
public class Order {
    private Customer customer;
    private List<OrderItem> items;
    
    public double calculateTotal() {
        return items.stream()
            .mapToDouble(OrderItem::getPrice)
            .sum();
    }
}
```

-> IntelliJ génère diagramme montrant :
- Classe Order
- Relations Customer, OrderItem
- Méthodes publiques


AVANTAGES REVERSE :
[OK] Documenter code existant
[OK] Comprendre legacy code
[OK] Visualiser dépendances
[OK] Onboarding nouveaux devs


INCONVÉNIENTS :
[X] Diagrammes complexes (gros projets)
[X] Logique métier invisible
[X] Patterns architecturaux flous
[X] Nécessite nettoyage manuel


ROUND-TRIP ENGINEERING

Synchronisation bidirectionnelle Code <-> UML

PROCESSUS :
1. Créer modèle UML
2. Générer code
3. Modifier code
4. Synchroniser -> MAJ diagramme
5. Modifier diagramme
6. Synchroniser -> MAJ code

OUTILS :
- Enterprise Architect
- Visual Paradigm
- Rational Rose (IBM)


DÉFIS :
[X] Complexité synchronisation
[X] Conflits merge difficiles
[X] Overhead maintenance
[X] Rarement utilisé en pratique


RECOMMANDATION :

[OBJECTIF] APPROCHE PRAGMATIQUE :

1. DESIGN INITIAL : UML manuel (Draw.io, PlantUML)
2. DÉVELOPPEMENT : Code first
3. DOCUMENTATION : Reverse engineering ponctuel
4. ARCHITECTURE : Diagrammes haut-niveau maintenus

Ne pas chercher synchronisation parfaite !
UML = outil communication, pas source of truth unique
"""


# ----------------------------------------------------------------------------
# [COURS] EXERCICE PRATIQUE : CRÉER DIAGRAMMES
# ----------------------------------------------------------------------------

"""
[NOTE] EXERCICE : SYSTÈME DE BIBLIOTHÈQUE

Créez les diagrammes suivants avec l'outil de votre choix
(PlantUML recommandé pour pratiquer) :

1. DIAGRAMME DE CLASSES :
   - Livre (ISBN, titre, auteur, disponible)
   - Membre (ID, nom, email)
   - Emprunt (date début, date fin, rendu?)
   - Bibliothécaire (hérite Membre)
   
   Relations :
   - Membre emprunte Livres (1..3)
   - Bibliothécaire gère Emprunts

2. DIAGRAMME DE SÉQUENCE :
   Scénario "Emprunter un livre" :
   - Membre demande livre
   - Système vérifie disponibilité
   - Si disponible :
     * Créer emprunt
     * Marquer livre non disponible
     * Confirmer au membre
   - Sinon :
     * Informer indisponible

3. DIAGRAMME D'ACTIVITÉS :
   Processus "Retour de livre" :
   - Bibliothécaire scanne livre
   - Calculer retard (jours)
   - Si retard > 0 :
     * Calculer amende
     * Demander paiement
   - Marquer livre disponible
   - Clôturer emprunt

Utilisez :
- PlantUML OU
- Draw.io OU
- Autre outil de votre choix


─────────────────────────────────────────────────────────────────────────
SOLUTION EXERCICE - PLANTUML
─────────────────────────────────────────────────────────────────────────

DIAGRAMME 1 : CLASSES

```plantuml
@startuml

class Livre {
  - ISBN: String
  - titre: String
  - auteur: String
  - disponible: boolean
  + emprunter(): void
  + retourner(): void
}

class Membre {
  # id: Long
  # nom: String
  # email: String
  + emprunterLivre(livre: Livre): Emprunt
  + retournerLivre(emprunt: Emprunt): void
}

class Bibliothecaire {
  - departement: String
  + gererEmprunt(emprunt: Emprunt): void
  + calculerAmende(jours: int): double
}

class Emprunt {
  - id: Long
  - dateDebut: Date
  - dateFin: Date
  - rendu: boolean
  + calculerRetard(): int
  + cloture(): void
}

Membre "1" --> "0..3" Emprunt : effectue
Emprunt "1" --> "1" Livre : concerne
Bibliothecaire --|> Membre
Bibliothecaire "1" --> "0..*" Emprunt : gère

@enduml
```


DIAGRAMME 2 : SÉQUENCE

```plantuml
@startuml

actor Membre
participant "Système" as Sys
database "BD" as DB

Membre -> Sys : emprunterLivre(ISBN)
activate Sys

Sys -> DB : getLivre(ISBN)
activate DB
DB --> Sys : livre
deactivate DB

alt livre disponible
    Sys -> DB : creerEmprunt(membre, livre)
    activate DB
    DB --> Sys : emprunt
    deactivate DB
    
    Sys -> DB : marquerIndisponible(livre)
    activate DB
    DB --> Sys : ok
    deactivate DB
    
    Sys --> Membre : emprunt confirmé
else livre indisponible
    Sys --> Membre : erreur : livre indisponible
end

deactivate Sys

@enduml
```


DIAGRAMME 3 : ACTIVITÉS

```plantuml
@startuml

start

:Bibliothécaire scanne livre;

:Récupérer emprunt associé;

:Calculer jours de retard;

if (Retard > 0 ?) then (oui)
  :Calculer amende;
  note right: 0.50€ par jour
  
  :Demander paiement;
  
  :Enregistrer paiement;
else (non)
  :Pas d'amende;
endif

:Marquer livre disponible;

:Clôturer emprunt;

:Envoyer reçu email;

stop

@enduml
```


CODE POUR TESTER :

Créer fichier bibliotheque.puml avec les 3 diagrammes séparés :

bibliotheque-classes.puml
bibliotheque-sequence.puml  
bibliotheque-activites.puml

Générer :
```bash
java -jar plantuml.jar *.puml
```

Ou en ligne :
-> Copier code dans https://www.plantuml.com/plantuml/
"""


# ----------------------------------------------------------------------------
# [DOCS] RÉCAPITULATIF CHAPITRE 10 - OUTILS UML
# ----------------------------------------------------------------------------

"""
CE QUE VOUS AVEZ APPRIS

[OK] Comparatif outils UML (textuel vs graphique)
[OK] PlantUML pour diagrammes as code
[OK] Draw.io pour édition visuelle
[OK] Outils professionnels (Visual Paradigm, EA)
[OK] Forward engineering (UML -> Code)
[OK] Reverse engineering (Code -> UML)
[OK] Intégration CI/CD
[OK] Exercice pratique complet


[CLE] POINTS CLÉS

CHOISIR OUTIL SELON :
- Budget (gratuit vs payant)
- Taille équipe (solo vs collaboration)
- Complexité projet (simple vs entreprise)
- Workflow (versioning vs WYSIWYG)


RECOMMANDATIONS :

DÉBUTANT :
-> Draw.io (gratuit, facile)

DÉVELOPPEUR :
-> PlantUML (versioning, automatisation)

ÉQUIPE :
-> Lucidchart (collaboration temps réel)

ENTREPRISE :
-> Visual Paradigm / Enterprise Architect


[IDEE] BONNES PRATIQUES

[OK] UN outil principal pour consistance
[OK] Versioning diagrammes (Git)
[OK] Nommer fichiers explicitement
[OK] Documenter conventions équipe
[OK] Automatiser génération si possible
[OK] Exporter en formats multiples (PNG + source)


[ATTENTION] PIÈGES À ÉVITER

[X] Trop d'outils différents
[X] Diagrammes non versionnés
[X] Pas de sauvegarde régulière
[X] Over-engineering avec outils pros
[X] Obsession synchronisation Code <-> UML


[COURS] POUR PRATIQUER

1. Installer PlantUML + VS Code extension
2. Créer compte Draw.io
3. Recréer vos anciens diagrammes avec PlantUML
4. Tester reverse engineering sur votre code
5. Automatiser génération dans projet


-> PROCHAINE ÉTAPE : Chapitre 11 - Patterns de Conception

Vous apprendrez à modéliser en UML :
- Design patterns classiques (GoF)
- Singleton, Factory, Observer
- MVC, MVP, MVVM
- Patterns architecturaux

Prêt pour les patterns ? Let's go ! [RAPIDE]
"""


# ============================================================================
# [GUIDE] CHAPITRE 11 : PATTERNS DE CONCEPTION EN UML
# ============================================================================

"""
[OBJECTIF] OBJECTIFS D'APPRENTISSAGE

À la fin de ce chapitre, vous saurez :
[OK] Qu'est-ce qu'un pattern de conception
[OK] Modéliser patterns GoF en UML
[OK] Reconnaître patterns dans code
[OK] Choisir bon pattern selon contexte
[OK] Appliquer patterns architecturaux
[OK] Documenter patterns dans projets
"""


# ----------------------------------------------------------------------------
# [REFLEXION] QU'EST-CE QU'UN PATTERN DE CONCEPTION ?
# ----------------------------------------------------------------------------

"""
DÉFINITION

Pattern (motif de conception) = Solution ÉPROUVÉE à un problème RÉCURRENT

Caractéristiques :
├─ RÉUTILISABLE (applicable à plusieurs contextes)
├─ DOCUMENTÉ (nom, problème, solution)
├─ ÉPROUVÉ (testé en production)
└─ COMMUNIQUE (langage commun équipe)


ORIGINE : GANG OF FOUR (GoF)

Livre fondateur (1994) :
"Design Patterns: Elements of Reusable Object-Oriented Software"

Auteurs (Gang of Four) :
- Erich Gamma
- Richard Helm
- Ralph Johnson
- John Vlissides

23 patterns classiques en 3 catégories


CATÉGORIES DE PATTERNS

1. CRÉATION (Creational)
   Comment créer objets
   - Singleton, Factory, Builder, Prototype

2. STRUCTURE (Structural)
   Comment organiser classes/objets
   - Adapter, Decorator, Facade, Proxy

3. COMPORTEMENT (Behavioral)
   Comment objets interagissent
   - Observer, Strategy, Command, Iterator


POURQUOI UML + PATTERNS ?

[OK] UML = LANGAGE VISUEL pour patterns
[OK] Diagrammes classes montrent STRUCTURE
[OK] Diagrammes séquence montrent COMPORTEMENT
[OK] Documentation claire et universelle
[OK] Communication équipe facilitée
"""


# ----------------------------------------------------------------------------
# [USINE] PATTERNS DE CRÉATION
# ----------------------------------------------------------------------------

"""
1. SINGLETON

PROBLÈME :
Garantir qu'une classe n'a qu'UNE SEULE instance

SOLUTION :
- Constructeur privé
- Instance statique
- Méthode getInstance()


DIAGRAMME UML :

    ┌────────────────────────────────┐
    │        <<Singleton>>           │
    │        DatabaseConnection      │
    ├────────────────────────────────┤
    │ - instance: DatabaseConnection │ <- static
    │ - host: String                 │
    │ - port: int                    │
    ├────────────────────────────────┤
    │ - DatabaseConnection()         │ <- private !
    │ + getInstance(): Database      │ <- static
    │ + query(sql: String): Result   │
    └────────────────────────────────┘


CODE JAVA :

```java
public class DatabaseConnection {
    private static DatabaseConnection instance;
    private String host;
    private int port;
    
    // Constructeur privé
    private DatabaseConnection() {
        this.host = "localhost";
        this.port = 5432;
    }
    
    // Méthode d'accès unique
    public static DatabaseConnection getInstance() {
        if (instance == null) {
            instance = new DatabaseConnection();
        }
        return instance;
    }
    
    public Result query(String sql) {
        // ...
    }
}
```

USAGE :
```java
DatabaseConnection db = DatabaseConnection.getInstance();
db.query("SELECT * FROM users");
```


AVANTAGES :
[OK] Une seule instance garantie
[OK] Accès global
[OK] Lazy initialization

INCONVÉNIENTS :
[X] Difficile à tester (global state)
[X] Problème multi-threading
[X] Couplage fort


2. FACTORY METHOD

PROBLÈME :
Créer objets sans spécifier classe exacte

SOLUTION :
Méthode abstraite de création dans classe abstraite


DIAGRAMME UML :

    ┌─────────────────────────┐
    │   <<abstract>>          │
    │   DocumentCreator       │
    ├─────────────────────────┤
    │ + {abstract} createDoc()│
    │ + openDocument()        │
    └─────────────────────────┘
              [WHITE_UP-POINTING_TRIANGLE]
              │
      ┌───────┴────────┐
      │                │
┌─────────────┐  ┌─────────────┐
│PDFCreator   │  │WordCreator  │
├─────────────┤  ├─────────────┤
│+ createDoc()│  │+ createDoc()│
└─────────────┘  └─────────────┘
      │                │
      │ creates        │ creates
      [BLACK_DOWN-POINTING_TRIANGLE]                [BLACK_DOWN-POINTING_TRIANGLE]
┌─────────────┐  ┌─────────────┐
│PDFDocument  │  │WordDocument │
└─────────────┘  └─────────────┘


CODE :

```java
abstract class DocumentCreator {
    public abstract Document createDocument();
    
    public void openDocument() {
        Document doc = createDocument();
        doc.open();
    }
}

class PDFCreator extends DocumentCreator {
    @Override
    public Document createDocument() {
        return new PDFDocument();
    }
}

class WordCreator extends DocumentCreator {
    @Override
    public Document createDocument() {
        return new WordDocument();
    }
}
```


3. BUILDER

PROBLÈME :
Construire objets complexes étape par étape

SOLUTION :
Classe Builder séparée avec méthodes chaînées


DIAGRAMME UML :

    ┌─────────────────────────┐
    │      Pizza              │
    ├─────────────────────────┤
    │ - size: String          │
    │ - cheese: boolean       │
    │ - pepperoni: boolean    │
    │ - bacon: boolean        │
    └─────────────────────────┘
              [WHITE_UP-POINTING_TRIANGLE]
              │ builds
              │
    ┌─────────────────────────┐
    │    PizzaBuilder         │
    ├─────────────────────────┤
    │ + setSize(s): Builder   │
    │ + addCheese(): Builder  │
    │ + addPepperoni(): Builder
    │ + addBacon(): Builder   │
    │ + build(): Pizza        │
    └─────────────────────────┘


CODE :

```java
public class Pizza {
    private String size;
    private boolean cheese;
    private boolean pepperoni;
    private boolean bacon;
    
    private Pizza(PizzaBuilder builder) {
        this.size = builder.size;
        this.cheese = builder.cheese;
        this.pepperoni = builder.pepperoni;
        this.bacon = builder.bacon;
    }
    
    public static class PizzaBuilder {
        private String size;
        private boolean cheese;
        private boolean pepperoni;
        private boolean bacon;
        
        public PizzaBuilder(String size) {
            this.size = size;
        }
        
        public PizzaBuilder addCheese() {
            this.cheese = true;
            return this;
        }
        
        public PizzaBuilder addPepperoni() {
            this.pepperoni = true;
            return this;
        }
        
        public PizzaBuilder addBacon() {
            this.bacon = true;
            return this;
        }
        
        public Pizza build() {
            return new Pizza(this);
        }
    }
}
```

USAGE :
```java
Pizza pizza = new Pizza.PizzaBuilder("Large")
    .addCheese()
    .addPepperoni()
    .addBacon()
    .build();
```
"""


# ----------------------------------------------------------------------------
# [CONSTRUCTION] PATTERNS DE STRUCTURE
# ----------------------------------------------------------------------------

"""
1. ADAPTER

PROBLÈME :
Rendre compatible 2 interfaces incompatibles

SOLUTION :
Classe Adapter qui traduit interface


DIAGRAMME UML :

    ┌──────────────┐
    │   Client     │
    └──────────────┘
            │
            │ uses
            [BLACK_DOWN-POINTING_TRIANGLE]
    ┌──────────────┐
    │ <<interface>>│
    │   Target     │
    ├──────────────┤
    │+ request()   │
    └──────────────┘
            [WHITE_UP-POINTING_TRIANGLE]
            │ implements
            │
    ┌──────────────┐        ┌──────────────┐
    │   Adapter    │───────>│  Adaptee     │
    ├──────────────┤        ├──────────────┤
    │+ request()   │        │+ specificReq()│
    └──────────────┘        └──────────────┘


EXEMPLE : Adapter ancien système de paiement

```java
// Nouvelle interface attendue
interface PaymentProcessor {
    void processPayment(double amount);
}

// Ancien système (ne peut pas modifier)
class LegacyPaymentSystem {
    public void makePayment(int cents) {
        System.out.println("Legacy payment: " + cents + " cents");
    }
}

// Adapter
class PaymentAdapter implements PaymentProcessor {
    private LegacyPaymentSystem legacy;
    
    public PaymentAdapter(LegacyPaymentSystem legacy) {
        this.legacy = legacy;
    }
    
    @Override
    public void processPayment(double amount) {
        int cents = (int) (amount * 100);
        legacy.makePayment(cents);
    }
}
```

USAGE :
```java
LegacyPaymentSystem legacy = new LegacyPaymentSystem();
PaymentProcessor processor = new PaymentAdapter(legacy);
processor.processPayment(19.99); // Converti en 1999 cents
```


2. DECORATOR

PROBLÈME :
Ajouter comportements dynamiquement sans sous-classes

SOLUTION :
Wrapping d'objets avec décorateurs


DIAGRAMME UML :

    ┌──────────────┐
    │<<interface>> │
    │  Component   │
    ├──────────────┤
    │+ operation() │
    └──────────────┘
           [WHITE_UP-POINTING_TRIANGLE]
           │
    ┌──────┴──────────────────┐
    │                         │
┌──────────────┐    ┌──────────────┐
│ConcreteComp  │    │  Decorator   │
├──────────────┤    ├──────────────┤
│+ operation() │    │- component   │
└──────────────┘    │+ operation() │
                    └──────────────┘
                            [WHITE_UP-POINTING_TRIANGLE]
                    ┌───────┴───────┐
             ┌──────────────┐ ┌──────────────┐
             │DecoratorA    │ │DecoratorB    │
             ├──────────────┤ ├──────────────┤
             │+ operation() │ │+ operation() │
             └──────────────┘ └──────────────┘


EXEMPLE : Coffee shop

```java
interface Coffee {
    double cost();
    String description();
}

class SimpleCoffee implements Coffee {
    public double cost() { return 2.0; }
    public String description() { return "Simple coffee"; }
}

abstract class CoffeeDecorator implements Coffee {
    protected Coffee coffee;
    
    public CoffeeDecorator(Coffee coffee) {
        this.coffee = coffee;
    }
}

class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee coffee) {
        super(coffee);
    }
    
    public double cost() {
        return coffee.cost() + 0.5;
    }
    
    public String description() {
        return coffee.description() + ", milk";
    }
}

class SugarDecorator extends CoffeeDecorator {
    public SugarDecorator(Coffee coffee) {
        super(coffee);
    }
    
    public double cost() {
        return coffee.cost() + 0.2;
    }
    
    public String description() {
        return coffee.description() + ", sugar";
    }
}
```

USAGE :
```java
Coffee coffee = new SimpleCoffee();
coffee = new MilkDecorator(coffee);
coffee = new SugarDecorator(coffee);

System.out.println(coffee.description()); // "Simple coffee, milk, sugar"
System.out.println(coffee.cost());        // 2.7
```


3. FACADE

PROBLÈME :
Simplifier interface complexe

SOLUTION :
Classe Facade qui encapsule sous-système


DIAGRAMME UML :

    ┌──────────────┐
    │   Client     │
    └──────────────┘
            │
            │ uses
            [BLACK_DOWN-POINTING_TRIANGLE]
    ┌──────────────┐
    │   Facade     │
    ├──────────────┤
    │+ operation() │
    └──────────────┘
            │
    ┌───────┼───────┐
    │       │       │
    [BLACK_DOWN-POINTING_TRIANGLE]       [BLACK_DOWN-POINTING_TRIANGLE]       [BLACK_DOWN-POINTING_TRIANGLE]
┌────────┬────────┬────────┐
│System A│System B│System C│
└────────┴────────┴────────┘


EXEMPLE : Home Theater

```java
class DVDPlayer {
    public void on() { }
    public void play(String movie) { }
}

class Projector {
    public void on() { }
    public void setInput(DVDPlayer dvd) { }
}

class Lights {
    public void dim(int level) { }
}

class SoundSystem {
    public void on() { }
    public void setVolume(int level) { }
}

// FACADE
class HomeTheaterFacade {
    private DVDPlayer dvd;
    private Projector projector;
    private Lights lights;
    private SoundSystem sound;
    
    public HomeTheaterFacade(...) {
        // Initialisation
    }
    
    public void watchMovie(String movie) {
        System.out.println("Get ready to watch movie...");
        lights.dim(10);
        projector.on();
        projector.setInput(dvd);
        sound.on();
        sound.setVolume(5);
        dvd.on();
        dvd.play(movie);
    }
    
    public void endMovie() {
        System.out.println("Shutting down...");
        // Éteindre tout
    }
}
```

USAGE :
```java
HomeTheaterFacade theater = new HomeTheaterFacade(...);
theater.watchMovie("Inception");
// Au lieu de 7-8 appels manuels
```
"""


# ----------------------------------------------------------------------------
# [SCENARIO] PATTERNS DE COMPORTEMENT
# ----------------------------------------------------------------------------

"""
1. OBSERVER

PROBLÈME :
Notifier automatiquement objets des changements

SOLUTION :
Subject maintient liste d'Observers et les notifie


DIAGRAMME UML :

    ┌──────────────┐           ┌──────────────┐
    │  Subject     │[WHITE_DIAMOND]─────────>│  Observer    │
    ├──────────────┤           ├──────────────┤
    │+ attach()    │           │+ update()    │
    │+ detach()    │           └──────────────┘
    │+ notify()    │                  [WHITE_UP-POINTING_TRIANGLE]
    └──────────────┘                  │
           [WHITE_UP-POINTING_TRIANGLE]                   ┌──────┴──────┐
           │                   │             │
    ┌──────────────┐    ┌──────────┐ ┌──────────┐
    │ConcreteSubject│    │Observer A│ │Observer B│
    ├──────────────┤    ├──────────┤ ├──────────┤
    │- state       │    │+ update()│ │+ update()│
    │+ getState()  │    └──────────┘ └──────────┘
    │+ setState()  │
    └──────────────┘


EXEMPLE : Newsletter

```java
interface Observer {
    void update(String news);
}

class Subject {
    private List<Observer> observers = new ArrayList<>();
    
    public void attach(Observer observer) {
        observers.add(observer);
    }
    
    public void detach(Observer observer) {
        observers.remove(observer);
    }
    
    public void notifyObservers(String news) {
        for (Observer obs : observers) {
            obs.update(news);
        }
    }
}

class NewsAgency extends Subject {
    public void publishNews(String news) {
        System.out.println("Publishing: " + news);
        notifyObservers(news);
    }
}

class EmailSubscriber implements Observer {
    private String email;
    
    public EmailSubscriber(String email) {
        this.email = email;
    }
    
    @Override
    public void update(String news) {
        System.out.println("Email to " + email + ": " + news);
    }
}
```

USAGE :
```java
NewsAgency agency = new NewsAgency();

EmailSubscriber sub1 = new EmailSubscriber("user1@mail.com");
EmailSubscriber sub2 = new EmailSubscriber("user2@mail.com");

agency.attach(sub1);
agency.attach(sub2);

agency.publishNews("Breaking news!");
// -> Emails envoyés à sub1 et sub2
```


2. STRATEGY

PROBLÈME :
Changer algorithme à l'exécution

SOLUTION :
Encapsuler algorithmes dans classes séparées


DIAGRAMME UML :

    ┌──────────────┐         ┌──────────────┐
    │   Context    │[WHITE_DIAMOND]───────>│ <<interface>>│
    ├──────────────┤         │  Strategy    │
    │- strategy    │         ├──────────────┤
    ├──────────────┤         │+ execute()   │
    │+ setStrategy()│         └──────────────┘
    │+ doSomething()│                [WHITE_UP-POINTING_TRIANGLE]
    └──────────────┘         ┌──────┴──────┐
                             │             │
                      ┌──────────┐  ┌──────────┐
                      │StrategyA │  │StrategyB │
                      ├──────────┤  ├──────────┤
                      │+ execute()│  │+ execute()│
                      └──────────┘  └──────────┘


EXEMPLE : Compression de fichiers

```java
interface CompressionStrategy {
    void compress(String file);
}

class ZipCompression implements CompressionStrategy {
    public void compress(String file) {
        System.out.println("Compressing " + file + " using ZIP");
    }
}

class RarCompression implements CompressionStrategy {
    public void compress(String file) {
        System.out.println("Compressing " + file + " using RAR");
    }
}

class FileCompressor {
    private CompressionStrategy strategy;
    
    public void setStrategy(CompressionStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void compressFile(String file) {
        strategy.compress(file);
    }
}
```

USAGE :
```java
FileCompressor compressor = new FileCompressor();

compressor.setStrategy(new ZipCompression());
compressor.compressFile("data.txt"); // ZIP

compressor.setStrategy(new RarCompression());
compressor.compressFile("data.txt"); // RAR
```


3. COMMAND

PROBLÈME :
Encapsuler requête comme objet

SOLUTION :
Commande objet avec méthode execute()


DIAGRAMME UML :

    ┌──────────────┐         ┌──────────────┐
    │   Invoker    │[WHITE_DIAMOND]───────>│ <<interface>>│
    ├──────────────┤         │   Command    │
    │+ setCommand()│         ├──────────────┤
    │+ execute()   │         │+ execute()   │
    └──────────────┘         └──────────────┘
                                    [WHITE_UP-POINTING_TRIANGLE]
                             ┌──────┴──────┐
                             │             │
                      ┌──────────┐  ┌──────────┐
                      │CommandA  │  │CommandB  │
                      ├──────────┤  ├──────────┤
                      │- receiver│  │- receiver│
                      │+ execute()│  │+ execute()│
                      └──────────┘  └──────────┘
                             │             │
                             [BLACK_DOWN-POINTING_TRIANGLE]             [BLACK_DOWN-POINTING_TRIANGLE]
                        ┌──────────┐
                        │ Receiver │
                        ├──────────┤
                        │+ action()│
                        └──────────┘


EXEMPLE : Remote Control

```java
interface Command {
    void execute();
}

class Light {
    public void on() {
        System.out.println("Light ON");
    }
    public void off() {
        System.out.println("Light OFF");
    }
}

class LightOnCommand implements Command {
    private Light light;
    
    public LightOnCommand(Light light) {
        this.light = light;
    }
    
    public void execute() {
        light.on();
    }
}

class LightOffCommand implements Command {
    private Light light;
    
    public LightOffCommand(Light light) {
        this.light = light;
    }
    
    public void execute() {
        light.off();
    }
}

class RemoteControl {
    private Command command;
    
    public void setCommand(Command command) {
        this.command = command;
    }
    
    public void pressButton() {
        command.execute();
    }
}
```

USAGE :
```java
Light livingRoomLight = new Light();

Command lightOn = new LightOnCommand(livingRoomLight);
Command lightOff = new LightOffCommand(livingRoomLight);

RemoteControl remote = new RemoteControl();
remote.setCommand(lightOn);
remote.pressButton(); // Light ON

remote.setCommand(lightOff);
remote.pressButton(); // Light OFF
```
"""


# ----------------------------------------------------------------------------
# [DOCS] RÉCAPITULATIF CHAPITRE 11 - PATTERNS
# ----------------------------------------------------------------------------

"""
CE QUE VOUS AVEZ APPRIS

[OK] Patterns = solutions éprouvées problèmes récurrents
[OK] Gang of Four (23 patterns classiques)
[OK] 3 catégories : Création, Structure, Comportement
[OK] Modélisation UML de patterns
[OK] Implémentation Java de patterns
[OK] Quand appliquer chaque pattern


[CLE] PATTERNS ESSENTIELS

CRÉATION :
- Singleton : 1 seule instance
- Factory : Création sans spécifier classe
- Builder : Construction étape par étape

STRUCTURE :
- Adapter : Compatibilité interfaces
- Decorator : Ajout comportements
- Facade : Simplification interface

COMPORTEMENT :
- Observer : Notification automatique
- Strategy : Algorithme interchangeable
- Command : Requête comme objet


[IDEE] QUAND UTILISER ?

NE PAS forcer patterns !
Utiliser SEULEMENT si :
[OK] Problème récurrent identifié
[OK] Pattern résout vraiment le problème
[OK] Bénéfice > Complexité ajoutée


[ATTENTION] ANTI-PATTERNS

[X] Over-engineering avec patterns
[X] Pattern pour "faire joli"
[X] Mauvais pattern pour problème
[X] Patterns partout (KISS !)


[COURS] POUR ALLER PLUS LOIN

Autres patterns à étudier :
- Proxy, Bridge, Composite (Structure)
- Iterator, State, Mediator (Comportement)
- Abstract Factory, Prototype (Création)
- Patterns architecturaux (MVC, MVVM)


-> PROCHAINE ÉTAPE : Chapitre 12

UML et Méthodologies Agiles :
- UML dans Scrum
- Documentation Agile
- User Stories -> Use Cases
- Continuous modeling

Prêt pour l'Agile ? Continuons ! [RAPIDE]
"""


# ============================================================================
# FIN DU CHAPITRE 11 - PATTERNS DE CONCEPTION
# Suite : Chapitre 12 - UML et Agile
# ============================================================================
# ============================================================================
# [LIVRE] UML - PARTIE 4 (FIN) : PRATIQUE ET OUTILS
# ============================================================================


# ============================================================================
# [GUIDE] CHAPITRE 12 : UML ET MÉTHODOLOGIES AGILES
# ============================================================================

"""
[OBJECTIF] OBJECTIFS D'APPRENTISSAGE

À la fin de ce chapitre, vous saurez :
[OK] Intégrer UML dans projets Agile/Scrum
[OK] Adapter niveau de détail UML selon contexte
[OK] Convertir User Stories en Use Cases
[OK] Pratiquer "Just Enough" modeling
[OK] Documenter architecture en mode Agile
[OK] Utiliser UML pour Continuous Modeling
"""


# ----------------------------------------------------------------------------
# [REFLEXION] UML ET AGILE : COMPATIBLES ?
# ----------------------------------------------------------------------------

"""
DÉBAT HISTORIQUE

2000s : UML vs Agile ?

CAMP ANTI-UML (Agile puristes) :
[X] "UML = Big Design Up Front (BDUF)"
[X] "Documentation lourde"
[X] "Pas de valeur pour client"
[X] "Ralentit développement"

CAMP PRO-UML (pragmatiques) :
[OK] "UML = outil, pas méthodologie"
[OK] "Just Enough modeling"
[OK] "Communication visuelle efficace"
[OK] "Architecture doit être pensée"


CONSENSUS MODERNE (2020s)

UML + Agile = COMPATIBLES si :
[OK] Modélisation légère (pas BDUF)
[OK] Documentation ciblée (pas exhaustive)
[OK] Itératif et incrémental
[OK] Juste ce qu'il faut (Just Enough)
[OK] Collaboration > Formalisme


MANIFESTO AGILE ET UML

Manifeste Agile (2001) :
"Individuals and interactions over processes and tools"
"Working software over comprehensive documentation"
"Customer collaboration over contract negotiation"
"Responding to change over following a plan"

Traduction pour UML :
-> Interactions > Diagrammes formels
-> Code fonctionnel > Modèles complets
-> Collaboration > Documentation contractuelle
-> Adaptation > Plan rigide

MAIS :
"while there is value in the items on the right..."

-> Documentation (dont UML) a sa place !
-> Question de DOSAGE, pas d'exclusion


CONTINUOUS MODELING (Scott Ambler)

Approche Agile de modélisation :

1. MODEL STORMING
   - Sessions courtes (5-10 min)
   - Tableau blanc
   - Équipe entière
   - Juste nécessaire

2. INCLUSIVE MODELING
   - Développeurs + Stakeholders
   - Langage simple
   - Focus communication

3. ITERATE
   - Modèles évoluent avec code
   - Pas de synchronisation parfaite
   - Refactoring modèles

4. TRAVEL LIGHT
   - Minimum documentation
   - Jeter modèles temporaires
   - Garder seulement essentiel
"""


# ----------------------------------------------------------------------------
# [RUNNER] UML DANS SCRUM
# ----------------------------------------------------------------------------

"""
SCRUM : RAPPEL RAPIDE

Rôles :
- Product Owner (PO)
- Scrum Master
- Dev Team

Cérémonies :
- Sprint Planning
- Daily Standup
- Sprint Review
- Sprint Retrospective

Artéfacts :
- Product Backlog
- Sprint Backlog
- Increment


OÙ UTILISER UML DANS SCRUM ?

1. PRODUCT BACKLOG REFINEMENT

User Stories -> Use Cases

Exemple User Story :
"En tant que client, je veux pouvoir rechercher des produits
par catégorie afin de trouver rapidement ce que je cherche"

Transformation en Use Case :
```
Use Case: Rechercher Produits
Acteur: Client
Préconditions: Catalogue disponible
Scénario nominal:
1. Client sélectionne catégorie
2. Système affiche produits de la catégorie
3. Client peut filtrer résultats
4. Système met à jour affichage
Postconditions: Produits affichés
```

DIAGRAMME USE CASE :
    ┌──────────┐
    │  Client  │
    └──────────┘
         │
         │
         [BLACK_DOWN-POINTING_TRIANGLE]
    (Rechercher Produits)
         │
         │ <<include>>
         [BLACK_DOWN-POINTING_TRIANGLE]
    (Filtrer Résultats)


2. SPRINT PLANNING

Architecture Sprint :

Quick sketch diagramme composants :
```
┌────────────────────────────────┐
│  Sprint N Architecture         │
├────────────────────────────────┤
│  [Frontend]                    │
│     v                          │
│  [API Gateway] <- New!          │
│     v                          │
│  [Product Service]             │
│     v                          │
│  [Database]                    │
└────────────────────────────────┘
```

10 minutes tableau blanc
Toute l'équipe comprend

3. DAILY STANDUP

Généralement PAS d'UML
(sauf problème complexe à éclaircir)

4. SPRINT REVIEW

Optionnel : Diagrammes architecture si :
- Changements architecturaux importants
- Démo technique pour stakeholders
- Documentation décisions


5. SPRINT RETROSPECTIVE

Analyse dette technique :
- Diagramme classes (couplage)
- Diagramme paquetages (dépendances)
- Identifier refactoring


NIVEAU DE DÉTAIL PAR PHASE

PRODUCT BACKLOG :
-> Diagrammes use case (haut niveau)
-> Rough sketches

SPRINT PLANNING :
-> Diagrammes classes (principales)
-> Diagrammes séquence (flows critiques)
-> Tableau blanc OK !

DÉVELOPPEMENT :
-> Code IS the model
-> Diagrammes si clarification nécessaire

SPRINT REVIEW :
-> Architecture générale si applicable
-> Décisions importantes documentées

RÉTROSPECTIVE :
-> Analyse qualité code/architecture
"""


# ----------------------------------------------------------------------------
# [NOTE] USER STORIES -> UML
# ----------------------------------------------------------------------------

"""
FORMAT USER STORY

Template :
"En tant que [RÔLE],
 je veux [ACTION],
 afin de [BÉNÉFICE]"


CONVERSION EN DIAGRAMMES UML

ÉTAPE 1 : User Story -> Use Case

Story :
"En tant qu'administrateur, je veux pouvoir supprimer
des utilisateurs inactifs afin de nettoyer la base"

Use Case :
```
Nom: Supprimer Utilisateurs Inactifs
Acteur principal: Administrateur
Préconditions:
- Admin authentifié
- Utilisateurs inactifs identifiés
Scénario nominal:
1. Admin accède liste utilisateurs
2. Système affiche utilisateurs avec statut
3. Admin sélectionne inactifs (>6 mois)
4. Admin confirme suppression
5. Système supprime utilisateurs
6. Système envoie confirmation
Extensions:
4a. Admin annule -> Retour liste
Postconditions: Utilisateurs supprimés
```

DIAGRAMME :
    ┌──────────┐
    │  Admin   │
    └──────────┘
         │
         [BLACK_DOWN-POINTING_TRIANGLE]
    (Supprimer Utilisateurs Inactifs)
         │
         │ <<include>>
         [BLACK_DOWN-POINTING_TRIANGLE]
    (Confirmer Suppression)


ÉTAPE 2 : Use Case -> Diagramme Séquence

```plantuml
@startuml

actor Admin
participant "UserManager" as UM
database "Database" as DB

Admin -> UM : getInactiveUsers()
activate UM

UM -> DB : SELECT users WHERE lastLogin < 6 months
activate DB
DB --> UM : userList
deactivate DB

UM --> Admin : display users

Admin -> UM : deleteUsers(userIds)
activate UM

loop for each user
    UM -> DB : DELETE user
    activate DB
    DB --> UM : deleted
    deactivate DB
end

UM --> Admin : confirmation
deactivate UM

@enduml
```


ÉTAPE 3 : Use Case -> Diagramme Classes

Identifier entités :
```plantuml
@startuml

class User {
  - id: Long
  - email: String
  - lastLogin: Date
  - active: boolean
  + isInactive(): boolean
}

class Administrator {
  - privileges: List<String>
  + deleteUsers(users: List<User>): void
}

class UserManager {
  + getInactiveUsers(months: int): List<User>
  + deleteUsers(users: List<User>): boolean
}

Administrator --> UserManager : uses
UserManager --> User : manages

@enduml
```


QUAND CONVERTIR ?

[OK] CONVERTIR SI :
- Story complexe (multiple scénarios)
- Besoins clarification équipe
- Dépendances multiples
- Décision architecture

[X] NE PAS CONVERTIR SI :
- Story simple et claire
- Équipe comprend déjà
- Pas de valeur ajoutée
- Temps limité


RÈGLE D'OR : "Just Enough"

Minimum diagrammes pour :
[OK] Clarifier ambiguïtés
[OK] Aligner équipe
[OK] Documenter décisions clés
[OK] Faciliter onboarding

PAS pour :
[X] Formalisme bureaucratique
[X] Documentation exhaustive
[X] Validation contractuelle
"""


# ----------------------------------------------------------------------------
# [OBJECTIF] JUST ENOUGH MODELING
# ----------------------------------------------------------------------------

"""
PRINCIPE

Créer JUSTE ASSEZ de diagrammes pour :
1. Communiquer efficacement
2. Prendre bonnes décisions
3. Documenter essentiel

PAS PLUS !


RÈGLES PRATIQUES

1. DEMANDEZ-VOUS :
   "Ce diagramme apporte-t-il de la VALEUR ?"
   
   Si NON -> Ne pas créer

2. PRIVILÉGIEZ :
   - Tableau blanc > Outil formel
   - Photo tableau > Diagramme parfait
   - Sketch rapide > Diagramme détaillé

3. JETEZ :
   - Diagrammes temporaires après session
   - Modèles obsolètes
   - Documentation non maintenue

4. GARDEZ :
   - Architecture haut niveau
   - Décisions techniques importantes
   - Patterns utilisés


NIVEAUX DE DÉTAIL

NIVEAU 0 : Aucun diagramme
-> Story simple, équipe aligned
-> Code suffit

NIVEAU 1 : Sketch tableau blanc (5 min)
-> Clarification rapide
-> Photo pour trace

NIVEAU 2 : Diagramme informel (15 min)
-> Draw.io, PlantUML
-> Sauvegardé dans repo

NIVEAU 3 : Diagramme formel (1h+)
-> Documentation officielle
-> Architecture critique
-> Conformité requise


QUAND UTILISER CHAQUE NIVEAU ?

NIVEAU 0 :
- Features simples
- Maintenance mineure
- Bugs fixes

NIVEAU 1 :
- Clarification design
- Brainstorming
- Spike technique

NIVEAU 2 :
- Feature moyenne complexité
- Design reviews
- Onboarding

NIVEAU 3 :
- Architecture système
- Décisions stratégiques
- Conformité/Audit
- Documentation externe


EXEMPLE TIMELINE PROJET

SEMAINE 1 (Inception) :
-> Niveau 2-3 : Architecture globale
-> Use cases principaux
-> Diagramme composants

SPRINT 1-5 (Développement) :
-> Niveau 1 : Sketches au besoin
-> Niveau 0 : Features simples
-> Code = documentation

SPRINT 6 (Refactoring) :
-> Niveau 2 : Nouvelle architecture
-> Mise à jour diagrammes existants

FIN PROJET :
-> Niveau 3 : Doc architecture finale
-> Nettoyage diagrammes obsolètes
"""


# ----------------------------------------------------------------------------
# [CONSTRUCTION] DOCUMENTATION ARCHITECTURE AGILE
# ----------------------------------------------------------------------------

"""
ARCHITECTURE VISION

Document minimal mais essentiel :

CONTENU (5-10 pages max) :
1. Vue d'ensemble (1 page)
   - Contexte business
   - Objectifs système

2. Architecture haut niveau (2-3 pages)
   - Diagramme composants principal
   - Technologies clés
   - Décisions architecturales

3. Patterns utilisés (1 page)
   - Patterns principaux
   - Justification

4. Contraintes (1 page)
   - Performance
   - Sécurité
   - Scalabilité

5. Évolution future (1 page)
   - Roadmap technique
   - Dette technique connue


DIAGRAMMES ESSENTIELS

MINIMUM VITAL :
[OK] Diagramme de déploiement (infrastructure)
[OK] Diagramme de composants (modules)
[OK] Diagramme de classes (domain model)

OPTIONNELS SELON CONTEXTE :
- Use cases (si API publique)
- Séquence (flows critiques)
- États (workflows complexes)


ARCHITECTURE DECISION RECORDS (ADR)

Format léger pour décisions :

```markdown
# ADR-001: Choice of PostgreSQL

## Status
Accepted

## Context
Need persistent storage for relational data.
Team familiar with SQL.
ACID guarantees required.

## Decision
Use PostgreSQL as primary database.

## Consequences
+ Mature, stable
+ Strong community
+ ACID compliant
- More complex than NoSQL
- Vertical scaling limitations

## Alternatives Considered
- MongoDB (rejected: need ACID)
- MySQL (rejected: prefer PG features)
```

DIAGRAMME ASSOCIÉ :
```plantuml
@startuml
component "API" as API
database "PostgreSQL" as DB

API --> DB : JDBC
@enduml
```


C4 MODEL (Alternative UML)

Hiérarchie 4 niveaux :
1. Context (système dans écosystème)
2. Containers (applications, bases)
3. Components (modules internes)
4. Code (classes - rarement fait)

Plus simple que UML complet
Très populaire en Agile


LIVING DOCUMENTATION

Principe :
Documentation générée DEPUIS code

OUTILS :
- Swagger/OpenAPI (APIs REST)
- Javadoc avec PlantUML
- arc42 (template architecture)
- Asciidoctor (doc technique)

EXEMPLE :
```java
/**
 * User service managing user operations.
 * 
 * @startuml
 * UserService --> UserRepository
 * UserService --> EmailService
 * @enduml
 */
public class UserService {
    // ...
}
```

Génération automatique :
```bash
javadoc -doclet plantuml.jar ...
```


CONTINUOUS DOCUMENTATION

Intégrer dans CI/CD :
1. Code commit
2. Tests pass
3. Generate docs (PlantUML, Swagger)
4. Publish docs (GitHub Pages)

-> Documentation toujours à jour !
"""


# ----------------------------------------------------------------------------
# [DOCS] RÉCAPITULATIF CHAPITRE 12
# ----------------------------------------------------------------------------

"""
CE QUE VOUS AVEZ APPRIS

[OK] UML et Agile sont compatibles
[OK] Just Enough modeling (pas BDUF)
[OK] UML dans cérémonies Scrum
[OK] User Stories -> Use Cases/UML
[OK] Niveaux de détail adaptés
[OK] Architecture Vision minimale
[OK] Living Documentation


[CLE] PRINCIPES CLÉS

1. JUSTE NÉCESSAIRE
   Créer SEULEMENT diagrammes utiles

2. COLLABORATION
   Tableau blanc > Outil formel

3. ÉVOLUTION
   Modèles évoluent avec code

4. PRAGMATISME
   Valeur > Formalisme


[IDEE] ANTI-PATTERNS À ÉVITER

[X] Big Design Up Front (BDUF)
[X] Documentation exhaustive
[X] Synchronisation parfaite Code <-> UML
[X] Diagrammes non maintenus
[X] Modélisation par obligation


[OK] BONNES PRATIQUES

[OK] Model storming (sessions courtes)
[OK] Photos tableau blanc
[OK] PlantUML in code
[OK] Architecture Decision Records
[OK] Living Documentation
[OK] Continuous Documentation (CI/CD)


[COURS] MENTALITÉ AGILE + UML

"UML is a tool, not a religion"

Utilisez UML pour :
[OK] Communiquer
[OK] Clarifier
[OK] Décider
[OK] Documenter essentiel

PAS pour :
[X] Processus bureaucratique
[X] Validation hiérarchique
[X] Documentation contractuelle
[X] Formalisme excessif


-> PROCHAINE ÉTAPE : Chapitre 13 - PROJET FINAL

Le chapitre final : Projet complet de A à Z
- Énoncé détaillé
- Tous les diagrammes UML
- Implémentation code
- Documentation complète

Le grand finale ! Prêt ? Let's go ! [RAPIDE]
"""


# ============================================================================
# [GUIDE] CHAPITRE 13 : PROJET FINAL COMPLET
# ============================================================================

"""
[OBJECTIF] OBJECTIFS

Appliquer TOUTES les compétences UML acquises sur un projet réaliste :
[OK] Analyse et conception complète
[OK] 10+ diagrammes UML différents
[OK] Architecture professionnelle
[OK] Implémentation guidée
[OK] Documentation finale


[LISTE] ÉNONCÉ : PLATEFORME DE STREAMING VIDÉO

Créer une plateforme de streaming vidéo type Netflix/YouTube.


FONCTIONNALITÉS

UTILISATEURS :
- Inscription/Connexion
- Profils multiples par compte
- Personnalisation préférences
- Historique visionnage

CONTENU :
- Catalogue vidéos (films, séries)
- Catégories et genres
- Recherche et filtres
- Recommandations personnalisées

LECTURE :
- Streaming vidéo adaptatif
- Lecture/Pause/Avance rapide
- Sous-titres multilingues
- Qualité ajustable (SD, HD, 4K)

ABONNEMENT :
- Plans : Gratuit, Standard, Premium
- Paiement mensuel
- Gestion renouvellement
- Annulation

SOCIAL :
- Listes de lecture
- Partage vidéos
- Commentaires et notes
- Profils publics/privés


CONTRAINTES TECHNIQUES

- Architecture microservices
- Backend : Java Spring Boot
- Frontend : React
- Base données : PostgreSQL + MongoDB
- Cache : Redis
- Queue : RabbitMQ
- CDN : CloudFront
- Authentification : JWT
- Streaming : HLS protocol


ACTEURS

1. VISITEUR (non connecté)
   - Parcourir catalogue (limité)
   - S'inscrire

2. UTILISATEUR (gratuit)
   - Regarder avec publicités
   - Qualité SD uniquement
   - 1 profil

3. ABONNÉ STANDARD
   - Sans publicités
   - Qualité HD
   - 2 profils
   - Téléchargement limité

4. ABONNÉ PREMIUM
   - 4K disponible
   - 4 profils
   - Téléchargement illimité
   - Accès early releases

5. ADMINISTRATEUR
   - Gestion contenu
   - Modération commentaires
   - Analytics
   - Configuration système
"""


# ----------------------------------------------------------------------------
# [GRAPHIQUE] DIAGRAMMES UML COMPLETS
# ----------------------------------------------------------------------------

"""
DIAGRAMME 1 : CAS D'UTILISATION

```plantuml
@startuml

left to right direction

actor Visiteur
actor Utilisateur
actor "Abonné Standard" as Standard
actor "Abonné Premium" as Premium
actor Administrateur

Utilisateur <|-- Standard
Standard <|-- Premium

rectangle "Plateforme Streaming" {
  
  ' Visiteur
  Visiteur -- (Parcourir Catalogue)
  Visiteur -- (S'inscrire)
  Visiteur -- (Se Connecter)
  
  ' Utilisateur
  Utilisateur -- (Regarder Vidéo)
  Utilisateur -- (Gérer Profil)
  Utilisateur -- (Rechercher)
  Utilisateur -- (Créer Liste Lecture)
  Utilisateur -- (Commenter)
  
  ' Standard
  Standard -- (Télécharger Vidéo)
  Standard -- (Voir en HD)
  
  ' Premium
  Premium -- (Voir en 4K)
  Premium -- (Accès Early Releases)
  
  ' Admin
  Administrateur -- (Gérer Contenu)
  Administrateur -- (Modérer)
  Administrateur -- (Voir Analytics)
  
  ' Relations
  (Regarder Vidéo) ..> (Authentifier) : <<include>>
  (Regarder Vidéo) ..> (Vérifier Abonnement) : <<include>>
  (Regarder Vidéo) ..> (Afficher Publicités) : <<extend>>
  
  (Télécharger Vidéo) ..> (Vérifier Quota) : <<include>>
}

@enduml
```


DIAGRAMME 2 : CLASSES (DOMAIN MODEL)

```plantuml
@startuml

class User {
  - id: Long
  - email: String
  - passwordHash: String
  - registrationDate: Date
  - subscription: Subscription
  + authenticate(): boolean
  + upgradeSubscription(): void
}

class Profile {
  - id: Long
  - name: String
  - avatar: String
  - isKidsProfile: boolean
  - watchHistory: List<WatchEntry>
  + addToHistory(video): void
}

enum SubscriptionPlan {
  FREE
  STANDARD
  PREMIUM
}

class Subscription {
  - id: Long
  - plan: SubscriptionPlan
  - startDate: Date
  - endDate: Date
  - autoRenew: boolean
  + isActive(): boolean
  + canWatch4K(): boolean
}

class Video {
  - id: Long
  - title: String
  - description: String
  - duration: int
  - releaseDate: Date
  - genres: List<Genre>
  - rating: double
  + stream(quality): Stream
}

class Genre {
  - id: Long
  - name: String
}

class WatchEntry {
  - id: Long
  - video: Video
  - profile: Profile
  - timestamp: int
  - watchedAt: Date
}

class Playlist {
  - id: Long
  - name: String
  - isPublic: boolean
  - videos: List<Video>
  + addVideo(video): void
}

class Comment {
  - id: Long
  - user: User
  - video: Video
  - text: String
  - createdAt: Date
  - likes: int
}

' Relations
User "1" *-- "1..*" Profile
User "1" --> "1" Subscription
Profile "1" --> "0..*" WatchEntry
Profile "1" --> "0..*" Playlist
WatchEntry "*" --> "1" Video
Playlist "*" --> "*" Video
Video "*" --> "*" Genre
Comment "*" --> "1" User
Comment "*" --> "1" Video

@enduml
```


DIAGRAMME 3 : COMPOSANTS (MICROSERVICES)

```plantuml
@startuml

package "Frontend" {
  component [React App] as React
  component [Player Component] as Player
}

package "Backend Services" {
  component [API Gateway] as Gateway
  component [User Service] as UserSvc
  component [Video Service] as VideoSvc
  component [Subscription Service] as SubSvc
  component [Recommendation Engine] as RecEngine
  component [Analytics Service] as Analytics
}

package "Infrastructure" {
  database "PostgreSQL" as DB
  database "MongoDB" as Mongo
  component [Redis Cache] as Redis
  component [RabbitMQ] as Queue
  component [CDN CloudFront] as CDN
}

package "External" {
  component [Payment Gateway] as Payment
  component [Email Service] as Email
}

' Connections
React --> Gateway : HTTPS/REST
Player --> CDN : HLS Streaming

Gateway --> UserSvc : gRPC
Gateway --> VideoSvc : gRPC
Gateway --> SubSvc : gRPC

UserSvc --> DB : JDBC
VideoSvc --> Mongo : MongoDB Driver
SubSvc --> DB : JDBC

UserSvc --> Redis : Cache
VideoSvc --> Redis : Cache

UserSvc --> Queue : Publish Events
VideoSvc --> Queue : Publish Events
Analytics --> Queue : Subscribe Events

RecEngine --> Mongo : Read Data
RecEngine --> Redis : Cache

SubSvc --> Payment : HTTPS
UserSvc --> Email : HTTPS

@enduml
```


DIAGRAMME 4 : SÉQUENCE (Regarder Vidéo)

```plantuml
@startuml

actor User
participant "React App" as React
participant "API Gateway" as Gateway
participant "User Service" as UserSvc
participant "Video Service" as VideoSvc
participant "CDN" as CDN
database "MongoDB" as DB

User -> React : Click "Play"
activate React

React -> Gateway : GET /api/video/{id}/stream
activate Gateway

Gateway -> UserSvc : validateToken(token)
activate UserSvc
UserSvc --> Gateway : user info
deactivate UserSvc

Gateway -> UserSvc : checkSubscription(userId)
activate UserSvc
UserSvc --> Gateway : subscription valid
deactivate UserSvc

Gateway -> VideoSvc : getStreamUrl(videoId, quality)
activate VideoSvc

VideoSvc -> DB : getVideo(videoId)
activate DB
DB --> VideoSvc : video metadata
deactivate DB

VideoSvc -> CDN : generateSignedUrl()
activate CDN
CDN --> VideoSvc : signed URL
deactivate CDN

VideoSvc --> Gateway : streaming URL
deactivate VideoSvc

Gateway --> React : {url, token}
deactivate Gateway

React -> CDN : Request HLS stream
activate CDN
CDN --> React : video chunks
deactivate CDN

React -> User : Display video

' Async: update watch history
React -> Gateway : POST /api/history
activate Gateway
Gateway -> VideoSvc : recordWatch(userId, videoId)
VideoSvc -->> Gateway : recorded
deactivate Gateway

deactivate React

@enduml
```


DIAGRAMME 5 : ACTIVITÉS (Processus Abonnement)

```plantuml
@startuml

start

:Utilisateur choisit plan;

:Afficher récapitulatif;

:Demander info paiement;

:Utilisateur saisit carte;

fork
  :Vérifier validité carte;
fork again
  :Vérifier fonds;
end fork

if (Paiement OK?) then (oui)
  :Créer abonnement;
  
  fork
    :Enregistrer paiement;
  fork again
    :Envoyer email confirmation;
  fork again
    :Activer fonctionnalités premium;
  end fork
  
  :Afficher confirmation;
  
  stop
else (non)
  :Afficher erreur;
  
  if (Retry?) then (oui)
    :Retour saisie;
  else (non)
    :Annuler;
    stop
  endif
endif

@enduml
```


DIAGRAMME 6 : ÉTATS (État Abonnement)

```plantuml
@startuml

[*] --> Inactif

Inactif --> Actif : souscription

state Actif {
  [*] --> EnCours
  
  EnCours --> Suspendu : paiement échoué
  Suspendu --> EnCours : paiement réussi
  Suspendu --> Expiré : délai dépassé
  
  EnCours --> ProchaineRenouvellement : approche fin période
  ProchaineRenouvellement --> EnCours : renouvellement réussi
  ProchaineRenouvellement --> Expiré : renouvellement échoué
}

Actif --> Annulé : résiliation utilisateur
Actif --> Expiré : expiration

Annulé --> [*]
Expiré --> [*]

Expiré --> Actif : réabonnement

@enduml
```


DIAGRAMME 7 : DÉPLOIEMENT (AWS)

```plantuml
@startuml

node "User Device" <<device>> {
  component [Web Browser]
  component [Mobile App]
}

cloud "AWS Cloud" {
  node "CloudFront CDN" <<AWS Service>> {
    artifact "Video Files"
  }
  
  node "EKS Cluster" <<Kubernetes>> {
    node "Pod: Gateway" {
      artifact "api-gateway.jar"
    }
    node "Pod: User Service" {
      artifact "user-service.jar"
    }
    node "Pod: Video Service" {
      artifact "video-service.jar"
    }
  }
  
  node "RDS PostgreSQL" <<AWS Service>> {
    database "Users DB"
  }
  
  node "DocumentDB" <<AWS Service>> {
    database "Videos DB"
  }
  
  node "ElastiCache" <<AWS Service>> {
    component [Redis]
  }
}

[Web Browser] --> [CloudFront CDN] : HTTPS
[Mobile App] --> [CloudFront CDN] : HTTPS

[Web Browser] --> [Pod: Gateway] : REST API
[Pod: Gateway] --> [Pod: User Service] : gRPC
[Pod: Gateway] --> [Pod: Video Service] : gRPC

[Pod: User Service] --> [Users DB] : JDBC
[Pod: Video Service] --> [Videos DB] : MongoDB
[Pod: User Service] --> [Redis] : Cache
[Pod: Video Service] --> [Redis] : Cache

@enduml
```


DIAGRAMME 8 : PAQUETAGES

```plantuml
@startuml

package com.streaming {
  
  package api {
    class UserController
    class VideoController
    class SubscriptionController
  }
  
  package service {
    package user {
      class UserService
      class AuthenticationService
    }
    package video {
      class VideoService
      class StreamingService
    }
    package subscription {
      class SubscriptionService
      class PaymentService
    }
  }
  
  package repository {
    interface UserRepository
    interface VideoRepository
    interface SubscriptionRepository
  }
  
  package model {
    package entity {
      class User
      class Video
      class Subscription
    }
    package dto {
      class UserDTO
      class VideoDTO
    }
  }
  
  package config {
    class SecurityConfig
    class DatabaseConfig
  }
}

' Dependencies
api ..> service
api ..> model.dto
service ..> repository
service ..> model.entity
repository ..> model.entity

@enduml
```
"""


# ----------------------------------------------------------------------------
# [CODE] IMPLÉMENTATION (Extraits Code)
# ----------------------------------------------------------------------------

"""
CLASSE User (Java)

```java
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(unique = true, nullable = false)
    private String email;
    
    @Column(nullable = false)
    private String passwordHash;
    
    @Column(nullable = false)
    private LocalDateTime registrationDate;
    
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
    private List<Profile> profiles;
    
    @OneToOne(cascade = CascadeType.ALL)
    private Subscription subscription;
    
    // Constructors
    public User() {
        this.registrationDate = LocalDateTime.now();
        this.subscription = new Subscription(SubscriptionPlan.FREE);
    }
    
    // Methods
    public boolean authenticate(String password) {
        return BCrypt.checkpw(password, this.passwordHash);
    }
    
    public void upgradeSubscription(SubscriptionPlan plan) {
        this.subscription.setPlan(plan);
        this.subscription.setStartDate(LocalDateTime.now());
        this.subscription.setEndDate(
            LocalDateTime.now().plusMonths(1)
        );
    }
    
    public boolean canWatch4K() {
        return subscription.canWatch4K();
    }
    
    // Getters/Setters
    // ...
}
```


SERVICE UserService (Java)

```java
@Service
@Transactional
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private PasswordEncoder passwordEncoder;
    
    @Autowired
    private JwtTokenProvider tokenProvider;
    
    public User register(UserDTO userDTO) {
        // Validate email unique
        if (userRepository.existsByEmail(userDTO.getEmail())) {
            throw new UserAlreadyExistsException();
        }
        
        // Create user
        User user = new User();
        user.setEmail(userDTO.getEmail());
        user.setPasswordHash(
            passwordEncoder.encode(userDTO.getPassword())
        );
        
        // Create default profile
        Profile defaultProfile = new Profile();
        defaultProfile.setName("Default");
        defaultProfile.setUser(user);
        user.getProfiles().add(defaultProfile);
        
        return userRepository.save(user);
    }
    
    public String authenticate(String email, String password) {
        User user = userRepository.findByEmail(email)
            .orElseThrow(() -> new InvalidCredentialsException());
        
        if (!user.authenticate(password)) {
            throw new InvalidCredentialsException();
        }
        
        return tokenProvider.generateToken(user);
    }
    
    public void upgradeSubscription(Long userId, SubscriptionPlan plan) {
        User user = userRepository.findById(userId)
            .orElseThrow(() -> new UserNotFoundException());
        
        user.upgradeSubscription(plan);
        userRepository.save(user);
        
        // Publish event
        eventPublisher.publish(
            new SubscriptionUpgradedEvent(userId, plan)
        );
    }
}
```


CONTROLLER VideoController (Java)

```java
@RestController
@RequestMapping("/api/videos")
public class VideoController {
    
    @Autowired
    private VideoService videoService;
    
    @Autowired
    private StreamingService streamingService;
    
    @GetMapping
    public ResponseEntity<Page<VideoDTO>> getVideos(
        @RequestParam(defaultValue = "0") int page,
        @RequestParam(defaultValue = "20") int size,
        @RequestParam(required = false) String genre
    ) {
        Pageable pageable = PageRequest.of(page, size);
        Page<VideoDTO> videos = genre != null
            ? videoService.findByGenre(genre, pageable)
            : videoService.findAll(pageable);
        
        return ResponseEntity.ok(videos);
    }
    
    @GetMapping("/{id}")
    public ResponseEntity<VideoDTO> getVideo(@PathVariable Long id) {
        VideoDTO video = videoService.findById(id);
        return ResponseEntity.ok(video);
    }
    
    @GetMapping("/{id}/stream")
    @PreAuthorize("isAuthenticated()")
    public ResponseEntity<StreamUrlResponse> getStreamUrl(
        @PathVariable Long id,
        @RequestParam(defaultValue = "HD") String quality,
        @AuthenticationPrincipal UserDetails userDetails
    ) {
        User user = userService.findByEmail(userDetails.getUsername());
        
        // Check subscription allows quality
        if ("4K".equals(quality) && !user.canWatch4K()) {
            throw new InsufficientSubscriptionException();
        }
        
        // Generate signed streaming URL
        String url = streamingService.generateStreamUrl(
            id, 
            quality,
            user.getId()
        );
        
        // Record watch event (async)
        videoService.recordWatch(user.getId(), id);
        
        return ResponseEntity.ok(
            new StreamUrlResponse(url, 3600) // 1h expiration
        );
    }
}
```


FRONTEND React Component

```javascript
// VideoPlayer.jsx
import React, { useState, useEffect } from 'react';
import ReactPlayer from 'react-player';
import { getStreamUrl } from '../services/videoService';

function VideoPlayer({ videoId, onClose }) {
  const [streamUrl, setStreamUrl] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);
  
  useEffect(() => {
    loadVideo();
  }, [videoId]);
  
  const loadVideo = async () => {
    try {
      const response = await getStreamUrl(videoId, 'HD');
      setStreamUrl(response.url);
      setLoading(false);
    } catch (err) {
      setError(err.message);
      setLoading(false);
    }
  };
  
  if (loading) return <div>Loading...</div>;
  if (error) return <div>Error: {error}</div>;
  
  return (
    <div className="video-player">
      <ReactPlayer
        url={streamUrl}
        controls
        playing
        width="100%"
        height="100%"
        onEnded={() => {
          // Mark as watched
          // Show next episode
        }}
      />
      <button onClick={onClose}>Close</button>
    </div>
  );
}

export default VideoPlayer;
```
"""


# ----------------------------------------------------------------------------
# [DOCS] CONCLUSION DU GUIDE
# ----------------------------------------------------------------------------

"""
╔══════════════════════════════════════════════════════════════════════╗
║                                                                      ║
║                 [COURS] FÉLICITATIONS ! [COURS]                                ║
║                                                                      ║
║         VOUS AVEZ TERMINÉ LE GUIDE UML ULTRA-DÉTAILLÉ !             ║
║                                                                      ║
╚══════════════════════════════════════════════════════════════════════╝


[GRAPHIQUE] CE QUE VOUS AVEZ ACCOMPLI

[OK] 13 chapitres complets
[OK] 9 types de diagrammes UML maîtrisés
[OK] 20+ exercices pratiques résolus
[OK] Patterns de conception
[OK] Outils UML professionnels
[OK] Méthodologies Agiles
[OK] Projet final complet


[OBJECTIF] COMPÉTENCES ACQUISES

ANALYSE :
[OK] Identifier acteurs et cas d'utilisation
[OK] Analyser besoins fonctionnels
[OK] Décomposer problèmes complexes

CONCEPTION :
[OK] Modéliser structures de données (classes)
[OK] Concevoir interactions (séquence)
[OK] Organiser architecture (composants, paquetages)
[OK] Modéliser comportements (activités, états)
[OK] Planifier infrastructure (déploiement)

IMPLÉMENTATION :
[OK] Passer de diagrammes à code
[OK] Appliquer patterns de conception
[OK] Structurer projets
[OK] Documenter architecture

COMMUNICATION :
[OK] Expliquer systèmes visuellement
[OK] Collaborer avec équipes
[OK] Documenter décisions
[OK] Faciliter onboarding


[RAPIDE] POUR ALLER PLUS LOIN

1. PRATIQUER :
   - Modélisez vos projets personnels
   - Refaites exercices avec autres contextes
   - Contribuez projets open source

2. APPROFONDIR :
   - Patterns avancés (Enterprise patterns)
   - Domain-Driven Design (DDD)
   - Architecture d'entreprise (TOGAF)
   - Diagrammes ArchiMate

3. CERTIFICATIONS :
   - OMG Certified UML Professional (OCUP)
   - IIBA Certification (analyse métier)
   - AWS/Azure Architecture

4. CONTINUER À APPRENDRE :
   - Livres recommandés (voir début guide)
   - Conférences techniques
   - Communautés en ligne
   - Formations avancées


[IDEE] CONSEILS FINAUX

1. PRAGMATISME AVANT TOUT
   UML = OUTIL, pas fin en soi
   Créez ce qui apporte VALEUR

2. ADAPTEZ AU CONTEXTE
   - Startup : Light modeling
   - Entreprise : Documentation complète
   - Open Source : Architecture claire

3. RESTEZ À JOUR
   - Nouvelles pratiques
   - Nouveaux outils
   - Évolution standards

4. PARTAGEZ VOS CONNAISSANCES
   - Mentoring juniors
   - Articles techniques
   - Présentations équipe


[MERCI] REMERCIEMENTS

Merci d'avoir suivi ce guide jusqu'au bout !

Vous avez maintenant une base SOLIDE en UML.
Utilisez-la pour créer des systèmes incroyables !


[EMAIL] FEEDBACK

Vos retours sont précieux :
- Ce qui vous a aidé
- Ce qui pourrait être amélioré
- Vos suggestions


╔══════════════════════════════════════════════════════════════════════╗
║                                                                      ║
║                  BON COURAGE POUR VOS PROJETS !                      ║
║                                                                      ║
║                    Happy Modeling! [RAPIDE][MESURE]*                            ║
║                                                                      ║
╚══════════════════════════════════════════════════════════════════════╝


VERSION : 1.0
DATE : Janvier 2026
AUTEUR : Guide créé avec méthodologie COMMENT/POURQUOI/QUAND
LICENCE : Éducatif - Libre utilisation pour apprentissage
"""


# ============================================================================
# FIN DU CHAPITRE 13 - PROJET FINAL
# FIN DE LA PARTIE 4 - PRATIQUE ET OUTILS
# FIN DU GUIDE UML ULTRA-DÉTAILLÉ COMPLET
# ============================================================================


################################################################################
################################################################################
##                                                                            ##
##                          FIN DU GUIDE COMPLET                              ##
##                                                                            ##
################################################################################
################################################################################


╔══════════════════════════════════════════════════════════════════════════╗
║                                                                          ║
║                         [COURS] FÉLICITATIONS ! [COURS]                            ║
║                                                                          ║
║              VOUS AVEZ MAINTENANT ACCÈS AU GUIDE COMPLET                 ║
║                    UML ULTRA-DÉTAILLÉ MASTER EDITION                     ║
║                                                                          ║
║                           ~700 KB de contenu                             ║
║                           13 chapitres complets                          ║
║                           9 types de diagrammes                          ║
║                           20+ exercices pratiques                        ║
║                                                                          ║
║                    BON COURAGE POUR VOTRE APPRENTISSAGE !                ║
║                                                                          ║
║                         Happy Modeling! [RAPIDE][MESURE]*                           ║
║                                                                          ║
╚══════════════════════════════════════════════════════════════════════════╝


################################################################################
#                            INFORMATIONS FINALES                              #
################################################################################

[EMAIL] FEEDBACK
───────────
Ce guide a été créé pour vous aider à maîtriser UML de A à Z.
Vos retours sont précieux pour améliorer le contenu.


[DOCS] RESSOURCES COMPLÉMENTAIRES
──────────────────────────────
-> PlantUML : https://plantuml.com
-> Draw.io : https://app.diagrams.net
-> OMG UML : https://www.omg.org/spec/UML


[OBJECTIF] PROCHAINES ÉTAPES
────────────────────
1. Lisez le README (Section I)
2. Consultez l'INDEX pour vous orienter
3. Commencez par le Chapitre 0
4. Pratiquez avec les exercices
5. Appliquez sur vos projets réels


[IDEE] RAPPEL IMPORTANT
───────────────────
"UML is a tool, not a religion"

Utilisez UML pour :
  [OK] Communiquer clairement
  [OK] Clarifier la conception
  [OK] Prendre de meilleures décisions
  [OK] Documenter l'essentiel

N'utilisez PAS UML pour :
  [X] Bureaucratie excessive
  [X] Documentation exhaustive non maintenue
  [X] Formalisme sans valeur ajoutée


################################################################################
#                                                                              #
#                    MERCI D'AVOIR CHOISI CE GUIDE !                           #
#                                                                              #
#                 © 2026 - Guide UML Ultra-Détaillé                            #
#                   Créé avec [HEAVY_BLACK_HEART] pour les développeurs                         #
#                                                                              #
################################################################################