feat: new services for food user and order

Author: =

src/main/kotlin/com/example/service/DatabaseModule.kt

@@ -1,6 +1,7 @@
 package com.example.service
 
 import com.example.table.Foods
+import com.example.table.OrderItems
 import com.example.table.Orders
 import com.example.table.Users
 import kotlinx.coroutines.Dispatchers
@@ -19,6 +20,7 @@ object DatabaseModule {
             SchemaUtils.create(Users)
             SchemaUtils.create(Foods)
             SchemaUtils.create(Orders)
+            SchemaUtils.create(OrderItems)
         }
     }
 

src/main/kotlin/com/example/service/FoodService.kt

@@ -0,0 +1,15 @@
+package com.example.service
+
+import com.example.dto.FoodDto
+import com.example.service.impl.FoodServiceImpl
+
+interface FoodService {
+    suspend fun getFoodDetail(foodId: Int): Result<FoodDto>
+    suspend fun searchFood(query: String): Result<List<FoodDto>>
+    suspend fun getAllFoods(): Result<List<FoodDto>>
+    suspend fun getFoodsByCategory(type: String): Result<List<FoodDto>>
+    suspend fun registerFood(foodDto: FoodDto): Result<Unit>
+    companion object {
+        val foodService: FoodService by lazy { FoodServiceImpl() }
+    }
+}

src/main/kotlin/com/example/service/OrderService.kt

@@ -1,9 +1,17 @@
 package com.example.service
 
+import com.example.dto.FoodDto
 import com.example.dto.OrderDto
-import kotlinx.coroutines.flow.Flow
+import com.example.service.impl.OrderServiceImpl
+import java.util.*
 
 interface OrderService {
-    suspend fun getOrder(userId: Int): Flow<List<OrderDto>>
-    suspend fun createOrder(orderDto: OrderDto): Result<Boolean>
+    suspend fun getActiveOrder(userId: UUID): Result<OrderDto>
+    suspend fun addFoodToOrder(userId: UUID, foodDto: FoodDto, quantity: Int): Result<Int>
+    suspend fun updateItemInOrder(orderId: Int, quantity: Int): Result<Boolean>
+    suspend fun clearCurrentOrder(userId: UUID): Result<Boolean>
+
+    companion object {
+        val orderService: OrderService by lazy { OrderServiceImpl() }
+    }
 }

src/main/kotlin/com/example/service/UserService.kt

@@ -4,13 +4,18 @@ import com.example.dto.UserDto
 import com.example.dto.UserLoginDto
 import com.example.dto.UserRegisterDto
 import com.example.dto.UserUpdateLocationDto
+import com.example.service.impl.UserServiceImpl
 import kotlinx.coroutines.flow.Flow
 import java.util.UUID
 
 interface UserService {
     suspend fun login(userLoginDto: UserLoginDto): Result<String>
     suspend fun register(userRegisterDto: UserRegisterDto): Result<Boolean>
-    suspend fun getProfileFlow(userId: Int): Result<Flow<UserDto>>
+    suspend fun getProfileFlow(userId: UUID): Result<Flow<UserDto>>
     suspend fun getProfile(userId: UUID): Result<UserDto>
-    suspend fun updateUserLocation(userId: Int, userUpdateLocationDto: UserUpdateLocationDto): Result<Boolean>
+    suspend fun updateUserLocation(userId: UUID, userUpdateLocationDto: UserUpdateLocationDto): Result<Boolean>
+
+    companion object {
+        val userService: UserService by lazy { UserServiceImpl() }
+    }
 }

src/main/kotlin/com/example/service/impl/FoodServiceImpl.kt

@@ -0,0 +1,50 @@
+package com.example.service.impl
+
+import com.example.dto.FoodDto
+import com.example.service.DatabaseModule.dbQuery
+import com.example.service.FoodService
+import com.example.table.Foods
+import com.example.util.ext.toFoodDto
+import org.jetbrains.exposed.sql.insert
+import org.jetbrains.exposed.sql.lowerCase
+import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.selectAll
+
+class FoodServiceImpl : FoodService {
+    override suspend fun getFoodDetail(foodId: Int): Result<FoodDto> = dbQuery {
+        val food = Foods.select { Foods.id eq foodId }.singleOrNull()
+        food?.toFoodDto() ?: throw Exception("Food not found")
+    }
+
+    override suspend fun searchFood(query: String): Result<List<FoodDto>> = dbQuery {
+        val searchStatement = Foods.select {
+            (Foods.name.lowerCase() like "%$query%")
+        }
+        val foods = searchStatement.map { it.toFoodDto() }
+        foods
+    }
+
+    override suspend fun getAllFoods(): Result<List<FoodDto>> = dbQuery {
+        val allFoods = Foods.selectAll()
+        val foods = allFoods.map { it.toFoodDto() }
+        foods
+    }
+
+    override suspend fun getFoodsByCategory(type: String): Result<List<FoodDto>> = dbQuery {
+        val foodsByCategory = Foods.select { Foods.category eq type }
+        val foods = foodsByCategory.map { it.toFoodDto() }
+        foods
+    }
+
+    override suspend fun registerFood(foodDto: FoodDto): Result<Unit> = dbQuery {
+        Foods.insert {
+            it[name] = foodDto.name
+            it[description] = foodDto.description
+            it[price] = foodDto.price
+            it[rating] = foodDto.rating
+            it[orderCount] = foodDto.orderCount
+            it[category] = foodDto.category
+            it[imageUrl] = foodDto.imageUrl
+        }
+    }
+}

src/main/kotlin/com/example/service/impl/OrderServiceImpl.kt

@@ -0,0 +1,91 @@
+package com.example.service.impl
+
+import com.example.dto.FoodDto
+import com.example.dto.OrderDto
+import com.example.dto.OrderStatus
+import com.example.service.DatabaseModule.dbQuery
+import com.example.service.OrderService
+import com.example.table.Foods
+import com.example.table.OrderItems
+import com.example.table.Orders
+import com.example.util.ext.toFoodDto
+import com.example.util.ext.toOrderDto
+import org.jetbrains.exposed.sql.and
+import org.jetbrains.exposed.sql.insert
+import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.update
+import java.util.*
+
+class OrderServiceImpl : OrderService {
+    override suspend fun getActiveOrder(userId: UUID): Result<OrderDto> = dbQuery {
+        val card = Orders.select {
+            (Orders.userId eq userId) and (Orders.orderStatus eq OrderStatus.Started)
+        }
+        if (card.empty()) {
+            throw Exception("No active order found")
+        }
+        card.single().toOrderDto()
+    }
+
+    override suspend fun addFoodToOrder(userId: UUID, foodDto: FoodDto, quantity: Int): Result<Int> = dbQuery {
+        val order = Orders.select {
+            (Orders.userId eq userId) and (Orders.orderStatus eq OrderStatus.Started)
+        }.forUpdate()
+
+        if (order.empty()) {
+            createOrder(userId)
+        }
+
+        val activeOrder = Orders.select {
+            (Orders.userId eq userId) and (Orders.orderStatus eq OrderStatus.Started)
+        }.forUpdate().single()
+
+        val orderId = OrderItems.insert {
+            it[OrderItems.orderId] = activeOrder[Orders.id]
+            it[OrderItems.foodId] = foodDto.id
+            it[OrderItems.quantity] = quantity
+            it[OrderItems.price] = foodDto.price.toBigDecimal()
+        }[OrderItems.id]
+
+        val totalPrice = activeOrder[Orders.totalPrice] + (foodDto.price * quantity).toBigDecimal()
+        Orders.update({ Orders.id eq activeOrder[Orders.id] }) {
+            it[Orders.totalPrice] = totalPrice
+        }
+
+        orderId
+    }
+
+    override suspend fun updateItemInOrder(orderId: Int, quantity: Int): Result<Boolean> = dbQuery {
+        val orderItem = OrderItems.select { OrderItems.id eq orderId }.singleOrNull()
+        if (orderItem == null) {
+            throw Exception("Order item not found")
+        }
+
+        val food = Foods.select { Foods.id eq orderItem[OrderItems.foodId] }.single()
+        val totalPrice = (food[Foods.price] * quantity).toBigDecimal()
+        OrderItems.update({ OrderItems.id eq orderId }) {
+            it[OrderItems.quantity] = quantity
+            it[OrderItems.price] = totalPrice
+        }
+
+        val activeOrder = Orders.select { Orders.id eq orderItem[OrderItems.orderId] }.single()
+        val orderItems = OrderItems.select { OrderItems.orderId eq activeOrder[Orders.id] }
+        val newTotalPrice = orderItems.sumOf { it[OrderItems.price].toDouble() }.toBigDecimal()
+        Orders.update({ Orders.id eq activeOrder[Orders.id] }) {
+            it[Orders.totalPrice] = newTotalPrice
+        }
+
+        true
+    }
+
+    override suspend fun clearCurrentOrder(userId: UUID): Result<Boolean> {
+        TODO("Not yet implemented")
+    }
+
+    private fun createOrder(userId: UUID) {
+        Orders.insert {
+            it[Orders.userId] = userId
+            it[Orders.orderStatus] = OrderStatus.Started
+        }
+    }
+}

src/main/kotlin/com/example/service/impl/UserServiceImpl.kt

@@ -7,12 +7,10 @@ import com.example.dto.UserUpdateLocationDto
 import com.example.service.DatabaseModule.dbQuery
 import com.example.service.UserService
 import com.example.table.Users
+import com.example.util.ext.toUserDto
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.asFlow
-import org.jetbrains.exposed.sql.ResultRow
-import org.jetbrains.exposed.sql.and
-import org.jetbrains.exposed.sql.insert
-import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.*
 import java.util.UUID
 
 class UserServiceImpl : UserService {
@@ -43,12 +41,12 @@ class UserServiceImpl : UserService {
         }
     }
 
-    override suspend fun getProfileFlow(userId: Int): Result<Flow<UserDto>> = dbQuery {
-        val user = Users.select { Users.id eq userId }
+    override suspend fun getProfileFlow(userId: UUID): Result<Flow<UserDto>> = dbQuery {
+        val user = Users.select { Users.userId eq userId }
         if (user.empty()) {
             throw Exception("User not found")
         } else {
-            val userFlow = user.map(::resultRowToUserDto).asFlow()
+            val userFlow = user.map { it.toUserDto() }.asFlow()
             userFlow
         }
     }
@@ -58,30 +56,23 @@ class UserServiceImpl : UserService {
         if (user.empty()) {
             throw Exception("User not found")
         } else {
-            resultRowToUserDto(user.single())
+            user.single().toUserDto()
         }
     }
 
     override suspend fun updateUserLocation(
-        userId: Int,
+        userId: UUID,
         userUpdateLocationDto: UserUpdateLocationDto
-    ): Result<Boolean> {
-        TODO("Not yet implemented")
+    ): Result<Boolean> = dbQuery {
+        val user = Users.select { Users.userId eq userId }
+        if (user.empty()) {
+            throw Exception("User not found")
+        } else {
+            Users.update({ Users.userId eq userId }) {
+                it[latitude] = userUpdateLocationDto.latitude
+                it[longitude] = userUpdateLocationDto.longitude
+            }
+            true
+        }
     }
-
-    private fun resultRowToUserDto(row: ResultRow): UserDto = UserDto(
-        id = row[Users.id],
-        userId = row[Users.userId].toString(),
-        fullName = row[Users.fullName],
-        email = row[Users.email],
-        password = row[Users.password],
-        phoneNumber = row[Users.phoneNumber],
-        occupation = row[Users.occupation],
-        employer = row[Users.employer],
-        country = row[Users.country],
-        latitude = row[Users.latitude],
-        longitude = row[Users.longitude]
-    )
 }
-
-val userService: UserService = UserServiceImpl()