feat: delete order and added minus operation to update

Author: f-arslan

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

@@ -48,5 +48,31 @@ fun Application.orderRoute() {
                 onFailure = { call.respond(HttpStatusCode.NotFound, it.message ?: "No active order found") }
             )
         }
+
+        delete("/orders/{userId}/current") {
+            val userId = call.parameters["userId"].let { UUID.fromString(it) } ?: run {
+                call.respond(HttpStatusCode.BadRequest, INVALID_USER_ID)
+                return@delete
+            }
+            orderService.deleteCurrentOrder(userId).fold(
+                onSuccess = { call.respond(HttpStatusCode.OK, true) },
+                onFailure = { call.respond(HttpStatusCode.InternalServerError, it.message ?: "Unknown error") }
+            )
+        }
+
+        delete("/orders/{userId}/{orderId}") {
+            val userId = call.parameters["userId"].let { UUID.fromString(it) } ?: run {
+                call.respond(HttpStatusCode.BadRequest, INVALID_USER_ID)
+                return@delete
+            }
+            val orderId = call.parameters["orderId"]?.toIntOrNull() ?: run {
+                call.respond(HttpStatusCode.BadRequest, "Invalid order id")
+                return@delete
+            }
+            orderService.deleteOrder(userId, orderId).fold(
+                onSuccess = { call.respond(HttpStatusCode.OK, true) },
+                onFailure = { call.respond(HttpStatusCode.InternalServerError, it.message ?: "Unknown error") }
+            )
+        }
     }
 }

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

@@ -9,8 +9,9 @@ import java.util.*
 interface OrderService {
     suspend fun getActiveOrder(userId: UUID): Result<GetActiveOrderDto>
     suspend fun addFoodToOrder(userId: UUID, foodDto: FoodDto, quantity: Int): Result<Int>
-    suspend fun updateItemInOrder(itemId: Int, quantity: Int): Result<ItemDto>
-    suspend fun clearCurrentOrder(userId: UUID): Result<Boolean>
+    suspend fun updateItemInOrder(itemId: Int, quantity: Int): Result<Boolean>
+    suspend fun deleteCurrentOrder(userId: UUID): Result<Boolean>
+    suspend fun deleteOrder(userId: UUID, orderId: Int): Result<Boolean>
 
     companion object {
         val orderService: OrderService by lazy { OrderServiceImpl() }

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

@@ -59,11 +59,24 @@ class OrderServiceImpl : OrderService {
         itemId
     }
 
-    override suspend fun updateItemInOrder(itemId: Int, quantity: Int): Result<ItemDto> = dbQuery {
+    override suspend fun updateItemInOrder(itemId: Int, quantity: Int): Result<Boolean> = dbQuery {
         val item = Items.select { Items.id eq itemId }.singleOrNull() ?: throw Exception("Item not found")
         val food = Foods.select { Foods.id eq item[Items.foodId] }.singleOrNull() ?: throw Exception("Food not found")
-
+        val order =
+            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
+            }
+
+            return@dbQuery true
+        }
+
         val newPrice = food[Foods.price] * newQuantity
         Items.update({ Items.id eq itemId }) {
             it[Items.quantity] = newQuantity
@@ -73,17 +86,31 @@ class OrderServiceImpl : OrderService {
             it[Orders.totalPrice] = newPrice.toBigDecimal()
         }
 
-        ItemDto(
-            id = item[Items.id],
-            orderId = item[Items.orderId],
-            foodId = item[Items.foodId],
-            quantity = newQuantity,
-            price = food[Foods.price]
-        )
+        true
+    }
+
+    override suspend fun deleteCurrentOrder(userId: UUID): Result<Boolean> = dbQuery {
+        val order = Orders.select {
+            (Orders.userId eq userId) and (Orders.orderStatus eq OrderStatus.Started)
+        }.singleOrNull() ?: throw Exception("No active order found")
+
+        Items.deleteWhere { Items.orderId eq order[Orders.id] }
+        Orders.update({ Orders.id eq order[Orders.id] }) {
+            it[orderStatus] = OrderStatus.Cancelled
+        }
+
+        true
     }
 
-    override suspend fun clearCurrentOrder(userId: UUID): Result<Boolean> {
-        TODO("Not yet implemented")
+    override suspend fun deleteOrder(userId: UUID, orderId: Int): Result<Boolean> = dbQuery {
+        val order = Orders.select {
+            (Orders.userId eq userId) and (Orders.id eq orderId)
+        }.singleOrNull() ?: throw Exception("Order not found")
+
+        Items.deleteWhere { Items.orderId eq order[Orders.id] }
+        Orders.deleteWhere { Orders.id eq order[Orders.id] }
+
+        true
     }
 
     private fun createOrder(userId: UUID) {