feat: dtos and utils

Author: =

build.gradle.kts

@@ -43,4 +43,6 @@ dependencies {
     implementation("org.postgresql:postgresql:$postgresql_version")
     implementation("org.jetbrains.kotlinx:kotlinx-datetime:$kotlinx_datetime_version")
     implementation("org.jetbrains.exposed:exposed-java-time:$exposed_version")
+    implementation("io.ktor:ktor-server-request-validation:$ktor_version")
+    implementation("io.ktor:ktor-server-status-pages:$ktor_version")
 }

settings.gradle.kts

@@ -1 +1 @@
-rootProject.name = "food-api"
+rootProject.name = "food-delivery-backend"

src/main/kotlin/com/example/Application.kt

@@ -1,6 +1,6 @@
 package com.example
 
-import com.example.plugins.*
+import com.example.plugin.*
 import io.ktor.server.application.*
 import io.ktor.server.engine.*
 import io.ktor.server.netty.*
@@ -18,5 +18,6 @@ fun Application.module() {
     configureDatabase()
     configureSerialization()
     configureRouting()
-    configureUserRouting()
+    configureValidation()
+    configureStatusPages()
 }

src/main/kotlin/com/example/dto/UserDto.kt

@@ -9,15 +9,16 @@ enum class FoodType {
 @Serializable
 data class UserDto(
     val id: Int,
+    val userId: String,
     val fullName: String,
     val email: String,
     val password: String,
-    val phoneNumber: String,
-    val occupation: String,
-    val employer: String,
-    val country: String,
-    val latitude: Double,
-    val longitude: Double,
+    val phoneNumber: String? = null,
+    val occupation: String? = null,
+    val employer: String? = null,
+    val country: String? = null,
+    val latitude: Double? = null,
+    val longitude: Double? = null
 )
 
 @Serializable

src/main/kotlin/com/example/route/UserRoute.kt

@@ -0,0 +1,61 @@
+package com.example.route
+
+import com.example.dto.UserLoginDto
+import com.example.dto.UserRegisterDto
+import com.example.service.impl.userService
+import io.ktor.http.*
+import io.ktor.server.application.*
+import io.ktor.server.request.*
+import io.ktor.server.response.*
+import io.ktor.server.routing.*
+import java.util.UUID
+
+fun Application.userRoute() {
+    routing {
+        post("/register") {
+            val userRegisterDto = call.receive<UserRegisterDto>()
+            userService.register(userRegisterDto).fold(
+                onSuccess = { call.respond(HttpStatusCode.Created) },
+                onFailure = { throwable ->
+                    call.respond(
+                        status = HttpStatusCode.BadRequest,
+                        message = throwable.message ?: "Something went wrong"
+                    )
+                }
+            )
+        }
+
+        post("/login") {
+            val userLoginDto: UserLoginDto = call.receive()
+            userService.login(userLoginDto).fold(
+                onSuccess = { userId -> call.respond(message = userId) },
+                onFailure = { throwable ->
+                    call.respond(
+                        status = HttpStatusCode.Unauthorized,
+                        message = throwable.message ?: "Something went wrong"
+                    )
+                }
+            )
+        }
+
+        get("/profile/{userId}") {
+            val userId = call.parameters["userId"]?.let { UUID.fromString(it) }
+            if (userId == null) {
+                call.respond(
+                    status = HttpStatusCode.BadRequest,
+                    message = "Invalid user id"
+                )
+                return@get
+            }
+            userService.getProfile(userId).fold(
+                onSuccess = { userDto -> call.respond(userDto) },
+                onFailure = { throwable ->
+                    call.respond(
+                        status = HttpStatusCode.NotFound,
+                        message = throwable.message ?: "Something went wrong"
+                    )
+                }
+            )
+        }
+    }
+}

src/main/kotlin/com/example/util/ext/StringExt.kt

@@ -0,0 +1,9 @@
+package com.example.util.ext
+
+
+private const val MinPassPattern = 8
+private const val PassPattern = "^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=\\S+$).{4,}$"
+private const val EmailPattern = "^[A-Za-z0-9+_.-]+@(.+)\$"
+
+fun String.isValidEmail(): Boolean = matches(EmailPattern.toRegex())
+fun String.isValidPassword(): Boolean = length >= MinPassPattern && matches(PassPattern.toRegex())

src/main/kotlin/com/example/validation/UserValidation.kt

@@ -0,0 +1,36 @@
+package com.example.validation
+
+import com.example.dto.UserLoginDto
+import com.example.dto.UserRegisterDto
+import com.example.util.ext.isValidEmail
+import com.example.util.ext.isValidPassword
+import io.ktor.server.plugins.requestvalidation.*
+
+private fun validationError(message: String) = ValidationResult.Invalid(message)
+
+fun RequestValidationConfig.userValidation() {
+    validate<UserRegisterDto> { user ->
+        with(user) {
+            when {
+                fullName.isBlank() -> validationError("Full name cannot be empty")
+                email.isBlank() -> validationError("Email cannot be empty")
+                !email.isValidEmail() -> validationError("Invalid email")
+                password.isBlank() -> validationError("Password cannot be empty")
+                !password.isValidPassword() -> validationError("Invalid password")
+                else -> ValidationResult.Valid
+            }
+        }
+    }
+
+    validate<UserLoginDto> { user ->
+        with(user) {
+            when {
+                email.isBlank() -> validationError("Email cannot be empty")
+                !email.isValidEmail() -> validationError("Invalid email")
+                password.isBlank() -> validationError("Password cannot be empty")
+                !password.isValidPassword() -> validationError("Invalid password")
+                else -> ValidationResult.Valid
+            }
+        }
+    }
+}