# 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
);
```
:::
Sign in with Wallet
Connect another wallet