diff --git a/.env.dev.example b/.env.dev.example index 0f7b39c0..617eb9d2 100644 --- a/.env.dev.example +++ b/.env.dev.example @@ -1,3 +1,5 @@ # Copy to `.env.dev` for machine-local overrides. +SPRING_PROFILES_ACTIVE=dev +APP_BOOTSTRAP_ENABLED=true APP_SECURITY_JWT_SECRET=replace-with-a-local-dev-secret APP_SECURITY_CORS_ALLOWED_ORIGINS=http://localhost:3000,http://localhost:5173 diff --git a/.env.example b/.env.example index b3a5e1d0..47f17268 100644 --- a/.env.example +++ b/.env.example @@ -1,4 +1,6 @@ # Shared local development defaults. Copy to `.env`. +SPRING_PROFILES_ACTIVE=dev +APP_BOOTSTRAP_ENABLED=true APP_SECURITY_JWT_ISSUER=https://nettdetektivene.local/backend APP_SECURITY_JWT_AUDIENCE=nettdetektivene-web APP_SECURITY_JWT_SECRET=change-me-development-secret-change-me-development-secret diff --git a/.github/workflows/backend.yml b/.github/workflows/backend.yml index 6b67b533..cf9b47cb 100644 --- a/.github/workflows/backend.yml +++ b/.github/workflows/backend.yml @@ -15,11 +15,11 @@ jobs: - name: Check out repository uses: actions/checkout@v4 - - name: Set up Java 25 + - name: Set up Java 21 uses: actions/setup-java@v4 with: distribution: temurin - java-version: '25' + java-version: '21' cache: gradle - name: Set up Gradle diff --git a/build.gradle b/build.gradle index 2ae6054d..fc567af7 100644 --- a/build.gradle +++ b/build.gradle @@ -15,7 +15,7 @@ description = 'backend' java { toolchain { - languageVersion = JavaLanguageVersion.of(25) + languageVersion = JavaLanguageVersion.of(21) } } @@ -52,7 +52,7 @@ dependencies { } kotlin { - jvmToolchain(25) + jvmToolchain(21) compilerOptions { freeCompilerArgs.addAll '-Xjsr305=strict', '-Xannotation-default-target=param-property' } diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/bootstrap/DevDataBootstrap.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/bootstrap/DevDataBootstrap.kt new file mode 100644 index 00000000..b56e1e83 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/bootstrap/DevDataBootstrap.kt @@ -0,0 +1,193 @@ +package edu.ntnu.idi.idatt.backend.bootstrap + +import edu.ntnu.idi.idatt.backend.iam.domain.PupilProfile +import edu.ntnu.idi.idatt.backend.iam.domain.RefreshToken +import edu.ntnu.idi.idatt.backend.iam.domain.TeacherProfile +import edu.ntnu.idi.idatt.backend.iam.domain.User +import edu.ntnu.idi.idatt.backend.iam.domain.UserRole +import edu.ntnu.idi.idatt.backend.iam.domain.UserStatus +import edu.ntnu.idi.idatt.backend.iam.infrastructure.PupilProfileRepository +import edu.ntnu.idi.idatt.backend.iam.infrastructure.RefreshTokenRepository +import edu.ntnu.idi.idatt.backend.iam.infrastructure.TeacherProfileRepository +import edu.ntnu.idi.idatt.backend.iam.infrastructure.UserRepository +import org.slf4j.LoggerFactory +import org.springframework.boot.ApplicationArguments +import org.springframework.boot.ApplicationRunner +import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty +import org.springframework.security.crypto.password.PasswordEncoder +import org.springframework.stereotype.Component +import org.springframework.transaction.annotation.Transactional +import java.nio.charset.StandardCharsets +import java.security.MessageDigest +import java.time.Instant +import java.time.temporal.ChronoUnit +import java.util.HexFormat + +/** + * Seeds deterministic development data after Flyway has created the schema. + * + * The runner is idempotent so repeated local startups keep the same sample accounts while filling + * in any missing rows from the current schema. + */ +@Component +@ConditionalOnProperty(name = ["app.bootstrap.enabled"], havingValue = "true") +class DevDataBootstrap( + private val userRepository: UserRepository, + private val teacherProfileRepository: TeacherProfileRepository, + private val pupilProfileRepository: PupilProfileRepository, + private val refreshTokenRepository: RefreshTokenRepository, + private val passwordEncoder: PasswordEncoder, +) : ApplicationRunner { + private val logger = LoggerFactory.getLogger(javaClass) + + @Transactional + override fun run(args: ApplicationArguments) { + val admin = seedUser( + email = "admin@nettdetektivene.local", + password = "Admin123!", + role = UserRole.ADMIN, + ) + val teacher = seedUser( + email = "teacher@nettdetektivene.local", + password = "Teacher123!", + role = UserRole.TEACHER, + ) + val pupilAda = seedUser( + username = "ada", + password = "Pupil123!", + role = UserRole.PUPIL, + ) + val pupilNoah = seedUser( + username = "noah", + password = "Pupil123!", + role = UserRole.PUPIL, + ) + + seedTeacherProfile(teacher, "Ada Lunde", "Trondheim Montessori") + seedPupilProfile(pupilAda, "Ada", 1250, 4, 101) + seedPupilProfile(pupilNoah, "Noah", 420, 2, null) + + seedRefreshToken(admin, "dev-admin-refresh-token", Instant.now().plus(14, ChronoUnit.DAYS), null) + seedRefreshToken( + teacher, + "dev-teacher-refresh-token", + Instant.now().plus(14, ChronoUnit.DAYS), + null, + ) + seedRefreshToken( + pupilAda, + "dev-pupil-ada-refresh-token", + Instant.now().plus(7, ChronoUnit.DAYS), + null, + ) + seedRefreshToken( + pupilNoah, + "dev-pupil-noah-revoked-token", + Instant.now().plus(1, ChronoUnit.DAYS), + Instant.now().minus(1, ChronoUnit.HOURS), + ) + + logger.info( + "Development bootstrap ensured sample rows for users, profiles, and refresh tokens", + ) + } + + private fun seedUser( + email: String? = null, + username: String? = null, + password: String, + role: UserRole, + ): User { + val existingUser = when { + email != null -> userRepository.findByEmailIgnoreCase(email) + username != null -> userRepository.findByUsernameIgnoreCase(username) + else -> null + } + if (existingUser != null) { + existingUser.email = email + existingUser.username = username + existingUser.passwordHash = requireNotNull(passwordEncoder.encode(password)) + existingUser.role = role + existingUser.status = UserStatus.ACTIVE + return existingUser + } + + return userRepository.save( + User( + email = email, + username = username, + passwordHash = requireNotNull(passwordEncoder.encode(password)), + role = role, + status = UserStatus.ACTIVE, + ), + ) + } + + private fun seedTeacherProfile( + user: User, + teacherName: String, + schoolName: String, + ) { + val userId = requireNotNull(user.id) { "Teacher seed user must have an id" } + if (teacherProfileRepository.existsById(userId)) { + return + } + + teacherProfileRepository.save( + TeacherProfile( + user = user, + teacherName = teacherName, + schoolName = schoolName, + ), + ) + } + + private fun seedPupilProfile( + user: User, + displayName: String, + totalXp: Int, + currentLevel: Int, + currentClassroomId: Long?, + ) { + val userId = requireNotNull(user.id) { "Pupil seed user must have an id" } + if (pupilProfileRepository.existsById(userId)) { + return + } + + pupilProfileRepository.save( + PupilProfile( + user = user, + displayName = displayName, + totalXp = totalXp, + currentLevel = currentLevel, + currentClassroomId = currentClassroomId, + ), + ) + } + + private fun seedRefreshToken( + user: User, + rawToken: String, + expiresAt: Instant, + revokedAt: Instant?, + ) { + val tokenHash = hashToken(rawToken) + if (refreshTokenRepository.findByTokenHash(tokenHash) != null) { + return + } + + refreshTokenRepository.save( + RefreshToken( + user = user, + tokenHash = tokenHash, + expiresAt = expiresAt, + revokedAt = revokedAt, + ), + ) + } + + private fun hashToken(rawToken: String): String = + HexFormat.of().formatHex( + MessageDigest.getInstance("SHA-256").digest(rawToken.toByteArray(StandardCharsets.UTF_8)), + ) +} diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/AuthApiMappings.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/AuthApiMappings.kt new file mode 100644 index 00000000..b0997286 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/AuthApiMappings.kt @@ -0,0 +1,84 @@ +package edu.ntnu.idi.idatt.backend.iam.api + +import edu.ntnu.idi.idatt.backend.iam.application.AuthSession +import edu.ntnu.idi.idatt.backend.iam.application.AuthenticatedUser +import edu.ntnu.idi.idatt.backend.iam.application.ChangePasswordCommand +import edu.ntnu.idi.idatt.backend.iam.application.PupilLoginCommand +import edu.ntnu.idi.idatt.backend.iam.application.RegisteredTeacher +import edu.ntnu.idi.idatt.backend.iam.application.TeacherLoginCommand +import edu.ntnu.idi.idatt.backend.iam.application.TeacherRegistrationCommand + +/** + * Converts the teacher login request payload to the application command. + * + * @return login command for teacher authentication + */ +fun TeacherLoginRequest.toCommand(): TeacherLoginCommand = + TeacherLoginCommand( + email = email, + password = password, + ) + +/** + * Converts the teacher registration request payload to the application command. + * + * @return registration command for teacher account creation + */ +fun TeacherRegistrationRequest.toCommand(): TeacherRegistrationCommand = + TeacherRegistrationCommand( + email = email, + password = password, + fullName = fullName, + schoolName = schoolName, + ) + +/** + * Converts the pupil login request payload to the application command. + * + * @return login command for pupil authentication + */ +fun PupilLoginRequest.toCommand(): PupilLoginCommand = + PupilLoginCommand( + username = username, + password = password, + ) + +/** + * Converts the internal session representation to the public login response payload. + * + * @return login response exposed by the auth API + */ +fun AuthSession.toLoginResponse(): LoginResponse = + LoginResponse( + accessToken = accessToken, + tokenType = "Bearer", + expiresInSeconds = expiresInSeconds, + refreshHandledViaCookie = true, + portalType = portalType, + user = user?.toAuthenticatedUserResponse(), + ) + +/** + * Converts a registered teacher result to the public registration response payload. + * + * @return teacher registration response exposed by the auth API + */ +fun RegisteredTeacher.toTeacherRegistrationResponse(): TeacherRegistrationResponse = + TeacherRegistrationResponse( + id = id, + role = role.name, + status = status.name, + ) + +fun ChangePasswordRequest.toCommand(subject: String): ChangePasswordCommand = + ChangePasswordCommand( + subject = subject, + currentPassword = currentPassword, + newPassword = newPassword, + ) + +private fun AuthenticatedUser.toAuthenticatedUserResponse(): AuthenticatedUserResponse = + AuthenticatedUserResponse( + subject = subject, + email = email, + ) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/AuthController.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/AuthController.kt index f35856c2..06f04ce1 100644 --- a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/AuthController.kt +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/AuthController.kt @@ -1,8 +1,7 @@ package edu.ntnu.idi.idatt.backend.iam.api import edu.ntnu.idi.idatt.backend.iam.application.AuthService -import edu.ntnu.idi.idatt.backend.iam.application.RegisteredTeacher -import edu.ntnu.idi.idatt.backend.iam.application.TeacherRegistrationCommand +import edu.ntnu.idi.idatt.backend.iam.application.PasswordChangeService import edu.ntnu.idi.idatt.backend.iam.application.TeacherRegistrationService import edu.ntnu.idi.idatt.backend.iam.security.AppSecurityProperties import edu.ntnu.idi.idatt.backend.iam.security.CurrentUser @@ -17,6 +16,7 @@ import org.springframework.security.core.annotation.AuthenticationPrincipal import org.springframework.security.web.csrf.CsrfTokenRepository import org.springframework.web.bind.annotation.GetMapping import org.springframework.web.bind.annotation.PostMapping +import org.springframework.web.bind.annotation.PutMapping import org.springframework.web.bind.annotation.RequestBody import org.springframework.web.bind.annotation.RequestMapping import org.springframework.web.bind.annotation.RestController @@ -26,6 +26,7 @@ import org.springframework.web.bind.annotation.RestController * teacher registration, plus CSRF bootstrap. * * @property authService application service that handles authentication and session lifecycle rules + * @property passwordChangeService application service that changes teacher/admin passwords * @property teacherRegistrationService application service that creates teacher accounts * @property securityProperties security configuration used for refresh-cookie settings * @property csrfTokenRepository repository used to load and generate CSRF tokens for SPA clients @@ -34,6 +35,7 @@ import org.springframework.web.bind.annotation.RestController @RequestMapping("/api/v1/auth") class AuthController( private val authService: AuthService, + private val passwordChangeService: PasswordChangeService, private val teacherRegistrationService: TeacherRegistrationService, private val securityProperties: AppSecurityProperties, private val csrfTokenRepository: CsrfTokenRepository, @@ -49,7 +51,7 @@ class AuthController( @Valid @RequestBody request: TeacherRegistrationRequest, ): ResponseEntity { val registeredTeacher = teacherRegistrationService.registerTeacher(request.toCommand()) - return ResponseEntity.status(HttpStatus.CREATED).body(registeredTeacher.toResponse()) + return ResponseEntity.status(HttpStatus.CREATED).body(registeredTeacher.toTeacherRegistrationResponse()) } /** @@ -62,10 +64,10 @@ class AuthController( fun teacherLogin( @Valid @RequestBody request: TeacherLoginRequest, ): ResponseEntity { - val session = authService.teacherLogin(request) + val session = authService.teacherLogin(request.toCommand()) return ResponseEntity.ok() .header(HttpHeaders.SET_COOKIE, refreshCookie(session.refreshToken).toString()) - .body(session.toResponse()) + .body(session.toLoginResponse()) } /** @@ -79,7 +81,7 @@ class AuthController( val session = authService.teacherRefresh(extractRefreshCookie(request)) return ResponseEntity.ok() .header(HttpHeaders.SET_COOKIE, refreshCookie(session.refreshToken).toString()) - .body(session.toResponse()) + .body(session.toLoginResponse()) } /** @@ -107,10 +109,10 @@ class AuthController( fun pupilLogin( @Valid @RequestBody request: PupilLoginRequest, ): ResponseEntity { - val session = authService.pupilLoginOrCreateUser(request) + val session = authService.pupilLoginOrCreateUser(request.toCommand()) return ResponseEntity.ok() .header(HttpHeaders.SET_COOKIE, refreshCookie(session.refreshToken).toString()) - .body(session.toResponse()) + .body(session.toLoginResponse()) } /** @@ -124,7 +126,7 @@ class AuthController( val session = authService.pupilRefresh(extractRefreshCookie(request)) return ResponseEntity.ok() .header(HttpHeaders.SET_COOKIE, refreshCookie(session.refreshToken).toString()) - .body(session.toResponse()) + .body(session.toLoginResponse()) } /** @@ -180,6 +182,22 @@ class AuthController( authorities = currentUser.authorities, ) + /** + * Changes the authenticated teacher/admin password after verifying the current password. + * + * @param currentUser user to change password + * @param request servlet request used to change the password + * @return empty response + */ + @PutMapping("/me/password") + fun changePassword( + @AuthenticationPrincipal currentUser: CurrentUser, + @Valid @RequestBody request: ChangePasswordRequest, + ): ResponseEntity { + passwordChangeService.changePassword(request.toCommand(currentUser.subject)) + return ResponseEntity.noContent().build() + } + private fun refreshCookie(rawToken: String): ResponseCookie = ResponseCookie.from(securityProperties.refresh.cookieName, rawToken) .httpOnly(true) @@ -203,150 +221,3 @@ class AuthController( ?.firstOrNull { it.name == securityProperties.refresh.cookieName } ?.value } - -// TODO: if we add more controllers that use these, move them out -/** - * Request payload for teacher and admin login. - * - * @property email teacher email address used for login - * @property password raw password supplied by the user - */ -data class TeacherLoginRequest( - @field:jakarta.validation.constraints.Email - @field:jakarta.validation.constraints.NotBlank - val email: String, - @field:jakarta.validation.constraints.NotBlank - val password: String, -) - -/** - * Request payload for teacher account registration. - * - * @property email teacher login email address - * @property password raw password supplied during registration - * @property fullName teacher full name - * @property schoolName teacher school name - */ -data class TeacherRegistrationRequest( - @field:jakarta.validation.constraints.Email - @field:jakarta.validation.constraints.NotBlank - val email: String, - @field:jakarta.validation.constraints.NotBlank - @field:jakarta.validation.constraints.Size(min = 8, max = 72) - val password: String, - @field:jakarta.validation.constraints.NotBlank - @field:jakarta.validation.constraints.Size(max = 255) - val fullName: String, - @field:jakarta.validation.constraints.NotBlank - @field:jakarta.validation.constraints.Size(max = 255) - val schoolName: String, -) { - /** - * Converts the HTTP request payload to the registration command used by the application layer. - * - * @return registration command for teacher account creation - */ - fun toCommand(): TeacherRegistrationCommand = - TeacherRegistrationCommand( - email = email, - password = password, - fullName = fullName, - schoolName = schoolName, - ) -} - -/** - * Request payload for pupil login. - * - * @property username pupil username used for login - * @property password raw password supplied by the user - */ -data class PupilLoginRequest( - @field:jakarta.validation.constraints.NotBlank - val username: String, - @field:jakarta.validation.constraints.NotBlank - val password: String, -) - -/** - * Response payload returned after successful login or refresh. - * - * @property accessToken signed JWT access token - * @property tokenType token type exposed to the client, normally `Bearer` - * @property expiresInSeconds access-token lifetime in seconds - * @property refreshHandledViaCookie whether refresh-token handling is cookie-based - * @property portalType authenticated portal type for the session - * @property user authenticated user information exposed to the frontend - */ -data class LoginResponse( - val accessToken: String, - val tokenType: String, - val expiresInSeconds: Long, - val refreshHandledViaCookie: Boolean, - val portalType: String, - val user: AuthenticatedUserResponse?, -) - -/** - * Response payload returned after a teacher account has been created. - * - * @property id created teacher user identifier - * @property role created user role - * @property status created user status - */ -data class TeacherRegistrationResponse( - val id: Long, - val role: String, - val status: String, -) - -/** - * Public user information returned in auth responses. - * - * @property subject authenticated user identifier - * @property email authenticated user email, or `null` for pupil users - */ -data class AuthenticatedUserResponse( - val subject: String, - val email: String?, -) - -/** - * Response payload containing CSRF token details for SPA clients. - * - * @property headerName HTTP header name expected for CSRF submission - * @property parameterName form a parameter name associated with the CSRF token - * @property token CSRF token value - */ -data class CsrfTokenResponse( - val headerName: String, - val parameterName: String, - val token: String, -) - -/** - * Response payload describing the currently authenticated user. - * - * @property subject authenticated user identifier - * @property portalType active portal type derived from the access token - * @property email authenticated user email, or `null` for pupil users - * @property authorities granted authorities embedded in the access token - */ -data class CurrentUserResponse( - val subject: String, - val portalType: String, - val email: String?, - val authorities: Set, -) - -/** - * Converts a registered teacher result to the public registration response payload. - * - * @return teacher registration response exposed by the auth API - */ -private fun RegisteredTeacher.toResponse(): TeacherRegistrationResponse = - TeacherRegistrationResponse( - id = id, - role = role.name, - status = status.name, - ) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/AuthenticatedUserResponse.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/AuthenticatedUserResponse.kt new file mode 100644 index 00000000..a242b7cb --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/AuthenticatedUserResponse.kt @@ -0,0 +1,12 @@ +package edu.ntnu.idi.idatt.backend.iam.api + +/** + * Public user information returned in auth responses. + * + * @property subject authenticated user identifier + * @property email authenticated user email, or `null` for pupil users + */ +data class AuthenticatedUserResponse( + val subject: String, + val email: String?, +) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/ChangePasswordRequest.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/ChangePasswordRequest.kt new file mode 100644 index 00000000..70492a16 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/ChangePasswordRequest.kt @@ -0,0 +1,15 @@ +package edu.ntnu.idi.idatt.backend.iam.api + +/** + * Request payload for changing the authenticated teacher/admin password. + * + * @property currentPassword current raw password supplied for verification + * @property newPassword new raw password to persist + */ +data class ChangePasswordRequest( + @field:jakarta.validation.constraints.NotBlank + val currentPassword: String, + @field:jakarta.validation.constraints.NotBlank + @field:jakarta.validation.constraints.Size(min = 8, max = 72) + val newPassword: String, +) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/CsrfTokenResponse.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/CsrfTokenResponse.kt new file mode 100644 index 00000000..6d863510 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/CsrfTokenResponse.kt @@ -0,0 +1,14 @@ +package edu.ntnu.idi.idatt.backend.iam.api + +/** + * Response payload containing CSRF token details for SPA clients. + * + * @property headerName HTTP header name expected for CSRF submission + * @property parameterName form a parameter name associated with the CSRF token + * @property token CSRF token value + */ +data class CsrfTokenResponse( + val headerName: String, + val parameterName: String, + val token: String, +) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/CurrentUserResponse.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/CurrentUserResponse.kt new file mode 100644 index 00000000..a8fcd9ff --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/CurrentUserResponse.kt @@ -0,0 +1,16 @@ +package edu.ntnu.idi.idatt.backend.iam.api + +/** + * Response payload describing the currently authenticated user. + * + * @property subject authenticated user identifier + * @property portalType active portal type derived from the access token + * @property email authenticated user email, or `null` for pupil users + * @property authorities granted authorities embedded in the access token + */ +data class CurrentUserResponse( + val subject: String, + val portalType: String, + val email: String?, + val authorities: Set, +) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/LoginResponse.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/LoginResponse.kt new file mode 100644 index 00000000..b88db6d3 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/LoginResponse.kt @@ -0,0 +1,20 @@ +package edu.ntnu.idi.idatt.backend.iam.api + +/** + * Response payload returned after successful login or refresh. + * + * @property accessToken signed JWT access token + * @property tokenType token type exposed to the client, normally `Bearer` + * @property expiresInSeconds access-token lifetime in seconds + * @property refreshHandledViaCookie whether refresh-token handling is cookie-based + * @property portalType authenticated portal type for the session + * @property user authenticated user information exposed to the frontend + */ +data class LoginResponse( + val accessToken: String, + val tokenType: String, + val expiresInSeconds: Long, + val refreshHandledViaCookie: Boolean, + val portalType: String, + val user: AuthenticatedUserResponse?, +) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/PupilLoginRequest.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/PupilLoginRequest.kt new file mode 100644 index 00000000..2fdd6e74 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/PupilLoginRequest.kt @@ -0,0 +1,14 @@ +package edu.ntnu.idi.idatt.backend.iam.api + +/** + * Request payload for pupil login. + * + * @property username pupil username used for login + * @property password raw password supplied by the user + */ +data class PupilLoginRequest( + @field:jakarta.validation.constraints.NotBlank + val username: String, + @field:jakarta.validation.constraints.NotBlank + val password: String, +) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/TeacherLoginRequest.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/TeacherLoginRequest.kt new file mode 100644 index 00000000..7f1473e6 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/TeacherLoginRequest.kt @@ -0,0 +1,15 @@ +package edu.ntnu.idi.idatt.backend.iam.api + +/** + * Request payload for teacher and admin login. + * + * @property email teacher email address used for login + * @property password raw password supplied by the user + */ +data class TeacherLoginRequest( + @field:jakarta.validation.constraints.Email + @field:jakarta.validation.constraints.NotBlank + val email: String, + @field:jakarta.validation.constraints.NotBlank + val password: String, +) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/TeacherRegistrationRequest.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/TeacherRegistrationRequest.kt new file mode 100644 index 00000000..9729dff7 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/TeacherRegistrationRequest.kt @@ -0,0 +1,24 @@ +package edu.ntnu.idi.idatt.backend.iam.api + +/** + * Request payload for teacher account registration. + * + * @property email teacher login email address + * @property password raw password supplied during registration + * @property fullName teacher full name + * @property schoolName teacher school name + */ +data class TeacherRegistrationRequest( + @field:jakarta.validation.constraints.Email + @field:jakarta.validation.constraints.NotBlank + val email: String, + @field:jakarta.validation.constraints.NotBlank + @field:jakarta.validation.constraints.Size(min = 8, max = 72) + val password: String, + @field:jakarta.validation.constraints.NotBlank + @field:jakarta.validation.constraints.Size(max = 255) + val fullName: String, + @field:jakarta.validation.constraints.NotBlank + @field:jakarta.validation.constraints.Size(max = 255) + val schoolName: String, +) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/TeacherRegistrationResponse.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/TeacherRegistrationResponse.kt new file mode 100644 index 00000000..42581186 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/api/TeacherRegistrationResponse.kt @@ -0,0 +1,14 @@ +package edu.ntnu.idi.idatt.backend.iam.api + +/** + * Response payload returned after a teacher account has been created. + * + * @property id created teacher user identifier + * @property role created user role + * @property status created user status + */ +data class TeacherRegistrationResponse( + val id: Long, + val role: String, + val status: String, +) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/AuthService.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/AuthService.kt index 75131e60..3eebfecd 100644 --- a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/AuthService.kt +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/AuthService.kt @@ -1,9 +1,5 @@ package edu.ntnu.idi.idatt.backend.iam.application -import edu.ntnu.idi.idatt.backend.iam.api.AuthenticatedUserResponse -import edu.ntnu.idi.idatt.backend.iam.api.LoginResponse -import edu.ntnu.idi.idatt.backend.iam.api.PupilLoginRequest -import edu.ntnu.idi.idatt.backend.iam.api.TeacherLoginRequest import edu.ntnu.idi.idatt.backend.iam.domain.RefreshToken import edu.ntnu.idi.idatt.backend.iam.domain.User import edu.ntnu.idi.idatt.backend.iam.domain.UserRole @@ -48,13 +44,13 @@ class AuthService( /** * Authenticates a teacher or admin user and creates a new access/refresh token session. * - * @param request teacher login payload containing email and password + * @param command teacher login payload containing email and password * @return authenticated session with access token and persisted refresh token */ @Transactional fun teacherLogin( - request: TeacherLoginRequest, - ): AuthSession = authenticateTeacher(request) + command: TeacherLoginCommand, + ): AuthSession = authenticateTeacher(command) /** * Validates and rotates a teacher refresh token, returning a fresh authenticated session. @@ -70,14 +66,14 @@ class AuthService( /** * Ensures a pupil user exists for the submitted username and then performs normal pupil login. * - * @param request pupil login payload containing username and password + * @param command pupil login payload containing username and password * @return authenticated session with access token and persisted refresh token */ fun pupilLoginOrCreateUser( - request: PupilLoginRequest, + command: PupilLoginCommand, ): AuthSession { - pupilProvisioningService.ensurePupilUserExists(request) - return authenticatePupil(request) + pupilProvisioningService.ensurePupilUserExists(command) + return authenticatePupil(command) } /** @@ -112,14 +108,14 @@ class AuthService( /** * Authenticates a teacher or admin user against the stored credentials and issues a session. * - * @param request teacher login payload containing email and password + * @param command teacher login payload containing email and password * @return authenticated teacher session * @throws ResponseStatusException when the credentials are invalid or the user is not allowed */ - private fun authenticateTeacher(request: TeacherLoginRequest): AuthSession { - val user = userRepository.findByEmailIgnoreCase(normalizeEmail(request.email)) + private fun authenticateTeacher(command: TeacherLoginCommand): AuthSession { + val user = userRepository.findByEmailIgnoreCase(normalizeEmail(command.email)) ?.takeIf { it.isActive() && it.role in setOf(UserRole.TEACHER, UserRole.ADMIN) } - ?.takeIf { passwordEncoder.matches(request.password, it.passwordHash) } + ?.takeIf { passwordEncoder.matches(command.password, it.passwordHash) } ?: throw ResponseStatusException(HttpStatus.UNAUTHORIZED, "Invalid email or password") return issueSession(user, "TEACHER") @@ -128,14 +124,14 @@ class AuthService( /** * Authenticates a pupil user against the stored credentials and issues a session. * - * @param request pupil login payload containing username and password + * @param command pupil login payload containing username and password * @return authenticated pupil session * @throws ResponseStatusException when the credentials are invalid or the user is not allowed */ - private fun authenticatePupil(request: PupilLoginRequest): AuthSession { - val user = userRepository.findByUsernameIgnoreCase(normalizeUsername(request.username)) + private fun authenticatePupil(command: PupilLoginCommand): AuthSession { + val user = userRepository.findByUsernameIgnoreCase(normalizeUsername(command.username)) ?.takeIf { it.isActive() && it.role == UserRole.PUPIL } - ?.takeIf { passwordEncoder.matches(request.password, it.passwordHash) } + ?.takeIf { passwordEncoder.matches(command.password, it.passwordHash) } ?: throw ResponseStatusException(HttpStatus.UNAUTHORIZED, "Invalid username or password") return issueSession(user, "PUPIL") @@ -260,46 +256,3 @@ class AuthService( */ private fun normalizeUsername(username: String): String = username.trim() } - -/** - * Internal authenticated session representation used to build auth API responses and cookies. - * - * @property accessToken signed JWT access token - * @property refreshToken raw refresh token to place in the HTTP-only cookie - * @property expiresInSeconds access-token lifetime in seconds - * @property portalType authenticated portal type for the session - * @property user authenticated user details returned to the frontend - */ -data class AuthSession( - val accessToken: String, - val refreshToken: String, - val expiresInSeconds: Long, - val portalType: String, - val user: AuthenticatedUser?, -) { - /** - * Converts the internal session representation to the public login response payload. - * - * @return login response exposed by the auth API - */ - fun toResponse(): LoginResponse = - LoginResponse( - accessToken = accessToken, - tokenType = "Bearer", - expiresInSeconds = expiresInSeconds, - refreshHandledViaCookie = true, - portalType = portalType, - user = user?.let { AuthenticatedUserResponse(it.subject, it.email) }, - ) -} - -/** - * Authenticated user details attached to a newly created session. - * - * @property subject authenticated user identifier - * @property email authenticated user email, or `null` for pupil users - */ -data class AuthenticatedUser( - val subject: String, - val email: String?, -) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/AuthSession.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/AuthSession.kt new file mode 100644 index 00000000..a57b0e94 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/AuthSession.kt @@ -0,0 +1,18 @@ +package edu.ntnu.idi.idatt.backend.iam.application + +/** + * Internal authenticated session representation used to build auth API responses and cookies. + * + * @property accessToken signed JWT access token + * @property refreshToken raw refresh token to place in the HTTP-only cookie + * @property expiresInSeconds access-token lifetime in seconds + * @property portalType authenticated portal type for the session + * @property user authenticated user details returned to the frontend + */ +data class AuthSession( + val accessToken: String, + val refreshToken: String, + val expiresInSeconds: Long, + val portalType: String, + val user: AuthenticatedUser?, +) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/AuthenticatedUser.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/AuthenticatedUser.kt new file mode 100644 index 00000000..814086e0 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/AuthenticatedUser.kt @@ -0,0 +1,12 @@ +package edu.ntnu.idi.idatt.backend.iam.application + +/** + * Authenticated user details attached to a newly created session. + * + * @property subject authenticated user identifier + * @property email authenticated user email, or `null` for pupil users + */ +data class AuthenticatedUser( + val subject: String, + val email: String?, +) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/ChangePasswordCommand.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/ChangePasswordCommand.kt new file mode 100644 index 00000000..52554172 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/ChangePasswordCommand.kt @@ -0,0 +1,14 @@ +package edu.ntnu.idi.idatt.backend.iam.application + +/** + * Self-service password-change payload for the authenticated user. + * + * @property subject authenticated user identifier from the JWT subject claim + * @property currentPassword current raw password supplied by the user + * @property newPassword new raw password to encode and persist + */ +data class ChangePasswordCommand( + val subject: String, + val currentPassword: String, + val newPassword: String, +) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/PasswordChangeService.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/PasswordChangeService.kt new file mode 100644 index 00000000..d7fa8960 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/PasswordChangeService.kt @@ -0,0 +1,48 @@ +package edu.ntnu.idi.idatt.backend.iam.application + +import edu.ntnu.idi.idatt.backend.iam.domain.UserRole +import edu.ntnu.idi.idatt.backend.iam.infrastructure.UserRepository +import org.springframework.http.HttpStatus +import org.springframework.security.crypto.password.PasswordEncoder +import org.springframework.stereotype.Service +import org.springframework.transaction.annotation.Transactional +import org.springframework.web.server.ResponseStatusException + +/** + * Handles self-service password changes for teacher and admin accounts. + * + * @property userRepository repository used to load and persist the authenticated user + * @property passwordEncoder password encoder used to verify and update password hashes + */ +@Service +class PasswordChangeService( + private val userRepository: UserRepository, + private val passwordEncoder: PasswordEncoder, +) { + /** + * Changes the current authenticated teacher/admin user's password. + * + * @param command authenticated subject plus current and new password values + * @return nothing; the user password hash is updated transactionally + */ + @Transactional + fun changePassword(command: ChangePasswordCommand) { + val userId = command.subject.toLongOrNull() + ?: throw ResponseStatusException(HttpStatus.UNAUTHORIZED, "Invalid authenticated user subject") + val user = userRepository.findById(userId) + .orElseThrow { + ResponseStatusException(HttpStatus.UNAUTHORIZED, "Authenticated user was not found") + } + + if (user.role == UserRole.PUPIL) { + throw ResponseStatusException(HttpStatus.FORBIDDEN, "Pupils cannot change password") + } + + if (!passwordEncoder.matches(command.currentPassword, user.passwordHash)) { + throw ResponseStatusException(HttpStatus.UNAUTHORIZED, "Invalid current password") + } + + user.passwordHash = requireNotNull(passwordEncoder.encode(command.newPassword)) + userRepository.save(user) + } +} diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/PupilLoginCommand.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/PupilLoginCommand.kt new file mode 100644 index 00000000..f9fd0012 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/PupilLoginCommand.kt @@ -0,0 +1,12 @@ +package edu.ntnu.idi.idatt.backend.iam.application + +/** + * Input values required to authenticate a pupil user. + * + * @property username pupil login username + * @property password raw password supplied during login + */ +data class PupilLoginCommand( + val username: String, + val password: String, +) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/PupilProvisioningService.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/PupilProvisioningService.kt index 9d0f34e7..2475e2ed 100644 --- a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/PupilProvisioningService.kt +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/PupilProvisioningService.kt @@ -1,6 +1,5 @@ package edu.ntnu.idi.idatt.backend.iam.application -import edu.ntnu.idi.idatt.backend.iam.api.PupilLoginRequest import edu.ntnu.idi.idatt.backend.iam.domain.User import edu.ntnu.idi.idatt.backend.iam.domain.UserRole import edu.ntnu.idi.idatt.backend.iam.domain.UserStatus @@ -34,16 +33,16 @@ class PupilProvisioningService( * If concurrent first-login requests race for the same username, a duplicate-key failure is * resolved by reloading the just-created user after the failed insert transaction has ended. * - * @param request pupil login payload containing username and password + * @param command pupil login payload containing username and password * @return existing or newly created user for the submitted username * @throws DataIntegrityViolationException when persistence fails and no reloaded user can be found */ - fun ensurePupilUserExists(request: PupilLoginRequest): User { - val normalizedUsername = normalizeUsername(request.username) + fun ensurePupilUserExists(command: PupilLoginCommand): User { + val normalizedUsername = normalizeUsername(command.username) userRepository.findByUsernameIgnoreCase(normalizedUsername)?.let { return it } return try { - createPupilUser(normalizedUsername, request.password) + createPupilUser(normalizedUsername, command.password) } catch (exception: DataIntegrityViolationException) { userRepository.findByUsernameIgnoreCase(normalizedUsername) ?: throw exception } diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/RegisteredTeacher.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/RegisteredTeacher.kt new file mode 100644 index 00000000..d73f6e80 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/RegisteredTeacher.kt @@ -0,0 +1,17 @@ +package edu.ntnu.idi.idatt.backend.iam.application + +import edu.ntnu.idi.idatt.backend.iam.domain.UserRole +import edu.ntnu.idi.idatt.backend.iam.domain.UserStatus + +/** + * Summary of a successfully created teacher account. + * + * @property id database identifier of the created teacher user + * @property role created user role + * @property status created user status + */ +data class RegisteredTeacher( + val id: Long, + val role: UserRole, + val status: UserStatus, +) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/TeacherLoginCommand.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/TeacherLoginCommand.kt new file mode 100644 index 00000000..b133110a --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/TeacherLoginCommand.kt @@ -0,0 +1,12 @@ +package edu.ntnu.idi.idatt.backend.iam.application + +/** + * Input values required to authenticate a teacher or admin user. + * + * @property email teacher/admin login email address + * @property password raw password supplied during login + */ +data class TeacherLoginCommand( + val email: String, + val password: String, +) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/TeacherRegistrationCommand.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/TeacherRegistrationCommand.kt new file mode 100644 index 00000000..d6446e68 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/TeacherRegistrationCommand.kt @@ -0,0 +1,16 @@ +package edu.ntnu.idi.idatt.backend.iam.application + +/** + * Input values required to register a teacher account. + * + * @property email teacher login email address + * @property password raw teacher password + * @property fullName teacher full name + * @property schoolName teacher school name + */ +data class TeacherRegistrationCommand( + val email: String, + val password: String, + val fullName: String, + val schoolName: String, +) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/TeacherRegistrationService.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/TeacherRegistrationService.kt index 5922160f..247483a7 100644 --- a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/TeacherRegistrationService.kt +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/TeacherRegistrationService.kt @@ -100,31 +100,3 @@ class TeacherRegistrationService( return normalizedValue } } - -/** - * Input values required to register a teacher account. - * - * @property email teacher login email address - * @property password raw teacher password - * @property fullName teacher full name - * @property schoolName teacher school name - */ -data class TeacherRegistrationCommand( - val email: String, - val password: String, - val fullName: String, - val schoolName: String, -) - -/** - * Summary of a successfully created teacher account. - * - * @property id database identifier of the created teacher user - * @property role created user role - * @property status created user status - */ -data class RegisteredTeacher( - val id: Long, - val role: UserRole, - val status: UserStatus, -) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/domain/PupilProfile.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/domain/PupilProfile.kt new file mode 100644 index 00000000..c8598085 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/domain/PupilProfile.kt @@ -0,0 +1,42 @@ +package edu.ntnu.idi.idatt.backend.iam.domain + +import jakarta.persistence.Column +import jakarta.persistence.Entity +import jakarta.persistence.FetchType +import jakarta.persistence.Id +import jakarta.persistence.JoinColumn +import jakarta.persistence.MapsId +import jakarta.persistence.OneToOne +import jakarta.persistence.Table + +/** + * Persisted pupil profile data attached to a pupil user account. + * + * @property userId shared primary key matching the owning user id + * @property user owning pupil user account + * @property displayName pupil name shown in the product + * @property totalXp accumulated experience points + * @property currentLevel current pupil progression level + * @property currentClassroomId current classroom id, or `null` when unassigned + */ +@Entity +@Table(name = "pupil_profiles") +class PupilProfile( + @Id + @Column(name = "user_id") + var userId: Long? = null, + @MapsId + @OneToOne(fetch = FetchType.LAZY, optional = false) + @JoinColumn(name = "user_id", nullable = false) + var user: User, + @Column(name = "display_name", nullable = false, length = 100) + var displayName: String, + @Column(name = "total_xp", nullable = false) + var totalXp: Int = 0, + @Column(name = "current_level", nullable = false) + var currentLevel: Int = 1, + // TODO: replace with @ManyToOne/@JoinColumn when Classroom table exists + // this column references classrooms.id. + @Column(name = "current_classroom_id") + var currentClassroomId: Long? = null, +) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/infrastructure/PupilProfileRepository.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/infrastructure/PupilProfileRepository.kt new file mode 100644 index 00000000..d4732ae4 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/infrastructure/PupilProfileRepository.kt @@ -0,0 +1,9 @@ +package edu.ntnu.idi.idatt.backend.iam.infrastructure + +import edu.ntnu.idi.idatt.backend.iam.domain.PupilProfile +import org.springframework.data.jpa.repository.JpaRepository + +/** + * Repository for pupil profile persistence. + */ +interface PupilProfileRepository : JpaRepository diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/security/IssuedAccessToken.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/security/IssuedAccessToken.kt new file mode 100644 index 00000000..77040374 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/security/IssuedAccessToken.kt @@ -0,0 +1,12 @@ +package edu.ntnu.idi.idatt.backend.iam.security + +/** + * Result of issuing a JWT access token. + * + * @property token signed JWT access token + * @property expiresInSeconds access-token lifetime in seconds + */ +data class IssuedAccessToken( + val token: String, + val expiresInSeconds: Long, +) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/security/JwtService.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/security/JwtService.kt index 603349b7..04969b09 100644 --- a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/security/JwtService.kt +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/security/JwtService.kt @@ -54,29 +54,3 @@ class JwtService( ) } } - -/** - * Principal data encoded into a JWT access token. - * - * @property subject authenticated user identifier - * @property portalType active portal type for the token - * @property email authenticated user email, or `null` for pupil users - * @property authorities granted authorities included in the token - */ -data class JwtSubject( - val subject: String, - val portalType: String, - val email: String?, - val authorities: Set = emptySet(), -) - -/** - * Result of issuing a JWT access token. - * - * @property token signed JWT access token - * @property expiresInSeconds access-token lifetime in seconds - */ -data class IssuedAccessToken( - val token: String, - val expiresInSeconds: Long, -) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/security/JwtSubject.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/security/JwtSubject.kt new file mode 100644 index 00000000..4958f102 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/security/JwtSubject.kt @@ -0,0 +1,16 @@ +package edu.ntnu.idi.idatt.backend.iam.security + +/** + * Principal data encoded into a JWT access token. + * + * @property subject authenticated user identifier + * @property portalType active portal type for the token + * @property email authenticated user email, or `null` for pupil users + * @property authorities granted authorities included in the token + */ +data class JwtSubject( + val subject: String, + val portalType: String, + val email: String?, + val authorities: Set = emptySet(), +) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/settings/api/UpdateUserSettingsRequest.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/settings/api/UpdateUserSettingsRequest.kt new file mode 100644 index 00000000..874c60c5 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/settings/api/UpdateUserSettingsRequest.kt @@ -0,0 +1,24 @@ +package edu.ntnu.idi.idatt.backend.users.settings.api + +/** + * Request payload for replacing the authenticated user's audio settings. + * + * @property musicEnabled whether background music is enabled + * @property sfxEnabled whether sound effects are enabled + * @property volumeMaster global audio volume + * @property volumeMusic music volume + * @property volumeSfx sound-effects volume + */ +data class UpdateUserSettingsRequest( + val musicEnabled: Boolean, + val sfxEnabled: Boolean, + @field:jakarta.validation.constraints.Min(0) + @field:jakarta.validation.constraints.Max(100) + val volumeMaster: Int, + @field:jakarta.validation.constraints.Min(0) + @field:jakarta.validation.constraints.Max(100) + val volumeMusic: Int, + @field:jakarta.validation.constraints.Min(0) + @field:jakarta.validation.constraints.Max(100) + val volumeSfx: Int, +) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/settings/api/UserSettingsApiMappings.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/settings/api/UserSettingsApiMappings.kt new file mode 100644 index 00000000..7f6915d6 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/settings/api/UserSettingsApiMappings.kt @@ -0,0 +1,32 @@ +package edu.ntnu.idi.idatt.backend.users.settings.api + +import edu.ntnu.idi.idatt.backend.users.settings.application.UpdateUserSettingsCommand +import edu.ntnu.idi.idatt.backend.users.settings.domain.UserSettings + +/** + * Converts the update request payload into an application command. + * + * @return command consumed by the service layer + */ +fun UpdateUserSettingsRequest.toCommand(): UpdateUserSettingsCommand = + UpdateUserSettingsCommand( + musicEnabled = musicEnabled, + sfxEnabled = sfxEnabled, + volumeMaster = volumeMaster, + volumeMusic = volumeMusic, + volumeSfx = volumeSfx, + ) + +/** + * Converts the persisted settings entity into the public API response. + * + * @return response exposed to the frontend + */ +fun UserSettings.toUserSettingsResponse(): UserSettingsResponse = + UserSettingsResponse( + musicEnabled = musicEnabled, + sfxEnabled = sfxEnabled, + volumeMaster = volumeMaster, + volumeMusic = volumeMusic, + volumeSfx = volumeSfx, + ) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/settings/api/UserSettingsController.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/settings/api/UserSettingsController.kt new file mode 100644 index 00000000..6ae0e77a --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/settings/api/UserSettingsController.kt @@ -0,0 +1,46 @@ +package edu.ntnu.idi.idatt.backend.users.settings.api + +import edu.ntnu.idi.idatt.backend.iam.security.CurrentUser +import edu.ntnu.idi.idatt.backend.users.settings.application.UserSettingsService +import jakarta.validation.Valid +import org.springframework.security.core.annotation.AuthenticationPrincipal +import org.springframework.web.bind.annotation.GetMapping +import org.springframework.web.bind.annotation.PutMapping +import org.springframework.web.bind.annotation.RequestBody +import org.springframework.web.bind.annotation.RequestMapping +import org.springframework.web.bind.annotation.RestController + +/** + * Exposes authenticated self-service endpoints for per-user audio settings. + * + * @property userSettingsService application service that handles settings lookup and updates + */ +@RestController +@RequestMapping("/api/v1/users/me/settings") +class UserSettingsController( + private val userSettingsService: UserSettingsService, +) { + /** + * Returns the current authenticated user's settings, creating defaults if needed. + * + * @param currentUser authenticated principal resolved from the JWT access token + * @return current user settings + */ + @GetMapping + fun getSettings(@AuthenticationPrincipal currentUser: CurrentUser): UserSettingsResponse = + userSettingsService.getUserSettings(currentUser.subject).toUserSettingsResponse() + + /** + * Replaces the current authenticated user's settings with the submitted values. + * + * @param currentUser authenticated principal resolved from the JWT access token + * @param request settings payload to persist + * @return updated user settings + */ + @PutMapping + fun updateSettings( + @AuthenticationPrincipal currentUser: CurrentUser, + @Valid @RequestBody request: UpdateUserSettingsRequest, + ): UserSettingsResponse = + userSettingsService.updateUserSettings(currentUser.subject, request.toCommand()).toUserSettingsResponse() +} diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/settings/api/UserSettingsResponse.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/settings/api/UserSettingsResponse.kt new file mode 100644 index 00000000..7cefe5b5 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/settings/api/UserSettingsResponse.kt @@ -0,0 +1,18 @@ +package edu.ntnu.idi.idatt.backend.users.settings.api + +/** + * Response payload for the authenticated user's audio settings. + * + * @property musicEnabled whether background music is enabled + * @property sfxEnabled whether sound effects are enabled + * @property volumeMaster global audio volume + * @property volumeMusic music volume + * @property volumeSfx sound-effects volume + */ +data class UserSettingsResponse( + val musicEnabled: Boolean, + val sfxEnabled: Boolean, + val volumeMaster: Int, + val volumeMusic: Int, + val volumeSfx: Int, +) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/settings/application/UpdateUserSettingsCommand.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/settings/application/UpdateUserSettingsCommand.kt new file mode 100644 index 00000000..7964b517 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/settings/application/UpdateUserSettingsCommand.kt @@ -0,0 +1,18 @@ +package edu.ntnu.idi.idatt.backend.users.settings.application + +/** + * Full audio-settings update payload for the authenticated user. + * + * @property musicEnabled whether background music is enabled + * @property sfxEnabled whether sound effects are enabled + * @property volumeMaster global audio volume + * @property volumeMusic music volume + * @property volumeSfx sound-effects volume + */ +data class UpdateUserSettingsCommand( + val musicEnabled: Boolean, + val sfxEnabled: Boolean, + val volumeMaster: Int, + val volumeMusic: Int, + val volumeSfx: Int, +) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/settings/application/UserSettingsService.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/settings/application/UserSettingsService.kt new file mode 100644 index 00000000..0a8f840b --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/settings/application/UserSettingsService.kt @@ -0,0 +1,95 @@ +package edu.ntnu.idi.idatt.backend.users.settings.application + +import edu.ntnu.idi.idatt.backend.iam.domain.User +import edu.ntnu.idi.idatt.backend.iam.infrastructure.UserRepository +import edu.ntnu.idi.idatt.backend.users.settings.domain.UserSettings +import edu.ntnu.idi.idatt.backend.users.settings.infrastructure.UserSettingsRepository +import org.springframework.http.HttpStatus +import org.springframework.stereotype.Service +import org.springframework.transaction.annotation.Transactional +import org.springframework.web.server.ResponseStatusException + +/** + * Handles lookup and updates of per-user audio settings for authenticated users. + * + * @property userRepository repository used to load the authenticated user + * @property userSettingsRepository repository used to load and persist user settings + */ +@Service +class UserSettingsService( + private val userRepository: UserRepository, + private val userSettingsRepository: UserSettingsRepository, +) { + /** + * Returns the current user's settings, creating defaults on first access when needed. + * + * @param authenticatedSubject JWT subject containing the persisted user id + * @return current user settings + */ + @Transactional + fun getUserSettings(authenticatedSubject: String): UserSettings { + val user = resolveUser(authenticatedSubject) + return findOrCreateSettings(user) + } + + /** + * Replaces the current user's audio settings with the submitted values. + * + * @param authenticatedSubject JWT subject containing the persisted user id + * @param command full settings payload to persist + * @return updated user settings + */ + @Transactional + fun updateUserSettings( + authenticatedSubject: String, + command: UpdateUserSettingsCommand, + ): UserSettings { + validateCommand(command) + val user = resolveUser(authenticatedSubject) + val settings = findOrCreateSettings(user) + settings.update( + musicEnabled = command.musicEnabled, + sfxEnabled = command.sfxEnabled, + volumeMaster = command.volumeMaster, + volumeMusic = command.volumeMusic, + volumeSfx = command.volumeSfx, + ) + return userSettingsRepository.save(settings) + } + + private fun findOrCreateSettings(user: User): UserSettings { + val userId = requireNotNull(user.id) { "Authenticated user is missing an id" } + val existingSettings = userSettingsRepository.findById(userId) + if (existingSettings.isPresent) { + return existingSettings.get() + } + return userSettingsRepository.save(UserSettings.defaultsFor(user)) + } + + private fun resolveUser(authenticatedSubject: String): User { + val userId = authenticatedSubject.toLongOrNull() + ?: throw ResponseStatusException(HttpStatus.UNAUTHORIZED, "Invalid authenticated user subject") + return userRepository.findById(userId) + .orElseThrow { + ResponseStatusException(HttpStatus.UNAUTHORIZED, "Authenticated user was not found") + } + } + + private fun validateCommand(command: UpdateUserSettingsCommand) { + validateVolume("volumeMaster", command.volumeMaster) + validateVolume("volumeMusic", command.volumeMusic) + validateVolume("volumeSfx", command.volumeSfx) + } + + private fun validateVolume( + fieldName: String, + value: Int, + ) { + if (value !in UserSettings.MIN_VOLUME..UserSettings.MAX_VOLUME) { + throw ResponseStatusException( + HttpStatus.BAD_REQUEST, + "$fieldName must be between ${UserSettings.MIN_VOLUME} and ${UserSettings.MAX_VOLUME}", + ) + } + } +} diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/settings/domain/UserSettings.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/settings/domain/UserSettings.kt new file mode 100644 index 00000000..f9c51192 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/settings/domain/UserSettings.kt @@ -0,0 +1,94 @@ +package edu.ntnu.idi.idatt.backend.users.settings.domain + +import edu.ntnu.idi.idatt.backend.iam.domain.User +import jakarta.persistence.Column +import jakarta.persistence.Entity +import jakarta.persistence.FetchType +import jakarta.persistence.Id +import jakarta.persistence.JoinColumn +import jakarta.persistence.MapsId +import jakarta.persistence.OneToOne +import jakarta.persistence.Table + +/** + * Persisted audio settings owned by a single authenticated user. + * + * @property userId shared primary key matching the owning user id + * @property user owning user account + * @property musicEnabled whether background music is enabled + * @property sfxEnabled whether sound effects are enabled + * @property volumeMaster global audio volume + * @property volumeMusic music volume + * @property volumeSfx sound-effects volume + */ +@Entity +@Table(name = "user_settings") +class UserSettings( + @Id + @Column(name = "user_id") + var userId: Long? = null, + @MapsId + @OneToOne(fetch = FetchType.LAZY, optional = false) + @JoinColumn(name = "user_id", nullable = false) + var user: User, + @Column(name = "music_enabled", nullable = false) + var musicEnabled: Boolean = DEFAULT_MUSIC_ENABLED, + @Column(name = "sfx_enabled", nullable = false) + var sfxEnabled: Boolean = DEFAULT_SFX_ENABLED, + @Column(name = "volume_master", nullable = false) + var volumeMaster: Int = DEFAULT_VOLUME_MASTER, + @Column(name = "volume_music", nullable = false) + var volumeMusic: Int = DEFAULT_VOLUME_MUSIC, + @Column(name = "volume_sfx", nullable = false) + var volumeSfx: Int = DEFAULT_VOLUME_SFX, +) { + /** + * Applies a full audio-settings update to the entity. + * + * @param musicEnabled whether music should be enabled + * @param sfxEnabled whether sound effects should be enabled + * @param volumeMaster updated master volume + * @param volumeMusic updated music volume + * @param volumeSfx updated sound-effects volume + * @return nothing; fields are updated in place + */ + fun update( + musicEnabled: Boolean, + sfxEnabled: Boolean, + volumeMaster: Int, + volumeMusic: Int, + volumeSfx: Int, + ) { + this.musicEnabled = musicEnabled + this.sfxEnabled = sfxEnabled + this.volumeMaster = volumeMaster + this.volumeMusic = volumeMusic + this.volumeSfx = volumeSfx + } + + companion object { + const val MIN_VOLUME = 0 + const val MAX_VOLUME = 100 + const val DEFAULT_MUSIC_ENABLED = true + const val DEFAULT_SFX_ENABLED = true + const val DEFAULT_VOLUME_MASTER = 100 + const val DEFAULT_VOLUME_MUSIC = 100 + const val DEFAULT_VOLUME_SFX = 100 + + /** + * Builds the default settings row for a user that has not stored preferences yet. + * + * @param user owning user account + * @return default settings entity ready for persistence + */ + fun defaultsFor(user: User): UserSettings = + UserSettings( + user = user, + musicEnabled = DEFAULT_MUSIC_ENABLED, + sfxEnabled = DEFAULT_SFX_ENABLED, + volumeMaster = DEFAULT_VOLUME_MASTER, + volumeMusic = DEFAULT_VOLUME_MUSIC, + volumeSfx = DEFAULT_VOLUME_SFX, + ) + } +} diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/settings/infrastructure/UserSettingsRepository.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/settings/infrastructure/UserSettingsRepository.kt new file mode 100644 index 00000000..314a0429 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/settings/infrastructure/UserSettingsRepository.kt @@ -0,0 +1,9 @@ +package edu.ntnu.idi.idatt.backend.users.settings.infrastructure + +import edu.ntnu.idi.idatt.backend.users.settings.domain.UserSettings +import org.springframework.data.jpa.repository.JpaRepository + +/** + * Repository for user-settings persistence. + */ +interface UserSettingsRepository : JpaRepository diff --git a/src/main/resources/application-dev.properties b/src/main/resources/application-dev.properties new file mode 100644 index 00000000..5a88ed11 --- /dev/null +++ b/src/main/resources/application-dev.properties @@ -0,0 +1 @@ +app.bootstrap.enabled=true diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties index 2cb250b2..bc20d06b 100644 --- a/src/main/resources/application.properties +++ b/src/main/resources/application.properties @@ -1,6 +1,8 @@ spring.application.name=backend spring.config.import=optional:file:.env[.properties],optional:file:.env.dev[.properties] +app.bootstrap.enabled=${APP_BOOTSTRAP_ENABLED:false} + app.security.jwt.issuer=${APP_SECURITY_JWT_ISSUER} app.security.jwt.audience=${APP_SECURITY_JWT_AUDIENCE} app.security.jwt.secret=${APP_SECURITY_JWT_SECRET} diff --git a/src/main/resources/db/migration/V4__create_user_settings_table.sql b/src/main/resources/db/migration/V4__create_user_settings_table.sql new file mode 100644 index 00000000..f5f8ba2a --- /dev/null +++ b/src/main/resources/db/migration/V4__create_user_settings_table.sql @@ -0,0 +1,14 @@ +CREATE TABLE user_settings ( + user_id BIGINT NOT NULL, + music_enabled BOOLEAN NOT NULL DEFAULT TRUE, + sfx_enabled BOOLEAN NOT NULL DEFAULT TRUE, + volume_master INT NOT NULL DEFAULT 100, + volume_music INT NOT NULL DEFAULT 100, + volume_sfx INT NOT NULL DEFAULT 100, + CONSTRAINT pk_user_settings PRIMARY KEY (user_id), + CONSTRAINT fk_user_settings_user + FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE, + CONSTRAINT chk_user_settings_volume_master CHECK (volume_master BETWEEN 0 AND 100), + CONSTRAINT chk_user_settings_volume_music CHECK (volume_music BETWEEN 0 AND 100), + CONSTRAINT chk_user_settings_volume_sfx CHECK (volume_sfx BETWEEN 0 AND 100) +); diff --git a/src/test/kotlin/edu/ntnu/idi/idatt/backend/iam/AuthControllerIntegrationTests.kt b/src/test/kotlin/edu/ntnu/idi/idatt/backend/iam/AuthControllerIntegrationTests.kt index 622b5fdf..505d5add 100644 --- a/src/test/kotlin/edu/ntnu/idi/idatt/backend/iam/AuthControllerIntegrationTests.kt +++ b/src/test/kotlin/edu/ntnu/idi/idatt/backend/iam/AuthControllerIntegrationTests.kt @@ -23,6 +23,7 @@ import org.springframework.security.test.web.servlet.request.SecurityMockMvcRequ import org.springframework.test.web.servlet.MockMvc import org.springframework.test.web.servlet.get import org.springframework.test.web.servlet.post +import org.springframework.test.web.servlet.put import java.time.Instant @SpringBootTest @@ -384,6 +385,113 @@ class AuthControllerIntegrationTests { } } + @Test + fun `authenticated teacher can change password and old password no longer works`() { + userRepository.save(activeTeacher()) + val accessToken = teacherAccessToken(email = "teacher@example.com", password = "secret123") + + mockMvc.put("/api/v1/auth/me/password") { + with(csrf()) + contentType = MediaType.APPLICATION_JSON + header("Authorization", "Bearer $accessToken") + content = """{"currentPassword":"secret123","newPassword":"newSecret123"}""" + }.andExpect { + status { isNoContent() } + } + + val persistedUser = requireNotNull(userRepository.findByEmailIgnoreCase("teacher@example.com")) + assertTrue(passwordEncoder.matches("newSecret123", persistedUser.passwordHash)) + + mockMvc.post("/api/v1/auth/teacher/login") { + with(csrf()) + contentType = MediaType.APPLICATION_JSON + content = """{"email":"teacher@example.com","password":"secret123"}""" + }.andExpect { + status { isUnauthorized() } + } + + mockMvc.post("/api/v1/auth/teacher/login") { + with(csrf()) + contentType = MediaType.APPLICATION_JSON + content = """{"email":"teacher@example.com","password":"newSecret123"}""" + }.andExpect { + status { isOk() } + } + } + + @Test + fun `authenticated admin can change password`() { + userRepository.save(activeAdmin()) + val accessToken = teacherAccessToken(email = "admin@example.com", password = "secret123") + + mockMvc.put("/api/v1/auth/me/password") { + with(csrf()) + contentType = MediaType.APPLICATION_JSON + header("Authorization", "Bearer $accessToken") + content = """{"currentPassword":"secret123","newPassword":"newSecret123"}""" + }.andExpect { + status { isNoContent() } + } + + val persistedUser = requireNotNull(userRepository.findByEmailIgnoreCase("admin@example.com")) + assertTrue(passwordEncoder.matches("newSecret123", persistedUser.passwordHash)) + } + + @Test + fun `authenticated pupil receives forbidden when changing password`() { + userRepository.save(activePupil()) + val accessToken = pupilAccessToken() + + mockMvc.put("/api/v1/auth/me/password") { + with(csrf()) + contentType = MediaType.APPLICATION_JSON + header("Authorization", "Bearer $accessToken") + content = """{"currentPassword":"secret123","newPassword":"newSecret123"}""" + }.andExpect { + status { isForbidden() } + } + } + + @Test + fun `password change validates request body`() { + userRepository.save(activeTeacher()) + val accessToken = teacherAccessToken(email = "teacher@example.com", password = "secret123") + + mockMvc.put("/api/v1/auth/me/password") { + with(csrf()) + contentType = MediaType.APPLICATION_JSON + header("Authorization", "Bearer $accessToken") + content = """{"currentPassword":"","newPassword":"short"}""" + }.andExpect { + status { isBadRequest() } + } + } + + @Test + fun `password change without authentication is rejected`() { + mockMvc.put("/api/v1/auth/me/password") { + with(csrf()) + contentType = MediaType.APPLICATION_JSON + content = """{"currentPassword":"secret123","newPassword":"newSecret123"}""" + }.andExpect { + status { isUnauthorized() } + } + } + + @Test + fun `password change with bearer token succeeds without csrf`() { + userRepository.save(activeTeacher()) + val accessToken = teacherAccessToken(email = "teacher@example.com", password = "secret123") + + mockMvc.put("/api/v1/auth/me/password") { + contentType = MediaType.APPLICATION_JSON + header("Authorization", "Bearer $accessToken") + content = """{"currentPassword":"secret123","newPassword":"newSecret123"}""" + }.andExpect { + status { isNoContent() } + } + } + @Test fun `protected endpoint requires authentication`() { mockMvc.get("/api/v1/auth/me") @@ -399,6 +507,18 @@ class AuthControllerIntegrationTests { content = """{"email":"teacher@example.com","password":"secret123"}""" }.andReturn().response + private fun teacherAccessToken( + email: String, + password: String, + ): String = + mockMvc.post("/api/v1/auth/teacher/login") { + with(csrf()) + contentType = MediaType.APPLICATION_JSON + content = """{"email":"$email","password":"$password"}""" + }.andReturn().response.contentAsString + .substringAfter(""""accessToken":"""") + .substringBefore('"') + private fun pupilLogin(password: String = "secret123") = mockMvc.post("/api/v1/auth/pupil/login") { with(csrf()) @@ -406,6 +526,11 @@ class AuthControllerIntegrationTests { content = """{"username":"pupil_one","password":"$password"}""" }.andReturn().response + private fun pupilAccessToken(password: String = "secret123"): String = + pupilLogin(password).contentAsString + .substringAfter(""""accessToken":"""") + .substringBefore('"') + private fun activeTeacher() = User( email = "teacher@example.com", @@ -414,6 +539,14 @@ class AuthControllerIntegrationTests { status = UserStatus.ACTIVE, ) + private fun activeAdmin() = + User( + email = "admin@example.com", + passwordHash = encodedPassword("secret123"), + role = UserRole.ADMIN, + status = UserStatus.ACTIVE, + ) + private fun activePupil(username: String = "pupil_one") = User( username = username, diff --git a/src/test/kotlin/edu/ntnu/idi/idatt/backend/iam/AuthServiceTests.kt b/src/test/kotlin/edu/ntnu/idi/idatt/backend/iam/AuthServiceTests.kt index 227a194a..497e2094 100644 --- a/src/test/kotlin/edu/ntnu/idi/idatt/backend/iam/AuthServiceTests.kt +++ b/src/test/kotlin/edu/ntnu/idi/idatt/backend/iam/AuthServiceTests.kt @@ -1,7 +1,7 @@ package edu.ntnu.idi.idatt.backend.iam -import edu.ntnu.idi.idatt.backend.iam.api.PupilLoginRequest import edu.ntnu.idi.idatt.backend.iam.application.AuthService +import edu.ntnu.idi.idatt.backend.iam.application.PupilLoginCommand import edu.ntnu.idi.idatt.backend.iam.application.PupilProvisioningService import edu.ntnu.idi.idatt.backend.iam.domain.User import edu.ntnu.idi.idatt.backend.iam.domain.UserRole @@ -54,7 +54,7 @@ class AuthServiceTests { val exception = assertThrows(ResponseStatusException::class.java) { authService.pupilLoginOrCreateUser( - PupilLoginRequest(username = "shared-name", password = "secret123"), + PupilLoginCommand(username = "shared-name", password = "secret123"), ) } diff --git a/src/test/kotlin/edu/ntnu/idi/idatt/backend/iam/PasswordChangeServiceTests.kt b/src/test/kotlin/edu/ntnu/idi/idatt/backend/iam/PasswordChangeServiceTests.kt new file mode 100644 index 00000000..cf4ee54f --- /dev/null +++ b/src/test/kotlin/edu/ntnu/idi/idatt/backend/iam/PasswordChangeServiceTests.kt @@ -0,0 +1,169 @@ +package edu.ntnu.idi.idatt.backend.iam + +import edu.ntnu.idi.idatt.backend.iam.application.ChangePasswordCommand +import edu.ntnu.idi.idatt.backend.iam.application.PasswordChangeService +import edu.ntnu.idi.idatt.backend.iam.domain.User +import edu.ntnu.idi.idatt.backend.iam.domain.UserRole +import edu.ntnu.idi.idatt.backend.iam.domain.UserStatus +import edu.ntnu.idi.idatt.backend.iam.infrastructure.UserRepository +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Assertions.assertNotEquals +import org.junit.jupiter.api.Assertions.assertThrows +import org.junit.jupiter.api.Test +import org.mockito.ArgumentMatchers.any +import org.mockito.Mockito +import org.springframework.http.HttpStatus +import org.springframework.security.crypto.password.PasswordEncoder +import org.springframework.web.server.ResponseStatusException +import java.util.Optional + +class PasswordChangeServiceTests { + @Test + fun `teacher with correct current password gets password updated`() { + val userRepository = Mockito.mock(UserRepository::class.java) + val passwordEncoder = Mockito.mock(PasswordEncoder::class.java) + val service = PasswordChangeService(userRepository, passwordEncoder) + val user = activeUser(id = 7L, role = UserRole.TEACHER, passwordHash = "encoded-old") + + Mockito.`when`(userRepository.findById(7L)).thenReturn(Optional.of(user)) + Mockito.`when`(passwordEncoder.matches("oldSecret123", "encoded-old")).thenReturn(true) + Mockito.`when`(passwordEncoder.encode("newSecret123")).thenReturn("encoded-new") + Mockito.`when`(userRepository.save(any(User::class.java))).thenAnswer { invocation -> + invocation.arguments[0] as User + } + + service.changePassword( + ChangePasswordCommand( + subject = "7", + currentPassword = "oldSecret123", + newPassword = "newSecret123", + ), + ) + + assertEquals("encoded-new", user.passwordHash) + assertNotEquals("newSecret123", user.passwordHash) + } + + @Test + fun `admin with correct current password gets password updated`() { + val userRepository = Mockito.mock(UserRepository::class.java) + val passwordEncoder = Mockito.mock(PasswordEncoder::class.java) + val service = PasswordChangeService(userRepository, passwordEncoder) + val user = activeUser(id = 9L, role = UserRole.ADMIN, passwordHash = "encoded-old") + + Mockito.`when`(userRepository.findById(9L)).thenReturn(Optional.of(user)) + Mockito.`when`(passwordEncoder.matches("oldSecret123", "encoded-old")).thenReturn(true) + Mockito.`when`(passwordEncoder.encode("newSecret123")).thenReturn("encoded-new") + Mockito.`when`(userRepository.save(any(User::class.java))).thenAnswer { invocation -> + invocation.arguments[0] as User + } + + service.changePassword( + ChangePasswordCommand( + subject = "9", + currentPassword = "oldSecret123", + newPassword = "newSecret123", + ), + ) + + assertEquals("encoded-new", user.passwordHash) + } + + @Test + fun `pupil is rejected even with correct current password`() { + val userRepository = Mockito.mock(UserRepository::class.java) + val passwordEncoder = Mockito.mock(PasswordEncoder::class.java) + val service = PasswordChangeService(userRepository, passwordEncoder) + val user = activeUser(id = 11L, role = UserRole.PUPIL, passwordHash = "encoded-old") + + Mockito.`when`(userRepository.findById(11L)).thenReturn(Optional.of(user)) + + val exception = assertThrows(ResponseStatusException::class.java) { + service.changePassword( + ChangePasswordCommand( + subject = "11", + currentPassword = "oldSecret123", + newPassword = "newSecret123", + ), + ) + } + + assertEquals(HttpStatus.FORBIDDEN, exception.statusCode) + } + + @Test + fun `wrong current password is rejected`() { + val userRepository = Mockito.mock(UserRepository::class.java) + val passwordEncoder = Mockito.mock(PasswordEncoder::class.java) + val service = PasswordChangeService(userRepository, passwordEncoder) + val user = activeUser(id = 7L, role = UserRole.TEACHER, passwordHash = "encoded-old") + + Mockito.`when`(userRepository.findById(7L)).thenReturn(Optional.of(user)) + Mockito.`when`(passwordEncoder.matches("wrong-password", "encoded-old")).thenReturn(false) + + val exception = assertThrows(ResponseStatusException::class.java) { + service.changePassword( + ChangePasswordCommand( + subject = "7", + currentPassword = "wrong-password", + newPassword = "newSecret123", + ), + ) + } + + assertEquals(HttpStatus.UNAUTHORIZED, exception.statusCode) + } + + @Test + fun `malformed subject is rejected`() { + val userRepository = Mockito.mock(UserRepository::class.java) + val passwordEncoder = Mockito.mock(PasswordEncoder::class.java) + val service = PasswordChangeService(userRepository, passwordEncoder) + + val exception = assertThrows(ResponseStatusException::class.java) { + service.changePassword( + ChangePasswordCommand( + subject = "not-a-number", + currentPassword = "oldSecret123", + newPassword = "newSecret123", + ), + ) + } + + assertEquals(HttpStatus.UNAUTHORIZED, exception.statusCode) + } + + @Test + fun `missing authenticated user is rejected`() { + val userRepository = Mockito.mock(UserRepository::class.java) + val passwordEncoder = Mockito.mock(PasswordEncoder::class.java) + val service = PasswordChangeService(userRepository, passwordEncoder) + + Mockito.`when`(userRepository.findById(7L)).thenReturn(Optional.empty()) + + val exception = assertThrows(ResponseStatusException::class.java) { + service.changePassword( + ChangePasswordCommand( + subject = "7", + currentPassword = "oldSecret123", + newPassword = "newSecret123", + ), + ) + } + + assertEquals(HttpStatus.UNAUTHORIZED, exception.statusCode) + } + + private fun activeUser( + id: Long, + role: UserRole, + passwordHash: String, + ) = User( + id = id, + email = if (role == UserRole.PUPIL) null else "user@example.com", + username = if (role == UserRole.PUPIL) "pupil-one" else null, + passwordHash = passwordHash, + role = role, + status = UserStatus.ACTIVE, + ) +} diff --git a/src/test/kotlin/edu/ntnu/idi/idatt/backend/iam/PupilProvisioningServiceTests.kt b/src/test/kotlin/edu/ntnu/idi/idatt/backend/iam/PupilProvisioningServiceTests.kt index 9756e9cd..00f3360d 100644 --- a/src/test/kotlin/edu/ntnu/idi/idatt/backend/iam/PupilProvisioningServiceTests.kt +++ b/src/test/kotlin/edu/ntnu/idi/idatt/backend/iam/PupilProvisioningServiceTests.kt @@ -1,6 +1,6 @@ package edu.ntnu.idi.idatt.backend.iam -import edu.ntnu.idi.idatt.backend.iam.api.PupilLoginRequest +import edu.ntnu.idi.idatt.backend.iam.application.PupilLoginCommand import edu.ntnu.idi.idatt.backend.iam.application.PupilProvisioningService import edu.ntnu.idi.idatt.backend.iam.domain.User import edu.ntnu.idi.idatt.backend.iam.domain.UserRole @@ -26,7 +26,7 @@ class PupilProvisioningServiceTests { passwordEncoder, transactionManager(), ) - val request = PupilLoginRequest(username = "fresh-pupil", password = "secret123") + val request = PupilLoginCommand(username = "fresh-pupil", password = "secret123") Mockito.`when`(userRepository.findByUsernameIgnoreCase("fresh-pupil")).thenReturn(null) Mockito.`when`(passwordEncoder.encode("secret123")).thenReturn("encoded-secret") @@ -54,7 +54,7 @@ class PupilProvisioningServiceTests { passwordEncoder, transactionManager(), ) - val request = PupilLoginRequest(username = "racing-pupil", password = "secret123") + val request = PupilLoginCommand(username = "racing-pupil", password = "secret123") val existingUser = User( id = 10L, username = "racing-pupil", diff --git a/src/test/kotlin/edu/ntnu/idi/idatt/backend/users/settings/UserSettingsControllerIntegrationTests.kt b/src/test/kotlin/edu/ntnu/idi/idatt/backend/users/settings/UserSettingsControllerIntegrationTests.kt new file mode 100644 index 00000000..4fb37b0d --- /dev/null +++ b/src/test/kotlin/edu/ntnu/idi/idatt/backend/users/settings/UserSettingsControllerIntegrationTests.kt @@ -0,0 +1,180 @@ +package edu.ntnu.idi.idatt.backend.users.settings + +import com.fasterxml.jackson.databind.json.JsonMapper +import edu.ntnu.idi.idatt.backend.iam.domain.User +import edu.ntnu.idi.idatt.backend.iam.domain.UserRole +import edu.ntnu.idi.idatt.backend.iam.domain.UserStatus +import edu.ntnu.idi.idatt.backend.iam.infrastructure.RefreshTokenRepository +import edu.ntnu.idi.idatt.backend.iam.infrastructure.TeacherProfileRepository +import edu.ntnu.idi.idatt.backend.iam.infrastructure.UserRepository +import edu.ntnu.idi.idatt.backend.users.settings.infrastructure.UserSettingsRepository +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Assertions.assertFalse +import org.junit.jupiter.api.Assertions.assertNotNull +import org.junit.jupiter.api.BeforeEach +import org.junit.jupiter.api.Test +import org.springframework.beans.factory.annotation.Autowired +import org.springframework.boot.test.context.SpringBootTest +import org.springframework.boot.webmvc.test.autoconfigure.AutoConfigureMockMvc +import org.springframework.http.HttpHeaders +import org.springframework.http.MediaType +import org.springframework.security.crypto.password.PasswordEncoder +import org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.csrf +import org.springframework.test.web.servlet.MockMvc +import org.springframework.test.web.servlet.get +import org.springframework.test.web.servlet.post +import org.springframework.test.web.servlet.put + +@SpringBootTest +@AutoConfigureMockMvc +class UserSettingsControllerIntegrationTests { + @Autowired + private lateinit var mockMvc: MockMvc + + @Autowired + private lateinit var userRepository: UserRepository + + @Autowired + private lateinit var userSettingsRepository: UserSettingsRepository + + @Autowired + private lateinit var refreshTokenRepository: RefreshTokenRepository + + @Autowired + private lateinit var teacherProfileRepository: TeacherProfileRepository + + @Autowired + private lateinit var passwordEncoder: PasswordEncoder + + @BeforeEach + fun setUp() { + refreshTokenRepository.deleteAll() + teacherProfileRepository.deleteAll() + userSettingsRepository.deleteAll() + userRepository.deleteAll() + } + + @Test + fun `authenticated get returns default settings on first access`() { + userRepository.save(activePupil()) + val accessToken = pupilAccessToken() + + mockMvc.get("/api/v1/users/me/settings") { + header(HttpHeaders.AUTHORIZATION, "Bearer $accessToken") + }.andExpect { + status { isOk() } + jsonPath("$.musicEnabled") { value(true) } + jsonPath("$.sfxEnabled") { value(true) } + jsonPath("$.volumeMaster") { value(100) } + jsonPath("$.volumeMusic") { value(100) } + jsonPath("$.volumeSfx") { value(100) } + } + + val persistedSettings = userSettingsRepository.findAll().single() + assertNotNull(persistedSettings.userId) + assertEquals(1, userSettingsRepository.count()) + } + + @Test + fun `repeated get does not create duplicate settings rows`() { + userRepository.save(activePupil()) + val accessToken = pupilAccessToken() + + repeat(2) { + mockMvc.get("/api/v1/users/me/settings") { + header(HttpHeaders.AUTHORIZATION, "Bearer $accessToken") + }.andExpect { + status { isOk() } + } + } + + assertEquals(1, userSettingsRepository.count()) + } + + @Test + fun `authenticated put updates persisted settings`() { + userRepository.save(activePupil()) + val accessToken = pupilAccessToken() + + mockMvc.put("/api/v1/users/me/settings") { + with(csrf()) + header(HttpHeaders.AUTHORIZATION, "Bearer $accessToken") + contentType = MediaType.APPLICATION_JSON + content = """ + {"musicEnabled":false,"sfxEnabled":false,"volumeMaster":25,"volumeMusic":15,"volumeSfx":35} + """.trimIndent() + }.andExpect { + status { isOk() } + jsonPath("$.musicEnabled") { value(false) } + jsonPath("$.sfxEnabled") { value(false) } + jsonPath("$.volumeMaster") { value(25) } + jsonPath("$.volumeMusic") { value(15) } + jsonPath("$.volumeSfx") { value(35) } + } + + val persistedSettings = userSettingsRepository.findAll().single() + assertFalse(persistedSettings.musicEnabled) + assertFalse(persistedSettings.sfxEnabled) + assertEquals(25, persistedSettings.volumeMaster) + assertEquals(15, persistedSettings.volumeMusic) + assertEquals(35, persistedSettings.volumeSfx) + } + + @Test + fun `settings endpoints require authentication`() { + mockMvc.get("/api/v1/users/me/settings") + .andExpect { + status { isUnauthorized() } + } + + mockMvc.put("/api/v1/users/me/settings") { + with(csrf()) + contentType = MediaType.APPLICATION_JSON + content = """ + {"musicEnabled":true,"sfxEnabled":true,"volumeMaster":100,"volumeMusic":100,"volumeSfx":100} + """.trimIndent() + }.andExpect { + status { isUnauthorized() } + } + } + + @Test + fun `put succeeds for authenticated bearer token without csrf`() { + userRepository.save(activePupil()) + val accessToken = pupilAccessToken() + + mockMvc.put("/api/v1/users/me/settings") { + header(HttpHeaders.AUTHORIZATION, "Bearer $accessToken") + contentType = MediaType.APPLICATION_JSON + content = """ + {"musicEnabled":true,"sfxEnabled":false,"volumeMaster":80,"volumeMusic":70,"volumeSfx":60} + """.trimIndent() + }.andExpect { + status { isOk() } + jsonPath("$.musicEnabled") { value(true) } + jsonPath("$.sfxEnabled") { value(false) } + jsonPath("$.volumeMaster") { value(80) } + jsonPath("$.volumeMusic") { value(70) } + jsonPath("$.volumeSfx") { value(60) } + } + } + + private fun pupilAccessToken(): String = + JsonMapper.builder().build().readTree( + mockMvc.post("/api/v1/auth/pupil/login") { + with(csrf()) + contentType = MediaType.APPLICATION_JSON + content = """{"username":"pupil_one","password":"secret123"}""" + }.andExpect { + status { isOk() } + }.andReturn().response.contentAsString, + ).get("accessToken").asText() + + private fun activePupil() = + User( + username = "pupil_one", + passwordHash = requireNotNull(passwordEncoder.encode("secret123")), + role = UserRole.PUPIL, + status = UserStatus.ACTIVE, + ) +} diff --git a/src/test/kotlin/edu/ntnu/idi/idatt/backend/users/settings/UserSettingsServiceTests.kt b/src/test/kotlin/edu/ntnu/idi/idatt/backend/users/settings/UserSettingsServiceTests.kt new file mode 100644 index 00000000..e2a99588 --- /dev/null +++ b/src/test/kotlin/edu/ntnu/idi/idatt/backend/users/settings/UserSettingsServiceTests.kt @@ -0,0 +1,149 @@ +package edu.ntnu.idi.idatt.backend.users.settings + +import edu.ntnu.idi.idatt.backend.iam.domain.User +import edu.ntnu.idi.idatt.backend.iam.domain.UserRole +import edu.ntnu.idi.idatt.backend.iam.domain.UserStatus +import edu.ntnu.idi.idatt.backend.iam.infrastructure.UserRepository +import edu.ntnu.idi.idatt.backend.users.settings.application.UpdateUserSettingsCommand +import edu.ntnu.idi.idatt.backend.users.settings.application.UserSettingsService +import edu.ntnu.idi.idatt.backend.users.settings.domain.UserSettings +import edu.ntnu.idi.idatt.backend.users.settings.infrastructure.UserSettingsRepository +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Assertions.assertSame +import org.junit.jupiter.api.Test +import org.mockito.ArgumentMatchers.any +import org.mockito.Mockito +import org.springframework.http.HttpStatus +import org.springframework.web.server.ResponseStatusException +import java.util.Optional + +class UserSettingsServiceTests { + @Test + fun `get user settings returns existing settings for authenticated user`() { + val userRepository = Mockito.mock(UserRepository::class.java) + val userSettingsRepository = Mockito.mock(UserSettingsRepository::class.java) + val service = UserSettingsService(userRepository, userSettingsRepository) + val user = activeUser(id = 42L) + val existingSettings = UserSettings( + userId = 42L, + user = user, + musicEnabled = false, + sfxEnabled = true, + volumeMaster = 60, + volumeMusic = 50, + volumeSfx = 70, + ) + + Mockito.`when`(userRepository.findById(42L)).thenReturn(Optional.of(user)) + Mockito.`when`(userSettingsRepository.findById(42L)).thenReturn(Optional.of(existingSettings)) + + val resolvedSettings = service.getUserSettings("42") + + assertSame(existingSettings, resolvedSettings) + } + + @Test + fun `get user settings creates defaults when settings row is missing`() { + val userRepository = Mockito.mock(UserRepository::class.java) + val userSettingsRepository = Mockito.mock(UserSettingsRepository::class.java) + val service = UserSettingsService(userRepository, userSettingsRepository) + val user = activeUser(id = 42L) + + Mockito.`when`(userRepository.findById(42L)).thenReturn(Optional.of(user)) + Mockito.`when`(userSettingsRepository.findById(42L)).thenReturn(Optional.empty()) + Mockito.`when`(userSettingsRepository.save(any(UserSettings::class.java))).thenAnswer { invocation -> + val savedSettings = invocation.arguments[0] as UserSettings + savedSettings.userId = 42L + savedSettings + } + + val createdSettings = service.getUserSettings("42") + + assertEquals(42L, createdSettings.userId) + assertEquals(UserSettings.DEFAULT_MUSIC_ENABLED, createdSettings.musicEnabled) + assertEquals(UserSettings.DEFAULT_SFX_ENABLED, createdSettings.sfxEnabled) + assertEquals(UserSettings.DEFAULT_VOLUME_MASTER, createdSettings.volumeMaster) + assertEquals(UserSettings.DEFAULT_VOLUME_MUSIC, createdSettings.volumeMusic) + assertEquals(UserSettings.DEFAULT_VOLUME_SFX, createdSettings.volumeSfx) + } + + @Test + fun `update user settings persists submitted values`() { + val userRepository = Mockito.mock(UserRepository::class.java) + val userSettingsRepository = Mockito.mock(UserSettingsRepository::class.java) + val service = UserSettingsService(userRepository, userSettingsRepository) + val user = activeUser(id = 42L) + val existingSettings = UserSettings.defaultsFor(user).apply { + userId = 42L + } + + Mockito.`when`(userRepository.findById(42L)).thenReturn(Optional.of(user)) + Mockito.`when`(userSettingsRepository.findById(42L)).thenReturn(Optional.of(existingSettings)) + Mockito.`when`(userSettingsRepository.save(any(UserSettings::class.java))).thenAnswer { invocation -> + invocation.arguments[0] as UserSettings + } + + val updatedSettings = service.updateUserSettings( + "42", + UpdateUserSettingsCommand( + musicEnabled = false, + sfxEnabled = false, + volumeMaster = 20, + volumeMusic = 10, + volumeSfx = 30, + ), + ) + + assertEquals(false, updatedSettings.musicEnabled) + assertEquals(false, updatedSettings.sfxEnabled) + assertEquals(20, updatedSettings.volumeMaster) + assertEquals(10, updatedSettings.volumeMusic) + assertEquals(30, updatedSettings.volumeSfx) + } + + @Test + fun `update user settings rejects out of range volume`() { + val userRepository = Mockito.mock(UserRepository::class.java) + val userSettingsRepository = Mockito.mock(UserSettingsRepository::class.java) + val service = UserSettingsService(userRepository, userSettingsRepository) + + val exception = org.junit.jupiter.api.assertThrows { + service.updateUserSettings( + "42", + UpdateUserSettingsCommand( + musicEnabled = true, + sfxEnabled = true, + volumeMaster = 101, + volumeMusic = 100, + volumeSfx = 100, + ), + ) + } + + assertEquals(HttpStatus.BAD_REQUEST, exception.statusCode) + } + + @Test + fun `get user settings rejects unknown authenticated user`() { + val userRepository = Mockito.mock(UserRepository::class.java) + val userSettingsRepository = Mockito.mock(UserSettingsRepository::class.java) + val service = UserSettingsService(userRepository, userSettingsRepository) + + Mockito.`when`(userRepository.findById(42L)).thenReturn(Optional.empty()) + + val exception = org.junit.jupiter.api.assertThrows { + service.getUserSettings("42") + } + + assertEquals(HttpStatus.UNAUTHORIZED, exception.statusCode) + } + + private fun activeUser(id: Long) = + User( + id = id, + username = "pupil_one", + passwordHash = "encoded-secret", + role = UserRole.PUPIL, + status = UserStatus.ACTIVE, + ) +}