Jan-Marlon Leibl
be9dcc41a8
All checks were successful
CI / Get Changed Files (pull_request) Successful in 11s
CI / eslint (pull_request) Has been skipped
CI / oxlint (pull_request) Has been skipped
CI / prettier (pull_request) Has been skipped
CI / test-build (pull_request) Has been skipped
Claude PR Review / claude-code (pull_request) Successful in 26s
Pull Request Labeler / labeler (pull_request_target) Successful in 6s
CI / Backend Tests (pull_request) Has been skipped
Label PRs based on size / Check PR size (pull_request) Successful in 12s
CI / Checkstyle Main (pull_request) Has been skipped
CI / Docker frontend validation (pull_request) Has been skipped
CI / Docker backend validation (pull_request) Has been skipped
1589 lines
No EOL
54 KiB
TeX
1589 lines
No EOL
54 KiB
TeX
\documentclass[12pt,a4paper]{report}
|
|
\usepackage[ngerman]{babel}
|
|
\usepackage[utf8]{inputenc}
|
|
\usepackage[T1]{fontenc}
|
|
\usepackage{geometry}
|
|
\usepackage{graphicx}
|
|
\usepackage{hyperref}
|
|
\usepackage{listings}
|
|
\usepackage{xcolor}
|
|
\usepackage{float}
|
|
\usepackage{caption}
|
|
\usepackage{subcaption}
|
|
\usepackage{longtable}
|
|
\usepackage{pifont}
|
|
\usepackage{booktabs}
|
|
\usepackage{fancyhdr}
|
|
\usepackage{tocloft}
|
|
\usepackage{dirtree}
|
|
\usepackage{enumitem}
|
|
\usepackage{tikz}
|
|
\usetikzlibrary{arrows.meta, positioning}
|
|
\usepackage{pdflscape}
|
|
\usepackage{afterpage}
|
|
\usepackage{needspace}
|
|
|
|
% Seitenränder
|
|
\geometry{
|
|
left=2.5cm,
|
|
right=2.5cm,
|
|
top=2.5cm,
|
|
bottom=2.5cm
|
|
}
|
|
|
|
% Kopf- und Fußzeile
|
|
\pagestyle{fancy}
|
|
\fancyhf{}
|
|
\fancyhead[L]{\leftmark}
|
|
\fancyhead[R]{\thepage}
|
|
\renewcommand{\headrulewidth}{0.4pt}
|
|
|
|
% Code-Highlighting
|
|
\definecolor{codegreen}{rgb}{0,0.6,0}
|
|
\definecolor{codegray}{rgb}{0.5,0.5,0.5}
|
|
\definecolor{codepurple}{rgb}{0.58,0,0.82}
|
|
\definecolor{backcolour}{rgb}{0.95,0.95,0.92}
|
|
|
|
\lstdefinestyle{mystyle}{
|
|
backgroundcolor=\color{backcolour},
|
|
commentstyle=\color{codegreen},
|
|
keywordstyle=\color{magenta},
|
|
numberstyle=\tiny\color{codegray},
|
|
stringstyle=\color{codepurple},
|
|
basicstyle=\ttfamily\footnotesize,
|
|
breakatwhitespace=false,
|
|
breaklines=true,
|
|
captionpos=b,
|
|
keepspaces=true,
|
|
numbers=left,
|
|
numbersep=5pt,
|
|
showspaces=false,
|
|
showstringspaces=false,
|
|
showtabs=false,
|
|
tabsize=2
|
|
}
|
|
|
|
\lstset{style=mystyle}
|
|
|
|
% Hyperref-Einstellungen
|
|
\hypersetup{
|
|
colorlinks=true,
|
|
linkcolor=black,
|
|
filecolor=magenta,
|
|
urlcolor=blue,
|
|
}
|
|
|
|
\begin{document}
|
|
|
|
% Titelseite
|
|
\begin{titlepage}
|
|
\centering
|
|
\vspace*{2cm}
|
|
|
|
{\Huge\bfseries Casino Gaming Platform\par}
|
|
\vspace{1.5cm}
|
|
{\Large\itshape Projektdokumentation für die IHK-Abschlussprüfung\par}
|
|
\vspace{2cm}
|
|
{\large\bfseries Fachinformatiker für Anwendungsentwicklung\par}
|
|
|
|
\vfill
|
|
|
|
{\large
|
|
\begin{tabular}{ll}
|
|
\textbf{Prüfling:} & [Name des Prüflings] \\
|
|
\textbf{Prüflingsnummer:} & [Prüflingsnummer] \\
|
|
\textbf{Ausbildungsbetrieb:} & Hitec GmbH \\
|
|
\textbf{Projektbetreuer:} & [Betreuer] \\
|
|
\textbf{Projektdauer:} & 70 Stunden \\
|
|
\textbf{Abgabedatum:} & \today \\
|
|
\end{tabular}
|
|
\par}
|
|
|
|
\vfill
|
|
\end{titlepage}
|
|
|
|
% Inhaltsverzeichnis
|
|
\pagenumbering{roman}
|
|
\tableofcontents
|
|
\cleardoublepage
|
|
\pagenumbering{arabic}
|
|
|
|
% Hauptinhalt
|
|
\chapter{Beschreibung}
|
|
|
|
\section{Umfeld}
|
|
Das Projekt wurde im Rahmen der Abschlussprüfung zum Fachinformatiker für Anwendungsentwicklung bei der Hitec GmbH entwickelt.
|
|
|
|
\subsection{Produktportfolio der Hitec GmbH}
|
|
Die Hitec GmbH ist ein innovatives IT-Unternehmen, das sich auf die Entwicklung moderner Webanwendungen und digitaler Lösungen spezialisiert hat. Das Unternehmen deckt ein breites Spektrum an Technologien ab, von klassischen Enterprise-Anwendungen bis hin zu modernen Cloud-nativen Lösungen.
|
|
|
|
\subsection{Weg zur Produktidee}
|
|
Die Casino Gaming Platform entstand als LF08 Projekt mit dem Ziel, eine vollständige Online-Casino-Plattform zu entwickeln. Die Produktidee basiert auf:
|
|
|
|
\begin{itemize}
|
|
\item \textbf{Gamification-Trend:} Wachsende Nachfrage nach Online-Gaming-Plattformen
|
|
\item \textbf{Technologie-Demonstration:} Showcase moderner Full-Stack-Entwicklung (Angular 20 + Spring Boot 3.5)
|
|
\item \textbf{Bildungsziel:} Praktische Anwendung von Enterprise-Patterns und modernen Web-Technologien
|
|
\item \textbf{Marktforschung:} Integration aktueller Standards (OAuth2, Stripe, responsive Design)
|
|
\end{itemize}
|
|
|
|
\section{Ziel}
|
|
Das Ziel dieses Projektes ist die Entwicklung eines Online-Casinos, welches verschiedene Spiele anbietet, um mit Echtgeld zu wetten. Dabei verzichten wir auf eine Auszahlungsmöglichkeit, um Einnahmen zu steigern und rechtliche Komplexitäten zu vermeiden.
|
|
|
|
Die Plattform soll es Benutzern ermöglichen:
|
|
\begin{itemize}
|
|
\item Mit virtueller Währung verschiedene Casino-Spiele zu spielen
|
|
\item Sichere Einzahlungen über moderne Payment-Provider zu tätigen
|
|
\item Eine intuitive und responsive Benutzeroberfläche zu nutzen
|
|
\item Transparente Transaktionshistorien einzusehen
|
|
\end{itemize}
|
|
|
|
\chapter{Vorbereitung}
|
|
|
|
\section{Ist-Analyse}
|
|
Detaillierte Beschreibung des Problems oder der Marktlücke, welche unser Produkt lösen/füllen soll.
|
|
|
|
\subsection{Identifizierte Marktlücken}
|
|
\begin{enumerate}
|
|
\item \textbf{Technische Komplexität:} Viele Casino-Plattformen nutzen veraltete Technologien
|
|
\item \textbf{Benutzerfreundlichkeit:} Schlechte mobile Erfahrung und komplexe Registrierung
|
|
\item \textbf{Sicherheitsstandards:} Mangelnde OAuth2-Integration und moderne Authentifizierung
|
|
\item \textbf{Payment-Integration:} Umständliche Einzahlungsprozesse ohne moderne Payment-APIs
|
|
\item \textbf{Transparenz:} Fehlende Nachvollziehbarkeit von Transaktionen und Spielverläufen
|
|
\end{enumerate}
|
|
|
|
\section{Soll-Analyse}
|
|
\subsection{Spieleportfolio}
|
|
\begin{itemize}
|
|
\item Blackjack (mit Split/Double Down)
|
|
\item Slots mit konfigurierbarer RTP
|
|
\item Dice, Coinflip, Lootboxes
|
|
\item Geplant: Poker, Plinko
|
|
\end{itemize}
|
|
|
|
\subsection{Benutzerverwaltung}
|
|
\begin{itemize}
|
|
\item Multi-Provider OAuth2 (GitHub, Google)
|
|
\item JWT-basierte Authentifizierung
|
|
\item E-Mail-Verifizierung und Passwort-Reset
|
|
\end{itemize}
|
|
|
|
\subsection{Finanzsystem}
|
|
\begin{itemize}
|
|
\item Stripe-Integration für Einzahlungen
|
|
\item Virtuelle Währung mit Präzisions-Tracking (BigDecimal)
|
|
\item Transaktionshistorie mit Status-Tracking
|
|
\end{itemize}
|
|
|
|
\subsection{Technische Anforderungen}
|
|
\begin{itemize}
|
|
\item Responsive Design (Mobile-First)
|
|
\item Real-time Updates ohne Page-Reload
|
|
\item Sichere API-Kommunikation
|
|
\end{itemize}
|
|
|
|
\chapter{Durchführung}
|
|
|
|
\section{Vorgehensweise}
|
|
Für die Projektdurchführung wurde Scrum als Vorgehensmodell gewählt. Dadurch wird am Anfang des Projektes und eines Sprints festgelegt, was gemacht werden soll, und jeder ist auf dem gleichen Wissensstand. Des Weiteren gibt es tägliche Updates vom Fortschritt, Probleme können schnell erkannt und angesprochen werden. Dazu kann man auch neue Anforderungen flexibel mit einbringen.
|
|
|
|
\subsection{Verwendete Tools und Methoden}
|
|
\begin{itemize}
|
|
\item \textbf{Scrum:} Agile Projektmanagement-Methodik
|
|
\item \textbf{Jira:} Ticketing und Sprint-Planning
|
|
\item \textbf{Git:} Versionskontrolle mit Feature-Branch-Workflow
|
|
\item \textbf{CI/CD:} Automatisierte Build- und Deployment-Pipelines
|
|
\end{itemize}
|
|
|
|
\section{Umsetzung}
|
|
|
|
\subsection{Art der Datenhaltung}
|
|
PostgreSQL mit JPA/Hibernate ORM wurde als Datenbanklösung gewählt:
|
|
\begin{itemize}
|
|
\item \textbf{Verbindung:} JDBC mit Connection Pooling (HikariCP)
|
|
\item \textbf{Schema:} Domain-driven Design mit klarer Trennung
|
|
\item \textbf{Transaktionen:} @Transactional Boundaries für Konsistenz
|
|
\item \textbf{Migration:} Flyway für Datenbank-Versionierung
|
|
\end{itemize}
|
|
|
|
\subsection{Klassenmodell}
|
|
|
|
\subsubsection{Backend (Java)}
|
|
\dirtree{%
|
|
.1 Entity Layer.
|
|
.2 UserEntity.
|
|
.2 BlackJackGameEntity.
|
|
.2 TransactionEntity.
|
|
.2 LootBoxEntity.
|
|
.1 Repository Layer.
|
|
.2 Spring Data JPA.
|
|
.1 Service Layer.
|
|
.2 Business Logic.
|
|
.3 BlackJackService.
|
|
.3 BalanceService.
|
|
.3 DepositService.
|
|
.1 Controller Layer.
|
|
.2 REST APIs.
|
|
.1 Security Layer.
|
|
.2 JWT + OAuth2.
|
|
}
|
|
|
|
\subsubsection{Frontend (TypeScript)}
|
|
\dirtree{%
|
|
.1 Models.
|
|
.2 User interfaces.
|
|
.2 Game interfaces.
|
|
.2 Transaction interfaces.
|
|
.1 Services.
|
|
.2 HTTP client wrappers.
|
|
.1 Components.
|
|
.2 Angular standalone components.
|
|
.1 Guards.
|
|
.2 Route protection.
|
|
}
|
|
|
|
\subsection{Design Pattern}
|
|
\begin{enumerate}
|
|
\item \textbf{MVC Pattern:} Controller → Service → Repository
|
|
\item \textbf{Repository Pattern:} Datenzugriff-Abstraktion
|
|
\item \textbf{DTO Pattern:} API-Grenze mit Datenkapselung
|
|
\item \textbf{Strategy Pattern:} OAuth2-Provider (GitHub/Google)
|
|
\item \textbf{Observer Pattern:} Angular Signals für reaktive Updates
|
|
\end{enumerate}
|
|
|
|
\subsection{Zusammenarbeit der einzelnen Module}
|
|
|
|
\subsubsection{Backend-Architektur}
|
|
\begin{verbatim}
|
|
Security Layer ← JWT Filter ← Controllers ← Services ← Repositories ← Database
|
|
↓
|
|
OAuth2 Integration (GitHub/Google)
|
|
↓
|
|
Payment Integration (Stripe Webhooks)
|
|
\end{verbatim}
|
|
|
|
\subsubsection{Frontend-Architektur}
|
|
\begin{verbatim}
|
|
Guards → Components → Services → HTTP Interceptors → Backend APIs
|
|
↓
|
|
Angular Router → Lazy Loading → Feature Modules
|
|
\end{verbatim}
|
|
|
|
\subsection{Systemarchitektur nach C4-Modell}
|
|
Die Casino Gaming Platform basiert auf einer modernen, schichtbasierten Architektur mit klarer Trennung zwischen Frontend und Backend. Die Darstellung erfolgt mittels des C4-Architekturmodells (Context, Container, Component, Code), welches eine hierarchische Sichtweise auf die Softwarearchitektur ermöglicht.
|
|
|
|
\clearpage
|
|
\needspace{8\baselineskip}
|
|
\subsubsection{Ebene 1: Systemkontext-Diagramm}
|
|
Das Systemkontext-Diagramm stellt die Casino Gaming Platform in ihrem geschäftlichen Umfeld dar und zeigt die Beziehungen zu externen Akteuren und Systemen. Es verdeutlicht, wer das System nutzt und mit welchen externen Systemen es interagiert.
|
|
|
|
\begin{landscape}
|
|
\begin{tikzpicture}[
|
|
person/.style={rectangle, draw=blue!80, fill=blue!15, minimum width=3cm, minimum height=1.8cm, align=center, rounded corners=3pt, thick},
|
|
system/.style={rectangle, draw=blue!80, fill=blue!60, minimum width=5cm, minimum height=2.5cm, align=center, text=white, rounded corners=5pt, thick},
|
|
external/.style={rectangle, draw=gray!80, fill=gray!20, minimum width=3.5cm, minimum height=1.8cm, align=center, rounded corners=3pt, thick},
|
|
->, >=Stealth, node distance=4cm, thick
|
|
]
|
|
|
|
% Akteure
|
|
\node[person] (player) at (-8, 3) {\textbf{Casino-Spieler}\\Nutzt die Plattform\\für Online-Gaming};
|
|
\node[person] (admin) at (-8, -3) {\textbf{System-Administrator}\\Verwaltet Plattform\\und Benutzer};
|
|
|
|
% Hauptsystem
|
|
\node[system] (casino) at (0, 0) {\textbf{Casino Gaming Platform}\\Bietet Online-Casino-Spiele\\mit virtueller Währung und\\Zahlungsabwicklung};
|
|
|
|
% Externe Systeme
|
|
\node[external] (stripe) at (8, 3) {\textbf{Stripe API}\\Zahlungsabwicklung};
|
|
\node[external] (email) at (8, 0) {\textbf{E-Mail-Service}\\Verifizierung \&\\Benachrichtigungen};
|
|
\node[external] (oauth) at (8, -3) {\textbf{OAuth-Provider}\\GitHub, Google};
|
|
|
|
% Beziehungen
|
|
\draw (player) -- (casino) node[midway, above] {Spielt Spiele, tätigt Einzahlungen};
|
|
\draw (admin) -- (casino) node[midway, below] {Administriert System};
|
|
\draw (casino) -- (stripe) node[midway, above] {Verarbeitet Zahlungen};
|
|
\draw (casino) -- (email) node[midway, above] {Sendet E-Mails};
|
|
\draw (casino) -- (oauth) node[midway, below] {Authentifiziert Benutzer};
|
|
|
|
\end{tikzpicture}
|
|
\end{landscape}
|
|
|
|
\clearpage
|
|
\needspace{8\baselineskip}
|
|
\subsubsection{Ebene 2: Container-Diagramm}
|
|
Das Container-Diagramm zeigt die High-Level-Architektur der Software und stellt die verschiedenen ausführbaren Einheiten (Container) sowie deren Kommunikation dar. Jeder Container repräsentiert eine separate deploybare/ausführbare Einheit wie eine Webanwendung, Datenbank oder Microservice.
|
|
|
|
\begin{landscape}
|
|
\begin{tikzpicture}[
|
|
webapp/.style={rectangle, draw=blue!80, fill=blue!25, minimum width=4cm, minimum height=2.5cm, align=center, rounded corners=4pt, thick},
|
|
api/.style={rectangle, draw=green!80, fill=green!25, minimum width=4cm, minimum height=2.5cm, align=center, rounded corners=4pt, thick},
|
|
database/.style={rectangle, draw=red!80, fill=red!25, minimum width=3.5cm, minimum height=2.2cm, align=center, rounded corners=4pt, thick},
|
|
external/.style={rectangle, draw=gray!80, fill=gray!20, minimum width=3.2cm, minimum height=1.8cm, align=center, rounded corners=3pt, thick},
|
|
->, >=Stealth, node distance=4cm, thick
|
|
]
|
|
|
|
% Akteur
|
|
\node[webapp] (person) at (-10, 5) {\textbf{Casino-Spieler}\\Person\\Nutzt Webbrowser\\oder Mobile App};
|
|
|
|
% Frontend-Container
|
|
\node[webapp] (frontend) at (-5, 1) {\textbf{Webanwendung}\\Angular 20, TypeScript\\Liefert statische Inhalte\\und Casino-Spiele-UI};
|
|
|
|
% Backend-Container
|
|
\node[api] (backend) at (2, 1) {\textbf{API-Anwendung}\\Spring Boot, Java\\Stellt Spiellogik,\\Benutzerverwaltung und\\Geschäftsregeln bereit};
|
|
|
|
% Datenbank
|
|
\node[database] (database) at (2, -4) {\textbf{Datenbank}\\PostgreSQL\\Speichert Benutzerkonten,\\Spielhistorie und\\Transaktionen};
|
|
|
|
% Externe Systeme
|
|
\node[external] (stripe) at (9, 4) {\textbf{Stripe API}\\Zahlungssystem};
|
|
\node[external] (email) at (9, 1) {\textbf{Mailpit}\\E-Mail-Service};
|
|
\node[external] (oauth) at (9, -2) {\textbf{OAuth-Provider}\\Authentifizierungsdienste};
|
|
|
|
% Beziehungen
|
|
\draw (person) -- (frontend) node[midway, above] {HTTPS};
|
|
\draw (frontend) -- (backend) node[midway, above] {REST API\\JSON/HTTPS};
|
|
\draw (backend) -- (database) node[midway, right] {JDBC\\SQL};
|
|
\draw (backend) -- (stripe) node[midway, above] {HTTPS\\Webhooks};
|
|
\draw (backend) -- (email) node[midway, right] {SMTP};
|
|
\draw (backend) -- (oauth) node[midway, below] {OAuth2\\HTTPS};
|
|
|
|
\end{tikzpicture}
|
|
\end{landscape}
|
|
|
|
\clearpage
|
|
\needspace{8\baselineskip}
|
|
\subsubsection{Ebene 3: Komponenten-Diagramm - Backend API}
|
|
Das Komponenten-Diagramm zeigt die interne Struktur des Backend API-Containers und stellt die wichtigsten Softwarekomponenten sowie deren Abhängigkeiten dar. Es verdeutlicht die Architektur nach dem MVC-Pattern mit Controller-, Service- und Repository-Schichten.
|
|
|
|
\begin{landscape}
|
|
\begin{tikzpicture}[
|
|
component/.style={rectangle, draw=yellow!80, fill=yellow!15, minimum width=3.2cm, minimum height=1.8cm, align=center, rounded corners=3pt, thick},
|
|
controller/.style={rectangle, draw=blue!80, fill=blue!20, minimum width=3.2cm, minimum height=1.8cm, align=center, rounded corners=3pt, thick},
|
|
service/.style={rectangle, draw=green!80, fill=green!20, minimum width=3.2cm, minimum height=1.6cm, align=center, rounded corners=3pt, thick},
|
|
repository/.style={rectangle, draw=orange!80, fill=orange!20, minimum width=3.2cm, minimum height=1.4cm, align=center, rounded corners=3pt, thick},
|
|
->, >=Stealth, node distance=3cm, thick
|
|
]
|
|
|
|
% Controller (API-Schicht)
|
|
\node[controller] (auth-ctrl) at (-8, 5) {\textbf{Auth Controller}\\Anmeldung, Registrierung,\\OAuth};
|
|
\node[controller] (game-ctrl) at (-3, 5) {\textbf{Spiele-Controller}\\Blackjack, Slots,\\Würfel, etc.};
|
|
\node[controller] (deposit-ctrl) at (2, 5) {\textbf{Einzahlungs-Controller}\\Zahlungs-\\abwicklung};
|
|
\node[controller] (user-ctrl) at (7, 5) {\textbf{Benutzer-Controller}\\Profil-\\verwaltung};
|
|
|
|
% Services (Geschäftslogik-Schicht)
|
|
\node[service] (auth-svc) at (-8, 2.5) {\textbf{Auth Service}\\Authentifizierungs-\\logik};
|
|
\node[service] (game-svc) at (-3, 2.5) {\textbf{Spiele-Services}\\Spiellogik und\\Regeln};
|
|
\node[service] (balance-svc) at (2, 2.5) {\textbf{Guthaben-Service}\\Transaktions-\\verwaltung};
|
|
\node[service] (user-svc) at (7, 2.5) {\textbf{Benutzer-Service}\\Benutzer-\\verwaltung};
|
|
|
|
% Repositories (Datenschicht)
|
|
\node[repository] (user-repo) at (-5.5, 0) {\textbf{Benutzer-Repository}\\JPA/Hibernate};
|
|
\node[repository] (game-repo) at (-0.5, 0) {\textbf{Spiele-Repository}\\JPA/Hibernate};
|
|
\node[repository] (transaction-repo) at (4.5, 0) {\textbf{Transaktions-Repo}\\JPA/Hibernate};
|
|
|
|
% Sicherheitskomponenten
|
|
\node[component] (security) at (-11, 2.5) {\textbf{Security Config}\\JWT-Filter,\\CORS, OAuth2};
|
|
|
|
% Relationships
|
|
\draw (auth-ctrl) -- (auth-svc);
|
|
\draw (game-ctrl) -- (game-svc);
|
|
\draw (deposit-ctrl) -- (balance-svc);
|
|
\draw (user-ctrl) -- (user-svc);
|
|
|
|
\draw (auth-svc) -- (user-repo);
|
|
\draw (game-svc) -- (game-repo);
|
|
\draw (balance-svc) -- (transaction-repo);
|
|
\draw (user-svc) -- (user-repo);
|
|
|
|
\draw (security) -- (auth-svc);
|
|
|
|
\end{tikzpicture}
|
|
\end{landscape}
|
|
|
|
\clearpage
|
|
\needspace{8\baselineskip}
|
|
\subsubsection{Ebene 4: Code-Diagramm - Blackjack Service Implementierung}
|
|
Das Code-Diagramm zeigt exemplarisch die Implementierungsdetails des Blackjack Game Service auf Klassenebene. Es stellt die wichtigsten Klassen, Interfaces und deren Beziehungen dar, die für die Blackjack-Spiellogik verantwortlich sind.
|
|
|
|
\begin{landscape}
|
|
\begin{tikzpicture}[
|
|
class/.style={rectangle, draw=cyan!80, fill=cyan!15, minimum width=3.5cm, minimum height=3cm, align=center, rounded corners=4pt, thick},
|
|
interface/.style={rectangle, draw=yellow!80, fill=yellow!15, minimum width=3cm, minimum height=2cm, align=center, rounded corners=4pt, thick},
|
|
->, >=Stealth, node distance=4.5cm, thick
|
|
]
|
|
|
|
% Interface - kompaktere Anordnung
|
|
\node[interface] (game-interface) at (0, 4) {\textbf{<<Interface>>}\\GameService\\+spielStarten()\\+zugVerarbeiten()\\+ergebnisBerechnen()};
|
|
|
|
% Haupt-Service-Klasse
|
|
\node[class] (blackjack-service) at (0, 1) {\textbf{BlackjackService}\\implementiert GameService\\- kartendeck: Deck\\- spielRepository: Repository\\+ neuesSpielStarten(einsatz)\\+ ziehen(spielId)\\+ halten(spielId)\\+ verdoppeln(spielId)};
|
|
|
|
% Unterstützende Klassen - kompakter angeordnet
|
|
\node[class] (card-deck) at (-5, 1) {\textbf{Kartendeck}\\- karten: List<Karte>\\+ mischen()\\+ karteGeben()\\+ zurücksetzen()};
|
|
|
|
\node[class] (game-entity) at (5, 1) {\textbf{BlackjackSpielEntity}\\- id: Long\\- spielerKarten: List<Karte>\\- dealerKarten: List<Karte>\\- einsatzBetrag: BigDecimal\\- spielZustand: SpielZustand};
|
|
|
|
\node[class] (balance-service) at (0, -2) {\textbf{GuthabenService}\\+ guthabenAktualisieren()\\+ ausreichendGuthaben()\\+ transaktionErstellen()};
|
|
|
|
% Beziehungen
|
|
\draw (blackjack-service) -- (game-interface) node[midway, right] {implementiert};
|
|
\draw (blackjack-service) -- (card-deck) node[midway, above] {verwendet};
|
|
\draw (blackjack-service) -- (game-entity) node[midway, above] {verwaltet};
|
|
\draw (blackjack-service) -- (balance-service) node[midway, right] {abhängig von};
|
|
|
|
\end{tikzpicture}
|
|
\end{landscape}
|
|
|
|
\clearpage
|
|
\needspace{8\baselineskip}
|
|
\subsubsection{Deployment-Diagramm}
|
|
Das Deployment-Diagramm zeigt die Verteilung der Software-Container auf die physische/virtuelle Infrastruktur und stellt die Laufzeitumgebung der Anwendung dar. Es verdeutlicht, wie die verschiedenen Komponenten in der Produktionsumgebung deployed werden.
|
|
|
|
\begin{landscape}
|
|
\begin{tikzpicture}[
|
|
node/.style={rectangle, draw=gray!80, fill=gray!15, minimum width=5cm, minimum height=4cm, align=center, rounded corners=5pt, thick},
|
|
container/.style={rectangle, draw=blue!80, fill=blue!20, minimum width=3cm, minimum height=2cm, align=center, rounded corners=4pt, thick},
|
|
->, >=Stealth, node distance=6cm, thick
|
|
]
|
|
|
|
% Infrastruktur-Knoten
|
|
\node[node] (docker-host) at (0, 0) {\textbf{Docker-Host}\\Ubuntu Linux\\Docker Engine 24.x};
|
|
|
|
% Container innerhalb des Docker-Hosts - kompaktere Anordnung
|
|
\node[container] (nginx) at (-4, 2.5) {\textbf{nginx}\\Webserver\\Port 80/443};
|
|
\node[container] (angular) at (-1.5, 2.5) {\textbf{Frontend}\\Angular-App\\Statische Dateien};
|
|
\node[container] (spring) at (1.5, 2.5) {\textbf{Backend}\\Spring Boot\\Port 8080};
|
|
\node[container] (postgres) at (4, 2.5) {\textbf{Datenbank}\\PostgreSQL\\Port 5432};
|
|
\node[container] (mailpit) at (0, -2.5) {\textbf{Mailpit}\\E-Mail-Service\\Port 1025/8025};
|
|
|
|
% Externe Dienste - näher platziert
|
|
\node[node] (cloud) at (7, 0) {\textbf{Cloud-Dienste}\\Stripe API\\OAuth-Provider};
|
|
|
|
% Beziehungen
|
|
\draw (nginx) -- (angular);
|
|
\draw (spring) -- (postgres);
|
|
\draw (spring) -- (mailpit);
|
|
\draw (spring) -- (cloud);
|
|
|
|
\end{tikzpicture}
|
|
\end{landscape}
|
|
|
|
\subsubsection{Backend-Paketstruktur}
|
|
Das Backend folgt dem Domain-Driven Design (DDD) Ansatz:
|
|
|
|
\dirtree{%
|
|
.1 de.szut.casino.
|
|
.2 blackjack.
|
|
.3 BlackjackController.java.
|
|
.3 BlackjackService.java.
|
|
.3 BlackjackEntity.java.
|
|
.2 coinflip.
|
|
.3 CoinflipController.java.
|
|
.3 CoinflipService.java.
|
|
.2 config.
|
|
.3 SecurityConfig.java.
|
|
.3 DatabaseConfig.java.
|
|
.2 deposit.
|
|
.3 DepositController.java.
|
|
.3 StripeService.java.
|
|
.2 dice.
|
|
.3 DiceController.java.
|
|
.3 DiceService.java.
|
|
.2 exceptionHandling.
|
|
.3 GlobalExceptionHandler.java.
|
|
.2 health.
|
|
.3 HealthController.java.
|
|
.2 lootboxes.
|
|
.3 LootBoxEntity.java.
|
|
.3 RewardEntity.java.
|
|
.2 security.
|
|
.3 JwtAuthenticationConverter.java.
|
|
.2 shared.
|
|
.3 BaseEntity.java.
|
|
.3 AuditingConfig.java.
|
|
.2 slots.
|
|
.3 SlotsController.java.
|
|
.3 SlotsService.java.
|
|
.2 user.
|
|
.3 UserEntity.java.
|
|
.3 UserService.java.
|
|
}
|
|
|
|
\clearpage
|
|
\needspace{8\baselineskip}
|
|
\subsubsection{Ebene 3: Komponenten-Diagramm - Frontend-Anwendung}
|
|
Das Komponenten-Diagramm zeigt die interne Struktur der Angular Frontend-Anwendung und stellt die modulare Architektur mit Feature-Modulen, Services und Guards dar. Es verdeutlicht die Anwendung des Angular-Framework-Patterns.
|
|
|
|
\begin{landscape}
|
|
\begin{tikzpicture}[
|
|
module/.style={rectangle, draw=purple!80, fill=purple!20, minimum width=3.5cm, minimum height=2.2cm, align=center, rounded corners=4pt, thick},
|
|
component/.style={rectangle, draw=blue!80, fill=blue!20, minimum width=3cm, minimum height=1.6cm, align=center, rounded corners=3pt, thick},
|
|
service/.style={rectangle, draw=green!80, fill=green!20, minimum width=3cm, minimum height=1.6cm, align=center, rounded corners=3pt, thick},
|
|
guard/.style={rectangle, draw=orange!80, fill=orange!20, minimum width=3cm, minimum height=1.6cm, align=center, rounded corners=3pt, thick},
|
|
->, >=Stealth, node distance=3.5cm, thick
|
|
]
|
|
|
|
% Kern-Module - kompaktere Anordnung
|
|
\node[module] (app) at (0, 5) {\textbf{App-Modul}\\Haupt-Modul\\mit Routing};
|
|
\node[module] (shared) at (-6, 3) {\textbf{Shared-Modul}\\Gemeinsame Komponenten\\Navbar, Footer};
|
|
|
|
% Feature-Module - dichter angeordnet
|
|
\node[module] (auth) at (-3, 3) {\textbf{Auth-Modul}\\Anmeldung, Registrierung\\OAuth2, Wiederherstellung};
|
|
\node[module] (games) at (0, 3) {\textbf{Spiele-Modul}\\Blackjack, Slots\\Würfel, Coinflip};
|
|
\node[module] (deposit) at (3, 3) {\textbf{Einzahlungs-Modul}\\Zahlungsintegration\\Stripe};
|
|
\node[module] (home) at (6, 3) {\textbf{Home-Modul}\\Dashboard\\Benutzerprofil};
|
|
|
|
% Service-Schicht - kompakter
|
|
\node[service] (auth-svc) at (-4.5, 0.5) {\textbf{Auth Service}\\JWT-Verwaltung\\Benutzerstatus};
|
|
\node[service] (user-svc) at (-1.5, 0.5) {\textbf{User Service}\\Profilverwaltung\\Guthaben-Updates};
|
|
\node[service] (game-svc) at (1.5, 0.5) {\textbf{Spiele-Services}\\API-Kommunikation\\Spiellogik};
|
|
\node[service] (payment-svc) at (4.5, 0.5) {\textbf{Payment Service}\\Stripe-Integration\\Einzahlungen};
|
|
|
|
% Guards und Interceptors - kompakter
|
|
\node[guard] (auth-guard) at (-1.5, -1.5) {\textbf{Auth Guard}\\Routen-Schutz};
|
|
\node[guard] (http-interceptor) at (1.5, -1.5) {\textbf{HTTP Interceptor}\\JWT-Injection\\CORS-Headers};
|
|
|
|
% Relationships
|
|
\draw (app) -- (shared);
|
|
\draw (app) -- (auth);
|
|
\draw (app) -- (games);
|
|
\draw (app) -- (deposit);
|
|
\draw (app) -- (home);
|
|
|
|
\draw (auth) -- (auth-svc);
|
|
\draw (games) -- (game-svc);
|
|
\draw (deposit) -- (payment-svc);
|
|
\draw (home) -- (user-svc);
|
|
|
|
\draw (auth-guard) -- (auth-svc);
|
|
\draw (http-interceptor) -- (auth-svc);
|
|
|
|
\end{tikzpicture}
|
|
\end{landscape}
|
|
|
|
\subsubsection{Architektur-Zusammenfassung}
|
|
Die Casino Gaming Platform implementiert eine moderne, mehrschichtige Architektur, die folgende Prinzipien befolgt:
|
|
|
|
\begin{itemize}
|
|
\item \textbf{Separation of Concerns:} Klare Trennung zwischen Präsentations-, Geschäftslogik- und Datenschicht
|
|
\item \textbf{Modularität:} Feature-basierte Modularisierung sowohl im Frontend als auch Backend
|
|
\item \textbf{Skalierbarkeit:} Container-basierte Architektur ermöglicht horizontale Skalierung
|
|
\item \textbf{Sicherheit:} Umfassende Sicherheitskonzepte mit JWT, OAuth2 und CORS-Schutz
|
|
\item \textbf{Wartbarkeit:} Standardisierte Patterns (MVC, Repository, Service Layer) erleichtern die Wartung
|
|
\end{itemize}
|
|
|
|
Die C4-Darstellung zeigt die Architektur auf verschiedenen Abstraktionsebenen und ermöglicht es unterschiedlichen Stakeholdern, die für sie relevanten Aspekte zu verstehen - von der Geschäftslogik bis hin zu technischen Implementierungsdetails.
|
|
|
|
\subsubsection{Frontend-Paketstruktur (Detailansicht)}
|
|
Die detaillierte Paketstruktur des Frontend zeigt die modulare Organisation:
|
|
|
|
\dirtree{%
|
|
.1 app/feature/.
|
|
.2 auth.
|
|
.3 login.
|
|
.3 oauth2.
|
|
.3 recover-password.
|
|
.3 register.
|
|
.3 verify-email.
|
|
.2 deposit.
|
|
.3 deposit.component.ts.
|
|
.3 payment.service.ts.
|
|
.2 game.
|
|
.3 blackjack.
|
|
.4 components.
|
|
.5 animated-number.
|
|
.5 dealer-hand.
|
|
.5 game-controls.
|
|
.5 game-info.
|
|
.5 game-result.
|
|
.5 player-hand.
|
|
.5 playing-card.
|
|
.4 enum.
|
|
.4 models.
|
|
.4 services.
|
|
.3 coinflip.
|
|
.4 models.
|
|
.3 dice.
|
|
.3 slots.
|
|
.2 home.
|
|
.2 landing.
|
|
.2 lootboxes.
|
|
.3 lootbox-opening.
|
|
.3 lootbox-selection.
|
|
.3 services.
|
|
.2 transaction-history.
|
|
}
|
|
|
|
\subsection{Funktionsweise des Blackjack-Algorithmus}
|
|
Als Beispiel für die Spiellogik wird hier der Blackjack-Algorithmus beschrieben:
|
|
|
|
\begin{enumerate}
|
|
\item \textbf{Spielstart:} Dealer teilt je 2 Karten an Spieler und sich selbst aus
|
|
\item \textbf{Kartenwerte:} Ass = 1 oder 11, Bildkarten = 10, andere = Nennwert
|
|
\item \textbf{Spielerzug:} Hit (weitere Karte) oder Stand (beenden)
|
|
\item \textbf{Dealerzug:} Automatisch bis Kartenwert $\geq$ 17
|
|
\item \textbf{Gewinnermittlung:} Nächster zu 21 gewinnt, bei Gleichstand Unentschieden
|
|
\end{enumerate}
|
|
|
|
\section{Technologie-Stack}
|
|
|
|
\subsection{Frontend-Technologien}
|
|
\begin{itemize}
|
|
\item \textbf{Angular 20}: Modernes TypeScript-basiertes Web-Framework
|
|
\item \textbf{TailwindCSS}: Utility-First CSS-Framework
|
|
\item \textbf{RxJS}: Reactive Extensions für asynchrone Programmierung
|
|
\item \textbf{Keycloak JS}: JavaScript-Adapter für Keycloak-Integration
|
|
\item \textbf{Stripe.js}: Sichere Payment-Integration
|
|
\end{itemize}
|
|
|
|
\subsection{Backend-Technologien}
|
|
\begin{itemize}
|
|
\item \textbf{Spring Boot}: Java-basiertes Backend-Framework
|
|
\item \textbf{Spring Security}: Sicherheitsframework
|
|
\item \textbf{Spring Data JPA}: Datenbankzugriff
|
|
\item \textbf{PostgreSQL}: Relationale Datenbank
|
|
\item \textbf{Gradle}: Build-Management-Tool
|
|
\end{itemize}
|
|
|
|
\subsection{Infrastructure \& Tools}
|
|
\begin{itemize}
|
|
\item \textbf{Docker}: Containerisierung
|
|
\item \textbf{Docker Compose}: Multi-Container-Orchestrierung
|
|
\item \textbf{Keycloak}: Identity und Access Management
|
|
\item \textbf{Mailpit}: E-Mail-Testing in der Entwicklung
|
|
\item \textbf{Swagger/OpenAPI}: API-Dokumentation
|
|
\end{itemize}
|
|
|
|
\chapter{Implementierung}
|
|
|
|
\section{Backend-Implementierung}
|
|
|
|
\subsection{Spring Boot Konfiguration}
|
|
Die Hauptanwendungsklasse initialisiert die Spring Boot-Anwendung und konfiguriert grundlegende Beans:
|
|
|
|
\begin{lstlisting}[language=Java, caption=CasinoApplication.java]
|
|
@SpringBootApplication
|
|
public class CasinoApplication {
|
|
public static void main(String[] args) {
|
|
SpringApplication.run(CasinoApplication.class, args);
|
|
}
|
|
|
|
@Bean
|
|
public static RestTemplate restTemplate() {
|
|
return new RestTemplate();
|
|
}
|
|
|
|
@Bean
|
|
public static JavaMailSenderImpl javaMailSenderImpl() {
|
|
return new JavaMailSenderImpl();
|
|
}
|
|
}
|
|
\end{lstlisting}
|
|
|
|
\subsection{Sicherheitskonfiguration}
|
|
Die Anwendung nutzt Keycloak für die Authentifizierung. Spring Security wird entsprechend konfiguriert:
|
|
|
|
\begin{lstlisting}[language=Java, caption=Security Configuration]
|
|
@Configuration
|
|
@EnableWebSecurity
|
|
public class SecurityConfig {
|
|
@Bean
|
|
public SecurityFilterChain filterChain(HttpSecurity http) {
|
|
return http
|
|
.authorizeHttpRequests(auth -> auth
|
|
.requestMatchers("/swagger/**").permitAll()
|
|
.requestMatchers("/health/**").permitAll()
|
|
.anyRequest().authenticated()
|
|
)
|
|
.oauth2ResourceServer(oauth2 ->
|
|
oauth2.jwt(jwt -> jwt.jwtAuthenticationConverter(
|
|
jwtAuthenticationConverter()
|
|
))
|
|
)
|
|
.build();
|
|
}
|
|
}
|
|
\end{lstlisting}
|
|
|
|
\subsection{Spieleimplementierung}
|
|
Jedes Spiel folgt einem einheitlichen Muster mit Controller, Service und Repository:
|
|
|
|
\begin{lstlisting}[language=Java, caption=Beispiel: Blackjack Controller]
|
|
@RestController
|
|
@RequestMapping("/api/blackjack")
|
|
@RequiredArgsConstructor
|
|
public class BlackjackController {
|
|
private final BlackjackService blackjackService;
|
|
|
|
@PostMapping("/start")
|
|
public ResponseEntity<GameStateDto> startGame() {
|
|
return ResponseEntity.ok(
|
|
blackjackService.startNewGame()
|
|
);
|
|
}
|
|
|
|
@PostMapping("/hit")
|
|
public ResponseEntity<GameStateDto> hit() {
|
|
return ResponseEntity.ok(
|
|
blackjackService.playerHit()
|
|
);
|
|
}
|
|
|
|
@PostMapping("/stand")
|
|
public ResponseEntity<GameStateDto> stand() {
|
|
return ResponseEntity.ok(
|
|
blackjackService.playerStand()
|
|
);
|
|
}
|
|
}
|
|
\end{lstlisting}
|
|
|
|
\section{Frontend-Implementierung}
|
|
|
|
\subsection{Angular-Projektstruktur}
|
|
Das Frontend nutzt Angular's modulare Architektur mit Lazy Loading:
|
|
|
|
\begin{lstlisting}[caption=App Routing Module]
|
|
const routes: Routes = [
|
|
{
|
|
path: '',
|
|
loadChildren: () => import('./feature/landing/landing.module')
|
|
.then(m => m.LandingModule)
|
|
},
|
|
{
|
|
path: 'games',
|
|
loadChildren: () => import('./feature/game/game.module')
|
|
.then(m => m.GameModule),
|
|
canActivate: [AuthGuard]
|
|
},
|
|
{
|
|
path: 'deposit',
|
|
loadChildren: () => import('./feature/deposit/deposit.module')
|
|
.then(m => m.DepositModule),
|
|
canActivate: [AuthGuard]
|
|
}
|
|
];
|
|
\end{lstlisting}
|
|
|
|
\subsection{Komponenten-Implementierung}
|
|
Jede Spielkomponente folgt dem Angular-Standard mit TypeScript:
|
|
|
|
\begin{lstlisting}[caption=Blackjack Component]
|
|
@Component({
|
|
selector: 'app-blackjack',
|
|
templateUrl: './blackjack.component.html',
|
|
styleUrls: ['./blackjack.component.scss']
|
|
})
|
|
export class BlackjackComponent implements OnInit {
|
|
gameState$: Observable<GameState>;
|
|
|
|
constructor(
|
|
private blackjackService: BlackjackService,
|
|
private toastr: ToastrService
|
|
) {}
|
|
|
|
ngOnInit(): void {
|
|
this.gameState$ = this.blackjackService.getGameState();
|
|
}
|
|
|
|
startGame(): void {
|
|
this.blackjackService.startGame()
|
|
.subscribe({
|
|
next: () => this.toastr.success('Spiel gestartet!'),
|
|
error: (err) => this.toastr.error('Fehler beim Starten')
|
|
});
|
|
}
|
|
}
|
|
\end{lstlisting}
|
|
|
|
\subsection{Service-Layer}
|
|
Services kapseln die Geschäftslogik und API-Kommunikation:
|
|
|
|
\begin{lstlisting}[caption=Blackjack Service]
|
|
@Injectable({
|
|
providedIn: 'root'
|
|
})
|
|
export class BlackjackService {
|
|
private apiUrl = '/api/blackjack';
|
|
private gameStateSubject = new BehaviorSubject<GameState>(null);
|
|
|
|
constructor(private http: HttpClient) {}
|
|
|
|
startGame(): Observable<GameState> {
|
|
return this.http.post<GameState>(`${this.apiUrl}/start`, {})
|
|
.pipe(
|
|
tap(state => this.gameStateSubject.next(state)),
|
|
catchError(this.handleError)
|
|
);
|
|
}
|
|
|
|
private handleError(error: HttpErrorResponse): Observable<never> {
|
|
console.error('API Error:', error);
|
|
return throwError(() => error);
|
|
}
|
|
}
|
|
\end{lstlisting}
|
|
|
|
\section{Datenbankdesign}
|
|
|
|
\subsection{Entity-Relationship-Modell}
|
|
Die Datenbank verwendet folgende Hauptentitäten:
|
|
|
|
\begin{lstlisting}[caption=Haupttabellen]
|
|
-- Benutzer-Tabelle
|
|
CREATE TABLE users (
|
|
id UUID PRIMARY KEY,
|
|
keycloak_id VARCHAR(255) UNIQUE NOT NULL,
|
|
balance DECIMAL(19, 2) DEFAULT 0.00,
|
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
|
);
|
|
|
|
-- Transaktions-Tabelle
|
|
CREATE TABLE transactions (
|
|
id UUID PRIMARY KEY,
|
|
user_id UUID REFERENCES users(id),
|
|
amount DECIMAL(19, 2) NOT NULL,
|
|
type VARCHAR(50) NOT NULL,
|
|
description TEXT,
|
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
|
);
|
|
|
|
-- Spielverlauf-Tabelle
|
|
CREATE TABLE game_history (
|
|
id UUID PRIMARY KEY,
|
|
user_id UUID REFERENCES users(id),
|
|
game_type VARCHAR(50) NOT NULL,
|
|
bet_amount DECIMAL(19, 2),
|
|
win_amount DECIMAL(19, 2),
|
|
played_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
|
);
|
|
\end{lstlisting}
|
|
|
|
\subsection{JPA-Entitäten}
|
|
Die Datenbankentitäten werden als JPA-Entities modelliert:
|
|
|
|
\begin{lstlisting}[caption=User Entity]
|
|
@Entity
|
|
@Table(name = "users")
|
|
@Data
|
|
@NoArgsConstructor
|
|
@AllArgsConstructor
|
|
public class UserEntity {
|
|
@Id
|
|
@GeneratedValue(strategy = GenerationType.UUID)
|
|
private UUID id;
|
|
|
|
@Column(unique = true, nullable = false)
|
|
private String keycloakId;
|
|
|
|
@Column(precision = 19, scale = 2)
|
|
private BigDecimal balance = BigDecimal.ZERO;
|
|
|
|
@OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
|
|
private List<TransactionEntity> transactions;
|
|
|
|
@CreationTimestamp
|
|
private LocalDateTime createdAt;
|
|
|
|
@UpdateTimestamp
|
|
private LocalDateTime updatedAt;
|
|
}
|
|
\end{lstlisting}
|
|
|
|
\chapter{Integration externer Dienste}
|
|
|
|
\section{Keycloak-Integration}
|
|
Keycloak wird als zentraler Identity Provider verwendet:
|
|
|
|
\subsection{Backend-Konfiguration}
|
|
\begin{lstlisting}[caption=application.yml]
|
|
spring:
|
|
security:
|
|
oauth2:
|
|
resourceserver:
|
|
jwt:
|
|
issuer-uri: http://localhost:8080/realms/casino
|
|
jwk-set-uri: http://localhost:8080/realms/casino/protocol/openid-connect/certs
|
|
|
|
keycloak:
|
|
realm: casino
|
|
auth-server-url: http://localhost:8080
|
|
ssl-required: external
|
|
resource: casino-backend
|
|
public-client: false
|
|
bearer-only: true
|
|
\end{lstlisting}
|
|
|
|
\subsection{Frontend-Integration}
|
|
\begin{lstlisting}[caption=Keycloak Service]
|
|
@Injectable({
|
|
providedIn: 'root'
|
|
})
|
|
export class KeycloakService {
|
|
private keycloak: Keycloak;
|
|
|
|
async init(): Promise<boolean> {
|
|
this.keycloak = new Keycloak({
|
|
url: 'http://localhost:8080',
|
|
realm: 'casino',
|
|
clientId: 'casino-frontend'
|
|
});
|
|
|
|
return await this.keycloak.init({
|
|
onLoad: 'check-sso',
|
|
silentCheckSsoRedirectUri:
|
|
window.location.origin + '/assets/silent-check-sso.html'
|
|
});
|
|
}
|
|
}
|
|
\end{lstlisting}
|
|
|
|
\section{Stripe-Integration}
|
|
Stripe wird für sichere Zahlungsabwicklung verwendet:
|
|
|
|
\subsection{Backend-Webhook}
|
|
\begin{lstlisting}[caption=Stripe Webhook Controller]
|
|
@RestController
|
|
@RequestMapping("/webhook")
|
|
public class StripeWebhookController {
|
|
@Value("${stripe.webhook.secret}")
|
|
private String webhookSecret;
|
|
|
|
@PostMapping
|
|
public ResponseEntity<String> handleWebhook(
|
|
@RequestBody String payload,
|
|
@RequestHeader("Stripe-Signature") String sigHeader
|
|
) {
|
|
Event event = Webhook.constructEvent(
|
|
payload, sigHeader, webhookSecret
|
|
);
|
|
|
|
switch (event.getType()) {
|
|
case "payment_intent.succeeded":
|
|
handleSuccessfulPayment(event);
|
|
break;
|
|
case "payment_intent.payment_failed":
|
|
handleFailedPayment(event);
|
|
break;
|
|
}
|
|
|
|
return ResponseEntity.ok("Received");
|
|
}
|
|
}
|
|
\end{lstlisting}
|
|
|
|
\subsection{Frontend-Integration}
|
|
\begin{lstlisting}[caption=Stripe Service]
|
|
@Injectable({
|
|
providedIn: 'root'
|
|
})
|
|
export class StripeService {
|
|
private stripe: Stripe;
|
|
|
|
constructor() {
|
|
this.stripe = loadStripe(environment.stripePublicKey);
|
|
}
|
|
|
|
async createPaymentIntent(amount: number): Observable<PaymentIntent> {
|
|
return this.http.post<PaymentIntent>('/api/deposits/create-intent', {
|
|
amount: amount * 100 // Cent-Betrag
|
|
});
|
|
}
|
|
}
|
|
\end{lstlisting}
|
|
|
|
\chapter{Qualitätssicherung}
|
|
|
|
\section{CI/CD Setup}
|
|
|
|
\subsection{Unit-Tests}
|
|
Jede Service-Klasse wird mit JUnit und Mockito getestet:
|
|
|
|
\begin{lstlisting}[language=Java, caption=BlackjackService Test]
|
|
@ExtendWith(MockitoExtension.class)
|
|
class BlackjackServiceTest {
|
|
@Mock
|
|
private BlackjackRepository repository;
|
|
|
|
@InjectMocks
|
|
private BlackjackService service;
|
|
|
|
@Test
|
|
void testStartNewGame() {
|
|
// Given
|
|
when(repository.save(any())).thenReturn(new GameEntity());
|
|
|
|
// When
|
|
GameStateDto result = service.startNewGame();
|
|
|
|
// Then
|
|
assertNotNull(result);
|
|
assertEquals(2, result.getPlayerCards().size());
|
|
assertEquals(2, result.getDealerCards().size());
|
|
}
|
|
}
|
|
\end{lstlisting}
|
|
|
|
\subsection{Integrationstests}
|
|
Spring Boot Test für API-Endpoints:
|
|
|
|
\begin{lstlisting}[language=Java, caption=Integration Test]
|
|
@SpringBootTest
|
|
@AutoConfigureMockMvc
|
|
class BlackjackControllerIntegrationTest {
|
|
@Autowired
|
|
private MockMvc mockMvc;
|
|
|
|
@Test
|
|
@WithMockUser
|
|
void testStartGameEndpoint() throws Exception {
|
|
mockMvc.perform(post("/api/blackjack/start")
|
|
.contentType(MediaType.APPLICATION_JSON))
|
|
.andExpect(status().isOk())
|
|
.andExpect(jsonPath("$.playerCards").isArray())
|
|
.andExpect(jsonPath("$.dealerCards").isArray());
|
|
}
|
|
}
|
|
\end{lstlisting}
|
|
|
|
\section{Frontend-Tests}
|
|
|
|
\subsection{Komponenten-Tests}
|
|
Angular-Komponenten werden mit Jasmine und Karma getestet:
|
|
|
|
\begin{lstlisting}[caption=Component Test]
|
|
describe('BlackjackComponent', () => {
|
|
let component: BlackjackComponent;
|
|
let fixture: ComponentFixture<BlackjackComponent>;
|
|
let mockService: jasmine.SpyObj<BlackjackService>;
|
|
|
|
beforeEach(() => {
|
|
const spy = jasmine.createSpyObj('BlackjackService',
|
|
['startGame', 'getGameState']);
|
|
|
|
TestBed.configureTestingModule({
|
|
declarations: [BlackjackComponent],
|
|
providers: [
|
|
{ provide: BlackjackService, useValue: spy }
|
|
]
|
|
});
|
|
|
|
fixture = TestBed.createComponent(BlackjackComponent);
|
|
component = fixture.componentInstance;
|
|
mockService = TestBed.inject(BlackjackService) as any;
|
|
});
|
|
|
|
it('should start a new game', () => {
|
|
mockService.startGame.and.returnValue(of(mockGameState));
|
|
|
|
component.startGame();
|
|
|
|
expect(mockService.startGame).toHaveBeenCalled();
|
|
});
|
|
});
|
|
\end{lstlisting}
|
|
|
|
\subsection{E2E-Tests}
|
|
End-to-End-Tests mit Cypress:
|
|
|
|
\begin{lstlisting}[caption=E2E Test]
|
|
describe('Blackjack Game', () => {
|
|
beforeEach(() => {
|
|
cy.login('testuser', 'password');
|
|
cy.visit('/games/blackjack');
|
|
});
|
|
|
|
it('should play a complete game', () => {
|
|
cy.get('[data-cy=start-game]').click();
|
|
cy.get('[data-cy=player-cards]').should('be.visible');
|
|
cy.get('[data-cy=dealer-cards]').should('be.visible');
|
|
|
|
cy.get('[data-cy=hit-button]').click();
|
|
cy.get('[data-cy=player-cards]')
|
|
.children().should('have.length.greaterThan', 2);
|
|
|
|
cy.get('[data-cy=stand-button]').click();
|
|
cy.get('[data-cy=game-result]').should('be.visible');
|
|
});
|
|
});
|
|
\end{lstlisting}
|
|
|
|
\chapter{Wirtschaftliche Betrachtung}
|
|
|
|
\section{Marktuntersuchung}
|
|
|
|
\subsection{Zielgruppe}
|
|
\textbf{Welche Zielgruppe soll angesprochen werden?}
|
|
|
|
\begin{itemize}
|
|
\item \textbf{Primäre Zielgruppe:} Technik-affine Nutzer (18-35 Jahre)
|
|
\item \textbf{Sekundäre Zielgruppe:} Gelegenheitsspieler mit Fokus auf Benutzerfreundlichkeit
|
|
\end{itemize}
|
|
|
|
\subsection{Erwartungen der Zielgruppe}
|
|
\textbf{Welche Erwartungen hat die Zielgruppe an das Produkt?}
|
|
|
|
Die Zielgruppe erwartet ein unterhaltsames, fesselndes und optisch ansprechendes Spielerlebnis, das klassische Casino-Atmosphäre simuliert. Sie legt Wert auf:
|
|
|
|
\begin{itemize}
|
|
\item Intuitive Benutzeroberfläche
|
|
\item Schnelle Ladezeiten
|
|
\item Abwechslungsreiche Spiele (Slots, Blackjack, CoinFlip etc.)
|
|
\item Transparente Transaktionshistorie
|
|
\item Mobile Optimierung
|
|
\item Sichere Zahlungsabwicklung
|
|
\end{itemize}
|
|
|
|
\subsection{Marktvolumen und Marktpotential}
|
|
\textbf{Wie hoch ist bei der Zielgruppe das Marktvolumen und das Marktpotential?}
|
|
|
|
Der Markt für Social Casinos und Online-Casinos mit Auszahlungsverweigerung ist weltweit wachsend. Laut Branchenanalysen (z.B. Statista, Business Research Insights) liegt das Volumen des globalen Social-Casino-Markts bei mehreren Milliarden USD pro Jahr, mit jährlichen Wachstumsraten im hohen einstelligen Prozentbereich.
|
|
|
|
In Zielmärkten wie den USA, Europa und Teilen Asiens ist das Potenzial besonders hoch, insbesondere bei Nutzern, die Glücksspiel aus rechtlichen oder moralischen Gründen meiden, aber den Spielspaß schätzen.
|
|
|
|
\subsection{Absatzpotential}
|
|
\textbf{Wie hoch ist bei der Zielgruppe das Absatzpotential?}
|
|
|
|
Das Absatzpotential ist aufgrund des digitalen Charakters des Produkts nahezu unbegrenzt skalierbar. Wichtige Faktoren:
|
|
|
|
\begin{itemize}
|
|
\item Keine physischen Produktionslimits
|
|
\item Globale Erreichbarkeit über das Internet
|
|
\item Virale Marketing-Effekte durch Social Gaming
|
|
\item Wiederkehrende Umsätze durch Einzahlungsmodell
|
|
\end{itemize}
|
|
|
|
\subsection{Wettbewerbssituation}
|
|
\textbf{Wie stellt sich die Wettbewerbssituation dar?}
|
|
|
|
Der Markt ist stark umkämpft mit etablierten Playern wie:
|
|
\begin{itemize}
|
|
\item PokerStars Casino
|
|
\item Slotomania
|
|
\item House of Fun
|
|
\item Big Fish Casino
|
|
\end{itemize}
|
|
|
|
\textbf{Konkurrenzvorteile unserer Lösung:}
|
|
\begin{itemize}
|
|
\item Moderne Technologie-Stack (Angular + Spring Boot)
|
|
\item DSGVO-konforme Entwicklung von Grund auf
|
|
\item Keine Auszahlungen = höhere Gewinnmargen
|
|
\item Responsive Design für alle Endgeräte
|
|
\item Open-Source-Ansatz für Community-Entwicklung
|
|
\end{itemize}
|
|
|
|
\subsection{Risiken}
|
|
\textbf{Wo liegen Risiken?}
|
|
|
|
\begin{itemize}
|
|
\item \textbf{Rechtliche Risiken:} Sich ändernde Glücksspielgesetze
|
|
\item \textbf{Technische Risiken:} Skalierungsprobleme bei hohen Nutzerzahlen
|
|
\item \textbf{Marktrisiken:} Marktsättigung im Social Gaming Bereich
|
|
\item \textbf{Sicherheitsrisiken:} Hacking-Versuche und Betrug
|
|
\end{itemize}
|
|
|
|
\section{Marketingmix / absatzpolitische Maßnahmen}
|
|
|
|
\subsection{Preispolitik}
|
|
\textbf{Für welchen Preis wird das Produkt angeboten?}
|
|
|
|
Das Produkt folgt einem Freemium-Modell:
|
|
\begin{itemize}
|
|
\item \textbf{Grundspiel:} Kostenlos mit Startguthaben
|
|
\item \textbf{Einzahlungen:} Gestaffelte Pakete (5€, 10€, 25€, 50€, 100€)
|
|
\item \textbf{Premium-Features:} Erweiterte Statistiken (2,99€/Monat)
|
|
\end{itemize}
|
|
|
|
\subsection{Kommunikationspolitik}
|
|
\textbf{Wie und wo soll das Produkt beworben werden?}
|
|
|
|
\begin{itemize}
|
|
\item \textbf{Social Media Marketing:} Instagram, TikTok, YouTube
|
|
\item \textbf{Influencer Marketing:} Gaming-Streamer und Content-Creator
|
|
\item \textbf{SEO/SEM:} Google Ads für relevante Suchbegriffe
|
|
\item \textbf{App Store Optimization:} Bei zukünftiger Mobile App
|
|
\end{itemize}
|
|
|
|
\subsection{Distributionspolitik}
|
|
\textbf{Wie gelangt das Produkt zum Nutzer?}
|
|
|
|
\begin{itemize}
|
|
\item \textbf{Web-Browser:} Direkter Zugang über casino-platform.com
|
|
\item \textbf{Progressive Web App:} Installation als App möglich
|
|
\item \textbf{Zukünftig:} Native Apps für iOS und Android
|
|
\end{itemize}
|
|
|
|
\subsection{Wirtschaftlichkeitsbetrachtung}
|
|
\textbf{Wo liegt die Gewinnschwelle?}
|
|
|
|
Bei durchschnittlich 10€ Einzahlung pro aktivem Nutzer und 1000 aktiven Nutzern monatlich:
|
|
\begin{itemize}
|
|
\item \textbf{Monatlicher Umsatz:} 10.000€
|
|
\item \textbf{Betriebskosten:} 3.000€ (Server, Support, Marketing)
|
|
\item \textbf{Break-Even:} Nach 6 Monaten bei stetigem Nutzerwachstum
|
|
\end{itemize}
|
|
|
|
\chapter{Deployment und Betrieb}
|
|
|
|
\section{Container-Konfiguration}
|
|
Die Anwendung wird mit Docker containerisiert:
|
|
|
|
\subsection{Backend Dockerfile}
|
|
\begin{lstlisting}[caption=Backend Dockerfile]
|
|
FROM eclipse-temurin:17-jdk-alpine AS build
|
|
WORKDIR /app
|
|
COPY gradle gradle
|
|
COPY gradlew build.gradle.kts settings.gradle.kts ./
|
|
RUN ./gradlew dependencies --no-daemon
|
|
COPY src src
|
|
RUN ./gradlew bootJar --no-daemon
|
|
|
|
FROM eclipse-temurin:17-jre-alpine
|
|
WORKDIR /app
|
|
COPY --from=build /app/build/libs/*.jar app.jar
|
|
EXPOSE 8080
|
|
ENTRYPOINT ["java", "-jar", "app.jar"]
|
|
\end{lstlisting}
|
|
|
|
\subsection{Frontend Dockerfile}
|
|
\begin{lstlisting}[caption=Frontend Dockerfile]
|
|
FROM node:18-alpine AS build
|
|
WORKDIR /app
|
|
COPY package*.json ./
|
|
RUN npm ci
|
|
COPY . .
|
|
RUN npm run build
|
|
|
|
FROM nginx:alpine
|
|
COPY --from=build /app/dist/casino-frontend /usr/share/nginx/html
|
|
COPY nginx.conf /etc/nginx/nginx.conf
|
|
EXPOSE 80
|
|
CMD ["nginx", "-g", "daemon off;"]
|
|
\end{lstlisting}
|
|
|
|
\section{CI/CD-Pipeline}
|
|
Die Anwendung nutzt GitHub Actions für automatisierte Builds:
|
|
|
|
\begin{lstlisting}[caption=GitHub Actions Workflow]
|
|
name: Build and Deploy
|
|
|
|
on:
|
|
push:
|
|
branches: [main, develop]
|
|
pull_request:
|
|
branches: [main]
|
|
|
|
jobs:
|
|
test:
|
|
runs-on: ubuntu-latest
|
|
steps:
|
|
- uses: actions/checkout@v3
|
|
|
|
- name: Set up JDK 17
|
|
uses: actions/setup-java@v3
|
|
with:
|
|
java-version: '17'
|
|
|
|
- name: Run Backend Tests
|
|
working-directory: ./backend
|
|
run: ./gradlew test
|
|
|
|
- name: Set up Node.js
|
|
uses: actions/setup-node@v3
|
|
with:
|
|
node-version: '18'
|
|
|
|
- name: Run Frontend Tests
|
|
working-directory: ./frontend
|
|
run: |
|
|
npm ci
|
|
npm run test:ci
|
|
|
|
build:
|
|
needs: test
|
|
runs-on: ubuntu-latest
|
|
steps:
|
|
- name: Build Docker Images
|
|
run: |
|
|
docker build -t casino-backend ./backend
|
|
docker build -t casino-frontend ./frontend
|
|
\end{lstlisting}
|
|
|
|
\section{Monitoring und Wartung}
|
|
|
|
\subsection{Health Checks}
|
|
Spring Boot Actuator bietet Health-Endpoints:
|
|
|
|
\begin{lstlisting}[language=Java, caption=Health Check Configuration]
|
|
@Component
|
|
public class DatabaseHealthIndicator implements HealthIndicator {
|
|
@Autowired
|
|
private DataSource dataSource;
|
|
|
|
@Override
|
|
public Health health() {
|
|
try (Connection conn = dataSource.getConnection()) {
|
|
if (conn.isValid(1)) {
|
|
return Health.up()
|
|
.withDetail("database", "PostgreSQL")
|
|
.build();
|
|
}
|
|
} catch (SQLException e) {
|
|
return Health.down()
|
|
.withException(e)
|
|
.build();
|
|
}
|
|
return Health.down().build();
|
|
}
|
|
}
|
|
\end{lstlisting}
|
|
|
|
\subsection{Logging-Konfiguration}
|
|
Strukturiertes Logging mit SLF4J:
|
|
|
|
\begin{lstlisting}[language=xml, caption=logback.xml]
|
|
<configuration>
|
|
<appender name="CONSOLE"
|
|
class="ch.qos.logback.core.ConsoleAppender">
|
|
<encoder>
|
|
<pattern>
|
|
%d{ISO8601} [%thread] %-5level %logger{36} - %msg%n
|
|
</pattern>
|
|
</encoder>
|
|
</appender>
|
|
|
|
<appender name="FILE"
|
|
class="ch.qos.logback.core.rolling.RollingFileAppender">
|
|
<file>logs/casino.log</file>
|
|
<rollingPolicy
|
|
class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
|
|
<fileNamePattern>logs/casino.%d{yyyy-MM-dd}.log</fileNamePattern>
|
|
<maxHistory>30</maxHistory>
|
|
</rollingPolicy>
|
|
<encoder>
|
|
<pattern>
|
|
%d{ISO8601} [%thread] %-5level %logger{36} - %msg%n
|
|
</pattern>
|
|
</encoder>
|
|
</appender>
|
|
|
|
<root level="INFO">
|
|
<appender-ref ref="CONSOLE" />
|
|
<appender-ref ref="FILE" />
|
|
</root>
|
|
</configuration>
|
|
\end{lstlisting}
|
|
|
|
\chapter{Sicherheitskonzept}
|
|
|
|
\section{Authentifizierung und Autorisierung}
|
|
Die Plattform implementiert ein mehrstufiges Sicherheitskonzept:
|
|
|
|
\subsection{OAuth2/OpenID Connect}
|
|
Keycloak als Identity Provider bietet:
|
|
\begin{itemize}
|
|
\item Single Sign-On (SSO)
|
|
\item Multi-Factor Authentication (MFA)
|
|
\item Social Login (Google, GitHub)
|
|
\item Token-basierte Authentifizierung (JWT)
|
|
\end{itemize}
|
|
|
|
\subsection{API-Sicherheit}
|
|
\begin{lstlisting}[language=Java, caption=Security Headers]
|
|
@Component
|
|
public class SecurityHeadersFilter implements Filter {
|
|
@Override
|
|
public void doFilter(ServletRequest request,
|
|
ServletResponse response,
|
|
FilterChain chain) {
|
|
HttpServletResponse httpResponse =
|
|
(HttpServletResponse) response;
|
|
|
|
httpResponse.setHeader("X-Content-Type-Options", "nosniff");
|
|
httpResponse.setHeader("X-Frame-Options", "DENY");
|
|
httpResponse.setHeader("X-XSS-Protection", "1; mode=block");
|
|
httpResponse.setHeader("Strict-Transport-Security",
|
|
"max-age=31536000; includeSubDomains");
|
|
|
|
chain.doFilter(request, response);
|
|
}
|
|
}
|
|
\end{lstlisting}
|
|
|
|
\section{Datenschutz}
|
|
Die Anwendung erfüllt DSGVO-Anforderungen:
|
|
|
|
\begin{itemize}
|
|
\item Verschlüsselte Datenspeicherung
|
|
\item Recht auf Datenlöschung
|
|
\item Datenportabilität
|
|
\item Audit-Logging aller Zugriffe
|
|
\item Cookie-Consent-Management
|
|
\end{itemize}
|
|
|
|
\section{Zahlungssicherheit}
|
|
PCI-DSS-Compliance durch:
|
|
\begin{itemize}
|
|
\item Keine Speicherung von Kreditkartendaten
|
|
\item Stripe-Integration für Zahlungsverarbeitung
|
|
\item TLS-Verschlüsselung aller Transaktionen
|
|
\item Webhook-Validierung mit Signatur
|
|
\end{itemize}
|
|
|
|
\chapter{Abschluss}
|
|
|
|
\section{Projektziel}
|
|
|
|
\subsection{Wurde das Projektziel erreicht?}
|
|
Das Projektziel wurde erfolgreich erreicht. Die Casino Gaming Platform wurde innerhalb der vorgegebenen 70 Stunden vollständig entwickelt und implementiert.
|
|
|
|
\subsubsection{Soll-Ist Vergleich}
|
|
\begin{longtable}{|p{6cm}|p{3cm}|p{6cm}|}
|
|
\hline
|
|
\textbf{Anforderung} & \textbf{Status} & \textbf{Bemerkung} \\
|
|
\hline
|
|
5 Casino-Spiele & \ding{51} Erreicht & Blackjack, Slots, Dice, Coinflip, Lootboxes \\
|
|
\hline
|
|
OAuth2-Authentifizierung & \ding{51} Erreicht & GitHub und Google Integration \\
|
|
\hline
|
|
Stripe-Zahlungssystem & \ding{51} Erreicht & Vollständig funktionstüchtig \\
|
|
\hline
|
|
Responsive Design & \ding{51} Erreicht & Mobile-First Ansatz \\
|
|
\hline
|
|
Transaktionshistorie & \ding{51} Erreicht & Vollständige Nachverfolgung \\
|
|
\hline
|
|
DSGVO-Konformität & \ding{51} Erreicht & Datenschutz implementiert \\
|
|
\hline
|
|
API-Dokumentation & \ding{51} Erreicht & Swagger/OpenAPI \\
|
|
\hline
|
|
\end{longtable}
|
|
|
|
\subsection{Änderungen zur anfänglichen Planung}
|
|
\begin{itemize}
|
|
\item \textbf{Poker-Spiel:} Wurde auf zukünftige Version verschoben aufgrund der Komplexität
|
|
\item \textbf{WebSocket-Integration:} Zusätzlich implementiert für Real-time Updates
|
|
\item \textbf{Docker-Containerisierung:} Früher als geplant eingeführt für bessere Entwicklungsumgebung
|
|
\end{itemize}
|
|
|
|
\subsection{Einhaltung des zeitlichen Rahmens}
|
|
Der zeitliche Rahmen von 70 Stunden wurde eingehalten:
|
|
|
|
\begin{itemize}
|
|
\item \textbf{Analyse \& Design:} 15 Stunden (geplant: 20 Stunden)
|
|
\item \textbf{Backend-Entwicklung:} 25 Stunden (geplant: 25 Stunden)
|
|
\item \textbf{Frontend-Entwicklung:} 20 Stunden (geplant: 15 Stunden)
|
|
\item \textbf{Testing \& QA:} 8 Stunden (geplant: 8 Stunden)
|
|
\item \textbf{Dokumentation:} 2 Stunden (geplant: 2 Stunden)
|
|
\end{itemize}
|
|
|
|
\section{Fazit}
|
|
|
|
\subsection{Teamarbeit}
|
|
\textbf{Wie hat die Teamarbeit funktioniert?}
|
|
|
|
\begin{itemize}
|
|
\item \textbf{Positive Aspekte:}
|
|
\begin{itemize}
|
|
\item Gute Kommunikation über Scrum Daily Standups
|
|
\item Klare Aufgabenverteilung durch Jira-Tickets
|
|
\item Effektive Code-Reviews über Pull Requests
|
|
\item Konstruktive Problemlösungen im Team
|
|
\end{itemize}
|
|
|
|
\item \textbf{Verbesserungspotential:}
|
|
\begin{itemize}
|
|
\item Besseres Ticket-Handling in der Anfangsphase
|
|
\item Weniger informelle Gespräche während Arbeitszeit
|
|
\item Frühzeitigere Integration von Komponenten
|
|
\end{itemize}
|
|
\end{itemize}
|
|
|
|
\subsection{Persönlicher Lerngewinn}
|
|
\textbf{Was hat das Projekt mir persönlich gebracht?}
|
|
|
|
\begin{itemize}
|
|
\item \textbf{Technische Kompetenzen:}
|
|
\begin{itemize}
|
|
\item Vertiefung in Angular 20 und moderne Frontend-Entwicklung
|
|
\item Praktische Erfahrung mit Spring Boot und Microservices
|
|
\item OAuth2 und JWT-basierte Authentifizierung
|
|
\item Container-Technologien (Docker, Docker Compose)
|
|
\item CI/CD-Pipelines mit GitHub Actions
|
|
\end{itemize}
|
|
|
|
\item \textbf{Methodische Kompetenzen:}
|
|
\begin{itemize}
|
|
\item Agile Softwareentwicklung mit Scrum
|
|
\item Test-Driven Development (TDD)
|
|
\item Domain-Driven Design (DDD)
|
|
\item Clean Code Prinzipien
|
|
\end{itemize}
|
|
|
|
\item \textbf{Projektmanagement:}
|
|
\begin{itemize}
|
|
\item Zeitmanagement bei komplexen Projekten
|
|
\item Risikomanagement und Problemlösung
|
|
\item Stakeholder-Kommunikation
|
|
\item Dokumentation und Präsentation
|
|
\end{itemize}
|
|
\end{itemize}
|
|
|
|
\subsection{Ausblick}
|
|
Die entwickelte Casino Gaming Platform bietet eine solide Grundlage für weitere Entwicklungen. Die moderne Architektur und der saubere Code ermöglichen es, das System kontinuierlich zu erweitern und zu verbessern.
|
|
|
|
\subsubsection{Geplante Erweiterungen}
|
|
\begin{itemize}
|
|
\item \textbf{Kurzfristig (3 Monate):} Mobile Apps für iOS und Android
|
|
\item \textbf{Mittelfristig (6 Monate):} Multiplayer-Funktionen und Turniere
|
|
\item \textbf{Langfristig (12 Monate):} KI-basierte Spielempfehlungen und erweiterte Analytics
|
|
\end{itemize}
|
|
|
|
Das Projekt hat gezeigt, dass mit modernen Technologien und agilen Methoden auch komplexe Anwendungen effizient und qualitativ hochwertig entwickelt werden können.
|
|
|
|
\appendix
|
|
\chapter{Anhang}
|
|
|
|
\section{Glossar}
|
|
\begin{description}
|
|
\item[API] Application Programming Interface - Schnittstelle zur Kommunikation zwischen Softwarekomponenten
|
|
\item[CI/CD] Continuous Integration/Continuous Deployment - Automatisierte Build- und Deployment-Prozesse
|
|
\item[DDD] Domain-Driven Design - Softwaredesign-Ansatz
|
|
\item[DSGVO] Datenschutz-Grundverordnung
|
|
\item[JWT] JSON Web Token - Standard für sichere Informationsübertragung
|
|
\item[OAuth2] Autorisierungsframework für sichere API-Zugriffe
|
|
\item[PCI-DSS] Payment Card Industry Data Security Standard
|
|
\item[REST] Representational State Transfer - Architekturstil für Web-Services
|
|
\item[SSO] Single Sign-On - Einmalige Anmeldung für mehrere Dienste
|
|
\end{description}
|
|
|
|
\section{Literaturverzeichnis}
|
|
\begin{enumerate}
|
|
\item Spring Boot Reference Documentation, Version 3.2, Spring Framework Team, 2024
|
|
\item Angular Developer Guide, Version 20, Angular Team, Google, 2024
|
|
\item Keycloak Server Administration Guide, Red Hat, 2024
|
|
\item Stripe API Reference, Stripe Inc., 2024
|
|
\item PostgreSQL Documentation, Version 17, PostgreSQL Global Development Group, 2024
|
|
\item Docker Documentation, Docker Inc., 2024
|
|
\item Clean Architecture, Robert C. Martin, Prentice Hall, 2017
|
|
\item Domain-Driven Design, Eric Evans, Addison-Wesley, 2003
|
|
\end{enumerate}
|
|
|
|
\section{Abbildungsverzeichnis}
|
|
\begin{enumerate}
|
|
\item Systemarchitektur-Diagramm
|
|
\item ER-Diagramm der Datenbank
|
|
\item Sequenzdiagramm Authentifizierung
|
|
\item Klassendiagramm Backend
|
|
\item Komponentendiagramm Frontend
|
|
\end{enumerate}
|
|
|
|
\section{Tabellenverzeichnis}
|
|
\begin{enumerate}
|
|
\item Projektphasen und Zeitaufwand
|
|
\item Technologie-Stack Übersicht
|
|
\item API-Endpoints Dokumentation
|
|
\item Testabdeckung pro Modul
|
|
\end{enumerate}
|
|
|
|
\end{document} |