Initialer commit

session-service/.classpath

@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" output="bin/main" path="src/main/java">
+		<attributes>
+			<attribute name="gradle_scope" value="main"/>
+			<attribute name="gradle_used_by_scope" value="main,test"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" output="bin/main" path="src/main/webapp">
+		<attributes>
+			<attribute name="gradle_scope" value="main"/>
+			<attribute name="gradle_used_by_scope" value="main,test"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" output="bin/main" path="src/main/resources">
+		<attributes>
+			<attribute name="gradle_scope" value="main"/>
+			<attribute name="gradle_used_by_scope" value="main,test"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-17/"/>
+	<classpathentry kind="con" path="org.eclipse.jst.j2ee.internal.web.container"/>
+	<classpathentry kind="con" path="org.eclipse.buildship.core.gradleclasspathcontainer">
+		<attributes>
+			<attribute name="org.eclipse.jst.component.nondependency" value=""/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" path="/framework">
+		<attributes>
+			<attribute name="without_test_code" value="true"/>
+			<attribute name="org.eclipse.jst.component.nondependency" value=""/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="output" path="bin/default"/>
+</classpath>

session-service/.project

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>session-service</name>
+	<comment></comment>
+	<projects/>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.wst.common.project.facet.core.nature</nature>
+		<nature>org.eclipse.wst.common.modulecore.ModuleCoreNature</nature>
+		<nature>org.eclipse.jem.workbench.JavaEMFNature</nature>
+		<nature>org.eclipse.buildship.core.gradleprojectnature</nature>
+	</natures>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments/>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.wst.common.project.facet.core.builder</name>
+			<arguments/>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.wst.validation.validationbuilder</name>
+			<arguments/>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.buildship.core.gradleprojectbuilder</name>
+			<arguments/>
+		</buildCommand>
+	</buildSpec>
+	<linkedResources/>
+	<filteredResources/>
+</projectDescription>

session-service/.settings/org.eclipse.buildship.core.prefs

@@ -0,0 +1,2 @@
+connection.project.dir=..
+eclipse.preferences.version=1

session-service/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,13 @@
+#
+#Sat Apr 01 12:17:22 CEST 2023
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=17
+org.eclipse.jdt.core.compiler.source=17
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.compliance=17
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate

session-service/.settings/org.eclipse.wst.common.component

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project-modules id="moduleCoreId" project-version="1.5.0">
+	<wb-module deploy-name="session-service">
+		<property name="context-root" value="session-service"/>
+		<wb-resource deploy-path="/WEB-INF/classes" source-path="src/main/resources"/>
+		<wb-resource deploy-path="/WEB-INF/classes" source-path="src/main/webapp"/>
+		<wb-resource deploy-path="/WEB-INF/classes" source-path="src/main/java"/>
+		<wb-resource deploy-path="/" source-path="src/main/webapp"/>
+		<dependent-module deploy-path="/WEB-INF/lib" handle="module:/resource/framework/framework">
+			<dependency-type>uses</dependency-type>
+		</dependent-module>
+	</wb-module>
+</project-modules>

session-service/.settings/org.eclipse.wst.common.project.facet.core.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<faceted-project>
+	<fixed facet="jst.java"/>
+	<fixed facet="jst.web"/>
+	<installed facet="jst.web" version="2.4"/>
+	<installed facet="jst.java" version="17"/>
+</faceted-project>

session-service/bin/main/META-INF/hibernate.cfg.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE hibernate-configuration PUBLIC
+        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
+        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
+
+<hibernate-configuration>
+    <session-factory>
+        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
+
+        <!-- Validate the database schema on startup -->
+        <property name="hbm2ddl.auto">validate</property>
+    </session-factory>
+</hibernate-configuration>

session-service/bin/main/META-INF/persistence.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<persistence xmlns="http://java.sun.com/xml/ns/persistence"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence 
+    	http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"
+    version="1.0" >
+
+	<persistence-unit name="registration"
+		transaction-type="JTA">
+		<provider>org.hibernate.ejb.HibernatePersistence</provider>
+		<jta-data-source>java:/Session</jta-data-source>
+		<properties>
+			<property name="hibernate.dialect"
+				value="org.hibernate.dialect.MySQLDialect" />
+			<property
+				name="javax.persistence.schema-generation.database.action"
+				value="drop-and-create" />
+		</properties>
+	</persistence-unit>
+</persistence>

session-service/bin/main/WEB-INF/web.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?><web-app version="5.0"
+         xmlns="https://jakarta.ee/xml/ns/jakartaee"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd">
+	
+</web-app>

session-service/bin/main/index.html

@@ -0,0 +1 @@
+<h1>Was machst du hier?</h1>

session-service/bin/main/log4j2.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Configuration status="INFO">
+    <Appenders>
+        <Console name="Console" target="SYSTEM_OUT">
+            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />
+        </Console>
+        <File name="MyFile" fileName="all.log" immediateFlush="false" append="false">
+            <PatternLayout pattern="%d{yyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
+        </File>
+    </Appenders>
+    <Loggers>
+        <Root level="debug">
+            <AppenderRef ref="Console" />
+            <AppenderRef ref="MyFile"/>
+        </Root>
+    </Loggers>
+</Configuration>

session-service/build.gradle

@@ -0,0 +1,39 @@
+plugins {
+	id 'java'
+    id 'war'
+    id 'eclipse'
+}
+
+repositories {
+    mavenCentral()
+}
+
+sourceSets {
+    main {
+        java {
+            srcDir 'src/main/java'
+        }
+        resources {
+        	srcDir 'src/main/webapp' 
+//        	srcDir 'src/main/resources'
+        }
+    }
+}
+
+dependencies {
+	implementation project(':framework')
+	
+	compileOnly 'jakarta.platform:jakarta.jakartaee-web-api:9.0.0'
+	compileOnly 'jakarta.persistence:jakarta.persistence-api:3.1.0'
+	compileOnly 'jakarta.resource:jakarta.resource-api:2.1.0'
+		
+	compileOnly 'org.jboss.ejb3:jboss-ejb3-ext-api:2.3.0.Final'
+	
+	compileOnly 'org.apache.logging.log4j:log4j-slf4j-impl:2.20.0'
+   
+    testImplementation 'org.junit.jupiter:junit-jupiter:5.8.1'
+}
+
+tasks.named('test') {
+   useJUnitPlatform()
+}

session-service/build/resources/main/META-INF/hibernate.cfg.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE hibernate-configuration PUBLIC
+        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
+        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
+
+<hibernate-configuration>
+    <session-factory>
+        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
+
+        <!-- Validate the database schema on startup -->
+        <property name="hbm2ddl.auto">validate</property>
+    </session-factory>
+</hibernate-configuration>

session-service/build/resources/main/META-INF/persistence.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<persistence xmlns="http://java.sun.com/xml/ns/persistence"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence 
+    	http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"
+    version="1.0" >
+
+	<persistence-unit name="registration"
+		transaction-type="JTA">
+		<provider>org.hibernate.ejb.HibernatePersistence</provider>
+		<jta-data-source>java:/Session</jta-data-source>
+		<properties>
+			<property name="hibernate.dialect"
+				value="org.hibernate.dialect.MySQLDialect" />
+			<property
+				name="javax.persistence.schema-generation.database.action"
+				value="drop-and-create" />
+		</properties>
+	</persistence-unit>
+</persistence>

session-service/build/resources/main/WEB-INF/web.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?><web-app version="5.0"
+         xmlns="https://jakarta.ee/xml/ns/jakartaee"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd">
+	
+</web-app>

session-service/build/resources/main/index.html

@@ -0,0 +1 @@
+<h1>Was machst du hier?</h1>

session-service/build/resources/main/log4j2.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Configuration status="INFO">
+    <Appenders>
+        <Console name="Console" target="SYSTEM_OUT">
+            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />
+        </Console>
+        <File name="MyFile" fileName="all.log" immediateFlush="false" append="false">
+            <PatternLayout pattern="%d{yyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
+        </File>
+    </Appenders>
+    <Loggers>
+        <Root level="debug">
+            <AppenderRef ref="Console" />
+            <AppenderRef ref="MyFile"/>
+        </Root>
+    </Loggers>
+</Configuration>

session-service/build/tmp/war/MANIFEST.MF

@@ -0,0 +1,2 @@
+Manifest-Version: 1.0
+

session-service/src/main/java/de/oaa/xxx/session/AktiveSperre.java

@@ -0,0 +1,72 @@
+package de.oaa.xxx.session;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.UUID;
+
+public class AktiveSperre {
+
+	private UUID aktiveSperreId;
+	private Mitspieler mitspieler;
+	private Integer minuten;
+	private LocalDateTime startzeit;
+	private LocalDateTime endzeit;
+	private List<Werkzeug> fuer;
+	private String releaseText;
+
+	public UUID getAktiveSperreId() {
+		return aktiveSperreId;
+	}
+
+	public void setAktiveSperreId(UUID aktiveSperreId) {
+		this.aktiveSperreId = aktiveSperreId;
+	}
+
+	public Mitspieler getMitspieler() {
+		return mitspieler;
+	}
+
+	public void setMitspieler(Mitspieler mitspieler) {
+		this.mitspieler = mitspieler;
+	}
+
+	public Integer getMinuten() {
+		return minuten;
+	}
+
+	public void setMinuten(Integer minuten) {
+		this.minuten = minuten;
+	}
+
+	public LocalDateTime getStartzeit() {
+		return startzeit;
+	}
+
+	public void setStartzeit(LocalDateTime startzeit) {
+		this.startzeit = startzeit;
+	}
+
+	public LocalDateTime getEndzeit() {
+		return endzeit;
+	}
+
+	public void setEndzeit(LocalDateTime endzeit) {
+		this.endzeit = endzeit;
+	}
+
+	public List<Werkzeug> getFuer() {
+		return fuer;
+	}
+
+	public void setFuer(List<Werkzeug> fuer) {
+		this.fuer = fuer;
+	}
+
+	public String getReleaseText() {
+		return releaseText;
+	}
+
+	public void setReleaseText(String releaseText) {
+		this.releaseText = releaseText;
+	}
+}

session-service/src/main/java/de/oaa/xxx/session/AufgabeAnzeige.java

@@ -0,0 +1,42 @@
+package de.oaa.xxx.session;
+
+public class AufgabeAnzeige {
+
+	private String nameAktiverMitspieler;
+	private String aufgabeText;
+	private Integer timer;
+	
+	private Callback callback;
+
+	public String getNameAktiverMitspieler() {
+		return nameAktiverMitspieler;
+	}
+
+	public void setNameAktiverMitspieler(String nameAktiverMitspieler) {
+		this.nameAktiverMitspieler = nameAktiverMitspieler;
+	}
+
+	public String getAufgabeText() {
+		return aufgabeText;
+	}
+
+	public void setAufgabeText(String aufgabeText) {
+		this.aufgabeText = aufgabeText;
+	}
+
+	public Integer getTimer() {
+		return timer;
+	}
+
+	public void setTimer(Integer timer) {
+		this.timer = timer;
+	}
+
+	public Callback getCallback() {
+		return callback;
+	}
+
+	public void setCallback(Callback callback) {
+		this.callback = callback;
+	}
+}

session-service/src/main/java/de/oaa/xxx/session/AufgabeArt.java

@@ -0,0 +1,8 @@
+package de.oaa.xxx.session;
+
+public enum AufgabeArt {
+
+	AUFGABE,
+	STRAFE,
+	SPERRE;
+}

session-service/src/main/java/de/oaa/xxx/session/Callback.java

@@ -0,0 +1,16 @@
+package de.oaa.xxx.session;
+
+import java.util.UUID;
+
+public abstract class Callback {
+
+	private UUID sessionId;
+
+	public UUID getSessionId() {
+		return sessionId;
+	}
+
+	public void setSessionId(UUID sessionId) {
+		this.sessionId = sessionId;
+	}
+}

session-service/src/main/java/de/oaa/xxx/session/GeschlechtEnum.java

@@ -0,0 +1,7 @@
+package de.oaa.xxx.session;
+
+public enum GeschlechtEnum {
+	WEIBLICH,
+	DIVERS,
+	MAENNLICH;
+}

session-service/src/main/java/de/oaa/xxx/session/Mitspieler.java

@@ -0,0 +1,76 @@
+package de.oaa.xxx.session;
+
+import java.util.List;
+import java.util.UUID;
+
+public class Mitspieler {
+
+	private UUID id;
+	private String name;
+	private GeschlechtEnum geschlecht;
+	private List<GeschlechtEnum> spieltMit;
+	private List<RolleEnum> rollen;
+	private List<Werkzeug> verfuegbareWerkzeuge;
+
+	public List<RolleEnum> getRollen() {
+		return rollen;
+	}
+
+	public void setRollen(List<RolleEnum> rollen) {
+		this.rollen = rollen;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public GeschlechtEnum getGeschlecht() {
+		return geschlecht;
+	}
+
+	public void setGeschlecht(GeschlechtEnum geschlecht) {
+		this.geschlecht = geschlecht;
+	}
+
+	public List<GeschlechtEnum> getSpieltMit() {
+		return spieltMit;
+	}
+
+	public void setSpieltMit(List<GeschlechtEnum> spieltMit) {
+		this.spieltMit = spieltMit;
+	}
+
+	public List<Werkzeug> getVerfuegbareWerkzeuge() {
+		return verfuegbareWerkzeuge;
+	}
+
+	public void setVerfuegbareWerkzeuge(List<Werkzeug> verfuegbareWerkzeuge) {
+		this.verfuegbareWerkzeuge = verfuegbareWerkzeuge;
+	}
+
+	public boolean isVerfuegbar(Werkzeug werkzeug) {
+		return verfuegbareWerkzeuge.contains(werkzeug);
+	}
+	
+	public boolean isPassenderSpielpartner(Mitspieler other) {
+		if (!spieltMit.contains(other.getGeschlecht())) {
+			return false;
+		}
+		if (!other.spieltMit.contains(geschlecht)) {
+			return false;
+		}
+		return true;
+	}
+
+	public UUID getId() {
+		return id;
+	}
+
+	public void setId(UUID id) {
+		this.id = id;
+	}
+}

session-service/src/main/java/de/oaa/xxx/session/RolleEnum.java

@@ -0,0 +1,9 @@
+package de.oaa.xxx.session;
+
+public enum RolleEnum {
+
+	BESTRAFUNG_AKTIV,
+	BESTRAFUNG_PASSIV,
+	AUFGABE_AKTIV,
+	AUFGABE_PASSIV;
+}

session-service/src/main/java/de/oaa/xxx/session/Session.java

@@ -0,0 +1,61 @@
+package de.oaa.xxx.session;
+
+import java.util.UUID;
+
+public class Session {
+
+	private UUID sessionId;
+	private UUID userId;
+	private Integer wahrscheinlichkeitSperre;
+	private Integer wahrscheinlichkeitStrafe;
+	private Integer aufgabenProLevel;
+	private Double zeitfaktorZeitstrafen;
+
+	public UUID getUserId() {
+		return userId;
+	}
+
+	public void setUserId(UUID userId) {
+		this.userId = userId;
+	}
+
+	public Integer getWahrscheinlichkeitSperre() {
+		return wahrscheinlichkeitSperre;
+	}
+
+	public void setWahrscheinlichkeitSperre(Integer wahrscheinlichkeitSperre) {
+		this.wahrscheinlichkeitSperre = wahrscheinlichkeitSperre;
+	}
+
+	public Integer getWahrscheinlichkeitStrafe() {
+		return wahrscheinlichkeitStrafe;
+	}
+
+	public void setWahrscheinlichkeitStrafe(Integer wahrscheinlichkeitStrafe) {
+		this.wahrscheinlichkeitStrafe = wahrscheinlichkeitStrafe;
+	}
+
+	public Integer getAufgabenProLevel() {
+		return aufgabenProLevel;
+	}
+
+	public void setAufgabenProLevel(Integer aufgabenProLevel) {
+		this.aufgabenProLevel = aufgabenProLevel;
+	}
+
+	public Double getZeitfaktorZeitstrafen() {
+		return zeitfaktorZeitstrafen;
+	}
+
+	public void setZeitfaktorZeitstrafen(Double zeitfaktorZeitstrafen) {
+		this.zeitfaktorZeitstrafen = zeitfaktorZeitstrafen;
+	}
+
+	public UUID getSessionId() {
+		return sessionId;
+	}
+
+	public void setSessionId(UUID sessionId) {
+		this.sessionId = sessionId;
+	}
+}

session-service/src/main/java/de/oaa/xxx/session/SessionDurchfuehren.java

@@ -0,0 +1,205 @@
+package de.oaa.xxx.session;
+
+import java.util.List;
+import java.util.Random;
+import java.util.stream.Collectors;
+
+import de.oaa.xxx.session.aufgaben.Aufgabe;
+import de.oaa.xxx.session.aufgaben.AufgabenList;
+import de.oaa.xxx.session.aufgaben.Sperre;
+import de.oaa.xxx.session.aufgaben.Strafe;
+import de.oaa.xxx.session.entity.SessionEntity;
+import de.oaa.xxx.session.sperre.SperreCallback;
+import de.oaa.xxx.session.sperre.SperrenVerlaengernCallback;
+import jakarta.json.bind.JsonbBuilder;
+
+public class SessionDurchfuehren {
+
+	private AufgabenList aufgabenList;
+	private List<Mitspieler> mitspieler;
+	private List<AktiveSperre> aktiveSperren;
+	
+	private Integer wahrscheinlichkeitSperre;
+	private Integer wahrscheinlichkeitStrafe;
+	
+	private Integer aufgabenProLevel;
+	private Integer level;
+	private Integer aufgabenAufAktuellemLevel;
+	
+	public SessionDurchfuehren(SessionEntity entity) {
+		aufgabenList = JsonbBuilder.create().fromJson(entity.getAufgaben(), AufgabenList.class);
+		entity.getMitspieler().forEach(mitspielerEntity -> mitspieler.add(mitspielerEntity.toMitspieler()));
+		entity.getAktiveSperren().forEach(sperreEntity -> aktiveSperren.add(sperreEntity.toSperre(mitspieler)));
+		
+		wahrscheinlichkeitSperre = entity.getWahrscheinlichkeitSperre();
+		wahrscheinlichkeitStrafe = entity.getWahrscheinlichkeitStrafe();
+		
+		aufgabenProLevel = entity.getAufgabenProLevel();
+		level = entity.getLevel();
+		aufgabenAufAktuellemLevel = entity.getAufgabenAufAktuellemLevel();
+	}
+	
+	public AufgabeAnzeige getNext() {
+		checkLevel();
+		AufgabeAnzeige anzeige = null;
+		int nextInt = new Random().nextInt(1, 100);
+		if (nextInt == 1) {
+			anzeige = findUltimativeStrafe();
+		} else if (nextInt == 2) {
+			anzeige = findSperreVerlaengern();
+		} else if (nextInt > wahrscheinlichkeitSperre + wahrscheinlichkeitStrafe + 2) {
+			anzeige = findeAufgabe();
+		} else if (nextInt > wahrscheinlichkeitSperre + 2) {
+			anzeige = findeStrafe();
+		} else {
+			anzeige = findeSperre();
+		}
+		if (anzeige == null) {
+			Mitspieler aktiv = findeMitspielerMitRolle(RolleEnum.AUFGABE_AKTIV);
+			Mitspieler passiv = findeMitspielerMitRolle(RolleEnum.AUFGABE_PASSIV, aktiv);
+			String text = "Ups, da ist etwas schief gelaufen. Keine Potentielle Aufgabe gefunden. Entweder seid ihr inzwischen so gut weggesperrt, dass wirklich keine Aufgaben mehr zur Verfügung stehen, oder uns ist ein Fehler unterlaufen. {AKTIV} und {PASSIV} überbücken die Zeit mit ein wenig Petting.";
+			anzeige = new AufgabeAnzeige();
+			anzeige.setNameAktiverMitspieler(aktiv.getName());
+			anzeige.setAufgabeText(getAnzeigeText(text, aktiv.getName(), passiv.getName()));
+			anzeige.setTimer(120);
+		}
+		return anzeige;
+	}
+	
+	private void checkLevel() {
+		if (++aufgabenAufAktuellemLevel >= aufgabenProLevel && level < 5) {
+			aufgabenAufAktuellemLevel = 0;
+			level++;
+		}
+	}
+	
+	private AufgabeAnzeige findUltimativeStrafe() {
+		Mitspieler aktiv = findeMitspielerMitRolle(RolleEnum.BESTRAFUNG_AKTIV);
+		if (aktiv != null) {
+			Mitspieler passiv = findeMitspielerMitRolle(RolleEnum.BESTRAFUNG_PASSIV, aktiv);
+			if (passiv != null) {				
+				String text = "{AKTIV}, verschnüre {PASSIV} fachmännisch inkl. KG, Plugs, Knebel, Aufgabebinde und was dir sonst einfällt. Nutze die Ruhe für was auch immer du möchtest.";
+				AufgabeAnzeige anzeige = new AufgabeAnzeige();
+				anzeige.setNameAktiverMitspieler(aktiv.getName());
+				anzeige.setAufgabeText(getAnzeigeText(text, aktiv.getName(), passiv.getName()));
+				anzeige.setTimer(new Random().nextInt(1800, 7200));
+				return anzeige;
+			}
+		}
+		return findeStrafe();
+	}
+	
+	private AufgabeAnzeige findSperreVerlaengern() {
+		if (aktiveSperren != null && !aktiveSperren.isEmpty()) {
+			AktiveSperre sperre = aktiveSperren.get(new Random().nextInt(aktiveSperren.size()));
+			Mitspieler passiv = sperre.getMitspieler();
+			Mitspieler aktiv = findeMitspielerMitRolle(RolleEnum.BESTRAFUNG_AKTIV, passiv);
+			if (aktiv != null) {
+				String text = "{AKTIV}, du entscheidest. Sollen alle bestehnden Zeitstrafen von {PASSIV} verlängert werden...?";
+				AufgabeAnzeige anzeige=  new AufgabeAnzeige();
+				anzeige.setAufgabeText(getAnzeigeText(text, aktiv.getName(), passiv.getName()));
+				anzeige.setNameAktiverMitspieler(aktiv.getName());
+				SperrenVerlaengernCallback callback = new SperrenVerlaengernCallback();
+				callback.setFaktor(new Random().nextInt(2, 4));
+				callback.setSpielerId(passiv.getId());
+				anzeige.setCallback(callback);
+				return anzeige;
+			}
+		}
+		return findeSperre();
+	}
+	
+	private AufgabeAnzeige findeAufgabe() {
+		Mitspieler aktiv = findeMitspielerMitRolle(RolleEnum.AUFGABE_AKTIV);
+		if (aktiv != null) {
+			Mitspieler passiv = findeMitspielerMitRolle(RolleEnum.AUFGABE_PASSIV, aktiv);
+			if (passiv != null) {
+				List<Aufgabe> list = aufgabenList.getAufgaben().stream().filter(aufgabe -> aufgabe.isAufgabePassend(level, aktiv, passiv)).collect(Collectors.toList());
+				if (list != null && list.size() > 0) {
+					Aufgabe aufgabe = list.get(new Random().nextInt(list.size()));
+					AufgabeAnzeige anzeige=  new AufgabeAnzeige();
+					anzeige.setNameAktiverMitspieler(aktiv.getName());
+					anzeige.setAufgabeText(getAnzeigeText(aufgabe.getText(), aktiv.getName(), passiv.getName()));				
+					if (aufgabe.getSekundenVon() != null) {
+						if (aufgabe.getSekundenBis() != null) {
+							anzeige.setTimer(new Random().nextInt(aufgabe.getSekundenVon(), aufgabe.getSekundenBis()));
+						} else {
+							anzeige.setTimer(aufgabe.getSekundenVon());
+						}
+					}
+					return anzeige;
+				}
+			}
+		}
+		return findeStrafe();
+	}
+	
+	private AufgabeAnzeige findeStrafe() {
+		Mitspieler aktiv = findeMitspielerMitRolle(RolleEnum.BESTRAFUNG_AKTIV);
+		if (aktiv != null) {
+			Mitspieler passiv = findeMitspielerMitRolle(RolleEnum.BESTRAFUNG_PASSIV, aktiv);
+			if (passiv != null) {
+				List<Strafe> list = aufgabenList.getStrafen().stream().filter(sperre -> sperre.isAufgabePassend(level, aktiv, passiv)).collect(Collectors.toList());
+				if (list != null && list.size() > 0) {
+					Strafe strafe = list.get(new Random().nextInt(list.size()));
+					AufgabeAnzeige anzeige=  new AufgabeAnzeige();
+					anzeige.setNameAktiverMitspieler(aktiv.getName());
+					anzeige.setAufgabeText(getAnzeigeText(strafe.getText(), aktiv.getName(), passiv.getName()));				
+					if (strafe.getSekundenVon() != null) {
+						if (strafe.getSekundenBis() != null) {
+							anzeige.setTimer(new Random().nextInt(strafe.getSekundenVon(), strafe.getSekundenBis()));
+						} else {
+							anzeige.setTimer(strafe.getSekundenVon());
+						}
+					}
+					return anzeige;
+				}
+			}
+		}
+		return findeSperre();
+	}
+	
+	private AufgabeAnzeige findeSperre() {
+		Mitspieler aktiv = findeMitspielerMitRolle(RolleEnum.BESTRAFUNG_AKTIV);
+		if (aktiv != null) {
+			Mitspieler passiv = findeMitspielerMitRolle(RolleEnum.BESTRAFUNG_PASSIV, aktiv);
+			if (passiv != null) {
+				List<Sperre> list = aufgabenList.getSperren().stream().filter(sperre -> sperre.isAufgabePassend(passiv)).collect(Collectors.toList());
+				if (list != null && list.size() > 0) {
+					Sperre sperre = list.get(new Random().nextInt(list.size()));
+					AufgabeAnzeige anzeige=  new AufgabeAnzeige();
+					anzeige.setNameAktiverMitspieler(aktiv.getName());
+					anzeige.setAufgabeText(getAnzeigeText(sperre.getText(), aktiv.getName(), passiv.getName()));				
+					SperreCallback callback = new SperreCallback();
+					callback.setSperreId(sperre.getSperreId());
+					callback.setSpielerId(passiv.getId());
+					callback.setReleaseText(getAnzeigeText(sperre.getReleaseText(), aktiv.getName(), passiv.getName()));
+					return anzeige;
+				}
+			}
+		}
+		return null;
+	}
+	
+	private String getAnzeigeText(String textMitPlatzhaltern, String nameAktiv, String namePassiv) {
+		return textMitPlatzhaltern.replace("{AKTIV}", nameAktiv).replace("{PASSIV}", namePassiv);
+	}
+	private Mitspieler findeMitspielerMitRolle(RolleEnum rolle) {
+		List<Mitspieler> list = mitspieler.stream().filter(mitspieler -> mitspieler.getRollen().contains(rolle)).toList();
+		if (list != null && list.size() > 0) {
+			return list.get(new Random().nextInt(list.size()));
+		}
+		return null;
+	}
+	
+	private Mitspieler findeMitspielerMitRolle(RolleEnum rolle, Mitspieler gengespieler) {
+		List<Mitspieler> list = mitspieler.stream().
+				filter(mitspieler -> mitspieler != gengespieler).
+				filter(mitspieler -> mitspieler.isPassenderSpielpartner(gengespieler)).
+				filter(mitspieler -> mitspieler.getRollen().contains(rolle)).toList();
+		if (list != null && list.size() > 0) {
+			return list.get(new Random().nextInt(list.size()));
+		}
+		return null;
+	}
+}

session-service/src/main/java/de/oaa/xxx/session/SessionResource.java

@@ -0,0 +1,243 @@
+package de.oaa.xxx.session;
+
+import java.time.LocalDateTime;
+import java.util.UUID;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import de.oaa.xxx.framework.request.RequestChecker;
+import de.oaa.xxx.session.aufgaben.AufgabenList;
+import de.oaa.xxx.session.entity.MitspielerDAO;
+import de.oaa.xxx.session.entity.MitspielerEntity;
+import de.oaa.xxx.session.entity.SessionDAO;
+import de.oaa.xxx.session.entity.SessionEntity;
+import jakarta.annotation.Resource;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.json.bind.JsonbBuilder;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.transaction.SystemException;
+import jakarta.transaction.UserTransaction;
+import jakarta.ws.rs.PathParam;
+import jakarta.ws.rs.Consumes;
+import jakarta.ws.rs.DELETE;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.POST;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.QueryParam;
+import jakarta.ws.rs.core.Context;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
+import jakarta.ws.rs.core.Response.Status;
+import jakarta.ws.rs.core.UriInfo;
+
+@ApplicationScoped
+@Path("session")
+public class SessionResource {
+
+
+	private Logger LOGGER = LoggerFactory.getLogger(getClass());
+	
+	@PersistenceContext(name = "aufgaben")
+	private EntityManager entityManager;
+	@Resource
+	private UserTransaction transaction;
+	
+	@GET
+	@Path("{sessionId}")
+	@Produces(MediaType.APPLICATION_JSON)
+	public Response getBySessionId(@PathParam("sessionId") UUID sessionId, @Context HttpServletRequest req) throws IllegalStateException, SecurityException, SystemException {
+		try {
+			RequestChecker.checkRequest(req);
+			transaction.begin();
+			SessionEntity entity = new SessionDAO(entityManager).findById(sessionId);
+			if (entity != null) {
+				Session session = new Session();
+				session.setSessionId(entity.getSessionId());
+				session.setUserId(entity.getUserId());
+				session.setAufgabenProLevel(entity.getAufgabenAufAktuellemLevel());
+				session.setWahrscheinlichkeitSperre(entity.getWahrscheinlichkeitSperre());
+				session.setWahrscheinlichkeitStrafe(entity.getWahrscheinlichkeitStrafe());
+				session.setZeitfaktorZeitstrafen(entity.getZeitfaktorZeitstrafen());
+				transaction.commit();
+				return Response.ok(session).build();
+			} else {
+				transaction.rollback();
+				return Response.noContent().build();
+			}
+		} catch (Exception exception) {
+			LOGGER.error(exception.getMessage(), exception);
+			transaction.rollback();
+			return Response.serverError().build();
+		}
+	}
+	
+	@GET
+	@Produces(MediaType.APPLICATION_JSON)
+	public Response getByUserId(@QueryParam("userId") UUID userId, @Context HttpServletRequest req) throws IllegalStateException, SecurityException, SystemException {
+		try {
+			RequestChecker.checkRequest(req);
+			transaction.begin();
+			SessionEntity entity = new SessionDAO(entityManager).findByUserId(userId);
+			if (entity != null) {
+				Session session = new Session();
+				session.setSessionId(entity.getSessionId());
+				session.setUserId(entity.getUserId());
+				session.setAufgabenProLevel(entity.getAufgabenAufAktuellemLevel());
+				session.setWahrscheinlichkeitSperre(entity.getWahrscheinlichkeitSperre());
+				session.setWahrscheinlichkeitStrafe(entity.getWahrscheinlichkeitStrafe());
+				session.setZeitfaktorZeitstrafen(entity.getZeitfaktorZeitstrafen());
+				transaction.commit();
+				return Response.ok(session).build();
+			} else {
+				transaction.rollback();
+				return Response.noContent().build();
+			}
+		} catch (Exception exception) {
+			LOGGER.error(exception.getMessage(), exception);
+			transaction.rollback();
+			return Response.serverError().build();
+		}
+	}
+	
+	@DELETE
+	public Response deleteSession(Session session, @Context HttpServletRequest req) throws IllegalStateException, SecurityException, SystemException {
+		try {
+			RequestChecker.checkRequest(req);
+			transaction.begin();
+			SessionEntity entity = new SessionDAO(entityManager).findByUserId(session.getSessionId());
+			if (entity != null) {
+				new SessionDAO(entityManager).remove(entity);
+				return Response.accepted().build();
+			} else {
+				transaction.rollback();
+				return Response.noContent().build();
+			}
+		} catch (Exception exception) {
+			LOGGER.error(exception.getMessage(), exception);
+			transaction.rollback();
+			return Response.serverError().build();
+		}
+	}
+	
+	@POST
+	@Consumes(MediaType.APPLICATION_JSON)
+	public Response create(Session session, @Context UriInfo uriInfo, @Context HttpServletRequest req) throws IllegalStateException, SecurityException, SystemException {
+		try {
+			UUID userId = RequestChecker.checkRequest(req).getUserId();
+			transaction.begin();
+			SessionEntity entity = new SessionEntity();
+			entity.setSessionId(UUID.randomUUID());
+			entity.setUserId(userId);
+			entity.setAufgabenAufAktuellemLevel(0);
+			entity.setAufgabenProLevel(session.getAufgabenProLevel() != null ? session.getAufgabenProLevel() : 5);
+			LocalDateTime now = LocalDateTime.now();
+			entity.setLetzteAktivitaet(now);
+			entity.setStartZeit(now);
+			entity.setWahrscheinlichkeitSperre(session.getWahrscheinlichkeitSperre() != null ? session.getWahrscheinlichkeitSperre() : 10);
+			entity.setWahrscheinlichkeitStrafe(session.getWahrscheinlichkeitStrafe() != null ? session.getWahrscheinlichkeitStrafe() : 10);
+			entity.setZeitfaktorZeitstrafen(session.getZeitfaktorZeitstrafen() != null ? session.getZeitfaktorZeitstrafen() : 1.0);
+			new SessionDAO(entityManager).persist(entity);
+			transaction.commit();
+			return Response.created(uriInfo.getAbsolutePathBuilder().path(entity.getSessionId().toString()).build())
+					.build();
+		} catch (Exception exception) {
+			LOGGER.error(exception.getMessage(), exception);
+			transaction.rollback();
+			return Response.serverError().build();
+		}
+	}
+	
+	@POST
+	@Consumes(MediaType.APPLICATION_JSON)
+	@Path("{sessionId}/aufgaben")
+	public Response setAufgaben(AufgabenList list, @PathParam("sessionId") UUID sessionId, @Context HttpServletRequest req) throws IllegalStateException, SecurityException, SystemException {
+		try {
+			RequestChecker.checkRequest(req);
+			if (list.size() > 1000) {
+				return Response.status(Status.BAD_REQUEST).build();
+			}
+			String aufgaben = JsonbBuilder.create().toJson(list);
+			transaction.begin();
+			SessionDAO dao = new SessionDAO(entityManager);
+			SessionEntity session = dao.findById(sessionId);
+			if (session == null) {
+				transaction.rollback();
+				return Response.status(Status.BAD_REQUEST).build();
+			}
+			session.setAufgaben(aufgaben);
+			dao.update(session);
+			transaction.commit();
+			return Response.accepted().build();
+		} catch (Exception exception) {
+			LOGGER.error(exception.getMessage(), exception);
+			transaction.rollback();
+			return Response.serverError().build();
+		}
+	}
+	
+	@GET
+	@Produces(MediaType.APPLICATION_JSON)
+	@Path("{sessionId}/aufgaben/next")
+	public Response getNextAufgabe(@PathParam("sessionId") UUID sessionId, @Context HttpServletRequest req) throws IllegalStateException, SecurityException, SystemException {
+		try {
+			RequestChecker.checkRequest(req);
+			transaction.begin();
+			SessionDAO dao = new SessionDAO(entityManager);
+			SessionEntity session = dao.findById(sessionId);
+			if (session == null) {
+				transaction.rollback();
+				return Response.status(Status.BAD_REQUEST).build();
+			}
+			session.setLetzteAktivitaet(LocalDateTime.now());
+			AufgabeAnzeige next = new SessionDurchfuehren(session).getNext();
+			transaction.commit();
+			return Response.ok(next).build();
+		} catch (Exception exception) {
+			LOGGER.error(exception.getMessage(), exception);
+			transaction.rollback();
+			return Response.serverError().build();
+		}
+	}
+	
+	@POST
+	@Consumes(MediaType.APPLICATION_JSON)
+	@Path("{sessionId}/mitspieler")
+	public Response addMitspieler(Mitspieler mitspieler, @PathParam("sessionId") UUID sessionId, @Context HttpServletRequest req) throws IllegalStateException, SecurityException, SystemException {
+		try {
+			RequestChecker.checkRequest(req);
+			if (mitspieler.getName() == null || mitspieler.getGeschlecht() == null || mitspieler.getRollen() == null 
+					|| mitspieler.getRollen().isEmpty() || mitspieler.getSpieltMit() == null || mitspieler.getSpieltMit().isEmpty()
+					|| mitspieler.getVerfuegbareWerkzeuge() == null || mitspieler.getVerfuegbareWerkzeuge().isEmpty()) {
+				return Response.status(Status.BAD_REQUEST).build();
+			}
+			transaction.begin();
+			SessionDAO dao = new SessionDAO(entityManager);
+			SessionEntity session = dao.findById(sessionId);
+			if (session == null) {
+				transaction.rollback();
+				return Response.status(Status.BAD_REQUEST).build();
+			}
+			
+			MitspielerEntity entity = new MitspielerEntity();
+			entity.setMitspielerId(UUID.randomUUID());
+			entity.setGeschlecht(mitspieler.getGeschlecht());
+			entity.setName(mitspieler.getName());
+			entity.setRollen(mitspieler.getRollen());
+			entity.setSpieltMit(mitspieler.getSpieltMit());
+			entity.setWerkzeuge(mitspieler.getVerfuegbareWerkzeuge());
+			entity.setSession(session);
+			new MitspielerDAO(entityManager).persist(entity);
+			transaction.commit();
+			return Response.accepted().build();
+		} catch (Exception exception) {
+			LOGGER.error(exception.getMessage(), exception);
+			transaction.rollback();
+			return Response.serverError().build();
+		}
+	}
+	
+}

session-service/src/main/java/de/oaa/xxx/session/Werkzeug.java

@@ -0,0 +1,26 @@
+package de.oaa.xxx.session;
+
+public enum Werkzeug {
+	
+	MUND("Mund", "Ob die Person gewillt ist den Mund einzusetzen."),
+	VAGINA("Vagina", "Ob die Person über eine Vagina verfügt und gewillt ist diese einzusetzen."),
+	PENIS("Penis", "Ob die Person über einen Penis verfügt und gewillt ist diesen einzusetzen."),
+	ANUS("Anus", "Ob die Person gewillt ist den Anus einzusetzen."),
+	UMSCHNALLDILDO("Umschnall-Dildo", "Ob die Person über einen Umschnall-Dildo verfügt und gewillt ist diesen einzusetzen.");
+		
+	private String anzeige;
+	private String beschreibung;
+	
+	Werkzeug(String anzeige, String beschreibung) {
+		this.anzeige = anzeige;
+		this.beschreibung = beschreibung;
+	}
+	
+	public String beschreibungsText() {
+		return beschreibung;
+	}
+
+	public String anzeigeText() {
+		return anzeige;
+	}
+}

session-service/src/main/java/de/oaa/xxx/session/aufgaben/Aufgabe.java

@@ -0,0 +1,115 @@
+package de.oaa.xxx.session.aufgaben;
+
+import java.util.List;
+import java.util.UUID;
+
+import de.oaa.xxx.session.Mitspieler;
+import de.oaa.xxx.session.Werkzeug;
+
+public class Aufgabe {
+
+	private UUID aufgabeId;
+	private String kurzText;
+	private String text;
+	private Integer level;
+	private Integer sekundenVon;
+	private Integer sekundenBis;
+	private UUID gruppeId;
+	private List<Werkzeug> benoetigtAktiv;
+	private List<Werkzeug> benoetigtPassiv;
+
+	public UUID getAufgabeId() {
+		return aufgabeId;
+	}
+
+	public void setAufgabeId(UUID aufgabeId) {
+		this.aufgabeId = aufgabeId;
+	}
+
+	public String getKurzText() {
+		return kurzText;
+	}
+
+	public void setKurzText(String kurzText) {
+		this.kurzText = kurzText;
+	}
+
+	public String getText() {
+		return text;
+	}
+
+	public void setText(String text) {
+		this.text = text;
+	}
+
+	public Integer getLevel() {
+		return level;
+	}
+
+	public void setLevel(Integer level) {
+		this.level = level;
+	}
+
+	public Integer getSekundenVon() {
+		return sekundenVon;
+	}
+
+	public void setSekundenVon(Integer sekundenVon) {
+		this.sekundenVon = sekundenVon;
+	}
+
+	public Integer getSekundenBis() {
+		return sekundenBis;
+	}
+
+	public void setSekundenBis(Integer sekundenBis) {
+		this.sekundenBis = sekundenBis;
+	}
+	
+	public List<Werkzeug> getBenoetigtAktiv() {
+		return benoetigtAktiv;
+	}
+
+	public void setBenoetigtAktiv(List<Werkzeug> benoetigtAktiv) {
+		this.benoetigtAktiv = benoetigtAktiv;
+	}
+
+	public List<Werkzeug> getBenoetigtPassiv() {
+		return benoetigtPassiv;
+	}
+
+	public void setBenoetigtPassiv(List<Werkzeug> benoetigtPassiv) {
+		this.benoetigtPassiv = benoetigtPassiv;
+	}
+
+	public UUID getGruppeId() {
+		return gruppeId;
+	}
+
+	public void setGruppeId(UUID gruppeId) {
+		this.gruppeId = gruppeId;
+	}
+	
+	public boolean isAufgabePassend(int level, Mitspieler aktiv, Mitspieler passiv) {
+		if (level != this.level &&  level - 1 != this.level) {
+			return false;
+		}
+		if (benoetigtPassiv != null) {			
+			for (Werkzeug werkzeug : benoetigtPassiv) {
+				if (!passiv.isVerfuegbar(werkzeug)) {
+					return false;
+				}
+			}
+		}
+		if (benoetigtAktiv == null || benoetigtAktiv.isEmpty()) {
+			return true;
+		} else {
+			for (Werkzeug werkzeug : benoetigtAktiv) {
+				if (aktiv.isVerfuegbar(werkzeug)) {
+					return true;
+				}
+			}
+			return false;
+		}
+	}
+}

session-service/src/main/java/de/oaa/xxx/session/aufgaben/AufgabenList.java

@@ -0,0 +1,48 @@
+package de.oaa.xxx.session.aufgaben;
+
+import java.util.List;
+
+public class AufgabenList {
+
+	private List<Aufgabe> aufgaben;
+	private List<Sperre> sperren;
+	private List<Strafe> strafen;
+
+	public List<Aufgabe> getAufgaben() {
+		return aufgaben;
+	}
+
+	public void setAufgaben(List<Aufgabe> aufgaben) {
+		this.aufgaben = aufgaben;
+	}
+
+	public List<Sperre> getSperren() {
+		return sperren;
+	}
+
+	public void setSperren(List<Sperre> sperren) {
+		this.sperren = sperren;
+	}
+
+	public List<Strafe> getStrafen() {
+		return strafen;
+	}
+
+	public void setStrafen(List<Strafe> strafen) {
+		this.strafen = strafen;
+	}
+	
+	public int size() {
+		int size = 0;
+		if (aufgaben != null) {
+			size += aufgaben.size();
+		}
+		if (sperren != null) {
+			size += sperren.size();
+		}
+		if (strafen != null) {
+			size += strafen.size();
+		}
+		return size;
+	}
+}

session-service/src/main/java/de/oaa/xxx/session/aufgaben/Sperre.java

@@ -0,0 +1,92 @@
+package de.oaa.xxx.session.aufgaben;
+
+import java.util.List;
+import java.util.UUID;
+
+import de.oaa.xxx.session.Mitspieler;
+import de.oaa.xxx.session.Werkzeug;
+
+public class Sperre {
+
+	private UUID sperreId;
+	private String kurzText;
+	private String text;
+	private String releaseText;
+	private UUID gruppeId;
+	private List<Werkzeug> sperreFuer;
+	private Integer minutenVon;
+	private Integer minutenBis;
+
+	public UUID getSperreId() {
+		return sperreId;
+	}
+
+	public void setSperreId(UUID sperreId) {
+		this.sperreId = sperreId;
+	}
+
+	public String getKurzText() {
+		return kurzText;
+	}
+
+	public void setKurzText(String kurzText) {
+		this.kurzText = kurzText;
+	}
+
+	public String getText() {
+		return text;
+	}
+
+	public void setText(String text) {
+		this.text = text;
+	}
+
+	public String getReleaseText() {
+		return releaseText;
+	}
+
+	public void setReleaseText(String releaseText) {
+		this.releaseText = releaseText;
+	}
+
+	public List<Werkzeug> getSperreFuer() {
+		return sperreFuer;
+	}
+
+	public void setSperreFuer(List<Werkzeug> sperreFuer) {
+		this.sperreFuer = sperreFuer;
+	}
+
+	public Integer getMinutenVon() {
+		return minutenVon;
+	}
+
+	public void setMinutenVon(Integer minutenVon) {
+		this.minutenVon = minutenVon;
+	}
+
+	public Integer getMinutenBis() {
+		return minutenBis;
+	}
+
+	public void setMinutenBis(Integer minutenBis) {
+		this.minutenBis = minutenBis;
+	}
+
+	public UUID getGruppeId() {
+		return gruppeId;
+	}
+
+	public void setGruppeId(UUID gruppeId) {
+		this.gruppeId = gruppeId;
+	}
+	
+	public boolean isAufgabePassend(Mitspieler passiv) {
+		for (Werkzeug werkzeug : sperreFuer) {
+			if (!passiv.isVerfuegbar(werkzeug)) {
+				return false;
+			}
+		}
+		return true;
+	}
+}

session-service/src/main/java/de/oaa/xxx/session/aufgaben/Strafe.java

@@ -0,0 +1,115 @@
+package de.oaa.xxx.session.aufgaben;
+
+import java.util.List;
+import java.util.UUID;
+
+import de.oaa.xxx.session.Mitspieler;
+import de.oaa.xxx.session.Werkzeug;
+
+public class Strafe {
+
+	private UUID strafeId;
+	private Integer level;
+	private String text;
+	private String kurzText;
+	private Integer sekundenVon;
+	private Integer sekundenBis;
+	private UUID gruppeId;
+	private List<Werkzeug> benoetigtAktiv;
+	private List<Werkzeug> benoetigtPassiv;
+
+	public UUID getStrafeId() {
+		return strafeId;
+	}
+
+	public void setStrafeId(UUID strafeId) {
+		this.strafeId = strafeId;
+	}
+
+	public Integer getLevel() {
+		return level;
+	}
+
+	public void setLevel(Integer level) {
+		this.level = level;
+	}
+
+	public String getText() {
+		return text;
+	}
+
+	public void setText(String text) {
+		this.text = text;
+	}
+
+	public Integer getSekundenVon() {
+		return sekundenVon;
+	}
+
+	public void setSekundenVon(Integer sekundenVon) {
+		this.sekundenVon = sekundenVon;
+	}
+
+	public Integer getSekundenBis() {
+		return sekundenBis;
+	}
+
+	public void setSekundenBis(Integer sekundenBis) {
+		this.sekundenBis = sekundenBis;
+	}
+
+	public List<Werkzeug> getBenoetigtAktiv() {
+		return benoetigtAktiv;
+	}
+
+	public void setBenoetigtAktiv(List<Werkzeug> benoetigtAktiv) {
+		this.benoetigtAktiv = benoetigtAktiv;
+	}
+
+	public List<Werkzeug> getBenoetigtPassiv() {
+		return benoetigtPassiv;
+	}
+
+	public void setBenoetigtPassiv(List<Werkzeug> benoetigtPassiv) {
+		this.benoetigtPassiv = benoetigtPassiv;
+	}
+	
+	public UUID getGruppeId() {
+		return gruppeId;
+	}
+
+	public void setGruppeId(UUID gruppeId) {
+		this.gruppeId = gruppeId;
+	}
+
+	public String getKurzText() {
+		return kurzText;
+	}
+
+	public void setKurzText(String kurzText) {
+		this.kurzText = kurzText;
+	}
+	
+	public boolean isAufgabePassend(int level, Mitspieler aktiv, Mitspieler passiv) {
+		if (level != this.level &&  level - 1 != this.level) {
+			return false;
+		}
+		if (benoetigtPassiv != null) {			
+			for (Werkzeug werkzeug : benoetigtPassiv) {
+				if (!passiv.isVerfuegbar(werkzeug)) {
+					return false;
+				}
+			}
+		}
+		if (benoetigtAktiv == null || benoetigtAktiv.isEmpty()) {
+			return true;
+		} else {
+			for (Werkzeug werkzeug : benoetigtAktiv) {
+				if (aktiv.isVerfuegbar(werkzeug)) {
+					return true;
+				}
+			}
+			return false;
+		}
+	}
+}

session-service/src/main/java/de/oaa/xxx/session/entity/AktiveSperreDAO.java

@@ -0,0 +1,36 @@
+package de.oaa.xxx.session.entity;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.UUID;
+
+import de.oaa.xxx.framework.AbstractDAO;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.TypedQuery;
+
+public class AktiveSperreDAO extends AbstractDAO<AktiveSperreEntity>{
+
+	public AktiveSperreDAO(EntityManager entityManager) {
+		super(AktiveSperreEntity.class, entityManager);
+	}
+	
+	public List<AktiveSperreEntity> findAbgelaufene(UUID sessionId) {
+		TypedQuery<AktiveSperreEntity> query = getEntityManager().createQuery("""
+				select a from AktiveSperreEntity a join a.session s 
+					where a.endzeit < :now
+					and s.sessionId = :sessionId
+				""", AktiveSperreEntity.class);
+		query.setParameter("now", LocalDateTime.now());
+		query.setParameter("sessionId", sessionId);
+		return query.getResultList();
+	}
+	
+	public List<AktiveSperreEntity> findAktiveLocks(UUID spielerId) {
+		TypedQuery<AktiveSperreEntity> query = getEntityManager().createQuery("""
+				select a from AktiveSperreEntity a join a.mitspieler m
+					where m.mitspielerId = :mitspielerId
+				""", AktiveSperreEntity.class);
+		query.setParameter("mitspielerId", spielerId);
+		return query.getResultList();
+	}
+}

session-service/src/main/java/de/oaa/xxx/session/entity/AktiveSperreEntity.java

@@ -0,0 +1,127 @@
+package de.oaa.xxx.session.entity;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+import de.oaa.xxx.framework.XXXEntity;
+import de.oaa.xxx.session.AktiveSperre;
+import de.oaa.xxx.session.Mitspieler;
+import de.oaa.xxx.session.Werkzeug;
+import jakarta.persistence.Column;
+import jakarta.persistence.ElementCollection;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+
+@Entity
+@Table(name = "aktiveSperre")
+public class AktiveSperreEntity implements XXXEntity {
+
+	@Id
+	@Column
+	private UUID aktiveSperreId;
+	@ManyToOne
+	@JoinColumn(name = "mitspielerId", nullable = false)
+	private MitspielerEntity mitspieler;
+	@Column
+	private Integer minuten;
+	@Column
+	private LocalDateTime startzeit;
+	@Column
+	private LocalDateTime endzeit;
+	@Column
+	@Enumerated
+	@ElementCollection(targetClass = Werkzeug.class)
+	private List<Werkzeug> fuer;
+	@Column
+	private String releaseText;
+	@ManyToOne
+	@JoinColumn(name = "sessionId", nullable = false)
+	private SessionEntity session;
+
+	public UUID getAktiveSperreId() {
+		return aktiveSperreId;
+	}
+
+	public void setAktiveSperreId(UUID aktiveSperreId) {
+		this.aktiveSperreId = aktiveSperreId;
+	}
+
+	public MitspielerEntity getMitspieler() {
+		return mitspieler;
+	}
+
+	public void setMitspieler(MitspielerEntity mitspieler) {
+		this.mitspieler = mitspieler;
+	}
+
+	public Integer getMinuten() {
+		return minuten;
+	}
+
+	public void setMinuten(Integer minuten) {
+		this.minuten = minuten;
+	}
+
+	public LocalDateTime getStartzeit() {
+		return startzeit;
+	}
+
+	public void setStartzeit(LocalDateTime startzeit) {
+		this.startzeit = startzeit;
+	}
+
+	public LocalDateTime getEndzeit() {
+		return endzeit;
+	}
+
+	public void setEndzeit(LocalDateTime endzeit) {
+		this.endzeit = endzeit;
+	}
+
+	public List<Werkzeug> getFuer() {
+		return fuer;
+	}
+
+	public void setFuer(List<Werkzeug> fuer) {
+		this.fuer = fuer;
+	}
+
+	public String getReleaseText() {
+		return releaseText;
+	}
+
+	public void setReleaseText(String releaseText) {
+		this.releaseText = releaseText;
+	}
+
+	public SessionEntity getSession() {
+		return session;
+	}
+
+	public void setSession(SessionEntity session) {
+		this.session = session;
+	}
+
+	public AktiveSperre toSperre(List<Mitspieler> mitspielerList) {
+		AktiveSperre sperre = new AktiveSperre();
+		sperre.setAktiveSperreId(aktiveSperreId);
+		sperre.setEndzeit(endzeit);
+		sperre.setFuer(fuer);
+		sperre.setMinuten(minuten);
+		sperre.setMitspieler(getMitspieler(mitspielerList, mitspieler.getMitspielerId()));
+		sperre.setReleaseText(releaseText);
+		sperre.setStartzeit(startzeit);
+		return sperre;
+	}
+	
+	private Mitspieler getMitspieler(List<Mitspieler> mitspielerList, UUID id) {
+		Optional<Mitspieler> first = mitspielerList.stream().filter(mit -> mit.getId().equals(id)).findFirst();
+		return first.isPresent() ? first.get() : null;
+	}
+}

session-service/src/main/java/de/oaa/xxx/session/entity/MitspielerDAO.java

@@ -0,0 +1,11 @@
+package de.oaa.xxx.session.entity;
+
+import de.oaa.xxx.framework.AbstractDAO;
+import jakarta.persistence.EntityManager;
+
+public class MitspielerDAO extends AbstractDAO<MitspielerEntity> {
+
+	public MitspielerDAO(EntityManager entityManager) {
+		super(MitspielerEntity.class, entityManager);
+	}
+}

session-service/src/main/java/de/oaa/xxx/session/entity/MitspielerEntity.java

@@ -0,0 +1,124 @@
+package de.oaa.xxx.session.entity;
+
+import java.util.List;
+import java.util.UUID;
+
+import de.oaa.xxx.framework.XXXEntity;
+import de.oaa.xxx.session.GeschlechtEnum;
+import de.oaa.xxx.session.Mitspieler;
+import de.oaa.xxx.session.RolleEnum;
+import de.oaa.xxx.session.Werkzeug;
+import jakarta.persistence.Column;
+import jakarta.persistence.ElementCollection;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.Table;
+
+@Entity
+@Table(name = "mitspieler")
+public class MitspielerEntity implements XXXEntity {
+
+	@Id
+	@Column
+	private UUID mitspielerId;
+	@Column
+	private String name;
+	@Column
+	private GeschlechtEnum geschlecht;
+	@Column
+	@Enumerated
+	@ElementCollection(targetClass = Werkzeug.class)
+	private List<Werkzeug> werkzeuge;
+	@Column
+	@Enumerated
+	@ElementCollection(targetClass = GeschlechtEnum.class)
+	private List<GeschlechtEnum> spieltMit;
+	@Column
+	@Enumerated
+	@ElementCollection(targetClass = RolleEnum.class)
+	private List<RolleEnum> rollen;
+	@ManyToOne
+	@JoinColumn(name = "sessionId", nullable = false)
+	private SessionEntity session;
+	@OneToMany(mappedBy = "mitspieler")
+	private List<AktiveSperreEntity> aktiveSperren;
+
+	public UUID getMitspielerId() {
+		return mitspielerId;
+	}
+
+	public void setMitspielerId(UUID mitspielerId) {
+		this.mitspielerId = mitspielerId;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public GeschlechtEnum getGeschlecht() {
+		return geschlecht;
+	}
+
+	public void setGeschlecht(GeschlechtEnum geschlecht) {
+		this.geschlecht = geschlecht;
+	}
+
+	public List<Werkzeug> getWerkzeuge() {
+		return werkzeuge;
+	}
+
+	public void setWerkzeuge(List<Werkzeug> werkzeuge) {
+		this.werkzeuge = werkzeuge;
+	}
+
+	public List<GeschlechtEnum> getSpieltMit() {
+		return spieltMit;
+	}
+
+	public void setSpieltMit(List<GeschlechtEnum> spieltMit) {
+		this.spieltMit = spieltMit;
+	}
+
+	public List<RolleEnum> getRollen() {
+		return rollen;
+	}
+
+	public void setRollen(List<RolleEnum> rollen) {
+		this.rollen = rollen;
+	}
+
+	public SessionEntity getSession() {
+		return session;
+	}
+
+	public void setSession(SessionEntity session) {
+		this.session = session;
+	}
+
+	public List<AktiveSperreEntity> getAktiveSperren() {
+		return aktiveSperren;
+	}
+
+	public void setAktiveSperren(List<AktiveSperreEntity> aktiveSperren) {
+		this.aktiveSperren = aktiveSperren;
+	}
+
+	public Mitspieler toMitspieler() {
+		Mitspieler mitspieler = new Mitspieler();
+		mitspieler.setGeschlecht(geschlecht);
+		mitspieler.setId(mitspielerId);
+		mitspieler.setName(name);
+		mitspieler.setRollen(rollen);
+		mitspieler.setSpieltMit(spieltMit);
+		mitspieler.setVerfuegbareWerkzeuge(werkzeuge);
+		return mitspieler;
+	}
+}

session-service/src/main/java/de/oaa/xxx/session/entity/SessionDAO.java

@@ -0,0 +1,20 @@
+package de.oaa.xxx.session.entity;
+
+import java.util.UUID;
+
+import de.oaa.xxx.framework.AbstractDAO;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.TypedQuery;
+
+public class SessionDAO extends AbstractDAO<SessionEntity> {
+
+	public SessionDAO(EntityManager entityManager) {
+		super(SessionEntity.class, entityManager);
+	}
+
+	public SessionEntity findByUserId(UUID userId) {
+		TypedQuery<SessionEntity> query = getEntityManager().createQuery("select s from SessionEntity s where s.userId = :userId", SessionEntity.class);
+		query.setParameter("userId", userId);
+		return query.getSingleResult();
+	}
+}

session-service/src/main/java/de/oaa/xxx/session/entity/SessionEntity.java

@@ -0,0 +1,156 @@
+package de.oaa.xxx.session.entity;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.UUID;
+
+import de.oaa.xxx.framework.XXXEntity;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.Table;
+import jakarta.persistence.Temporal;
+import jakarta.persistence.TemporalType;
+
+@Entity
+@Table(name = "session")
+public class SessionEntity implements XXXEntity {
+
+	@Id
+	@Column
+	private UUID sessionId;
+	@Column(unique = true)
+	private UUID userId;
+	@Column
+	@Temporal(TemporalType.TIMESTAMP)
+	private LocalDateTime startZeit;
+	@Column
+	@Temporal(TemporalType.TIMESTAMP)
+	private LocalDateTime letzteAktivitaet;
+	@Column
+	@OneToMany(mappedBy = "session")
+	private List<MitspielerEntity> mitspieler;
+	@Column
+	@OneToMany(mappedBy = "session")
+	private List<AktiveSperreEntity> aktiveSperren;
+	@Column
+	private Integer wahrscheinlichkeitSperre;
+	@Column
+	private Integer wahrscheinlichkeitStrafe;
+	@Column
+	private Integer aufgabenProLevel;
+	@Column
+	private Integer level;
+	@Column
+	private Integer aufgabenAufAktuellemLevel;
+	@Column
+	private String aufgaben;
+	@Column
+	private Double zeitfaktorZeitstrafen;
+
+	public UUID getSessionId() {
+		return sessionId;
+	}
+
+	public void setSessionId(UUID sessionId) {
+		this.sessionId = sessionId;
+	}
+
+	public UUID getUserId() {
+		return userId;
+	}
+
+	public void setUserId(UUID userId) {
+		this.userId = userId;
+	}
+
+	public LocalDateTime getStartZeit() {
+		return startZeit;
+	}
+
+	public void setStartZeit(LocalDateTime startZeit) {
+		this.startZeit = startZeit;
+	}
+
+	public LocalDateTime getLetzteAktivitaet() {
+		return letzteAktivitaet;
+	}
+
+	public void setLetzteAktivitaet(LocalDateTime letzteAktivitaet) {
+		this.letzteAktivitaet = letzteAktivitaet;
+	}
+
+	public List<MitspielerEntity> getMitspieler() {
+		return mitspieler;
+	}
+
+	public void setMitspieler(List<MitspielerEntity> mitspieler) {
+		this.mitspieler = mitspieler;
+	}
+
+	public Integer getWahrscheinlichkeitSperre() {
+		return wahrscheinlichkeitSperre;
+	}
+
+	public void setWahrscheinlichkeitSperre(Integer wahrscheinlichkeitSperre) {
+		this.wahrscheinlichkeitSperre = wahrscheinlichkeitSperre;
+	}
+
+	public Integer getWahrscheinlichkeitStrafe() {
+		return wahrscheinlichkeitStrafe;
+	}
+
+	public void setWahrscheinlichkeitStrafe(Integer wahrscheinlichkeitStrafe) {
+		this.wahrscheinlichkeitStrafe = wahrscheinlichkeitStrafe;
+	}
+
+	public Integer getAufgabenProLevel() {
+		return aufgabenProLevel;
+	}
+
+	public void setAufgabenProLevel(Integer aufgabenProLevel) {
+		this.aufgabenProLevel = aufgabenProLevel;
+	}
+
+	public Integer getLevel() {
+		return level;
+	}
+
+	public void setLevel(Integer level) {
+		this.level = level;
+	}
+
+	public Integer getAufgabenAufAktuellemLevel() {
+		return aufgabenAufAktuellemLevel;
+	}
+
+	public void setAufgabenAufAktuellemLevel(Integer aufgabenAufAktuellemLevel) {
+		this.aufgabenAufAktuellemLevel = aufgabenAufAktuellemLevel;
+	}
+
+	public String getAufgaben() {
+		return aufgaben;
+	}
+
+	public void setAufgaben(String aufgaben) {
+		this.aufgaben = aufgaben;
+	}
+
+	public Double getZeitfaktorZeitstrafen() {
+		return zeitfaktorZeitstrafen;
+	}
+
+	public void setZeitfaktorZeitstrafen(Double zeitfaktorZeitstrafen) {
+		this.zeitfaktorZeitstrafen = zeitfaktorZeitstrafen;
+	}
+
+	public List<AktiveSperreEntity> getAktiveSperren() {
+		return aktiveSperren;
+	}
+
+	public void setAktiveSperren(List<AktiveSperreEntity> aktiveSperren) {
+		this.aktiveSperren = aktiveSperren;
+	}
+
+}

session-service/src/main/java/de/oaa/xxx/session/sperre/SperreCallback.java

@@ -0,0 +1,32 @@
+package de.oaa.xxx.session.sperre;
+
+import java.util.UUID;
+
+import de.oaa.xxx.session.Callback;
+
+public class SperreCallback extends Callback {
+
+	private UUID sperreId;
+	private UUID spielerId;
+	private String releaseText;
+	
+	public UUID getSperreId() {
+		return sperreId;
+	}
+	public void setSperreId(UUID sperreId) {
+		this.sperreId = sperreId;
+	}
+	public UUID getSpielerId() {
+		return spielerId;
+	}
+	public void setSpielerId(UUID spielerId) {
+		this.spielerId = spielerId;
+	}
+	public String getReleaseText() {
+		return releaseText;
+	}
+	public void setReleaseText(String releaseText) {
+		this.releaseText = releaseText;
+	}
+	
+}

session-service/src/main/java/de/oaa/xxx/session/sperre/SperreResource.java

@@ -0,0 +1,104 @@
+package de.oaa.xxx.session.sperre;
+
+import java.util.List;
+import java.util.UUID;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import de.oaa.xxx.session.entity.AktiveSperreDAO;
+import de.oaa.xxx.session.entity.AktiveSperreEntity;
+import de.oaa.xxx.session.entity.MitspielerDAO;
+import de.oaa.xxx.session.entity.SessionDAO;
+import jakarta.annotation.Resource;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import jakarta.transaction.SystemException;
+import jakarta.transaction.UserTransaction;
+import jakarta.ws.rs.Consumes;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.POST;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.QueryParam;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
+import jakarta.ws.rs.core.Response.Status;
+
+@ApplicationScoped
+@Path("sperre")
+public class SperreResource {
+
+	private Logger LOGGER = LoggerFactory.getLogger(getClass());
+	
+	@PersistenceContext(name = "aufgaben")
+	private EntityManager entityManager;
+	@Resource
+	private UserTransaction transaction;
+	
+	@POST
+	@Consumes(MediaType.APPLICATION_JSON)
+	public Response sperren(SperreCallback callback) throws IllegalStateException, SecurityException, SystemException {
+		try {
+			transaction.begin();
+			new SperreVerarbeiten().sperreAnwenden(callback, new SessionDAO(entityManager), new MitspielerDAO(entityManager), new AktiveSperreDAO(entityManager));
+			transaction.commit();
+			return Response.status(jakarta.ws.rs.core.Response.Status.CREATED).build();
+		} catch (Exception exception) {
+			LOGGER.error(exception.getMessage(), exception);
+			transaction.rollback();
+			return Response.serverError().build();
+		}
+	}
+	
+	@GET
+	@Path("abgelaufene")
+	@Produces(MediaType.TEXT_PLAIN)
+	public Response getAbgelaufeneSperren(@QueryParam("sessionId") UUID sessionId) throws IllegalStateException, SecurityException, SystemException {
+		try {
+			if (sessionId == null) {
+				return Response.status(Status.BAD_REQUEST).build();
+			}
+			transaction.begin();
+			List<AktiveSperreEntity> abgelaufene = new AktiveSperreDAO(entityManager).findAbgelaufene(sessionId);
+			StringBuilder builder = new StringBuilder();
+			SperreVerarbeiten verarbeitun = new SperreVerarbeiten();
+			if (abgelaufene != null && !abgelaufene.isEmpty()) {
+				for (AktiveSperreEntity abgelaufen: abgelaufene) {					
+					builder.append(verarbeitun.sperreAufheben(abgelaufen, 
+							new AktiveSperreDAO(entityManager), new MitspielerDAO(entityManager)));
+					builder.append(";");
+				}
+			}
+			transaction.commit();
+			return Response.ok(builder.toString()).build();
+		} catch (Exception exception) {
+			LOGGER.error(exception.getMessage(), exception);
+			transaction.rollback();
+			return Response.serverError().build();
+		}
+	}
+	
+	@POST
+	@Path("verlaengern")
+	@Consumes(MediaType.APPLICATION_JSON)
+	public Response aktiveVerlaengern(SperrenVerlaengernCallback callback) throws IllegalStateException, SecurityException, SystemException {
+		try {
+			if (callback == null || callback.getSpielerId() == null || callback.getFaktor() == null) {
+				return Response.status(Status.BAD_REQUEST).build();
+			}
+			transaction.begin();
+			AktiveSperreDAO aktiveSperreDAO = new AktiveSperreDAO(entityManager);
+			List<AktiveSperreEntity> aktiveLocks = aktiveSperreDAO.findAktiveLocks(callback.getSpielerId());
+			SperreVerarbeiten verarbeiten = new SperreVerarbeiten();
+			aktiveLocks.forEach(lock -> verarbeiten.SperreVerlaengern(lock, callback.getFaktor(), aktiveSperreDAO));
+			transaction.commit();
+			return Response.accepted().build();
+		} catch (Exception exception) {
+			LOGGER.error(exception.getMessage(), exception);
+			transaction.rollback();
+			return Response.serverError().build();
+		}
+	}
+}

session-service/src/main/java/de/oaa/xxx/session/sperre/SperreVerarbeiten.java

@@ -0,0 +1,83 @@
+package de.oaa.xxx.session.sperre;
+
+import java.time.LocalDateTime;
+import java.util.Optional;
+import java.util.Random;
+import java.util.UUID;
+
+import de.oaa.xxx.session.aufgaben.AufgabenList;
+import de.oaa.xxx.session.aufgaben.Sperre;
+import de.oaa.xxx.session.entity.AktiveSperreDAO;
+import de.oaa.xxx.session.entity.AktiveSperreEntity;
+import de.oaa.xxx.session.entity.MitspielerDAO;
+import de.oaa.xxx.session.entity.MitspielerEntity;
+import de.oaa.xxx.session.entity.SessionDAO;
+import de.oaa.xxx.session.entity.SessionEntity;
+import jakarta.json.bind.JsonbBuilder;
+
+public class SperreVerarbeiten {
+
+	public void sperreAnwenden(SperreCallback callback, SessionDAO sessionDao, MitspielerDAO mitspielerDAO, AktiveSperreDAO sperreDao) {
+		SessionEntity session = sessionDao.findById(callback.getSessionId());
+		MitspielerEntity mitspieler = mitspielerDAO.findById(callback.getSpielerId());
+		if (session != null) {
+			AufgabenList aufgaben = JsonbBuilder.create().fromJson(session.getAufgaben(), AufgabenList.class);
+			Optional<Sperre> first = aufgaben.getSperren().stream().filter(sperre -> sperre.getSperreId().equals(callback.getSperreId())).findFirst();
+			if (first.isPresent()) {
+				Sperre sperre = first.get();
+				AktiveSperreEntity aktiv = new AktiveSperreEntity();
+				fill(callback, session, mitspieler, sperre, aktiv);
+				sperreDao.persist(aktiv);
+				sperre.getSperreFuer().forEach(mitspieler.getWerkzeuge()::remove);
+				mitspielerDAO.update(mitspieler);
+			}
+		}
+	}
+	
+	public String sperreAufheben(AktiveSperreEntity aufzuheben, AktiveSperreDAO sperreDAO, MitspielerDAO mitspielerDAO) {
+		MitspielerEntity mitspieler = aufzuheben.getMitspieler();
+		aufzuheben.getFuer().forEach(mitspieler.getWerkzeuge()::add);
+		mitspielerDAO.update(mitspieler);
+		String releaseText = aufzuheben.getReleaseText();
+		sperreDAO.remove(aufzuheben);
+		return releaseText;
+	}
+	
+	public void SperreVerlaengern(AktiveSperreEntity verlaengern, Integer faktor, AktiveSperreDAO dao) {
+		Integer neueDauer = verlaengern.getMinuten() * faktor;
+		verlaengern.setEndzeit(verlaengern.getStartzeit().plusMinutes(neueDauer));
+		verlaengern.setMinuten(neueDauer);
+		dao.update(verlaengern);
+	}
+
+	private void fill(SperreCallback callback, SessionEntity session, MitspielerEntity mitspieler, Sperre sperre,
+			AktiveSperreEntity aktiv) {
+		aktiv.setAktiveSperreId(UUID.randomUUID());
+		LocalDateTime now = LocalDateTime.now();
+		Integer minuten = berechneDauer(session, sperre);
+		aktiv.setStartzeit(now);
+		aktiv.setEndzeit(now.plusMinutes(minuten));
+		aktiv.setMinuten(minuten);
+		aktiv.setMitspieler(mitspieler);
+		aktiv.setFuer(sperre.getSperreFuer());
+		aktiv.setReleaseText(callback.getReleaseText());
+	}
+
+	private Integer berechneDauer(SessionEntity session, Sperre sperre) {
+		Integer minuten = 30;
+		if (sperre.getMinutenVon() != null) {
+			if (sperre.getMinutenBis() != null) {
+				minuten = new Random().nextInt(sperre.getMinutenVon(), sperre.getMinutenBis());
+			} else {
+				minuten = sperre.getMinutenVon();
+			}
+		}
+		if (session.getZeitfaktorZeitstrafen() != null) {
+			 minuten = (int) (minuten * session.getZeitfaktorZeitstrafen());
+		}
+		if (minuten == 0) {
+			minuten = 1;
+		}
+		return minuten;
+	}
+}

session-service/src/main/java/de/oaa/xxx/session/sperre/SperrenVerlaengernCallback.java

@@ -0,0 +1,27 @@
+package de.oaa.xxx.session.sperre;
+
+import java.util.UUID;
+
+import de.oaa.xxx.session.Callback;
+
+public class SperrenVerlaengernCallback extends Callback {
+
+	private UUID spielerId;
+	private Integer faktor;
+
+	public UUID getSpielerId() {
+		return spielerId;
+	}
+
+	public void setSpielerId(UUID spielerId) {
+		this.spielerId = spielerId;
+	}
+
+	public Integer getFaktor() {
+		return faktor;
+	}
+
+	public void setFaktor(Integer faktor) {
+		this.faktor = faktor;
+	}
+}

session-service/src/main/resources/log4j2.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Configuration status="INFO">
+    <Appenders>
+        <Console name="Console" target="SYSTEM_OUT">
+            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />
+        </Console>
+        <File name="MyFile" fileName="all.log" immediateFlush="false" append="false">
+            <PatternLayout pattern="%d{yyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
+        </File>
+    </Appenders>
+    <Loggers>
+        <Root level="debug">
+            <AppenderRef ref="Console" />
+            <AppenderRef ref="MyFile"/>
+        </Root>
+    </Loggers>
+</Configuration>

session-service/src/main/webapp/META-INF/hibernate.cfg.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE hibernate-configuration PUBLIC
+        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
+        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
+
+<hibernate-configuration>
+    <session-factory>
+        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
+
+        <!-- Validate the database schema on startup -->
+        <property name="hbm2ddl.auto">validate</property>
+    </session-factory>
+</hibernate-configuration>

session-service/src/main/webapp/META-INF/persistence.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<persistence xmlns="http://java.sun.com/xml/ns/persistence"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence 
+    	http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"
+    version="1.0" >
+
+	<persistence-unit name="registration"
+		transaction-type="JTA">
+		<provider>org.hibernate.ejb.HibernatePersistence</provider>
+		<jta-data-source>java:/Session</jta-data-source>
+		<properties>
+			<property name="hibernate.dialect"
+				value="org.hibernate.dialect.MySQLDialect" />
+			<property
+				name="javax.persistence.schema-generation.database.action"
+				value="drop-and-create" />
+		</properties>
+	</persistence-unit>
+</persistence>

session-service/src/main/webapp/WEB-INF/web.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?><web-app version="5.0"
+         xmlns="https://jakarta.ee/xml/ns/jakartaee"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd">
+	
+</web-app>

session-service/src/main/webapp/index.html

@@ -0,0 +1 @@
+<h1>Was machst du hier?</h1>