package com.xiaopeng.vehicleConvoy.service.impl;
|
|
import cn.hutool.core.bean.BeanUtil;
|
import cn.hutool.core.collection.CollUtil;
|
import com.alibaba.fastjson2.JSONArray;
|
import com.alibaba.fastjson2.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.xiaopeng.api.feignClient.account.SysUserClient;
|
import com.xiaopeng.api.feignClient.account.XpOperationUserClient;
|
import com.xiaopeng.api.feignClient.vehicleConvoy.XpVehicleClient;
|
import com.xiaopeng.api.model.account.SysUser;
|
import com.xiaopeng.api.model.account.XpOperationsUser;
|
import com.xiaopeng.api.model.vehicleConvoy.XpPolicyApplication;
|
import com.xiaopeng.api.model.vehicleConvoy.XpVehicle;
|
import com.xiaopeng.common.core.domain.R;
|
import com.xiaopeng.common.core.enums.AuditStateEnum;
|
import com.xiaopeng.common.core.enums.PolicyApplicationAuditStateEnum;
|
import com.xiaopeng.common.core.web.page.PageInfo;
|
import com.xiaopeng.common.security.utils.SecurityUtils;
|
import com.xiaopeng.evi.oss.service.AliOssService;
|
import com.xiaopeng.vehicleConvoy.mapper.XpPolicyApplicationMapper;
|
import com.xiaopeng.vehicleConvoy.mapper.XpVehicleMapper;
|
import com.xiaopeng.vehicleConvoy.model.dto.XpPolicyApplicationAuditDTO;
|
import com.xiaopeng.vehicleConvoy.model.query.XpPolicyApplicationQuery;
|
import com.xiaopeng.vehicleConvoy.model.vo.QueryPolicyInfoVO;
|
import com.xiaopeng.vehicleConvoy.model.vo.XpPolicyApplicationVO;
|
import com.xiaopeng.vehicleConvoy.service.IXpPolicyApplicationService;
|
import lombok.RequiredArgsConstructor;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.context.annotation.Lazy;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.CollectionUtils;
|
|
import javax.annotation.Resource;
|
import java.io.UnsupportedEncodingException;
|
import java.time.LocalDateTime;
|
import java.time.LocalTime;
|
import java.util.*;
|
import java.util.function.Function;
|
import java.util.stream.Collectors;
|
|
/**
|
* <p>
|
* 保单申请 服务实现类
|
* </p>
|
*
|
* @author mitao
|
* @since 2026-02-03
|
*/
|
@Service
|
@RequiredArgsConstructor(onConstructor_ = @Lazy)
|
public class XpPolicyApplicationServiceImpl extends ServiceImpl<XpPolicyApplicationMapper, XpPolicyApplication> implements IXpPolicyApplicationService {
|
|
private final XpOperationUserClient xpOperationUserClient;
|
private final XpVehicleClient xpVehicleClient;
|
private final SysUserClient sysUserClient;
|
private final XpVehicleMapper xpVehicleMapper;
|
private final AliOssService aliOssService;
|
@Override
|
public PageInfo<XpPolicyApplicationVO> pageList(XpPolicyApplicationQuery query) {
|
PageInfo<XpPolicyApplicationVO> resultPage = new PageInfo<>(query.getPageNum(), query.getPageSize());
|
// 1. 根据运维人员名称查询运维人员ID列表
|
List<Long> operationUserIds = null;
|
List<Long> vehicleIds = null;
|
if (StringUtils.isNotBlank(query.getNickName())) {
|
R<List<XpOperationsUser>> userData = xpOperationUserClient.listByName(query.getNickName());
|
if (R.isSuccess(userData)) {
|
if (CollUtil.isEmpty(userData.getData())) {
|
return resultPage;
|
}
|
operationUserIds = userData.getData().stream().map(XpOperationsUser::getId).collect(Collectors.toList());
|
}
|
}
|
|
// 2.根据车牌号获取车辆ID列表
|
if (StringUtils.isNotBlank(query.getPlateNumber())) {
|
R<List<XpVehicle>> vehicleData = xpVehicleClient.listByPlateNumber(query.getPlateNumber());
|
if (R.isSuccess(vehicleData)) {
|
vehicleIds = vehicleData.getData().stream().map(XpVehicle::getId).collect(Collectors.toList());
|
}
|
}
|
|
// 3.分页查询保单申请列表
|
LambdaQueryWrapper<XpPolicyApplication> lambdaQueryWrapper = new LambdaQueryWrapper<>();
|
if (Objects.nonNull(query.getStartTime())) {
|
lambdaQueryWrapper.ge(XpPolicyApplication::getCreateTime, LocalDateTime.of(query.getStartTime(), LocalTime.MIN));
|
}
|
if (Objects.nonNull(query.getStartTime())) {
|
lambdaQueryWrapper.le(XpPolicyApplication::getCreateTime, LocalDateTime.of(query.getEndTime(), LocalTime.MAX));
|
}
|
lambdaQueryWrapper.in(CollUtil.isNotEmpty(operationUserIds), XpPolicyApplication::getApplicantId, operationUserIds)
|
.in(CollUtil.isNotEmpty(vehicleIds), XpPolicyApplication::getVehicleId, vehicleIds)
|
.eq(Objects.nonNull(query.getAuditStatus()), XpPolicyApplication::getAuditStatus, query.getAuditStatus())
|
.orderByDesc(XpPolicyApplication::getCreateTime);
|
Page<XpPolicyApplication> page = page(new Page<>(query.getPageNum(), query.getPageSize()), lambdaQueryWrapper);
|
//4.批量获取相关用户和车辆信息
|
Set<Long> operationsUserIdSet = page.getRecords().stream().map(XpPolicyApplication::getApplicantId).filter(Objects::nonNull).collect(Collectors.toSet());
|
Set<Long> vehicleIdSet = page.getRecords().stream().map(XpPolicyApplication::getVehicleId).filter(Objects::nonNull).collect(Collectors.toSet());
|
Set<Long> auditUserIds = page.getRecords().stream().map(XpPolicyApplication::getAuditUserId).filter(Objects::nonNull).collect(Collectors.toSet());
|
Map<Long, XpVehicle> longXpVehicleMap = batchGetVehicles(vehicleIdSet);
|
Map<Long, XpOperationsUser> longXpOperationsUserMap = batchGetOperationsUsers(operationsUserIdSet);
|
Map<Long, SysUser> auditUserMap = batchGetUsers(auditUserIds);
|
|
// 5. 组装 VO
|
List<XpPolicyApplicationVO> voList = page.getRecords().stream()
|
.map(item -> convertToPageVO(item, longXpVehicleMap, longXpOperationsUserMap, auditUserMap))
|
.collect(Collectors.toList());
|
// 6. 返回分页结果
|
resultPage.setTotal(page.getTotal());
|
resultPage.setRecords(voList);
|
return resultPage;
|
}
|
|
/**
|
* 转换为页面 VO
|
*
|
* @param item
|
* @param longXpVehicleMap
|
* @param longXpOperationsUserMap
|
* @param auditUserMap
|
* @return
|
*/
|
private XpPolicyApplicationVO convertToPageVO(XpPolicyApplication item, Map<Long, XpVehicle> longXpVehicleMap,
|
Map<Long, XpOperationsUser> longXpOperationsUserMap, Map<Long, SysUser> auditUserMap) {
|
XpPolicyApplicationVO xpPolicyApplicationVO = BeanUtil.copyProperties(item, XpPolicyApplicationVO.class);
|
xpPolicyApplicationVO.setAuditStatusDesc(AuditStateEnum.getDescByCode(item.getAuditStatus()));
|
// 车辆信息
|
if (Objects.nonNull(item.getVehicleId())) {
|
XpVehicle xpVehicle = longXpVehicleMap.get(item.getVehicleId());
|
if (Objects.nonNull(xpVehicle)) {
|
xpPolicyApplicationVO.setPlateNumber(xpVehicle.getPlateNumber());
|
xpPolicyApplicationVO.setVehicleCode(xpVehicle.getVehicleCode());
|
}
|
}
|
// 申请人信息
|
if (Objects.nonNull(item.getApplicantId())) {
|
XpOperationsUser operationsUser = longXpOperationsUserMap.get(item.getApplicantId());
|
if (Objects.nonNull(operationsUser)) {
|
xpPolicyApplicationVO.setNickName(operationsUser.getNickName());
|
xpPolicyApplicationVO.setPhoneNumber(operationsUser.getPhoneNumber());
|
}
|
}
|
// 审核人信息
|
if (Objects.nonNull(item.getAuditUserId())) {
|
SysUser sysUser = auditUserMap.get(item.getAuditUserId());
|
if (Objects.nonNull(sysUser)) {
|
xpPolicyApplicationVO.setAuditUserName(sysUser.getNickName());
|
}
|
}
|
return xpPolicyApplicationVO;
|
}
|
|
/**
|
* 批量获取系统用户信息
|
*/
|
private Map<Long, SysUser> batchGetUsers(Set<Long> auditUserIds) {
|
if (CollectionUtils.isEmpty(auditUserIds)) {
|
return new HashMap<>();
|
}
|
try {
|
R<List<SysUser>> result = sysUserClient.listByIds(new ArrayList<>(auditUserIds));
|
if (Objects.nonNull(result) && Objects.nonNull(result.getData())) {
|
return result.getData().stream()
|
.collect(Collectors.toMap(SysUser::getId, Function.identity(), (a, b) -> a));
|
}
|
} catch (Exception e) {
|
log.error("批量获取管理员用户信息失败", e);
|
}
|
return new HashMap<>();
|
}
|
|
/**
|
* 批量获取车辆信息
|
*/
|
private Map<Long, XpVehicle> batchGetVehicles(Set<Long> vehicleIds) {
|
if (CollectionUtils.isEmpty(vehicleIds)) {
|
return new HashMap<>();
|
}
|
try {
|
R<List<XpVehicle>> result = xpVehicleClient.listByIds(new ArrayList<>(vehicleIds));
|
if (Objects.nonNull(result) && Objects.nonNull(result.getData())) {
|
return result.getData().stream()
|
.collect(Collectors.toMap(XpVehicle::getId, Function.identity(), (a, b) -> a));
|
}
|
} catch (Exception e) {
|
log.error("批量获取车辆信息失败", e);
|
}
|
return new HashMap<>();
|
}
|
|
/**
|
* 批量获取用户信息
|
*/
|
private Map<Long, XpOperationsUser> batchGetOperationsUsers(Set<Long> operationsUserIds) {
|
if (CollectionUtils.isEmpty(operationsUserIds)) {
|
return new HashMap<>();
|
}
|
try {
|
R<List<XpOperationsUser>> result = xpOperationUserClient.listByIds(new ArrayList<>(operationsUserIds));
|
if (Objects.nonNull(result) && Objects.nonNull(result.getData())) {
|
return result.getData().stream()
|
.collect(Collectors.toMap(XpOperationsUser::getId, Function.identity(), (a, b) -> a));
|
}
|
} catch (Exception e) {
|
log.error("批量获取运维用户信息失败", e);
|
}
|
return new HashMap<>();
|
}
|
|
@Override
|
public void batchAudit(XpPolicyApplicationAuditDTO dto) {
|
// 1.查询待审核的保单申请记录
|
List<XpPolicyApplication> applications = lambdaQuery().in(XpPolicyApplication::getId, dto.getIds())
|
.eq(XpPolicyApplication::getAuditStatus, AuditStateEnum.PENDING_APPROVAL.getCode()).list();
|
if (CollectionUtils.isEmpty(applications)) {
|
return;
|
}
|
// 2.批量更新审核状态和审核信息
|
LocalDateTime now = LocalDateTime.now();
|
Long userId = SecurityUtils.getUserId();
|
applications.forEach(app -> {
|
app.setAuditStatus(dto.getAuditStatus());
|
app.setAuditRemarks(dto.getAuditRemarks());
|
app.setAuditUserId(userId);
|
app.setAuditTime(now);
|
});
|
updateBatchById(applications);
|
}
|
|
@Override
|
public void applyPolicyInformation(Long vehicleId, Long userId) {
|
XpPolicyApplication xpPolicyApplication = new XpPolicyApplication();
|
xpPolicyApplication.setVehicleId(vehicleId);
|
xpPolicyApplication.setApplicantId(userId);
|
xpPolicyApplication.setApplyTime(LocalDateTime.now());
|
xpPolicyApplication.setAuditStatus(PolicyApplicationAuditStateEnum.PENDING_APPROVAL.getCode());
|
this.save(xpPolicyApplication);
|
}
|
|
@Override
|
public QueryPolicyInfoVO queryPolicyInfoByVid(Long vehicleId, Long id) {
|
|
XpPolicyApplication xpPolicyApplication = this.getOne(Wrappers.lambdaQuery(XpPolicyApplication.class)
|
.eq(XpPolicyApplication::getVehicleId, vehicleId)
|
.eq(XpPolicyApplication::getApplicantId, id)
|
.orderByDesc(XpPolicyApplication::getCreateTime)
|
.last("limit 1"));
|
QueryPolicyInfoVO queryPolicyInfoVO = new QueryPolicyInfoVO();
|
if (Objects.nonNull(xpPolicyApplication)) {
|
XpPolicyApplicationVO xpPolicyApplicationVO = new XpPolicyApplicationVO();
|
BeanUtils.copyProperties(xpPolicyApplication, xpPolicyApplicationVO);
|
// 查询车辆
|
if (Objects.nonNull(xpPolicyApplication.getVehicleId())) {
|
XpVehicle xpVehicle = xpVehicleMapper.selectById(xpPolicyApplication.getVehicleId());
|
xpPolicyApplicationVO.setPlateNumber(xpVehicle.getPlateNumber());
|
xpPolicyApplicationVO.setVehicleCode(xpVehicle.getVehicleCode());
|
xpPolicyApplicationVO.setAuditRemarks(xpPolicyApplication.getAuditRemarks());
|
if (xpPolicyApplicationVO.getAuditStatus() == 2 && StringUtils.isNotBlank(xpVehicle.getPolicyInformation())) {
|
JSONArray jsonArray = JSONArray.parseArray(xpVehicle.getPolicyInformation());
|
for (int i = 0; i < jsonArray.size(); i++) {
|
JSONObject jsonObject = jsonArray.getJSONObject(i);
|
if (Objects.isNull(jsonObject)) {
|
continue;
|
}
|
// 1
|
String downloadUrl = jsonObject.getString("url");;
|
try {
|
downloadUrl = aliOssService.getDownloadUrl(jsonObject.getString("id"), jsonObject.getString("name"), true);
|
} catch (UnsupportedEncodingException e) {
|
log.error("获取图片下载地址失败", e);
|
}
|
jsonObject.put("url", downloadUrl);
|
}
|
xpPolicyApplicationVO.setPolicyInformation(JSONArray.toJSONString(jsonArray));
|
|
}
|
}
|
queryPolicyInfoVO.setStatus(xpPolicyApplication.getAuditStatus());
|
queryPolicyInfoVO.setXpPolicyApplicationVO(xpPolicyApplicationVO);
|
} else {
|
queryPolicyInfoVO.setStatus(0);
|
}
|
return queryPolicyInfoVO;
|
}
|
|
}
|
