package com.zbkj.admin.service.impl;
|
|
import cn.hutool.core.date.DateTime;
|
import cn.hutool.core.date.DateUtil;
|
import cn.hutool.core.util.ObjectUtil;
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.github.pagehelper.Page;
|
import com.github.pagehelper.PageHelper;
|
import com.github.pagehelper.PageInfo;
|
import com.zbkj.admin.filter.TokenComponent;
|
import com.zbkj.admin.manager.AdminLineUpWebSocketHandler;
|
import com.zbkj.admin.manager.BigScreenWebSocketHandler;
|
import com.zbkj.common.constants.VehicleInfoConstants;
|
import com.zbkj.common.exception.CarException;
|
import com.zbkj.common.model.sms.SmsTemplate;
|
import com.zbkj.common.model.system.AdminAreaRelation;
|
import com.zbkj.common.model.system.SystemNotification;
|
import com.zbkj.common.model.vehicle.EbVehicleInfo;
|
import com.zbkj.common.model.system.SystemGroupData;
|
import com.zbkj.common.page.CommonPage;
|
import com.zbkj.common.request.AddEbVehicleInfoListReq;
|
import com.zbkj.common.request.AddEbVehicleInfoReq;
|
import com.zbkj.common.request.EditEbVehicleInfoReq;
|
import com.zbkj.common.request.PageEbVehicleInfoReq;
|
import com.zbkj.common.response.EbVehicleInfoRep;
|
import com.zbkj.common.response.PageEbVehicleInfoRep;
|
import com.zbkj.common.response.VehicleInfoStatistics;
|
import com.zbkj.common.response.VehicleScreenResponse;
|
import com.zbkj.common.utils.MiracleAECUtil;
|
import com.zbkj.common.utils.RedisUtil;
|
import com.zbkj.common.utils.SendSmsUtils;
|
import com.zbkj.common.vo.SendSmsVo;
|
import com.zbkj.service.dao.EbVehicleInfoDao;
|
import com.zbkj.admin.service.EbVehicleInfoService;
|
import com.zbkj.service.service.AdminAreaRelationService;
|
import com.zbkj.service.service.SmsTemplateService;
|
import com.zbkj.service.service.SystemGroupDataService;
|
import com.zbkj.service.service.SystemNotificationService;
|
import lombok.SneakyThrows;
|
import lombok.extern.slf4j.Slf4j;
|
import lombok.val;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import javax.servlet.http.HttpServletRequest;
|
import java.time.LocalDateTime;
|
import java.util.*;
|
import java.util.concurrent.TimeUnit;
|
import java.util.stream.Collectors;
|
|
@Slf4j
|
@Service
|
public class EbVehicleInfoServiceImpl extends ServiceImpl<EbVehicleInfoDao, EbVehicleInfo> implements EbVehicleInfoService {
|
|
@Autowired
|
private SystemGroupDataService systemGroupDataService;
|
|
private final BigScreenWebSocketHandler webSocketHandler;
|
|
private final AdminLineUpWebSocketHandler lineUpWebSocketHandler;
|
|
@Autowired
|
private TokenComponent tokenComponent;
|
|
@Autowired
|
private AdminAreaRelationService adminAreaRelationService;
|
|
@Autowired
|
private RedisUtil redisUtil;
|
|
@Autowired
|
private SystemNotificationService systemNotificationService;
|
|
@Autowired
|
private SmsTemplateService smsTemplateService;
|
|
@Value("${car-manager.sms.apiKey}")
|
private String smsApiKey;
|
@Value("${car-manager.sms.apiSecret}")
|
private String smsApiSecret;
|
@Value("${car-manager.sms.signName}")
|
private String smsSignName;
|
|
@Autowired
|
public EbVehicleInfoServiceImpl(BigScreenWebSocketHandler webSocketHandler, AdminLineUpWebSocketHandler lineUpWebSocketHandler) {
|
this.webSocketHandler = webSocketHandler;
|
this.lineUpWebSocketHandler = lineUpWebSocketHandler;
|
}
|
|
|
/**
|
* @Description:添加车辆信息
|
* @author:chenbing
|
* @date 2025/7/3 9:56
|
*/
|
@SneakyThrows
|
@Override
|
@Transactional
|
public List<EbVehicleInfoRep> add(AddEbVehicleInfoListReq request) {
|
List<EbVehicleInfoRep> ebVehicleInfoRepList = new ArrayList<>();
|
List<EbVehicleInfo> ebVehicleInfoList = new ArrayList<>();
|
|
final HashMap<String, DateTime> stringDateTimeHashMap = checkTime();
|
final DateTime startDateTime = stringDateTimeHashMap.get("startDateTime");
|
final DateTime endDateTime = stringDateTimeHashMap.get("endDateTime");
|
|
for (AddEbVehicleInfoReq addEbVehicleInfoReq : request.getAddEbVehicleInfoList()) {
|
EbVehicleInfo ebVehicleInfo = new EbVehicleInfo();
|
BeanUtils.copyProperties(addEbVehicleInfoReq, ebVehicleInfo);
|
ebVehicleInfo.setLoadingAreaCode(addEbVehicleInfoReq.getLoadingAreaCode());
|
//判断当前时间段中是否有数据,并获取当前时间段中最大的排队号码
|
//生成排队号码（生成规则：长度为8位数字，从00000001开始，99999999结束）
|
String maxQueueNumber = baseMapper.selectMaxQueueNumber(DateUtil.format(startDateTime, "yyyy-MM-dd HH:mm:ss"), DateUtil.format(endDateTime, "yyyy-MM-dd HH:mm:ss"));
|
int nextNumber = (maxQueueNumber == null) ? 1 : Integer.parseInt(maxQueueNumber) + 1;
|
final String maxSort = baseMapper.selectMaxSort(DateUtil.format(startDateTime, "yyyy-MM-dd HH:mm:ss"), DateUtil.format(endDateTime, "yyyy-MM-dd HH:mm:ss"));
|
int nextSort = (maxSort == null) ? 1 : Integer.parseInt(maxSort) + 1;
|
ebVehicleInfo.setQueueNumber(nextNumber);
|
ebVehicleInfo.setSort(nextSort);
|
ebVehicleInfo.setRegisterTime(DateTime.now());
|
ebVehicleInfo.setLinkCode(generateRandomString());
|
final boolean save = save(ebVehicleInfo);
|
if (!save) {
|
throw new CarException("添加车辆信息失败");
|
}
|
ebVehicleInfoList.add(ebVehicleInfo);
|
}
|
for (EbVehicleInfo ebVehicleInfo : ebVehicleInfoList) {
|
if (ebVehicleInfo.getIsPrint()) {
|
EbVehicleInfoRep ebVehicleInfoRep = getVehicleInfoById(ebVehicleInfo.getId(), null, null, null, true);
|
ebVehicleInfoRepList.add(ebVehicleInfoRep);
|
}
|
}
|
final HashMap<String, Object> a = screen("添加车辆信息");
|
webSocketHandler.broadcast(JSONObject.toJSONString(a));
|
lineUpWebSocketHandler.broadcast("update");
|
|
new Thread(() -> {
|
for (EbVehicleInfoRep ebVehicleInfo : ebVehicleInfoRepList) {
|
// if (!ebVehicleInfo.getSendSms()) {
|
// log.error("添加车辆信息时未开启发送叫号短信");
|
// continue;
|
// }
|
final SystemNotification systemNotification = systemNotificationService.getByMark(VehicleInfoConstants.REGISTRATION_SUCCESSFUL);
|
if (systemNotification.getIsSms() != 1) {
|
log.error("短信通知未开启");
|
continue;
|
}
|
//发送短信验证码
|
HashMap<String, Object> justPram = new HashMap<>();
|
justPram.put("preNumber", ebVehicleInfo.getQueueNumber());
|
justPram.put("carNumber", ebVehicleInfo.getCurrentWaitNum());
|
justPram.put("time", ebVehicleInfo.getRegisterTime());
|
justPram.put("code", ebVehicleInfo.getLinkCode());
|
SendSmsVo sendSmsVo = new SendSmsVo();
|
sendSmsVo.setAccessKeyIdSms(smsApiKey);
|
sendSmsVo.setAccessKeySecretSms(smsApiSecret);
|
sendSmsVo.setSignName(smsSignName);
|
sendSmsVo.setTemplateParam(JSONObject.toJSONString(justPram));
|
final SmsTemplate smsTemplate = smsTemplateService.getDetail(systemNotification.getSmsId());
|
sendSmsVo.setTempLateCode(smsTemplate.getTempId());
|
sendSmsVo.setPhoneNumber(ebVehicleInfo.getPhone());
|
try {
|
SendSmsUtils.sendSms(sendSmsVo);
|
} catch (Exception e) {
|
log.error("发送短信通知异常 {}", e.getMessage());
|
log.error("发送短信通知失败，车辆信息：{}", JSONObject.toJSONString(ebVehicleInfo));
|
}
|
}
|
}).start();
|
return ebVehicleInfoRepList;
|
}
|
|
/**
|
* @Description:生成随机字符串
|
* @author:chenbing
|
* @date 2025/7/23 14:57
|
*/
|
public String generateRandomString() {
|
boolean grs = true;
|
String code = "";
|
while (grs) {
|
String characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
|
Random random = new Random();
|
StringBuilder sb = new StringBuilder(6);
|
|
for (int i = 0; i < 6; i++) {
|
int randomIndex = random.nextInt(characters.length());
|
char randomChar = characters.charAt(randomIndex);
|
sb.append(randomChar);
|
}
|
code = sb.toString();
|
if (count(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getLinkCode, code)) <= 0) {
|
grs = false;
|
}
|
}
|
return code;
|
}
|
|
@Override
|
public HashMap<String, DateTime> getSystemConfigTime(DateTime dateTime) {
|
//判断当前时间是否在上班时间内
|
final SystemGroupData systemGroupData = systemGroupDataService.getById(VehicleInfoConstants.TIME_CONFIG_ID);
|
if (systemGroupData == null) {
|
throw new CarException("未配置上班时间");
|
}
|
Integer validityHour = Integer.valueOf(getGroupDataValue(systemGroupData, "validity"));
|
Integer startTimeShangBanStr = Integer.valueOf(getGroupDataValue(systemGroupData, "startTime"));
|
String startTimeShangBan = startTimeShangBanStr >= 10 ? startTimeShangBanStr + ":00:00" : "0" + startTimeShangBanStr + ":00:00";
|
// 解析上班时间
|
DateTime startTime = DateUtil.parse(startTimeShangBan, "HH:mm:ss");
|
DateTime endTime = DateUtil.offsetHour(startTime, validityHour);
|
// 获取当前时间
|
DateTime now = DateTime.now();
|
if (dateTime != null) {
|
now = dateTime;
|
}
|
DateTime startDateTime = new DateTime();
|
DateTime endDateTime = new DateTime();
|
if (now.getHours() < startTime.getHours()) {
|
//如果当前小时数小于开始时间小时数，那么计算开始时间小时数就需要往前面推一天
|
final String start = DateUtil.format(DateUtil.offsetDay(now, -1), "yyyy-MM-dd " + startTimeShangBan);
|
startDateTime = DateUtil.parse(start, "yyyy-MM-dd HH:mm:ss");
|
endDateTime = DateUtil.offsetHour(startDateTime, validityHour);
|
} else {
|
final String start = DateUtil.format(now, "yyyy-MM-dd " + startTimeShangBan);
|
startDateTime = DateUtil.parse(start, "yyyy-MM-dd HH:mm:ss");
|
endDateTime = DateUtil.offsetHour(startDateTime, validityHour);
|
}
|
HashMap<String, DateTime> timeMap = new HashMap<>();
|
timeMap.put("startDateTime", startDateTime);
|
timeMap.put("endDateTime", endDateTime);
|
return timeMap;
|
}
|
|
/**
|
* @Description:检查时间
|
* @author:chenbing
|
* @date 2025/7/18 14:36
|
*/
|
private HashMap<String, DateTime> checkTime() {
|
//判断当前时间是否在上班时间内
|
final SystemGroupData systemGroupData = systemGroupDataService.getById(VehicleInfoConstants.TIME_CONFIG_ID);
|
if (systemGroupData == null) {
|
throw new CarException("未配置上班时间");
|
}
|
Integer validityHour = Integer.valueOf(getGroupDataValue(systemGroupData, "validity"));
|
Integer startTimeShangBanStr = Integer.valueOf(getGroupDataValue(systemGroupData, "startTime"));
|
// 处理上班时间判断逻辑
|
if (validityHour == 0) {
|
log.error("上班时长为0小时");
|
throw new CarException("当前时间不在上班时间内");
|
}
|
String startTimeShangBan = startTimeShangBanStr >= 10 ? startTimeShangBanStr + ":00:00" : "0" + startTimeShangBanStr + ":00:00";
|
// 解析上班时间
|
DateTime startTime = DateUtil.parse(startTimeShangBan, "HH:mm:ss");
|
DateTime endTime = DateUtil.offsetHour(startTime, validityHour);
|
// 获取当前时间
|
DateTime now = DateTime.now();
|
DateTime startDateTime = new DateTime();
|
DateTime endDateTime = new DateTime();
|
if (now.getHours() < startTime.getHours()) {
|
//如果当前小时数小于开始时间小时数，那么计算开始时间小时数就需要往前面推一天
|
final String start = DateUtil.format(DateUtil.offsetDay(now, -1), "yyyy-MM-dd " + startTimeShangBan);
|
startDateTime = DateUtil.parse(start, "yyyy-MM-dd HH:mm:ss");
|
endDateTime = DateUtil.offsetHour(startDateTime, validityHour);
|
} else {
|
final String start = DateUtil.format(now, "yyyy-MM-dd " + startTimeShangBan);
|
startDateTime = DateUtil.parse(start, "yyyy-MM-dd HH:mm:ss");
|
endDateTime = DateUtil.offsetHour(startDateTime, validityHour);
|
}
|
if (now.isAfter(endDateTime) || now.isBefore(startDateTime)) {
|
throw new CarException("当前时间不在上班时间内");
|
}
|
System.out.println("startDateTime = " + startDateTime);
|
System.out.println("endDateTime = " + endDateTime);
|
HashMap<String, DateTime> timeMap = new HashMap<>();
|
timeMap.put("startDateTime", startDateTime);
|
timeMap.put("endDateTime", endDateTime);
|
return timeMap;
|
}
|
|
private String getGroupDataValue(SystemGroupData systemGroupData, String key) {
|
String result = "";
|
final JSONObject data = JSONObject.parseObject(systemGroupData.getValue());
|
final JSONArray fields = data.getJSONArray("fields");
|
for (Object field : fields) {
|
JSONObject fieldJson = (JSONObject) field;
|
if (!fieldJson.containsValue(key)) {
|
continue;
|
}
|
result = fieldJson.getString("value");
|
}
|
return result;
|
}
|
|
/**
|
* @Description:修改车辆信息
|
* @author:chenbing
|
* @date 2025/7/3 10:49
|
*/
|
@Override
|
public boolean edit(EditEbVehicleInfoReq request) {
|
EbVehicleInfo ebVehicleInfo = getById(request.getId());
|
if (ObjectUtil.isNull(ebVehicleInfo)) {
|
throw new CarException("车辆信息不存在");
|
}
|
BeanUtils.copyProperties(request, ebVehicleInfo);
|
ebVehicleInfo.setUpdateTime(DateTime.now());
|
if (updateById(ebVehicleInfo)) {
|
webSocketHandler.broadcast(JSONObject.toJSONString(screen("修改车辆信息")));
|
lineUpWebSocketHandler.broadcast("update");
|
return true;
|
}
|
return false;
|
}
|
|
/**
|
* @Description:分页查询车辆信息
|
* @author:chenbing
|
* @date 2025/7/3 10:31
|
*/
|
@Override
|
public PageInfo<PageEbVehicleInfoRep> getPage(PageEbVehicleInfoReq request) {
|
Page<EbVehicleInfo> startPage = PageHelper.startPage(request.getPage(), request.getLimit());
|
LambdaQueryWrapper<EbVehicleInfo> lqw = new LambdaQueryWrapper<>();
|
if (ObjectUtil.isNotNull(request.getIdCard())) {
|
lqw.like(EbVehicleInfo::getIdCard, request.getIdCard());
|
}
|
if (ObjectUtil.isNotNull(request.getName())) {
|
lqw.like(EbVehicleInfo::getName, request.getName());
|
}
|
if (ObjectUtil.isNotNull(request.getPhone())) {
|
lqw.like(EbVehicleInfo::getPhone, request.getPhone());
|
}
|
if (ObjectUtil.isNotNull(request.getLicensePlate())) {
|
lqw.like(EbVehicleInfo::getLicensePlate, request.getLicensePlate());
|
}
|
if (ObjectUtil.isNotNull(request.getLoadingAreaCode())) {
|
lqw.eq(EbVehicleInfo::getLoadingAreaCode, request.getLoadingAreaCode());
|
}
|
if (ObjectUtil.isNotNull(request.getOrderTypeCode())) {
|
lqw.eq(EbVehicleInfo::getOrderTypeCode, request.getOrderTypeCode());
|
}
|
if (ObjectUtil.isNotNull(request.getLoadUnloadQtyMin()) && ObjectUtil.isNotNull(request.getLoadUnloadQtyMax())) {
|
lqw.between(EbVehicleInfo::getLoadUnloadQty, request.getLoadUnloadQtyMin(), request.getLoadUnloadQtyMax());
|
}
|
if (ObjectUtil.isNotNull(request.getUnitCode())) {
|
lqw.eq(EbVehicleInfo::getUnitCode, request.getUnitCode());
|
}
|
if (ObjectUtil.isNotNull(request.getVehicleStatusCode())) {
|
lqw.eq(EbVehicleInfo::getVehicleStatusCode, request.getVehicleStatusCode());
|
}
|
if (ObjectUtil.isNotNull(request.getGoodsStatusCode())) {
|
lqw.eq(EbVehicleInfo::getGoodsStatusCode, request.getGoodsStatusCode());
|
}
|
if (ObjectUtil.isNotNull(request.getQueueNumber())) {
|
lqw.like(EbVehicleInfo::getQueueNumber, request.getQueueNumber());
|
}
|
if (ObjectUtil.isNotNull(request.getReasonCode())) {
|
lqw.eq(EbVehicleInfo::getReasonCode, request.getReasonCode());
|
}
|
if (ObjectUtil.isNotNull(request.getRegisterTimeStart()) && ObjectUtil.isNotNull(request.getRegisterTimeEnd())) {
|
lqw.between(EbVehicleInfo::getRegisterTime, handleDate(request.getRegisterTimeStart(), true), handleDate(request.getRegisterTimeEnd(), false));
|
}
|
lqw.eq(EbVehicleInfo::getIsDel, false).orderByDesc(EbVehicleInfo::getRegisterTime);
|
List<EbVehicleInfo> ebVehicleInfoList = baseMapper.selectList(lqw);
|
if (ObjectUtil.isNotEmpty(ebVehicleInfoList)) {
|
return CommonPage.copyPageInfo(startPage, handleVehicleInfoList(ebVehicleInfoList));
|
}
|
return CommonPage.copyPageInfo(startPage, new ArrayList<>());
|
}
|
|
/**
|
* @param areaId 厂区ID
|
* @param queueNumber 排队号码
|
* @param phone 手机号
|
* @param page 当前页码，从1开始
|
* @param limit 每页显示记录数
|
* @Description:排队叫号列表
|
* @author:chenbing
|
* @date 2025/7/3 13:14
|
*/
|
@Override
|
public PageInfo<PageEbVehicleInfoRep> queueList(Integer areaId, Integer queueNumber, String phone, Integer page, Integer limit) {
|
LambdaQueryWrapper<EbVehicleInfo> lqw = new LambdaQueryWrapper<>();
|
lqw.eq(EbVehicleInfo::getLoadingAreaCode, areaId)
|
.in(EbVehicleInfo::getVehicleStatusCode, Arrays.asList(VehicleInfoConstants.SCREEN_STATUS_FILTER))
|
.eq(EbVehicleInfo::getIsDel, false).orderByAsc(EbVehicleInfo::getSort).orderByAsc(EbVehicleInfo::getQueueNumber);
|
if (ObjectUtil.isNotNull(queueNumber)) {
|
lqw.like(EbVehicleInfo::getQueueNumber, queueNumber);
|
}
|
if (ObjectUtil.isNotNull(phone)) {
|
lqw.like(EbVehicleInfo::getPhone, phone);
|
}
|
final HashMap<String, DateTime> systemConfigTime = getSystemConfigTime(null);
|
lqw.between(EbVehicleInfo::getRegisterTime, systemConfigTime.get("startDateTime"), systemConfigTime.get("endDateTime"));
|
Page<EbVehicleInfo> startPage = PageHelper.startPage(page, limit);
|
List<EbVehicleInfo> ebVehicleInfoList = baseMapper.selectList(lqw);
|
PageInfo<EbVehicleInfo> pageInfo = new PageInfo<>(startPage);
|
if (ObjectUtil.isNotEmpty(ebVehicleInfoList)) {
|
return CommonPage.copyPageInfo(pageInfo, handleVehicleInfoList(ebVehicleInfoList));
|
}
|
return CommonPage.copyPageInfo(startPage, new ArrayList<>());
|
}
|
|
/**
|
* @param vehicleId 车辆信息ID
|
* @param linkCode
|
* @Description:根据车辆ID查询车辆信息
|
* @author:chenbing
|
* @date 2025/7/3 14:31
|
*/
|
@Override
|
public EbVehicleInfoRep getVehicleInfoById(String vehicleId, Integer queueNumber, String linkCode, HttpServletRequest httpServletRequest, boolean isDriver) {
|
final HashMap<String, DateTime> systemConfigTime = getSystemConfigTime(null);
|
if (!isDriver) {
|
EbVehicleInfo ebVehicleInfo = getOne(new LambdaQueryWrapper<EbVehicleInfo>()
|
.eq(ObjectUtil.isNotNull(queueNumber), EbVehicleInfo::getQueueNumber, queueNumber)
|
.eq(ObjectUtil.isNotNull(linkCode), EbVehicleInfo::getLinkCode, linkCode)
|
.eq(EbVehicleInfo::getIsDel, false)
|
.between(EbVehicleInfo::getRegisterTime, systemConfigTime.get("startDateTime"), systemConfigTime.get("endDateTime")));
|
if (ObjectUtil.isNull(ebVehicleInfo)) {
|
throw new RuntimeException("车辆信息不存在");
|
}
|
//查询门卫权限
|
if (adminAreaRelationService.count(new LambdaQueryWrapper<AdminAreaRelation>().eq(AdminAreaRelation::getAdminId, tokenComponent.getLoginUser(httpServletRequest).getUser().getId()).eq(AdminAreaRelation::getAreaId, ebVehicleInfo.getLoadingAreaCode())) <= 0) {
|
throw new CarException("无权限核销该区域");
|
}
|
}
|
EbVehicleInfoRep pageEbVehicleInfoRep = new EbVehicleInfoRep();
|
// EbVehicleInfo ebVehicleInfo = null;
|
// if (ObjectUtil.isNotNull(vehicleId)) {
|
// ebVehicleInfo = getOne(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getId, vehicleId).eq(EbVehicleInfo::getIsDel, false)
|
// .between(EbVehicleInfo::getRegisterTime, systemConfigTime.get("startDateTime"), systemConfigTime.get("endDateTime")));
|
// }
|
// if (ObjectUtil.isNull(ebVehicleInfo)) {
|
// ebVehicleInfo = getOne(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getQueueNumber, queueNumber).eq(EbVehicleInfo::getIsDel, false)
|
// .between(EbVehicleInfo::getRegisterTime, systemConfigTime.get("startDateTime"), systemConfigTime.get("endDateTime")));
|
// }
|
EbVehicleInfo ebVehicleInfo = getOne(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getIsDel, false)
|
.eq(ObjectUtil.isNotNull(vehicleId), EbVehicleInfo::getId, vehicleId)
|
.eq(ObjectUtil.isNotNull(queueNumber), EbVehicleInfo::getQueueNumber, queueNumber)
|
.eq(ObjectUtil.isNotNull(linkCode), EbVehicleInfo::getLinkCode, linkCode)
|
.between(EbVehicleInfo::getRegisterTime, systemConfigTime.get("startDateTime"), systemConfigTime.get("endDateTime")));
|
BeanUtils.copyProperties(handleVehicleInfo(ebVehicleInfo), pageEbVehicleInfoRep);
|
//查询当前厂区所有车辆信息
|
List<EbVehicleInfo> ebVehicleInfos = list(new LambdaQueryWrapper<EbVehicleInfo>()
|
// .between(EbVehicleInfo::getRegisterTime, DateUtil.format(DateUtil.beginOfDay(new Date()), "yyyy-MM-dd HH:mm:ss"), DateUtil.format(DateUtil.endOfDay(new Date()), "yyyy-MM-dd HH:mm:ss"))
|
// .in(EbVehicleInfo::getVehicleStatusCode, Arrays.asList(VehicleInfoConstants.QUEUE_STATUS_FILTER))
|
.eq(EbVehicleInfo::getVehicleStatusCode, VehicleInfoConstants.QUEUE_STATUS_UNDERWAY)
|
.eq(EbVehicleInfo::getLoadingAreaCode, ebVehicleInfo.getLoadingAreaCode())
|
.eq(EbVehicleInfo::getIsDel, false)
|
.between(EbVehicleInfo::getRegisterTime, systemConfigTime.get("startDateTime"), systemConfigTime.get("endDateTime"))
|
.orderByAsc(EbVehicleInfo::getSort).orderByAsc(EbVehicleInfo::getQueueNumber));
|
//判断vehicleId在ebVehicleInfos中的哪一个item中
|
if (!ebVehicleInfos.isEmpty()) {
|
int waitCount = ebVehicleInfos.indexOf(ebVehicleInfo);
|
pageEbVehicleInfoRep.setCurrentWaitNum(waitCount);
|
} else {
|
pageEbVehicleInfoRep.setCurrentWaitNum(0);
|
}
|
//查询当前车辆关联的所有厂区
|
List<String> loadingAreaNames = new ArrayList<>();
|
list(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getMasterId, ebVehicleInfo.getMasterId())).forEach(ebVehicleInfo1 -> {
|
loadingAreaNames.add(handleDataTeam(ebVehicleInfo1.getLoadingAreaCode(), "name"));
|
});
|
if (loadingAreaNames.size() > 1) {
|
pageEbVehicleInfoRep.setLoadingAreaName(StringUtils.join(loadingAreaNames, ","));
|
} else {
|
pageEbVehicleInfoRep.setLoadingAreaName(loadingAreaNames.get(0));
|
}
|
return pageEbVehicleInfoRep;
|
}
|
|
public Integer passCarNumber(String vehicleId) {
|
final HashMap<String, DateTime> systemConfigTime = getSystemConfigTime(null);
|
EbVehicleInfo ebVehicleInfo = getOne(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getIsDel, false)
|
.eq(ObjectUtil.isNotNull(vehicleId), EbVehicleInfo::getId, vehicleId)
|
.between(EbVehicleInfo::getRegisterTime, systemConfigTime.get("startDateTime"), systemConfigTime.get("endDateTime")));
|
//查询当前正在排队中的车辆数量
|
return count(new LambdaQueryWrapper<EbVehicleInfo>()
|
.eq(EbVehicleInfo::getVehicleStatusCode, VehicleInfoConstants.QUEUE_STATUS_UNDERWAY)
|
.eq(EbVehicleInfo::getLoadingAreaCode, ebVehicleInfo.getLoadingAreaCode())
|
.eq(EbVehicleInfo::getIsDel, false)
|
.between(EbVehicleInfo::getRegisterTime, systemConfigTime.get("startDateTime"), systemConfigTime.get("endDateTime"))
|
.orderByAsc(EbVehicleInfo::getSort).orderByAsc(EbVehicleInfo::getQueueNumber));
|
}
|
|
/**
|
* @param masterId 关联关系ID
|
* @Description:门卫-车辆入厂核销
|
* @author:chenbing
|
* @date 2025/7/3 14:51
|
*/
|
@Override
|
public boolean vehicleIn(String masterId, HttpServletRequest httpServletRequest) {
|
checkAdminAuth(masterId, httpServletRequest);
|
if (update(new UpdateWrapper<EbVehicleInfo>().set("vehicle_status_code", VehicleInfoConstants.QUEUE_STATUS_ENTERED)
|
.set("enter_time", DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss")).eq("master_id", masterId))) {
|
webSocketHandler.broadcast(JSONObject.toJSONString(screen("车辆入厂核销")));
|
lineUpWebSocketHandler.broadcast("update");
|
return true;
|
}
|
return false;
|
}
|
|
/**
|
* @Description:检查门卫权限
|
* @author:chenbing
|
* @date 2025/7/18 15:14
|
*/
|
private void checkAdminAuth(String masterId, HttpServletRequest httpServletRequest) {
|
EbVehicleInfo ebVehicleInfo = getOne(new LambdaQueryWrapper<EbVehicleInfo>()
|
.eq(ObjectUtil.isNotNull(masterId), EbVehicleInfo::getMasterId, masterId)
|
// .eq(EbVehicleInfo::getIsPrint, true)
|
.eq(EbVehicleInfo::getIsCall, true)
|
.eq(EbVehicleInfo::getIsDel, false));
|
if (ObjectUtil.isNull(ebVehicleInfo)) {
|
throw new RuntimeException("车辆信息不存在");
|
}
|
//查询门卫权限
|
if (adminAreaRelationService.count(new LambdaQueryWrapper<AdminAreaRelation>().eq(AdminAreaRelation::getAdminId, tokenComponent.getLoginUser(httpServletRequest).getUser().getId()).eq(AdminAreaRelation::getAreaId, ebVehicleInfo.getLoadingAreaCode())) <= 0) {
|
throw new CarException("无权限核销该区域");
|
}
|
}
|
|
/**
|
* @param masterId 关联关系ID
|
* @Description:门卫-车辆离厂核销
|
* @author:chenbing
|
* @date 2025/7/3 14:53
|
*/
|
@Override
|
public boolean vehicleOut(String masterId, HttpServletRequest httpServletRequest) {
|
checkAdminAuth(masterId, httpServletRequest);
|
if (update(new UpdateWrapper<EbVehicleInfo>().set("vehicle_status_code", VehicleInfoConstants.QUEUE_STATUS_LEFT)
|
.set("leave_time", DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss")).eq("master_id", masterId))) {
|
webSocketHandler.broadcast(JSONObject.toJSONString(screen("车辆离厂核销")));
|
lineUpWebSocketHandler.broadcast("update");
|
return true;
|
}
|
return false;
|
}
|
|
/**
|
* @Description:自动更新数据
|
* @author:chenbing
|
* @date 2025/7/23 11:09
|
*/
|
@Override
|
public void autoUpdateScreen() {
|
webSocketHandler.broadcast(JSONObject.toJSONString(screen("每小时定时更新")));
|
lineUpWebSocketHandler.broadcast("update");
|
}
|
|
/**
|
* @param card 身份证号
|
* @Description:根据身份证号获取最近的一条车辆信息数据
|
* @author:chenbing
|
* @date 2025/7/7 16:53
|
*/
|
@Override
|
public PageEbVehicleInfoRep getVehicleInfoByCard(String card) {
|
final List<EbVehicleInfo> ebVehicleInfos = list(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getIdCard, card).eq(EbVehicleInfo::getIsDel, false).orderByDesc(EbVehicleInfo::getRegisterTime));
|
if (ObjectUtil.isNotEmpty(ebVehicleInfos)) {
|
return handleVehicleInfo(ebVehicleInfos.get(0));
|
}
|
return null;
|
}
|
|
/**
|
* @Description:处理车辆信息列表
|
* @author:chenbing
|
* @date 2025/7/3 13:44
|
*/
|
private List<PageEbVehicleInfoRep> handleVehicleInfoList(List<EbVehicleInfo> ebVehicleInfoList) {
|
return ebVehicleInfoList.stream().map(this::handleVehicleInfo).collect(Collectors.toList());
|
}
|
|
|
/**
|
* @Description:处理车辆信息
|
* @author:chenbing
|
* @date 2025/7/3 14:43
|
*/
|
private PageEbVehicleInfoRep handleVehicleInfo(EbVehicleInfo ebVehicleInfo) {
|
PageEbVehicleInfoRep pageEbVehicleInfoRep = new PageEbVehicleInfoRep();
|
BeanUtils.copyProperties(ebVehicleInfo, pageEbVehicleInfoRep);
|
if (ObjectUtil.isNotNull(ebVehicleInfo.getLoadingAreaCode())) {
|
pageEbVehicleInfoRep.setLoadingAreaName(handleDataTeam(ebVehicleInfo.getLoadingAreaCode(), "name"));
|
}
|
if (ObjectUtil.isNotNull(ebVehicleInfo.getOrderTypeCode())) {
|
pageEbVehicleInfoRep.setOrderTypeName(handleDataTeam(ebVehicleInfo.getOrderTypeCode(), "name"));
|
}
|
if (ObjectUtil.isNotNull(ebVehicleInfo.getUnitCode())) {
|
pageEbVehicleInfoRep.setUnitName(handleDataTeam(ebVehicleInfo.getUnitCode(), "name"));
|
}
|
if (ObjectUtil.isNotNull(ebVehicleInfo.getVehicleStatusCode())) {
|
pageEbVehicleInfoRep.setVehicleStatusName(handleDataTeam(ebVehicleInfo.getVehicleStatusCode(), "name"));
|
}
|
if (ObjectUtil.isNotNull(ebVehicleInfo.getGoodsStatusCode())) {
|
pageEbVehicleInfoRep.setGoodsStatusName(handleDataTeam(ebVehicleInfo.getGoodsStatusCode(), "name"));
|
}
|
if (ObjectUtil.isNotNull(ebVehicleInfo.getReasonCode())) {
|
pageEbVehicleInfoRep.setReasonName(handleDataTeam(ebVehicleInfo.getReasonCode(), "name"));
|
}
|
if (ObjectUtil.isNotNull(ebVehicleInfo.getEnterTime())) {
|
pageEbVehicleInfoRep.setEnterTime(DateUtil.format(ebVehicleInfo.getEnterTime(), "yyyy-MM-dd HH:mm:ss"));
|
}
|
if (ObjectUtil.isNotNull(ebVehicleInfo.getLeaveTime())) {
|
pageEbVehicleInfoRep.setLeaveTime(DateUtil.format(ebVehicleInfo.getLeaveTime(), "yyyy-MM-dd HH:mm:ss"));
|
}
|
if (ObjectUtil.isNotNull(ebVehicleInfo.getRegisterTime())) {
|
pageEbVehicleInfoRep.setRegisterTime(DateUtil.format(ebVehicleInfo.getRegisterTime(), "yyyy-MM-dd HH:mm:ss"));
|
}
|
return pageEbVehicleInfoRep;
|
}
|
|
|
/**
|
* @Description:大屏数据
|
* @author:chenbing
|
* @date 2025/7/3 18:07
|
*/
|
@Override
|
public HashMap<String, Object> screen(String event) {
|
HashMap<String, Object> result = new HashMap<>();
|
int totalWaitCount = 0;
|
int totalCurrentCount = 0;
|
int totalOverCount = 0;
|
int totalCount = 0;
|
//查询出所有的厂区
|
List<SystemGroupData> systemGroupDataList = systemGroupDataService.list(new LambdaQueryWrapper<SystemGroupData>()
|
.eq(SystemGroupData::getGid, VehicleInfoConstants.LOADING_AREA_ID).eq(SystemGroupData::getStatus, true));
|
if (ObjectUtil.isEmpty(systemGroupDataList)) {
|
return null;
|
}
|
//遍历厂区
|
JSONArray jsonArray = new JSONArray();
|
for (SystemGroupData systemGroupData : systemGroupDataList) {
|
HashMap<String, Object> areaMap = new HashMap<>();
|
HashMap<String, Object> map = new HashMap<>();
|
//获取当前厂区名称
|
String loadingAreaName = handleDataTeam(systemGroupData.getId(), "name");
|
//查询当前厂区所有车辆信息
|
// String registerTimeStart = DateUtil.format(DateUtil.beginOfDay(new Date()), "yyyy-MM-dd HH:mm:ss");
|
// String registerTimeEnd = DateUtil.format(DateUtil.endOfDay(new Date()), "yyyy-MM-dd HH:mm:ss");
|
final HashMap<String, DateTime> systemConfigTime = getSystemConfigTime(null);
|
String registerTimeStart = DateUtil.format(systemConfigTime.get("startDateTime"), "yyyy-MM-dd HH:mm:ss");
|
String registerTimeEnd = DateUtil.format(systemConfigTime.get("endDateTime"), "yyyy-MM-dd HH:mm:ss");
|
List<EbVehicleInfo> ebVehicleInfoList = list(new LambdaQueryWrapper<EbVehicleInfo>()
|
.between(EbVehicleInfo::getRegisterTime, registerTimeStart, registerTimeEnd)
|
.eq(EbVehicleInfo::getLoadingAreaCode, systemGroupData.getId())
|
.eq(EbVehicleInfo::getIsDel, false).orderByAsc(EbVehicleInfo::getSort)
|
.orderByAsc(EbVehicleInfo::getQueueNumber).last("LIMIT 27"));
|
//查询当前厂区统计数据
|
VehicleInfoStatistics vehicleInfoStatistics = new VehicleInfoStatistics();
|
if (ebVehicleInfoList.isEmpty()) {
|
map.put("vehicleInfoStatistics", vehicleInfoStatistics);
|
map.put("ebVehicleInfoList", new ArrayList<>());
|
// areaMap.put(loadingAreaName, map);
|
areaMap.put("name", loadingAreaName);
|
areaMap.put("value", map);
|
jsonArray.add(areaMap);
|
continue;
|
}
|
//统计等待车辆（车辆状态为：排队中、已叫号、已过号）的数量
|
long waitCount = ebVehicleInfoList.stream().filter(ebVehicleInfo ->
|
Arrays.asList(VehicleInfoConstants.QUEUE_STATUS_FILTER).contains(ebVehicleInfo.getVehicleStatusCode())).count();
|
vehicleInfoStatistics.setWaitingVehicleCount(Math.toIntExact(waitCount));
|
totalWaitCount += Math.toIntExact(waitCount);
|
//统计当前厂区车辆（车辆状态为：已入厂并且已打印）数量
|
long currentCount = ebVehicleInfoList.stream().filter(ebVehicleInfo ->
|
VehicleInfoConstants.QUEUE_STATUS_ENTERED.equals(ebVehicleInfo.getVehicleStatusCode()) && Boolean.TRUE.equals(ebVehicleInfo.getIsCall())).count();
|
vehicleInfoStatistics.setCurrentVehicleCount(Math.toIntExact(currentCount));
|
totalCurrentCount += Math.toIntExact(currentCount);
|
//统计已发货车辆（车辆状态为：已离厂）数量
|
long overCount = ebVehicleInfoList.stream().filter(ebVehicleInfo ->
|
VehicleInfoConstants.QUEUE_STATUS_LEFT.equals(ebVehicleInfo.getVehicleStatusCode())).count();
|
vehicleInfoStatistics.setShippedVehicleCount(Math.toIntExact(overCount));
|
totalOverCount += Math.toIntExact(overCount);
|
map.put("vehicleInfoStatistics", vehicleInfoStatistics);
|
//统计当前登记车辆总数量（等待车辆数量 + 当前厂区车辆数量 + 已发货车辆数量）
|
vehicleInfoStatistics.setCurrentLevelVehicleCount(Math.toIntExact(waitCount + currentCount + overCount));
|
totalCount += Math.toIntExact(waitCount + currentCount + overCount);
|
ebVehicleInfoList = ebVehicleInfoList.stream().filter(ebVehicleInfo -> Arrays.asList(VehicleInfoConstants.SCREEN_STATUS_FILTER).contains(ebVehicleInfo.getVehicleStatusCode())).collect(Collectors.toList());
|
List<VehicleScreenResponse> vehicleScreenResponseList = new ArrayList<>();
|
for (EbVehicleInfo ebVehicleInfo : ebVehicleInfoList) {
|
VehicleScreenResponse vehicleScreenResponse = new VehicleScreenResponse();
|
BeanUtils.copyProperties(ebVehicleInfo, vehicleScreenResponse);
|
vehicleScreenResponse.setVehicleStatusName(handleDataTeam(ebVehicleInfo.getVehicleStatusCode(), "name"));
|
vehicleScreenResponse.setRegisterTime(DateUtil.format(ebVehicleInfo.getRegisterTime(), "yyyy-MM-dd HH:mm:ss"));
|
vehicleScreenResponse.setName(getName(ebVehicleInfo.getName()));
|
vehicleScreenResponse.setLicensePlate(getLicensePlate(ebVehicleInfo.getLicensePlate()));
|
vehicleScreenResponse.setPhone(getPhone(ebVehicleInfo.getPhone()));
|
vehicleScreenResponseList.add(vehicleScreenResponse);
|
}
|
map.put("ebVehicleInfoList", vehicleScreenResponseList);
|
// areaMap.put(loadingAreaName, map);
|
areaMap.put("name", loadingAreaName);
|
areaMap.put("value", map);
|
jsonArray.add(areaMap);
|
}
|
result.put("areaList", jsonArray);
|
HashMap<String, Object> totalMap = new HashMap<>();
|
totalMap.put("totalWaitCount", totalWaitCount);
|
totalMap.put("totalCurrentCount", totalCurrentCount);
|
totalMap.put("totalOverCount", totalOverCount);
|
totalMap.put("totalCount", totalCount);
|
result.put("total", totalMap);
|
result.put("time", DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss"));
|
result.put("event", event);
|
// 创建一个新的 HashMap 并复制 result 的内容
|
HashMap<String, Object> result1 = new HashMap<>(result);
|
result1.put("event", "建立连接返回数据");
|
redisUtil.set("screen-data", JSONObject.toJSONString(result1));
|
return result;
|
}
|
|
public String getName(String name) {
|
if (StringUtils.isEmpty(name) || name.length() < 2) {
|
return name;
|
}
|
// Java 8 兼容方案
|
return name.charAt(0) + String.join("", Collections.nCopies(name.length() - 1, "*"));
|
}
|
|
public String getLicensePlate(String licensePlate) {
|
// if (StringUtils.isEmpty(licensePlate) || licensePlate.length() < 3) {
|
// return licensePlate;
|
// }
|
// // Java 8 兼容方案
|
// return licensePlate.substring(0, 2) +
|
// String.join("", Collections.nCopies(licensePlate.length() - 4, "*")) +
|
// licensePlate.substring(licensePlate.length() - 2);
|
if (StringUtils.isEmpty(licensePlate)) {
|
return licensePlate;
|
}
|
if (licensePlate.length() <= 2) {
|
// 长度小于等于 2 时，不进行脱敏处理
|
return licensePlate;
|
}
|
// 提取首尾字符
|
String firstChar = licensePlate.substring(0, 1);
|
String lastChar = licensePlate.substring(licensePlate.length() - 1);
|
// 生成中间的 * 字符串
|
String maskedPart = String.join("", Collections.nCopies(licensePlate.length() - 2, "*"));
|
return firstChar + maskedPart + lastChar;
|
}
|
|
public String getPhone(String phone) {
|
if (StringUtils.isEmpty(phone) || phone.length() != 11) {
|
return phone;
|
}
|
return phone.substring(0, 3) + "****" + phone.substring(7);
|
}
|
|
/**
|
* @param areaId 厂区ID
|
* @Description:根据厂区ID统计车辆信息数据
|
* @author:chenbing
|
* @date 2025/7/3 13:29
|
*/
|
@Override
|
public VehicleInfoStatistics statistics(Integer areaId) {
|
VehicleInfoStatistics vehicleInfoStatistics = new VehicleInfoStatistics();
|
//根据厂区ID查询当前厂区车辆最大数量
|
Integer maxCount = Integer.parseInt(handleDataTeam(areaId, "maxcount"));
|
vehicleInfoStatistics.setMaxVehicleCount(maxCount);
|
//查询当前厂区所有车辆信息
|
final HashMap<String, DateTime> systemConfigTime = getSystemConfigTime(null);
|
List<EbVehicleInfo> ebVehicleInfoList = list(new LambdaQueryWrapper<EbVehicleInfo>()
|
.between(EbVehicleInfo::getRegisterTime, systemConfigTime.get("startDateTime"), systemConfigTime.get("endDateTime"))
|
.eq(EbVehicleInfo::getLoadingAreaCode, areaId)
|
.eq(EbVehicleInfo::getIsDel, false));
|
if (ebVehicleInfoList.isEmpty()) {
|
return vehicleInfoStatistics;
|
}
|
//统计等待车辆（车辆状态为：排队中、已叫号、已过号）的数量
|
long waitCount = ebVehicleInfoList.stream().filter(ebVehicleInfo ->
|
Arrays.asList(VehicleInfoConstants.QUEUE_STATUS_FILTER).contains(ebVehicleInfo.getVehicleStatusCode())).count();
|
vehicleInfoStatistics.setWaitingVehicleCount(Math.toIntExact(waitCount));
|
//统计当前厂区车辆（车辆状态为：已入厂并且已叫号）数量
|
long currentCount = ebVehicleInfoList.stream().filter(ebVehicleInfo ->
|
VehicleInfoConstants.QUEUE_STATUS_ENTERED.equals(ebVehicleInfo.getVehicleStatusCode()) && Boolean.TRUE.equals(ebVehicleInfo.getIsCall())).count();
|
vehicleInfoStatistics.setCurrentVehicleCount(Math.toIntExact(currentCount));
|
//统计已发货车辆（车辆状态为：已离厂）数量
|
long overCount = ebVehicleInfoList.stream().filter(ebVehicleInfo ->
|
VehicleInfoConstants.QUEUE_STATUS_LEFT.equals(ebVehicleInfo.getVehicleStatusCode())).count();
|
vehicleInfoStatistics.setShippedVehicleCount(Math.toIntExact(overCount));
|
//统计当前登记车辆总数量（等待车辆数量 + 当前厂区车辆数量 + 已发货车辆数量）
|
vehicleInfoStatistics.setCurrentLevelVehicleCount(Math.toIntExact(waitCount + currentCount + overCount));
|
return vehicleInfoStatistics;
|
}
|
|
private String handleDate(String date, Boolean begin) {
|
if (!begin) {
|
return date + " 23:59:59";
|
}
|
return date + " 00:00:00";
|
}
|
|
/**
|
* @param vehicleId 车辆信息ID
|
* @param sort 排序
|
* @Description:调整排序
|
* @author:chenbing
|
* @date 2025/7/3 14:11
|
*/
|
@Override
|
public boolean sort(String vehicleId, Integer sort) {
|
EbVehicleInfo ebVehicleInfo = getOne(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getId, vehicleId).eq(EbVehicleInfo::getIsDel, false));
|
if (ObjectUtil.isNull(ebVehicleInfo)) {
|
throw new CarException("车辆信息不存在");
|
}
|
if (update(new UpdateWrapper<EbVehicleInfo>().set("sort", sort).eq("id", vehicleId))) {
|
lineUpWebSocketHandler.broadcast("update");
|
return true;
|
}
|
return false;
|
}
|
|
/**
|
* @param vehicleId 车辆信息ID
|
* @Description:手动叫号
|
* @author:chenbing
|
* @date 2025/7/3 14:15
|
*/
|
@Override
|
public boolean callNumber(String vehicleId) {
|
EbVehicleInfo ebVehicleInfo = getOne(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getId, vehicleId).eq(EbVehicleInfo::getIsDel, false));
|
if (update(new UpdateWrapper<EbVehicleInfo>().set("vehicle_status_code", VehicleInfoConstants.QUEUE_STATUS_CALLED).set("call_time", LocalDateTime.now()).eq("master_id", ebVehicleInfo.getMasterId()))) {
|
//设置 手动叫号 的车辆信息 is_call 为 true
|
update(new UpdateWrapper<EbVehicleInfo>().set("is_call", true).eq("id", vehicleId));
|
if (!ebVehicleInfo.getSendSms()) {
|
//todo 发送短信提醒
|
webSocketHandler.broadcast(JSONObject.toJSONString(screen("手动叫号")));
|
lineUpWebSocketHandler.broadcast("update");
|
return true;
|
}
|
final SystemNotification systemNotification = systemNotificationService.getByMark(VehicleInfoConstants.CALL_THE_NUMBER_TO_ENTER_THE_FACTORY);
|
if (systemNotification.getIsSms() != 1) {
|
webSocketHandler.broadcast(JSONObject.toJSONString(screen("手动叫号")));
|
lineUpWebSocketHandler.broadcast("update");
|
return true;
|
}
|
//发送短信验证码
|
HashMap<String, Object> justPram = new HashMap<>();
|
justPram.put("areaName", handleDataTeam(ebVehicleInfo.getLoadingAreaCode(), "name"));
|
justPram.put("code", ebVehicleInfo.getLinkCode());
|
SendSmsVo sendSmsVo = new SendSmsVo();
|
sendSmsVo.setAccessKeyIdSms(smsApiKey);
|
sendSmsVo.setAccessKeySecretSms(smsApiSecret);
|
sendSmsVo.setSignName(smsSignName);
|
sendSmsVo.setTemplateParam(JSONObject.toJSONString(justPram));
|
final SmsTemplate smsTemplate = smsTemplateService.getDetail(systemNotification.getSmsId());
|
sendSmsVo.setTempLateCode(smsTemplate.getTempId());
|
sendSmsVo.setPhoneNumber(ebVehicleInfo.getPhone());
|
try {
|
Boolean sendSms = SendSmsUtils.sendSms(sendSmsVo);
|
if (!sendSms) {
|
log.error("发送短信通知失败，车辆信息：{}", JSONObject.toJSONString(ebVehicleInfo));
|
}
|
} catch (Exception e) {
|
log.error("发送短信通知异常 {}", e.getMessage());
|
}
|
webSocketHandler.broadcast(JSONObject.toJSONString(screen("手动叫号")));
|
lineUpWebSocketHandler.broadcast("update");
|
return true;
|
}
|
return false;
|
}
|
|
/**
|
* 不是已叫号的状态，提示当前车辆未叫号
|
*
|
* @param vehicleId 车辆信息ID
|
* @Description:发送短信提醒
|
* @author:chenbing
|
* @date 2025/8/4 18:26
|
*/
|
@SneakyThrows
|
@Override
|
public boolean sendSms(String vehicleId) {
|
EbVehicleInfo ebVehicleInfo = getOne(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getId, vehicleId).eq(EbVehicleInfo::getIsDel, false));
|
final SystemNotification systemNotification = systemNotificationService.getByMark(VehicleInfoConstants.CALL_THE_NUMBER_TO_ENTER_THE_FACTORY);
|
if (systemNotification.getIsSms() != 1) {
|
throw new CarException("当前通知设置未开启短信通知");
|
}
|
//发送短信验证码
|
HashMap<String, Object> justPram = new HashMap<>();
|
justPram.put("areaName", handleDataTeam(ebVehicleInfo.getLoadingAreaCode(), "name"));
|
justPram.put("code", ebVehicleInfo.getLinkCode());
|
SendSmsVo sendSmsVo = new SendSmsVo();
|
sendSmsVo.setAccessKeyIdSms(smsApiKey);
|
sendSmsVo.setAccessKeySecretSms(smsApiSecret);
|
sendSmsVo.setSignName(smsSignName);
|
sendSmsVo.setTemplateParam(JSONObject.toJSONString(justPram));
|
final SmsTemplate smsTemplate = smsTemplateService.getDetail(systemNotification.getSmsId());
|
sendSmsVo.setTempLateCode(smsTemplate.getTempId());
|
sendSmsVo.setPhoneNumber(ebVehicleInfo.getPhone());
|
Boolean sendSms = SendSmsUtils.sendSms(sendSmsVo);
|
if (!sendSms) {
|
log.error("发送短信通知失败，车辆信息：{}", JSONObject.toJSONString(ebVehicleInfo));
|
throw new CarException("发送短信通知失败");
|
}
|
return true;
|
}
|
|
public boolean autoCallNumber(String masterId, String vehicleId) {
|
if (update(new UpdateWrapper<EbVehicleInfo>().set("vehicle_status_code", VehicleInfoConstants.QUEUE_STATUS_CALLED).set("call_time", LocalDateTime.now()).eq("master_id", masterId))) {
|
//设置 自动叫号 的车辆信息 is_call 为 true
|
return update(new UpdateWrapper<EbVehicleInfo>().set("is_call", true).eq("id", vehicleId));
|
}
|
return false;
|
}
|
|
/**
|
* @param masterId 关联关系ID
|
* @Description:标记为已过号
|
* @author:chenbing
|
* @date 2025/7/3 14:16
|
*/
|
@Override
|
public boolean passNumber(String masterId) {
|
final EbVehicleInfo ebVehicleInfo = getOne(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getMasterId, masterId).eq(EbVehicleInfo::getIsCall, true).eq(EbVehicleInfo::getIsDel, false));
|
if (update(new UpdateWrapper<EbVehicleInfo>().set("vehicle_status_code", VehicleInfoConstants.QUEUE_STATUS_PASSED).set("is_call", false).eq("master_id", masterId))) {
|
webSocketHandler.broadcast(JSONObject.toJSONString(screen("标记为已过号")));
|
lineUpWebSocketHandler.broadcast("update");
|
//todo 发送短信提醒
|
final SystemNotification systemNotification = systemNotificationService.getByMark(VehicleInfoConstants.PASS_NUMBER_SMS);
|
if (systemNotification.getIsSms() != 1) {
|
return true;
|
}
|
//发送短信验证码
|
HashMap<String, Object> justPram = new HashMap<>();
|
justPram.put("preNumber", ebVehicleInfo.getQueueNumber());
|
justPram.put("areaName", handleDataTeam(ebVehicleInfo.getLoadingAreaCode(), "name"));
|
justPram.put("carNumber", passCarNumber(ebVehicleInfo.getId()));
|
SendSmsVo sendSmsVo = new SendSmsVo();
|
sendSmsVo.setAccessKeyIdSms(smsApiKey);
|
sendSmsVo.setAccessKeySecretSms(smsApiSecret);
|
sendSmsVo.setSignName(smsSignName);
|
sendSmsVo.setTemplateParam(JSONObject.toJSONString(justPram));
|
final SmsTemplate smsTemplate = smsTemplateService.getDetail(systemNotification.getSmsId());
|
sendSmsVo.setTempLateCode(smsTemplate.getTempId());
|
sendSmsVo.setPhoneNumber(ebVehicleInfo.getPhone());
|
try {
|
final Boolean sendSms = SendSmsUtils.sendSms(sendSmsVo);
|
if (!sendSms) {
|
log.error("发送短信通知失败，车辆信息：{}", JSONObject.toJSONString(ebVehicleInfo));
|
}
|
} catch (Exception e) {
|
log.error("发送短信通知异常 {}", e.getMessage());
|
}
|
return true;
|
}
|
return false;
|
}
|
|
/**
|
* @param masterId 关联关系ID
|
* @param sort 排序
|
* @Description:重新排队
|
* @author:chenbing
|
* @date 2025/7/3 14:18
|
*/
|
@Override
|
public boolean reQueue(String masterId, Integer sort) {
|
if (update(new UpdateWrapper<EbVehicleInfo>().set("vehicle_status_code", VehicleInfoConstants.QUEUE_STATUS_UNDERWAY).set("sort", sort).eq("master_id", masterId))) {
|
webSocketHandler.broadcast(JSONObject.toJSONString(screen("重新排队")));
|
lineUpWebSocketHandler.broadcast("update");
|
return true;
|
}
|
return false;
|
}
|
|
/**
|
* @Description:自动叫号
|
* @author:chenbing
|
* @date 2025/7/3 14:19
|
*/
|
@Override
|
public void autoCallNumber() {
|
//查询所有的厂区
|
final List<SystemGroupData> systemGroupData = systemGroupDataService.list(new LambdaQueryWrapper<SystemGroupData>().eq(SystemGroupData::getGid, VehicleInfoConstants.LOADING_AREA_ID));
|
if (ObjectUtil.isNotEmpty(systemGroupData)) {
|
//遍历所有的厂区
|
for (SystemGroupData groupData : systemGroupData) {
|
final HashMap<String, DateTime> systemConfigTime = getSystemConfigTime(null);
|
//根据厂区ID查询当前厂区车辆最大数量
|
Integer maxCount = Integer.parseInt(handleDataTeam(groupData.getId(), "maxcount"));
|
//统计当前厂区车辆（车辆状态为：已入厂）数量并且从当前区域叫号的车辆数量
|
final int currentCount = count(new LambdaQueryWrapper<EbVehicleInfo>()
|
.between(EbVehicleInfo::getRegisterTime, DateUtil.format(systemConfigTime.get("startDateTime"), "yyyy-MM-dd HH:mm:ss"), DateUtil.format(systemConfigTime.get("endDateTime"), "yyyy-MM-dd HH:mm:ss"))
|
.eq(EbVehicleInfo::getLoadingAreaCode, groupData.getId())
|
.eq(EbVehicleInfo::getIsDel, false)
|
// .eq(EbVehicleInfo::getIsPrint, true)
|
.eq(EbVehicleInfo::getIsCall, true)
|
.eq(EbVehicleInfo::getVehicleStatusCode, VehicleInfoConstants.QUEUE_STATUS_ENTERED)
|
.orderByAsc(EbVehicleInfo::getSort).orderByAsc(EbVehicleInfo::getQueueNumber));
|
//统计当前已叫号车辆数量并且从当前区域叫号的车辆数量
|
final int waitCount = count(new LambdaQueryWrapper<EbVehicleInfo>()
|
.between(EbVehicleInfo::getRegisterTime, DateUtil.format(systemConfigTime.get("startDateTime"), "yyyy-MM-dd HH:mm:ss"), DateUtil.format(systemConfigTime.get("endDateTime"), "yyyy-MM-dd HH:mm:ss"))
|
.eq(EbVehicleInfo::getLoadingAreaCode, groupData.getId())
|
.eq(EbVehicleInfo::getIsDel, false)
|
.eq(EbVehicleInfo::getIsCall, true)
|
.eq(EbVehicleInfo::getVehicleStatusCode, VehicleInfoConstants.QUEUE_STATUS_CALLED)
|
.orderByAsc(EbVehicleInfo::getSort).orderByAsc(EbVehicleInfo::getQueueNumber));
|
final int rotaCount = maxCount - currentCount - waitCount;
|
if (rotaCount <= 0) {
|
continue;
|
}
|
//查询当前厂区所有车辆信息（状态为：排队中的）
|
final List<EbVehicleInfo> ebVehicleInfoList = list(new LambdaQueryWrapper<EbVehicleInfo>()
|
.between(EbVehicleInfo::getRegisterTime, DateUtil.format(systemConfigTime.get("startDateTime"), "yyyy-MM-dd HH:mm:ss"), DateUtil.format(systemConfigTime.get("endDateTime"), "yyyy-MM-dd HH:mm:ss"))
|
.eq(EbVehicleInfo::getLoadingAreaCode, groupData.getId())
|
.eq(EbVehicleInfo::getIsDel, false)
|
// .eq(EbVehicleInfo::getIsPrint, true)
|
.eq(EbVehicleInfo::getVehicleStatusCode, VehicleInfoConstants.QUEUE_STATUS_UNDERWAY)
|
.ne(EbVehicleInfo::getGoodsStatusCode, VehicleInfoConstants.VEHICLE_STATUS_PRODUCTION)
|
.orderByAsc(EbVehicleInfo::getSort).orderByAsc(EbVehicleInfo::getQueueNumber).last("LIMIT " + rotaCount));
|
if (ebVehicleInfoList.isEmpty()) {
|
continue;
|
}
|
for (EbVehicleInfo ebVehicleInfo : ebVehicleInfoList) {
|
//叫号
|
if (autoCallNumber(ebVehicleInfo.getMasterId(), ebVehicleInfo.getId())) {
|
log.info("自动叫号成功，车辆信息ID：{}", JSONObject.toJSONString(ebVehicleInfo));
|
if (!ebVehicleInfo.getSendSms()) {
|
//todo 发送短信提醒
|
continue;
|
}
|
final SystemNotification systemNotification = systemNotificationService.getByMark(VehicleInfoConstants.CALL_THE_NUMBER_TO_ENTER_THE_FACTORY);
|
if (systemNotification.getIsSms() != 1) {
|
continue;
|
}
|
//发送短信验证码
|
HashMap<String, Object> justPram = new HashMap<>();
|
justPram.put("areaName", handleDataTeam(ebVehicleInfo.getLoadingAreaCode(), "name"));
|
justPram.put("code", ebVehicleInfo.getLinkCode());
|
SendSmsVo sendSmsVo = new SendSmsVo();
|
sendSmsVo.setAccessKeyIdSms(smsApiKey);
|
sendSmsVo.setAccessKeySecretSms(smsApiSecret);
|
sendSmsVo.setSignName(smsSignName);
|
sendSmsVo.setTemplateParam(JSONObject.toJSONString(justPram));
|
final SmsTemplate smsTemplate = smsTemplateService.getDetail(systemNotification.getSmsId());
|
sendSmsVo.setTempLateCode(smsTemplate.getTempId());
|
sendSmsVo.setPhoneNumber(ebVehicleInfo.getPhone());
|
try {
|
final Boolean sendSms = SendSmsUtils.sendSms(sendSmsVo);
|
if (!sendSms) {
|
log.error("发送短信通知失败，车辆信息：{}", JSONObject.toJSONString(ebVehicleInfo));
|
}
|
} catch (Exception e) {
|
log.error("发送短信通知异常 {}", e.getMessage());
|
}
|
}
|
}
|
webSocketHandler.broadcast(JSONObject.toJSONString(screen("手动叫号")));
|
lineUpWebSocketHandler.broadcast("update");
|
}
|
}
|
}
|
|
/**
|
* @Description:自动标记为已过号
|
* @author:chenbing
|
* @date 2025/8/4 18:27
|
*/
|
@Override
|
public void autoPassNumber() {
|
//获取叫号超时时长
|
final String callNumberTimeout = handleDataTeam(VehicleInfoConstants.CALL_NUMBER_TIMEOUT_DATA_ID, "overtime");
|
if (StringUtils.isBlank(callNumberTimeout)) {
|
return;
|
}
|
//获取叫号超时时长
|
final Integer callNumberTimeoutInt = Integer.parseInt(callNumberTimeout);
|
final HashMap<String, DateTime> systemConfigTime = getSystemConfigTime(null);
|
//查询叫号超时时长前的车辆信息
|
final List<EbVehicleInfo> ebVehicleInfoList = list(new LambdaQueryWrapper<EbVehicleInfo>()
|
.between(EbVehicleInfo::getRegisterTime, DateUtil.format(systemConfigTime.get("startDateTime"), "yyyy-MM-dd HH:mm:ss"), DateUtil.format(systemConfigTime.get("endDateTime"), "yyyy-MM-dd HH:mm:ss"))
|
.eq(EbVehicleInfo::getIsDel, false)
|
.eq(EbVehicleInfo::getIsCall, true)
|
.eq(EbVehicleInfo::getVehicleStatusCode, VehicleInfoConstants.QUEUE_STATUS_CALLED));
|
if (CollectionUtils.isEmpty(ebVehicleInfoList)) {
|
return;
|
}
|
//获取当前时间
|
final DateTime now = DateUtil.date();
|
for (EbVehicleInfo ebVehicleInfo : ebVehicleInfoList) {
|
//判断叫号时间+超时时间 是否 大于当前时间
|
DateTime callTime = DateUtil.parse(ebVehicleInfo.getCallTime(), "yyyy-MM-dd HH:mm:ss");
|
DateTime passCallTime = DateUtil.offsetMinute(callTime, callNumberTimeoutInt);
|
if (passCallTime.isAfterOrEquals(now)) {
|
// 此时还没有过号，就到下一个 item
|
continue;
|
}
|
log.info("自动标记为已过号，车辆信息ID：{}", JSONObject.toJSONString(ebVehicleInfo));
|
//标记为已过号
|
passNumber(ebVehicleInfo.getMasterId());
|
}
|
}
|
|
/**
|
* @Description:处理数据组内容
|
* @author:chenbing
|
* @date 2025/7/3 11:22
|
*/
|
private String handleDataTeam(Integer dataId, String key) {
|
String result = "";
|
//获取数据组内容
|
final SystemGroupData systemGroupData = systemGroupDataService.getById(dataId);
|
final JSONObject data = JSONObject.parseObject(systemGroupData.getValue());
|
final JSONArray fields = data.getJSONArray("fields");
|
for (Object field : fields) {
|
JSONObject fieldJson = (JSONObject) field;
|
if (!fieldJson.containsValue(key)) {
|
continue;
|
}
|
result = fieldJson.getString("value");
|
}
|
return result;
|
}
|
|
/**
|
* @Description:删除车辆信息
|
* @author:chenbing
|
* @date 2025/7/3 10:47
|
*/
|
@Override
|
public boolean delete(String masterId) {
|
// EbVehicleInfo ebVehicleInfo = getOne(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getMasterId, masterId).eq(EbVehicleInfo::getIsPrint, true).eq(EbVehicleInfo::getIsDel, false));
|
if (count(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getMasterId, masterId).eq(EbVehicleInfo::getIsDel, false)) <= 0) {
|
throw new CarException("车辆信息不存在");
|
}
|
if (update(new UpdateWrapper<EbVehicleInfo>().set("is_del", true).eq("master_id", masterId))) {
|
webSocketHandler.broadcast(JSONObject.toJSONString(screen("删除车辆信息")));
|
lineUpWebSocketHandler.broadcast("update");
|
return true;
|
}
|
return false;
|
}
|
}
|
