Merge remote-tracking branch 'origin'

Author: Hank-Choi

api/src/main/kotlin/handler/EvServiceHandler.kt

@@ -15,25 +15,25 @@ class EvServiceHandler(
     suspend fun handleGet(req: ServerRequest) =
         handle(req) {
             val body = req.awaitBodyOrNull<String>() ?: ""
-            evService.handleRouting(req.userId, req.pathVariable("requestPath"), req.queryParams(), body, HttpMethod.GET)
+            evService.handleRouting(req.user, req.pathVariable("requestPath"), req.queryParams(), body, HttpMethod.GET)
         }
 
     suspend fun handlePost(req: ServerRequest) =
         handle(req) {
             val body = req.awaitBodyOrNull<String>() ?: ""
-            evService.handleRouting(req.userId, req.pathVariable("requestPath"), req.queryParams(), body, HttpMethod.POST)
+            evService.handleRouting(req.user, req.pathVariable("requestPath"), req.queryParams(), body, HttpMethod.POST)
         }
 
     suspend fun handleDelete(req: ServerRequest) =
         handle(req) {
             val body = req.awaitBodyOrNull<String>() ?: ""
-            evService.handleRouting(req.userId, req.pathVariable("requestPath"), req.queryParams(), body, HttpMethod.DELETE)
+            evService.handleRouting(req.user, req.pathVariable("requestPath"), req.queryParams(), body, HttpMethod.DELETE)
         }
 
     suspend fun handlePatch(req: ServerRequest) =
         handle(req) {
             val body = req.awaitBodyOrNull<String>() ?: ""
-            evService.handleRouting(req.userId, req.pathVariable("requestPath"), req.queryParams(), body, HttpMethod.PATCH)
+            evService.handleRouting(req.user, req.pathVariable("requestPath"), req.queryParams(), body, HttpMethod.PATCH)
         }
 
     suspend fun getMyLatestLectures(req: ServerRequest) =

api/src/main/kotlin/handler/RequestContext.kt

@@ -20,6 +20,9 @@ fun ServerRequest.setContext(value: RequestContext) {
     this.attributes()[CONTEXT_ATTRIBUTE_KEY] = value
 }
 
+val ServerRequest.user: User
+    get() = this.getContext().user ?: throw WrongUserTokenException
+
 val ServerRequest.userId: String
     get() = this.getContext().user?.id ?: throw WrongUserTokenException
 

core/src/main/kotlin/common/cache/Cache.kt

@@ -50,55 +50,40 @@ class RedisCache(
         typeRef: TypeReference<T>,
         supplier: (suspend () -> T?)?,
     ): T? {
-        try {
-            log.debug("[CACHE GET] {}", builtKey.key)
-            val redisValue = redisTemplate.opsForValue().getAndAwait(builtKey.key)
-            redisValue?.let {
-                return objectMapper.readValue(it, typeRef)
+        val redisValue = runCatching { redisTemplate.opsForValue().getAndAwait(builtKey.key) }.getOrNull()
+        return if (redisValue != null) {
+            objectMapper.readValue(redisValue, typeRef)
+        } else {
+            if (supplier == null) return null
+            supplier().also { value ->
+                coroutineScope.launch {
+                    set(builtKey, value)
+                }
             }
-        } catch (e: Exception) {
-            log.error(e.message, e)
         }
-
-        if (supplier == null) return null
-
-        val value = supplier()
-
-        coroutineScope.launch { set(builtKey, value) }
-
-        return value
     }
 
     override suspend fun <T : Any> set(
         builtKey: BuiltCacheKey,
         value: T?,
     ) {
-        try {
-            val redisValue = objectMapper.writeValueAsString(value)
-
-            log.debug("[CACHE SET] {}", builtKey.key)
-            redisTemplate.opsForValue().setAndAwait(builtKey.key, redisValue, builtKey.ttl)
-        } catch (_: Exception) {
-        }
+        val redisValue = objectMapper.writeValueAsString(value)
+        runCatching { redisTemplate.opsForValue().setAndAwait(builtKey.key, redisValue, builtKey.ttl) }
     }
 
     override suspend fun delete(builtKey: BuiltCacheKey) {
-        try {
-            log.debug("[CACHE DEL] {}", builtKey.key)
-            redisTemplate.deleteAndAwait(builtKey.key)
-        } catch (_: Exception) {
-        }
+        runCatching { redisTemplate.deleteAndAwait(builtKey.key) }
     }
 
-    override suspend fun acquireLock(builtKey: BuiltCacheKey): Boolean {
-        log.debug("[CACHE SETNX] {}", builtKey.key)
-        return redisTemplate.opsForValue().setIfAbsentAndAwait(builtKey.key, "true", builtKey.ttl)
-    }
+    override suspend fun acquireLock(builtKey: BuiltCacheKey): Boolean =
+        runCatching {
+            redisTemplate.opsForValue().setIfAbsentAndAwait(builtKey.key, "true", builtKey.ttl)
+        }.getOrDefault(false)
 
-    override suspend fun releaseLock(builtKey: BuiltCacheKey): Boolean {
-        log.debug("[CACHE DEL] {}", builtKey.key)
-        return redisTemplate.deleteAndAwait(builtKey.key) > 0
-    }
+    override suspend fun releaseLock(builtKey: BuiltCacheKey): Boolean =
+        runCatching {
+            redisTemplate.deleteAndAwait(builtKey.key) > 0
+        }.getOrDefault(false)
 }
 
 suspend inline fun <reified T : Any> Cache.get(

core/src/main/kotlin/common/exception/ErrorType.kt

@@ -29,6 +29,7 @@ enum class ErrorType(
     LECTURE_TIME_OVERLAP(HttpStatus.FORBIDDEN, 0x300C, "강의 시간이 겹칩니다."),
     CANNOT_RESET_CUSTOM_LECTURE(HttpStatus.FORBIDDEN, 0x300D, "cannot reset custom lectures"),
     INVALID_EMAIL(HttpStatus.FORBIDDEN, 0x300F, "email이 유효하지 않습니다.", "이메일 형식이 올바르지 않습니다."),
+    USER_EMAIL_IS_NOT_VERIFIED(HttpStatus.FORBIDDEN, 0x3011, "User email is not verified", "이메일 인증이 필요합니다."),
 
     LECTURE_NOT_FOUND(HttpStatus.NOT_FOUND, 0x4003, "lecture가 없습니다.", "해당 강의는 존재하지 않습니다."),
     USER_NOT_FOUND(HttpStatus.NOT_FOUND, 0x4004, "user가 없습니다.", "해당 유저는 존재하지 않습니다."),

core/src/main/kotlin/common/exception/SnuttException.kt

@@ -34,6 +34,8 @@ object DuplicateLocalIdException : SnuttException(ErrorType.DUPLICATE_LOCAL_ID)
 
 object InvalidEmailException : SnuttException(ErrorType.INVALID_EMAIL)
 
+object UserEmailIsNotVerifiedException : SnuttException(ErrorType.USER_EMAIL_IS_NOT_VERIFIED)
+
 object LectureNotFoundException : SnuttException(ErrorType.LECTURE_NOT_FOUND)
 
 object UserNotFoundException : SnuttException(ErrorType.USER_NOT_FOUND)

core/src/main/kotlin/evaluation/service/EvService.kt

@@ -4,6 +4,7 @@ import com.fasterxml.jackson.databind.ObjectMapper
 import com.wafflestudio.snutt.common.dto.ListResponse
 import com.wafflestudio.snutt.common.exception.EvDataNotFoundException
 import com.wafflestudio.snutt.common.exception.EvServiceProxyException
+import com.wafflestudio.snutt.common.exception.UserEmailIsNotVerifiedException
 import com.wafflestudio.snutt.common.util.buildMultiValueMap
 import com.wafflestudio.snutt.config.SnuttEvWebClient
 import com.wafflestudio.snutt.coursebook.service.CoursebookService
@@ -13,6 +14,7 @@ import com.wafflestudio.snutt.evaluation.dto.EvUserDto
 import com.wafflestudio.snutt.evaluation.dto.SnuttEvLectureIdDto
 import com.wafflestudio.snutt.evaluation.dto.SnuttEvLectureSummaryDto
 import com.wafflestudio.snutt.timetables.repository.TimetableRepository
+import com.wafflestudio.snutt.users.data.User
 import com.wafflestudio.snutt.users.service.UserService
 import kotlinx.coroutines.flow.toList
 import org.springframework.http.HttpHeaders
@@ -35,16 +37,19 @@ class EvService(
     private val objectMapper: ObjectMapper,
 ) {
     suspend fun handleRouting(
-        userId: String,
+        user: User,
         requestPath: String,
         requestQueryParams: MultiValueMap<String, String> = buildMultiValueMap(mapOf()),
         originalBody: String,
         method: HttpMethod,
     ): Map<String, Any?>? {
+        if (user.isEmailVerified == false) {
+            throw UserEmailIsNotVerifiedException
+        }
         val result: MutableMap<String, Any?>? =
             snuttEvWebClient.method(method)
                 .uri { builder -> builder.path(requestPath).queryParams(requestQueryParams).build() }
-                .header("Snutt-User-Id", userId)
+                .header("Snutt-User-Id", user.id)
                 .header(HttpHeaders.CONTENT_ENCODING, "UTF-8")
                 .contentType(MediaType.APPLICATION_JSON)
                 .bodyValue(originalBody)