Merge branch 'feature/3.0' into feature/fangxinxing

longz

2026-07-02 c788ca1640f080f821cb1cbe07da741302d355ef

 DriverYKDTravel/guns-admin/src/main/java/com/stylefeng/guns/modular/system/service/impl/ReassignServiceImpl.java

@@ -12,6 +12,7 @@
import com.stylefeng.guns.modular.crossCity.dao.LineShiftDriverMapper;
import com.stylefeng.guns.modular.crossCity.dao.LineShiftMapper;
import com.stylefeng.guns.modular.crossCity.dao.LineSiteMapper;
import com.stylefeng.guns.modular.crossCity.model.Line;
import com.stylefeng.guns.modular.crossCity.model.LineShift;
import com.stylefeng.guns.modular.crossCity.model.LineShiftDriver;
import com.stylefeng.guns.modular.crossCity.model.OrderCrossCity;
@@ -23,6 +24,8 @@
import com.stylefeng.guns.modular.system.dao.DispatchMapper;
import com.stylefeng.guns.modular.system.dao.ReassignMapper;
import com.stylefeng.guns.modular.system.dao.SensitiveWordsMapper;
import com.stylefeng.guns.modular.system.dao.CarBrandMapper;
import com.stylefeng.guns.modular.system.dao.CarModelMapper;
import com.stylefeng.guns.modular.system.model.*;
import com.stylefeng.guns.modular.system.service.*;
import com.stylefeng.guns.modular.system.util.*;
@@ -113,6 +116,18 @@
    @Autowired
    private LineShiftDriverMapper lineShiftDriverMapper;

    @Autowired
    private ICarService carService;

    @Resource
    private CarBrandMapper carBrandMapper;

    @Resource
    private CarModelMapper carModelMapper;

    @Autowired
    private IOrderEvaluateService orderEvaluateService;


    /**
     * 提交改派申请
@@ -140,14 +155,14 @@
//        }
        int types = 1;
        Reassign query = reassignMapper.query(uid, null, reassign.getOrderId(), reassign.getOrderType(), 1);
        if (null != query) {
        if (isActiveReassign(query)) {
            types = 2;
//            return ResultUtil.error("不能重复提交申请");
            reassignMapper.deleteById(query.getId());
        }
        query = reassignMapper.query(uid, null, reassign.getOrderId(), reassign.getOrderType(), 2);

        if (null != query) {
        if (isActiveReassign(query)) {
            types = 2;
//            return ResultUtil.error("您提交的申请正在处理中");
        }
@@ -454,17 +469,27 @@
//            return ResultUtil.error("有未完成支付的改派申请");
//        }
        String[] split = orderIds.split(",");//获取支付金额
        Double aDouble = orderService.queryReassignMoney(Integer.valueOf(split[0]), 3);

        // 跨城改派：如果指定了司机，不收改派费用
        Double aDouble;
        if (isAssignedReassignTarget(reassign.getNowDriverId())) {
            aDouble = 0.0; // 指定司机，免费
        } else {
            aDouble = orderService.queryReassignMoney(Integer.valueOf(split[0]), 3);
        }

        Double totalMoney = aDouble * split.length;
        String ids = "";
        Integer requestTargetId = reassign.getNowDriverId();
        List<Reassign> currentReassignList = new ArrayList<>();
        for (String id : split) {
            Reassign query = reassignMapper.query(uid, null, Integer.valueOf(id), 3, 1);
            if (null != query) {
            if (isActiveReassign(query)) {
//                return ResultUtil.error("不能重复提交申请");
                reassignMapper.deleteById(query.getId());
            }
            query = reassignMapper.query(uid, null, Integer.valueOf(id), 3, 2);
            if (null != query) {
            if (isActiveReassign(query)) {
                return ResultUtil.error("您提交的申请正在处理中");
            }

@@ -475,11 +500,46 @@
            reassign.setOriginalCarId(driver.getCarId());
            reassign.setInsertTime(new Date());
            reassign.setState(1);
            reassign.setNowDriverId(requestTargetId);
            reassign.setNeedConfirm(null);
            reassign.setConfirmStatus(null);
            reassign.setConfirmTime(null);
            reassign.setExpireTime(null);
            reassign.setTempLineShiftDriverId(null);

            // 设置是否需要确认相关字段
            if (isAssignedReassignTarget(requestTargetId)) {
                OrderCrossCity orderCrossCity = orderCrossCityService.selectById(Integer.valueOf(id));
                boolean needConfirm = checkIfNeedConfirm(requestTargetId, orderCrossCity);
                reassign.setNeedConfirm(needConfirm ? 2 : 1);

                if (needConfirm) {
                    reassign.setNowDriverId(resolveConfirmDriverId(requestTargetId));
                    // 需要确认：设置超时时间
                    reassign.setConfirmStatus(1); // 待确认
                    Date expireTime = new Date(System.currentTimeMillis() + 60000); // 60秒后
                    reassign.setExpireTime(expireTime);
                } else {
                    reassign.setNowDriverId(requestTargetId);
                    // 不需要确认
                    reassign.setConfirmStatus(2); // 直接同意
                }
            } else {
                // 未指定司机，由调度分配
                reassign.setNeedConfirm(1);
            }

            this.insert(reassign);
            currentReassignList.add(this.selectById(reassign.getId()));
            ids += reassign.getId() + ",";
        }
        ids = ids.substring(0, ids.length() - 1);
        systemNoticeService.addSystemNotice(2, "您的改派申请已成功提交，我们会尽快为你处理！", uid, 1);

        if (isAssignedReassignTarget(requestTargetId)) {
            processFreeAssignedCrossCityReassign(split, currentReassignList, reassign);
            return ResultUtil.success();
        }

        //开始支付
        if (null != reassign.getPayType()) {
@@ -533,15 +593,65 @@


                //修改改派通知状态
                boolean needConfirmPush = false; // 标记是否需要发送确认推送
                OrderCrossCity firstOrder = null; // 保存第一个订单用于发送推送
                Reassign firstConfirmReassign = null; // 保存第一条待确认改派记录
                int totalPeopleNumber = 0; // 累计总人数
                List<String> orderIdList = new ArrayList<>(); // 收集所有订单ID
                List<String> reassignIdList = new ArrayList<>(); // 收集所有改派记录ID

                for (String id : split) {
                    OrderCrossCity orderCrossCity = orderCrossCityService.selectById(id);
                    orderCrossCity.setOldState(orderCrossCity.getState());
                    if(reassign.getNowDriverId()==null){

                    // 查询改派记录
                    Reassign reassignRecord = reassignMapper.query(uid, null, Integer.valueOf(id), 3, 1, 2, 3);
                    if (reassignRecord != null) {
                        reassignIdList.add(String.valueOf(reassignRecord.getId()));
                    }

                    // 累加人数
                    if (orderCrossCity.getPeopleNumber() != null) {
                        totalPeopleNumber += orderCrossCity.getPeopleNumber();
                    }
                    orderIdList.add(id);

                    if(reassignRecord == null || reassignRecord.getNowDriverId()==null){
                        System.out.println("跨城改派确认Socket未触发: reassignRecord为空或未指定司机, orderId=" + id);
                        orderCrossCity.setState(11);
                    }else {
//                        orderCrossCity.setDriverId(reassign.getNowDriverId());
                        //reassign.getNowDriverId() 是lineShiftDriverId
                        driverReassignSelf(reassign, orderCrossCity);
                        boolean needConfirm = reassignRecord.getNeedConfirm() != null && reassignRecord.getNeedConfirm() == 2;
                        System.out.println("跨城改派余额支付确认判断: orderId=" + id
                                + ", reassignId=" + reassignRecord.getId()
                                + ", nowDriverId=" + reassignRecord.getNowDriverId()
                                + ", needConfirm=" + reassignRecord.getNeedConfirm()
                                + ", confirmStatus=" + reassignRecord.getConfirmStatus()
                                + ", state=" + reassignRecord.getState());

                        if (needConfirm) {
                            // 需要确认：标记需要发送推送，但不立即发送
                            orderCrossCity.setState(11); // 改派中状态
                            needConfirmPush = true;
                            if (firstConfirmReassign == null) {
                                firstConfirmReassign = reassignRecord;
                            }
                            if (firstOrder == null) {
                                firstOrder = orderCrossCity; // 保存第一个订单
                            }
                        } else {
                            // 不需要确认：直接改派
                            driverReassignSelf(reassignRecord, orderCrossCity);

                            // 只有无需确认时才推送乘客和司机信息
                            try {
                                // 推送用户消息
                                pushUtil.pushOrderReassign(orderCrossCity.getUserId(), 1, orderCrossCity.getId(), 3);
                                // 推送司机消息
                                pushUtil.pushOrderReassign(orderCrossCity.getDriverId(), 2, orderCrossCity.getId(), 3);
                            } catch (Exception ignore) {

                            }
                        }
                    }

                    orderCrossCity.setReassignNotice(2);
@@ -549,19 +659,18 @@
                    orderCrossCityService.updateById(orderCrossCity);
                    //添加已收入明细
                    incomeService.saveData(1, orderCrossCity.getCompanyId(), 4, orderCrossCity.getId(), 3, reassign.getMoney());
                }


                    if(reassign.getNowDriverId()!=null){
                        try {
                            // 推送用户消息
                            pushUtil.pushOrderReassign(orderCrossCity.getUserId(), 1, orderCrossCity.getId(), 3);
                            // 推送司机消息
                            pushUtil.pushOrderReassign(orderCrossCity.getDriverId(), 2, orderCrossCity.getId(), 3);
                        } catch (Exception ignore) {

                        }

                    }
                // 所有订单处理完后，只发送一次确认推送
                if (needConfirmPush && firstOrder != null && firstConfirmReassign != null) {
                    System.out.println("准备发送跨城改派确认Socket(余额支付): driverId=" + firstConfirmReassign.getNowDriverId()
                            + ", reassignIds=" + String.join(",", reassignIdList)
                            + ", orderIds=" + String.join(",", orderIdList));
                    sendReassignConfirmPush(firstConfirmReassign.getNowDriverId(), firstConfirmReassign, firstOrder, totalPeopleNumber, orderIdList, reassignIdList);
                } else {
                    System.out.println("跨城改派确认Socket未发送(余额支付): needConfirmPush=" + needConfirmPush
                            + ", firstOrder=" + (firstOrder == null ? "null" : firstOrder.getId())
                            + ", firstConfirmReassign=" + (firstConfirmReassign == null ? "null" : firstConfirmReassign.getId()));
                }
                systemNoticeService.addSystemNotice(2, "您已使用余额成功支付改派申请费用！", uid, 1);

@@ -640,6 +749,7 @@
            String[] split = s[0].split(",");
            List<Reassign> reassigns = this.selectBatchIds(Arrays.asList(split));
            Driver driver = driverService.selectById(reassigns.get(0).getOriginalDriverId());
            boolean batchHandled = false;
            for (String key : split) {
                PaymentRecord query = paymentRecordService.query(1, driver.getId(), 2, Integer.valueOf(key), 3, type, 1);
                if (null != query) {
@@ -668,16 +778,60 @@
                    query.setCode(order_id);
                    paymentRecordService.updateById(query);
                    System.out.println("==============paymentRecord完毕===================" + query);

                    if (batchHandled) {
                        continue;
                    }
                    batchHandled = true;

                    //修改改派通知状态
                    boolean needConfirmPush = false;
                    OrderCrossCity firstOrder = null;
                    Reassign firstConfirmReassign = null;
                    int totalPeopleNumber = 0;
                    List<String> orderIdList = new ArrayList<>();
                    List<String> reassignIdList = new ArrayList<>();
                    for (Reassign reassign : reassigns) {
                        OrderCrossCity orderCrossCity1 = orderCrossCityService.selectById(reassign.getOrderId());
                        orderCrossCity1.setOldState(orderCrossCity1.getState());
                        if (orderCrossCity1.getPeopleNumber() != null) {
                            totalPeopleNumber += orderCrossCity1.getPeopleNumber();
                        }
                        orderIdList.add(String.valueOf(orderCrossCity1.getId()));
                        reassignIdList.add(String.valueOf(reassign.getId()));
                        if(reassign.getNowDriverId()==null){
                            System.out.println("跨城改派确认Socket未触发: 未指定司机, reassignId=" + reassign.getId() + ", orderId=" + reassign.getOrderId());
                            orderCrossCity1.setState(11);
                        } else {
//                            orderCrossCity1.setDriverId(reassign.getNowDriverId());
                            //reassign.getNowDriverId() 是lineShiftDriverId
                            driverReassignSelf(reassign, orderCrossCity1);
                            boolean needConfirm = reassign.getNeedConfirm() != null
                                    ? reassign.getNeedConfirm() == 2
                                    : checkIfNeedConfirm(reassign.getNowDriverId(), orderCrossCity1);
                            System.out.println("跨城改派在线支付确认判断: orderId=" + reassign.getOrderId()
                                    + ", reassignId=" + reassign.getId()
                                    + ", nowDriverId=" + reassign.getNowDriverId()
                                    + ", needConfirm=" + reassign.getNeedConfirm()
                                    + ", confirmStatus=" + reassign.getConfirmStatus()
                                    + ", state=" + reassign.getState()
                                    + ", needConfirmResult=" + needConfirm);
                            if (needConfirm) {
                                if (reassign.getNeedConfirm() == null) {
                                    reassign.setNowDriverId(resolveConfirmDriverId(reassign.getNowDriverId()));
                                }
                                ensureReassignConfirmTimeout(reassign);
                                reassign.setState(3);
                                this.updateById(reassign);
                                orderCrossCity1.setState(11);
                                needConfirmPush = true;
                                if (firstConfirmReassign == null) {
                                    firstConfirmReassign = reassign;
                                }
                                if (firstOrder == null) {
                                    firstOrder = orderCrossCity1;
                                }
                            } else {
                                // reassign.getNowDriverId() 是 lineShiftDriverId
                                driverReassignSelf(reassign, orderCrossCity1);
                            }
                        }
                        orderCrossCity1.setReassignNotice(2);
                        orderCrossCity1.setIsReassign(2);
@@ -689,11 +843,23 @@


                        if(reassign.getNowDriverId()!=null){
                            // 推送用户消息
                            pushUtil.pushOrderReassign(orderCrossCity1.getUserId(), 1, orderCrossCity1.getId(), 3);
                            // 推送司机消息
                            pushUtil.pushOrderReassign(orderCrossCity1.getDriverId(), 2, orderCrossCity1.getId(), 3);
                            if (reassign.getNeedConfirm() == null || reassign.getNeedConfirm().intValue() != 2) {
                                // 推送用户消息
                                pushUtil.pushOrderReassign(orderCrossCity1.getUserId(), 1, orderCrossCity1.getId(), 3);
                                // 推送司机消息
                                pushUtil.pushOrderReassign(orderCrossCity1.getDriverId(), 2, orderCrossCity1.getId(), 3);
                            }
                        }
                    }
                    if (needConfirmPush && firstOrder != null && firstConfirmReassign != null) {
                        System.out.println("准备发送跨城改派确认Socket(在线支付): driverId=" + firstConfirmReassign.getNowDriverId()
                                + ", reassignIds=" + String.join(",", reassignIdList)
                                + ", orderIds=" + String.join(",", orderIdList));
                        sendReassignConfirmPush(firstConfirmReassign.getNowDriverId(), firstConfirmReassign, firstOrder, totalPeopleNumber, orderIdList, reassignIdList);
                    } else {
                        System.out.println("跨城改派确认Socket未发送(在线支付): needConfirmPush=" + needConfirmPush
                                + ", firstOrder=" + (firstOrder == null ? "null" : firstOrder.getId())
                                + ", firstConfirmReassign=" + (firstConfirmReassign == null ? "null" : firstConfirmReassign.getId()));
                    }
                    systemNoticeService.addSystemNotice(2, "您已使用" + (type == 1 ? "微信" : (type == 2 ? "支付宝" : "云闪付")) + "成功支付改派申请费用！", reassigns.get(0).getOriginalDriverId(), 1);
                    System.out.println("==============跨城修改改派通知状态完毕===================");
@@ -797,6 +963,10 @@
    }

    private void driverReassignSelf(Reassign reassign, OrderCrossCity orderCrossCity1) {
        driverReassignSelf(reassign, orderCrossCity1, null);
    }

    private void driverReassignSelf(Reassign reassign, OrderCrossCity orderCrossCity1, Integer peopleNumberOverride) {
        // 交换人数 交换座位
        Integer oldLineShiftDriverId = orderCrossCity1.getLineShiftDriverId();
        LineShiftDriver oldLineShiftDriver = lineShiftDriverMapper.selectById(oldLineShiftDriverId);
@@ -805,7 +975,7 @@
        orderCrossCity1.setLineShiftDriverId(reassign.getNowDriverId());
        Driver driver1 = driverService.selectById(lineShiftDriver.getDriverId());
        orderCrossCity1.setCarId(driver1.getCarId());
        Integer peopleNumber = orderCrossCity1.getPeopleNumber();
        Integer peopleNumber = peopleNumberOverride == null ? orderCrossCity1.getPeopleNumber() : peopleNumberOverride;
        oldLineShiftDriver.setLaveSeat(oldLineShiftDriver.getLaveSeat() + peopleNumber);
        lineShiftDriver.setLaveSeat(lineShiftDriver.getLaveSeat() - peopleNumber);
        String laveSeatNumber = Arrays.stream(lineShiftDriver.getLaveSeatNumber().split(",")).skip(peopleNumber).collect(Collectors.joining(","));
@@ -823,6 +993,137 @@
        lineShiftDriverMapper.updateById(lineShiftDriver);
    }

    private void processFreeAssignedCrossCityReassign(String[] orderIds, List<Reassign> currentReassignList, Reassign requestReassign) throws Exception {
        Map<Integer, Reassign> currentReassignMap = new HashMap<>();
        for (Reassign currentReassign : currentReassignList) {
            if (currentReassign == null || currentReassign.getOrderId() == null) {
                continue;
            }
            currentReassign.setState(currentReassign.getNowDriverId() != null ? 3 : 2);
            currentReassign.setPayTime(new Date());
            reassignMapper.updateById(currentReassign);
            currentReassignMap.put(currentReassign.getOrderId(), currentReassign);
        }

        boolean needConfirmPush = false;
        OrderCrossCity firstOrder = null;
        Reassign firstConfirmReassign = null;
        int totalPeopleNumber = 0;
        List<String> orderIdList = new ArrayList<>();
        List<String> reassignIdList = new ArrayList<>();

        for (String id : orderIds) {
            OrderCrossCity orderCrossCity = orderCrossCityService.selectById(id);
            if (orderCrossCity == null) {
                continue;
            }
            orderCrossCity.setOldState(orderCrossCity.getState());

            Reassign reassignRecord = currentReassignMap.get(Integer.valueOf(id));
            if (reassignRecord != null) {
                reassignIdList.add(String.valueOf(reassignRecord.getId()));
            }

            if (orderCrossCity.getPeopleNumber() != null) {
                totalPeopleNumber += orderCrossCity.getPeopleNumber();
            }
            orderIdList.add(id);

            if (reassignRecord == null || reassignRecord.getNowDriverId() == null) {
                orderCrossCity.setState(11);
            } else {
                boolean needConfirm = reassignRecord.getNeedConfirm() != null && reassignRecord.getNeedConfirm() == 2;
                System.out.println("跨城指定司机免费改派确认判断: orderId=" + id
                        + ", reassignId=" + reassignRecord.getId()
                        + ", nowDriverId=" + reassignRecord.getNowDriverId()
                        + ", needConfirm=" + reassignRecord.getNeedConfirm()
                        + ", confirmStatus=" + reassignRecord.getConfirmStatus()
                        + ", state=" + reassignRecord.getState());

                if (needConfirm) {
                    orderCrossCity.setState(11);
                    needConfirmPush = true;
                    if (firstConfirmReassign == null) {
                        firstConfirmReassign = reassignRecord;
                    }
                    if (firstOrder == null) {
                        firstOrder = orderCrossCity;
                    }
                } else {
                    driverReassignSelf(reassignRecord, orderCrossCity);
                    try {
                        pushUtil.pushOrderReassign(orderCrossCity.getUserId(), 1, orderCrossCity.getId(), 3);
                        pushUtil.pushOrderReassign(orderCrossCity.getDriverId(), 2, orderCrossCity.getId(), 3);
                    } catch (Exception ignore) {
                    }
                }
            }

            orderCrossCity.setReassignNotice(2);
            orderCrossCity.setIsReassign(2);
            orderCrossCityService.updateById(orderCrossCity);
            incomeService.saveData(1, orderCrossCity.getCompanyId(), 4, orderCrossCity.getId(), 3, requestReassign.getMoney());
        }

        if (needConfirmPush && firstOrder != null && firstConfirmReassign != null) {
            System.out.println("准备发送跨城改派确认Socket(指定司机免费): driverId=" + firstConfirmReassign.getNowDriverId()
                    + ", reassignIds=" + String.join(",", reassignIdList)
                    + ", orderIds=" + String.join(",", orderIdList));
            sendReassignConfirmPush(firstConfirmReassign.getNowDriverId(), firstConfirmReassign, firstOrder, totalPeopleNumber, orderIdList, reassignIdList);
        } else {
            System.out.println("跨城改派确认Socket未发送(指定司机免费): needConfirmPush=" + needConfirmPush
                    + ", firstOrder=" + (firstOrder == null ? "null" : firstOrder.getId())
                    + ", firstConfirmReassign=" + (firstConfirmReassign == null ? "null" : firstConfirmReassign.getId()));
        }
    }

    private void ensureReassignConfirmTimeout(Reassign reassign) {
        reassign.setNeedConfirm(2);
        reassign.setConfirmStatus(1);
        if (reassign.getExpireTime() == null) {
            reassign.setExpireTime(new Date(System.currentTimeMillis() + 60000));
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void timeoutReassign(Reassign reassign) throws Exception {
        if (reassign == null) {
            return;
        }
        Reassign current = this.selectById(reassign.getId());
        if (current == null || current.getConfirmStatus() == null || current.getConfirmStatus() != 1) {
            return;
        }
        current.setConfirmStatus(4);
        current.setState(5);
        current.setConfirmTime(new Date());
        this.updateById(current);
        restoreCrossCityOrderAfterReassignEnd(current);
    }

    private void restoreCrossCityOrderAfterReassignEnd(Reassign reassign) {
        if (reassign == null || reassign.getOrderType() == null || reassign.getOrderType() != 3 || reassign.getOrderId() == null) {
            return;
        }
        OrderCrossCity order = orderCrossCityService.selectById(reassign.getOrderId());
        if (order == null || order.getState() == null || order.getState() != 11) {
            return;
        }
        order.setState(order.getOldState() == null ? 2 : order.getOldState());
        order.setReassignNotice(0);
        order.setIsReassign(1);
        orderCrossCityService.updateById(order);
    }
    private void restoreCrossCityOrderAfterReassignSuccess(OrderCrossCity order) {
        if (order == null || order.getState() == null || order.getState() != 11) {
            return;
        }
        order.setState(order.getOldState() == null ? 2 : order.getOldState());
        order.setReassignNotice(0);
        order.setIsReassign(1);
    }

    @Override
    public List<Map<String, Object>> queryDriver(String orderId) throws Exception {
        OrderCrossCity orderCrossCity = orderCrossCityService.selectById(orderId);
@@ -833,6 +1134,29 @@
        c.setTime(new Date());
        c.set(c.get(Calendar.YEAR), c.get(Calendar.MONTH), c.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
        c.set(Calendar.MILLISECOND, 0);
        List<Map<String, Object>> list = new ArrayList<>();

        // 1. 查询同批次同时间的司机（不需要确认）
        List<Map<String, Object>> sameBatchDrivers = querySameBatchDrivers(orderCrossCity, sdf, day, c);
        for (Map<String, Object> driver : sameBatchDrivers) {
            driver.put("needConfirm", 1); // 不需要确认
        }
        list.addAll(sameBatchDrivers);

        // 2. 查询其他同公司司机（需要确认）
        List<Map<String, Object>> otherCompanyDrivers = queryOtherCompanyDrivers(orderCrossCity, day);
        for (Map<String, Object> driver : otherCompanyDrivers) {
            driver.put("needConfirm", 2); // 需要确认
        }
        list.addAll(otherCompanyDrivers);

        return list;
    }

    /**
     * 查询同批次同时间的司机（原逻辑）
     */
    private List<Map<String, Object>> querySameBatchDrivers(OrderCrossCity orderCrossCity, SimpleDateFormat sdf, String day, Calendar c) throws Exception {
        List<Map<String, Object>> list = new ArrayList<>();
        List<LineShift> lineShifts = lineShiftMapper.getOtherDriverLineShift(orderCrossCity.getLineShiftDriverId());
        List<Map<String, Object>> s = lineSiteMapper.queryOtherDriver(orderCrossCity.getLineId(), sdf.parse(day), orderCrossCity.getDriverId());
@@ -866,7 +1190,6 @@
                    continue;
                }


                int i = orderTaxiService.selectCount(new EntityWrapper<OrderTaxi>().eq("driverId", map.get("driverId")).in("state", Arrays.asList(2, 3, 4, 5, 11)).eq("DATE_FORMAT(travelTime, '%Y-%m-%d')", day));
                if (i > 0) {
                    continue;
@@ -897,6 +1220,146 @@
                list.add(data);
            }
        }
        return list;
    }

    /**
     * 查询其他同公司司机（需要确认）
     * 条件：同公司 + 该时段无排班 + 该时段无订单 + 座位数足够
     */
    private List<Map<String, Object>> queryOtherCompanyDrivers(OrderCrossCity orderCrossCity, String day) throws Exception {
        List<Map<String, Object>> list = new ArrayList<>();

        // 获取原司机信息
        Driver originalDriver = driverService.selectById(orderCrossCity.getDriverId());
        if (originalDriver == null || originalDriver.getCompanyId() == null) {
            return list;
        }

        // 获取班次时间信息
        LineShiftDriver originalLsd = lineShiftDriverMapper.selectById(orderCrossCity.getLineShiftDriverId());
        if (originalLsd == null) {
            return list;
        }
        LineShift lineShift = lineShiftMapper.selectById(originalLsd.getLineShiftId());
        if (lineShift == null) {
            return list;
        }

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date dayDate = sdf.parse(day);

        // 获取 VEHICLE 黑名单
        String vehicle = (String) redisTemplate.opsForValue().get("VEHICLE");
        List<Integer> blacklist = new ArrayList<>();
        if (ToolUtil.isNotEmpty(vehicle)) {
            blacklist = JSON.parseArray(vehicle).toJavaList(Integer.class);
        }

        // 查询同公司的所有空闲司机
        List<Driver> companyDrivers = driverService.selectList(
            new EntityWrapper<Driver>()
                .eq("companyId", originalDriver.getCompanyId())
                .eq("state", 2) // 空闲状态
                .ne("id", orderCrossCity.getDriverId()) // 排除当前司机
        );

        for (Driver driver : companyDrivers) {
            // 检查司机是否在黑名单中
            if (blacklist.contains(driver.getId())) {
                continue; // 黑名单司机，跳过
            }

            // 检查该司机在该时段是否有排班
            int shiftCount = lineShiftDriverMapper.selectCount(
                new EntityWrapper<LineShiftDriver>()
                    .eq("driverId", driver.getId())
                    .eq("day", dayDate)
                    .exists("SELECT 1 FROM t_line_shift ls WHERE ls.id = {0}.lineShiftId " +
                            "AND ls.startTime <= '" + lineShift.getEndTime() + "' " +
                            "AND ls.endTime >= '" + lineShift.getStartTime() + "'")
            );
            if (shiftCount > 0) {
                continue; // 该时段有排班，跳过
            }

            // 检查该司机在该时段是否有跨城订单（使用相同的方法检查）
            List<OrderCrossCity> orderList = orderCrossCityService.queryListOrder(
                driver.getId(),
                lineShift.getId(),
                Arrays.asList(2, 3, 4, 5), // 待出发、服务中等
                day
            );
            if (orderList != null && orderList.size() > 0) {
                continue; // 该时段有跨城订单，跳过
            }

            // 检查该司机在该时段是否有出租车订单
            int taxiOrderCount = orderTaxiService.selectCount(
                new EntityWrapper<OrderTaxi>()
                    .eq("driverId", driver.getId())
                    .in("state", Arrays.asList(2, 3, 4, 5, 11)) // 待出发、服务中等
                    .eq("DATE_FORMAT(travelTime, '%Y-%m-%d')", day)
            );
            if (taxiOrderCount > 0) {
                continue; // 该时段有出租车订单，跳过
            }

            // 检查该司机在该时段是否有专车订单
            int privateCarOrderCount = orderPrivateCarService.selectCount(
                new EntityWrapper<OrderPrivateCar>()
                    .eq("driverId", driver.getId())
                    .in("state", Arrays.asList(2, 3, 4, 5, 11)) // 待出发、服务中等
                    .eq("DATE_FORMAT(travelTime, '%Y-%m-%d')", day)
            );
            if (privateCarOrderCount > 0) {
                continue; // 该时段有专车订单，跳过
            }

            // 检查车辆信息和座位数
            if (driver.getCarId() == null) {
                continue; // 未分配车辆，跳过
            }
            Car car = carService.selectById(driver.getCarId());
            if (car == null || car.getCarModelId() == null) {
                continue; // 车辆不存在或未设置车型，跳过
            }

            // 从车型获取座位数
            CarModel carModel = carModelMapper.selectById(car.getCarModelId());
            if (carModel == null || carModel.getSeat() == null || carModel.getSeat() < orderCrossCity.getPeopleNumber()) {
                continue; // 座位数不足，跳过
            }

            // 构建返回数据
            Map<String, Object> data = new HashMap<>();
            data.put("id", lineShift.getId());
            data.put("lineShiftDriverId", null); // 无现有排班
            data.put("startTime", lineShift.getStartTime() + "-" + lineShift.getEndTime());
            data.put("headImgUrl", driver.getHeadImgUrl());
            data.put("name", driver.getName().substring(0, 1) + "师傅");
            data.put("carLicensePlate", car.getCarLicensePlate());
            data.put("carColor", car.getCarColor());
            data.put("driverId", driver.getId());
            data.put("carId", car.getId());
            data.put("totalSeat", carModel.getSeat() - 1); // 总座位数（减去司机位）
            data.put("laveSeat", carModel.getSeat() - 1); // 全部座位可用

            // 获取品牌型号
            if (car.getCarBrandId() != null && car.getCarModelId() != null) {
                CarBrand brand = carBrandMapper.selectById(car.getCarBrandId());
                CarModel model = carModelMapper.selectById(car.getCarModelId());
                if (brand != null && model != null) {
                    data.put("brand", brand.getName() + model.getName());
                }
            }

            // 设置默认评分
            data.put("evaluate", 5.0);

            list.add(data);
        }

        return list;
    }

@@ -1085,4 +1548,425 @@
        }).start();
    }

    /**
     * 检查是否需要对方确认
     * @param targetId 正数为同批次 lineShiftDriverId，负数为扩展司机的 0-driverId
     * @param orderCrossCity 订单
     * @return true=需要确认, false=不需要确认
     */
    private boolean checkIfNeedConfirm(Integer targetId, OrderCrossCity orderCrossCity) {
        try {
            if (targetId == null || orderCrossCity == null || orderCrossCity.getLineShiftDriverId() == null) {
                return true;
            }
            if (targetId < 0) {
                return true;
            }
            LineShiftDriver targetLineShiftDriver = lineShiftDriverMapper.selectById(targetId);
            if (targetLineShiftDriver == null) {
                return true;
            }
            LineShiftDriver originalLsd = lineShiftDriverMapper.selectById(orderCrossCity.getLineShiftDriverId());
            if (originalLsd == null || targetLineShiftDriver.getLineShiftId() == null || originalLsd.getLineShiftId() == null) {
                return true;
            }
            return targetLineShiftDriver.getLineShiftId().compareTo(originalLsd.getLineShiftId()) != 0
                    || targetLineShiftDriver.getDay() == null
                    || originalLsd.getDay() == null
                    || !new SimpleDateFormat("yyyy-MM-dd").format(targetLineShiftDriver.getDay())
                    .equals(new SimpleDateFormat("yyyy-MM-dd").format(originalLsd.getDay()));
        } catch (Exception e) {
            e.printStackTrace();
            return true; // 出错默认需要确认
        }
    }

    private boolean isAssignedReassignTarget(Integer targetId) {
        return targetId != null && targetId != 0;
    }

    private boolean isActiveReassign(Reassign reassign) {
        if (reassign == null) {
            return false;
        }
        if (reassign.getState() != null && (reassign.getState() == 4 || reassign.getState() == 5)) {
            return false;
        }
        return reassign.getConfirmStatus() == null
                || (reassign.getConfirmStatus() != 3 && reassign.getConfirmStatus() != 4);
    }

    private Integer resolveConfirmDriverId(Integer targetId) {
        if (targetId == null) {
            return null;
        }
        if (targetId < 0) {
            return 0 - targetId;
        }
        LineShiftDriver lineShiftDriver = lineShiftDriverMapper.selectById(targetId);
        return lineShiftDriver == null ? targetId : lineShiftDriver.getDriverId();
    }

    /**
     * 发送改派确认推送给目标司机（使用Socket推送，不用极光推送）
     * @param driverId 目标司机ID
     * @param reassign 改派记录
     * @param order 订单信息
     * @param totalPeopleNumber 总人数（已在调用处计算好）
     * @param orderIdList 订单ID列表
     * @param reassignIdList 改派记录ID列表
     */
    private void sendReassignConfirmPush(Integer driverId, Reassign reassign, OrderCrossCity order, int totalPeopleNumber, List<String> orderIdList, List<String> reassignIdList) {
        try {
            System.out.println("进入跨城改派确认Socket发送方法: driverId=" + driverId
                    + ", reassignId=" + (reassign == null ? "null" : reassign.getId())
                    + ", orderId=" + (order == null ? "null" : order.getId())
                    + ", totalPeopleNumber=" + totalPeopleNumber);
            // 使用订单的起点和终点地址（订单的startAddress和endAddress就是跨城站点地址）
            String startSite = order.getStartAddress() != null ? order.getStartAddress() : "";
            String endSite = order.getEndAddress() != null ? order.getEndAddress() : "";

            // 转换时间为字符串
            SimpleDateFormat dateTimeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String travelTime = order.getTravelTime() != null ? dateTimeFormat.format(order.getTravelTime()) : "";
            String expireTime = reassign.getExpireTime() != null ? dateTimeFormat.format(reassign.getExpireTime()) : "";

            // 使用 Socket 推送（不用极光推送）
            pushUtil.pushReassignConfirmRequest(
                driverId,
                String.join(",", reassignIdList), // 改派记录ID列表（逗号分隔）
                String.join(",", orderIdList),     // 订单ID列表（逗号分隔）
                startSite,
                endSite,
                totalPeopleNumber,
                travelTime,
                expireTime
            );
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 为司机创建临时 LineShiftDriver
     * @param order 订单
     * @param driverId 司机ID
     * @return 新创建的 LineShiftDriverId
     */
    private Integer createTempLineShiftDriver(OrderCrossCity order, Integer driverId) throws Exception {
        return createTempLineShiftDriver(order, driverId, order.getPeopleNumber());
    }

    private Integer createTempLineShiftDriver(OrderCrossCity order, Integer driverId, Integer peopleNumber) throws Exception {
        // 获取原始班次信息
        LineShiftDriver originalLsd = lineShiftDriverMapper.selectById(order.getLineShiftDriverId());
        if (originalLsd == null) {
            throw new Exception("原始班次信息不存在");
        }

        // 创建新的 LineShiftDriver
        LineShiftDriver tempLsd = new LineShiftDriver();
        tempLsd.setLineShiftId(originalLsd.getLineShiftId()); // 相同班次
        tempLsd.setDriverId(driverId); // 新司机
        tempLsd.setDay(originalLsd.getDay());

        Driver driver = driverService.selectById(driverId);
        if (driver == null) {
            throw new Exception("司机信息不存在");
        }

        Car car = carService.selectById(driver.getCarId());
        if (car == null || car.getCarModelId() == null) {
            throw new Exception("车辆信息不存在或未设置车型");
        }

        // 从车型获取座位数
        CarModel carModel = carModelMapper.selectById(car.getCarModelId());
        if (carModel == null || carModel.getSeat() == null) {
            throw new Exception("车型信息不存在");
        }

        int totalSeat = carModel.getSeat() - 1; // 总座位数（减去司机位）
        tempLsd.setTotalSeat(totalSeat);
        tempLsd.setLaveSeat(totalSeat);

        // 新建临时班次时先放全部可用座位，后续统一按本批总人数扣减。
        StringBuilder seatNumbers = new StringBuilder();
        for (int i = 1; i <= totalSeat; i++) {
            if (i > 1) seatNumbers.append(",");
            seatNumbers.append(i);
        }
        tempLsd.setLaveSeatNumber(seatNumbers.toString());

        tempLsd.setInserTime(new Date());

        lineShiftDriverMapper.insert(tempLsd);
        return tempLsd.getId();
    }

    /**
     * 通知原司机改派成功（使用Socket推送）
     */
    private void pushReassignSuccess(Reassign reassign) {
        try {
            pushUtil.pushReassignSuccess(
                reassign.getOriginalDriverId(),
                reassign.getId(),
                reassign.getOrderId(),
                reassign.getOrderType()
            );
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 通知原司机改派被拒绝（使用Socket推送）
     */
    private void pushReassignRejected(Reassign reassign) {
        try {
            pushUtil.pushReassignRejected(
                reassign.getOriginalDriverId(),
                reassign.getId(),
                reassign.getOrderId(),
                reassign.getOrderType()
            );
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 通知原司机改派超时（使用Socket推送）
     */
    private void pushReassignTimeout(Reassign reassign) {
        try {
            pushUtil.pushReassignTimeout(
                reassign.getOriginalDriverId(),
                reassign.getId(),
                reassign.getOrderId(),
                reassign.getOrderType()
            );
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public ResultUtil respondReassign(Integer reassignId, Integer driverId, Integer responseType) {
        // 兼容旧接口：单个改派记录
        return respondReassignBatch(String.valueOf(reassignId), driverId, responseType);
    }

    /**
     * 批量响应改派请求（同意或拒绝）
     * @param reassignIds 改派记录ID列表（逗号分隔）
     * @param driverId 司机ID
     * @param responseType 响应类型（1=同意，2=拒绝）
     * @return 处理结果
     */
    @Transactional(rollbackFor = Exception.class)
    public ResultUtil respondReassignBatch(String reassignIds, Integer driverId, Integer responseType) {
        try {
            if (reassignIds == null || reassignIds.trim().isEmpty()) {
                return reassignResponse("改派申请ID不能为空", false);
            }

            String[] idArray = reassignIds.split(",");
            List<Reassign> reassignList = new ArrayList<>();

            // 第一步：验证所有改派记录
            for (String idStr : idArray) {
                Integer reassignId = Integer.valueOf(idStr.trim());
                Reassign reassign = this.baseMapper.selectById(reassignId);

                if (reassign == null) {
                    return reassignResponse("改派申请不存在: " + reassignId, false);
                }

                // 验证权限：检查nowDriverId是否匹配
                if (reassign.getNowDriverId() == null || !reassign.getNowDriverId().equals(driverId)) {
                    return reassignResponse("无权操作改派申请: " + reassignId, false);
                }

                // 幂等性检查：只有待确认状态才能响应
                if (reassign.getConfirmStatus() != 1) {
                    if (reassign.getConfirmStatus() == 2) {
                        return reassignResponse("改派申请已被接受: " + reassignId, false);
                    } else if (reassign.getConfirmStatus() == 3) {
                        return reassignResponse("改派申请已被拒绝: " + reassignId, false);
                    } else if (reassign.getConfirmStatus() == 4) {
                        return reassignResponse("改派申请已超时: " + reassignId, false);
                    } else {
                        return reassignResponse("改派申请已处理: " + reassignId, false);
                    }
                }

                // 验证是否超时
                if (new Date().after(reassign.getExpireTime())) {
                    reassign.setConfirmStatus(4);
                    this.updateById(reassign);
                    return reassignResponse("改派申请已超时: " + reassignId, false);
                }

                reassignList.add(reassign);
            }

            // 第二步：批量处理所有改派记录
            if (responseType == 1) {
                // 同意改派
                List<OrderCrossCity> orderList = new ArrayList<>();
                int totalPeopleNumber = 0;
                for (Reassign reassign : reassignList) {
                    OrderCrossCity order = orderCrossCityService.selectById(reassign.getOrderId());
                    if (order == null) {
                        return reassignResponse("订单不存在: " + reassign.getOrderId(), false);
                    }
                    if (order.getState() != 11) {
                        return reassignResponse("订单状态已变更，无法改派: " + order.getId(), false);
                    }
                    orderList.add(order);
                    if (order.getPeopleNumber() != null) {
                        totalPeopleNumber += order.getPeopleNumber();
                    }
                }

                OrderCrossCity firstOrder = orderList.get(0);
                String batchOrderNum = firstOrder.getOrderNum();
                Integer tempLineShiftDriverId = createTempLineShiftDriver(firstOrder, driverId, totalPeopleNumber);
                Reassign tempReassign = new Reassign();
                tempReassign.setNowDriverId(tempLineShiftDriverId);
                driverReassignSelf(tempReassign, firstOrder, totalPeopleNumber);

                LineShiftDriver tempLineShiftDriver = lineShiftDriverMapper.selectById(tempLineShiftDriverId);
                Driver targetDriver = driverService.selectById(driverId);

                for (int i = 0; i < reassignList.size(); i++) {
                    Reassign reassign = reassignList.get(i);
                    OrderCrossCity order = orderList.get(i);
                    // 使用乐观锁更新状态
                    reassign.setConfirmStatus(2);
                    reassign.setConfirmTime(new Date());
                    reassign.setTempLineShiftDriverId(tempLineShiftDriverId);
                    int updateCount = this.baseMapper.update(reassign,
                        new EntityWrapper<Reassign>()
                            .eq("id", reassign.getId())
                            .eq("confirmStatus", 1) // 只有待确认状态才能更新
                    );

                    if (updateCount == 0) {
                        return reassignResponse("改派申请已被处理: " + reassign.getId(), false);
                    }

                    order.setDriverId(tempLineShiftDriver.getDriverId());
                    order.setLineShiftDriverId(tempLineShiftDriverId);
                    order.setOrderNum(batchOrderNum);
                    restoreCrossCityOrderAfterReassignSuccess(order);
                    if (targetDriver != null) {
                        order.setCarId(targetDriver.getCarId());
                    }
                    orderCrossCityService.updateById(order);

                    // 推送乘客和司机通知
                    try {
                        pushUtil.pushOrderReassign(order.getUserId(), 1, order.getId(), 3);
                        //司机就是发起确定的人 这里就不需要通知司机了
                    } catch (Exception ignore) {
                    }
                }

                // 通知原司机改派成功（只通知一次）
                if (!reassignList.isEmpty()) {
                    pushReassignSuccess(reassignList.get(0));
                }

                return reassignResponse("批量改派成功，共处理 " + reassignList.size() + " 条订单", true);

            } else {
                // 拒绝改派
                for (Reassign reassign : reassignList) {
                    reassign.setConfirmStatus(3);
                    reassign.setConfirmTime(new Date());
                    int updateCount = this.baseMapper.update(reassign,
                        new EntityWrapper<Reassign>()
                            .eq("id", reassign.getId())
                            .eq("confirmStatus", 1)
                    );

                    if (updateCount == 0) {
                        return reassignResponse("改派申请已被处理: " + reassign.getId(), false);
                    }
                    restoreCrossCityOrderAfterReassignEnd(reassign);
                }

                // 通知原司机被拒绝（只通知一次）
                if (!reassignList.isEmpty()) {
                    pushReassignRejected(reassignList.get(0));
                }

                return reassignResponse("已拒绝改派，共 " + reassignList.size() + " 条订单", true);
            }

        } catch (Exception e) {
            e.printStackTrace();
            return reassignResponse("操作失败：" + e.getMessage(), false);
        }
    }

    private ResultUtil<Boolean> reassignResponse(String message, boolean success) {
        return ResultUtil.success(message, success);
    }

    @Override
    public List<Map<String, Object>> queryPendingReassigns(Integer driverId) {
        try {
            List<Reassign> list = this.selectList(
                new EntityWrapper<Reassign>()
                    .eq("nowDriverId", driverId)
                    .eq("needConfirm", 2)
                    .eq("confirmStatus", 1)
                    .gt("expireTime", new Date()) // 未超时
                    .orderBy("insertTime", false)
            );

            List<Map<String, Object>> result = new ArrayList<>();
            for (Reassign reassign : list) {
                Map<String, Object> data = new HashMap<>();
                data.put("reassignId", reassign.getId());
                data.put("orderId", reassign.getOrderId());
                data.put("orderType", reassign.getOrderType());
                data.put("expireTime", reassign.getExpireTime());
                data.put("reason", reassign.getReason());
                data.put("insertTime", reassign.getInsertTime());

                // 获取订单详情
                if (reassign.getOrderType() == 3) {
                    OrderCrossCity order = orderCrossCityService.selectById(reassign.getOrderId());
                    if (order != null) {
                        data.put("startAddress", order.getStartAddress());
                        data.put("endAddress", order.getEndAddress());
                        data.put("peopleNumber", order.getPeopleNumber());
                        data.put("travelTime", order.getTravelTime());
                        data.put("orderMoney", order.getOrderMoney());
                    }
                }

                // 获取原司机信息
                Driver originalDriver = driverService.selectById(reassign.getOriginalDriverId());
                if (originalDriver != null) {
                    data.put("originalDriverName", originalDriver.getName());
                    data.put("originalDriverPhone", originalDriver.getPhone());
                }

                result.add(data);
            }

            return result;
        } catch (Exception e) {
            e.printStackTrace();
            return new ArrayList<>();
        }
    }

}