룰렛

- 확률 수동설정 하도록 변경
- 결과 로직 서버에서 실행되도록 변경
- 활성화 된 룰렛 중 선택하여 돌리도록 변경
- 룰렛 결과를 후원메시지 리스트에서 볼 수 있도록 기록

src/main/kotlin/kr/co/vividnext/sodalive/live/room/info/LiveRoomInfo.kt

@@ -95,6 +95,18 @@ data class LiveRoomInfo(
         donationMessageList = donationMessageSet.toList()
     }
 
+    fun addRouletteMessage(nickname: String, donationMessage: String) {
+        val donationMessageSet = donationMessageList.toMutableSet()
+        donationMessageSet.add(
+            LiveRoomDonationMessage(
+                nickname = nickname,
+                canMessage = "",
+                donationMessage = donationMessage
+            )
+        )
+        donationMessageList = donationMessageSet.toList()
+    }
+
     fun removeDonationMessage(uuid: String) {
         (donationMessageList as MutableList).removeIf { it.uuid == uuid }
     }

src/main/kotlin/kr/co/vividnext/sodalive/live/roulette/v2/CreateRouletteRequestV2.kt

@@ -0,0 +1,9 @@
+package kr.co.vividnext.sodalive.live.roulette.v2
+
+import kr.co.vividnext.sodalive.live.roulette.RouletteItem
+
+data class CreateRouletteRequestV2(
+    val can: Int,
+    val isActive: Boolean,
+    val items: List<RouletteItem>
+)

src/main/kotlin/kr/co/vividnext/sodalive/live/roulette/v2/GetRouletteResponseV2.kt

@@ -0,0 +1,10 @@
+package kr.co.vividnext.sodalive.live.roulette.v2
+
+import kr.co.vividnext.sodalive.live.roulette.RouletteItem
+
+data class GetRouletteResponseV2(
+    val id: Long,
+    val can: Int,
+    val isActive: Boolean,
+    val items: List<RouletteItem>
+)

src/main/kotlin/kr/co/vividnext/sodalive/live/roulette/v2/RouletteController.kt

@@ -3,9 +3,14 @@ package kr.co.vividnext.sodalive.live.roulette.v2
 import kr.co.vividnext.sodalive.common.ApiResponse
 import kr.co.vividnext.sodalive.common.SodaException
 import kr.co.vividnext.sodalive.member.Member
+import kr.co.vividnext.sodalive.member.MemberRole
 import org.springframework.security.access.prepost.PreAuthorize
 import org.springframework.security.core.annotation.AuthenticationPrincipal
 import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.PathVariable
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.PutMapping
+import org.springframework.web.bind.annotation.RequestBody
 import org.springframework.web.bind.annotation.RequestMapping
 import org.springframework.web.bind.annotation.RequestParam
 import org.springframework.web.bind.annotation.RestController
@@ -23,4 +28,60 @@ class RouletteController(private val service: RouletteService) {
 
         ApiResponse.ok(service.getAllRoulette(creatorId = creatorId, memberId = member.id!!))
     }
+
+    @PostMapping
+    @PreAuthorize("hasRole('CREATOR')")
+    fun createNewRoulette(
+        @RequestBody request: CreateRouletteRequestV2,
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?
+    ) = run {
+        if (member == null || member.role != MemberRole.CREATOR) {
+            throw SodaException("로그인 정보를 확인해주세요.")
+        }
+
+        ApiResponse.ok(service.createRoulette(memberId = member.id!!, request = request))
+    }
+
+    @PutMapping
+    @PreAuthorize("hasRole('CREATOR')")
+    fun updateNewRoulette(
+        @RequestBody request: UpdateRouletteRequestV2,
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?
+    ) = run {
+        if (member == null || member.role != MemberRole.CREATOR) {
+            throw SodaException("로그인 정보를 확인해주세요.")
+        }
+
+        ApiResponse.ok(service.updateRoulette(memberId = member.id!!, request = request))
+    }
+
+    @GetMapping
+    fun getRoulette(
+        @RequestParam creatorId: Long,
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?
+    ) = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+
+        ApiResponse.ok(service.getRoulette(creatorId = creatorId, memberId = member.id!!))
+    }
+
+    @PostMapping("/spin")
+    fun spinRoulette(
+        @RequestBody request: SpinRouletteRequestV2,
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?
+    ) = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+
+        ApiResponse.ok(service.spinRoulette(request = request, member = member))
+    }
+
+    @PostMapping("/refund/{id}")
+    fun refundDonation(
+        @PathVariable id: Long,
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?
+    ) = run {
+        if (member == null) throw SodaException("로그인 정보를 확인해주세요.")
+
+        ApiResponse.ok(service.refundDonation(id, member))
+    }
 }

src/main/kotlin/kr/co/vividnext/sodalive/live/roulette/v2/RouletteService.kt

@@ -1,26 +1,245 @@
 package kr.co.vividnext.sodalive.live.roulette.v2
 
+import kr.co.vividnext.sodalive.can.CanRepository
+import kr.co.vividnext.sodalive.can.charge.Charge
+import kr.co.vividnext.sodalive.can.charge.ChargeRepository
+import kr.co.vividnext.sodalive.can.charge.ChargeStatus
+import kr.co.vividnext.sodalive.can.payment.CanPaymentService
+import kr.co.vividnext.sodalive.can.payment.Payment
+import kr.co.vividnext.sodalive.can.payment.PaymentGateway
+import kr.co.vividnext.sodalive.can.payment.PaymentStatus
+import kr.co.vividnext.sodalive.can.use.CanUsage
+import kr.co.vividnext.sodalive.can.use.UseCanCalculateRepository
+import kr.co.vividnext.sodalive.can.use.UseCanCalculateStatus
 import kr.co.vividnext.sodalive.common.SodaException
-import kr.co.vividnext.sodalive.live.roulette.GetNewRouletteResponse
+import kr.co.vividnext.sodalive.live.room.LiveRoomRepository
+import kr.co.vividnext.sodalive.live.room.info.LiveRoomInfoRedisRepository
+import kr.co.vividnext.sodalive.live.roulette.NewRoulette
+import kr.co.vividnext.sodalive.live.roulette.RedisIdGenerator
+import kr.co.vividnext.sodalive.live.roulette.RouletteItem
+import kr.co.vividnext.sodalive.member.Member
+import kr.co.vividnext.sodalive.member.MemberRepository
+import kr.co.vividnext.sodalive.member.MemberRole
+import org.springframework.data.repository.findByIdOrNull
 import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+import java.util.concurrent.locks.ReentrantReadWriteLock
+import kotlin.concurrent.write
+import kotlin.random.Random
 
 @Service
 class RouletteService(
-    private val repository: RouletteRepository
+    private val idGenerator: RedisIdGenerator,
+    private val canPaymentService: CanPaymentService,
+
+    private val canRepository: CanRepository,
+    private val repository: RouletteRepository,
+    private val roomRepository: LiveRoomRepository,
+    private val memberRepository: MemberRepository,
+    private val chargeRepository: ChargeRepository,
+    private val roomInfoRepository: LiveRoomInfoRedisRepository,
+    private val useCanCalculateRepository: UseCanCalculateRepository
 ) {
-    fun getAllRoulette(creatorId: Long, memberId: Long): List<GetNewRouletteResponse> {
+    private val tokenLocks: MutableMap<Long, ReentrantReadWriteLock> = mutableMapOf()
+
+    fun getAllRoulette(creatorId: Long, memberId: Long): List<GetRouletteResponseV2> {
         if (creatorId != memberId) throw SodaException("잘못된 요청입니다.")
 
-        val rouletteList = repository.findByCreatorId(creatorId)
+        return repository.findByCreatorId(creatorId)
-
+            .sortedBy { it.id }
-        return rouletteList.sortedBy { it.id }
             .map {
-                GetNewRouletteResponse(
+                GetRouletteResponseV2(
-                    it.id,
+                    id = it.id,
-                    it.can,
+                    can = it.can,
-                    it.isActive,
+                    isActive = it.isActive,
-                    it.items
+                    items = it.items
                 )
             }
     }
+
+    fun createRoulette(memberId: Long, request: CreateRouletteRequestV2): Boolean {
+        rouletteValidate(can = request.can, items = request.items)
+
+        val roulette = NewRoulette(
+            id = idGenerator.generateId(SEQUENCE_NAME),
+            creatorId = memberId,
+            can = request.can,
+            isActive = request.isActive,
+            items = request.items
+        )
+
+        repository.save(roulette)
+        return request.isActive
+    }
+
+    fun updateRoulette(memberId: Long, request: UpdateRouletteRequestV2): Boolean {
+        rouletteValidate(can = request.can, items = request.items)
+
+        val rouletteList = repository.findByCreatorId(creatorId = memberId)
+
+        if (rouletteList.isEmpty()) {
+            throw SodaException("잘못된 요청입니다.")
+        }
+
+        var isActive = false
+        rouletteList.forEach {
+            if (request.isActive || it.isActive) {
+                isActive = true
+            }
+
+            if (it.id == request.id) {
+                it.can = request.can
+                it.items = request.items
+                it.isActive = request.isActive
+                repository.save(it)
+            } else if (request.isActive) {
+                it.isActive = false
+                repository.save(it)
+            }
+        }
+
+        return isActive
+    }
+
+    fun getRoulette(creatorId: Long, memberId: Long): List<GetRouletteResponseV2> {
+        val rouletteList = repository.findByCreatorId(creatorId = creatorId)
+            .filter { it.isActive }
+            .filter { it.items.isNotEmpty() }
+            .map { GetRouletteResponseV2(it.id, it.can, it.isActive, it.items) }
+
+        if (rouletteList.isEmpty()) {
+            throw SodaException("룰렛을 사용할 수 없습니다.")
+        }
+
+        return rouletteList
+    }
+
+    @Transactional
+    fun spinRoulette(request: SpinRouletteRequestV2, member: Member): SpinRouletteResponse {
+        // STEP 1 - 라이브 정보 가져오기
+        val room = roomRepository.findByIdOrNull(request.roomId)
+            ?: throw SodaException("해당하는 라이브가 없습니다.")
+
+        val host = room.member ?: throw SodaException("잘못된 요청입니다.")
+
+        if (host.role != MemberRole.CREATOR) {
+            throw SodaException("비비드넥스트와 계약한\n크리에이터의 룰렛만 사용하실 수 있습니다.")
+        }
+
+        // STEP 2 - 룰렛 데이터 가져오기
+        val roulette = repository.findByIdOrNull(id = request.rouletteId)
+
+        if (roulette == null || roulette.items.isEmpty()) {
+            throw SodaException("룰렛을 사용할 수 없습니다.")
+        }
+
+        // STEP 3 - 캔 사용
+        canPaymentService.spendCan(
+            memberId = member.id!!,
+            needCan = roulette.can,
+            canUsage = CanUsage.SPIN_ROULETTE,
+            liveRoom = room,
+            container = request.container
+        )
+
+        val itemList = roulette.items
+        val result = randomSelectRouletteItem(itemList = itemList)
+
+        val lock = getOrCreateLock(memberId = member.id!!)
+        lock.write {
+            val roomInfo = roomInfoRepository.findByIdOrNull(room.id!!)
+                ?: throw SodaException("해당하는 라이브의 정보가 없습니다.")
+
+            roomInfo.addRouletteMessage(
+                nickname = member.nickname,
+                donationMessage = "[$result] 당첨!"
+            )
+
+            roomInfoRepository.save(roomInfo)
+        }
+
+        return SpinRouletteResponse(can = roulette.can, result = result, items = itemList)
+    }
+
+    @Transactional
+    fun refundDonation(roomId: Long, member: Member) {
+        val donator = memberRepository.findByIdOrNull(member.id)
+            ?: throw SodaException("룰렛 돌리기에 실패한 캔이 환불되지 않았습니다\n고객센터로 문의해주세요.")
+
+        val useCan = canRepository.getCanUsedForLiveRoomNotRefund(
+            memberId = member.id!!,
+            roomId = roomId,
+            canUsage = CanUsage.SPIN_ROULETTE
+        ) ?: throw SodaException("룰렛 돌리기에 실패한 캔이 환불되지 않았습니다\n고객센터로 문의해주세요.")
+        useCan.isRefund = true
+
+        val useCanCalculates = useCanCalculateRepository.findByUseCanIdAndStatus(useCan.id!!)
+        useCanCalculates.forEach {
+            it.status = UseCanCalculateStatus.REFUND
+            val charge = Charge(0, it.can, status = ChargeStatus.REFUND_CHARGE)
+            charge.title = "${it.can} 캔"
+            charge.useCan = useCan
+
+            when (it.paymentGateway) {
+                PaymentGateway.GOOGLE_IAP -> donator.googleRewardCan += charge.rewardCan
+                PaymentGateway.APPLE_IAP -> donator.appleRewardCan += charge.rewardCan
+                else -> donator.pgRewardCan += charge.rewardCan
+            }
+            charge.member = donator
+
+            val payment = Payment(
+                status = PaymentStatus.COMPLETE,
+                paymentGateway = it.paymentGateway
+            )
+            payment.method = "룰렛 환불"
+            charge.payment = payment
+
+            chargeRepository.save(charge)
+        }
+    }
+
+    private fun randomSelectRouletteItem(itemList: List<RouletteItem>): String {
+        val cumulativeProbabilities = calculateCumulativeProbabilities(itemList)
+
+        val randomValue = Random.nextFloat()
+        for (i in itemList.indices) {
+            if (randomValue <= cumulativeProbabilities[i]) {
+                return itemList[i].title
+            }
+        }
+
+        return itemList.random().title
+    }
+
+    private fun calculateCumulativeProbabilities(items: List<RouletteItem>): List<Float> {
+        val totalPercent = items.map { it.percentage }.sum()
+        var cumulativeProbability = 0f
+        return items.map {
+            cumulativeProbability += it.percentage / totalPercent
+            cumulativeProbability
+        }
+    }
+
+    private fun rouletteValidate(can: Int, items: List<RouletteItem>) {
+        if (can < 5) {
+            throw SodaException("룰렛 금액은 최소 5캔 입니다.")
+        }
+
+        if (items.size < 2 || items.size > 10) {
+            throw SodaException("룰렛 옵션은 최소 2개, 최대 10개까지 설정할 수 있습니다.")
+        }
+
+        val totalPercentage = items.map { it.percentage }.sum()
+        if (totalPercentage != 100f) {
+            throw SodaException("확률이 100%가 아닙니다")
+        }
+    }
+
+    private fun getOrCreateLock(memberId: Long): ReentrantReadWriteLock {
+        return tokenLocks.computeIfAbsent(memberId) { ReentrantReadWriteLock() }
+    }
+
+    companion object {
+        const val SEQUENCE_NAME = "newRoulette:sequence"
+    }
 }

src/main/kotlin/kr/co/vividnext/sodalive/live/roulette/v2/SpinRouletteRequestV2.kt

@@ -0,0 +1,7 @@
+package kr.co.vividnext.sodalive.live.roulette.v2
+
+data class SpinRouletteRequestV2(
+    val roomId: Long,
+    val rouletteId: Long,
+    val container: String
+)

src/main/kotlin/kr/co/vividnext/sodalive/live/roulette/v2/SpinRouletteResponse.kt

@@ -0,0 +1,9 @@
+package kr.co.vividnext.sodalive.live.roulette.v2
+
+import kr.co.vividnext.sodalive.live.roulette.RouletteItem
+
+data class SpinRouletteResponse(
+    val can: Int,
+    val result: String,
+    val items: List<RouletteItem>
+)

src/main/kotlin/kr/co/vividnext/sodalive/live/roulette/v2/UpdateRouletteRequestV2.kt

@@ -0,0 +1,10 @@
+package kr.co.vividnext.sodalive.live.roulette.v2
+
+import kr.co.vividnext.sodalive.live.roulette.RouletteItem
+
+data class UpdateRouletteRequestV2(
+    val id: Long,
+    val can: Int,
+    val isActive: Boolean,
+    val items: List<RouletteItem>
+)