Merge http4k

app/src/main/kotlin/controllers/BaseController.kt

@@ -0,0 +1,13 @@
+package be.simplenotes.app.controllers
+
+import be.simplenotes.app.extensions.html
+import be.simplenotes.app.views.BaseView
+import be.simplenotes.domain.security.JwtPayload
+import org.http4k.core.Request
+import org.http4k.core.Response
+import org.http4k.core.Status.Companion.OK
+
+class BaseController(private val view: BaseView) {
+    fun index(@Suppress("UNUSED_PARAMETER") request: Request, jwtPayload: JwtPayload?) =
+        Response(OK).html(view.renderHome(jwtPayload))
+}

app/src/main/kotlin/controllers/NoteController.kt

@@ -0,0 +1,96 @@
+package be.simplenotes.app.controllers
+
+import be.simplenotes.app.extensions.html
+import be.simplenotes.app.extensions.redirect
+import be.simplenotes.app.views.NoteView
+import be.simplenotes.domain.security.JwtPayload
+import be.simplenotes.domain.usecases.NoteService
+import be.simplenotes.domain.usecases.markdown.InvalidMeta
+import be.simplenotes.domain.usecases.markdown.MissingMeta
+import be.simplenotes.domain.usecases.markdown.ValidationError
+import org.http4k.core.Method
+import org.http4k.core.Request
+import org.http4k.core.Response
+import org.http4k.core.Status.Companion.BAD_REQUEST
+import org.http4k.core.Status.Companion.NOT_FOUND
+import org.http4k.core.Status.Companion.OK
+import org.http4k.core.body.form
+import org.http4k.routing.path
+import java.util.*
+import kotlin.math.abs
+
+class NoteController(
+    private val view: NoteView,
+    private val noteService: NoteService,
+) {
+
+    fun new(request: Request, jwtPayload: JwtPayload): Response {
+        if (request.method == Method.GET) return Response(OK).html(view.noteEditor(jwtPayload))
+
+        val markdownForm = request.form("markdown") ?: ""
+
+        return noteService.create(jwtPayload.userId, markdownForm).fold({
+            val html = when (it) {
+                MissingMeta -> view.noteEditor(jwtPayload, error = "Missing note metadata", textarea = markdownForm)
+                InvalidMeta -> view.noteEditor(jwtPayload, error = "Invalid note metadata", textarea = markdownForm)
+                is ValidationError -> view.noteEditor(jwtPayload, validationErrors = it.validationErrors, textarea = markdownForm)
+            }
+            Response(BAD_REQUEST).html(html)
+        }, {
+            Response.redirect("/notes/${it.uuid}")
+        })
+    }
+
+    fun list(request: Request, jwtPayload: JwtPayload): Response {
+        val currentPage = request.query("page")?.toIntOrNull()?.let(::abs) ?: 1
+        val (pages, notes) = noteService.paginatedNotes(jwtPayload.userId, currentPage)
+        return Response(OK).html(view.notes(jwtPayload, notes, currentPage, pages))
+    }
+
+    fun note(request: Request, jwtPayload: JwtPayload): Response {
+        val noteUuid = request.uuidPath() ?: return Response(NOT_FOUND)
+
+        if (request.method == Method.POST && request.form("delete") != null) {
+            return if (noteService.delete(jwtPayload.userId, noteUuid))
+                Response.redirect("/notes") // FIXME: flash cookie to show success ?
+            else
+                Response(NOT_FOUND) // FIXME: show an error
+        }
+
+        val note = noteService.find(jwtPayload.userId, noteUuid) ?: return Response(NOT_FOUND)
+        return Response(OK).html(view.renderedNote(jwtPayload, note))
+    }
+
+    fun edit(request: Request, jwtPayload: JwtPayload): Response {
+        val noteUuid = request.uuidPath() ?: return Response(NOT_FOUND)
+        val note = noteService.find(jwtPayload.userId, noteUuid) ?: return Response(NOT_FOUND)
+
+        if (request.method == Method.GET) {
+            return Response(OK).html(view.noteEditor(jwtPayload, textarea = note.markdown))
+        }
+
+        val markdownForm = request.form("markdown") ?: ""
+
+        return noteService.update(jwtPayload.userId, note.uuid, markdownForm).fold({
+            val html = when (it) {
+                MissingMeta -> view.noteEditor(jwtPayload, error = "Missing note metadata", textarea = markdownForm)
+                InvalidMeta -> view.noteEditor(jwtPayload, error = "Invalid note metadata", textarea = markdownForm)
+                is ValidationError -> view.noteEditor(jwtPayload, validationErrors = it.validationErrors, textarea = markdownForm)
+            }
+            Response(BAD_REQUEST).html(html)
+        }, {
+            Response.redirect("/notes/${note.uuid}")
+        })
+
+    }
+
+    private fun Request.uuidPath(): UUID? {
+        val uuidPath = path("uuid")!!
+        return try {
+            UUID.fromString(uuidPath)!!
+        } catch (e: IllegalArgumentException) {
+            null
+        }
+    }
+
+}

app/src/main/kotlin/controllers/UserController.kt

@@ -0,0 +1,112 @@
+package be.simplenotes.app.controllers
+
+import be.simplenotes.app.extensions.html
+import be.simplenotes.app.extensions.isSecure
+import be.simplenotes.app.extensions.redirect
+import be.simplenotes.app.views.UserView
+import be.simplenotes.domain.security.JwtPayload
+import be.simplenotes.domain.usecases.UserService
+import be.simplenotes.domain.usecases.login.*
+import be.simplenotes.domain.usecases.register.InvalidRegisterForm
+import be.simplenotes.domain.usecases.register.RegisterForm
+import be.simplenotes.domain.usecases.register.UserExists
+import org.http4k.core.Method.GET
+import org.http4k.core.Request
+import org.http4k.core.Response
+import org.http4k.core.Status.Companion.OK
+import org.http4k.core.body.form
+import org.http4k.core.cookie.Cookie
+import org.http4k.core.cookie.SameSite
+import org.http4k.core.cookie.cookie
+import org.http4k.core.cookie.invalidateCookie
+
+class UserController(
+    private val userService: UserService,
+    private val userView: UserView,
+) {
+    fun register(request: Request, jwtPayload: JwtPayload?): Response {
+        if (request.method == GET) return Response(OK).html(
+            userView.register(jwtPayload)
+        )
+
+        val result = userService.register(request.registerForm())
+
+        return result.fold(
+            {
+                val html = when (it) {
+                    UserExists -> userView.register(
+                        jwtPayload,
+                        error = "User already exists"
+                    )
+                    is InvalidRegisterForm ->
+                        userView.register(
+                            jwtPayload,
+                            validationErrors = it.validationErrors
+                        )
+                }
+                Response(OK).html(html)
+            },
+            {
+                Response.redirect("/login")
+            }
+        )
+    }
+
+    private fun Request.registerForm() = RegisterForm(form("username"), form("password"))
+    private fun Request.loginForm(): LoginForm = registerForm()
+
+    fun login(request: Request, jwtPayload: JwtPayload?): Response {
+        if (request.method == GET) return Response(OK).html(
+            userView.login(jwtPayload)
+        )
+
+        val result = userService.login(request.loginForm())
+
+        return result.fold(
+            {
+                val html = when (it) {
+                    Unregistered ->
+                        userView.login(
+                            jwtPayload,
+                            error = "User does not exist"
+                        )
+                    WrongPassword ->
+                        userView.login(
+                            jwtPayload,
+                            error = "Wrong password"
+                        )
+                    is InvalidLoginForm ->
+                        userView.login(
+                            jwtPayload,
+                            validationErrors = it.validationErrors
+                        )
+                }
+                Response(OK).html(html)
+            },
+            { token ->
+                Response.redirect("/").loginCookie(token, request.isSecure())
+            }
+        )
+    }
+
+    private fun Response.loginCookie(token: Token, secure: Boolean): Response {
+        // FIXME: expires
+        // val expiresAt = JWT.decode(token).expiresAt
+        // LocalDateTime.ofEpochSecond(expiresAt.time, 0)
+
+        return this.cookie(
+            Cookie(
+                name = "Authorization",
+                value = "Bearer $token",
+                path = "/",
+                httpOnly = true,
+                sameSite = SameSite.Lax,
+                secure = secure
+            )
+        )
+    }
+
+    fun logout(@Suppress("UNUSED_PARAMETER") request: Request) = Response.redirect("/")
+        .invalidateCookie("Authorization")
+
+}