Merge branch 'dev_20251130' into dev_mvp3

sckw-modules-api/sckw-contract-api/src/main/java/com/sckw/contract/api/model/dto/req/LogisticsScoreDetailFeignDto.java

@@ -24,10 +24,10 @@ public class LogisticsScoreDetailFeignDto {
     @NotNull(message = "物流企业id不能为空")
     private Long logisticsEntId;
     /**
-     * 评分行为影响人id
+     * 影响人手机号
      */
-    @NotNull(message = "影响人id不能为空")
-    private Long influenceBy;
+    @NotBlank(message = "影响人手机号")
+    private String phone;
     /**
      * 评分行为
      */

sckw-modules-api/sckw-system-api/src/main/java/com/sckw/system/api/RemoteSystemService.java

@@ -188,6 +188,7 @@ public interface RemoteSystemService {
      */
     UserCacheResDto queryUserCacheById(Long userId);
     UserResDto queryUserById(Long userId);
+    UserResDto queryUserByPhone(String phone);
 
     /**
      * @desc: 从缓存查用户信息

sckw-modules/sckw-contract/src/main/java/com/sckw/contract/dubbo/RemoteContractServiceImpl.java

@@ -485,7 +485,7 @@ public class RemoteContractServiceImpl implements RemoteContractService {
 
             //查询供应企业
             KwcContractLogisticsUnit unit = kwcContractLogisticsUnitRepository
-                    .queryByContractIdAndEntType(log.getId(), entId, EntTypeEnum.LOGISTICS3.getCode());
+                    .queryByContractIdAndEntType(log.getId(), EntTypeEnum.LOGISTICS3.getCode());
             if (unit != null) {
                 dto.setSupEntId(unit.getEntId());
             }

sckw-modules/sckw-contract/src/main/java/com/sckw/contract/repository/KwcContractLogisticsUnitRepository.java

@@ -87,10 +87,9 @@ public class KwcContractLogisticsUnitRepository extends ServiceImpl<KwcContractL
                 .last("limit 1"));
     }
 
-    public KwcContractLogisticsUnit queryByContractIdAndEntType(Long contractId, Long entId, Integer entType) {
+    public KwcContractLogisticsUnit queryByContractIdAndEntType(Long contractId, Integer entType) {
         return getOne(Wrappers.<KwcContractLogisticsUnit>lambdaQuery()
                 .eq(KwcContractLogisticsUnit::getContractId, contractId)
-                .eq(KwcContractLogisticsUnit::getEntId, entId)
                 .eq(KwcContractLogisticsUnit::getUnitType, entType)
                 .eq(KwcContractLogisticsUnit::getDelFlag,0)
                 .last("limit 1"));

sckw-modules/sckw-contract/src/main/java/com/sckw/contract/service/impl/KwcContractLogisticsScoreServiceImpl.java

@@ -40,6 +40,7 @@ import com.sckw.redis.utils.RedissonUtils;
 import com.sckw.system.api.RemoteSystemService;
 import com.sckw.system.api.model.dto.res.EntCacheResDto;
 import com.sckw.system.api.model.dto.res.UserCacheResDto;
+import com.sckw.system.api.model.dto.res.UserResDto;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.dubbo.config.annotation.DubboReference;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -412,7 +413,11 @@ public class KwcContractLogisticsScoreServiceImpl implements IKwcContractLogisti
             //2.插入评分明细记录
             LogisticsScoreDetailAddDto detailAddDto = new LogisticsScoreDetailAddDto();
             detailAddDto.setScoreId(logisticsScore.getId());
-            detailAddDto.setInfluenceBy(detailDto.getInfluenceBy());
+            //根据影响人手机号查询影响人userId
+            UserResDto userResDto = remoteSystemService.queryUserByPhone(detailDto.getPhone());
+            if(userResDto != null){
+                detailAddDto.setInfluenceBy(userResDto.getId());
+            }
             detailAddDto.setAction(detailDto.getAction());
             detailAddDto.setScoreChange(entScoreChange);
             detailAddDto.setScore(resultScore);

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-system/src/main/java/com/sckw/system/dao/KwsUserDao.java

@@ -40,6 +40,13 @@ public interface KwsUserDao extends BaseMapper<KwsUser> {
      */
     KwsUser selectByKey(Long id);
 
+    /**
+     * 详情查询
+     * @param phone
+     * @return
+     */
+    KwsUser selectByPhone(String phone);
+
     /**
      * 详情查询
      * @param list

sckw-modules/sckw-system/src/main/java/com/sckw/system/dubbo/RemoteSystemServiceImpl.java

@@ -623,6 +623,16 @@ public class RemoteSystemServiceImpl implements RemoteSystemService {
         return null;
     }
 
+    @Override
+    public UserResDto queryUserByPhone(String phone) {
+        KwsUser kwsUser = kwsUserService.selectByPhone(phone);
+        if (Objects.nonNull(kwsUser)) {
+            UserResDto bean = BeanUtil.toBean(kwsUser, UserResDto.class);
+            return bean;
+        }
+        return null;
+    }
+
     @Override
     public List<UserCacheResDto> queryUserCacheByIds(List<Long> userIds) {
         if (CollectionUtils.isEmpty(userIds)) {

sckw-modules/sckw-system/src/main/java/com/sckw/system/service/KwsUserService.java

@@ -406,6 +406,13 @@ public class KwsUserService {
         return kwsUserDao.selectByKey(key);
     }
 
+    /**
+     * 根据主键查询
+     */
+    public KwsUser selectByPhone(String phone) {
+        return kwsUserDao.selectByPhone(phone);
+    }
+
     /**
      * 根据主键查询
      */

sckw-modules/sckw-system/src/main/resources/mapper/KwsUserDao.xml

@@ -70,6 +70,13 @@
         where id = #{id,jdbcType=BIGINT}
     </select>
 
+    <select id="selectByPhone" parameterType="java.lang.String" resultMap="BaseResultMap">
+        select
+        <include refid="Base_Column_List"/>
+        from kws_user
+        where phone = #{phone, jdbcType=VARCHAR}
+    </select>
+
     <select id="selectByKeys" resultMap="BaseResultMap">
         select
         <include refid="Base_Column_List"/>

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);
     }
 
 
@@ -356,7 +368,7 @@ public abstract class AbstractWaybillOrderHandler<T extends WaybillOrderProcessP
         LogisticsScoreDetailFeignDto detailDto = new LogisticsScoreDetailFeignDto();
         detailDto.setProviderEntId(supplierId);
         detailDto.setLogisticsEntId(waybillOrder.getEntId());
-        detailDto.setInfluenceBy(waybillOrder.getDriverId());
+        detailDto.setPhone(waybillOrder.getDriverPhone());
         detailDto.setAction(remark);
         detailDto.setScoreChange(BigDecimal.valueOf(score));
         logisticsScoreFeignService.updateLogisticsScore(detailDto);

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
      */
@@ -123,7 +122,7 @@ public class ComeIntoHandler extends AbstractWaybillOrderHandler<WaybillOrderCme
 //            return;
 //        }
         // 司机到达装货点是否超时（未按时到场）
-        checkArrivedLoadingPointTimeout(waybillOrder);
+//        checkArrivedLoadingPointTimeout(waybillOrder);
 
         //校验连续按时到场次数
         checkContinuousArriveTimes(waybillOrder);
@@ -131,42 +130,121 @@ 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 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!");
+    private void checkContinuousArriveTimes(KwtWaybillOrder waybillOrder) {
+        Long supEntId = getSupplierId(waybillOrder);
+        // 获取司机行为规则配置
+        DriverConductRulesVO driverRulesVO = getDriverConductRulesByEntId(supEntId);
+        //连续按时到场分数
+        Integer continuousOnTimeScore = driverRulesVO.getContinuousOnTimeArriveScore();
+        //连续按时到场次数
+        Integer continuousOnTimeArriveTimes = driverRulesVO.getContinuousOnTimeArriveTimes();
+        if (continuousOnTimeScore <= 0 || continuousOnTimeArriveTimes <= 0) {
+            log.warn("【司机连续按时到场】该司机无需加分，企业{}的连续按时到场次数/分数配置异常，运单ID：{}", supEntId, waybillOrder.getId());
+            throw new BusinessPlatfromException(ErrorCodeEnum.DATA_NOT_EXIST, "【司机连续按时到场】次数/分数需大于0!");
+        }
+
+        //查询该司机连续到达装货点的节点数据
+        List<KwtWaybillOrderNode> waybillOrderNodeList = getWaybillOrderNodesByStatus(waybillOrder, continuousOnTimeArriveTimes, CarWaybillV1Enum.REFUSE_TRAFFIC);
+        List<KwtWaybillOrderNode> recentNodes = getWaybillOrderDistantNodeList(waybillOrderNodeList, continuousOnTimeArriveTimes);
+        if (recentNodes.size() != continuousOnTimeArriveTimes) {
+            log.info("司机{}最近按时到场记录不足{}条，当前：{}", waybillOrder.getDriverId(), continuousOnTimeArriveTimes, recentNodes.size());
+            return;
+        }
+        List<Long> nodeIds = new ArrayList<>();
+        boolean allOnTime = true;
+        for (KwtWaybillOrderNode orderNode : recentNodes) {
+            if (orderNode.getContinuous() == 1) {
+                break;
             }
-            //1、更新司机分数（减分）
-            notOnTimeArrive = -Math.abs(notOnTimeArrive);
-            Long supEntId = getSupplierId(waybillOrder);
-            updateDriverScore(supEntId, waybillOrder.getEntId(), waybillOrder.getDriverId(), notOnTimeArrive, "司机未按时到场");
+            //计算每次运单到达场地耗时时间
+            if (isTimeOut(waybillOrder, orderNode.getWOrderId())) {
+                allOnTime = false;
+                break;
+            }
+            nodeIds.add(orderNode.getId());
+        }
+        if (allOnTime && nodeIds.size() == continuousOnTimeArriveTimes) {
+            //1. 给连续的N次节点数据打标
+            updateNode(waybillOrder, nodeIds, continuousOnTimeArriveTimes, continuousOnTimeScore);
 
-            //2、更新企业分数（减分）
-            updateLogEntScore(waybillOrder, supEntId, notOnTimeArrive, "司机未按时到场");
+            //2 .更新司机分数（加分）
+            updateDriverScore(supEntId, waybillOrder.getEntId(), waybillOrder.getDriverId(), continuousOnTimeScore, "司机连续按时到场");
+
+            //3. 更新企业分数（加分）
+            updateLogEntScore(waybillOrder, supEntId, continuousOnTimeScore, "司机连续按时到场");
+        } else {
+            log.info("司机{}最近{}次中存在超时，未加分", waybillOrder.getDriverId(), continuousOnTimeArriveTimes);
         }
-    }
 
+    }
 
+    /**
+     * 获取去重后的节点数据
+     * @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 entId
+     *
+     * @param waybillOrder
      */
-    private Boolean isTimeOut(Long entId, Long wOrderId) {
+    private Boolean isTimeOut(KwtWaybillOrder waybillOrder, Long wOrderId) {
+        Long supEntId = getSupplierId(waybillOrder);
         // 获取自动派单系数配置（司机超时限制）
-        TruckDispatchCoefficientVO truckDispatchVO = getAutoTruckDispatchByEntId(entId);
+        TruckDispatchCoefficientVO truckDispatchVO = getAutoTruckDispatchByEntId(supEntId);
         Integer driverTimeout = truckDispatchVO.getDriverTimeoutLimit();
         if (driverTimeout <= 0) {
-            log.warn("【司机未按时到场】企业{}的司机超时限制配置异常，运单ID：{}", entId,wOrderId);
+            log.warn("【司机未按时到场】企业{}的司机超时限制配置异常，运单ID：{}", supEntId, wOrderId);
             throw new BusinessPlatfromException(ErrorCodeEnum.DATA_NOT_EXIST, "【司机未按时到场】司机超时限制配置需大于0!");
         }
         //司机接单时间
@@ -185,65 +263,4 @@ public class ComeIntoHandler extends AbstractWaybillOrderHandler<WaybillOrderCme
         }
         return false;
     }
-
-
-    /**
-     * 校验连续按时到场次数
-     * @param waybillOrder
-     */
-    private void checkContinuousArriveTimes(KwtWaybillOrder waybillOrder) {
-        // 获取司机行为规则配置
-        DriverConductRulesVO driverRulesVO = getDriverConductRulesByEntId(waybillOrder.getEntId());
-        //连续按时到场分数
-        Integer continuousOnTimeScore = driverRulesVO.getContinuousOnTimeArriveScore();
-        //连续按时到场次数
-        Integer continuousOnTimeArriveTimes = driverRulesVO.getContinuousOnTimeArriveTimes();
-        if (continuousOnTimeScore <= 0 || continuousOnTimeArriveTimes <= 0) {
-            log.warn("【司机连续按时到场】该司机无需加分，企业{}的连续按时到场次数/分数配置异常，运单ID：{}", waybillOrder.getEntId(), waybillOrder.getId());
-            throw new BusinessPlatfromException(ErrorCodeEnum.DATA_NOT_EXIST, "【司机连续按时到场】次数/分数需大于0!");
-        }
-
-        //查询该司机连续到达装货点的节点数据
-        List<KwtWaybillOrderNode> waybillOrderNodeList = getWaybillOrderNodesByStatus(waybillOrder, continuousOnTimeArriveTimes, CarWaybillV1Enum.REFUSE_TRAFFIC);
-        if (waybillOrderNodeList == null)  {
-            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;
-            }
-            continuousCount++;
-            qualifiedNodeIds.add(orderNode.getId());
-
-            // 达到10次，返回最新的10条ID
-            if (continuousCount >= continuousOnTimeArriveTimes) {
-                // 截断前10条
-                nodeIds = qualifiedNodeIds.subList(0, continuousOnTimeArriveTimes);
-                break;
-            }
-        }
-        // 校验是否达到次数
-        if (continuousCount < continuousOnTimeArriveTimes) {
-            log.info("【司机连续按时到场】司机{}连续按时到场次数{}，未达到配置阈值{}", waybillOrder.getDriverId(), continuousCount, continuousOnTimeArriveTimes);
-            return;
-        }
-
-        //1. 给连续的10次节点数据打标
-        updateNode(waybillOrder, nodeIds, continuousOnTimeArriveTimes, continuousOnTimeScore);
-
-        //2 .更新司机分数（加分）
-        Long supEntId = getSupplierId(waybillOrder);
-        updateDriverScore(supEntId, waybillOrder.getEntId(), waybillOrder.getDriverId(), continuousOnTimeScore, "司机连续按时到场");
-
-        //3. 更新企业分数（加分）
-        updateLogEntScore(waybillOrder, supEntId, continuousOnTimeScore, "司机连续按时到场");
-
-    }
-
 }

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/model/KwtWaybillOrderNode.java

@@ -103,6 +103,11 @@ public class KwtWaybillOrderNode implements Serializable {
      */
     private Integer continuous;
 
+    /**
+     * 是否已用于连续加分（审核通过）
+     */
+    private Integer isBonus;
+
     /**
      * 创建时间
      */

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

@@ -31,8 +31,8 @@ public class KwtWaybillOrderNodeRepository extends ServiceImpl<KwtWaybillOrderNo
         if (wSubtaskId != null) {
             wrapper.eq(KwtWaybillOrderNode::getWSubtaskId, wSubtaskId);
         }
-        wrapper.orderByAsc(KwtWaybillOrderNode::getCreateTime);
-        wrapper.orderByAsc(KwtWaybillOrderNode::getId);
+        wrapper.orderByDesc(KwtWaybillOrderNode::getCreateTime);
+        wrapper.orderByDesc(KwtWaybillOrderNode::getId);
         return this.list(wrapper);
     }
 
@@ -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));
+    }
+
 }

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

@@ -153,7 +153,7 @@ public class KwtWaybillOrderV1Service {
     private RemoteSystemService remoteSystemService;
     @DubboReference(version = "1.0.0", group = "design", check = false, timeout = 6000)
     private RemoteUserService remoteUserService;
-    @DubboReference(version = "1.0.0", group = "design", check = false)
+    @DubboReference(version = "1.0.0", group = "design", check = false, timeout = 10000)
     private RemoteFleetService remoteFleetService;
     @DubboReference(version = "1.0.0", group = "design", check = false)
     private TradeOrderInfoService tradeOrderInfoService;
@@ -4553,6 +4553,9 @@ public class KwtWaybillOrderV1Service {
                 }
             }
 
+            //计算司机分值
+            calculateAutoDispatchScore(billOrder, status);
+
             return Boolean.TRUE;
         }
         // 驳回的订单可以通过完善单证变成已完成
@@ -4593,8 +4596,6 @@ public class KwtWaybillOrderV1Service {
             return Boolean.TRUE;
         }
         noticeTraderOrder(status, subtask,kwtLogistics);
-        //计算司机分值
-        calculateAutoDispatchScore(billOrder, status);
 
         return Boolean.FALSE;
     }
@@ -4631,47 +4632,39 @@ public class KwtWaybillOrderV1Service {
      * @param billOrder
      */
     protected void calculateAutoDispatchScore(KwtWaybillOrder billOrder, Integer status) {
-//        if (true) {
-//            //先不执行自动派单逻辑
-//            return;
-//        }
-        //查询物流订单
-        KwtLogisticsOrder logisticsOrder = kwtLogisticsOrderRepository.queryByLogisticsOrderId(billOrder.getLOrderId());
-
-        //查询运单装卸货地址
-        List<KwtWaybillOrderAddress> addressList = waybillOrderAddressRepository.queryByWOrderId(billOrder.getId());
-        if (CollectionUtils.isEmpty(addressList)) {
-            log.info("物流运单无装卸货地址信息，运单id:{}", billOrder.getId());
-            throw new BusinessPlatfromException(ErrorCodeEnum.LOGISTICS_ORDER_NOT_ADDRESS, "物流订单无装卸货地址信息");
-        }
-        Map<Integer, KwtWaybillOrderAddress> addressMap = addressList.stream()
-                .filter(addr -> addr.getAddressType() != null)
-                .collect(Collectors.toMap(KwtWaybillOrderAddress::getAddressType, Function.identity(),
-                        (x,y) ->x));
-
-        // 获取司机行为规则配置（司机违规取消运单分钟数）
-        DriverConductRulesVO driverRulesVO = remoteFleetService.findDriverConductRulesByEntId(billOrder.getEntId());
-        if (driverRulesVO == null) {
-            throw new BusinessPlatfromException(ErrorCodeEnum.DATA_NOT_EXIST, "未找到司机行为规则数据！");
-        }
+        try {
+            if (!DispatchWayEnums.AUTO_DISPATCH.getCode().equals(billOrder.getDispatchWay())) {
+                return;
+            }
+            Long supEntId = getSupplierId(billOrder);
+            //查询物流订单
+            KwtLogisticsOrder logisticsOrder = kwtLogisticsOrderRepository.queryByLogisticsOrderId(billOrder.getLOrderId());
+            // 获取司机行为规则配置（司机违规取消运单分钟数）
+            DriverConductRulesVO driverRulesVO = remoteFleetService.findDriverConductRulesByEntId(supEntId);
+            if (driverRulesVO == null) {
+                throw new BusinessPlatfromException(ErrorCodeEnum.DATA_NOT_EXIST, "未找到司机行为规则数据！");
+            }
 
+            //1. 运单单据错误被驳回
+            checkRefuseScore(billOrder, status, driverRulesVO);
 
-        //1. 运单单据错误被驳回
-        checkRefuseScore(billOrder, status, driverRulesVO);
+            //运单没通过，不执行以下逻辑
+            if (!Objects.equals(status, CarWaybillV1Enum.COMPLETED.getCode())) {
+                return;
+            }
 
-        //运单没通过，不执行以下逻辑
-        if (!Objects.equals(status, CarWaybillV1Enum.COMPLETED.getCode())) {
-            return;
-        }
+            //2. 校验司机运单完成是否超时
+            checkCompletionTimeout(billOrder, logisticsOrder, driverRulesVO);
 
-        //2. 校验司机运单完成是否超时
-        checkCompletionTimeout(billOrder, logisticsOrder, driverRulesVO);
+            //3. 校验司机连续准时卸货（审核通过）
+            checkContinuousUnload(billOrder, logisticsOrder, supEntId);
 
-        //3. 校验司机连续准时卸货（审核通过）
-        checkContinuousUnload(billOrder, logisticsOrder);
+            //4. 校验司机连续准确填写卸货信息（审核通过）
+            checkContinuousPass(billOrder, supEntId);
+        } catch (Exception e) {
+            log.info("司机分数计算失败！", e);
+        }
 
-        //4. 校验司机连续准确填写卸货信息（审核通过）
-        checkContinuousPass(billOrder, addressMap);
 
     }
 
@@ -4693,11 +4686,10 @@ public class KwtWaybillOrderV1Service {
 
         //1、更新司机分数（减分）
         documentErrorScore = -Math.abs(documentErrorScore);
-        Long supEntId = getSupplierId(waybillOrder);
-        updateDriverScore(supEntId, waybillOrder.getEntId(), waybillOrder.getDriverId(), documentErrorScore, "单据错误/缺失");
+        updateDriverScore(driverRulesVO.getEntId(), waybillOrder.getEntId(), waybillOrder.getDriverId(), documentErrorScore, "单据错误/缺失");
 
         //2、更新企业分数（减分）
-        updateLogEntScore(waybillOrder, supEntId, documentErrorScore, "单据错误/缺失");
+        updateLogEntScore(waybillOrder, driverRulesVO.getEntId(), documentErrorScore, "单据错误/缺失");
 
     }
 
@@ -4721,11 +4713,10 @@ public class KwtWaybillOrderV1Service {
         if (isTimeOut) {
             //1、更新司机分数（减分）
             timeoutScore = -Math.abs(timeoutScore);
-            Long supEntId = getSupplierId(waybillOrder);
-            updateDriverScore(supEntId, waybillOrder.getEntId(), waybillOrder.getDriverId(), timeoutScore, "卸货严重超时");
+            updateDriverScore(driverRulesVO.getEntId(), waybillOrder.getEntId(), waybillOrder.getDriverId(), timeoutScore, "卸货严重超时");
 
             //2、更新企业分数（减分）
-            updateLogEntScore(waybillOrder, supEntId, timeoutScore, "卸货严重超时");
+            updateLogEntScore(waybillOrder, driverRulesVO.getEntId(), timeoutScore, "卸货严重超时");
         }
     }
 
@@ -4823,9 +4814,9 @@ public class KwtWaybillOrderV1Service {
      * 校验司机连续准时卸货
      * @param waybillOrder
      */
-    private void checkContinuousUnload(KwtWaybillOrder waybillOrder, KwtLogisticsOrder logisticsOrder) {
+    private void checkContinuousUnload(KwtWaybillOrder waybillOrder, KwtLogisticsOrder logisticsOrder, Long supEntId) {
         // 获取司机行为规则配置（连续准时卸货次数）
-        DriverConductRulesVO driverRulesVO = remoteFleetService.findDriverConductRulesByEntId(waybillOrder.getEntId());
+         DriverConductRulesVO driverRulesVO = remoteFleetService.findDriverConductRulesByEntId(supEntId);
         if (driverRulesVO == null) {
             throw new BusinessPlatfromException(ErrorCodeEnum.DATA_NOT_EXIST, "未找到司机行为规则数据！");
         }
@@ -4834,58 +4825,51 @@ public class KwtWaybillOrderV1Service {
         //连续卸货加分分数
         Integer continuousScore = driverRulesVO.getContinuousOnTimeUnloadScore();
         if (continuousOnTimes <= 0 || continuousScore <= 0) {
-            log.warn("【连续准时卸货】获取连续准时卸货数据失败：企业{}的连续按时到场次数/分数配置异常，运单ID：{}", waybillOrder.getEntId(), waybillOrder.getId());
+            log.warn("【连续准时卸货】获取连续准时卸货数据失败：企业{}的连续按时到场次数/分数配置异常，运单ID：{}", supEntId, waybillOrder.getId());
             throw new BusinessPlatfromException(ErrorCodeEnum.DATA_NOT_EXIST, "【连续准时卸货】配置的次数/分数需大于0!");
         }
 
         //查询该司机连续审核通过节点数据
-        List<KwtWaybillOrderNode> waybillOrderNodeList = getWaybillOrderNodesByStatus(waybillOrder, continuousOnTimes, CarWaybillV1Enum.COMPLETED);
-        if (waybillOrderNodeList == null)  {
+        List<KwtWaybillOrderNode> waybillOrderNodeList = getWaybillOrderNodesByStatus(waybillOrder, continuousOnTimes);
+        if (waybillOrderNodeList.size() != continuousOnTimes) {
+            log.info("司机{}最近连续准时卸货记录不足{}条，当前：{}", waybillOrder.getDriverId(), continuousOnTimes, waybillOrderNodeList.size());
             return;
         }
         //记录连续审核通过次数
-        int continuousCount = 0;
-        List<Long> qualifiedNodeIds = new ArrayList<>();
         List<Long> nodeIds = new ArrayList<>();
+        boolean allOnTime = true;
         for (KwtWaybillOrderNode orderNode : waybillOrderNodeList) {
+            if (orderNode.getContinuous() == 1) {
+                break;
+            }
+            //计算每次运单是否准时卸货
             KwtWaybillOrder wOrder = kwtWaybillOrderRepository.queryByBillOrderId(orderNode.getWOrderId());
-            Boolean timeOut = isTimeOut(wOrder, logisticsOrder, BigDecimal.ZERO);
-            if (timeOut) {
+            if (isTimeOut(wOrder, logisticsOrder, BigDecimal.ZERO)) {
                 log.info("司机{}存在超时情况，运单id：{}", orderNode.getDriverId(), orderNode.getWOrderId());
-                return;
-            }
-            continuousCount++;
-            qualifiedNodeIds.add(orderNode.getId());
-            // 达到10次，返回最新的10条ID
-            if (continuousCount >= continuousOnTimes) {
-                // 截断前10条
-                nodeIds = qualifiedNodeIds.subList(0, continuousOnTimes);
+                allOnTime = false;
                 break;
             }
+            nodeIds.add(orderNode.getId());
         }
-        // 校验是否达到次数
-        if (continuousCount < continuousOnTimes) {
-            log.info("司机{}连续卸货完成次数{}，未达到配置阈值{}", waybillOrder.getDriverId(), continuousCount, continuousOnTimes);
-            return;
-        }
-        //1. 给连续的10次节点数据打标
-        updateNode(waybillOrder, nodeIds, continuousScore);
+        if (allOnTime && nodeIds.size() == continuousOnTimes) {
+            //1. 给连续的10次节点数据打标
+            updateNode(waybillOrder, nodeIds, continuousScore);
 
-        //2 .更新司机分数（加分）
-        Long supEntId = getSupplierId(waybillOrder);
-        updateDriverScore(supEntId, waybillOrder.getEntId(), waybillOrder.getDriverId(), continuousScore, "连续准时卸货");
+            //2 .更新司机分数（加分）
+            updateDriverScore(supEntId, waybillOrder.getEntId(), waybillOrder.getDriverId(), continuousScore, "连续准时卸货");
 
-        //3. 更新企业分数（加分）
-        updateLogEntScore(waybillOrder, supEntId, continuousScore, "连续准时卸货");
+            //3. 更新企业分数（加分）
+            updateLogEntScore(waybillOrder, supEntId, continuousScore, "连续准时卸货");
+        }
     }
 
     /**
      * 校验司机连续准确填写卸货信息
      * @param waybillOrder
      */
-    private void checkContinuousPass(KwtWaybillOrder waybillOrder, Map<Integer, KwtWaybillOrderAddress> addressMap) {
+    private void checkContinuousPass(KwtWaybillOrder waybillOrder, Long supEntId) {
         // 获取司机行为规则配置（连续准确填写卸货信息次数）
-        DriverConductRulesVO driverRulesVO = remoteFleetService.findDriverConductRulesByEntId(waybillOrder.getEntId());
+        DriverConductRulesVO driverRulesVO = remoteFleetService.findDriverConductRulesByEntId(supEntId);
         if (driverRulesVO == null) {
             throw new BusinessPlatfromException(ErrorCodeEnum.DATA_NOT_EXIST, "未找到司机行为规则数据！");
         }
@@ -4894,43 +4878,41 @@ public class KwtWaybillOrderV1Service {
         //连续卸货加分分数
         Integer continuousScore = driverRulesVO.getContinuousAccurateUnloadScore();
         if (continuousUnloadTimes <= 0 || continuousScore <= 0) {
-            log.warn("【连续准确填写卸货信息】企业{}的连续准确填写卸货信息配置的次数/分数异常，运单ID：{}", waybillOrder.getEntId(), waybillOrder.getId());
+            log.warn("【连续准确填写卸货信息】企业{}的连续准确填写卸货信息配置的次数/分数异常，运单ID：{}", supEntId, waybillOrder.getId());
             throw new BusinessPlatfromException(ErrorCodeEnum.DATA_NOT_EXIST, "【连续准确填写卸货信息】配置的次数/分数需大于0!");
         }
 
         //查询该司机连续审核通过节点数据
-        List<KwtWaybillOrderNode> waybillOrderNodeList = getWaybillOrderNodesByStatus(waybillOrder, continuousUnloadTimes, CarWaybillV1Enum.COMPLETED);
+        List<KwtWaybillOrderNode> waybillOrderNodeList = getWaybillOrderNodesByStatus(waybillOrder, continuousUnloadTimes);
         if (waybillOrderNodeList == null)  {
             return;
         }
         //记录连续审核通过次数
-        int continuousCount = 0;
-        List<Long> qualifiedNodeIds = new ArrayList<>();
         List<Long> nodeIds = new ArrayList<>();
+        boolean allOnTime = true;
         for (KwtWaybillOrderNode orderNode : waybillOrderNodeList) {
-            continuousCount++;
-            qualifiedNodeIds.add(orderNode.getId());
-            // 达到10次，返回最新的10条ID
-            if (continuousCount >= continuousUnloadTimes) {
-                // 截断前10条
-                nodeIds = qualifiedNodeIds.subList(0, continuousUnloadTimes);
+            if (orderNode.getIsBonus() == 2) {
                 break;
             }
+            //计算每次运单是否连续审核通过
+            KwtWaybillOrderNode wOrderNode = kwtWaybillOrderNodeRepository.queryNodesByOrderId(orderNode.getWOrderId(), CarWaybillV1Enum.REVIEW_REJECTION.getCode());
+            if (wOrderNode != null) {
+                log.info("司机{}存在审核驳回的情况，运单id：{}", orderNode.getDriverId(), orderNode.getWOrderId());
+                allOnTime = false;
+                break;
+            }
+            nodeIds.add(orderNode.getId());
         }
-        // 校验是否达到次数
-        if (continuousCount < continuousUnloadTimes) {
-            log.info("司机{}连续准确填写卸货信息次数{}，未达到配置阈值{}", waybillOrder.getDriverId(), continuousCount, continuousUnloadTimes);
-            return;
-        }
-        //1. 给连续的10次节点数据打标
-        updateNode(waybillOrder, nodeIds, continuousScore);
+        if (allOnTime && nodeIds.size() == continuousUnloadTimes) {
+            //1. 给连续的10次节点数据打标
+            updateReviewNode(waybillOrder, nodeIds, continuousScore);
 
-        //2 .更新司机分数（加分）
-        Long supEntId = getSupplierId(waybillOrder);
-        updateDriverScore(supEntId, waybillOrder.getEntId(), waybillOrder.getDriverId(), continuousScore, "连续准确填写卸货信息");
+            //2 .更新司机分数（加分）
+            updateDriverScore(supEntId, waybillOrder.getEntId(), waybillOrder.getDriverId(), continuousScore, "连续准确填写卸货信息");
 
-        //3. 更新企业分数（加分）
-        updateLogEntScore(waybillOrder, supEntId, continuousScore, "连续准确填写卸货信息");
+            //3. 更新企业分数（加分）
+            updateLogEntScore(waybillOrder, supEntId, continuousScore, "连续准确填写卸货信息");
+        }
     }
 
     /**
@@ -4939,7 +4921,7 @@ public class KwtWaybillOrderV1Service {
      * @param continuousOnTimes
      * @return
      */
-    protected List<KwtWaybillOrderNode> getWaybillOrderNodesByStatus(KwtWaybillOrder waybillOrder, Integer continuousOnTimes, CarWaybillV1Enum waybillV1Enum) {
+    protected List<KwtWaybillOrderNode> getWaybillOrderNodesByStatus(KwtWaybillOrder waybillOrder, Integer continuousOnTimes) {
         //司机运单数据
         List<KwtWaybillOrder> waybillOrders = kwtWaybillOrderRepository.queryByEntId(waybillOrder.getEntId(), waybillOrder.getDriverId());
         if (CollectionUtils.isEmpty(waybillOrders)) {
@@ -4948,12 +4930,16 @@ public class KwtWaybillOrderV1Service {
         List<Long> wOrderIds = waybillOrders.stream().map(KwtWaybillOrder::getId).collect(Collectors.toList());
         //查询司机的节点数据
         List<KwtWaybillOrderNode> waybillOrderNodeList = kwtWaybillOrderNodeRepository
-                .queryContinuousNodesByDriverId(wOrderIds, waybillOrder.getDriverId(), waybillV1Enum.getCode());
+                .queryContinuousNodesByDriverId(wOrderIds, waybillOrder.getDriverId(),  CarWaybillV1Enum.COMPLETED.getCode());
         if (CollectionUtils.isEmpty(waybillOrderNodeList) || waybillOrderNodeList.size() < continuousOnTimes) {
             log.info("司机{}按时接节点不足{}次，当前记录数：{}", waybillOrder.getDriverId(), continuousOnTimes, waybillOrderNodeList.size());
             return null;
         }
-        return waybillOrderNodeList;
+
+        //取continuousOnTimes条节点数据
+        return waybillOrderNodeList.stream().sorted(Comparator.comparing(KwtWaybillOrderNode::getCreateTime).reversed())
+                .limit(continuousOnTimes)
+                .collect(Collectors.toList());
     }
 
     /**
@@ -4968,6 +4954,18 @@ public class KwtWaybillOrderV1Service {
         log.info("司机{}连续执行运单节点,加分：{}，节点ID：{}", waybillOrder.getDriverId(), continuousOnTimeScore, JSON.toJSONString(nodeIds));
     }
 
+    /**
+     * 给连续的10次的节点数据打标
+     */
+    protected void updateReviewNode(KwtWaybillOrder waybillOrder, List<Long> nodeIds, Integer continuousOnTimeScore) {
+        KwtWaybillOrderNode updateEntity = new KwtWaybillOrderNode();
+        updateEntity.setIsBonus(2);
+        LambdaQueryWrapper<KwtWaybillOrderNode> updateWrapper = new LambdaQueryWrapper<KwtWaybillOrderNode>()
+                .in(KwtWaybillOrderNode::getId, nodeIds);
+        kwtWaybillOrderNodeRepository.update(updateEntity, updateWrapper);
+        log.info("司机{}连续执行运单节点,加分：{}，节点ID：{}", waybillOrder.getDriverId(), continuousOnTimeScore, JSON.toJSONString(nodeIds));
+    }
+
     // 查询供应商id
     protected Long getSupplierId(KwtWaybillOrder waybillOrder) {
         if (waybillOrder == null) {
@@ -5008,7 +5006,7 @@ public class KwtWaybillOrderV1Service {
         LogisticsScoreDetailFeignDto detailDto = new LogisticsScoreDetailFeignDto();
         detailDto.setProviderEntId(supplierId);
         detailDto.setLogisticsEntId(waybillOrder.getEntId());
-        detailDto.setInfluenceBy(waybillOrder.getDriverId());
+        detailDto.setPhone(waybillOrder.getDriverPhone());
         detailDto.setAction(remark);
         detailDto.setScoreChange(BigDecimal.valueOf(score));
         logisticsScoreFeignService.updateLogisticsScore(detailDto);

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

@@ -419,7 +419,7 @@ public class LogisticsOrderCompletionTask {
         LogisticsScoreDetailFeignDto detailDto = new LogisticsScoreDetailFeignDto();
         detailDto.setProviderEntId(supplierId);
         detailDto.setLogisticsEntId(waybillOrder.getEntId());
-        detailDto.setInfluenceBy(waybillOrder.getDriverId());
+        detailDto.setPhone(waybillOrder.getDriverPhone());
         detailDto.setAction(remark);
         detailDto.setScoreChange(BigDecimal.valueOf(score));
         logisticsScoreFeignService.updateLogisticsScore(detailDto);