feat: 북마크 여부 포함 경험 전체 조회 API 구현

Api-Module/src/docs/asciidoc/Tag.adoc

@@ -14,7 +14,7 @@ operation::TagControllerTest/createChildTagTest/[snippets='http-request,path-par
 [[GetParentTagTest]]
 === 상위 태그 조회 API
 
-operation::TagControllerTest/getAllParentTagByUserRegisterTest/[snippets='http-request,request-headers,http-response,response-fields']
+operation::TagControllerTest/getAllParentTagByUserTest/[snippets='http-request,request-headers,http-response,response-fields']
 
 [[GetTopRankTagTest]]
 === 연도 내 경험 최근 추가 순 태그 조회 API
@@ -24,7 +24,7 @@ operation::TagControllerTest/getTopRankParentTagTest/[snippets='http-request,req
 [[GetParentTagsByFilter]]
 === 연도 내 상위 태그 조회 API
 
-operation::TagControllerTest/getParentTagsByFilter/[snippets='http-request,http-response,response-fields']
+operation::TagControllerTest/getParentTagsByYear/[snippets='http-request,http-response,response-fields']
 
 [[GetChildTagTest]]
 === 하위 태그 전체 조회 API

Api-Module/src/main/kotlin/com/bamyanggang/apimodule/domain/bookmark/application/BookmarkService.kt

@@ -20,5 +20,4 @@ class BookmarkService(
             bookmarkModifier.modifyBookmarkStatus(it)
         } ?: bookmarkAppender.appendBookmark(jobDescriptionId, experienceId)
     }
-
 }

Api-Module/src/main/kotlin/com/bamyanggang/apimodule/domain/experience/application/dto/GetExperience.kt

@@ -19,6 +19,23 @@ class GetExperience {
         val endedAt: LocalDateTime,
     )
 
+    data class BookmarkResponse(
+        val experience: List<BookmarkDetailExperience>
+    )
+
+    data class BookmarkDetailExperience(
+        val id: UUID,
+        val title: String,
+        val parentTag: DetailTag,
+        val childTag: DetailTag,
+        val strongPoints: List<DetailStrongPoint>,
+        val contents: List<DetailExperienceContent>,
+        val startedAt: LocalDateTime,
+        val endedAt: LocalDateTime,
+        val bookmarked: Boolean,
+    )
+
+
     data class DetailExperienceContent(
         val question: String,
         val answer: String,

Api-Module/src/main/kotlin/com/bamyanggang/apimodule/domain/experience/application/service/ExperienceGetService.kt

@@ -3,31 +3,40 @@ package com.bamyanggang.apimodule.domain.experience.application.service
 import com.bamyanggang.apimodule.common.getAuthenticationPrincipal
 import com.bamyanggang.apimodule.domain.experience.application.dto.ExperienceYear
 import com.bamyanggang.apimodule.domain.experience.application.dto.GetExperience
+import com.bamyanggang.domainmodule.domain.bookmark.enums.BookmarkStatus
+import com.bamyanggang.domainmodule.domain.bookmark.service.BookmarkReader
 import com.bamyanggang.domainmodule.domain.experience.aggregate.Experience
+import com.bamyanggang.domainmodule.domain.experience.aggregate.ExperienceContent
+import com.bamyanggang.domainmodule.domain.experience.aggregate.ExperienceStrongPoint
 import com.bamyanggang.domainmodule.domain.experience.service.ExperienceReader
 import com.bamyanggang.domainmodule.domain.strongpoint.service.StrongPointReader
 import com.bamyanggang.domainmodule.domain.tag.service.TagReader
 import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
 import java.util.*
 
 @Service
 class ExperienceGetService(
     private val experienceReader: ExperienceReader,
     private val strongPointReader: StrongPointReader,
     private val tagReader: TagReader,
+    private val bookMarkReader: BookmarkReader,
 ) {
+    @Transactional(readOnly = true)
     fun getExperienceDetailById(experienceId: UUID) : GetExperience.DetailExperience {
         val oneExperience = experienceReader.readExperience(experienceId)
         return createExperienceDetailResponse(oneExperience)
     }
 
+    @Transactional(readOnly = true)
     fun getAllYearsByExistExperience(): ExperienceYear.Response {
         val currentUserId = getAuthenticationPrincipal()
 
         return experienceReader.readAllYearsByExistExperience(currentUserId)
             .let { ExperienceYear.Response(it) }
     }
 
+    @Transactional(readOnly = true)
     fun getExperienceByYearAndParentTag(year: Int, parentTagId: UUID): GetExperience.Response {
         val experiences = experienceReader.readByYearAndParentTagId(year, parentTagId).map {
             createExperienceDetailResponse(it)
@@ -36,19 +45,58 @@ class ExperienceGetService(
         return GetExperience.Response(experiences)
     }
 
+    @Transactional(readOnly = true)
     fun getExperienceByYearAndChildTag(year: Int, childTagId: UUID): GetExperience.Response {
-        val experiences = experienceReader.readByYearAndParentTagId(year, childTagId).map {
+        val experiences = experienceReader.readByYearAndChildTagId(year, childTagId).map {
             createExperienceDetailResponse(it)
         }
 
         return GetExperience.Response(experiences)
     }
 
+    @Transactional(readOnly = true)
+    fun getAllBookmarkExperiences(jobDescriptionId: UUID): GetExperience.BookmarkResponse {
+        val experienceIds = bookMarkReader.readByStatusAndJobDescriptionId(jobDescriptionId, BookmarkStatus.ON).map { it.experienceId }
+
+        val userExperiences = experienceReader.readAllByUserId(getAuthenticationPrincipal())
+
+        val bookmarkExperienceDetails = userExperiences.map {
+            when {
+                it.id in experienceIds -> createBookmarkExperienceDetailResponse(it, BookmarkStatus.ON)
+                else -> createBookmarkExperienceDetailResponse(it, BookmarkStatus.OFF)
+            }
+        }
+
+        return GetExperience.BookmarkResponse(bookmarkExperienceDetails)
+    }
+
+    @Transactional(readOnly = true)
+    fun getBookmarkExperienceBySearch(jobDescriptionId: UUID, search: String): GetExperience.BookmarkResponse {
+        val currentUserId = getAuthenticationPrincipal()
+
+        val experiencesIds = experienceReader.readByTitleContains(search) +
+                experienceReader.readByContentsContains(currentUserId, search) +
+                tagReader.readIdsByNameContains(search) +
+                strongPointReader.readIdsByNameContains(search)
+
+        val searchExperiences = experienceReader.readByIds(experiencesIds)
+        val bookmarkExperienceIds = bookMarkReader.readByExperienceIds(experiencesIds).map { it.experienceId }
+
+        val bookmarkExperienceDetails = searchExperiences.map {
+            when {
+                it.id in bookmarkExperienceIds -> createBookmarkExperienceDetailResponse(it, BookmarkStatus.ON)
+                else -> createBookmarkExperienceDetailResponse(it, BookmarkStatus.OFF)
+            }
+        }
+
+        return GetExperience.BookmarkResponse(bookmarkExperienceDetails)
+    }
+
     private fun createExperienceDetailResponse(experience: Experience): GetExperience.DetailExperience {
-        val detailExperienceContents = convertDetailExperienceContent(experience)
-        val strongPointDetails = convertStrongPoints(experience)
-        val detailParentTag = convertParentTag(experience)
-        val detailChildTag = convertChildTag(experience)
+        val detailExperienceContents = convertExperienceContent(experience.contents)
+        val strongPointDetails = convertStrongPoints(experience.strongPoints)
+        val detailParentTag = convertParentTag(experience.parentTagId)
+        val detailChildTag = convertChildTag(experience.childTagId)
 
         return GetExperience.DetailExperience(
             id = experience.id,
@@ -62,36 +110,55 @@ class ExperienceGetService(
         )
     }
 
-    private fun convertChildTag(oneExperience: Experience) =
-        tagReader.readById(oneExperience.childTagId).let {
+    private fun createBookmarkExperienceDetailResponse(experience: Experience, bookmarkStatus: BookmarkStatus): GetExperience.BookmarkDetailExperience {
+        val detailExperienceContents = convertExperienceContent(experience.contents)
+        val strongPointDetails = convertStrongPoints(experience.strongPoints)
+        val detailParentTag = convertParentTag(experience.parentTagId)
+        val detailChildTag = convertChildTag(experience.childTagId)
+
+        return GetExperience.BookmarkDetailExperience(
+            id = experience.id,
+            title = experience.title,
+            parentTag = detailParentTag,
+            childTag = detailChildTag,
+            strongPoints = strongPointDetails,
+            contents = detailExperienceContents,
+            startedAt = experience.startedAt,
+            endedAt = experience.endedAt,
+            bookmarked = bookmarkStatus.boolStatus
+        )
+    }
+
+    private fun convertChildTag(childTagId: UUID) =
+        tagReader.readById(childTagId).let {
             GetExperience.DetailTag(
                 it.id,
                 it.name
             )
         }
 
-    private fun convertParentTag(oneExperience: Experience) =
-        tagReader.readById(oneExperience.parentTagId).let {
+    private fun convertParentTag(parentTagId: UUID) =
+        tagReader.readById(parentTagId).let {
             GetExperience.DetailTag(
                 it.id,
                 it.name
             )
         }
 
-    private fun convertDetailExperienceContent(experience: Experience) =
-        experience.contents.map { GetExperience.DetailExperienceContent(
+    private fun convertExperienceContent(contents: List<ExperienceContent>) =
+        contents.map { GetExperience.DetailExperienceContent(
                 it.question,
                 it.answer
             )
         }
 
-    private fun convertStrongPoints(experience: Experience) =
-        experience.strongPoints.map { it.strongPointId }.let {
+    private fun convertStrongPoints(strongPoints: List<ExperienceStrongPoint>) =
+        strongPoints.map { it.strongPointId }.let {
             strongPointReader.readByIds(it).map { strongPoint ->
                 GetExperience.DetailStrongPoint(
                     strongPoint.id,
                     strongPoint.name
                 )
             }
     }
-}   
+}

Api-Module/src/main/kotlin/com/bamyanggang/apimodule/domain/experience/presentation/ExperienceApi.kt

@@ -4,4 +4,5 @@ object ExperienceApi {
     const val BASE_URL = "/api/experiences"
     const val EXPERIENCE_PATH_VARIABLE_URL = "$BASE_URL/{experienceId}"
     const val ALL_YEARS = "$BASE_URL/all-years"
+    const val BOOKMARK_EXPERIENCE_URL = "$BASE_URL/bookmark/{jobDescriptionId}"
 }

Api-Module/src/main/kotlin/com/bamyanggang/apimodule/domain/experience/presentation/ExperienceController.kt

@@ -1,6 +1,9 @@
 package com.bamyanggang.apimodule.domain.experience.presentation
 
-import com.bamyanggang.apimodule.domain.experience.application.dto.*
+import com.bamyanggang.apimodule.domain.experience.application.dto.CreateExperience
+import com.bamyanggang.apimodule.domain.experience.application.dto.EditExperience
+import com.bamyanggang.apimodule.domain.experience.application.dto.ExperienceYear
+import com.bamyanggang.apimodule.domain.experience.application.dto.GetExperience
 import com.bamyanggang.apimodule.domain.experience.application.service.ExperienceCreateService
 import com.bamyanggang.apimodule.domain.experience.application.service.ExperienceDeleteService
 import com.bamyanggang.apimodule.domain.experience.application.service.ExperienceEditService
@@ -15,6 +18,16 @@ class ExperienceController(
     private val experienceEditService: ExperienceEditService,
     private val experienceGetService: ExperienceGetService
 ) {
+    @GetMapping(ExperienceApi.BOOKMARK_EXPERIENCE_URL)
+    fun getBookMarkExperiences(
+        @PathVariable("jobDescriptionId") jobDescriptionId: UUID,
+        @RequestParam("search", required = false) search: String?,
+    ) : GetExperience.BookmarkResponse =
+        when (search) {
+            null -> experienceGetService.getAllBookmarkExperiences(jobDescriptionId)
+            else -> experienceGetService.getBookmarkExperienceBySearch(jobDescriptionId, search)
+        }
+
     @GetMapping(ExperienceApi.BASE_URL)
     fun getExperienceByFilter(@RequestParam("year") year: Int,
                               @RequestParam("parent-tag") parentTagId: UUID,

Api-Module/src/main/kotlin/com/bamyanggang/apimodule/domain/strongpoint/application/service/StrongPointDeleteService.kt

@@ -1,14 +1,15 @@
 package com.bamyanggang.apimodule.domain.strongpoint.application.service
 
-import ch.qos.logback.core.rolling.helper.ArchiveRemover
 import com.bamyanggang.domainmodule.domain.strongpoint.service.StrongPointRemover
 import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
 import java.util.*
 
 @Service
 class StrongPointDeleteService(
     private val strongPointRemover: StrongPointRemover
 ) {
+    @Transactional
     fun deleteStrongPoint(strongPointId: UUID) {
         strongPointRemover.removeStrongPoint(strongPointId)
     }

Api-Module/src/main/kotlin/com/bamyanggang/apimodule/domain/strongpoint/application/service/StrongPointGetService.kt

@@ -4,11 +4,13 @@ import com.bamyanggang.apimodule.common.getAuthenticationPrincipal
 import com.bamyanggang.apimodule.domain.strongpoint.application.dto.GetStrongPoint
 import com.bamyanggang.domainmodule.domain.strongpoint.service.StrongPointReader
 import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
 
 @Service
 class StrongPointGetService(
     private val strongPointReader: StrongPointReader,
 ) {
+    @Transactional(readOnly = true)
     fun getAllStrongPoints(): GetStrongPoint.Response {
         return getAuthenticationPrincipal().let {
             val detailStrongPoints = strongPointReader.readAllByUserId(it).map { strongPoint ->

Api-Module/src/test/kotlin/com/bamyanggang/apimodule/domain/tag/presentation/TagControllerTest.kt

@@ -317,7 +317,7 @@ class TagControllerTest : BaseRestDocsTest() {
                     fieldWithPath("tags[].name").description("태그 이름"),
                 )
             )
-            )
+        )
     }
 
     @Test

Domain-Module/src/main/kotlin/com/bamyanggang/domainmodule/domain/bookmark/enums/BookmarkStatus.kt

@@ -1,6 +1,6 @@
 package com.bamyanggang.domainmodule.domain.bookmark.enums
 
-enum class BookmarkStatus {
-    ON,
-    OFF
+enum class BookmarkStatus(val boolStatus: Boolean) {
+    ON(true),
+    OFF(false)
 }

Domain-Module/src/main/kotlin/com/bamyanggang/domainmodule/domain/bookmark/repository/BookmarkRepository.kt

@@ -1,12 +1,13 @@
 package com.bamyanggang.domainmodule.domain.bookmark.repository
 
 import com.bamyanggang.domainmodule.domain.bookmark.aggregate.Bookmark
+import com.bamyanggang.domainmodule.domain.bookmark.enums.BookmarkStatus
 import java.util.*
 
 interface BookmarkRepository {
 
-    fun findByIds(jobDescriptionId : UUID, experienceId : UUID) : Bookmark?
-
+    fun findById(jobDescriptionId : UUID, experienceId : UUID) : Bookmark?
     fun save(bookmark: Bookmark)
-
+    fun findByStatusAndJobDescriptionId(jobDescriptionId: UUID, status: BookmarkStatus): List<Bookmark>
+    fun findByExperienceIds(experiences: List<UUID>): List<Bookmark>
 }

Domain-Module/src/main/kotlin/com/bamyanggang/domainmodule/domain/bookmark/service/BookmarkReader.kt

@@ -1,6 +1,7 @@
 package com.bamyanggang.domainmodule.domain.bookmark.service
 
 import com.bamyanggang.domainmodule.domain.bookmark.aggregate.Bookmark
+import com.bamyanggang.domainmodule.domain.bookmark.enums.BookmarkStatus
 import com.bamyanggang.domainmodule.domain.bookmark.repository.BookmarkRepository
 import org.springframework.stereotype.Service
 import java.util.*
@@ -11,7 +12,14 @@ class BookmarkReader(
 ) {
 
     fun readBookmark(jobDescriptionId: UUID, experienceId: UUID) : Bookmark? {
-        return bookmarkRepository.findByIds(jobDescriptionId, experienceId)
+        return bookmarkRepository.findById(jobDescriptionId, experienceId)
     }
 
+    fun readByStatusAndJobDescriptionId(jobDescriptionId: UUID, status: BookmarkStatus): List<Bookmark> {
+        return bookmarkRepository.findByStatusAndJobDescriptionId(jobDescriptionId, status)
+    }
+
+    fun readByExperienceIds(experiencesIds: List<UUID>) : List<Bookmark>{
+        return bookmarkRepository.findByExperienceIds(experiencesIds)
+    }
 }

Domain-Module/src/main/kotlin/com/bamyanggang/domainmodule/domain/experience/repository/ExperienceRepository.kt

@@ -11,4 +11,6 @@ interface ExperienceRepository {
     fun findByUserIdAndYearDesc(year: Int, userId: UUID): List<Experience>
     fun findByYearAndParentTagId(year: Int, parentTagId: UUID): List<Experience>
     fun findByYearAndChildTagId(year: Int, childTagId: UUID): List<Experience>
+    fun findByIds(experienceIds: List<UUID>): List<Experience>
+    fun findByTitleContains(search: String): List<Experience>
 }

Domain-Module/src/main/kotlin/com/bamyanggang/domainmodule/domain/experience/service/ExperienceReader.kt

@@ -37,4 +37,21 @@ class ExperienceReader(
     fun readByYearAndChildTagId(year: Int, childTagId: UUID): List<Experience> {
         return experienceRepository.findByYearAndChildTagId(year, childTagId)
     }
+
+    fun readByIds(experienceIds: List<UUID>) : List<Experience> {
+        return experienceRepository.findByIds(experienceIds)
+    }
+
+    fun readByTitleContains(search: String): List<UUID> {
+        return experienceRepository.findByTitleContains(search).map { it.id }
+    }
+
+    fun readByContentsContains(userId: UUID, search: String): List<UUID> {
+        val experiences = experienceRepository.findAllByUserId(userId)
+
+        return experiences.filter {
+            it.contents.map { content ->
+                content.question.contains(search) || content.answer.contains(search)
+            }.contains(true) }.map { it.id }
+    }
 }

Domain-Module/src/main/kotlin/com/bamyanggang/domainmodule/domain/strongpoint/repository/StrongPointRepository.kt

@@ -10,4 +10,5 @@ interface StrongPointRepository {
     fun isExistByStrongPointId(strongPointId: UUID): Boolean
     fun findByIds(strongPointIds: List<UUID>) : List<StrongPoint>
     fun saveAll(strongPoints: List<StrongPoint>)
+    fun findByNameContains(search: String): List<StrongPoint>
 }

Domain-Module/src/main/kotlin/com/bamyanggang/domainmodule/domain/strongpoint/service/StrongPointReader.kt

@@ -16,4 +16,8 @@ class StrongPointReader(
     fun readByIds(strongPointIds: List<UUID>) : List<StrongPoint> {
         return strongPointRepository.findByIds(strongPointIds)
     }
+
+    fun readIdsByNameContains(search: String) : List<UUID> {
+        return strongPointRepository.findByNameContains(search).map { it.id }
+    }
 }

Domain-Module/src/main/kotlin/com/bamyanggang/domainmodule/domain/tag/repository/TagRepository.kt

@@ -11,4 +11,5 @@ interface TagRepository {
     fun deleteByTagId(tagId: UUID)
     fun isExistById(tagId: UUID): Boolean
     fun findByParentTagIds(tagParentTagIds: List<UUID>): List<Tag>
+    fun findByNameContains(search: String): List<Tag>
 }