Skip to content

Commit

Permalink
Refactor | CAKK-91 | 의존성 관련 리팩토링
Browse files Browse the repository at this point in the history
  • Loading branch information
@lcomment
lcomment committed Oct 1, 2024
1 parent 0d91c5d commit 05a8945
Show file tree
Hide file tree
Showing 4 changed files with 116 additions and 107 deletions.
91 changes: 51 additions & 40 deletions cakk-core/src/main/kotlin/com/cakk/core/facade/cake/CakeReadFacade.kt
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,7 @@
package com.cakk.core.facade.cake

import java.util.*

import com.cakk.common.enums.CakeDesignCategory
import com.cakk.common.enums.ReturnCode
import com.cakk.common.exception.CakkException
Expand All @@ -13,66 +15,75 @@ import com.cakk.domain.mysql.entity.user.User
import com.cakk.domain.mysql.repository.jpa.CakeCategoryJpaRepository
import com.cakk.domain.mysql.repository.jpa.CakeJpaRepository
import com.cakk.domain.mysql.repository.query.CakeQueryRepository
import java.util.*
import com.cakk.domain.redis.repository.CakeViewsRedisRepository

@DomainFacade
class CakeReadFacade(
private val cakeJpaRepository: CakeJpaRepository,
private val cakeCategoryJpaRepository: CakeCategoryJpaRepository,
private val cakeQueryRepository: CakeQueryRepository
private val cakeQueryRepository: CakeQueryRepository,
private val cakeViewsRedisRepository: CakeViewsRedisRepository,
) {

fun findById(cakeId: Long): Cake {
return cakeJpaRepository.findById(cakeId).orElseThrow { CakkException(ReturnCode.NOT_EXIST_CAKE) }
fun findById(cakeId: Long): Cake {
return cakeJpaRepository.findById(cakeId).orElseThrow { CakkException(ReturnCode.NOT_EXIST_CAKE) }
}

fun findByIdWithHeart(cakeId: Long): Cake {
val cake: Cake = cakeQueryRepository.searchByIdWithHeart(cakeId) ?: throw CakkException(ReturnCode.NOT_EXIST_CAKE)
fun findByIdWithHeart(cakeId: Long): Cake {
val cake: Cake = cakeQueryRepository.searchByIdWithHeart(cakeId) ?: throw CakkException(ReturnCode.NOT_EXIST_CAKE)

return cake
}
return cake
}

fun searchCakeImagesByCursorAndCategory(
fun searchCakeImagesByCursorAndCategory(
cakeId: Long?,
category: CakeDesignCategory,
pageSize: Int
): List<CakeImageResponseParam> {
return cakeQueryRepository.searchCakeImagesByCursorAndCategory(cakeId, category, pageSize)
}
): List<CakeImageResponseParam> {
return cakeQueryRepository.searchCakeImagesByCursorAndCategory(cakeId, category, pageSize)
}

fun searchCakeImagesByCursorAndCakeShopId(
cakeId: Long?,
cakeShopId: Long?,
pageSize: Int
): List<CakeImageResponseParam> {
return cakeQueryRepository.searchCakeImagesByCursorAndCakeShopId(cakeId, cakeShopId, pageSize)
}
fun searchCakeImagesByCursorAndCakeShopId(
cakeId: Long?,
cakeShopId: Long?,
pageSize: Int
): List<CakeImageResponseParam> {
return cakeQueryRepository.searchCakeImagesByCursorAndCakeShopId(cakeId, cakeShopId, pageSize)
}

fun searchCakeImagesByCursorAndSearchKeyword(param: CakeSearchParam): List<CakeImageResponseParam> {
return cakeQueryRepository.searchCakeImagesByCursorAndSearchKeyword(
param.cakeId,
param.keyword,
param.location,
param.pageSize
)
}

fun searchCakeImagesByCursorAndSearchKeyword(param: CakeSearchParam): List<CakeImageResponseParam> {
return cakeQueryRepository.searchCakeImagesByCursorAndSearchKeyword(
param.cakeId,
param.keyword,
param.location,
param.pageSize
)
}
fun searchBestCakeImages(
offset: Long,
pageSize: Int
): Pair<List<Long>, List<CakeImageResponseParam>> {
val cakeIds: List<Long> = cakeViewsRedisRepository.findTopCakeIdsByOffsetAndCount(offset, pageSize.toLong())

fun searchCakeImagesByCakeIds(cakeIds: List<Long>): List<CakeImageResponseParam> {
return cakeQueryRepository.searchCakeImagesByCakeIds(cakeIds)
}
return when {
cakeIds.isEmpty() -> Pair(listOf(), listOf())
else -> Pair(cakeIds, cakeQueryRepository.searchCakeImagesByCakeIds(cakeIds))
}
}

fun findWithCakeTagsAndCakeCategories(cakeId: Long, owner: User): Cake {
return cakeQueryRepository.searchWithCakeTagsAndCakeCategories(cakeId, owner)
.orElseThrow { CakkException(ReturnCode.NOT_CAKE_SHOP_OWNER) }
fun findWithCakeTagsAndCakeCategories(cakeId: Long, owner: User): Cake {
return cakeQueryRepository.searchWithCakeTagsAndCakeCategories(cakeId, owner)
.orElseThrow { CakkException(ReturnCode.NOT_CAKE_SHOP_OWNER) }
}

fun searchCakeDetailById(cakeId: Long?): CakeDetailParam {
val param: CakeDetailParam = cakeQueryRepository.searchCakeDetailById(cakeId)
if (Objects.isNull(param)) {
throw CakkException(ReturnCode.NOT_EXIST_CAKE)
}
return param
}
fun searchCakeDetailById(cakeId: Long?): CakeDetailParam {
val param: CakeDetailParam = cakeQueryRepository.searchCakeDetailById(cakeId)
if (Objects.isNull(param)) {
throw CakkException(ReturnCode.NOT_EXIST_CAKE)
}
return param
}

fun findCakeCategoryByCakeId(cakeId: Long?): CakeCategory {
return cakeCategoryJpaRepository.findByCakeId(cakeId) ?: throw CakkException(ReturnCode.NOT_EXIST_CAKE_CATEGORY)
Expand Down
90 changes: 51 additions & 39 deletions cakk-core/src/main/kotlin/com/cakk/core/facade/cake/CakeShopReadFacade.kt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -18,6 +18,7 @@ import com.cakk.domain.mysql.repository.jpa.CakeShopJpaRepository
import com.cakk.domain.mysql.repository.jpa.CakeShopLinkJpaRepository
import com.cakk.domain.mysql.repository.jpa.CakeShopOperationJpaRepository
import com.cakk.domain.mysql.repository.query.CakeShopQueryRepository
import com.cakk.domain.redis.repository.CakeShopViewsRedisRepository
import org.locationtech.jts.geom.Point

@DomainFacade
Expand All @@ -26,24 +27,25 @@ class CakeShopReadFacade(
private val cakeShopQueryRepository: CakeShopQueryRepository,
private val cakeShopOperationJpaRepository: CakeShopOperationJpaRepository,
private val cakeShopLinkJpaRepository: CakeShopLinkJpaRepository,
private val businessInformationJpaRepository: BusinessInformationJpaRepository
private val businessInformationJpaRepository: BusinessInformationJpaRepository,
private val cakeShopViewsRedisRepository: CakeShopViewsRedisRepository
) {

fun findById(cakeShopId: Long): CakeShop {
return cakeShopJpaRepository.findById(cakeShopId).orElseThrow { CakkException(ReturnCode.NOT_EXIST_CAKE_SHOP) }
fun findById(cakeShopId: Long): CakeShop {
return cakeShopJpaRepository.findById(cakeShopId).orElseThrow { CakkException(ReturnCode.NOT_EXIST_CAKE_SHOP) }
}

fun findByIdWithHeart(cakeShopId: Long): CakeShop {
return cakeShopQueryRepository.searchByIdWithHeart(cakeShopId) ?: throw CakkException(ReturnCode.NOT_EXIST_CAKE_SHOP)
}
fun findByIdWithHeart(cakeShopId: Long): CakeShop {
return cakeShopQueryRepository.searchByIdWithHeart(cakeShopId) ?: throw CakkException(ReturnCode.NOT_EXIST_CAKE_SHOP)
}

fun findByIdWithLike(cakeShopId: Long): CakeShop {
fun findByIdWithLike(cakeShopId: Long): CakeShop {
return cakeShopQueryRepository.searchByIdWithLike(cakeShopId) ?: throw CakkException(ReturnCode.NOT_EXIST_CAKE_SHOP)
}
}

fun searchSimpleById(cakeShopId: Long): CakeShopSimpleParam {
fun searchSimpleById(cakeShopId: Long): CakeShopSimpleParam {
return cakeShopQueryRepository.searchSimpleById(cakeShopId) ?: throw CakkException(ReturnCode.NOT_EXIST_CAKE_SHOP)
}
}

fun searchDetailById(cakeShopId: Long): CakeShopDetailParam {
return cakeShopQueryRepository.searchDetailById(cakeShopId) ?: throw CakkException(ReturnCode.NOT_EXIST_CAKE_SHOP)
Expand All @@ -53,45 +55,55 @@ class CakeShopReadFacade(
return cakeShopQueryRepository.searchInfoById(cakeShopId) ?: throw CakkException(ReturnCode.NOT_EXIST_CAKE_SHOP)
}

fun findBusinessInformationWithShop(cakeShopId: Long): BusinessInformation {
return businessInformationJpaRepository.findBusinessInformationWithCakeShop(cakeShopId) ?: throw CakkException(ReturnCode.NOT_EXIST_CAKE_SHOP)
}
fun findBusinessInformationWithShop(cakeShopId: Long): BusinessInformation {
return businessInformationJpaRepository.findBusinessInformationWithCakeShop(cakeShopId)
?: throw CakkException(ReturnCode.NOT_EXIST_CAKE_SHOP)
}

fun findBusinessInformationByCakeShopId(cakeShopId: Long): BusinessInformation {
return businessInformationJpaRepository.findBusinessInformationWithCakeShop(cakeShopId) ?: throw CakkException(ReturnCode.NOT_EXIST_CAKE_SHOP)
}
fun findBusinessInformationByCakeShopId(cakeShopId: Long): BusinessInformation {
return businessInformationJpaRepository.findBusinessInformationWithCakeShop(cakeShopId)
?: throw CakkException(ReturnCode.NOT_EXIST_CAKE_SHOP)
}

fun searchShopByLocationBased(point: Point?, distance: Double?): List<CakeShopByLocationParam> {
return cakeShopQueryRepository.findShopsByLocationBased(point, distance)
}
fun searchShopByLocationBased(point: Point?, distance: Double?): List<CakeShopByLocationParam> {
return cakeShopQueryRepository.findShopsByLocationBased(point, distance)
}

fun searchShopBySearch(param: CakeShopSearchParam): List<CakeShop> {
return cakeShopQueryRepository.searchByKeywordWithLocation(
param.cakeShopId,
param.keyword,
param.location,
param.pageSize
)
}
fun searchShopBySearch(param: CakeShopSearchParam): List<CakeShop> {
return cakeShopQueryRepository.searchByKeywordWithLocation(
param.cakeShopId,
param.keyword,
param.location,
param.pageSize
)
}

fun searchWithShopLinks(owner: User?, cakeShopId: Long?): CakeShop {
return cakeShopQueryRepository.searchWithShopLinks(owner, cakeShopId)
.orElseThrow { CakkException(ReturnCode.NOT_CAKE_SHOP_OWNER) }
fun searchWithShopLinks(owner: User?, cakeShopId: Long?): CakeShop {
return cakeShopQueryRepository.searchWithShopLinks(owner, cakeShopId)
.orElseThrow { CakkException(ReturnCode.NOT_CAKE_SHOP_OWNER) }
}

fun searchByIdAndOwner(cakeShopId: Long, owner: User): CakeShop {
return cakeShopQueryRepository.searchWithBusinessInformationAndOwnerById(owner, cakeShopId)
.orElseThrow { CakkException(ReturnCode.NOT_CAKE_SHOP_OWNER) }
fun searchByIdAndOwner(cakeShopId: Long, owner: User): CakeShop {
return cakeShopQueryRepository.searchWithBusinessInformationAndOwnerById(owner, cakeShopId)
.orElseThrow { CakkException(ReturnCode.NOT_CAKE_SHOP_OWNER) }
}

fun searchWithOperations(owner: User?, cakeShopId: Long?): CakeShop {
return cakeShopQueryRepository.searchWithOperations(owner, cakeShopId)
.orElseThrow { CakkException(ReturnCode.NOT_CAKE_SHOP_OWNER) }
fun searchWithOperations(owner: User?, cakeShopId: Long?): CakeShop {
return cakeShopQueryRepository.searchWithOperations(owner, cakeShopId)
.orElseThrow { CakkException(ReturnCode.NOT_CAKE_SHOP_OWNER) }
}

fun searchShopsByShopIds(shopIds: List<Long>?): List<CakeShop> {
return cakeShopQueryRepository.searchByShopIds(shopIds)
}
fun searchBestShops(
offset: Long,
pageSize: Int
): List<CakeShop> {
val cakeShopIds = cakeShopViewsRedisRepository.findTopShopIdsByOffsetAndCount(offset, pageSize.toLong())

return when {
cakeShopIds.isEmpty() -> listOf()
else -> cakeShopQueryRepository.searchByShopIds(cakeShopIds)
}
}

fun findCakeShopOperationsByCakeShopId(cakeShopId: Long): List<CakeShopOperation> {
return cakeShopOperationJpaRepository.findAllByCakeShopId(cakeShopId)
Expand Down
16 changes: 2 additions & 14 deletions cakk-core/src/main/kotlin/com/cakk/core/service/cake/CakeService.kt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -15,7 +15,6 @@ import com.cakk.core.facade.tag.TagReadFacade
import com.cakk.core.mapper.cakeDetailResponseFromParam
import com.cakk.core.mapper.supplyCakeImageListResponse
import com.cakk.domain.mysql.entity.user.User
import com.cakk.domain.redis.repository.CakeViewsRedisRepository

@Transactional(readOnly = true)
@Service
Expand All @@ -24,11 +23,9 @@ class CakeService(
private val tagReadFacade: TagReadFacade,
private val cakeShopReadFacade: CakeShopReadFacade,
private val cakeManageFacade: CakeManageFacade,
private val cakeViewsRedisRepository: CakeViewsRedisRepository,
private val eventPublisher: ApplicationEventPublisher
) {


fun findCakeImagesByCursorAndCategory(dto: CakeSearchByCategoryParam): CakeImageListResponse {
val cakeImages = cakeReadFacade.searchCakeImagesByCursorAndCategory(dto.cakeId, dto.category, dto.pageSize)

Expand All @@ -55,18 +52,9 @@ class CakeService(
fun searchCakeImagesByCursorAndViews(dto: CakeSearchByViewsParam): CakeImageListResponse {
val offset = dto.offset
val pageSize = dto.pageSize
val cakeIds: List<Long> = cakeViewsRedisRepository.findTopCakeIdsByOffsetAndCount(offset, pageSize.toLong())

return when {
cakeIds.isEmpty() -> {
supplyCakeImageListResponse(listOf(), cakeIds)
}
val (cakeIds, cakeImages) = cakeReadFacade.searchBestCakeImages(offset, pageSize)

else -> {
val cakeImages = cakeReadFacade.searchCakeImagesByCakeIds(cakeIds)
supplyCakeImageListResponse(cakeImages, cakeIds)
}
}
return supplyCakeImageListResponse(cakeImages, cakeIds)
}

fun findCakeDetailById(cakeId: Long): CakeDetailResponse {
Expand Down
26 changes: 12 additions & 14 deletions cakk-core/src/main/kotlin/com/cakk/core/service/shop/ShopService.kt
View file
Original file line number Diff line number Diff line change
@@ -1,7 +1,5 @@
package com.cakk.core.service.shop

import java.util.*

import org.springframework.context.ApplicationEventPublisher
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
Expand All @@ -25,15 +23,13 @@ import com.cakk.domain.mysql.dto.param.shop.CakeShopUpdateParam
import com.cakk.domain.mysql.dto.param.shop.UpdateShopAddressParam
import com.cakk.domain.mysql.dto.param.user.CertificationParam
import com.cakk.domain.mysql.entity.user.User
import com.cakk.domain.redis.repository.CakeShopViewsRedisRepository

@Service
class ShopService(
private val userReadFacade: UserReadFacade,
private val cakeShopReadFacade: CakeShopReadFacade,
private val businessInformationReadFacade: BusinessInformationReadFacade,
private val cakeShopManageFacade: CakeShopManageFacade,
private val cakeShopViewsRedisRepository: CakeShopViewsRedisRepository,
private val verificationPolicy: VerificationPolicy,
private val eventPublisher: ApplicationEventPublisher
) {
Expand Down Expand Up @@ -160,17 +156,19 @@ class ShopService(
fun searchCakeShopsByCursorAndViews(param: CakeShopSearchByViewsParam): CakeShopSearchResponse {
val offset = param.offset ?: 0
val pageSize = param.pageSize
val cakeShopIds = cakeShopViewsRedisRepository.findTopShopIdsByOffsetAndCount(offset, pageSize.toLong())

if (Objects.isNull(cakeShopIds) || cakeShopIds.isEmpty()) {
return supplyCakeShopSearchResponseBy(listOf())
val result = cakeShopReadFacade.searchBestShops(offset, pageSize)

return when {
result.isEmpty() -> {
supplyCakeShopSearchResponseBy(listOf())
}
else -> {
val cakeShopBySearchParams = supplyCakeShopBySearchParamListBy(result)
val cakeShops = CakeShops(cakeShopBySearchParams, 6, pageSize)

supplyCakeShopSearchResponseBy(cakeShops.cakeShops)
}
}

val result = cakeShopReadFacade.searchShopsByShopIds(cakeShopIds)
val cakeShopBySearchParams = supplyCakeShopBySearchParamListBy(result)
val cakeShops = CakeShops(cakeShopBySearchParams, 6, pageSize)

return supplyCakeShopSearchResponseBy(cakeShops.cakeShops)
}

@Transactional(readOnly = true)
Expand Down

0 comments on commit 05a8945

Please sign in to comment.