update

src/main/java/com/ffii/fpsms/modules/deliveryOrder/entity/DoPickOrderLineRecordRepository.kt

@@ -7,4 +7,6 @@ import org.springframework.stereotype.Repository
 interface DoPickOrderLineRecordRepository : JpaRepository<DoPickOrderLineRecord, Long> {
     fun findByDoPickOrderIdAndDeletedFalse(doPickOrderId: Long): List<DoPickOrderLineRecord>
     fun findByDoOrderIdAndDeletedFalse(doOrderId: Long): List<DoPickOrderLineRecord>
+    fun findByDoPickOrderIdInAndDeletedFalse(doPickOrderIds: Collection<Long>): List<DoPickOrderLineRecord>
+    
 }

src/main/java/com/ffii/fpsms/modules/deliveryOrder/entity/DoPickOrderRecordRepository.kt

@@ -25,4 +25,5 @@ interface DoPickOrderRecordRepository : JpaRepository<DoPickOrderRecord, Long> {
     fun findLatestDeliveryNoteCodeByPrefix(prefix: String): String?
 
     fun findByStoreIdAndRequiredDeliveryDateAndTicketStatusIn(storeId: String, requiredDeliveryDate: LocalDate, ticketStatus: List<DoPickOrderStatus>): List<DoPickOrderRecord>
+    fun findByHandledByAndTicketStatusAndDeletedFalse(handledBy: Long, ticketStatus: DoPickOrderStatus): List<DoPickOrderRecord>
 }

src/main/java/com/ffii/fpsms/modules/pickOrder/service/PickOrderService.kt

@@ -4,6 +4,7 @@ import com.ffii.core.response.RecordsRes
 import com.ffii.core.support.AbstractBaseEntityService
 import com.ffii.core.support.JdbcDao
 import com.ffii.fpsms.modules.common.SecurityUtils
+
 import com.ffii.fpsms.modules.jobOrder.entity.JobOrderRepository
 import com.ffii.fpsms.modules.master.entity.ItemsRepository
 import com.ffii.fpsms.modules.master.entity.UomConversionRepository
@@ -4538,153 +4539,95 @@ println("DEBUG sol polIds in linesResults: " + linesResults.mapNotNull { it["sto
 
         open fun getCompletedDoPickOrders(
             userId: Long,
-            pickOrderCode: String?,
-            shopName: String?,
-            deliveryNo: String?,
-            ticketNo: String?
-        ): List<Map<String, Any?>> {
+            request: GetCompletedDoPickOrdersRequest
+        ): List<CompletedDoPickOrderResponse> {
             return try {
-                println("=== getCompletedDoPickOrders (from record table) ===")
-                println("userId: $userId")
-                
-                //  从 do_pick_order_record 表查询已完成的订单
-                val sql = """
-                    SELECT DISTINCT
-                        dpor.id as doPickOrderRecordId,
-                        dpor.record_id as recordId,
-                        dpor.ticket_no as ticketNo,
-                        dpor.store_id as storeId,
-                        dpor.ticketCompleteDateTime as completedDate,
-                        dpor.ShopCode as shopCode,
-                        dpor.ShopName as shopName,
-                        dpor.TruckLanceCode as truckLanceCode,
-                        dpor.truck_departure_time as departureTime,
-                        
-                        --  聚合该 do_pick_order_record 下的所有 pick orders
-                        GROUP_CONCAT(DISTINCT dpolr.pick_order_id ORDER BY dpolr.pick_order_id) as pickOrderIds,
-                        GROUP_CONCAT(DISTINCT dpolr.pick_order_code ORDER BY dpolr.pick_order_id SEPARATOR ', ') as pickOrderCodes,
-                        GROUP_CONCAT(DISTINCT dpolr.do_order_id ORDER BY dpolr.do_order_id) as deliveryOrderIds,
-                        GROUP_CONCAT(DISTINCT dpolr.delivery_order_code ORDER BY dpolr.do_order_id SEPARATOR ', ') as deliveryNos,
-                        
-                        --  获取第一个 pick order 的详细信息（用于显示）
-                        (SELECT po.consoCode FROM pick_order po WHERE po.id = MIN(dpolr.pick_order_id) LIMIT 1) as pickOrderConsoCode,
-                        (SELECT po.status FROM pick_order po WHERE po.id = MIN(dpolr.pick_order_id) LIMIT 1) as pickOrderStatus,
-                        (SELECT do.orderDate FROM delivery_order do WHERE do.id = MIN(dpolr.do_order_id) LIMIT 1) as deliveryDate,
-                        
-                        --  计算总箱数
-                        (SELECT SUM(pol_count.line_count)
-                         FROM (
-                             SELECT COUNT(*) as line_count
-                             FROM pick_order po3
-                             JOIN pick_order_line pol3 ON pol3.poId = po3.id AND pol3.deleted = false
-                             WHERE po3.id IN (SELECT dpolr2.pick_order_id FROM do_pick_order_line_record dpolr2 WHERE dpolr2.do_pick_order_id = dpor.id AND dpolr2.deleted = 0)
-                             GROUP BY po3.id
-                         ) pol_count
-                        ) as numberOfCartons,
-                        
-                        s.id as shopId,
-                        CONCAT_WS(', ', s.addr1, s.addr2, s.addr3, s.addr4, s.district) as shopAddress
-                        
-                    FROM fpsmsdb.do_pick_order_record dpor
-                    INNER JOIN fpsmsdb.do_pick_order_line_record dpolr ON dpolr.do_pick_order_id = dpor.id AND dpolr.deleted = 0
-                    INNER JOIN fpsmsdb.pick_order po ON po.id = dpolr.pick_order_id
-                    LEFT JOIN fpsmsdb.shop s ON s.id = dpor.shop_id
-                    WHERE dpor.deleted = false
-                    AND dpor.handled_by = :userId
-                    AND dpor.ticket_status = 'completed'
-                """.trimIndent()
-                
-                //  添加搜索过滤条件
-                val conditions = mutableListOf<String>()
-                val params = mutableMapOf<String, Any>("userId" to userId)
-                
-                if (pickOrderCode != null) {
-                    conditions.add("dpolr.pick_order_code LIKE :pickOrderCode")
-                    params["pickOrderCode"] = "%$pickOrderCode%"
-                }
-                if (shopName != null) {
-                    conditions.add("dpor.ShopName LIKE :shopName")
-                    params["shopName"] = "%$shopName%"
-                }
-                if (deliveryNo != null) {
-                    conditions.add("dpolr.delivery_order_code LIKE :deliveryNo")
-                    params["deliveryNo"] = "%$deliveryNo%"
-                }
-                if (ticketNo != null) {
-                    conditions.add("dpor.ticket_no LIKE :ticketNo")
-                    params["ticketNo"] = "%$ticketNo%"
+                val completedRecords = doPickOrderRecordRepository
+                    .findByHandledByAndTicketStatusAndDeletedFalse(userId, DoPickOrderStatus.completed)
+                    .filter { record ->
+                        val matchTicket = request.ticketNo.isNullOrBlank() ||
+                            record.ticketNo?.contains(request.ticketNo, ignoreCase = true) == true
+                        val matchShop = request.shopName.isNullOrBlank() ||
+                            record.shopName?.contains(request.shopName, ignoreCase = true) == true
+                        matchTicket && matchShop
+                    }
+                    .filter { (it.recordId ?: 0L) > 0 }
+        
+                if (completedRecords.isEmpty()) {
+                    return emptyList()
                 }
+        
+                val recordIds = completedRecords.mapNotNull { it.recordId }.distinct()
+                val lineRecords = doPickOrderLineRecordRepository.findByDoPickOrderIdInAndDeletedFalse(recordIds)
+                val lineRecordsByRecordId = lineRecords.groupBy { it.doPickOrderId }
                 
-                val finalSql = if (conditions.isNotEmpty()) {
-                    sql + " AND " + conditions.joinToString(" AND ") + 
-                    " GROUP BY dpor.id, dpor.ticket_no, dpor.store_id, dpor.ticketCompleteDateTime, " +
-                    "dpor.ShopCode, dpor.ShopName, dpor.TruckLanceCode, dpor.truck_departure_time, " +
-                    "s.id, s.addr1, s.addr2, s.addr3, s.addr4, s.district " +
-                    " ORDER BY dpor.ticketCompleteDateTime DESC"
-                } else {
-                    sql + 
-                    " GROUP BY dpor.id, dpor.ticket_no, dpor.store_id, dpor.ticketCompleteDateTime, " +
-                    "dpor.ShopCode, dpor.ShopName, dpor.TruckLanceCode, dpor.truck_departure_time, " +
-                    "s.id, s.addr1, s.addr2, s.addr3, s.addr4, s.district " +
-                    " ORDER BY dpor.ticketCompleteDateTime DESC"
+                val filteredRecords = completedRecords.filter { record ->
+                    val lines = lineRecordsByRecordId[record.recordId] ?: emptyList()
+                    val matchPo = request.pickOrderCode.isNullOrBlank() ||
+                        lines.any { it.pickOrderCode?.contains(request.pickOrderCode, ignoreCase = true) == true }
+                    val matchDelivery = request.deliveryNo.isNullOrBlank() ||
+                        lines.any { it.deliveryOrderCode?.contains(request.deliveryNo, ignoreCase = true) == true }
+                    matchPo && matchDelivery
+                }.sortedByDescending { it.ticketCompleteDateTime }
+        
+                if (filteredRecords.isEmpty()) {
+                    return emptyList()
                 }
-                
-                println("🔍 Executing SQL: $finalSql")
-                val results = jdbcDao.queryForList(finalSql, params)
-                println(" Found ${results.size} completed do_pick_order_record entries")
-                
-                //  格式化返回数据
-                val formattedResults = results.map { row ->
-                    //  解析 pick order IDs 列表
-                    val pickOrderIdsStr = row["pickOrderIds"] as? String ?: ""
-                    val pickOrderIds = if (pickOrderIdsStr.isNotEmpty()) {
-                        pickOrderIdsStr.split(",").mapNotNull { it.trim().toLongOrNull() }
-                    } else {
-                        emptyList()
-                    }
-                    
-                    //  解析 delivery order IDs 列表
-                    val deliveryOrderIdsStr = row["deliveryOrderIds"] as? String ?: ""
-                    val deliveryOrderIds = if (deliveryOrderIdsStr.isNotEmpty()) {
-                        deliveryOrderIdsStr.split(",").mapNotNull { it.trim().toLongOrNull() }
-                    } else {
-                        emptyList()
+        
+                val allPickOrderIds = lineRecords.mapNotNull { it.pickOrderId }.distinct()
+                val pickOrdersById = pickOrderRepository.findAllById(allPickOrderIds).associateBy { it.id!! }
+        
+                val allDeliveryOrderIds = lineRecords.mapNotNull { it.doOrderId }.distinct()
+                val deliveryOrdersById = deliveryOrderRepository.findAllById(allDeliveryOrderIds).associateBy { it.id!! }
+        
+                filteredRecords.map { record ->
+                    val lines = lineRecordsByRecordId[record.recordId] ?: emptyList()
+                    val pickOrderIds = lines.mapNotNull { it.pickOrderId }.distinct()
+                    val pickOrderCodes = lines.mapNotNull { it.pickOrderCode }.distinct()
+                    val deliveryOrderIds = lines.mapNotNull { it.doOrderId }.distinct()
+                    val deliveryNos = lines.mapNotNull { it.deliveryOrderCode }.distinct()
+        
+                    val numberOfCartons = pickOrderIds.sumOf { id ->
+                        pickOrdersById[id]?.pickOrderLines?.count { !it.deleted } ?: 0
                     }
-                    
-                    mapOf(
-                        "id" to (row["doPickOrderRecordId"] ?: 0L),
-                        "doPickOrderRecordId" to (row["doPickOrderRecordId"] ?: 0L),
-                        "recordId" to (row["recordId"] ?: ""),
-                        "ticketNo" to (row["ticketNo"] ?: ""),
-                        "storeId" to (row["storeId"] ?: ""),
-                        "completedDate" to (row["completedDate"]?.toString() ?: ""),
-                        "shopCode" to (row["shopCode"] ?: ""),
-                        "shopName" to (row["shopName"] ?: ""),
-                        "truckLanceCode" to (row["truckLanceCode"] ?: ""),
-                        "departureTime" to (row["departureTime"]?.toString() ?: ""),
-                        "pickOrderIds" to pickOrderIds,
-                        "pickOrderCodes" to (row["pickOrderCodes"] ?: ""),
-                        "pickOrderCode" to ((row["pickOrderCodes"] as? String)?.split(", ")?.firstOrNull() ?: ""),
-                        "deliveryOrderIds" to deliveryOrderIds,
-                        "deliveryNos" to (row["deliveryNos"] ?: ""),
-                        "deliveryNo" to ((row["deliveryNos"] as? String)?.split(", ")?.firstOrNull() ?: ""),
-                        "pickOrderConsoCode" to (row["pickOrderConsoCode"] ?: ""),
-                        "pickOrderStatus" to (row["pickOrderStatus"] ?: ""),
-                        "deliveryDate" to (row["deliveryDate"]?.toString() ?: ""),
-                        "numberOfCartons" to (row["numberOfCartons"] ?: 0),
-                        "shopId" to (row["shopId"] ?: 0L),
-                        "shopAddress" to (row["shopAddress"] ?: ""),
-                        "fgPickOrders" to pickOrderIds.map { pickOrderId ->
-                            mapOf(
-                                "pickOrderId" to pickOrderId,
-                                "deliveryOrderId" to deliveryOrderIds.firstOrNull()
+                    val completedDateStr = record.ticketCompleteDateTime
+                    ?.format(DateTimeFormatter.ofPattern("yyyyMMdd"))             
+
+                    val representativePickOrder = pickOrderIds.firstOrNull()?.let { pickOrdersById[it] }
+                    val representativeDelivery = deliveryOrderIds.firstOrNull()?.let { deliveryOrdersById[it] }
+                    val shopAddress = representativeDelivery?.shop?.let { buildShopAddress(it) } ?: ""
+                    val deliveryDateStr = representativeDelivery?.orderDate
+                        ?.format(DateTimeFormatter.ofPattern("yyyyMMdd"))
+                    CompletedDoPickOrderResponse(
+                        id = record.id ?: 0L,
+                        doPickOrderRecordId = record.id ?: 0L,
+                        recordId = record.recordId ?: 0L,
+                        ticketNo = record.ticketNo.orEmpty(),
+                        storeId = record.storeId,
+                        completedDate = completedDateStr,
+                        shopCode = record.shopCode,
+                        shopName = record.shopName,
+                        truckLanceCode = record.truckLanceCode,
+                        departureTime = record.truckDepartureTime,
+                        deliveryNoteCode=record.deliveryNoteCode,
+                        pickOrderIds = pickOrderIds,
+                        pickOrderCodes = pickOrderCodes,
+                        deliveryOrderIds = deliveryOrderIds,
+                        deliveryNos = deliveryNos,
+                        pickOrderConsoCode = representativePickOrder?.consoCode,
+                        pickOrderStatus = representativePickOrder?.status?.value,
+                        deliveryDate = deliveryDateStr,
+                        numberOfCartons = numberOfCartons,
+                        shopId = record.shopId ?: representativeDelivery?.shop?.id,
+                        shopAddress = shopAddress,
+                        fgPickOrders = pickOrderIds.map { poId ->
+                            FgPickOrderSummary(
+                                pickOrderId = poId,
+                                deliveryOrderId = deliveryOrderIds.firstOrNull()
                             )
                         }
                     )
                 }
-                
-                println(" Formatted ${formattedResults.size} results")
-                formattedResults  //  返回格式化后的结果
             } catch (e: Exception) {
                 println("❌ Error in getCompletedDoPickOrders: ${e.message}")
                 e.printStackTrace()

src/main/java/com/ffii/fpsms/modules/pickOrder/web/PickOrderController.kt

@@ -300,8 +300,14 @@ fun getCompletedDoPickOrders(
     @RequestParam(required = false) shopName: String?,
     @RequestParam(required = false) deliveryNo: String?,
     @RequestParam(required = false) ticketNo: String?
-): List<Map<String, Any?>> {
-    return pickOrderService.getCompletedDoPickOrders(userId, pickOrderCode, shopName, deliveryNo, ticketNo)
+): List<CompletedDoPickOrderResponse> {
+    val request = GetCompletedDoPickOrdersRequest(
+        pickOrderCode = pickOrderCode,
+        shopName = shopName,
+        deliveryNo = deliveryNo,
+        ticketNo = ticketNo
+    )
+    return pickOrderService.getCompletedDoPickOrders(userId, request)
 }
 
 

src/main/java/com/ffii/fpsms/modules/pickOrder/web/models/SearchPickOrderRequest.kt

@@ -1,7 +1,8 @@
 package com.ffii.fpsms.modules.pickOrder.web.models
 
 import org.springframework.web.bind.annotation.RequestParam
-
+import java.time.LocalDateTime
+import java.time.LocalTime
 data class SearchPickOrderRequest (
     val code: String?,
     val targetDateFrom: String?,
@@ -11,4 +12,39 @@ data class SearchPickOrderRequest (
     val itemName: String?,
     val pageSize: Int?,
     val pageNum: Int?,
+)
+data class GetCompletedDoPickOrdersRequest(
+    val pickOrderCode: String? = null,
+    val shopName: String? = null,
+    val deliveryNo: String? = null,
+    val ticketNo: String? = null
+)
+data class CompletedDoPickOrderResponse(
+    val id: Long,
+    val doPickOrderRecordId: Long,
+    val recordId: Long,
+    val ticketNo: String,
+    val storeId: String?,
+    val completedDate: String?,
+    val shopCode: String?,
+    val shopName: String?,
+    val deliveryNoteCode: String?,
+    val truckLanceCode: String?,
+    val departureTime: LocalTime?,
+    val pickOrderIds: List<Long>,
+    val pickOrderCodes: List<String>,
+    val deliveryOrderIds: List<Long>,
+    val deliveryNos: List<String>,
+    val pickOrderConsoCode: String?,
+    val pickOrderStatus: String?,
+    val deliveryDate: String?,
+    val numberOfCartons: Int,
+    val shopId: Long?,
+    val shopAddress: String?,
+    val fgPickOrders: List<FgPickOrderSummary>
+)
+
+data class FgPickOrderSummary(
+    val pickOrderId: Long,
+    val deliveryOrderId: Long?
 )