添加重复下单屏蔽功能

Pu Zhibing

13 小时以前 aad8398747479ec7fbf3d40e9d6207c3d6e68f78

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

@@ -25,6 +25,8 @@
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 org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpEntity;
@@ -35,6 +37,7 @@
import org.springframework.util.CollectionUtils;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.util.StringUtils;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
@@ -54,6 +57,8 @@

@Service
public class OrderPrivateCarServiceImpl extends ServiceImpl<OrderPrivateCarMapper, OrderPrivateCar> implements IOrderPrivateCarService {

    Logger logger = LoggerFactory.getLogger(OrderPrivateCarServiceImpl.class);

    @Resource
    private OrderPrivateCarMapper orderPrivateCarMapper;
@@ -153,6 +158,9 @@

    @Autowired
    private GDMapElectricFenceUtil gdMapElectricFenceUtil;
    
    @Autowired
    private GeodesyUtil geodesyUtil;

    @Autowired
    private IOrderPositionService orderPositionService;
@@ -187,6 +195,12 @@
    @Value("${pushMinistryOfTransport}")
    private boolean pushMinistryOfTransport;

    @Autowired
    private IAppOperationLogService appOperationLogService;

    @Resource
    private DriverMapper driverMapper;



    /**
@@ -207,316 +221,328 @@
     * @throws Exception
     */
    @Override
    public synchronized ResultUtil<BaseWarpper> saveOrderPrivateCar(Integer serverCarModelId, 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 type, Integer uid,
                                                                    BigDecimal estimatedPrice,String cityCode,Integer carIndex) throws Exception {

        //如果出行时间大于当前10分钟则默认为预约单
        if(travelTime.getTime() > (System.currentTimeMillis() + 600000)){
            reservation = 2;
    public ResultUtil<BaseWarpper> saveOrderPrivateCar(Integer serverCarModelId, 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 type, Integer uid,
                                                       BigDecimal estimatedPrice, String cityCode, Integer carIndex) throws Exception {
        String k = "addOrder" + uid;
        boolean b = redisUtil.hasKey(k);
        if(b){
            return ResultUtil.error("不能重复下单");
        }
        redisUtil.setStrValue(k, UUIDUtil.getRandomCode(), 30);

        /**
         * 1.下了即时单就不能下预约单和即时单
         * 2.下了预约单和再下一张即时单不能再下预约单
         */
        List<OrderPrivateCar> orderPrivateCars = orderPrivateCarMapper.queryByState(uid, 1, 1, 1, 2, 3, 4, 5, 6,  11);
        if(orderPrivateCars.size() > 0){
            return ResultUtil.error("有未完成的订单");
        }
        List<OrderTaxi> list = orderTaxiMapper.queryByState_(uid, 1, 1, 1, 2, 3, 4, 5, 6, 11);
        if(list.size() > 0){
            return ResultUtil.error("有未完成的订单");
        }

        orderPrivateCars = orderPrivateCarMapper.queryByState(uid, 2, 1, 1, 2, 3, 4, 5, 6,  11);
        if(orderPrivateCars.size() > 0 && reservation == 2){
            return ResultUtil.error("有未完成的订单");
        }

        orderPrivateCars = orderPrivateCarMapper.queryByState(uid, 1, 1, 7,12);
        if(orderPrivateCars.size() > 0){
            BaseWarpper baseWarpper = new BaseWarpper();
            baseWarpper.setState(7);
            baseWarpper.setId(orderPrivateCars.get(0).getId());
            return ResultUtil.success(baseWarpper);
        }


        list = orderTaxiMapper.queryByState_(uid, 2, 1, 1, 2, 3, 4, 5, 6, 11);
        if(list.size() > 0 && reservation == 2){
            return ResultUtil.error("有未完成的订单");
        }

        startAddress = startAddress.replaceAll("& #40;", "(");
        startAddress = startAddress.replaceAll("& #41;", ")");
        endAddress = endAddress.replaceAll("& #40;", "(");
        endAddress = endAddress.replaceAll("& #41;", ")");
        if((orderSource == 1 || orderSource == 3) && null == serverCarModelId){
            return ResultUtil.error("请选择服务车型");
        }

        OrderPrivateCar orderPrivateCar = new OrderPrivateCar();
        orderPrivateCar.setType(type);
        orderPrivateCar.setUserId(uid);
        orderPrivateCar.setServerCarModelId(serverCarModelId);
        orderPrivateCar.setOrderNum(this.getOrderNum());
        orderPrivateCar.setPlacementLon(Double.valueOf(placementLon));
        orderPrivateCar.setPlacementLat(Double.valueOf(placementLat));
        Map<String, String> geocode = gdMapGeocodingUtil.geocode(placementLon, placementLat);
        orderPrivateCar.setPlacementAddress(geocode.get("address"));
        orderPrivateCar.setStartLon(Double.valueOf(startLon));
        orderPrivateCar.setStartLat(Double.valueOf(startLat));
        orderPrivateCar.setStartAddress(startAddress);
        orderPrivateCar.setEndLon(Double.valueOf(endLon));
        orderPrivateCar.setEndLat(Double.valueOf(endLat));
        orderPrivateCar.setEndAddress(endAddress);
        orderPrivateCar.setSubstitute(instead);
        orderPrivateCar.setPassengers(name);
        orderPrivateCar.setPassengersPhone(phone);
        if(instead == 0 || ToolUtil.isEmpty(orderPrivateCar.getPassengers())){
            UserInfo userInfo = userInfoService.selectById(uid);
            if(ToolUtil.isEmpty(userInfo.getPhone())){
                return ResultUtil.error("请先绑定手机号码");
            }
            orderPrivateCar.setPassengers(userInfo.getName());
            orderPrivateCar.setPassengersPhone(userInfo.getPhone());
        }
        orderPrivateCar.setState(1);
        orderPrivateCar.setInsertTime(new Date());
        orderPrivateCar.setTravelTime(travelTime);
        orderPrivateCar.setOrderType(reservation);
        orderPrivateCar.setOrderSource(orderSource);
        if(orderSource == 2){//扫码下单
            Driver driver = driverService.selectById(driverId);
            if(null == driver){
                return ResultUtil.error("司机信息有误，无法完成下单");
            }
            if(driver.getAuthState() == 1){
                return ResultUtil.error("司机信息还未完成审核，无法完成下单");
            }
            if(driver.getAuthState() == 3){
                return ResultUtil.error("司机账户已被冻结，无法提供服务");
            }
            if(driver.getAuthState() == 4){
                return ResultUtil.error("司机信息未通过审核，无法提供服务");
            }
            if(driver.getState() == 1){
                return ResultUtil.error("司机还未上线，无法提供服务");
            }
            if(driver.getState() == 3){
                return ResultUtil.error("司机正在服务中，无法提供服务");
            }
            List<DriverService> query = driverServiceService.query(driverId, 1);
            if(query.size() == 0){
                return ResultUtil.error("该司机不能服务此业务");
        try {
            long timeMillis = System.currentTimeMillis();
            //如果出行时间大于当前10分钟则默认为预约单
            if(travelTime.getTime() > (System.currentTimeMillis() + 600000)){
                reservation = 2;
            }

            orderPrivateCar.setDriverId(driverId);
            orderPrivateCar.setCompanyId(driver.getFranchiseeId() != null && driver.getFranchiseeId() != 0 ? driver.getFranchiseeId() : (
                    driver.getCompanyId() != null && driver.getCompanyId() != 0 ? driver.getCompanyId() : 1));
            orderPrivateCar.setState(2);
            orderPrivateCar.setCarId(driver.getCarId());
            CarService query1 = carServiceMapper.query(1, driver.getCarId());
            orderPrivateCar.setServerCarModelId(query1.getServerCarModelId());
            orderPrivateCar.setSnatchOrderTime(new Date());
            driver.setState(3);
            driverService.updateById(driver);
        }
        // 查询城市的订单额度
        OpenCity openCity = openCityService.selectOne(new EntityWrapper<OpenCity>()
                .eq("code", cityCode)
                .ne("flag", 3)
                .orderBy("orderMagnitude", false)
                .last("LIMIT 1"));
        if(Objects.isNull(openCity)){
            String city = cityCode.substring(0, 4) + "00";
            openCity = openCityService.selectOne(new EntityWrapper<OpenCity>()
                    .eq("code", city)
            /**
             * 1.下了即时单就不能下预约单和即时单
             * 2.下了预约单和再下一张即时单不能再下预约单
             */
            List<OrderPrivateCar> orderPrivateCars = orderPrivateCarMapper.queryByState(uid, 1, 1, 1, 2, 3, 4, 5, 6,  11);
            if(orderPrivateCars.size() > 0){
                return ResultUtil.error("有未完成的订单");
            }
//        List<OrderTaxi> list = orderTaxiMapper.queryByState_(uid, 1, 1, 1, 2, 3, 4, 5, 6, 11);
//        if(list.size() > 0){
//            return ResultUtil.error("有未完成的订单");
//        }

            orderPrivateCars = orderPrivateCarMapper.queryByState(uid, 2, 1, 1, 2, 3, 4, 5, 6,  11);
            if(orderPrivateCars.size() > 0 && reservation == 2){
                return ResultUtil.error("有未完成的订单");
            }

            orderPrivateCars = orderPrivateCarMapper.queryByState(uid, 1, 1, 7,12);
            if(orderPrivateCars.size() > 0){
                BaseWarpper baseWarpper = new BaseWarpper();
                baseWarpper.setState(7);
                baseWarpper.setId(orderPrivateCars.get(0).getId());
                return ResultUtil.success(baseWarpper);
            }


//        list = orderTaxiMapper.queryByState_(uid, 2, 1, 1, 2, 3, 4, 5, 6, 11);
//        if(list.size() > 0 && reservation == 2){
//            return ResultUtil.error("有未完成的订单");
//        }

            startAddress = startAddress.replaceAll("& #40;", "(");
            startAddress = startAddress.replaceAll("& #41;", ")");
            endAddress = endAddress.replaceAll("& #40;", "(");
            endAddress = endAddress.replaceAll("& #41;", ")");
            if((orderSource == 1 || orderSource == 3) && null == serverCarModelId){
                return ResultUtil.error("请选择服务车型");
            }

            OrderPrivateCar orderPrivateCar = new OrderPrivateCar();
            orderPrivateCar.setType(type);
            orderPrivateCar.setUserId(uid);
            orderPrivateCar.setServerCarModelId(serverCarModelId);
            orderPrivateCar.setOrderNum(this.getOrderNum());
            orderPrivateCar.setPlacementLon(Double.valueOf(placementLon));
            orderPrivateCar.setPlacementLat(Double.valueOf(placementLat));
            Map<String, String> geocode = gdMapGeocodingUtil.geocode(placementLon, placementLat);
            orderPrivateCar.setPlacementAddress(geocode.get("address"));
            orderPrivateCar.setStartLon(Double.valueOf(startLon));
            orderPrivateCar.setStartLat(Double.valueOf(startLat));
            orderPrivateCar.setStartAddress(startAddress);
            orderPrivateCar.setEndLon(Double.valueOf(endLon));
            orderPrivateCar.setEndLat(Double.valueOf(endLat));
            orderPrivateCar.setEndAddress(endAddress);
            orderPrivateCar.setSubstitute(instead);
            orderPrivateCar.setPassengers(name);
            orderPrivateCar.setPassengersPhone(phone);
            if(instead == 0 || ToolUtil.isEmpty(orderPrivateCar.getPassengers())){
                UserInfo userInfo = userInfoService.selectById(uid);
                if(ToolUtil.isEmpty(userInfo.getPhone())){
                    return ResultUtil.error("请先绑定手机号码");
                }
                orderPrivateCar.setPassengers(userInfo.getName());
                orderPrivateCar.setPassengersPhone(userInfo.getPhone());
            }
            orderPrivateCar.setState(1);
            orderPrivateCar.setInsertTime(new Date());
            orderPrivateCar.setTravelTime(travelTime);
            orderPrivateCar.setOrderType(reservation);
            orderPrivateCar.setOrderSource(orderSource);
            Driver driver2 = driverService.selectById(driverId);
            if(orderSource == 2){//扫码下单
                if(null == driver2){
                    return ResultUtil.error("司机信息有误，无法完成下单");
                }
                if(driver2.getAuthState() == 1){
                    return ResultUtil.error("司机信息还未完成审核，无法完成下单");
                }
                if(driver2.getAuthState() == 3){
                    return ResultUtil.error("司机账户已被冻结，无法提供服务");
                }
                if(driver2.getAuthState() == 4){
                    return ResultUtil.error("司机信息未通过审核，无法提供服务");
                }
                if(driver2.getState() == 1){
                    return ResultUtil.error("司机还未上线，无法提供服务");
                }
                if(driver2.getState() == 3){
                    return ResultUtil.error("司机正在服务中，无法提供服务");
                }
                List<DriverService> query = driverServiceService.query(driverId, 1);
                if(query.size() == 0){
                    return ResultUtil.error("该司机不能服务此业务");
                }

                orderPrivateCar.setDriverId(driverId);
                orderPrivateCar.setCompanyId(driver2.getFranchiseeId() != null && driver2.getFranchiseeId() != 0 ? driver2.getFranchiseeId() : (
                        driver2.getCompanyId() != null && driver2.getCompanyId() != 0 ? driver2.getCompanyId() : 1));
                orderPrivateCar.setState(2);
                orderPrivateCar.setCarId(driver2.getCarId());
                CarService query1 = carServiceMapper.query(1, driver2.getCarId());
                orderPrivateCar.setServerCarModelId(query1.getServerCarModelId());
                orderPrivateCar.setSnatchOrderTime(new Date());
                driver2.setState(3);
                driverService.updateById(driver2);
                serverCarModelId = query1.getServerCarModelId();
            }
            long timeMillis1 = System.currentTimeMillis();
            logger.info("第一段用时：" + (timeMillis1 - timeMillis));
            timeMillis = timeMillis1;
            // 查询城市的订单额度
            OpenCity openCity = openCityService.selectOne(new EntityWrapper<OpenCity>()
                    .eq("code", cityCode)
                    .ne("flag", 3)
                    .orderBy("orderMagnitude", false)
                    .last("LIMIT 1"));
        }
            if(Objects.isNull(openCity)){
                String city = cityCode.substring(0, 4) + "00";
                openCity = openCityService.selectOne(new EntityWrapper<OpenCity>()
                        .eq("code", city)
                        .ne("flag", 3)
                        .orderBy("orderMagnitude", false)
                        .last("LIMIT 1"));
            }

        // 查询预估价格
        ResultUtil<List<ServerCarModelWarpper>> listResultUtil = serverCarModelService.queryServerCarModel(startLon + "," + startLat, endLon + "," + endLat, 1);
        List<ServerCarModelWarpper> data = listResultUtil.getData();
        data = data.stream().filter(e -> serverCarModelId.equals(e.getId())).sorted(Comparator.comparing(ServerCarModelWarpper::getAmount)).collect(Collectors.toList());
        if(Objects.nonNull(openCity) && !CollectionUtils.isEmpty(data) && BigDecimal.valueOf(data.get(0).getAmount()).compareTo(openCity.getOrderMagnitude()) > 0){
            orderPrivateCar.setIsReassign(1);
            orderPrivateCar.setIsDelete(1);
            orderPrivateCar.setState(7);
            if(orderSource == 2){
                orderPrivateCar.setOrderMoney(data.get(0).getAmount());
                orderPrivateCar.setEstimatedPrice(data.get(0).getAmount());
            // 查询预估价格
            ResultUtil<ServerCarModelWarpper> listResultUtil = serverCarModelService.queryServerCarModel1(serverCarModelId, startLon + "," + startLat, endLon + "," + endLat, 1);
            if(200 != listResultUtil.getCode()){
                return ResultUtil.error(listResultUtil.getMsg());
            }
            ServerCarModelWarpper data = listResultUtil.getData();
            if(Objects.nonNull(openCity) && BigDecimal.valueOf(data.getAmount()).compareTo(openCity.getOrderMagnitude()) > 0){
                orderPrivateCar.setIsReassign(1);
                orderPrivateCar.setIsDelete(1);
                orderPrivateCar.setState(7);
                orderPrivateCar.setOrderMoney(data.getAmount());
                orderPrivateCar.setEstimatedPrice(data.getAmount());
                orderPrivateCar.setPayMethod(0);
                this.insert(orderPrivateCar);

                appOperationLogService.addAppOperationLog(uid, "{\"type\":\"用户下单\",\"orderId\":\"" + orderPrivateCar.getId() + "\",\"orderPrivateCar\":\"" + JSON.toJSONString(orderPrivateCar) + "\"}");

                BaseWarpper baseWarpper = new BaseWarpper();
                baseWarpper.setId(orderPrivateCar.getId());
                baseWarpper.setState(orderPrivateCar.getState());
                baseWarpper.setPayMethod(0);
                baseWarpper.setAmount(orderPrivateCar.getOrderMoney());
                return ResultUtil.success(baseWarpper);
            }else {
                orderPrivateCar.setOrderMoney(data.get(carIndex).getAmount());
                orderPrivateCar.setEstimatedPrice(data.get(carIndex).getAmount());
            }
            orderPrivateCar.setPayMethod(0);
            this.insert(orderPrivateCar);
            BaseWarpper baseWarpper = new BaseWarpper();
            baseWarpper.setId(orderPrivateCar.getId());
            baseWarpper.setState(orderPrivateCar.getState());
            baseWarpper.setPayMethod(0);
            baseWarpper.setAmount(orderPrivateCar.getOrderMoney());
            return ResultUtil.success(baseWarpper);
        }else {
            if(orderSource == 2){
                orderPrivateCar.setEstimatedPrice(data.get(0).getAmount());
            }else {
                orderPrivateCar.setEstimatedPrice(data.get(carIndex).getAmount());
            }
            orderPrivateCar.setIsReassign(1);
            orderPrivateCar.setIsDelete(1);
            orderPrivateCar.setPayMethod(1);
            this.insert(orderPrivateCar);

            if(orderSource == 2){//扫码下单
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        pushUtil.pushOrderState(1, uid, orderPrivateCar.getId(), 1, 2, 0);
                        pushUtil.pushOrderState(2, orderPrivateCar.getDriverId(), orderPrivateCar.getId(), 1, 2, 0);
                        pushUtil.pushDriverPosition(orderPrivateCar.getId(), 1);
                    }
                }).start();
            }


            // TODO: 2021/5/11 修改，根据后台设定的派单范围查询范围内有无司机，将单子指派给距离最近的司机（距离相同随机取），范围内没有司机再进行推单流程
            if(orderPrivateCar.getState() == 1){
                Company query = companyCityService.query(orderPrivateCar.getStartLon().toString(), orderPrivateCar.getStartLat().toString());
                if(null == query){
                    return ResultUtil.error("起点暂未企业提供服务");
                }
                AssignOrder assignOrder = assignOrderService.selectOne(new EntityWrapper<AssignOrder>().eq("companyId", query.getId()).eq("type", 1));
                if(null != assignOrder){//配置了指派规则才处理
                    boolean lock = redisUtil.lock("order_lock", 10);
                    if(!lock){
                        int num1 = 1;
                        while (num1 <= 10){
                            Thread.sleep(3000);//等待3秒
                            lock = redisUtil.lock("order_lock", 10);
                            if(lock){
                                break;
                            }else{
                                num1++;
                            }
                orderPrivateCar.setEstimatedPrice(data.getAmount());
                orderPrivateCar.setIsReassign(1);
                orderPrivateCar.setIsDelete(1);
                orderPrivateCar.setPayMethod(1);
                this.insert(orderPrivateCar);
                appOperationLogService.addAppOperationLog(uid, "{\"type\":\"用户下单\",\"orderId\":\"" + orderPrivateCar.getId() + "\",\"orderPrivateCar\":\"" + JSON.toJSONString(orderPrivateCar) + "\"}");
                if(orderSource == 2){//扫码下单
                    new Thread(new Runnable() {
                        @Override
                        public void run() {
                            pushUtil.pushOrderState(1, uid, orderPrivateCar.getId(), 1, 2, 0);
                            pushUtil.pushOrderState(2, orderPrivateCar.getDriverId(), orderPrivateCar.getId(), 1, 2, 0);
                            pushUtil.pushDriverPosition(orderPrivateCar.getId(), 1);
                        }
                    }).start();
                }
                long timeMillis2 = System.currentTimeMillis();
                logger.info("第二段用时：" + (timeMillis2 - timeMillis));
                timeMillis = timeMillis2;

                // TODO: 2021/5/11 修改，根据后台设定的派单范围查询范围内有无司机，将单子指派给距离最近的司机（距离相同随机取），范围内没有司机再进行推单流程
                if(orderPrivateCar.getState() == 1){
                    Company query = companyCityService.query(orderPrivateCar.getStartLon().toString(), orderPrivateCar.getStartLat().toString());
                    if(null == query){
                        return ResultUtil.error("起点暂未企业提供服务");
                    }
                    try {
                        //获取空闲司机
                        List<Driver> drivers = driverService.queryIdleDriver(1, orderPrivateCar.getServerCarModelId(), orderPrivateCar.getStartLon(), orderPrivateCar.getStartLat(), assignOrder.getDistance(), null);//获取范围内空闲司机
                        List<Integer> driverIds = drivers.stream().map(Driver::getId).collect(Collectors.toList());
                        if(drivers.size() > 0) {//有司机，直接指派给司机
                            Driver dr = null;
                            if (drivers.size() > 1) {
                                List<Driver> ds = new ArrayList<>();//存储直线距离最近的几个司机
                                for (int i = 0; i < assignOrder.getPeople(); i++) {
                                    Driver driver = null;
                                    int m = 0;
                                    int index = 0;
                    AssignOrder assignOrder = assignOrderService.selectOne(new EntityWrapper<AssignOrder>().eq("companyId", query.getId()).eq("type", 1));
                    if(null != assignOrder){//配置了指派规则才处理
                        boolean lock = redisUtil.lock("order_lock", 10, 30);
                        if(!lock){
                            return ResultUtil.error("系统繁忙，请稍后重试");
                        }
                        try {
                            //获取空闲司机
                            List<Driver> drivers = driverMapper.queryIdleDriver_(1, serverCarModelId, null);
                            List<Integer> driverIds = drivers.stream().map(Driver::getId).collect(Collectors.toList());
                            logger.info("指派的空闲司机【" + orderPrivateCar.getOrderNum() + "】：" + JSON.toJSONString(drivers));
                            if(drivers.size() > 0) {//有司机，直接指派给司机
                                Driver dr = null;
                                if (drivers.size() > 1) {
                                    List<Driver> ds = new ArrayList<>();
                                    double dis = assignOrder.getDistance() * 1000;
                                    // 查询预约单
                                    List<OrderPrivateCar> orderPrivateCarss = orderPrivateCarMapper.queryOrderByState(driverIds, 2, 1, 2, 3, 4, 5, 6, 11);
                                    List<Integer> orderPrivateCarDriverIds = orderPrivateCars.stream().map(OrderPrivateCar::getDriverId).collect(Collectors.toList());
                                    for (int j = 0; j < drivers.size(); j++) {
                                        Driver driver1 = drivers.get(j);
                                        if (orderPrivateCar.getOrderType() == 2 && orderPrivateCarDriverIds.contains(driver.getId())) {
                                        driver1.setDistance(0D);
                                        if (orderPrivateCar.getOrderType() == 2 && orderPrivateCarDriverIds.contains(driver1.getId())) {
                                            continue;
                                        }
                                        // 判断司机是否有订单进行中
                                        long count = orderPrivateCarMapper.selectCount(new EntityWrapper<OrderPrivateCar>().eq("driverId", driver1.getId())
                                                .in("state", Arrays.asList(2, 3, 4, 5, 6, 11)).eq("isDelete", 1));
                                        if(0 != count){
                                            continue;
                                        }
                                        // 判断该司机是否有30分钟内预约单
                                        long count = orderPrivateCarss.stream().filter(s -> s.getDriverId().equals(driver1.getId()) &&
                                        count = orderPrivateCarss.stream().filter(s -> s.getDriverId().equals(driver1.getId()) &&
                                                DateUtil.dateToLocalDateTime(s.getTravelTime()).minusMinutes(query.getLimitationTime()).isBefore(LocalDateTime.now())).count();
                                        if (count > 0) {
                                            continue;
                                        }
                                        String value = redisUtil.getValue("DRIVER" + drivers.get(j).getId());
                                        if (null != value) {
//                                Map<String, String> distance1 = gdMapElectricFenceUtil.getDistance(orderPrivateCar.getStartLon() + "," + orderPrivateCar.getStartLat(), value, 0);//计算距离
//                                Integer d = Integer.valueOf(distance1.get("distance"));
                                            String[] split = value.split(",");
                                            double distance = GDMapGeocodingUtil.getDistance(orderPrivateCar.getStartLat(), orderPrivateCar.getStartLon(), Double.valueOf(split[1]), Double.valueOf(split[0]));
                                            int d = Double.valueOf(distance).intValue();
                                            if ((0 == m && null == driver) || (d < m)) {
                                                driver = drivers.get(j);
                                                m = d;
                                                index = j;
                                            Map<String, String> distance = gdMapElectricFenceUtil.getDistance(orderPrivateCar.getStartLon() + "," + orderPrivateCar.getStartLat(), value, 1);
                                            double d = Double.parseDouble(distance.get("distance"));
                                            logger.info("指派推单，司机距离【" + orderPrivateCar.getOrderNum() + "】" + driver1.getPhone() + "：" + d);
                                            if(dis >= d){
                                                driver1.setDistance(d);
                                                ds.add(driver1);
                                            }
                                        }
                                    }
                                    ds.add(driver);
                                    drivers.remove(index);

                                    if(!ds.isEmpty()){
                                        ds.sort(new Comparator<Driver>() {
                                            @Override
                                            public int compare(Driver o1, Driver o2) {
                                                return o1.getDistance().compareTo(o2.getDistance());
                                            }
                                        });
                                        logger.info("指派推单，符合条件的司机【" + orderPrivateCar.getOrderNum() + "】：" + JSON.toJSONString(ds));
                                        appOperationLogService.addAppOperationLog(uid, "{\"type\":\"指派推单，符合条件的司机\",\"orderId\":\"" + orderPrivateCar.getId() + "\",\"driver\":\"" + JSON.toJSONString(ds) + "\"}");
                                        dr = ds.get(0);
                                    }
                                } else {
                                    List<OrderPrivateCar> orderPrivateCarss = orderPrivateCarMapper.queryOrderByState(driverIds, 2, 1, 2, 3, 4, 5, 6, 11);
                                    if (orderPrivateCarss.size() == 0) {
                                        dr = drivers.get(0);
                                    }
                                    logger.info("指派推单，符合条件的司机【" + orderPrivateCar.getOrderNum() + "】：" + JSON.toJSONString(dr));
                                    appOperationLogService.addAppOperationLog(uid, "{\"type\":\"指派推单，符合条件的司机\",\"orderId\":\"" + orderPrivateCar.getId() + "\",\"driver\":\"" + JSON.toJSONString(dr) + "\"}");
                                }

                                //再根据直线距离最短的司机中找出行驶距离最短的司机
                                Integer m = 0;
                                for (Driver driver : ds) {
                                    String value = redisUtil.getValue("DRIVER" + driver.getId());
                                    if (null != value) {
                                        Map<String, String> distance1 = gdMapElectricFenceUtil.getDistance(orderPrivateCar.getStartLon() + "," + orderPrivateCar.getStartLat(), value, 1);//计算距离
                                        Integer d = Integer.valueOf(distance1.get("distance"));
                                        if ((0 == m && null == dr) || (d.intValue() < m.intValue())) {
                                            dr = driver;
                                            m = d;
                                if (Objects.nonNull(dr)) {
                                    orderPrivateCar.setDriverId(dr.getId());
                                    orderPrivateCar.setCompanyId(dr.getFranchiseeId() != null && dr.getFranchiseeId() != 0 ? dr.getFranchiseeId() : (
                                            dr.getCompanyId() != null && dr.getCompanyId() != 0 ? dr.getCompanyId() : 1));
                                    orderPrivateCar.setState(2);
                                    orderPrivateCar.setCarId(dr.getCarId());
                                    CarService query1 = carServiceMapper.query(1, dr.getCarId());
                                    orderPrivateCar.setServerCarModelId(query1.getServerCarModelId());
                                    orderPrivateCar.setSnatchOrderTime(new Date());
                                    if (orderPrivateCar.getOrderType() != 2) {
                                        dr.setState(3);
                                    }
                                    driverService.updateById(dr);
                                    redisUtil.setStrValue("DRIVER_ORDER" + dr.getId(), orderPrivateCar.getId().toString(), 600);
                                    new Thread(new Runnable() {
                                        @Override
                                        public void run() {
                                            pushUtil.pushOrderState(1, uid, orderPrivateCar.getId(), 1, 2, 0);
                                            pushUtil.pushOrderState(2, orderPrivateCar.getDriverId(), orderPrivateCar.getId(), 1, 2, 0);
                                            pushUtil.pushDriverPosition(orderPrivateCar.getId(), 1);
                                        }
                                    }
                                    }).start();
                                }
                            } else {
                                List<OrderPrivateCar> orderPrivateCarss = orderPrivateCarMapper.queryOrderByState(driverIds, 2, 1, 2, 3, 4, 5, 6, 11);
                                if (orderPrivateCarss.size() == 0) {
                                    dr = drivers.get(0);
                                }
                            }
                                this.updateById(orderPrivateCar);

                            if (Objects.nonNull(dr)) {
                                orderPrivateCar.setDriverId(dr.getId());
                                orderPrivateCar.setCompanyId(dr.getFranchiseeId() != null && dr.getFranchiseeId() != 0 ? dr.getFranchiseeId() : (
                                        dr.getCompanyId() != null && dr.getCompanyId() != 0 ? dr.getCompanyId() : 1));
                                orderPrivateCar.setState(2);
                                orderPrivateCar.setCarId(dr.getCarId());
                                CarService query1 = carServiceMapper.query(1, dr.getCarId());
                                orderPrivateCar.setServerCarModelId(query1.getServerCarModelId());
                                orderPrivateCar.setSnatchOrderTime(new Date());
                                if (orderPrivateCar.getOrderType() != 2) {
                                    dr.setState(3);
                                }
                                driverService.updateById(dr);
                                new Thread(new Runnable() {
                                    @Override
                                    public void run() {
                                        pushUtil.pushOrderState(1, uid, orderPrivateCar.getId(), 1, 2, 0);
                                        pushUtil.pushOrderState(2, orderPrivateCar.getDriverId(), orderPrivateCar.getId(), 1, 2, 0);
                                        pushUtil.pushDriverPosition(orderPrivateCar.getId(), 1);
                                    }
                                }).start();
                            }
                            this.updateById(orderPrivateCar);

                            //发送短信给司机
                                //发送短信给司机
//                    aLiSendSms.sendSms(dr.getPhone(), "SMS_216832951", "{\"" + orderPrivateCar.getStartAddress() + "\"}");
                            }
                        }catch (Exception e){
                            e.printStackTrace();
                        }finally {
                            redisUtil.unlock("order_lock");
                        }
                    }catch (Exception e){
                        e.printStackTrace();
                    }finally {
                        redisUtil.unlock("order_lock");
                    }
                }
            }
                long timeMillis3 = System.currentTimeMillis();
                logger.info("第三段用时：" + (timeMillis3 - timeMillis));
                timeMillis = timeMillis3;


            //推单操作
            if(orderPrivateCar.getState() == 1){
                this.pushOrder(orderPrivateCar);
                //推单操作
                if(orderPrivateCar.getState() == 1){
                    this.pushOrder(orderPrivateCar);
                }
                //添加消息
                systemNoticeService.addSystemNotice(1, "您的专车订单已下单成功，我们正在为您指派司机，请稍后！", orderPrivateCar.getUserId(), 1);
                BaseWarpper baseWarpper = new BaseWarpper();
                baseWarpper.setState(orderPrivateCar.getState());
                baseWarpper.setId(orderPrivateCar.getId());
                baseWarpper.setPayMethod(1);
                long timeMillis4 = System.currentTimeMillis();
                logger.info("第四段用时：" + (timeMillis4 - timeMillis));
                timeMillis = timeMillis4;
                return ResultUtil.success(baseWarpper);
            }
            //添加消息
            systemNoticeService.addSystemNotice(1, "您的专车订单已下单成功，我们正在为您指派司机，请稍后！", orderPrivateCar.getUserId(), 1);
            BaseWarpper baseWarpper = new BaseWarpper();
            baseWarpper.setState(orderPrivateCar.getState());
            baseWarpper.setId(orderPrivateCar.getId());
            baseWarpper.setPayMethod(1);
            return ResultUtil.success(baseWarpper);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            redisUtil.remove(k);
        }
        return ResultUtil.error("下单失败");
    }

//    @Override
@@ -984,6 +1010,7 @@
                        }
                    }
                }
                appOperationLogService.addAppOperationLog(uid, "{\"type\":\"用户取消订单\",\"orderId\":\"" + orderPrivateCar.getId() + "\",\"orderPrivateCar\":\"" + JSON.toJSONString(orderPrivateCar) + "\"}");
                this.deleteTask(id);//删除定时任务

                new Thread(new Runnable() {
@@ -1030,18 +1057,9 @@
     */
    @Override
    public ResultUtil cancleOrderPrivateCar(Integer id, Integer payType, Integer cancleId, Integer type) throws Exception {
        boolean lock = redisUtil.lock(id + "_cancleOrder", 10);
        boolean lock = redisUtil.lock(id + "_cancleOrder", 10, 30);
        if(!lock){
            int num1 = 1;
            while (num1 <= 10){
                Thread.sleep(3000);//等待3秒
                lock = redisUtil.lock(id + "_cancleOrder", 10);
                if(lock){
                    break;
                }else{
                    num1++;
                }
            }
            return ResultUtil.error("系统繁忙，请稍后重试");
        }
        ResultUtil resultUtil = ResultUtil.success("");
        try {
@@ -1228,6 +1246,8 @@
                            double driverProportion = pushOrder.getDriverProportion() / 100;//推送占比计算成小数
                            int lastIndex = Double.valueOf(list.size() * driverProportion).intValue();//计算占比转成整数（下标截取）
                            list = list.subList(0, lastIndex);//获取空闲司机中占比数据

                            appOperationLogService.addAppOperationLog(orderPrivateCar.getUserId(), "{\"type\":\"范围推单，第" + i +"轮，符合条件的司机\",\"orderId\":\"" + orderPrivateCar.getId() + "\",\"driver\":\"" + JSON.toJSONString(list) + "\"}");
                            for(Driver driver : list){//开始进行推送
                                // 判断该司机是否有30分钟内预约单
                                long count = orderPrivateCars.stream().filter(orderPrivateCar1 -> driver.getId().equals(orderPrivateCar1.getDriverId())
@@ -1260,9 +1280,12 @@
                            pushUtil.pushEndPush(1, orderPrivateCar.getUserId(), orderPrivateCar.getId(), 1);
                            orderIds.remove(orderPrivateCar.getId());


                            // 第三轮取消订单
                            orderPrivateCar.setState(10);
                            orderPrivateCarMapper.updateById(orderPrivateCar);

                            appOperationLogService.addAppOperationLog(orderPrivateCar.getUserId(), "{\"type\":\"范围推单结束，无司机接单，自动取消订单\",\"orderId\":\"" + orderPrivateCar.getId() + "\",\"orderInfo\":\"" + JSON.toJSONString(orderPrivateCar) + "\"}");
                            pushUtil.pushOrderState(1, orderPrivateCar.getUserId(), orderPrivateCar.getId(), 1, orderPrivateCar.getState(), 0);
                            // 添加站内信
                            systemNoticeService.addSystemNotice(1, "当前区域未能及时为您匹配到合适车辆。为避免耽误您的行程，系统已自动取消订单，建议您稍后重新尝试。", orderPrivateCar.getUserId(), 1);
@@ -1380,19 +1403,15 @@

    @Override
    public ResultUtil payPrivateCarOrder(Integer payType, Integer orderId, Integer couponId, Integer type) throws Exception {
        boolean lock = redisUtil.lock(orderId + "_payment", 10);
        boolean lock = redisUtil.lock(orderId + "_payment", 10, 30);
        if(!lock){
            int num1 = 1;
            while (num1 <= 10){
                Thread.sleep(3000);//等待3秒
                lock = redisUtil.lock(orderId + "_payment", 10);
                if(lock){
                    break;
                }else{
                    num1++;
                }
            }
            return ResultUtil.error("系统繁忙，请稍后重试");
        }
        String key = orderId + "_during_payment";
        if(redisUtil.hasKey(key)){
            return ResultUtil.error("支付中，不能重复发起支付");
        }
        redisUtil.setStrValue(key, UUIDUtil.getRandomCode(), 10);
        try {
            OrderPrivateCar orderPrivateCar = this.selectById(orderId);
            if(orderPrivateCar.getState() == 8 || orderPrivateCar.getState() == 9){
@@ -1437,11 +1456,9 @@
    
            Integer uid = orderPrivateCar.getUserId();
            Double orderMoney = orderPrivateCar.getOrderMoney();
            System.out.println("=========================订单金额====================="+orderMoney);
            if(Objects.nonNull(orderPrivateCar.getPaymentAdvanceMoney()) && orderPrivateCar.getPaymentAdvanceMoney() > 0){
                double couponMoney1 = Objects.nonNull(orderPrivateCar.getCouponMoney()) ? orderPrivateCar.getCouponMoney() : 0.00;
                orderMoney = orderMoney - orderPrivateCar.getPaymentAdvanceMoney() - couponMoney1;
                System.out.println("=========================减去先付后金额====================="+orderMoney);
            }
            UserInfo userInfo = userInfoService.selectById(uid);
            ResultUtil resultUtil = ResultUtil.success(new HashMap<>());
@@ -1504,16 +1521,13 @@
                resultUtil = payMoneyUtil.weixinpay("完成订单",orderId +"", code,orderMoney+"","/base/wxPayOrderTaxi","JSAPI",userInfo.getAppletsOpenId());
                if(resultUtil.getCode()==200){
                    paymentRecordService.saveData(1, orderPrivateCar.getUserId(), 1, orderId, 1, 1, orderMoney, null, 1, code);//添加预支付数据
                    long millis = System.currentTimeMillis();
                    appOperationLogService.addAppOperationLog(orderPrivateCar.getUserId(), "{\"type\":\"用户支付订单\",\"orderId\":\"" + orderPrivateCar.getId() + "\",\"orderInfo\":\"" + JSON.toJSONString(orderPrivateCar) + "\"}");
                    new Thread(()->{
                        long time = millis;
                        try {
                            Thread.sleep(5000);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                        //订单创建后15分钟
                        while ((System.currentTimeMillis() - time) <= 900000) {
                        int num = 1;
                        int wait = 0;
                        while (num <= 13) {
                            int min = 5000;
                            wait += (min * num);
                            OrderPrivateCar orderPrivateCar1 = OrderPrivateCarServiceImpl.this.selectById(orderId);
                            if(orderPrivateCar1.getState() != 7){
                                break;
@@ -1543,12 +1557,17 @@
                                    if ("NOTPAY".equals(s) || "USERPAYING".equals(s)) {
                                    }
                                }
                                Thread.sleep(5000);
                            }catch (Exception e){
                                e.printStackTrace();
                            }finally {
                                try {
                                    Thread.sleep(wait);
                                } catch (InterruptedException e) {
                                    e.printStackTrace();
                                }
                                num++;
                            }
                        }
                
                        OrderPrivateCar orderPrivateCar1 = OrderPrivateCarServiceImpl.this.selectById(orderId);
                        if(7 == orderPrivateCar1.getState()){
                            //关闭订单，不允许支付
@@ -1707,7 +1726,8 @@
            }
    
            this.updateAllColumnById(orderPrivateCar);
    
            appOperationLogService.addAppOperationLog(orderPrivateCar.getUserId(), "{\"type\":\"用户" + (payType == 1 ? "微信" : payType == 2 ? "支付宝" : "余额") + "支付订单，" + (orderPrivateCar.getPayMethod() == 0 ? "先付" : "后付") + "\"" +
                    ",\"orderId\":\"" + orderPrivateCar.getId() + "\",\"orderInfo\":\"" + JSON.toJSONString(orderPrivateCar) + "\"}");
            new Thread(new Runnable() {
                @Override
                public void run() {
@@ -1898,21 +1918,10 @@
    @Override
    @Transactional(rollbackFor = Exception.class)
    public synchronized void payOrderPrivateCarCallback(Integer id, String order_id, Integer type) throws Exception {
        boolean lock = redisUtil.lock(order_id + "_paymentCallback", 10);
        boolean lock = redisUtil.lock(order_id + "_paymentCallback", 10, 30);
        if(!lock){
            int num1 = 1;
            while (num1 <= 10){
                Thread.sleep(3000);//等待3秒
                lock = redisUtil.lock(order_id + "_paymentCallback", 10);
                if(lock){
                    break;
                }else{
                    num1++;
                }
            }
            return;
        }
        
        
        try {
            PaymentRecord query = paymentRecordService.query(1, null, null, Integer.valueOf(id), 1, type, null);
            if(null != query){
@@ -1924,13 +1933,15 @@
                transactionDetailsService.saveData(orderPrivateCar.getUserId(), "完成订单", query.getAmount(), 2, 1, 1, 1, query.getOrderId());
//                orderPrivateCar.setState(8);
                orderPrivateCar.setPayType(type);
                orderPrivateCar.setTransactionId(order_id);
                if(!StringUtils.hasLength(orderPrivateCar.getTransactionId())){
                    orderPrivateCar.setTransactionId(order_id);
                }
                this.updateById(orderPrivateCar);
        
                UserInfo userInfo = userInfoService.selectById(orderPrivateCar.getUserId());
                SysIntegral query1 = sysIntegralMapper.query(orderPrivateCar.getCompanyId());
                userInfo.setIntegral(userInfo.getIntegral() + (query.getAmount().intValue() * query1.getIntegral()));//积分
                userInfoService.updateById(userInfo);
//                UserInfo userInfo = userInfoService.selectById(orderPrivateCar.getUserId());
//                SysIntegral query1 = sysIntegralMapper.query(orderPrivateCar.getCompanyId());
//                userInfo.setIntegral(userInfo.getIntegral() + (query.getAmount().intValue() * query1.getIntegral()));//积分
//                userInfoService.updateById(userInfo);
        
                //处理优惠券和红包
                if(null != orderPrivateCar.getCouponId()){
@@ -1952,7 +1963,6 @@

                // 判断先付还是后付
                if(orderPrivateCar.getPayMethod() == 0){

                    if (Objects.nonNull(orderPrivateCar.getPaymentAdvanceMoney()) && orderPrivateCar.getPaymentAdvanceMoney() > 0 ) {
                        orderPrivateCar.setState(8);
                        orderPrivateCar.setOrderMoney(orderPrivateCar.getOrderMoney()+query.getAmount());
@@ -2021,6 +2031,10 @@
                        incomeService.saveDriverData(2, orderPrivateCar.getDriverId(), 2, orderPrivateCar.getId(), 1, c.doubleValue(), driver.getLaveBusinessMoney());
                    }
                }

                appOperationLogService.addAppOperationLog(orderPrivateCar.getUserId(), "{\"type\":\"用户" + (type == 1 ? "微信" : "支付宝") + "支付订单，" + (orderPrivateCar.getPayMethod() == 0 ? "先付" : "后付") + "\"" +
                        ",\"orderId\":\"" + orderPrivateCar.getId() + "\",\"orderInfo\":\"" + JSON.toJSONString(orderPrivateCar) + "\"}");

                // TODO: 2020/5/24 这里需要给司机和用户推送订单状态
                new Thread(new Runnable() {
                    @Override