Merge remote-tracking branch 'origin/dev_20251130' into dev_20251130

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/model/dto/GenerateTraceReq.java

@@ -6,6 +6,7 @@ import lombok.Data;
 
 import java.io.Serial;
 import java.io.Serializable;
+import java.util.List;
 
 /**
  * @author system
@@ -59,5 +60,5 @@ public class GenerateTraceReq implements Serializable {
      * 异常类型（1-车辆偏航，2-急刹车，3-超速，4-异常停车）
      */
     @Schema(description = "异常类型（1-车辆偏航，2-急刹车，3-超速，4-异常停车）")
-    private Integer exceptionType;
+    private List<Integer> exceptionType;
 }

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/repository/KwtVehicleExceptionRepository.java

@@ -113,4 +113,10 @@ public class KwtVehicleExceptionRepository extends ServiceImpl<KwtVehicleExcepti
                         Collectors.collectingAndThen(Collectors.counting(), Long::intValue)
                 ));
     }
+
+    public List<KwtVehicleException> queryByEnt(Long entId) {
+        return list(Wrappers.<KwtVehicleException>lambdaQuery()
+                .eq(KwtVehicleException::getDelFlag, 0)
+                .eq(KwtVehicleException::getEntId, entId));
+    }
 }

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

@@ -1,25 +1,28 @@
 package com.sckw.transport.service;
 
 
+import cn.hutool.core.collection.CollUtil;
 import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.google.common.collect.Lists;
+import com.sckw.core.model.base.BaseModel;
 import com.sckw.core.model.enums.CarWaybillEnum;
 import com.sckw.core.utils.DateUtils;
+import com.sckw.core.web.context.LoginEntHolder;
+import com.sckw.core.web.context.LoginUserHolder;
 import com.sckw.fleet.api.RemoteFleetService;
 import com.sckw.fleet.api.model.vo.RFleetDriverVo;
 import com.sckw.fleet.api.model.vo.RFleetVo;
 import com.sckw.transport.common.config.AmapProperties;
-import com.sckw.transport.model.KwtWaybillOrder;
-import com.sckw.transport.model.KwtWaybillOrderSubtask;
-import com.sckw.transport.model.TaskStatisticsVo;
+import com.sckw.transport.dao.KwtWaybillOrderMapper;
+import com.sckw.transport.dao.KwtWaybillOrderSubtaskMapper;
+import com.sckw.transport.model.*;
 import com.sckw.transport.model.param.FleetRankingReq;
 import com.sckw.transport.model.param.LogisticsOrderStatisticsReq;
 import com.sckw.transport.model.param.TaskStatisticsReq;
 import com.sckw.transport.model.vo.FleetRankingVo;
 import com.sckw.transport.model.vo.LogOrderStatisticsVo;
-import com.sckw.transport.repository.KwtLogisticsOrderRepository;
-import com.sckw.transport.repository.KwtWaybillOrderRepository;
-import com.sckw.transport.repository.KwtWaybillOrderSubtaskRepository;
+import com.sckw.transport.repository.*;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections4.CollectionUtils;
@@ -45,11 +48,41 @@ public class KwfTaskService {
     private final AmapProperties amapProperties;
     private final KwtWaybillOrderSubtaskRepository kwtWaybillOrderSubtaskRepository;
     private final KwtLogisticsOrderRepository kwtLogisticsOrderRepository;
+    private final KwtVehicleExceptionRepository kwtVehicleExceptionRepository;
+    private final KwtLogisticsOrderUnitRepository kwtLogisticsOrderUnitRepository;
+    private final KwtWaybillOrderSubtaskMapper waybillOrderSubtaskDao;
     @DubboReference(version = "1.0.0", group = "design", check = false, timeout = 8000)
     RemoteFleetService fleetService;
     public TaskStatisticsVo getTaskStatistics(TaskStatisticsReq req) {
         log.info("开始获取任务统计信息请求参数:{}",JSON.toJSONString(req));
-        List<KwtWaybillOrder> waybillOrder= kwtWaybillOrderRepository.findByEntId(req.getEntId());
+        Long entId = Objects.nonNull(req.getEntId()) ? req.getEntId() : LoginUserHolder.getEntId();
+        //根据企业查询物流订单
+        List<KwtLogisticsOrderUnit> kwtLogisticsOrderUnits = kwtLogisticsOrderUnitRepository.queryByEntId(entId);
+        if (CollUtil.isEmpty(kwtLogisticsOrderUnits)) {
+            log.info("该企业未查询到物流订单数据，企业id:{}", entId);
+            return new TaskStatisticsVo();
+        }
+        //获取物流订单号
+        Set<Long> logOrderIds = kwtLogisticsOrderUnits.stream()
+                .map(KwtLogisticsOrderUnit::getLOrderId)
+                .collect(Collectors.toSet());
+        if (CollUtil.isEmpty(logOrderIds)) {
+            log.info("该企业下物流订单数据，企业id:{}", entId);
+            return new TaskStatisticsVo();
+        }
+        //查询子运单
+        List<KwtWaybillOrderSubtask> kwtWaybillOrderSubtasks = waybillOrderSubtaskDao.selectList(Wrappers.<KwtWaybillOrderSubtask>lambdaQuery()
+                .in(KwtWaybillOrderSubtask::getLOrderId, logOrderIds)
+                .eq(BaseModel::getDelFlag, 0));
+        if(org.apache.commons.collections4.CollectionUtils.isEmpty(kwtWaybillOrderSubtasks)){
+            log.info("该企业下子运单的订单数据不存在，企业id:{}", entId);
+            return new TaskStatisticsVo();
+        }
+        Set<Long> wayOrderIds = kwtWaybillOrderSubtasks.stream()
+                .map(KwtWaybillOrderSubtask::getWOrderId)
+                .collect(Collectors.toSet());
+
+        List<KwtWaybillOrder> waybillOrder= kwtWaybillOrderRepository.queryByBillOrderIds(wayOrderIds);
         //任务总数
         int totalCount = waybillOrder.size();
         if (totalCount == 0) {
@@ -87,20 +120,28 @@ public class KwfTaskService {
         if (yesterdayTaskCount != 0.0){
             growthRate= (double) (yesterdayTaskCount - taskTotalBeforeYesterday) / taskTotalBeforeYesterday * 100;
         }
+        //查询车辆异常车辆数
+        List<KwtVehicleException> vehicleExceptions = kwtVehicleExceptionRepository.queryByEnt(entId);
+        Map<Long, List<KwtVehicleException>> vehicleExceptionMap = Optional.ofNullable(vehicleExceptions)
+                .orElse(List.of())
+                .stream()
+                .collect(Collectors.groupingBy(KwtVehicleException::getTruckId));
         return getTaskStatisticsVo(totalCount, taskingCount, completedCount, yesterdayTaskCount,
-                taskTotalBeforeYesterday, growthRate, unloadTon, unloadTonThisMonth, unloadTonBeforeMonth,unloadGrowthRate);
+                taskTotalBeforeYesterday, growthRate, unloadTon, unloadTonThisMonth, unloadTonBeforeMonth,unloadGrowthRate,vehicleExceptionMap);
     }
 
 
     private TaskStatisticsVo getTaskStatisticsVo(int totalCount, long taskingCount, long completedCount
             , long yesterdayTaskCount, long taskTotalBeforeYesterday, double growthRate, double unloadTon
-            , double unloadTonThisMonth, double unloadTonBeforeMonth,double unloadGrowthRate) {
+            , double unloadTonThisMonth, double unloadTonBeforeMonth,double unloadGrowthRate,
+                                                 Map<Long, List<KwtVehicleException>> vehicleExceptionMap) {
         TaskStatisticsVo taskStatisticsVo = new TaskStatisticsVo();
         taskStatisticsVo.setTaskTotal(String.valueOf(totalCount));
         taskStatisticsVo.setTaskRunning(String.valueOf(taskingCount));
         taskStatisticsVo.setTaskCompleted(String.valueOf(completedCount));
         taskStatisticsVo.setTaskPercent(taskingCount == 0 ? "0" : String.format("%.2f", (double) taskingCount / totalCount * 100));
-        taskStatisticsVo.setTruckAbnormal("0");
+        int size = vehicleExceptionMap.size();
+        taskStatisticsVo.setTruckAbnormal(String.valueOf(size));
         taskStatisticsVo.setWarningTotal("0");
         taskStatisticsVo.setTaskTotalYesterday(String.valueOf(yesterdayTaskCount));
         taskStatisticsVo.setTaskTotalBeforeYesterday(String.valueOf(taskTotalBeforeYesterday));

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

@@ -1585,12 +1585,54 @@ public class kwfTruckTraceService {
         // 输入的日期字符串
        // LocalDate date = LocalDate.parse(dateStr, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
         LocalDateTime dateTime = date.atTime(LocalTime.now());
+        
+        // 如果存在异常类型集合，根据异常类型数量随机选择对应数量的轨迹点来设置异常
+        Random random = new Random();
+        // 轨迹点索引 -> 异常类型 的映射
+        Map<Integer, Integer> exceptionPointMap = new HashMap<>();
+        if (CollectionUtils.isNotEmpty(req.getExceptionType()) && routePoints.size() > 0) {
+            List<Integer> exceptionTypes = req.getExceptionType();
+            int exceptionTypeCount = exceptionTypes.size();
+            
+            // 异常类型有几种，就随机生成几种异常节点
+            // 随机选择对应数量的轨迹点索引（不重复）
+            Set<Integer> selectedIndexes = new HashSet<>();
+            while (selectedIndexes.size() < exceptionTypeCount && selectedIndexes.size() < routePoints.size()) {
+                selectedIndexes.add(random.nextInt(routePoints.size()));
+            }
+            
+            // 将每个异常类型分配给一个轨迹点
+            List<Integer> selectedIndexList = new ArrayList<>(selectedIndexes);
+            Collections.shuffle(selectedIndexList, random); // 打乱顺序，确保随机分配
+            
+            for (int j = 0; j < exceptionTypeCount && j < selectedIndexList.size(); j++) {
+                int pointIndex = selectedIndexList.get(j);
+                int exceptionType = exceptionTypes.get(j);
+                exceptionPointMap.put(pointIndex, exceptionType);
+            }
+            
+            log.info("异常类型数量：{}，随机选择{}个轨迹点设置异常，轨迹点索引和异常类型映射：{}", 
+                    exceptionTypeCount, exceptionPointMap.size(), exceptionPointMap);
+        }
+        
         for (int i = 0; i < routePoints.size(); i++) {
             LocUtils.RoutePoint routePoint = routePoints.get(i);
             VehiclesTrajectoryReq vehiclesTrajectoryReq = getVehiclesTrajectoryReq(req, order, routePoint.getLongitude(), routePoint.getLatitude(), logisticsOrder, fleetByTruckId);
             LocalDateTime localDateTime = dateTime.plusSeconds(i * 5L);
             Timestamp timestamp = Timestamp.valueOf(localDateTime);
             vehiclesTrajectoryReq.setTs(timestamp);
+            
+            // 如果当前轨迹点被选中设置异常，则使用对应的异常类型
+            Integer selectedExceptionType = exceptionPointMap.get(i);
+            if (selectedExceptionType != null) {
+                // 设置状态为异常（异常类型的code转换为字符串）
+                vehiclesTrajectoryReq.setStatus(String.valueOf(selectedExceptionType));
+                log.info("轨迹点[{}]设置异常类型：{}", i, selectedExceptionType);
+            } else {
+                // 正常状态
+                vehiclesTrajectoryReq.setStatus("0");
+            }
+            
             try {
                 // 调用数据中台保存轨迹数据
                 log.info("调用数据中台保存车辆轨迹数据：{}", JSON.toJSONString(vehiclesTrajectoryReq));
@@ -1600,10 +1642,12 @@ public class kwfTruckTraceService {
                     throw new BusinessException("生成轨迹失败：" + result.getMessage());
                 }
 
-                // 如果请求中包含异常类型，则同时保存到本地车辆异常表
-                saveException(req, order, longitude, latitude);
+                // 如果当前轨迹点有异常类型，则保存到本地车辆异常表
+                if (selectedExceptionType != null) {
+                    saveException(req, order, routePoint.getLongitude(), routePoint.getLatitude(), selectedExceptionType, timestamp);
+                }
 
-                log.info("生成车辆轨迹成功，运单号：{}，车牌号：{}", req.getWayOrderNo(), req.getTruckNo());
+                log.info("生成车辆轨迹成功，运单号：{}，车牌号：{}，轨迹点：{}", req.getWayOrderNo(), req.getTruckNo(), i);
             } catch (Exception e) {
                 log.error("生成车辆轨迹异常：", e);
                 throw new BusinessException("生成轨迹失败：" + e.getMessage());
@@ -1639,33 +1683,44 @@ public class kwfTruckTraceService {
             return null;
         }
     }
-    private void saveException(GenerateTraceReq req, KwtWaybillOrder order, String longitude, String latitude) {
-        if (Objects.nonNull(req.getExceptionType())) {
-            // 保存到车辆异常表
-            KwtVehicleException vehicleException = new KwtVehicleException();
-            vehicleException.setEntId(order.getEntId());
-            vehicleException.setTruckId(order.getTruckId());
-            vehicleException.setTruckNo(req.getTruckNo());
-            vehicleException.setTruckId(order.getTruckId());
-            vehicleException.setWOrderNo(req.getWayOrderNo());
-            vehicleException.setDriverId(order.getDriverId());
-            vehicleException.setDriverName(order.getDriverName());
-            vehicleException.setDriverPhone(order.getDriverPhone());
-            vehicleException.setExceptionType(req.getExceptionType());
-            vehicleException.setDescription(VehicleExceptionTypeEnum.getName(req.getExceptionType()));
-            vehicleException.setLocation(req.getExceptionLocation());
-            vehicleException.setLongitude(longitude);
-            vehicleException.setLatitude(latitude);
-            vehicleException.setExceptionTime(new Date());
-            vehicleException.setCreateBy(LoginUserHolder.getUserId());
-            vehicleException.setCreateTime(new Date());
-            vehicleException.setUpdateBy(LoginUserHolder.getUserId());
-            vehicleException.setUpdateTime(new Date());
-            vehicleException.setDelFlag(0);
-
-            // 保存异常信息
-            kwtVehicleExceptionRepository.save(vehicleException);
+    /**
+     * 保存单个异常信息到车辆异常表
+     * @param req 生成轨迹请求参数
+     * @param order 运单信息
+     * @param longitude 经度
+     * @param latitude 纬度
+     * @param exceptionType 异常类型
+     * @param exceptionTime 异常时间
+     */
+    private void saveException(GenerateTraceReq req, KwtWaybillOrder order, String longitude, String latitude, Integer exceptionType, Timestamp exceptionTime) {
+        if (exceptionType == null) {
+            return;
         }
+        
+        // 保存到车辆异常表
+        KwtVehicleException vehicleException = new KwtVehicleException();
+        vehicleException.setEntId(order.getEntId());
+        vehicleException.setTruckId(order.getTruckId());
+        vehicleException.setTruckNo(req.getTruckNo());
+        vehicleException.setWOrderNo(req.getWayOrderNo());
+        vehicleException.setDriverId(order.getDriverId());
+        vehicleException.setDriverName(order.getDriverName());
+        vehicleException.setDriverPhone(order.getDriverPhone());
+        vehicleException.setExceptionType(exceptionType);
+        vehicleException.setDescription(VehicleExceptionTypeEnum.getName(exceptionType));
+        vehicleException.setLocation(req.getExceptionLocation());
+        vehicleException.setLongitude(longitude);
+        vehicleException.setLatitude(latitude);
+        vehicleException.setExceptionTime(exceptionTime != null ? new Date(exceptionTime.getTime()) : new Date());
+        vehicleException.setCreateBy(LoginUserHolder.getUserId());
+        vehicleException.setCreateTime(new Date());
+        vehicleException.setUpdateBy(LoginUserHolder.getUserId());
+        vehicleException.setUpdateTime(new Date());
+        vehicleException.setDelFlag(0);
+        
+        // 保存异常信息
+        kwtVehicleExceptionRepository.save(vehicleException);
+        log.info("保存车辆异常信息成功，运单号：{}，异常类型：{}，位置：{},{}", req.getWayOrderNo(), exceptionType, longitude, latitude);
     }
 
     @NotNull
@@ -1685,9 +1740,6 @@ public class kwfTruckTraceService {
         vehiclesTrajectoryReq.setBatteryVoltage(30.0f);
         vehiclesTrajectoryReq.setStatus("0");
         vehiclesTrajectoryReq.setAlarmCode("0");
-        if (req.getExceptionType() != null){
-            vehiclesTrajectoryReq.setStatus(String.valueOf(req.getExceptionType()));
-        }
         vehiclesTrajectoryReq.setWOrderNo(req.getWayOrderNo());
         vehiclesTrajectoryReq.setWayOrderNo(req.getWayOrderNo());
         vehiclesTrajectoryReq.setLOrderNo(Optional.ofNullable(logisticsOrder).map(KwtLogisticsOrder::getLOrderNo).orElse( ""));