xuhy
2023-08-11 3c1223bf3eb6df077b48637a7c93a93246a1a8ae
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
package com.stylefeng.guns.modular.crossCity.server.impl;
 
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.stylefeng.guns.modular.crossCity.dao.LinePriceMapper;
import com.stylefeng.guns.modular.crossCity.dao.LineShiftDriverMapper;
import com.stylefeng.guns.modular.crossCity.dao.LineShiftMapper;
import com.stylefeng.guns.modular.crossCity.model.LineShift;
import com.stylefeng.guns.modular.crossCity.model.LineShiftDriver;
import com.stylefeng.guns.modular.crossCity.model.OrderCrossCity;
import com.stylefeng.guns.modular.crossCity.server.ILineService;
import com.stylefeng.guns.modular.crossCity.server.ILineShiftDriverService;
import com.stylefeng.guns.modular.crossCity.server.ILineSiteService;
import com.stylefeng.guns.modular.crossCity.server.IOrderCrossCityService;
import com.stylefeng.guns.modular.system.dao.CarModelMapper;
import com.stylefeng.guns.modular.system.dao.CarServiceMapper;
import com.stylefeng.guns.modular.system.dao.ServerCarModelMapper;
import com.stylefeng.guns.modular.system.model.CarModel;
import com.stylefeng.guns.modular.system.model.CarService;
import com.stylefeng.guns.modular.system.service.ICarService;
import com.stylefeng.guns.modular.system.service.IDriverService;
import com.stylefeng.guns.modular.system.util.DateUtil;
import com.stylefeng.guns.modular.system.util.ResultUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.util.*;
 
 
@Service
public class LineShiftDriverServiceImpl extends ServiceImpl<LineShiftDriverMapper, LineShiftDriver> implements ILineShiftDriverService {
 
    @Resource
    private LineShiftDriverMapper lineShiftDriverMapper;
 
    @Autowired
    private DateUtil dateUtil;
 
    @Autowired
    private ICarService carService;
 
    @Autowired
    private IDriverService driverService;
 
    @Resource
    private CarModelMapper carModelMapper;
 
    @Resource
    private LineShiftMapper lineShiftMapper;
 
    @Resource
    private LinePriceMapper linePriceMapper;
 
    @Resource
    private CarServiceMapper carServiceMapper;
 
    @Autowired
    private IOrderCrossCityService orderCrossCityService;
 
    @Autowired
    private ILineService lineService;
 
 
 
    /**
     * 预约班次操作
     * @param lineShiftId
     * @param time
     * @param driverId
     * @return
     * @throws Exception
     */
    @Override
    public synchronized ResultUtil reservation(Integer type, Integer lineShiftId, String time, Integer driverId) throws Exception {
        Map<String, Date> date = dateUtil.getStartAndEndDate(time);
        List<LineShiftDriver> startTime = lineShiftDriverMapper.queryByDriver(lineShiftId, driverId, date.get("startTime"));
        if(type == 1 && startTime.size() > 0){
            return ResultUtil.error("不能重复预约");
        }
        if(type == 2 && startTime.size() == 0){
            return ResultUtil.error("您还没预约呢");
        }
        if(type == 1){//预约操作
            boolean b = this.judgeTime(driverId, lineShiftId, date.get("startTime"));
            if(b){
                return ResultUtil.error("预约间隔超出给定可预约范围");
            }
            int num = lineShiftDriverMapper.queryByDriver(lineShiftId, null, date.get("startTime")).size();
            LineShift lineShift = lineShiftMapper.selectById(lineShiftId);
            Integer carNum = lineShift.getCarNum();
            if(num >= carNum){
                return ResultUtil.error("该班次已经超出了可预约车次");
            }
            CarService query = carServiceMapper.query(3, driverService.selectById(driverId).getCarId());
            Map<String, Object> query1 = linePriceMapper.query(lineShift.getLineId(), query.getServerCarModelId());
            if(null == query1){
                return ResultUtil.error("该线路还未设置服务车型相关数据,请联系管理员!");
            }
            CarModel carModel = carModelMapper.selectById(carService.selectById(driverService.selectById(driverId).getCarId()).getCarModelId());
            LineShiftDriver lineShiftDriver = new LineShiftDriver();
            lineShiftDriver.setLineShiftId(lineShiftId);
            lineShiftDriver.setDriverId(driverId);
            lineShiftDriver.setDay(date.get("startTime"));
            lineShiftDriver.setLaveSeat(carModel.getSeat() - 1);
            String seatNumber = "";
            for(int i = 1; i < carModel.getSeat(); i++){
                seatNumber += i + ",";
            }
            lineShiftDriver.setLaveSeatNumber(seatNumber.substring(0, seatNumber.length() - 1));
            lineShiftDriver.setTotalSeat(carModel.getSeat() - 1);
            lineShiftDriver.setInserTime(new Date());
            lineShiftDriverMapper.insert(lineShiftDriver);
        }
        if(type == 2){//取消预约
            Integer id = startTime.get(0).getId();
            int i = orderCrossCityService.selectCount(
                    new EntityWrapper<OrderCrossCity>()
                            .eq("driverId", driverId)
                            .eq("lineShiftDriverId", id)
                            .eq("isDelete", 1)
                            .in("state", Arrays.asList(2, 3, 4, 5, 6, 7, 8, 9, 11))
            );
            if(i > 0){
                return ResultUtil.error("班次已使用,不允许取消");
            }
 
            lineShiftDriverMapper.deleteById(id);
        }
        return ResultUtil.success();
    }
 
 
 
    /**
     * 判断当前预约的班次时间与之前已经预约的班次时间的间隔是否大于设定的间隔时间
     * @param driverId
     * @param shiftId
     * @param day
     * @return
     */
    public boolean judgeTime(Integer driverId, Integer shiftId, Date day) throws Exception{
        //获取当前预约班次的开始时间
        LineShift lineShift = lineShiftMapper.selectById(shiftId);
        String startTime = lineShift.getStartTime();//需要预约的班次开始时间
        String endTime1 = lineShift.getEndTime();//需要预约的班次结束时间
 
        List<Integer> list = new ArrayList<>();//存储给定天的预约的班次
        List<LineShiftDriver> lineShiftDrivers = lineShiftDriverMapper.queryByDriver(null, driverId, day);
        for(LineShiftDriver lineShiftDriver : lineShiftDrivers){
            list.add(lineShiftDriver.getLineShiftId());
        }
 
        if(list.size() == 0){
            return false;
        }
 
        List<LineShift> lineShifts_ = lineShiftMapper.selectList(new EntityWrapper<LineShift>().eq("lineId", lineShift.getLineId()).eq("state", 1).orderBy("endTime"));
        int index = 0;//需要预约的数据下标
        for(int i = 0; i < lineShifts_.size(); i++){
            if(startTime.equals(lineShifts_.get(i).getStartTime()) && endTime1.equals(lineShifts_.get(i).getEndTime())){
                index = i;
                break;
            }
        }
 
        //找出预约数据最近的预约了的数据
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-DD HH:mm:ss");
        Integer shiftInterval = lineService.selectById(lineShift.getLineId()).getShiftInterval();//获取可预约的间隔(分钟)
        long time = simpleDateFormat.parse("1999-01-01 " + startTime + ":00").getTime();//当前预约的班次的开始时间
        long time1 = simpleDateFormat.parse("1999-01-01 " + endTime1 + ":00").getTime();//当前预约的班次的结束时间
        if(index == 0 && lineShifts_.size() > 1){
            for(LineShift lineShift1 : lineShifts_){
                if(list.contains(lineShift1.getId())){
                    long s = simpleDateFormat.parse("1999-01-01 " + lineShift1.getStartTime() + ":00").getTime();
                    long e = simpleDateFormat.parse("1999-01-01 " + lineShift1.getEndTime() + ":00").getTime();
                    if((s - time1) < (Long.valueOf(shiftInterval) * 60 * 1000)){
                        return true;
                    }
                }
            }
            return false;
        }
        if(index == lineShifts_.size() - 1 && lineShifts_.size() > 1){
            for(LineShift lineShift1 : lineShifts_){
                if(list.contains(lineShift1.getId())){
                    long s = simpleDateFormat.parse("1999-01-01 " + lineShift1.getStartTime() + ":00").getTime();
                    long e = simpleDateFormat.parse("1999-01-01 " + lineShift1.getEndTime() + ":00").getTime();
                    if((time - e) < (Long.valueOf(shiftInterval) * 60 * 1000)){
                        return true;
                    }
                }
            }
            return false;
        }
        if(index > 0 && index < lineShifts_.size() - 1 && lineShifts_.size() > 2){
            for(int i = index + 1; i < lineShifts_.size(); i++){
                if(list.contains(lineShifts_.get(i).getId())){
                    long s = simpleDateFormat.parse("1999-01-01 " + lineShifts_.get(i).getStartTime() + ":00").getTime();
                    long e = simpleDateFormat.parse("1999-01-01 " + lineShifts_.get(i).getEndTime() + ":00").getTime();
                    if((s - time1) < (Long.valueOf(shiftInterval) * 60 * 1000)){
                        return true;
                    }
                }
            }
            for(int i = 0; i < index; i++){
                if(list.contains(lineShifts_.get(i).getId())){
                    long s = simpleDateFormat.parse("1999-01-01 " + lineShifts_.get(i).getStartTime() + ":00").getTime();
                    long e = simpleDateFormat.parse("1999-01-01 " + lineShifts_.get(i).getEndTime() + ":00").getTime();
                    if((time - e) < (Long.valueOf(shiftInterval) * 60 * 1000)){
                        return true;
                    }
                }
            }
            return false;
        }
        return false;
    }
}