原矿订单新增手动完结、定时任务完结、报表筛选时间更改

sckw-common/sckw-common-core/src/main/java/com/sckw/core/model/enums/LogisticsOrderV1Enum.java

@@ -28,7 +28,7 @@ public enum LogisticsOrderV1Enum {
      */
     IN_TRANSIT(10, "inTransit", "10", "运输中"),
     /**
-     * 物流订单-已完成
+     * 物流订单-完结中
      */
     NEARING_COMPLETION(15, "haveFinished", "15", "完结中"),
     /**

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/controller/KwtLogisticsOrderController.java

@@ -210,6 +210,15 @@ public class KwtLogisticsOrderController {
         return BaseResult.success(logisticsConsignmentService.logisticOrderFinish(req));
     }
 
+    /**
+     * 完结原矿订单
+     */
+    @PostMapping("/rawOreLogisticOrderFinish")
+    @Operation(summary = "完结原矿订单", description = "完结原矿订单")
+    public BaseResult<Boolean> rawOreLogisticOrderFinish(@RequestBody @Valid OrderFinishReq req) {
+        return BaseResult.success(logisticsConsignmentService.rawOreLogisticOrderFinish(req));
+    }
+
     /**
      * 状态统计
      */

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/service/KwtLogisticsConsignmentService.java

@@ -83,6 +83,7 @@ import org.springframework.util.ObjectUtils;
 
 import java.math.BigDecimal;
 import java.math.RoundingMode;
+import java.time.LocalDateTime;
 import java.time.ZoneId;
 import java.util.*;
 import java.util.concurrent.CompletableFuture;
@@ -4225,6 +4226,57 @@ public class KwtLogisticsConsignmentService {
         }
     }
 
+
+    /**
+     * 原矿订单变成完结中
+     * @param req
+     * @return
+     */
+    public Boolean rawOreLogisticOrderFinish(OrderFinishReq req) {
+        log.info("[原矿]物流订单-完结中订单传递参数信息:{}", JSONObject.toJSONString(req));
+        //查询物流订单
+        List<KwtLogisticsOrder> logisticsOrder = logisticsOrderRepository.queryByLogisticsOrderIds(req.getLogisticOrderId());
+
+        if (CollectionUtils.isEmpty(logisticsOrder)) {
+            throw new BusinessException("未找到该物流订单信息!");
+        }
+
+        // 校验批量物流订单是否都是原矿订单
+        boolean hasInvalidOrder = logisticsOrder.stream().anyMatch(order -> !Objects.equals(order.getOrderType(), 1));
+        if (hasInvalidOrder) {
+            throw new BusinessException("存在不是原矿的订单数据！");
+        }
+        // 获取当前时间
+        LocalDateTime now = LocalDateTime.now();
+
+        List<KwtLogisticsOrder> logisticsOrders = Lists.newArrayList();
+        // 遍历每个物流订单
+        logisticsOrder.forEach(logOrder -> {
+                // 当前时间未超过结束时间
+                if (!now.isAfter(logOrder.getEndTime())) {
+                    log.warn("[原矿]物流订单[{}]没有超过结束时间，跳过处理", logOrder.getId());
+                } else {
+                    // 更新物流订单状态为"完结中"
+                    KwtLogisticsOrder updateOrder = new KwtLogisticsOrder();
+                    updateOrder.setId(logOrder.getId());
+                    updateOrder.setStatus(LogisticsOrderV1Enum.NEARING_COMPLETION.getCode());
+                    updateOrder.setUpdateTime(new Date());
+                    // 定时任务更新，updateBy 可以设置为系统用户或0
+                    updateOrder.setUpdateBy(0L);
+                    logisticsOrders.add(updateOrder);
+                }
+        });
+
+        //更新物流订单
+        if (org.apache.commons.collections4.CollectionUtils.isEmpty(logisticsOrders)) {
+            log.info("没有需要更新的物流订单");
+            return false;
+        }
+        logisticsOrderRepository.updateBatchById(logisticsOrders);
+        log.info("[原矿]物流订单-完结中订单结束");
+        return Boolean.TRUE;
+    }
+
     private void updateTradeOrder(Set<Long> tradeIds) {
         if (org.apache.commons.collections4.CollectionUtils.isEmpty(tradeIds)) {
             return;

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/service/app/WaybillOrderService.java

@@ -2100,8 +2100,8 @@ public class WaybillOrderService {
 
         LambdaQueryWrapper<KwtWaybillOrder> queryWrapper = Wrappers.<KwtWaybillOrder>lambdaQuery()
                 .in(KwtWaybillOrder::getLOrderId, lOrderIds)
-                .ge(KwtWaybillOrder::getCreateTime, startOfDay)
-                .le(KwtWaybillOrder::getCreateTime, endOfDay)
+                .ge(KwtWaybillOrder::getUpdateTime, startOfDay)
+                .le(KwtWaybillOrder::getUpdateTime, endOfDay)
                 .eq(KwtWaybillOrder::getStatus,25)
                 .isNull(KwtWaybillOrder::getRemark)
                 .eq(KwtWaybillOrder::getDelFlag, 0)

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/task/LogisticsOrderCompletionTask.java

@@ -35,6 +35,7 @@ import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.math.BigDecimal;
+import java.time.LocalDateTime;
 import java.util.*;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
@@ -239,6 +240,182 @@ public class LogisticsOrderCompletionTask {
 
     }
 
+    /**
+     * 定时任务：每5分钟执行一次
+     * cron表达式：0 0/5 * * * ? 表示每5分钟执行一次
+     * 可以根据实际需求调整执行频率
+     */
+    @Scheduled(cron = "${schedule.logistics-order-completion-cron}")
+    public void processRawOre() {
+        log.info("[原矿]物流订单自动完结中定时任务开始...");
+
+        try {
+            // 查询状态为'待派车'和'运输中'的原矿物流订单
+            List<KwtLogisticsOrder> nearingCompletionOrders = logisticsOrderRepository.list(
+                    new LambdaQueryWrapper<KwtLogisticsOrder>()
+                            .in(KwtLogisticsOrder::getStatus, Arrays.asList(
+                                    LogisticsOrderV1Enum.WAIT_DELIVERY.getCode(),
+                                    LogisticsOrderV1Enum.IN_TRANSIT.getCode()))
+                            .eq(KwtLogisticsOrder::getDelFlag, 0)
+                            .eq(KwtLogisticsOrder::getOrderType, 1)
+            );
+
+            if (CollectionUtils.isEmpty(nearingCompletionOrders)) {
+                log.info("[原矿]没有状态为'待派车'和'运输中'的物流订单需要处理");
+                return;
+            }
+            log.info("[原矿]查询到{}条状态为'待派车'和'运输中’的物流订单", nearingCompletionOrders.size());
+
+
+            // 准备需要更新的物流订单列表
+            List<KwtLogisticsOrder> updateLogisticOrders = new ArrayList<>();
+
+            // 获取当前时间
+            LocalDateTime now = LocalDateTime.now();
+
+            // 遍历每个物流订单及其关联的运单子任务
+            nearingCompletionOrders.forEach(logOrder -> {
+                try {
+                    // 当前时间未超过结束时间
+                    if (!now.isAfter(logOrder.getEndTime())) {
+                        log.warn("[原矿]物流订单[{}]没有超过结束时间，跳过处理", logOrder.getId());
+                    } else {
+                        // 更新物流订单状态为"完结中"
+                        KwtLogisticsOrder updateOrder = new KwtLogisticsOrder();
+                        updateOrder.setId(logOrder.getId());
+                        updateOrder.setStatus(LogisticsOrderV1Enum.NEARING_COMPLETION.getCode());
+                        updateOrder.setUpdateTime(new Date());
+                        // 定时任务更新，updateBy 可以设置为系统用户或0
+                        updateOrder.setUpdateBy(0L);
+                        updateLogisticOrders.add(updateOrder);
+                    }
+                } catch (Exception e) {
+                    log.error("[原矿]处理物流订单时发生异常，订单ID:{}", logOrder.getId(), e);
+                }
+            });
+            // 如果没有需要更新的物流订单，则直接返回
+            if (CollectionUtils.isEmpty(updateLogisticOrders)){
+                log.info("[原矿]没有需要更新状态的物流订单");
+                return;
+            }
+
+            // 批量更新物流订单状态
+            boolean updated = logisticsOrderRepository.updateBatchById(updateLogisticOrders);
+            Set<Long> logOrderIds = updateLogisticOrders.stream().map(KwtLogisticsOrder::getId).collect(Collectors.toSet());
+
+            // 记录更新结果日志
+            if (updated) {
+                log.info("[原矿]物流订单自动完结中定时任务结束,物流订单已更新为'完结中'，订单ID:{},成功:{}条", JSON.toJSONString(logOrderIds), logOrderIds.size());
+            } else {
+                log.error("[原矿]物流订单自动完结中定时任务结束,物流订单状态更新失败，订单ID:{},失败:{}条", JSON.toJSONString(logOrderIds), logOrderIds.size());
+            }
+        } catch (Exception e) {
+            log.error("[原矿]物流订单自动完结中定时任务执行异常", e);
+            throw new BusinessException("[原矿]物流订单自动完结中定时任务执行异常", e);
+        }
+    }
+
+
+
+    /**
+     * 定时任务：每5分钟执行一次
+     * cron表达式：0 0/5 * * * ? 表示每5分钟执行一次
+     * 可以根据实际需求调整执行频率
+     */
+    @Scheduled(cron = "${schedule.logistics-order-completion-cron}")
+    public void processRawOre2() {
+        log.info("[原矿]物流订单自动完成定时任务开始...");
+
+        try {
+            // 查询状态为"完结中"的原矿物流订单
+            List<KwtLogisticsOrder> nearingCompletionOrders = logisticsOrderRepository.list(
+                    new LambdaQueryWrapper<KwtLogisticsOrder>()
+                            .eq(KwtLogisticsOrder::getStatus, LogisticsOrderV1Enum.NEARING_COMPLETION.getCode())
+                            .eq(KwtLogisticsOrder::getDelFlag, 0)
+                            .eq(KwtLogisticsOrder::getOrderType, 1)
+            );
+
+            if (CollectionUtils.isEmpty(nearingCompletionOrders)) {
+                log.info("[原矿]没有状态为'完结中'的物流订单需要处理");
+                return;
+            }
+
+            log.info("[原矿]查询到{}条状态为'完结中'的物流订单", nearingCompletionOrders.size());
+
+            // 提取物流订单ID列表
+            List<Long> logisticOrderIds = nearingCompletionOrders
+                    .stream()
+                    .map(KwtLogisticsOrder::getId)
+                    .collect(Collectors.toList());
+
+            // 根据物流订单ID查询相关运单子任务
+            List<KwtWaybillOrderSubtask> subtasks = waybillOrderSubtaskRepository.queryByLogIds(logisticOrderIds);
+
+            // 按照物流订单ID分组运单子任务
+            Map<Long, List<KwtWaybillOrderSubtask>> logOrderSubtasksMap = Optional.ofNullable(subtasks)
+                    .orElse(Collections.emptyList()).stream().collect(Collectors.groupingBy(KwtWaybillOrderSubtask::getLOrderId));
+
+            // 准备需要更新的物流订单列表
+            List<KwtLogisticsOrder> updateLogisticOrders = new ArrayList<>();
+
+            // 遍历每个物流订单及其关联的运单子任务
+            logOrderSubtasksMap.forEach((logOrderId, subtaskList) -> {
+                try {
+                    // 如果没有运单，跳过
+                    if (CollectionUtils.isEmpty(subtaskList)) {
+                        log.warn("[原矿]物流订单[{}]下没有运单，跳过处理", logOrderId);
+                        return;
+                    }
+
+                    // 检查所有运单状态是否都是"已完成"（COMPLETED）和已取消（CANCELLED）
+                    List<Integer> statusList = Arrays.asList(CarWaybillV1Enum.COMPLETED.getCode(), CarWaybillV1Enum.CANCELLED.getCode());
+                    boolean allCompleted = subtaskList.stream()
+                            .allMatch(subtask -> statusList.contains(subtask.getStatus()));
+
+                    if (allCompleted) {
+                        // 更新物流订单状态为"已完成"
+                        KwtLogisticsOrder updateOrder = new KwtLogisticsOrder();
+                        updateOrder.setId(logOrderId);
+                        updateOrder.setStatus(LogisticsOrderV1Enum.COMPLETED.getCode());
+                        updateOrder.setUpdateTime(new Date());
+                        // 定时任务更新，updateBy 可以设置为系统用户或0
+                        updateOrder.setUpdateBy(0L);
+                        updateLogisticOrders.add(updateOrder);
+
+                    } else {
+                        // 存在未完成的运单，判断当前订单状态，“运输中”的改为“完结中”
+                        long completedCount = subtaskList.stream()
+                                .filter(subtask -> Objects.equals(subtask.getStatus(), CarWaybillV1Enum.COMPLETED.getCode()))
+                                .count();
+                        log.debug("[原矿]物流订单下还有未完成的运单，已完成运单数:{}/{}，订单ID:{}",
+                                completedCount, subtaskList.size(), logOrderId);
+                    }
+                } catch (Exception e) {
+                    log.error("[原矿]处理物流订单时发生异常，订单ID:{}", logOrderId, e);
+                }
+            });
+            // 如果没有需要更新的物流订单，则直接返回
+            if (CollectionUtils.isEmpty(updateLogisticOrders)){
+                log.info("[原矿]没有需要更新状态的物流订单");
+                return;
+            }
+
+            // 批量更新物流订单状态
+            boolean updated = logisticsOrderRepository.updateBatchById(updateLogisticOrders);
+            Set<Long> logOrderIds = updateLogisticOrders.stream().map(KwtLogisticsOrder::getId).collect(Collectors.toSet());
+
+            // 记录更新结果日志
+            if (updated) {
+                log.info("[原矿]物流订单自动完成定时任务结束,物流订单已更新为'已完成'，订单ID:{},成功:{}条", JSON.toJSONString(logOrderIds), logOrderIds.size());
+            } else {
+                log.error("[原矿]物流订单自动完成定时任务结束,物流订单状态更新失败，订单ID:{},失败:{}条", JSON.toJSONString(logOrderIds), logOrderIds.size());
+            }
+        } catch (Exception e) {
+            log.error("[原矿]物流订单自动完成定时任务执行异常", e);
+            throw new BusinessException("[原矿]物流订单自动完成定时任务执行异常", e);
+        }
+    }
+
 
     /**
      * 定时任务：每2分钟执行一次