858 lines
31 KiB
Java
858 lines
31 KiB
Java
package com.cdzy.ebikemaintenance.controller;
|
|
|
|
import com.alibaba.fastjson2.JSONObject;
|
|
import com.cdzy.common.model.JsonResult;
|
|
import com.cdzy.common.model.ResGPSDto;
|
|
import com.cdzy.ebikemaintenance.model.dto.request.*;
|
|
import com.cdzy.ebikemaintenance.model.dto.response.*;
|
|
import com.cdzy.ebikemaintenance.model.pojo.*;
|
|
import com.cdzy.ebikemaintenance.service.*;
|
|
import com.cdzy.common.utils.ConvertUtil;
|
|
import com.cdzy.ebikemaintenance.utils.MinioUtil;
|
|
import com.cdzy.ebikemaintenance.utils.RedisUtil;
|
|
import com.ebike.feign.model.res.ReqEcuSnDto;
|
|
import com.ebike.feign.model.rsp.RspBikeInfo;
|
|
import com.mybatisflex.core.paginate.Page;
|
|
import com.mybatisflex.core.query.QueryWrapper;
|
|
import jakarta.annotation.Resource;
|
|
import lombok.extern.slf4j.Slf4j;
|
|
import org.springframework.beans.BeanUtils;
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
import org.springframework.util.StringUtils;
|
|
import org.springframework.web.bind.annotation.*;
|
|
import org.springframework.web.multipart.MultipartFile;
|
|
|
|
import java.io.InputStream;
|
|
import java.time.LocalDateTime;
|
|
import java.util.*;
|
|
|
|
import static com.cdzy.ebikemaintenance.model.pojo.table.EbikeBatteryInfoTableDef.EBIKE_BATTERY_INFO;
|
|
import static com.cdzy.ebikemaintenance.model.pojo.table.EbikeHelmetInfoTableDef.EBIKE_HELMET_INFO;
|
|
|
|
/**
|
|
* 车辆基本信息 控制层。
|
|
*
|
|
* @author zjd
|
|
* @since 2025-03-17
|
|
*/
|
|
@Slf4j
|
|
@RestController
|
|
@RequestMapping("/ebikeBikeInfo")
|
|
public class EbikeBikeInfoController {
|
|
|
|
@Autowired
|
|
private EbikeBikeInfoService ebikeBikeInfoService;
|
|
@Autowired
|
|
private EbikeEcuInfoService ebikeEcuInfoService;
|
|
@Autowired
|
|
private EbikeBatteryInfoService ebikeBatteryInfoService;
|
|
@Autowired
|
|
private EbikeHelmetInfoService ebikeHelmetInfoService;
|
|
@Autowired
|
|
private EbikeBikeCheckinService ebikeBikeCheckinService;
|
|
@Resource
|
|
private EbikeSystemInfoService ebikeSystemInfoService;
|
|
@Autowired
|
|
@Resource
|
|
private RedisUtil redisUtil;
|
|
@Autowired
|
|
private MinioUtil minioUtil;
|
|
|
|
|
|
/**
|
|
* 整车信息保存
|
|
*
|
|
* @param reqEbikeBikeInfoDto 车辆基本信息
|
|
* @return
|
|
*/
|
|
@PostMapping("saveEbikeInfo")
|
|
public JsonResult<?> saveEbikeInfo(@RequestBody ReqEbikeBikeInfoDto reqEbikeBikeInfoDto) {
|
|
|
|
Boolean b = ebikeBikeInfoService.saveEbikeInfo(reqEbikeBikeInfoDto);
|
|
if (b) {
|
|
return JsonResult.success(true);
|
|
}
|
|
return JsonResult.failed("保存失败");
|
|
}
|
|
|
|
/**
|
|
* 根据车辆ID 获取整车信息详情
|
|
*
|
|
* @param ebikeId 车辆ID
|
|
* @return
|
|
*/
|
|
@RequestMapping("getEbikeInfoById")
|
|
public JsonResult<?> getEbikeInfoById(@RequestParam(name = "ebikeId") String ebikeId) {
|
|
try {
|
|
ReqEbikeBikeInfoDto reqEbikeBikeInfoDto = new ReqEbikeBikeInfoDto();
|
|
EbikeBikeInfo ebikeBikeInfo = ebikeBikeInfoService.getById(ebikeId);
|
|
BeanUtils.copyProperties(ebikeBikeInfo, reqEbikeBikeInfoDto);
|
|
EbikeBatteryInfo ebikeBatteryInfo = ebikeBatteryInfoService.getById(ebikeBikeInfo.getBatteryId());
|
|
EbikeHelmetInfo ebikeHelmetInfo = ebikeHelmetInfoService.getById(ebikeBikeInfo.getHelmetId());
|
|
EbikeEcuInfo ebikeEcuInfo = ebikeEcuInfoService.getById(ebikeBikeInfo.getEcuId());
|
|
reqEbikeBikeInfoDto.setEbikeBatteryInfo(ebikeBatteryInfo);
|
|
reqEbikeBikeInfoDto.setEbikeHelmetInfo(ebikeHelmetInfo);
|
|
reqEbikeBikeInfoDto.setEbikeEcuInfo(ebikeEcuInfo);
|
|
//汉化状态
|
|
String bike_state = ebikeBikeInfo.getState();
|
|
if (bike_state == null || bike_state.isEmpty()) {
|
|
bike_state = "0";
|
|
}
|
|
bike_state = ebikeSystemInfoService.getEbikeCarStatusName(Integer.valueOf(bike_state));
|
|
reqEbikeBikeInfoDto.setState(bike_state);
|
|
return JsonResult.success(reqEbikeBikeInfoDto);
|
|
} catch (Exception e) {
|
|
log.error("getEbikeInfoById===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
|
|
return JsonResult.failed(e.getMessage());
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* 根据车辆编号 获取整车信息详情
|
|
*
|
|
* @param ebikeCode 车辆编号
|
|
* @return
|
|
*/
|
|
@RequestMapping("getEbikeInfoByCode")
|
|
public JsonResult<?> getEbikeInfoByCode(@RequestParam(name = "ebikeCode") String ebikeCode) {
|
|
try {
|
|
ReqEbikeBikeInfoDto reqEbikeBikeInfoDto = new ReqEbikeBikeInfoDto();
|
|
EbikeBikeInfo ebikeBikeInfo = ebikeBikeInfoService.getByBikeCode(ebikeCode);
|
|
BeanUtils.copyProperties(ebikeBikeInfo, reqEbikeBikeInfoDto);
|
|
EbikeBatteryInfo ebikeBatteryInfo = ebikeBatteryInfoService.getById(ebikeBikeInfo.getBatteryId());
|
|
EbikeHelmetInfo ebikeHelmetInfo = ebikeHelmetInfoService.getById(ebikeBikeInfo.getHelmetId());
|
|
EbikeEcuInfo ebikeEcuInfo = ebikeEcuInfoService.getById(ebikeBikeInfo.getEcuId());
|
|
reqEbikeBikeInfoDto.setEbikeBatteryInfo(ebikeBatteryInfo);
|
|
reqEbikeBikeInfoDto.setEbikeHelmetInfo(ebikeHelmetInfo);
|
|
reqEbikeBikeInfoDto.setEbikeEcuInfo(ebikeEcuInfo);
|
|
//汉化状态
|
|
String bike_state = ebikeBikeInfo.getState();
|
|
if (bike_state == null || bike_state.isEmpty()) {
|
|
bike_state = "0";
|
|
}
|
|
bike_state = ebikeSystemInfoService.getEbikeCarStatusName(Integer.valueOf(bike_state));
|
|
reqEbikeBikeInfoDto.setState(bike_state);
|
|
return JsonResult.success(reqEbikeBikeInfoDto);
|
|
} catch (Exception e) {
|
|
log.error("getEbikeInfoByCode===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
|
|
return JsonResult.failed(e.getMessage());
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* 根据车辆编号获取ecuSn
|
|
*
|
|
* @param bikeCode 车辆编号
|
|
* @return
|
|
*/
|
|
@GetMapping("getEbikeEcuSnByCode")
|
|
public JsonResult<?> getEbikeEcuSnByID(@RequestParam(name = "bikeCode") String bikeCode) {
|
|
String ecuSn = ebikeBikeInfoService.getEcuSnByBikeCode(bikeCode);
|
|
if (ecuSn == null || ecuSn.isEmpty()) {
|
|
return JsonResult.failed("获取车辆ECU信息失败");
|
|
}
|
|
return JsonResult.success("获取车辆ECU信息成功", ecuSn);
|
|
}
|
|
|
|
/**
|
|
* 更换头盔
|
|
*
|
|
* @param ebikeBikeInfo 车辆基本信息
|
|
* @return
|
|
*/
|
|
@PostMapping("updateEbikeHelmet")
|
|
public JsonResult<?> updateEbikeHelmet(@RequestBody ReqUpdateHelmetDto ebikeBikeInfo) {
|
|
|
|
Boolean b = ebikeBikeInfoService.updateEbikeHelmet(ebikeBikeInfo);
|
|
if (b) {
|
|
return JsonResult.success(true);
|
|
}
|
|
return JsonResult.failed("保存失败");
|
|
}
|
|
|
|
/**
|
|
* 根据头盔编号获取头盔信息
|
|
*
|
|
* @param helmetCode 头盔编号
|
|
* @return
|
|
*/
|
|
@RequestMapping("getHelmetInfo")
|
|
public JsonResult<?> getHelmetInfo(@RequestParam(value = "helmetCode") String helmetCode) {
|
|
|
|
try {
|
|
ResEbikeHelmetInfoDto resEbikeHelmetInfoDto = new ResEbikeHelmetInfoDto();
|
|
QueryWrapper queryWrapper = QueryWrapper.create();
|
|
queryWrapper.eq(EBIKE_HELMET_INFO.HELMET_CODE.getName(), helmetCode);
|
|
EbikeHelmetInfo one = ebikeHelmetInfoService.getOne(queryWrapper);
|
|
BeanUtils.copyProperties(one, resEbikeHelmetInfoDto);
|
|
return JsonResult.success(resEbikeHelmetInfoDto);
|
|
} catch (Exception e) {
|
|
log.error("getHelmetInfo===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
|
|
return JsonResult.failed(e.getMessage());
|
|
}
|
|
}
|
|
|
|
///**
|
|
// * 更换中控
|
|
// *
|
|
// * @param reqUpdateEcuDto 车辆基本信息
|
|
// * @return
|
|
// */
|
|
// @PostMapping("updateEbikeEcu")
|
|
// public JsonResult<?> updateEbikeEcu(@RequestBody ReqUpdateEcuDto reqUpdateEcuDto) {
|
|
// Boolean b = ebikeBikeInfoService.updateEbikeEcu(reqUpdateEcuDto);
|
|
// if (b) {
|
|
// return JsonResult.success(true);
|
|
// }
|
|
// return JsonResult.failed("保存失败");
|
|
// }
|
|
|
|
/**
|
|
* 分页查询车辆信息列表
|
|
*
|
|
* @param request 查询参数
|
|
* @return
|
|
*/
|
|
@PostMapping("pageQueryEbikeList")
|
|
public JsonResult<Object> pageQueryEbikeList(@RequestBody ReqEbikeCheckinDto request) {
|
|
//查询车辆信息列表
|
|
Page<ResInventoryBikeListDto> inventoryBikeListDtoPage = ebikeBikeInfoService.getInventoryBikeList(request);
|
|
//汉化状态 改为leftJoin查询
|
|
//inventoryBikeListDtoPage.getRecords().forEach(resInventoryBikeListDto -> {
|
|
// String bikeState = resInventoryBikeListDto.getState();
|
|
// if (bikeState == null || bikeState.isEmpty()) {
|
|
// bikeState = "0";
|
|
// }
|
|
// bikeState = ebikeSystemInfoService.getEbikeCarStatusName(Integer.valueOf(bikeState));
|
|
// resInventoryBikeListDto.setStateName(bikeState);
|
|
//});
|
|
return JsonResult.success(inventoryBikeListDtoPage);
|
|
}
|
|
|
|
/**
|
|
* 获取库存车辆详情信息
|
|
*
|
|
* @param bikeId 车辆ID
|
|
* @return
|
|
*/
|
|
@RequestMapping("getInventoryBikeDetails")
|
|
public JsonResult<?> getInventoryBikeDetails(@RequestParam(name = "bikeId") String bikeId) {
|
|
ResInventoryBikeDetailsDto details = ebikeBikeInfoService.getInventoryBikeDetails(bikeId);
|
|
if (details != null) {
|
|
//查询车辆入库时间
|
|
LocalDateTime bikeCheckinTime = ebikeBikeCheckinService.getBikeCheckinTime(details.getBikeId());
|
|
if (bikeCheckinTime != null) {
|
|
details.setEnterTime(bikeCheckinTime);
|
|
}
|
|
return JsonResult.success(details);
|
|
}
|
|
return JsonResult.failed("获取库存车辆详情信息失败");
|
|
}
|
|
|
|
/**
|
|
* 根据车辆编号获取车辆基本信息
|
|
*
|
|
* @param bikeCode 车辆编号
|
|
* @return
|
|
*/
|
|
@RequestMapping("getBikeINfoData")
|
|
public JsonResult<?> getBikeINfoData(@RequestParam(name = "bikeCode") String bikeCode) {
|
|
|
|
Boolean b = ebikeBikeInfoService.inspectBikeHaveOrNot(bikeCode);
|
|
if (!b) {
|
|
return JsonResult.failed("车辆信息不存在");
|
|
}
|
|
ResEbikeBikeAndEcuCodeDto bikeINfoData = ebikeBikeInfoService.getBikeINfoData(bikeCode);
|
|
if (bikeINfoData != null) {
|
|
return JsonResult.success(bikeINfoData);
|
|
}
|
|
return JsonResult.failed("获取信息失败");
|
|
}
|
|
|
|
|
|
/**
|
|
* 根据头盔编号、车辆编号获取车辆头盔信息
|
|
*
|
|
* @param helmetDto
|
|
* @return
|
|
*/
|
|
@RequestMapping("/getHelmetINfoData")
|
|
public JsonResult<?> getHelmetINfoData(@RequestBody ReqEbikeHelmetDto helmetDto) {
|
|
if ((helmetDto.getHelmetCode() == null || helmetDto.getHelmetCode().isEmpty()) && (helmetDto.getBikeCode() == null || helmetDto.getBikeCode().isEmpty())) {
|
|
return JsonResult.failed("参数不能为空");
|
|
}
|
|
ResEbikeHelmetInfoDto2 helmetINfoData = ebikeHelmetInfoService.getHelmetINfoData(helmetDto);
|
|
if (helmetINfoData != null) {
|
|
ResEbikeHelmetInfoDto helmetInfoDto = new ResEbikeHelmetInfoDto();
|
|
BeanUtils.copyProperties(helmetINfoData, helmetInfoDto);
|
|
if (helmetINfoData.getEcuSn() != null && !helmetINfoData.getEcuSn().isEmpty()) {
|
|
String jsonString = JSONObject.toJSONString(redisUtil.get(helmetINfoData.getEcuSn()));
|
|
ResGPSDto resGpsDto = JSONObject.parseObject(jsonString, ResGPSDto.class);
|
|
if (resGpsDto != null) {
|
|
helmetInfoDto.setUpdatedAt(ConvertUtil.timestampToDate(resGpsDto.getTimestamp().longValue()));
|
|
helmetInfoDto.setHelmetExit(resGpsDto.getHelmetExit() == '0' ? "不在位" : "在位");
|
|
}
|
|
}
|
|
return JsonResult.success(helmetInfoDto);
|
|
}
|
|
return JsonResult.failed("获取信息失败");
|
|
}
|
|
|
|
/**
|
|
* 解绑中控
|
|
*
|
|
* @param bikeId 车辆ID
|
|
* @return
|
|
*/
|
|
@PostMapping("untieEcu")
|
|
public JsonResult<?> untieEcu(@RequestBody List<String> bikeId) {
|
|
|
|
Boolean b = ebikeBikeInfoService.untieEcu(bikeId);
|
|
if (b) {
|
|
return JsonResult.success(true);
|
|
}
|
|
return JsonResult.failed("解绑失败");
|
|
}
|
|
|
|
/**
|
|
* 更换二维码
|
|
*
|
|
* @param reqUpBikeCodeDto 更换二维码dto
|
|
* @return
|
|
*/
|
|
@PostMapping("updateBikeQRCode")
|
|
public JsonResult<?> updateBikeQRCode(@RequestBody ReqUpBikeCodeDto reqUpBikeCodeDto) {
|
|
|
|
Boolean b = ebikeBikeInfoService.updateBikeQRCode(reqUpBikeCodeDto);
|
|
if (b) {
|
|
return JsonResult.success(true);
|
|
}
|
|
return JsonResult.failed("更换成功");
|
|
}
|
|
|
|
/**
|
|
* 车辆批量出库
|
|
*
|
|
* @param reqBulkDeliveryDto 车辆出库信息
|
|
* @return
|
|
*/
|
|
@PostMapping("vehicleLeaveWarehouse")
|
|
public JsonResult<?> vehicleLeaveWarehouse(@RequestBody ReqBulkDeliveryDto reqBulkDeliveryDto) {
|
|
|
|
Boolean b = ebikeBikeInfoService.vehicleLeaveWarehouse(reqBulkDeliveryDto);
|
|
if (b) {
|
|
return JsonResult.success(true);
|
|
}
|
|
return JsonResult.failed("出库失败");
|
|
}
|
|
|
|
|
|
/**
|
|
* 文件上传
|
|
*
|
|
* @param multipartFile 文件对象
|
|
* @return
|
|
*/
|
|
@PostMapping(value = "fileUpload", consumes = "multipart/*", headers = "content-type=multipart/form-data")
|
|
public JsonResult<?> fileUpload(@RequestParam("multipartFile") MultipartFile multipartFile) {
|
|
|
|
try {
|
|
minioUtil.createBucket(MinioUtil.BUCKET_FAULT);
|
|
InputStream inputStream = multipartFile.getInputStream();
|
|
String fileName = multipartFile.getOriginalFilename();
|
|
String fileUniqueKey = UUID.randomUUID() + fileName.substring(fileName.lastIndexOf("."));
|
|
minioUtil.uploadFile(inputStream, MinioUtil.BUCKET_FAULT, fileUniqueKey);
|
|
String fileUrl = minioUtil.getFileUrl(MinioUtil.BUCKET_FAULT, fileUniqueKey);
|
|
ResEbikeFaultReportFileDto resEbikeFaultReportFileDto = new ResEbikeFaultReportFileDto();
|
|
resEbikeFaultReportFileDto.setUrl(fileUrl);
|
|
resEbikeFaultReportFileDto.setFileUniqueKey(fileUniqueKey);
|
|
//resEbikeFaultReportFileDto.setFileBucket(MinioUtil.BUCKET_FAULT);
|
|
resEbikeFaultReportFileDto.setFileName(fileName);
|
|
resEbikeFaultReportFileDto.setFileType(fileName.substring(fileName.lastIndexOf(".")));
|
|
resEbikeFaultReportFileDto.setFileSize(multipartFile.getSize());
|
|
return JsonResult.success(resEbikeFaultReportFileDto);
|
|
} catch (Exception e) {
|
|
log.error("fileUpload===>{}", e.getMessage() + Arrays.toString(e.getStackTrace()));
|
|
return JsonResult.failed("上传失败");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 删除附件
|
|
*
|
|
* @param fileUniqueKey 附件唯一标识
|
|
* @return
|
|
*/
|
|
@RequestMapping("deletedFile")
|
|
public JsonResult<?> deletedFile(@RequestParam(name = "fileUniqueKey") String fileUniqueKey) {
|
|
|
|
try {
|
|
minioUtil.deleteObject(MinioUtil.BUCKET_FAULT, fileUniqueKey);
|
|
return JsonResult.success("删除成功");
|
|
} catch (Exception e) {
|
|
log.error("deletedFile===>{}", e.getMessage() + Arrays.toString(e.getStackTrace()));
|
|
return JsonResult.failed("删除失败");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 故障上报提交
|
|
*
|
|
* @param reqEbikeBikeFaultReportDto 故障上报基本信息
|
|
* @return
|
|
*/
|
|
@PostMapping("faultReporting")
|
|
public JsonResult<?> faultReporting(@RequestBody ReqEbikeBikeFaultReportDto reqEbikeBikeFaultReportDto) {
|
|
|
|
Boolean b = ebikeBikeInfoService.faultReporting(reqEbikeBikeFaultReportDto);
|
|
if (b) {
|
|
return JsonResult.success(true);
|
|
}
|
|
return JsonResult.failed("提交失败");
|
|
}
|
|
|
|
/**
|
|
* 获取当前车辆所有上报的故障列表
|
|
*
|
|
* @param bikeCode 车辆编号
|
|
* @return
|
|
*/
|
|
@RequestMapping("getFaultReportList")
|
|
public JsonResult<?> getFaultReportList(@RequestParam(name = "bikeCode") String bikeCode) {
|
|
return JsonResult.success(ebikeBikeInfoService.getFaultReportList(bikeCode));
|
|
}
|
|
|
|
/**
|
|
* 检查是否有工单
|
|
*
|
|
* @param reqEbikeWorkOrderDto 工单基本信息
|
|
* @return
|
|
*/
|
|
@PostMapping("inspectHaveOrNotWorkOrder")
|
|
public JsonResult<?> inspectHaveOrNotWorkOrder(@RequestBody ReqEbikeWorkOrderDto reqEbikeWorkOrderDto) {
|
|
|
|
EbikeBikeOrder ebikeBikeOrder = ebikeBikeInfoService.inspectHaveOrNotWorkOrder(reqEbikeWorkOrderDto);
|
|
if (ebikeBikeOrder != null) {
|
|
return JsonResult.success("", ebikeBikeOrder.getOrderId());
|
|
}
|
|
return JsonResult.failed("没有找到相关工单信息");
|
|
}
|
|
|
|
/**
|
|
* 故障领取创建工单
|
|
*
|
|
* @param reqEbikeBikeOrderDto 工单基本信息
|
|
* @return
|
|
*/
|
|
@PostMapping("createWorkOrder")
|
|
public JsonResult<?> createWorkOrder(@RequestBody ReqEbikeBikeOrderDto reqEbikeBikeOrderDto) {
|
|
|
|
String orderId = ebikeBikeInfoService.createWorkOrder(reqEbikeBikeOrderDto);
|
|
if (!StringUtils.isEmpty(orderId)) {
|
|
return JsonResult.success("", orderId);
|
|
}
|
|
return JsonResult.failed("领取失败");
|
|
}
|
|
|
|
/**
|
|
* 根据车辆编号获取故障信息详情
|
|
*
|
|
* @param orderId 工单ID
|
|
* @return
|
|
*/
|
|
@RequestMapping("getFaultInfo")
|
|
public JsonResult<?> getFaultInfo(@RequestParam(name = "orderId") String orderId) {
|
|
|
|
try {
|
|
return JsonResult.success(ebikeBikeInfoService.getFaultInfo(orderId));
|
|
} catch (Exception e) {
|
|
log.error("getFaultInfo===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
|
|
return JsonResult.failed("获取信息失败");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 故障处理完成
|
|
*
|
|
* @param reqEbikeBikeFaultHandleDto 故障处理完成实体
|
|
* @return
|
|
*/
|
|
@PostMapping("faultHandelComplete")
|
|
public JsonResult<?> faultHandelComplete(@RequestBody ReqEbikeBikeFaultHandleDto reqEbikeBikeFaultHandleDto) {
|
|
|
|
Boolean b = ebikeBikeInfoService.faultHandelComplete(reqEbikeBikeFaultHandleDto);
|
|
if (b) {
|
|
return JsonResult.success(true);
|
|
}
|
|
return JsonResult.failed("处理失败");
|
|
}
|
|
|
|
/**
|
|
* 根据车辆编号获取故障上报历史记录
|
|
*
|
|
* @param reqFaultHistoryListDto 查询参数
|
|
* @return
|
|
*/
|
|
@PostMapping("getFaultHistoryList")
|
|
public JsonResult<?> getFaultHistoryList(@RequestBody ReqFaultHistoryListDto reqFaultHistoryListDto) {
|
|
|
|
try {
|
|
return JsonResult.success(ebikeBikeInfoService.getFaultHistoryList(reqFaultHistoryListDto));
|
|
} catch (Exception e) {
|
|
log.error("getFaultHistoryList===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
|
|
return JsonResult.failed("获取信息失败");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获取指令记录列表
|
|
*
|
|
* @param reqInstructionRecordListDto 查询参数
|
|
* @return
|
|
*/
|
|
@PostMapping("getInstructionRecordList")
|
|
public JsonResult<?> getInstructionRecordList(@RequestBody ReqInstructionRecordListDto reqInstructionRecordListDto) {
|
|
try {
|
|
return JsonResult.success(ebikeBikeInfoService.getInstructionRecordList(reqInstructionRecordListDto));
|
|
} catch (Exception e) {
|
|
log.error("getFaultHistoryList===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
|
|
return JsonResult.failed("获取信息失败");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获取工单记录列表
|
|
*
|
|
* @param reqWorkOrderRecordListDto 查询参数
|
|
* @return
|
|
*/
|
|
@PostMapping("getWorkOrderRecordList")
|
|
public JsonResult<?> getWorkOrderRecordList(@RequestBody ReqWorkOrderRecordListDto reqWorkOrderRecordListDto) {
|
|
try {
|
|
return JsonResult.success(ebikeBikeInfoService.getWorkOrderRecordList(reqWorkOrderRecordListDto));
|
|
} catch (Exception e) {
|
|
log.error("getFaultHistoryList===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
|
|
return JsonResult.failed("获取信息失败");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 取消工单
|
|
*
|
|
* @param orderId 工单ID orderType 1 维修工单 2 换电工单 3 调度工单
|
|
*
|
|
* @return
|
|
*/
|
|
@RequestMapping("canCellWorkOrder")
|
|
public JsonResult<?> canCellWorkOrder(@RequestParam(name = "orderId") String orderId,@RequestParam(name = "orderType") String orderType) {
|
|
|
|
boolean b = ebikeBikeInfoService.canCellWorkOrder(orderId,orderType);
|
|
if (b) {
|
|
return JsonResult.success(true);
|
|
}
|
|
return JsonResult.failed("取消失败");
|
|
}
|
|
|
|
/**
|
|
* 获取车辆信息详情
|
|
*
|
|
* @param reqEbikeGetBikeDetailsDto 车辆基本信息
|
|
* @return
|
|
*/
|
|
@PostMapping("getBikeDetailsINfoData")
|
|
public JsonResult<?> getBikeDetailsINfoData(@RequestBody ReqEbikeGetBikeDetailsDto reqEbikeGetBikeDetailsDto) {
|
|
|
|
try {
|
|
return JsonResult.success(ebikeBikeInfoService.getBikeDetailsINfoData(reqEbikeGetBikeDetailsDto));
|
|
} catch (Exception e) {
|
|
log.error("getBikeDetailsINfoData===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
|
|
return JsonResult.failed("获取信息失败");
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* 根据EcuSn列表获取车辆信息
|
|
*
|
|
* @param ecuSnDto 中控SN码
|
|
* @return 车辆基本信息列表
|
|
*/
|
|
@PostMapping("getBikeByEcuSn")
|
|
public JsonResult<?> getBikeByEcuSn(@RequestBody ReqEcuSnDto ecuSnDto) {
|
|
List<RspBikeInfo> list = ebikeBikeInfoService.getBikeByEcuSn(ecuSnDto);
|
|
return JsonResult.success(list);
|
|
}
|
|
|
|
/**
|
|
* 获取定位基本信息
|
|
*
|
|
* @param reqEbikeGetBikeDetailsDto 车辆基本信息
|
|
* @return
|
|
*/
|
|
@PostMapping("getOrientationInfo")
|
|
public JsonResult<?> getOrientationInfo(@RequestBody ReqEbikeGetBikeDetailsDto reqEbikeGetBikeDetailsDto) {
|
|
|
|
try {
|
|
return JsonResult.success(ebikeBikeInfoService.getOrientationInfo(reqEbikeGetBikeDetailsDto));
|
|
} catch (Exception e) {
|
|
log.error("getOrientationInfo===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
|
|
return JsonResult.failed("获取信息失败");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 保存头盔信息
|
|
*
|
|
* @param helmetCodes 头盔编号
|
|
* @return
|
|
*/
|
|
@PostMapping("saveHelmetInfo")
|
|
public JsonResult<?> saveHelmetInfo(@RequestBody List<String> helmetCodes) {
|
|
|
|
try {
|
|
List<EbikeHelmetInfo> ebikeHelmetInfos = new ArrayList<>();
|
|
for (String helmetCode : helmetCodes) {
|
|
QueryWrapper query = QueryWrapper.create();
|
|
query.eq(EBIKE_HELMET_INFO.HELMET_CODE.getName(), helmetCode);
|
|
EbikeHelmetInfo one = ebikeHelmetInfoService.getOne(query);
|
|
if (one == null) {
|
|
EbikeHelmetInfo ebikeHelmetInfo = new EbikeHelmetInfo();
|
|
ebikeHelmetInfo.setHelmetCode(helmetCode);
|
|
ebikeHelmetInfos.add(ebikeHelmetInfo);
|
|
}
|
|
}
|
|
if (!ebikeHelmetInfos.isEmpty()) {
|
|
ebikeHelmetInfoService.saveBatch(ebikeHelmetInfos);
|
|
}
|
|
return JsonResult.success();
|
|
} catch (Exception e) {
|
|
log.error("saveHelmetInfo===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
|
|
return JsonResult.failed("保存失败");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 保存电池信息
|
|
*
|
|
* @param batteryCodes 电池编号
|
|
* @return
|
|
*/
|
|
@PostMapping("saveBatteryInfo")
|
|
public JsonResult<?> saveBatteryInfo(@RequestBody List<String> batteryCodes) {
|
|
|
|
try {
|
|
List<EbikeBatteryInfo> ebikeBatteryInfos = new ArrayList<>();
|
|
for (String batteryCode : batteryCodes) {
|
|
QueryWrapper query = QueryWrapper.create();
|
|
query.eq(EBIKE_BATTERY_INFO.BATTERY_CODE.getName(), batteryCode);
|
|
EbikeBatteryInfo one = ebikeBatteryInfoService.getOne(query);
|
|
if (one == null) {
|
|
EbikeBatteryInfo ebikeBatteryInfo = new EbikeBatteryInfo();
|
|
ebikeBatteryInfo.setBatteryCode(batteryCode);
|
|
ebikeBatteryInfos.add(ebikeBatteryInfo);
|
|
}
|
|
}
|
|
if (!ebikeBatteryInfos.isEmpty()) {
|
|
ebikeBatteryInfoService.saveBatch(ebikeBatteryInfos);
|
|
}
|
|
return JsonResult.success();
|
|
} catch (Exception e) {
|
|
log.error("saveHelmetInfo===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
|
|
return JsonResult.failed("保存失败");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获取工单详情信息
|
|
*
|
|
* @param orderId 工单ID
|
|
* @return
|
|
*/
|
|
@RequestMapping("getWorkOrderInfo")
|
|
public JsonResult<?> getWorkOrderInfo(@RequestParam(value = "orderId") String orderId) {
|
|
try {
|
|
return JsonResult.success(ebikeBikeInfoService.getWorkOrderInfo(orderId));
|
|
} catch (Exception e) {
|
|
log.error("getWorkOrderInfo===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
|
|
return JsonResult.failed("获取信息失败");
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* 删除头盔信息
|
|
*
|
|
* @param helmetCodes 头盔编号
|
|
* @return
|
|
*/
|
|
@PostMapping("deleteHelmetInfo")
|
|
public JsonResult<?> deleteHelmetInfo(@RequestBody List<String> helmetCodes) {
|
|
try {
|
|
List<String> ebikeHelmetIds = new ArrayList<>();
|
|
for (String helmetCode : helmetCodes) {
|
|
QueryWrapper query = QueryWrapper.create();
|
|
query.eq(EBIKE_HELMET_INFO.HELMET_CODE.getName(), helmetCode);
|
|
EbikeHelmetInfo one = ebikeHelmetInfoService.getOne(query);
|
|
if (one == null) {
|
|
ebikeHelmetIds.add(one.getHelmetId());
|
|
}
|
|
}
|
|
if (!ebikeHelmetIds.isEmpty()) {
|
|
ebikeHelmetInfoService.removeByIds(ebikeHelmetIds);
|
|
}
|
|
return JsonResult.success();
|
|
} catch (Exception e) {
|
|
log.error("deleteHelmetInfo===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
|
|
return JsonResult.failed("删除失败");
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* 删除电池信息
|
|
*
|
|
* @param batteryCodes 电池编号
|
|
* @return
|
|
*/
|
|
@PostMapping("deleteBatteryInfo")
|
|
public JsonResult<?> deleteBatteryInfo(@RequestBody List<String> batteryCodes) {
|
|
|
|
try {
|
|
List<String> ebikeBatteryIds = new ArrayList<>();
|
|
for (String batteryCode : batteryCodes) {
|
|
QueryWrapper query = QueryWrapper.create();
|
|
query.eq(EBIKE_BATTERY_INFO.BATTERY_CODE.getName(), batteryCode);
|
|
EbikeBatteryInfo one = ebikeBatteryInfoService.getOne(query);
|
|
if (one == null) {
|
|
ebikeBatteryIds.add(one.getBatteryId());
|
|
}
|
|
}
|
|
if (!ebikeBatteryIds.isEmpty()) {
|
|
ebikeBatteryInfoService.removeByIds(ebikeBatteryIds);
|
|
}
|
|
return JsonResult.success();
|
|
} catch (Exception e) {
|
|
log.error("deleteBatteryInfo===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
|
|
return JsonResult.failed("删除失败");
|
|
}
|
|
}
|
|
/**
|
|
* 批量投放，创建车辆调度工单
|
|
*
|
|
* @param reqWorkOrderDispatchDto 车辆编号
|
|
* @return
|
|
*/
|
|
@PostMapping("createWorkOrderDispatch")
|
|
public JsonResult<?> createWorkOrderDispatch(@RequestBody ReqWorkOrderDispatchDto reqWorkOrderDispatchDto) {
|
|
|
|
String orderId = ebikeBikeInfoService.createWorkOrderDispatch(reqWorkOrderDispatchDto);
|
|
if (!StringUtils.isEmpty(orderId)) {
|
|
return JsonResult.success("", orderId);
|
|
}
|
|
return JsonResult.failed("创建调度工单失败");
|
|
}
|
|
/**
|
|
* 根据工单id 获取调度车辆数据接口
|
|
*
|
|
* @param orderId 工单Id
|
|
* @return
|
|
*/
|
|
@GetMapping("getDispatchVehicleByOrderId")
|
|
public JsonResult<?> getDispatchVehicleByOrderId(@RequestParam(name = "orderId") String orderId) {
|
|
ResDispatchVehicleDto resDispatchVehicleDto = ebikeBikeInfoService.getDispatchVehicleByOrderId(orderId);
|
|
if (!StringUtils.isEmpty(resDispatchVehicleDto)) {
|
|
return JsonResult.success("", resDispatchVehicleDto);
|
|
}
|
|
return JsonResult.failed("获取调度车辆数据失败！");
|
|
}
|
|
/**
|
|
* 有工单-根据工单ID 车辆编号 新增调度车车辆
|
|
* @param ebikeDispatchRecordDto
|
|
*/
|
|
|
|
@PostMapping("createDispatchRecord")
|
|
public JsonResult<?> createDispatchRecord(@RequestBody ReqEbikeDispatchRecordDto ebikeDispatchRecordDto) {
|
|
EbikeDispatchRecords dispatchRecord = ebikeBikeInfoService.createDispatchRecord(ebikeDispatchRecordDto);
|
|
if (!StringUtils.isEmpty(dispatchRecord)) {
|
|
return JsonResult.success("", dispatchRecord);
|
|
}else{
|
|
return JsonResult.failed("车辆已经在调度列表中！");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 删除调度记录接口
|
|
* @param recordId
|
|
* @return
|
|
*/
|
|
@GetMapping("deleteDispatchRecord")
|
|
public JsonResult<?> deleteDispatchRecord(@RequestParam(name = "recordId") String recordId) {
|
|
Boolean aBoolean = ebikeBikeInfoService.deleteDispatchRecord(recordId);
|
|
if (aBoolean) {
|
|
return JsonResult.success("删除成功", aBoolean);
|
|
}
|
|
return JsonResult.failed("删除失败！");
|
|
}
|
|
|
|
|
|
/**
|
|
* 获取运营车辆列表
|
|
*
|
|
* @param request 查询参数
|
|
* @return
|
|
*/
|
|
@PostMapping("getOperationalBikeList")
|
|
public JsonResult<Object> getOperationalBikeList(@RequestBody ReqEbikeCheckinDto request) {
|
|
//查询车辆信息列表
|
|
Page<ResInventoryBikeListDto> inventoryBikeListDtoPage = ebikeBikeInfoService.getOperationalBikeList(request);
|
|
|
|
return JsonResult.success(inventoryBikeListDtoPage);
|
|
}
|
|
/**
|
|
* 修改车辆状态
|
|
*
|
|
* @param request 车辆状态修改请求参数
|
|
* @return
|
|
*/
|
|
@PostMapping("updateVehicleStatus")
|
|
public JsonResult<?> updateVehicleStatus(@RequestBody ReqVehicleStatusUpdateDto request) {
|
|
// 调用服务层方法，执行车辆状态修改操作
|
|
return ebikeBikeInfoService.updateVehicleStatus(request);
|
|
}
|
|
/**
|
|
* 完成投放
|
|
*
|
|
* @param request 完成投放请求参数 orderId
|
|
* @return
|
|
*/
|
|
@PostMapping("completeDeployment")
|
|
public JsonResult<?> completeDeployment(@RequestBody Map<String,Object> request) {
|
|
// 调用服务层方法，执行完成投放操作
|
|
return ebikeBikeInfoService.completeDeployment(request);
|
|
}
|
|
/**
|
|
* 获取工单列表
|
|
*
|
|
* @param request 获取工单列表请求参数，如分页信息、筛选条件等
|
|
* @return 返回工单列表数据
|
|
*/
|
|
@PostMapping("getWorkOrderList")
|
|
public JsonResult<?> getWorkOrderList(@RequestBody Map<String, Object> request) {
|
|
// 调用服务层方法，获取工单列表数据
|
|
return ebikeBikeInfoService.getWorkOrderList(request);
|
|
}
|
|
|
|
/**
|
|
*根据regin_id 获取车辆详情和EcuId
|
|
* @param regionId
|
|
* @return
|
|
*/
|
|
@GetMapping("getVehicleDetailsByRegionId")
|
|
public JsonResult<?> getVehicleDetailsByRegionId(@RequestParam(name = "regionId") String regionId) {
|
|
// 调用服务层方法，获取工单列表数据
|
|
return ebikeBikeInfoService.getVehicleDetailsByRegionId(regionId);
|
|
}
|
|
}
|