[🚌 Issue] dev api 로그인 요청 위치에 따라 redirect url 변환

backend/application/api/src/main/kotlin/io/raemian/api/cheer/controller/CheeringController.kt

@@ -6,7 +6,7 @@ import io.raemian.api.cheer.model.CheererResult
 import io.raemian.api.cheer.model.CheeringCountResult
 import io.raemian.api.cheer.service.CheeringService
 import io.raemian.api.support.response.ApiResponse
-import io.raemian.api.support.response.PaginationResult
+import io.raemian.api.support.response.CursorPaginationResult
 import org.springframework.http.ResponseEntity
 import org.springframework.web.bind.annotation.GetMapping
 import org.springframework.web.bind.annotation.PathVariable
@@ -25,7 +25,7 @@ class CheeringController(
     fun findCheeringSquad(
         @PathVariable("lifeMapId") lifeMapId: Long,
         request: CheeringSquadPageRequest,
-    ): ResponseEntity<ApiResponse<PaginationResult<Long, CheererResult>>> =
+    ): ResponseEntity<ApiResponse<CursorPaginationResult<CheererResult>>> =
         ResponseEntity.ok().body(ApiResponse.success(cheeringService.findCheeringSquad(lifeMapId, request)))
 
     @GetMapping("/count/{userName}")

backend/application/api/src/main/kotlin/io/raemian/api/support/limiter/CheeringLimiter.kt → backend/application/api/src/main/kotlin/io/raemian/api/cheer/service/CheeringLimiter.kt

@@ -1,4 +1,4 @@
-package io.raemian.api.support.limiter
+package io.raemian.api.cheer.service
 
 import com.github.benmanes.caffeine.cache.Caffeine
 import org.springframework.stereotype.Component

backend/application/api/src/main/kotlin/io/raemian/api/cheer/service/CheeringService.kt

@@ -7,16 +7,15 @@ import io.raemian.api.cheer.model.CheeringCountResult
 import io.raemian.api.event.model.CheeredEvent
 import io.raemian.api.support.exception.CoreApiException
 import io.raemian.api.support.exception.ErrorInfo
-import io.raemian.api.support.limiter.CheeringLimiter
-import io.raemian.api.support.response.PaginationResult
+import io.raemian.api.support.response.CursorPaginationResult
 import io.raemian.storage.db.core.cheer.CheerJdbcQueryRepository
 import io.raemian.storage.db.core.cheer.Cheerer
 import io.raemian.storage.db.core.cheer.CheererRepository
 import io.raemian.storage.db.core.cheer.Cheering
 import io.raemian.storage.db.core.cheer.CheeringRepository
 import io.raemian.storage.db.core.cheer.model.CheererQueryResult
-import io.raemian.storage.db.core.common.pagination.CursorPaginationResult
 import io.raemian.storage.db.core.common.pagination.CursorPaginationTemplate
+import io.raemian.storage.db.core.common.pagination.PaginationResult
 import io.raemian.storage.db.core.lifemap.LifeMapRepository
 import io.raemian.storage.db.core.user.UserRepository
 import org.springframework.context.ApplicationEventPublisher
@@ -46,15 +45,15 @@ class CheeringService(
     }
 
     @Transactional(readOnly = true)
-    fun findCheeringSquad(lifeMapId: Long, request: CheeringSquadPageRequest): PaginationResult<Long, CheererResult> {
+    fun findCheeringSquad(lifeMapId: Long, request: CheeringSquadPageRequest): CursorPaginationResult<CheererResult> {
         val cheering = cheeringRepository.findByLifeMapId(lifeMapId)
             ?: Cheering(0, lifeMapId)
 
         val cheeringSquad = findCheeringSquadWithCursor(lifeMapId, request)
 
         val filteredCheeringSquad = cheeringSquad.transform { CheererResult.from(it) }
 
-        return PaginationResult.from(cheering.count, filteredCheeringSquad)
+        return CursorPaginationResult.from(cheering.count, filteredCheeringSquad)
     }
 
     @Transactional(readOnly = true)
@@ -89,7 +88,7 @@ class CheeringService(
         )
     }
 
-    private fun findCheeringSquadWithCursor(lifeMapId: Long, request: CheeringSquadPageRequest): CursorPaginationResult<Long, CheererQueryResult> {
+    private fun findCheeringSquadWithCursor(lifeMapId: Long, request: CheeringSquadPageRequest): PaginationResult<CheererQueryResult> {
         return CursorPaginationTemplate.execute(lifeMapId, request.cursor ?: Long.MAX_VALUE, request.size) {
                 id, cursor, size ->
             cheererJdbcQueryRepository.findAllByLifeMapWithCursor(id, cursor, size)

backend/application/api/src/main/kotlin/io/raemian/api/config/WebSecurityConfig.kt

@@ -4,14 +4,13 @@ import io.raemian.api.auth.converter.TokenRequestEntityConverter
 import io.raemian.api.auth.model.CurrentUser
 import io.raemian.api.auth.service.OAuth2UserService
 import io.raemian.api.support.constant.WebSecurityConstant
+import io.raemian.api.support.security.LoginRedirector
 import io.raemian.api.support.security.StateOAuth2AuthorizationRequestRepository
 import io.raemian.api.support.security.TokenProvider
 import jakarta.servlet.http.HttpServletResponse
 import org.slf4j.LoggerFactory
-import org.springframework.beans.factory.annotation.Value
 import org.springframework.context.annotation.Bean
 import org.springframework.context.annotation.Configuration
-import org.springframework.http.MediaType
 import org.springframework.security.config.annotation.SecurityConfigurerAdapter
 import org.springframework.security.config.annotation.web.builders.HttpSecurity
 import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity
@@ -25,16 +24,14 @@ import org.springframework.security.web.DefaultSecurityFilterChain
 import org.springframework.security.web.SecurityFilterChain
 import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter
 import org.springframework.web.filter.CorsFilter
-import java.nio.charset.StandardCharsets
 
 @Configuration
 @EnableWebSecurity
 class WebSecurityConfig(
     private val corsFilter: CorsFilter,
     private val tokenProvider: TokenProvider,
     private val oAuth2UserService: OAuth2UserService,
-    @Value("\${spring.profiles.active:local}")
-    private val profile: String,
+    private val loginRedirector: LoginRedirector,
     private val tokenRequestEntityConverter: TokenRequestEntityConverter,
     private val httpCookieOAuth2AuthorizationRequestRepository: StateOAuth2AuthorizationRequestRepository,
 ) : SecurityConfigurerAdapter<DefaultSecurityFilterChain, HttpSecurity>() {
@@ -66,23 +63,9 @@ class WebSecurityConfig(
                 it.authorizationEndpoint { it.authorizationRequestRepository(httpCookieOAuth2AuthorizationRequestRepository) }
                 it.successHandler { request, response, authentication ->
                     val user = authentication.principal as CurrentUser
-                    response.contentType = MediaType.APPLICATION_JSON_VALUE
-                    response.characterEncoding = StandardCharsets.UTF_8.name()
-
-                    val tokenDTO = tokenProvider.generateTokenDto(user)
-                    response.setHeader("x-token", tokenDTO.accessToken)
-                    log.info("x-token access ${tokenDTO.accessToken}")
-
-                    // TODO edit redirect url
-                    val referer = request.getHeader("referer")
-                    val redirectUrl =
-                        if (profile == "live") {
-                            "https://bandiboodi.com/oauth2/token"
-                        } else {
-                            "http://localhost:3000/oauth2/token"
-                        }
-
-                    response.sendRedirect("$redirectUrl?token=${tokenDTO.accessToken}&refresh=${tokenDTO.refreshToken}")
+                    val token = tokenProvider.generateTokenDto(user)
+                    val redirectUrl = loginRedirector.getUrl(request.getParameter("state"), token)
+                    response.sendRedirect(redirectUrl)
                 }
                 it.failureHandler { request, response, exception ->
                     log.error("x-token error ${exception.message}")

backend/application/api/src/main/kotlin/io/raemian/api/goal/controller/request/TimelinePageRequest.kt

@@ -1,8 +1,6 @@
 package io.raemian.api.goal.controller.request
 
-import java.time.LocalDateTime
-
 data class TimelinePageRequest(
-    val cursor: LocalDateTime?,
-    val size: Int,
+    val page: Int = 0,
+    val size: Int = 20,
 )

backend/application/api/src/main/kotlin/io/raemian/api/goal/service/GoalQueryService.kt

@@ -6,38 +6,46 @@ import io.raemian.api.goal.controller.request.TimelinePageRequest
 import io.raemian.api.goal.model.GoalTimelineCountSubset
 import io.raemian.api.goal.model.GoalTimelinePageResult
 import io.raemian.api.lifemap.service.LifeMapService
-import io.raemian.api.support.constant.LocalDateTimeConstant
-import io.raemian.api.support.response.PaginationResult
+import io.raemian.api.support.response.OffsetPaginationResult
 import io.raemian.api.task.service.TaskService
-import io.raemian.storage.db.core.common.pagination.CursorPaginationResult
-import io.raemian.storage.db.core.common.pagination.CursorPaginationTemplate
 import io.raemian.storage.db.core.goal.GoalJdbcQueryRepository
-import io.raemian.storage.db.core.goal.model.GoalQueryResult
+import io.raemian.storage.db.core.goal.GoalRepository
 import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
-import java.time.LocalDateTime
 
 @Service
 class GoalQueryService(
     private val lifeMapService: LifeMapService,
     private val goalJdbcQueryRepository: GoalJdbcQueryRepository,
+    private val goalRepository: GoalRepository,
     private val emojiService: EmojiService,
     private val taskService: TaskService,
     private val commentService: CommentService,
 ) {
     @Transactional(readOnly = true)
-    fun findAllByUsernameWithCursor(username: String, request: TimelinePageRequest): PaginationResult<LocalDateTime, GoalTimelinePageResult> {
+    fun findAllByUsernameWithOffset(username: String, request: TimelinePageRequest): OffsetPaginationResult<GoalTimelinePageResult> {
         val lifeMap = lifeMapService.getFirstByUserName(username)
-        val goals = findAllByLifeMapIdWithCursor(lifeMap.lifeMapId, request)
+        val goals = goalJdbcQueryRepository.findAllByLifeMapWithOffset(lifeMap.lifeMapId, request.page, request.size)
+        val total = goalRepository.countByLifeMapId(lifeMap.lifeMapId)
 
-        val goalIds = goals.contents.map { it.goalId }
+        val goalIds = goals.map { it.goalId }
 
         val goalCountMap = findGoalCountMap(goalIds)
         val reactedEmojiMap = emojiService.findAllByGoalIds(goalIds, lifeMap.user.id)
 
-        return PaginationResult.from(
-            lifeMap.goals.size,
-            goals.transform {
+        goals.map {
+            GoalTimelinePageResult.from(
+                goal = it,
+                counts = goalCountMap[it.goalId],
+                reactedEmojisResult = reactedEmojiMap[it.goalId],
+            )
+        }
+
+        return OffsetPaginationResult.of(
+            request.page,
+            request.size,
+            total,
+            goals.map {
                 GoalTimelinePageResult.from(
                     goal = it,
                     counts = goalCountMap[it.goalId],
@@ -58,11 +66,4 @@ class GoalQueryService(
             )
         }
     }
-
-    private fun findAllByLifeMapIdWithCursor(lifeMapId: Long, request: TimelinePageRequest): CursorPaginationResult<LocalDateTime, GoalQueryResult> {
-        return CursorPaginationTemplate.execute(lifeMapId, request.cursor ?: LocalDateTimeConstant.MAX, request.size) {
-                id, cursor, size ->
-            goalJdbcQueryRepository.findAllByLifeMapWithCursor(id, cursor, size)
-        }
-    }
 }

backend/application/api/src/main/kotlin/io/raemian/api/lifemap/controller/OpenLifeMapController.kt

@@ -8,15 +8,14 @@ import io.raemian.api.goal.service.GoalQueryService
 import io.raemian.api.lifemap.model.LifeMapResponse
 import io.raemian.api.lifemap.service.LifeMapService
 import io.raemian.api.support.response.ApiResponse
-import io.raemian.api.support.response.PaginationResult
+import io.raemian.api.support.response.OffsetPaginationResult
 import io.swagger.v3.oas.annotations.Operation
 import org.springframework.http.ResponseEntity
 import org.springframework.security.core.annotation.AuthenticationPrincipal
 import org.springframework.web.bind.annotation.GetMapping
 import org.springframework.web.bind.annotation.PathVariable
 import org.springframework.web.bind.annotation.RequestMapping
 import org.springframework.web.bind.annotation.RestController
-import java.time.LocalDateTime
 
 @RestController
 @RequestMapping("/open/life-map")
@@ -51,8 +50,8 @@ class OpenLifeMapController(
     fun getTimeline(
         @PathVariable("username") username: String,
         request: TimelinePageRequest,
-    ): ResponseEntity<ApiResponse<PaginationResult<LocalDateTime, GoalTimelinePageResult>>> {
-        val goalTimeline = goalQueryService.findAllByUsernameWithCursor(username, request)
+    ): ResponseEntity<ApiResponse<OffsetPaginationResult<GoalTimelinePageResult>>> {
+        val goalTimeline = goalQueryService.findAllByUsernameWithOffset(username, request)
         return ResponseEntity.ok(ApiResponse.success(goalTimeline))
     }
 }

backend/application/api/src/main/kotlin/io/raemian/api/support/response/PaginationResult.kt → backend/application/api/src/main/kotlin/io/raemian/api/support/response/CursorPaginationResult.kt

@@ -1,25 +1,25 @@
 package io.raemian.api.support.response
 
-import io.raemian.storage.db.core.common.pagination.CursorPaginationResult
+import io.raemian.storage.db.core.common.pagination.PaginationResult
 
-data class PaginationResult<CursorType, T>(
+data class CursorPaginationResult<T>(
     val total: Long,
     val contents: List<T>,
     val isLast: Boolean,
-    val nextCursor: CursorType?,
+    val nextCursor: Long?,
 ) {
     companion object {
-        fun <CursorType, T> from(total: Long, result: CursorPaginationResult<CursorType, T>): PaginationResult<CursorType, T> {
-            return PaginationResult(
+        fun <T> from(total: Long, result: PaginationResult<T>): CursorPaginationResult<T> {
+            return CursorPaginationResult(
                 total = total,
                 contents = result.contents,
                 isLast = result.isLast,
                 nextCursor = result.nextCursor,
             )
         }
 
-        fun <CursorType, T> from(total: Int, result: CursorPaginationResult<CursorType, T>): PaginationResult<CursorType, T> {
-            return PaginationResult(
+        fun <T> from(total: Int, result: PaginationResult<T>): CursorPaginationResult<T> {
+            return CursorPaginationResult(
                 total = total.toLong(),
                 contents = result.contents,
                 isLast = result.isLast,

backend/application/api/src/main/kotlin/io/raemian/api/support/response/OffsetPaginationResult.kt

@@ -0,0 +1,14 @@
+package io.raemian.api.support.response
+
+data class OffsetPaginationResult<T>(
+    val total: Long,
+    val page: Int,
+    val size: Int,
+    val contents: List<T>,
+) {
+    companion object {
+        fun <T> of(page: Int, size: Int, total: Long, contents: List<T>): OffsetPaginationResult<T> {
+            return OffsetPaginationResult(total, page, size, contents)
+        }
+    }
+}

backend/application/api/src/main/kotlin/io/raemian/api/support/security/LoginRedirector.kt

@@ -0,0 +1,25 @@
+package io.raemian.api.support.security
+
+import io.raemian.api.auth.model.Token
+import org.springframework.stereotype.Component
+
+@Component
+class LoginRedirector(
+    val profilePlaceHolder: ProfileHolder,
+    val redirectUrlHolder: RedirectUrlHolder,
+    val loginRequestRefererStorage: LoginRequestRefererStorage,
+) {
+    fun getUrl(state: String, token: Token): String {
+        if (profilePlaceHolder.isLive()) {
+            return "${redirectUrlHolder.live}?token=${token.accessToken}&refresh=${token.refreshToken}"
+        }
+
+        val referer = loginRequestRefererStorage.get(state)
+
+        if (profilePlaceHolder.isDev() && referer.contains("dev-bandiboodi")) {
+            return "${redirectUrlHolder.dev}?token=${token.accessToken}&refresh=${token.refreshToken}"
+        }
+
+        return "${redirectUrlHolder.local}?token=${token.accessToken}&refresh=${token.refreshToken}"
+    }
+}

backend/application/api/src/main/kotlin/io/raemian/api/support/security/LoginRequestRefererStorage.kt

@@ -0,0 +1,24 @@
+package io.raemian.api.support.security
+
+import com.github.benmanes.caffeine.cache.Caffeine
+import org.springframework.stereotype.Component
+import java.util.concurrent.TimeUnit
+
+@Component
+class LoginRequestRefererStorage {
+    private val timedStorage = Caffeine.newBuilder()
+        .expireAfterWrite(60L, TimeUnit.SECONDS)
+        .build<String, String>()
+
+    fun put(state: String, referer: String?) {
+        if (referer.isNullOrBlank()) {
+            return
+        } else {
+            timedStorage.put(state, referer)
+        }
+    }
+
+    fun get(state: String): String {
+        return timedStorage.getIfPresent(state) ?: ""
+    }
+}

backend/application/api/src/main/kotlin/io/raemian/api/support/security/ProfileHolder.kt

@@ -0,0 +1,18 @@
+package io.raemian.api.support.security
+
+import org.springframework.beans.factory.annotation.Value
+import org.springframework.stereotype.Component
+
+@Component
+class ProfileHolder(
+    @Value("\${spring.profiles.active:local}")
+    private val profile: String,
+) {
+    fun isLive(): Boolean {
+        return ProfileType.fromString(profile) == ProfileType.LIVE
+    }
+
+    fun isDev(): Boolean {
+        return ProfileType.fromString(profile) == ProfileType.DEV
+    }
+}

backend/application/api/src/main/kotlin/io/raemian/api/support/security/ProfileType.kt

@@ -0,0 +1,17 @@
+package io.raemian.api.support.security
+
+enum class ProfileType(
+    value: String,
+) {
+    LIVE("live"),
+    DEV("dev"),
+    LOCAL("local"), ;
+    companion object {
+        fun fromString(value: String): ProfileType =
+            when (value) {
+                "live" -> LIVE
+                "dev" -> DEV
+                else -> LOCAL
+            }
+    }
+}

backend/application/api/src/main/kotlin/io/raemian/api/support/security/RedirectUrlHolder.kt

@@ -0,0 +1,10 @@
+package io.raemian.api.support.security
+
+import org.springframework.boot.context.properties.ConfigurationProperties
+
+@ConfigurationProperties(prefix = "redirect-url")
+data class RedirectUrlHolder(
+    val live: String,
+    val dev: String,
+    val local: String,
+)