Od tekstu do architektury: Opanowanie VPasCode Visual Paradigm dla zespołów Agile

@startuml

class Biblioteka {
  - nazwa: String
  - adres: String
  - telefon: String
  + dodajCzłonka(członek: Członek): void
  + usuńCzłonka(idCzłonka: String): void
  + dodajElement(element: ElementBiblioteczny): void
  + usuńElement(idElementu: String): void
  + wypożyczElement(idCzłonka: String, idElementu: String): boolean
  + zwróćElement(idElementu: String): boolean
}

class ElementBiblioteczny {
  # idElementu: String
  # tytuł: String
  # wydawca: String
  # rokWydania: int
  # dostępny: boolean
  + uzyskajSzczegóły(): String
  + ustawDostępność(status: boolean): void
}

abstract class Książka {
  - isbn: String
  - autor: String
  - liczbaStron: int
  + uzyskajAutora(): String
}

class EBook {
  - rozmiarPlikuMB: double
  - format: String
  - urlPobrania: String
  + pobierz(): void
}

class KsiążkaDrukowana {
  - lokalizacjaNaPółce: String
  - stan: String
  + uzyskajLokalizacjęNaPółce(): String
}

class Czasopismo {
  - numerWydania: int
  - numerTomu: int
  - dataOkładki: Date
}

class DVD {
  - czasTrwaniaMinuty: int
  - reżyser: String
  - język: String
  - dostępneNapisy: boolean
}

class Członek {
  - idCzłonka: String
  - imię: String
  - email: String
  - telefon: String
  - dataZapisu: Date
  + wypożyczElement(element: ElementBiblioteczny): boolean
  + zwróćElement(element: ElementBiblioteczny): boolean
  + uzyskajWypożyczoneElementy(): List
}

class RejestrWypożyczeń {
  - idRejestru: String
  - dataWypożyczenia: Date
  - dataZwrotu: Date
  - dataFaktycznegoZwrotu: Date
  - czyPrzekroczonoTermin(): boolean
  - obliczKara(): double
}

class Kara {
  - idKary: String
  - kwota: double
  - dataWystawienia: Date
  - opłacona: boolean
  + opłaćKara(): void
}

class Bibliotekarz {
  - idPracownika: String
  - wydział: String
  + obsłużWypożyczenie(członek: Członek, element: ElementBiblioteczny): void
  + obsłużZwrot(element: ElementBiblioteczny): void
  + wygenerujRaport(): void
  + zarządzajZapasami(): void
}

' Relacje dziedziczenia
ElementBiblioteczny <|-- Książka
ElementBiblioteczny <|-- Czasopismo
ElementBiblioteczny <|-- DVD
Książka <|-- EBook
Książka <|-- KsiążkaDrukowana 

' Kompozycja i agregacja 

Biblioteka "1" -- "wiele" Członek : posiada >
Biblioteka "1" -- "wiele" ElementBiblioteczny : zawiera >
Biblioteka "1" -- "wiele" Bibliotekarz : zatrudnia >

Członek "1" -- "wiele" RejestrWypożyczeń : posiada >
RejestrWypożyczeń "1" -- "1..*" ElementBiblioteczny : odnosi się do >
RejestrWypożyczeń "1" -- "0..*" Kara : generuje >

' Asocjacja
Bibliotekarz --> RejestrWypożyczeń : zarządza >
Członek --> RejestrWypożyczeń : tworzy >

note top of Biblioteka : Centralny system zarządzającynczłonkami, elementami i wypożyczeniami
note right of ElementBiblioteczny : Abstrakcyjna klasa bazowandla wszystkich materiałów bibliotecznych
@enduml

@startuml
' Tytuł
title Wypłata gotówki z bankomatu - Diagram sekwencji

' Aktorzy i uczestnicy
actor Klient jako K
participant "Bankomat" jako ATM
participant "System bankowy" jako SB
database "Konto klienta" jako DB

' Sekwencja
K -> ATM : Włóż kartę
ATM -> ATM : Odczytaj szczegóły karty
ATM -> K : Poproś o PIN
K -> ATM : Wprowadź PIN
ATM -> SB : Zweryfikuj kartę i PIN
SB -> DB : Sprawdź dane uwierzytelniające
DB --> SB : Wynik weryfikacji

alt Nieprawidłowy PIN
    SB --> ATM : Nieprawidłowy PIN
    ATM -> K : Nieprawidłowy PIN, spróbuj ponownie
    note right: Po 3 nieudanych próbach,nkarta zostaje zatrzymana
else Prawidłowy PIN
    SB --> ATM : Prawidłowy PIN
    ATM -> K : Wyświetl menu główne
    K -> ATM : Wybierz wypłatę
    ATM -> K : Poproś o kwotę
    K -> ATM : Wprowadź kwotę
    ATM -> SB : Sprawdź stan konta i limit
    SB -> DB : Zapytaj o stan konta
    DB --> SB : Aktualny stan konta
    
    alt Niewystarczające środki
        SB --> ATM : Niewystarczający stan konta
        ATM -> K : Transakcja odrzuconan(Wyświetl stan konta)
        K -> ATM : Anuluj transakcję
        ATM -> K : Zwróć kartę
    else Wystarczające środki
        SB --> ATM : Zatwierdzono
        ATM -> ATM : Wypłać gotówkę
        ATM -> K : Wypłać gotówkę
        K -> ATM : Pobierz gotówkę
        ATM -> SB : Potwierdź wypłatę gotówki
        SB -> DB : Obciąż konto i zaloguj transakcję
        DB --> SB : Aktualizacja zakończona
        SB --> ATM : Transakcja zakończona
        ATM -> K : Drukuj paragon
        alt Żądany paragon
            K -> ATM : Pobierz paragon
        else Brak paragonu
            K -> ATM : Odrzuć paragon
        end
        ATM -> K : Zwróć kartę
        K -> ATM : Pobierz kartę
    end
end

ATM -> K : Dziękujemy / Koniec transakcji

@enduml

@startuml SystemZgłoszeńUbezpieczeniowych

start

:Posiadacz polisy składa zgłoszenie;
:Zgłoszenie jest rejestrowane w systemie;

if (Czy polisa jest aktywna i ważna?) then (tak)
  :Przypisz zgłoszenie do rzeczoznawcy;
  :Powiadom rzeczoznawcę o nowym zgłoszeniu;
else (nie)
  :Wyślij odmowę do posiadacza polisy;
  :Zaloguj powód: Polisa nieaktywna/nieważna;
  stop
endif

:Rzeczoznawca przegląda przesłane dokumenty;

if (Czy wszystkie wymagane dokumenty są obecne?) then (tak)
  :Rzeczoznawca inicjuje weryfikację zgłoszenia;
else (nie)
  :Poproś posiadacza polisy o brakujące dokumenty;
  :Czekaj na dodatkowe dokumenty;
  :Sprawdź dokumenty ponownie;
  note right
    System czeka na
    odpowiedź posiadacza polisy
  end note
  -> powrót do "Rzeczoznawca przegląda przesłane dokumenty";
endif

:Rzeczoznawca bada zgłoszenie;
:Skontaktuj się ze świadkami/ekspertami, jeśli to konieczne;
:Oszacuj kwotę szkody/straty;

if (Czy zgłoszenie jest ważne zgodnie z warunkami polisy?) then (tak)
  :Oblicz zatwierdzoną kwotę;
  :Zastosuj udział własny, jeśli dotyczy;
else (nie)
  :Wyślij odmowę z uzasadnieniem;
  :Zaloguj decyzję w systemie;
  stop
endif

:Wygeneruj ofertę ugody;
:Wyślij ofertę ugody do posiadacza polisy;

:Posiadacz polisy przegląda ofertę;

if (Czy posiadacz polisy akceptuje ofertę?) then (tak)
  :Przetwórz płatność;
  :Zaktualizuj status zgłoszenia na "Uregulowane";
  :Wyślij potwierdzenie do posiadacza polisy;
  :Zaloguj szczegóły zamknięcia;
else (nie)
  :Przekaz do rozwiązywania sporów;
  :Negocjuj ugodę;
  :Zaktualizuj ofertę;
  -> powrót do "Wyślij ofertę ugody do posiadacza polisy";
endif

stop

@enduml

@startuml SmokeDetectionSystem

title Diagram stanów - System wykrywania dymu

[*] --> PowerOff

state PowerOff {
    [*] --> NoPower
    NoPower : Urządzenie wyłączone
    NoPower --> PowerOn : Naciśnięto przycisk zasilania
}

state PowerOn {
    [*] --> Standby
    Standby : System gotowy
    Standby --> SelfCheck : Okresowy test samodiagnostyczny (co 24h)
    Standby --> Monitoring : Rozpocznij monitorowanie (czujnik aktywny)
    
    state SelfCheck {
        [*] --> TestingSensors
        TestingSensors --> TestPass : Wszystkie czujniki OK
        TestingSensors --> TestFail : Wykryto błąd czujnika
        TestPass --> Standby : Powrót do stanu czuwania
        TestFail --> ErrorState : Zgłoś błąd
    }
    
    state Monitoring {
        [*] --> NoSmoke
        NoSmoke : Normalna praca
        NoSmoke --> SmokeDetected : Poziom dymu > próg
        NoSmoke --> LowBattery : Niski poziom baterii (bezprzewodowy)
        LowBattery --> NoSmoke : Bateria wymieniona
        
        state SmokeDetected {
            [*] --> InitialAlert
            InitialAlert --> ConfirmedSmoke : Dym utrzymuje się > 5 sek
            InitialAlert --> FalseAlarm : Dym ustępuje < 5 sek FalseAlarm --> NoSmoke : Reset
            ConfirmedSmoke --> AlarmActive
        }
        
        state AlarmActive {
            [*] --> SoundAlarm : Aktywuj syrenę i światła
            SoundAlarm --> SendNotification : Powiadom panel sterujący / aplikację
            SendNotification --> WaitForReset
            WaitForReset --> AlarmActive : Dym nadal obecny
            WaitForReset --> ResetSystem : Naciśnięto przycisk resetu
            ResetSystem --> NoSmoke : System zresetowany
        }
    }
}

state ErrorState {
    [*] --> FaultIndicator : Miganie diody błędu
    FaultIndicator --> PowerOff : Wymagane ręczne przełączenie zasilania
}

PowerOn --> ErrorState : Błąd samodiagnostyki
ErrorState --> PowerOff : Przełączenie zasilania

PowerOff --> [*] : System odłączony / bateria wyjęta

@enduml

@startuml CourierSystem

title System kurierski - Diagram komponentów

' === Komponenty ===
component "Aplikacja klienta" as CustomerApp
component "Aplikacja mobilna kuriera" as CourierApp
component "Panel administracyjny webowy" as AdminWeb

component "Brama API" as ApiGateway

component "Usługa zamówień" as OrderService
component "Usługa dyspozycji" as DispatchService
component "Usługa śledzenia" as TrackingService
component "Usługa płatności" as PaymentService
component "Usługa powiadomień" as NotificationService
component "Usługa użytkowników" as UserService

component "Kolejka wiadomościn(RabbitMQ/Kafka)" as MessageQueue
component "Pamięć podręczna Redis" as RedisCache

database "Baza PostgreSQL" as SQLDB
database "MongoDBn(Logi/Historia śledzenia)" as MongoLogs

' === Interfejsy / Porty ===
CustomerApp --> ApiGateway : "REST / WebSocket"
CourierApp --> ApiGateway : "REST / WebSocket"
AdminWeb --> ApiGateway : "REST"

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

' === Zależności usług ===
OrderService --> DispatchService : "gRPC / REST"
OrderService --> PaymentService
OrderService --> NotificationService
OrderService --> SQLDB : "JDBC"
OrderService --> RedisCache : "Cache"

DispatchService --> MessageQueue : "Publikuj zdarzenia"
DispatchService --> CourierApp : "Push przez bramę API"
DispatchService --> SQLDB

TrackingService --> MessageQueue : "Subskrybuj aktualizacje lokalizacji"
TrackingService --> MongoLogs : "Zapisz historię śledzenia"
TrackingService --> RedisCache : "Pamięć podręczna aktualnej lokalizacji"

PaymentService --> SQLDB
PaymentService --> NotificationService

NotificationService --> MessageQueue : "Konsumuj powiadomienia"
NotificationService --> CustomerApp : "Push przez bramę API"

UserService --> SQLDB
UserService --> RedisCache

' === Notatki ===
note right of OrderService
  Obsługuje tworzenie przesyłek,
  wycenę i status zamówienia
end note

note right of DispatchService
  Dopasowuje zamówienia do kurierów,
   optymalizuje trasy
end note

note bottom of MessageQueue
  Zdarzenia asynchroniczne: order_created,
  location_updated,
  delivery_status_changed
end note

@enduml

@startuml
node "AWS Cloud Route53" jako DNS

node "VPC (10.0.0.0/16)" {
  node "Podsieć publiczna" {
    artifact "NGINX Load Balancer" jako ALB
  }
  
  node "Klasster podsieci prywatnej" {
    node "Instancja EC2 1" {
      component "Node.js API [Pod 1]" jako Pod1
    }
    node "Instancja EC2 2" {
      component "Node.js API [Pod 2]" jako Pod2
    }
  }
  
  node "Podsieć bazodanowa" {
    database "Amazon RDS (Multi-AZ Aurora)" jako Aurora
  }
}

DNS --> ALB : Rozwiązuje ruch
ALB --> Pod1 : Balansowanie round-robin
ALB --> Pod2
Pod1 --> Aurora : Połączenie puli
Pod2 --> Aurora
@enduml

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

title Przykład Archimate - Przeglądarka internetowa

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

Grouping(business, "Biznes"){
  Business_Object(businessObject, "Obiekt biznesowy")
  Business_Process(someBusinessProcess,"Pewien proces biznesowy")
  Business_Service(itSupportService, "Wsparcie IT dla biznesu (Usługa aplikacyjna)")
}

Grouping(application, "Aplikacja"){
  Application_DataObject(dataObject, "Dane strony internetowej n 'w locie'")
  Application_Function(webpageBehaviour, "Zachowanie strony internetowej")
  Application_Component(ActivePartWebPage, "Aktywna część strony internetowej n 'w locie'")
}

Grouping(technology, "Technologia"){
  Technology_Artifact(inMemoryItem,"w pamięci / 'w locie' html/javascript")
  Technology_Service(internetBrowser, "Przeglądarka internetowa ogólna i wtyczka")
  Technology_Service(internetBrowserPlugin, "Pewna wtyczka przeglądarki internetowej")
  Technology_Service(webServer, "Pewny serwer WWW")
}


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 "Klient" jako klient {
  * 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" jako film {
  * movie_id : UUID <>
  --
  * title : VARCHAR(200)
  * description : TEXT
  * duration_minutes : INT
  * genre : VARCHAR(50)
  * release_date : DATE
  * rating : VARCHAR(10)
}

entity "Teatr" jako teatr {
  * theater_id : UUID <>
  --
  * theater_name : VARCHAR(100)
  * total_seats : INT
  * seat_layout : JSON
}

entity "Występ" jako wystep {
  * 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 "Miejsce" jako miejsce {
  * seat_id : UUID <>
  --
  * theater_id : UUID <>
  * row_label : CHAR(2)
  * seat_number : INT
  * seat_type : VARCHAR(20)
  * is_accessible : BOOLEAN
}

entity "Rezerwacja" jako rezerwacja {
  * 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 "RezerwacjaMiejsce" jako rezerwacja_miejsce {
  * booking_id : UUID <<FK,PK>>
  * seat_id : UUID <<FK,PK>>
  --
  * ticket_price : DECIMAL(10,2)
  * discount_applied : DECIMAL(10,2)
}

entity "Płatność" jako platnosc {
  * 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 "Opinia" jako opinia {
  * review_id : UUID <>
  --
  * customer_id : UUID <>
  * movie_id : UUID <>
  * rating : INT
  * comment : TEXT
  * review_date : TIMESTAMP
}

' Relacje
klient ||--o{ rezerwacja : "składa"
film ||--o{ wystep : "planowany jako"
teatr ||--o{ wystep : "organizuje"
wystep ||--o{ rezerwacja : "ma"
rezerwacja ||--|{ rezerwacja_miejsce : "zawiera"
miejsce ||--o{ rezerwacja_miejsce : "przypisane do"
rezerwacja ||--|| platnosc : "ma"
klient ||--o{ opinia : "pisze"
film ||--o{ opinia : "otrzymuje"

note right of rezerwacja : Status: PENDING, CONFIRMED, CANCELLED, EXPIRED
note left of miejsce : seat_type: REGULAR, VIP, COUPLES
note right of platnosc : payment_status: PENDING, SUCCESS, FAILED, REFUNDED

@enduml

flowchart TD
    A[Przypadek złego samopoczucia lub potrzeba porady medycznej] --> B{Czy to nagły wypadek?}

    B -->|Tak| C[Zadzwoń na numer alarmowy lub udaj się na SOR]
    B -->|Nie| D[Umów wizytę u lekarza]

    D --> E[Weź udział w wizycie]
    E --> F[Ewaluacja przez lekarza]

    F --> G{Czy postawiono diagnozę?}

    G -->|Tak| H[Plan leczenia]
    G -->|Nie| I[Zamów badania]

    I --> J[Otrzymaj wyniki badań]
    J --> F

    H --> K[Steruj leczeniem]
    K --> L{Czy objawy się poprawiły?}

    L -->|Tak| M[Wyleczenie / Rutynowa kontrola]
    L -->|Nie| N[Wróć do lekarza]
    N --> F

graph UndirectedSpanningTree {
    fontname="Helvetica,Arial,sans-serif"
    label="Topologia sieci mesh centrum danych infrastruktura szkieletowa"
    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=" Łącze trunkowe", weight=5]
    SwitchAlpha -- Node1
    SwitchAlpha -- Node2
    SwitchBeta -- Node3
    SwitchBeta -- Node4
    Node1 -- Node2 [style=dashed, color="#cbd5e1", label=" Połączenie failover"]
}