refactor: for big decimal

Author: f-arslan

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

@@ -8,7 +8,7 @@ interface FoodService {
     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>
+    suspend fun registerFood(foodDto: FoodDto): Result<Boolean>
     companion object {
         val foodService: FoodService by lazy { FoodServiceImpl() }
     }

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

@@ -2,7 +2,6 @@ package com.example.service
 
 import com.example.dto.FoodDto
 import com.example.dto.GetOrderWithItemsDto
-import com.example.dto.OrderDto
 import com.example.service.impl.OrderServiceImpl
 import kotlinx.coroutines.flow.Flow
 import java.util.*

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

@@ -1,11 +1,11 @@
 package com.example.service.impl
 
 import com.example.dto.FoodDto
-import com.example.fake.foodDtos
 import com.example.service.DatabaseModule.dbQuery
 import com.example.service.FoodService
 import com.example.table.Foods
 import com.example.util.ext.toFoodDto
+import com.example.util.ext.toFoodType
 import org.jetbrains.exposed.sql.*
 
 class FoodServiceImpl : FoodService {
@@ -29,12 +29,12 @@ class FoodServiceImpl : FoodService {
     }
 
     override suspend fun getFoodsByCategory(type: String): Result<List<FoodDto>> = dbQuery {
-        val foodsByCategory = Foods.select { Foods.category eq type }
+        val foodsByCategory = Foods.select { Foods.category eq type.toFoodType() }
         val foods = foodsByCategory.map { it.toFoodDto() }
         foods
     }
 
-    override suspend fun registerFood(foodDto: FoodDto): Result<Unit> = dbQuery {
+    override suspend fun registerFood(foodDto: FoodDto): Result<Boolean> = dbQuery {
         Foods.insert {
             it[name] = foodDto.name
             it[description] = foodDto.description
@@ -44,5 +44,6 @@ class FoodServiceImpl : FoodService {
             it[category] = foodDto.category
             it[imageUrl] = foodDto.imageUrl
         }
+        true
     }
 }

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

@@ -1,14 +1,17 @@
 package com.example.service.impl
 
-import com.example.dto.*
+import com.example.dto.FoodDto
+import com.example.dto.GetOrderWithItemsDto
+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.Items
 import com.example.table.Orders
 import com.example.util.ext.toItemDto
 import com.example.util.ext.toOrderDto
-import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.asFlow
 import org.jetbrains.exposed.sql.*
 import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
 import java.util.*
@@ -56,11 +59,11 @@ class OrderServiceImpl : OrderService {
                 it[Items.orderId] = activeOrder[Orders.id]
                 it[Items.foodId] = foodDto.id
                 it[Items.quantity] = quantity
-                it[Items.price] = foodDto.price.toBigDecimal()
+                it[Items.price] = foodDto.price
             }[Items.id]
         }
 
-        val totalPrice = activeOrder[Orders.totalPrice] + (foodDto.price * quantity).toBigDecimal()
+        val totalPrice = activeOrder[Orders.totalPrice] + foodDto.price * quantity.toBigDecimal()
         Orders.update({ Orders.id eq activeOrder[Orders.id] }) {
             it[Orders.totalPrice] = totalPrice
         }
@@ -75,26 +78,27 @@ class OrderServiceImpl : OrderService {
             Orders.select { Orders.id eq item[Items.orderId] }.singleOrNull() ?: throw Exception("Order not found")
         val newQuantity = item[Items.quantity] + quantity
 
-        if (newQuantity < 0) {
-            Items.deleteWhere { Items.id eq itemId }
-
-            val newPrice = order[Orders.totalPrice] - (food[Foods.price] * item[Items.quantity]).toBigDecimal()
-            Orders.update({ Orders.id eq item[Items.orderId] }) {
-                it[Orders.totalPrice] = newPrice
+        when {
+            newQuantity < 0 -> {
+                Items.deleteWhere { Items.id eq itemId }
+                val newPrice = order[Orders.totalPrice] - (food[Foods.price] * item[Items.quantity].toBigDecimal())
+                Orders.update({ Orders.id eq item[Items.orderId] }) {
+                    it[Orders.totalPrice] = newPrice
+                }
             }
 
-            return@dbQuery true
-        }
+            else -> {
+                val newPrice = food[Foods.price] * newQuantity.toBigDecimal()
+                Items.update({ Items.id eq itemId }) {
+                    it[Items.quantity] = newQuantity
+                }
 
-        val newPrice = food[Foods.price] * newQuantity
-        Items.update({ Items.id eq itemId }) {
-            it[Items.quantity] = newQuantity
-        }
+                Orders.update({ Orders.id eq item[Items.orderId] }) {
+                    it[Orders.totalPrice] = newPrice
+                }
 
-        Orders.update({ Orders.id eq item[Items.orderId] }) {
-            it[Orders.totalPrice] = newPrice.toBigDecimal()
+            }
         }
-
         true
     }