feat: 상세 지역 검색 추가

src/main/kotlin/com/retrip/map/application/in/request/LocationDetailCreateRequest.kt

@@ -1,7 +1,9 @@
 package com.retrip.map.application.`in`.request
 
+import com.retrip.map.domain.entity.Location
 import com.retrip.map.domain.entity.LocationDetail
 import io.swagger.v3.oas.annotations.media.Schema
+import java.util.UUID
 
 @Schema(description = "장소 상세 생성 Request")
 data class LocationDetailCreateRequest(
@@ -14,8 +16,9 @@ data class LocationDetailCreateRequest(
     val latitude: Double,
     val longitude: Double,
 ) {
-    fun to(): LocationDetail {
+    fun to(location: Location): LocationDetail {
         return LocationDetail.create(
+            location,
             name,
             category,
             description,

src/main/kotlin/com/retrip/map/application/in/response/LocationDetailSearchResponse.kt

@@ -0,0 +1,30 @@
+package com.retrip.map.application.`in`.response
+
+import com.retrip.map.domain.vo.LocationCountry
+import io.swagger.v3.oas.annotations.media.Schema
+import java.util.UUID
+
+@Schema(description = "장소 빠른 조회 Response")
+data class LocationDetailSearchResponse(
+    @Schema(description = "장소 상세 id")
+    val id: UUID,
+    @Schema(description = "장소 id")
+    val locationId: UUID,
+    @Schema(description = "장소 상세명")
+    val name: String,
+    @Schema(description = "장소 상세 카테고리")
+    val category: String,
+    @Schema(description = "장소 상세 설명")
+    val description: String?,
+    @Schema(description = "장소 상세 전화번호")
+    val telephone: String?,
+    @Schema(description = "장소 상세 주소")
+    val address: String?,
+    @Schema(description = "장소 상세 도로명 주소")
+    val roadAddress: String?,
+    @Schema(description = "장소 상세 위도")
+    val latitude: Double?,
+    @Schema(description = "장소 상세 경도")
+    val longitude: Double?,
+) {
+}

src/main/kotlin/com/retrip/map/application/in/service/LocationDetailIndexService.kt → src/main/kotlin/com/retrip/map/application/in/service/LocationDetailDetailIndexService.kt

@@ -1,16 +1,16 @@
 package com.retrip.map.application.`in`.service
 
-import com.retrip.map.application.`in`.usecase.LocationIndexUseCase
+import com.retrip.map.application.`in`.usecase.LocationDetailIndexUseCase
 import com.retrip.map.application.out.repository.LocationDetailElasticRepository
 import com.retrip.map.infra.adapter.out.search.elasticsearch.entity.LocationDetailDocument
 import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
 
 @Service
 @Transactional
-class LocationDetailIndexService(
+class LocationDetailDetailIndexService(
     private val locationDetailElasticRepository: LocationDetailElasticRepository
-) : LocationIndexUseCase {
+) : LocationDetailIndexUseCase {
     override fun indexLocationDetailDocuments(documents: List<LocationDetailDocument>?) {
         documents?.let { locationDetailElasticRepository.saveAll(it) }
     }

src/main/kotlin/com/retrip/map/application/in/service/LocationDetailSearchService.kt

@@ -0,0 +1,38 @@
+package com.retrip.map.application.`in`.service
+
+import com.retrip.map.application.`in`.response.LocationDetailSearchResponse
+import com.retrip.map.application.`in`.usecase.LocationDetailSearchUseCase
+import com.retrip.map.application.out.repository.LocationDetailElasticRepository
+import lombok.RequiredArgsConstructor
+import org.springframework.data.domain.Page
+import org.springframework.data.domain.Pageable
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+import java.util.UUID
+
+@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+class LocationDetailSearchService(
+    private val locationDetailElasticRepository: LocationDetailElasticRepository
+) : LocationDetailSearchUseCase {
+
+    override fun getDetailLocation(locationId: UUID?, searchText: String?, page: Pageable): Page<LocationDetailSearchResponse> {
+        val locationDetails = locationDetailElasticRepository.findByLocationIdAndSearchText(locationId, searchText, page)
+        return locationDetails.map {
+            LocationDetailSearchResponse(
+                id = it.id,
+                locationId = it.locationId,
+                name = it.name,
+                category = it.category,
+                description = it.description,
+                telephone = it.telephone,
+                address = it.address,
+                roadAddress = it.roadAddress,
+                latitude = it.latitude,
+                longitude = it.longitude,
+            )
+        }
+    }
+}
+

src/main/kotlin/com/retrip/map/application/in/service/LocationDetailService.kt

@@ -1,19 +1,24 @@
 package com.retrip.map.application.`in`.service
 
-import co.elastic.clients.elasticsearch.core.search.ContextBuilders.location
 import com.retrip.map.application.`in`.request.LocationDetailCreateRequest
 import com.retrip.map.application.`in`.request.LocationDetailUpdateRequest
 import com.retrip.map.application.`in`.response.LocationDetailCreateResponse
 import com.retrip.map.application.`in`.response.LocationDetailResponse
 import com.retrip.map.application.`in`.response.LocationDetailUpdateResponse
 import com.retrip.map.application.`in`.usecase.LocationDetailUseCase
+import com.retrip.map.application.out.repository.LocationDetailElasticRepository
 import com.retrip.map.application.out.repository.LocationDetailQueryRepository
 import com.retrip.map.application.out.repository.LocationDetailRepository
+import com.retrip.map.application.out.repository.LocationRepository
+import com.retrip.map.domain.exception.LocationDetailDuplicateException
 import com.retrip.map.domain.exception.LocationDetailNotFoundException
+import com.retrip.map.domain.exception.LocationNotFoundException
 import com.retrip.map.domain.exception.common.RequireException
+import com.retrip.map.infra.adapter.out.search.elasticsearch.entity.LocationDetailDocument
 import lombok.RequiredArgsConstructor
 import org.springframework.data.domain.Page
 import org.springframework.data.domain.Pageable
+import org.springframework.data.jpa.domain.AbstractPersistable_.id
 import org.springframework.data.repository.findByIdOrNull
 import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
@@ -23,17 +28,25 @@ import java.util.*
 @RequiredArgsConstructor
 @Transactional
 class LocationDetailService(
+    val locationRepository: LocationRepository,
     val locationDetailRepository: LocationDetailRepository,
-    val locationDetailQueryRepository: LocationDetailQueryRepository
+    val locationDetailQueryRepository: LocationDetailQueryRepository,
+    val locationDetailElasticRepository: LocationDetailElasticRepository,
 ) : LocationDetailUseCase {
 
     @Transactional(readOnly = true)
-    override fun getLocationDetail(id: UUID?, page: Pageable): Page<LocationDetailResponse> {
-       return locationDetailQueryRepository.findLocationDetails(id, page)
+    override fun getLocationDetail(locationId: UUID, id: UUID?, page: Pageable): Page<LocationDetailResponse> {
+        return locationDetailQueryRepository.findLocationDetails(locationId, id, page)
     }
 
-    override fun createLocationDetail(request: LocationDetailCreateRequest): LocationDetailCreateResponse {
-        val locationDetail = locationDetailRepository.save(request.to())
+    override fun createLocationDetail(locationId: UUID, request: LocationDetailCreateRequest): LocationDetailCreateResponse {
+        val location = locationRepository.findByIdOrNull(locationId) ?: throw LocationNotFoundException()
+        val isDuplicate =
+            locationDetailRepository.findByNameValueAndLocationId(request.name, locationId)
+                ?.run { throw LocationDetailDuplicateException() }
+
+        val locationDetail = locationDetailRepository.save(request.to(location))
+        locationDetailElasticRepository.save(LocationDetailDocument.of(locationDetail))
         return LocationDetailCreateResponse(
             locationDetail.id ?: throw LocationDetailNotFoundException(),
             locationDetail.name?.value ?: throw RequireException(),
@@ -47,9 +60,14 @@ class LocationDetailService(
         )
     }
 
-    override fun updateLocationDetail(id: UUID, request: LocationDetailUpdateRequest): LocationDetailUpdateResponse {
-        val location = locationDetailRepository.findByIdOrNull(id) ?: throw LocationDetailNotFoundException()
-        location.update(
+    override fun updateLocationDetail(locationId: UUID, id: UUID, request: LocationDetailUpdateRequest): LocationDetailUpdateResponse {
+        val location = locationRepository.findByIdOrNull(locationId) ?: throw LocationNotFoundException()
+        val isDuplicate =
+            locationDetailRepository.findByNameValueAndLocationId(request.name, locationId)
+                ?.run { throw LocationDetailDuplicateException() }
+        val locationDetails = locationDetailRepository.findByIdOrNull(id) ?: throw LocationDetailNotFoundException()
+        locationDetails.update(
+            location,
             request.name,
             request.category,
             request.description,
@@ -59,21 +77,25 @@ class LocationDetailService(
             request.latitude,
             request.longitude,
         )
+        locationDetailElasticRepository.deleteById(id)
+        locationDetailElasticRepository.save(LocationDetailDocument.of(locationDetails))
         return LocationDetailUpdateResponse(
-            location.id ?: throw LocationDetailNotFoundException(),
-            location.name?.value ?: throw RequireException(),
-            location.category?.value ?: throw RequireException(),
-            location.description?.value,
-            location.telephone,
-            location.address?.address,
-            location.address?.roadAddress,
-            location.geoPoint?.latitude,
-            location.geoPoint?.longitude,
+            locationDetails.id ?: throw LocationDetailNotFoundException(),
+            locationDetails.name?.value ?: throw RequireException(),
+            locationDetails.category?.value ?: throw RequireException(),
+            locationDetails.description?.value,
+            locationDetails.telephone,
+            locationDetails.address?.address,
+            locationDetails.address?.roadAddress,
+            locationDetails.geoPoint?.latitude,
+            locationDetails.geoPoint?.longitude,
         )
     }
 
     override fun deleteLocationDetail(locationDetailId: UUID) {
         locationDetailRepository.deleteById(locationDetailId)
+        locationDetailElasticRepository.deleteById(locationDetailId)
+
     }
 }
 

src/main/kotlin/com/retrip/map/application/in/service/LocationSearchService.kt

@@ -18,7 +18,7 @@ class LocationSearchService(
 
     @Transactional(readOnly = true)
     override fun getLocation(searchText: String?, page: Pageable): Page<LocationSearchResponse> {
-        val locations = locationElasticRepository.findBySearchTextContaining(searchText, page)
+        val locations = locationElasticRepository.findBySearchText(searchText, page)
         return locations.map {
             LocationSearchResponse(
                 id = it.id,

src/main/kotlin/com/retrip/map/application/in/service/LocationService.kt

@@ -20,7 +20,7 @@ import org.springframework.data.domain.Pageable
 import org.springframework.data.repository.findByIdOrNull
 import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
-import java.util.UUID
+import java.util.*
 
 @Service
 @RequiredArgsConstructor
@@ -39,11 +39,10 @@ class LocationService(
 
     override fun createLocation(request: LocationCreateRequest): LocationCreateResponse {
         val isDuplicate =
-            locationRepository.findFirstByNameValueAndCountryValue(request.name, request.country)
+            locationRepository.findFirstByNameValueAndCountryValue(request.name, request.country)?.run {
+                throw LocationDuplicateException()
+            }
 
-        if(isDuplicate != null){
-            throw LocationDuplicateException()
-        }
         val location = locationRepository.save(request.to())
         locationElasticRepository.save(LocationDocument.of(location))
         return LocationCreateResponse(
@@ -57,10 +56,9 @@ class LocationService(
 
     override fun updateLocation(id: UUID, request: LocationUpdateRequest): LocationUpdateResponse {
         val isDuplicate =
-            locationRepository.findFirstByNameValueAndCountryValue(request.name, request.country)
-        if(isDuplicate != null){
-            throw LocationDuplicateException()
-        }
+            locationRepository.findFirstByNameValueAndCountryValue(request.name, request.country)?.run {
+                throw LocationDuplicateException()
+            }
 
         val location = locationRepository.findByIdOrNull(id) ?: throw LocationNotFoundException()
         locationElasticRepository.deleteById(id)

src/main/kotlin/com/retrip/map/application/in/usecase/LocationIndexUseCase.kt → src/main/kotlin/com/retrip/map/application/in/usecase/LocationDetailIndexUseCase.kt

@@ -2,6 +2,6 @@ package com.retrip.map.application.`in`.usecase
 
 import com.retrip.map.infra.adapter.out.search.elasticsearch.entity.LocationDetailDocument
 
-interface LocationIndexUseCase {
+interface LocationDetailIndexUseCase {
     fun indexLocationDetailDocuments(documents: List<LocationDetailDocument>?)
 }

src/main/kotlin/com/retrip/map/application/in/usecase/LocationDetailSearchUseCase.kt

@@ -0,0 +1,10 @@
+package com.retrip.map.application.`in`.usecase
+
+import com.retrip.map.application.`in`.response.LocationDetailSearchResponse
+import org.springframework.data.domain.Page
+import org.springframework.data.domain.Pageable
+import java.util.UUID
+
+interface LocationDetailSearchUseCase {
+    fun getDetailLocation(locationId: UUID?,searchText: String?, page: Pageable): Page<LocationDetailSearchResponse>
+}

src/main/kotlin/com/retrip/map/application/in/usecase/LocationDetailUseCase.kt

@@ -7,11 +7,11 @@ import com.retrip.map.application.`in`.response.LocationDetailResponse
 import com.retrip.map.application.`in`.response.LocationDetailUpdateResponse
 import org.springframework.data.domain.Page
 import org.springframework.data.domain.Pageable
-import java.util.UUID
+import java.util.*
 
 interface LocationDetailUseCase {
-    fun createLocationDetail(request: LocationDetailCreateRequest): LocationDetailCreateResponse
-    fun updateLocationDetail(id: UUID, request: LocationDetailUpdateRequest): LocationDetailUpdateResponse
+    fun createLocationDetail(locationId: UUID, request: LocationDetailCreateRequest): LocationDetailCreateResponse
+    fun updateLocationDetail(locationId: UUID, id: UUID, request: LocationDetailUpdateRequest): LocationDetailUpdateResponse
     fun deleteLocationDetail(locationDetailId: UUID)
-    fun getLocationDetail(id: UUID?, page: Pageable): Page<LocationDetailResponse>
+    fun getLocationDetail(locationId: UUID, id: UUID?, page: Pageable): Page<LocationDetailResponse>
 }

src/main/kotlin/com/retrip/map/application/out/repository/LocationDetailElasticRepository.kt

@@ -1,11 +1,17 @@
 package com.retrip.map.application.out.repository
 
+import com.retrip.map.application.`in`.response.LocationDetailResponse
 import com.retrip.map.infra.adapter.out.search.elasticsearch.entity.LocationDetailDocument
+import com.retrip.map.infra.adapter.out.search.elasticsearch.entity.LocationDocument
+import org.springframework.data.domain.Page
+import org.springframework.data.domain.Pageable
 import org.springframework.data.elasticsearch.repository.ElasticsearchRepository
 import org.springframework.stereotype.Repository
 import java.util.UUID
 
 @Repository
 interface LocationDetailElasticRepository: ElasticsearchRepository<LocationDetailDocument, UUID> {
     fun findFirstByOrderByEditedAtDesc(): LocationDetailDocument?
+    fun findByLocationIdAndSearchText(locationId: UUID?, name: String?, pageable: Pageable): Page<LocationDetailDocument>
+
 }

src/main/kotlin/com/retrip/map/application/out/repository/LocationDetailQueryRepository.kt

@@ -5,9 +5,9 @@ import com.retrip.map.domain.entity.LocationDetail
 import org.springframework.data.domain.Page
 import org.springframework.data.domain.Pageable
 import java.time.LocalDateTime
-import java.util.UUID
+import java.util.*
 
 interface LocationDetailQueryRepository {
-    fun findLocationDetails(id: UUID?, page: Pageable): Page<LocationDetailResponse>
-    fun findLocationDetailsByEditedAt( editedAt: LocalDateTime): List<LocationDetail>
+    fun findLocationDetails(locationId: UUID, id: UUID?, page: Pageable): Page<LocationDetailResponse>
+    fun findLocationDetailsByEditedAt(editedAt: LocalDateTime): List<LocationDetail>
 }

src/main/kotlin/com/retrip/map/application/out/repository/LocationDetailRepository.kt

@@ -5,4 +5,5 @@ import org.springframework.data.jpa.repository.JpaRepository
 import java.util.UUID
 
 interface LocationDetailRepository: JpaRepository<LocationDetail, UUID> {
+    fun findByNameValueAndLocationId(name: String, locationId: UUID): LocationDetail?
 }

src/main/kotlin/com/retrip/map/application/out/repository/LocationElasticRepository.kt

@@ -10,5 +10,5 @@ import java.util.UUID
 @Repository
 interface LocationElasticRepository: ElasticsearchRepository<LocationDocument, UUID> {
     // 이름 포함 검색 + 페이징
-    fun findBySearchTextContaining(searchText: String?, pageable: Pageable): Page<LocationDocument>
+    fun findBySearchText(searchText: String?, pageable: Pageable): Page<LocationDocument>
 }