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

@@ -1,14 +1,19 @@
 package space.mori.chzzk_bot.chatbot.chzzk
 
+import com.google.gson.Gson
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.future.await
 import kotlinx.coroutines.launch
+import okhttp3.OkHttpClient
 import org.koin.java.KoinJavaComponent.inject
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
+import space.mori.chzzk_bot.chatbot.chzzk.Connector.client as ChzzkClient
 import space.mori.chzzk_bot.chatbot.chzzk.Connector.getChannel
 import space.mori.chzzk_bot.chatbot.discord.Discord
+import space.mori.chzzk_bot.chatbot.utils.refreshAccessToken
 import space.mori.chzzk_bot.common.events.*
 import space.mori.chzzk_bot.common.models.User
 import space.mori.chzzk_bot.common.services.LiveStatusService
@@ -16,12 +21,12 @@ import space.mori.chzzk_bot.common.services.TimerConfigService
 import space.mori.chzzk_bot.common.services.UserService
 import space.mori.chzzk_bot.common.utils.*
 import xyz.r2turntrue.chzzk4j.ChzzkClient
+import xyz.r2turntrue.chzzk4j.auth.ChzzkSimpleUserLoginAdapter
 import xyz.r2turntrue.chzzk4j.session.ChzzkSessionBuilder
 import xyz.r2turntrue.chzzk4j.session.ChzzkSessionSubscriptionType
 import xyz.r2turntrue.chzzk4j.session.ChzzkUserSession
 import xyz.r2turntrue.chzzk4j.session.event.SessionChatMessageEvent
 import xyz.r2turntrue.chzzk4j.types.channel.ChzzkChannel
-import xyz.r2turntrue.chzzk4j.types.channel.live.ChzzkLiveStatus
 import java.lang.Exception
 import java.net.SocketTimeoutException
 import java.time.LocalDateTime
@@ -38,7 +43,6 @@ object ChzzkHandler {
     }
 
     fun enable() {
-        botUid = Connector.client.fetchLoggedUser().userId
         UserService.getAllUsers().map {
             if(!it.isDisabled)
                 try {
@@ -49,8 +53,8 @@ object ChzzkHandler {
         }
 
         handlers.forEach { handler ->
-            val streamInfo = Connector.getLive(handler.channel.channelId)
-            if (streamInfo?.isOnline == true) handler.isActive(true, streamInfo)
+            val streamInfo = getStreamInfo(handler.channel.channelId)
+            if (streamInfo.content?.status == "OPEN") handler.isActive(true, streamInfo)
         }
 
         dispatcher.subscribe(UserRegisterEvent::class) {
@@ -109,15 +113,15 @@ object ChzzkHandler {
                 handlers.forEach {
                     if (!running) return@forEach
                     try {
-                        val streamInfo = Connector.getLive(it.channel.channelId)
-                        if (streamInfo?.isOnline == true && !it.isActive) {
+                        val streamInfo = getStreamInfo(it.channel.channelId)
+                        if (streamInfo.content?.status == "OPEN" && !it.isActive) {
                             try {
                                 it.isActive(true, streamInfo)
                             } catch(e: Exception) {
                                 logger.info("Exception: ${e.stackTraceToString()}")
                             }
                         }
-                        if (streamInfo?.isOnline == false && it.isActive) it.isActive(false, streamInfo)
+                        if (streamInfo.content?.status == "CLOSE" && it.isActive) it.isActive(false, streamInfo)
                     } catch (e: SocketTimeoutException) {
                         logger.info("Thread 1 Timeout: ${it.channel.channelName} / ${e.stackTraceToString()}")
                     } catch (e: Exception) {
@@ -137,19 +141,19 @@ object ChzzkHandler {
                 handlers.forEach {
                     if (!running) return@forEach
                     try {
-                        val streamInfo = Connector.getLive(it.channel.channelId)
-                        if (streamInfo?.isOnline == true && !it.isActive) {
+                        val streamInfo = getStreamInfo(it.channel.channelId)
+                        if (streamInfo.content?.status == "OPEN" && !it.isActive) {
                             try {
                                 it.isActive(true, streamInfo)
                             } catch(e: Exception) {
                                 logger.info("Exception: ${e.stackTraceToString()}")
                             }
                         }
-                        if (streamInfo?.isOnline == false && it.isActive) it.isActive(false, streamInfo)
+                        if (streamInfo.content?.status == "CLOSE" && it.isActive) it.isActive(false, streamInfo)
                     } catch (e: SocketTimeoutException) {
-                        logger.info("Thread 1 Timeout: ${it.channel.channelName} / ${e.stackTraceToString()}")
+                        logger.info("Thread 2 Timeout: ${it.channel.channelName} / ${e.stackTraceToString()}")
                     } catch (e: Exception) {
-                        logger.info("Thread 1 Exception: ${it.channel.channelName} / ${e.stackTraceToString()}")
+                        logger.info("Thread 2 Exception: ${it.channel.channelName} / ${e.stackTraceToString()}")
                     } finally {
                         Thread.sleep(5000)
                     }
@@ -200,8 +204,8 @@ class UserHandler(
     var streamStartTime: LocalDateTime?,
 ) {
     var messageHandler: MessageHandler
-    var client: ChzzkClient
-    var listener: ChzzkUserSession
+    lateinit var client: ChzzkClient
+    lateinit var listener: ChzzkUserSession
 
     private val dispatcher: CoroutinesEventBus by inject(CoroutinesEventBus::class.java)
     private var _isActive: Boolean
@@ -216,28 +220,20 @@ class UserHandler(
         if(user?.accessToken == null || user.refreshToken == null) {
             throw RuntimeException("AccessToken or RefreshToken is not valid.")
         }
-        try {
 
-            client = Connector.getClient(user.accessToken!!, user.refreshToken!!)
-
-            client.loginAsync().join()
-            client.refreshTokenAsync().join()
-
-            UserService.setRefreshToken(user, client.loginResult.accessToken(), client.loginResult.refreshToken())
+        val tokens = ChzzkClient.refreshAccessToken(user.refreshToken!!)
 
+        client = Connector.getClient(tokens.first, tokens.second)
         listener = ChzzkSessionBuilder(client).buildUserSession()
 
-            listener.createAndConnectAsync().join()
+        UserService.setRefreshToken(user, tokens.first, tokens.second)
 
-            messageHandler = MessageHandler(this@UserHandler)
+        listener.createAndConnectAsync().join()
 
         listener.on(SessionChatMessageEvent::class.java) {
             messageHandler.handle(it.message, user)
         }
-        } catch(e: Exception) {
-            logger.error("Exception(${user.username}): ${e.stackTraceToString()}")
-            throw RuntimeException("Exception: ${e.stackTraceToString()}")
-        }
+        messageHandler = MessageHandler(this@UserHandler)
     }
 
     internal fun disable() {
@@ -256,7 +252,7 @@ class UserHandler(
     internal val isActive: Boolean
         get() = _isActive
 
-    internal fun isActive(value: Boolean, status: ChzzkLiveStatus) {
+    internal fun isActive(value: Boolean, status: IData<IStreamInfo?>) {
         if(value) {
             CoroutineScope(Dispatchers.Default).launch {
                 logger.info("${user.username} is live.")
@@ -266,7 +262,7 @@ class UserHandler(
                 logger.info("ChzzkChat connecting... ${channel.channelName} - ${channel.channelId}")
                 listener.subscribeAsync(ChzzkSessionSubscriptionType.CHAT)
 
-                streamStartTime = LocalDateTime.now()
+                streamStartTime = status.content?.openDate?.let { convertChzzkDateToLocalDateTime(it) }
 
                 if(!_isActive) {
                     _isActive = true

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

@@ -1,56 +1,28 @@
 package space.mori.chzzk_bot.chatbot.chzzk
 
 import io.github.cdimascio.dotenv.dotenv
-import kotlinx.coroutines.DelicateCoroutinesApi
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.launch
-import org.koin.java.KoinJavaComponent.inject
 import org.slf4j.LoggerFactory
-import space.mori.chzzk_bot.common.events.ChzzkUserFindEvent
-import space.mori.chzzk_bot.common.events.ChzzkUserReceiveEvent
-import space.mori.chzzk_bot.common.events.CoroutinesEventBus
 import xyz.r2turntrue.chzzk4j.ChzzkClient
 import xyz.r2turntrue.chzzk4j.ChzzkClientBuilder
-import xyz.r2turntrue.chzzk4j.auth.ChzzkLegacyLoginAdapter
+import xyz.r2turntrue.chzzk4j.auth.ChzzkOauthLoginAdapter
 import xyz.r2turntrue.chzzk4j.auth.ChzzkSimpleUserLoginAdapter
 import xyz.r2turntrue.chzzk4j.types.channel.ChzzkChannel
-import xyz.r2turntrue.chzzk4j.types.channel.live.ChzzkLiveStatus
-import kotlin.getValue
 
 val dotenv = dotenv {
     ignoreIfMissing = true
 }
 
-@OptIn(DelicateCoroutinesApi::class)
 object Connector {
-    val adapter = ChzzkLegacyLoginAdapter(dotenv["NID_AUT"], dotenv["NID_SES"])
     val client: ChzzkClient = ChzzkClientBuilder(dotenv["NAVER_CLIENT_ID"], dotenv["NAVER_CLIENT_SECRET"])
-        .withLoginAdapter(adapter)
         .build()
     private val logger = LoggerFactory.getLogger(this::class.java)
-    private val dispatcher: CoroutinesEventBus by inject(CoroutinesEventBus::class.java)
 
     fun getChannel(channelId: String): ChzzkChannel? = client.fetchChannel(channelId)
-    fun getLive(channelId: String): ChzzkLiveStatus? = client.fetchLiveStatus(channelId)
 
     init {
         logger.info("chzzk logged: ${client.isLoggedIn}")
 
         client.loginAsync().join()
-
-        dispatcher.subscribe(ChzzkUserFindEvent::class) { event ->
-            GlobalScope.launch {
-                val user = getChannel(event.uid)
-
-                dispatcher.post(ChzzkUserReceiveEvent(
-                    find = user != null,
-                    uid = user?.channelId,
-                    nickname = user?.channelName,
-                    isStreamOn = user?.isBroadcasting,
-                    avatarUrl = user?.channelImageUrl
-                ))
-            }
-        }
     }
 
     fun getClient(accessToken: String, refreshToken: String): ChzzkClient {
@@ -61,6 +33,4 @@ object Connector {
 
         return client
     }
-
-
 }

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

@@ -12,11 +12,11 @@ import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEve
 import net.dv8tion.jda.api.hooks.ListenerAdapter
 import net.dv8tion.jda.api.utils.messages.MessageCreateBuilder
 import org.slf4j.LoggerFactory
+import space.mori.chzzk_bot.common.utils.IData
+import space.mori.chzzk_bot.common.utils.IStreamInfo
 import space.mori.chzzk_bot.chatbot.discord.commands.*
 import space.mori.chzzk_bot.common.models.User
-import xyz.r2turntrue.chzzk4j.types.channel.live.ChzzkLiveStatus
 import java.time.Instant
-import kotlin.jvm.optionals.getOrNull
 
 val dotenv = dotenv {
     ignoreIfMissing = true
@@ -33,19 +33,20 @@ class Discord: ListenerAdapter() {
             return bot.getGuildById(guildId)?.getTextChannelById(channelId)
         }
 
-        fun sendDiscord(user: User, status: ChzzkLiveStatus) {
+        fun sendDiscord(user: User, status: IData<IStreamInfo?>) {
+            if(status.content == null) return
             if(user.liveAlertMessage != null && user.liveAlertGuild != null && user.liveAlertChannel != null) {
                 val channel = getChannel(user.liveAlertGuild ?: 0, user.liveAlertChannel ?: 0)
                     ?: throw RuntimeException("${user.liveAlertChannel} is not valid.")
 
                 val embed = EmbedBuilder()
-                embed.setTitle(status.title, "https://chzzk.naver.com/live/${user.token}")
+                embed.setTitle(status.content!!.liveTitle, "https://chzzk.naver.com/live/${user.token}")
                 embed.setDescription("${user.username} 님이 방송을 시작했습니다.")
                 embed.setTimestamp(Instant.now())
-                embed.setAuthor(user.username, "https://chzzk.naver.com/live/${user.token}")
-                embed.addField("카테고리", status.liveCategoryValue, true)
-                embed.addField("태그", status.tags.joinToString(", ") { it.trim() }, true)
-                // embed.setImage(status.)
+                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()

chatbot/src/main/kotlin/space/mori/chzzk_bot/chatbot/utils/accessTokenRefresh.kt

@@ -0,0 +1,55 @@
+package space.mori.chzzk_bot.chatbot.utils
+
+import com.google.gson.Gson
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import space.mori.chzzk_bot.common.utils.client
+import xyz.r2turntrue.chzzk4j.ChzzkClient
+import java.io.IOException
+
+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()
+
+data class RefreshTokenResponse(
+    val accessToken: String,
+    val refreshToken: String,
+    val expiresIn: Int,
+    val tokenType: String = "Bearer",
+    val scope: String
+)
+
+fun ChzzkClient.refreshAccessToken(refreshToken: String): Pair<String, String> {
+    val url = "https://openapi.chzzk.naver.com/auth/v1/token"
+    val request = Request.Builder()
+        .url(url)
+        .header("Content-Type", "application/json")
+        .post(gson.toJson(mapOf(
+            "grantType" to "refresh_token",
+            "refreshToken" to refreshToken,
+            "clientId" to this.apiClientId,
+            "clientSecret" to this.apiSecret
+        )).toRequestBody())
+        .build()
+
+    client.newCall(request).execute().use { response ->
+        try {
+            if(!response.isSuccessful) throw IOException("Unexpected code ${response.code}")
+            val body = response.body?.string()
+            val data = gson.fromJson(body, RefreshTokenResponse::class.java)
+
+            return Pair(data.accessToken, data.refreshToken)
+        } catch(e: Exception) {
+            throw e
+        }
+    }
+}

common/src/main/kotlin/space/mori/chzzk_bot/common/events/ChzzkUserFindEvent.kt

@@ -1,7 +0,0 @@
-package space.mori.chzzk_bot.common.events
-
-data class ChzzkUserFindEvent(
-    val uid: String
-): Event {
-    val TAG = javaClass.simpleName
-}

common/src/main/kotlin/space/mori/chzzk_bot/common/events/ChzzkUserReceiveEvent.kt

@@ -1,11 +0,0 @@
-package space.mori.chzzk_bot.common.events
-
-data class ChzzkUserReceiveEvent(
-    val find: Boolean = true,
-    val uid: String? = null,
-    val nickname: String? = null,
-    val isStreamOn: Boolean? = null,
-    val avatarUrl: String? = null,
-): Event {
-    val TAG = javaClass.simpleName
-}

common/src/main/kotlin/space/mori/chzzk_bot/common/utils/ChzzkApis.kt

@@ -52,6 +52,49 @@ 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 ->
@@ -84,3 +127,41 @@ fun getFollowDate(chatID: String, userId: String) : IData<IFollowContent?> {
         }
     }
 }
+
+fun getStreamInfo(userId: String) : IData<IStreamInfo?> {
+    val url = "https://api.chzzk.naver.com/service/v3/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
+        }
+    }
+}
+
+fun getUserInfo(userId: String): IData<Channel?> {
+    val url = "https://api.chzzk.naver.com/service/v1/channels/${userId}"
+    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 channel = gson.fromJson(body, object: TypeToken<IData<Channel?>>() {})
+
+            return channel
+        } catch(e: Exception) {
+            throw e
+        }
+    }
+}

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

@@ -22,16 +22,12 @@ import io.ktor.server.websocket.*
 import kotlinx.coroutines.delay
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
-import org.koin.java.KoinJavaComponent.inject
-import space.mori.chzzk_bot.common.events.CoroutinesEventBus
-import space.mori.chzzk_bot.common.events.UserRegisterEvent
 import space.mori.chzzk_bot.common.services.UserService
 import space.mori.chzzk_bot.webserver.routes.*
 import space.mori.chzzk_bot.webserver.utils.DiscordRatelimits
 import java.math.BigInteger
 import java.security.SecureRandom
 import java.time.Duration
-import kotlin.getValue
 import kotlin.time.toKotlinDuration
 
 val dotenv = dotenv {
@@ -85,8 +81,6 @@ val server = embeddedServer(Netty, port = 8080, ) {
         }
     }
     routing {
-        val dispatcher: CoroutinesEventBus by inject(CoroutinesEventBus::class.java)
-
         route("/auth") {
             // discord login
             authenticate("auth-oauth-discord") {
@@ -197,12 +191,7 @@ val server = embeddedServer(Netty, port = 8080, ) {
                     val userInfo = getChzzkUser(tokenResponse.content.accessToken)
 
                     if(userInfo.content != null) {
-                        var user = UserService.getUser(userInfo.content.channelId)
-
-                        if(user == null) {
-                            user = UserService.saveUser(userInfo.content.channelName , userInfo.content.channelId)
-                        }
-
+                        val user = UserService.getUser(userInfo.content.channelId)
                         call.sessions.set(
                             UserSession(
                                 session.state,
@@ -210,13 +199,7 @@ val server = embeddedServer(Netty, port = 8080, ) {
                                 listOf()
                             )
                         )
-                        UserService.setRefreshToken(user,
-                            tokenResponse.content.accessToken,
-                            tokenResponse.content.refreshToken ?: ""
-                        )
-
-                        dispatcher.post(UserRegisterEvent(user.token))
-
+                        user?.let { UserService.setRefreshToken(it, tokenResponse.content.accessToken, tokenResponse.content.refreshToken ?: "") }
                         call.respondRedirect(getFrontendURL(""))
                     }
                 } catch (e: Exception) {

webserver/src/main/kotlin/space/mori/chzzk_bot/webserver/routes/ApiRoutes.kt

@@ -11,10 +11,7 @@ import space.mori.chzzk_bot.common.events.CoroutinesEventBus
 import space.mori.chzzk_bot.common.services.SongConfigService
 import space.mori.chzzk_bot.common.services.UserService
 import space.mori.chzzk_bot.webserver.UserSession
-import kotlinx.coroutines.CompletableDeferred
-import kotlinx.coroutines.withTimeoutOrNull
-import space.mori.chzzk_bot.common.events.ChzzkUserFindEvent
-import space.mori.chzzk_bot.common.events.ChzzkUserReceiveEvent
+import space.mori.chzzk_bot.webserver.utils.ChzzkUserCache
 
 @Serializable
 data class GetUserDTO(
@@ -39,20 +36,6 @@ data class GetSessionDTO(
 fun Routing.apiRoutes() {
     val dispatcher: CoroutinesEventBus by inject(CoroutinesEventBus::class.java)
 
-    suspend fun getChzzkUserWithId(uid: String): ChzzkUserReceiveEvent? {
-        val completableDeferred = CompletableDeferred<ChzzkUserReceiveEvent>()
-        dispatcher.subscribe(ChzzkUserReceiveEvent::class) { event ->
-            if (event.uid == uid) {
-                completableDeferred.complete(event)
-            }
-        }
-        val user = withTimeoutOrNull(5000) {
-            dispatcher.post(ChzzkUserFindEvent(uid))
-            completableDeferred.await()
-        }
-        return user
-    }
-
     route("/") {
         get {
             call.respondText("Hello World!", status =
@@ -72,16 +55,16 @@ fun Routing.apiRoutes() {
                 call.respondText("Require UID", status = HttpStatusCode.NotFound)
                 return@get
             }
-            val user = getChzzkUserWithId(uid)
-            if (user?.find == false) {
+            val user = ChzzkUserCache.getCachedUser(uid)
+            if(user?.content == null) {
                 call.respondText("User not found", status = HttpStatusCode.NotFound)
                 return@get
             } else {
                 call.respond(HttpStatusCode.OK, GetUserDTO(
-                    user?.uid ?: "",
-                    user?.nickname ?: "",
-                    user?.isStreamOn ?: false,
-                    user?.avatarUrl ?: ""
+                    user.content!!.channel.channelId,
+                    user.content!!.channel.channelName,
+                    user.content!!.status == "OPEN",
+                    user.content!!.channel.channelImageUrl
                 ))
             }
         }
@@ -99,7 +82,7 @@ fun Routing.apiRoutes() {
                 user = UserService.saveUser("임시닉네임", session.id)
             }
             val songConfig = SongConfigService.getConfig(user)
-            val status = getChzzkUserWithId(user.token)
+            val status = ChzzkUserCache.getCachedUser(session.id)
             val returnUsers = mutableListOf<GetSessionDTO>()
 
             if(status == null) {
@@ -108,14 +91,14 @@ fun Routing.apiRoutes() {
             }
 
             if (user.username == "임시닉네임") {
-                status.let { stats -> UserService.updateUser(user, stats.uid ?: "", stats.nickname ?: "") }
+                status.content?.channel?.let { it1 -> UserService.updateUser(user, it1.channelId, it1.channelName) }
             }
 
             returnUsers.add(GetSessionDTO(
-                status.uid ?: user.token,
-                status.nickname ?: user.username,
-                status.isStreamOn == true,
-                status.avatarUrl ?: "",
+                status.content?.channel?.channelId ?: user.username,
+                status.content?.channel?.channelName ?: user.token,
+                status.content?.status == "OPEN",
+                status.content?.channel?.channelImageUrl ?: "",
                 songConfig.queueLimit,
                 songConfig.personalLimit,
                 songConfig.streamerOnly,
@@ -126,15 +109,15 @@ fun Routing.apiRoutes() {
                 user.subordinates.toList()
             }
             returnUsers.addAll(subordinates.map {
-                val subStatus = getChzzkUserWithId(it.token)
-                return@map if (subStatus == null) {
+                val subStatus = ChzzkUserCache.getCachedUser(it.token)
+                return@map if (subStatus?.content == null) {
                     null
                 } else {
                     GetSessionDTO(
-                        subStatus.uid ?: "",
-                        subStatus.nickname ?: "",
-                        subStatus.isStreamOn == true,
-                        subStatus.avatarUrl ?: "",
+                        subStatus.content!!.channel.channelId,
+                        subStatus.content!!.channel.channelName,
+                        subStatus.content!!.status == "OPEN",
+                        subStatus.content!!.channel.channelImageUrl,
                         0,
                         0,
                         false,

webserver/src/main/kotlin/space/mori/chzzk_bot/webserver/utils/ChzzkUserCache.kt

@@ -0,0 +1,50 @@
+package space.mori.chzzk_bot.webserver.utils
+
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import org.slf4j.LoggerFactory
+import space.mori.chzzk_bot.common.utils.IData
+import space.mori.chzzk_bot.common.utils.IStreamInfo
+import space.mori.chzzk_bot.common.utils.getStreamInfo
+import space.mori.chzzk_bot.common.utils.getUserInfo
+import java.time.Instant
+import java.util.concurrent.ConcurrentHashMap
+
+object ChzzkUserCache {
+    private val cache = ConcurrentHashMap<String, CachedUser>()
+    private const val EXP_SECONDS = 600L
+    private val mutex = Mutex()
+    private val logger = LoggerFactory.getLogger(this::class.java)
+
+    suspend fun getCachedUser(id: String): IData<IStreamInfo?>? {
+        val now = Instant.now()
+        var user = cache[id]
+
+        if(user == null || user.timestamp.plusSeconds(EXP_SECONDS).isBefore(now)) {
+            mutex.withLock {
+                if(user == null || user.timestamp.plusSeconds(EXP_SECONDS)?.isBefore(now) != false) {
+                    var findUser = getStreamInfo(id)
+                    if(findUser.content == null) {
+                        val userInfo = getUserInfo(id)
+
+                        if(userInfo.content == null) return null
+
+                        findUser = IData(200, null, IStreamInfo(
+                            channel = userInfo.content!!
+                        ))
+                    }
+
+                    user = CachedUser(findUser)
+                    user.let { cache[id] = user }
+                }
+            }
+        }
+
+        return cache[id]?.user
+    }
+}
+
+data class CachedUser(
+    val user: IData<IStreamInfo?>,
+    val timestamp: Instant = Instant.now(),
+)