From 6e305989a7f83608fef11135e1c45b11dd2277c8 Mon Sep 17 00:00:00 2001
From: guenhter <grill.guenther@gmail.com>
Date: Mon, 19 Feb 2018 08:38:33 +0100
Subject: [PATCH] Upgrade ktor from 0.3.0 to 0.9.1

This upgrade also includes the upgrade of kotlin to 1.2.x.
---
 .idea/runConfigurations/Backend____Jetty.xml  |  4 +-
 backend/build.gradle                          | 16 +++----
 .../jetbrains/demo/thinkter/Application.kt    | 43 +++++++++---------
 .../demo/thinkter/ApplicationPage.kt          |  4 +-
 .../src/org/jetbrains/demo/thinkter/Delete.kt | 29 +++++++-----
 .../src/org/jetbrains/demo/thinkter/Index.kt  | 22 ++++-----
 .../org/jetbrains/demo/thinkter/Locations.kt  | 22 ++++-----
 .../src/org/jetbrains/demo/thinkter/Login.kt  | 30 ++++++++-----
 .../jetbrains/demo/thinkter/PostThought.kt    | 28 ++++++++----
 .../org/jetbrains/demo/thinkter/Register.kt   | 45 ++++++++++---------
 .../org/jetbrains/demo/thinkter/UserPage.kt   |  9 ++--
 .../org/jetbrains/demo/thinkter/Utilities.kt  | 13 +++---
 .../jetbrains/demo/thinkter/ViewThought.kt    | 11 ++---
 build.gradle                                  | 14 +++---
 14 files changed, 160 insertions(+), 130 deletions(-)

diff --git a/.idea/runConfigurations/Backend____Jetty.xml b/.idea/runConfigurations/Backend____Jetty.xml
index 17fe544..4abe07e 100644
--- a/.idea/runConfigurations/Backend____Jetty.xml
+++ b/.idea/runConfigurations/Backend____Jetty.xml
@@ -2,7 +2,7 @@
   <configuration default="false" name="Backend :: Jetty" type="Application" factoryName="Application" singleton="true">
     <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
     <extension name="org.jetbrains.fluid.java.FluidRunConfigurationExtension" fluid.enabledBundledTracers="false" fluid.enabledBundledTracers.list="" />
-    <option name="MAIN_CLASS_NAME" value="org.jetbrains.ktor.jetty.DevelopmentHost" />
+    <option name="MAIN_CLASS_NAME" value="io.ktor.server.jetty.DevelopmentEngine" />
     <option name="VM_PARAMETERS" value="" />
     <option name="PROGRAM_PARAMETERS" value="" />
     <option name="WORKING_DIRECTORY" value="file://$PROJECT_DIR$" />
@@ -11,7 +11,7 @@
     <option name="ENABLE_SWING_INSPECTOR" value="false" />
     <option name="ENV_VARIABLES" />
     <option name="PASS_PARENT_ENVS" value="true" />
-    <module name="backend" />
+    <module name="backend_main" />
     <envs />
     <RunnerSettings RunnerId="JProfiler" />
     <method />
diff --git a/backend/build.gradle b/backend/build.gradle
index 6097f03..f9c050d 100644
--- a/backend/build.gradle
+++ b/backend/build.gradle
@@ -5,21 +5,19 @@ apply plugin: 'kotlin'
 apply plugin: 'application'
 
 dependencies {
-    compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+    compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
     compile "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"
 
-    compile "org.jetbrains.ktor:ktor-locations:$ktor_version"
-    compile "org.jetbrains.ktor:ktor-html-builder:$ktor_version"
+    compile "io.ktor:ktor-locations:$ktor_version"
+    compile "io.ktor:ktor-html-builder:$ktor_version"
+    compile "io.ktor:ktor-gson:$ktor_version"
     compile "org.ehcache:ehcache:3.0.0.m4"
 
     compile "org.jetbrains.squash:squash-h2:$squash_version"
 
-    testCompile("org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version")
-    testCompile "org.jetbrains.ktor:ktor-test-host:$ktor_version"
+    testCompile "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"
+    testCompile "io.ktor:ktor-server-test-host:$ktor_version"
     testCompile "org.jsoup:jsoup:1.9.1"
-
-    compile "org.jetbrains.ktor:ktor-jetty:$ktor_version"
-    compile group: 'com.google.code.gson', name: 'gson', version: '2.8.0'
 }
 
 sourceSets {
@@ -41,4 +39,4 @@ kotlin {
     }
 }
 
-mainClassName = 'org.jetbrains.ktor.jetty.DevelopmentHost'
+mainClassName = 'io.ktor.server.jetty.DevelopmentEngine'
diff --git a/backend/src/org/jetbrains/demo/thinkter/Application.kt b/backend/src/org/jetbrains/demo/thinkter/Application.kt
index e5fb2b4..88b0f87 100644
--- a/backend/src/org/jetbrains/demo/thinkter/Application.kt
+++ b/backend/src/org/jetbrains/demo/thinkter/Application.kt
@@ -1,17 +1,18 @@
 package org.jetbrains.demo.thinkter
 
-import com.google.gson.*
-import org.jetbrains.demo.thinkter.dao.*
-import org.jetbrains.demo.thinkter.model.*
-import org.jetbrains.ktor.application.*
-import org.jetbrains.ktor.content.*
-import org.jetbrains.ktor.features.*
-import org.jetbrains.ktor.http.*
-import org.jetbrains.ktor.locations.*
-import org.jetbrains.ktor.logging.*
-import org.jetbrains.ktor.routing.*
-import org.jetbrains.ktor.sessions.*
-import org.jetbrains.ktor.transform.*
+import io.ktor.application.Application
+import io.ktor.application.call
+import io.ktor.application.install
+import io.ktor.features.*
+import io.ktor.gson.gson
+import io.ktor.http.HttpStatusCode
+import io.ktor.locations.Locations
+import io.ktor.response.respond
+import io.ktor.routing.routing
+import io.ktor.sessions.SessionTransportTransformerMessageAuthentication
+import io.ktor.sessions.Sessions
+import io.ktor.sessions.cookie
+import org.jetbrains.demo.thinkter.dao.ThinkterDatabase
 
 data class Session(val userId: String)
 
@@ -21,21 +22,21 @@ fun Application.main() {
     install(DefaultHeaders)
     install(CallLogging)
     install(ConditionalHeaders)
-    install(PartialContentSupport)
+    install(PartialContent)
     install(Compression)
     install(Locations)
     install(StatusPages) {
-        exception<NotImplementedError> { call.respond(HttpStatusCode.NotImplemented) }
+        exception<NotImplementedError> { call.respond(HttpStatusCode.NotImplemented, "${it.message}") }
     }
-
-    withSessions<Session> {
-        withCookieByValue {
-            settings = SessionCookiesSettings(transformers = listOf(SessionCookieTransformerMessageAuthentication(hashKey)))
+    install(ContentNegotiation) {
+        gson {
+            setPrettyPrinting()
         }
     }
-
-    transform.register<RpcData> {
-        TextContent(Gson().toJson(it), ContentType.Application.Json)
+    install(Sessions) {
+        cookie<Session>(name = "SESSION") {
+            transform(SessionTransportTransformerMessageAuthentication(hashKey))
+        }
     }
 
     routing {
diff --git a/backend/src/org/jetbrains/demo/thinkter/ApplicationPage.kt b/backend/src/org/jetbrains/demo/thinkter/ApplicationPage.kt
index 7479793..5490ecc 100644
--- a/backend/src/org/jetbrains/demo/thinkter/ApplicationPage.kt
+++ b/backend/src/org/jetbrains/demo/thinkter/ApplicationPage.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.demo.thinkter
 
 import kotlinx.html.*
-import org.jetbrains.ktor.html.*
+import io.ktor.html.*
 
 class ApplicationPage : Template<HTML> {
     val caption = Placeholder<TITLE>()
@@ -45,7 +45,7 @@ class ApplicationPage : Template<HTML> {
                 }
             }
             div { id = "content" }
-            script(src = "frontend/frontend.bundle.js")
+            script(src = "frontend/frontend.bundle.js", block = {})
         }
     }
 }
diff --git a/backend/src/org/jetbrains/demo/thinkter/Delete.kt b/backend/src/org/jetbrains/demo/thinkter/Delete.kt
index 21254fb..e97de38 100644
--- a/backend/src/org/jetbrains/demo/thinkter/Delete.kt
+++ b/backend/src/org/jetbrains/demo/thinkter/Delete.kt
@@ -2,15 +2,18 @@ package org.jetbrains.demo.thinkter
 
 import org.jetbrains.demo.thinkter.dao.*
 import org.jetbrains.demo.thinkter.model.*
-import org.jetbrains.ktor.application.*
-import org.jetbrains.ktor.http.*
-import org.jetbrains.ktor.locations.*
-import org.jetbrains.ktor.routing.*
-import org.jetbrains.ktor.sessions.*
+import io.ktor.application.*
+import io.ktor.http.*
+import io.ktor.locations.*
+import io.ktor.request.receive
+import io.ktor.response.respond
+import io.ktor.routing.*
+import io.ktor.sessions.get
+import io.ktor.sessions.sessions
 
 fun Route.delete(dao: ThinkterStorage, hashFunction: (String) -> String) {
     get<ThoughtDelete> {
-        val user = call.sessionOrNull<Session>()?.let { dao.user(it.userId) }
+        val user = call.sessions.get<Session>()?.let { dao.user(it.userId) }
         val date = System.currentTimeMillis()
 
         if (user == null) {
@@ -22,13 +25,19 @@ fun Route.delete(dao: ThinkterStorage, hashFunction: (String) -> String) {
     }
 
     post<ThoughtDelete> {
-        val user = call.sessionOrNull<Session>()?.let { dao.user(it.userId) }
-        val thought = dao.getThought(it.id)
+        val user = call.sessions.get<Session>()?.let { dao.user(it.userId) }
 
-        if (user == null || thought.userId != user.userId || !call.verifyCode(it.date, user, it.code, hashFunction)) {
+        val form = call.receive<Parameters>()
+        val id = form["id"]?.toInt() ?: -1
+        val date = form["date"]?.toLong() ?: -1
+        val code = form["code"] ?: ""
+
+        val thought = dao.getThought(id)
+
+        if (user == null || thought.userId != user.userId || !call.verifyCode(date, user, code, hashFunction)) {
             call.respond(HttpStatusCode.Forbidden)
         } else {
-            dao.deleteThought(it.id)
+            dao.deleteThought(id)
             call.respond(object : RpcData {})
         }
     }
diff --git a/backend/src/org/jetbrains/demo/thinkter/Index.kt b/backend/src/org/jetbrains/demo/thinkter/Index.kt
index 63ece58..2ee1128 100644
--- a/backend/src/org/jetbrains/demo/thinkter/Index.kt
+++ b/backend/src/org/jetbrains/demo/thinkter/Index.kt
@@ -2,30 +2,30 @@ package org.jetbrains.demo.thinkter
 
 import org.jetbrains.demo.thinkter.dao.*
 import org.jetbrains.demo.thinkter.model.*
-import org.jetbrains.ktor.application.*
-import org.jetbrains.ktor.html.*
-import org.jetbrains.ktor.http.*
-import org.jetbrains.ktor.locations.*
-import org.jetbrains.ktor.response.*
-import org.jetbrains.ktor.routing.*
-import org.jetbrains.ktor.sessions.*
+import io.ktor.application.*
+import io.ktor.html.*
+import io.ktor.http.*
+import io.ktor.locations.*
+import io.ktor.response.*
+import io.ktor.routing.*
+import io.ktor.sessions.*
 import java.time.*
 
 fun Route.index(storage: ThinkterStorage) {
-    contentType(ContentType.Text.Html) {
+    accept(ContentType.Text.Html) {
         get<Index> {
             call.respondHtmlTemplate(ApplicationPage()) {
                 caption { +"Thinkter" }
             }
         }
     }
-    contentType(ContentType.Application.Json) {
+    accept(ContentType.Application.Json) {
         get<Index> {
-            val user = call.sessionOrNull<Session>()?.let { storage.user(it.userId) }
+            val user = call.sessions.get<Session>()?.let { storage.user(it.userId) }
             val top = storage.top(10).map(storage::getThought)
             val latest = storage.latest(10).map(storage::getThought)
 
-            call.response.pipeline.intercept(ApplicationResponsePipeline.After) {
+            call.response.pipeline.intercept(ApplicationSendPipeline.After) {
                 val etagString = user?.userId + "," + top.joinToString { it.id.toString() } + latest.joinToString { it.id.toString() }
                 call.response.etag(etagString)
             }
diff --git a/backend/src/org/jetbrains/demo/thinkter/Locations.kt b/backend/src/org/jetbrains/demo/thinkter/Locations.kt
index 7b3a668..5de6a67 100644
--- a/backend/src/org/jetbrains/demo/thinkter/Locations.kt
+++ b/backend/src/org/jetbrains/demo/thinkter/Locations.kt
@@ -1,35 +1,35 @@
 package org.jetbrains.demo.thinkter
 
-import org.jetbrains.ktor.locations.*
+import io.ktor.locations.*
 
 
-@location("/")
+@Location("/")
 class Index()
 
-@location("/poll")
+@Location("/poll")
 class Poll(val lastTime: String = "")
 
-@location("/post-new")
+@Location("/post-new")
 data class PostThought(val text: String = "", val date: Long = 0L, val code: String = "", val replyTo: Int? = null)
 
-@location("/thought/{id}/delete")
+@Location("/thought/{id}/delete")
 data class ThoughtDelete(val id: Int, val date: Long, val code: String)
 
-@location("/thought/{id}")
+@Location("/thought/{id}")
 data class ViewThought(val id: Int)
 
-@location("/user/{user}")
+@Location("/user/{user}")
 @Deprecated("")
 data class UserPage(val user: String)
 
-@location("/user/{user}/thoughts")
+@Location("/user/{user}/thoughts")
 data class UserThoughts(val user: String)
 
-@location("/register")
+@Location("/register")
 data class Register(val userId: String = "", val displayName: String = "", val email: String = "", val password: String = "", val error: String = "")
 
-@location("/login")
+@Location("/login")
 data class Login(val userId: String = "", val password: String = "", val error: String = "")
 
-@location("/logout")
+@Location("/logout")
 class Logout()
\ No newline at end of file
diff --git a/backend/src/org/jetbrains/demo/thinkter/Login.kt b/backend/src/org/jetbrains/demo/thinkter/Login.kt
index acaffd1..44e1b99 100644
--- a/backend/src/org/jetbrains/demo/thinkter/Login.kt
+++ b/backend/src/org/jetbrains/demo/thinkter/Login.kt
@@ -2,15 +2,17 @@ package org.jetbrains.demo.thinkter
 
 import org.jetbrains.demo.thinkter.dao.*
 import org.jetbrains.demo.thinkter.model.*
-import org.jetbrains.ktor.application.*
-import org.jetbrains.ktor.http.*
-import org.jetbrains.ktor.locations.*
-import org.jetbrains.ktor.routing.*
-import org.jetbrains.ktor.sessions.*
+import io.ktor.application.*
+import io.ktor.http.*
+import io.ktor.locations.*
+import io.ktor.request.receive
+import io.ktor.response.respond
+import io.ktor.routing.*
+import io.ktor.sessions.*
 
 fun Route.login(dao: ThinkterStorage, hash: (String) -> String) {
     get<Login> {
-        val user = call.sessionOrNull<Session>()?.let { dao.user(it.userId) }
+        val user = call.sessions.get<Session>()?.let { dao.user(it.userId) }
         if (user == null) {
             call.respond(HttpStatusCode.Forbidden)
         } else {
@@ -18,22 +20,26 @@ fun Route.login(dao: ThinkterStorage, hash: (String) -> String) {
         }
     }
     post<Login> {
+        val form = call.receive<Parameters>()
+        val userId = form["userId"] ?: ""
+        val password = form["password"] ?: ""
+
         val login = when {
-            it.userId.length < 4 -> null
-            it.password.length < 6 -> null
-            !userNameValid(it.userId) -> null
-            else -> dao.user(it.userId, hash(it.password))
+            userId.length < 4 -> null
+            password.length < 6 -> null
+            !userNameValid(userId) -> null
+            else -> dao.user(userId, hash(password))
         }
 
         if (login == null) {
             call.respond(LoginResponse(error = "Invalid username or password"))
         } else {
-            call.session(Session(login.userId))
+            call.sessions.set(Session(login.userId))
             call.respond(LoginResponse(login))
         }
     }
     post<Logout> {
-        call.clearSession()
+        call.sessions.clear<Session>()
         call.respond(HttpStatusCode.OK)
     }
 }
diff --git a/backend/src/org/jetbrains/demo/thinkter/PostThought.kt b/backend/src/org/jetbrains/demo/thinkter/PostThought.kt
index f4153f6..9df9621 100644
--- a/backend/src/org/jetbrains/demo/thinkter/PostThought.kt
+++ b/backend/src/org/jetbrains/demo/thinkter/PostThought.kt
@@ -2,15 +2,17 @@ package org.jetbrains.demo.thinkter
 
 import org.jetbrains.demo.thinkter.dao.*
 import org.jetbrains.demo.thinkter.model.*
-import org.jetbrains.ktor.application.*
-import org.jetbrains.ktor.http.*
-import org.jetbrains.ktor.locations.*
-import org.jetbrains.ktor.routing.*
-import org.jetbrains.ktor.sessions.*
+import io.ktor.application.*
+import io.ktor.http.*
+import io.ktor.locations.*
+import io.ktor.request.receive
+import io.ktor.response.respond
+import io.ktor.routing.*
+import io.ktor.sessions.*
 
 fun Route.postThought(dao: ThinkterStorage, hashFunction: (String) -> String) {
     get<PostThought> {
-        val user = call.sessionOrNull<Session>()?.let { dao.user(it.userId) }
+        val user = call.sessions.get<Session>()?.let { dao.user(it.userId) }
 
         if (user == null) {
             call.respond(HttpStatusCode.Forbidden)
@@ -21,11 +23,19 @@ fun Route.postThought(dao: ThinkterStorage, hashFunction: (String) -> String) {
         }
     }
     post<PostThought> {
-        val user = call.sessionOrNull<Session>()?.let { dao.user(it.userId) }
-        if (user == null || !call.verifyCode(it.date, user, it.code, hashFunction)) {
+        val user = call.sessions.get<Session>()?.let { dao.user(it.userId) }
+
+        val form = call.receive<Parameters>()
+        val date = form["date"]?.toLong() ?: -1
+        val code = form["code"] ?: ""
+
+        if (user == null || !call.verifyCode(date, user, code, hashFunction)) {
             call.respond(HttpStatusCode.Forbidden)
         } else {
-            val id = dao.createThought(user.userId, it.text, it.replyTo)
+            val text = form["text"] ?: ""
+            val replyTo = form["replyTo"]?.toInt()
+
+            val id = dao.createThought(user.userId, text, replyTo)
             call.respond(PostThoughtResult(dao.getThought(id)))
         }
     }
diff --git a/backend/src/org/jetbrains/demo/thinkter/Register.kt b/backend/src/org/jetbrains/demo/thinkter/Register.kt
index 0752763..15087b2 100644
--- a/backend/src/org/jetbrains/demo/thinkter/Register.kt
+++ b/backend/src/org/jetbrains/demo/thinkter/Register.kt
@@ -2,47 +2,52 @@ package org.jetbrains.demo.thinkter
 
 import org.jetbrains.demo.thinkter.dao.*
 import org.jetbrains.demo.thinkter.model.*
-import org.jetbrains.ktor.application.*
-import org.jetbrains.ktor.http.*
-import org.jetbrains.ktor.locations.*
-import org.jetbrains.ktor.routing.*
-import org.jetbrains.ktor.sessions.*
-import org.jetbrains.ktor.util.*
+import io.ktor.application.*
+import io.ktor.http.*
+import io.ktor.locations.*
+import io.ktor.request.receive
+import io.ktor.response.respond
+import io.ktor.routing.*
+import io.ktor.sessions.*
 
 fun Route.register(dao: ThinkterStorage, hashFunction: (String) -> String) {
-    post<Register> { form ->
-        val vm = call.request.content.get<ValuesMap>()
-
-        val user = call.sessionOrNull<Session>()?.let { dao.user(it.userId) }
+    post<Register> {
+        val user = call.sessions.get<Session>()?.let { dao.user(it.userId) }
         if (user != null) {
             call.redirect(LoginResponse(user))
         } else {
-            if (form.password.length < 6) {
+            val form = call.receive<Parameters>()
+            val userId = form["userId"] ?: ""
+            val email = form["email"] ?: ""
+            val displayName = form["displayName"] ?: ""
+            val password = form["password"] ?: ""
+
+            if (password.length < 6) {
                 call.respond(LoginResponse(error = "Password should be at least 6 characters long"))
-            } else if (form.userId.length < 4) {
+            } else if (userId.length < 4) {
                 call.respond(LoginResponse(error = "Login should be at least 4 characters long"))
-            } else if (!userNameValid(form.userId)) {
+            } else if (!userNameValid(userId)) {
                 call.respond(LoginResponse(error = "Login should be consists of digits, letters, dots or underscores"))
-            } else if (dao.user(form.userId) != null) {
+            } else if (dao.user(userId) != null) {
                 call.respond(LoginResponse(error = "User with the following login is already registered"))
             } else {
-                val hash = hashFunction(form.password)
-                val newUser = User(form.userId, form.email, form.displayName, hash)
+                val hash = hashFunction(password)
+                val newUser = User(userId, email, displayName, hash)
 
                 try {
                     dao.createUser(newUser)
                 } catch (e: Throwable) {
-                    if (dao.user(form.userId) != null) {
+                    if (dao.user(userId) != null) {
                         call.respond(LoginResponse(error = "User with the following login is already registered"))
-                    } else if (dao.userByEmail(form.email) != null) {
-                        call.respond(LoginResponse(error = "User with the following email ${form.email} is already registered"))
+                    } else if (dao.userByEmail(email) != null) {
+                        call.respond(LoginResponse(error = "User with the following email $email is already registered"))
                     } else {
                         application.environment.log.error("Failed to register user", e)
                         call.respond(LoginResponse(error = "Failed to register"))
                     }
                 }
 
-                call.session(Session(newUser.userId))
+                call.sessions.set(Session(newUser.userId))
                 call.respond(LoginResponse(newUser))
             }
         }
diff --git a/backend/src/org/jetbrains/demo/thinkter/UserPage.kt b/backend/src/org/jetbrains/demo/thinkter/UserPage.kt
index a97c0e9..4bc1c14 100644
--- a/backend/src/org/jetbrains/demo/thinkter/UserPage.kt
+++ b/backend/src/org/jetbrains/demo/thinkter/UserPage.kt
@@ -2,10 +2,11 @@ package org.jetbrains.demo.thinkter
 
 import org.jetbrains.demo.thinkter.dao.*
 import org.jetbrains.demo.thinkter.model.*
-import org.jetbrains.ktor.application.*
-import org.jetbrains.ktor.http.*
-import org.jetbrains.ktor.locations.*
-import org.jetbrains.ktor.routing.*
+import io.ktor.application.*
+import io.ktor.http.*
+import io.ktor.locations.*
+import io.ktor.response.respond
+import io.ktor.routing.*
 
 fun Route.userPage(dao: ThinkterStorage) {
     get<UserThoughts> {
diff --git a/backend/src/org/jetbrains/demo/thinkter/Utilities.kt b/backend/src/org/jetbrains/demo/thinkter/Utilities.kt
index 315983b..22c6f10 100644
--- a/backend/src/org/jetbrains/demo/thinkter/Utilities.kt
+++ b/backend/src/org/jetbrains/demo/thinkter/Utilities.kt
@@ -1,13 +1,12 @@
 package org.jetbrains.demo.thinkter
 
-import org.jetbrains.demo.thinkter.dao.*
 import org.jetbrains.demo.thinkter.model.*
-import org.jetbrains.ktor.application.*
-import org.jetbrains.ktor.http.*
-import org.jetbrains.ktor.locations.*
-import org.jetbrains.ktor.request.*
-import org.jetbrains.ktor.response.*
-import org.jetbrains.ktor.util.*
+import io.ktor.application.*
+import io.ktor.http.*
+import io.ktor.locations.*
+import io.ktor.request.*
+import io.ktor.response.*
+import io.ktor.util.*
 import java.net.*
 import java.util.concurrent.*
 import javax.crypto.*
diff --git a/backend/src/org/jetbrains/demo/thinkter/ViewThought.kt b/backend/src/org/jetbrains/demo/thinkter/ViewThought.kt
index 9a58018..1c45a6e 100644
--- a/backend/src/org/jetbrains/demo/thinkter/ViewThought.kt
+++ b/backend/src/org/jetbrains/demo/thinkter/ViewThought.kt
@@ -2,14 +2,15 @@ package org.jetbrains.demo.thinkter
 
 import org.jetbrains.demo.thinkter.dao.*
 import org.jetbrains.demo.thinkter.model.*
-import org.jetbrains.ktor.application.*
-import org.jetbrains.ktor.locations.*
-import org.jetbrains.ktor.routing.*
-import org.jetbrains.ktor.sessions.*
+import io.ktor.application.*
+import io.ktor.locations.*
+import io.ktor.response.respond
+import io.ktor.routing.*
+import io.ktor.sessions.*
 
 fun Route.viewThought(dao: ThinkterStorage, hashFunction: (String) -> String) {
     get<ViewThought> {
-        val user = call.sessionOrNull<Session>()?.let { dao.user(it.userId) }
+        val user = call.sessions.get<Session>()?.let { dao.user(it.userId) }
         val date = System.currentTimeMillis()
         val code = if (user != null) call.securityCode(date, user, hashFunction) else null
 
diff --git a/build.gradle b/build.gradle
index ef2d7df..95f27d8 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,9 +1,9 @@
 group = 'org.jetbrains.demo.thinkter'
-version = '0.0.1-SNAPSHOT'
+version = '0.0.2-SNAPSHOT'
 
 subprojects { p ->
     p.buildscript {
-        ext.kotlin_version = "1.1.51"
+        ext.kotlin_version = "1.2.21"
 
         repositories {
             mavenLocal()
@@ -13,16 +13,16 @@ subprojects { p ->
         
         dependencies {
             classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-            classpath "org.jetbrains.kotlin:kotlin-frontend-plugin:0.0.23"
+            classpath "org.jetbrains.kotlin:kotlin-frontend-plugin:0.0.27"
         }
     }
 }
 
 subprojects {
-    ext.kotlin_version = "1.1.51"
-    ext.html_version = "0.6.6"
-    ext.ktor_version = "0.3.0"
-    ext.squash_version = "0.2.2"
+    ext.kotlin_version = "1.2.21"
+    ext.html_version = "0.6.7"
+    ext.ktor_version = "0.9.1"
+    ext.squash_version = "0.2.4"
 
     repositories {
         mavenLocal()