add webserver, etc...

- add ktor webserver
- package is subpackaged.

src/main/kotlin/space/mori/chzzk_bot/Connector.kt

@@ -1,28 +0,0 @@
-package space.mori.chzzk_bot
-
-import com.zaxxer.hikari.HikariConfig
-import com.zaxxer.hikari.HikariDataSource
-import org.jetbrains.exposed.sql.Database
-import org.jetbrains.exposed.sql.SchemaUtils
-import org.jetbrains.exposed.sql.transactions.transaction
-import space.mori.chzzk_bot.models.*
-
-object Connector {
-    private val hikariConfig = HikariConfig().apply {
-        jdbcUrl = dotenv["DB_URL"]
-        driverClassName = "org.mariadb.jdbc.Driver"
-        username = dotenv["DB_USER"]
-        password = dotenv["DB_PASS"]
-        maximumPoolSize = 10
-    }
-    val dataSource = HikariDataSource(hikariConfig)
-
-    init {
-        Database.connect(dataSource)
-        val tables = listOf(Users, Commands, Counters, DailyCounters, PersonalCounters, Managers)
-
-        transaction {
-            SchemaUtils.createMissingTablesAndColumns(* tables.toTypedArray())
-        }
-    }
-}

src/main/kotlin/space/mori/chzzk_bot/Main.kt

@@ -5,9 +5,12 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.runBlocking
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
-import space.mori.chzzk_bot.chzzk.ChzzkHandler
-import space.mori.chzzk_bot.discord.Discord
-import space.mori.chzzk_bot.chzzk.Connector as ChzzkConnector
+import space.mori.chzzk_bot.chatbot.chzzk.ChzzkHandler
+import space.mori.chzzk_bot.chatbot.discord.Discord
+import space.mori.chzzk_bot.chatbot.chzzk.Connector as ChzzkConnector
+import space.mori.chzzk_bot.common.Connector
+import space.mori.chzzk_bot.webserver.start
+import space.mori.chzzk_bot.webserver.stop
 import java.util.concurrent.TimeUnit
 import kotlin.system.exitProcess
 
@@ -26,6 +29,7 @@ fun main(args: Array<String>) {
     discord.enable()
     chzzkHandler.enable()
     chzzkHandler.runStreamInfo()
+    start()
 
     if(dotenv.get("RUN_AGENT", "false").toBoolean()) {
         runBlocking {
@@ -36,6 +40,8 @@ fun main(args: Array<String>) {
 
     Runtime.getRuntime().addShutdownHook(Thread {
         logger.info("Shutting down...")
+        stop()
+
         chzzkHandler.stopStreamInfo()
         chzzkHandler.disable()
         discord.disable()

src/main/kotlin/space/mori/chzzk_bot/chzzk/ChzzkApis.kt

@@ -1,148 +0,0 @@
-package space.mori.chzzk_bot.chzzk
-
-import com.google.gson.Gson
-import com.google.gson.reflect.TypeToken
-import okhttp3.OkHttpClient
-import okhttp3.Request
-import java.io.IOException
-
-data class IData<T>(
-    val code: Int = 200,
-    val message: String? = null,
-    val content: T
-)
-
-// Follows
-data class IFollowContent(
-    val userIdHash: String = "",
-    val nickname: String = "",
-    val profileImageUrl: String = "",
-    val userRoleCode: String = "",
-    val badge: Badge? = null,
-    val title: Title? = null,
-    val verifiedMark: Boolean = false,
-    val activityBadges: List<Badge> = emptyList(),
-    val streamingProperty: StreamingProperty = StreamingProperty()
-)
-
-data class Badge(
-    val badgeNo: Int?,
-    val badgeId: String?,
-    val imageUrl: String?,
-    val title: String?,
-    val description: String?,
-    val activated: Boolean?
-)
-
-data class Title(
-    val name: String = "",
-    val color: String = ""
-)
-
-data class StreamingProperty(
-    val following: Following? = Following(),
-    val nicknameColor: NicknameColor = NicknameColor()
-)
-
-data class Following(
-    val followDate: String? = null
-)
-
-data class NicknameColor(
-    val colorCode: String = ""
-)
-
-// Stream info
-data class IStreamInfo(
-    val liveId: Int = 0,
-    val liveTitle: String = "",
-    val status: String = "",
-    val liveImageUrl: String = "",
-    val defaultThumbnailImageUrl: String? = null,
-    val concurrentUserCount: Int = 0,
-    val accumulateCount: Int = 0,
-    val openDate: String = "",
-    val closeDate: String = "",
-    val adult: Boolean = false,
-    val clipActive: Boolean = false,
-    val tags: List<String> = emptyList(),
-    val chatChannelId: String = "",
-    val categoryType: String = "",
-    val liveCategory: String = "",
-    val liveCategoryValue: String = "",
-    val chatActive: Boolean = true,
-    val chatAvailableGroup: String = "",
-    val paidPromotion: Boolean = false,
-    val chatAvailableCondition: String = "",
-    val minFollowerMinute: Int = 0,
-    val livePlaybackJson: String = "",
-    val p2pQuality: List<Any> = emptyList(),
-    val channel: Channel = Channel(),
-    val livePollingStatusJson: String = "",
-    val userAdultStatus: String? = null,
-    val chatDonationRankingExposure: Boolean = true,
-    val adParameter: AdParameter = AdParameter()
-)
-
-data class Channel(
-    val channelId: String = "",
-    val channelName: String = "",
-    val channelImageUrl: String = "",
-    val verifiedMark: Boolean = false
-)
-
-data class AdParameter(
-    val tag: String = ""
-)
-
-// OkHttpClient에 Interceptor 추가
-val client = OkHttpClient.Builder()
-    .addNetworkInterceptor { chain ->
-        chain.proceed(
-            chain.request()
-                .newBuilder()
-                .header("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36")
-                .build()
-        )
-    }
-    .build()
-val gson = Gson()
-
-fun getFollowDate(chatID: String, userId: String) : IData<IFollowContent> {
-    val url = "https://comm-api.game.naver.com/nng_main/v1/chats/$chatID/users/$userId/profile-card?chatType=STREAMING"
-    val request = Request.Builder()
-        .url(url)
-        .build()
-
-    client.newCall(request).execute().use { response ->
-        try {
-            if(!response.isSuccessful) throw IOException("Unexpected code ${response.code}")
-            val body = response.body?.string()
-            val follow = gson.fromJson(body, object: TypeToken<IData<IFollowContent>>() {})
-
-            return follow
-        } catch(e: Exception) {
-            println(e.stackTrace)
-            throw e
-        }
-    }
-}
-
-fun getStreamInfo(userId: String) : IData<IStreamInfo> {
-    val url = "https://api.chzzk.naver.com/service/v2/channels/${userId}/live-detail"
-    val request = Request.Builder()
-        .url(url)
-        .build()
-
-    client.newCall(request).execute().use { response ->
-        try {
-            if(!response.isSuccessful) throw IOException("Unexpected code ${response.code}")
-            val body = response.body?.string()
-            val follow = gson.fromJson(body, object: TypeToken<IData<IStreamInfo>>() {})
-
-            return follow
-        } catch(e: Exception) {
-            throw e
-        }
-    }
-}

src/main/kotlin/space/mori/chzzk_bot/chzzk/ChzzkHandler.kt

@@ -1,169 +0,0 @@
-package space.mori.chzzk_bot.chzzk
-
-import net.dv8tion.jda.api.EmbedBuilder
-import net.dv8tion.jda.api.utils.messages.MessageCreateBuilder
-import org.slf4j.Logger
-import org.slf4j.LoggerFactory
-import space.mori.chzzk_bot.chzzk.Connector.chzzk
-import space.mori.chzzk_bot.discord
-import space.mori.chzzk_bot.models.User
-import space.mori.chzzk_bot.services.UserService
-import xyz.r2turntrue.chzzk4j.chat.ChatEventListener
-import xyz.r2turntrue.chzzk4j.chat.ChatMessage
-import xyz.r2turntrue.chzzk4j.chat.ChzzkChat
-import xyz.r2turntrue.chzzk4j.types.channel.ChzzkChannel
-import java.lang.Exception
-import java.net.SocketTimeoutException
-import java.time.Instant
-
-object ChzzkHandler {
-    private val handlers = mutableListOf<UserHandler>()
-    private val logger = LoggerFactory.getLogger(this::class.java)
-    @Volatile private var running: Boolean = false
-
-    internal fun addUser(chzzkChannel: ChzzkChannel, user: User) {
-        handlers.add(UserHandler(chzzkChannel, logger, user))
-    }
-
-    internal fun enable() {
-        UserService.getAllUsers().map {
-            chzzk.getChannel(it.token)?.let { token -> addUser(token, it)}
-        }
-    }
-
-    internal fun disable() {
-        handlers.forEach { handler ->
-            handler.disable()
-        }
-    }
-
-    internal fun reloadCommand(chzzkChannel: ChzzkChannel) {
-        val handler = handlers.firstOrNull { it.channel.channelId == chzzkChannel.channelId }
-        if (handler != null)
-            handler.reloadCommand()
-        else
-            throw RuntimeException("${chzzkChannel.channelName} doesn't have handler")
-    }
-
-    internal fun reloadUser(chzzkChannel: ChzzkChannel, user: User) {
-        val handler = handlers.firstOrNull { it.channel.channelId == chzzkChannel.channelId }
-        if (handler != null)
-            handler.reloadUser(user)
-        else
-            throw RuntimeException("${chzzkChannel.channelName} doesn't have handler")
-    }
-
-    internal fun runStreamInfo() {
-        running = true
-        val thread = Thread({
-            while(running) {
-                handlers.forEach {
-                    if (!running) return@forEach
-                    try {
-                        val streamInfo = getStreamInfo(it.channel.channelId)
-                        if (streamInfo.content.status == "OPEN" && !it.isActive) it.isActive(true, streamInfo)
-                        if (streamInfo.content.status == "CLOSE" && it.isActive) it.isActive(false, streamInfo)
-                    } catch(e: SocketTimeoutException) {
-                        logger.info("Timeout: ${it.channel.channelName} / ${e.stackTraceToString()}")
-                    } catch (e: Exception) {
-                        logger.info("Exception: ${it.channel.channelName} / ${e.stackTraceToString()}")
-                    } finally {
-                        Thread.sleep(5000)
-                    }
-                }
-                Thread.sleep(60000)
-            }
-        }, "Chzzk-StreamInfo")
-
-        thread.start()
-    }
-
-    internal fun stopStreamInfo() {
-        running = false
-    }
-}
-
-class UserHandler(
-    val channel: ChzzkChannel,
-    private val logger: Logger,
-    private var user: User,
-    private var _isActive: Boolean = false
-) {
-    private lateinit var messageHandler: MessageHandler
-
-    private var listener: ChzzkChat = chzzk.chat(channel.channelId)
-        .withAutoReconnect(true)
-        .withChatListener(object : ChatEventListener {
-            override fun onConnect(chat: ChzzkChat, isReconnecting: Boolean) {
-                logger.info("ChzzkChat connected. ${channel.channelName} - ${channel.channelId} / reconnected: $isReconnecting")
-                messageHandler = MessageHandler(channel, logger, chat)
-            }
-
-            override fun onError(ex: Exception) {
-                logger.info("ChzzkChat error. ${channel.channelName} - ${channel.channelId}")
-                logger.debug(ex.stackTraceToString())
-            }
-
-            override fun onChat(msg: ChatMessage) {
-                if(!_isActive) return
-                messageHandler.handle(msg, user)
-            }
-
-            override fun onConnectionClosed(code: Int, reason: String?, remote: Boolean, tryingToReconnect: Boolean) {
-                logger.info("ChzzkChat closed. ${channel.channelName} - ${channel.channelId}")
-                logger.info("Reason: $reason / $tryingToReconnect")
-            }
-        })
-        .build()
-
-    internal fun disable() {
-        listener.closeAsync()
-    }
-
-    internal fun reloadCommand() {
-        messageHandler.reloadCommand()
-    }
-
-    internal fun reloadUser(user: User) {
-        this.user = user
-    }
-
-    internal val isActive: Boolean
-        get() = _isActive
-
-    internal fun isActive(value: Boolean, status: IData<IStreamInfo>) {
-        _isActive = value
-        if(value) {
-            logger.info("${user.username} is live.")
-
-            logger.info("ChzzkChat connecting... ${channel.channelName} - ${channel.channelId}")
-            listener.connectAsync()
-
-            if(user.liveAlertMessage != "" && user.liveAlertGuild != null && user.liveAlertChannel != null) {
-                val channel = discord.getChannel(user.liveAlertGuild!!, user.liveAlertChannel!!) ?: throw RuntimeException("${user.liveAlertChannel} is not valid.")
-
-                val embed = EmbedBuilder()
-                embed.setTitle(status.content.liveTitle, "https://chzzk.naver.com/live/${user.token}")
-                embed.setDescription("${user.username} 님이 방송을 시작했습니다.")
-                embed.setUrl(status.content.channel.channelImageUrl)
-                embed.setTimestamp(Instant.now())
-                embed.setAuthor(user.username, "https://chzzk.naver.com/live/${user.token}", status.content.channel.channelImageUrl)
-                embed.addField("카테고리", status.content.liveCategoryValue, true)
-                embed.addField("태그", status.content.tags.joinToString(", "), true)
-                embed.setImage(status.content.liveImageUrl.replace("{type}", "1080"))
-
-                channel.sendMessage(
-                    MessageCreateBuilder()
-                        .setContent(user.liveAlertMessage)
-                        .setEmbeds(embed.build())
-                        .build()
-                ).queue()
-
-                listener.sendChat("${user.username} 님의 방송이 감지되었습니다.")
-            }
-        } else {
-            logger.info("${user.username} is offline.")
-            listener.closeAsync()
-        }
-    }
-}

src/main/kotlin/space/mori/chzzk_bot/chzzk/Connector.kt

@@ -1,20 +0,0 @@
-package space.mori.chzzk_bot.chzzk
-
-import org.slf4j.LoggerFactory
-import xyz.r2turntrue.chzzk4j.Chzzk
-import xyz.r2turntrue.chzzk4j.ChzzkBuilder
-import xyz.r2turntrue.chzzk4j.types.channel.ChzzkChannel
-import space.mori.chzzk_bot.dotenv
-
-object Connector {
-    val chzzk: Chzzk = ChzzkBuilder()
-        .withAuthorization(dotenv["NID_AUT"], dotenv["NID_SES"])
-        .build()
-    private val logger = LoggerFactory.getLogger(this::class.java)
-
-    fun getChannel(channelId: String): ChzzkChannel? = chzzk.getChannel(channelId)
-
-    init {
-        logger.info("chzzk logged: ${chzzk.isLoggedIn} / ${chzzk.loggedUser?.nickname ?: "----"}")
-    }
-}

src/main/kotlin/space/mori/chzzk_bot/chzzk/MessageHandler.kt

@@ -1,193 +0,0 @@
-package space.mori.chzzk_bot.chzzk
-
-import org.slf4j.Logger
-import space.mori.chzzk_bot.models.User
-import space.mori.chzzk_bot.services.CommandService
-import space.mori.chzzk_bot.services.CounterService
-import space.mori.chzzk_bot.services.UserService
-import xyz.r2turntrue.chzzk4j.chat.ChatMessage
-import xyz.r2turntrue.chzzk4j.chat.ChzzkChat
-import xyz.r2turntrue.chzzk4j.types.channel.ChzzkChannel
-import java.time.LocalDateTime
-import java.time.format.DateTimeFormatter
-import java.time.temporal.ChronoUnit
-
-
-class MessageHandler(
-    private val channel: ChzzkChannel,
-    private val logger: Logger,
-    private val listener: ChzzkChat
-) {
-    private val commands = mutableMapOf<String, (msg: ChatMessage, user: User) -> Unit>()
-
-    private val counterPattern = Regex("<counter:([^>]+)>")
-    private val personalCounterPattern = Regex("<counter_personal:([^>]+)>")
-    private val dailyCounterPattern = Regex("<daily_counter:([^>]+)>")
-    private val namePattern = Regex("<name>")
-    private val followPattern = Regex("<following>")
-    private val daysPattern = """<days:(\d{4})-(\d{2})-(\d{2})>""".toRegex()
-
-    init {
-        reloadCommand()
-    }
-
-    internal fun reloadCommand() {
-        val user = UserService.getUser(channel.channelId)
-            ?: throw RuntimeException("User not found. it's bug? ${channel.channelName} - ${channel.channelId}")
-        val commands = CommandService.getCommands(user)
-        val manageCommands = mapOf("!명령어추가" to this::manageAddCommand, "!명령어삭제" to this::manageRemoveCommand, "!명령어수정" to this::manageUpdateCommand)
-
-        manageCommands.forEach { (commandName, command) ->
-            this.commands[commandName] = command
-        }
-
-        commands.map {
-            this.commands.put(it.command.lowercase()) { msg, user ->
-                logger.debug("${channel.channelName} - ${it.command} - ${it.content}/${it.failContent}")
-
-                val result = replaceCounters(Pair(it.content, it.failContent), user, msg, listener, msg.profile?.nickname ?: "")
-                listener.sendChat(result)
-            }
-        }
-    }
-
-    private fun manageAddCommand(msg: ChatMessage, user: User) {
-        if (msg.profile?.userRoleCode == "common_user") {
-            listener.sendChat("매니저만 명령어를 추가할 수 있습니다.")
-            return
-        }
-
-        val parts = msg.content.split(" ", limit = 3)
-        if (parts.size < 3) {
-            listener.sendChat("명령어 추가 형식은 '!명령어추가 명령어 내용'입니다.")
-            return
-        }
-        if (commands.containsKey(parts[1])) {
-            listener.sendChat("${parts[1]} 명령어는 이미 있는 명령어입니다.")
-            return
-        }
-        val command = parts[1]
-        val content = parts[2]
-        CommandService.saveCommand(user, command, content, "")
-        listener.sendChat("명령어 '$command' 추가되었습니다.")
-    }
-
-    private fun manageUpdateCommand(msg: ChatMessage, user: User) {
-        if (msg.profile?.userRoleCode == "common_user") {
-            listener.sendChat("매니저만 명령어를 추가할 수 있습니다.")
-            return
-        }
-
-        val parts = msg.content.split(" ", limit = 3)
-        if (parts.size < 3) {
-            listener.sendChat("명령어 수정 형식은 '!명령어수정 명령어 내용'입니다.")
-            return
-        }
-        if (!commands.containsKey(parts[1])) {
-            listener.sendChat("${parts[1]} 명령어는 없는 명령어입니다.")
-            return
-        }
-        val command = parts[1]
-        val content = parts[2]
-        CommandService.updateCommand(user, command, content, "")
-        listener.sendChat("명령어 '$command' 수정되었습니다.")
-    }
-
-    private fun manageRemoveCommand(msg: ChatMessage, user: User) {
-        if (msg.profile?.userRoleCode == "common_user") {
-            listener.sendChat("매니저만 명령어를 삭제할 수 있습니다.")
-            return
-        }
-
-        val parts = msg.content.split(" ", limit = 2)
-        if (parts.size < 2) {
-            listener.sendChat("명령어 삭제 형식은 '!명령어삭제 명령어'입니다.")
-            return
-        }
-        val command = parts[1]
-        CommandService.removeCommand(user, command)
-        listener.sendChat("명령어 '$command' 삭제되었습니다.")
-    }
-
-    internal fun handle(msg: ChatMessage, user: User) {
-        val commandKey = msg.content.split(' ')[0]
-
-        commands[commandKey.lowercase()]?.let { it(msg, user) }
-    }
-
-    private fun replaceCounters(chat: Pair<String, String>, user: User, msg: ChatMessage, listener: ChzzkChat, userName: String): String {
-        var result = chat.first
-        var isFail = false
-
-        // Replace dailyCounterPattern
-        result = dailyCounterPattern.replace(result) { matchResult ->
-            val name = matchResult.groupValues[1]
-            val dailyCounter = CounterService.getDailyCounterValue(name, msg.userId, user)
-
-            if (dailyCounter.second) {
-                CounterService.updateDailyCounterValue(name, msg.userId, 1, user).first.toString()
-            } else {
-                isFail = true
-                dailyCounter.first.toString()
-            }
-        }
-
-        // Handle fail case
-        if (isFail && chat.second.isNotEmpty()) {
-            result = chat.second
-            result = dailyCounterPattern.replace(result) { matchResult ->
-                val name = matchResult.groupValues[1]
-                val dailyCounter = CounterService.getDailyCounterValue(name, msg.userId, user)
-                dailyCounter.first.toString()
-            }
-        }
-
-        // Replace followPattern
-        result = followPattern.replace(result) { matchResult ->
-            try {
-                val followingDate = getFollowDate(listener.chatId, msg.userId)
-                    .content.streamingProperty.following?.followDate
-
-                val period = followingDate?.let {
-                    val formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")
-                    val pastDate = LocalDateTime.parse(it, formatter)
-                    val today = LocalDateTime.now()
-                    ChronoUnit.DAYS.between(pastDate, today)
-                } ?: 0
-
-                period.toString()
-            } catch (e: Exception) {
-                logger.error(e.message)
-                "0"
-            }
-        }
-
-        // Replace daysPattern
-        result = daysPattern.replace(result) { matchResult ->
-            val (year, month, day) = matchResult.destructured
-            val pastDate = LocalDateTime.of(year.toInt(), month.toInt(), day.toInt(), 0, 0, 0)
-            val today = LocalDateTime.now()
-
-            val daysBetween = ChronoUnit.DAYS.between(pastDate, today)
-            daysBetween.toString()
-        }
-
-        // Replace counterPattern
-        result = counterPattern.replace(result) { matchResult ->
-            val name = matchResult.groupValues[1]
-            CounterService.updateCounterValue(name, 1, user).toString()
-        }
-
-        // Replace personalCounterPattern
-        result = personalCounterPattern.replace(result) { matchResult ->
-            val name = matchResult.groupValues[1]
-            CounterService.updatePersonalCounterValue(name, msg.userId, 1, user).toString()
-        }
-
-        // Replace namePattern
-        result = namePattern.replace(result, userName)
-
-        return result
-    }
-
-}

src/main/kotlin/space/mori/chzzk_bot/discord/Commands.kt

@@ -1,11 +0,0 @@
-package space.mori.chzzk_bot.discord
-
-import net.dv8tion.jda.api.JDA
-import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
-import net.dv8tion.jda.api.interactions.commands.build.CommandData
-
-interface CommandInterface {
-    val name: String
-    fun run(event: SlashCommandInteractionEvent, bot: JDA): Unit
-    val command: CommandData
-}

src/main/kotlin/space/mori/chzzk_bot/discord/Discord.kt

@@ -1,97 +0,0 @@
-package space.mori.chzzk_bot.discord
-
-import net.dv8tion.jda.api.JDA
-import net.dv8tion.jda.api.JDABuilder
-import net.dv8tion.jda.api.entities.Activity
-import net.dv8tion.jda.api.entities.Guild
-import net.dv8tion.jda.api.events.guild.GuildJoinEvent
-import net.dv8tion.jda.api.events.guild.member.GuildMemberRemoveEvent
-import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
-import net.dv8tion.jda.api.hooks.ListenerAdapter
-import space.mori.chzzk_bot.dotenv
-import org.slf4j.LoggerFactory
-import space.mori.chzzk_bot.discord.commands.*
-import space.mori.chzzk_bot.services.ManagerService
-
-class Discord: ListenerAdapter() {
-    private lateinit var bot: JDA
-    private var guild: Guild? = null
-    private val logger = LoggerFactory.getLogger(this::class.java)
-
-    private val commands = listOf(
-        AddCommand,
-        AlertCommand,
-        PingCommand,
-        RegisterCommand,
-        RemoveCommand,
-        UpdateCommand,
-        AddManagerCommand,
-        ListManagerCommand,
-        RemoveManagerCommand,
-    )
-
-    override fun onSlashCommandInteraction(event: SlashCommandInteractionEvent) {
-        event.deferReply().queue()
-        val handler = commands.find { it.name == event.name }
-        logger.debug("Handler: ${handler?.name ?: "undefined"} command")
-        handler?.run(event, bot)
-    }
-
-    override fun onGuildMemberRemove(event: GuildMemberRemoveEvent) {
-        event.member?.let { ManagerService.deleteManager(event.guild.idLong, it.idLong) }
-    }
-
-    override fun onGuildJoin(event: GuildJoinEvent) {
-        commandUpdate(event.guild)
-    }
-
-    private fun commandUpdate(guild: Guild) {
-        guild.updateCommands().addCommands(* commands.map { it.command}.toTypedArray())
-            .onSuccess {
-                logger.info("Command update on guild success!")
-            }
-            .queue()
-    }
-
-    private fun commandUpdate(bot: JDA) {
-        bot.updateCommands().addCommands(* commands.map { it.command}.toTypedArray())
-            .onSuccess {
-                logger.info("Command update bot boot success!")
-            }
-            .queue()
-    }
-
-    internal fun enable() {
-        val thread = Thread {
-            try {
-                bot = JDABuilder.createDefault(dotenv["DISCORD_TOKEN"])
-                    .setActivity(Activity.playing("치지직 보는중"))
-                    .addEventListeners(this)
-                    .build().awaitReady()
-
-                guild = bot.getGuildById(dotenv["GUILD_ID"])
-
-                commandUpdate(bot)
-                bot.guilds.forEach {
-                    commandUpdate(it)
-                }
-            } catch (e: Exception) {
-                logger.info("Could not enable Discord!")
-                logger.debug(e.stackTraceToString())
-            }
-        }
-        thread.start()
-    }
-
-    internal fun disable() {
-        try {
-            bot.shutdown()
-        } catch(e: Exception) {
-            logger.info("Error while shutting down Discord!")
-            logger.debug(e.stackTraceToString())
-        }
-    }
-
-    internal fun getChannel(guildId: Long, channelId: Long) =
-        bot.getGuildById(guildId)?.getTextChannelById(channelId)
-}

src/main/kotlin/space/mori/chzzk_bot/discord/commands/AddCommand.kt

@@ -1,65 +0,0 @@
-package space.mori.chzzk_bot.discord.commands
-
-import net.dv8tion.jda.api.JDA
-import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
-import net.dv8tion.jda.api.interactions.commands.OptionType
-import net.dv8tion.jda.api.interactions.commands.build.Commands
-import net.dv8tion.jda.api.interactions.commands.build.OptionData
-import org.slf4j.LoggerFactory
-import space.mori.chzzk_bot.chzzk.ChzzkHandler
-import space.mori.chzzk_bot.chzzk.Connector
-import space.mori.chzzk_bot.discord.CommandInterface
-import space.mori.chzzk_bot.services.CommandService
-import space.mori.chzzk_bot.services.ManagerService
-import space.mori.chzzk_bot.services.UserService
-
-object AddCommand : CommandInterface {
-    private val logger = LoggerFactory.getLogger(this::class.java)
-    override val name: String = "add"
-    override val command = Commands.slash(name, "명령어를 추가합니다.")
-        .addOptions(OptionData(OptionType.STRING, "label", "작동할 명령어를 입력하세요.", true))
-        .addOptions(OptionData(OptionType.STRING, "content", "표시될 텍스트를 입력하세요.", true))
-        .addOptions(OptionData(OptionType.STRING, "fail_content", "카운터 업데이트 실패시 표시될 텍스트를 입력하세요.", false))
-
-    override fun run(event: SlashCommandInteractionEvent, bot: JDA) {
-        val label = event.getOption("label")?.asString
-        val content = event.getOption("content")?.asString
-        val failContent = event.getOption("fail_content")?.asString
-
-        if(label == null || content == null) {
-            event.hook.sendMessage("명령어와 텍스트는 필수 입력입니다.").queue()
-            return
-        }
-
-        var user = UserService.getUser(event.user.idLong)
-        val manager = event.guild?.idLong?.let { ManagerService.getUser(it, event.user.idLong) }
-        if(user == null && manager == null) {
-            event.hook.sendMessage("당신은 이 명령어를 사용할 수 없습니다.").queue()
-            return
-        }
-
-        if (manager != null) {
-            user = manager.user
-            ManagerService.updateManager(user, event.user.idLong, event.user.effectiveName)
-        }
-
-        val commands = CommandService.getCommands(user!!)
-        if (commands.any { it.command == label }) {
-            event.hook.sendMessage("$label 명령어는 이미 있습니다! 업데이트 명령어를 써주세요.").queue()
-            return
-        }
-
-        val chzzkChannel = Connector.getChannel(user.token)
-
-        try {
-            CommandService.saveCommand(user, label, content, failContent ?: "")
-            try {
-                ChzzkHandler.reloadCommand(chzzkChannel!!)
-            } catch (_: Exception) {}
-            event.hook.sendMessage("등록이 완료되었습니다. $label = $content/$failContent").queue()
-        } catch (e: Exception) {
-            event.hook.sendMessage("에러가 발생했습니다.").queue()
-            logger.debug(e.stackTraceToString())
-        }
-    }
-}

src/main/kotlin/space/mori/chzzk_bot/discord/commands/AddManagerCommand.kt

@@ -1,47 +0,0 @@
-package space.mori.chzzk_bot.discord.commands
-
-import net.dv8tion.jda.api.JDA
-import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
-import net.dv8tion.jda.api.interactions.commands.OptionType
-import net.dv8tion.jda.api.interactions.commands.build.Commands
-import net.dv8tion.jda.api.interactions.commands.build.OptionData
-import org.slf4j.LoggerFactory
-import space.mori.chzzk_bot.discord.CommandInterface
-import space.mori.chzzk_bot.services.ManagerService
-import space.mori.chzzk_bot.services.UserService
-
-object AddManagerCommand : CommandInterface {
-    private val logger = LoggerFactory.getLogger(this::class.java)
-    override val name: String = "addmanager"
-    override val command = Commands.slash(name, "매니저를 추가합니다.")
-        .addOptions(OptionData(OptionType.USER, "user", "추가할 유저를 선택하세요.", true))
-
-    override fun run(event: SlashCommandInteractionEvent, bot: JDA) {
-        val manager = event.getOption("user")?.asUser
-
-        if(manager == null) {
-            event.hook.sendMessage("유저는 필수사항입니다.").queue()
-            return
-        }
-        if(manager.idLong == event.user.idLong) {
-            event.hook.sendMessage("자신은 매니저로 설정할 수 없습니다.").queue()
-            return
-        }
-
-        val user = UserService.getUser(event.user.idLong)
-        if(user == null) {
-            event.hook.sendMessage("치지직 계정을 찾을 수 없습니다.").queue()
-            return
-        }
-
-        try {
-            ManagerService.saveManager(user, manager.idLong, manager.effectiveName)
-            if(user.liveAlertGuild == null)
-                UserService.updateLiveAlert(user.id.value, event.guild!!.idLong, event.channelIdLong, "")
-            event.hook.sendMessage("등록이 완료되었습니다. ${manager.effectiveName}").queue()
-        } catch (e: Exception) {
-            event.hook.sendMessage("에러가 발생했습니다.").queue()
-            logger.debug(e.stackTraceToString())
-        }
-    }
-}

src/main/kotlin/space/mori/chzzk_bot/discord/commands/AlertCommand.kt

@@ -1,51 +0,0 @@
-package space.mori.chzzk_bot.discord.commands
-
-import net.dv8tion.jda.api.JDA
-import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
-import net.dv8tion.jda.api.interactions.commands.OptionType
-import net.dv8tion.jda.api.interactions.commands.build.Commands
-import net.dv8tion.jda.api.interactions.commands.build.OptionData
-import org.slf4j.LoggerFactory
-import space.mori.chzzk_bot.chzzk.ChzzkHandler
-import space.mori.chzzk_bot.chzzk.Connector
-import space.mori.chzzk_bot.discord.CommandInterface
-import space.mori.chzzk_bot.services.ManagerService
-import space.mori.chzzk_bot.services.UserService
-
-object AlertCommand : CommandInterface {
-    private val logger = LoggerFactory.getLogger(this::class.java)
-    override val name: String = "alert"
-    override val command = Commands.slash(name, "명령어를 추가합니다.")
-        .addOptions(OptionData(OptionType.CHANNEL, "channel", "알림을 보낼 채널을 입력하세요."))
-        .addOptions(OptionData(OptionType.STRING, "content", "표시될 텍스트를 입력하세요. 비워두면 알람이 취소됩니다."))
-
-    override fun run(event: SlashCommandInteractionEvent, bot: JDA) {
-        val channel = event.getOption("channel")?.asChannel
-        val content = event.getOption("content")?.asString
-
-        var user = UserService.getUser(event.user.idLong)
-        val manager = event.guild?.idLong?.let { ManagerService.getUser(it, event.user.idLong) }
-        if(user == null && manager == null) {
-            event.hook.sendMessage("당신은 이 명령어를 사용할 수 없습니다.").queue()
-            return
-        }
-
-        if (manager != null) {
-            user = manager.user
-            ManagerService.updateManager(user, event.user.idLong, event.user.effectiveName)
-        }
-
-        val chzzkChannel = Connector.getChannel(user!!.token)
-
-        try {
-            val newUser = UserService.updateLiveAlert(user.id.value, channel?.guild?.idLong ?: 0L, channel?.idLong ?: 0L, content ?: "")
-            try {
-                ChzzkHandler.reloadUser(chzzkChannel!!, newUser)
-            } catch (_: Exception) {}
-            event.hook.sendMessage("업데이트가 완료되었습니다.").queue()
-        } catch (e: Exception) {
-            event.hook.sendMessage("에러가 발생했습니다.").queue()
-            logger.debug(e.stackTraceToString())
-        }
-    }
-}

src/main/kotlin/space/mori/chzzk_bot/discord/commands/ListManagerCommand.kt

@@ -1,44 +0,0 @@
-package space.mori.chzzk_bot.discord.commands
-
-import net.dv8tion.jda.api.EmbedBuilder
-import net.dv8tion.jda.api.JDA
-import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
-import net.dv8tion.jda.api.interactions.commands.build.Commands
-import org.slf4j.LoggerFactory
-import space.mori.chzzk_bot.discord.CommandInterface
-import space.mori.chzzk_bot.services.ManagerService
-import space.mori.chzzk_bot.services.UserService
-
-object ListManagerCommand : CommandInterface {
-    private val logger = LoggerFactory.getLogger(this::class.java)
-    override val name: String = "listmanager"
-    override val command = Commands.slash(name, "매니저 목록을 확인합니다.")
-
-    override fun run(event: SlashCommandInteractionEvent, bot: JDA) {
-        try {
-            val managers = event.guild?.idLong?.let { ManagerService.getAllUsers(it) }
-
-            if(managers == null) {
-                event.channel.sendMessage("여기에서는 사용할 수 없습니다.")
-                return
-            }
-
-            val user = UserService.getUserWithGuildId(event.guild!!.idLong)
-
-            val embed = EmbedBuilder()
-            embed.setTitle("${user!!.username} 매니저 목록")
-            embed.setDescription("매니저 목록입니다.")
-
-            var idx = 1
-
-            managers.forEach {
-                embed.addField("${idx++}", it.lastUserName ?: it.managerId.toString(), true)
-            }
-
-            event.channel.sendMessageEmbeds(embed.build()).queue()
-        } catch (e: Exception) {
-            event.hook.sendMessage("에러가 발생했습니다.").queue()
-            logger.debug(e.stackTraceToString())
-        }
-    }
-}

src/main/kotlin/space/mori/chzzk_bot/discord/commands/PingCommand.kt

@@ -1,17 +0,0 @@
-package space.mori.chzzk_bot.discord.commands
-
-import net.dv8tion.jda.api.JDA
-import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
-import net.dv8tion.jda.api.interactions.commands.build.Commands
-import org.slf4j.LoggerFactory
-import space.mori.chzzk_bot.discord.CommandInterface
-
-object PingCommand: CommandInterface {
-    private val logger = LoggerFactory.getLogger(this::class.java)
-    override val name = "ping"
-    override val command = Commands.slash(name, "봇이 살아있을까요?")
-
-    override fun run(event: SlashCommandInteractionEvent, bot: JDA) {
-        event.hook.sendMessage("${event.user.asMention} Pong!").queue()
-    }
-}

src/main/kotlin/space/mori/chzzk_bot/discord/commands/RegisterCommand.kt

@@ -1,49 +0,0 @@
-package space.mori.chzzk_bot.discord.commands
-
-import net.dv8tion.jda.api.JDA
-import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
-import net.dv8tion.jda.api.interactions.commands.OptionType
-import net.dv8tion.jda.api.interactions.commands.build.Commands
-import net.dv8tion.jda.api.interactions.commands.build.OptionData
-import org.slf4j.LoggerFactory
-import space.mori.chzzk_bot.chzzk.ChzzkHandler
-import space.mori.chzzk_bot.chzzk.Connector
-import space.mori.chzzk_bot.discord.CommandInterface
-import space.mori.chzzk_bot.services.UserService
-
-object RegisterCommand: CommandInterface {
-    private val logger = LoggerFactory.getLogger(this::class.java)
-    override val name = "register"
-    override val command =  Commands.slash(name, "치지직 계정을 등록합니다.")
-        .addOptions(
-            OptionData(
-                OptionType.STRING,
-                "chzzk_id",
-                "36da10b7c35800f298e9c565a396bafd 형식으로 입력해주세요.",
-                true
-            )
-        )
-
-    override fun run(event: SlashCommandInteractionEvent, bot: JDA) {
-        val chzzkID = event.getOption("chzzk_id")?.asString
-        if(chzzkID == null) {
-            event.hook.sendMessage("치지직 계정은 필수 입력입니다.").queue()
-            return
-        }
-
-        val chzzkChannel = Connector.getChannel(chzzkID)
-        if (chzzkChannel == null) {
-            event.hook.sendMessage("치지직 계정을 찾을 수 없습니다.").queue()
-            return
-        }
-
-        try {
-            val user = UserService.saveUser(chzzkChannel.channelName, chzzkChannel.channelId, event.user.idLong)
-            event.hook.sendMessage("등록이 완료되었습니다. `${chzzkChannel.channelId}` - `${chzzkChannel.channelName}`")
-            ChzzkHandler.addUser(chzzkChannel, user)
-        } catch(e: Exception) {
-            event.hook.sendMessage("에러가 발생했습니다.").queue()
-            logger.debug(e.stackTraceToString())
-        }
-    }
-}

src/main/kotlin/space/mori/chzzk_bot/discord/commands/RemoveCommand.kt

@@ -1,55 +0,0 @@
-package space.mori.chzzk_bot.discord.commands
-
-import net.dv8tion.jda.api.JDA
-import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
-import net.dv8tion.jda.api.interactions.commands.OptionType
-import net.dv8tion.jda.api.interactions.commands.build.Commands
-import net.dv8tion.jda.api.interactions.commands.build.OptionData
-import org.slf4j.LoggerFactory
-import space.mori.chzzk_bot.chzzk.ChzzkHandler
-import space.mori.chzzk_bot.chzzk.Connector
-import space.mori.chzzk_bot.discord.CommandInterface
-import space.mori.chzzk_bot.services.CommandService
-import space.mori.chzzk_bot.services.ManagerService
-import space.mori.chzzk_bot.services.UserService
-
-object RemoveCommand : CommandInterface {
-    private val logger = LoggerFactory.getLogger(this::class.java)
-    override val name: String = "remove"
-    override val command = Commands.slash(name, "명령어를 삭제합니다.")
-        .addOptions(OptionData(OptionType.STRING, "label", "삭제할 명령어를 입력하세요.", true))
-
-    override fun run(event: SlashCommandInteractionEvent, bot: JDA) {
-        val label = event.getOption("label")?.asString
-
-        if(label == null) {
-            event.hook.sendMessage("명령어는 필수 입력입니다.").queue()
-            return
-        }
-
-        var user = UserService.getUser(event.user.idLong)
-        val manager = event.guild?.idLong?.let { ManagerService.getUser(it, event.user.idLong) }
-        if(user == null && manager == null) {
-            event.hook.sendMessage("당신은 이 명령어를 사용할 수 없습니다.").queue()
-            return
-        }
-
-        if (manager != null) {
-            user = manager.user
-            ManagerService.updateManager(user, event.user.idLong, event.user.effectiveName)
-        }
-
-        val chzzkChannel = Connector.getChannel(user!!.token)
-
-        try {
-            CommandService.removeCommand(user, label)
-            try {
-                ChzzkHandler.reloadCommand(chzzkChannel!!)
-            } catch (_: Exception) {}
-            event.hook.sendMessage("삭제가 완료되었습니다. $label").queue()
-        } catch (e: Exception) {
-            event.hook.sendMessage("에러가 발생했습니다.").queue()
-            logger.debug(e.stackTraceToString())
-        }
-    }
-}

src/main/kotlin/space/mori/chzzk_bot/discord/commands/RemoveManagerCommand.kt

@@ -1,49 +0,0 @@
-package space.mori.chzzk_bot.discord.commands
-
-import net.dv8tion.jda.api.JDA
-import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
-import net.dv8tion.jda.api.interactions.commands.OptionType
-import net.dv8tion.jda.api.interactions.commands.build.Commands
-import net.dv8tion.jda.api.interactions.commands.build.OptionData
-import org.slf4j.LoggerFactory
-import space.mori.chzzk_bot.discord.CommandInterface
-import space.mori.chzzk_bot.services.ManagerService
-import space.mori.chzzk_bot.services.UserService
-
-object RemoveManagerCommand : CommandInterface {
-    private val logger = LoggerFactory.getLogger(this::class.java)
-    override val name: String = "removemanager"
-    override val command = Commands.slash(name, "매니저를 삭제합니다.")
-        .addOptions(OptionData(OptionType.USER, "user", "삭제할 유저를 선택하세요.", true))
-
-    override fun run(event: SlashCommandInteractionEvent, bot: JDA) {
-        val manager = event.getOption("user")?.asUser
-
-        if(manager == null) {
-            event.hook.sendMessage("유저는 필수사항입니다.").queue()
-            return
-        }
-        if(manager.idLong == event.user.idLong) {
-            event.hook.sendMessage("자신은 매니저로 설정할 수 없습니다.").queue()
-            return
-        }
-
-        val user = UserService.getUser(event.user.idLong)
-        if(user == null) {
-            event.hook.sendMessage("치지직 계정을 찾을 수 없습니다.").queue()
-            return
-        }
-
-        if(ManagerService.getUser(user.liveAlertGuild ?: 0L, manager.idLong) == null) {
-            event.hook.sendMessage("${manager.name}은 매니저가 아닙니다.")
-        }
-
-        try {
-            ManagerService.deleteManager(user, manager.idLong)
-            event.hook.sendMessage("삭제가 완료되었습니다. ${manager.effectiveName}").queue()
-        } catch (e: Exception) {
-            event.hook.sendMessage("에러가 발생했습니다.").queue()
-            logger.debug(e.stackTraceToString())
-        }
-    }
-}

src/main/kotlin/space/mori/chzzk_bot/discord/commands/UpdateCommand.kt

@@ -1,57 +0,0 @@
-package space.mori.chzzk_bot.discord.commands
-
-import net.dv8tion.jda.api.JDA
-import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
-import net.dv8tion.jda.api.interactions.commands.OptionType
-import net.dv8tion.jda.api.interactions.commands.build.Commands
-import net.dv8tion.jda.api.interactions.commands.build.OptionData
-import org.slf4j.LoggerFactory
-import space.mori.chzzk_bot.chzzk.ChzzkHandler
-import space.mori.chzzk_bot.chzzk.Connector
-import space.mori.chzzk_bot.discord.CommandInterface
-import space.mori.chzzk_bot.services.CommandService
-import space.mori.chzzk_bot.services.ManagerService
-import space.mori.chzzk_bot.services.UserService
-
-object UpdateCommand : CommandInterface {
-    private val logger = LoggerFactory.getLogger(this::class.java)
-    override val name: String = "update"
-    override val command = Commands.slash(name, "명령어를 수정합니다.")
-        .addOptions(OptionData(OptionType.STRING, "label", "수정할 명령어를 입력하세요.", true))
-        .addOptions(OptionData(OptionType.STRING, "content", "표시될 텍스트를 입력하세요.", true))
-        .addOptions(OptionData(OptionType.STRING, "fail_content", "카운터 업데이트 실패시 표시될 텍스트를 입력하세요.", false))
-
-    override fun run(event: SlashCommandInteractionEvent, bot: JDA) {
-        val label = event.getOption("label")?.asString
-        val content = event.getOption("content")?.asString
-        val failContent = event.getOption("fail_content")?.asString
-
-        if(label == null || content == null) {
-            event.hook.sendMessage("명령어와 텍스트는 필수 입력입니다.").queue()
-            return
-        }
-
-        var user = UserService.getUser(event.user.idLong)
-        val manager = event.guild?.idLong?.let { ManagerService.getUser(it, event.user.idLong) }
-        if(user == null && manager == null) {
-            event.hook.sendMessage("당신은 이 명령어를 사용할 수 없습니다.").queue()
-            return
-        }
-
-        if (manager != null) {
-            user = manager.user
-            ManagerService.updateManager(user, event.user.idLong, event.user.effectiveName)
-        }
-
-        val chzzkChannel = Connector.getChannel(user!!.token)
-
-        try {
-            CommandService.updateCommand(user, label, content, failContent ?: "")
-            chzzkChannel?.let { ChzzkHandler.reloadCommand(it) }
-            event.hook.sendMessage("등록이 완료되었습니다. $label = $content").queue()
-        } catch (e: Exception) {
-            event.hook.sendMessage("에러가 발생했습니다.").queue()
-            logger.debug(e.stackTraceToString())
-        }
-    }
-}

src/main/kotlin/space/mori/chzzk_bot/models/Command.kt

@@ -1,23 +0,0 @@
-package space.mori.chzzk_bot.models
-
-import org.jetbrains.exposed.dao.IntEntity
-import org.jetbrains.exposed.dao.IntEntityClass
-import org.jetbrains.exposed.dao.id.EntityID
-import org.jetbrains.exposed.dao.id.IntIdTable
-import org.jetbrains.exposed.sql.ReferenceOption
-
-object Commands: IntIdTable("commands") {
-    val user = reference("user", Users, onDelete = ReferenceOption.CASCADE)
-    val command = varchar("command", 255)
-    val content = text("content")
-    val failContent = text("fail_content")
-}
-
-class Command(id: EntityID<Int>) : IntEntity(id) {
-    companion object : IntEntityClass<Command>(Commands)
-
-    var user by User referencedOn Commands.user
-    var command by Commands.command
-    var content by Commands.content
-    var failContent by Commands.failContent
-}

src/main/kotlin/space/mori/chzzk_bot/models/Counter.kt

@@ -1,20 +0,0 @@
-package space.mori.chzzk_bot.models
-
-import org.jetbrains.exposed.dao.IntEntity
-import org.jetbrains.exposed.dao.IntEntityClass
-import org.jetbrains.exposed.dao.id.EntityID
-import org.jetbrains.exposed.dao.id.IntIdTable
-
-object Counters: IntIdTable("counters") {
-    val name = varchar("name", 255)
-    val value = integer("value")
-    val user = reference("streamer", Users)
-}
-
-class Counter(id: EntityID<Int>) : IntEntity(id) {
-    companion object : IntEntityClass<Counter>(Counters)
-
-    var name by Counters.name
-    var value by Counters.value
-    var user by User referencedOn Counters.user
-}

src/main/kotlin/space/mori/chzzk_bot/models/DailyCounters.kt

@@ -1,25 +0,0 @@
-package space.mori.chzzk_bot.models
-
-import org.jetbrains.exposed.dao.IntEntity
-import org.jetbrains.exposed.dao.IntEntityClass
-import org.jetbrains.exposed.dao.id.EntityID
-import org.jetbrains.exposed.dao.id.IntIdTable
-import org.jetbrains.exposed.sql.javatime.date
-
-object DailyCounters: IntIdTable("daily_counters") {
-    val name = varchar("name", 255)
-    val userId = varchar("user_id", 64)
-    val value = integer("value")
-    val updatedAt = date("updated_at")
-    val user = reference("streamer", Users)
-}
-
-class DailyCounter(id: EntityID<Int>) : IntEntity(id) {
-    companion object : IntEntityClass<DailyCounter>(DailyCounters)
-
-    var name by DailyCounters.name
-    var userId by DailyCounters.userId
-    var value by DailyCounters.value
-    var updatedAt by DailyCounters.updatedAt
-    var user by User referencedOn DailyCounters.user
-}

src/main/kotlin/space/mori/chzzk_bot/models/Manager.kt

@@ -1,22 +0,0 @@
-package space.mori.chzzk_bot.models
-
-import org.jetbrains.exposed.dao.IntEntity
-import org.jetbrains.exposed.dao.IntEntityClass
-import org.jetbrains.exposed.dao.id.EntityID
-import org.jetbrains.exposed.dao.id.IntIdTable
-
-object Managers: IntIdTable("manager") {
-    val user = reference("user", Users)
-    val managerId = long("manager_id")
-    val discordGuildId = long("discord_guild_id")
-    var lastUserName = varchar("last_user_name", 255).nullable()
-}
-
-class Manager(id: EntityID<Int>) : IntEntity(id) {
-    companion object : IntEntityClass<Manager>(Managers)
-
-    var user by User referencedOn Managers.user
-    var managerId by Managers.managerId
-    var discordGuildId by Managers.discordGuildId
-    var lastUserName by Managers.lastUserName
-}

src/main/kotlin/space/mori/chzzk_bot/models/PersonalCounter.kt

@@ -1,22 +0,0 @@
-package space.mori.chzzk_bot.models
-
-import org.jetbrains.exposed.dao.IntEntity
-import org.jetbrains.exposed.dao.IntEntityClass
-import org.jetbrains.exposed.dao.id.EntityID
-import org.jetbrains.exposed.dao.id.IntIdTable
-
-object PersonalCounters: IntIdTable("personal_counters") {
-    val name = varchar("name", 255)
-    val userId = varchar("user_id", 64)
-    val value = integer("value")
-    val user = reference("streamer", Users)
-}
-
-class PersonalCounter(id: EntityID<Int>) : IntEntity(id) {
-    companion object : IntEntityClass<PersonalCounter>(PersonalCounters)
-
-    var name by PersonalCounters.name
-    var userId by PersonalCounters.userId
-    var value by PersonalCounters.value
-    var user by User referencedOn PersonalCounters.user
-}

src/main/kotlin/space/mori/chzzk_bot/models/User.kt

@@ -1,27 +0,0 @@
-package space.mori.chzzk_bot.models
-
-import org.jetbrains.exposed.dao.IntEntity
-import org.jetbrains.exposed.dao.IntEntityClass
-import org.jetbrains.exposed.dao.id.EntityID
-import org.jetbrains.exposed.dao.id.IntIdTable
-
-
-object Users: IntIdTable("users") {
-    val username = varchar("username", 255)
-    val token = varchar("token", 64)
-    val discord = long("discord")
-    val liveAlertGuild = long("live_alert_guild").nullable()
-    val liveAlertChannel = long("live_alert_channel").nullable()
-    val liveAlertMessage = text("live_alert_message").nullable()
-}
-
-class User(id: EntityID<Int>) : IntEntity(id) {
-    companion object : IntEntityClass<User>(Users)
-
-    var username by Users.username
-    var token by Users.token
-    var discord by Users.discord
-    var liveAlertGuild by Users.liveAlertGuild
-    var liveAlertChannel by Users.liveAlertChannel
-    var liveAlertMessage by Users.liveAlertMessage
-}

src/main/kotlin/space/mori/chzzk_bot/services/CommandService.kt

@@ -1,59 +0,0 @@
-package space.mori.chzzk_bot.services
-
-import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
-import org.jetbrains.exposed.sql.and
-import org.jetbrains.exposed.sql.transactions.transaction
-import org.jetbrains.exposed.sql.update
-import space.mori.chzzk_bot.models.Command
-import space.mori.chzzk_bot.models.Commands
-import space.mori.chzzk_bot.models.User
-
-object CommandService {
-    fun saveCommand(user: User, command: String, content: String, failContent: String): Command {
-        return transaction {
-            return@transaction Command.new {
-                this.user = user
-                this.command = command
-                this.content = content
-                this.failContent = failContent
-            }
-        }
-    }
-
-    fun removeCommand(user: User, command: String): Command? {
-        return transaction {
-            val commandRow = Command.find(Commands.user eq user.id and(Commands.command eq command)).firstOrNull()
-
-            commandRow ?: throw RuntimeException("Command not found! $command")
-            commandRow.delete()
-
-           commandRow
-        }
-    }
-
-    fun updateCommand(user: User, command: String, content: String, failContent: String): Command {
-        return transaction {
-            val updated = Commands.update({Commands.user eq user.id and(Commands.command eq command)}) {
-                it[Commands.content] = content
-                it[Commands.failContent] = failContent
-            }
-
-            if(updated == 0) throw RuntimeException("Command not found! $command")
-
-            Command.find(Commands.user eq user.id and(Commands.command eq command)).first()
-        }
-    }
-
-    fun getCommand(id: Int): Command? {
-        return transaction {
-            Command.findById(id)
-        }
-    }
-
-    fun getCommands(user: User): List<Command> {
-        return transaction {
-            Command.find(Commands.user eq user.id)
-                .toList()
-        }
-    }
-}

src/main/kotlin/space/mori/chzzk_bot/services/CounterService.kt

@@ -1,104 +0,0 @@
-package space.mori.chzzk_bot.services
-
-import org.jetbrains.exposed.sql.and
-import org.jetbrains.exposed.sql.transactions.transaction
-import space.mori.chzzk_bot.models.*
-import java.time.LocalDate
-
-object CounterService {
-    fun getCounterValue(name: String, user: User): Int {
-        return transaction {
-            Counter.find {
-                (Counters.name eq name) and (Counters.user eq user.id)
-            }.singleOrNull()?.value ?: 0
-        }
-    }
-
-    fun updateCounterValue(name: String, increment: Int, user: User): Int {
-        return transaction {
-            val counter = Counter.find {
-                (Counters.name eq name) and (Counters.user eq user.id) }.singleOrNull()
-            return@transaction if (counter != null) {
-                counter.value += increment
-                counter.value
-            } else {
-                val newCounter = Counter.new {
-                    this.name = name
-                    this.value = increment
-                    this.user = user
-                }
-                newCounter.value
-            }
-        }
-    }
-
-    fun getPersonalCounterValue(name: String, userId: String, user: User): Int {
-        return transaction {
-            PersonalCounter.find {
-                (PersonalCounters.name eq name) and (PersonalCounters.userId eq userId) and (PersonalCounters.user eq user.id)
-            }.singleOrNull()?.value ?: 0
-        }
-    }
-
-    fun updatePersonalCounterValue(name: String, userId: String, increment: Int, user: User): Int {
-        return transaction {
-            val counter = PersonalCounter.find {
-                (PersonalCounters.name eq name) and (PersonalCounters.userId eq userId) and (PersonalCounters.user eq user.id)
-            }.singleOrNull()
-
-            return@transaction if (counter != null) {
-                counter.value += increment
-                counter.value
-            } else {
-                val newCounter = PersonalCounter.new {
-                    this.name = name
-                    this.value = increment
-                    this.userId = userId
-                    this.user = user
-                }
-                newCounter.value
-            }
-        }
-    }
-
-    fun getDailyCounterValue(name: String, userId: String, user: User): Pair<Int, Boolean> {
-        val today = LocalDate.now()
-
-        return transaction {
-            val counter = DailyCounter.find {
-                (DailyCounters.name eq name) and (DailyCounters.userId eq userId) and (DailyCounters.user eq user.id)
-            }.singleOrNull()
-
-            Pair(counter?.value ?: 0, counter?.updatedAt != today)
-        }
-    }
-
-    fun updateDailyCounterValue(name: String, userId: String, increment: Int, user: User): Pair<Int, Boolean> {
-        val today = LocalDate.now()
-
-        return transaction {
-            val counter = DailyCounter.find {
-                (DailyCounters.name eq name) and (DailyCounters.userId eq userId) and (DailyCounters.user eq user.id)
-            }.singleOrNull()
-
-            if(counter == null) {
-                val newCounter = DailyCounter.new {
-                    this.name = name
-                    this.value = increment
-                    this.userId = userId
-                    this.updatedAt = today
-                    this.user = user
-                }
-                return@transaction Pair(newCounter.value, true)
-            }
-
-            return@transaction if(counter.updatedAt == today)
-                Pair(counter.value, false)
-            else {
-                counter.value += increment
-                counter.updatedAt = today
-                Pair(counter.value, true)
-            }
-        }
-    }
-}

src/main/kotlin/space/mori/chzzk_bot/services/ManagerService.kt

@@ -1,70 +0,0 @@
-package space.mori.chzzk_bot.services
-
-import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
-import org.jetbrains.exposed.sql.and
-import org.jetbrains.exposed.sql.transactions.transaction
-import space.mori.chzzk_bot.models.Manager
-import space.mori.chzzk_bot.models.Managers
-import space.mori.chzzk_bot.models.User
-
-object ManagerService {
-    fun saveManager(user: User, discordId: Long, name: String): Manager {
-        if (user.liveAlertGuild == null)
-            throw RuntimeException("${user.username} has no liveAlertGuild")
-
-        return transaction {
-            Manager.new {
-                this.user = user
-                this.discordGuildId = user.liveAlertGuild!!
-                this.managerId = discordId
-                this.lastUserName = name
-            }
-        }
-    }
-
-    fun updateManager(user: User, discordId: Long, name: String): Manager {
-        if (user.liveAlertGuild == null)
-            throw RuntimeException("${user.username} has no liveAlertGuild")
-
-        val manager = getUser(user.liveAlertGuild!!, discordId)
-
-        if (manager == null)
-            throw RuntimeException("$name isn't manager.")
-        manager.lastUserName = name
-
-        return manager
-    }
-
-    fun getUser(guildId: Long, discordId: Long): Manager? {
-        return transaction {
-            val manager = Manager.find(
-                (Managers.discordGuildId eq guildId) and (Managers.managerId eq discordId)
-            )
-
-            manager.firstOrNull()
-        }
-    }
-
-    fun getAllUsers(guildId: Long): List<Manager> {
-        return transaction {
-            Manager.find(Managers.discordGuildId eq guildId).toList()
-        }
-    }
-
-    fun deleteManager(user: User, discordId: Long): Manager {
-        if (user.liveAlertGuild == null)
-            throw RuntimeException("${user.username} has no liveAlertGuild")
-        return deleteManager(user.liveAlertGuild!!, discordId)
-    }
-
-    fun deleteManager(guildId: Long, discordId: Long): Manager {
-        return transaction {
-            val managerRow = Manager.find((Managers.discordGuildId eq guildId) and (Managers.managerId eq discordId)).firstOrNull()
-
-            managerRow ?: throw RuntimeException("Manager not found! $discordId")
-            managerRow.delete()
-
-            managerRow
-        }
-    }
-}

src/main/kotlin/space/mori/chzzk_bot/services/UserService.kt

@@ -1,70 +0,0 @@
-package space.mori.chzzk_bot.services
-
-import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
-import org.jetbrains.exposed.sql.transactions.transaction
-import org.jetbrains.exposed.sql.update
-import space.mori.chzzk_bot.models.User
-import space.mori.chzzk_bot.models.Users
-
-object UserService {
-    fun saveUser(username: String, token: String, discordID: Long): User {
-        return transaction {
-            User.new {
-                this.username = username
-                this.token = token
-                this.discord = discordID
-            }
-        }
-    }
-
-    fun getUser(id: Int): User? {
-        return transaction {
-            User.findById(id)
-        }
-    }
-
-    fun getUser(discordID: Long): User? {
-        return transaction {
-            val users = User.find(Users.discord eq discordID)
-
-            users.firstOrNull()
-        }
-    }
-
-    fun getUser(chzzkID: String): User? {
-        return transaction {
-            val users = User.find(Users.token eq chzzkID)
-
-            users.firstOrNull()
-        }
-    }
-
-    fun getUserWithGuildId(discordGuildId: Long): User? {
-        return transaction {
-            val users = User.find(Users.liveAlertGuild eq discordGuildId)
-
-            users.firstOrNull()
-        }
-    }
-
-    fun getAllUsers(): List<User> {
-        return transaction {
-            User.all().toList()
-        }
-    }
-
-    fun updateLiveAlert(id: Int, guildId: Long, channelId: Long, alertMessage: String?): User {
-        return transaction {
-            val updated = Users.update({ Users.id eq id }) {
-                it[liveAlertGuild] = guildId
-                it[liveAlertChannel] = channelId
-                it[liveAlertMessage] = alertMessage ?: ""
-            }
-
-            if(updated == 0) throw RuntimeException("User not found! $id")
-            val users = User.find { Users.id eq id }
-
-            return@transaction users.first()
-        }
-    }
-}