Pu Zhibing
13 小时以前 43d8da7e3b60cb7deb7d31ae0a6c06bff1ae9390
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
package com.supersavedriving.driver.modular.system.service.impl;
 
 
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.supersavedriving.driver.core.util.ToolUtil;
import com.supersavedriving.driver.modular.system.dao.TOrderCheckMapper;
import com.supersavedriving.driver.modular.system.model.*;
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.warpper.CheckOrderInfoWarpper;
import com.supersavedriving.driver.modular.system.warpper.OrderInfoWarpper;
import com.supersavedriving.driver.modular.system.warpper.ProcessCheckOperationsWarpper;
import com.supersavedriving.driver.modular.system.warpper.ProcessOperationsWarpper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.stereotype.Service;
 
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;
 
/**
 * <p>
 * 订单 服务实现类
 * </p>
 *
 * @author administrator
 * @since 2025-07-23
 */
@Service
public class TOrderCheckServiceImpl extends ServiceImpl<TOrderCheckMapper, TOrderCheck> implements TOrderCheckService {
 
    @Autowired
    private IDriverWorkService driverWorkService;
 
    @Autowired
    private IDriverService driverService;
 
 
    @Autowired
    private PushUtil pushUtil;
 
 
    @Autowired
    private RedisUtil redisUtil;
 
    @Autowired
    private ISystemMessageService systemMessageService;
 
    @Autowired
    private IAppUserService appUserService;
 
 
    /**
     * 获取订单详情
     * @param orderId
     * @return
     * @throws Exception
     */
    @Override
    public CheckOrderInfoWarpper queryOrderInfo(Integer uid, Long orderId) {
        TOrderCheck order = this.selectById(orderId);
        if(!order.getDriverId().equals(uid) && order.getState()>101){
            return null;
        }
        CheckOrderInfoWarpper orderInfoWarpper = this.baseMapper.queryOrderInfo(orderId);
        if(ToolUtil.isEmpty(orderInfoWarpper.getAvatar())){
            orderInfoWarpper.setAvatar("https://csxdj.obs.cn-south-1.myhuaweicloud.com:443/66cc269703a84e4da87fb21e2c21ab1f.png");
        }
        orderInfoWarpper.setDriverId(order.getDriverId());
        Driver driver = driverService.selectById(orderInfoWarpper.getDriverId());
        orderInfoWarpper.setDriverAvatar(driver.getAvatar());
        orderInfoWarpper.setDriverName(driver.getName());
        orderInfoWarpper.setDriverPhone(driver.getPhone());
        return orderInfoWarpper;
    }
 
 
    @Override
    public ResultUtil receiveCheckOrder(Integer uid, Long orderId) throws Exception {
        try {
            Driver driver = driverService.selectById(uid);
 
            if(driver.getCheckServer()==null || driver.getCheckServer()==2){
                return ResultUtil.error("请先开启车检服务");
            }
 
            DriverWork driverWork = driverWorkService.selectOne(new EntityWrapper<DriverWork>().eq("driverId", uid).eq("status", 1));
            if(null == driverWork){
                return ResultUtil.error("请先上班");
            }
 
            List<Integer> state1 = Arrays.asList(102, 103, 104, 105, 106,107,108);
            int count = this.selectCount(new EntityWrapper<TOrderCheck>().eq("driverId", uid).eq("status", 1).in("state", state1));
            if(count > 0){
                return ResultUtil.error("还有未完成的订单");
            }
            boolean lock = redisUtil.lock(orderId.toString()+"_check", 5);
            if(!lock){
                int num1 = 1;
                while (num1 <= 10){
                    Thread.sleep(3000);//等待3秒
                    lock = redisUtil.lock(orderId.toString(),5);
                    if(lock){
                        break;
                    }else{
                        num1++;
                    }
                }
            }
            if(!lock){
                redisUtil.unlock(orderId.toString());
                return ResultUtil.error("请重试");
            }
            TOrderCheck order = this.selectById(orderId);
            Integer state = order.getState();
            if(state == 111){
                redisUtil.unlock(orderId.toString());
                return ResultUtil.error("订单已被取消");
            }
            if(state != 101){
                redisUtil.unlock(orderId.toString());
                return ResultUtil.error("手速慢了哦");
            }
            order.setDriverId(uid);
            order.setBranchOfficeId(driver.getBranchOfficeId());
            order.setState(102);
            order.setOrderTakingTime(new Date());
            this.updateById(order);
            redisUtil.unlock(orderId.toString());
 
            driver.setServerStatus(2);
            driverService.updateById(driver);
 
            //推动订单数据
            redisUtil.addSetValue("orderService_check", order.getId().toString());
            //发送系统消息
            systemMessageService.addSystemMessage(uid, 2, "接单成功", "您已成功接到用户订单,请尽快联系客户!");
            pushUtil.pushCheckOrderStatus(order.getDriverId(), 2, order.getId(), order.getState());
            if(null != order.getUserId()){
                systemMessageService.addSystemMessage(order.getUserId(), 1, "接单成功", driver.getName() + "师傅已成功接到您的订单,请保持电话畅通!");
                pushUtil.pushCheckOrderStatus(order.getUserId(), 1, order.getId(), order.getState());
            }
        }catch (Exception e){
            redisUtil.unlock(orderId.toString()+"_check");
            e.printStackTrace();
            throw e;
        }
        return ResultUtil.success();
    }
 
 
    /**
     * 司机走订单流程
     * @param uid
     * @param processOperationsWarpper
     * @return
     * @throws Exception
     */
    @Override
    public ResultUtil driverCheckProcessOperations(Integer uid, ProcessCheckOperationsWarpper processOperationsWarpper)  {
        //100=待派单   101=待接单,102=已接单(正在前往取车地),104=到达预约点(用户待支付车检),105=开始服务,106=车检完成,107=前往还车地,108=到达还车地(用户待支付服务费),109=已完成,110=已评价 111取消
        TOrderCheck order = this.selectById(processOperationsWarpper.getOrderId());
        if(order.getState() == processOperationsWarpper.getState()){
            return ResultUtil.error("不能重复操作");
        }
        if(order.getState() == 111){
            redisUtil.unlock();
            return ResultUtil.error("订单已被取消");
        }
        //104=到达预约点,105=开始服务(可以录入车检信息),106=车检完成,,107=前往还车地,108=到达还车地(用户待支付服务费)
        switch (processOperationsWarpper.getState()){
            case 104:
                if(order.getState()!=102){
                    return ResultUtil.error("请先接单");
                }
                if(processOperationsWarpper.getCarType()==null){
                    return ResultUtil.error("请选择车类型");
                }
                order.setArrivalTimeAtTheAppointmentPoint(new Date());
                if(order.getReInspection() !=null && order.getReInspection()==1){
                    processOperationsWarpper.setState(105);
                }
                order.setCarType(processOperationsWarpper.getCarType());
                break;
            case 106:
                if(order.getState()!=105){
                    return ResultUtil.error("请先开始服务");
                }
                if(processOperationsWarpper.getCheckStatus()==null || processOperationsWarpper.getCheckIntro()==null || processOperationsWarpper.getCheckImg()==null ){
                    return ResultUtil.error("请填写车检信息");
                }
                order.setCheckStatus(processOperationsWarpper.getCheckStatus());
                order.setCheckIntro(processOperationsWarpper.getCheckIntro());
                order.setCheckImg(processOperationsWarpper.getCheckImg());
                order.setEndTime(new Date());
                break;
            case 107:
                if(order.getState()!=106){
                    return ResultUtil.error("请先完成车检");
                }
                order.setGoTime(new Date());
                break;
            case 108:
                if(order.getState()!=107){
                    return ResultUtil.error("请先前往还车地");
                }
                order.setSuccessTime(new Date());
                break;
        }
        order.setState(processOperationsWarpper.getState());
        this.updateAllColumnById(order);
 
        //推送订单状态
        pushUtil.pushCheckOrderStatus(order.getDriverId(), 2, order.getId(), order.getState());
        if(null != order.getUserId()){
            pushUtil.pushCheckOrderStatus(order.getUserId(), 1, order.getId(), order.getState());
        }
        return ResultUtil.success();
    }
 
 
 
}