---
# System prepended metadata

title: Haptiplan UML
tags: [UML, Projekt Haptiplan]

---

# Haptiplan - UML Diagramme

**Autoren:** 
NM, HB, OK, RM (Ansprechpartner Rico Meiner)

**Lizenz:** 
[CC-BY-SA](https://creativecommons.org/licenses/by-sa/4.0/deed.de)

:::spoiler Inhaltsverzeichnis
[toc]
:::

## Frontend - Anwendungsfälle Spieler

### Akteure im Unternehmensplanspiel

```plantuml
skinparam packageStyle rectangle

package Akteure {
    actor User as U
    actor Gamemaster as S
    actor Admin as A
}
    actor Backend as B
```

```plantuml
left to right direction
skinparam packageStyle rectangle

package Rollen {
    actor User as U
    actor Gamemaster as G
    actor Admin as A
}

package Unternehmensplanspiel {
    usecase "Entscheidungen eingeben" as UC1
    usecase "Entscheidungen verarbeiten" as UC2
    usecase "Spiel/Spieler verwalten" as UC3    
    usecase "Software administrieren" as UC4
}

:U: --> UC1
:G: --> UC2
:G: --> UC3
:A: --> UC4


UC1 --> :Backend:
UC2 --> :Backend:
UC3 --> :Backend:
UC4 --> :Backend:
```

Das Unternehmensplanspiel bietet den Akteuren folgende Möglichkeiten:

* Use Case 1 Teilnehmer können Entscheidungen eingeben
* Use Case 2 Spielleiter können die eingegebenen Entscheidungen verarbeiten
* Use Case 3 Spielleiter kann Spieler sowie Einstellungen des Spiels verwalten
* Use Case 4 Administrator kann die gesamte Software verwalten

Der Spielleiter kann die Rolle des Spielers einnehmen und die Entscheidungen "überarbeiten".

### Produktion

```plantuml
left to right direction
skinparam packageStyle rectangle

actor Teilnehmer as T
actor Backend as B

rectangle Produktion{
    usecase "Produzierbaremenge eingeben" as UC1
    usecase "Auslastung eingeben" as UC2
    usecase "Überstunden eingeben" as UC3
}

T --> UC1
T --> UC2
T --> UC3

UC1 --> B                      
UC2 --> B
UC3 --> B

note right of B : Verabeitung der Daten
```

### Maschinenverwalten

```plantuml
left to right direction
actor Teilnehmer as T
actor Backend as B

rectangle Maschinenverwalten{
    usecase "Maschinen kaufen" as UC2
    usecase "Maschine löschen" as UC1
    usecase "Maschine updaten" as UC3
}

T -->UC1
T-->UC2
T --> UC3

UC1 --> B
UC2 --> B
UC3 --> B
```

### Rohstoffenbeschaffung

```plantuml
left to right direction
actor Teilnehmer as T
actor Lieferant as L

rectangle Rohstoffenbeschaffung{
    usecase "bestellen" as UC1
}

T -- UC1
UC1 -- L
```

### Login

```plantuml
left to right direction
actor Teilnehmer as T
actor Backend as B

rectangle login{
    usecase "Login" as UC1
    usecase "Authentifizieren" as UC2
    usecase "Login \nwiederherstellen" as UC3
    note "Condition: Login \n    vergessen \nextension point: Login\n    wiederherstellen" as N2
}
T --> UC1

UC1 ..> UC2 :include
N2 .. UC3
UC1 <.. (N2) :extends

UC2 --> B
UC3 --> B
```

Noch verbessern bzw. übersichtlicher machen!

### Kredit

```plantuml
left to right direction
actor Teilnehmer as T
actor Backend as B

rectangle Kredit{
    usecase "Kredit anfragen" as UC1
    usecase "Kredit tilgen" as UC2
}

T --> UC2
T --> UC1
UC1 --> B
UC2 --> B
```

### Wertanlage

```plantuml
left to right direction
actor Teilnehmer as T
actor Backend as B

rectangle Wertanlage{
    usecase "Wertanlage anlegen" as UC1
    usecase "Wertanlage tilgen" as UC2
}

UC2 --> B
UC1 --> B
T --> UC2
T --> UC1
```

### Marketing und Werbung

```plantuml
left to right direction
actor Teilnehmer as T
actor Backend as B

rectangle Marketing_Werbung {
    usecase "Werbebudget (pro Markt) setzen" as UC1
    usecase "Vertriebsmitarbeiter \n(pro Markt) einstellen" as UC2
    usecase "Werbebudget (Aufträge)" as UC3
}

UC1 --> B
T --> UC1

UC2 --> B
T --> UC2

UC3 --> B
T --> UC3
```

Usecase 3 kritisch prüfen! (Werbebudget für Aufträge)

### Forschung und Entwicklung

```plantuml
left to right direction
actor Teilnehmer as T
actor Backend as B

rectangle Forschung {
    usecase "Kompetenzen und Produkte planen" as UC1
    usecase "FuE-Personal einstellen" as UC2
    usecase "FuE-Personal entlassen" as UC3
}

UC1 --> B
T --> UC1

UC2 --> B
T --> UC2

UC3 --> B
T --> UC3
```

### Personal

```plantuml
left to right direction
actor "Teilnehmer" as T
actor "Backend" as B

rectangle Personal {
    usecase "Personal einstellen" as UC1
    usecase "Personal entlassen" as UC2
    usecase "Personal umstationieren" as UC3
    usecase "Personal weiterbilden" as UC4
}

T --> UC1
T --> UC2
T --> UC3
T --> UC4

UC1 --> B
UC2 --> B
UC3 --> B
UC4 --> B
```

### Grundstücke

```plantuml
left to right direction
actor Teilnehmer as T
actor Backend as B

rectangle Grundstücke {
    usecase "Grundstück kaufen" as UC1
    usecase "Grundstück verkaufen" as UC2
    usecase "Grundstück mieten" as UC3
    usecase "Grundstücksmiete\nkündigen" as UC4
}

T --> UC1
T --> UC2
T --> UC3
T --> UC4

UC1 --> B
UC2 --> B
UC3 --> B
UC4 --> B
```

### Gebäude

```plantuml
left to right direction
actor Teilnehmer as T
actor Backend as B

rectangle Gebäude {
    usecase "Gebäude kaufen" as UC1
    usecase "Gebäude verkaufen" as UC2
    usecase "Gebäude mieten" as UC3
    usecase "Gebäudemiete kündigen" as UC4
}

T --> UC1
T --> UC2
T --> UC3
T --> UC4

UC1 --> B
UC2 --> B
UC3 --> B
UC4 --> B
```

### GuV-Rechnung

```plantuml
left to right direction
actor "Teilnehmer" as T
actor "Backend" as B

rectangle GuV-Rechnung{
    usecase "Saldo GuV-Konto\n anzeigen" as UC1
    usecase "auf Konto buchen" as UC3
}

T<--UC1
UC3-->B
UC1<-- B
T-->UC3
```

### Kommunikation

```plantuml
left to right direction
actor Unternehmen as U
actor Spielleiter as S
rectangle Kommunikation{
    usecase "Privatnachricht" as UC1
    usecase "Nachricht an alle" as UC2
    
}

U  <|-- S
U --> UC1
S -->UC2

```

Kommunikation kritisch prüfen.

### Aufträge

```plantuml
left to right direction
actor Kunde as K
actor Unternehmen as U
actor Subunternehmen1 as S1


rectangle Aufträge {
    usecase (Auftrag geben) as UC1 
    usecase (Auftrag nehmen) as UC2
    usecase (Auftrag bearbeiten) as UC3
    usecase (Auftrag weiterleiten) as UC4
    usecase (Eintragen der Arbeitzeit) as UC5
    usecase (Rechnungen erstellen) as UC6
}

K -- UC1
UC1 --> U
UC2 <-- U
UC3 <-- U
UC4 <.. UC3: include
UC4 --> S1
UC5 <-- S1
UC6 ..> UC5: Uses
UC6 <-- U
```

### Aufträge (neu)

```plantuml
left to right direction
actor Kunde as K
actor Unternehmen as U
actor Subunternehmen1 as S1


rectangle Aufträge {
    usecase (Auftrag geben) as UC1 
    usecase (Auftrag bearbeiten) as UC3
    usecase (Auftrag weiterleiten) as UC4
    usecase (Rechnungen erstellen) as UC6
}

K -- UC1
UC1 --> U
UC4 .left.> UC3: extends
UC3 <-left- U
UC4 --> S1
UC6 <-- U
```

## Frontend - Anwendungsfälle Spielleiter

- [x] Teilnehmer verwalten
- [x] Unternehmen verwalten
- [x] Spiel starten
- [x] Spiel beenden

### Runde beenden

```plantuml
left to right direction
actor "Spielleiter" as S
actor "Backend" as B
actor "Unternehmen 1..n" as U

rectangle Runde_beenden {
    usecase "Entscheidung [Runde beenden]" as UC1    
    usecase "Entscheidungen anpassen" as UC2
    usecase "Runde beenden" as UC3
}

UC1 --> B
U --> UC1

UC2 --> UC3

UC3 --> B
S --> UC2

```

### Schlussbilanz

:::danger
noch zu überarbeiten!
:::

```plantuml
left to right direction

rectangle Schlussbilanz{
    usecase "Schlussbilanz\n anzeigen" as UC1
    usecase "Schlussbilanzkonto\n erstellen" as UC2
}
UC1<--:Teilnehmer:
UC2<..UC1: includes
:Backend:-->UC2
```

### Eröffnungsbilanz

:::danger
noch zu überarbeiten!
:::

```plantuml
left to right direction
rectangle Eröffnungsbilanz{
    usecase "Eröffnungsbilanz\n erstellen" as UC1
    usecase "Eröffnungsbilanz\n anzeigen" as UC2
}
:Backend:-->UC1
UC1<..UC2: includes
UC2<--:Teilnehmer:
```

### Entscheidungen

```plantuml
left to right direction
rectangle Entscheidungen{
    usecase "Beschaffen/\nVerkaufen" as UC1
    usecase "Entscheidung \nverwalten" as UC2
    usecase "Produktion \nverwalten" as UC4
    usecase "Aufträge\nannehmen" as UC5
    usecase "Teilaufträge\nunterteilen + abgeben" as UC6
    usecase "Marktforschung\nfördern" as UC7
    usecase "Werbung schalten" as UC8
    usecase "Runde\nabschließen" as UC10
}

:Teilnehmer:-->UC2
:Teilnehmer:-->(UC5)
:Teilnehmer:-->UC1
:Teilnehmer:-->(UC4)
:Teilnehmer:-->(UC7)
:Teilnehmer:-->(UC8)
:Teilnehmer:-->(UC10)
(UC5)<..(UC6): extends
(UC10)-->:Backend:
UC2-->:Backend:
```

Alle Entscheidung in einem Use Case Diagramm oder jede Entscheidung einzeln.

### Teilnehmer

```plantuml
left to right direction
actor "Spielleiter" as S
actor "Backend" as B

rectangle "Teilnehmer verwalten"{
    usecase "Teilnehmer erstellen" as UC1
    usecase "Teilnehmer löschen" as UC2
    usecase "Teilnehmer\nName bearbeiten" as UC3
}

S --> UC1
S --> UC2
S --> UC3

UC1 --> B
UC2 --> B
UC3 --> B
```

### Unternehmen

```plantuml
left to right direction
actor "Spielleiter" as S
actor "Backend" as B

rectangle "Unternehmen verwalten"{
    usecase "Unternehmen erstellen" as UC1
    usecase "Unternehmen löschen" as UC2
    usecase "Teilnehmer hinzufügen" as UC3
    usecase "Teilnehmer entfernen" as UC4
}

S --> UC1
S --> UC2
S --> UC3
S --> UC4

UC1 --> B
UC2 --> B
UC3 --> B
UC4 --> B
```

### Spielstart

```plantuml
left to right direction
actor "Spielleiter" as S
actor "Backend" as B

rectangle "Spiel starten"{
    usecase "Spieler erstellen" as UC1
    usecase "Unternehmen erstellen" as UC2
    usecase "Spielern ein\nUnternehmen zuweisen" as UC3
    usecase "Anfangsbedingungen setzten" as UC4
}

S --> UC1
S --> UC2
S --> UC3
S --> UC4

UC1 --> B
UC2 --> B
UC3 --> B
UC4 --> B
```

### Spielende

```plantuml
left to right direction
actor "Spielleiter" as S
actor "Backend" as B

rectangle "Spiel beenden"{
    usecase "Entscheidungen/Ergebnisse\nexportieren" as UC1
    usecase "Spiel (Unternehmen, Spieler)\nlöschen" as UC2
}

S --> UC1
S --> UC2

UC1 --> B
UC2 --> B
```

## Backend - Anwendungsfälle, Use Case

- [ ] Eventuell Datenbank und Backend Usecase
- [ ] Kommunikation zwischen Backend und Frontend

## Klassendiagramm

Dokumentation [Klassendiagramme](https://plantuml.com/de/class-diagram)

### FrontController

```plantuml
skinparam style strictuml

class Request { 
    - requestedPage: String
    + setRequestedPage()
    + getRequestedPage(): String
}

class Router {
    - machinecontroller: MachineController
    + Router()
    + callController($requestedPage, $method)
}

class MachineController {
    + Model
    + views
    + addMachine()
    + updateMachine()
    + deleteMachine()
    + displayMachine()
    + createMachine()
    + editMachine()
    + deleteForm()
}

class Model {
     State Data
}

class MachineType {
    - machine_id: int
    - machine_name: String
    - machine_capacity: int
    - machine_price: double
    - machine_duration: int 
    - machine_period : int
    + setId(id: int)
    + getId():int
    + setNam(name: String)
    + getName(): String
    + setKapazitaet(kapazitaet: int)
    + getKapazitaet():int
    + setPreis(preis: double)
    + getPreis(): double
    + setLaufzeit(laufzeit: int)
    + getLaufzeit(): int
    + setPeriode(periode: int)
    + getPeriode():int
}

Request -left--> Router
Router --> MachineController
MachineController --> Model
MachineController --> View
View --> Model
View --> Router
```

```plantuml
skinparam style strictuml

abstract class Decision {
    - decision_id:int
    - timestamp: datetime
    - company_id: int
    - user_id: int
    - period_id: int
}

class Machine implements Decision {
    - position
    - decision_type
    - machine_type_id
}

class Building implements Decision {
    - position
    - decision_type  
    - building_type_id
}

class EmployeeProduction implements Decision {    
    - decision_type
    - employee_id
}

class Raw implements Decision {
    - postition
    - decision_type  
    - product_type_id
}

class Credit implements Decision {
    - credit_amount
    - decision_type
    - credit_type_id
}

note right of Decision
    Sets for decision_type
    - Machine {buy, sell, replace}
    - Building {buy, sell, rent}
    - Employee {hire, fire, educate}
    - Raw {buy, sell, }
    - Credit {take, repay}
end note
```

### Rechnungswesen

```plantuml
skinparam style strictuml

class Account {
    - company_id
    - period_id
    - account_id
    - account_number
    - account_type
    - account_level
    - account_name
}

note bottom of Account    
    number: Kontonummer
    type: {Aktiv, Passiv, Aufwand, Ertrag}
    level: {AV, UV, EK, FK}
end note

class Balance{
    - asset_accounts[]
    - liability_accounts[]
}

class ProfitLoss {
    - profit_accounts[]
    - loss_accounts[]
}

class Account_entry{
    - account_entry_id
    - account_number_debit
    - account_number_credit
    - account_entry_value
}

Account *--left Account_entry
Balance o-- Account
ProfitLoss o-- Account
```

## Sequenzdiagramme

### Router

```plantuml
actor Client

Client ++
Client -> index ++ : HTTP request

index -> Router ++ : CallController($requested_page, $method)

Router -> MachineController ++ : addMachine()

MachineController -> Model ++ : createMachine()
Model --> MachineController : machine
deactivate Model

MachineController -> View ++ : rednerView(machine):Response
View --> MachineController : viewResponse
deactivate View

MachineController --> Router : viewResponse
deactivate MachineController

Router --> index : Response
deactivate Router

index -> ResponseHandler ++ : sendResponse(response)
ResponseHandler --> index : HTTP response
deactivate ResponseHandler

index --> Client : HTTP response
deactivate index

deactivate Client
```

## Json

### Maschine

:::spoiler Beispiele
noch zu überarbeiten!

```plantuml
@startjson
{
  "name": "Holzklopper",
  "Kapazität": "15",
  "Preis":"75000" ,
  "id": 1,
  "Laufzeit" : 3,
  "Periode" : 4, 
  "TypID" :     
      {
          "Funktion" : "Säge"
      }
}
@endjson
```

### Stifte(Beispiel)

Auftrag 100.000 Stifte

```plantuml
@startjson
{
  "Stiftmine": 100.000,
  "Holzform": 100.000,
  "Radiergummi" : 100.000,
  "Preis":"2 Euro",
  "Teilaufträge" :
    [
        {
          "Typ" : "Holzverarbeiter",
          "Stück": "100.000 Formen",
          "Teilauftrag" : {
          "Typ" : "Holzlieferant",
          "Stück" : "5000"
          }
        }
    ]  
  
}
@endjson
```

### Pinsel

```plantuml
@startjson
{
  "Borsten": {
        "Typ": "Hof",
      "Stück": ""
    },
  "Zwinge": 75000,
  "Stiel": {
      "Typ": "Säge",
        "Stück": "75000"
    },
  "Kleber": "",
  "Preis" : "1€ pro Stück" 
}
@endjson
```

### Regal

Auftrag 500 Regale

```plantuml
@startjson
{
    "Auftrag" : "Regale",
    "Menge" : 500,
    "UVP" : "200 Euro pro Regal",
    "Aufgaben" : ["montage", "kleben"],
    "Vorprodukt" : 
    [ 
        {
            "Auftrag" : "Brett lackiert dick",
            "Menge" : 2000,
            "Aufgaben" : ["fräsen", "lackieren"],
            "Vorprodukt" : "Brett"
        },
        { 
            "Auftrag" : "Brett  dick",
            "Menge" : 1500,
            "Aufgaben" : ["fräsen", "lackieren"],
            "Vorprodukt" : "Brett"
        },
        {
            "Auftrag" : "Dübel",
            "Menge" : 10000,
            "Aufgaben" : ["sägen", "fräsen"],
            "Vorprodukt" : "Holz"
        }
    ]
}
@endjson
```

:::

## Datenbanken

:::spoiler SQL (Erzeugen der DB)

```sql=
create database haptiplan;
use haptiplan;

CREATE TABLE machinetype (
    machine_id INT PRIMARY KEY AUTO_INCREMENT,
    machine_name VARCHAR(255),
    machine_capacity INT,
    machine_price FLOAT,
    machine_duration INT,
    machine_period INT
);

INSERT INTO machinetype (machine_id, machine_name, machine_capacity, machine_price, machine_duration, machine_period)
VALUES
(1, 'MachineA', 100, 1500.50, 24, 12),
(2, 'MachineB', 75, 1200.75, 18, 8),
(3, 'MachineC', 120, 2000.25, 36, 24),
(4, 'MachineD', 90, 1800.00, 30, 16),
(5, 'MachineE', 150, 2500.80, 48, 20); 

CREATE TABLE credit (
    credit_id INT AUTO_INCREMENT PRIMARY KEY,
    credit_amount int
);

CREATE TABLE building (
    building_id INT AUTO_INCREMENT PRIMARY KEY,
    building_name VARCHAR(255),
    building_position INT,
    building_price INT,
    building_type_id INT

);

CREATE TABLE player_building (
    player_id INT,
    building_id INT,
    FOREIGN KEY (building_id) REFERENCES building(building_id),
    FOREIGN KEY (building_type_id) REFERENCES building(building_type_id),
    PRIMARY KEY (player_id, building_id)
);

CREATE TABLE employeetype (
    employee_id INT AUTO-INCREMENT PRIMARY KEY,
    employee_name VARCHAR(255),
    employee_salary INT
);

```

:::
