Replace javalin old method with newer

vn7n24fzkq · vn7n24fzkq · commit 5f6f0649c2b7 · 2020-04-24T23:47:53.000+08:00
diff --git a/src/main/kotlin/io/realworld/app/config/AppConfig.kt b/src/main/kotlin/io/realworld/app/config/AppConfig.kt
@@ -3,8 +3,7 @@ package io.realworld.app.config
 import com.fasterxml.jackson.databind.SerializationFeature
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
 import io.javalin.Javalin
-import io.javalin.JavalinEvent
-import io.javalin.json.JavalinJackson
+import io.javalin.plugin.json.JavalinJackson
 import io.realworld.app.config.ModulesConfig.allModules
 import io.realworld.app.web.ErrorExceptionMapping
 import io.realworld.app.web.Router
@@ -21,32 +20,36 @@ class AppConfig : KoinComponent {
 
     fun setup(): Javalin {
         StandAloneContext.startKoin(
-            allModules,
-            KoinProperties(true, true)
+                allModules,
+                KoinProperties(true, true)
         )
         return Javalin.create()
-            .also { app ->
-                this.configureMapper()
-                app.enableCorsForAllOrigins()
-                    .contextPath(getProperty("context"))
-                    .event(JavalinEvent.SERVER_STOPPING) {
-                        StandAloneContext.stopKoin()
+                .also { app ->
+                    this.configureMapper()
+                    app.config!!.apply {
+                        this.enableWebjars()
+                        this.enableCorsForAllOrigins()
+                        this.contextPath = getProperty("context")
                     }
-                authConfig.configure(app)
-                router.register(app)
-                ErrorExceptionMapping.register(app)
-                app.port(getProperty("server_port"))
-                app.enableWebJars()
-            }
+                    app.events {
+                        it.serverStopping {
+                            StandAloneContext.stopKoin()
+                        }
+                    }
+                    authConfig.configure(app)
+                    router.register(app)
+                    ErrorExceptionMapping.register(app)
+                    app.server()!!.serverPort = getProperty("server_port")
+                }
     }
 
     private fun configureMapper() {
         val dateFormat = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'")
         JavalinJackson.configure(
-            jacksonObjectMapper()
-                .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
-                .setDateFormat(dateFormat)
-                .configure(SerializationFeature.WRITE_DATES_WITH_ZONE_ID, true)
+                jacksonObjectMapper()
+                        .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
+                        .setDateFormat(dateFormat)
+                        .configure(SerializationFeature.WRITE_DATES_WITH_ZONE_ID, true)
         )
     }
 }
diff --git a/src/main/kotlin/io/realworld/app/config/AuthConfig.kt b/src/main/kotlin/io/realworld/app/config/AuthConfig.kt
@@ -1,10 +1,10 @@
 package io.realworld.app.config
 
 import com.auth0.jwt.interfaces.DecodedJWT
-import io.javalin.Context
-import io.javalin.ForbiddenResponse
 import io.javalin.Javalin
-import io.javalin.security.Role
+import io.javalin.core.security.Role
+import io.javalin.http.Context
+import io.javalin.http.ForbiddenResponse
 import io.realworld.app.utils.JwtProvider
 
 internal enum class Roles : Role {
@@ -15,7 +15,7 @@ private const val headerTokenName = "Authorization"
 
 class AuthConfig(private val jwtProvider: JwtProvider) {
     fun configure(app: Javalin) {
-        app.accessManager { handler, ctx, permittedRoles ->
+        app.config.accessManager { handler, ctx, permittedRoles ->
             val jwtToken = getJwtTokenHeader(ctx)
             val userRole = getUserRole(jwtToken) ?: Roles.ANYONE
             permittedRoles.takeIf { !it.contains(userRole) }?.apply { throw ForbiddenResponse() }
diff --git a/src/main/kotlin/io/realworld/app/domain/repository/ArticleRepository.kt b/src/main/kotlin/io/realworld/app/domain/repository/ArticleRepository.kt
@@ -1,6 +1,6 @@
 package io.realworld.app.domain.repository
 
-import io.javalin.NotFoundResponse
+import io.javalin.http.NotFoundResponse
 import io.realworld.app.domain.Article
 import io.realworld.app.domain.User
 import org.jetbrains.exposed.sql.Column
diff --git a/src/main/kotlin/io/realworld/app/domain/repository/CommentRepository.kt b/src/main/kotlin/io/realworld/app/domain/repository/CommentRepository.kt
@@ -1,7 +1,7 @@
 package io.realworld.app.domain.repository
 
-import io.javalin.BadRequestResponse
-import io.javalin.NotFoundResponse
+import io.javalin.http.BadRequestResponse
+import io.javalin.http.NotFoundResponse
 import io.realworld.app.domain.Comment
 import io.realworld.app.domain.User
 import org.jetbrains.exposed.dao.LongIdTable
diff --git a/src/main/kotlin/io/realworld/app/domain/repository/UserRepository.kt b/src/main/kotlin/io/realworld/app/domain/repository/UserRepository.kt
@@ -1,6 +1,6 @@
 package io.realworld.app.domain.repository
 
-import io.javalin.NotFoundResponse
+import io.javalin.http.NotFoundResponse
 import io.realworld.app.domain.User
 import org.jetbrains.exposed.dao.LongIdTable
 import org.jetbrains.exposed.sql.Column
diff --git a/src/main/kotlin/io/realworld/app/domain/service/ArticleService.kt b/src/main/kotlin/io/realworld/app/domain/service/ArticleService.kt
@@ -1,9 +1,9 @@
 package io.realworld.app.domain.service
 
 import com.github.slugify.Slugify
-import io.javalin.BadRequestResponse
-import io.javalin.InternalServerErrorResponse
-import io.javalin.NotFoundResponse
+import io.javalin.http.BadRequestResponse
+import io.javalin.http.InternalServerErrorResponse
+import io.javalin.http.NotFoundResponse
 import io.realworld.app.domain.Article
 import io.realworld.app.domain.repository.ArticleRepository
 import io.realworld.app.domain.repository.UserRepository
diff --git a/src/main/kotlin/io/realworld/app/domain/service/CommentService.kt b/src/main/kotlin/io/realworld/app/domain/service/CommentService.kt
@@ -1,6 +1,6 @@
 package io.realworld.app.domain.service
 
-import io.javalin.BadRequestResponse
+import io.javalin.http.BadRequestResponse
 import io.realworld.app.domain.Comment
 import io.realworld.app.domain.repository.CommentRepository
 
diff --git a/src/main/kotlin/io/realworld/app/domain/service/UserService.kt b/src/main/kotlin/io/realworld/app/domain/service/UserService.kt
@@ -1,9 +1,9 @@
 package io.realworld.app.domain.service
 
-import io.javalin.BadRequestResponse
-import io.javalin.HttpResponseException
-import io.javalin.NotFoundResponse
-import io.javalin.UnauthorizedResponse
+import io.javalin.http.BadRequestResponse
+import io.javalin.http.HttpResponseException
+import io.javalin.http.NotFoundResponse
+import io.javalin.http.UnauthorizedResponse
 import io.realworld.app.config.Roles
 import io.realworld.app.domain.Profile
 import io.realworld.app.domain.User
diff --git a/src/main/kotlin/io/realworld/app/utils/JwtProvider.kt b/src/main/kotlin/io/realworld/app/utils/JwtProvider.kt
@@ -2,7 +2,7 @@ package io.realworld.app.utils
 
 import com.auth0.jwt.JWT
 import com.auth0.jwt.interfaces.DecodedJWT
-import io.javalin.security.Role
+import io.javalin.core.security.Role
 import io.realworld.app.domain.User
 import java.util.*
 
diff --git a/src/main/kotlin/io/realworld/app/web/ErrorExceptionMapping.kt b/src/main/kotlin/io/realworld/app/web/ErrorExceptionMapping.kt
@@ -1,12 +1,8 @@
 package io.realworld.app.web
 
 import com.auth0.jwt.exceptions.JWTVerificationException
-import io.javalin.BadRequestResponse
-import io.javalin.ForbiddenResponse
-import io.javalin.HttpResponseException
 import io.javalin.Javalin
-import io.javalin.NotFoundResponse
-import io.javalin.UnauthorizedResponse
+import io.javalin.http.*
 import org.eclipse.jetty.http.HttpStatus
 import org.jetbrains.exposed.exceptions.ExposedSQLException
 import org.slf4j.LoggerFactory
diff --git a/src/main/kotlin/io/realworld/app/web/Router.kt b/src/main/kotlin/io/realworld/app/web/Router.kt
@@ -6,8 +6,7 @@ import io.javalin.apibuilder.ApiBuilder.get
 import io.javalin.apibuilder.ApiBuilder.path
 import io.javalin.apibuilder.ApiBuilder.post
 import io.javalin.apibuilder.ApiBuilder.put
-import io.javalin.core.util.SwaggerRenderer
-import io.javalin.security.SecurityUtil.roles
+import io.javalin.core.security.SecurityUtil.roles
 import io.realworld.app.config.Roles
 import io.realworld.app.web.controllers.ArticleController
 import io.realworld.app.web.controllers.CommentController
@@ -64,7 +63,7 @@ class Router(
             path("tags") {
                 get(tagController::get, rolesOptionalAuthenticated)
             }
-            get("", SwaggerRenderer("swagger/api.yaml"), rolesOptionalAuthenticated)
+            //get("", SwaggerRenderer("swagger/api.yaml"), rolesOptionalAuthenticated)
         }
     }
 }
diff --git a/src/main/kotlin/io/realworld/app/web/controllers/ArticleController.kt b/src/main/kotlin/io/realworld/app/web/controllers/ArticleController.kt
@@ -1,6 +1,6 @@
 package io.realworld.app.web.controllers
 
-import io.javalin.Context
+import io.javalin.http.Context
 import io.realworld.app.domain.ArticleDTO
 import io.realworld.app.domain.ArticlesDTO
 import io.realworld.app.domain.service.ArticleService
@@ -27,54 +27,54 @@ class ArticleController(private val articleService: ArticleService) {
     }
 
     fun get(ctx: Context) {
-        ctx.validatedPathParam("slug")
+        ctx.pathParam<String>("slug")
                 .check({ it.isNotBlank() })
-                .getOrThrow().also { slug ->
+                .get().also { slug ->
                     articleService.findBySlug(slug).apply {
                         ctx.json(ArticleDTO(this))
                     }
                 }
     }
 
     fun create(ctx: Context) {
-        ctx.validatedBody<ArticleDTO>()
+        ctx.bodyValidator<ArticleDTO>()
                 .check({ !it.article?.title.isNullOrBlank() })
                 .check({ !it.article?.description.isNullOrBlank() })
                 .check({ !it.article?.body.isNullOrBlank() })
-                .getOrThrow().article?.also { article ->
+                .get().article?.also { article ->
             articleService.create(ctx.attribute("email"), article).apply {
                 ctx.json(ArticleDTO(this))
             }
         }
     }
 
     fun update(ctx: Context) {
-        val slug = ctx.validatedPathParam("slug").getOrThrow()
-        ctx.validatedBody<ArticleDTO>()
+        val slug = ctx.pathParam<String>("slug").get()
+        ctx.bodyValidator<ArticleDTO>()
                 .check({ !it.article?.body.isNullOrBlank() })
-                .getOrThrow().article?.also { article ->
+                .get().article?.also { article ->
             articleService.update(slug, article).apply {
                 ctx.json(ArticleDTO(this))
             }
         }
     }
 
     fun delete(ctx: Context) {
-        ctx.validatedPathParam("slug").getOrThrow().also { slug ->
+        ctx.pathParam<String>("slug").get().also { slug ->
             articleService.delete(slug)
         }
     }
 
     fun favorite(ctx: Context) {
-        ctx.validatedPathParam("slug").getOrThrow().also { slug ->
+        ctx.pathParam<String>("slug").get().also { slug ->
             articleService.favorite(ctx.attribute("email"), slug).apply {
                 ctx.json(ArticleDTO(this))
             }
         }
     }
 
     fun unfavorite(ctx: Context) {
-        ctx.validatedPathParam("slug").getOrThrow().also { slug ->
+        ctx.pathParam<String>("slug").get().also { slug ->
             articleService.unfavorite(ctx.attribute("email"), slug).apply {
                 ctx.json(ArticleDTO(this))
             }
diff --git a/src/main/kotlin/io/realworld/app/web/controllers/CommentController.kt b/src/main/kotlin/io/realworld/app/web/controllers/CommentController.kt
@@ -1,33 +1,33 @@
 package io.realworld.app.web.controllers
 
-import io.javalin.Context
+import io.javalin.http.Context
 import io.realworld.app.domain.CommentDTO
 import io.realworld.app.domain.CommentsDTO
 import io.realworld.app.domain.service.CommentService
 
 class CommentController(private val commentService: CommentService) {
     fun add(ctx: Context) {
-        val slug = ctx.validatedPathParam("slug").getOrThrow()
-        ctx.validatedBody<CommentDTO>()
+        val slug = ctx.pathParam<String>("slug").get()
+        ctx.bodyValidator<CommentDTO>()
                 .check({ !it.comment?.body.isNullOrBlank() })
-                .getOrThrow().apply {
+                .get().apply {
                     commentService.add(slug, ctx.attribute("email")!!, this.comment!!).also {
                         ctx.json(CommentDTO(it))
                     }
                 }
     }
 
     fun findBySlug(ctx: Context) {
-        ctx.validatedPathParam("slug").getOrThrow().apply {
+        ctx.pathParam<String>("slug").get().apply {
             commentService.findBySlug(this).also { comments ->
                 ctx.json(CommentsDTO(comments))
             }
         }
     }
 
     fun delete(ctx: Context) {
-        val slug = ctx.validatedPathParam("slug").getOrThrow()
-        val id = ctx.validatedPathParam("id").asLong().getOrThrow()
+        val slug = ctx.pathParam<String>("slug").get()
+        val id = ctx.pathParam<Long>("slug").get()
         commentService.delete(id, slug)
     }
 
diff --git a/src/main/kotlin/io/realworld/app/web/controllers/ProfileController.kt b/src/main/kotlin/io/realworld/app/web/controllers/ProfileController.kt
@@ -1,28 +1,28 @@
 package io.realworld.app.web.controllers
 
-import io.javalin.Context
+import io.javalin.http.Context
 import io.realworld.app.domain.ProfileDTO
 import io.realworld.app.domain.service.UserService
 
 class ProfileController(private val userService: UserService) {
     fun get(ctx: Context) {
-        ctx.validatedPathParam("username").getOrThrow().also { usernameFollowing ->
+        ctx.pathParam<String>("username").get().also { usernameFollowing ->
             userService.getProfileByUsername(ctx.attribute("email")!!, usernameFollowing).also { profile ->
                 ctx.json(ProfileDTO(profile))
             }
         }
     }
 
     fun follow(ctx: Context) {
-        ctx.validatedPathParam("username").getOrThrow().also { usernameToFollow ->
+        ctx.pathParam<String>("username").get().also { usernameToFollow ->
             userService.follow(ctx.attribute("email")!!, usernameToFollow).also { profile ->
                 ctx.json(ProfileDTO(profile))
             }
         }
     }
 
     fun unfollow(ctx: Context) {
-        ctx.validatedPathParam("username").getOrThrow().also { usernameToUnfollow ->
+        ctx.pathParam<String>("username").get().also { usernameToUnfollow ->
             userService.unfollow(ctx.attribute("email")!!, usernameToUnfollow).also { profile ->
                 ctx.json(ProfileDTO(profile))
             }
diff --git a/src/main/kotlin/io/realworld/app/web/controllers/TagController.kt b/src/main/kotlin/io/realworld/app/web/controllers/TagController.kt
@@ -1,6 +1,6 @@
 package io.realworld.app.web.controllers
 
-import io.javalin.Context
+import io.javalin.http.Context
 import io.realworld.app.domain.service.TagService
 
 class TagController(private val tagService: TagService) {
diff --git a/src/main/kotlin/io/realworld/app/web/controllers/UserController.kt b/src/main/kotlin/io/realworld/app/web/controllers/UserController.kt
@@ -1,28 +1,28 @@
 package io.realworld.app.web.controllers
 
-import io.javalin.Context
+import io.javalin.http.Context
 import io.realworld.app.domain.UserDTO
 import io.realworld.app.domain.service.UserService
 import io.realworld.app.ext.isEmailValid
 
 class UserController(private val userService: UserService) {
     fun login(ctx: Context) {
-        ctx.validatedBody<UserDTO>()
+        ctx.bodyValidator<UserDTO>()
                 .check({ it.user?.email?.isEmailValid() ?: true })
                 .check({ !it.user?.password.isNullOrBlank() })
-                .getOrThrow().user?.also { user ->
+                .get().user?.also { user ->
             userService.authenticate(user).apply {
                 ctx.json(UserDTO(this))
             }
         }
     }
 
     fun register(ctx: Context) {
-        ctx.validatedBody<UserDTO>()
+        ctx.bodyValidator<UserDTO>()
                 .check({ it.user?.email?.isEmailValid() ?: true })
                 .check({ !it.user?.password.isNullOrBlank() })
                 .check({ !it.user?.username.isNullOrBlank() })
-                .getOrThrow().user?.also { user ->
+                .get().user?.also { user ->
             userService.create(user).apply {
                 ctx.json(UserDTO(this))
             }
@@ -37,14 +37,14 @@ class UserController(private val userService: UserService) {
 
     fun update(ctx: Context) {
         val email = ctx.attribute<String>("email")
-        ctx.validatedBody<UserDTO>()
+        ctx.bodyValidator<UserDTO>()
                 .check({ it.user != null })
                 .check({ it.user?.email?.isEmailValid() ?: true })
                 .check({ it.user?.username?.isNotBlank() ?: true })
                 .check({ it.user?.password?.isNotBlank() ?: true })
                 .check({ it.user?.bio?.isNotBlank() ?: true })
                 .check({ it.user?.image?.isNotBlank() ?: true })
-                .getOrThrow()
+                .get()
                 .user?.also { user ->
             userService.update(email, user).apply {
                 ctx.json(UserDTO(this))
diff --git a/src/main/resources/koin.properties b/src/main/resources/koin.properties
