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 index 3df32441..2bba03ed 100644 --- a/src/main/kotlin/edu/ntnu/idi/idatt/backend/bootstrap/DevDataBootstrap.kt +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/bootstrap/DevDataBootstrap.kt @@ -4,6 +4,9 @@ import edu.ntnu.idi.idatt.backend.classroom.domain.Classroom import edu.ntnu.idi.idatt.backend.classroom.domain.ClassroomPupilStatus import edu.ntnu.idi.idatt.backend.classroom.domain.ClassroomStatus import edu.ntnu.idi.idatt.backend.classroom.infrastructure.ClassroomRepository +import edu.ntnu.idi.idatt.backend.game.gameProgress.domain.PupilGameProgress +import edu.ntnu.idi.idatt.backend.game.gameProgress.domain.PupilGameProgressId +import edu.ntnu.idi.idatt.backend.game.gameProgress.infrastructure.PupilGameProgressRepository import edu.ntnu.idi.idatt.backend.game.mapstops.domain.MapStop import edu.ntnu.idi.idatt.backend.game.mapstops.infrastructure.MapStopsRepository import edu.ntnu.idi.idatt.backend.game.tasks.domain.Task @@ -59,6 +62,7 @@ class DevDataBootstrap( private val pupilProfileRepository: PupilProfileRepository, private val userAvatarRepository: UserAvatarRepository, private val refreshTokenRepository: RefreshTokenRepository, + private val pupilGameProgressRepository: PupilGameProgressRepository, private val passwordEncoder: PasswordEncoder, private val mapStopBootstrap: MapStopBootstrap, private val mapStopsRepository: MapStopsRepository, @@ -97,10 +101,33 @@ class DevDataBootstrap( joinCode = "CLASS42", ) seedClassroomMembership(sampleClassroom, pupilAda, "Ada") + seedClassroomMembership(sampleClassroom, pupilNoah, "Noah") seedPupilProfile(pupilAda, "Ada", sampleClassroom.id) - seedPupilProfile(pupilNoah, "Noah", null) + seedPupilProfile(pupilNoah, "Noah", sampleClassroom.id) seedPupilAvatar(pupilAda) seedPupilAvatar(pupilNoah) + seedPupilGameProgress( + pupil = pupilAda, + classroom = sampleClassroom, + totalScore = 240, + totalXp = 480, + currentLevel = 4, + completedStopsCount = 3, + completedTasksCount = 9, + finalBossCompleted = false, + lastActivityAt = Instant.now().minus(2, ChronoUnit.HOURS), + ) + seedPupilGameProgress( + pupil = pupilNoah, + classroom = sampleClassroom, + totalScore = 125, + totalXp = 260, + currentLevel = 2, + completedStopsCount = 1, + completedTasksCount = 5, + finalBossCompleted = false, + lastActivityAt = Instant.now().minus(1, ChronoUnit.DAYS), + ) seedRefreshToken(admin, "dev-admin-refresh-token", Instant.now().plus(14, ChronoUnit.DAYS), null) seedRefreshToken( @@ -193,7 +220,10 @@ class DevDataBootstrap( currentClassroomId: Long?, ) { val userId = requireNotNull(user.id) { "Pupil seed user must have an id" } - if (pupilProfileRepository.existsById(userId)) { + val existingProfile = pupilProfileRepository.findById(userId).orElse(null) + if (existingProfile != null) { + existingProfile.displayName = displayName + existingProfile.currentClassroomId = currentClassroomId return } @@ -206,6 +236,52 @@ class DevDataBootstrap( ) } + private fun seedPupilGameProgress( + pupil: User, + classroom: Classroom, + totalScore: Int, + totalXp: Int, + currentLevel: Int, + completedStopsCount: Int, + completedTasksCount: Int, + finalBossCompleted: Boolean, + lastActivityAt: Instant, + ) { + val pupilUserId = requireNotNull(pupil.id) { "Pupil seed user must have an id" } + val classroomId = classroom.id + val existingProgress = pupilGameProgressRepository.findByPupilIdAndClassroom_Id(pupilUserId, classroomId) + if (existingProgress != null) { + existingProgress.updateProgress( + totalScore = totalScore, + totalXp = totalXp, + currentLevel = currentLevel, + completedStopsCount = completedStopsCount, + completedTasksCount = completedTasksCount, + finalBossCompleted = finalBossCompleted, + lastActivityAt = lastActivityAt, + ) + return + } + + pupilGameProgressRepository.save( + PupilGameProgress( + id = PupilGameProgressId( + pupilUserId = pupilUserId, + classroomId = classroomId, + ), + pupil = pupil, + classroom = classroom, + totalScore = totalScore, + totalXp = totalXp, + currentLevel = currentLevel, + completedStopsCount = completedStopsCount, + completedTasksCount = completedTasksCount, + finalBossCompleted = finalBossCompleted, + lastActivityAt = lastActivityAt, + ), + ) + } + private fun seedPupilAvatar(user: User) { val userId = requireNotNull(user.id) { "Pupil seed user must have an id" } if (userAvatarRepository.existsById(userId)) { @@ -309,6 +385,11 @@ class DevDataBootstrap( passingScore = seed.passingScore, maxScore = seed.maxScore, ) + if (task.id != null) { + task.items.clear() + task.translations.clear() + taskRepository.saveAndFlush(task) + } applyTaskSeed(task, classroom, teacher, stopId, seed) taskRepository.save(task) } @@ -350,8 +431,6 @@ class DevDataBootstrap( task.passingScore = seed.passingScore task.maxScore = seed.maxScore task.isPublished = seed.isPublished - task.items.clear() - task.translations.clear() addTaskTranslations(task, seed.title, seed.introText) seed.items.forEach { itemSeed -> val item = TaskItem( diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/classroom/application/ClassroomService.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/classroom/application/ClassroomService.kt index 3ef2e358..91f85b6c 100644 --- a/src/main/kotlin/edu/ntnu/idi/idatt/backend/classroom/application/ClassroomService.kt +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/classroom/application/ClassroomService.kt @@ -2,6 +2,9 @@ package edu.ntnu.idi.idatt.backend.classroom.application import edu.ntnu.idi.idatt.backend.classroom.domain.ClassroomStatus import edu.ntnu.idi.idatt.backend.classroom.infrastructure.ClassroomRepository +import edu.ntnu.idi.idatt.backend.game.gameProgress.domain.PupilGameProgress +import edu.ntnu.idi.idatt.backend.game.gameProgress.domain.PupilGameProgressId +import edu.ntnu.idi.idatt.backend.game.gameProgress.infrastructure.PupilGameProgressRepository import edu.ntnu.idi.idatt.backend.iam.application.CurrentUserResolver import org.springframework.context.ApplicationEventPublisher import org.springframework.http.HttpStatus @@ -20,6 +23,7 @@ import java.util.* class ClassroomService( private val classroomRepository: ClassroomRepository, private val currentUserResolver: CurrentUserResolver, + private val pupilGameProgressRepository: PupilGameProgressRepository, private val eventPublisher: ApplicationEventPublisher, ) { /** @@ -47,6 +51,16 @@ class ClassroomService( classroom.addPupilMembership(user) classroomRepository.save(classroom) + pupilGameProgressRepository.save( + PupilGameProgress( + id = PupilGameProgressId( + pupilUserId = userId, + classroomId = classroom.id, + ), + pupil = user, + classroom = classroom, + ), + ) eventPublisher.publishEvent(PupilJoinedClassroomEvent(pupil = user, classroom = classroom)) return JoinClassroomResult( diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/classroom/infrastructure/ClassroomRepository.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/classroom/infrastructure/ClassroomRepository.kt index 3c54ee2b..e814bf04 100644 --- a/src/main/kotlin/edu/ntnu/idi/idatt/backend/classroom/infrastructure/ClassroomRepository.kt +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/classroom/infrastructure/ClassroomRepository.kt @@ -13,4 +13,12 @@ interface ClassroomRepository : JpaRepository { * @return The classroom if found, or null otherwise. */ fun findByJoinCode(code: String): Classroom? -} \ No newline at end of file + + /** + * Finds the first classroom owned by the given teacher, ordered by id. + * + * This is only suitable as a fallback when the caller has not supplied an + * explicit classroom id. + */ + fun findFirstByOwnerTeacherIdOrderByIdAsc(ownerTeacherId: Long): Classroom? +} diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/game/gameProgress/domain/PupilGameProgress.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/game/gameProgress/domain/PupilGameProgress.kt new file mode 100644 index 00000000..d3a1e3aa --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/game/gameProgress/domain/PupilGameProgress.kt @@ -0,0 +1,87 @@ +package edu.ntnu.idi.idatt.backend.game.gameProgress.domain + +import edu.ntnu.idi.idatt.backend.classroom.domain.Classroom +import edu.ntnu.idi.idatt.backend.iam.domain.User +import jakarta.persistence.Column +import jakarta.persistence.Embeddable +import jakarta.persistence.EmbeddedId +import jakarta.persistence.Entity +import jakarta.persistence.FetchType +import jakarta.persistence.JoinColumn +import jakarta.persistence.ManyToOne +import jakarta.persistence.MapsId +import jakarta.persistence.Table +import java.io.Serializable +import java.time.Instant + +/** + * Aggregated classroom-scoped game progress for a pupil. + * + * This entity is the source of truth for leaderboard-related progress values + * within a classroom. It stores both score-based and XP-based progression, + * the pupil's current level, completion counters, whether the final boss has + * been completed, and the timestamp of the latest recorded activity. + * + * The entity is keyed by the combination of pupil and classroom, which means + * each pupil has one progress record per classroom. + */ +@Entity +@Table(name = "pupil_game_progress") +class PupilGameProgress( + @EmbeddedId + var id: PupilGameProgressId = PupilGameProgressId(), + @ManyToOne(fetch = FetchType.LAZY, optional = false) + @MapsId("pupilUserId") + @JoinColumn(name = "pupil_user_id", nullable = false) + var pupil: User? = null, + @ManyToOne(fetch = FetchType.LAZY, optional = false) + @MapsId("classroomId") + @JoinColumn(name = "classroom_id", nullable = false) + var classroom: Classroom? = null, + @Column(name = "total_score", nullable = false) + var totalScore: Int = 0, + @Column(name = "total_xp", nullable = false) + var totalXp: Int = 0, + @Column(name = "current_level", nullable = false) + var currentLevel: Int = 1, + @Column(name = "completed_stops_count", nullable = false) + var completedStopsCount: Int = 0, + @Column(name = "completed_tasks_count", nullable = false) + var completedTasksCount: Int = 0, + @Column(name = "final_boss_completed", nullable = false) + var finalBossCompleted: Boolean = false, + @Column(name = "last_activity_at", nullable = false) + var lastActivityAt: Instant = Instant.now(), +) { + /** + * Replaces the current aggregated progress snapshot for this pupil in the classroom. + */ + fun updateProgress( + totalScore: Int, + totalXp: Int, + currentLevel: Int, + completedStopsCount: Int, + completedTasksCount: Int, + finalBossCompleted: Boolean, + lastActivityAt: Instant, + ) { + this.totalScore = totalScore + this.totalXp = totalXp + this.currentLevel = currentLevel + this.completedStopsCount = completedStopsCount + this.completedTasksCount = completedTasksCount + this.finalBossCompleted = finalBossCompleted + this.lastActivityAt = lastActivityAt + } +} + +/** + * Composite identifier for [PupilGameProgress]. + */ +@Embeddable +data class PupilGameProgressId( + @Column(name = "pupil_user_id") + val pupilUserId: Long = 0, + @Column(name = "classroom_id") + val classroomId: Long = 0, +) : Serializable diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/game/gameProgress/infrastructure/PupilGameProgressRepository.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/game/gameProgress/infrastructure/PupilGameProgressRepository.kt new file mode 100644 index 00000000..91f37f49 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/game/gameProgress/infrastructure/PupilGameProgressRepository.kt @@ -0,0 +1,29 @@ +package edu.ntnu.idi.idatt.backend.game.gameProgress.infrastructure + +import edu.ntnu.idi.idatt.backend.game.gameProgress.domain.PupilGameProgress +import edu.ntnu.idi.idatt.backend.game.gameProgress.domain.PupilGameProgressId +import org.springframework.data.jpa.repository.JpaRepository + +/** + * Repository for pupil game progress. + */ +interface PupilGameProgressRepository : JpaRepository { + /** + * Finds the aggregated game progress for a specific pupil in a specific classroom. + * + * @param pupilUserId the pupil user ID + * @param classroomId the classroom ID + * @return the matching progress record, or null if no record exists + */ + fun findByPupilIdAndClassroom_Id(pupilUserId: Long, classroomId: Long): PupilGameProgress? + + /** + * Finds all progress records for a classroom. + * + * @param classroomId the classroom ID + * @return all progress records registered for the classroom, ordered for leaderboard display + */ + fun findAllByClassroomIdOrderByTotalScoreDescTotalXpDescCurrentLevelDescLastActivityAtDesc( + classroomId: Long, + ): List +} diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/CurrentUserResolver.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/CurrentUserResolver.kt index 5c014069..c4ca05af 100644 --- a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/CurrentUserResolver.kt +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/CurrentUserResolver.kt @@ -1,8 +1,11 @@ package edu.ntnu.idi.idatt.backend.iam.application +import edu.ntnu.idi.idatt.backend.classroom.domain.Classroom +import edu.ntnu.idi.idatt.backend.classroom.infrastructure.ClassroomRepository 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.infrastructure.UserRepository +import edu.ntnu.idi.idatt.backend.users.profile.infrastructure.PupilProfileRepository import org.springframework.http.HttpStatus import org.springframework.stereotype.Service import org.springframework.web.server.ResponseStatusException @@ -15,6 +18,8 @@ import org.springframework.web.server.ResponseStatusException @Service class CurrentUserResolver( private val userRepository: UserRepository, + private val pupilProfileRepository: PupilProfileRepository, + private val classroomRepository: ClassroomRepository, ) { /** * Resolves the authenticated user from the JWT subject claim. @@ -59,5 +64,43 @@ class CurrentUserResolver( return user } + /** + * Resolves a classroom for the authenticated user. + * + * Pupils resolve through `PupilProfile.currentClassroomId`. + * Teachers resolve through the first classroom they own. + * + * Note: teachers can own multiple classrooms. This method therefore only + * works as a fallback when no explicit classroom id is supplied. + * + * @param authenticatedSubject JWT subject containing the persisted user id + * @return resolved classroom + */ + fun getClassroomByUser(authenticatedSubject: String): Classroom { + val user = requireUser(authenticatedSubject) + val userId = requireNotNull(user.id) { "Authenticated user is missing an id" } + + return when (user.role) { + UserRole.PUPIL -> { + val pupilProfile = pupilProfileRepository.findById(userId) + .orElseThrow { + ResponseStatusException(HttpStatus.NOT_FOUND, "Pupil profile was not found") + } + val classroomId = pupilProfile.currentClassroomId + ?: throw ResponseStatusException(HttpStatus.BAD_REQUEST, "Pupil has no current classroom") + classroomRepository.findById(classroomId) + .orElseThrow { + ResponseStatusException(HttpStatus.NOT_FOUND, "Classroom was not found") + } + } + UserRole.TEACHER -> classroomRepository.findFirstByOwnerTeacherIdOrderByIdAsc(userId) + ?: throw ResponseStatusException(HttpStatus.NOT_FOUND, "Teacher does not own any classroom") + + UserRole.ADMIN -> throw ResponseStatusException( + HttpStatus.FORBIDDEN, + "Admins are not associated with a classroom", + ) + } + } } diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/leaderboard/api/LeaderboardApiMappings.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/leaderboard/api/LeaderboardApiMappings.kt new file mode 100644 index 00000000..3726d461 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/leaderboard/api/LeaderboardApiMappings.kt @@ -0,0 +1,26 @@ +package edu.ntnu.idi.idatt.backend.leaderboard.api + +import edu.ntnu.idi.idatt.backend.leaderboard.application.LeaderboardEntry + +/** + * Converts ordered classroom leaderboard rows into the public leaderboard payload. + * + * @return response exposed by the leaderboard API + */ +fun List.toLeaderboardResponse(): LeaderboardResponse = + LeaderboardResponse( + entries = map { entry -> + LeaderboardEntryResponse( + rank = entry.rank, + pupilUserId = entry.pupilUserId, + displayName = entry.displayName, + totalScore = entry.totalScore, + totalXp = entry.totalXp, + currentLevel = entry.currentLevel, + completedStopsCount = entry.completedStopsCount, + completedTasksCount = entry.completedTasksCount, + finalBossCompleted = entry.finalBossCompleted, + lastActivityAt = entry.lastActivityAt, + ) + }, + ) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/leaderboard/api/LeaderboardController.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/leaderboard/api/LeaderboardController.kt new file mode 100644 index 00000000..86843c26 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/leaderboard/api/LeaderboardController.kt @@ -0,0 +1,31 @@ +package edu.ntnu.idi.idatt.backend.leaderboard.api + +import edu.ntnu.idi.idatt.backend.iam.security.CurrentUser +import edu.ntnu.idi.idatt.backend.leaderboard.application.LeaderboardService +import org.springframework.security.core.annotation.AuthenticationPrincipal +import org.springframework.web.bind.annotation.GetMapping +import org.springframework.web.bind.annotation.RequestMapping +import org.springframework.web.bind.annotation.RestController + +/** + * Exposes authenticated leaderboard endpoints. + * + * @property leaderboardService application service that handles classroom leaderboard lookup + */ +@RestController +@RequestMapping("/api/v1/leaderboard") +class LeaderboardController( + private val leaderboardService: LeaderboardService, +) { + /** + * Returns the leaderboard for the authenticated user's resolved classroom. + * + * @param currentUser authenticated principal resolved from the JWT access token + * @return ordered leaderboard entries for the resolved classroom + */ + @GetMapping + fun getLeaderboard( + @AuthenticationPrincipal currentUser: CurrentUser, + ): LeaderboardResponse = + leaderboardService.getClassLeaderboardList(currentUser.subject).toLeaderboardResponse() +} diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/leaderboard/api/LeaderboardResponse.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/leaderboard/api/LeaderboardResponse.kt new file mode 100644 index 00000000..1e4501d4 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/leaderboard/api/LeaderboardResponse.kt @@ -0,0 +1,39 @@ +package edu.ntnu.idi.idatt.backend.leaderboard.api + +import java.time.Instant + +/** + * Response payload for a classroom leaderboard. + * + * @property entries ordered leaderboard rows for the resolved classroom + */ +data class LeaderboardResponse( + val entries: List, +) + +/** + * Public leaderboard row exposed to clients. + * + * @property rank one-based position in the ordered leaderboard + * @property pupilUserId persisted pupil id for the row + * @property displayName pupil display name shown in the product + * @property totalScore total accumulated score within the classroom + * @property totalXp total accumulated XP within the classroom + * @property currentLevel current level reached by the pupil + * @property completedStopsCount number of completed stops + * @property completedTasksCount number of completed tasks + * @property finalBossCompleted whether the final boss has been completed + * @property lastActivityAt timestamp of the latest tracked classroom activity + */ +data class LeaderboardEntryResponse( + val rank: Int, + val pupilUserId: Long, + val displayName: String, + val totalScore: Int, + val totalXp: Int, + val currentLevel: Int, + val completedStopsCount: Int, + val completedTasksCount: Int, + val finalBossCompleted: Boolean, + val lastActivityAt: Instant, +) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/leaderboard/application/LeaderboardService.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/leaderboard/application/LeaderboardService.kt new file mode 100644 index 00000000..4810ca09 --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/leaderboard/application/LeaderboardService.kt @@ -0,0 +1,76 @@ +package edu.ntnu.idi.idatt.backend.leaderboard.application + +import edu.ntnu.idi.idatt.backend.game.gameProgress.infrastructure.PupilGameProgressRepository +import edu.ntnu.idi.idatt.backend.iam.application.CurrentUserResolver +import edu.ntnu.idi.idatt.backend.users.profile.infrastructure.PupilProfileRepository +import org.springframework.stereotype.Service +import org.springframework.transaction.annotation.Transactional + +/** + * Application service for classroom-scoped leaderboard lookups. + * + * The classroom is resolved from the authenticated user: + * pupils use their current classroom, while teachers use an owned classroom + * resolved by [CurrentUserResolver]. + */ +@Service +class LeaderboardService( + private val pupilGameProgressRepository: PupilGameProgressRepository, + private val currentUserResolver: CurrentUserResolver, + private val pupilProfileRepository: PupilProfileRepository, +) { + + /** + * Returns leaderboard entries for the authenticated user's classroom. + * + * Entries are sorted so the leaderboard is deterministic. + * + * @param authenticatedSubject JWT subject containing the persisted user id + * @return classroom leaderboard entries ordered by rank + */ + @Transactional(readOnly = true) + fun getClassLeaderboardList(authenticatedSubject: String): List { + val classroom = currentUserResolver.getClassroomByUser(authenticatedSubject) + + val progressEntries = pupilGameProgressRepository + .findAllByClassroomIdOrderByTotalScoreDescTotalXpDescCurrentLevelDescLastActivityAtDesc(classroom.id) + + val pupilUserIds = progressEntries.mapNotNull { it.pupil?.id }.toSet() + val displayNamesByUserId = pupilProfileRepository.findAllByUserIdIn(pupilUserIds) + .associateBy({ requireNotNull(it.userId) { "Pupil profile is missing user id" } }, { it.displayName }) + + return progressEntries.mapIndexed { index, progress -> + val pupil = requireNotNull(progress.pupil) { "Leaderboard row is missing pupil relation" } + val pupilUserId = requireNotNull(pupil.id) { "Leaderboard row pupil is missing id" } + + LeaderboardEntry( + rank = index + 1, + pupilUserId = pupilUserId, + displayName = displayNamesByUserId[pupilUserId] ?: pupil.username ?: "Unknown pupil", + totalScore = progress.totalScore, + totalXp = progress.totalXp, + currentLevel = progress.currentLevel, + completedStopsCount = progress.completedStopsCount, + completedTasksCount = progress.completedTasksCount, + finalBossCompleted = progress.finalBossCompleted, + lastActivityAt = progress.lastActivityAt, + ) + } + } +} + +/** + * Internal leaderboard row projection enriched with pupil profile data. + */ +data class LeaderboardEntry( + val rank: Int, + val pupilUserId: Long, + val displayName: String, + val totalScore: Int, + val totalXp: Int, + val currentLevel: Int, + val completedStopsCount: Int, + val completedTasksCount: Int, + val finalBossCompleted: Boolean, + val lastActivityAt: java.time.Instant, +) diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/profile/infrastructure/PupilProfileRepository.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/profile/infrastructure/PupilProfileRepository.kt index d71ed3ed..9befd76c 100644 --- a/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/profile/infrastructure/PupilProfileRepository.kt +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/users/profile/infrastructure/PupilProfileRepository.kt @@ -6,4 +6,9 @@ import org.springframework.data.jpa.repository.JpaRepository /** * Repository for pupil profile persistence. */ -interface PupilProfileRepository : JpaRepository +interface PupilProfileRepository : JpaRepository { + /** + * Finds all pupil profiles for the given user ids. + */ + fun findAllByUserIdIn(userIds: Collection): List +} diff --git a/src/main/resources/db/migration/V12__create_pupil_game_progress_table.sql b/src/main/resources/db/migration/V12__create_pupil_game_progress_table.sql new file mode 100644 index 00000000..262dcdb0 --- /dev/null +++ b/src/main/resources/db/migration/V12__create_pupil_game_progress_table.sql @@ -0,0 +1,18 @@ +CREATE TABLE pupil_game_progress ( + pupil_user_id BIGINT NOT NULL, + classroom_id BIGINT NOT NULL, + total_score INT NOT NULL DEFAULT 0, + total_xp INT NOT NULL DEFAULT 0, + current_level INT NOT NULL DEFAULT 1, + completed_stops_count INT NOT NULL DEFAULT 0, + completed_tasks_count INT NOT NULL DEFAULT 0, + final_boss_completed BOOLEAN NOT NULL DEFAULT FALSE, + last_activity_at DATETIME(6) NOT NULL, + CONSTRAINT pk_pupil_game_progress PRIMARY KEY (pupil_user_id, classroom_id), + CONSTRAINT fk_pgp_pupil + FOREIGN KEY (pupil_user_id) REFERENCES users (id) ON DELETE CASCADE, + CONSTRAINT fk_pgp_classroom + FOREIGN KEY (classroom_id) REFERENCES classrooms (id) ON DELETE CASCADE +); + +CREATE INDEX idx_pgp_classroom ON pupil_game_progress (classroom_id); diff --git a/src/test/kotlin/edu/ntnu/idi/idatt/backend/classroom/ClassroomIntegrationTests.kt b/src/test/kotlin/edu/ntnu/idi/idatt/backend/classroom/ClassroomIntegrationTests.kt index 83ca65eb..013a1bad 100644 --- a/src/test/kotlin/edu/ntnu/idi/idatt/backend/classroom/ClassroomIntegrationTests.kt +++ b/src/test/kotlin/edu/ntnu/idi/idatt/backend/classroom/ClassroomIntegrationTests.kt @@ -4,6 +4,7 @@ import com.fasterxml.jackson.databind.json.JsonMapper import edu.ntnu.idi.idatt.backend.classroom.domain.Classroom import edu.ntnu.idi.idatt.backend.classroom.domain.ClassroomStatus import edu.ntnu.idi.idatt.backend.classroom.infrastructure.ClassroomRepository +import edu.ntnu.idi.idatt.backend.game.gameProgress.infrastructure.PupilGameProgressRepository 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 @@ -39,6 +40,9 @@ class ClassroomIntegrationTests { @Autowired private lateinit var classroomRepository: ClassroomRepository + @Autowired + private lateinit var pupilGameProgressRepository: PupilGameProgressRepository + @Autowired private lateinit var refreshTokenRepository: RefreshTokenRepository @@ -63,6 +67,7 @@ class ClassroomIntegrationTests { fun setUp() { refreshTokenRepository.deleteAll() classroomRepository.deleteAll() + pupilGameProgressRepository.deleteAll() userAvatarRepository.deleteAll() pupilProfileRepository.deleteAll() teacherProfileRepository.deleteAll() @@ -106,6 +111,14 @@ class ClassroomIntegrationTests { requireNotNull(pupil.id), ) ?: 0 assertEquals(1, membershipCount) + + val progressCount = jdbcTemplate.queryForObject( + "SELECT COUNT(*) FROM pupil_game_progress WHERE classroom_id = ? AND pupil_user_id = ?", + Int::class.java, + classroom.id, + requireNotNull(pupil.id), + ) ?: 0 + assertEquals(1, progressCount) } @Test @@ -132,6 +145,14 @@ class ClassroomIntegrationTests { "padding-check", ) ?: 0 assertEquals(1, membershipCount) + + val progressCount = jdbcTemplate.queryForObject( + "SELECT COUNT(*) FROM pupil_game_progress pgp JOIN users u ON u.id = pgp.pupil_user_id WHERE pgp.classroom_id = (SELECT id FROM classrooms WHERE join_code = ?) AND u.username = ?", + Int::class.java, + "CLASS42", + "padding-check", + ) ?: 0 + assertEquals(1, progressCount) } @Test diff --git a/src/test/kotlin/edu/ntnu/idi/idatt/backend/classroom/ClassroomServiceTest.kt b/src/test/kotlin/edu/ntnu/idi/idatt/backend/classroom/ClassroomServiceTest.kt index 67343e1e..9b44f0ac 100644 --- a/src/test/kotlin/edu/ntnu/idi/idatt/backend/classroom/ClassroomServiceTest.kt +++ b/src/test/kotlin/edu/ntnu/idi/idatt/backend/classroom/ClassroomServiceTest.kt @@ -8,6 +8,8 @@ import edu.ntnu.idi.idatt.backend.classroom.domain.ClassroomPupilMembershipId import edu.ntnu.idi.idatt.backend.classroom.domain.ClassroomPupilStatus import edu.ntnu.idi.idatt.backend.classroom.domain.ClassroomStatus import edu.ntnu.idi.idatt.backend.classroom.infrastructure.ClassroomRepository +import edu.ntnu.idi.idatt.backend.game.gameProgress.domain.PupilGameProgress +import edu.ntnu.idi.idatt.backend.game.gameProgress.infrastructure.PupilGameProgressRepository import edu.ntnu.idi.idatt.backend.iam.application.CurrentUserResolver import edu.ntnu.idi.idatt.backend.iam.domain.User import edu.ntnu.idi.idatt.backend.iam.domain.UserRole @@ -16,6 +18,7 @@ import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Assertions.assertTrue import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test +import org.mockito.ArgumentMatchers.any import org.mockito.Mockito.mock import org.mockito.Mockito.never import org.mockito.Mockito.verify @@ -27,6 +30,7 @@ import org.springframework.web.server.ResponseStatusException class ClassroomServiceTest { private lateinit var classroomRepository: ClassroomRepository private lateinit var currentUserResolver: CurrentUserResolver + private lateinit var pupilGameProgressRepository: PupilGameProgressRepository private lateinit var classroomService: ClassroomService private lateinit var eventPublisher: ApplicationEventPublisher @@ -34,8 +38,14 @@ class ClassroomServiceTest { fun setup() { classroomRepository = mock(ClassroomRepository::class.java) currentUserResolver = mock(CurrentUserResolver::class.java) + pupilGameProgressRepository = mock(PupilGameProgressRepository::class.java) eventPublisher = mock(ApplicationEventPublisher::class.java) - classroomService = ClassroomService(classroomRepository, currentUserResolver, eventPublisher) + classroomService = ClassroomService( + classroomRepository, + currentUserResolver, + pupilGameProgressRepository, + eventPublisher, + ) } @Test @@ -55,6 +65,7 @@ class ClassroomServiceTest { assertEquals("class", result.classroomTitle) assertEquals("PENDING", result.membershipStatus) verify(classroomRepository).save(classroom) + verify(pupilGameProgressRepository).save(any(PupilGameProgress::class.java)) verify(classroomRepository).findByJoinCode(classroomCode) } @@ -74,6 +85,7 @@ class ClassroomServiceTest { assertEquals(HttpStatus.CONFLICT, exception.statusCode) verify(classroomRepository, never()).save(classroom) + verify(pupilGameProgressRepository, never()).save(any(PupilGameProgress::class.java)) } @Test @@ -89,6 +101,7 @@ class ClassroomServiceTest { classroomService.joinClassroom(command) } assertEquals(HttpStatus.NOT_FOUND, exception.statusCode) + verify(pupilGameProgressRepository, never()).save(any(PupilGameProgress::class.java)) } @Test @@ -114,6 +127,7 @@ class ClassroomServiceTest { } assertEquals(HttpStatus.CONFLICT, exception.statusCode) + verify(pupilGameProgressRepository, never()).save(any(PupilGameProgress::class.java)) } @Test @@ -134,6 +148,7 @@ class ClassroomServiceTest { assertEquals(HttpStatus.FORBIDDEN, exception.statusCode) verify(classroomRepository, never()).save(classroom) + verify(pupilGameProgressRepository, never()).save(any(PupilGameProgress::class.java)) } @Test @@ -154,6 +169,7 @@ class ClassroomServiceTest { assertEquals(HttpStatus.FORBIDDEN, exception.statusCode) verify(classroomRepository, never()).save(classroom) + verify(pupilGameProgressRepository, never()).save(any(PupilGameProgress::class.java)) } @Test @@ -168,6 +184,7 @@ class ClassroomServiceTest { } assertEquals(HttpStatus.UNAUTHORIZED, exception.statusCode) + verify(pupilGameProgressRepository, never()).save(any(PupilGameProgress::class.java)) } @Test diff --git a/src/test/kotlin/edu/ntnu/idi/idatt/backend/iam/CurrentUserResolverTests.kt b/src/test/kotlin/edu/ntnu/idi/idatt/backend/iam/CurrentUserResolverTests.kt index 013568df..19ce77a6 100644 --- a/src/test/kotlin/edu/ntnu/idi/idatt/backend/iam/CurrentUserResolverTests.kt +++ b/src/test/kotlin/edu/ntnu/idi/idatt/backend/iam/CurrentUserResolverTests.kt @@ -1,10 +1,14 @@ package edu.ntnu.idi.idatt.backend.iam +import edu.ntnu.idi.idatt.backend.classroom.domain.Classroom +import edu.ntnu.idi.idatt.backend.classroom.infrastructure.ClassroomRepository import edu.ntnu.idi.idatt.backend.iam.application.CurrentUserResolver 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.profile.domain.PupilProfile +import edu.ntnu.idi.idatt.backend.users.profile.infrastructure.PupilProfileRepository import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Assertions.assertSame import org.junit.jupiter.api.Test @@ -17,7 +21,9 @@ class CurrentUserResolverTests { @Test fun `require user returns persisted user for valid subject`() { val userRepository = Mockito.mock(UserRepository::class.java) - val resolver = CurrentUserResolver(userRepository) + val pupilProfileRepository = Mockito.mock(PupilProfileRepository::class.java) + val classroomRepository = Mockito.mock(ClassroomRepository::class.java) + val resolver = CurrentUserResolver(userRepository, pupilProfileRepository, classroomRepository) val user = user(id = 42L, role = UserRole.PUPIL) Mockito.`when`(userRepository.findById(42L)).thenReturn(Optional.of(user)) @@ -30,7 +36,9 @@ class CurrentUserResolverTests { @Test fun `require user rejects malformed subject`() { val userRepository = Mockito.mock(UserRepository::class.java) - val resolver = CurrentUserResolver(userRepository) + val pupilProfileRepository = Mockito.mock(PupilProfileRepository::class.java) + val classroomRepository = Mockito.mock(ClassroomRepository::class.java) + val resolver = CurrentUserResolver(userRepository, pupilProfileRepository, classroomRepository) val exception = org.junit.jupiter.api.assertThrows { resolver.requireUser("not-a-number") @@ -42,7 +50,9 @@ class CurrentUserResolverTests { @Test fun `require user rejects missing user`() { val userRepository = Mockito.mock(UserRepository::class.java) - val resolver = CurrentUserResolver(userRepository) + val pupilProfileRepository = Mockito.mock(PupilProfileRepository::class.java) + val classroomRepository = Mockito.mock(ClassroomRepository::class.java) + val resolver = CurrentUserResolver(userRepository, pupilProfileRepository, classroomRepository) Mockito.`when`(userRepository.findById(42L)).thenReturn(Optional.empty()) @@ -56,7 +66,9 @@ class CurrentUserResolverTests { @Test fun `require pupil rejects teacher user`() { val userRepository = Mockito.mock(UserRepository::class.java) - val resolver = CurrentUserResolver(userRepository) + val pupilProfileRepository = Mockito.mock(PupilProfileRepository::class.java) + val classroomRepository = Mockito.mock(ClassroomRepository::class.java) + val resolver = CurrentUserResolver(userRepository, pupilProfileRepository, classroomRepository) val user = user(id = 7L, role = UserRole.TEACHER) Mockito.`when`(userRepository.findById(7L)).thenReturn(Optional.of(user)) @@ -71,7 +83,9 @@ class CurrentUserResolverTests { @Test fun `require teacher or admin rejects pupil user`() { val userRepository = Mockito.mock(UserRepository::class.java) - val resolver = CurrentUserResolver(userRepository) + val pupilProfileRepository = Mockito.mock(PupilProfileRepository::class.java) + val classroomRepository = Mockito.mock(ClassroomRepository::class.java) + val resolver = CurrentUserResolver(userRepository, pupilProfileRepository, classroomRepository) val user = user(id = 9L, role = UserRole.PUPIL) Mockito.`when`(userRepository.findById(9L)).thenReturn(Optional.of(user)) @@ -83,6 +97,47 @@ class CurrentUserResolverTests { assertEquals(HttpStatus.FORBIDDEN, exception.statusCode) } + @Test + fun `resolve classroom by user returns current pupil classroom`() { + val userRepository = Mockito.mock(UserRepository::class.java) + val pupilProfileRepository = Mockito.mock(PupilProfileRepository::class.java) + val classroomRepository = Mockito.mock(ClassroomRepository::class.java) + val resolver = CurrentUserResolver(userRepository, pupilProfileRepository, classroomRepository) + val user = user(id = 11L, role = UserRole.PUPIL) + val classroom = Classroom(id = 101L, ownerTeacherId = 7L, title = "Class A") + val pupilProfile = PupilProfile( + userId = 11L, + user = user, + displayName = "Pupil One", + currentClassroomId = 101L, + ) + + Mockito.`when`(userRepository.findById(11L)).thenReturn(Optional.of(user)) + Mockito.`when`(pupilProfileRepository.findById(11L)).thenReturn(Optional.of(pupilProfile)) + Mockito.`when`(classroomRepository.findById(101L)).thenReturn(Optional.of(classroom)) + + val resolvedClassroom = resolver.getClassroomByUser("11") + + assertSame(classroom, resolvedClassroom) + } + + @Test + fun `resolve classroom by user returns first teacher classroom`() { + val userRepository = Mockito.mock(UserRepository::class.java) + val pupilProfileRepository = Mockito.mock(PupilProfileRepository::class.java) + val classroomRepository = Mockito.mock(ClassroomRepository::class.java) + val resolver = CurrentUserResolver(userRepository, pupilProfileRepository, classroomRepository) + val user = user(id = 12L, role = UserRole.TEACHER) + val classroom = Classroom(id = 202L, ownerTeacherId = 12L, title = "Class B") + + Mockito.`when`(userRepository.findById(12L)).thenReturn(Optional.of(user)) + Mockito.`when`(classroomRepository.findFirstByOwnerTeacherIdOrderByIdAsc(12L)).thenReturn(classroom) + + val resolvedClassroom = resolver.getClassroomByUser("12") + + assertSame(classroom, resolvedClassroom) + } + private fun user( id: Long, role: UserRole,