diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/ClassroomUserResolver.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/ClassroomUserResolver.kt index d5bd1f03..3de5e045 100644 --- a/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/ClassroomUserResolver.kt +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/iam/application/ClassroomUserResolver.kt @@ -71,8 +71,6 @@ class ClassroomUserResolver( /** * Verifies that [user] is a member of the given classroom. * - * TODO: Implement once the classroom membership table is in place. - * * @param user the authenticated user to check * @param classroomId the classroom to verify membership of * @return the classroom if [user] is a member @@ -100,7 +98,18 @@ class ClassroomUserResolver( } return classroom + } - TODO("Not implemented: requires classroom membership table") + /** + * Verifies that a pupil has a membership row in the supplied classroom. + * + * @param classroom classroom whose pupil memberships should be checked. + * @param pupilUserId pupil user id to verify. + * @throws ResponseStatusException 404 if the pupil is not a member of the classroom. + */ + fun requirePupilInClassroom(classroom: Classroom, pupilUserId: Long) { + if (!classroom.hasPupilMembership(pupilUserId)) { + throw ResponseStatusException(HttpStatus.NOT_FOUND, "Pupil not found in classroom") + } } -} \ No newline at end of file +} diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/notebook/api/TeacherNotebookEntryController.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/notebook/api/TeacherNotebookEntryController.kt new file mode 100644 index 00000000..d993579b --- /dev/null +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/notebook/api/TeacherNotebookEntryController.kt @@ -0,0 +1,66 @@ +package edu.ntnu.idi.idatt.backend.notebook.api + +import edu.ntnu.idi.idatt.backend.iam.security.CurrentUser +import edu.ntnu.idi.idatt.backend.notebook.application.NotebookService +import org.springframework.http.HttpStatus +import org.springframework.security.access.prepost.PreAuthorize +import org.springframework.security.core.annotation.AuthenticationPrincipal +import org.springframework.web.bind.annotation.DeleteMapping +import org.springframework.web.bind.annotation.GetMapping +import org.springframework.web.bind.annotation.PathVariable +import org.springframework.web.bind.annotation.RequestMapping +import org.springframework.web.bind.annotation.ResponseStatus +import org.springframework.web.bind.annotation.RestController + +/** + * REST API for teacher review of pupil notebook entries. + */ +@RestController +@RequestMapping("/api/v1/classrooms/{classroomId}/pupils/{pupilUserId}/notebook-entries") +class TeacherNotebookEntryController( + private val notebookService: NotebookService, +) { + /** + * Returns notebook entries for a pupil in a classroom. + * + * @param currentUser authenticated teacher principal + * @param classroomId classroom to scope the notebook to + * @param pupilUserId pupil whose notebook should be reviewed + * @return notebook entries serialized for the API layer + */ + @GetMapping + @PreAuthorize("hasRole('TEACHER')") + fun getPupilNotebookEntries( + @AuthenticationPrincipal currentUser: CurrentUser, + @PathVariable classroomId: Long, + @PathVariable pupilUserId: Long, + ): List = + notebookService + .getNotebookEntriesForTeacherReview(currentUser, classroomId, pupilUserId) + .map { it.toResponse() } + + /** + * Deletes one pupil-authored notebook entry during teacher review. + * + * @param currentUser authenticated teacher principal + * @param classroomId classroom to scope the notebook entry to + * @param pupilUserId pupil whose notebook owns the entry + * @param notebookEntryId notebook entry id to delete + */ + @DeleteMapping("/{notebookEntryId}") + @PreAuthorize("hasRole('TEACHER')") + @ResponseStatus(HttpStatus.NO_CONTENT) + fun deletePupilNotebookEntry( + @AuthenticationPrincipal currentUser: CurrentUser, + @PathVariable classroomId: Long, + @PathVariable pupilUserId: Long, + @PathVariable notebookEntryId: Long, + ) { + notebookService.deleteNotebookEntryForTeacherReview( + currentUser, + classroomId, + pupilUserId, + notebookEntryId, + ) + } +} diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/notebook/application/NotebookService.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/notebook/application/NotebookService.kt index bbcae205..f77c9894 100644 --- a/src/main/kotlin/edu/ntnu/idi/idatt/backend/notebook/application/NotebookService.kt +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/notebook/application/NotebookService.kt @@ -2,6 +2,7 @@ package edu.ntnu.idi.idatt.backend.notebook.application import edu.ntnu.idi.idatt.backend.game.gameProgress.application.PupilGameProgressService import edu.ntnu.idi.idatt.backend.game.mapstops.infrastructure.MapStopsRepository +import edu.ntnu.idi.idatt.backend.iam.application.ClassroomUserResolver import edu.ntnu.idi.idatt.backend.iam.application.CurrentUserResolver import edu.ntnu.idi.idatt.backend.iam.security.CurrentUser import edu.ntnu.idi.idatt.backend.notebook.domain.NotebookEntry @@ -27,6 +28,7 @@ import org.springframework.web.server.ResponseStatusException class NotebookService( private val notebookEntryRepository: NotebookEntryRepository, private val currentUserResolver: CurrentUserResolver, + private val classroomUserResolver: ClassroomUserResolver, private val mapStopsRepository: MapStopsRepository, private val pupilGameProgressService: PupilGameProgressService, private val xpService: XpService, @@ -47,7 +49,35 @@ class NotebookService( val completedStopsCount = pupilGameProgressService.getUserCompletedStopsCount(currentUser) - return notebookEntryRepository.findAllVisibleToPupil(pupilId, classroomId, completedStopsCount) + return notebookEntryRepository.findAllVisibleInNotebook(pupilId, classroomId, completedStopsCount) + } + + /** + * Returns notebook entries for a pupil in a classroom when reviewed by a teacher. + * + * @param currentUser authenticated teacher principal + * @param classroomId classroom to scope the notebook to + * @param pupilUserId pupil whose notebook should be reviewed + * @return notebook entries visible in the pupil's notebook context + */ + @Transactional(readOnly = true) + fun getNotebookEntriesForTeacherReview( + currentUser: CurrentUser, + classroomId: Long, + pupilUserId: Long, + ): List { + val teacher = currentUserResolver.requireTeacherOrAdmin(currentUser.subject) + val classroom = classroomUserResolver.requireClassroomTeacherAccess(teacher, classroomId) + classroomUserResolver.requirePupilInClassroom(classroom, pupilUserId) + + val gameProgress = pupilGameProgressService.getPupilProgress(pupilUserId, classroomId) + val completedStopsCount = gameProgress?.completedStopsCount ?: 0 + + return notebookEntryRepository.findAllVisibleInNotebook( + pupilUserId, + classroomId, + completedStopsCount, + ) } /** @@ -59,6 +89,7 @@ class NotebookService( @Transactional fun createNotebookEntry(command: CreateNotebookEntryCommand): NotebookEntry { val pupil = currentUserResolver.requirePupil(command.currentUser.subject) + requireNotNull(pupil.id) { "Authenticated pupil is missing an id" } val classroom = currentUserResolver.getClassroomByUser(command.currentUser) if (command.sourceType == NotebookSourceType.GAME) { @@ -117,6 +148,42 @@ class NotebookService( notebookEntryRepository.delete(notebookEntry) } + /** + * Deletes one pupil-authored notebook entry during teacher review. + * + * @param currentUser authenticated teacher principal + * @param classroomId classroom to scope the notebook entry to + * @param pupilUserId pupil whose notebook owns the entry + * @param notebookEntryId notebook entry id to delete + */ + @Transactional + fun deleteNotebookEntryForTeacherReview( + currentUser: CurrentUser, + classroomId: Long, + pupilUserId: Long, + notebookEntryId: Long, + ) { + val teacher = currentUserResolver.requireTeacherOrAdmin(currentUser.subject) + val classroom = classroomUserResolver.requireClassroomTeacherAccess(teacher, classroomId) + classroomUserResolver.requirePupilInClassroom(classroom, pupilUserId) + + val notebookEntry = notebookEntryRepository.findById(notebookEntryId).orElseThrow { + ResponseStatusException(HttpStatus.NOT_FOUND, "Notebook entry not found") + } + + if (notebookEntry.sourceType == NotebookSourceType.GAME) { + throw ResponseStatusException(HttpStatus.FORBIDDEN, "Game-generated notebook entries cannot be deleted") + } + + val ownerId = notebookEntry.pupil?.id + val entryClassroomId = notebookEntry.classroom.id + if (ownerId != pupilUserId || entryClassroomId != classroomId) { + throw ResponseStatusException(HttpStatus.FORBIDDEN, "Notebook entry does not belong to this pupil notebook") + } + + notebookEntryRepository.delete(notebookEntry) + } + /** * Loads one notebook entry and verifies that it is owned by the supplied pupil. * @@ -132,7 +199,7 @@ class NotebookService( } if (notebookEntry.sourceType == NotebookSourceType.GAME) { - throw ResponseStatusException(HttpStatus.FORBIDDEN, "Pupil cannot create notebook entries outside the active classroom") + throw ResponseStatusException(HttpStatus.FORBIDDEN, "Game-generated notebook entries cannot be deleted") } val ownerId = notebookEntry.pupil?.id diff --git a/src/main/kotlin/edu/ntnu/idi/idatt/backend/notebook/infrastructure/NotebookEntryRepository.kt b/src/main/kotlin/edu/ntnu/idi/idatt/backend/notebook/infrastructure/NotebookEntryRepository.kt index bf6cd2b1..c46deb7a 100644 --- a/src/main/kotlin/edu/ntnu/idi/idatt/backend/notebook/infrastructure/NotebookEntryRepository.kt +++ b/src/main/kotlin/edu/ntnu/idi/idatt/backend/notebook/infrastructure/NotebookEntryRepository.kt @@ -12,13 +12,14 @@ import org.springframework.stereotype.Repository interface NotebookEntryRepository : JpaRepository { /** - * Finds all notebook entries visible to a pupil: - * - pupil-authored entries owned by the pupil - * - game-authored entries for the pupil's active classroom + * Finds all notebook entries visible in a pupil notebook context: + * - pupil-authored entries owned by the pupil in the classroom + * - game-authored entries for the classroom * * @param pupilId the id of the pupil - * @param classroomId the id of the active classroom - * @return all visible notebook entries + * @param classroomId the id of the classroom + * @param completedStops number of completed stops used to gate notebook visibility + * @return all visible notebook entries for the pupil notebook */ @Query( """ @@ -26,8 +27,13 @@ interface NotebookEntryRepository : JpaRepository { from NotebookEntry notebookEntry where (notebookEntry.pupil.id = :pupilId or (notebookEntry.pupil is null and notebookEntry.classroom.id = :classroomId)) + and notebookEntry.classroom.id = :classroomId and notebookEntry.stop.displayOrder <= :completedStops + 1 """ ) - fun findAllVisibleToPupil(pupilId: Long, classroomId: Long, completedStops: Int): List + fun findAllVisibleInNotebook( + pupilId: Long, + classroomId: Long, + completedStops: Int, + ): List } diff --git a/src/test/kotlin/edu/ntnu/idi/idatt/backend/notebook/NotebookEntryControllerIntegrationTests.kt b/src/test/kotlin/edu/ntnu/idi/idatt/backend/notebook/NotebookEntryControllerIntegrationTests.kt index 94c6de52..ebb0fa09 100644 --- a/src/test/kotlin/edu/ntnu/idi/idatt/backend/notebook/NotebookEntryControllerIntegrationTests.kt +++ b/src/test/kotlin/edu/ntnu/idi/idatt/backend/notebook/NotebookEntryControllerIntegrationTests.kt @@ -83,8 +83,8 @@ class NotebookEntryControllerIntegrationTests { ) val pupil = userRepository.save(activePupil("ada")) val otherPupil = userRepository.save(activePupil("grace")) - pupilProfileRepository.save(PupilProfile(user = pupil, displayName = "Ada", currentClassroom = classroom)) - pupilProfileRepository.save(PupilProfile(user = otherPupil, displayName = "Grace", currentClassroom = classroom)) + pupilProfileRepository.save(pupilProfile(pupil, "Ada", classroom)) + pupilProfileRepository.save(pupilProfile(otherPupil, "Grace", classroom)) notebookEntryRepository.save( NotebookEntry( pupil = pupil, @@ -120,6 +120,86 @@ class NotebookEntryControllerIntegrationTests { assertEquals(requireNotNull(pupil.id), body[0].get("pupilUserId").asLong()) } + @Test + fun `authenticated teacher lists pupil notebook entries`() { + val teacher = userRepository.save(activeTeacher()) + val classroom = classroomRepository.save( + Classroom(ownerTeacherId = requireNotNull(teacher.id), title = "Class A") + ) + val stop = mapStopsRepository.save( + MapStop(slug = "intro", title = "Intro", displayOrder = 1) + ) + val pupil = userRepository.save(activePupil("ada")) + val otherPupil = userRepository.save(activePupil("grace")) + classroom.addPupilMembership(pupil) + classroom.addPupilMembership(otherPupil) + classroomRepository.save(classroom) + pupilProfileRepository.save(pupilProfile(pupil, "Ada", classroom)) + pupilProfileRepository.save(pupilProfile(otherPupil, "Grace", classroom)) + notebookEntryRepository.save( + NotebookEntry( + pupil = pupil, + classroom = classroom, + stop = stop, + sourceType = NotebookSourceType.PUPIL, + title = "Ada note", + content = "Visible to teacher", + ), + ) + notebookEntryRepository.save( + NotebookEntry( + pupil = otherPupil, + classroom = classroom, + stop = stop, + sourceType = NotebookSourceType.PUPIL, + title = "Grace note", + content = "Should not be returned", + ), + ) + notebookEntryRepository.save( + NotebookEntry( + pupil = null, + classroom = classroom, + stop = stop, + sourceType = NotebookSourceType.GAME, + title = "Game note", + content = "Shared note", + ), + ) + val accessToken = teacherAccessToken("teacher@example.com", "secret123") + + val body = readJson( + mockMvc.get("/api/v1/classrooms/${classroom.id}/pupils/${pupil.id}/notebook-entries") { + header(HttpHeaders.AUTHORIZATION, "Bearer $accessToken") + }.andExpect { + status { isOk() } + }.andReturn().response.contentAsString, + ) + + assertEquals(2, body.size()) + assertEquals(listOf("Ada note", "Game note"), body.map { it.get("title").asText() }) + } + + @Test + fun `teacher cannot list pupil notebook outside classroom access`() { + val owner = userRepository.save(activeTeacher("owner@example.com")) + val outsider = userRepository.save(activeTeacher("outsider@example.com")) + val classroom = classroomRepository.save( + Classroom(ownerTeacherId = requireNotNull(owner.id), title = "Class A") + ) + val pupil = userRepository.save(activePupil("ada")) + classroom.addPupilMembership(pupil) + classroomRepository.save(classroom) + pupilProfileRepository.save(pupilProfile(pupil, "Ada", classroom)) + val accessToken = teacherAccessToken(requireNotNull(outsider.email), "secret123") + + mockMvc.get("/api/v1/classrooms/${classroom.id}/pupils/${pupil.id}/notebook-entries") { + header(HttpHeaders.AUTHORIZATION, "Bearer $accessToken") + }.andExpect { + status { isForbidden() } + } + } + @Test fun `authenticated pupil creates notebook entry`() { val teacher = userRepository.save(activeTeacher()) @@ -130,7 +210,7 @@ class NotebookEntryControllerIntegrationTests { MapStop(slug = "intro", title = "Intro", displayOrder = 1) ) val pupil = userRepository.save(activePupil("ada")) - pupilProfileRepository.save(PupilProfile(user = pupil, displayName = "Ada", currentClassroom = classroom)) + pupilProfileRepository.save(pupilProfile(pupil, "Ada", classroom)) val accessToken = pupilAccessToken("ada", "secret123") val body = readJson( @@ -172,7 +252,7 @@ class NotebookEntryControllerIntegrationTests { MapStop(slug = "intro", title = "Intro", displayOrder = 1) ) val pupil = userRepository.save(activePupil("ada")) - pupilProfileRepository.save(PupilProfile(user = pupil, displayName = "Ada", currentClassroom = classroom)) + pupilProfileRepository.save(pupilProfile(pupil, "Ada", classroom)) val entry = notebookEntryRepository.save( NotebookEntry( pupil = pupil, @@ -212,8 +292,8 @@ class NotebookEntryControllerIntegrationTests { ) val pupil = userRepository.save(activePupil("ada")) val otherPupil = userRepository.save(activePupil("grace")) - pupilProfileRepository.save(PupilProfile(user = pupil, displayName = "Ada", currentClassroom = classroom)) - pupilProfileRepository.save(PupilProfile(user = otherPupil, displayName = "Grace", currentClassroom = classroom)) + pupilProfileRepository.save(pupilProfile(pupil, "Ada", classroom)) + pupilProfileRepository.save(pupilProfile(otherPupil, "Grace", classroom)) val entry = notebookEntryRepository.save( NotebookEntry( pupil = otherPupil, @@ -236,6 +316,80 @@ class NotebookEntryControllerIntegrationTests { assertTrue(notebookEntryRepository.findById(requireNotNull(entry.id)).isPresent) } + @Test + fun `authenticated teacher deletes pupil authored notebook entry`() { + val teacher = userRepository.save(activeTeacher()) + val classroom = classroomRepository.save( + Classroom(ownerTeacherId = requireNotNull(teacher.id), title = "Class A") + ) + val stop = mapStopsRepository.save( + MapStop(slug = "intro", title = "Intro", displayOrder = 1) + ) + val pupil = userRepository.save(activePupil("ada")) + classroom.addPupilMembership(pupil) + classroomRepository.save(classroom) + pupilProfileRepository.save(pupilProfile(pupil, "Ada", classroom)) + val entry = notebookEntryRepository.save( + NotebookEntry( + pupil = pupil, + classroom = classroom, + stop = stop, + sourceType = NotebookSourceType.PUPIL, + title = "Bad note", + content = "Delete me", + ), + ) + val accessToken = teacherAccessToken("teacher@example.com", "secret123") + + mockMvc.delete( + "/api/v1/classrooms/${classroom.id}/pupils/${pupil.id}/notebook-entries/${entry.id}", + ) { + with(csrf()) + header(HttpHeaders.AUTHORIZATION, "Bearer $accessToken") + }.andExpect { + status { isNoContent() } + } + + assertTrue(notebookEntryRepository.findById(requireNotNull(entry.id)).isEmpty) + } + + @Test + fun `authenticated teacher cannot delete game authored notebook entry`() { + val teacher = userRepository.save(activeTeacher()) + val classroom = classroomRepository.save( + Classroom(ownerTeacherId = requireNotNull(teacher.id), title = "Class A") + ) + val stop = mapStopsRepository.save( + MapStop(slug = "intro", title = "Intro", displayOrder = 1) + ) + val pupil = userRepository.save(activePupil("ada")) + classroom.addPupilMembership(pupil) + classroomRepository.save(classroom) + pupilProfileRepository.save(pupilProfile(pupil, "Ada", classroom)) + val entry = notebookEntryRepository.save( + NotebookEntry( + pupil = null, + classroom = classroom, + stop = stop, + sourceType = NotebookSourceType.GAME, + title = "Game note", + content = "Keep me", + ), + ) + val accessToken = teacherAccessToken("teacher@example.com", "secret123") + + mockMvc.delete( + "/api/v1/classrooms/${classroom.id}/pupils/${pupil.id}/notebook-entries/${entry.id}", + ) { + with(csrf()) + header(HttpHeaders.AUTHORIZATION, "Bearer $accessToken") + }.andExpect { + status { isForbidden() } + } + + assertTrue(notebookEntryRepository.findById(requireNotNull(entry.id)).isPresent) + } + @Test fun `notebook endpoints require authentication`() { mockMvc.get("/api/v1/users/me/notebook-entries") @@ -265,6 +419,17 @@ class NotebookEntryControllerIntegrationTests { }.andReturn().response.contentAsString, ).get("accessToken").asText() + private fun teacherAccessToken(email: String, password: String): String = + readJson( + mockMvc.post("/api/v1/auth/teacher/login") { + with(csrf()) + contentType = MediaType.APPLICATION_JSON + content = """{"email":"$email","password":"$password"}""" + }.andExpect { + status { isOk() } + }.andReturn().response.contentAsString, + ).get("accessToken").asText() + private fun activePupil(username: String) = User( username = username, passwordHash = requireNotNull(passwordEncoder.encode("secret123")), @@ -272,10 +437,13 @@ class NotebookEntryControllerIntegrationTests { status = UserStatus.ACTIVE, ) - private fun activeTeacher() = User( - email = "teacher@example.com", + private fun activeTeacher(email: String = "teacher@example.com") = User( + email = email, passwordHash = requireNotNull(passwordEncoder.encode("secret123")), role = UserRole.TEACHER, status = UserStatus.ACTIVE, ) + + private fun pupilProfile(pupil: User, displayName: String, classroom: Classroom) = + PupilProfile(user = pupil, displayName = displayName, currentClassroom = classroom) } diff --git a/src/test/kotlin/edu/ntnu/idi/idatt/backend/notebook/NotebookServiceTests.kt b/src/test/kotlin/edu/ntnu/idi/idatt/backend/notebook/NotebookServiceTests.kt index fbd731de..04d6e338 100644 --- a/src/test/kotlin/edu/ntnu/idi/idatt/backend/notebook/NotebookServiceTests.kt +++ b/src/test/kotlin/edu/ntnu/idi/idatt/backend/notebook/NotebookServiceTests.kt @@ -5,6 +5,7 @@ import edu.ntnu.idi.idatt.backend.game.gameProgress.application.PupilGameProgres 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.xp.application.XpService +import edu.ntnu.idi.idatt.backend.iam.application.ClassroomUserResolver 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 @@ -31,6 +32,7 @@ class NotebookServiceTests { @Test fun `get all notebook entries returns persisted rows for authenticated pupil`() { val currentUserResolver = Mockito.mock(CurrentUserResolver::class.java) + val classroomUserResolver = Mockito.mock(ClassroomUserResolver::class.java) val notebookEntryRepository = Mockito.mock(NotebookEntryRepository::class.java) val mapStopsRepository = Mockito.mock(MapStopsRepository::class.java) val pupilGameProgressService = Mockito.mock(PupilGameProgressService::class.java) @@ -38,6 +40,7 @@ class NotebookServiceTests { val service = NotebookService( notebookEntryRepository, currentUserResolver, + classroomUserResolver, mapStopsRepository, pupilGameProgressService, xpService, @@ -50,16 +53,82 @@ class NotebookServiceTests { Mockito.`when`(currentUserResolver.requirePupil("42")).thenReturn(pupil) Mockito.`when`(currentUserResolver.getClassroomByUser(currentUser)).thenReturn(classroom) Mockito.`when`(pupilGameProgressService.getUserCompletedStopsCount(currentUser)).thenReturn(0) - Mockito.`when`(notebookEntryRepository.findAllVisibleToPupil(42L, 7L, 0)).thenReturn(entries) + Mockito.`when`(notebookEntryRepository.findAllVisibleInNotebook(42L, 7L, 0)).thenReturn(entries) val result = service.getAllNotebookEntries(currentUser) assertSame(entries, result) } + @Test + fun `teacher review returns visible entries for pupil notebook`() { + val currentUserResolver = Mockito.mock(CurrentUserResolver::class.java) + val classroomUserResolver = Mockito.mock(ClassroomUserResolver::class.java) + val notebookEntryRepository = Mockito.mock(NotebookEntryRepository::class.java) + val mapStopsRepository = Mockito.mock(MapStopsRepository::class.java) + val pupilGameProgressService = Mockito.mock(PupilGameProgressService::class.java) + val xpService = Mockito.mock(XpService::class.java) + val service = NotebookService( + notebookEntryRepository, + currentUserResolver, + classroomUserResolver, + mapStopsRepository, + pupilGameProgressService, + xpService, + ) + val currentUser = teacherCurrentUser("500") + val teacher = teacherUser(500L) + val pupil = pupilUser(42L) + val classroom = classroom(7L).apply { addPupilMembership(pupil) } + val entries = listOf(notebookEntry(1L, pupil), notebookEntry(2L, null)) + + Mockito.`when`(currentUserResolver.requireTeacherOrAdmin("500")).thenReturn(teacher) + Mockito.`when`(classroomUserResolver.requireClassroomTeacherAccess(teacher, 7L)).thenReturn(classroom) + Mockito.`when`(pupilGameProgressService.getPupilProgress(42L, 7L)).thenReturn(null) + Mockito.`when`(notebookEntryRepository.findAllVisibleInNotebook(42L, 7L, 0)).thenReturn(entries) + + val result = service.getNotebookEntriesForTeacherReview(currentUser, 7L, 42L) + + assertSame(entries, result) + } + + @Test + fun `teacher review rejects pupil outside classroom`() { + val currentUserResolver = Mockito.mock(CurrentUserResolver::class.java) + val classroomUserResolver = Mockito.mock(ClassroomUserResolver::class.java) + val notebookEntryRepository = Mockito.mock(NotebookEntryRepository::class.java) + val mapStopsRepository = Mockito.mock(MapStopsRepository::class.java) + val pupilGameProgressService = Mockito.mock(PupilGameProgressService::class.java) + val xpService = Mockito.mock(XpService::class.java) + val service = NotebookService( + notebookEntryRepository, + currentUserResolver, + classroomUserResolver, + mapStopsRepository, + pupilGameProgressService, + xpService, + ) + val currentUser = teacherCurrentUser("500") + val teacher = teacherUser(500L) + val classroom = classroom(7L) + + Mockito.`when`(currentUserResolver.requireTeacherOrAdmin("500")).thenReturn(teacher) + Mockito.`when`(classroomUserResolver.requireClassroomTeacherAccess(teacher, 7L)).thenReturn(classroom) + Mockito.doThrow(ResponseStatusException(HttpStatus.NOT_FOUND, "Pupil not found in classroom")) + .`when`(classroomUserResolver) + .requirePupilInClassroom(classroom, 42L) + + val exception = assertThrows { + service.getNotebookEntriesForTeacherReview(currentUser, 7L, 42L) + } + + assertEquals(HttpStatus.NOT_FOUND, exception.statusCode) + } + @Test fun `create notebook entry persists resolved pupil classroom and stop`() { val currentUserResolver = Mockito.mock(CurrentUserResolver::class.java) + val classroomUserResolver = Mockito.mock(ClassroomUserResolver::class.java) val notebookEntryRepository = Mockito.mock(NotebookEntryRepository::class.java) val mapStopsRepository = Mockito.mock(MapStopsRepository::class.java) val pupilGameProgressService = Mockito.mock(PupilGameProgressService::class.java) @@ -67,6 +136,7 @@ class NotebookServiceTests { val service = NotebookService( notebookEntryRepository, currentUserResolver, + classroomUserResolver, mapStopsRepository, pupilGameProgressService, xpService, @@ -107,6 +177,7 @@ class NotebookServiceTests { @Test fun `create notebook entry rejects game source`() { val currentUserResolver = Mockito.mock(CurrentUserResolver::class.java) + val classroomUserResolver = Mockito.mock(ClassroomUserResolver::class.java) val notebookEntryRepository = Mockito.mock(NotebookEntryRepository::class.java) val mapStopsRepository = Mockito.mock(MapStopsRepository::class.java) val pupilGameProgressService = Mockito.mock(PupilGameProgressService::class.java) @@ -114,6 +185,7 @@ class NotebookServiceTests { val service = NotebookService( notebookEntryRepository, currentUserResolver, + classroomUserResolver, mapStopsRepository, pupilGameProgressService, xpService, @@ -143,6 +215,7 @@ class NotebookServiceTests { @Test fun `create notebook entry rejects classroom outside active classroom`() { val currentUserResolver = Mockito.mock(CurrentUserResolver::class.java) + val classroomUserResolver = Mockito.mock(ClassroomUserResolver::class.java) val notebookEntryRepository = Mockito.mock(NotebookEntryRepository::class.java) val mapStopsRepository = Mockito.mock(MapStopsRepository::class.java) val pupilGameProgressService = Mockito.mock(PupilGameProgressService::class.java) @@ -150,6 +223,7 @@ class NotebookServiceTests { val service = NotebookService( notebookEntryRepository, currentUserResolver, + classroomUserResolver, mapStopsRepository, pupilGameProgressService, xpService, @@ -179,6 +253,7 @@ class NotebookServiceTests { @Test fun `create notebook entry rejects unknown stop`() { val currentUserResolver = Mockito.mock(CurrentUserResolver::class.java) + val classroomUserResolver = Mockito.mock(ClassroomUserResolver::class.java) val notebookEntryRepository = Mockito.mock(NotebookEntryRepository::class.java) val mapStopsRepository = Mockito.mock(MapStopsRepository::class.java) val pupilGameProgressService = Mockito.mock(PupilGameProgressService::class.java) @@ -186,6 +261,7 @@ class NotebookServiceTests { val service = NotebookService( notebookEntryRepository, currentUserResolver, + classroomUserResolver, mapStopsRepository, pupilGameProgressService, xpService, @@ -216,6 +292,7 @@ class NotebookServiceTests { @Test fun `update notebook entry updates owned row`() { val currentUserResolver = Mockito.mock(CurrentUserResolver::class.java) + val classroomUserResolver = Mockito.mock(ClassroomUserResolver::class.java) val notebookEntryRepository = Mockito.mock(NotebookEntryRepository::class.java) val mapStopsRepository = Mockito.mock(MapStopsRepository::class.java) val pupilGameProgressService = Mockito.mock(PupilGameProgressService::class.java) @@ -223,6 +300,7 @@ class NotebookServiceTests { val service = NotebookService( notebookEntryRepository, currentUserResolver, + classroomUserResolver, mapStopsRepository, pupilGameProgressService, xpService, @@ -254,6 +332,7 @@ class NotebookServiceTests { @Test fun `update notebook entry rejects other pupils entry`() { val currentUserResolver = Mockito.mock(CurrentUserResolver::class.java) + val classroomUserResolver = Mockito.mock(ClassroomUserResolver::class.java) val notebookEntryRepository = Mockito.mock(NotebookEntryRepository::class.java) val mapStopsRepository = Mockito.mock(MapStopsRepository::class.java) val pupilGameProgressService = Mockito.mock(PupilGameProgressService::class.java) @@ -261,6 +340,7 @@ class NotebookServiceTests { val service = NotebookService( notebookEntryRepository, currentUserResolver, + classroomUserResolver, mapStopsRepository, pupilGameProgressService, xpService, @@ -288,6 +368,7 @@ class NotebookServiceTests { @Test fun `delete notebook entry deletes owned row`() { val currentUserResolver = Mockito.mock(CurrentUserResolver::class.java) + val classroomUserResolver = Mockito.mock(ClassroomUserResolver::class.java) val notebookEntryRepository = Mockito.mock(NotebookEntryRepository::class.java) val mapStopsRepository = Mockito.mock(MapStopsRepository::class.java) val pupilGameProgressService = Mockito.mock(PupilGameProgressService::class.java) @@ -295,6 +376,7 @@ class NotebookServiceTests { val service = NotebookService( notebookEntryRepository, currentUserResolver, + classroomUserResolver, mapStopsRepository, pupilGameProgressService, xpService, @@ -318,6 +400,7 @@ class NotebookServiceTests { @Test fun `delete notebook entry rejects other pupils entry`() { val currentUserResolver = Mockito.mock(CurrentUserResolver::class.java) + val classroomUserResolver = Mockito.mock(ClassroomUserResolver::class.java) val notebookEntryRepository = Mockito.mock(NotebookEntryRepository::class.java) val mapStopsRepository = Mockito.mock(MapStopsRepository::class.java) val pupilGameProgressService = Mockito.mock(PupilGameProgressService::class.java) @@ -325,6 +408,7 @@ class NotebookServiceTests { val service = NotebookService( notebookEntryRepository, currentUserResolver, + classroomUserResolver, mapStopsRepository, pupilGameProgressService, xpService, @@ -347,6 +431,72 @@ class NotebookServiceTests { assertEquals(HttpStatus.FORBIDDEN, exception.statusCode) } + @Test + fun `teacher review deletes pupil authored notebook entry`() { + val currentUserResolver = Mockito.mock(CurrentUserResolver::class.java) + val classroomUserResolver = Mockito.mock(ClassroomUserResolver::class.java) + val notebookEntryRepository = Mockito.mock(NotebookEntryRepository::class.java) + val mapStopsRepository = Mockito.mock(MapStopsRepository::class.java) + val pupilGameProgressService = Mockito.mock(PupilGameProgressService::class.java) + val xpService = Mockito.mock(XpService::class.java) + val service = NotebookService( + notebookEntryRepository, + currentUserResolver, + classroomUserResolver, + mapStopsRepository, + pupilGameProgressService, + xpService, + ) + val currentUser = teacherCurrentUser("500") + val teacher = teacherUser(500L) + val pupil = pupilUser(42L) + val classroom = classroom(7L).apply { addPupilMembership(pupil) } + val existing = notebookEntry(15L, pupil) + + Mockito.`when`(currentUserResolver.requireTeacherOrAdmin("500")).thenReturn(teacher) + Mockito.`when`(classroomUserResolver.requireClassroomTeacherAccess(teacher, 7L)).thenReturn(classroom) + Mockito.`when`(notebookEntryRepository.findById(15L)).thenReturn(Optional.of(existing)) + + service.deleteNotebookEntryForTeacherReview(currentUser, 7L, 42L, 15L) + + Mockito.verify(notebookEntryRepository).delete(existing) + } + + @Test + fun `teacher review cannot delete game authored notebook entry`() { + val currentUserResolver = Mockito.mock(CurrentUserResolver::class.java) + val classroomUserResolver = Mockito.mock(ClassroomUserResolver::class.java) + val notebookEntryRepository = Mockito.mock(NotebookEntryRepository::class.java) + val mapStopsRepository = Mockito.mock(MapStopsRepository::class.java) + val pupilGameProgressService = Mockito.mock(PupilGameProgressService::class.java) + val xpService = Mockito.mock(XpService::class.java) + val service = NotebookService( + notebookEntryRepository, + currentUserResolver, + classroomUserResolver, + mapStopsRepository, + pupilGameProgressService, + xpService, + ) + val currentUser = teacherCurrentUser("500") + val teacher = teacherUser(500L) + val pupil = pupilUser(42L) + val classroom = classroom(7L).apply { addPupilMembership(pupil) } + val existing = notebookEntry(15L, null).apply { + sourceType = NotebookSourceType.GAME + } + + Mockito.`when`(currentUserResolver.requireTeacherOrAdmin("500")).thenReturn(teacher) + Mockito.`when`(classroomUserResolver.requireClassroomTeacherAccess(teacher, 7L)).thenReturn(classroom) + Mockito.`when`(notebookEntryRepository.findById(15L)).thenReturn(Optional.of(existing)) + + val exception = assertThrows { + service.deleteNotebookEntryForTeacherReview(currentUser, 7L, 42L, 15L) + } + + assertEquals(HttpStatus.FORBIDDEN, exception.statusCode) + } + private fun currentUser(subject: String) = CurrentUser( subject = subject, portalType = "pupil", @@ -354,6 +504,13 @@ class NotebookServiceTests { authorities = setOf("ROLE_PUPIL"), ) + private fun teacherCurrentUser(subject: String) = CurrentUser( + subject = subject, + portalType = "teacher", + email = "teacher@example.com", + authorities = setOf("ROLE_TEACHER"), + ) + private fun pupilUser(id: Long) = User( id = id, username = "pupil-$id", @@ -362,6 +519,14 @@ class NotebookServiceTests { status = UserStatus.ACTIVE, ) + private fun teacherUser(id: Long) = User( + id = id, + email = "teacher-$id@example.com", + passwordHash = "encoded-secret", + role = UserRole.TEACHER, + status = UserStatus.ACTIVE, + ) + private fun classroom(id: Long) = Classroom( id = id, ownerTeacherId = 500L,