DRAW-275 디스코드 웹훅 작업

adapter/webhook/discord/build.gradle.kts

@@ -0,0 +1,17 @@
+import org.springframework.boot.gradle.tasks.bundling.BootJar
+
+plugins {
+ kotlin("plugin.spring")
+}
+
+dependencies {
+ implementation(project(":domain"))
+ implementation(project(":support:logging"))
+
+ implementation("org.springframework.boot:spring-boot-starter-webflux:${Versions.SPRING_BOOT}")
+}
+
+tasks {
+ withType<Jar> { enabled = true }
+ withType<BootJar> { enabled = false }
+}

adapter/webhook/discord/src/main/kotlin/com/xorker/draw/webhook/discord/DiscordClient.kt

@@ -0,0 +1,15 @@
+package com.xorker.draw.webhook.discord
+
+import com.xorker.draw.webhook.discord.dto.DiscordMessage
+import org.springframework.web.bind.annotation.PathVariable
+import org.springframework.web.bind.annotation.RequestBody
+import org.springframework.web.service.annotation.PostExchange
+import reactor.core.publisher.Mono
+
+internal interface DiscordClient {
+ @PostExchange("/api/webhooks/{path}")
+ fun sendMessage(
+ @PathVariable("path") path: String,
+ @RequestBody discordMessage: DiscordMessage,
+ ): Mono<Void>
+}

adapter/webhook/discord/src/main/kotlin/com/xorker/draw/webhook/discord/DiscordWebHookAdapter.kt

@@ -0,0 +1,36 @@
+package com.xorker.draw.webhook.discord
+
+import com.xorker.draw.notify.NotifyRepository
+import com.xorker.draw.notify.NotifyType
+import com.xorker.draw.support.logging.logger
+import com.xorker.draw.webhook.discord.config.DiscordProperties
+import com.xorker.draw.webhook.discord.dto.DiscordEmbed
+import com.xorker.draw.webhook.discord.dto.DiscordMessage
+import org.springframework.stereotype.Component
+
+@Component
+internal class DiscordWebHookAdapter(
+ private val discordClient: DiscordClient,
+ private val discordProperties: DiscordProperties,
+) : NotifyRepository {
+ val logger = logger()
+
+ override fun notifyMessage(notifyType: NotifyType) {
+ try {
+ when (notifyType) {
+ is NotifyType.DiscordRandomMatchingNotifyType ->
+ discordClient.sendMessage(discordProperties.randomMatchingUrl, notifyType.toDiscordMessage()).block()
+
+ is NotifyType.DiscordStartGameNotifyType ->
+ discordClient.sendMessage(discordProperties.startGameUrl, notifyType.toDiscordMessage()).block()
+ }
+ } catch (ex: Exception) {
+ logger.warn(ex.message, ex)
+ }
+ }
+
+ fun NotifyType.toDiscordMessage(): DiscordMessage = when (this) {
+ is NotifyType.DiscordRandomMatchingNotifyType -> DiscordMessage(listOf(DiscordEmbed(this.message)))
+ is NotifyType.DiscordStartGameNotifyType -> DiscordMessage(listOf(DiscordEmbed(this.message)))
+ }
+}

adapter/webhook/discord/src/main/kotlin/com/xorker/draw/webhook/discord/config/DiscordClientConfig.kt

@@ -0,0 +1,26 @@
+package com.xorker.draw.webhook.discord.config
+
+import com.xorker.draw.webhook.discord.DiscordClient
+import org.springframework.boot.context.properties.EnableConfigurationProperties
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+import org.springframework.web.reactive.function.client.WebClient
+import org.springframework.web.reactive.function.client.support.WebClientAdapter
+import org.springframework.web.service.invoker.HttpServiceProxyFactory
+
+@EnableConfigurationProperties(DiscordProperties::class)
+@Configuration
+internal class DiscordClientConfig {
+
+ @Bean
+ fun webClient(): WebClient = WebClient.create("https://discord.com")
+
+ @Bean
+ fun discordClient(): DiscordClient {
+ val factory = HttpServiceProxyFactory.builder()
+ .exchangeAdapter(WebClientAdapter.create(webClient()))
+ .build()
+
+ return factory.createClient(DiscordClient::class.java)
+ }
+}

adapter/webhook/discord/src/main/kotlin/com/xorker/draw/webhook/discord/config/DiscordProperties.kt

@@ -0,0 +1,9 @@
+package com.xorker.draw.webhook.discord.config
+
+import org.springframework.boot.context.properties.ConfigurationProperties
+
+@ConfigurationProperties(prefix = "discord")
+internal data class DiscordProperties(
+ val randomMatchingUrl: String,
+ val startGameUrl: String,
+)

adapter/webhook/discord/src/main/kotlin/com/xorker/draw/webhook/discord/dto/DiscordEmbed.kt

@@ -0,0 +1,5 @@
+package com.xorker.draw.webhook.discord.dto
+
+data class DiscordEmbed(
+ val title: String,
+)

adapter/webhook/discord/src/main/kotlin/com/xorker/draw/webhook/discord/dto/DiscordMessage.kt

@@ -0,0 +1,5 @@
+package com.xorker.draw.webhook.discord.dto
+
+data class DiscordMessage(
+ val embeds: List<DiscordEmbed>,
+)

adapter/webhook/discord/src/main/resources/application-discord.yml

@@ -0,0 +1,3 @@
+discord:
+ random-matching-url: ${WEBHOOK_RANDOM_MATCHING_URL}
+ start-game-url: ${WEBHOOK_START_GAME_URL}

core/build.gradle.kts

@@ -9,6 +9,7 @@ dependencies {
  implementation(project(":adapter:memory"))
  implementation(project(":adapter:oauth"))
  implementation(project(":adapter:rdb"))
+ implementation(project(":adapter:webhook:discord"))
  implementation(project(":support:jwt"))
  implementation(project(":support:time"))
 

core/src/main/kotlin/com/xorker/draw/mafia/MafiaGameRandomMatchingService.kt

@@ -1,6 +1,8 @@
 package com.xorker.draw.mafia
 
 import com.xorker.draw.exception.InvalidRequestOtherPlayingException
+import com.xorker.draw.notify.NotifyRepository
+import com.xorker.draw.notify.NotifyType
 import com.xorker.draw.websocket.WaitingQueueSession
 import com.xorker.draw.websocket.WaitingQueueSessionEventListener
 import org.springframework.stereotype.Service
@@ -10,6 +12,7 @@ internal class MafiaGameRandomMatchingService(
  private val mafiaGameUseCase: MafiaGameUseCase,
  private val mafiaGameWaitingQueueRepository: MafiaGameWaitingQueueRepository,
  private val mafiaGameMessenger: MafiaGameMessenger,
+ private val notifyRepository: NotifyRepository,
 ) : WaitingQueueSessionEventListener {
 
  override fun connectSession(session: WaitingQueueSession) {
@@ -22,6 +25,8 @@ internal class MafiaGameRandomMatchingService(
  mafiaGameWaitingQueueRepository.enqueue(4, session)
 
  mafiaGameMessenger.unicastRandomMatching(user.id)
+
+ notifyRepository.notifyMessage(NotifyType.DiscordRandomMatchingNotifyType(user.name, session.locale))
  }
 
  override fun exitSession(session: WaitingQueueSession) {

core/src/main/kotlin/com/xorker/draw/mafia/phase/MafiaPhaseStartGameProcessor.kt

@@ -3,6 +3,8 @@ package com.xorker.draw.mafia.phase
 import com.xorker.draw.mafia.MafiaGameInfo
 import com.xorker.draw.mafia.MafiaKeywordRepository
 import com.xorker.draw.mafia.MafiaPhase
+import com.xorker.draw.notify.NotifyRepository
+import com.xorker.draw.notify.NotifyType
 import com.xorker.draw.timer.TimerRepository
 import org.springframework.stereotype.Component
 import kotlin.random.Random
@@ -11,6 +13,7 @@ import kotlin.random.Random
 internal class MafiaPhaseStartGameProcessor(
  private val mafiaKeywordRepository: MafiaKeywordRepository,
  private val timerRepository: TimerRepository,
+ private val notifyRepository: NotifyRepository,
 ) {
  private val random: Random = Random(System.currentTimeMillis())
 
@@ -34,6 +37,8 @@ internal class MafiaPhaseStartGameProcessor(
  )
  gameInfo.phase = phase
 
+ notifyRepository.notifyMessage(NotifyType.DiscordStartGameNotifyType(room.id, room.locale))
+
  return phase
  }
 }

domain/src/main/kotlin/com/xorker/draw/notify/NotifyRepository.kt

@@ -0,0 +1,5 @@
+package com.xorker.draw.notify
+
+interface NotifyRepository {
+ fun notifyMessage(notifyType: NotifyType)
+}

domain/src/main/kotlin/com/xorker/draw/notify/NotifyType.kt

@@ -0,0 +1,52 @@
+package com.xorker.draw.notify
+
+import com.xorker.draw.exception.UnSupportedException
+import com.xorker.draw.room.RoomId
+
+sealed class NotifyType {
+ class DiscordRandomMatchingNotifyType(
+ name: String,
+ language: LanguageType,
+ ) : NotifyType() {
+ val message: String = language.content + " ${name}님이 빠른 게임 상대를 기다리고 있어요."
+
+ companion object {
+ private fun from(name: String, language: String):
+ DiscordRandomMatchingNotifyType = DiscordRandomMatchingNotifyType(name, getLanguageType(language))
+
+ operator fun invoke(name: String, language: String): DiscordRandomMatchingNotifyType = from(name, language)
+ }
+ }
+
+ class DiscordStartGameNotifyType(
+ roomId: RoomId,
+ language: LanguageType,
+ ) : NotifyType() {
+ val message: String = language.content + " ${roomId.value} 방에서 게임이 시작되었어요."
+
+ companion object {
+ private fun from(roomId: RoomId, language: String):
+ DiscordStartGameNotifyType = DiscordStartGameNotifyType(roomId, getLanguageType(language))
+
+ operator fun invoke(roomId: RoomId, language: String): DiscordStartGameNotifyType = from(roomId, language)
+ }
+ }
+
+ companion object {
+ fun getLanguageType(language: String): LanguageType {
+ return when (language) {
+ "ko" -> LanguageType.KOREAN
+ "en" -> LanguageType.ENGLISH
+ else -> throw UnSupportedException
+ }
+ }
+ }
+}
+
+enum class LanguageType(
+ val content: String,
+) {
+ KOREAN("\uD83C\uDDF0\uD83C\uDDF7"),
+ ENGLISH("\uD83C\uDDFA\uD83C\uDDF8"),
+ ;
+}

settings.gradle.kts

@@ -2,6 +2,7 @@ include(
  "adapter:memory",
  "adapter:oauth",
  "adapter:rdb",
+ "adapter:webhook:discord",
  "app:api",
  "app:support:auth",
  "app:support:exception",