feat: 기록 수정, 삭제 기능 추가

apis/src/main/kotlin/org/yapp/apis/book/controller/BookController.kt

@@ -33,10 +33,9 @@ class BookController(
 
     @GetMapping("/search")
     override fun searchBooks(
-        @AuthenticationPrincipal userId: UUID,
         @Valid @ModelAttribute request: BookSearchRequest
     ): ResponseEntity<BookSearchResponse> {
-        val response = bookUseCase.searchBooks(request, userId)
+        val response = bookUseCase.searchBooks(request)
         return ResponseEntity.ok(response)
     }
 

apis/src/main/kotlin/org/yapp/apis/book/controller/BookControllerApi.kt

@@ -51,7 +51,6 @@ interface BookControllerApi {
     )
     @GetMapping("/search")
     fun searchBooks(
-        @AuthenticationPrincipal userId: UUID,
         @Valid @Parameter(description = "도서 검색 요청 객체") request: BookSearchRequest
     ): ResponseEntity<BookSearchResponse>
 

apis/src/main/kotlin/org/yapp/apis/book/usecase/BookUseCase.kt

@@ -29,13 +29,10 @@ class BookUseCase(
     private val bookManagementService: BookManagementService
 ) {
     fun searchBooks(
-        request: BookSearchRequest,
-        userId: UUID
+        request: BookSearchRequest
     ): BookSearchResponse {
-        userService.validateUserExists(userId)
-
         val searchResponse = bookQueryService.searchBooks(request)
-        val booksWithUserStatus = mergeWithUserBookStatus(searchResponse.books, userId)
+        val booksWithUserStatus = mergeWithUserBookStatus(searchResponse.books, null)
 
         return searchResponse.withUpdatedBooks(booksWithUserStatus)
     }
@@ -89,10 +86,10 @@ class BookUseCase(
 
     private fun mergeWithUserBookStatus(
         searchedBooks: List<BookSummary>,
-        userId: UUID
+        userId: UUID?
     ): List<BookSummary> {
-        if (searchedBooks.isEmpty()) {
-            return emptyList()
+        if (userId == null || searchedBooks.isEmpty()) {
+            return searchedBooks
         }
 
         val isbn13s = searchedBooks.map { it.isbn13 }
@@ -107,8 +104,9 @@ class BookUseCase(
 
     private fun getUserBookStatusMap(
         isbn13s: List<String>,
-        userId: UUID
+        userId: UUID?
     ): Map<String, BookStatus> {
+        if (userId == null) return emptyMap()
         val userBooksResponse = userBookService.findAllByUserIdAndBookIsbn13In(
             UserBooksByIsbn13sRequest.of(userId, isbn13s)
         )

apis/src/main/kotlin/org/yapp/apis/readingrecord/controller/ReadingRecordController.kt

@@ -7,14 +7,17 @@ import org.springframework.data.web.PageableDefault
 import org.springframework.http.HttpStatus
 import org.springframework.http.ResponseEntity
 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.PostMapping
+import org.springframework.web.bind.annotation.PatchMapping
 import org.springframework.web.bind.annotation.RequestBody
 import org.springframework.web.bind.annotation.RequestMapping
 import org.springframework.web.bind.annotation.RequestParam
 import org.springframework.web.bind.annotation.RestController
 import org.yapp.apis.readingrecord.dto.request.CreateReadingRecordRequest
+import org.yapp.apis.readingrecord.dto.request.UpdateReadingRecordRequest
 import org.yapp.apis.readingrecord.dto.response.ReadingRecordPageResponse // Added import
 import org.yapp.apis.readingrecord.dto.response.ReadingRecordResponse
 import org.yapp.apis.readingrecord.usecase.ReadingRecordUseCase
@@ -80,4 +83,27 @@ class ReadingRecordController(
         val stats = readingRecordUseCase.getSeedStats(userId, userBookId)
         return ResponseEntity.ok(stats)
     }
+
+    @PatchMapping("/{readingRecordId}")
+    override fun updateReadingRecord(
+        @AuthenticationPrincipal userId: UUID,
+        @PathVariable readingRecordId: UUID,
+        @Valid @RequestBody request: UpdateReadingRecordRequest
+    ): ResponseEntity<ReadingRecordResponse> {
+        val response = readingRecordUseCase.updateReadingRecord(
+            userId = userId,
+            readingRecordId = readingRecordId,
+            request = request
+        )
+        return ResponseEntity.ok(response)
+    }
+
+    @DeleteMapping("/{readingRecordId}")
+    override fun deleteReadingRecord(
+        @AuthenticationPrincipal userId: UUID,
+        @PathVariable readingRecordId: UUID
+    ): ResponseEntity<Unit> {
+        readingRecordUseCase.deleteReadingRecord(userId, readingRecordId)
+        return ResponseEntity.noContent().build()
+    }
 }

apis/src/main/kotlin/org/yapp/apis/readingrecord/controller/ReadingRecordControllerApi.kt

@@ -16,6 +16,7 @@ import org.springframework.http.ResponseEntity
 import org.springframework.security.core.annotation.AuthenticationPrincipal
 import org.springframework.web.bind.annotation.*
 import org.yapp.apis.readingrecord.dto.request.CreateReadingRecordRequest
+import org.yapp.apis.readingrecord.dto.request.UpdateReadingRecordRequest
 import org.yapp.apis.readingrecord.dto.response.ReadingRecordPageResponse
 import org.yapp.apis.readingrecord.dto.response.ReadingRecordResponse
 import org.yapp.apis.readingrecord.dto.response.SeedStatsResponse
@@ -131,4 +132,58 @@ interface ReadingRecordControllerApi {
         @AuthenticationPrincipal userId: UUID,
         @PathVariable userBookId: UUID
     ): ResponseEntity<SeedStatsResponse>
+
+    @Operation(
+        summary = "독서 기록 수정",
+        description = "독서 기록 ID로 독서 기록을 수정합니다."
+    )
+    @ApiResponses(
+        value = [
+            ApiResponse(
+                responseCode = "200",
+                description = "독서 기록 수정 성공",
+                content = [Content(schema = Schema(implementation = ReadingRecordResponse::class))]
+            ),
+            ApiResponse(
+                responseCode = "400",
+                description = "잘못된 요청",
+                content = [Content(schema = Schema(implementation = ErrorResponse::class))]
+            ),
+
+            ApiResponse(
+                responseCode = "404",
+                description = "독서 기록을 찾을 수 없음",
+                content = [Content(schema = Schema(implementation = ErrorResponse::class))]
+            )
+        ]
+    )
+    @PatchMapping("/{readingRecordId}")
+    fun updateReadingRecord(
+        @AuthenticationPrincipal @Parameter(description = "인증된 사용자 ID") userId: UUID,
+        @PathVariable @Parameter(description = "수정할 독서 기록 ID") readingRecordId: UUID,
+        @Valid @RequestBody @Parameter(description = "독서 기록 수정 요청 객체") request: UpdateReadingRecordRequest
+    ): ResponseEntity<ReadingRecordResponse>
+
+    @Operation(
+        summary = "독서 기록 삭제",
+        description = "독서 기록 ID로 독서 기록을 삭제합니다."
+    )
+    @ApiResponses(
+        value = [
+            ApiResponse(
+                responseCode = "204",
+                description = "독서 기록 삭제 성공"
+            ),
+            ApiResponse(
+                responseCode = "404",
+                description = "독서 기록을 찾을 수 없음",
+                content = [Content(schema = Schema(implementation = ErrorResponse::class))]
+            )
+        ]
+    )
+    @DeleteMapping("/{readingRecordId}")
+    fun deleteReadingRecord(
+        @AuthenticationPrincipal @Parameter(description = "인증된 사용자 ID") userId: UUID,
+        @PathVariable @Parameter(description = "삭제할 독서 기록 ID") readingRecordId: UUID
+    ): ResponseEntity<Unit>
 }

apis/src/main/kotlin/org/yapp/apis/readingrecord/dto/request/UpdateReadingRecordRequest.kt

@@ -0,0 +1,42 @@
+package org.yapp.apis.readingrecord.dto.request
+
+import io.swagger.v3.oas.annotations.media.Schema
+import jakarta.validation.constraints.Max
+import jakarta.validation.constraints.Min
+import jakarta.validation.constraints.Size
+
+@Schema(
+    name = "UpdateReadingRecordRequest",
+    description = "독서 기록 수정 요청",
+    example = """
+        {
+          "pageNumber": 50,
+          "quote": "수정된 기억에 남는 문장입니다.",
+          "review": "수정된 감상평입니다.",
+          "emotionTags": ["놀라움"]
+        }
+    """
+)
+data class UpdateReadingRecordRequest private constructor(
+    @field:Min(1, message = "페이지 번호는 1 이상이어야 합니다.")
+    @field:Max(9999, message = "페이지 번호는 9999 이하여야 합니다.")
+    @field:Schema(description = "수정할 페이지 번호", example = "50")
+    val pageNumber: Int?,
+
+    @field:Size(max = 1000, message = "기억에 남는 문장은 1000자를 초과할 수 없습니다.")
+    @field:Schema(description = "수정할 기억에 남는 문장", example = "수정된 기억에 남는 문장입니다.")
+    val quote: String?,
+
+    @field:Size(max = 1000, message = "감상평은 1000자를 초과할 수 없습니다.")
+    @field:Schema(description = "수정할 감상평", example = "수정된 감상평입니다.")
+    val review: String?,
+
+    @field:Size(max = 3, message = "감정 태그는 최대 3개까지 가능합니다.")
+    @field:Schema(description = "수정할 감정 태그 목록", example = """["따뜻함","즐거움","슬픔","깨달음"]""")
+    val emotionTags: List<@Size(max = 10, message = "감정 태그는 10자를 초과할 수 없습니다.") String>?
+) {
+    fun validPageNumber(): Int = pageNumber!!
+    fun validQuote(): String = quote!!
+    fun validReview(): String = review!!
+    fun validEmotionTags(): List<String> = emotionTags!!
+}

apis/src/main/kotlin/org/yapp/apis/readingrecord/service/ReadingRecordService.kt

@@ -3,6 +3,7 @@ package org.yapp.apis.readingrecord.service
 import org.springframework.data.domain.Page
 import org.springframework.data.domain.Pageable
 import org.yapp.apis.readingrecord.dto.request.CreateReadingRecordRequest
+import org.yapp.apis.readingrecord.dto.request.UpdateReadingRecordRequest
 import org.yapp.apis.readingrecord.dto.response.ReadingRecordResponse
 import org.yapp.domain.readingrecord.ReadingRecordDomainService
 import org.yapp.domain.readingrecord.ReadingRecordSortType
@@ -45,4 +46,24 @@ class ReadingRecordService(
         val page = readingRecordDomainService.findReadingRecordsByDynamicCondition(userBookId, sort, pageable)
         return page.map { ReadingRecordResponse.from(it) }
     }
+
+    fun updateReadingRecord(
+        readingRecordId: UUID,
+        request: UpdateReadingRecordRequest
+    ): ReadingRecordResponse {
+        val readingRecordInfoVO = readingRecordDomainService.modifyReadingRecord(
+            readingRecordId = readingRecordId,
+            pageNumber = request.validPageNumber(),
+            quote = request.validQuote(),
+            review = request.validReview(),
+            emotionTags = request.validEmotionTags()
+        )
+        return ReadingRecordResponse.from(readingRecordInfoVO)
+    }
+
+    fun deleteReadingRecord(
+        readingRecordId: UUID
+    ) {
+        readingRecordDomainService.deleteReadingRecord(readingRecordId)
+    }
 }

apis/src/main/kotlin/org/yapp/apis/readingrecord/usecase/ReadingRecordUseCase.kt

@@ -5,6 +5,7 @@ import org.springframework.data.domain.Pageable
 import org.springframework.transaction.annotation.Transactional
 import org.yapp.apis.book.service.UserBookService
 import org.yapp.apis.readingrecord.dto.request.CreateReadingRecordRequest
+import org.yapp.apis.readingrecord.dto.request.UpdateReadingRecordRequest
 import org.yapp.apis.readingrecord.dto.response.ReadingRecordPageResponse // Added import
 import org.yapp.apis.readingrecord.dto.response.ReadingRecordResponse
 import org.yapp.apis.readingrecord.dto.response.SeedStatsResponse
@@ -76,4 +77,27 @@ class ReadingRecordUseCase(
         userBookService.validateUserBookExists(userBookId, userId)
         return readingRecordTagService.getSeedStatsByUserIdAndUserBookId(userId, userBookId)
     }
+
+    @Transactional
+    fun updateReadingRecord(
+        userId: UUID,
+        readingRecordId: UUID,
+        request: UpdateReadingRecordRequest
+    ): ReadingRecordResponse {
+        userService.validateUserExists(userId)
+
+        return readingRecordService.updateReadingRecord(
+            readingRecordId = readingRecordId,
+            request = request
+        )
+    }
+
+    @Transactional
+    fun deleteReadingRecord(
+        userId: UUID,
+        readingRecordId: UUID
+    ) {
+        userService.validateUserExists(userId)
+        readingRecordService.deleteReadingRecord(readingRecordId)
+    }
 }

domain/src/main/kotlin/org/yapp/domain/readingrecord/ReadingRecord.kt

@@ -58,6 +58,21 @@ data class ReadingRecord private constructor(
         }
     }
 
+    fun update(
+        pageNumber: Int?,
+        quote: String?,
+        review: String?,
+        emotionTags: List<String>?
+    ): ReadingRecord {
+        return this.copy(
+            pageNumber = pageNumber?.let { PageNumber.newInstance(it) } ?: this.pageNumber,
+            quote = quote?.let { Quote.newInstance(it) } ?: this.quote,
+            review = review?.let { Review.newInstance(it) } ?: this.review,
+            emotionTags = emotionTags?.map { EmotionTag.newInstance(it) } ?: this.emotionTags,
+            updatedAt = LocalDateTime.now()
+        )
+    }
+
     @JvmInline
     value class Id(val value: UUID) {
         companion object {
@@ -114,4 +129,8 @@ data class ReadingRecord private constructor(
             }
         }
     }
+
+    fun delete(): ReadingRecord {
+        return this.copy(deletedAt = LocalDateTime.now())
+    }
 }

domain/src/main/kotlin/org/yapp/domain/readingrecord/ReadingRecordDomainService.kt

@@ -102,24 +102,64 @@ class ReadingRecordDomainService(
         sort: ReadingRecordSortType?,
         pageable: Pageable
     ): Page<ReadingRecordInfoVO> {
-        val page = readingRecordRepository.findReadingRecordsByDynamicCondition(userBookId, sort, pageable)
-
-        // Get the UserBook entity to get the book thumbnail, title, and publisher
-        val userBook = userBookRepository.findById(userBookId)
+        return readingRecordRepository.findReadingRecordsByDynamicCondition(userBookId, sort, pageable)
+            .map { buildReadingRecordInfoVO(it) }
+    }
 
-        return page.map { readingRecord ->
-            val readingRecordTags = readingRecordTagRepository.findByReadingRecordId(readingRecord.id.value)
-            val tagIds = readingRecordTags.map { it.tagId.value }
-            val tags = tagRepository.findByIds(tagIds)
-            ReadingRecordInfoVO.newInstance(
-                readingRecord = readingRecord,
-                emotionTags = tags.map { it.name },
-                bookTitle = userBook?.title,
-                bookPublisher = userBook?.publisher,
-                bookCoverImageUrl = userBook?.coverImageUrl,
-                author = userBook?.author
+    fun modifyReadingRecord(
+        readingRecordId: UUID,
+        pageNumber: Int?,
+        quote: String?,
+        review: String?,
+        emotionTags: List<String>?
+    ): ReadingRecordInfoVO {
+        val readingRecord = readingRecordRepository.findById(readingRecordId)
+            ?: throw ReadingRecordNotFoundException(
+                ReadingRecordErrorCode.READING_RECORD_NOT_FOUND,
+                "Reading record not found with id: $readingRecordId"
             )
+
+        val updatedReadingRecord = readingRecord.update(
+            pageNumber = pageNumber,
+            quote = quote,
+            review = review,
+            emotionTags = emotionTags
+        )
+
+        val savedReadingRecord = readingRecordRepository.save(updatedReadingRecord)
+
+        // Update emotion tags
+        if (emotionTags != null) {
+            readingRecordTagRepository.deleteAllByReadingRecordId(readingRecordId)
+            val tags = emotionTags.map { tagName ->
+                tagRepository.findByName(tagName) ?: tagRepository.save(Tag.create(tagName))
+            }
+            val newReadingRecordTags = tags.map {
+                ReadingRecordTag.create(
+                    readingRecordId = savedReadingRecord.id.value,
+                    tagId = it.id.value
+                )
+            }
+            readingRecordTagRepository.saveAll(newReadingRecordTags)
         }
+
+        return buildReadingRecordInfoVO(savedReadingRecord)
     }
 
+    fun deleteReadingRecord(readingRecordId: UUID) {
+        val readingRecord = readingRecordRepository.findById(readingRecordId)
+            ?: throw ReadingRecordNotFoundException(
+                ReadingRecordErrorCode.READING_RECORD_NOT_FOUND,
+                "Reading record not found with id: $readingRecordId"
+            )
+
+        val userBook = userBookRepository.findById(readingRecord.userBookId.value)
+            ?: throw UserBookNotFoundException(
+                UserBookErrorCode.USER_BOOK_NOT_FOUND,
+                "User book not found with id: ${readingRecord.userBookId.value}"
+            )
+
+        readingRecordRepository.deleteById(readingRecordId)
+        userBookRepository.save(userBook.decreaseReadingRecordCount())
+    }
 }