新增加司机端接口

puzhibing

2023-02-25 4ba348b700fd7f461f754a283eaeeba3fc9ff36c

 driver/guns-admin/src/main/java/com/supersavedriving/driver/modular/system/service/impl/OrderServiceImpl.java

@@ -11,11 +11,11 @@
import com.supersavedriving.driver.modular.system.service.*;
import com.supersavedriving.driver.modular.system.util.*;
import com.supersavedriving.driver.modular.system.util.GaoDe.MapUtil;
import com.supersavedriving.driver.modular.system.util.GaoDe.model.District;
import com.supersavedriving.driver.modular.system.util.juhe.WeatherUtil;
import com.supersavedriving.driver.modular.system.util.mongodb.model.Location;
import com.supersavedriving.driver.modular.system.warpper.AddOrderWarpper;
import com.supersavedriving.driver.modular.system.warpper.HallOrderList;
import com.supersavedriving.driver.modular.system.warpper.OrderInfoWarpper;
import com.supersavedriving.driver.modular.system.warpper.*;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.geo.Circle;
import org.springframework.data.geo.Distance;
@@ -71,6 +71,20 @@
    @Autowired
    private IYouTuiDriverService youTuiDriverService;

    @Autowired
    private IWeatherCityService weatherCityService;

    @Autowired
    private IOrderTransferService orderTransferService;

    @Autowired
    private ICancelOrderService cancelOrderService;

    @Autowired
    private IRevenueService revenueService;

    private Map<String, Timer> timerMap = new HashMap<>();




@@ -116,6 +130,7 @@
        if(driverWork != null && null == order1){
            order.setDriverId(uid);
            driver.setServerStatus(2);
            order.setOrderTakingTime(new Date());
        }
        order.setCode(UUIDUtil.getTimeStr() + UUIDUtil.getNumberRandom(3));
        order.setSource(2);
@@ -143,7 +158,13 @@
            d = Double.valueOf(distance.get("distance")) / 1000;
            order.setEstimatedMileage(d);
        }
        order = getOrderPrice(1, d, 0, order, "");
        String city = "";
        District geocode = MapUtil.geocode(order.getStartLng(), order.getStartLat());
        if(null != geocode){
            WeatherCity weatherCity = weatherCityService.selectOne(new EntityWrapper<WeatherCity>().where(" '" + geocode.getProvince() + "' like district"));
            city = null != weatherCity ? weatherCity.getId().toString() : "";
        }
        order = getOrderPrice(1, d, 0, order, city);
        order.setHallOrder(0);
        order.setState(null == order.getDriverId() ? 101 : 102);
        order.setStatus(1);
@@ -291,9 +312,15 @@
            }
        }

        //计算折扣
        if(null != order.getUserId()){

        }

        //计算总金额
        BigDecimal bigDecimal = new BigDecimal(order.getStartPrice() + order.getOverDrivePrice() + order.getLongDistancePrice() + order.getOverLongDistancePrice() +
                order.getWaitTimePrice() + order.getOutWaitTimePrice() + order.getBadWeatherPrice() + order.getOverBadWeatherPrice()).setScale(2, BigDecimal.ROUND_HALF_EVEN);
                order.getWaitTimePrice() + order.getOutWaitTimePrice() + order.getBadWeatherPrice() + order.getOverBadWeatherPrice() - order.getDiscountAmount()).setScale(2, BigDecimal.ROUND_HALF_EVEN);

        if(type == 1){//预估价
            order.setEstimatedPrice(bigDecimal.doubleValue());
        }
@@ -328,6 +355,8 @@
        order.setOverBadWeatherPrice(0D);//恶劣天气超出里程费
        order.setDiscountedPrice(0D);//优惠金额
        order.setCouponId(null);//优惠券
        order.setDiscountAmount(0D);//折扣优惠金额
        order.setDiscount(0D);//折扣
        return order;
    }

@@ -446,7 +475,7 @@
                @Override
                public void run() {
                    Order order1 = OrderServiceImpl.this.selectById(order.getId());
                    if(order1.getState() == 101){
                    if(order1.getState() == 101 || order1.getState() == 201){
                        order1.setHallOrder(1);
                        OrderServiceImpl.this.updateById(order1);
                    }
@@ -535,11 +564,13 @@
                }
            }
            Order order = this.selectById(orderId);
            if(order.getState() != 301){
            Integer state = order.getState();
            Integer oldDriverId = order.getDriverId();
            if(state != 301){
                redisUtil.unlock();
                return ResultUtil.error("订单已被取消");
            }
            if(order.getState() != 101){
            if(state != 101){
                redisUtil.unlock();
                return ResultUtil.error("手速慢了哦");
            }
@@ -547,11 +578,49 @@
            order.setAgentId(driver.getAgentId());
            order.setBranchOfficeId(driver.getBranchOfficeId());
            order.setState(102);
            order.setOrderTakingTime(new Date());
            this.updateById(order);
            redisUtil.unlock();

            driver.setServerStatus(2);
            driverService.updateById(driver);
            if(state == 201){//转单的订单
                //停止定时任务
                Timer timer = timerMap.get(order.getId().toString());
                if(null != timer){
                    timer.cancel();
                    timerMap.remove(order.getId().toString());
                }
                //原司机下班
                Driver oldDriver = driverService.selectById(oldDriverId);
                oldDriver.setServerStatus(1);
                driverService.updateById(oldDriver);

                DriverWork driverWork1 = driverWorkService.selectOne(new EntityWrapper<DriverWork>().eq("driverId", oldDriverId).eq("status", 1));
                driverWork1.setStatus(2);
                driverWork1.setOffWorkTime(new Date());
                driverWorkService.updateById(driverWork1);

                //添加关系数据
                OrderTransfer orderTransfer = orderTransferService.selectOne(new EntityWrapper<OrderTransfer>().eq("orderId", order.getId()).eq("status", 1).isNull("successTime"));
                if(null != orderTransfer){
                    orderTransfer.setNewDriverId(uid);
                    orderTransfer.setSuccessTime(new Date());
                    orderTransferService.updateById(orderTransfer);
                }else{
                    orderTransfer = new OrderTransfer();
                    orderTransfer.setOrderId(order.getId());
                    orderTransfer.setOldDriverId(oldDriverId);
                    orderTransfer.setCreateTime(new Date());
                    orderTransfer.setStatus(1);
                    orderTransfer.setNewDriverId(uid);
                    orderTransfer.setSuccessTime(new Date());
                    orderTransferService.insert(orderTransfer);
                }

                pushUtil.pushTransferSuccessful(order.getUserId(), 1, order.getId());
                pushUtil.pushTransferSuccessful(oldDriverId, 2, order.getId());
            }

            //推动订单数据
            new Thread(new Runnable() {
@@ -590,4 +659,314 @@
        orderInfoWarpper.setCurrentDistance(wgs84);
        return orderInfoWarpper;
    }


    /**
     * 司机走订单流程
     * @param uid
     * @param processOperationsWarpper
     * @return
     * @throws Exception
     */
    @Override
    public ResultUtil driverProcessOperations(Integer uid, ProcessOperationsWarpper processOperationsWarpper) throws Exception {
        //101=待接单，102=已接单，103=前往预约点，104=到达预约点，105=开始服务，106=到达目的地，107=待支付，108=待评价，109=已完成，201=转单中，301=已取消，401=等待中
        Order order = this.selectById(processOperationsWarpper.getOrderId());
        if(order.getState() == processOperationsWarpper.getState()){
            return ResultUtil.error("不能重复操作");
        }
        if(order.getState() == 201){
            return ResultUtil.error("订单正在转单中");
        }
        order.setState(processOperationsWarpper.getState());
        switch (processOperationsWarpper.getState()){
            case 103:
                order.setGoToAppointmentPointTime(new Date());
                pushOrderInfo(order.getId(), uid);//开始推送订单数据
                break;
            case 104:
                order.setStartWaitTime(new Date());
                order.setArrivalTimeAtTheAppointmentPoint(new Date());
                break;
            case 105:
                if(null == order.getStartTime()){
                    redisUtil.addSetValue("serverOrder", order.getId().toString());//存入缓存用于计算实时距离
                    order.setBoardingTime(new Date());
                    order.setStartTime(new Date());
                }
                order.setStartWaitTime(null);
                //计算等待用户时长
                Integer w = Double.valueOf((System.currentTimeMillis() - order.getStartWaitTime().getTime()) / 60000).intValue();
                order.setWaitTime(order.getWaitTime() + w);
                break;
            case 106:
                order.setGetoffTime(new Date());
                if(ToolUtil.isEmpty(order.getEndAddress())){
                    order.setEndAddress(processOperationsWarpper.getEndAddress());
                    order.setEndLng(processOperationsWarpper.getEndLng());
                    order.setEndLat(processOperationsWarpper.getEndLat());
                }
                //停止定时任务
                Timer timer = timerMap.get(order.getId().toString());
                if(null != timer){
                    timer.cancel();
                    timerMap.remove(order.getId().toString());
                }
                //开始计算费用
                String city = "";
                District geocode = MapUtil.geocode(order.getEndLng(), order.getEndLat());
                if(null != geocode){
                    WeatherCity weatherCity = weatherCityService.selectOne(new EntityWrapper<WeatherCity>().where(" '" + geocode.getProvince() + "' like district"));
                    city = null != weatherCity ? weatherCity.getId().toString() : "";
                }
                order = getOrderPrice(2, Double.valueOf(order.getActualMileage() / 1000), order.getWaitTime(), order, city);

                //修改司机状态
                Driver driver = driverService.selectById(order.getDriverId());
                driver.setServerStatus(1);
                driverService.updateById(driver);
                break;
            case 401:
                order.setStartWaitTime(new Date());
                break;
        }
        this.updateAllColumnById(order);

        //推送订单状态
        pushUtil.pushOrderStatus(order.getDriverId(), 2, order.getId(), order.getState());
        if(null != order.getUserId()){
            pushUtil.pushOrderStatus(order.getUserId(), 1, order.getId(), order.getState());
        }
        return ResultUtil.success();
    }


    /**
     * 定时任务推送订单数据
     * @param orderId
     * @param uid
     */
    public void pushOrderInfo(Long orderId, Integer uid){
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                String value = redisUtil.getValue("DRIVER" + uid);
                Order order = OrderServiceImpl.this.selectById(orderId);
                if(order.getState() == 106){
                    Timer timer = timerMap.get(order.getId().toString());
                    if(null != timer){
                        timer.cancel();
                        timerMap.remove(order.getId().toString());
                    }
                }

                PushOrderInfoWarpper pushOrderInfoWarpper = new PushOrderInfoWarpper();
                pushOrderInfoWarpper.setId(orderId);
                if(ToolUtil.isNotEmpty(value)){
                    String[] split = value.split(",");
                    pushOrderInfoWarpper.setDriverLat(split[1]);
                    pushOrderInfoWarpper.setDriverLng(split[0]);
                }
                pushOrderInfoWarpper.setWaitTime(order.getWaitTime());
                pushOrderInfoWarpper.setState(order.getState());
                pushOrderInfoWarpper.setActualMileage(Double.valueOf(order.getActualMileage() / 1000));
                int travelTime = Double.valueOf((System.currentTimeMillis() - order.getStartTime().getTime()) / 60000).intValue();
                pushOrderInfoWarpper.setTravelTime(travelTime);
                pushUtil.pushOrderInfo(uid, 2, pushOrderInfoWarpper);
            }
        },0, 5000);
        timerMap.put(orderId.toString(), timer);
    }


    /**
     * 司机转单操作
     * @param uid
     * @param orderId
     * @param cause
     * @return
     * @throws Exception
     */
    @Override
    public ResultUtil transferOrder(Integer uid, Long orderId, String cause) throws Exception {
        Order order = this.selectById(orderId);
        if(order.getDriverId().compareTo(uid) != 0){
            return ResultUtil.error("无权操作");
        }
        if(order.getState() > 104){
            return ResultUtil.error("订单不支持转单");
        }
        order.setOldState(order.getState());
        order.setState(201);
        this.updateById(order);

        OrderTransfer orderTransfer = new OrderTransfer();
        orderTransfer.setOrderId(orderId);
        orderTransfer.setOldDriverId(order.getDriverId());
        orderTransfer.setCause(cause);
        orderTransfer.setStatus(1);
        orderTransfer.setCreateTime(new Date());
        orderTransferService.insert(orderTransfer);

        //开始派单
        pushOrder(order);
        return ResultUtil.success();
    }


    /**
     * 司机修改订单终点
     * @param uid
     * @param orderEndAddressWarpper
     * @return
     * @throws Exception
     */
    @Override
    public ResultUtil setOrderEndAddress(Integer uid, OrderEndAddressWarpper orderEndAddressWarpper) throws Exception {
        Order order = this.selectById(orderEndAddressWarpper.getOrderId());
        order.setEndLat(orderEndAddressWarpper.getEndLat());
        order.setEndLng(orderEndAddressWarpper.getEndLng());
        order.setEndAddress(orderEndAddressWarpper.getEndAddress());
        Map<String, String> distance = MapUtil.getDistance(order.getStartLng() + "," + order.getStartLat(), order.getEndLng() + "," + order.getEndLat(), 1);
        if(null == distance){
            return ResultUtil.error("获取预估距离出错");
        }
        Double d = Double.valueOf(distance.get("distance")) / 1000;
        order.setEstimatedMileage(d);
        String city = "";
        District geocode = MapUtil.geocode(order.getStartLng(), order.getStartLat());
        if(null != geocode){
            WeatherCity weatherCity = weatherCityService.selectOne(new EntityWrapper<WeatherCity>().where(" '" + geocode.getProvince() + "' like district"));
            city = null != weatherCity ? weatherCity.getId().toString() : "";
        }
        order = getOrderPrice(1, d, 0, order, city);
        this.updateById(order);
        return ResultUtil.success();
    }


    /**
     * 司机取消转到操作
     * @param uid
     * @param orderId
     * @return
     * @throws Exception
     */
    @Override
    public ResultUtil cancelTransferOrder(Integer uid, Long orderId) throws Exception {
        Order order = this.selectById(orderId);
        if(order.getState() != 201){
            return ResultUtil.error("不能取消转单");
        }
        order.setState(order.getOldState());
        order.setOldState(null);
        this.updateAllColumnById(order);

        OrderTransfer orderTransfer = orderTransferService.selectOne(new EntityWrapper<OrderTransfer>().eq("orderId", orderId)
                .eq("status", 1).isNull("successTime").orderBy("createTime desc limit 0, 1"));
        if(null != orderTransfer){
            orderTransfer.setStatus(3);
            orderTransferService.updateById(orderTransfer);
        }
        return ResultUtil.success();
    }


    /**
     * 司机取消订单
     * @param uid
     * @param orderId
     * @param cause
     * @return
     * @throws Exception
     */
    @Override
    public ResultUtil driverCancelOrder(Integer uid, Long orderId, String cause) throws Exception {
        Order order = this.selectById(orderId);
        if(uid.compareTo(order.getDriverId()) != 0){
            return ResultUtil.error("无法取消订单");
        }
        if(order.getState() > 105){
            return ResultUtil.error("无法取消订单");
        }

        order.setState(301);
        this.updateById(order);

        CancelOrder cancelOrder = new CancelOrder();
        cancelOrder.setOrderId(orderId);
        cancelOrder.setUserType(2);
        cancelOrder.setUserId(uid);
        cancelOrder.setCause(cause);
        cancelOrder.setStatus(1);
        cancelOrder.setCreateTime(new Date());
        cancelOrderService.insert(cancelOrder);
        return ResultUtil.success();
    }


    /**
     * 获取订单费用明细
     * @param uid
     * @param orderId
     * @return
     * @throws Exception
     */
    @Override
    public OrderPriceWarpper queryOrderPrice(Integer uid, Long orderId) throws Exception {
        Driver driver = driverService.selectById(uid);
        Order order = this.selectById(orderId);
        OrderPriceWarpper orderPriceWarpper = new OrderPriceWarpper();
        BeanUtils.copyProperties(order, orderPriceWarpper);
        orderPriceWarpper.setActualMileage(new BigDecimal(order.getActualMileage() / 1000).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
        orderPriceWarpper.setTravelTime(Double.valueOf((order.getGetoffTime().getTime() - order.getStartTime().getTime()) / 60000).intValue());
        orderPriceWarpper.setWxCollectionCode(driver.getWxCollectionCode());
        orderPriceWarpper.setZfbCollectionCode(driver.getZfbCollectionCode());
        return orderPriceWarpper;
    }


    /**
     * 修改订单状态
     * @param uid
     * @param orderId
     * @param state
     * @return
     * @throws Exception
     */
    @Override
    public ResultUtil setOrderStatus(Integer uid, Long orderId, Integer state) throws Exception {
        List<Integer> s = Arrays.asList(107, 108);
        if(s.contains(state)){
            return ResultUtil.error("操作失败");
        }
        Order order = this.selectById(orderId);
        order.setState(state);
        if(state == 108){
            order.setPayType(3);
            order.setPayTime(new Date());
            order.setPayMoney(order.getOrderMoney() - order.getDiscountAmount());
        }
        this.updateById(order);

        if(state == 108){//计算抽成
            saveRevenue(order);
        }

        pushUtil.pushOrderStatus(order.getDriverId(), 2, orderId, order.getState());
        if(null != order.getUserId()){
            pushUtil.pushOrderStatus(order.getUserId(), 1, orderId, order.getState());
        }
        return ResultUtil.success();
    }


    /**
     * 计算抽成和分佣
     * @param order
     */
    public void saveRevenue(Order order){

    }
}