From cc9b3815773920f0851b7b764e9690fb2ff2fe49 Mon Sep 17 00:00:00 2001 From: Oliver Wallisch Date: Fri, 11 Sep 2026 21:46:00 +0200 Subject: [PATCH 1/7] feat: new endpoint for seeing remainnig screentime, test integration --- .../oliver/kidio/backend/plugins/Routing.kt | 17 ++++++++++++ src/test/kotlin/ServerTest.kt | 27 +++++++++++++++++++ 2 files changed, 44 insertions(+) diff --git a/src/main/kotlin/com/oliver/kidio/backend/plugins/Routing.kt b/src/main/kotlin/com/oliver/kidio/backend/plugins/Routing.kt index 0654cc5..3fbec59 100644 --- a/src/main/kotlin/com/oliver/kidio/backend/plugins/Routing.kt +++ b/src/main/kotlin/com/oliver/kidio/backend/plugins/Routing.kt @@ -133,6 +133,23 @@ fun Application.configureRouting(repository: KidioRepository, jwtService : JwtSe ) } } + get("/api/v1/screentime") { + val principal = call.principal() + val userid = principal?.userId?: run { + call.respond(HttpStatusCode.Unauthorized, mapOf("error" to "Ungültiger Token")) + return@get + } + val remainingSeconds = repository.getScreentime(userid) + call.respond( + HttpStatusCode.OK, + SyncResponse( + remainingSeconds = remainingSeconds, + isBlocked = remainingSeconds <= 0 + ) + ) + + + } // 3. Bildschirmzeit synchronisieren post("/api/v1/screentime/sync") { diff --git a/src/test/kotlin/ServerTest.kt b/src/test/kotlin/ServerTest.kt index 0acddd7..fe23153 100644 --- a/src/test/kotlin/ServerTest.kt +++ b/src/test/kotlin/ServerTest.kt @@ -34,6 +34,33 @@ class ServerTest { assertTrue(response.bodyAsText().contains("Kidio Backend läuft!")) } + @Test + fun `test get screentime returns current status`() = testApplication { + val jwtService = JwtService() + val repository = InMemoryKidioRepository() + + application { + install(ServerContentNegotiation) { json() } + configureSecurity(jwtService) + configureRouting(repository, jwtService) + } + + val token = jwtService.generateToken("default_user") + + // Ohne Token -> 401 Unauthorized + val unauthResponse = client.get("/api/v1/screentime") + assertEquals(HttpStatusCode.Unauthorized, unauthResponse.status) + + // Mit Token -> 200 OK + val response = client.get("/api/v1/screentime") { + header(HttpHeaders.Authorization, "Bearer $token") + } + assertEquals(HttpStatusCode.OK, response.status) + val json = Json.decodeFromString(response.bodyAsText()) + assertEquals(1800, json.remainingSeconds) + assertFalse(json.isBlocked) + } + @Test fun `test protected endpoints reject unauthorized requests`() = testApplication { val jwtService = JwtService() From 3ff53a43e7543a4445d3c7e3900e47fcde40ba9b Mon Sep 17 00:00:00 2001 From: Oliver Wallisch Date: Fri, 11 Sep 2026 21:58:07 +0200 Subject: [PATCH 2/7] add: pipeline for tests and linter --- .github/workflows/ci.yml | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 .github/workflows/ci.yml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..f5b98a7 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,33 @@ +name: CI Pipeline + +on: + push: + branches: [ "main" ] + pull_request: + branches: [ "main" ] + +jobs: + lint-and-test: + runs-on: ubuntu-latest + + steps: + - name: Code auschecken + uses: actions/checkout@v4 + + - name: Java 21 einrichten + uses: actions/setup-java@v4 + with: + distribution: 'temurin' + java-version: '21' + + - name: Gradle Rechte vergeben + run: chmod +x gradlew + + - name: 1. Code-Style (Linter) prüfen + run: ./gradlew ktlintCheck + + - name: 2. Tests ausführen + run: ./gradlew test + + - name: 3. Backend bauen + run: ./gradlew build -x test \ No newline at end of file From ebd2854442d376a109e713dd33e25095fcce41b7 Mon Sep 17 00:00:00 2001 From: Oliver Wallisch Date: Fri, 11 Sep 2026 22:06:52 +0200 Subject: [PATCH 3/7] updated pipeline --- .github/workflows/ci.yml | 4 ++-- build.gradle.kts | 1 + 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f5b98a7..570e904 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -12,10 +12,10 @@ jobs: steps: - name: Code auschecken - uses: actions/checkout@v4 + uses: https://github.com/actions/checkout@v4 # <-- Vollständige URL oder github/ Prefix - name: Java 21 einrichten - uses: actions/setup-java@v4 + uses: https://github.com/actions/setup-java@v4 # <-- Vollständige URL oder github/ Prefix with: distribution: 'temurin' java-version: '21' diff --git a/build.gradle.kts b/build.gradle.kts index 594bcaa..46b4549 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -1,6 +1,7 @@ plugins { alias(libs.plugins.kotlin.jvm) alias(ktorLibs.plugins.ktor) + id("org.jlleitschuh.gradle.ktlint") version "12.1.0" kotlin("plugin.serialization") version "2.0.0" } From 809d559562a841bcb9339cc41c1de6271c814e12 Mon Sep 17 00:00:00 2001 From: Oliver Wallisch Date: Fri, 11 Sep 2026 22:15:37 +0200 Subject: [PATCH 4/7] fixed pipelinesv2 --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 570e904..5643391 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -30,4 +30,4 @@ jobs: run: ./gradlew test - name: 3. Backend bauen - run: ./gradlew build -x test \ No newline at end of file + run: ./gradlew build -x test --max-workers=2 -Dorg.gradle.jvmargs="-Xmx1024m" \ No newline at end of file From 0d8fdec26ae3cebfb2a9db97d3f44457f91eddb4 Mon Sep 17 00:00:00 2001 From: Oliver Wallisch Date: Fri, 11 Sep 2026 22:38:56 +0200 Subject: [PATCH 5/7] style: fix missing assertion imports in ServerTest --- .editorconfig | 4 + build.gradle.kts | 2 +- src/main/kotlin/{main.kt => Main.kt} | 11 +- .../backend/data/database/DatabaseFactory.kt | 22 +- .../backend/data/database/RedisFactory.kt | 35 +- .../domain/models/{models.kt => Models.kt} | 26 +- .../domain/repository/KidioRepository.kt | 187 +++++---- .../oliver/kidio/backend/plugins/Routing.kt | 157 ++++---- .../kidio/backend/security/JwtService.kt | 14 +- src/test/kotlin/ServerTest.kt | 365 ++++++++++-------- 10 files changed, 450 insertions(+), 373 deletions(-) create mode 100644 .editorconfig rename src/main/kotlin/{main.kt => Main.kt} (76%) rename src/main/kotlin/com/oliver/kidio/backend/domain/models/{models.kt => Models.kt} (70%) diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..b6ebc1c --- /dev/null +++ b/.editorconfig @@ -0,0 +1,4 @@ +[*.{kt,kts}] +# Erlaubt Wildcard-Imports für das gesamte Projekt: +ij_kotlin_allow_trailing_comma = true +disabled_rules = no-wildcard-imports \ No newline at end of file diff --git a/build.gradle.kts b/build.gradle.kts index 46b4549..9868e1e 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -45,4 +45,4 @@ dependencies { // redis implementation("redis.clients:jedis:5.1.2") -} \ No newline at end of file +} diff --git a/src/main/kotlin/main.kt b/src/main/kotlin/Main.kt similarity index 76% rename from src/main/kotlin/main.kt rename to src/main/kotlin/Main.kt index dd67d89..2f97bc1 100644 --- a/src/main/kotlin/main.kt +++ b/src/main/kotlin/Main.kt @@ -1,12 +1,13 @@ -import com.oliver.kidio.backend.plugins.configureRouting import com.oliver.kidio.backend.data.database.DatabaseFactory import com.oliver.kidio.backend.data.database.RedisFactory import com.oliver.kidio.backend.domain.repository.ExposedKidioRepository +import com.oliver.kidio.backend.plugins.configureRouting import com.oliver.kidio.backend.plugins.configureSecurity import com.oliver.kidio.backend.security.JwtService -import io.ktor.serialization.kotlinx.json.* -import io.ktor.server.application.* -import io.ktor.server.plugins.contentnegotiation.* +import io.ktor.serialization.kotlinx.json.json +import io.ktor.server.application.Application +import io.ktor.server.application.install +import io.ktor.server.plugins.contentnegotiation.ContentNegotiation fun Application.module() { // Datenbank initialisieren @@ -25,6 +26,6 @@ fun Application.module() { configureRouting( repository = repository, - jwtService = jwtService + jwtService = jwtService, ) } diff --git a/src/main/kotlin/com/oliver/kidio/backend/data/database/DatabaseFactory.kt b/src/main/kotlin/com/oliver/kidio/backend/data/database/DatabaseFactory.kt index df3362f..b1aa9c0 100644 --- a/src/main/kotlin/com/oliver/kidio/backend/data/database/DatabaseFactory.kt +++ b/src/main/kotlin/com/oliver/kidio/backend/data/database/DatabaseFactory.kt @@ -22,6 +22,7 @@ object ScreentimeTable : Table("user_screentime") { override val primaryKey = PrimaryKey(userId) } + object UserTable : Table("users") { val id = varchar("id", 36) val email = varchar("email", 255).uniqueIndex() @@ -30,7 +31,6 @@ object UserTable : Table("users") { val childAge = integer("child_age") val parentPin = varchar("parent_pin", 4) - override val primaryKey = PrimaryKey(id) } @@ -46,12 +46,13 @@ object DatabaseFactory { val jdbcURL = "jdbc:postgresql://$host:$port/$dbName" - val database = Database.connect( - url = jdbcURL, - driver = driverClassName, - user = dbUsername, - password = password - ) + val database = + Database.connect( + url = jdbcURL, + driver = driverClassName, + user = dbUsername, + password = password, + ) transaction(database) { SchemaUtils.create(TasksTable, ScreentimeTable, UserTable) @@ -79,7 +80,7 @@ object DatabaseFactory { it[remainingSeconds] = 1800 } } - + if (UserTable.selectAll().empty()) { UserTable.insert { it[id] = "default_user" @@ -93,6 +94,5 @@ object DatabaseFactory { } } - suspend fun dbQuery(block: suspend () -> T): T = - newSuspendedTransaction(Dispatchers.IO) { block() } -} \ No newline at end of file + suspend fun dbQuery(block: suspend () -> T): T = newSuspendedTransaction(Dispatchers.IO) { block() } +} diff --git a/src/main/kotlin/com/oliver/kidio/backend/data/database/RedisFactory.kt b/src/main/kotlin/com/oliver/kidio/backend/data/database/RedisFactory.kt index b32d0a1..efad7e5 100644 --- a/src/main/kotlin/com/oliver/kidio/backend/data/database/RedisFactory.kt +++ b/src/main/kotlin/com/oliver/kidio/backend/data/database/RedisFactory.kt @@ -1,5 +1,6 @@ package com.oliver.kidio.backend.data.database -import io.ktor.server.config.* +import io.ktor.server.config.ApplicationConfig +import io.ktor.server.routing.get import redis.clients.jedis.JedisPool import redis.clients.jedis.JedisPoolConfig @@ -7,22 +8,28 @@ object RedisFactory { private var jedisPool: JedisPool? = null fun init(config: ApplicationConfig) { - val host = System.getenv("REDIS_HOST") - ?: config.propertyOrNull("storage.redisHost")?.getString() - ?: "localhost" + val host = + System.getenv("REDIS_HOST") + ?: config.propertyOrNull("storage.redisHost")?.getString() + ?: "localhost" - val port = (System.getenv("REDIS_PORT") - ?: config.propertyOrNull("storage.redisPort")?.getString() - ?: "6379").toInt() + val port = + ( + System.getenv("REDIS_PORT") + ?: config.propertyOrNull("storage.redisPort")?.getString() + ?: "6379" + ).toInt() - val poolConfig = JedisPoolConfig().apply { - maxTotal = 32 - maxIdle = 8 - minIdle = 2 - } + val poolConfig = + JedisPoolConfig().apply { + maxTotal = 32 + maxIdle = 8 + minIdle = 2 + } jedisPool = JedisPool(poolConfig, host, port) } - fun getResource() = jedisPool?.resource - ?: throw IllegalStateException("Redis Verbindungspool ist nicht initzialisiert") + fun getResource() = + jedisPool?.resource + ?: throw IllegalStateException("Redis Verbindungspool ist nicht initzialisiert") } diff --git a/src/main/kotlin/com/oliver/kidio/backend/domain/models/models.kt b/src/main/kotlin/com/oliver/kidio/backend/domain/models/Models.kt similarity index 70% rename from src/main/kotlin/com/oliver/kidio/backend/domain/models/models.kt rename to src/main/kotlin/com/oliver/kidio/backend/domain/models/Models.kt index 79bccbf..d4b56df 100644 --- a/src/main/kotlin/com/oliver/kidio/backend/domain/models/models.kt +++ b/src/main/kotlin/com/oliver/kidio/backend/domain/models/Models.kt @@ -8,14 +8,14 @@ data class Task( val id: String, val question: String, val options: List, - val rewardMinutes: Int // Wie viel Belohnung es gibt + val rewardMinutes: Int, ) // Anfrage des Kindes, wenn es eine Aufgabe löst @Serializable data class TaskVerifyRequest( val taskId: String, - val selectedAnswer: String + val selectedAnswer: String, ) // Antwort vom Server nach der Aufgaben-Prüfung @@ -23,20 +23,20 @@ data class TaskVerifyRequest( data class TaskVerifyResponse( val isCorrect: Boolean, val earnedMinutes: Int, - val message: String + val message: String, ) // Datenabgleich für die Bildschirmzeit (Sync) @Serializable data class SyncRequest( val userId: String, - val usedSecondsSinceLastSync: Int + val usedSecondsSinceLastSync: Int, ) @Serializable data class SyncResponse( val remainingSeconds: Int, - val isBlocked: Boolean + val isBlocked: Boolean, ) // --- NEU: AUTHENTIFIZIERUNG --- @@ -47,21 +47,21 @@ data class RegisterRequest( val passwordPlain: String, val familyName: String, val childAge: Int, - val parentPin: String + val parentPin: String, ) @Serializable data class LoginRequest( val email: String, - val passwordPlain: String + val passwordPlain: String, ) @Serializable data class AuthResponse( - val token: String, // Der digitale "Ausweis" (JWT) - val userId: String, // Wichtig für die App, um Aufgaben zuzuordnen - val familyName: String, // Für "Hallo Familie Müller!" - val childAge: Int + val token: String, + val userId: String, + val familyName: String, + val childAge: Int, ) // Interne Backend-Klasse (Domain Model). @@ -71,5 +71,5 @@ data class User( val passwordHash: String, val familyName: String, val childAge: Int, - val parentPin: String -) \ No newline at end of file + val parentPin: String, +) diff --git a/src/main/kotlin/com/oliver/kidio/backend/domain/repository/KidioRepository.kt b/src/main/kotlin/com/oliver/kidio/backend/domain/repository/KidioRepository.kt index a15c87e..177e0e9 100644 --- a/src/main/kotlin/com/oliver/kidio/backend/domain/repository/KidioRepository.kt +++ b/src/main/kotlin/com/oliver/kidio/backend/domain/repository/KidioRepository.kt @@ -12,53 +12,68 @@ import org.mindrot.jbcrypt.BCrypt interface KidioRepository { suspend fun getAllTasks(): List + suspend fun getTaskAnswerAndReward(taskId: String): Pair? + suspend fun getScreentime(userId: String): Int - suspend fun updateScreentime(userId: String, seconds: Int) + + suspend fun updateScreentime( + userId: String, + seconds: Int, + ) + suspend fun findByEmail(email: String): User? - suspend fun verifyPassword(password: String, passwordHash: String): Boolean + + suspend fun verifyPassword( + password: String, + passwordHash: String, + ): Boolean + suspend fun registerUser(user: User): Boolean } class ExposedKidioRepository : KidioRepository { - override suspend fun getAllTasks(): List = DatabaseFactory.dbQuery { - TasksTable.selectAll().map { - Task( - id = it[TasksTable.id], - question = it[TasksTable.question], - options = it[TasksTable.options].split(",").map { opt -> opt.trim() }, - rewardMinutes = it[TasksTable.rewardMinutes] - ) - } - } - - override suspend fun registerUser(user: User): Boolean = DatabaseFactory.dbQuery { - try { - UserTable.insert { - it[id] = user.id - it[email] = user.email - it[passwordHash] = user.passwordHash - it[familyName] = user.familyName - it[childAge] = user.childAge - it[parentPin] = user.parentPin + override suspend fun getAllTasks(): List = + DatabaseFactory.dbQuery { + TasksTable.selectAll().map { + Task( + id = it[TasksTable.id], + question = it[TasksTable.question], + options = it[TasksTable.options].split(",").map { opt -> opt.trim() }, + rewardMinutes = it[TasksTable.rewardMinutes], + ) } - ScreentimeTable.insert { - it[userId] = user.id - it[remainingSeconds] = 1800 // Startguthaben: 30 Minuten - } - true - } catch (e: Exception) { - println("FEHLER bei Registrierung: ${e.message}") - false } - } - override suspend fun getTaskAnswerAndReward(taskId: String): Pair? = DatabaseFactory.dbQuery { - TasksTable.selectAll() - .where { TasksTable.id eq taskId } - .map { it[TasksTable.correctAnswer] to it[TasksTable.rewardMinutes] } - .singleOrNull() - } + override suspend fun registerUser(user: User): Boolean = + DatabaseFactory.dbQuery { + try { + UserTable.insert { + it[id] = user.id + it[email] = user.email + it[passwordHash] = user.passwordHash + it[familyName] = user.familyName + it[childAge] = user.childAge + it[parentPin] = user.parentPin + } + ScreentimeTable.insert { + it[userId] = user.id + it[remainingSeconds] = 1800 // Startguthaben: 30 Minuten + } + true + } catch (e: Exception) { + println("FEHLER bei Registrierung: ${e.message}") + false + } + } + + override suspend fun getTaskAnswerAndReward(taskId: String): Pair? = + DatabaseFactory.dbQuery { + TasksTable.selectAll() + .where { TasksTable.id eq taskId } + .map { it[TasksTable.correctAnswer] to it[TasksTable.rewardMinutes] } + .singleOrNull() + } override suspend fun getScreentime(userId: String): Int { val redisKey = "screentime:$userId" @@ -75,12 +90,13 @@ class ExposedKidioRepository : KidioRepository { println("WARNUNG: Konnte nicht aus Redis lesen (Postgres-Fallback genutzt): ${e.message}") } - val dbSeconds = DatabaseFactory.dbQuery { - ScreentimeTable.selectAll() - .where { ScreentimeTable.userId eq userId } - .map { it[ScreentimeTable.remainingSeconds] } - .singleOrNull() ?: 1800 - } + val dbSeconds = + DatabaseFactory.dbQuery { + ScreentimeTable.selectAll() + .where { ScreentimeTable.userId eq userId } + .map { it[ScreentimeTable.remainingSeconds] } + .singleOrNull() ?: 1800 + } try { RedisFactory.getResource().use { jedis -> @@ -93,11 +109,15 @@ class ExposedKidioRepository : KidioRepository { return dbSeconds } - override suspend fun updateScreentime(userId: String, seconds: Int) { + override suspend fun updateScreentime( + userId: String, + seconds: Int, + ) { DatabaseFactory.dbQuery { - val rowsUpdated = ScreentimeTable.update({ ScreentimeTable.userId eq userId }) { - it[remainingSeconds] = seconds - } + val rowsUpdated = + ScreentimeTable.update({ ScreentimeTable.userId eq userId }) { + it[remainingSeconds] = seconds + } if (rowsUpdated == 0) { ScreentimeTable.insert { it[ScreentimeTable.userId] = userId @@ -116,39 +136,46 @@ class ExposedKidioRepository : KidioRepository { } } - override suspend fun findByEmail(email: String): User? = DatabaseFactory.dbQuery { - UserTable.selectAll() - .where { UserTable.email eq email } - .map { - User( - id = it[UserTable.id], - email = it[UserTable.email], - passwordHash = it[UserTable.passwordHash], - familyName = it[UserTable.familyName], - childAge = it[UserTable.childAge], - parentPin = it[UserTable.parentPin] - ) - } - .singleOrNull() - } + override suspend fun findByEmail(email: String): User? = + DatabaseFactory.dbQuery { + UserTable.selectAll() + .where { UserTable.email eq email } + .map { + User( + id = it[UserTable.id], + email = it[UserTable.email], + passwordHash = it[UserTable.passwordHash], + familyName = it[UserTable.familyName], + childAge = it[UserTable.childAge], + parentPin = it[UserTable.parentPin], + ) + } + .singleOrNull() + } - override suspend fun verifyPassword(password: String, passwordHash: String): Boolean { + override suspend fun verifyPassword( + password: String, + passwordHash: String, + ): Boolean { return BCrypt.checkpw(password, passwordHash) } } class InMemoryKidioRepository : KidioRepository { - private val tasks = mutableListOf( - Task("t1", "Was ist 12 + 15?", listOf("25", "27", "30", "22"), 10), - Task("t2", "Was ist 8 x 7?", listOf("54", "56", "64", "48"), 15) - ) - private val answers = mutableMapOf( - "t1" to ("27" to 10), - "t2" to ("56" to 15) - ) - private val screentimes = mutableMapOf( - "default_user" to 1800 - ) + private val tasks = + mutableListOf( + Task("t1", "Was ist 12 + 15?", listOf("25", "27", "30", "22"), 10), + Task("t2", "Was ist 8 x 7?", listOf("54", "56", "64", "48"), 15), + ) + private val answers = + mutableMapOf( + "t1" to ("27" to 10), + "t2" to ("56" to 15), + ) + private val screentimes = + mutableMapOf( + "default_user" to 1800, + ) private val users = mutableListOf() override suspend fun getAllTasks(): List = tasks @@ -157,7 +184,10 @@ class InMemoryKidioRepository : KidioRepository { override suspend fun getScreentime(userId: String): Int = screentimes[userId] ?: 1800 - override suspend fun updateScreentime(userId: String, seconds: Int) { + override suspend fun updateScreentime( + userId: String, + seconds: Int, + ) { screentimes[userId] = seconds } @@ -165,7 +195,10 @@ class InMemoryKidioRepository : KidioRepository { return users.find { it.email == email } } - override suspend fun verifyPassword(password: String, passwordHash: String): Boolean { + override suspend fun verifyPassword( + password: String, + passwordHash: String, + ): Boolean { return BCrypt.checkpw(password, passwordHash) } @@ -174,4 +207,4 @@ class InMemoryKidioRepository : KidioRepository { screentimes[user.id] = 1800 return true } -} \ No newline at end of file +} diff --git a/src/main/kotlin/com/oliver/kidio/backend/plugins/Routing.kt b/src/main/kotlin/com/oliver/kidio/backend/plugins/Routing.kt index 3fbec59..c82939d 100644 --- a/src/main/kotlin/com/oliver/kidio/backend/plugins/Routing.kt +++ b/src/main/kotlin/com/oliver/kidio/backend/plugins/Routing.kt @@ -13,7 +13,10 @@ import io.ktor.server.routing.* import org.mindrot.jbcrypt.BCrypt import java.util.UUID -fun Application.configureRouting(repository: KidioRepository, jwtService : JwtService) { +fun Application.configureRouting( + repository: KidioRepository, + jwtService: JwtService, +) { routing { post("/api/v1/auth/register") { val registerRequest = call.receive() @@ -24,7 +27,7 @@ fun Application.configureRouting(repository: KidioRepository, jwtService : JwtSe if (registerRequest.parentPin.length != 4) { call.respond(HttpStatusCode.BadRequest, "Die Eltern-PIN muss genau 4 Ziffern lang sein") return@post - } + } val existingUser = repository.findByEmail(registerRequest.email) if (existingUser != null) { call.respond(HttpStatusCode.Conflict, "Ein Benutzer mit dieser E-Mail-Adresse existiert bereits") @@ -35,8 +38,17 @@ fun Application.configureRouting(repository: KidioRepository, jwtService : JwtSe val userId = UUID.randomUUID().toString() val passwordHash = BCrypt.hashpw(registerRequest.passwordPlain, BCrypt.gensalt()) - //datenbank insert hinzufügen - repository.registerUser(User(userId, registerRequest.email, passwordHash, registerRequest.familyName, registerRequest.childAge, registerRequest.parentPin)) + // datenbank insert hinzufügen + repository.registerUser( + User( + userId, + registerRequest.email, + passwordHash, + registerRequest.familyName, + registerRequest.childAge, + registerRequest.parentPin, + ), + ) val token = jwtService.generateToken(userId) @@ -45,8 +57,8 @@ fun Application.configureRouting(repository: KidioRepository, jwtService : JwtSe mapOf( "token" to token, "userId" to userId, - "message" to "Registrierung erfolgreich" - ) + "message" to "Registrierung erfolgreich", + ), ) } // Health-Check @@ -54,33 +66,31 @@ fun Application.configureRouting(repository: KidioRepository, jwtService : JwtSe call.respond(mapOf("status" to "OK", "message" to "Kidio Backend läuft!")) } - post ("/api/v1/auth/login" ) { + post("/api/v1/auth/login") { val loginRequest = call.receive() - if(loginRequest.email.isBlank() || loginRequest.passwordPlain.isBlank()){ + if (loginRequest.email.isBlank() || loginRequest.passwordPlain.isBlank()) { call.respond(HttpStatusCode.BadRequest, "Bitte füllen Sie alle Felder aus") return@post } val getUser = repository.findByEmail(loginRequest.email) - if (getUser == null ||!repository.verifyPassword(loginRequest.passwordPlain, getUser.passwordHash)){ + if (getUser == null || !repository.verifyPassword(loginRequest.passwordPlain, getUser.passwordHash)) { call.respond(HttpStatusCode.Unauthorized, "Ungültige Anmeldedaten") return@post } val token = jwtService.generateToken(getUser.id) - call.respond(HttpStatusCode.OK, AuthResponse( - token, - userId = getUser.id, - familyName = getUser.familyName, - childAge = getUser.childAge - )) + call.respond( + HttpStatusCode.OK, + AuthResponse( + token, + userId = getUser.id, + familyName = getUser.familyName, + childAge = getUser.childAge, + ), + ) return@post - - - - } authenticate("auth-jwt") { - // 1. Alle verfügbaren Aufgaben abrufen get("/api/v1/tasks") { val tasks = repository.getAllTasks() @@ -88,67 +98,67 @@ fun Application.configureRouting(repository: KidioRepository, jwtService : JwtSe } // 2. Antwort auf eine Aufgabe überprüfen - post("/api/v1/tasks/verify") { - val request = call.receive() - val principal = call.principal() - val userId = principal?.userId - if (userId == null){ - call.respond(HttpStatusCode.Unauthorized, mapOf("error" to "Ungültiges oder abgelaufenes Token")) + post("/api/v1/tasks/verify") { + val request = call.receive() + val principal = call.principal() + val userId = principal?.userId + if (userId == null) { + call.respond(HttpStatusCode.Unauthorized, mapOf("error" to "Ungültiges oder abgelaufenes Token")) return@post - } - val taskInfo = repository.getTaskAnswerAndReward(request.taskId) - if (taskInfo == null) { - call.respond( - TaskVerifyResponse( - isCorrect = false, - earnedMinutes = 0, - message = "Aufgabe nicht gefunden!" - ) - ) - return@post - } - - val (correctAnswer, reward) = taskInfo - val isCorrect = request.selectedAnswer.trim() == correctAnswer.trim() - - if (isCorrect) { - val currentScreentime = repository.getScreentime(userId) - val newSeconds = currentScreentime + (reward * 60) - repository.updateScreentime(userId, newSeconds) - - call.respond( - TaskVerifyResponse( - isCorrect = true, - earnedMinutes = reward, - message = "Super gemacht! Du hast $reward Minuten gewonnen." - ) - ) - } else { - call.respond( - TaskVerifyResponse( - isCorrect = false, - earnedMinutes = 0, - message = "Schade, das war leider falsch. Versuche es nochmal!" - ) - ) - } } + val taskInfo = repository.getTaskAnswerAndReward(request.taskId) + if (taskInfo == null) { + call.respond( + TaskVerifyResponse( + isCorrect = false, + earnedMinutes = 0, + message = "Aufgabe nicht gefunden!", + ), + ) + return@post + } + + val (correctAnswer, reward) = taskInfo + val isCorrect = request.selectedAnswer.trim() == correctAnswer.trim() + + if (isCorrect) { + val currentScreentime = repository.getScreentime(userId) + val newSeconds = currentScreentime + (reward * 60) + repository.updateScreentime(userId, newSeconds) + + call.respond( + TaskVerifyResponse( + isCorrect = true, + earnedMinutes = reward, + message = "Super gemacht! Du hast $reward Minuten gewonnen.", + ), + ) + } else { + call.respond( + TaskVerifyResponse( + isCorrect = false, + earnedMinutes = 0, + message = "Schade, das war leider falsch. Versuche es nochmal!", + ), + ) + } + } get("/api/v1/screentime") { val principal = call.principal() - val userid = principal?.userId?: run { - call.respond(HttpStatusCode.Unauthorized, mapOf("error" to "Ungültiger Token")) - return@get - } + val userid = + principal?.userId + ?: run { + call.respond(HttpStatusCode.Unauthorized, mapOf("error" to "Ungültiger Token")) + return@get + } val remainingSeconds = repository.getScreentime(userid) call.respond( HttpStatusCode.OK, SyncResponse( remainingSeconds = remainingSeconds, - isBlocked = remainingSeconds <= 0 - ) + isBlocked = remainingSeconds <= 0, + ), ) - - } // 3. Bildschirmzeit synchronisieren @@ -168,11 +178,10 @@ fun Application.configureRouting(repository: KidioRepository, jwtService : JwtSe call.respond( SyncResponse( remainingSeconds = newSeconds, - isBlocked = newSeconds <= 0 - ) + isBlocked = newSeconds <= 0, + ), ) } } } } - diff --git a/src/main/kotlin/com/oliver/kidio/backend/security/JwtService.kt b/src/main/kotlin/com/oliver/kidio/backend/security/JwtService.kt index e5faf17..6d0cc09 100644 --- a/src/main/kotlin/com/oliver/kidio/backend/security/JwtService.kt +++ b/src/main/kotlin/com/oliver/kidio/backend/security/JwtService.kt @@ -9,14 +9,14 @@ class JwtService( private val secret: String = System.getenv("JWT_SECRET") ?: "super-geheimes-secret-fuer-dev", private val issuer: String = "https://kidio.oliver.com/", private val audience: String = "kidio-users", - private val expirationInMs: Long = java.util.concurrent.TimeUnit.DAYS.toMillis(30) // 30 Tage + private val expirationInMs: Long = java.util.concurrent.TimeUnit.DAYS.toMillis(30), ) { - - val verifier: JWTVerifier = JWT - .require(Algorithm.HMAC256(secret)) - .withAudience(audience) - .withIssuer(issuer) - .build() + val verifier: JWTVerifier = + JWT + .require(Algorithm.HMAC256(secret)) + .withAudience(audience) + .withIssuer(issuer) + .build() /** * Generiert ein JWT-Token für einen bestimmten Benutzer. diff --git a/src/test/kotlin/ServerTest.kt b/src/test/kotlin/ServerTest.kt index fe23153..af98e24 100644 --- a/src/test/kotlin/ServerTest.kt +++ b/src/test/kotlin/ServerTest.kt @@ -4,220 +4,243 @@ import com.oliver.kidio.backend.domain.repository.InMemoryKidioRepository import com.oliver.kidio.backend.plugins.configureRouting import com.oliver.kidio.backend.plugins.configureSecurity import com.oliver.kidio.backend.security.JwtService -import io.ktor.client.request.* -import io.ktor.client.statement.* -import io.ktor.http.* -import io.ktor.serialization.kotlinx.json.* -import io.ktor.server.application.* +import io.ktor.client.request.get +import io.ktor.client.request.header +import io.ktor.client.request.post +import io.ktor.client.request.setBody +import io.ktor.client.statement.bodyAsText +import io.ktor.http.ContentType +import io.ktor.http.HttpHeaders +import io.ktor.http.HttpStatusCode +import io.ktor.serialization.kotlinx.json.json +import io.ktor.server.application.install +import io.ktor.server.testing.testApplication +import kotlinx.serialization.json.Json +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertNotNull +import kotlin.test.assertTrue import io.ktor.server.plugins.contentnegotiation.ContentNegotiation as ServerContentNegotiation -import io.ktor.server.testing.* -import kotlinx.serialization.json.* -import kotlin.test.* class ServerTest { - @Test - fun `test health endpoint`() = testApplication { - val jwtService = JwtService() - val repository = InMemoryKidioRepository() + fun `test health endpoint`() = + testApplication { + val jwtService = JwtService() + val repository = InMemoryKidioRepository() - application { - install(ServerContentNegotiation) { - json() + application { + install(ServerContentNegotiation) { + json() + } + configureSecurity(jwtService) + configureRouting(repository, jwtService) } - configureSecurity(jwtService) - configureRouting(repository, jwtService) - } - val response = client.get("/api/v1/health") - assertEquals(HttpStatusCode.OK, response.status) - assertTrue(response.bodyAsText().contains("Kidio Backend läuft!")) - } + val response = client.get("/api/v1/health") + assertEquals(HttpStatusCode.OK, response.status) + assertTrue(response.bodyAsText().contains("Kidio Backend läuft!")) + } @Test - fun `test get screentime returns current status`() = testApplication { - val jwtService = JwtService() - val repository = InMemoryKidioRepository() + fun `test get screentime returns current status`() = + testApplication { + val jwtService = JwtService() + val repository = InMemoryKidioRepository() - application { - install(ServerContentNegotiation) { json() } - configureSecurity(jwtService) - configureRouting(repository, jwtService) - } - - val token = jwtService.generateToken("default_user") - - // Ohne Token -> 401 Unauthorized - val unauthResponse = client.get("/api/v1/screentime") - assertEquals(HttpStatusCode.Unauthorized, unauthResponse.status) - - // Mit Token -> 200 OK - val response = client.get("/api/v1/screentime") { - header(HttpHeaders.Authorization, "Bearer $token") - } - assertEquals(HttpStatusCode.OK, response.status) - val json = Json.decodeFromString(response.bodyAsText()) - assertEquals(1800, json.remainingSeconds) - assertFalse(json.isBlocked) - } - - @Test - fun `test protected endpoints reject unauthorized requests`() = testApplication { - val jwtService = JwtService() - val repository = InMemoryKidioRepository() - - application { - install(ServerContentNegotiation) { - json() + application { + install(ServerContentNegotiation) { json() } + configureSecurity(jwtService) + configureRouting(repository, jwtService) } - configureSecurity(jwtService) - configureRouting(repository, jwtService) - } - // Ohne Token muss 401 Unauthorized kommen - val tasksResponse = client.get("/api/v1/tasks") - assertEquals(HttpStatusCode.Unauthorized, tasksResponse.status) - } + val token = jwtService.generateToken("default_user") + + // Ohne Token -> 401 Unauthorized + val unauthResponse = client.get("/api/v1/screentime") + assertEquals(HttpStatusCode.Unauthorized, unauthResponse.status) + + // Mit Token -> 200 OK + val response = + client.get("/api/v1/screentime") { + header(HttpHeaders.Authorization, "Bearer $token") + } + assertEquals(HttpStatusCode.OK, response.status) + val json = Json.decodeFromString(response.bodyAsText()) + assertEquals(1800, json.remainingSeconds) + assertFalse(json.isBlocked) + } @Test - fun `test registration and login flow`() = testApplication { - val jwtService = JwtService() - val repository = InMemoryKidioRepository() + fun `test protected endpoints reject unauthorized requests`() = + testApplication { + val jwtService = JwtService() + val repository = InMemoryKidioRepository() - application { - install(ServerContentNegotiation) { - json() + application { + install(ServerContentNegotiation) { + json() + } + configureSecurity(jwtService) + configureRouting(repository, jwtService) } - configureSecurity(jwtService) - configureRouting(repository, jwtService) + + // Ohne Token muss 401 Unauthorized kommen + val tasksResponse = client.get("/api/v1/tasks") + assertEquals(HttpStatusCode.Unauthorized, tasksResponse.status) } - // 1. Registrierung - val registerResponse = client.post("/api/v1/auth/register") { - header(HttpHeaders.ContentType, ContentType.Application.Json.toString()) - setBody( - """{ + @Test + fun `test registration and login flow`() = + testApplication { + val jwtService = JwtService() + val repository = InMemoryKidioRepository() + + application { + install(ServerContentNegotiation) { + json() + } + configureSecurity(jwtService) + configureRouting(repository, jwtService) + } + + // 1. Registrierung + val registerResponse = + client.post("/api/v1/auth/register") { + header(HttpHeaders.ContentType, ContentType.Application.Json.toString()) + setBody( + """{ "email": "test@family.de", "passwordPlain": "strengGeheim1", "familyName": "Familie Schmidt", "childAge": 8, "parentPin": "4321" - }""" - ) - } - assertEquals(HttpStatusCode.Created, registerResponse.status) - assertTrue(registerResponse.bodyAsText().contains("token")) + }""", + ) + } + assertEquals(HttpStatusCode.Created, registerResponse.status) + assertTrue(registerResponse.bodyAsText().contains("token")) - // 2. Login mit denselben Daten - val loginResponse = client.post("/api/v1/auth/login") { - header(HttpHeaders.ContentType, ContentType.Application.Json.toString()) - setBody( - """{ + // 2. Login mit denselben Daten + val loginResponse = + client.post("/api/v1/auth/login") { + header(HttpHeaders.ContentType, ContentType.Application.Json.toString()) + setBody( + """{ "email": "test@family.de", "passwordPlain": "strengGeheim1" - }""" - ) + }""", + ) + } + assertEquals(HttpStatusCode.OK, loginResponse.status) + val loginJson = Json.decodeFromString(loginResponse.bodyAsText()) + assertNotNull(loginJson.token) + assertEquals("Familie Schmidt", loginJson.familyName) } - assertEquals(HttpStatusCode.OK, loginResponse.status) - val loginJson = Json.decodeFromString(loginResponse.bodyAsText()) - assertNotNull(loginJson.token) - assertEquals("Familie Schmidt", loginJson.familyName) - } @Test - fun `test tasks endpoint and verify with jwt`() = testApplication { - val jwtService = JwtService() - val repository = InMemoryKidioRepository() + fun `test tasks endpoint and verify with jwt`() = + testApplication { + val jwtService = JwtService() + val repository = InMemoryKidioRepository() - application { - install(ServerContentNegotiation) { - json() + application { + install(ServerContentNegotiation) { + json() + } + configureSecurity(jwtService) + configureRouting(repository, jwtService) } - configureSecurity(jwtService) - configureRouting(repository, jwtService) - } - val token = jwtService.generateToken("default_user") + val token = jwtService.generateToken("default_user") - // 1. Get Tasks mit Token - val tasksResponse = client.get("/api/v1/tasks") { - header(HttpHeaders.Authorization, "Bearer $token") - } - assertEquals(HttpStatusCode.OK, tasksResponse.status) - val tasksJson = Json.decodeFromString>(tasksResponse.bodyAsText()) - assertEquals(2, tasksJson.size) - assertEquals("t1", tasksJson[0].id) - assertEquals("Was ist 12 + 15?", tasksJson[0].question) + // 1. Get Tasks mit Token + val tasksResponse = + client.get("/api/v1/tasks") { + header(HttpHeaders.Authorization, "Bearer $token") + } + assertEquals(HttpStatusCode.OK, tasksResponse.status) + val tasksJson = Json.decodeFromString>(tasksResponse.bodyAsText()) + assertEquals(2, tasksJson.size) + assertEquals("t1", tasksJson[0].id) + assertEquals("Was ist 12 + 15?", tasksJson[0].question) - // 2. Verify Task correct answer - val verifyResponse = client.post("/api/v1/tasks/verify") { - header(HttpHeaders.Authorization, "Bearer $token") - header(HttpHeaders.ContentType, ContentType.Application.Json.toString()) - setBody("""{"taskId":"t1","selectedAnswer":"27"}""") - } - assertEquals(HttpStatusCode.OK, verifyResponse.status) - val verifyJson = Json.decodeFromString(verifyResponse.bodyAsText()) - assertTrue(verifyJson.isCorrect) - assertEquals(10, verifyJson.earnedMinutes) + // 2. Verify Task correct answer + val verifyResponse = + client.post("/api/v1/tasks/verify") { + header(HttpHeaders.Authorization, "Bearer $token") + header(HttpHeaders.ContentType, ContentType.Application.Json.toString()) + setBody("""{"taskId":"t1","selectedAnswer":"27"}""") + } + assertEquals(HttpStatusCode.OK, verifyResponse.status) + val verifyJson = Json.decodeFromString(verifyResponse.bodyAsText()) + assertTrue(verifyJson.isCorrect) + assertEquals(10, verifyJson.earnedMinutes) - // 3. Verify Task incorrect answer - val verifyWrongResponse = client.post("/api/v1/tasks/verify") { - header(HttpHeaders.Authorization, "Bearer $token") - header(HttpHeaders.ContentType, ContentType.Application.Json.toString()) - setBody("""{"taskId":"t1","selectedAnswer":"99"}""") + // 3. Verify Task incorrect answer + val verifyWrongResponse = + client.post("/api/v1/tasks/verify") { + header(HttpHeaders.Authorization, "Bearer $token") + header(HttpHeaders.ContentType, ContentType.Application.Json.toString()) + setBody("""{"taskId":"t1","selectedAnswer":"99"}""") + } + assertEquals(HttpStatusCode.OK, verifyWrongResponse.status) + val verifyWrongJson = Json.decodeFromString(verifyWrongResponse.bodyAsText()) + assertFalse(verifyWrongJson.isCorrect) + assertEquals(0, verifyWrongJson.earnedMinutes) } - assertEquals(HttpStatusCode.OK, verifyWrongResponse.status) - val verifyWrongJson = Json.decodeFromString(verifyWrongResponse.bodyAsText()) - assertFalse(verifyWrongJson.isCorrect) - assertEquals(0, verifyWrongJson.earnedMinutes) - } @Test - fun `test screentime sync deducts time repeatedly`() = testApplication { - val jwtService = JwtService() - val repository = InMemoryKidioRepository() + fun `test screentime sync deducts time repeatedly`() = + testApplication { + val jwtService = JwtService() + val repository = InMemoryKidioRepository() - application { - install(ServerContentNegotiation) { - json() + application { + install(ServerContentNegotiation) { + json() + } + configureSecurity(jwtService) + configureRouting(repository, jwtService) } - configureSecurity(jwtService) - configureRouting(repository, jwtService) - } - val token = jwtService.generateToken("default_user") + val token = jwtService.generateToken("default_user") - // 1. Sync: 200 Sekunden abziehen (1800 -> 1600) - val syncResponse1 = client.post("/api/v1/screentime/sync") { - header(HttpHeaders.Authorization, "Bearer $token") - header(HttpHeaders.ContentType, ContentType.Application.Json.toString()) - setBody("""{"userId":"default_user","usedSecondsSinceLastSync":200}""") - } - assertEquals(HttpStatusCode.OK, syncResponse1.status) - val syncJson1 = Json.decodeFromString(syncResponse1.bodyAsText()) - assertEquals(1600, syncJson1.remainingSeconds) - assertFalse(syncJson1.isBlocked) + // 1. Sync: 200 Sekunden abziehen (1800 -> 1600) + val syncResponse1 = + client.post("/api/v1/screentime/sync") { + header(HttpHeaders.Authorization, "Bearer $token") + header(HttpHeaders.ContentType, ContentType.Application.Json.toString()) + setBody("""{"userId":"default_user","usedSecondsSinceLastSync":200}""") + } + assertEquals(HttpStatusCode.OK, syncResponse1.status) + val syncJson1 = Json.decodeFromString(syncResponse1.bodyAsText()) + assertEquals(1600, syncJson1.remainingSeconds) + assertFalse(syncJson1.isBlocked) - // 2. Erneuter Sync: Weitere 300 Sekunden abziehen (1600 -> 1300) - darf nicht auf 1800 zurückspringen! - val syncResponse2 = client.post("/api/v1/screentime/sync") { - header(HttpHeaders.Authorization, "Bearer $token") - header(HttpHeaders.ContentType, ContentType.Application.Json.toString()) - setBody("""{"userId":"default_user","usedSecondsSinceLastSync":300}""") - } - assertEquals(HttpStatusCode.OK, syncResponse2.status) - val syncJson2 = Json.decodeFromString(syncResponse2.bodyAsText()) - assertEquals(1300, syncJson2.remainingSeconds) - assertFalse(syncJson2.isBlocked) + // 2. Erneuter Sync: Weitere 300 Sekunden abziehen (1600 -> 1300) - darf nicht auf 1800 zurückspringen! + val syncResponse2 = + client.post("/api/v1/screentime/sync") { + header(HttpHeaders.Authorization, "Bearer $token") + header(HttpHeaders.ContentType, ContentType.Application.Json.toString()) + setBody("""{"userId":"default_user","usedSecondsSinceLastSync":300}""") + } + assertEquals(HttpStatusCode.OK, syncResponse2.status) + val syncJson2 = Json.decodeFromString(syncResponse2.bodyAsText()) + assertEquals(1300, syncJson2.remainingSeconds) + assertFalse(syncJson2.isBlocked) - // 3. Sync bis zur Sperre (weitere 1500 Sekunden abziehen -> 0) - val syncResponse3 = client.post("/api/v1/screentime/sync") { - header(HttpHeaders.Authorization, "Bearer $token") - header(HttpHeaders.ContentType, ContentType.Application.Json.toString()) - setBody("""{"userId":"default_user","usedSecondsSinceLastSync":1500}""") + // 3. Sync bis zur Sperre (weitere 1500 Sekunden abziehen -> 0) + val syncResponse3 = + client.post("/api/v1/screentime/sync") { + header(HttpHeaders.Authorization, "Bearer $token") + header(HttpHeaders.ContentType, ContentType.Application.Json.toString()) + setBody("""{"userId":"default_user","usedSecondsSinceLastSync":1500}""") + } + assertEquals(HttpStatusCode.OK, syncResponse3.status) + val syncJson3 = Json.decodeFromString(syncResponse3.bodyAsText()) + assertEquals(0, syncJson3.remainingSeconds) + assertTrue(syncJson3.isBlocked) } - assertEquals(HttpStatusCode.OK, syncResponse3.status) - val syncJson3 = Json.decodeFromString(syncResponse3.bodyAsText()) - assertEquals(0, syncJson3.remainingSeconds) - assertTrue(syncJson3.isBlocked) - } } From 0a31a3dff0c3d5e156c573cf7a881f85f4a96aab Mon Sep 17 00:00:00 2001 From: Oliver Wallisch Date: Fri, 11 Sep 2026 22:42:54 +0200 Subject: [PATCH 6/7] style: update editorconfig syntax and format settings script --- .editorconfig | 2 +- settings.gradle.kts | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/.editorconfig b/.editorconfig index b6ebc1c..030a4fb 100644 --- a/.editorconfig +++ b/.editorconfig @@ -1,4 +1,4 @@ [*.{kt,kts}] # Erlaubt Wildcard-Imports für das gesamte Projekt: ij_kotlin_allow_trailing_comma = true -disabled_rules = no-wildcard-imports \ No newline at end of file +ktlint_standard_no-wildcard-imports = disabled \ No newline at end of file diff --git a/settings.gradle.kts b/settings.gradle.kts index 4f8e337..0c4b796 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -19,4 +19,3 @@ dependencyResolutionManagement { } rootProject.name = "Kidio_backend" - From a44a68c963756924d1d664cf55a158b6d5bf71e8 Mon Sep 17 00:00:00 2001 From: Oliver Wallisch Date: Fri, 11 Sep 2026 22:54:18 +0200 Subject: [PATCH 7/7] updated README --- README.md | 598 ++++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 473 insertions(+), 125 deletions(-) diff --git a/README.md b/README.md index 3a73713..490dbeb 100644 --- a/README.md +++ b/README.md @@ -1,171 +1,519 @@ # Kidio Backend -Das Kidio-Backend ist eine gamifizierte Lösung zur Verwaltung von Bildschirmzeit für Kinder. Die Anwendung basiert auf dem **Ktor**-Framework in Kotlin und kombiniert **PostgreSQL** für die Persistenz mit **Redis** als Caching-Layer für schnelle Zugriffszeiten. +Das **Kidio-Backend** ist eine gamifizierte Lösung zur Verwaltung von Bildschirmzeit für Kinder. -Kinder können durch das Lösen von Lernaufgaben (z. B. Mathe-Aufgaben) zusätzliche Bildschirmzeit erwerben, während das System ihre verbrauchte Bildschirmzeit synchronisiert und bei Ablauf sperrt. +Die Anwendung basiert auf dem **Ktor-Framework in Kotlin** und kombiniert **PostgreSQL** für die persistente Datenhaltung mit **Redis** als Caching-Layer für schnelle Zugriffszeiten. + +Kinder können durch das Lösen von Lernaufgaben, beispielsweise Mathematikaufgaben, zusätzliche Bildschirmzeit erwerben. Gleichzeitig synchronisiert das System die verbrauchte Bildschirmzeit und sperrt das Gerät automatisch, sobald keine verfügbare Bildschirmzeit mehr vorhanden ist. --- ## Features -Hier ist eine Übersicht der implementierten Kernfunktionen des Kidio-Backends: - -| Name | Beschreibung | -|------|-------------| -| **JWT Authentifizierung** | Sichere API-Endpunkte für authentifizierte Benutzer über JSON Web Tokens (JWT). | -| **Lernaufgaben (Tasks)** | Abrufen von interaktiven Lernaufgaben mit vordefinierten Antwortmöglichkeiten und Belohnungen (z. B. Minuten). | -| **Antwort-Verifizierung** | Überprüfung der vom Kind ausgewählten Antworten. Bei korrekter Antwort wird die Belohnung direkt auf die verbleibende Bildschirmzeit aufgerechnet. | -| **Bildschirmzeit-Synchronisation** | Laufender Datenabgleich der genutzten Bildschirmzeit. Sinkt die Zeit auf oder unter Null, wird der Status automatisch auf `isBlocked = true` gesetzt. | -| **Zwei-Ebenen-Speicher** | Datenhaltung in **PostgreSQL** (via JetBrains Exposed ORM) kombiniert mit **Redis-Caching** (via Jedis) für optimale Performance bei der Screentime-Abfrage. | -| **Fallback-Mechanismus** | Ist die Redis-Instanz nicht erreichbar, fällt das System automatisch und transparent auf PostgreSQL zurück. | +| Feature | Beschreibung | +| :--------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| **JWT-Authentifizierung** | Sichere API-Endpunkte für authentifizierte Benutzer über JSON Web Tokens (JWT). | +| **Lernaufgaben (Tasks)** | Abrufen von interaktiven Lernaufgaben mit vordefinierten Antwortmöglichkeiten und Belohnungen in Minuten. | +| **Antwort-Verifizierung** | Überprüfung der vom Kind ausgewählten Antworten. Bei korrekter Antwort wird die Belohnung direkt auf die verbleibende Bildschirmzeit aufgerechnet. | +| **Bildschirmzeit-Synchronisation** | Laufender Datenabgleich der verbrauchten Bildschirmzeit. Sinkt die verbleibende Zeit auf oder unter null, wird der Status automatisch auf `isBlocked = true` gesetzt. | +| **Zwei-Ebenen-Speicher** | PostgreSQL als persistente Datenbank, kombiniert mit Redis-Caching für schnelle Screentime-Abfragen. | +| **Fallback-Mechanismus** | Ist Redis nicht erreichbar, fällt das System automatisch und transparent auf PostgreSQL zurück. | --- ## Technologiestack -- **Framework**: [Ktor](https://ktor.io/) (Kotlin-basiertes asynchrones Web-Framework) -- **Datenbank-ORM**: [JetBrains Exposed](https://github.com/JetBrains/Exposed) -- **Persistenz**: PostgreSQL -- **Caching**: Redis (via Jedis Client) -- **Sicherheit & Auth**: JWT (Java JWT von auth0) -- **Serialization**: Kotlinx Serialization (JSON) -- **Testing**: Ktor Server Testing, JUnit +* **Framework:** Ktor +* **Programmiersprache:** Kotlin +* **Datenbank-ORM:** JetBrains Exposed +* **Persistenz:** PostgreSQL +* **Caching:** Redis via Jedis +* **Authentifizierung:** JWT via Java JWT (Auth0) +* **Serialisierung:** Kotlinx Serialization +* **Code Quality / Linter:** KtLint +* **Testing:** Ktor Server Testing, JUnit +* **CI/CD:** Forgejo Actions (Gitea / Act Runner) --- ## API-Endpunkte -Alle Endpunkte befinden sich unter dem Präfix `/api/v1`. +Alle API-Endpunkte befinden sich unter dem Präfix: + +```text +/api/v1 +``` ### Öffentliche Endpunkte #### 1. Health-Check -- **Methode**: `GET` -- **Pfad**: `/api/v1/health` -- **Beschreibung**: Prüft, ob der Backend-Server ordnungsgemäß läuft. -- **Antwort**: - ```json - { - "status": "OK", - "message": "Kidio Backend läuft!" - } - ``` -#### 2. Benutzer-Login (Auth-Token abholen) -- **Methode**: `POST` -- **Pfad**: `/api/v1/auth/login` -- **Request-Body**: - ```json - { - "userId": "default_user" - } - ``` -- **Antwort**: - ```json - { - "token": "eyJhbGciOiJIUzI1NiIsIn..." - } - ``` +**Methode:** `GET` -### Geschützte Endpunkte (Erfordern JWT im `Authorization: Bearer ` Header) +**Pfad:** -#### 3. Alle verfügbaren Aufgaben abrufen -- **Methode**: `GET` -- **Pfad**: `/api/v1/tasks` -- **Beschreibung**: Liefert eine Liste aller verfügbaren Lernaufgaben. -- **Antwort**: - ```json - [ - { - "id": "t1", - "question": "Was ist 12 + 15?", - "options": ["25", "27", "30", "22"], - "rewardMinutes": 10 - } - ] - ``` +```text +/api/v1/health +``` -#### 4. Antwort überprüfen & Belohnung verbuchen -- **Methode**: `POST` -- **Pfad**: `/api/v1/tasks/verify` -- **Request-Body**: - ```json - { - "taskId": "t1", - "selectedAnswer": "27" - } - ``` -- **Antwort (Erfolg)**: - ```json - { - "isCorrect": true, - "earnedMinutes": 10, - "message": "Super gemacht! Du hast 10 Minuten gewonnen." - } - ``` -- **Antwort (Fehler)**: - ```json - { - "isCorrect": false, - "earnedMinutes": 0, - "message": "Schade, das war leider falsch. Versuche es nochmal!" - } - ``` +**Beschreibung:** + +Prüft, ob der Backend-Server ordnungsgemäß läuft. + +**Antwort:** + +```json +{ + "status": "OK", + "message": "Kidio Backend läuft!" +} +``` + +--- + +#### 2. Benutzer-Registrierung + +**Methode:** `POST` + +**Pfad:** + +```text +/api/v1/auth/register +``` + +**Request-Body:** + +```json +{ + "email": "test@family.de", + "passwordPlain": "strengGeheim1", + "familyName": "Familie Schmidt", + "childAge": 8, + "parentPin": "4321" +} +``` + +**Antwort – `201 Created`:** + +```json +{ + "token": "eyJhbGciOiJIUzI1NiIsIn...", + "familyName": "Familie Schmidt" +} +``` + +--- + +#### 3. Benutzer-Login + +**Methode:** `POST` + +**Pfad:** + +```text +/api/v1/auth/login +``` + +**Request-Body:** + +```json +{ + "email": "test@family.de", + "passwordPlain": "strengGeheim1" +} +``` + +**Antwort – `200 OK`:** + +```json +{ + "token": "eyJhbGciOiJIUzI1NiIsIn...", + "familyName": "Familie Schmidt" +} +``` + +--- + +### Geschützte Endpunkte + +Die folgenden Endpunkte erfordern ein gültiges JWT im HTTP-Header: + +```http +Authorization: Bearer +``` + +--- + +#### 4. Bildschirmzeit abrufen + +**Methode:** `GET` + +**Pfad:** + +```text +/api/v1/screentime +``` + +**Beschreibung:** + +Liefert die aktuell verbleibende Bildschirmzeit sowie den aktuellen Sperrstatus. + +**Antwort:** + +```json +{ + "remainingSeconds": 1800, + "isBlocked": false +} +``` + +--- #### 5. Bildschirmzeit synchronisieren -- **Methode**: `POST` -- **Pfad**: `/api/v1/screentime/sync` -- **Beschreibung**: Zieht die seit dem letzten Abgleich verbrauchten Sekunden von der verfügbaren Bildschirmzeit ab. -- **Request-Body**: - ```json + +**Methode:** `POST` + +**Pfad:** + +```text +/api/v1/screentime/sync +``` + +**Beschreibung:** + +Zieht die seit dem letzten Abgleich verbrauchten Sekunden von der verfügbaren Bildschirmzeit ab. + +**Request-Body:** + +```json +{ + "userId": "default_user", + "usedSecondsSinceLastSync": 200 +} +``` + +**Antwort:** + +```json +{ + "remainingSeconds": 1600, + "isBlocked": false +} +``` + +--- + +#### 6. Alle verfügbaren Aufgaben abrufen + +**Methode:** `GET` + +**Pfad:** + +```text +/api/v1/tasks +``` + +**Beschreibung:** + +Liefert eine Liste aller verfügbaren Lernaufgaben. + +**Antwort:** + +```json +[ { - "userId": "default_user", - "usedSecondsSinceLastSync": 200 + "id": "t1", + "question": "Was ist 12 + 15?", + "options": [ + "25", + "27", + "30", + "22" + ], + "rewardMinutes": 10 } - ``` -- **Antwort**: - ```json - { - "remainingSeconds": 1600, - "isBlocked": false - } - ``` +] +``` + +--- + +#### 7. Antwort überprüfen und Belohnung verbuchen + +**Methode:** `POST` + +**Pfad:** + +```text +/api/v1/tasks/verify +``` + +**Request-Body:** + +```json +{ + "taskId": "t1", + "selectedAnswer": "27" +} +``` + +**Antwort – korrekte Lösung:** + +```json +{ + "isCorrect": true, + "earnedMinutes": 10, + "message": "Super gemacht! Du hast 10 Minuten gewonnen." +} +``` + +**Antwort – falsche Lösung:** + +```json +{ + "isCorrect": false, + "earnedMinutes": 0, + "message": "Schade, das war leider falsch. Versuche es nochmal!" +} +``` --- ## Projektkonfiguration und Umgebungsvariablen -Das Projekt wird über die Datei `src/main/resources/application.yaml` konfiguriert. Folgende Umgebungsvariablen können zur flexiblen Docker- oder Deployment-Konfiguration übergeben werden: +Die Anwendung wird über folgende Konfigurationsdatei konfiguriert: -| Variable | Beschreibung | Standardwert | -|----------|--------------|--------------| -| `DB_HOST` | Hostname der PostgreSQL-Datenbank | `localhost` / aus `application.yaml` | -| `DB_PORT` | Port der PostgreSQL-Datenbank | `5432` / aus `application.yaml` | -| `DB_NAME` | Name der PostgreSQL-Datenbank | `kidio_db` | -| `DB_USER` | PostgreSQL-Benutzername | `kidio_admin` | -| `DB_PASSWORD` | PostgreSQL-Passwort | `learning` | -| `REDIS_HOST` | Hostname der Redis-Instanz | `localhost` | -| `REDIS_PORT` | Port der Redis-Instanz | `6379` | -| `JWT_SECRET` | Geheimer Schlüssel zur Signierung der JWTs | `super-geheimes-secret-fuer-dev` | +```text +src/main/resources/application.yaml +``` + +Für eine flexible Konfiguration in lokalen Entwicklungsumgebungen, Docker-Containern oder Deployments können folgende Umgebungsvariablen gesetzt werden: + +| Variable | Beschreibung | Standardwert | +| :------------ | :----------------------------------------- | :------------------------------- | +| `DB_HOST` | Hostname der PostgreSQL-Datenbank | `localhost` | +| `DB_PORT` | Port der PostgreSQL-Datenbank | `5432` | +| `DB_NAME` | Name der PostgreSQL-Datenbank | `kidio_db` | +| `DB_USER` | PostgreSQL-Benutzername | `kidio_admin` | +| `DB_PASSWORD` | PostgreSQL-Passwort | `learning` | +| `REDIS_HOST` | Hostname der Redis-Instanz | `localhost` | +| `REDIS_PORT` | Port der Redis-Instanz | `6379` | +| `JWT_SECRET` | Geheimer Schlüssel zur Signierung der JWTs | `super-geheimes-secret-fuer-dev` | + +> **Hinweis:** Die angegebenen Standardwerte sind für die lokale Entwicklung gedacht. Für produktive Umgebungen sollten insbesondere `DB_PASSWORD` und `JWT_SECRET` über sichere Secrets bzw. Umgebungsvariablen gesetzt werden. --- -## Lokale Entwicklung, Bauen & Testen +## Lokale Entwicklung -Zur Ausführung des Projekts werden die folgenden Gradle-Tasks bereitgestellt: +### Voraussetzungen -| Task | Beschreibung | -|------|-------------| -| `./gradlew test` | Führt alle automatisierten Unit- und Integrationstests aus (nutzt die InMemory-Repository-Implementierung). | -| `./gradlew build` | Kompiliert das Projekt und baut das Artefakt. | -| `./gradlew run` | Startet den Ktor-Entwicklungsserver lokal auf Port `8080`. | +Für die lokale Entwicklung werden benötigt: + +* JDK / Java +* Kotlin bzw. Gradle Wrapper +* PostgreSQL +* Redis + +Die konkreten Versionen richten sich nach der im Projekt konfigurierten Gradle- und Kotlin-Version. + +--- + +## Bauen und Ausführen + +Das Projekt verwendet den Gradle Wrapper, sodass Gradle nicht global installiert sein muss. + +### Anwendung starten ```bash -# Tests ausführen -./gradlew test - -# Server starten ./gradlew run ``` -Sobald der Server erfolgreich gestartet ist, ist er unter `http://localhost:8080` erreichbar. +Der Ktor-Server ist anschließend standardmäßig unter folgender Adresse erreichbar: + +```text +http://localhost:8080 +``` + +### Projekt bauen + +```bash +./gradlew build +``` + +### Tests ausführen + +```bash +./gradlew test +``` + +--- + +## Code Quality + +Für die Einhaltung der Kotlin-Coding-Standards wird **KtLint** verwendet. + +### Code automatisch formatieren + +```bash +./gradlew ktlintFormat +``` + +### Code Style prüfen + +```bash +./gradlew ktlintCheck +``` + +Der KtLint-Check wird ebenfalls innerhalb der CI-Pipeline ausgeführt. + +--- + +## Empfohlener Workflow vor Commits / Pull Requests + +Vor einem Commit oder Pull Request sollte der folgende Workflow ausgeführt werden: + +```bash +# 1. Kotlin-Code automatisch formatieren +./gradlew ktlintFormat + +# 2. Code Style überprüfen +./gradlew ktlintCheck + +# 3. Tests ausführen +./gradlew test + +# 4. Projekt bauen +./gradlew build + +# 5. Server lokal starten +./gradlew run +``` + +Der Server ist anschließend unter: + +```text +http://localhost:8080 +``` + +erreichbar. + +--- + +## CI/CD Pipeline + +Das Repository verwendet **Forgejo Actions** für Continuous Integration. + +Bei jedem Push oder Pull Request auf den `main`-Branch wird automatisch ein Workflow ausgeführt. + +Die Pipeline führt unter anderem folgende Prüfungen durch: + +1. **Code Style** + + ```bash + ./gradlew ktlintCheck + ``` + +2. **Automatisierte Tests** + + ```bash + ./gradlew test + ``` + +Dadurch wird sichergestellt, dass Änderungen den bestehenden Code-Style einhalten und die automatisierten Tests weiterhin erfolgreich ausgeführt werden können. + +--- + +## Architektur + +Das Backend besteht im Wesentlichen aus folgenden Komponenten: + +```text + ┌───────────────────┐ + │ Client │ + │ Web / Mobile / │ + │ Device │ + └─────────┬─────────┘ + │ + │ HTTP / JSON + ▼ + ┌───────────────────┐ + │ Ktor │ + │ REST API │ + └─────────┬─────────┘ + │ + ┌────────────┴────────────┐ + │ │ + ▼ ▼ + ┌─────────────────┐ ┌─────────────────┐ + │ Redis │ │ PostgreSQL │ + │ Cache │ │ Persistence │ + └────────┬────────┘ └────────┬────────┘ + │ │ + └────────────┬────────────┘ + │ + ▼ + ┌───────────────────┐ + │ Exposed ORM │ + └───────────────────┘ +``` + +### Redis-Fallback + +Redis wird für schnelle Zugriffe auf häufig benötigte Daten, insbesondere die verbleibende Bildschirmzeit, verwendet. + +Sollte Redis nicht erreichbar sein, greift das Backend automatisch auf PostgreSQL zurück. + +Dadurch bleibt die Anwendung auch bei einem Ausfall des Caches funktionsfähig. + +--- + +## Bildschirmzeit-Logik + +Die Bildschirmzeit wird intern in Sekunden verwaltet. + +Beispielsweise: + +```text +Start: +1800 Sekunden += 30 Minuten + +Verbrauch: +200 Sekunden + +Verbleibend: +1600 Sekunden += 26 Minuten 40 Sekunden +``` + +Sobald die verbleibende Bildschirmzeit auf `0` oder darunter fällt, wird der Benutzer automatisch gesperrt: + +```json +{ + "remainingSeconds": 0, + "isBlocked": true +} +``` + +Durch das Lösen einer Aufgabe kann zusätzliche Bildschirmzeit erworben werden. + +Beispiel: + +```text +Verbleibend: 0 Sekunden +Aufgaben-Belohnung: 10 Minuten + ↓ +Neue Bildschirmzeit: 600 Sekunden +``` + +--- + +## Lizenz + +Falls für das Projekt eine bestimmte Lizenz verwendet wird, sollte diese hier ergänzt werden, beispielsweise: + +```text +MIT License +``` + +Eine entsprechende `LICENSE`-Datei sollte sich im Root-Verzeichnis des Repositorys befinden.