Du texte à l’architecture : Maîtriser VPasCode de Visual Paradigm pour les équipes Agile

@startuml

class Bibliothèque {
  - nom: String
  - adresse: String
  - téléphone: String
  + ajouterMembre(membre: Membre): void
  + supprimerMembre(idMembre: String): void
  + ajouterArticle(article: ArticleBibliothèque): void
  + supprimerArticle(idArticle: String): void
  + prêterArticle(idMembre: String, idArticle: String): boolean
  + retournerArticle(idArticle: String): boolean
}

class ArticleBibliothèque {
  # idArticle: String
  # titre: String
  # éditeur: String
  # annéePublication: int
  # estDisponible: boolean
  + obtenirDétails(): String
  + définirDisponibilité(statut: boolean): void
}

abstract class Livre {
  - isbn: String
  - auteur: String
  - nombrePages: int
  + obtenirAuteur(): String
}

class LivreNumérique {
  - tailleFichierMo: double
  - format: String
  - urlTéléchargement: String
  + télécharger(): void
}

class LivreImprimé {
  - emplacementÉtagère: String
  - état: String
  + obtenirEmplacementÉtagère(): String
}

class Magazine {
  - numéroÉdition: int
  - numéroVolume: int
  - dateCouverture: Date
}

class DVD {
  - duréeMinutes: int
  - réalisateur: String
  - langue: String
  - sous-titresDisponibles: boolean
}

class Membre {
  - idMembre: String
  - nom: String
  - email: String
  - téléphone: String
  - dateAdhésion: Date
  + emprunterArticle(article: ArticleBibliothèque): boolean
  + retournerArticle(article: ArticleBibliothèque): boolean
  + obtenirArticlesEmpruntés(): List
}

class EnregistrementEmprunt {
  - idEnregistrement: String
  - dateEmprunt: Date
  - dateÉchéance: Date
  - dateRetour: Date
  - estEnRetard(): boolean
  - calculerAmende(): double
}

class Amende {
  - idAmende: String
  - montant: double
  - dateÉmission: Date
  - estPayée: boolean
  + payerAmende(): void
}

class Bibliothécaire {
  - idEmployé: String
  - département: String
  + traiterEmprunt(membre: Membre, article: ArticleBibliothèque): void
  + traiterRetour(article: ArticleBibliothèque): void
  + générerRapport(): void
  + gérerInventaire(): void
}

' Relations d'héritage
ArticleBibliothèque <|-- Livre
ArticleBibliothèque <|-- Magazine
ArticleBibliothèque <|-- DVD
Livre <|-- LivreNumérique
Livre <|-- LivreImprimé 

' Composition et Agrégation 

Bibliothèque "1" -- "many" Membre : possède >
Bibliothèque "1" -- "many" ArticleBibliothèque : contient >
Bibliothèque "1" -- "many" Bibliothécaire : emploie >

Membre "1" -- "many" EnregistrementEmprunt : possède >
EnregistrementEmprunt "1" -- "1..*" ArticleBibliothèque : référence >
EnregistrementEmprunt "1" -- "0..*" Amende : génère >

' Association
Bibliothécaire --> EnregistrementEmprunt : gère >
Membre --> EnregistrementEmprunt : crée >

note top of Bibliothèque : Système central qui gèrenles membres, les articles et les prêts
note right of ArticleBibliothèque : Classe de base abstraitenpour tous les supports de la bibliothèque
@enduml

@startuml
' Titre
title Retrait d'espèces à un guichet automatique - Diagramme de séquence

' Acteurs et participants
actor Client as C
participant "Guichet automatique" as ATM
participant "Système bancaire" as BS
database "Compte client" as DB

' Séquence
C -> ATM : Insérer la carte
ATM -> ATM : Lire les détails de la carte
ATM -> C : Demander le code PIN
C -> ATM : Saisir le code PIN
ATM -> BS : Valider la carte et le code PIN
BS -> DB : Vérifier les identifiants
DB --> BS : Résultat de la validation

alt Code PIN invalide
    BS --> ATM : Code PIN invalide
    ATM -> C : Code PIN invalide, réessayez
    note right: Après 3 tentatives échouées,nla carte est conservée
else Code PIN valide
    BS --> ATM : Code PIN valide
    ATM -> C : Afficher le menu principal
    C -> ATM : Sélectionner le retrait
    ATM -> C : Demander le montant
    C -> ATM : Saisir le montant
    ATM -> BS : Vérifier le solde et la limite
    BS -> DB : Interroger le solde
    DB --> BS : Solde actuel
    
    alt Fonds insuffisants
        BS --> ATM : Solde insuffisant
        ATM -> C : Transaction refuséen(Afficher le solde)
        C -> ATM : Annuler la transaction
        ATM -> C : Rendre la carte
    else Fonds suffisants
        BS --> ATM : Approuvé
        ATM -> ATM : Distribuer l'argent
        ATM -> C : Distribuer l'argent
        C -> ATM : Prendre l'argent
        ATM -> BS : Confirmer la distribution d'argent
        BS -> DB : Débiter le compte et enregistrer la transaction
        DB --> BS : Mise à jour terminée
        BS --> ATM : Transaction terminée
        ATM -> C : Imprimer le reçu
        alt Reçu demandé
            C -> ATM : Prendre le reçu
        else Pas de reçu
            C -> ATM : Refuser le reçu
        end
        ATM -> C : Rendre la carte
        C -> ATM : Prendre la carte
    end
end

ATM -> C : Merci / Fin de la transaction

@enduml

@startuml InsuranceClaimSystem

début

:Le souscripteur soumet une réclamation;
:La réclamation est enregistrée dans le système;

si (La police est-elle active et valide ?) alors (oui)
  :Attribuer la réclamation à l'expert;
  :Informer l'expert de la nouvelle réclamation;
sinon (non)
  :Envoyer un avis de rejet au souscripteur;
  :Enregistrer la raison : Police inactive/invalidée;
  fin
fin

:L'expert examine les documents soumis;

si (Tous les documents requis sont-ils présents ?) alors (oui)
  :L'expert initie la validation de la réclamation;
sinon (non)
  :Demander les documents manquants au souscripteur;
  :Attendre les documents supplémentaires;
  :Re-vérifier les documents;
  note right
    Le système attend
    la réponse du souscripteur
  end note
  -> retour à "L'expert examine les documents soumis";
fin

:L'expert enquête sur la réclamation;
:Contacter des témoins/experts si nécessaire;
:Estimer le montant des dommages/pertes;

si (La réclamation est-elle valide selon les termes de la police ?) alors (oui)
  :Calculer le montant approuvé;
  :Appliquer la franchise si applicable;
sinon (non)
  :Envoyer un avis de rejet avec la raison;
  :Enregistrer la décision dans le système;
  fin
fin

:Générer une offre de règlement;
:Envoyer l'offre de règlement au souscripteur;

:Le souscripteur examine l'offre;

si (Le souscripteur accepte-t-il l'offre ?) alors (oui)
  :Traiter le paiement;
  :Mettre à jour le statut de la réclamation à "Règlementé";
  :Envoyer une confirmation au souscripteur;
  :Enregistrer les détails de clôture;
sinon (non)
  :Escalader vers la résolution des litiges;
  :Négocier le règlement;
  :Mettre à jour l'offre;
  -> retour à "Envoyer l'offre de règlement au souscripteur";
fin

fin

@enduml

@startuml SmokeDetectionSystem

title Diagramme d'états - Système de détection de fumée

[*] --> PowerOff

state PowerOff {
    [*] --> NoPower
    NoPower : L'appareil est éteint
    NoPower --> PowerOn : Bouton d'alimentation pressé
}

state PowerOn {
    [*] --> Standby
    Standby : Système prêt
    Standby --> SelfCheck : Auto-test périodique (toutes les 24h)
    Standby --> Monitoring : Démarrer la surveillance (capteur actif)
    
    state SelfCheck {
        [*] --> TestingSensors
        TestingSensors --> TestPass : Tous les capteurs OK
        TestingSensors --> TestFail : Erreur de capteur détectée
        TestPass --> Standby : Retour à la veille
        TestFail --> ErrorState : Signaler l'erreur
    }
    
    state Monitoring {
        [*] --> NoSmoke
        NoSmoke : Fonctionnement normal
        NoSmoke --> SmokeDetected : Niveau de fumée > seuil
        NoSmoke --> LowBattery : Batterie faible (sans fil)
        LowBattery --> NoSmoke : Batterie remplacée
        
        state SmokeDetected {
            [*] --> InitialAlert
            InitialAlert --> ConfirmedSmoke : La fumée persiste > 5 sec
            InitialAlert --> FalseAlarm : La fumée se dissipe < 5 sec FalseAlarm --> NoSmoke : Réinitialisation
            ConfirmedSmoke --> AlarmActive
        }
        
        state AlarmActive {
            [*] --> SoundAlarm : Activer sirène et lumières
            SoundAlarm --> SendNotification : Notifier le panneau de contrôle / l'application
            SendNotification --> WaitForReset
            WaitForReset --> AlarmActive : Fumée toujours présente
            WaitForReset --> ResetSystem : Bouton de réinitialisation pressé
            ResetSystem --> NoSmoke : Le système se réinitialise
        }
    }
}

state ErrorState {
    [*] --> FaultIndicator : Clignotement de la LED d'erreur
    FaultIndicator --> PowerOff : Cycle d'alimentation manuel requis
}

PowerOn --> ErrorState : Échec de l'auto-test
ErrorState --> PowerOff : Cycle d'alimentation

PowerOff --> [*] : Système débranché / batterie retirée

@enduml

@startuml CourierSystem

title Système de messagerie - Diagramme de composants

' === Composants ===
component "Application client" as CustomerApp
component "Application mobile du livreur" as CourierApp
component "Tableau de bord Web administrateur" as AdminWeb

component "Passerelle API" as ApiGateway

component "Service de commande" as OrderService
component "Service d'expédition" as DispatchService
component "Service de suivi" as TrackingService
component "Service de paiement" as PaymentService
component "Service de notification" as NotificationService
component "Service utilisateur" as UserService

component "File d'attente de messagesn(RabbitMQ/Kafka)" as MessageQueue
component "Cache Redis" as RedisCache

database "Base de données PostgreSQL" as SQLDB
database "MongoDBn(Journaux/Historique de suivi)" as MongoLogs

' === Interfaces / Ports ===
CustomerApp --> ApiGateway : "REST / WebSocket"
CourierApp --> ApiGateway : "REST / WebSocket"
AdminWeb --> ApiGateway : "REST"

ApiGateway --> OrderService
ApiGateway --> TrackingService
ApiGateway --> PaymentService
ApiGateway --> UserService

' === Dépendances des services ===
OrderService --> DispatchService : "gRPC / REST"
OrderService --> PaymentService
OrderService --> NotificationService
OrderService --> SQLDB : "JDBC"
OrderService --> RedisCache : "Cache"

DispatchService --> MessageQueue : "Publier des événements"
DispatchService --> CourierApp : "Pousser via la passerelle API"
DispatchService --> SQLDB

TrackingService --> MessageQueue : "S'abonner aux mises à jour de localisation"
TrackingService --> MongoLogs : "Écrire l'historique de suivi"
TrackingService --> RedisCache : "Cache de la localisation actuelle"

PaymentService --> SQLDB
PaymentService --> NotificationService

NotificationService --> MessageQueue : "Consommer les notifications"
NotificationService --> CustomerApp : "Pousser via la passerelle API"

UserService --> SQLDB
UserService --> RedisCache

' === Notes ===
note right of OrderService
  Gère la création de colis,
  la tarification et le statut de la commande
end note

note right of DispatchService
  Apparie les commandes aux livreurs,
  optimise les itinéraires
end note

note bottom of MessageQueue
  Événements asynchrones : commande_créée,
  localisation_mise_à_jour,
  statut_livraison_modifié
end note

@enduml

@startuml
node "AWS Cloud Route53" as DNS

node "VPC (10.0.0.0/16)" {
  node "Sous-réseau public" {
    artifact "Équilibreur de charge NGINX" as ALB
  }
  
  node "Cluster de sous-réseau privé" {
    node "Instance EC2 1" {
      component "API Node.js [Pod 1]" as Pod1
    }
    node "Instance EC2 2" {
      component "API Node.js [Pod 2]" as Pod2
    }
  }
  
  node "Sous-réseau de base de données" {
    database "Amazon RDS (Aurora Multi-AZ)" as Aurora
  }
}

DNS --> ALB : Résout le trafic
ALB --> Pod1 : Équilibrage round-robin
ALB --> Pod2
Pod1 --> Aurora : Pool de connexions
Pod2 --> Aurora
@enduml

@startuml Internet Browser Sample
!include <archimate/Archimate>

title Exemple ArchiMate - Navigateur Internet

'LAYOUT_AS_SKETCH()
'LAYOUT_LEFT_RIGHT()
'LAYOUT_TOP_DOWN()

Grouping(business, "Métier"){
  Business_Object(businessObject, "Un objet métier")
  Business_Process(someBusinessProcess,"Un processus métier")
  Business_Service(itSupportService, "Support informatique pour le métier (Service applicatif)")
}

Grouping(application, "Application"){
  Application_DataObject(dataObject, "Données de page Web n 'à la volée'")
  Application_Function(webpageBehaviour, "Comportement de la page Web")
  Application_Component(ActivePartWebPage, "Partie active de la page Web n 'à la volée'")
}

Grouping(technology, "Technologie"){
  Technology_Artifact(inMemoryItem,"en mémoire / 'à la volée' html/javascript")
  Technology_Service(internetBrowser, "Navigateur Internet générique et plugin")
  Technology_Service(internetBrowserPlugin, "Certains plugins de navigateur Internet")
  Technology_Service(webServer, "Certains serveurs Web")
}


Rel_Flow_Left(someBusinessProcess, businessObject, "")
Rel_Serving_Up(itSupportService, someBusinessProcess, "")
Rel_Specialization_Up(webpageBehaviour, itSupportService, "")
Rel_Flow_Right(dataObject, webpageBehaviour, "")
Rel_Specialization_Up(dataObject, businessObject, "")
Rel_Assignment_Left(ActivePartWebPage, webpageBehaviour, "")
Rel_Specialization_Up(inMemoryItem, dataObject, "")
Rel_Realization_Up(inMemoryItem, ActivePartWebPage, "")
Rel_Specialization_Right(inMemoryItem,internetBrowser, "")
Rel_Serving_Up(internetBrowser, webpageBehaviour, "")
Rel_Serving_Up(internetBrowserPlugin, webpageBehaviour, "")
Rel_Aggregation_Right(internetBrowser, internetBrowserPlugin, "")
Rel_Access_Up(webServer, inMemoryItem, "")
Rel_Serving_Up(webServer, internetBrowser, "")

@enduml

@startuml

entité "Client" as client {
  * client_id : UUID <>
  --
  * prénom : VARCHAR(50)
  * nom : VARCHAR(50)
  * email : VARCHAR(100) <>
  * téléphone : VARCHAR(20)
  * points_fidélité : INT
  * date_inscription : TIMESTAMP
}

entité "Film" as film {
  * film_id : UUID <>
  --
  * titre : VARCHAR(200)
  * description : TEXT
  * durée_minutes : INT
  * genre : VARCHAR(50)
  * date_sortie : DATE
  * note : VARCHAR(10)
}

entité "Cinéma" as cinéma {
  * cinéma_id : UUID <>
  --
  * nom_cinéma : VARCHAR(100)
  * nombre_total_places : INT
  * disposition_places : JSON
}

entité "Spectacle" as spectacle {
  * spectacle_id : UUID <>
  --
  * film_id : UUID <>
  * cinéma_id : UUID <>
  * heure_spectacle : TIMESTAMP
  * heure_fin : TIMESTAMP
  * langue : VARCHAR(50)
  * sous_titres : BOOLEAN
  * prix_régulier : DECIMAL(10,2)
  * prix_vip : DECIMAL(10,2)
}

entité "Place" as place {
  * place_id : UUID <>
  --
  * cinéma_id : UUID <>
  * ligne_label : CHAR(2)
  * numéro_place : INT
  * type_place : VARCHAR(20)
  * est_accessible : BOOLEAN
}

entité "Réservation" as réservation {
  * réservation_id : UUID <>
  --
  * client_id : UUID <>
  * spectacle_id : UUID <>
  * heure_réservation : TIMESTAMP
  * montant_total : DECIMAL(10,2)
  * statut : VARCHAR(20)
  * mode_paiement : VARCHAR(30)
  * identifiant_transaction : VARCHAR(100)
}

entité "RéservationPlace" as réservation_place {
  * réservation_id : UUID <<FK,PK>>
  * place_id : UUID <<FK,PK>>
  --
  * prix_billet : DECIMAL(10,2)
  * réduction_appliquée : DECIMAL(10,2)
}

entité "Paiement" as paiement {
  * paiement_id : UUID <>
  --
  * réservation_id : UUID <>
  * montant : DECIMAL(10,2)
  * date_paiement : TIMESTAMP
  * statut_paiement : VARCHAR(20)
  * passerelle_paiement : VARCHAR(30)
  * référence_passerelle : VARCHAR(200)
}

entité "Avis" as avis {
  * avis_id : UUID <>
  --
  * client_id : UUID <>
  * film_id : UUID <>
  * note : INT
  * commentaire : TEXT
  * date_avis : TIMESTAMP
}

' Relations
client ||--o{ réservation : "effectue"
film ||--o{ spectacle : "programmé comme"
cinéma ||--o{ spectacle : "accueille"
spectacle ||--o{ réservation : "a"
réservation ||--|{ réservation_place : "contient"
place ||--o{ réservation_place : "attribuée à"
réservation ||--|| paiement : "a"
client ||--o{ avis : "rédige"
film ||--o{ avis : "reçoit"

note right of réservation : Statut : EN_ATTENTE, CONFIRMÉE, ANNULÉE, EXPIRÉE
note left of place : type_place : RÉGULIÈRE, VIP, COUPLE
note right of paiement : statut_paiement : EN_ATTENTE, RÉUSSI, ÉCHOUÉ, REMBOURSÉ

@enduml

flowchart TD
    A[Se sentir malade ou avoir besoin de conseils médicaux] --> B{Est-ce une urgence?}

    B -->|Oui| C[Appeler les services d'urgence ou aller aux urgences]
    B -->|Non| D[Prendre rendez-vous avec un médecin]

    D --> E[Assister au rendez-vous]
    E --> F[Évaluation par le médecin]

    F --> G{Diagnostic établi?}

    G -->|Oui| H[Plan de traitement]
    G -->|Non| I[Commander des tests]

    I --> J[Recevoir les résultats des tests]
    J --> F

    H --> K[Suivre le traitement]
    K --> L{Symptômes améliorés?}

    L -->|Oui| M[Récupération / Suivi de routine]
    L -->|Non| N[Retourner voir le médecin]
    N --> F

graph UndirectedSpanningTree {
    fontname="Helvetica,Arial,sans-serif"
    label="Topologie de réseau maillé de centre de données - Infrastructure d'épine dorsale"
    labelloc="b"
    fontsize=14
    
    node [fontname="Helvetica,Arial,sans-serif", shape=circle, style=filled, color="#475569", fillcolor="#f1f5f9", width=0.8, fixedsize=true]
    edge [color="#94a3b8", penwidth=2.5]
    
    SwitchAlpha  [label="SW_A", fillcolor="#cbd5e1"]
    SwitchBeta   [label="SW_B", fillcolor="#cbd5e1"]
    Node1        [label="Host_01"]
    Node2        [label="Host_02"]
    Node3        [label="Host_03"]
    Node4        [label="Host_04"]
    
    SwitchAlpha -- SwitchBeta [label=" Lien Trunk", weight=5]
    SwitchAlpha -- Node1
    SwitchAlpha -- Node2
    SwitchBeta -- Node3
    SwitchBeta -- Node4
    Node1 -- Node2 [style=dashed, color="#cbd5e1", label=" Interconnexion de basculement"]
}