feat: two new endpoints for get all orders

Author: f-arslan

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

@@ -1,22 +1,23 @@
 package com.example.service
 
 import com.example.dto.FoodDto
-import com.example.dto.GetActiveOrderDto
-import com.example.dto.ItemDto
+import com.example.dto.GetOrderWithItemsDto
 import com.example.dto.OrderDto
 import com.example.service.impl.OrderServiceImpl
 import kotlinx.coroutines.flow.Flow
 import java.util.*
 
 interface OrderService {
-    suspend fun getActiveOrder(userId: UUID): Result<GetActiveOrderDto>
-    suspend fun getActiveOrderFlow(userId: UUID): Result<Flow<GetActiveOrderDto>>
+    suspend fun getActiveOrder(userId: UUID): Result<GetOrderWithItemsDto>
+    suspend fun getActiveOrderFlow(userId: UUID): Result<Flow<GetOrderWithItemsDto>>
     suspend fun addFoodToOrder(userId: UUID, foodDto: FoodDto, quantity: Int): Result<Int>
     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>
     suspend fun completeCurrentOrder(userId: UUID): Result<Boolean>
     suspend fun cancelOrder(userId: UUID, orderId: Int): Result<Boolean>
+    suspend fun getAllOrders(userId: UUID): Result<List<GetOrderWithItemsDto>>
+    suspend fun getAllOrderFlow(userId: UUID): Result<Flow<GetOrderWithItemsDto>>
     companion object {
         val orderService: OrderService by lazy { OrderServiceImpl() }
     }

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

@@ -1,14 +1,12 @@
 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 org.jetbrains.exposed.sql.insert
-import org.jetbrains.exposed.sql.lowerCase
-import org.jetbrains.exposed.sql.select
-import org.jetbrains.exposed.sql.selectAll
+import org.jetbrains.exposed.sql.*
 
 class FoodServiceImpl : FoodService {
     override suspend fun getFoodDetail(foodId: Int): Result<FoodDto> = dbQuery {

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

@@ -14,21 +14,21 @@ import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
 import java.util.*
 
 class OrderServiceImpl : OrderService {
-    override suspend fun getActiveOrder(userId: UUID): Result<GetActiveOrderDto> = dbQuery {
+    override suspend fun getActiveOrder(userId: UUID): Result<GetOrderWithItemsDto> = dbQuery {
         val order = Orders.select {
             (Orders.userId eq userId) and (Orders.orderStatus eq OrderStatus.Started)
         }.singleOrNull() ?: throw Exception("No active order found")
 
         val items = Items.select { Items.orderId eq order[Orders.id] }.map { it.toItemDto() }
-        GetActiveOrderDto(order.toOrderDto(), items)
+        GetOrderWithItemsDto(order.toOrderDto(), items)
     }
 
-    override suspend fun getActiveOrderFlow(userId: UUID): Result<Flow<GetActiveOrderDto>> = dbQuery {
+    override suspend fun getActiveOrderFlow(userId: UUID): Result<Flow<GetOrderWithItemsDto>> = dbQuery {
         Orders.select {
             (Orders.userId eq userId) and (Orders.orderStatus eq OrderStatus.Started)
         }.map { order ->
             val items = Items.select { Items.orderId eq order[Orders.id] }.map { it.toItemDto() }
-            GetActiveOrderDto(order.toOrderDto(), items)
+            GetOrderWithItemsDto(order.toOrderDto(), items)
         }.asFlow()
     }
 
@@ -146,6 +146,21 @@ class OrderServiceImpl : OrderService {
         true
     }
 
+    override suspend fun getAllOrders(userId: UUID): Result<List<GetOrderWithItemsDto>> = dbQuery {
+        val orders = Orders.select { Orders.userId eq userId }.map { order ->
+            val items = Items.select { Items.orderId eq order[Orders.id] }.map { it.toItemDto() }
+            GetOrderWithItemsDto(order.toOrderDto(), items)
+        }
+        orders
+    }
+
+    override suspend fun getAllOrderFlow(userId: UUID): Result<Flow<GetOrderWithItemsDto>> = dbQuery {
+        Orders.select { Orders.userId eq userId }.map { order ->
+            val items = Items.select { Items.orderId eq order[Orders.id] }.map { it.toItemDto() }
+            GetOrderWithItemsDto(order.toOrderDto(), items)
+        }.asFlow()
+    }
+
     private fun createOrder(userId: UUID) {
         Orders.insert {
             it[Orders.userId] = userId