Skip to content

Commit

Permalink
Refactor | CAKK-82 | Reader에 대해 ReadFacade로 리팩토링
Browse files Browse the repository at this point in the history
  • Loading branch information
YongsHub committed Sep 15, 2024
1 parent 819f614 commit 18d8196
Show file tree
Hide file tree
Showing 6 changed files with 118 additions and 54 deletions.
Original file line number Diff line number Diff line change
@@ -1,25 +1,30 @@
package com.cakk.core.facade.cake

import com.cakk.domain.mysql.annotation.Reader
import com.cakk.common.enums.ReturnCode
import com.cakk.common.enums.VerificationStatus
import com.cakk.common.exception.CakkException
import com.cakk.core.annotation.DomainFacade
import com.cakk.domain.mysql.entity.user.BusinessInformation
import com.cakk.domain.mysql.entity.user.User
import java.util.function.Supplier
import com.cakk.domain.mysql.repository.jpa.BusinessInformationJpaRepository

class BusinessInformationReader {
private val businessInformationJpaRepository: BusinessInformationJpaRepository? = null
fun isExistBusinessInformation(owner: User?, cakeShopId: Long?): Boolean {
@DomainFacade
class BusinessInformationReadFacade(
private val businessInformationJpaRepository: BusinessInformationJpaRepository
) {
fun isExistBusinessInformation(owner: User, cakeShopId: Long): Boolean {
return businessInformationJpaRepository.existsBusinessInformationByUserAndCakeShop_Id(owner, cakeShopId)
}

fun findAllWithCakeShopByUser(owner: User?): List<BusinessInformation> {
fun findAllWithCakeShopByUser(owner: User): List<BusinessInformation> {
return businessInformationJpaRepository.findAllWithCakeShopByUser(owner)
}

fun findAllCakeShopBusinessOwnerCandidates(): List<BusinessInformation> {
return businessInformationJpaRepository.findAllCakeShopBusinessOwnerCandidates(VerificationStatus.PENDING)
}

fun findByUserId(userId: Long?): BusinessInformation {
return businessInformationJpaRepository.findBusinessInformationByUserId(userId)
.orElseThrow<CakkException>(Supplier<CakkException> { CakkException(ReturnCode.NOT_EXIST_CAKE_SHOP) })
fun findByUserId(userId: Long): BusinessInformation {
return businessInformationJpaRepository.findBusinessInformationByUserId(userId) ?: throw CakkException(ReturnCode.NOT_EXIST_CAKE_SHOP)
}
}
Original file line number Diff line number Diff line change
@@ -1,16 +1,30 @@
package com.cakk.core.facade.cake

import com.cakk.domain.mysql.annotation.Reader
import com.cakk.common.enums.CakeDesignCategory
import com.cakk.common.enums.ReturnCode
import com.cakk.common.exception.CakkException
import com.cakk.core.annotation.DomainFacade
import com.cakk.domain.mysql.dto.param.cake.CakeDetailParam
import com.cakk.domain.mysql.dto.param.cake.CakeImageResponseParam
import com.cakk.domain.mysql.dto.param.cake.CakeSearchParam
import com.cakk.domain.mysql.entity.cake.Cake
import com.cakk.domain.mysql.entity.cake.CakeCategory
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 java.util.function.Supplier

class CakeReader {
private val cakeJpaRepository: CakeJpaRepository? = null
private val cakeQueryRepository: CakeQueryRepository? = null
fun findById(cakeId: Long?): Cake {
return cakeJpaRepository.findById(cakeId).orElseThrow<CakkException>(Supplier<CakkException> { CakkException(ReturnCode.NOT_EXIST_CAKE) })
}
@DomainFacade
class CakeReadFacade(
private val cakeJpaRepository: CakeJpaRepository,
private val cakeCategoryJpaRepository: CakeCategoryJpaRepository,
private val cakeQueryRepository: CakeQueryRepository
) {
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)
Expand All @@ -21,9 +35,9 @@ class CakeReader {
}

fun searchCakeImagesByCursorAndCategory(
cakeId: Long?,
category: CakeDesignCategory?,
pageSize: Int
cakeId: Long?,
category: CakeDesignCategory,
pageSize: Int
): List<CakeImageResponseParam> {
return cakeQueryRepository.searchCakeImagesByCursorAndCategory(cakeId, category, pageSize)
}
Expand Down Expand Up @@ -51,8 +65,8 @@ class CakeReader {

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

fun searchCakeDetailById(cakeId: Long?): CakeDetailParam {
val param: CakeDetailParam = cakeQueryRepository.searchCakeDetailById(cakeId)
Expand All @@ -61,4 +75,8 @@ class CakeReader {
}
return param
}

fun findByCakeId(cakeId: Long?): CakeCategory {
return cakeCategoryJpaRepository.findByCakeId(cakeId) ?: throw CakkException(ReturnCode.NOT_EXIST_CAKE_CATEGORY)
}
}
Original file line number Diff line number Diff line change
Expand Up @@ -2,23 +2,32 @@ package com.cakk.core.facade.cake

import com.cakk.common.enums.ReturnCode
import com.cakk.common.exception.CakkException
import com.cakk.core.annotation.DomainFacade
import com.cakk.domain.mysql.bo.shop.CakeShopByLocationParam
import com.cakk.domain.mysql.dto.param.shop.CakeShopDetailParam
import com.cakk.domain.mysql.dto.param.shop.CakeShopInfoParam
import com.cakk.domain.mysql.dto.param.shop.CakeShopSearchParam
import com.cakk.domain.mysql.dto.param.shop.CakeShopSimpleParam
import com.cakk.domain.mysql.entity.shop.CakeShop
import com.cakk.domain.mysql.entity.shop.CakeShopLink
import com.cakk.domain.mysql.entity.shop.CakeShopOperation
import com.cakk.domain.mysql.entity.user.BusinessInformation
import com.cakk.domain.mysql.entity.user.User
import com.cakk.domain.mysql.repository.jpa.BusinessInformationJpaRepository
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 org.locationtech.jts.geom.Point
import java.util.*
import java.util.function.Supplier


class CakeShopReader(
@DomainFacade
class CakeShopReadFacade(
private val cakeShopJpaRepository: CakeShopJpaRepository,
private val cakeShopQueryRepository: CakeShopQueryRepository,
private val cakeShopOperationJpaRepository: CakeShopOperationJpaRepository,
private val cakeShopLinkJpaRepository: CakeShopLinkJpaRepository,
private val businessInformationJpaRepository: BusinessInformationJpaRepository
) {
fun findById(cakeShopId: Long): CakeShop {
Expand Down Expand Up @@ -65,14 +74,12 @@ class CakeShopReader(
return response
}

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)
.orElseThrow<CakkException>(Supplier<CakkException> { 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> {
Expand Down Expand Up @@ -106,4 +113,12 @@ class CakeShopReader(
fun searchShopsByShopIds(shopIds: List<Long?>?): List<CakeShop> {
return cakeShopQueryRepository.searchByShopIds(shopIds)
}

fun findCakeShopsByCakeShopId(cakeShopId: Long): List<CakeShopOperation> {
return cakeShopOperationJpaRepository.findAllByCakeShopId(cakeShopId)
}

fun findCakeShopLinksByCakeShopId(cakeShopId: Long): List<CakeShopLink> {
return cakeShopLinkJpaRepository.findAllByCakeShopId(cakeShopId)
}
}
Original file line number Diff line number Diff line change
@@ -1,10 +1,19 @@
package com.cakk.core.facade.cake

import com.cakk.core.annotation.DomainFacade
import com.cakk.domain.mysql.dto.param.like.HeartCakeImageResponseParam
import com.cakk.domain.mysql.dto.param.like.HeartCakeShopResponseParam
import com.cakk.domain.mysql.repository.jpa.CakeShopHeartJpaRepository
import com.cakk.domain.mysql.repository.query.CakeHeartQueryRepository
import com.cakk.domain.mysql.repository.query.CakeShopHeartQueryRepository


class CakeShopHeartReader {
private val cakeShopHeartQueryRepository: CakeShopHeartQueryRepository? = null
private val cakeShopHeartJpaRepository: CakeShopHeartJpaRepository? = null
@DomainFacade
class CakeShopUserReadFacade(
private val cakeShopHeartQueryRepository: CakeShopHeartQueryRepository,
private val cakeShopHeartJpaRepository: CakeShopHeartJpaRepository,
private val cakeHeartQueryRepository: CakeHeartQueryRepository
) {
fun searchAllByCursorAndHeart(
cakeShopHeartId: Long?,
userId: Long?,
Expand All @@ -13,4 +22,12 @@ class CakeShopHeartReader {
val cakeShopHeartIds: List<Long> = cakeShopHeartQueryRepository.searchIdsByCursorAndHeart(cakeShopHeartId, userId, pageSize)
return cakeShopHeartQueryRepository.searchAllByCursorAndHeart(cakeShopHeartIds)
}

fun searchCakeImagesByCursorAndHeart(
cakeHeartId: Long?,
userId: Long?,
pageSize: Int
): List<HeartCakeImageResponseParam> {
return cakeHeartQueryRepository.searchCakeImagesByCursorAndHeart(cakeHeartId, userId, pageSize)
}
}
24 changes: 14 additions & 10 deletions cakk-core/src/main/kotlin/com/cakk/core/facade/tag/TagReadFacade.kt
Original file line number Diff line number Diff line change
@@ -1,20 +1,24 @@
package com.cakk.core.facade.tag

import com.cakk.domain.mysql.annotation.Reader
import com.cakk.core.annotation.DomainFacade
import com.cakk.domain.mysql.entity.cake.Tag
import com.cakk.domain.mysql.mapper.TagMapper
import com.cakk.domain.mysql.repository.jpa.TagJpaRepository

@DomainFacade
class TagReadFacade(
private val tagJpaRepository: TagJpaRepository
) {

class TagReader {
private val tagJpaRepository: TagJpaRepository? = null
fun getTagsByTagName(tagNames: List<String>): List<Tag> {
val tags: List<Tag> = tagJpaRepository.findTagsByTagNameIsIn(tagNames)
return tagNames.stream()
.map<Tag> { tagName: String ->
.map { tagName: String ->
tags
.stream()
.filter { tag: Tag -> tag.tagName == tagName }
.findAny()
.orElse(tagJpaRepository.save<Tag>(TagMapper.supplyTagBy(tagName)))
}
.toList()
.stream()
.filter { tag: Tag -> tag.tagName == tagName }
.findAny()
.orElse(tagJpaRepository.save(TagMapper.supplyTagBy(tagName)))
}.toList()
}
}
Original file line number Diff line number Diff line change
@@ -1,24 +1,29 @@
package com.cakk.core.facade.user

import com.cakk.domain.mysql.annotation.Reader
import com.cakk.common.enums.ReturnCode
import com.cakk.common.exception.CakkException
import com.cakk.core.annotation.DomainFacade
import com.cakk.domain.mysql.entity.user.User
import com.cakk.domain.mysql.repository.jpa.UserJpaRepository
import com.cakk.domain.mysql.repository.query.UserQueryRepository
import java.util.*
import java.util.function.Supplier



class UserReader {
private val userJpaRepository: UserJpaRepository? = null
private val userQueryRepository: UserQueryRepository? = null
fun findByUserId(userId: Long?): User {
return userJpaRepository.findById(userId).orElseThrow<CakkException>(Supplier<CakkException> { CakkException(ReturnCode.NOT_EXIST_USER) })
}
@DomainFacade
class UserReadFacade(
private val userJpaRepository: UserJpaRepository,
private val userQueryRepository: UserQueryRepository
) {
fun findByUserId(userId: Long): User {
return userJpaRepository.findById(userId).orElseThrow { CakkException(ReturnCode.NOT_EXIST_USER) }
}

fun findByProviderId(providerId: String?): User {
return userJpaRepository.findByProviderId(providerId).orElseThrow<CakkException>(Supplier<CakkException> { CakkException(ReturnCode.NOT_EXIST_USER) })
}
fun findByProviderId(providerId: String): User {
return userJpaRepository.findByProviderId(providerId) ?: throw CakkException(ReturnCode.NOT_EXIST_USER)
}

fun findByIdWithAll(userId: Long?): User {
fun findByIdWithAll(userId: Long): User {
val user: User = userQueryRepository.searchByIdWithAll(userId)
if (Objects.isNull(user)) {
throw CakkException(ReturnCode.NOT_EXIST_USER)
Expand Down

0 comments on commit 18d8196

Please sign in to comment.