司机连续到场加分

sckw-modules/sckw-fleet/src/main/java/com/sckw/fleet/service/KwfDriverScoreService.java

@@ -327,6 +327,7 @@ public class KwfDriverScoreService {
             detailVO.setAction(detail.getAction());
             detailVO.setScoreChange(detail.getScoreChange());
             detailVO.setScore(detail.getScore());
+            detailVO.setCreateTime(detail.getCreateTime());
             scorerDetailVOList.add(detailVO);
 
             //查询当前物流企业自动派单且生效的物流合同

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/handler/AbstractWaybillOrderHandler.java

@@ -26,7 +26,7 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.math.BigDecimal;
-import java.util.List;
+import java.util.*;
 import java.util.stream.Collectors;
 
 /**
@@ -310,21 +310,33 @@ public abstract class AbstractWaybillOrderHandler<T extends WaybillOrderProcessP
                 .queryContinuousNodesByDriverId(wOrderIds, waybillOrder.getDriverId(), waybillV1Enum.getCode());
         if (CollectionUtils.isEmpty(waybillOrderNodeList) || waybillOrderNodeList.size() < continuousOnTimes) {
             log.info("司机{}按时接节点不足{}次，当前记录数：{}", waybillOrder.getDriverId(), continuousOnTimes, waybillOrderNodeList.size());
-            return null;
+            return Collections.emptyList();
         }
         return waybillOrderNodeList;
     }
 
     /**
-     * 给连续的10次的节点数据打标
+     * 给连续的N次的节点数据打标
      */
     protected void updateNode(KwtWaybillOrder waybillOrder, List<Long> nodeIds, Integer continuousOnTimes, Integer continuousOnTimeScore) {
+        if (CollectionUtils.isEmpty(nodeIds)) {
+            return;
+        }
+        List<KwtWaybillOrderNode> nodes = waybillOrderNodeRepository.queryContinuousNodesByIds(nodeIds);
+
+        Set<Long> wOrderIds = nodes.stream()
+                .map(KwtWaybillOrderNode::getWOrderId)
+                .filter(Objects::nonNull)
+                .collect(Collectors.toSet());
+
         KwtWaybillOrderNode updateEntity = new KwtWaybillOrderNode();
         updateEntity.setContinuous(1);
         LambdaQueryWrapper<KwtWaybillOrderNode> updateWrapper = new LambdaQueryWrapper<KwtWaybillOrderNode>()
-                .in(KwtWaybillOrderNode::getId, nodeIds);
+                .eq(KwtWaybillOrderNode::getDriverId, waybillOrder.getDriverId())
+                .in(KwtWaybillOrderNode::getWOrderId, wOrderIds)
+                .eq(KwtWaybillOrderNode::getOrderStatus, CarWaybillV1Enum.REFUSE_TRAFFIC.getCode());
         waybillOrderNodeRepository.update(updateEntity, updateWrapper);
-        log.info("司机{}最新{}条节点全部未超时，加分：{}，节点ID：{}", waybillOrder.getDriverId(), continuousOnTimes, continuousOnTimeScore, nodeIds);
+        log.info("司机{}最新{}条节点全部未超时，加分：{}，涉及运单ID：{}", waybillOrder.getDriverId(), continuousOnTimes, continuousOnTimeScore, wOrderIds);
     }
 
 

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/handler/ComeIntoHandler.java

@@ -23,10 +23,8 @@ import org.springframework.transaction.annotation.Transactional;
 
 import java.math.BigDecimal;
 import java.math.RoundingMode;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
-import java.util.Objects;
+import java.util.*;
+import java.util.stream.Collectors;
 
 /**
  * Author: donglang
@@ -36,7 +34,7 @@ import java.util.Objects;
  */
 @Slf4j
 @Service
-public class ComeIntoHandler extends AbstractWaybillOrderHandler<WaybillOrderCmeIntoWeighParam>{
+public class ComeIntoHandler extends AbstractWaybillOrderHandler<WaybillOrderCmeIntoWeighParam> {
 
     @Autowired
     private KwtWaybillOrderTicketRepository waybillOrderTicketRepository;
@@ -57,7 +55,7 @@ public class ComeIntoHandler extends AbstractWaybillOrderHandler<WaybillOrderCme
     @Override
     protected void doBusiness(WaybillOrderCmeIntoWeighParam param, KwtWaybillOrder waybillOrder) {
         //1.填充运单皮重
-        LambdaQueryWrapper<KwtWaybillOrderTicket>  queryWrapper = Wrappers.<KwtWaybillOrderTicket>lambdaQuery()
+        LambdaQueryWrapper<KwtWaybillOrderTicket> queryWrapper = Wrappers.<KwtWaybillOrderTicket>lambdaQuery()
                 .eq(KwtWaybillOrderTicket::getWOrderId, param.getWaybillOrderId())
                 .eq(KwtWaybillOrderTicket::getType, AddressTypeEnum.SHIPMENT.getCode());
         KwtWaybillOrderTicket orderTicket = waybillOrderTicketRepository.getOne(queryWrapper);
@@ -112,6 +110,7 @@ public class ComeIntoHandler extends AbstractWaybillOrderHandler<WaybillOrderCme
 
     /**
      * 自动派单计算分值
+     *
      * @param param
      * @param waybillOrder
      */
@@ -131,64 +130,34 @@ public class ComeIntoHandler extends AbstractWaybillOrderHandler<WaybillOrderCme
     }
 
 
-    /**
-     * 校验司机到达装货点是否超时
-     * @param waybillOrder
-     */
-    private void checkArrivedLoadingPointTimeout(KwtWaybillOrder waybillOrder) {
-        //计算司机到达装货点是否超时
-        Boolean isTimeOut = isTimeOut(waybillOrder.getEntId(), waybillOrder.getId());
-        if (isTimeOut) {
-            DriverConductRulesVO rulesVO = getDriverConductRulesByEntId(waybillOrder.getEntId());
-            Integer notOnTimeArrive = rulesVO.getNotOnTimeArriveScore();
-            if (notOnTimeArrive <= 0) {
-                log.warn("【司机未按时到场】司机扣分失败，企业{}的司机未按时到场分数配置异常，运单ID：{}", waybillOrder.getEntId(), waybillOrder.getId());
-                throw new BusinessPlatfromException(ErrorCodeEnum.DATA_NOT_EXIST, "【司机未按时到场】分数配置需大于0!");
-            }
-            //1、更新司机分数（减分）
-            notOnTimeArrive = -Math.abs(notOnTimeArrive);
-            Long supEntId = getSupplierId(waybillOrder);
-            updateDriverScore(supEntId, waybillOrder.getEntId(), waybillOrder.getDriverId(), notOnTimeArrive, "司机未按时到场");
-
-            //2、更新企业分数（减分）
-            updateLogEntScore(waybillOrder, supEntId, notOnTimeArrive, "司机未按时到场");
-        }
-    }
-
-
-
-    /**
-     * 司机到达装货点是否超时
-     * @param entId
-     */
-    private Boolean isTimeOut(Long entId, Long wOrderId) {
-        // 获取自动派单系数配置（司机超时限制）
-        TruckDispatchCoefficientVO truckDispatchVO = getAutoTruckDispatchByEntId(entId);
-        Integer driverTimeout = truckDispatchVO.getDriverTimeoutLimit();
-        if (driverTimeout <= 0) {
-            log.warn("【司机未按时到场】企业{}的司机超时限制配置异常，运单ID：{}", entId,wOrderId);
-            throw new BusinessPlatfromException(ErrorCodeEnum.DATA_NOT_EXIST, "【司机未按时到场】司机超时限制配置需大于0!");
-        }
-        //司机接单时间
-        KwtWaybillOrderNode takingOrderNodes = getNodesByOrderId(wOrderId, CarWaybillV1Enum.PENDING_VEHICLE.getCode());
-        Date takingOrderTime = takingOrderNodes.getCreateTime() != null ? takingOrderNodes.getCreateTime() : null;
-        //司机到底装货点时间
-        KwtWaybillOrderNode comeIntoNode = getNodesByOrderId(wOrderId, CarWaybillV1Enum.REFUSE_TRAFFIC.getCode());
-        Date comeIntoTime = comeIntoNode.getCreateTime() != null ? comeIntoNode.getCreateTime() : null;
-
-        // 计算两个时间的分钟差
-        Long timeDiffMinutes = DateUtils.calculateTimeDiffMinutes(takingOrderTime, comeIntoTime);
-        //超时
-        if (timeDiffMinutes > driverTimeout.longValue()) {
-            log.info("司机到场耗时超时！司机超时限制：" + driverTimeout + "分钟，实际：" + timeDiffMinutes + "分钟");
-            return true;
-        }
-        return false;
-    }
+//    /**
+//     * 校验司机到达装货点是否超时
+//     * @param waybillOrder
+//     */
+//    private void checkArrivedLoadingPointTimeout(KwtWaybillOrder waybillOrder) {
+//        //计算司机到达装货点是否超时
+//        Boolean isTimeOut = isTimeOut(waybillOrder.getEntId(), waybillOrder.getId());
+//        if (isTimeOut) {
+//            DriverConductRulesVO rulesVO = getDriverConductRulesByEntId(waybillOrder.getEntId());
+//            Integer notOnTimeArrive = rulesVO.getNotOnTimeArriveScore();
+//            if (notOnTimeArrive <= 0) {
+//                log.warn("【司机未按时到场】司机扣分失败，企业{}的司机未按时到场分数配置异常，运单ID：{}", waybillOrder.getEntId(), waybillOrder.getId());
+//                throw new BusinessPlatfromException(ErrorCodeEnum.DATA_NOT_EXIST, "【司机未按时到场】分数配置需大于0!");
+//            }
+//            //1、更新司机分数（减分）
+//            notOnTimeArrive = -Math.abs(notOnTimeArrive);
+//            Long supEntId = getSupplierId(waybillOrder);
+//            updateDriverScore(supEntId, waybillOrder.getEntId(), waybillOrder.getDriverId(), notOnTimeArrive, "司机未按时到场");
+//
+//            //2、更新企业分数（减分）
+//            updateLogEntScore(waybillOrder, supEntId, notOnTimeArrive, "司机未按时到场");
+//        }
+//    }
 
 
     /**
      * 校验连续按时到场次数
+     *
      * @param waybillOrder
      */
     private void checkContinuousArriveTimes(KwtWaybillOrder waybillOrder) {
@@ -206,44 +175,92 @@ public class ComeIntoHandler extends AbstractWaybillOrderHandler<WaybillOrderCme
 
         //查询该司机连续到达装货点的节点数据
         List<KwtWaybillOrderNode> waybillOrderNodeList = getWaybillOrderNodesByStatus(waybillOrder, continuousOnTimeArriveTimes, CarWaybillV1Enum.REFUSE_TRAFFIC);
-        if (waybillOrderNodeList == null)  {
+        List<KwtWaybillOrderNode> recentNodes = getWaybillOrderDistantNodeList(waybillOrderNodeList, continuousOnTimeArriveTimes);
+        if (recentNodes.size() != continuousOnTimeArriveTimes) {
+            log.info("司机{}最近按时到场记录不足{}条，当前：{}", waybillOrder.getDriverId(), continuousOnTimeArriveTimes, recentNodes.size());
             return;
         }
-        //记录连续到场次数
-        int continuousCount = 0;
-        List<Long> qualifiedNodeIds = new ArrayList<>();
         List<Long> nodeIds = new ArrayList<>();
-        for (KwtWaybillOrderNode orderNode : waybillOrderNodeList) {
-            //计算每次运单到达场地耗时时间
-            if (isTimeOut(waybillOrder.getEntId(), orderNode.getWOrderId())){
-                log.info("司机{}存在超时情况，运单id：{}", orderNode.getDriverId(), orderNode.getWOrderId());
-                return;
+        boolean allOnTime = true;
+        for (KwtWaybillOrderNode orderNode : recentNodes) {
+            if (orderNode.getContinuous() == 1) {
+                break;
             }
-            continuousCount++;
-            qualifiedNodeIds.add(orderNode.getId());
-
-            // 达到10次，返回最新的10条ID
-            if (continuousCount >= continuousOnTimeArriveTimes) {
-                // 截断前10条
-                nodeIds = qualifiedNodeIds.subList(0, continuousOnTimeArriveTimes);
+            //计算每次运单到达场地耗时时间
+            if (isTimeOut(waybillOrder, orderNode.getWOrderId())) {
+                allOnTime = false;
                 break;
             }
+            nodeIds.add(orderNode.getId());
         }
-        // 校验是否达到次数
-        if (continuousCount < continuousOnTimeArriveTimes) {
-            log.info("【司机连续按时到场】司机{}连续按时到场次数{}，未达到配置阈值{}", waybillOrder.getDriverId(), continuousCount, continuousOnTimeArriveTimes);
-            return;
-        }
+        if (allOnTime && nodeIds.size() == continuousOnTimeArriveTimes) {
+            //1. 给连续的N次节点数据打标
+            updateNode(waybillOrder, nodeIds, continuousOnTimeArriveTimes, continuousOnTimeScore);
 
-        //1. 给连续的10次节点数据打标
-        updateNode(waybillOrder, nodeIds, continuousOnTimeArriveTimes, continuousOnTimeScore);
+            //2 .更新司机分数（加分）
+            updateDriverScore(supEntId, waybillOrder.getEntId(), waybillOrder.getDriverId(), continuousOnTimeScore, "司机连续按时到场");
 
-        //2 .更新司机分数（加分）
-        updateDriverScore(supEntId, waybillOrder.getEntId(), waybillOrder.getDriverId(), continuousOnTimeScore, "司机连续按时到场");
+            //3. 更新企业分数（加分）
+            updateLogEntScore(waybillOrder, supEntId, continuousOnTimeScore, "司机连续按时到场");
+        } else {
+            log.info("司机{}最近{}次中存在超时，未加分", waybillOrder.getDriverId(), continuousOnTimeArriveTimes);
+        }
 
-        //3. 更新企业分数（加分）
-        updateLogEntScore(waybillOrder, supEntId, continuousOnTimeScore, "司机连续按时到场");
+    }
 
+    /**
+     * 获取去重后的节点数据
+     * @param waybillOrderNodeList
+     * @param continuousOnTimeArriveTimes
+     * @return
+     */
+    private List<KwtWaybillOrderNode> getWaybillOrderDistantNodeList(List<KwtWaybillOrderNode> waybillOrderNodeList, Integer continuousOnTimeArriveTimes) {
+        //由于到达装货点有生成两条节点数据，需要过来出一条
+        List<KwtWaybillOrderNode> deduplicated = waybillOrderNodeList.stream()
+                .collect(Collectors.toMap(
+                        KwtWaybillOrderNode::getWOrderId,
+                        node -> node,
+                        (existing, replacement) ->
+                                existing.getCreateTime().compareTo(replacement.getCreateTime()) >= 0 ? existing : replacement,
+                        LinkedHashMap::new)
+                ).values()
+                .stream()
+                .collect(Collectors.toList());
+
+        //取continuousOnTimes条节点数据
+        return deduplicated.stream().sorted(Comparator.comparing(KwtWaybillOrderNode::getCreateTime).reversed())
+                .limit(continuousOnTimeArriveTimes)
+                .collect(Collectors.toList());
     }
 
+    /**
+     * 司机到达装货点是否超时
+     *
+     * @param waybillOrder
+     */
+    private Boolean isTimeOut(KwtWaybillOrder waybillOrder, Long wOrderId) {
+        Long supEntId = getSupplierId(waybillOrder);
+        // 获取自动派单系数配置（司机超时限制）
+        TruckDispatchCoefficientVO truckDispatchVO = getAutoTruckDispatchByEntId(supEntId);
+        Integer driverTimeout = truckDispatchVO.getDriverTimeoutLimit();
+        if (driverTimeout <= 0) {
+            log.warn("【司机未按时到场】企业{}的司机超时限制配置异常，运单ID：{}", supEntId, wOrderId);
+            throw new BusinessPlatfromException(ErrorCodeEnum.DATA_NOT_EXIST, "【司机未按时到场】司机超时限制配置需大于0!");
+        }
+        //司机接单时间
+        KwtWaybillOrderNode takingOrderNodes = getNodesByOrderId(wOrderId, CarWaybillV1Enum.PENDING_VEHICLE.getCode());
+        Date takingOrderTime = takingOrderNodes.getCreateTime() != null ? takingOrderNodes.getCreateTime() : null;
+        //司机到底装货点时间
+        KwtWaybillOrderNode comeIntoNode = getNodesByOrderId(wOrderId, CarWaybillV1Enum.REFUSE_TRAFFIC.getCode());
+        Date comeIntoTime = comeIntoNode.getCreateTime() != null ? comeIntoNode.getCreateTime() : null;
+
+        // 计算两个时间的分钟差
+        Long timeDiffMinutes = DateUtils.calculateTimeDiffMinutes(takingOrderTime, comeIntoTime);
+        //超时
+        if (timeDiffMinutes > driverTimeout.longValue()) {
+            log.info("司机到场耗时超时！司机超时限制：" + driverTimeout + "分钟，实际：" + timeDiffMinutes + "分钟");
+            return true;
+        }
+        return false;
+    }
 }

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

@@ -46,7 +46,8 @@ public class KwtWaybillOrderNodeRepository extends ServiceImpl<KwtWaybillOrderNo
                 .eq(KwtWaybillOrderNode::getWOrderId, wOrderId)
                 .eq(KwtWaybillOrderNode::getOrderStatus, status)
                 .orderByDesc(KwtWaybillOrderNode::getCreateTime)
-                .orderByDesc(KwtWaybillOrderNode::getId));
+                .orderByDesc(KwtWaybillOrderNode::getId)
+                .last("limit 1"));
     }
 
     /**
@@ -59,7 +60,6 @@ public class KwtWaybillOrderNodeRepository extends ServiceImpl<KwtWaybillOrderNo
                 .in(KwtWaybillOrderNode::getWOrderId, wOrderIds)
                 .eq(KwtWaybillOrderNode::getDriverId, driverId)
                 .eq(KwtWaybillOrderNode::getOrderStatus, status)
-                .eq(KwtWaybillOrderNode::getContinuous, 0)
                 .orderByAsc(KwtWaybillOrderNode::getCreateTime));
     }
 
@@ -89,4 +89,16 @@ public class KwtWaybillOrderNodeRepository extends ServiceImpl<KwtWaybillOrderNo
                 .between(KwtWaybillOrderNode::getCreateTime, startDate, endDate)
                 .orderByAsc(KwtWaybillOrderNode::getCreateTime));
     }
+
+    /**
+     * 查询司机的运单节点数据
+     * @param nodeIds
+     * @return
+     */
+    public List<KwtWaybillOrderNode> queryContinuousNodesByIds(List<Long> nodeIds) {
+        return list(Wrappers.<KwtWaybillOrderNode>lambdaQuery()
+                .in(KwtWaybillOrderNode::getId, nodeIds)
+                .orderByAsc(KwtWaybillOrderNode::getCreateTime));
+    }
+
 }