Du texte à l’insight : maîtriser VPasCode de Visual Paradigm pour le diagrammation moderne

@startuml
direction gauche à droite
acteur "Client e-commerce" comme customer
acteur "Fournisseur d'identité" comme authPool
acteur "Processeur de paiement" comme stripe

rectangle "Frontière du système de caisse" {
  cas d'utilisation "Authentifier" comme UC_Auth
  cas d'utilisation "Voir le panier" comme UC_Cart
  cas d'utilisation "Passer à la caisse" comme UC_Check
  cas d'utilisation "Appliquer un bon" comme UC_Promo
  cas d'utilisation "Payer par carte bancaire" comme UC_Pay
}

customer --> UC_Cart
customer --> UC_Check
UC_Check ..> UC_Auth : <>
UC_Check <.. UC_Promo : <>
UC_Check ..> UC_Pay : <>
UC_Auth --> authPool
UC_Pay --> stripe
@enduml

@startuml

class Bibliothèque {
  - nom : Chaîne
  - adresse : Chaîne
  - téléphone : Chaîne
  + ajouterMembre(membre : Membre) : void
  + supprimerMembre(idMembre : Chaîne) : void
  + ajouterArticle(article : ArticleBiblio) : void
  + supprimerArticle(idArticle : Chaîne) : void
  + prêterArticle(idMembre : Chaîne, idArticle : Chaîne) : booléen
  + rendreArticle(idArticle : Chaîne) : booléen
}

class ArticleBiblio {
  # idArticle : Chaîne
  # titre : Chaîne
  # éditeur : Chaîne
  # annéePublication : entier
  # estDisponible : booléen
  + obtenirDétails() : Chaîne
  + définirDisponibilité(statut : booléen) : void
}

classe abstraite Livre {
  - isbn : Chaîne
  - auteur : Chaîne
  - nombrePages : entier
  + obtenirAuteur() : Chaîne
}

class eBook {
  - tailleFichierMo : double
  - format : Chaîne
  - urlTéléchargement : Chaîne
  + télécharger() : void
}

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

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

class DVD {
  - duréeMinutes : entier
  - réalisateur : Chaîne
  - langue : Chaîne
  - sous-titresDisponibles : booléen
}

class Membre {
  - idMembre : Chaîne
  - nom : Chaîne
  - courriel : Chaîne
  - téléphone : Chaîne
  - dateAdhésion : Date
  + emprunterArticle(article : ArticleBiblio) : booléen
  + rendreArticle(article : ArticleBiblio) : booléen
  + obtenirArticlesEmpruntés() : Liste
}

class EnregistrementEmprunt {
  - idEnregistrement : Chaîne
  - dateEmprunt : Date
  - dateRetour : Date
  - dateRetourRéelle : Date
  - estEnRetard() : booléen
  - calculerPénalité() : double
}

class Pénalité {
  - idPénalité : Chaîne
  - montant : double
  - dateÉmission : Date
  - estPayée : booléen
  + payerPénalité() : void
}

class Bibliothécaire {
  - idPersonnel : Chaîne
  - département : Chaîne
  + traiterEmprunt(membre : Membre, article : ArticleBiblio) : void
  + traiterRetour(article : ArticleBiblio) : void
  + générerRapport() : void
  + gérerInventaire() : void
}

' Relations d'héritage
ArticleBiblio <|-- Livre
ArticleBiblio <|-- Magazine
ArticleBiblio <|-- DVD
Livre <|-- eBook
Livre <|-- LivreImprimé

' Composition et agrégation

Bibliothèque "1" -- "plusieurs" Membre : a >
Bibliothèque "1" -- "plusieurs" ArticleBiblio : contient >
Bibliothèque "1" -- "plusieurs" Bibliothécaire : emploie >

Membre "1" -- "plusieurs" EnregistrementEmprunt : a >
EnregistrementEmprunt "1" -- "1..*" ArticleBiblio : référence >
EnregistrementEmprunt "1" -- "0..*" Pénalité : génère >

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

note haut de Bibliothèque : Système central qui gèrenles membres, les articles et les prêts
note droite de ArticleBiblio : Classe de base abstraitenpour tous les matériaux de bibliothèque
@enduml

@startuml
' Titre
title Retrait de cash par distributeur automatique - Diagramme de séquence

' Acteurs et participants
acteur Client comme C
participant "Distributeur automatique" comme ATM
participant "Système bancaire" comme BS
base de données "Compte client" comme 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 validation

alt Code PIN invalide
    BS --> ATM : Code PIN invalide
    ATM -> C : Code PIN invalide, réessayer
    note right: Après 3 tentatives infructueuses,ncarte retenue
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 le cash
        ATM -> C : Distribuer le cash
        C -> ATM : Prendre le cash
        ATM -> BS : Confirmer la distribution du cash
        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 transaction

@enduml

@startuml SystemeSinistreAssurance

start

:Le titulaire de police dépose un sinistre;
:Le sinistre est enregistré dans le système;

si (La police est-elle active et valide ?) alors (oui)
  :Attribuer le sinistre à l'expert;
  :Notifier l'expert d'un nouveau sinistre;
sinon (non)
  :Envoyer une notification de rejet au titulaire de police;
  :Enregistrer la raison : Police inactive/valide;
  stop
fin si

:L'expert examine les documents soumis;

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

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

si (Le sinistre est-il valide selon les conditions de la police ?) alors (oui)
  :Calculer le montant approuvé;
  :Appliquer la franchise si applicable;
sinon (non)
  :Envoyer une notification de rejet avec la raison;
  :Enregistrer la décision dans le système;
  stop
fin si

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

:Le titulaire de police examine l'offre;

si (Le titulaire de police accepte-t-il l'offre ?) alors (oui)
  :Traiter le paiement;
  :Mettre à jour le statut du sinistre en "Règlement";
  :Envoyer une confirmation au titulaire de police;
  :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 titulaire de police";
fin si

stop

@enduml

@startuml SystemDetectionFumee

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

[*] --> Eteint

état Eteint {
    [*] --> HorsTension
    HorsTension : Appareil éteint
    HorsTension --> Allume : Bouton d'alimentation pressé
}

état Allume {
    [*] --> Veille
    Veille : Système prêt
    Veille --> AutoTest : Auto-vérification périodique (toutes les 24h)
    Veille --> Surveillance : Démarrer la surveillance (capteur actif)
    
    état AutoTest {
        [*] --> TestCapteurs
        TestCapteurs --> TestReussi : Tous les capteurs OK
        TestCapteurs --> TestEchec : Erreur de capteur détectée
        TestReussi --> Veille : Retour à l'état veille
        TestEchec --> EtatErreur : Signaler l'erreur
    }
    
    état Surveillance {
        [*] --> PasDeFumee
        PasDeFumee : Fonctionnement normal
        PasDeFumee --> DetectionFumee : Niveau de fumée > seuil
        PasDeFumee --> BatterieFaible : Batterie faible (sans fil)
        BatterieFaible --> PasDeFumee : Batterie remplacée
        
        état DetectionFumee {
            [*] --> AlertInitial
            AlertInitial --> FumeeConfirmee : La fumée persiste > 5 sec
            AlertInitial --> FauxAlarme : La fumée disparaît < 5 sec FauxAlarme --> PasDeFumee : Réinitialisation
            FumeeConfirmee --> AlarmeActive
        }
        
        état AlarmeActive {
            [*] --> ActiverAlarme : Activer la sirène et les lumières
            ActiverAlarme --> EnvoyerNotification : Avertir le panneau de contrôle / application
            EnvoyerNotification --> AttendReinitialisation
            AttendReinitialisation --> AlarmeActive : La fumée est encore présente
            AttendReinitialisation --> ReinitialiserSysteme : Bouton de réinitialisation pressé
            ReinitialiserSysteme --> PasDeFumee : Le système se réinitialise
        }
    }
}

état EtatErreur {
    [*] --> IndicateurDefaut : Clignotement de la LED d'erreur
    IndicateurDefaut --> Eteint : Cycle manuel d'alimentation requis
}

Allume --> EtatErreur : Échec de l'auto-vérification
EtatErreur --> Eteint : Cycle d'alimentation

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

@enduml

@startuml SystemLivraison

title Système de livraison - Diagramme de composants

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

composant "Passerelle API" as ApiGateway

composant "Service de commande" as OrderService
composant "Service d'envoi" as DispatchService
composant "Service de suivi" as TrackingService
composant "Service de paiement" as PaymentService
composant "Service de notification" as NotificationService
composant "Service utilisateur" as UserService

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

database "Base de données PostgreSQL" as SQLDB
database "Base de données MongoDBn(Connexions/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 : "Envoi push via passerelle API"
DispatchService --> SQLDB

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

PaymentService --> SQLDB
PaymentService --> NotificationService

NotificationService --> MessageQueue : "Consommer les notifications"
NotificationService --> CustomerApp : "Envoi push via passerelle API"

UserService --> SQLDB
UserService --> RedisCache

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

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

note bottom of MessageQueue
  Événements asynchrones : order_created,
  location_updated,
  delivery_status_changed
end note

@enduml

@startuml
nœud "AWS Cloud Route53" as DNS

nœud "VPC (10.0.0.0/16)" {
  nœud "Sous-réseau public" {
    artefact "Équilibreur de charge NGINX" as ALB
  }
  
  nœud "Cluster de sous-réseau privé" {
    nœud "Instance EC2 1" {
      composant "API Node.js [Pod 1]" as Pod1
    }
    nœud "Instance EC2 2" {
      composant "API Node.js [Pod 2]" as Pod2
    }
  }
  
  nœud "Sous-réseau base de données" {
    base de données "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 Exemple de navigateur internet
!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 application)")
}

Grouping(application, "Application"){
  Application_DataObject(dataObject, "Données de page web n 'en temps réel'")
  Application_Function(webpageBehaviour, "Comportement de la page web")
  Application_Component(ActivePartWebPage, "Partie active de la page web n 'en temps réel'")
}

Grouping(technology, "Technologie"){
  Technology_Artifact(inMemoryItem,"en mémoire / 'en temps réel' html/javascript")
  Technology_Service(internetBrowser, "Navigateur internet générique & plugin")
  Technology_Service(internetBrowserPlugin, "Un plugin de navigateur internet")
  Technology_Service(webServer, "Un serveur 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

entity "Client" as customer {
  * customer_id : UUID <>
  --
  * first_name : VARCHAR(50)
  * last_name : VARCHAR(50)
  * email : VARCHAR(100) <>
  * phone : VARCHAR(20)
  * loyalty_points : INT
  * registration_date : TIMESTAMP
}

entity "Film" as movie {
  * movie_id : UUID <>
  --
  * title : VARCHAR(200)
  * description : TEXT
  * duration_minutes : INT
  * genre : VARCHAR(50)
  * release_date : DATE
  * rating : VARCHAR(10)
}

entity "Théâtre" as theater {
  * theater_id : UUID <>
  --
  * theater_name : VARCHAR(100)
  * total_seats : INT
  * seat_layout : JSON
}

entity "Séance" as show {
  * show_id : UUID <>
  --
  * movie_id : UUID <>
  * theater_id : UUID <>
  * show_time : TIMESTAMP
  * end_time : TIMESTAMP
  * language : VARCHAR(50)
  * subtitle : BOOLEAN
  * price_regular : DECIMAL(10,2)
  * price_vip : DECIMAL(10,2)
}

entity "Siège" as seat {
  * seat_id : UUID <>
  --
  * theater_id : UUID <>
  * row_label : CHAR(2)
  * seat_number : INT
  * seat_type : VARCHAR(20)
  * is_accessible : BOOLEAN
}

entity "Réservation" as booking {
  * booking_id : UUID <>
  --
  * customer_id : UUID <>
  * show_id : UUID <>
  * booking_time : TIMESTAMP
  * total_amount : DECIMAL(10,2)
  * status : VARCHAR(20)
  * payment_method : VARCHAR(30)
  * transaction_id : VARCHAR(100)
}

entity "SiègeRéservé" as booking_seat {
  * booking_id : UUID <<FK,PK>>
  * seat_id : UUID <<FK,PK>>
  --
  * ticket_price : DECIMAL(10,2)
  * discount_applied : DECIMAL(10,2)
}

entity "Paiement" as payment {
  * payment_id : UUID <>
  --
  * booking_id : UUID <>
  * amount : DECIMAL(10,2)
  * payment_date : TIMESTAMP
  * payment_status : VARCHAR(20)
  * payment_gateway : VARCHAR(30)
  * gateway_reference : VARCHAR(200)
}

entity "Avis" as review {
  * review_id : UUID <>
  --
  * customer_id : UUID <>
  * movie_id : UUID <>
  * rating : INT
  * comment : TEXT
  * review_date : TIMESTAMP
}

' Relations
customer ||--o{ booking : "effectue"
movie ||--o{ show : "programmée comme"
theater ||--o{ show : "accueille"
show ||--o{ booking : "possède"
booking ||--|{ booking_seat : "contient"
seat ||--o{ booking_seat : "affecté à"
booking ||--|| payment : "possède"
customer ||--o{ review : "rédige"
movie ||--o{ review : "reçoit"

note right of booking : Statut : EN_ATTENTE, CONFIRMÉ, ANNULÉ, EXPIRÉ
note left of seat : type_siège : NORMAL, VIP, COUPLES
note right of payment : statut_paiement : EN_ATTENTE, RÉUSSI, ÉCHOUÉ, REMBOURSÉ

@enduml

flowchart TD
    A[Se sentir mal 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[Demander des tests]

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

    H --> K[Suivre le traitement]
    K --> L{Les symptômes ont-ils diminué ?}

    L -->|Oui| M[Récupération / suivi régulier]
    L -->|Non| N[Rentrer voir le médecin]
    N --> F

graph ArbreCouvrantNonOriente {
    fontname="Helvetica,Arial,sans-serif"
    label="Infrastructure principale de topologie réseau en maillage pour centre de données"
    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="Hôte_01"]
    Node2        [label="Hôte_02"]
    Node3        [label="Hôte_03"]
    Node4        [label="Hôte_04"]
    
    SwitchAlpha -- SwitchBeta [label=" Lien de trunking", weight=5]
    SwitchAlpha -- Node1
    SwitchAlpha -- Node2
    SwitchBeta -- Node3
    SwitchBeta -- Node4
    Node1 -- Node2 [style=dashed, color="#cbd5e1", label=" Connexion de secours"]
}