feat: 用户下单推送给司机，指派模式不需要枪单

yanderong

2026-07-10 4deaaf2d80772ab1bcfc253a9012f07b7498a95f

feat: 用户下单推送给司机，指派模式不需要枪单

 ManagementYKDTravel/guns-admin/src/main/webapp/WEB-INF/view/system/tDriverPromotionActivity/tDriverPromotionActivity_add.html

@@ -200,6 +200,7 @@
    });
    laydate.render({
        elem: '#time'
        ,trigger:'click'
        ,range: true
    });
    function provinceChange(e) {

 ManagementYKDTravel/guns-admin/src/main/webapp/WEB-INF/view/system/tDriverPromotionActivity/tDriverPromotionActivity_edit.html

@@ -100,8 +100,9 @@

        // 初始化活动时间
        laydate.render({
            elem: '#time',
            range: true
            elem: '#time'
            ,trigger:'click'
            ,range: true
        });

        // 回显关联业务

 UserYKDTravel/guns-admin/src/main/java/com/stylefeng/guns/modular/specialTrain/server/impl/OrderPrivateCarServiceImpl.java

@@ -26,6 +26,7 @@
import com.stylefeng.guns.modular.taxi.service.IOrderTaxiService;
import com.stylefeng.guns.modular.taxi.service.IPaymentRecordService;
import com.stylefeng.guns.modular.taxi.service.ITransactionDetailsService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
@@ -54,7 +55,7 @@
import java.util.concurrent.locks.ReentrantLock;
import java.util.stream.Collectors;


@Slf4j
@Service
public class OrderPrivateCarServiceImpl extends ServiceImpl<OrderPrivateCarMapper, OrderPrivateCar> implements IOrderPrivateCarService {
    
@@ -617,6 +618,7 @@
    @Override
    public ResultUtil<BaseWarpper> saveOrderPrivateCars(String serverCarModel, Date travelTime, Integer reservation, Integer instead, String placementLon, String placementLat, String startLon, String startLat, String startAddress, String endLon,
                                                        String endLat, String endAddress, String name, String phone, Integer orderSource, Integer driverId, Integer uid, Integer peopleNum, Integer callType) throws Exception {
        log.info("批量订单-服务车型请求参数为：{}，订单来源：{}", serverCarModel, orderSource);
        BaseWarpper baseWarpper = new BaseWarpper();
        String key = "saveOrderPrivateCar:" + uid;
        Boolean hasKey = redisTemplate.hasKey(key);
@@ -807,6 +809,8 @@

                //判断独享，一口价，拼车
                JSONArray jsonArray = JSON.parseArray(serverCarModel);
                log.info("批量订单-服务车型数据为：{}", serverCarModel);

                this.insert(orderPrivateCar);

                if (orderPrivateCar.getState() != 7) {
@@ -823,11 +827,13 @@
                            orderTaxi.setStartLat(orderPrivateCar.getStartLat());
                            orderTaxiService.pushOrder(orderTaxi, 3);
                        }
						
                        log.info("批量订单-推单操作类型为：{}", rideType);
                        if (rideType != 3) {
                            log.info("推单操作-独享");
                            //推单操作-独享
                            this.pushOrder(orderPrivateCar.getId(), rideType, serverCarModelId, orderPrivateCar.getStartLon(), orderPrivateCar.getStartLat());
                        } else if (quickCall) {
                            log.info("快捷叫车不参与拼车合单，拼车车型也按普通派单处理");
                            // 快捷叫车不参与拼车合单，拼车车型也按普通派单处理。
                            this.pushOrder(orderPrivateCar.getId(), rideType, serverCarModelId, orderPrivateCar.getStartLon(), orderPrivateCar.getStartLat());
                        } else {
@@ -868,6 +874,7 @@
                                }
                            }
                            if (orderPrivateCar1 == null) {
                                log.info("推单操作-orderPrivateCar1为空");
                                this.pushOrder(orderPrivateCar.getId(), rideType, serverCarModelId, orderPrivateCar.getStartLon(), orderPrivateCar.getStartLat());
                            } else {
                                Driver driver = driverService.selectById(orderPrivateCar1.getDriverId());
@@ -3510,6 +3517,7 @@
            @Override
            public void run() {
                try {
                    log.info("一键叫车推送订单------开始");
                    Integer orderType = rideType == 1 ? 1 : rideType == 2 ? 9 : 8;
                    orderIds.add(id);//添加记录，防止调用接口重复提醒无人接单
                    String vehicle = (String) redisTemplate.opsForValue().get("VEHICLE");
@@ -3520,114 +3528,11 @@
                    OpenCity openCity = openCityService.openCity1(startLon.toString(), startLat.toString());
                    OrderPrivateCar priorityOrder = orderPrivateCarMapper.selectById(id);
                    boolean priorityDispatch = isNewUserPriorityDispatch(openCity, priorityOrder == null ? null : priorityOrder.getUserId());
                    List<PushOrder> querys = pushOrderService.querys(null, 1, openCity.getId());//获取需要推送的次数
                    //整轮派单结束，若无司机接单，系统自动增加派单5轮，若增加5轮后任无司机接单，则系统结束派单，乘客端显示无司机接单、是否再次打车
                    int num = 0;
                    for (int j = 0; j < 6; j++) {
                        Boolean push = false;
                        for (int i = 1; i <= querys.size(); i++) {
                            num++;
                            OrderPrivateCar orderPrivateCar = orderPrivateCarMapper.selectById(id);
                            if (null == orderPrivateCar || orderPrivateCar.getState() > 1) {
                                push = true;
                                break;
                            }
                            int finalI = i;
                            PushOrder pushOrder = querys.stream().filter(s -> s.getType() == (finalI <= 3 ? finalI : 3)).findFirst().orElse(null);
                            System.out.println("pushOrder2:" + pushOrder);
                            if (orderPrivateCar.getState() > 1) {
                                push = true;
                                break;
                            }
                            //获取空闲司机
                            List<Driver> list = driverService.queryIdleDriver(orderType, serverCarModelId, startLon, startLat, pushOrder.getPushDistance(), null);//所有附近空闲司机
                            //随机排序
                            if (priorityDispatch) {
                                sortDriversForNewUserPriority(list);
                            } else {
                                Collections.shuffle(list);
                            }
                            if (list.size() > 0) {
                                double driverProportion = pushOrder.getDriverProportion() / 100;//推送占比计算成小数
                                int lastIndex = Double.valueOf(list.size() * driverProportion).intValue();//计算占比转成整数（下标截取）
                                lastIndex = lastIndex == 0 ? list.size() : lastIndex;
                                list = list.subList(0, lastIndex);//获取空闲司机中占比数据
                                for (Driver driver : list) {//开始进行推送
                                    boolean bo = false;
                                    for (Integer integer : integers) {
                                        if (integer.compareTo(driver.getId()) == 0) {
                                            bo = true;
                                            break;
                                        }
                                    }
                                    if (bo) {
                                        continue;
                                    }
                                    pushUtil.pushOrderState(2, driver.getId(), id, 1, 1, pushOrder.getPushTime());
                                }
                            }
                            Thread.sleep(pushOrder.getPushTime() * 1000);//设置等待时间
                            OrderPrivateCar orderPrivateCar1 = orderPrivateCarMapper.selectById(orderPrivateCar.getId());
                            if(null == orderPrivateCar1){
                                break;
                            }
                            Integer state =orderPrivateCar1.getState();
                            if (state > 1) {
                                orderIds.remove(orderPrivateCar.getId());
                                push = true;
                                break;
                            }
                            if (num == 18) {
                                ResultUtil refundResult = handlePrivateCarPrepayCancelRefund(orderPrivateCar1, "无司机接单", "无司机接单", orderPrivateCar1.getUserId());
                                if (refundResult == null) {
                                    orderPrivateCar1.setState(10);
                                    orderPrivateCarMapper.updateById(orderPrivateCar1);
                                }
                                pushUtil.pushEndPush(1, orderPrivateCar.getUserId(), orderPrivateCar.getId(), 1, 1);
                                orderIds.remove(orderPrivateCar.getId());
                            }
                        }
                        if(push){
                            break;
                        }
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
	
    /**
     * 推送抢单数据
     *
     * @param orderPrivateCar
     * @throws Exception
     */
    public void pushOrder(OrderPrivateCar orderPrivateCar) throws Exception {


        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("推单推单推单！！");
                    Integer id = orderPrivateCar.getId();
                    Integer orderType = orderPrivateCar.getRideType() == 1 ? 1 : orderPrivateCar.getRideType() == 2 ? 9 : 8;
                    orderIds.add(orderPrivateCar.getId());//添加记录，防止调用接口重复提醒无人接单
                    String vehicle = (String) redisTemplate.opsForValue().get("VEHICLE");
                    List<Integer> integers = new ArrayList<>();
                    if (ToolUtil.isNotEmpty(vehicle)) {
                        integers = JSON.parseArray(vehicle).toJavaList(Integer.class);
                    }
                    OpenCity openCity = openCityService.openCity1(orderPrivateCar.getStartLon().toString(), orderPrivateCar.getStartLat().toString());

                    // 判断是否为派单模式
                    boolean priorityDispatch = isNewUserPriorityDispatch(openCity, orderPrivateCar.getUserId());
                    TSysPushType sysPushType = tSysPushTypeService.selectOne(new EntityWrapper<TSysPushType>().eq("openCityId", openCity.getId()));
                    if(sysPushType!=null && sysPushType.getPushType()==2){
                        System.out.println( "派单模式");
                        log.info( "专车订单-派单模式-----开始---");
                        OrderPrivateCar orderPrivateCar = orderPrivateCarMapper.selectById(id);
                        if (null != orderPrivateCar && orderPrivateCar.getState() == 1) {
                            // 固定5公里进行派单
@@ -3735,8 +3640,226 @@
                        }

                    }else {
                        System.out.println( "推单模式");
                        log.info( "专车订单-推单模式-----开始---");
                        List<PushOrder> querys = pushOrderService.querys(null, 1, openCity.getId());//获取需要推送的次数
                        //整轮派单结束，若无司机接单，系统自动增加派单5轮，若增加5轮后任无司机接单，则系统结束派单，乘客端显示无司机接单、是否再次打车
                        int num = 0;
                        for (int j = 0; j < 6; j++) {
                            Boolean push = false;
                            for (int i = 1; i <= querys.size(); i++) {
                                num++;
                                OrderPrivateCar orderPrivateCar = orderPrivateCarMapper.selectById(id);
                                if (null == orderPrivateCar || orderPrivateCar.getState() > 1) {
                                    push = true;
                                    break;
                                }
                                int finalI = i;
                                PushOrder pushOrder = querys.stream().filter(s -> s.getType() == (finalI <= 3 ? finalI : 3)).findFirst().orElse(null);
                                System.out.println("pushOrder2:" + pushOrder);
                                if (orderPrivateCar.getState() > 1) {
                                    push = true;
                                    break;
                                }
                                //获取空闲司机
                                List<Driver> list = driverService.queryIdleDriver(orderType, serverCarModelId, startLon, startLat, pushOrder.getPushDistance(), null);//所有附近空闲司机
                                //随机排序
                                if (priorityDispatch) {
                                    sortDriversForNewUserPriority(list);
                                } else {
                                    Collections.shuffle(list);
                                }
                                if (list.size() > 0) {
                                    double driverProportion = pushOrder.getDriverProportion() / 100;//推送占比计算成小数
                                    int lastIndex = Double.valueOf(list.size() * driverProportion).intValue();//计算占比转成整数（下标截取）
                                    lastIndex = lastIndex == 0 ? list.size() : lastIndex;
                                    list = list.subList(0, lastIndex);//获取空闲司机中占比数据
                                    for (Driver driver : list) {//开始进行推送
                                        boolean bo = false;
                                        for (Integer integer : integers) {
                                            if (integer.compareTo(driver.getId()) == 0) {
                                                bo = true;
                                                break;
                                            }
                                        }
                                        if (bo) {
                                            continue;
                                        }
                                        pushUtil.pushOrderState(2, driver.getId(), id, 1, 1, pushOrder.getPushTime());
                                    }
                                }
                                Thread.sleep(pushOrder.getPushTime() * 1000);//设置等待时间
                                OrderPrivateCar orderPrivateCar1 = orderPrivateCarMapper.selectById(orderPrivateCar.getId());
                                if(null == orderPrivateCar1){
                                    break;
                                }
                                Integer state =orderPrivateCar1.getState();
                                if (state > 1) {
                                    orderIds.remove(orderPrivateCar.getId());
                                    push = true;
                                    break;
                                }
                                if (num == 18) {
                                    ResultUtil refundResult = handlePrivateCarPrepayCancelRefund(orderPrivateCar1, "无司机接单", "无司机接单", orderPrivateCar1.getUserId());
                                    if (refundResult == null) {
                                        orderPrivateCar1.setState(10);
                                        orderPrivateCarMapper.updateById(orderPrivateCar1);
                                    }
                                    pushUtil.pushEndPush(1, orderPrivateCar.getUserId(), orderPrivateCar.getId(), 1, 1);
                                    orderIds.remove(orderPrivateCar.getId());
                                }
                            }
                            if(push){
                                break;
                            }
                        }
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
	
    /**
     * 推送抢单数据
     *
     * @param orderPrivateCar
     * @throws Exception
     */
    public void pushOrder(OrderPrivateCar orderPrivateCar) throws Exception {


        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    log.info("专车订单-推送抢单数据----开始-----！");
                    Integer id = orderPrivateCar.getId();
                    Integer orderType = orderPrivateCar.getRideType() == 1 ? 1 : orderPrivateCar.getRideType() == 2 ? 9 : 8;
                    orderIds.add(orderPrivateCar.getId());//添加记录，防止调用接口重复提醒无人接单
                    String vehicle = (String) redisTemplate.opsForValue().get("VEHICLE");
                    List<Integer> integers = new ArrayList<>();
                    if (ToolUtil.isNotEmpty(vehicle)) {
                        integers = JSON.parseArray(vehicle).toJavaList(Integer.class);
                    }
                    OpenCity openCity = openCityService.openCity1(orderPrivateCar.getStartLon().toString(), orderPrivateCar.getStartLat().toString());

                    // 判断是否为派单模式
                    boolean priorityDispatch = isNewUserPriorityDispatch(openCity, orderPrivateCar.getUserId());
                    TSysPushType sysPushType = tSysPushTypeService.selectOne(new EntityWrapper<TSysPushType>().eq("openCityId", openCity.getId()));

                    log.info("专车订单-推送抢单数据，订单id为：{}, 位置为：{}, 设置的推单模式为：{}", id, orderPrivateCar.getStartLon().toString()+"_"+orderPrivateCar.getStartLat().toString(), JSON.toJSONString(sysPushType));
                    if(sysPushType!=null && sysPushType.getPushType()==2){
                        log.info( "专车订单-派单模式-----开始---");
                        OrderPrivateCar orderPrivateCar = orderPrivateCarMapper.selectById(id);
                        if (null != orderPrivateCar && orderPrivateCar.getState() == 1) {
                            // 固定5公里进行派单
                            List<Driver> list = driverService.queryIdleDriver(orderType, orderPrivateCar.getServerCarModelId(), orderPrivateCar.getStartLon(), orderPrivateCar.getStartLat(), 5.0, null);//所有附近空闲司机
                            if (list.size() > 0) {
                                Driver driver1 = selectDispatchDriver(list, priorityDispatch);
                                if(orderPrivateCar.getType() == 3){
                                    //批量订单
                                    CarService carService = new CarService();
                                    carService.setCarId(driver1.getCarId());
                                    carService.setType(1);
                                    CarService carService1 = carServiceMapper.selectOne(carService);
                                    orderPrivateCar.setServerCarModelId(carService1.getServerCarModelId());
                                    //1=独享，2=一口价
                                    String serverCarModel = orderPrivateCar.getServerCarModel();
                                    JSONArray jsonArray = JSON.parseArray(serverCarModel);
                                    Integer rideType1 = null;
                                    for (int i = 0; i < jsonArray.size(); i++) {
                                        JSONObject jsonObject = jsonArray.getJSONObject(i);
                                        Integer serverCarModelId = jsonObject.getInteger("serverCarModelId");
                                        Integer rideType = jsonObject.getInteger("rideType");
                                        if(serverCarModelId.equals(carService1.getServerCarModelId())){
                                            rideType1 = rideType;
                                            if(rideType == 1){
                                                break;
                                            }
                                        }
                                    }
                                    orderPrivateCar.setRideType(rideType1);
                                }
                                orderPrivateCar.setDriverId(driver1.getId());
                                orderPrivateCar.setCarId(driver1.getCarId());
                                orderPrivateCar.setCompanyId(driver1.getFranchiseeId() != null && driver1.getFranchiseeId() != 0 ? driver1.getFranchiseeId() : (
                                        driver1.getCompanyId() != null && driver1.getCompanyId() != 0 ? driver1.getCompanyId() : 1));
                                orderPrivateCar.setState(2);
                                orderPrivateCar.setSnatchOrderTime(new Date());

                                // 是否推广订单
                                Integer promotion = isPromotion(orderPrivateCar.getUserId(), driver1.getPlaceOfEmployment());
                                if(null != promotion){
                                    orderPrivateCar.setPromotion(2);
                                    driver1 = driverService.selectById(promotion);
                                    orderPrivateCar.setPromotionUser(driver1.getName());
                                    orderPrivateCar.setPromotionPhone(driver1.getPhone());
                                    orderPrivateCar.setPromotionDriverId(promotion);
                                }else{
                                    orderPrivateCar.setPromotion(1);
                                }
                                orderPrivateCarMapper.updateById(orderPrivateCar);

                                //如果是预约单，则不修改司机为服务中
                                if(orderPrivateCar.getOrderType() != 2 || (orderPrivateCar.getOrderType() == 2 && orderPrivateCar.getTravelTime().getTime() < System.currentTimeMillis() + 600000)){
                                    //修改司机为服务中
                                    driver1.setState(3);
                                    driverService.updateById(driver1);
                                }

                                //推送相关代码------------------start----------------
                                new Thread(new Runnable() {
                                    @Override
                                    public void run() {
                                            pushUtil.pushOrderState(1, orderPrivateCar.getUserId(), orderPrivateCar.getId(), 1, orderPrivateCar.getState(),0);
                                            pushUtil.pushOrderState(2, orderPrivateCar.getDriverId(), orderPrivateCar.getId(), 1, orderPrivateCar.getState(),0);
                                            if(orderPrivateCar.getType() == 2){
                                                pushUtil.pushFerryOrderState(1, orderPrivateCar.getUserId(), orderPrivateCar.getId(), 1, 2);
                                            }

                                    }
                                }).start();

                                new Thread(new Runnable() {
                                    @Override
                                    public void run() {
                                        pushUtil.pushDriverPosition(orderPrivateCar.getId(), 1);
                                    }
                                }).start();

                                systemNoticeService.addSystemNotice(2, "已为您派得快车订单，请及时联系客户！", orderPrivateCar.getDriverId(), 1);
                                systemNoticeService.addSystemNotice(1, "您的订单已指派给" + driver1.getName().substring(0, 1) + "师傅，请保持电话畅通！", orderPrivateCar.getUserId(), 1);

                                if(pushMinistryOfTransport){
                                    new Thread(new Runnable() {
                                        @Override
                                        public void run() {
                                            //上传数据
                                            pushMinistryOfTransportUtil.orderCreate(orderPrivateCar.getId());
                                            pushMinistryOfTransportUtil.orderMatch(orderPrivateCar.getId());
                                        }
                                    }).start();
                                }


                            }else {
                                // 没找到车辆
                                Thread.sleep(5000);
                                ResultUtil refundResult = handlePrivateCarPrepayCancelRefund(orderPrivateCar, "无司机接单", "无司机接单", orderPrivateCar.getUserId());
                                if (refundResult == null) {
                                    orderPrivateCar.setState(10);
                                    orderPrivateCarMapper.updateById(orderPrivateCar);
                                }
                                pushUtil.pushEndPush(1, orderPrivateCar.getUserId(), orderPrivateCar.getId(), 1, 10);
                            }


                        }

                    }else {
                        log.info("专车订单-推单模式--------开始");
                        List<PushOrder> querys = pushOrderService.querys(null, 1, openCity.getId());//获取需要推送的次数
                        for (int i = 1; i <= querys.size() + 15; i++) {
                            OrderPrivateCar orderPrivateCar = orderPrivateCarMapper.selectById(id);