✨ feat(certificate) : 챌린지 얼리기 기능 구현

Author: 5hseok

server/src/main/kotlin/com/app/server/challenge_certification/application/service/CertificationFacadeService.kt

@@ -21,7 +21,7 @@ class CertificationFacadeService(
     private val certificationService: CertificationService,
     private val certificationInfraService: CertificationInfraService,
     private val userChallengeService: UserChallengeService
-) : CertificationUseCase, UsingIceUseCase {
+) : CertificationUseCase {
 
     override fun certificateChallengeWithDate(
         certificationRequestDto: CertificationRequestDto,
@@ -51,12 +51,4 @@ class CertificationFacadeService(
         return certificationService.processAfterCertificateSuccess(userChallenge, certificationFacadeToServiceDto)
     }
 
-    override fun execute(
-        userChallengeIceRequestDto: UserChallengeIceRequestDto,
-        certificationDate: LocalDate
-    ): UserChallenge {
-
-       return certificationService.processAfterUserChallengeIce(userChallengeIceRequestDto, certificationDate)
-    }
-
 }

server/src/main/kotlin/com/app/server/challenge_certification/application/service/CertificationService.kt

@@ -2,8 +2,8 @@ package com.app.server.challenge_certification.application.service
 
 import com.app.server.challenge_certification.application.dto.CertificationFacadeToServiceDto
 import com.app.server.challenge_certification.application.service.constant.EConsecutiveState
-import com.app.server.challenge_certification.ui.dto.CertificationRequestDto
 import com.app.server.challenge_certification.ui.dto.UserChallengeIceRequestDto
+import com.app.server.challenge_certification.usecase.UsingIceUseCase
 import com.app.server.common.exception.InternalServerErrorException
 import com.app.server.user_challenge.application.service.UserChallengeService
 import com.app.server.user_challenge.domain.enums.EUserChallengeCertificationStatus
@@ -15,8 +15,8 @@ import java.time.LocalDate
 
 @Service
 class CertificationService(
-    private val userChallengeService: UserChallengeService
-) {
+    private val userChallengeService: UserChallengeService,
+) : UsingIceUseCase {
 
     fun processAfterCertificateSuccess(
        userChallenge: UserChallenge, certificationDto: CertificationFacadeToServiceDto
@@ -39,6 +39,22 @@ class CertificationService(
         return userChallenge
     }
 
+    override fun processAfterCertificateIce(
+        iceDto: UserChallengeIceRequestDto,
+        certificationDate: LocalDate
+    ): UserChallenge {
+        val userChallenge = userChallengeService.findById(userChallengeId = iceDto.userChallengeId)
+
+        // 얼리기 가능 여부 판단
+        userChallenge.validateCanIceAndUse()
+        // 날짜 인증 상태 Ice로 변경
+        userChallenge.updateCertificationStateIsIce(certificationDate)
+        // 연속 참여 일수 증가
+        readyForValidateCanIncreaseConsecutiveParticipantDays(userChallenge, certificationDate)
+
+        return userChallenge
+    }
+
     private fun readyForValidateCanIncreaseConsecutiveParticipantDays(
         userChallenge: UserChallenge,
         certificationDate: LocalDate
@@ -119,18 +135,4 @@ class CertificationService(
         }
     }
 
-    fun processAfterUserChallengeIce(
-        userChallengeIceRequestDto: UserChallengeIceRequestDto, certificationDate: LocalDate
-    ): UserChallenge {
-        val userChallenge = userChallengeService.findById(userChallengeId = userChallengeIceRequestDto.userChallengeId)
-
-        // 얼리기 가능 여부 판단
-        userChallenge.validateCanIceAndUse()
-        // 날짜 인증 상태 Ice로 변경
-        userChallenge.updateCertificationStateIsIce(certificationDate)
-        // 연속 참여 일수 증가
-        readyForValidateCanIncreaseConsecutiveParticipantDays(userChallenge, certificationDate)
-
-        return userChallenge
-    }
 }

server/src/main/kotlin/com/app/server/challenge_certification/ui/CertificationController.kt

@@ -1,26 +1,30 @@
 package com.app.server.challenge_certification.ui
 
 import com.app.server.challenge_certification.ui.dto.CertificationRequestDto
+import com.app.server.challenge_certification.ui.dto.UserChallengeIceRequestDto
 import com.app.server.challenge_certification.usecase.CertificationUseCase
+import com.app.server.challenge_certification.usecase.UsingIceUseCase
 import com.app.server.common.enums.CommonResultCode
 import com.app.server.common.enums.ResultCode
 import com.app.server.common.response.ApiResponse
+import org.springframework.web.bind.annotation.PathVariable
 import org.springframework.web.bind.annotation.PostMapping
 import org.springframework.web.bind.annotation.RequestBody
 import org.springframework.web.bind.annotation.RequestMapping
 import org.springframework.web.bind.annotation.RestController
 import java.time.LocalDate
 
 @RestController
-@RequestMapping("/api/v1")
-class CertificationController (
-    private val certificationUseCase: CertificationUseCase
-){
+@RequestMapping("/api/v1/challenge/user/{userChallengeId}")
+class CertificationController(
+    private val certificationUseCase: CertificationUseCase,
+    private val usingIceUseCase: UsingIceUseCase
+) {
 
-    @PostMapping("/challenge/user/{userChallengeId}/certification")
+    @PostMapping("/certification")
     fun certificateDailyUserChallenge(
         @RequestBody certificationRequestDto: CertificationRequestDto
-    ) : ApiResponse<ResultCode> {
+    ): ApiResponse<ResultCode> {
         certificationUseCase.certificateChallengeWithDate(
             certificationRequestDto = certificationRequestDto,
             certificationDate = LocalDate.now()
@@ -29,4 +33,19 @@ class CertificationController (
         return ApiResponse.success(CommonResultCode.SUCCESS)
     }
 
+    @PostMapping("/ice")
+    fun iceDailyUserChallenge(
+        @PathVariable userChallengeId: Long
+    ): ApiResponse<ResultCode> {
+        val iceRequest = UserChallengeIceRequestDto(
+            userChallengeId = userChallengeId
+        )
+        usingIceUseCase.processAfterCertificateIce(
+            iceRequestDto = iceRequest,
+            certificationDate = LocalDate.now()
+        )
+
+        return ApiResponse.success(CommonResultCode.SUCCESS)
+    }
+
 }

server/src/main/kotlin/com/app/server/challenge_certification/usecase/UsingIceUseCase.kt

@@ -6,5 +6,5 @@ import java.time.LocalDate
 
 interface UsingIceUseCase {
 
-    fun execute(iceRequestDto: UserChallengeIceRequestDto, certificationDate: LocalDate) : UserChallenge
+    fun processAfterCertificateIce(iceRequestDto: UserChallengeIceRequestDto, certificationDate: LocalDate) : UserChallenge
 }

server/src/main/kotlin/com/app/server/user_challenge/domain/model/UserChallenge.kt

@@ -125,7 +125,7 @@ class UserChallenge(
 
     fun validateCanIceAndUse(): Boolean {
         if (this.iceCount > 0) {
-            this.iceCount.minus(1)
+            this.iceCount -= 1
             return true
         }
         throw BadRequestException(UserChallengeException.CANNOT_USE_ICE)

server/src/test/kotlin/com/app/server/IntegrationTestContainer.kt

@@ -42,6 +42,9 @@ abstract class IntegrationTestContainer {
     protected val participationDays: Int = 7
     protected val participantsStartDate: LocalDate = LocalDate.now()
     protected val testEmail = "testEmail@email.com"
+    protected val imageUrl = "testImageUrl"
+    protected val challengeTitle = "유휴 전원 / 대기 전력 OFF"
+    protected val challengeDescription = "사용하지 않는 전자기기의 전원을 끄거나, 플러그를 뽑는 챌린지입니다. TV, 컴퓨터 등의 대기 전력을 차단함으로써 불필요한 전기 낭비를 줄이고 온실가스 배출을 저감할 수 있습니다."
     protected val accessTokenValidationTime = 360000L
     protected val token : String by lazy {
         jwtUtil.createToken(userId, testEmail, "USER", accessTokenValidationTime)

server/src/test/kotlin/com/app/server/challenge_certification/application/usecase/CertificationUseCaseTest.kt

@@ -49,30 +49,25 @@ class CertificationUseCaseTest : IntegrationTestContainer() {
     @MockitoBean
     private lateinit var certificationInfraService: CertificationInfraService
 
-    val imageUrl = "testImageUrl"
-    val challengeTitle = "유휴 전원 / 대기 전력 OFF"
-    val challengeDescription = "사용하지 않는 전자기기의 전원을 끄거나, 플러그를 뽑는 챌린지입니다. TV, 컴퓨터 등의 대기 전력을 차단함으로써 불필요한 전기 낭비를 줄이고 온실가스 배출을 저감할 수 있습니다."
     var certificationRequestDto = CertificationRequestDto(
         userChallengeId = userChallengeId,
         imageUrl = imageUrl,
     )
-    var pastCertificationRequestDto = CertificationRequestDto(
-        userChallengeId = userChallengeId - 1,
-        imageUrl = imageUrl
-    )
+
     var sendToCertificationServerRequestDto = SendToCertificationServerRequestDto(
         imageUrl = imageUrl,
         challengeId = challengeId,
         challengeName = challengeTitle,
         challengeDescription = challengeDescription
     )
+    var savedUserChallenge: UserChallenge? = null
 
     @BeforeEach
-    fun setUpChallengeFixture() {
-        val savedUserChallenge = makeUserChallengeAndHistory(participantsStartDate)
+    fun setUp() {
+        savedUserChallenge = makeUserChallengeAndHistory(participantsStartDate)
 
         certificationRequestDto = CertificationRequestDto(
-            userChallengeId = savedUserChallenge.id!!,
+            userChallengeId = savedUserChallenge!!.id!!,
             imageUrl = imageUrl,
         )
         val challenge = challengeService.findById(challengeId)
@@ -193,15 +188,16 @@ class CertificationUseCaseTest : IntegrationTestContainer() {
         given(certificationInfraService.certificate(sendToCertificationServerRequestDto)).willReturn(
             EUserCertificatedResultCode.SUCCESS_CERTIFICATED
         )
-        val pastUserChallenge : UserChallenge? = makeUserChallengeAndHistory(participantsStartDate.minusDays(1))
+        val pastUserChallengeNowConsecutiveParticipationDayCount = savedUserChallenge!!.nowConsecutiveParticipationDayCount
+        val pastUserChallengeMaxConsecutiveParticipationDayCount = savedUserChallenge!!.maxConsecutiveParticipationDayCount
 
         // when
         val todayUserChallenge : UserChallenge =
             certificationUseCase.certificateChallengeWithDate(certificationRequestDto, participantsStartDate)
         // then
-        assertThat(todayUserChallenge.nowConsecutiveParticipationDayCount).isGreaterThan(pastUserChallenge!!.nowConsecutiveParticipationDayCount)
-        assertThat(todayUserChallenge.nowConsecutiveParticipationDayCount - pastUserChallenge.nowConsecutiveParticipationDayCount).isOne
-        assertThat(todayUserChallenge.maxConsecutiveParticipationDayCount).isEqualTo(todayUserChallenge.nowConsecutiveParticipationDayCount)
+        assertThat(todayUserChallenge.nowConsecutiveParticipationDayCount).isGreaterThan(pastUserChallengeNowConsecutiveParticipationDayCount)
+        assertThat(todayUserChallenge.nowConsecutiveParticipationDayCount - pastUserChallengeNowConsecutiveParticipationDayCount).isOne
+        assertThat(todayUserChallenge.maxConsecutiveParticipationDayCount).isEqualTo(pastUserChallengeMaxConsecutiveParticipationDayCount)
     }
 
     @Test