package com.xiaopeng.vehicleConvoy.service.impl;
|
|
import cn.hutool.core.bean.BeanUtil;
|
import cn.hutool.core.collection.CollUtil;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.xiaopeng.api.dto.vehicleConvoy.VehicleTemperatureDto;
|
import com.xiaopeng.api.feignClient.automaticPilot.XpuVinClient;
|
import com.xiaopeng.api.feignClient.operation.XpElectronicClient;
|
import com.xiaopeng.api.feignClient.order.XpOrderClient;
|
import com.xiaopeng.api.model.operation.XpElectronicFence;
|
import com.xiaopeng.api.model.operation.XpElectronicFenceArea;
|
import com.xiaopeng.api.model.order.XpOrder;
|
import com.xiaopeng.api.model.vehicleConvoy.XpVehicle;
|
import com.xiaopeng.api.model.vehicleConvoy.XpVehicleAnnualRecord;
|
import com.xiaopeng.api.vo.automaticPilot.VehiclePosition;
|
import com.xiaopeng.api.vo.operation.ElectronicFenceDetailVo;
|
import com.xiaopeng.api.vo.vehicleConvoy.VehiclesCommandEnum;
|
import com.xiaopeng.api.vo.vehicleConvoy.VehiclesCommandParamVo;
|
import com.xiaopeng.api.vo.vehicleConvoy.VehiclesCommandVo;
|
import com.xiaopeng.common.core.constant.CacheConstants;
|
import com.xiaopeng.common.core.domain.R;
|
import com.xiaopeng.common.core.exception.ServiceException;
|
import com.xiaopeng.common.core.web.page.PageInfo;
|
import com.xiaopeng.common.redis.service.RedisService;
|
import com.xiaopeng.vehicleConvoy.constant.I18nKeyConstant;
|
import com.xiaopeng.vehicleConvoy.mapper.XpVehicleMapper;
|
import com.xiaopeng.vehicleConvoy.model.dto.*;
|
import com.xiaopeng.vehicleConvoy.model.importExcel.XpVehicleImportExcel;
|
import com.xiaopeng.vehicleConvoy.model.query.*;
|
import com.xiaopeng.vehicleConvoy.model.vo.XpVehicleVO;
|
import com.xiaopeng.vehicleConvoy.service.IXpVehicleAnnualRecordService;
|
import com.xiaopeng.vehicleConvoy.service.IXpVehicleService;
|
import com.xiaopeng.vehicleConvoy.util.VehicleControlUtil;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.context.i18n.LocaleContextHolder;
|
import org.springframework.data.geo.Point;
|
import org.springframework.data.mongodb.core.MongoTemplate;
|
import org.springframework.data.mongodb.core.geo.GeoJsonPoint;
|
import org.springframework.data.mongodb.core.query.Criteria;
|
import org.springframework.data.mongodb.core.query.Query;
|
import org.springframework.data.redis.core.RedisTemplate;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.CollectionUtils;
|
|
import javax.annotation.Resource;
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.LocalTime;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* <p>
|
* 车辆管理 服务实现类
|
* </p>
|
*
|
* @author mitao
|
* @since 2026-02-03
|
*/
|
@Slf4j
|
@Service
|
public class XpVehicleServiceImpl extends ServiceImpl<XpVehicleMapper, XpVehicle> implements IXpVehicleService {
|
|
@Autowired
|
private VehicleControlUtil vehicleControlUtil;
|
|
@Autowired
|
private XpOrderClient xpOrderClient;
|
|
@Autowired
|
private XpElectronicClient xpElectronicClient;
|
|
@Autowired
|
private IXpVehicleAnnualRecordService xpVehicleAnnualRecordService;
|
@Resource
|
private XpuVinClient xpuVinClient;
|
@Autowired
|
private RedisService redisService;
|
@Autowired
|
private MongoTemplate mongoTemplate;
|
@Autowired
|
private RedisTemplate redisTemplate;
|
|
@Override
|
public List<XpVehicle> listByIds(List<Long> ids) {
|
if (CollectionUtils.isEmpty(ids)) {
|
return new ArrayList<>();
|
}
|
return super.listByIds(ids);
|
}
|
|
@Override
|
public List<XpVehicle> listAvailableVehicles(Long orderId) {
|
// 1. 通过订单ID查询订单信息，获取区域ID
|
R<XpOrder> orderResult = xpOrderClient.queryOrderById(orderId);
|
if (orderResult == null || orderResult.getData() == null) {
|
log.warn("查询订单失败，orderId: {}", orderId);
|
return Collections.emptyList();
|
}
|
|
XpOrder order = orderResult.getData();
|
Long areaId = order.getXpElectronicFenceAreaId();
|
|
if (areaId == null) {
|
log.warn("订单区域ID为空，orderId: {}", orderId);
|
return Collections.emptyList();
|
}
|
|
// 2. 通过区域ID查询围栏ID
|
R<XpElectronicFenceArea> areaResult = xpElectronicClient.queryElectronicFenceAreaById(areaId);
|
if (areaResult == null || areaResult.getData() == null) {
|
log.warn("查询围栏区域失败，areaId: {}", areaId);
|
return Collections.emptyList();
|
}
|
|
Long electronicId = areaResult.getData().getElectronicId();
|
if (electronicId == null) {
|
log.warn("围栏ID为空，areaId: {}", areaId);
|
return Collections.emptyList();
|
}
|
|
// 3. 根据围栏ID查询车辆列表 (operatingStatus=1 且 state=0)
|
LambdaQueryWrapper<XpVehicle> wrapper = new LambdaQueryWrapper<>();
|
wrapper.eq(XpVehicle::getElectronicId, electronicId)
|
.eq(XpVehicle::getOperatingStatus, 1)
|
.eq(XpVehicle::getState, 0);
|
|
// 排序：按电量降序、入库时间降序
|
wrapper.orderByDesc(XpVehicle::getCurrentElectricity)
|
.orderByDesc(XpVehicle::getWarehousingTime);
|
|
return this.list(wrapper);
|
}
|
|
@Override
|
public PageInfo<XpVehicleVO> pageList(VehicleMapQuery query) {
|
PageInfo<XpVehicleVO> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
|
|
if(StringUtils.isNotBlank(query.getStatus())){
|
query.setStatusList(Arrays.asList(query.getStatus().split(",")));
|
}
|
if(StringUtils.isNotBlank(query.getElectronicId())){
|
query.setElectronicIdList(Arrays.asList(query.getElectronicId().split(",")));
|
}
|
List<XpVehicleVO> list = this.baseMapper.pageList(pageInfo, query);
|
if (CollectionUtils.isEmpty(list)){
|
return pageInfo;
|
}
|
|
for (XpVehicleVO xpVehicleVO : list) {
|
List<Point> positionList = redisTemplate.opsForGeo().position("vehiclePosition:" + xpVehicleVO.getVehicleVin(), xpVehicleVO.getVehicleVin());
|
if (CollUtil.isNotEmpty(positionList)){
|
Point geoJsonPoint = positionList.get(0);
|
// 获取经纬度
|
xpVehicleVO.setLongitude(geoJsonPoint.getX());
|
xpVehicleVO.setLatitude(geoJsonPoint.getY());
|
}
|
// 查询车辆的续航里程
|
VehiclePosition vehiclePosition = mongoTemplate.findOne(new Query(Criteria.where("vin").is(xpVehicleVO.getVehicleVin())), VehiclePosition.class);
|
if(Objects.nonNull(vehiclePosition)){
|
xpVehicleVO.setMileageRange(vehiclePosition.getMileageRange());
|
xpVehicleVO.setCurrentElectricity(vehiclePosition.getCurrentElectricity());
|
}else {
|
xpVehicleVO.setMileageRange(0F);
|
xpVehicleVO.setCurrentElectricity(0);
|
}
|
}
|
|
pageInfo.setRecords(list);
|
return pageInfo;
|
}
|
|
@Override
|
public List<XpVehicle> listByPlateNumber(String plateNumber) {
|
if (StringUtils.isBlank(plateNumber)) {
|
return Collections.emptyList();
|
}
|
|
return lambdaQuery().like(XpVehicle::getPlateNumber, plateNumber).list();
|
}
|
|
@Override
|
public List<XpVehicle> listByFenceId(Long fenceId) {
|
if (fenceId == null) {
|
return Collections.emptyList();
|
}
|
return lambdaQuery().eq(XpVehicle::getElectronicId, fenceId).eq(XpVehicle::getOperatingStatus,1).eq(XpVehicle::getState,0).list();
|
}
|
|
@Override
|
public Integer unlock(UnlockAppletDTO dto) {
|
// 查询订单
|
XpOrder xpOrder = xpOrderClient.queryOrderById(dto.getOrderId()).getData();
|
if(Objects.isNull(xpOrder)){
|
throw new ServiceException("未查询到有效订单信息", I18nKeyConstant.ORDER_NOT_EXISTS);
|
}
|
XpVehicle xpVehicle = this.getById(xpOrder.getVehicleId());
|
if(Objects.isNull(xpVehicle)){
|
throw new ServiceException("未查询到有效车辆信息", I18nKeyConstant.VEHICLE_NOT_EXISTS);
|
}
|
// 车门解锁、后备箱解锁
|
VehiclesCommandVo vehiclesCommandVo = new VehiclesCommandVo();
|
vehiclesCommandVo.setUid(xpOrder.getAppUserId());
|
vehiclesCommandVo.setVin(xpVehicle.getVehicleVin());
|
if("door".equals(dto.getDoorType())){
|
// 开启车门 判断是否为P档
|
Integer gearLevel = redisService.getCacheObject(CacheConstants.GEAR_LEVEL + xpVehicle.getVehicleVin());
|
if(gearLevel == null || gearLevel != 4){
|
throw new ServiceException("车辆非P档，无法开启车门", I18nKeyConstant.VEHICLE_NOT_P_GEAR);
|
}
|
vehiclesCommandVo.setCommandCode(VehiclesCommandEnum.DOOR_UNLOCK);
|
}else {
|
// 开启后备箱 判断是否为P档
|
Integer gearLevel = redisService.getCacheObject(CacheConstants.GEAR_LEVEL + xpVehicle.getXpuId());
|
if(gearLevel == null || gearLevel != 4){
|
throw new ServiceException("车辆非P档，无法开启后备箱", I18nKeyConstant.VEHICLE_NOT_P_GEAR);
|
}
|
vehiclesCommandVo.setCommandCode(VehiclesCommandEnum.DOOR_TRUNK_OPEN);
|
}
|
try{
|
String result = vehicleControlUtil.vehiclesCommand(vehiclesCommandVo);
|
log.info("车辆控制结果：{}", result);
|
return 1;
|
}catch (Exception e){
|
log.error("车辆控制异常：{}", e.getMessage());
|
return 0;
|
}
|
}
|
|
@Override
|
public Integer setTemperature(SetTemperatureDTO dto) {
|
// 查询订单
|
XpOrder xpOrder = xpOrderClient.queryOrderById(dto.getOrderId()).getData();
|
if(Objects.isNull(xpOrder)){
|
throw new ServiceException("未查询到有效订单信息", I18nKeyConstant.ORDER_NOT_EXISTS);
|
}
|
XpVehicle xpVehicle = this.getById(xpOrder.getVehicleId());
|
if(Objects.isNull(xpVehicle)){
|
throw new ServiceException("未查询到有效车辆信息", I18nKeyConstant.VEHICLE_NOT_EXISTS);
|
}
|
if(dto.getTargetTemperature() > 28){
|
throw new ServiceException("温度最高28℃", I18nKeyConstant.VEHICLE_TEMPERATURE_UP);
|
}
|
if(dto.getTargetTemperature() < 22){
|
throw new ServiceException("温度最低22℃", I18nKeyConstant.VEHICLE_TEMPERATURE_DOWN);
|
}
|
// 设定温度
|
VehiclesCommandVo vehiclesCommandVo = new VehiclesCommandVo();
|
vehiclesCommandVo.setUid(xpOrder.getAppUserId());
|
vehiclesCommandVo.setVin(xpVehicle.getVehicleVin());
|
vehiclesCommandVo.setCommandCode(VehiclesCommandEnum.HVAC_TEMP_SET);
|
VehiclesCommandParamVo vehiclesCommandParamVo = new VehiclesCommandParamVo();
|
vehiclesCommandParamVo.setDegree(dto.getTargetTemperature());
|
vehiclesCommandVo.setExtParam(vehiclesCommandParamVo);
|
try{
|
String result = vehicleControlUtil.vehiclesCommand(vehiclesCommandVo);
|
log.info("车辆控制结果：{}", result);
|
return 1;
|
}catch (Exception e){
|
log.error("车辆控制异常：{}", e.getMessage());
|
return 0;
|
}
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void addVehicle(VehicleAddDTO dto) {
|
// DTO转实体
|
XpVehicle xpVehicle = new XpVehicle();
|
BeanUtil.copyProperties(dto, xpVehicle);
|
|
// 设置默认值：在库车辆
|
xpVehicle.setVehicleType(1);
|
// 新增时状态为待完善
|
xpVehicle.setStatus(1);
|
// 设置入库时间
|
xpVehicle.setWarehousingTime(LocalDateTime.now());
|
//绑定XPUID
|
String vin = xpVehicle.getVehicleVin();
|
String xpuid = xpuVinClient.getXpuIdByVin(vin).getData();
|
xpVehicle.setXpuId(xpuid);
|
this.save(xpVehicle);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void editVehicle(VehicleEditDTO dto) {
|
// DTO转实体
|
XpVehicle xpVehicle = new XpVehicle();
|
BeanUtil.copyProperties(dto, xpVehicle);
|
//绑定XPUID
|
String vin = xpVehicle.getVehicleVin();
|
String xpuid = xpuVinClient.getXpuIdByVin(vin).getData();
|
xpVehicle.setXpuId(xpuid);
|
this.updateById(xpVehicle);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void improveInfo(VehicleImproveInfoDTO dto) {
|
// 校验已填写的时间字段是否在有效范围内
|
validateTimeFields(dto);
|
|
// DTO转实体
|
XpVehicle xpVehicle = new XpVehicle();
|
BeanUtil.copyProperties(dto, xpVehicle);
|
|
// 更新保险、年检、运营资质等信息
|
this.updateById(xpVehicle);
|
// 查询更新后的完整信息
|
XpVehicle vehicle = this.getById(dto.getId());
|
if (vehicle == null) {
|
return;
|
}
|
|
if (Integer.valueOf(2).equals(dto.getSaveType())) {
|
// 保存并开始运营：校验保险、年检、运营区域、运营资质是否完善
|
validateForOperation(vehicle);
|
// 校验通过，直接转为运营状态
|
vehicle.setStatus(2);
|
vehicle.setVehicleType(2);
|
vehicle.setOperatingStatus(1);
|
this.updateById(vehicle);
|
} else {
|
// 仅保存：如果信息完善则状态改为待运营
|
if (isInfoComplete(vehicle)) {
|
vehicle.setStatus(2);
|
this.updateById(vehicle);
|
}
|
}
|
//保存年检记录
|
XpVehicleAnnualRecord xpVehicleAnnualRecord = BeanUtil.copyProperties(dto, XpVehicleAnnualRecord.class, "id");
|
xpVehicleAnnualRecord.setVehicleId(dto.getId());
|
xpVehicleAnnualRecordService.save(xpVehicleAnnualRecord);
|
}
|
|
/**
|
* 校验已填写的时间字段是否在有效范围内（未过期）
|
*/
|
private void validateTimeFields(VehicleImproveInfoDTO dto) {
|
LocalDateTime now = LocalDateTime.now();
|
List<String> expiredItems = new ArrayList<>();
|
Locale locale = LocaleContextHolder.getLocale();
|
|
if (dto.getAnnualInspectionDate() != null && dto.getAnnualInspectionDate().isBefore(now)) {
|
if ("zh".equals(locale.getLanguage())) {
|
expiredItems.add("年检到期时间");
|
} else {
|
expiredItems.add("Annual inspection expiration date");
|
}
|
}
|
if (dto.getInsuranceEndTime() != null && dto.getInsuranceEndTime().isBefore(now)) {
|
if ("zh".equals(locale.getLanguage())) {
|
expiredItems.add("保险到期时间");
|
} else {
|
expiredItems.add("Insurance expiration date");
|
}
|
}
|
if (dto.getQualificationExpireTime() != null && dto.getQualificationExpireTime().isBefore(now)) {
|
if ("zh".equals(locale.getLanguage())) {
|
expiredItems.add("运营资质到期时间");
|
} else {
|
expiredItems.add("Operation qualification expiration date");
|
}
|
}
|
|
if (!expiredItems.isEmpty()) {
|
String detail;
|
if ("zh".equals(locale.getLanguage())) {
|
detail = String.join("、", expiredItems);
|
} else {
|
detail = String.join("; ", expiredItems);
|
}
|
throw new ServiceException("以下时间已过期，请填写有效日期：" + detail,
|
I18nKeyConstant.VEHICLE_TIME_EXPIRED, new Object[]{detail});
|
}
|
}
|
|
/**
|
* 校验车辆运营前置条件
|
*/
|
private void validateForOperation(XpVehicle vehicle) {
|
List<String> missingItems = new ArrayList<>();
|
Locale locale = LocaleContextHolder.getLocale();
|
|
// 校验保险信息
|
if (StringUtils.isBlank(vehicle.getInsuranceCompany())
|
|| StringUtils.isBlank(vehicle.getInsurancePhone())
|
|| vehicle.getInsuranceEndTime() == null
|
|| StringUtils.isBlank(vehicle.getPolicyInformation())) {
|
if ("zh".equals(locale.getLanguage())) {
|
missingItems.add("保险信息");
|
} else {
|
missingItems.add("Insurance information");
|
}
|
}
|
|
// 校验年检信息
|
if (vehicle.getAnnualInspectionDate() == null
|
|| StringUtils.isBlank(vehicle.getInspectionAttachments())) {
|
if ("zh".equals(locale.getLanguage())) {
|
missingItems.add("年检信息");
|
} else {
|
missingItems.add("Annual inspection information");
|
}
|
}
|
|
// 校验运营区域
|
if (vehicle.getElectronicId() == null) {
|
if ("zh".equals(locale.getLanguage())) {
|
missingItems.add("运营区域");
|
} else {
|
missingItems.add("Operation area");
|
}
|
}
|
|
// 校验运营资质
|
if (StringUtils.isBlank(vehicle.getOperationQualification())
|
|| vehicle.getQualificationExpireTime() == null) {
|
if ("zh".equals(locale.getLanguage())) {
|
missingItems.add("运营资质");
|
} else {
|
missingItems.add("Operation qualification");
|
}
|
}
|
|
if (!missingItems.isEmpty()) {
|
String detail;
|
if ("zh".equals(locale.getLanguage())) {
|
detail = String.join("、", missingItems);
|
} else {
|
detail = String.join("; ", missingItems);
|
}
|
throw new ServiceException("以下信息未完善，无法开始运营：" + detail,
|
I18nKeyConstant.VEHICLE_OPERATION_INFO_INCOMPLETE, new Object[]{detail});
|
}
|
}
|
|
/**
|
* 判断车辆信息是否已完善
|
*/
|
private boolean isInfoComplete(XpVehicle vehicle) {
|
return vehicle.getAnnualInspectionDate() != null
|
&& StringUtils.isNotBlank(vehicle.getInsuranceCompany())
|
&& StringUtils.isNotBlank(vehicle.getInsurancePhone())
|
&& vehicle.getInsuranceEndTime() != null
|
&& StringUtils.isNotBlank(vehicle.getInspectionAttachments())
|
&& StringUtils.isNotBlank(vehicle.getPolicyInformation())
|
&& StringUtils.isNotBlank(vehicle.getOperationQualification())
|
&& vehicle.getQualificationExpireTime() != null;
|
}
|
|
/**
|
* 检查车辆是否有任意一项证件过期（精确到日期）
|
* - 精确度：yyyy-MM-dd（只比较日期部分）
|
* - 到期日期等于今天不算过期（使用 isBefore）
|
* @param vehicle 车辆信息
|
* @param today 今天日期
|
*/
|
private boolean isAnyDateExpired(XpVehicle vehicle, LocalDate today) {
|
// 年检到期时间检查：已过期
|
if (vehicle.getAnnualInspectionDate() != null
|
&& vehicle.getAnnualInspectionDate().toLocalDate().isBefore(today)) {
|
return true;
|
}
|
// 保险到期时间检查：已过期
|
if (vehicle.getInsuranceEndTime() != null
|
&& vehicle.getInsuranceEndTime().toLocalDate().isBefore(today)) {
|
return true;
|
}
|
// 运营资质到期时间检查:已过期
|
if (vehicle.getQualificationExpireTime() != null
|
&& vehicle.getQualificationExpireTime().toLocalDate().isBefore(today)) {
|
return true;
|
}
|
return false;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void batchOperation(String idStr) {
|
if (StringUtils.isBlank(idStr)) {
|
return;
|
}
|
List<String> ids = Arrays.asList(idStr.split(","));
|
// 查询车辆完整信息
|
List<XpVehicle> vehicles = this.listByIds(ids);
|
LocalDate now = LocalDate.now();
|
List<String> errorMessages = new ArrayList<>();
|
|
for (XpVehicle vehicle : vehicles) {
|
List<String> reasons = new ArrayList<>();
|
Locale locale = LocaleContextHolder.getLocale();
|
|
// 校验状态为待运营
|
if (!Integer.valueOf(2).equals(vehicle.getStatus())) {
|
if ("zh".equals(locale.getLanguage())) {
|
reasons.add("状态非待运营");
|
} else {
|
reasons.add("Status is not 'Pending Operation'");
|
}
|
}
|
// 校验年检到期时间
|
if (vehicle.getAnnualInspectionDate() == null || vehicle.getAnnualInspectionDate().toLocalDate().isBefore(now)) {
|
if ("zh".equals(locale.getLanguage())) {
|
reasons.add("年检已过期");
|
} else {
|
reasons.add("Annual inspection has expired");
|
}
|
}
|
// 校验保险到期时间
|
if (vehicle.getInsuranceEndTime() == null || vehicle.getInsuranceEndTime().toLocalDate().isBefore(now)) {
|
if ("zh".equals(locale.getLanguage())) {
|
reasons.add("保险已过期");
|
} else {
|
reasons.add("Insurance has expired");
|
}
|
}
|
// 校验运营资质到期时间
|
if (vehicle.getQualificationExpireTime() == null || vehicle.getQualificationExpireTime().toLocalDate().isBefore(now)) {
|
if ("zh".equals(locale.getLanguage())) {
|
reasons.add("运营资质已过期");
|
} else {
|
reasons.add("Operation qualification has expired");
|
}
|
}
|
if (!reasons.isEmpty()) {
|
if ("zh".equals(locale.getLanguage())) {
|
errorMessages.add("车辆[" + vehicle.getPlateNumber() + "]：" + String.join("、", reasons));
|
} else {
|
errorMessages.add("Vehicles [" + vehicle.getPlateNumber() + "]: " + String.join("; ", reasons));
|
}
|
}
|
}
|
|
if (!errorMessages.isEmpty()) {
|
String detail = String.join("；", errorMessages);
|
throw new ServiceException("以下车辆不满足运营条件：" + detail,
|
I18nKeyConstant.VEHICLE_BATCH_OPERATION_CONDITION_NOT_MET, new Object[]{detail});
|
}
|
|
// 校验通过，批量转为运营状态（vehicleType: 1→2）
|
LambdaUpdateWrapper<XpVehicle> wrapper = new LambdaUpdateWrapper<>();
|
wrapper.in(XpVehicle::getId, ids)
|
.set(XpVehicle::getVehicleType, 2)
|
.set(XpVehicle::getOperatingStatus, 1);
|
this.update(wrapper);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void batchStock(String idStr) {
|
if (StringUtils.isBlank(idStr)) {
|
return;
|
}
|
List<String> ids = Arrays.asList(idStr.split(","));
|
// 批量将运营车辆转为在库状态（vehicleType: 2→1）
|
LambdaUpdateWrapper<XpVehicle> wrapper = new LambdaUpdateWrapper<>();
|
wrapper.in(XpVehicle::getId, ids)
|
.set(XpVehicle::getVehicleType, 1);
|
this.update(wrapper);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void batchSetElectronic(List<Long> ids, Long electronicId) {
|
if (CollectionUtils.isEmpty(ids)) {
|
return;
|
}
|
// 批量更新运营区域并设置状态为待运营
|
LambdaUpdateWrapper<XpVehicle> wrapper = new LambdaUpdateWrapper<>();
|
wrapper.in(XpVehicle::getId, ids)
|
.set(XpVehicle::getElectronicId, electronicId)
|
.set(XpVehicle::getStatus, 2);
|
this.update(wrapper);
|
}
|
|
@Override
|
public PageInfo<XpVehicle> vehiclePageList(VehiclePageQuery query) {
|
PageInfo<XpVehicle> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
|
List<XpVehicle> list = this.baseMapper.vehiclePageList(pageInfo, query);
|
//查询运营区域名称
|
List<Long> electronicIds = list.stream()
|
.map(XpVehicle::getElectronicId)
|
.filter(Objects::nonNull)
|
.distinct()
|
.collect(Collectors.toList());
|
Map<Long, String> electronicNameMap = new HashMap<>();
|
if (CollUtil.isNotEmpty(electronicIds)) {
|
List<XpElectronicFence> data = xpElectronicClient.listByIds(electronicIds).getData();
|
electronicNameMap = CollUtil.isNotEmpty(data) ?
|
data.stream().collect(Collectors.toMap(XpElectronicFence::getId, XpElectronicFence::getElectronicName))
|
: Collections.emptyMap();
|
}
|
Map<Long, String> finalElectronicNameMap = electronicNameMap;
|
list.forEach(item -> {
|
if (item.getElectronicId() != null) {
|
item.setElectronicName(finalElectronicNameMap.get(item.getElectronicId()));
|
}
|
});
|
if (CollUtil.isNotEmpty(list)) {
|
LocalDate today = LocalDate.now();
|
List<Long> expiredVehicleIds = new ArrayList<>();
|
|
for (XpVehicle vehicle : list) {
|
// 检查是否有任意一项过期（精确到 yyyy-MM-dd）
|
boolean isExpired = isAnyDateExpired(vehicle, today);
|
|
if (isExpired && !Integer.valueOf(3).equals(vehicle.getStatus())) {
|
// 记录需要更新状态的车辆ID
|
expiredVehicleIds.add(vehicle.getId());
|
// 同时更新返回结果中的状态
|
vehicle.setStatus(3);
|
}
|
}
|
|
// 批量更新过期车辆状态到数据库
|
if (CollUtil.isNotEmpty(expiredVehicleIds)) {
|
LambdaUpdateWrapper<XpVehicle> updateWrapper = new LambdaUpdateWrapper<>();
|
updateWrapper.in(XpVehicle::getId, expiredVehicleIds)
|
.set(XpVehicle::getStatus, 3);
|
this.update(updateWrapper);
|
}
|
}
|
|
pageInfo.setRecords(list);
|
return pageInfo;
|
}
|
|
@Override
|
public List<XpVehicle> vehicleExportList(VehicleExportQuery query) {
|
return this.baseMapper.vehicleExportList(query);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void importVehicles(List<XpVehicleImportExcel> importList) {
|
if (CollectionUtils.isEmpty(importList)) {
|
return;
|
}
|
List<XpVehicle> vehicleList = importList.stream().map(item -> {
|
XpVehicle vehicle = new XpVehicle();
|
BeanUtil.copyProperties(item, vehicle);
|
// 设置默认值
|
vehicle.setVehicleType(1);
|
vehicle.setStatus(1);
|
vehicle.setWarehousingTime(LocalDateTime.now());
|
return vehicle;
|
}).collect(Collectors.toList());
|
this.saveBatch(vehicleList);
|
}
|
|
@Override
|
public XpVehicle getVehicleDetail(Long id) {
|
XpVehicle vehicle = this.getById(id);
|
if (vehicle == null) {
|
return null;
|
}
|
// 查询围栏名称
|
if (vehicle.getElectronicId() != null) {
|
try {
|
R<ElectronicFenceDetailVo> result = xpElectronicClient.queryById(vehicle.getElectronicId());
|
if (R.isSuccess(result) && result.getData() != null) {
|
vehicle.setElectronicName(result.getData().getElectronicName());
|
}
|
} catch (Exception e) {
|
log.warn("查询围栏名称失败, electronicId={}", vehicle.getElectronicId(), e);
|
}
|
}
|
return vehicle;
|
}
|
|
@Override
|
public PageInfo<XpVehicle> operationPageList(OperationVehiclePageQuery query) {
|
//1.构建分页参数
|
PageInfo<XpVehicle> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
|
|
// 2.构建查询条件
|
LambdaQueryWrapper<XpVehicle> wrapper = new LambdaQueryWrapper<>();
|
wrapper.eq(XpVehicle::getVehicleType, 2)
|
.like(StringUtils.isNotBlank(query.getVehicleCode()), XpVehicle::getVehicleCode, query.getVehicleCode())
|
.like(StringUtils.isNotBlank(query.getVehicleVin()), XpVehicle::getVehicleVin, query.getVehicleVin())
|
.like(StringUtils.isNotBlank(query.getPlateNumber()), XpVehicle::getPlateNumber, query.getPlateNumber())
|
.eq(Objects.nonNull(query.getOperatingStatus()), XpVehicle::getOperatingStatus, query.getOperatingStatus())
|
.eq(Objects.nonNull(query.getElectronicId()), XpVehicle::getElectronicId, query.getOperatingStatus());
|
if (Objects.nonNull(query.getStartTime())) {
|
wrapper.ge(XpVehicle::getAnnualInspectionDate, LocalDateTime.of(query.getStartTime(), LocalTime.MIN));
|
}
|
if (Objects.nonNull(query.getEndTime())) {
|
wrapper.le(XpVehicle::getAnnualInspectionDate, LocalDateTime.of(query.getEndTime(), LocalTime.MAX));
|
}
|
wrapper.orderByDesc(XpVehicle::getCreateTime);
|
//3.执行分页查询
|
PageInfo<XpVehicle> page = this.page(pageInfo, wrapper);
|
|
//4.批量查询围栏名称并填充
|
Set<Long> electronicIdSet = page.getRecords().stream().map(XpVehicle::getElectronicId).collect(Collectors.toSet());
|
List<XpElectronicFence> fenceList = CollUtil.isNotEmpty(electronicIdSet) ?
|
xpElectronicClient.listByIds(electronicIdSet).getData() :
|
Collections.emptyList();
|
if (CollUtil.isNotEmpty(fenceList)) {
|
Map<Long, String> fenceNameMap = fenceList.stream().collect(Collectors.toMap(XpElectronicFence::getId, XpElectronicFence::getElectronicName));
|
page.getRecords().forEach(vehicle -> {
|
if (vehicle.getElectronicId() != null) {
|
vehicle.setElectronicName(fenceNameMap.get(vehicle.getElectronicId()));
|
}
|
});
|
}
|
return pageInfo;
|
}
|
|
@Override
|
public List<XpVehicle> operationVehicleExportList(OperationVehicleExportQuery query) {
|
// 1.构建查询条件
|
LambdaQueryWrapper<XpVehicle> wrapper = new LambdaQueryWrapper<>();
|
wrapper.eq(XpVehicle::getVehicleType, 2)
|
.like(StringUtils.isNotBlank(query.getVehicleCode()), XpVehicle::getVehicleCode, query.getVehicleCode())
|
.like(StringUtils.isNotBlank(query.getVehicleVin()), XpVehicle::getVehicleVin, query.getVehicleVin())
|
.like(StringUtils.isNotBlank(query.getPlateNumber()), XpVehicle::getPlateNumber, query.getPlateNumber())
|
.eq(Objects.nonNull(query.getOperatingStatus()), XpVehicle::getOperatingStatus, query.getOperatingStatus())
|
.eq(Objects.nonNull(query.getElectronicId()), XpVehicle::getElectronicId, query.getOperatingStatus())
|
.in(CollUtil.isNotEmpty(query.getIds()), XpVehicle::getId, query.getIds());
|
if (Objects.nonNull(query.getStartTime())) {
|
wrapper.ge(XpVehicle::getAnnualInspectionDate, LocalDateTime.of(query.getStartTime(), LocalTime.MIN));
|
}
|
if (Objects.nonNull(query.getEndTime())) {
|
wrapper.le(XpVehicle::getAnnualInspectionDate, LocalDateTime.of(query.getEndTime(), LocalTime.MAX));
|
}
|
wrapper.orderByDesc(XpVehicle::getCreateTime);
|
//2.执行查询
|
List<XpVehicle> list = this.list(wrapper);
|
|
//3.批量查询围栏名称并填充
|
Set<Long> electronicIdSet = list.stream().map(XpVehicle::getElectronicId).collect(Collectors.toSet());
|
List<XpElectronicFence> fenceList = CollUtil.isNotEmpty(electronicIdSet) ?
|
xpElectronicClient.listByIds(electronicIdSet).getData() :
|
Collections.emptyList();
|
if (CollUtil.isNotEmpty(fenceList)) {
|
Map<Long, String> fenceNameMap = fenceList.stream().collect(Collectors.toMap(XpElectronicFence::getId, XpElectronicFence::getElectronicName));
|
list.forEach(vehicle -> {
|
if (vehicle.getElectronicId() != null) {
|
vehicle.setElectronicName(fenceNameMap.get(vehicle.getElectronicId()));
|
}
|
});
|
}
|
return list;
|
}
|
|
@Override
|
public VehicleTemperatureDto queryTemperatureByOrderId(Long orderId,String uid) {
|
XpOrder xpOrder = xpOrderClient.queryOrderById(orderId).getData();
|
if(Objects.isNull(xpOrder)){
|
throw new ServiceException("未查询到有效订单信息", I18nKeyConstant.ORDER_NOT_EXISTS);
|
}
|
XpVehicle xpVehicle = this.getById(xpOrder.getVehicleId());
|
if(Objects.isNull(xpVehicle)){
|
throw new ServiceException("未查询到有效车辆信息", I18nKeyConstant.VEHICLE_NOT_EXISTS);
|
}
|
try{
|
VehicleTemperatureDto vehicleTemperatureDto = vehicleControlUtil.queryVehicleTemperature(uid, xpVehicle.getVehicleVin());
|
log.info("查询车辆温度成功：{}",vehicleTemperatureDto);
|
return vehicleTemperatureDto;
|
}catch (Exception e){
|
log.error("查询车辆温度失败",e);
|
return new VehicleTemperatureDto();
|
}
|
}
|
|
@Override
|
public PageInfo<XpVehicleVO> getVehiclePageList(VehicleSelectPageQuery query) {
|
Page<XpVehicleVO> page = new Page<>(query.getPageNum(), query.getPageSize());
|
page = baseMapper.getVehiclePageList(page, query.getPlateNumber(), query.getFleetName());
|
PageInfo<XpVehicleVO> pageInfo = new PageInfo<>();
|
pageInfo.setTotal(page.getTotal());
|
pageInfo.setRecords(page.getRecords());
|
return pageInfo;
|
}
|
}
|
