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.order.XpOrder;
|
import com.xiaopeng.api.model.vehicleConvoy.XpVehicle;
|
import com.xiaopeng.api.model.vehicleConvoy.XpVehicleAnnualRecord;
|
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.domain.R;
|
import com.xiaopeng.common.core.exception.ServiceException;
|
import com.xiaopeng.common.core.web.page.PageInfo;
|
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.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.CollectionUtils;
|
|
import javax.annotation.Resource;
|
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;
|
|
@Override
|
public List<XpVehicle> listByIds(List<Long> ids) {
|
if (CollectionUtils.isEmpty(ids)) {
|
return new ArrayList<>();
|
}
|
return super.listByIds(ids);
|
}
|
|
@Override
|
public List<XpVehicle> listAvailableVehicles() {
|
// 构建查询条件
|
LambdaQueryWrapper<XpVehicle> wrapper = new LambdaQueryWrapper<>();
|
|
// 必要条件：可改派车辆的4个核心条件
|
wrapper.ne(XpVehicle::getStatus, 3) // 状态不是保险/年检过期
|
.isNotNull(XpVehicle::getStatus)
|
.eq(XpVehicle::getOperatingStatus, 1) // 运营中
|
.eq(XpVehicle::getAcceptOrTest, 1) // 接单模式
|
.eq(XpVehicle::getAcceptOrTestStatus, 1); // 开始接单
|
|
// 排序：按电量降序、入库时间降序
|
wrapper.orderByDesc(XpVehicle::getCurrentElectricity)
|
.orderByDesc(XpVehicle::getWarehousingTime);
|
|
// 执行查询
|
return this.list(wrapper);
|
}
|
|
@Override
|
public PageInfo<XpVehicle> pageList(VehicleMapQuery query) {
|
PageInfo<XpVehicle> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
|
List<XpVehicle> list = this.baseMapper.pageList(pageInfo, query);
|
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())){
|
vehiclesCommandVo.setCommandCode(VehiclesCommandEnum.DOOR_UNLOCK);
|
}else {
|
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);
|
}
|
// 设定温度
|
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 (locale.equals(Locale.CHINESE)) {
|
expiredItems.add("年检到期时间");
|
} else {
|
expiredItems.add("Annual inspection expiration date");
|
}
|
}
|
if (dto.getInsuranceEndTime() != null && dto.getInsuranceEndTime().isBefore(now)) {
|
if (locale.equals(Locale.CHINESE)) {
|
expiredItems.add("保险到期时间");
|
} else {
|
expiredItems.add("Insurance expiration date");
|
}
|
}
|
if (dto.getQualificationExpireTime() != null && dto.getQualificationExpireTime().isBefore(now)) {
|
if (locale.equals(Locale.CHINESE)) {
|
expiredItems.add("运营资质到期时间");
|
} else {
|
expiredItems.add("Operation qualification expiration date");
|
}
|
}
|
|
if (!expiredItems.isEmpty()) {
|
String detail;
|
if (locale.equals(Locale.CHINESE)) {
|
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 (locale.equals(Locale.CHINESE)) {
|
missingItems.add("保险信息");
|
} else {
|
missingItems.add("Insurance information");
|
}
|
}
|
|
// 校验年检信息
|
if (vehicle.getAnnualInspectionDate() == null
|
|| StringUtils.isBlank(vehicle.getInspectionAttachments())) {
|
if (locale.equals(Locale.CHINESE)) {
|
missingItems.add("年检信息");
|
} else {
|
missingItems.add("Annual inspection information");
|
}
|
}
|
|
// 校验运营区域
|
if (vehicle.getElectronicId() == null) {
|
if (locale.equals(Locale.CHINESE)) {
|
missingItems.add("运营区域");
|
} else {
|
missingItems.add("Operation area");
|
}
|
}
|
|
// 校验运营资质
|
if (StringUtils.isBlank(vehicle.getOperationQualification())
|
|| vehicle.getQualificationExpireTime() == null) {
|
if (locale.equals(Locale.CHINESE)) {
|
missingItems.add("运营资质");
|
} else {
|
missingItems.add("Operation qualification");
|
}
|
}
|
|
if (!missingItems.isEmpty()) {
|
String detail;
|
if (locale.equals(Locale.CHINESE)) {
|
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;
|
}
|
|
@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);
|
LocalDateTime now = LocalDateTime.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 (locale.equals(Locale.CHINESE)) {
|
reasons.add("状态非待运营");
|
} else {
|
reasons.add("Status is not 'Pending Operation'");
|
}
|
}
|
// 校验年检到期时间
|
if (vehicle.getAnnualInspectionDate() == null || vehicle.getAnnualInspectionDate().isBefore(now)) {
|
if (locale.equals(Locale.CHINESE)) {
|
reasons.add("年检已过期");
|
} else {
|
reasons.add("Annual inspection has expired");
|
}
|
}
|
// 校验保险到期时间
|
if (vehicle.getInsuranceEndTime() == null || vehicle.getInsuranceEndTime().isBefore(now)) {
|
if (locale.equals(Locale.CHINESE)) {
|
reasons.add("保险已过期");
|
} else {
|
reasons.add("Insurance has expired");
|
}
|
}
|
// 校验运营资质到期时间
|
if (vehicle.getQualificationExpireTime() == null || vehicle.getQualificationExpireTime().isBefore(now)) {
|
if (locale.equals(Locale.CHINESE)) {
|
reasons.add("运营资质已过期");
|
} else {
|
reasons.add("Operation qualification has expired");
|
}
|
}
|
if (!reasons.isEmpty()) {
|
if (locale.equals(Locale.CHINESE)) {
|
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, idStr)
|
.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)
|
.set(XpVehicle::getOperatingStatus, null);
|
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);
|
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;
|
}
|
}
|
