package com.xiaopeng.maintenance.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.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.google.common.collect.Lists;
|
import com.xiaopeng.api.dto.account.XpOperationsUserPositionDTO;
|
import com.xiaopeng.api.dto.account.XpOperationsUserQueryDTO;
|
import com.xiaopeng.api.dto.operation.LonLatDto;
|
import com.xiaopeng.api.dto.pushMessage.AliPushMessageDTO;
|
import com.xiaopeng.api.feignClient.account.SysUserClient;
|
import com.xiaopeng.api.feignClient.account.XpOperationUserClient;
|
import com.xiaopeng.api.feignClient.account.XpOperationUserNotificationClient;
|
import com.xiaopeng.api.feignClient.operation.SmsClient;
|
import com.xiaopeng.api.feignClient.pushMessage.WebSocketMessageClient;
|
import com.xiaopeng.api.feignClient.pushMessage.XpAliPushMessageClient;
|
import com.xiaopeng.api.feignClient.vehicleConvoy.XpFleetOperationsClient;
|
import com.xiaopeng.api.feignClient.vehicleConvoy.XpFleetVehicleClient;
|
import com.xiaopeng.api.feignClient.vehicleConvoy.XpVehicleClient;
|
import com.xiaopeng.api.model.account.SysUser;
|
import com.xiaopeng.api.model.account.XpOperationsRole;
|
import com.xiaopeng.api.model.account.XpOperationsUser;
|
import com.xiaopeng.api.model.account.XpOperationsUserNotification;
|
import com.xiaopeng.api.model.maintenance.*;
|
import com.xiaopeng.api.model.vehicleConvoy.XpVehicle;
|
import com.xiaopeng.api.vo.XpTaskVO;
|
import com.xiaopeng.api.vo.account.XpOperationsUserWithRoleVO;
|
import com.xiaopeng.api.vo.automaticPilot.VehiclePosition;
|
import com.xiaopeng.api.vo.maintenance.TaskScheduleConstants;
|
import com.xiaopeng.api.vo.operation.RouteVo;
|
import com.xiaopeng.api.vo.operation.SmsVo;
|
import com.xiaopeng.common.core.constant.AliPushTypeConstant;
|
import com.xiaopeng.common.core.domain.R;
|
import com.xiaopeng.common.core.enums.NotificationTypeEnum;
|
import com.xiaopeng.common.core.enums.TaskTypeEnum;
|
import com.xiaopeng.common.core.enums.TaskTypeNotificationEnum;
|
import com.xiaopeng.common.core.exception.ServiceException;
|
import com.xiaopeng.common.core.web.page.PageInfo;
|
import com.xiaopeng.evi.oss.service.AliOssService;
|
import com.xiaopeng.maintenance.constant.I18nKeyConstant;
|
import com.xiaopeng.maintenance.dto.HandleVehicleAccidentDto;
|
import com.xiaopeng.maintenance.dto.SaveErrorTaskDto;
|
import com.xiaopeng.maintenance.dto.SaveRoutineDetailDto;
|
import com.xiaopeng.maintenance.dto.SaveVehicleAccidentDto;
|
import com.xiaopeng.maintenance.mapper.*;
|
import com.xiaopeng.maintenance.model.query.TaskManagementPageListQuery;
|
import com.xiaopeng.maintenance.model.query.TaskPageListQuery;
|
import com.xiaopeng.maintenance.model.query.WorkBenchQuery;
|
import com.xiaopeng.maintenance.model.query.XpTaskRecordPageQuery;
|
import com.xiaopeng.maintenance.model.vo.*;
|
import com.xiaopeng.maintenance.repo.XpOperationsUserRepository;
|
import com.xiaopeng.maintenance.service.IXpClockInService;
|
import com.xiaopeng.maintenance.service.IXpTaskRuleRoleService;
|
import com.xiaopeng.maintenance.service.IXpTaskRuleService;
|
import com.xiaopeng.maintenance.service.XpTaskService;
|
import com.xiaopeng.maintenance.utils.AliOssDownloadUtil;
|
import com.xiaopeng.maintenance.utils.GDMapGeocodingUtil;
|
import com.xiaopeng.maintenance.utils.UUIDUtil;
|
import com.xiaopeng.maintenance.vo.TaskCleanDetailVO;
|
import com.xiaopeng.maintenance.vo.TaskDetectionDetailVO;
|
import com.xiaopeng.maintenance.vo.TaskReassignmentVo;
|
import lombok.Data;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.logging.log4j.util.Strings;
|
import org.apache.shardingsphere.transaction.annotation.ShardingSphereTransactionType;
|
import org.apache.shardingsphere.transaction.core.TransactionType;
|
import org.redisson.api.RLock;
|
import org.redisson.api.RedissonClient;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
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.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.CollectionUtils;
|
|
import javax.annotation.Resource;
|
import java.io.UnsupportedEncodingException;
|
import java.math.BigDecimal;
|
import java.text.SimpleDateFormat;
|
import java.time.Duration;
|
import java.time.LocalDateTime;
|
import java.time.LocalTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.*;
|
import java.util.concurrent.LinkedBlockingQueue;
|
import java.util.concurrent.ThreadPoolExecutor;
|
import java.util.concurrent.TimeUnit;
|
import java.util.stream.Collectors;
|
|
/**
|
* <p>
|
* 任务管理 服务实现类
|
* </p>
|
*
|
* @author WuGuanFengYue
|
* @since 2026-02-03
|
*/
|
@Slf4j
|
@Service
|
public class XpTaskServiceImpl extends ServiceImpl<XpTaskMapper, XpTask> implements XpTaskService {
|
@Autowired
|
private RedissonClient redissonClient;
|
@Autowired
|
private XpErrorTypeMapper errorTypeMapper;
|
@Resource
|
private XpOperationUserClient operationUserClient;
|
|
@Autowired
|
private XpTaskHandleDetailMapper xpTaskHandleDetailMapper;
|
@Autowired
|
private XpChargingRecordMapper chargingRecordMapper;
|
@Autowired
|
private XpVehicleRepairMapper vehicleRepairMapper;
|
@Autowired
|
private XpVehiclePreparationMapper vehiclePreparationMapper;
|
@Autowired
|
private XpVehicleDetectionMapper vehicleDetectionMapper;
|
|
@Autowired
|
private XpVehicleCleanMapper vehicleCleanMapper;
|
@Resource
|
private XpOperationUserClient xpOperationUserClient;
|
@Resource
|
private SysUserClient sysUserClient;
|
@Autowired
|
private XpTaskHandleDetailRoutineMapper xpTaskHandleDetailRoutineMapper;
|
|
@Resource
|
private XpVehicleClient xpVehicleClient;
|
@Autowired
|
private XpTaskRuleMapper xpTaskRuleMapper;
|
@Autowired
|
private MongoTemplate mongoTemplate;
|
@Resource
|
private XpAliPushMessageClient xpAliPushMessageClient;
|
@Resource
|
private XpOperationUserNotificationClient xpOperationUserNotificationClient;
|
@Autowired
|
private IXpTaskRuleRoleService xpTaskRuleRoleService;
|
@Autowired
|
private IXpTaskRuleService xpTaskRuleService;
|
|
@Resource
|
private GDMapGeocodingUtil gdMapGeocodingUtil;
|
|
@Resource
|
private XpFleetVehicleClient xpFleetVehicleClient;
|
|
@Resource
|
private XpFleetOperationsClient xpFleetOperationsClient;
|
|
@Resource
|
private AliOssService aliOssService;
|
@Autowired
|
private AliOssDownloadUtil aliOssDownloadUtil;
|
|
@Resource
|
private WebSocketMessageClient xpWebSocketMessageClient;
|
|
@Resource
|
private IXpClockInService xpClockInService;
|
|
@Override
|
public PageInfo<WorkBenchVO> workbench(WorkBenchQuery query) throws UnsupportedEncodingException {
|
PageInfo<WorkBenchVO> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
|
List<WorkBenchVO> list = this.baseMapper.workbench(pageInfo, query);
|
|
for (WorkBenchVO workBenchVO : list) {
|
String vehiclePictures = workBenchVO.getVehiclePictures();
|
if (StringUtils.isNotBlank(vehiclePictures)) {
|
JSONObject jsonObject = JSONObject.parseObject(vehiclePictures);
|
//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);
|
workBenchVO.setVehiclePictures(jsonObject.toJSONString());
|
}
|
}
|
|
pageInfo.setRecords(list);
|
return pageInfo;
|
}
|
|
@Override
|
public PageInfo<TaskPageListVO> pageList(TaskPageListQuery query) {
|
if (query.getDistributeType() != null) {
|
LocalDateTime now = LocalDateTime.now();
|
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
|
switch (query.getDistributeType()) {
|
case 1: // 今天
|
query.setStartTime(now.with(LocalTime.MIN).format(formatter));
|
query.setEndTime(now.with(LocalTime.MAX).format(formatter));
|
break;
|
case 2: // 昨天
|
LocalDateTime yesterdayStart = now.minusDays(1).with(LocalTime.MIN);
|
LocalDateTime yesterdayEnd = now.minusDays(1).with(LocalTime.MAX);
|
query.setStartTime(yesterdayStart.format(formatter));
|
query.setEndTime(yesterdayEnd.format(formatter));
|
break;
|
case 3: // 近一周
|
LocalDateTime weekAgoStart = now.minusDays(7).with(LocalTime.MIN);
|
query.setStartTime(weekAgoStart.format(formatter));
|
query.setEndTime(now.with(LocalTime.MAX).format(formatter));
|
break;
|
case 4: // 近一月
|
LocalDateTime monthAgoStart = now.minusDays(30).with(LocalTime.MIN);
|
query.setStartTime(monthAgoStart.format(formatter));
|
query.setEndTime(now.with(LocalTime.MAX).format(formatter));
|
break;
|
default:
|
// 默认不设置时间范围
|
break;
|
}
|
}
|
PageInfo<TaskPageListVO> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
|
List<TaskPageListVO> list = this.baseMapper.pageList(pageInfo, query);
|
XpTaskRule xpTaskRule = xpTaskRuleMapper.selectOne(new LambdaQueryWrapper<XpTaskRule>().last("limit 1"));
|
if (Objects.nonNull(xpTaskRule)) {
|
list.stream().filter(item -> item.getTaskCategory().equals(2)).forEach(item -> {
|
item.setCanArriveRange(xpTaskRule.getCanArriveRange());
|
});
|
}
|
pageInfo.setRecords(list);
|
return pageInfo;
|
}
|
|
|
@Override
|
@Transactional
|
@ShardingSphereTransactionType(TransactionType.BASE)
|
public XpTask saveVehicleAccident(SaveVehicleAccidentDto dto, XpOperationsUser xpOperationsUser) {
|
XpTask xpTask = new XpTask();
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
|
String code = sdf.format(new Date()) + UUIDUtil.getNumberRandom(5);
|
xpTask.setTaskCode(code);
|
xpTask.setTaskCategory(2);
|
xpTask.setTaskTypeId(normalizeAccidentTaskTypeId(dto.getTaskTypeId()));
|
xpTask.setTaskUrgencyLevel(dto.getTaskUrgencyLevel());
|
xpTask.setTaskDescription(dto.getTaskDescription());
|
xpTask.setTaskImage(dto.getTaskImage());
|
xpTask.setVehicleId(dto.getId());
|
XpVehicle vehicle = xpVehicleClient.queryById(xpTask.getVehicleId()).getData();
|
if (Objects.isNull(vehicle)) {
|
throw new ServiceException("上报失败，未获取到车辆信息", I18nKeyConstant.TASK_VEHICLE_NOT_EXIST);
|
}
|
// VehiclePosition vehiclePosition = mongoTemplate.findOne(new Query(Criteria.where("vin").is(vehicle.getVehicleVin())), VehiclePosition.class);
|
// if (Objects.isNull(vehiclePosition)) {
|
// log.error("事故上报未获取到车辆当前定位");
|
// throw new ServiceException("获取车辆实时定位信息失败，请稍后重试", I18nKeyConstant.TASK_SAVE_ERROR);
|
// }
|
// xpTask.setVehicleLon(new BigDecimal(vehiclePosition.getPoint().getX()));
|
// xpTask.setVehicleLat(new BigDecimal(vehiclePosition.getPoint().getY()));
|
// Map<String, String> geocode = gdMapGeocodingUtil.geocode(xpTask.getVehicleLon().toString(), xpTask.getVehicleLat().toString());
|
// String address = geocode == null ? null : geocode.get("address");
|
// if (StringUtils.isBlank(address)) {
|
// log.error("事故上报通过车辆定位从高德获取地址信息失败");
|
// throw new ServiceException("获取车辆实时定位信息失败，请稍后重试", I18nKeyConstant.TASK_SAVE_ERROR);
|
// }
|
// xpTask.setVehicleLocation(address);
|
// 临时处理
|
xpTask.setVehicleLon(new BigDecimal("104.055683"));
|
xpTask.setVehicleLat(new BigDecimal("30.585991"));
|
xpTask.setVehicleLocation("四川省成都市武侯区石羊街道天府新谷");
|
xpTask.setVehicleId(dto.getId());
|
xpTask.setReportUserId(xpOperationsUser.getId());
|
xpTask.setReportTime(LocalDateTime.now());
|
xpTask.setStatus(0);
|
xpTask.setCreateBy(xpOperationsUser.getNickName());
|
XpTaskRule taskRule = xpTaskRuleService.lambdaQuery().last("limit 1").one();
|
List<XpTaskRuleRole> list = xpTaskRuleRoleService.lambdaQuery().eq(XpTaskRuleRole::getRuleType, 9).list();
|
if (CollUtil.isEmpty(list) || Objects.isNull(taskRule)) {
|
throw new ServiceException("未配置车辆事故任务分配规则");
|
}
|
List<Long> roleIds = list.stream().map(XpTaskRuleRole::getRoleId).collect(Collectors.toList());
|
R<List<XpOperationsRole>> xpOperationsRoleResult = xpOperationUserClient.getXpOperationsRoleByRoleIds(roleIds);
|
if (CollUtil.isNotEmpty(xpOperationsRoleResult.getData())) {
|
Long fleetId = xpFleetVehicleClient.getFleetIdByVehicleId(vehicle.getId()).getData();
|
List<Long> ids = xpFleetOperationsClient.getOperationsIdsByFleetId(fleetId).getData();
|
// 根据配置的事故处理角色和事故车辆所属车队人员，确定最终的任务分配人列表（取交集）
|
List<Long> userIds = xpOperationsRoleResult.getData().stream().filter(x -> ids.contains(x.getOperationsUserId()))
|
.map(XpOperationsRole::getOperationsUserId)
|
.distinct().collect(Collectors.toList());
|
//获取首选人的实时定位，计算每个人到事故车辆位置的导航距离
|
List<Operations> operationsList = new ArrayList<>();
|
for (Long userId : userIds) {
|
Operations operations = new Operations();
|
operations.setUserId(userId);
|
XpOperationsUserPositionDTO vehiclePosition = mongoTemplate.findOne(new Query(Criteria.where("id").is(userId)), XpOperationsUserPositionDTO.class);
|
if(null != vehiclePosition){
|
LonLatDto start = new LonLatDto(vehiclePosition.getLongitude(), vehiclePosition.getLatitude());
|
LonLatDto end = new LonLatDto(xpTask.getVehicleLon().doubleValue(), xpTask.getVehicleLat().doubleValue());
|
RouteVo routeVo = gdMapGeocodingUtil.getDistanceAndTime(start, end, null, null, null, null);
|
operations.setDistance(routeVo.getDistance());
|
}
|
operationsList.add(operations);
|
}
|
//对距离进行排序，去距离最近的人员
|
operationsList.sort((o1, o2) -> o1.getDistance().compareTo(o2.getDistance()) * -1);
|
Operations operations = operationsList.get(0);
|
Long userId = operations.getUserId();
|
//如果多人距离相同，可按照上班状态>空闲状态>工号排序
|
List<Operations> collect = operationsList.stream().filter(s -> s.getDistance().equals(operations.getDistance())).collect(Collectors.toList());
|
if(collect.size() > 1){
|
//查询已经上班打卡了的人员
|
List<XpClockIn> xpClockIns = xpClockInService.list(new QueryWrapper<XpClockIn>().in("app_user_id", collect)
|
.isNull("clock_out_result").last(" and DATE(now()) = DATE(clock_in_time)"));
|
if(xpClockIns.size() == 1){
|
userId = xpClockIns.get(0).getAppUserId();
|
}else if(xpClockIns.size() > 1){
|
//查询有任务的人员
|
List<Long> collect1 = xpClockIns.stream().map(XpClockIn::getAppUserId).collect(Collectors.toList());
|
List<XpTask> list1 = this.list(new QueryWrapper<XpTask>().eq("task_category", 2).in("handle_user_id", collect1)
|
.in("status", Arrays.asList(0, 1, 4)));
|
if(list1.size() > 0){
|
//对工号进行排序
|
List<String> collect2 = list1.stream().map(XpTask::getHandleUserId).collect(Collectors.toList());
|
//找出没有任务的人员
|
List<Long> collect3 = collect1.stream().filter(s -> !collect2.contains(s.toString())).collect(Collectors.toList());
|
//查询人员数据，对其进行工号排序
|
XpOperationsUserQueryDTO dto1 = new XpOperationsUserQueryDTO();
|
dto1.setIds(collect3);
|
List<XpOperationsUserWithRoleVO> data = xpOperationUserClient.findList(dto1).getData();
|
data.sort((o1, o2) -> o1.getUniqueNumber().compareTo(o2.getUniqueNumber()) * -1);
|
userId = data.get(0).getId();
|
}
|
}
|
}
|
xpTask.setHandleUserId(userId.toString());
|
}
|
// 根据事故处理限时配置设置任务截止时间
|
LocalDateTime endTime = LocalDateTime.now().plusMinutes(taskRule.getProcessingTimeLimit());
|
xpTask.setEndTime(endTime);
|
xpTask.setExpiredNoticeSent(0);
|
xpTask.setWillTimeoutNoticeSent(0);
|
this.save(xpTask);
|
if (xpTask.getId() == null && StringUtils.isNotBlank(xpTask.getTaskCode())) {
|
XpTask savedTask = this.getOne(new LambdaQueryWrapper<XpTask>()
|
.eq(XpTask::getTaskCode, xpTask.getTaskCode())
|
.last("limit 1"));
|
if (savedTask != null && savedTask.getId() != null) {
|
xpTask.setId(savedTask.getId());
|
}
|
}
|
|
// 异步发送消息通知
|
String plateNumber = Objects.nonNull(vehicle) ? vehicle.getPlateNumber() : "";
|
sendAccidentNotificationAsync(xpTask, plateNumber, taskRule.getProcessingTimeLimit());
|
return xpTask;
|
}
|
|
|
@Data
|
class Operations {
|
/**
|
* 候选人id
|
*/
|
private Long userId;
|
/**
|
* 距离
|
*/
|
private Integer distance;
|
}
|
|
|
|
/**
|
* 异步发送事故通知
|
* @param xpTask 任务信息
|
* @param plateNumber 车牌号
|
* @param processingTimeLimit 处理时限（分钟）
|
*/
|
private void sendAccidentNotificationAsync(XpTask xpTask, String plateNumber, Integer processingTimeLimit) {
|
ThreadPoolExecutor executor = new ThreadPoolExecutor(
|
1, 1, 0L, TimeUnit.MILLISECONDS,
|
new LinkedBlockingQueue<Runnable>()
|
);
|
|
executor.execute(() -> {
|
try {
|
List<Long> userIds = Arrays.stream(xpTask.getHandleUserId().split(",")).map(Long::valueOf).collect(Collectors.toList());
|
if (CollUtil.isEmpty(userIds)) {
|
return;
|
}
|
|
R<List<XpOperationsUser>> xpOperationUserResult = xpOperationUserClient.listByIds(userIds);
|
List<XpOperationsUser> data = xpOperationUserResult.getData();
|
if (CollUtil.isEmpty(data)) {
|
return;
|
}
|
|
// 构建通知内容
|
String content = buildAccidentNotificationContent(xpTask, plateNumber, processingTimeLimit);
|
saveAndPushAccidentNotification(data, content, xpTask);
|
} catch (Exception e) {
|
log.error("发送事故通知失败，任务ID={}", xpTask.getId(), e);
|
}
|
});
|
|
executor.shutdown();
|
}
|
|
/**
|
* 异步发送事故任务分配通知
|
*
|
* @param xpTask 任务信息
|
* @param handlerUserId 当前分配的处理人
|
* @param plateNumber 车牌号
|
* @param processingTimeLimit 处理时限（分钟）
|
*/
|
private void sendAssignedAccidentNotificationAsync(XpTask xpTask, Long handlerUserId, String plateNumber, Integer processingTimeLimit) {
|
ThreadPoolExecutor executor = new ThreadPoolExecutor(
|
1, 1, 0L, TimeUnit.MILLISECONDS,
|
new LinkedBlockingQueue<Runnable>()
|
);
|
|
executor.execute(() -> {
|
try {
|
R<List<XpOperationsUser>> xpOperationUserResult = xpOperationUserClient.listByIds(Collections.singletonList(handlerUserId));
|
List<XpOperationsUser> data = xpOperationUserResult == null ? Collections.emptyList() : xpOperationUserResult.getData();
|
if (CollUtil.isEmpty(data)) {
|
return;
|
}
|
|
String content = buildAccidentNotificationContent(xpTask, plateNumber, processingTimeLimit);
|
saveAndPushAccidentNotification(data, content, xpTask);
|
} catch (Exception e) {
|
log.error("发送事故任务分配通知失败，任务ID={}, handlerUserId={}", xpTask.getId(), handlerUserId, e);
|
}
|
});
|
|
executor.shutdown();
|
}
|
|
/**
|
* 构建事故通知文案
|
*
|
* @param xpTask 任务信息
|
* @param plateNumber 车牌号
|
* @param processingTimeLimit 处理时限（分钟）
|
* @return 通知内容
|
*/
|
private String buildAccidentNotificationContent(XpTask xpTask, String plateNumber, Integer processingTimeLimit) {
|
return String.format("车辆%s在%s发生了紧急事故，请在%d分钟内到达现场！", plateNumber, xpTask.getVehicleLocation(), processingTimeLimit);
|
}
|
|
/**
|
* 构建事故推送 body JSON
|
* @param content 消息内容
|
* @param xpTask 任务信息
|
* @return JSON 字符串
|
*/
|
private String buildAccidentPushBodyJson(String content, XpTask xpTask) {
|
Map<String, Object> param = new HashMap<>();
|
param.put("content", content);
|
param.put("strategy", NotificationTypeEnum.ACCIDENT_NEW.getCode());
|
param.put("type", TaskTypeNotificationEnum.ACCIDENT_TASK.getCode());
|
param.put("id", xpTask.getId().toString());
|
return JSONObject.toJSONString(param);
|
}
|
|
/**
|
* 保存事故通知记录并发送阿里云推送
|
*
|
* @param data 接收通知的运维人员
|
* @param content 通知内容
|
* @param xpTask 任务信息
|
*/
|
private void saveAndPushAccidentNotification(List<XpOperationsUser> data, String content, XpTask xpTask) {
|
String bodyJson = buildAccidentPushBodyJson(content, xpTask);
|
|
List<XpOperationsUserNotification> notifications = data.stream().map(item -> {
|
XpOperationsUserNotification notification = new XpOperationsUserNotification();
|
notification.setOperationsUserId(item.getId());
|
notification.setNotificationType(NotificationTypeEnum.ACCIDENT_NEW.getCode());
|
notification.setNotificationContent(content);
|
notification.setDataId(xpTask.getId());
|
notification.setReadStatus(0);
|
notification.setNotificationExt(bodyJson);
|
return notification;
|
}).collect(Collectors.toList());
|
|
if (CollUtil.isNotEmpty(notifications)) {
|
xpOperationUserNotificationClient.addNotificationBatch(notifications);
|
log.info("事故通知记录保存成功，共 {} 条", notifications.size());
|
}
|
|
XpTaskVO xpTaskVO = new XpTaskVO();
|
BeanUtil.copyProperties(xpTask, xpTaskVO);
|
xpWebSocketMessageClient.pushTask(xpTaskVO);
|
|
Map<Integer, List<XpOperationsUser>> operationUserMap = data.stream()
|
.filter(u -> u.getDeviceType() != null && StringUtils.isNotBlank(u.getPhoneNumber()))
|
.collect(Collectors.groupingBy(XpOperationsUser::getDeviceType));
|
for (Map.Entry<Integer, List<XpOperationsUser>> entry : operationUserMap.entrySet()) {
|
pushAliMessage(entry.getValue(), content, xpTask);
|
}
|
}
|
|
|
/**
|
* 推送阿里云通知
|
*
|
* @param data
|
* @param content
|
* @param xpTask
|
*/
|
private void pushAliMessage(List<XpOperationsUser> data, String content, XpTask xpTask) {
|
String account = data.stream().map(XpOperationsUser::getPhoneNumber).filter(Objects::nonNull).collect(Collectors.joining(","));
|
Map<String, Object> param = new HashMap<>();
|
param.put("content", content);
|
param.put("strategy", NotificationTypeEnum.ACCIDENT_NEW.getCode());
|
param.put("type", TaskTypeNotificationEnum.ACCIDENT_TASK.getCode());
|
param.put("id", xpTask.getId().toString());
|
xpAliPushMessageClient.pushMessage(AliPushMessageDTO.builder()
|
.body(JSONObject.toJSONString(param))
|
.account(account).title("车辆事故警示")
|
.pushType(AliPushTypeConstant.NOTICE)
|
.deviceType(data.get(0).getDeviceType())
|
.build());
|
}
|
|
@Override
|
public R<TaskAccidentDetailVO> vehicleAccidentDetail(Long id) throws UnsupportedEncodingException {
|
TaskAccidentDetailVO res = new TaskAccidentDetailVO();
|
XpTask task = this.getById(id);
|
if (task == null) {
|
throw new ServiceException(
|
"任务不存在",
|
I18nKeyConstant.TASK_NOT_EXIST
|
);
|
}
|
XpVehicle vehicle = xpVehicleClient.queryById(task.getVehicleId()).getData();
|
if (vehicle == null) {
|
throw new ServiceException(
|
"车辆不存在",
|
I18nKeyConstant.VEHICLE_NOT_EXIST
|
);
|
}
|
res.setId(id);
|
res.setVehicleId(vehicle.getId());
|
res.setTaskUrgencyLevel(task.getTaskUrgencyLevel());
|
res.setEndTime(task.getEndTime());
|
res.setPlateNumber(vehicle.getPlateNumber());
|
res.setVehicleColor(vehicle.getVehicleColor());
|
res.setVehicleCode(vehicle.getVehicleCode());
|
res.setVehicleVin(vehicle.getVehicleVin());
|
res.setVehicleLocation(task.getVehicleLocation());
|
res.setCreateBy(task.getCreateBy());
|
res.setCreateTime(task.getCreateTime());
|
res.setTaskCode(task.getTaskCode());
|
res.setTaskCategory(task.getTaskCategory());
|
res.setTaskTypeId(task.getTaskTypeId());
|
res.setVehicleLon(task.getVehicleLon());
|
res.setVehicleLat(task.getVehicleLat());
|
Map<Long, List<XpErrorType>> errorType = errorTypeMapper.selectList(new LambdaQueryWrapper<XpErrorType>()
|
.in(XpErrorType::getId, Arrays.asList(task.getTaskTypeId().split(","))))
|
.stream().collect(Collectors.groupingBy(XpErrorType::getParentId));
|
List<XpErrorType> xpErrorTypes = errorType.get(0L);
|
for (XpErrorType xpErrorType : xpErrorTypes) {
|
xpErrorType.setChild(errorType.get(xpErrorType.getId()));
|
}
|
res.setErrorTypeList(xpErrorTypes);
|
res.setStatus(task.getStatus());
|
res.setTaskDescription(task.getTaskDescription());
|
res.setTaskImage(task.getTaskImage());
|
XpTaskRule xpTaskRule = xpTaskRuleMapper.selectOne(new LambdaQueryWrapper<XpTaskRule>().last("limit 1"));
|
if (Objects.nonNull(xpTaskRule)) {
|
res.setCanArriveRange(xpTaskRule.getCanArriveRange());
|
}
|
res.setTaskImage(aliOssDownloadUtil.getPictureJsonArray(res.getTaskImage()));
|
return R.ok(res);
|
}
|
|
@ShardingSphereTransactionType(TransactionType.BASE)
|
@Transactional(rollbackFor = Exception.class)
|
@Override
|
public R handleVehicleAccident(HandleVehicleAccidentDto dto, XpOperationsUser xpOperationsUser) {
|
XpTask task = this.getById(dto.getId());
|
if (task == null) {
|
throw new ServiceException(
|
"任务不存在",
|
I18nKeyConstant.TASK_NOT_EXIST
|
);
|
}
|
|
task.setHandleTime(LocalDateTime.now());
|
task.setHandleUserId(xpOperationsUser.getId().toString());
|
task.setStatus(2);
|
updateById(task);
|
// 存储事故处理日志
|
XpTaskHandleDetail xpTaskHandleDetail = new XpTaskHandleDetail();
|
xpTaskHandleDetail.setTaskId(task.getId());
|
xpTaskHandleDetail.setDeathCount(dto.getDeathCount());
|
xpTaskHandleDetail.setSevereCount(dto.getSevereCount());
|
xpTaskHandleDetail.setMinorCount(dto.getMinorCount());
|
xpTaskHandleDetail.setResponsibilityJudgment(dto.getResponsibilityJudgment());
|
xpTaskHandleDetail.setResponsibleDescription(dto.getResponsibleDescription());
|
xpTaskHandleDetail.setResponsibleImage(dto.getResponsibleImage());
|
xpTaskHandleDetail.setDisposalDescription(dto.getDisposalDescription());
|
xpTaskHandleDetail.setDisposalImage(dto.getDisposalImage());
|
xpTaskHandleDetail.setSituationDescription(dto.getSituationDescription());
|
xpTaskHandleDetail.setSituationImage(dto.getSituationImage());
|
xpTaskHandleDetailMapper.insert(xpTaskHandleDetail);
|
return R.ok();
|
}
|
|
@Override
|
public R<TaskRoutineDetailVO> vehicleRoutineDetail(Long id) throws UnsupportedEncodingException {
|
TaskRoutineDetailVO res = new TaskRoutineDetailVO();
|
XpTask task = this.getById(id);
|
if (task == null) {
|
throw new ServiceException(
|
"任务不存在",
|
I18nKeyConstant.TASK_NOT_EXIST
|
);
|
}
|
XpVehicle vehicle = xpVehicleClient.queryById(task.getVehicleId()).getData();
|
if (vehicle == null) {
|
throw new ServiceException(
|
"车辆不存在",
|
I18nKeyConstant.VEHICLE_NOT_EXIST
|
);
|
}
|
//查询任务处理记录
|
XpTaskHandleDetailRoutine xpTaskHandleDetailRoutine = xpTaskHandleDetailRoutineMapper.selectOne(new LambdaQueryWrapper<XpTaskHandleDetailRoutine>()
|
.eq(XpTaskHandleDetailRoutine::getTaskId, id).last("limit 1"));
|
res.setId(id);
|
res.setTaskUrgencyLevel(task.getTaskUrgencyLevel());
|
res.setEndTime(task.getEndTime());
|
res.setVehicleId(task.getVehicleId());
|
res.setVehicleLat(task.getVehicleLat());
|
res.setVehicleLon(task.getVehicleLon());
|
res.setPlateNumber(vehicle.getPlateNumber());
|
res.setVehicleColor(vehicle.getVehicleColor());
|
res.setVehicleCode(vehicle.getVehicleCode());
|
res.setVehicleVin(vehicle.getVehicleVin());
|
res.setVehicleLocation(task.getVehicleLocation());
|
res.setCreateBy(task.getCreateBy());
|
res.setCreateTime(task.getCreateTime());
|
res.setTaskCode(task.getTaskCode());
|
res.setTaskCategory(task.getTaskCategory());
|
res.setTaskTypeId(task.getTaskTypeId());
|
res.setStatus(task.getStatus());
|
res.setTaskDescription(task.getTaskDescription());
|
res.setTaskImage(task.getTaskImage());
|
res.setHandleUserId(task.getHandleUserId());
|
res.setHandleTime(task.getHandleTime());
|
if (Objects.nonNull(xpTaskHandleDetailRoutine)) {
|
res.setTaskDescription(xpTaskHandleDetailRoutine.getTaskDescription());
|
task.setHandleUserId(xpTaskHandleDetailRoutine.getOperationsUserId().toString());
|
res.setHandleTime(xpTaskHandleDetailRoutine.getCreateTime());
|
res.setTaskImage(xpTaskHandleDetailRoutine.getTaskImage());
|
}
|
if (Objects.nonNull(task.getHandleUserId()) && task.getHandleUserId().split(",").length == 1) {
|
XpOperationsUser data = xpOperationUserClient.queryById(Long.valueOf(task.getHandleUserId())).getData();
|
if (Objects.nonNull(data)) {
|
res.setHandleUserName(data.getNickName());
|
}
|
}
|
res.setTaskImage(aliOssDownloadUtil.getPictureJsonArray(res.getTaskImage()));
|
return R.ok(res);
|
}
|
|
@Override
|
public R<TaskChargingDetailVO> chargingDetail(Long id) {
|
TaskChargingDetailVO res = new TaskChargingDetailVO();
|
XpTask task = this.getById(id);
|
if (task == null) {
|
throw new ServiceException(
|
"任务不存在",
|
I18nKeyConstant.TASK_NOT_EXIST
|
);
|
}
|
XpVehicle vehicle = xpVehicleClient.queryById(task.getVehicleId()).getData();
|
if (vehicle == null) {
|
throw new ServiceException(
|
"车辆不存在",
|
I18nKeyConstant.VEHICLE_NOT_EXIST
|
);
|
}
|
res.setVehicleId(task.getVehicleId());
|
res.setId(id);
|
res.setTaskUrgencyLevel(task.getTaskUrgencyLevel());
|
res.setPlateNumber(vehicle.getPlateNumber());
|
res.setVehicleColor(vehicle.getVehicleColor());
|
res.setVehicleCode(vehicle.getVehicleCode());
|
res.setVehicleVin(vehicle.getVehicleVin());
|
res.setVehicleLocation(task.getVehicleLocation());
|
res.setCreateBy(task.getCreateBy());
|
res.setCreateTime(task.getCreateTime());
|
res.setTaskCode(task.getTaskCode());
|
res.setTaskCategory(task.getTaskCategory());
|
res.setTaskTypeId(task.getTaskTypeId());
|
res.setStatus(task.getStatus());
|
XpChargingRecord chargingRecord = chargingRecordMapper.selectOne(new LambdaQueryWrapper<XpChargingRecord>()
|
.eq(XpChargingRecord::getTaskId, id).last("limit 1").orderByDesc(XpChargingRecord::getCreateTime));
|
if (chargingRecord != null) {
|
res.setStartRemainingBattery(chargingRecord.getStartRemainingBattery());
|
res.setStartChargingPicture(aliOssDownloadUtil.getPictureJsonArray(chargingRecord.getStartChargingPicture()));
|
res.setStartTime(chargingRecord.getStartTime());
|
res.setEndRemainingBattery(chargingRecord.getEndRemainingBattery());
|
res.setEndChargingPicture(aliOssDownloadUtil.getPictureJsonArray(chargingRecord.getEndChargingPicture()));
|
|
res.setEndTime(chargingRecord.getEndTime());
|
res.setStartOperationsUserId(chargingRecord.getStartOperationsUserId());
|
res.setEndOperationsUserId(chargingRecord.getEndOperationsUserId());
|
if (chargingRecord.getStartOperationsUserId() != null) {
|
XpOperationsUser operationsUser = xpOperationUserClient.queryById(chargingRecord.getStartOperationsUserId()).getData();
|
if (operationsUser != null) {
|
res.setStartOperationsUserName(operationsUser.getNickName());
|
}
|
}
|
if (chargingRecord.getEndOperationsUserId() != null) {
|
XpOperationsUser operationsUser = xpOperationUserClient.queryById(chargingRecord.getEndOperationsUserId()).getData();
|
if (operationsUser != null) {
|
res.setEndOperationsUserName(operationsUser.getNickName());
|
}
|
}
|
}
|
|
return R.ok(res);
|
}
|
|
@Override
|
public R<TaskRepairDetailVO> repairDetail(Long id) {
|
TaskRepairDetailVO res = new TaskRepairDetailVO();
|
|
|
XpTask task = this.getById(id);
|
if (task == null) {
|
throw new ServiceException(
|
"任务不存在",
|
I18nKeyConstant.TASK_NOT_EXIST
|
);
|
}
|
XpVehicle vehicle = xpVehicleClient.queryById(task.getVehicleId()).getData();
|
if (vehicle == null) {
|
throw new ServiceException(
|
"车辆不存在",
|
I18nKeyConstant.VEHICLE_NOT_EXIST
|
);
|
}
|
res.setVehicleId(task.getVehicleId());
|
res.setId(id);
|
res.setTaskUrgencyLevel(task.getTaskUrgencyLevel());
|
res.setPlateNumber(vehicle.getPlateNumber());
|
res.setVehicleColor(vehicle.getVehicleColor());
|
res.setVehicleCode(vehicle.getVehicleCode());
|
res.setVehicleLocation(task.getVehicleLocation());
|
res.setCreateBy(task.getCreateBy());
|
res.setCreateTime(task.getCreateTime());
|
res.setTaskCode(task.getTaskCode());
|
res.setTaskCategory(task.getTaskCategory());
|
res.setTaskTypeId(task.getTaskTypeId());
|
res.setStatus(task.getStatus());
|
XpVehicleRepair vehicleRepair = vehicleRepairMapper.selectOne(new LambdaQueryWrapper<XpVehicleRepair>()
|
.eq(XpVehicleRepair::getTaskId, id).last("limit 1"));
|
if (vehicleRepair != null) {
|
res.setStartTime(vehicleRepair.getStartTime());
|
res.setEndTime(vehicleRepair.getEndTime());
|
res.setRepairReason(vehicleRepair.getRepairReason());
|
|
|
res.setStartRepairPicture(aliOssDownloadUtil.getPictureJsonArray(vehicleRepair.getStartRepairPicture()));
|
res.setRepairMoney(vehicleRepair.getRepairMoney());
|
res.setRepairMoneyDetail(vehicleRepair.getRepairMoneyDetail());
|
res.setSendUserId(vehicleRepair.getSendUserId());
|
res.setSendTime(vehicleRepair.getSendTime());
|
res.setReturnUserId(vehicleRepair.getReturnUserId());
|
res.setReturnTime(vehicleRepair.getReturnTime());
|
if (vehicleRepair.getReturnUserId() != null) {
|
XpOperationsUser operationsUser = xpOperationUserClient.queryById(vehicleRepair.getReturnUserId()).getData();
|
if (operationsUser != null) {
|
res.setReturnUserName(operationsUser.getNickName());
|
}
|
}
|
|
if (vehicleRepair.getSendUserId() != null) {
|
XpOperationsUser operationsUser = xpOperationUserClient.queryById(vehicleRepair.getSendUserId()).getData();
|
if (operationsUser != null) {
|
res.setSendUserName(operationsUser.getNickName());
|
}
|
}
|
}
|
|
return R.ok(res);
|
}
|
|
@Override
|
public R<TaskPreparationDetailVO> preparationDetail(Long id) {
|
TaskPreparationDetailVO res = new TaskPreparationDetailVO();
|
|
|
XpTask task = this.getById(id);
|
if (task == null) {
|
throw new ServiceException(
|
"任务不存在",
|
I18nKeyConstant.TASK_NOT_EXIST
|
);
|
}
|
XpVehicle vehicle = xpVehicleClient.queryById(task.getVehicleId()).getData();
|
if (vehicle == null) {
|
throw new ServiceException(
|
"车辆不存在",
|
I18nKeyConstant.VEHICLE_NOT_EXIST
|
);
|
}
|
res.setVehicleId(task.getVehicleId());
|
res.setId(id);
|
res.setTaskUrgencyLevel(task.getTaskUrgencyLevel());
|
res.setPlateNumber(vehicle.getPlateNumber());
|
res.setVehicleColor(vehicle.getVehicleColor());
|
res.setVehicleCode(vehicle.getVehicleCode());
|
res.setVehicleLocation(task.getVehicleLocation());
|
res.setCreateBy(task.getCreateBy());
|
res.setCreateTime(task.getCreateTime());
|
res.setTaskCode(task.getTaskCode());
|
res.setTaskCategory(task.getTaskCategory());
|
res.setTaskTypeId(task.getTaskTypeId());
|
res.setStatus(task.getStatus());
|
XpVehiclePreparation vehiclePreparation = vehiclePreparationMapper.selectOne(new LambdaQueryWrapper<XpVehiclePreparation>()
|
.eq(XpVehiclePreparation::getTaskId, id).last("limit 1"));
|
if (vehiclePreparation != null) {
|
res.setLeftFrontWheel(vehiclePreparation.getLeftFrontWheel());
|
res.setRightFrontWheel(vehiclePreparation.getRightFrontWheel());
|
res.setLeftRearWheel(vehiclePreparation.getLeftRearWheel());
|
res.setRightRearWheel(vehiclePreparation.getRightRearWheel());
|
res.setHeadLight(vehiclePreparation.getHeadLight());
|
res.setTurnSignal(vehiclePreparation.getTurnSignal());
|
res.setBrakeLight(vehiclePreparation.getBrakeLight());
|
res.setFogLight(vehiclePreparation.getFogLight());
|
res.setBodyEmblem(vehiclePreparation.getBodyEmblem());
|
res.setCabinCleaning(vehiclePreparation.getCabinCleaning());
|
res.setLostItems(vehiclePreparation.getLostItems());
|
res.setRemarks(vehiclePreparation.getRemarks());
|
res.setOperationsUserId(vehiclePreparation.getOperationsUserId());
|
res.setOperationsTime(vehiclePreparation.getCreateTime());
|
if (vehiclePreparation.getOperationsUserId() != null) {
|
XpOperationsUser operationsUser = xpOperationUserClient.queryById(vehiclePreparation.getOperationsUserId()).getData();
|
if (operationsUser != null) {
|
res.setOperationsUserName(operationsUser.getNickName());
|
}
|
}
|
}
|
return R.ok(res);
|
}
|
|
@Override
|
public R<TaskDetectionDetailVO> detectionDetail(Long id) {
|
TaskDetectionDetailVO res = new TaskDetectionDetailVO();
|
XpTask task = this.getById(id);
|
if (task == null) {
|
throw new ServiceException(
|
"任务不存在",
|
I18nKeyConstant.TASK_NOT_EXIST
|
);
|
}
|
XpVehicle vehicle = xpVehicleClient.queryById(task.getVehicleId()).getData();
|
if (vehicle == null) {
|
throw new ServiceException(
|
"车辆不存在",
|
I18nKeyConstant.VEHICLE_NOT_EXIST
|
);
|
}
|
res.setVehicleId(task.getVehicleId());
|
res.setId(id);
|
res.setTaskUrgencyLevel(task.getTaskUrgencyLevel());
|
res.setPlateNumber(vehicle.getPlateNumber());
|
res.setVehicleColor(vehicle.getVehicleColor());
|
res.setVehicleCode(vehicle.getVehicleCode());
|
res.setVehicleVin(vehicle.getVehicleVin());
|
res.setVehicleLocation(task.getVehicleLocation());
|
res.setCreateBy(task.getCreateBy());
|
res.setCreateTime(task.getCreateTime());
|
res.setTaskCode(task.getTaskCode());
|
res.setTaskCategory(task.getTaskCategory());
|
res.setTaskTypeId(task.getTaskTypeId());
|
res.setStatus(task.getStatus());
|
XpVehicleDetection vehicleDetection = vehicleDetectionMapper.selectOne(new LambdaQueryWrapper<XpVehicleDetection>()
|
.eq(XpVehicleDetection::getTaskId, id).last("limit 1"));
|
if (vehicleDetection != null) {
|
res.setNetworkDetection(vehicleDetection.getNetworkDetection());
|
res.setVersionVerification(vehicleDetection.getVersionVerification());
|
res.setCommunicationSelfCheck(vehicleDetection.getCommunicationSelfCheck());
|
res.setRemoteSelfCheck(vehicleDetection.getRemoteSelfCheck());
|
res.setCollisionPrevention(vehicleDetection.getCollisionPrevention());
|
res.setSensorSelfCheck(vehicleDetection.getSensorSelfCheck());
|
res.setSensorCleaning(vehicleDetection.getSensorCleaning());
|
res.setSensorCleaningPicture(aliOssDownloadUtil.getPictureJsonArray(vehicleDetection.getSensorCleaningPicture()));
|
res.setInteractiveScreen(vehicleDetection.getInteractiveScreen());
|
String InteractiveScreenPicture = vehicleDetection.getInteractiveScreenPicture();
|
res.setInteractiveScreenPicture(aliOssDownloadUtil.getPictureJsonArray(vehicleDetection.getInteractiveScreenPicture()));
|
res.setHelpButton(vehicleDetection.getHelpButton());
|
res.setHelpButtonPicture(aliOssDownloadUtil.getPictureJsonArray(vehicleDetection.getHelpButtonPicture()));
|
res.setPaymentFunction(vehicleDetection.getPaymentFunction());
|
res.setPaymentFunctionPicture(aliOssDownloadUtil.getPictureJsonArray(vehicleDetection.getPaymentFunctionPicture()));
|
res.setSystemCheck(vehicleDetection.getSystemCheck());
|
res.setSystemCheckPicture(aliOssDownloadUtil.getPictureJsonArray(vehicleDetection.getSystemCheckPicture()));
|
res.setCheckTime(vehicleDetection.getCheckTime());
|
res.setOperationsUserId(vehicleDetection.getOperationsUserId());
|
if (vehicleDetection.getOperationsUserId() != null) {
|
XpOperationsUser operationsUser = xpOperationUserClient.queryById(vehicleDetection.getOperationsUserId()).getData();
|
if (operationsUser != null) {
|
res.setOperationsUserName(operationsUser.getNickName());
|
}
|
}
|
}
|
return R.ok(res);
|
}
|
|
@Override
|
public R saveRoutineDetail(SaveRoutineDetailDto dto, Long id) {
|
XpTask task = this.getById(dto.getId());
|
if (task == null) {
|
throw new ServiceException(
|
"任务不存在",
|
I18nKeyConstant.TASK_NOT_EXIST
|
);
|
}
|
XpTaskHandleDetailRoutine xpTaskHandleDetailRoutine = new XpTaskHandleDetailRoutine();
|
xpTaskHandleDetailRoutine.setTaskId(task.getId());
|
String taskTypeId = task.getTaskTypeId();
|
switch (taskTypeId) {
|
case "6":
|
xpTaskHandleDetailRoutine.setTaskType(1);
|
break;
|
case "7":
|
xpTaskHandleDetailRoutine.setTaskType(2);
|
|
break;
|
case "8":
|
xpTaskHandleDetailRoutine.setTaskType(3);
|
|
break;
|
case "9":
|
xpTaskHandleDetailRoutine.setTaskType(4);
|
break;
|
}
|
xpTaskHandleDetailRoutine.setTaskDescription(dto.getTaskDescription());
|
xpTaskHandleDetailRoutine.setTaskImage(dto.getTaskImage());
|
xpTaskHandleDetailRoutine.setOperationsUserId(id);
|
xpTaskHandleDetailRoutineMapper.insert(xpTaskHandleDetailRoutine);
|
//更新任务状态为已完成
|
lambdaUpdate().set(XpTask::getStatus, 2).set(XpTask::getHandleUserId, id)
|
.set(XpTask::getHandleTime, LocalDateTime.now())
|
.eq(XpTask::getId, dto.getId())
|
.update();
|
return R.ok();
|
}
|
|
@Override
|
public R<TaskCleanDetailVO> cleanDetail(Long id) throws UnsupportedEncodingException {
|
TaskCleanDetailVO res = new TaskCleanDetailVO();
|
XpTask task = this.getById(id);
|
if (task == null) {
|
throw new ServiceException(
|
"任务不存在",
|
I18nKeyConstant.TASK_NOT_EXIST
|
);
|
}
|
XpVehicle vehicle = xpVehicleClient.queryById(task.getVehicleId()).getData();
|
if (vehicle == null) {
|
throw new ServiceException(
|
"车辆不存在",
|
I18nKeyConstant.VEHICLE_NOT_EXIST
|
);
|
}
|
res.setVehicleId(task.getVehicleId());
|
res.setId(id);
|
res.setTaskUrgencyLevel(task.getTaskUrgencyLevel());
|
res.setPlateNumber(vehicle.getPlateNumber());
|
res.setVehicleColor(vehicle.getVehicleColor());
|
res.setVehicleCode(vehicle.getVehicleCode());
|
res.setVehicleLocation(task.getVehicleLocation());
|
res.setCreateBy(task.getCreateBy());
|
res.setCreateTime(task.getCreateTime());
|
res.setTaskCode(task.getTaskCode());
|
res.setTaskCategory(task.getTaskCategory());
|
res.setTaskTypeId(task.getTaskTypeId());
|
res.setStatus(task.getStatus());
|
XpVehicleClean vehicleDetection = vehicleCleanMapper.selectOne(new LambdaQueryWrapper<XpVehicleClean>()
|
.eq(XpVehicleClean::getTaskId, id).last("limit 1"));
|
if (vehicleDetection != null) {
|
res.setHandleTime(vehicleDetection.getCreateTime());
|
|
|
res.setTaskImage(vehicleDetection.getTaskImage());
|
res.setTaskImage(aliOssDownloadUtil.getPictureJsonArray(vehicleDetection.getTaskImage()));
|
res.setOperationUserId(vehicleDetection.getOperationsUserId());
|
if (vehicleDetection.getOperationsUserId() != null) {
|
XpOperationsUser operationsUser = xpOperationUserClient.queryById(vehicleDetection.getOperationsUserId()).getData();
|
if (operationsUser != null) {
|
res.setOperationsUserName(operationsUser.getNickName());
|
res.setHandleUserName(operationsUser.getNickName());
|
}
|
}
|
}
|
return R.ok(res);
|
}
|
|
@Override
|
@Transactional
|
@ShardingSphereTransactionType(TransactionType.BASE)
|
public R confirmArrive(Long id, Long userId) {
|
RLock lock = redissonClient.getLock("TASK_CONFIRM_" + id);
|
|
try {
|
// 尝试获取锁，最多等待3秒
|
boolean isLocked = lock.tryLock(3, 10, TimeUnit.SECONDS);
|
if (!isLocked) {
|
return R.fail("系统繁忙，请稍后重试");
|
}
|
|
// 查询任务
|
XpTask task = this.getById(id);
|
if (task == null) {
|
return R.fail("任务不存在");
|
}
|
|
// 检查任务状态
|
if (task.getStatus() != 0) {
|
return R.fail("任务已被处理");
|
}
|
|
Long vehicleId = task.getVehicleId();
|
String plateNumber = "";
|
try {
|
if (vehicleId != null) {
|
R<XpVehicle> vehicleResult = xpVehicleClient.queryById(vehicleId);
|
XpVehicle vehicle = vehicleResult == null ? null : vehicleResult.getData();
|
if (vehicle != null && StringUtils.isNotBlank(vehicle.getPlateNumber())) {
|
plateNumber = vehicle.getPlateNumber();
|
}
|
}
|
} catch (Exception e) {
|
log.error("confirmArrive查询车辆信息失败，taskId={}, vehicleId={}", id, vehicleId, e);
|
}
|
String taskCode = StringUtils.isNotBlank(task.getTaskCode())
|
? task.getTaskCode()
|
: String.valueOf(task.getId());
|
|
// 更新任务
|
task.setStatus(1);
|
task.setVehicleId(null);
|
task.setHandleUserId(userId.toString());
|
|
this.updateById(task);
|
|
// 保存通知记录 + 推送阿里云 NOTICE 消息（不影响主流程）
|
try {
|
String content = String.format("你处理的%s关联车辆：%s状态由待到达变更为待处理", taskCode, plateNumber);
|
String bodyJson = buildTaskStatusChangedPushBodyJson(content, id);
|
|
XpOperationsUserNotification notification = new XpOperationsUserNotification();
|
notification.setNotificationType(NotificationTypeEnum.ACCIDENT_STATUS_CHANGED.getCode());
|
notification.setNotificationContent(content);
|
notification.setOperationsUserId(userId);
|
notification.setDataId(id);
|
notification.setReadStatus(0);
|
notification.setNotificationExt(bodyJson);
|
xpOperationUserNotificationClient.addNotificationBatch(Collections.singletonList(notification));
|
|
XpOperationsUser operationsUser = xpOperationUserClient.queryById(userId).getData();
|
if (operationsUser != null
|
&& operationsUser.getDeviceType() != null
|
&& StringUtils.isNotBlank(operationsUser.getPhoneNumber())) {
|
xpAliPushMessageClient.pushMessage(AliPushMessageDTO.builder()
|
.deviceType(operationsUser.getDeviceType())
|
.account(operationsUser.getPhoneNumber())
|
.title("任务状态变更")
|
.body(bodyJson)
|
.pushType(AliPushTypeConstant.MESSAGE)
|
.build());
|
}
|
} catch (Exception e) {
|
log.error("confirmArrive消息通知失败，taskId={}, userId={}", id, userId, e);
|
}
|
return R.ok();
|
|
} catch (InterruptedException e) {
|
Thread.currentThread().interrupt();
|
return R.fail("操作被中断");
|
} finally {
|
// 确保锁被释放
|
if (lock.isHeldByCurrentThread()) {
|
lock.unlock();
|
}
|
}
|
}
|
|
/**
|
* 构建任务状态变更推送 body JSON
|
*/
|
private String buildTaskStatusChangedPushBodyJson(String content, Long taskId) {
|
Map<String, Object> param = new HashMap<>();
|
param.put("content", content);
|
param.put("strategy", NotificationTypeEnum.ACCIDENT_STATUS_CHANGED.getCode());
|
param.put("type", TaskTypeNotificationEnum.ACCIDENT_TASK.getCode());
|
param.put("id", taskId == null ? "0" : taskId.toString());
|
return JSONObject.toJSONString(param);
|
}
|
|
@Override
|
public PageInfo<XpTaskRecordVO> queryTaskByVehicleId(XpTaskRecordPageQuery query) {
|
// 1. 构建查询条件
|
LambdaQueryWrapper<XpTask> wrapper = new LambdaQueryWrapper<>();
|
wrapper.eq(XpTask::getVehicleId, query.getVehicleId());
|
|
if (query.getTaskCategory() != null) {
|
wrapper.eq(XpTask::getTaskCategory, query.getTaskCategory());
|
}
|
|
if (Objects.nonNull(query.getTaskGeneralId())) {
|
wrapper.eq(XpTask::getTaskTypeId, query.getTaskGeneralId()).eq(XpTask::getTaskCategory, 1);
|
}
|
|
if (Objects.nonNull(query.getTaskErrorId())) {
|
wrapper.apply("find_in_set({0}, task_type_id)", query.getTaskErrorId())
|
.eq(XpTask::getTaskCategory, 2);
|
}
|
if (query.getStartTime() != null) {
|
wrapper.ge(XpTask::getCreateTime, query.getStartTime().atStartOfDay());
|
}
|
|
if (query.getEndTime() != null) {
|
wrapper.le(XpTask::getCreateTime, query.getEndTime().atTime(23, 59, 59));
|
}
|
|
wrapper.orderByDesc(XpTask::getCreateTime);
|
|
// 2. 执行分页查询
|
Page<XpTask> page = new Page<>(query.getPageNum(), query.getPageSize());
|
Page<XpTask> resultPage = this.page(page, wrapper);
|
|
// 3. 转换为 VO 并填充 typeName
|
List<XpTaskRecordVO> records = new ArrayList<>();
|
|
if (!CollectionUtils.isEmpty(resultPage.getRecords())) {
|
// 3.1 收集所有事故任务的 errorType ID
|
Set<Long> errorTypeIds = new HashSet<>();
|
for (XpTask task : resultPage.getRecords()) {
|
if (task.getTaskCategory() != null && task.getTaskCategory() == 2
|
&& StringUtils.isNotBlank(task.getTaskTypeId())) {
|
String[] ids = task.getTaskTypeId().split(",");
|
for (String id : ids) {
|
try {
|
errorTypeIds.add(Long.parseLong(id.trim()));
|
} catch (NumberFormatException e) {
|
// 忽略格式错误的ID
|
}
|
}
|
}
|
}
|
|
// 3.2 批量查询 errorType
|
Map<Long, String> errorTypeMap = new HashMap<>();
|
if (!errorTypeIds.isEmpty()) {
|
List<XpErrorType> errorTypes = errorTypeMapper.selectBatchIds(errorTypeIds);
|
for (XpErrorType errorType : errorTypes) {
|
errorTypeMap.put(errorType.getId(), errorType.getErrorName());
|
}
|
}
|
|
// 3.3 填充 typeName
|
for (XpTask task : resultPage.getRecords()) {
|
XpTaskRecordVO vo = new XpTaskRecordVO();
|
BeanUtils.copyProperties(task, vo);
|
|
// 填充 typeName
|
if (task.getTaskCategory() != null && task.getTaskCategory() == 1) {
|
// 常规任务: 使用枚举映射
|
vo.setTypeName(TaskTypeEnum.getEnumDescByCode(Integer.valueOf(task.getTaskTypeId())));
|
} else if (task.getTaskCategory() != null && task.getTaskCategory() == 2) {
|
// 事故任务: 拼接父子级名称
|
if (StringUtils.isNotBlank(task.getTaskTypeId())) {
|
String[] ids = task.getTaskTypeId().split(",");
|
if (ids.length >= 2) {
|
try {
|
String parentName = errorTypeMap.get(Long.parseLong(ids[0].trim()));
|
String childName = errorTypeMap.get(Long.parseLong(ids[1].trim()));
|
if (parentName != null && childName != null) {
|
vo.setTypeName(parentName + "->" + childName);
|
}
|
} catch (NumberFormatException e) {
|
// 忽略格式错误的ID
|
}
|
}
|
}
|
}
|
|
records.add(vo);
|
}
|
}
|
|
// 4. 构建分页结果
|
PageInfo<XpTaskRecordVO> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
|
|
for (XpTaskRecordVO record : records) {
|
String taskImage = record.getTaskImage();
|
record.setTaskImage(aliOssDownloadUtil.getPictureJsonArray(record.getTaskCode()));
|
}
|
|
|
pageInfo.setRecords(records);
|
pageInfo.setTotal(resultPage.getTotal());
|
return pageInfo;
|
}
|
|
@Override
|
public void deleteTaskById(Long id) {
|
removeById(id);
|
}
|
|
@Override
|
public void updateTaskStatus(Long taskId, Integer status, Long operationUserId) {
|
if (Objects.nonNull(taskId)) {
|
XpTask task = this.getById(taskId);
|
if (Objects.nonNull(task)) {
|
this.lambdaUpdate().set(XpTask::getStatus, status).eq(XpTask::getId, taskId)
|
.set(XpTask::getHandleUserId, operationUserId)
|
.set(XpTask::getHandleTime, LocalDateTime.now())
|
.update();
|
}
|
}
|
}
|
|
@Override
|
public PageInfo<TaskManagementPageListVO> pageListManagement(TaskManagementPageListQuery query) {
|
PageInfo<TaskManagementPageListVO> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
|
List<TaskManagementPageListVO> list = this.baseMapper.pageListManagement(pageInfo, query);
|
for (TaskManagementPageListVO taskManagementPageListVO : list) {
|
if (org.springframework.util.StringUtils.hasLength(taskManagementPageListVO.getHandleUserId())) {
|
String[] split = taskManagementPageListVO.getHandleUserId().split(",");
|
List<XpOperationsUser> users = operationUserClient.listByIds(Arrays.stream(split).map(Long::parseLong).collect(Collectors.toList())).getData();
|
if (users != null) {
|
StringBuilder handleUserName = new StringBuilder();
|
for (XpOperationsUser user : users) {
|
handleUserName.append(user.getNickName()).append(";");
|
}
|
taskManagementPageListVO.setHandleUserName(handleUserName.toString());
|
}
|
}
|
taskManagementPageListVO.setTaskTypeName(resolveManagementTaskTypeName(taskManagementPageListVO));
|
}
|
pageInfo.setRecords(list);
|
return pageInfo;
|
}
|
|
@Override
|
public List<TaskManagementPageListVO> exportList(TaskManagementPageListQuery query) {
|
List<TaskManagementPageListVO> list = this.baseMapper.exportList(query);
|
for (TaskManagementPageListVO taskManagementPageListVO : list) {
|
if (org.springframework.util.StringUtils.hasLength(taskManagementPageListVO.getHandleUserId())) {
|
String[] split = taskManagementPageListVO.getHandleUserId().split(",");
|
List<XpOperationsUser> users = operationUserClient.listByIds(Arrays.stream(split).map(Long::parseLong).collect(Collectors.toList())).getData();
|
if (users != null) {
|
StringBuilder handleUserName = new StringBuilder();
|
for (XpOperationsUser user : users) {
|
handleUserName.append(user.getNickName()).append(";");
|
}
|
taskManagementPageListVO.setHandleUserName(handleUserName.toString());
|
}
|
}
|
taskManagementPageListVO.setTaskTypeName(resolveManagementTaskTypeName(taskManagementPageListVO));
|
}
|
return list;
|
}
|
|
private String resolveManagementTaskTypeName(TaskManagementPageListVO taskManagementPageListVO) {
|
if (Integer.valueOf(1).equals(taskManagementPageListVO.getTaskCategory())) {
|
return resolveRoutineTaskTypeName(taskManagementPageListVO.getTaskTypeId());
|
}
|
if (Integer.valueOf(2).equals(taskManagementPageListVO.getTaskCategory())) {
|
return resolveAccidentTaskTypeName(taskManagementPageListVO.getTaskTypeId());
|
}
|
return "";
|
}
|
|
private String resolveRoutineTaskTypeName(String taskTypeId) {
|
if (StringUtils.isBlank(taskTypeId)) {
|
return "";
|
}
|
switch (taskTypeId) {
|
case "1":
|
return "车辆检查";
|
case "2":
|
return "车辆充电";
|
case "3":
|
return "车辆整备";
|
case "4":
|
return "整备洗车";
|
case "5":
|
return "车辆维修";
|
case "6":
|
return "车辆保养";
|
case "7":
|
return "车辆保险到期";
|
case "8":
|
return "车辆年检到期";
|
case "9":
|
return "车辆运营资质到期";
|
default:
|
return "";
|
}
|
}
|
|
private String resolveAccidentTaskTypeName(String taskTypeId) {
|
List<Long> orderedTypeIds = parseAccidentTaskTypeIds(taskTypeId);
|
if (orderedTypeIds.isEmpty()) {
|
return "";
|
}
|
|
Map<Long, XpErrorType> errorTypeMap = getAccidentErrorTypeMap(orderedTypeIds);
|
if (errorTypeMap.isEmpty()) {
|
return "";
|
}
|
|
LinkedHashSet<Long> orderedParentIds = new LinkedHashSet<>();
|
LinkedHashMap<Long, List<XpErrorType>> childrenByParent = new LinkedHashMap<>();
|
for (Long typeId : orderedTypeIds) {
|
XpErrorType errorType = errorTypeMap.get(typeId);
|
if (errorType == null || StringUtils.isBlank(errorType.getErrorName())) {
|
continue;
|
}
|
|
if (isTopLevelErrorType(errorType)) {
|
orderedParentIds.add(errorType.getId());
|
continue;
|
}
|
|
Long parentId = errorType.getParentId();
|
if (parentId == null) {
|
continue;
|
}
|
orderedParentIds.add(parentId);
|
childrenByParent.computeIfAbsent(parentId, key -> new ArrayList<>()).add(errorType);
|
}
|
|
List<String> displayNames = new ArrayList<>();
|
for (Long parentId : orderedParentIds) {
|
XpErrorType parent = errorTypeMap.get(parentId);
|
List<XpErrorType> children = childrenByParent.get(parentId);
|
if (CollectionUtils.isEmpty(children)) {
|
if (parent != null && StringUtils.isNotBlank(parent.getErrorName())) {
|
displayNames.add(parent.getErrorName());
|
}
|
continue;
|
}
|
|
String parentName = parent == null ? null : parent.getErrorName();
|
for (XpErrorType child : children) {
|
if (StringUtils.isBlank(parentName)) {
|
displayNames.add(child.getErrorName());
|
} else {
|
displayNames.add(parentName + ">" + child.getErrorName());
|
}
|
}
|
}
|
return String.join(";", displayNames);
|
}
|
|
private Map<Long, XpErrorType> getAccidentErrorTypeMap(List<Long> orderedTypeIds) {
|
Map<Long, XpErrorType> errorTypeMap = getErrorTypeMap(orderedTypeIds);
|
if (errorTypeMap.isEmpty()) {
|
return errorTypeMap;
|
}
|
|
Set<Long> missingParentIds = new LinkedHashSet<>();
|
for (Long typeId : orderedTypeIds) {
|
XpErrorType errorType = errorTypeMap.get(typeId);
|
if (errorType == null || isTopLevelErrorType(errorType)) {
|
continue;
|
}
|
if (errorType.getParentId() != null && !errorTypeMap.containsKey(errorType.getParentId())) {
|
missingParentIds.add(errorType.getParentId());
|
}
|
}
|
if (!missingParentIds.isEmpty()) {
|
errorTypeMap.putAll(getErrorTypeMap(missingParentIds));
|
}
|
return errorTypeMap;
|
}
|
|
private boolean isTopLevelErrorType(XpErrorType errorType) {
|
return errorType.getParentId() == null || errorType.getParentId() == 0L;
|
}
|
|
private String normalizeAccidentTaskTypeId(String taskTypeId) {
|
List<Long> orderedTypeIds = parseAccidentTaskTypeIds(taskTypeId);
|
if (orderedTypeIds.isEmpty()) {
|
return taskTypeId;
|
}
|
|
LinkedHashSet<Long> normalizedTypeIds = new LinkedHashSet<>(orderedTypeIds);
|
Map<Long, XpErrorType> errorTypeMap = getErrorTypeMap(orderedTypeIds);
|
for (Long typeId : orderedTypeIds) {
|
XpErrorType errorType = errorTypeMap.get(typeId);
|
if (errorType == null || errorType.getParentId() == null || errorType.getParentId() == 0L) {
|
continue;
|
}
|
normalizedTypeIds.add(errorType.getParentId());
|
}
|
return normalizedTypeIds.stream().map(String::valueOf).collect(Collectors.joining(","));
|
}
|
|
private List<Long> parseAccidentTaskTypeIds(String taskTypeId) {
|
if (StringUtils.isBlank(taskTypeId)) {
|
return Collections.emptyList();
|
}
|
|
LinkedHashSet<Long> typeIds = new LinkedHashSet<>();
|
for (String typeId : taskTypeId.split(",")) {
|
if (StringUtils.isBlank(typeId)) {
|
continue;
|
}
|
try {
|
typeIds.add(Long.parseLong(typeId.trim()));
|
} catch (NumberFormatException ignored) {
|
}
|
}
|
return new ArrayList<>(typeIds);
|
}
|
|
private Map<Long, XpErrorType> getErrorTypeMap(Collection<Long> typeIds) {
|
if (CollectionUtils.isEmpty(typeIds)) {
|
return Collections.emptyMap();
|
}
|
|
return errorTypeMapper.selectBatchIds(typeIds).stream()
|
.filter(Objects::nonNull)
|
.collect(Collectors.toMap(XpErrorType::getId, errorType -> errorType, (left, right) -> left));
|
}
|
|
@Override
|
public XpTask queryInfoByVehicleId(Long vehicleId) {
|
return this.baseMapper.queryInfoByVehicleId(vehicleId);
|
}
|
|
|
@Autowired
|
private XpOperationsUserRepository repository;
|
|
@Override
|
@Transactional
|
public void reassign(Long taskId, String msg) {
|
|
XpTask task = getById(taskId);
|
XpVehicle vehicle = xpVehicleClient.queryById(task.getVehicleId()).getData();
|
XpTaskRule taskRule = xpTaskRuleService.lambdaQuery().last("limit 1").one();
|
|
int type = 9;
|
if(task.getTaskCategory() != 2) {
|
type = Integer.parseInt(task.getTaskTypeId());
|
}
|
|
List<XpTaskRuleRole> taskRuleRole = xpTaskRuleRoleService.lambdaQuery().eq(XpTaskRuleRole::getRuleType, type).list();
|
|
if (Objects.isNull(taskRuleRole) || Objects.isNull(taskRule)) {
|
throw new ServiceException("未配置车辆事故任务分配规则");
|
}
|
|
List<XpTask.Reject> rejects = Optional.ofNullable(task.getExcluded()).orElse(new ArrayList<>());
|
if(msg != null && Strings.isNotBlank(task.getHandleUserId())) {
|
XpTask.Reject reject = task.reject(msg);
|
rejects.add(reject);
|
List<Long> id = Collections.singletonList(Long.parseLong(task.getHandleUserId()));
|
String roleName = xpOperationUserClient.listByIdsWithRole(id).getData().get(0).getRoleName();
|
reject.setRejectUserRoleName(roleName);
|
}
|
task.setExcluded(rejects);
|
task.setReassignmentStatus(1);
|
task.setStatus(4);
|
Set<String> excludedUserIds = rejects.stream().map(XpTask.Reject::getRejectUserId).collect(Collectors.toSet());
|
|
Long fleetId = xpFleetVehicleClient.getFleetIdByVehicleId(vehicle.getId()).getData();
|
List<Long> roleIds = taskRuleRole.stream().map(XpTaskRuleRole::getRoleId).collect(Collectors.toList());
|
List<Long> ids = xpFleetOperationsClient.getOperationsIdsByFleetId(fleetId).getData();
|
String belongUserIds = xpOperationUserClient.getXpOperationsRoleByRoleIds(roleIds).getData().stream()
|
.map(XpOperationsRole::getOperationsUserId)
|
.filter(e -> ids == null || ids.isEmpty() || ids.contains(e))
|
.filter(id -> !excludedUserIds.contains(id.toString()))
|
.map(String::valueOf).collect(Collectors.joining(","));
|
|
|
VehiclePosition vehiclePosition = mongoTemplate.findOne(new Query(Criteria.where("vin").is(vehicle.getVehicleVin())), VehiclePosition.class);
|
// VehiclePosition vehiclePosition = new VehiclePosition();
|
// vehiclePosition.setPoint(new GeoJsonPoint(103.12615621, 30.264561));
|
String handlerUser = chooseNearestAvailableOperationsUser(belongUserIds, vehiclePosition);
|
task.setHandleUserId(handlerUser);
|
if(handlerUser == null) {
|
task.setStatus(4);
|
task.setReassignmentStatus(1);
|
noticeAdministrator(task);//TODO 需要通知管理员手动处理，考虑再AliPushUtil 中给管理员发送消息
|
}
|
updateById(task);
|
if(StringUtils.isNotBlank(task.getHandleUserId())){
|
sendAccidentNotificationAsync(task, vehicle.getPlateNumber(), taskRule.getProcessingTimeLimit());
|
}
|
}
|
|
|
@Override
|
public void saveVehicleAccidentError(Long vehicleId) {
|
XpVehicle vehicle = xpVehicleClient.queryById(vehicleId).getData();
|
XpTaskRule taskRule = xpTaskRuleService.lambdaQuery().last("limit 1").one();
|
List<XpTaskRuleRole> taskRuleRole = xpTaskRuleRoleService.lambdaQuery().eq(XpTaskRuleRole::getRuleType, 9).list();
|
if (Objects.isNull(taskRuleRole) || Objects.isNull(taskRule)) {
|
throw new ServiceException("未配置车辆事故任务分配规则");
|
}
|
Long fleetId = xpFleetVehicleClient.getFleetIdByVehicleId(vehicle.getId()).getData();
|
List<Long> roleIds = taskRuleRole.stream().map(XpTaskRuleRole::getRoleId).collect(Collectors.toList());
|
List<Long> ids = xpFleetOperationsClient.getOperationsIdsByFleetId(fleetId).getData();
|
String belongUserIds = xpOperationUserClient.getXpOperationsRoleByRoleIds(roleIds).getData().stream()
|
.map(XpOperationsRole::getOperationsUserId)
|
.filter(ids::contains)
|
.map(String::valueOf).collect(Collectors.joining(","));
|
|
VehiclePosition vehiclePosition = mongoTemplate.findOne(new Query(Criteria.where("vin").is(vehicle.getVehicleVin())), VehiclePosition.class);
|
Map<String, String> geocode = gdMapGeocodingUtil.geocode(vehiclePosition.getPoint().getX() + "", vehiclePosition.getPoint().getY() + "");
|
String address = geocode.get("address");
|
|
XpTask task = new XpTask();
|
String taskCode = new SimpleDateFormat("yyyyMMddHHmmssSSS").format(new Date()) + UUIDUtil.getNumberRandom(5);
|
task.setTaskCode(taskCode);
|
task.setTaskCategory(TaskScheduleConstants.TASK_CATEGORY_ACCIDENT);
|
task.setTaskTypeId("8,10");
|
task.setTaskUrgencyLevel(TaskScheduleConstants.URGENCY_LEVEL_P0);
|
String taskDescription = "车辆" + vehicle.getPlateNumber() + "在" + address + "发生紧急事故，请在" + taskRule.getProcessingTimeLimit() + "内到达现场！";
|
task.setTaskDescription(taskDescription);
|
task.setVehicleId(vehicle.getId());
|
task.setVehicleLocation(address);
|
task.setVehicleLat(new BigDecimal(vehiclePosition.getPoint().getY()));
|
task.setVehicleLon(new BigDecimal(vehiclePosition.getPoint().getX()));
|
String handlerUser = chooseNearestAvailableOperationsUser(belongUserIds, vehiclePosition);
|
task.setHandleUserId(handlerUser);
|
if(handlerUser == null) {
|
task.setStatus(4);
|
task.setReassignmentStatus(1);
|
noticeAdministrator(task);
|
}
|
task.setAssigneeTime(LocalDateTime.now());
|
task.setReportUserId(0L);
|
task.setReportTime(LocalDateTime.now());
|
task.setEndTime(LocalDateTime.now().plusMinutes(taskRule.getProcessingTimeLimit()));
|
task.setExpiredNoticeSent(0);
|
task.setWillTimeoutNoticeSent(0);
|
task.setStatus(TaskScheduleConstants.TASK_STATUS_PENDING_ARRIVE);
|
task.setCreateBy("系统自动生成");
|
task.setCreateTime(LocalDateTime.now());
|
this.save(task);
|
// 异步发送消息通知
|
sendAccidentNotificationAsync(task, vehicle.getPlateNumber(), taskRule.getProcessingTimeLimit());
|
}
|
|
@Override
|
@Transactional
|
public void accept(String taskId) {
|
|
XpTask task = getById(Long.valueOf(taskId));
|
XpVehicle vehicle = xpVehicleClient.queryById(task.getVehicleId()).getData();
|
updateTaskStatus(task.getId(), TaskScheduleConstants.TASK_STATUS_PENDING_ARRIVE, Long.valueOf(task.getHandleUserId()));
|
sendAccidentNotificationAsync(getById(task.getId()), vehicle.getPlateNumber(), (int) Duration.between(LocalDateTime.now(),task.getEndTime()).toMinutes());
|
}
|
|
@Override
|
public PageInfo<XpTaskVO> reassignTaskPageList(TaskPageListQuery query) {
|
|
PageInfo<XpTaskVO> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
|
List<XpTaskVO> list = baseMapper.reassignTaskPageList(pageInfo, query);
|
pageInfo.setRecords(list);
|
return pageInfo;
|
}
|
|
@Override
|
public XpTaskVO detail(Long taskId) {
|
XpTask task = getById(taskId);
|
if (task == null) {
|
return null;
|
}
|
XpTaskVO xpTaskVO = new XpTaskVO();
|
BeanUtil.copyProperties(task, xpTaskVO);
|
|
String taskImage = xpTaskVO.getTaskImage();
|
if (StringUtils.isNotBlank(taskImage)) {
|
try {
|
xpTaskVO.setTaskImage(aliOssDownloadUtil.getPictureJsonArray(taskImage));
|
} catch (Exception e) {
|
log.error("获取任务图片下载地址失败，taskId={}", taskId, e);
|
}
|
}
|
|
// 2. 如果有车辆信息，可以补充车辆相关详情（如果需要）
|
if (task.getVehicleId() != null) {
|
R<XpVehicle> vehicleResult = xpVehicleClient.queryById(task.getVehicleId());
|
if (vehicleResult != null && vehicleResult.getData() != null) {
|
XpVehicle vehicle = vehicleResult.getData();
|
xpTaskVO.setPlateNumber(vehicle.getPlateNumber());
|
// xpTaskVO.setVehicleColor(vehicle.getVehicleColor());
|
// xpTaskVO.setVehicleCode(vehicle.getVehicleCode());
|
// xpTaskVO.setVehicleVin(vehicle.getVehicleVin());
|
|
}
|
}
|
|
return xpTaskVO;
|
}
|
|
@Override
|
public List<XpTaskVO> exportList(TaskPageListQuery query) {
|
|
return baseMapper.reassignTaskPageList(query);
|
|
}
|
|
@Value("${robotaxi.sms.app-id:1476153389173952512}")
|
private String smsAppId;
|
@Value("${robotaxi.sms.app-push-config-code:ROBOTAXI_VERIFY_CODE_SMS}")
|
private String ROBOTAXI_VERIFY_CODE_SMS_TPL;
|
@Resource
|
private SmsClient smsClient;
|
|
private void noticeAdministrator(XpTask task) {
|
|
SmsVo smsVo = new SmsVo();
|
smsVo.setAppId(smsAppId);
|
smsVo.setParams(Collections.EMPTY_MAP);
|
smsVo.setTemplateCode(ROBOTAXI_VERIFY_CODE_SMS_TPL);
|
|
String adminPhone = "139..";
|
|
smsVo.setReceivers(adminPhone);
|
smsClient.pushSms(smsVo);
|
|
}
|
|
private String chooseNearestAvailableOperationsUser(String belongUserIds, VehiclePosition vehiclePosition) {
|
|
if (StringUtils.isBlank(belongUserIds)) return null;
|
List<Long> ids = Arrays.stream(belongUserIds.split(",")).filter(StringUtils::isNotBlank).map(Long::valueOf).collect(Collectors.toList());
|
|
// 让mongo根据[id in ids]返回距离排序的users
|
// List<XpOperationsUserPositionDTO> users = mongoTemplate.find(new Query(Criteria.where("_id").in(ids)), XpOperationsUserPositionDTO.class);
|
|
List<XpOperationsUserPositionDTO> XpOperationsUserPositionDTOs = mongoTemplate.find(
|
new Query(Criteria.where("_id").in(ids).and("location").nearSphere(new GeoJsonPoint(vehiclePosition.getPoint().getX(), vehiclePosition.getPoint().getY())).maxDistance(1000 / 6378137.0)),
|
XpOperationsUserPositionDTO.class
|
);
|
|
boolean skipBusy = false;//TODO 获取系统配置，是否开启跳过忙碌
|
|
List<XpOperationsUserPositionDTO> candidates = XpOperationsUserPositionDTOs.stream()
|
// .filter(positionDTO -> skipBusy && positionDTO.getStatus() == 1)
|
.sorted(Comparator.comparing(XpOperationsUserPositionDTO::getDistance))
|
.collect(Collectors.toList());
|
|
if (candidates.isEmpty()) return null;
|
|
return String.valueOf(candidates.get(0).getId());
|
}
|
|
|
|
@Override
|
public R assigneeTask(Long id, Long handlerUserId, Long assigneeUserId) {
|
XpTask task = this.getById(id);
|
if (task == null) {
|
throw new ServiceException(
|
"任务不存在",
|
I18nKeyConstant.TASK_NOT_EXIST
|
);
|
}
|
|
boolean isAccidentTask = Integer.valueOf(2).equals(task.getTaskCategory());
|
Long vehicleId = task.getVehicleId();
|
Integer processingTimeLimit = null;
|
String plateNumber = "";
|
if (isAccidentTask) {
|
// 查询规则 任务结束时间从任务分配时开始计算
|
XpTaskRule taskRule = xpTaskRuleMapper.selectOne(null);
|
if (taskRule != null) {
|
processingTimeLimit = taskRule.getProcessingTimeLimit();
|
task.setEndTime(LocalDateTime.now().plusMinutes(taskRule.getProcessingTimeLimit()));
|
}
|
if (vehicleId != null) {
|
XpVehicle vehicle = xpVehicleClient.queryById(vehicleId).getData();
|
if (vehicle != null && StringUtils.isNotBlank(vehicle.getPlateNumber())) {
|
plateNumber = vehicle.getPlateNumber();
|
}
|
}
|
} else {
|
task.setEndTime(LocalDateTime.now().plusDays(3));
|
}
|
task.setReassignmentStatus(2);
|
task.setStatus(1);
|
task.setAssigneeTime(LocalDateTime.now());
|
task.setHandleUserId(handlerUserId.toString());
|
task.setVehicleId(null);
|
task.setAssigneeUserId(assigneeUserId);
|
this.updateById(task);
|
if (isAccidentTask && processingTimeLimit != null) {
|
sendAssignedAccidentNotificationAsync(task, handlerUserId, plateNumber, processingTimeLimit);
|
}
|
return R.ok();
|
}
|
|
@Override
|
@Transactional
|
public void saveTask(SaveErrorTaskDto dto, Long reportUserId) {
|
|
List<XpTask> saveTask = new ArrayList<>();
|
String normalizedTaskTypeId = normalizeAccidentTaskTypeId(dto.getTaskTypeId());
|
for (Long vehicleId : dto.getVehicleIds()) {
|
XpTask task = new XpTask();
|
BeanUtils.copyProperties(dto, task);
|
task.setReportTime(LocalDateTime.now());
|
task.setStatus(0);
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
|
String code = sdf.format(new Date()) + UUIDUtil.getNumberRandom(5);
|
task.setTaskCode(code);
|
task.setTaskCategory(2);
|
task.setTaskTypeId(normalizedTaskTypeId);
|
task.setTaskUrgencyLevel(dto.getTaskUrgencyLevel());
|
task.setTaskDescription(dto.getTaskDescription());
|
task.setTaskImage(dto.getTaskImage());
|
task.setVehicleId(vehicleId);
|
task.setVehicleLocation(dto.getVehicleLocation());
|
task.setVehicleLon(dto.getVehicleLon());
|
task.setVehicleLat(dto.getVehicleLat());
|
task.setReportUserId(reportUserId);
|
task.setReportTime(LocalDateTime.now());
|
task.setExpiredNoticeSent(0);
|
task.setWillTimeoutNoticeSent(0);
|
task.setTaskSource(2);
|
saveTask.add(task);
|
}
|
for (XpTask task : saveTask) {
|
|
reassign(task.getId(),null);
|
}
|
this.saveBatch(saveTask);
|
|
}
|
|
@Override
|
public R<TaskManagementDetailVO> taskDetail(Long id) throws UnsupportedEncodingException {
|
TaskManagementDetailVO managementDetailVO = new TaskManagementDetailVO();
|
XpTask task = this.getById(id);
|
if (task == null) {
|
throw new ServiceException(
|
"任务不存在",
|
I18nKeyConstant.TASK_NOT_EXIST
|
);
|
}
|
XpVehicle vehicle = xpVehicleClient.queryById(task.getVehicleId()).getData();
|
if (vehicle == null) {
|
throw new ServiceException(
|
"车辆不存在",
|
I18nKeyConstant.VEHICLE_NOT_EXIST
|
);
|
}
|
String vehiclePicture = aliOssDownloadUtil.getPictureJSONObject(vehicle.getVehiclePictures());
|
if (task.getTaskCategory() == 1) {
|
// 常规任务
|
|
switch (task.getTaskTypeId()) {
|
case "1":
|
// 检测
|
TaskManagementDetectionDetailVO taskManagementDetectionDetailVO = new TaskManagementDetectionDetailVO();
|
taskManagementDetectionDetailVO.setId(task.getId());
|
taskManagementDetectionDetailVO.setVehicleId(vehicle.getId());
|
taskManagementDetectionDetailVO.setTaskUrgencyLevel(task.getTaskUrgencyLevel());
|
taskManagementDetectionDetailVO.setPlateNumber(vehicle.getPlateNumber());
|
taskManagementDetectionDetailVO.setVehicleColor(vehicle.getVehicleColor());
|
taskManagementDetectionDetailVO.setVehicleCode(vehicle.getVehicleCode());
|
taskManagementDetectionDetailVO.setVehicleVin(vehicle.getVehicleVin());
|
taskManagementDetectionDetailVO.setVehicleLocation(task.getVehicleLocation());
|
taskManagementDetectionDetailVO.setVehiclePictures(vehiclePicture);
|
|
taskManagementDetectionDetailVO.setTaskCode(task.getTaskCode());
|
XpVehicleDetection vehicleDetection = vehicleDetectionMapper.selectOne(new LambdaQueryWrapper<XpVehicleDetection>()
|
.eq(XpVehicleDetection::getTaskId, id).last("limit 1"));
|
if (vehicleDetection != null) {
|
taskManagementDetectionDetailVO.setNetworkDetection(vehicleDetection.getNetworkDetection());
|
taskManagementDetectionDetailVO.setVersionVerification(vehicleDetection.getVersionVerification());
|
taskManagementDetectionDetailVO.setCommunicationSelfCheck(vehicleDetection.getCommunicationSelfCheck());
|
taskManagementDetectionDetailVO.setRemoteSelfCheck(vehicleDetection.getRemoteSelfCheck());
|
taskManagementDetectionDetailVO.setCollisionPrevention(vehicleDetection.getCollisionPrevention());
|
taskManagementDetectionDetailVO.setSensorSelfCheck(vehicleDetection.getSensorSelfCheck());
|
taskManagementDetectionDetailVO.setSensorCleaning(vehicleDetection.getSensorCleaning());
|
|
|
String SensorCleaningPicture = vehicleDetection.getSensorCleaningPicture();
|
if (StringUtils.isNotBlank(SensorCleaningPicture)) {
|
JSONArray jsonArray = JSONArray.parseArray(SensorCleaningPicture);
|
for (int i = 0; i < jsonArray.size(); i++) {
|
JSONObject jsonObject = jsonArray.getJSONObject(i);
|
if (Objects.isNull(jsonObject)) {
|
continue;
|
}
|
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);
|
}
|
taskManagementDetectionDetailVO.setSensorCleaningPicture(JSONArray.toJSONString(jsonArray));
|
}
|
|
|
taskManagementDetectionDetailVO.setInteractiveScreen(vehicleDetection.getInteractiveScreen());
|
|
|
String InteractiveScreenPicture = vehicleDetection.getInteractiveScreenPicture();
|
if (StringUtils.isNotBlank(InteractiveScreenPicture)) {
|
JSONArray jsonArray = JSONArray.parseArray(InteractiveScreenPicture);
|
for (int i = 0; i < jsonArray.size(); i++) {
|
JSONObject jsonObject = jsonArray.getJSONObject(i);
|
if (Objects.isNull(jsonObject)) {
|
continue;
|
}
|
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);
|
}
|
taskManagementDetectionDetailVO.setInteractiveScreenPicture(JSONArray.toJSONString(jsonArray));
|
}
|
|
taskManagementDetectionDetailVO.setHelpButton(vehicleDetection.getHelpButton());
|
|
|
String HelpButtonPicture = vehicleDetection.getHelpButtonPicture();
|
if (StringUtils.isNotBlank(HelpButtonPicture)) {
|
JSONArray jsonArray = JSONArray.parseArray(HelpButtonPicture);
|
for (int i = 0; i < jsonArray.size(); i++) {
|
JSONObject jsonObject = jsonArray.getJSONObject(i);
|
if (Objects.isNull(jsonObject)) {
|
continue;
|
}
|
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);
|
}
|
taskManagementDetectionDetailVO.setHelpButtonPicture(JSONArray.toJSONString(jsonArray));
|
}
|
|
taskManagementDetectionDetailVO.setPaymentFunction(vehicleDetection.getPaymentFunction());
|
|
|
String PaymentFunctionPicture = vehicleDetection.getPaymentFunctionPicture();
|
if (StringUtils.isNotBlank(PaymentFunctionPicture)) {
|
JSONArray jsonArray = JSONArray.parseArray(PaymentFunctionPicture);
|
for (int i = 0; i < jsonArray.size(); i++) {
|
JSONObject jsonObject = jsonArray.getJSONObject(i);
|
if (Objects.isNull(jsonObject)) {
|
continue;
|
}
|
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);
|
}
|
taskManagementDetectionDetailVO.setPaymentFunctionPicture(JSONArray.toJSONString(jsonArray));
|
}
|
|
|
taskManagementDetectionDetailVO.setSystemCheck(vehicleDetection.getSystemCheck());
|
|
|
String SystemCheckPicture = vehicleDetection.getSystemCheckPicture();
|
if (StringUtils.isNotBlank(SystemCheckPicture)) {
|
JSONArray jsonArray = JSONArray.parseArray(SystemCheckPicture);
|
for (int i = 0; i < jsonArray.size(); i++) {
|
JSONObject jsonObject = jsonArray.getJSONObject(i);
|
if (Objects.isNull(jsonObject)) {
|
continue;
|
}
|
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);
|
}
|
taskManagementDetectionDetailVO.setSystemCheckPicture(JSONArray.toJSONString(jsonArray));
|
}
|
|
taskManagementDetectionDetailVO.setCheckTime(vehicleDetection.getCheckTime());
|
taskManagementDetectionDetailVO.setOperationsUserId(vehicleDetection.getOperationsUserId());
|
if (vehicleDetection.getOperationsUserId() != null) {
|
XpOperationsUser operationsUser = xpOperationUserClient.queryById(vehicleDetection.getOperationsUserId()).getData();
|
if (operationsUser != null) {
|
taskManagementDetectionDetailVO.setOperationsUserName(operationsUser.getNickName());
|
}
|
}
|
}
|
managementDetailVO.setDetectionDetailVO(taskManagementDetectionDetailVO);
|
break;
|
case "2":
|
// 充电
|
TaskManagementChargingDetailVO taskManagementChargingDetailVO = new TaskManagementChargingDetailVO();
|
taskManagementChargingDetailVO.setId(task.getId());
|
taskManagementChargingDetailVO.setVehicleId(vehicle.getId());
|
taskManagementChargingDetailVO.setTaskUrgencyLevel(task.getTaskUrgencyLevel());
|
taskManagementChargingDetailVO.setPlateNumber(vehicle.getPlateNumber());
|
taskManagementChargingDetailVO.setVehicleColor(vehicle.getVehicleColor());
|
taskManagementChargingDetailVO.setVehicleCode(vehicle.getVehicleCode());
|
taskManagementChargingDetailVO.setVehicleVin(vehicle.getVehicleVin());
|
taskManagementChargingDetailVO.setVehicleLocation(task.getVehicleLocation());
|
taskManagementChargingDetailVO.setTaskCode(task.getTaskCode());
|
taskManagementChargingDetailVO.setVehiclePictures(vehiclePicture);
|
|
XpChargingRecord chargingRecord = chargingRecordMapper.selectOne(new LambdaQueryWrapper<XpChargingRecord>()
|
.eq(XpChargingRecord::getTaskId, id).last("limit 1"));
|
if (chargingRecord != null) {
|
taskManagementChargingDetailVO.setStartRemainingBattery(chargingRecord.getStartRemainingBattery());
|
taskManagementChargingDetailVO.setStartChargingPicture(chargingRecord.getStartChargingPicture());
|
taskManagementChargingDetailVO.setStartTime(chargingRecord.getStartTime());
|
taskManagementChargingDetailVO.setEndRemainingBattery(chargingRecord.getEndRemainingBattery());
|
taskManagementChargingDetailVO.setEndChargingPicture(chargingRecord.getEndChargingPicture());
|
taskManagementChargingDetailVO.setEndTime(chargingRecord.getEndTime());
|
taskManagementChargingDetailVO.setStartOperationsUserId(chargingRecord.getStartOperationsUserId());
|
taskManagementChargingDetailVO.setEndOperationsUserId(chargingRecord.getEndOperationsUserId());
|
if (chargingRecord.getStartOperationsUserId() != null) {
|
XpOperationsUser operationsUser = xpOperationUserClient.queryById(chargingRecord.getStartOperationsUserId()).getData();
|
if (operationsUser != null) {
|
taskManagementChargingDetailVO.setStartOperationsUserName(operationsUser.getNickName());
|
}
|
}
|
if (chargingRecord.getEndOperationsUserId() != null) {
|
XpOperationsUser operationsUser = xpOperationUserClient.queryById(chargingRecord.getEndOperationsUserId()).getData();
|
if (operationsUser != null) {
|
taskManagementChargingDetailVO.setEndOperationsUserName(operationsUser.getNickName());
|
}
|
}
|
}
|
managementDetailVO.setChargingDetailVO(taskManagementChargingDetailVO);
|
|
break;
|
case "3":
|
// 整备
|
TaskManagementPreparationDetailVO taskManagementPreparationDetailVO = new TaskManagementPreparationDetailVO();
|
taskManagementPreparationDetailVO.setId(task.getId());
|
taskManagementPreparationDetailVO.setVehicleId(vehicle.getId());
|
taskManagementPreparationDetailVO.setTaskUrgencyLevel(task.getTaskUrgencyLevel());
|
taskManagementPreparationDetailVO.setPlateNumber(vehicle.getPlateNumber());
|
taskManagementPreparationDetailVO.setVehicleColor(vehicle.getVehicleColor());
|
taskManagementPreparationDetailVO.setVehicleCode(vehicle.getVehicleCode());
|
taskManagementPreparationDetailVO.setVehicleVin(vehicle.getVehicleVin());
|
taskManagementPreparationDetailVO.setVehicleLocation(task.getVehicleLocation());
|
taskManagementPreparationDetailVO.setTaskCode(task.getTaskCode());
|
taskManagementPreparationDetailVO.setVehiclePictures(vehiclePicture);
|
|
XpVehiclePreparation vehiclePreparation = vehiclePreparationMapper.selectOne(new LambdaQueryWrapper<XpVehiclePreparation>()
|
.eq(XpVehiclePreparation::getTaskId, id).last("limit 1"));
|
if (vehiclePreparation != null) {
|
taskManagementPreparationDetailVO.setLeftFrontWheel(vehiclePreparation.getLeftFrontWheel());
|
taskManagementPreparationDetailVO.setRightFrontWheel(vehiclePreparation.getRightFrontWheel());
|
taskManagementPreparationDetailVO.setLeftRearWheel(vehiclePreparation.getLeftRearWheel());
|
taskManagementPreparationDetailVO.setRightRearWheel(vehiclePreparation.getRightRearWheel());
|
taskManagementPreparationDetailVO.setHeadLight(vehiclePreparation.getHeadLight());
|
taskManagementPreparationDetailVO.setTurnSignal(vehiclePreparation.getTurnSignal());
|
taskManagementPreparationDetailVO.setBrakeLight(vehiclePreparation.getBrakeLight());
|
taskManagementPreparationDetailVO.setFogLight(vehiclePreparation.getFogLight());
|
taskManagementPreparationDetailVO.setBodyEmblem(vehiclePreparation.getBodyEmblem());
|
taskManagementPreparationDetailVO.setCabinCleaning(vehiclePreparation.getCabinCleaning());
|
taskManagementPreparationDetailVO.setLostItems(vehiclePreparation.getLostItems());
|
taskManagementPreparationDetailVO.setRemarks(vehiclePreparation.getRemarks());
|
taskManagementPreparationDetailVO.setOperationsUserId(vehiclePreparation.getOperationsUserId());
|
taskManagementPreparationDetailVO.setOperationsTime(vehiclePreparation.getCreateTime());
|
if (vehiclePreparation.getOperationsUserId() != null) {
|
XpOperationsUser operationsUser = xpOperationUserClient.queryById(vehiclePreparation.getOperationsUserId()).getData();
|
if (operationsUser != null) {
|
taskManagementPreparationDetailVO.setOperationsUserName(operationsUser.getNickName());
|
}
|
}
|
}
|
managementDetailVO.setPreparationDetailVO(taskManagementPreparationDetailVO);
|
|
break;
|
case "4":
|
// 洗车
|
TaskManagementCleanDetailVO taskManagementCleanDetailVO = new TaskManagementCleanDetailVO();
|
taskManagementCleanDetailVO.setId(task.getId());
|
taskManagementCleanDetailVO.setVehicleId(vehicle.getId());
|
taskManagementCleanDetailVO.setTaskUrgencyLevel(task.getTaskUrgencyLevel());
|
taskManagementCleanDetailVO.setPlateNumber(vehicle.getPlateNumber());
|
taskManagementCleanDetailVO.setVehicleColor(vehicle.getVehicleColor());
|
taskManagementCleanDetailVO.setVehicleCode(vehicle.getVehicleCode());
|
taskManagementCleanDetailVO.setVehicleVin(vehicle.getVehicleVin());
|
taskManagementCleanDetailVO.setVehicleLocation(task.getVehicleLocation());
|
taskManagementCleanDetailVO.setTaskCode(task.getTaskCode());
|
taskManagementCleanDetailVO.setVehiclePictures(vehiclePicture);
|
|
XpVehicleClean vehicleClean = vehicleCleanMapper.selectOne(new LambdaQueryWrapper<XpVehicleClean>()
|
.eq(XpVehicleClean::getTaskId, id).last("limit 1"));
|
if (vehicleClean != null) {
|
taskManagementCleanDetailVO.setTaskImage(vehicleClean.getTaskImage());
|
taskManagementCleanDetailVO.setOperationUserId(vehicleClean.getOperationsUserId());
|
if (vehicleClean.getOperationsUserId() != null) {
|
XpOperationsUser operationsUser = xpOperationUserClient.queryById(vehicleClean.getOperationsUserId()).getData();
|
if (operationsUser != null) {
|
taskManagementCleanDetailVO.setOperationsUserName(operationsUser.getNickName());
|
}
|
}
|
}
|
managementDetailVO.setCleanDetailVO(taskManagementCleanDetailVO);
|
|
break;
|
case "5":
|
// 维修
|
TaskManagementRepairDetailVO taskManagementRepairDetailVO = new TaskManagementRepairDetailVO();
|
taskManagementRepairDetailVO.setId(task.getId());
|
taskManagementRepairDetailVO.setVehicleId(vehicle.getId());
|
taskManagementRepairDetailVO.setTaskUrgencyLevel(task.getTaskUrgencyLevel());
|
taskManagementRepairDetailVO.setPlateNumber(vehicle.getPlateNumber());
|
taskManagementRepairDetailVO.setVehicleColor(vehicle.getVehicleColor());
|
taskManagementRepairDetailVO.setVehicleCode(vehicle.getVehicleCode());
|
taskManagementRepairDetailVO.setVehicleVin(vehicle.getVehicleVin());
|
taskManagementRepairDetailVO.setVehicleLocation(task.getVehicleLocation());
|
taskManagementRepairDetailVO.setTaskCode(task.getTaskCode());
|
taskManagementRepairDetailVO.setVehiclePictures(vehiclePicture);
|
|
XpVehicleRepair vehicleRepair = vehicleRepairMapper.selectOne(new LambdaQueryWrapper<XpVehicleRepair>()
|
.eq(XpVehicleRepair::getTaskId, id).last("limit 1"));
|
if (vehicleRepair != null) {
|
taskManagementRepairDetailVO.setStartTime(vehicleRepair.getStartTime());
|
taskManagementRepairDetailVO.setEndTime(vehicleRepair.getEndTime());
|
taskManagementRepairDetailVO.setRepairReason(vehicleRepair.getRepairReason());
|
taskManagementRepairDetailVO.setStartRepairPicture(vehicleRepair.getStartRepairPicture());
|
taskManagementRepairDetailVO.setRepairMoney(vehicleRepair.getRepairMoney());
|
taskManagementRepairDetailVO.setRepairMoneyDetail(vehicleRepair.getRepairMoneyDetail());
|
taskManagementRepairDetailVO.setSendUserId(vehicleRepair.getSendUserId());
|
taskManagementRepairDetailVO.setSendTime(vehicleRepair.getSendTime());
|
taskManagementRepairDetailVO.setReturnUserId(vehicleRepair.getReturnUserId());
|
taskManagementRepairDetailVO.setReturnTime(vehicleRepair.getReturnTime());
|
if (vehicleRepair.getReturnUserId() != null) {
|
XpOperationsUser operationsUser = xpOperationUserClient.queryById(vehicleRepair.getReturnUserId()).getData();
|
if (operationsUser != null) {
|
taskManagementRepairDetailVO.setReturnUserName(operationsUser.getNickName());
|
}
|
}
|
if (vehicleRepair.getSendUserId() != null) {
|
XpOperationsUser operationsUser = xpOperationUserClient.queryById(vehicleRepair.getSendUserId()).getData();
|
if (operationsUser != null) {
|
taskManagementRepairDetailVO.setSendUserName(operationsUser.getNickName());
|
}
|
}
|
}
|
managementDetailVO.setRepairDetailVO(taskManagementRepairDetailVO);
|
|
break;
|
default:
|
// 保养、年检、保险、营运资质
|
TaskManagementRoutineDetailVO res = new TaskManagementRoutineDetailVO();
|
res.setId(task.getId());
|
res.setTaskUrgencyLevel(task.getTaskUrgencyLevel());
|
res.setPlateNumber(vehicle.getPlateNumber());
|
res.setVehicleColor(vehicle.getVehicleColor());
|
res.setVehicleCode(vehicle.getVehicleCode());
|
res.setVehicleLocation(task.getVehicleLocation());
|
res.setVehicleVin(vehicle.getVehicleVin());
|
res.setTaskCode(task.getTaskCode());
|
res.setVehiclePictures(vehiclePicture);
|
XpTaskHandleDetailRoutine xpTaskHandleDetailRoutine = xpTaskHandleDetailRoutineMapper.selectOne(new LambdaQueryWrapper<XpTaskHandleDetailRoutine>()
|
.eq(XpTaskHandleDetailRoutine::getTaskId, id));
|
if (xpTaskHandleDetailRoutine != null) {
|
res.setTaskDescription(xpTaskHandleDetailRoutine.getTaskDescription());
|
res.setTaskImage(xpTaskHandleDetailRoutine.getTaskImage());
|
res.setHandleUserId(task.getHandleUserId());
|
XpOperationsUser operationsUser = xpOperationUserClient.queryById(xpTaskHandleDetailRoutine.getOperationsUserId()).getData();
|
if (operationsUser != null) {
|
res.setHandleUserId(operationsUser.getId().toString());
|
res.setHandleUserName(operationsUser.getNickName());
|
}
|
}
|
|
res.setHandleTime(task.getHandleTime());
|
res.setId(id);
|
res.setTaskUrgencyLevel(task.getTaskUrgencyLevel());
|
res.setPlateNumber(vehicle.getPlateNumber());
|
res.setVehicleColor(vehicle.getVehicleColor());
|
res.setVehicleCode(vehicle.getVehicleCode());
|
res.setVehicleLocation(task.getVehicleLocation());
|
res.setVehicleVin(vehicle.getVehicleVin());
|
managementDetailVO.setRoutineDetailVO(res);
|
|
break;
|
}
|
|
|
} else {
|
// 事故任务
|
TaskManagementAccidentDetailVO res = new TaskManagementAccidentDetailVO();
|
|
Map<Long, List<XpErrorType>> errorType = errorTypeMapper.selectList(new LambdaQueryWrapper<XpErrorType>()
|
.in(XpErrorType::getId, Arrays.asList(task.getTaskTypeId().split(","))))
|
.stream().collect(Collectors.groupingBy(XpErrorType::getParentId));
|
if (CollUtil.isEmpty(errorType)) {
|
throw new ServiceException(
|
"事故类型不存在",
|
I18nKeyConstant.ACCIDENT_TYPE_NOT_EXIST
|
);
|
}
|
List<XpErrorType> xpErrorTypes = errorType.get(0L);
|
for (XpErrorType xpErrorType : xpErrorTypes) {
|
xpErrorType.setChild(errorType.get(xpErrorType.getId()));
|
}
|
res.setCreateTime(task.getCreateTime());
|
res.setHandleTime(task.getHandleTime());
|
res.setErrorTypeList(xpErrorTypes);
|
res.setStatus(task.getStatus());
|
res.setTaskDescription(task.getTaskDescription());
|
|
String taskImage = task.getTaskImage();
|
if (StringUtils.isNotBlank(taskImage)) {
|
JSONArray jsonArray = JSONArray.parseArray(taskImage);
|
for (int i = 0; i < jsonArray.size(); i++) {
|
JSONObject jsonObject = jsonArray.getJSONObject(i);
|
if (Objects.isNull(jsonObject)) {
|
continue;
|
}
|
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);
|
}
|
res.setTaskImage(JSONArray.toJSONString(jsonArray));
|
}
|
|
res.setId(id);
|
res.setVehicleId(vehicle.getId());
|
res.setTaskUrgencyLevel(task.getTaskUrgencyLevel());
|
res.setPlateNumber(vehicle.getPlateNumber());
|
res.setVehicleColor(vehicle.getVehicleColor());
|
res.setVehicleCode(vehicle.getVehicleCode());
|
res.setVehicleLocation(task.getVehicleLocation());
|
res.setVehicleVin(vehicle.getVehicleVin());
|
if (task.getReportUserId().equals(0L)) {
|
// 系统补偿上传车辆异常任务 为系统创建
|
res.setReportUserId(0L);
|
res.setReportUserName("系统");
|
// todo 临时设置 待客户确认默认头像和电话号码
|
res.setReportUserPhone("111111");
|
res.setReportUserAvatar("[]");
|
} else {
|
if (Objects.nonNull(task.getTaskSource()) && task.getTaskSource().equals(2)) {
|
List<SysUser> list = sysUserClient.listByIds(Lists.newArrayList(task.getReportUserId())).getData();
|
if (CollUtil.isNotEmpty(list)) {
|
SysUser sysUser = list.get(0);
|
res.setReportUserId(sysUser.getId());
|
res.setReportUserName(sysUser.getNickName());
|
res.setReportUserPhone(sysUser.getPhoneNumber());
|
}
|
} else {
|
XpOperationsUser data = xpOperationUserClient.queryById(task.getReportUserId()).getData();
|
if (data != null) {
|
res.setReportUserId(data.getId());
|
res.setReportUserName(data.getNickName());
|
res.setReportUserPhone(data.getPhoneNumber());
|
res.setReportUserAvatar(data.getAvatar());
|
}
|
}
|
}
|
|
if (task.getHandleUserId() != null && task.getHandleUserId().split(",").length == 1) {
|
XpOperationsUser operationsUser = xpOperationUserClient.queryById(Long.valueOf(task.getHandleUserId())).getData();
|
if (operationsUser != null) {
|
res.setHandleUserId(operationsUser.getId());
|
res.setHandleUserName(operationsUser.getNickName());
|
res.setHandleUserPhone(operationsUser.getPhoneNumber());
|
res.setHandleUserAvatar(operationsUser.getAvatar());
|
}
|
}
|
XpTaskHandleDetail xpTaskHandleDetail = xpTaskHandleDetailMapper.selectOne(new LambdaQueryWrapper<XpTaskHandleDetail>()
|
.eq(XpTaskHandleDetail::getTaskId, id));
|
if (xpTaskHandleDetail != null) {
|
res.setDeathCount(xpTaskHandleDetail.getDeathCount());
|
res.setSevereCount(xpTaskHandleDetail.getSevereCount());
|
res.setMinorCount(xpTaskHandleDetail.getMinorCount());
|
res.setResponsibilityJudgment(xpTaskHandleDetail.getResponsibilityJudgment());
|
res.setResponsibleDescription(xpTaskHandleDetail.getResponsibleDescription());
|
res.setResponsibleImage(xpTaskHandleDetail.getResponsibleImage());
|
res.setDisposalDescription(xpTaskHandleDetail.getDisposalDescription());
|
res.setDisposalImage(xpTaskHandleDetail.getDisposalImage());
|
res.setSituationDescription(xpTaskHandleDetail.getSituationDescription());
|
res.setSituationImage(xpTaskHandleDetail.getSituationImage());
|
}
|
|
managementDetailVO.setAccidentDetailVO(res);
|
}
|
|
|
return R.ok(managementDetailVO);
|
}
|
|
|
/**
|
* 任务改派操作
|
* @param vo
|
*/
|
@Override
|
public void taskReassignment(TaskReassignmentVo vo) {
|
XpTask xpTask = this.getById(vo.getTaskId());
|
if(null == xpTask){
|
throw new ServiceException("无效的任务", I18nKeyConstant.TASK_NOT_EXIST);
|
}
|
if(2 == xpTask.getReassignmentStatus()){
|
throw new ServiceException("任务已改派，不能重复操作", I18nKeyConstant.TASK_HAS_BEEN_REASSIGNED);
|
}
|
xpTask.setReassignmentStatus(2);
|
xpTask.setHandleUserId(vo.getNewOperationsUserId() + "");
|
xpTask.setStatus(1);
|
this.updateById(xpTask);
|
//推送websocket
|
XpTaskVO xpTaskVO = new XpTaskVO();
|
BeanUtil.copyProperties(xpTask, xpTaskVO);
|
xpWebSocketMessageClient.pushTask(xpTaskVO);
|
boolean isAccidentTask = Integer.valueOf(2).equals(xpTask.getTaskCategory());
|
Long vehicleId = xpTask.getVehicleId();
|
Integer processingTimeLimit = null;
|
String plateNumber = "";
|
if (isAccidentTask) {
|
// 查询规则 任务结束时间从任务分配时开始计算
|
XpTaskRule taskRule = xpTaskRuleMapper.selectOne(null);
|
if (taskRule != null) {
|
processingTimeLimit = taskRule.getProcessingTimeLimit();
|
}
|
if (vehicleId != null) {
|
XpVehicle vehicle = xpVehicleClient.queryById(vehicleId).getData();
|
if (vehicle != null && StringUtils.isNotBlank(vehicle.getPlateNumber())) {
|
plateNumber = vehicle.getPlateNumber();
|
}
|
}
|
}
|
if (isAccidentTask && processingTimeLimit != null) {
|
sendAssignedAccidentNotificationAsync(xpTask, Long.valueOf(xpTask.getHandleUserId()), plateNumber, processingTimeLimit);
|
}
|
}
|
}
|
