修改bug

puzhibing

2026-05-12 ad0f3c5321e4f1ba6388c8ada1462b978c25674d

修改bug

 xp-robotaxi-account-boot/src/main/java/com/xiaopeng/account/mapper/XpAppUserCollectAddrMapper.java

@@ -18,7 +18,11 @@
 * @since 2026-02-03
 */
public interface XpAppUserCollectAddrMapper extends BaseMapper<XpAppUserCollectAddr> {
    Page<XpAppUserCollectAddrVO> userCollectAddrPageList(@Param("page") Page<XpAppUserCollectAddrVO> page, @Param("query") XpUserCollectAddrListQuery query, @Param("uid") Long uid);


    Page<XpAppUserCollectAddrVO> userCollectAddrPageList(@Param("page") Page<XpAppUserCollectAddrVO> page,
                                                         @Param("query") XpUserCollectAddrListQuery query,
                                                         @Param("uid") Long uid);

    CollectAddrTargetVO selectPointCollectTarget(@Param("pointId") Long pointId);


 xp-robotaxi-account-boot/src/main/java/com/xiaopeng/account/service/impl/XpAppUserCollectAddrServiceImpl.java

@@ -25,12 +25,7 @@
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.*;
import java.util.stream.Collectors;

/**
@@ -120,28 +115,29 @@
        Page<XpAppUserCollectAddrVO> page = new Page<>(query.getPageNum(), query.getPageSize());
        Page<XpAppUserCollectAddrVO> pageData = this.baseMapper.userCollectAddrPageList(page, query, Long.parseLong(uid));
        Set<Long> collectedPointIds = new HashSet<>(getPointIdsByUserId(Long.parseLong(uid)));
        pageData.getRecords().forEach(xpAppUserCollectAddrVO -> {
            if(xpAppUserCollectAddrVO.getItemType() == 1){
                XpPointExportExcelQuery xpPointExportExcelQuery = new XpPointExportExcelQuery();
                xpPointExportExcelQuery.setPointIds(Arrays.asList(xpAppUserCollectAddrVO.getPointId()));
                List<XpPoint> data = xpPointClient.getByIds(xpPointExportExcelQuery).getData();
                if(null != data && data.size() > 0){
                    fillPointInfo(xpAppUserCollectAddrVO, data.get(0), query);
        List<XpAppUserCollectAddrVO> list = new ArrayList<>();
        for (XpAppUserCollectAddrVO record : pageData.getRecords()) {
            if(record.getItemType() == 1){
                XpPoint point = xpPointClient.queryById(record.getPointId()).getData();
                if(null == point){
                    continue;
                }
                fillPointInfo(record, point, query);
            }
            if(xpAppUserCollectAddrVO.getItemType() == 2){
                fillCollectPointInfo(xpAppUserCollectAddrVO, query);
                XpStation data = xpStationClient.getXpStationById(xpAppUserCollectAddrVO.getStationId()).getData();
                if(null != data){
                    xpAppUserCollectAddrVO.setPointName(data.getStationName());
            if(record.getItemType() == 2){
                fillCollectPointInfo(record, query);
                XpStation data = xpStationClient.getXpStationById(record.getStationId()).getData();
                if(null == data){
                    continue;
                }
                xpAppUserCollectAddrVO.setChildren(buildStationChildren(xpAppUserCollectAddrVO.getStationId(), query, collectedPointIds));
                record.setPointName(data.getStationName());
                record.setChildren(buildStationChildren(record.getStationId(), query, collectedPointIds));
            }
        });


        page.setTotal(pageData.getTotal());
        page.setRecords(pageData.getRecords());
            list.add(record);
        }
        page.setTotal(list.size());
        page.setRecords(list);
        return page;
    }


 xp-robotaxi-api/src/main/java/com/xiaopeng/api/factory/order/XpOrderClientFallbackFactory.java

@@ -105,7 +105,7 @@
            }

            @Override
            public R<String> updateOrderStatus(Long orderId, Integer status, Boolean orderException) {
            public R<String> updateOrderStatus(Long orderId, Integer status) {
                log.error("更新订单状态失败，原因: {}", cause.getMessage());
                return R.fail("更新订单状态失败");
            }

 xp-robotaxi-api/src/main/java/com/xiaopeng/api/factory/order/XpTestOrderClientFallbackFactory.java

@@ -47,6 +47,11 @@
                log.info("保存订单轨迹数据失败：{}",  cause.getMessage());
                return R.fail("保存订单轨迹数据失败");
            }

            @Override
            public R<?> carAbnormalUpdateOrderStatus(Long orderId) {
                return R.fail("处理异常情况下的订单失败");
            }
        };
    }
}

 xp-robotaxi-api/src/main/java/com/xiaopeng/api/feignClient/order/XpOrderClient.java

@@ -134,8 +134,7 @@
     */
    @PostMapping("/logan/inner/v1/order/updateOrderStatus")
    R<String> updateOrderStatus(@RequestParam Long orderId,
                                @RequestParam Integer status,
                                @RequestParam Boolean orderException);
                                @RequestParam Integer status);
    /**
     * 行驶中车辆异常，订单状态修改- 修改状态=7 再修改 金额-再将状态修改成8
     * @param orderId

 xp-robotaxi-api/src/main/java/com/xiaopeng/api/feignClient/order/XpTestOrderClient.java

@@ -63,4 +63,13 @@
     */
    @PostMapping("/logan/inner/v1/testOrder/saveVehicleLocation")
    R<String> saveVehicleLocation(@RequestBody OrderTrajectoryVo orderTrajectory);


    /**
     * 行程中订单异常的处理
     * @param orderId
     * @return
     */
    @PostMapping("/logan/inner/v1/testOrder/carAbnormalUpdateOrderStatus")
    R<?> carAbnormalUpdateOrderStatus(@RequestParam Long orderId);
}

 xp-robotaxi-api/src/main/java/com/xiaopeng/api/model/order/XpTestOrder.java

@@ -130,6 +130,9 @@
    @ApiModelProperty(value = "预付金额")
    private BigDecimal prepayMoney;

    @ApiModelProperty(value = "关闭订单的时候不能为空 是否豁免（0=否，1=是）")
    private Boolean isFree;

    @ApiModelProperty(value = "起步里程")
    private Double startMileage;


 xp-robotaxi-api/src/main/java/com/xiaopeng/api/vo/operation/MultiRouteAndFareVo.java

@@ -30,7 +30,11 @@

    @ApiModelProperty("价格变动超过该百分比则提示路况变化（如 5 表示 5%）")
    private Double priceWaveThresholdPercent;

    @ApiModelProperty(value = "是否开启试运营（0=否，1=是）")
    private Integer operateFree;

    @ApiModelProperty(value = "限乘人数")
    private Integer maxPeopleNumber;

}

 xp-robotaxi-automatic-pilot-boot/src/main/java/com/xiaopeng/automaticPilot/controller/OrderMissionController.java

@@ -585,7 +585,7 @@
            log.error("【模拟接单】推送消息失败，appUserId={}, orderId={}, msg={}", appUserId, orderId, stringR.getMsg());
        }
        log.info("【模拟接单】更新订单状态为PICK_UP，orderId={}", orderId);
        xpOrderClient.updateOrderStatus(orderId, OrderStatusEnum.PICK_UP.getCode(), false);
        xpOrderClient.updateOrderStatus(orderId, OrderStatusEnum.PICK_UP.getCode());
        log.info("【模拟接单】流程完成，orderId={}", orderId);

//        PushOrderRouteDTO dto3 = new PushOrderRouteDTO();
@@ -724,7 +724,7 @@
                log.error("【推送接驾轨迹】推送消息失败，appUserId={}, orderId={}, msg={}", appUserId, finalOrderId, stringR.getMsg());
            }
            log.info("【推送接驾轨迹】更新订单状态为PICK_UP_GUESTS，orderId={}", finalOrderId);
            xpOrderClient.updateOrderStatus(finalOrderId, OrderStatusEnum.PICK_UP_GUESTS.getCode(), false);
            xpOrderClient.updateOrderStatus(finalOrderId, OrderStatusEnum.PICK_UP_GUESTS.getCode());
            log.info("【推送接驾轨迹】流程完成，orderId={}", finalOrderId);
        });

@@ -767,7 +767,7 @@
            log.error("【模拟修改订单状态】推送消息失败，appUserId={}, orderId={}, msg={}", xpOrder.getAppUserId(), orderId, stringR.getMsg());
        }
        log.info("【模拟修改订单状态】更新订单状态，orderId={}, status={}", orderId, status);
        xpOrderClient.updateOrderStatus(orderId, status, false);
        xpOrderClient.updateOrderStatus(orderId, status);
        if(5 == status){
            log.info("【模拟修改订单状态】status=5，主动推送全程轨迹，orderId={}", orderId);
            //主动推一次全程轨迹
@@ -940,7 +940,7 @@
                log.error("【推送送驾轨迹】推送消息失败，appUserId={}, orderId={}, msg={}", appUserId, finalOrderId, stringR.getMsg());
            }
            log.info("【推送送驾轨迹】更新订单状态为SEE_OFF_GUESTS，orderId={}", finalOrderId);
            xpOrderClient.updateOrderStatus(finalOrderId, OrderStatusEnum.SEE_OFF_GUESTS.getCode(), false);
            xpOrderClient.updateOrderStatus(finalOrderId, OrderStatusEnum.SEE_OFF_GUESTS.getCode());
            log.info("【推送送驾轨迹】流程完成，orderId={}", finalOrderId);
        });
    }

 xp-robotaxi-automatic-pilot-boot/src/main/java/com/xiaopeng/automaticPilot/job/jobs/OrderExceptionJob.java

@@ -25,14 +25,12 @@
        Long orderId = maps.getLong("id");
        String orderType = maps.getString("orderType");
        if(OrderType.USER_ORDER.equals(orderType)){
            //修改订单状态
            xpOrderClient.updateOrderStatus(orderId, OrderStatusEnum.SEE_OFF_GUESTS.getCode(), true);
            //处理异常情况下的订单
            xpOrderClient.carAbnormalUpdateOrderStatus(orderId);
        }
        if(OrderType.TEST_ORDER.equals(orderType)){
            xpTestOrderClient.updateOrderStatus(orderId, OrderStatusEnum.SEE_OFF_GUESTS.getCode());
            xpTestOrderClient.carAbnormalUpdateOrderStatus(orderId);
        }
        //发起客服工单

    }

}

 xp-robotaxi-automatic-pilot-boot/src/main/java/com/xiaopeng/automaticPilot/service/KafkaConsumerService.java

@@ -572,10 +572,6 @@
                    reassignOrderDTO.setUid(xpOrder.getAppUserId().toString());
                    reassignOrderDTO.setOrderNo(xpOrder.getOrderNumber());
                    reassignOrderDTO.setCount(10);
//                    RealtimePose pose = systemRuntimeStatus.getPose();
//                    Wgs naviPose = pose.getNaviPose();
//                    Double latitude = naviPose.getLatitude();
//                    Double longitude = naviPose.getLongitude();
                    reassignOrderDTO.setLongitude(xpOrder.getStartLon());
                    reassignOrderDTO.setLatitude(xpOrder.getStartLat());
                    reassignOrderClient.reassignOrder(reassignOrderDTO);
@@ -1192,7 +1188,7 @@
                            testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.READY_DEPART.getCode());
                        }else{
                            buildPushOrderStatus(cmd, orderId, OrderStatusEnum.READY_DEPART, sequence);
                            xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.READY_DEPART.getCode(), false);
                            xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.READY_DEPART.getCode());
                        }
                    }
                    break;
@@ -1207,7 +1203,7 @@
                            testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.PICK_UP.getCode());
                        }else{
                            buildPushOrderStatus(cmd, orderId, OrderStatusEnum.PICK_UP, sequence);
                            xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.PICK_UP.getCode(), false);
                            xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.PICK_UP.getCode());
                        }
                    }
                    break;
@@ -1222,7 +1218,7 @@
                            testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.PICK_UP_GUESTS.getCode());
                        }else{
                            buildPushOrderStatus(cmd, orderId, OrderStatusEnum.PICK_UP_GUESTS, sequence);
                            xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.PICK_UP_GUESTS.getCode(), false);
                            xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.PICK_UP_GUESTS.getCode());
                        }
                    }
                    break;
@@ -1233,7 +1229,7 @@
                            testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.PASSENGER_BOARDED.getCode());
                        }else{
                            buildPushOrderStatus(cmd, orderId, OrderStatusEnum.PASSENGER_BOARDED, sequence);
                            xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.PASSENGER_BOARDED.getCode(), false);
                            xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.PASSENGER_BOARDED.getCode());
                        }
                    }
                    break;
@@ -1244,7 +1240,7 @@
                            testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.IN_SERVICE.getCode());
                        }else{
                            buildPushOrderStatus(cmd, orderId, OrderStatusEnum.IN_SERVICE, sequence);
                            xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.IN_SERVICE.getCode(), false);
                            xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.IN_SERVICE.getCode());
                        }
                    }
                    break;
@@ -1259,7 +1255,7 @@
                            testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.SEE_OFF_GUESTS.getCode());
                        }else{
                            buildPushOrderStatus(cmd, orderId, OrderStatusEnum.SEE_OFF_GUESTS, sequence);
                            xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.SEE_OFF_GUESTS.getCode(), false);
                            xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.SEE_OFF_GUESTS.getCode());
                        }
                    }
                    break;
@@ -1322,74 +1318,75 @@
                            }
                            return;
                        }
                        if(orderId.contains("TEST")){
                            //判断订单状态，已经取消的不作处理
                            Object cacheObject = redisService.getCacheObject("TEST_ORDER_STATUS:" + orderId.substring(4));
                            if(null != cacheObject){
                                int order_status = Integer.parseInt(cacheObject.toString());
                                if(0 == order_status){
                                    return;
                                }
                            }
                            XpTestOrder testOrder = testOrderClient.queryOrderById(Long.valueOf(orderId.substring(4))).getData();
                            if(testOrder.getStatus() == 0 || testOrder.getStatus() >= 8){
                                return;
                            }
                            //行程中取消订单，按照行程结束处理
                            if(testOrder.getStatus() > 5 && testOrder.getStatus() < 8){
                                testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.SEE_OFF_GUESTS.getCode());
                                redisService.setCacheObject("TEST_ORDER_STATUS:" + orderId.substring(4), OrderStatusEnum.SEE_OFF_GUESTS.getCode(), 24L, TimeUnit.HOURS);
                            }else{
                                testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.CANCELED.getCode());
                                redisService.setCacheObject("TEST_ORDER_STATUS:" + orderId.substring(4), OrderStatusEnum.CANCELED.getCode(), 24L, TimeUnit.HOURS);
                            }
                        }else{
                            //判断订单状态，已经取消的不作处理
                            Object cacheObject = redisService.getCacheObject("ORDER_STATUS:" + orderId);
                            if(null != cacheObject){
                                int order_status = Integer.parseInt(cacheObject.toString());
                                if(0 == order_status){
                                    return;
                                }
                            }
                            XpOrder xpOrder = xpOrderClient.queryOrderById(Long.parseLong(orderId)).getData();
                            if(xpOrder.getStatus() == 0 || xpOrder.getStatus() >= 8){
                                return;
                            }

                            List<Integer>  xczqx = new ArrayList<Integer>(){{
                                add(OrderStatusEnum.IN_SERVICE.getCode());//服务中
                                add(OrderStatusEnum.SEE_OFF_GUESTS.getCode());//SEE_OFF_GUESTS
                            }};
                            if(xczqx.contains(xpOrder.getStatus())){//行程中取消订单，按照行程结束处理
                                buildPushOrderStatus(cmd, orderId, OrderStatusEnum.SEE_OFF_GUESTS, sequence);
                                xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.SEE_OFF_GUESTS.getCode(), true);
                                redisService.setCacheObject("ORDER_STATUS:" + orderId, OrderStatusEnum.SEE_OFF_GUESTS.getCode(), 24L, TimeUnit.HOURS);
                                // 判断当前订单的车辆是否有连环派单，然后判断是都还满足连环派单的条件，不满足则需要重新派单
                                String json = redisService.getCacheObject(CacheConstants.nextOrder(orderId));
                                if (StringUtils.isNotEmpty(json)){
                                    JSONObject jsonObject = JSON.parseObject(json);
                                    Long nextOrderId = jsonObject.getLong("orderId");
                                    XpOrder nextOrder = xpOrderClient.queryOrderById(nextOrderId).getData();
                                    if(null != nextOrder && nextOrder.getStatus() == OrderStatusEnum.PICK_UP.getCode()){
                                        redisService.setCacheObject(CacheConstants.nextOrder(orderId),null);
                                        ReassignOrderDTO reassignOrderDTO = new ReassignOrderDTO();
                                        reassignOrderDTO.setUid(xpOrder.getAppUserId().toString());
                                        reassignOrderDTO.setOrderNo(xpOrder.getOrderNumber());
                                        reassignOrderDTO.setCount(10);
                                        reassignOrderDTO.setLongitude(xpOrder.getStartLon());
                                        reassignOrderDTO.setLatitude(xpOrder.getStartLon());
                                        reassignOrderClient.reassignOrder(reassignOrderDTO);
                                    }
                                }
                                redisService.getCacheObject("ORDER_CONNECT_ORDER:" + orderId);

                            }else{
                                buildPushOrderStatus(cmd, orderId, OrderStatusEnum.CANCELED, sequence);
                                xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.CANCELED.getCode(), true);
                                redisService.setCacheObject("ORDER_STATUS:" + orderId, OrderStatusEnum.CANCELED.getCode(), 24L, TimeUnit.HOURS);
                            }
                        }
                        // 这部分不做处理，已经移到靠边停车报文处理中了
//                        if(orderId.contains("TEST")){
//                            //判断订单状态，已经取消的不作处理
//                            Object cacheObject = redisService.getCacheObject("TEST_ORDER_STATUS:" + orderId.substring(4));
//                            if(null != cacheObject){
//                                int order_status = Integer.parseInt(cacheObject.toString());
//                                if(0 == order_status){
//                                    return;
//                                }
//                            }
//                            XpTestOrder testOrder = testOrderClient.queryOrderById(Long.valueOf(orderId.substring(4))).getData();
//                            if(testOrder.getStatus() == 0 || testOrder.getStatus() >= 8){
//                                return;
//                            }
//                            //行程中取消订单，按照行程结束处理
//                            if(testOrder.getStatus() > 5 && testOrder.getStatus() < 8){
//                                testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.SEE_OFF_GUESTS.getCode());
//                                redisService.setCacheObject("TEST_ORDER_STATUS:" + orderId.substring(4), OrderStatusEnum.SEE_OFF_GUESTS.getCode(), 24L, TimeUnit.HOURS);
//                            }else{
//                                testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.CANCELED.getCode());
//                                redisService.setCacheObject("TEST_ORDER_STATUS:" + orderId.substring(4), OrderStatusEnum.CANCELED.getCode(), 24L, TimeUnit.HOURS);
//                            }
//                        }else{
//                            //判断订单状态，已经取消的不作处理
//                            Object cacheObject = redisService.getCacheObject("ORDER_STATUS:" + orderId);
//                            if(null != cacheObject){
//                                int order_status = Integer.parseInt(cacheObject.toString());
//                                if(0 == order_status){
//                                    return;
//                                }
//                            }
//                            XpOrder xpOrder = xpOrderClient.queryOrderById(Long.parseLong(orderId)).getData();
//                            if(xpOrder.getStatus() == 0 || xpOrder.getStatus() >= 8){
//                                return;
//                            }
//
//                            List<Integer> xczqx = new ArrayList<Integer>(){{
//                                add(OrderStatusEnum.IN_SERVICE.getCode());//服务中
//                                add(OrderStatusEnum.SEE_OFF_GUESTS.getCode());//SEE_OFF_GUESTS
//                            }};
//                            if(xczqx.contains(xpOrder.getStatus())){//行程中取消订单，按照行程结束处理
//                                buildPushOrderStatus(cmd, orderId, OrderStatusEnum.SEE_OFF_GUESTS, sequence);
//                                xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.SEE_OFF_GUESTS.getCode());
//                                redisService.setCacheObject("ORDER_STATUS:" + orderId, OrderStatusEnum.SEE_OFF_GUESTS.getCode(), 24L, TimeUnit.HOURS);
//                                // 判断当前订单的车辆是否有连环派单，然后判断是都还满足连环派单的条件，不满足则需要重新派单
//                                String json = redisService.getCacheObject(CacheConstants.nextOrder(orderId));
//                                if (StringUtils.isNotEmpty(json)){
//                                    JSONObject jsonObject = JSON.parseObject(json);
//                                    Long nextOrderId = jsonObject.getLong("orderId");
//                                    XpOrder nextOrder = xpOrderClient.queryOrderById(nextOrderId).getData();
//                                    if(null != nextOrder && nextOrder.getStatus() == OrderStatusEnum.PICK_UP.getCode()){
//                                        redisService.setCacheObject(CacheConstants.nextOrder(orderId),null);
//                                        ReassignOrderDTO reassignOrderDTO = new ReassignOrderDTO();
//                                        reassignOrderDTO.setUid(xpOrder.getAppUserId().toString());
//                                        reassignOrderDTO.setOrderNo(xpOrder.getOrderNumber());
//                                        reassignOrderDTO.setCount(10);
//                                        reassignOrderDTO.setLongitude(xpOrder.getStartLon());
//                                        reassignOrderDTO.setLatitude(xpOrder.getStartLon());
//                                        reassignOrderClient.reassignOrder(reassignOrderDTO);
//                                    }
//                                }
//                                redisService.getCacheObject("ORDER_CONNECT_ORDER:" + orderId);
//
//                            }else{
//                                buildPushOrderStatus(cmd, orderId, OrderStatusEnum.CANCELED, sequence);
//                                xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.CANCELED.getCode());
//                                redisService.setCacheObject("ORDER_STATUS:" + orderId, OrderStatusEnum.CANCELED.getCode(), 24L, TimeUnit.HOURS);
//                            }
//                        }
                    }
                    break;
                case ORDER_ARRIVED_AT_CRUISE_DESTINATION:
@@ -1688,31 +1685,33 @@

    //靠边停车处理逻辑
    public void pulloverStatusEvent(MsgContent msgContent){
        // todo 等对接完成数据结构后再实现相关功能
        //开始处理消息对应的业务逻辑
        NavigationRequest naviRequest = msgContent.getNavigationRequest();
        String requestId = naviRequest.getRequestId();
        String orderId = naviRequest.getOrderId();
        String taskId = naviRequest.getTaskId();
        OrderPhase orderPhase = naviRequest.getOrderPhase();
        PullOverInfo pulloverInfo = msgContent.getPulloverInfo();
        String orderId = pulloverInfo.getOrderId();
        String taskId = pulloverInfo.getTaskId();
        PullOverStatus pullOverStatus = pulloverInfo.getPullOverStatus();
        log.info("订单ID：{}", orderId);
        log.info("任务ID：{}", taskId);

        //获取系统异常订单超时配置，创建定时任务取消订单
        if(!orderId.contains("XU")){
            XpSystemSetting xpSystemSetting = systemSettingClient.getSystemSettingOne().getData();
            Map<String, ? extends Object> jobMaps =
                    new ImmutableMap.Builder<String, String>()
                            .put("id", orderId)
                            .put("orderType", orderId.contains("TEST") ? OrderType.TEST_ORDER : OrderType.USER_ORDER)
                            .build();
            QuartzManager.addJob(
                    OrderExceptionJob.class,
                    (OrderExceptionJob.name + orderId).toUpperCase(),
                    TimeJobType.ERROR_ORDER_CANCEL,
                    DateUtils.localDateTimeToDate(LocalDateTime.now().plusMinutes(xpSystemSetting.getOrderExceptionalTimeout())),
                    jobMaps
            );
            //靠边停车完成后，创建定时任务处理后续业务逻辑
            if(pullOverStatus.getNumber() == PullOverStatus.PULL_OVER_COMPLETED.getNumber()){
                XpSystemSetting xpSystemSetting = systemSettingClient.getSystemSettingOne().getData();
                Map<String, ? extends Object> jobMaps =
                        new ImmutableMap.Builder<String, String>()
                                .put("id", orderId)
                                .put("orderType", orderId.contains("TEST") ? OrderType.TEST_ORDER : OrderType.USER_ORDER)
                                .build();
                QuartzManager.addJob(
                        OrderExceptionJob.class,
                        (OrderExceptionJob.name + orderId).toUpperCase(),
                        TimeJobType.ERROR_ORDER_CANCEL,
                        DateUtils.localDateTimeToDate(LocalDateTime.now().plusMinutes(xpSystemSetting.getOrderExceptionalTimeout())),
                        jobMaps
                );
            }

        }

    }

 xp-robotaxi-itinerary-boot/src/main/java/com/xiaopeng/itinerary/service/impl/XpPricingServiceImpl.java

@@ -1242,7 +1242,7 @@
        vo.setStaleCheckSeconds(navigationStaleSeconds);
        vo.setPriceWaveThresholdPercent(navigationPriceWavePercent);
        vo.setOperateFree(operateFree);

//        vo.setMaxPeopleNumber(systemSettingMapper.selectOne(null).getMaxPeopleNumber());

        RouteOptionVo first = options.get(0);
        redisService.setCacheObject("ORDER_NAVIGATION_END_DATA:" + userId, JSON.toJSONString(first.getRoute()), 24L, TimeUnit.HOURS);

 xp-robotaxi-operation-boot/src/main/java/com/xiaopeng/operation/service/impl/XpPointServiceImpl.java

@@ -769,6 +769,7 @@
            orderDistanceVo.setXczCaCount(xpSystemSetting.getXczCaCount());
            orderDistanceVo.setXczHmSpeedPerHour(xpSystemSetting.getXczHmSpeedPerHour());
            orderDistanceVo.setXczHmDuration(xpSystemSetting.getXczHmDuration());
            orderDistanceVo.setOperateFree(xpSystemSetting.getOperateFree());
            return orderDistanceVo;
        }
        return orderDistanceVo;

 xp-robotaxi-operation-boot/src/main/java/com/xiaopeng/operation/utils/TaskOrderUtil.java

@@ -37,6 +37,7 @@
import com.xiaopeng.common.core.constant.Constants;
import com.xiaopeng.common.core.domain.R;
import com.xiaopeng.common.core.enums.OrderStatusEnum;
import com.xiaopeng.common.core.enums.PushMessageTypeEnum;
import com.xiaopeng.common.redis.service.RedisService;
import com.xiaopeng.operation.config.UidVinBindingConfig;
import com.xiaopeng.operation.dto.PriorityMatchResult;
@@ -1084,12 +1085,13 @@
                        //非合作商的车辆需要处理巡游单
                        if(null != vehiclePosition.getOfficialPartnerId()){
                            //  关闭巡游单子
                            R stringR = xpCruiseOrderClient.cancelCruiseOrderByVin(vehiclePosition.getVehicleVin());
                            R<XpCruiseOrder> stringR = xpCruiseOrderClient.cancelCruiseOrderByVin(vehiclePosition.getVehicleVin());
                            if (stringR == null || stringR.getCode() != 200) {
                                log.info("关闭巡游单子失败 车牌号 {}", vehiclePosition.getPlateNumber());
                                continue;
                            }
                            log.info("关闭巡游单成功 {} {}", vehiclePosition.getPlateNumber(), orderNo);
                            XpCruiseOrder cruiseOrder = stringR.getData();
                            // 下发命令
                            PushOrderDto pushOrderDto = new PushOrderDto();
                            pushOrderDto.setVin(vehiclePosition.getVehicleVin());
@@ -1103,6 +1105,9 @@
                            pushOrderDto.setEndPoiName(xpOrder.getEndPointName());
                            pushOrderDto.setOrderType(OrderType.USER_ORDER);
                            pushOrderDto.setStage(1);
                            pushOrderDto.setLastOrderId("XU" + cruiseOrder.getId());
                            pushOrderDto.setLastXpuTaskId(cruiseOrder.getXpuTaskId());
                            pushOrderDto.setTaskActionType(TaskActionType.kTerminateForNewTask);
                            // 调用推送服务  orderId + carVin
                            orderMissionClient.pushOrder(pushOrderDto);
                            log.info("开始推送 {} 订单到XPU。单号 {}", xpOrder.getOrderNumber(), orderNo);
@@ -1152,12 +1157,13 @@

                        if(null == vehicleId1.getOfficialPartnerId()){
                            //  关闭巡游单子
                            R<?> stringR = xpCruiseOrderClient.cancelCruiseOrderByVin(vehicleId1.getVehicleVin());
                            R<XpCruiseOrder> stringR = xpCruiseOrderClient.cancelCruiseOrderByVin(vehicleId1.getVehicleVin());
                            if (stringR == null || stringR.getCode() != 200) {
                                log.info("关闭巡游单子失败 车牌号 {}", vehicleId1.getPlateNumber());
                                continue;
                            }
                            log.info("关闭巡游单成功 {} {}", vehicleId1.getPlateNumber(), orderNo);
                            XpCruiseOrder cruiseOrder = stringR.getData();
                            PushOrderDto pushOrderDto = new PushOrderDto();
                            pushOrderDto.setVin(vehiclePosition.getVin());
                            pushOrderDto.setOrderId(xpOrder.getId().toString());
@@ -1170,6 +1176,9 @@
                            pushOrderDto.setEndPoiName(xpOrder.getEndPointName());
                            pushOrderDto.setOrderType(OrderType.USER_ORDER);
                            pushOrderDto.setStage(1);
                            pushOrderDto.setLastOrderId("XU" + cruiseOrder.getId());
                            pushOrderDto.setLastXpuTaskId(cruiseOrder.getXpuTaskId());
                            pushOrderDto.setTaskActionType(TaskActionType.kTerminateForNewTask);
                            // 调用推送服务  orderId + carVin
                            orderMissionClient.pushOrder(pushOrderDto);
                        }else {
@@ -1263,6 +1272,40 @@
                    redisService.setCacheObject(CacheConstants.navigationStart(xpOrder.getAppUserId().toString()), JSON.toJSONString(route));
                    redisService.removeByPattern(quoteName,xpOrder.getOrderNumber());
                    log.info("将订单 {} 从队列 {} 弹出去", orderNo, quoteName);

                    //构建推送消息
                    Map<String, Object> params = new HashMap<>();
                    Map<String, Object> content = new HashMap<>();
                    content.put("orderId", xpOrder.getId().toString());
                    content.put("status", 2);
                    params.put("type", PushMessageTypeEnum.ORDER_STATUS.getDesc());
                    params.put("content", JSONObject.toJSONString(content));
                    params.put("timestamp", System.currentTimeMillis() + "");
                    String message = JSONObject.toJSONString(params);
                    SendMessageDTO dto1 = new SendMessageDTO();
                    dto1.setAppUserId(xpOrder.getAppUserId() + "");
                    dto1.setMessage(message);
                    R<String> stringR = xpPushMessageClient.sendStatus(dto1);

                    //推送失败，重试3次
                    if (stringR.getCode() != Constants.SUCCESS) {
                        ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>());
                        XpOrder finalXpOrder = xpOrder;
                        executor.execute(() -> {
                            for (int j = 0; j < 3; j++) {
                                R<String> stringR1 = xpPushMessageClient.sendStatus(dto1);
                                if (stringR1.getCode() == Constants.SUCCESS) {
                                    break;
                                }
                                try {
                                    Thread.sleep(1000);
                                } catch (InterruptedException e) {
                                    throw new RuntimeException(e);
                                }
                                log.info("推送订单状态消息失败：{} {} {}", stringR1.getMsg(), JSON.toJSONString(dto1), finalXpOrder.getOrderNumber());
                            }
                        });
                    }
                    return true;
                }
            }
@@ -2432,7 +2475,7 @@
                entity.setIsComplete(true);
//                //接单成功 将 修改 订单的状态=1 （ 状态 0=已取消，1=待接单，2=待出发，3=接驾中，4=待客上车，5=乘客已上车，6=服务中，7=待客下车，8=待付款，9=待评价，10=已完成）
//                orderCarStatus = true;
                xpOrderClient.updateOrderStatus(data.getId(), OrderStatusEnum.PENDING_ORDER.getCode(), false);
                xpOrderClient.updateOrderStatus(data.getId(), OrderStatusEnum.PENDING_ORDER.getCode());
                redisService.setCacheObject("ORDER_STATUS:" + data.getId(), OrderStatusEnum.PENDING_ORDER.getCode(), 24L, TimeUnit.HOURS);

                break;

 xp-robotaxi-operation-boot/src/main/java/com/xiaopeng/operation/vo/OrderDistanceVo.java

@@ -33,6 +33,9 @@
    @ApiModelProperty("下单页停留时长")
    private Integer maxStandingTiming;

    @ApiModelProperty("是否载客测试免费（0=否，1=是）")
    private Integer operateFree;





 xp-robotaxi-order-boot/src/main/java/com/xiaopeng/order/controller/XpOrderController.java

@@ -16,10 +16,12 @@
import com.xiaopeng.api.dto.statistics.StatisticsQueryDTO;
import com.xiaopeng.api.dto.vehicleConvoy.BaseVehicleUserDto;
import com.xiaopeng.api.feignClient.account.SysGroupMenuClient;
import com.xiaopeng.api.feignClient.operation.XpSystemSettingClient;
import com.xiaopeng.api.feignClient.operation.XpWhiteListClient;
import com.xiaopeng.api.feignClient.vehicleConvoy.VehicleMacClient;
import com.xiaopeng.api.feignClient.vehicleConvoy.XpVehicleClient;
import com.xiaopeng.api.model.operation.XpOfficialPartner;
import com.xiaopeng.api.model.operation.XpSystemSetting;
import com.xiaopeng.api.model.operation.XpWhitelist;
import com.xiaopeng.api.model.order.XpOrder;
import com.xiaopeng.api.model.vehicleConvoy.XpVehicle;
@@ -30,6 +32,7 @@
import com.xiaopeng.api.vo.order.*;
import com.xiaopeng.api.vo.vehicleConvoy.GetBleInfoVo;
import com.xiaopeng.common.core.domain.R;
import com.xiaopeng.common.core.enums.OrderStatusEnum;
import com.xiaopeng.common.core.exception.ServiceException;
import com.xiaopeng.common.core.utils.StringUtils;
import com.xiaopeng.common.core.utils.WebUtils;
@@ -54,6 +57,7 @@
import com.xiaopeng.order.model.vo.XpOrderHistoryVO;
import com.xiaopeng.order.model.vo.XpOrderPageVO;
import com.xiaopeng.order.service.IXpOrderService;
import com.xiaopeng.order.service.impl.BootCommonService;
import com.xiaopeng.order.vo.BluetoothTokenVo;
import com.xiaopeng.order.vo.OrderDetailVo;
import com.xiaopeng.order.vo.UpdateOrderStatusVo;
@@ -119,6 +123,13 @@

    @Autowired
    private BluetoothDebugConfig bluetoothDebugConfig;

    @Resource
    private XpSystemSettingClient xpSystemSettingClient;

    @Resource
    @Lazy
    private BootCommonService bootCommonService;



@@ -550,6 +561,19 @@
        String uid = request.getHeader("XP-Uid");
        try {
            Boolean b = xpOrderService.endTrip(orderId, uid);
            //判断是否测试免费
            XpSystemSetting xpSystemSetting = xpSystemSettingClient.getSystemSettingOne().getData();
            if (xpSystemSetting != null && xpSystemSetting.getOperateFree() == 1) {
                //将支付金额修改成0 并将状态修改成 订单状态9
                XpOrder xpOrder1 = new XpOrder();
                xpOrder1.setId(orderId);
                xpOrder1.setIsFree(true);//豁免
                xpOrder1.setPayMoney(BigDecimal.ZERO);
                xpOrder1.setStatus(OrderStatusEnum.PENDING_PAYMENT.getCode());
                xpOrder1.setUpdateTime(LocalDateTime.now());
                xpOrderService.updateById(xpOrder1);
                bootCommonService.setCache_orderStatus(xpOrder1.getId(), xpOrder1, null);
            }
            return R.ok(b);

        } catch (Exception e) {
@@ -615,9 +639,8 @@
    @ApiOperation(value = "订单状态推送修改")
    @PostMapping("/logan/inner/v1/order/updateOrderStatus")
    public R<String> updateOrderStatus(@RequestParam Long orderId,
                                       @RequestParam Integer status,
                                       @RequestParam Boolean orderException) {
        return xpOrderService.updateOrderStatus(orderId, status, orderException);
                                       @RequestParam Integer status) {
        return xpOrderService.updateOrderStatus(orderId, status);
    }

    /**

 xp-robotaxi-order-boot/src/main/java/com/xiaopeng/order/controller/XpTestOrderController.java

@@ -205,4 +205,13 @@
    }


    /**
     * 行驶中车辆异常，订单状态修改- 修改状态=7 再修改 金额-再将状态修改成8
     */
    @ApiOperation(value = "行驶中车辆异常，订单状态修改- 修改状态=7 再修改 金额-再将状态修改成8")
    @PostMapping("/logan/inner/v1/testOrder/carAbnormalUpdateOrderStatus")
    public R<?> carAbnormalUpdateOrderStatus(@RequestParam Long orderId) {
        xpTestOrderService.carAbnormalUpdateOrderStatus(orderId);
        return R.ok();
    }
}

 xp-robotaxi-order-boot/src/main/java/com/xiaopeng/order/service/IXpOrderService.java

@@ -160,7 +160,7 @@
     * @param status 状态 0=已取消，1=待接单，2=待出发，3=接驾中，4=待客上车，5=乘客已上车，6=服务中，7=待客下车，8=待付款，9=待评价，10=已完成
     * @return 修改结果
     */
    R<String> updateOrderStatus(Long orderId, Integer status, Boolean orderException);
    R<String> updateOrderStatus(Long orderId, Integer status);

    /**
     * 行驶中车辆异常，订单状态修改- 修改状态=7 再修改 金额-再将状态修改成8

 xp-robotaxi-order-boot/src/main/java/com/xiaopeng/order/service/IXpTestOrderService.java

@@ -61,6 +61,12 @@
    void cancelOrCloseOrder(Long orderId, Integer type);

    /**
     * 行程中订单异常后的处理
     * @param order
     */
    void carAbnormalUpdateOrderStatus(Long orderId);

    /**
     * 改派订单
     *
     * @param orderId 订单ID

 xp-robotaxi-order-boot/src/main/java/com/xiaopeng/order/service/impl/XpOrderReassignServiceImpl.java

@@ -66,7 +66,7 @@
            b = updateById(entity);
            //是否取消订单
            if(canceled){
                xpOrderService.updateOrderStatus(entity.getOrderId(),OrderStatusEnum.CANCELED.getCode(), false);
                xpOrderService.updateOrderStatus(entity.getOrderId(),OrderStatusEnum.CANCELED.getCode());
            }
        }
        return b;

 xp-robotaxi-order-boot/src/main/java/com/xiaopeng/order/service/impl/XpOrderServiceImpl.java

@@ -946,13 +946,6 @@
            });
        }

        //给XPU推送订单取消的报文
//        PushOrderDto pushOrderDto = new PushOrderDto();
//        pushOrderDto.setOrderId(order.getId().toString());
//        pushOrderDto.setVin(xpVehicle.getVehicleVin());
//        pushOrderDto.setOperation_type(OrderOperationType.CLOUD_CANCEL_ORDER);
//        orderMissionClient.cancelOrder(pushOrderDto);

        //结束行程，修改状态和计算费用
        endTrip(order.getId(), appUserId.toString());

@@ -1401,7 +1394,9 @@
        Long userId = Long.valueOf(uid);
        // - 新用户处理： 历史订单数 < 3单或无匹配数据时，隐藏该胶囊。
        Long validHistoryCount = this.baseMapper.countUserValidHistoryOrders(userId);
        if (validHistoryCount == null || validHistoryCount < 3) return null;
        if (validHistoryCount == null || validHistoryCount < 3) {
            return null;
        }

        LocalDateTime now = LocalDateTime.now();
        LocalTime startMoment = now.minusHours(1).toLocalTime();
@@ -1415,7 +1410,10 @@
        endPointId.addAll(this.baseMapper.frequencyOrders(startDate, endDate, startMoment, endMoment, userId));

        Integer minOrderDistance = getMinOrderDistanceSafely(uid, startPointId);
        if (minOrderDistance == null) return null;//获取用户最短可发单距离失败
        //获取用户最短可发单距离失败
        if (minOrderDistance == null) {
            return null;
        }
        XpPoint start = getPointById(startPointId);
        GlobalCoordinates startCoordinates = new GlobalCoordinates(start.getPointLon(), start.getPointLat());
        List<Long> pointIdsByUserId = Optional.ofNullable(xpAppUserCollectAddrClient.getPointIdsByUserId(Long.valueOf(uid)).getData())
@@ -2039,7 +2037,7 @@
    }

    @Override
    public R<String> updateOrderStatus(Long orderId, Integer status, Boolean orderException) {
    public R<String> updateOrderStatus(Long orderId, Integer status) {
        XpOrder xpOrder = this.getById(orderId);
        if (Objects.isNull(xpOrder)) {
            return R.fail("订单不存在");
@@ -2215,20 +2213,34 @@
                if (StringUtils.isNotEmpty(json)) {
                    JSONObject jsonObject = JSON.parseObject(json);
                    Long id = jsonObject.getLong("orderId");
                    jobMaps = new ImmutableMap.Builder<String, String>()
                            .put("id", id.toString())
                            .put("oldOrderId", xpOrder.getId().toString())
                            .put("appid", appid)
                            .put("orderType", OrderType.USER_ORDER)
                            .build();
                    //判断订单状态
                    XpOrder xpOrder1 = this.getById(id);
                    if(2 == xpOrder1.getStatus()){
                        jobMaps = new ImmutableMap.Builder<String, String>()
                                .put("id", id.toString())
                                .put("oldOrderId", xpOrder.getId().toString())
                                .put("appid", appid)
                                .put("orderType", OrderType.USER_ORDER)
                                .build();

                    QuartzManager.addJob(
                            PushChainReactionOrderJob.class,
                            (PushChainReactionOrderJob.name + id).toUpperCase(),
                            TimeJobType.ADD_CHAIN_REACTION_ORDER_MISSION,
                            DateUtils.localDateTimeToDate(LocalDateTime.now().plusMinutes(point.getParkingTimeLimit())),
                            jobMaps
                    );
                        QuartzManager.addJob(
                                PushChainReactionOrderJob.class,
                                (PushChainReactionOrderJob.name + id).toUpperCase(),
                                TimeJobType.ADD_CHAIN_REACTION_ORDER_MISSION,
                                DateUtils.localDateTimeToDate(LocalDateTime.now().plusMinutes(point.getParkingTimeLimit())),
                                jobMaps
                        );
                    }
                    //连环派订单取消的情况，继续走巡游
                    if(0 == xpOrder1.getStatus()){
                        QuartzManager.addJob(
                                AddCruiseMissionJob.class,
                                (AddCruiseMissionJob.name + xpOrder.getId()).toUpperCase(),
                                TimeJobType.ADD_CRUISE_MISSION,
                                DateUtils.localDateTimeToDate(LocalDateTime.now().plusMinutes(point.getParkingTimeLimit())),
                                jobMaps
                        );
                    }
                } else {
                    QuartzManager.addJob(
                            AddCruiseMissionJob.class,
@@ -2770,8 +2782,6 @@
            baseMapper.updateById(order);

        }


        if (order.getCouponId() != null) {
//            UseUserCouponDto useUserCouponDto = new UseUserCouponDto();
//            useUserCouponDto.setUserId(Long.valueOf(uid));
@@ -3670,7 +3680,7 @@
                            } catch (InterruptedException e) {
                                throw new RuntimeException(e);
                            }
                            log.info("推送订单状态消息失败：{} {} {}", stringR1.getMsg(), JSON.toJSONString(dto), order.getOrderNumber());
                            log.info("推送订单状态消息失败：{} {} {}", stringR1.getMsg(), JSON.toJSONString(dto1), order.getOrderNumber());
                        }
                    });
                }

 xp-robotaxi-order-boot/src/main/java/com/xiaopeng/order/service/impl/XpTestOrderServiceImpl.java

@@ -39,6 +39,7 @@
import com.xiaopeng.common.core.constant.CacheConstants;
import com.xiaopeng.common.core.constant.HttpStatus;
import com.xiaopeng.common.core.domain.R;
import com.xiaopeng.common.core.enums.OrderStatusEnum;
import com.xiaopeng.common.core.exception.ServiceException;
import com.xiaopeng.common.core.utils.DateUtils;
import com.xiaopeng.common.core.utils.GeodesyUtil;
@@ -690,6 +691,66 @@
        endTrip(order.getId());
    }



    public void carAbnormalUpdateOrderStatus(Long orderId) {
        XpTestOrder order = this.getById(orderId);
        XpVehicle xpVehicle = xpVehicleClient.queryById(order.getVehicleId()).getData();
        order.setStatus(7);
        order.setGetoffTime(LocalDateTime.now());
        // 解析下车地点
        VehiclePosition vehiclePosition = mongoTemplate.findOne(new Query(Criteria.where("vin").is(xpVehicle.getVehicleVin())), VehiclePosition.class);
        if(Objects.nonNull(vehiclePosition)){
            GeoJsonPoint point = vehiclePosition.getPoint();
            if(Objects.nonNull(point)){
                double x = point.getX();
                double y = point.getY();
                Map<String, String> geocode = gdMapGeocodingUtil.geocode(String.valueOf(x), String.valueOf(y));
                order.setGetoffAddress(geocode.get("address"));
            }
        }
        //计算行驶总距离和时长
        List<OrderTrajectory> orderTrajectoryList = mongoTemplate.find(new Query().addCriteria(Criteria.where("orderId").is(order.getId())), OrderTrajectory.class);
        Double reduce = orderTrajectoryList.stream().map(OrderTrajectory::getDistance).reduce(0.0, Double::sum);
        order.setMileageKilometers(new BigDecimal(reduce).divide(new BigDecimal(1000)).setScale(4, RoundingMode.HALF_EVEN).doubleValue());
        long duration = LocalDateTime.now().toEpochSecond(ZoneOffset.of("+8")) - order.getTripBegin().toEpochSecond(ZoneOffset.of("+8"));
        order.setDuration(new BigDecimal(duration).divide(new BigDecimal(60), 2, RoundingMode.HALF_EVEN).doubleValue());
        order.setStartTestPointId(null);
        this.updateById(order);
        redisService.setCacheObject("TEST_ORDER_STATUS:" + order.getId(), 7, 24L, TimeUnit.HOURS);

        //给XPU推送订单取消的报文
        PushOrderDto pushOrderDto = new PushOrderDto();
        pushOrderDto.setOrderId("TEST" + order.getId().toString());
        pushOrderDto.setVin(xpVehicle.getVehicleVin());
        pushOrderDto.setOperation_type(OrderOperationType.CLOUD_CANCEL_ORDER);
        orderMissionClient.cancelOrder(pushOrderDto);

        //结束行程，修改状态和计算费用
        endTrip(order.getId());

        //将支付金额修改成0 并将状态修改成 订单状态9
        setFree(order.getId());
    }



    /**
     * 豁免
     */
    public void setFree(Long id) {

        //将支付金额修改成0 并将状态修改成 订单状态9
        XpTestOrder xpOrder1 = new XpTestOrder();
        xpOrder1.setId(id);
        xpOrder1.setIsFree(true);//豁免
        xpOrder1.setPayMoney(BigDecimal.ZERO);
        xpOrder1.setStatus(OrderStatusEnum.PENDING_PAYMENT.getCode());
        xpOrder1.setUpdateTime(LocalDateTime.now());
        baseMapper.updateById(xpOrder1);
    }


    /**
     * 改派订单
     */