package org.jeecg.modules.eam.controller;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.github.xiaoymin.knife4j.core.util.CollectionUtils;
|
import io.swagger.annotations.Api;
|
import io.swagger.annotations.ApiOperation;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.ibatis.annotations.Param;
|
import org.apache.shiro.SecurityUtils;
|
import org.jeecg.common.api.vo.Result;
|
import org.jeecg.common.aspect.annotation.AutoLog;
|
import org.jeecg.common.constant.CommonConstant;
|
import org.jeecg.common.system.api.ISysBaseAPI;
|
import org.jeecg.common.system.base.entity.SysUpload;
|
import org.jeecg.common.system.base.entity.SysUploadRela;
|
import org.jeecg.common.system.query.QueryGenerator;
|
import org.jeecg.common.system.util.JwtUtil;
|
import org.jeecg.common.system.vo.LoginUser;
|
import org.jeecg.common.util.oConvertUtils;
|
import org.jeecg.modules.eam.entity.CalibrationOrder;
|
import org.jeecg.modules.eam.entity.CalibrationOrderDetail;
|
import org.jeecg.modules.eam.entity.CalibrationOrderReport;
|
import org.jeecg.modules.eam.entity.Equipment;
|
import org.jeecg.modules.eam.service.ICalibrationOrderDetailService;
|
import org.jeecg.modules.eam.service.ICalibrationOrderReportService;
|
import org.jeecg.modules.eam.service.ICalibrationOrderService;
|
import org.jeecg.modules.eam.service.IEamEquipmentService;
|
import org.jeecg.modules.eam.vo.CalibrationOrderPage;
|
import org.jeecgframework.poi.excel.ExcelImportUtil;
|
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
|
import org.jeecgframework.poi.excel.entity.ExportParams;
|
import org.jeecgframework.poi.excel.entity.ImportParams;
|
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.bind.annotation.*;
|
import org.springframework.web.multipart.MultipartFile;
|
import org.springframework.web.multipart.MultipartHttpServletRequest;
|
import org.springframework.web.servlet.ModelAndView;
|
|
import javax.servlet.http.HttpServletRequest;
|
import javax.servlet.http.HttpServletResponse;
|
import java.io.IOException;
|
import java.util.*;
|
import java.util.concurrent.atomic.AtomicReference;
|
import java.util.stream.Collectors;
|
|
/**
|
* @Description: 检定工单
|
* @Author: jeecg-boot
|
* @Date: 2023-04-23
|
* @Version: V1.0
|
*/
|
@Api(tags = "检定工单")
|
@RestController
|
@RequestMapping("/eam/calibrationOrder")
|
@Slf4j
|
public class CalibrationOrderController {
|
@Autowired
|
private ICalibrationOrderService calibrationOrderService;
|
@Autowired
|
private ICalibrationOrderDetailService calibrationOrderDetailService;
|
|
@Autowired
|
private ICalibrationOrderReportService calibrationOrderReportService;
|
@Autowired
|
private IEamEquipmentService equipmentService;
|
// @Autowired
|
// private IUploadRelaService uploadRelaService;
|
// @Autowired
|
// private IUploadService uploadService;
|
|
private ISysBaseAPI sysBaseApi;
|
/**
|
* 分页列表查询
|
*
|
* @param calibrationOrder
|
* @param pageNo
|
* @param pageSize
|
* @param req
|
* @return
|
*/
|
//@AutoLog(value = "检定工单-分页列表查询")
|
@ApiOperation(value = "检定工单-分页列表查询", notes = "检定工单-分页列表查询")
|
@GetMapping(value = "/list")
|
public Result<IPage<CalibrationOrder>> queryPageList(CalibrationOrder calibrationOrder,
|
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
|
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
|
HttpServletRequest req) {
|
LambdaQueryWrapper<CalibrationOrder> wrapper = new LambdaQueryWrapper<>();
|
if (calibrationOrder != null) {
|
// 工单号
|
if (calibrationOrder.getNum() != null) {
|
wrapper.like(CalibrationOrder::getNum, calibrationOrder.getNum());
|
}
|
// 设备id
|
if (calibrationOrder.getEquipmentId() != null) {
|
wrapper.eq(CalibrationOrder::getEquipmentId, calibrationOrder.getEquipmentId());
|
}
|
// 创建人
|
if (calibrationOrder.getCreateBy() != null) {
|
wrapper.like(CalibrationOrder::getCreateBy, calibrationOrder.getCreateBy());
|
}
|
// 创建开始时间-结束时间
|
if (calibrationOrder.getCreateStartDate() != null && calibrationOrder.getCreateEndDate() != null) {
|
wrapper.ge(CalibrationOrder::getCreateTime, calibrationOrder.getCreateStartDate());
|
wrapper.le(CalibrationOrder::getCreateTime, calibrationOrder.getCreateEndDate());
|
}
|
// 下发开始日期-结束时间
|
if (calibrationOrder.getIssueStartDate() != null && calibrationOrder.getIssueEndDate() != null) {
|
wrapper.ge(CalibrationOrder::getIssueTime, calibrationOrder.getIssueStartDate());
|
wrapper.le(CalibrationOrder::getIssueTime, calibrationOrder.getIssueEndDate());
|
}
|
|
}
|
Page<CalibrationOrder> page = new Page<>(pageNo, pageSize);
|
IPage<CalibrationOrder> pageList = calibrationOrderService.page(page, wrapper);
|
List<CalibrationOrder> records = pageList.getRecords();
|
if (CollectionUtils.isNotEmpty(records)) {
|
Set<String> equipmentIds = records.stream().map(CalibrationOrder::getEquipmentId).collect(Collectors.toSet());
|
List<Equipment> equipmentList = equipmentService.listByIds(equipmentIds);
|
records.forEach(re -> {
|
if (CollectionUtils.isNotEmpty(equipmentList) && re.getEquipmentId() != null) {
|
equipmentList.forEach(ea -> {
|
if (re.getEquipmentId().equals(ea.getId())) {
|
// 设备名称
|
re.setNumName(ea.getName());
|
// 设备型号
|
re.setNumModel(ea.getModel());
|
// 设备编码
|
re.setNumCode(ea.getNum());
|
// 设备规格
|
re.setSpecification(ea.getSpecification());
|
}
|
});
|
}
|
});
|
}
|
return Result.OK(pageList);
|
}
|
|
/**
|
* 添加
|
*
|
* @param calibrationOrder
|
* @return
|
*/
|
@AutoLog(value = "检定工单-添加")
|
@ApiOperation(value = "检定工单-添加", notes = "检定工单-添加")
|
@PostMapping(value = "/add")
|
public Result<String> add(@RequestBody CalibrationOrder calibrationOrder) {
|
calibrationOrderService.save(calibrationOrder);
|
if (CollectionUtils.isNotEmpty(calibrationOrder.getCalibrationOrderDetailList())) {
|
List<CalibrationOrderDetail> calibrationOrderDetailList = calibrationOrder.getCalibrationOrderDetailList();
|
calibrationOrderDetailList.forEach(cod -> {
|
cod.setId(null);
|
cod.setCalibrationOrderId(calibrationOrder.getId());
|
});
|
calibrationOrderDetailService.saveBatch(calibrationOrderDetailList);
|
}
|
return Result.OK("添加成功！");
|
}
|
|
/**
|
* 编辑
|
*
|
* @param calibrationOrder
|
* @return
|
*/
|
@AutoLog(value = "检定工单-编辑")
|
@ApiOperation(value = "检定工单-编辑", notes = "检定工单-编辑")
|
// @RequiresPermissions("org.jeecg.modules:mom_eam_calibration_order:edit")
|
@RequestMapping(value = "/edit", method = {RequestMethod.PUT, RequestMethod.POST})
|
public Result<String> edit(@RequestBody CalibrationOrder calibrationOrder) {
|
calibrationOrderService.updateById(calibrationOrder);
|
return Result.OK("编辑成功!");
|
}
|
|
/**
|
* 通过id删除
|
*
|
* @param id
|
* @return
|
*/
|
@AutoLog(value = "检定工单-通过id删除")
|
@ApiOperation(value = "检定工单-通过id删除", notes = "检定工单-通过id删除")
|
@DeleteMapping(value = "/delete")
|
public Result<String> delete(@RequestParam(name = "id", required = true) String id) {
|
CalibrationOrder calibrationOrder = calibrationOrderService.getById(id);
|
calibrationOrder.setDelFlag(CommonConstant.DEL_FLAG_1);
|
calibrationOrderService.updateById(calibrationOrder);
|
calibrationOrderDetailService.delCalibrationOrderDetailByCalibrationOrderId(id);
|
return Result.OK("删除成功!");
|
}
|
|
/**
|
* 批量删除
|
*
|
* @param ids
|
* @return
|
*/
|
@AutoLog(value = "检定工单-批量删除")
|
@ApiOperation(value = "检定工单-批量删除", notes = "检定工单-批量删除")
|
//@RequiresPermissions("org.jeecg.modules:mom_eam_calibration_order:deleteBatch")
|
@DeleteMapping(value = "/deleteBatch")
|
public Result<String> deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
|
this.calibrationOrderService.delBatchMain(Arrays.asList(ids.split(",")));
|
return Result.OK("批量删除成功！");
|
}
|
|
/**
|
* 通过id查询
|
*
|
* @param id
|
* @return
|
*/
|
//@AutoLog(value = "检定工单-通过id查询")
|
@ApiOperation(value = "检定工单-通过id查询", notes = "检定工单-通过id查询")
|
@GetMapping(value = "/queryById")
|
public Result<CalibrationOrder> queryById(@RequestParam(name = "id", required = true) String id) {
|
CalibrationOrder calibrationOrder = calibrationOrderService.getById(id);
|
if (calibrationOrder == null) {
|
return Result.error("未找到对应数据");
|
}
|
return Result.OK(calibrationOrder);
|
|
}
|
|
/**
|
* 检定工单-提交
|
*
|
* @param id
|
* @return
|
*/
|
@ApiOperation(value = "检定工单-提交", notes = "检定工单-提交")
|
@GetMapping(value = "/submit")
|
// @RequiresPermissions("org.jeecg.modules:mom_eam_calibration_order:submit")
|
public Result<String> submit(@RequestParam(name = "id", required = true) String id, HttpServletRequest request) {
|
CalibrationOrder calibrationOrder = calibrationOrderService.getById(id);
|
if (calibrationOrder == null) {
|
return Result.error("未找到对应数据");
|
}
|
AtomicReference<String> judgmentResult = new AtomicReference<>("pass");
|
// 数据判定依据
|
if (calibrationOrder.getManagementMode().equals("data")) {
|
List<CalibrationOrderDetail> calibrationOrderDetails = calibrationOrderDetailService.selectByMainId(id);
|
AtomicReference<Boolean> decide = new AtomicReference<>(false);
|
calibrationOrderDetails.forEach(cod -> {
|
if (cod.getActualValue().isEmpty() || cod.getJudgmentResult().isEmpty()) {
|
decide.set(true);
|
} else {
|
if (cod.getJudgmentResult().equals("fail")) {
|
judgmentResult.set(cod.getJudgmentResult());
|
}
|
}
|
});
|
if (decide.get()) {
|
return Result.error("实际测定值不能为空");
|
}
|
} else if (calibrationOrder.getManagementMode().equals("report")) {
|
List<SysUploadRela> uploadRelaList = sysBaseApi.listByBusIdAndBusType(id, "calibration_order_photo");
|
if (CollectionUtils.isEmpty(uploadRelaList)) {
|
return Result.error("检定附件报告不能为空");
|
} else {
|
for (SysUploadRela uploadRela : uploadRelaList) {
|
SysUpload sysUpload = sysBaseApi.getUploadById(uploadRela.getUploadId());
|
if (sysUpload.getDescription().equals("fail")) {
|
judgmentResult.set(sysUpload.getDescription());
|
}
|
uploadRela.setUpload(sysUpload);
|
}
|
}
|
}
|
// 判定结果保存
|
calibrationOrder.setCalibrationResult(judgmentResult.get());
|
// 保存检定人检定时间
|
String username = JwtUtil.getUserNameByToken(request);
|
calibrationOrder.setCalibrationUserId(username);
|
calibrationOrderService.updateById(calibrationOrder);
|
return Result.OK("提交成功");
|
|
}
|
|
/**
|
* 检定单撤回
|
*
|
* @param id
|
* @return
|
*/
|
@AutoLog(value = "检定单撤回")
|
@ApiOperation(value = "检定单撤回", notes = "检定单撤回")
|
@GetMapping(value = "/withdraw")
|
public Result<String> withdraw(@RequestParam(name = "id", required = true) String id) {
|
|
List<SysUploadRela> sysUploadRelaList = sysBaseApi.listByBusIdAndBusType(id, "calibration_order_photo");
|
if (CollectionUtils.isNotEmpty(sysUploadRelaList)) {
|
return Result.error("撤回失败，检定附件报告已添加!");
|
}
|
CalibrationOrder calibrationOrder = new CalibrationOrder();
|
calibrationOrder.setId(id);
|
calibrationOrder.setStatus("2");
|
calibrationOrderService.updateById(calibrationOrder);
|
return Result.OK("撤回成功!");
|
}
|
|
/**
|
* 通过id查询
|
*
|
* @param id
|
* @return
|
*/
|
//@AutoLog(value = "检定工单明细通过主表ID查询")
|
@ApiOperation(value = "检定工单明细主表ID查询", notes = "检定工单明细-通主表ID查询")
|
@GetMapping(value = "/queryCalibrationOrderDetailByMainId")
|
public Result<List<CalibrationOrderDetail>> queryCalibrationOrderDetailListByMainId(@RequestParam(name = "id", required = true) String id) {
|
List<CalibrationOrderDetail> calibrationOrderDetailList = calibrationOrderDetailService.selectByMainId(id);
|
return Result.OK(calibrationOrderDetailList);
|
}
|
|
/**
|
* 检定附件报告建立关系
|
*
|
* @param sysUploadList
|
* @return
|
*/
|
@AutoLog(value = "检定附件报告建立关系")
|
@ApiOperation(value = "检定附件报告建立关系", notes = "检定附件报告建立关系")
|
@PostMapping(value = "/addAttachmentRelation")
|
public Result<String> addAttachmentRelation(@RequestBody List<SysUpload> sysUploadList) {
|
// 附件上传列表是否为空
|
if (sysUploadList != null) {
|
if (CollectionUtils.isNotEmpty(sysUploadList)) {
|
List<SysUploadRela> sysUploadRelaList = new ArrayList<>();
|
sysUploadList.forEach(sul -> {
|
SysUploadRela sysUploadRela = new SysUploadRela();
|
sysUploadRela.setBusId(sul.getBusinessAssociationId());
|
sysUploadRela.setBusType("calibration_order_photo");
|
sysUploadRela.setUploadId(sul.getId());
|
sysUploadRelaList.add(sysUploadRela);
|
});
|
// 上传文件与业务数据关系
|
sysBaseApi.saveOrUpdateBatchUploadRela(sysUploadRelaList);
|
// 保存判定结果
|
sysBaseApi.updateBatchUploadById(sysUploadList);
|
// 上传文件与业务数据关系
|
// uploadRelaService.saveBatch(sysUploadRelaList);
|
// // 保存判定结果
|
// uploadService.updateBatchById(sysUploadList);
|
}
|
}
|
return Result.OK("上传成功");
|
}
|
|
/**
|
* 导出excel
|
*
|
* @param request
|
* @param calibrationOrder
|
*/
|
//@RequiresPermissions("org.jeecg.modules:mom_eam_calibration_order:exportXls")
|
@RequestMapping(value = "/exportXls")
|
public ModelAndView exportXls(HttpServletRequest request, CalibrationOrder calibrationOrder) {
|
// Step.1 组装查询条件查询数据
|
QueryWrapper<CalibrationOrder> queryWrapper = QueryGenerator.initQueryWrapper(calibrationOrder, request.getParameterMap());
|
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
|
|
//配置选中数据查询条件
|
String selections = request.getParameter("selections");
|
if (oConvertUtils.isNotEmpty(selections)) {
|
List<String> selectionList = Arrays.asList(selections.split(","));
|
queryWrapper.in("id", selectionList);
|
}
|
//Step.2 获取导出数据
|
List<CalibrationOrder> calibrationOrderList = calibrationOrderService.list(queryWrapper);
|
|
// Step.3 组装pageList
|
List<CalibrationOrderPage> pageList = new ArrayList<CalibrationOrderPage>();
|
for (CalibrationOrder main : calibrationOrderList) {
|
CalibrationOrderPage vo = new CalibrationOrderPage();
|
BeanUtils.copyProperties(main, vo);
|
List<CalibrationOrderDetail> calibrationOrderDetailList = calibrationOrderDetailService.selectByMainId(main.getId());
|
// vo.setCalibrationOrderDetailList(calibrationOrderDetailList);
|
pageList.add(vo);
|
}
|
|
// Step.4 AutoPoi 导出Excel
|
ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
|
mv.addObject(NormalExcelConstants.FILE_NAME, "检定工单列表");
|
mv.addObject(NormalExcelConstants.CLASS, CalibrationOrderPage.class);
|
mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("检定工单数据", "导出人:" + sysUser.getRealname(), "检定工单"));
|
mv.addObject(NormalExcelConstants.DATA_LIST, pageList);
|
return mv;
|
}
|
|
/**
|
* 通过excel导入数据
|
*
|
* @param request
|
* @param response
|
* @return
|
*/
|
//@RequiresPermissions("org.jeecg.modules:mom_eam_calibration_order:importExcel")
|
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
|
public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
|
MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
|
Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
|
for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
|
// 获取上传文件对象
|
MultipartFile file = entity.getValue();
|
ImportParams params = new ImportParams();
|
params.setTitleRows(2);
|
params.setHeadRows(1);
|
params.setNeedSave(true);
|
try {
|
List<CalibrationOrderPage> list = ExcelImportUtil.importExcel(file.getInputStream(), CalibrationOrderPage.class, params);
|
for (CalibrationOrderPage page : list) {
|
CalibrationOrder po = new CalibrationOrder();
|
BeanUtils.copyProperties(page, po);
|
// calibrationOrderService.saveMain(po, page.getCalibrationOrderDetailList());
|
}
|
return Result.OK("文件导入成功！数据行数:" + list.size());
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
return Result.error("文件导入失败:" + e.getMessage());
|
} finally {
|
try {
|
file.getInputStream().close();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
}
|
}
|
return Result.OK("文件导入失败！");
|
}
|
|
// qsw 2023-7-18======================================================================================================================
|
|
/**
|
* 分页列表查询
|
*
|
*/
|
@GetMapping(value = "/listNew")
|
public Result<IPage<CalibrationOrder>> queryPageListNew(CalibrationOrder calibrationOrder,
|
@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
|
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
|
HttpServletRequest req) {
|
QueryWrapper<CalibrationOrder> queryWrapper = QueryGenerator.initQueryWrapper(calibrationOrder, req.getParameterMap());
|
Page<CalibrationOrder> page = new Page<CalibrationOrder>(pageNo, pageSize);
|
IPage<CalibrationOrder> pageList = calibrationOrderService.page(page, queryWrapper);
|
for (CalibrationOrder record : pageList.getRecords()) {
|
String id = record.getId();
|
String status = record.getStatus();
|
String managementMode = record.getManagementMode();
|
String equipmentId = record.getEquipmentId();
|
Equipment equipment = equipmentService.getById(equipmentId);
|
if(equipment != null){
|
record.setEquipmentNum(equipment.getNum());
|
record.setEquipmentName(equipment.getName());
|
record.setEquipmentModel(equipment.getModel());
|
record.setEquipmentSpecification(equipment.getSpecification());
|
}
|
List<Map<String, Object>> precisionParameterList = calibrationOrderService.getPrecisionParameterList(equipmentId);
|
record.setPrecisionParameterList(precisionParameterList);
|
if("4".equals(status)){
|
if("data".equals(managementMode)){
|
List<CalibrationOrderDetail> calibrationOrderDetails = calibrationOrderDetailService.lambdaQuery()
|
.eq(CalibrationOrderDetail::getCalibrationOrderId, id)
|
.eq(CalibrationOrderDetail::getJudgmentResult, "fail")
|
.eq(CalibrationOrderDetail::getDelFlag,"0").list();
|
if(calibrationOrderDetails.size()>0){
|
record.setCalibrationResult("异常");
|
}else{
|
record.setCalibrationResult("正常");
|
}
|
}else{
|
List<CalibrationOrderReport> calibrationOrderReports = calibrationOrderReportService.lambdaQuery()
|
.eq(CalibrationOrderReport::getCalibrationOrderId, id)
|
.eq(CalibrationOrderReport::getJudgmentResult, "fail")
|
.eq(CalibrationOrderReport::getDelFlag, "0").list();
|
if(calibrationOrderReports.size()>0){
|
record.setCalibrationResult("异常");
|
}else{
|
record.setCalibrationResult("正常");
|
}
|
}
|
}
|
}
|
return Result.OK(pageList);
|
}
|
/**
|
* 编辑
|
* qsw 2023-7-18
|
*/
|
@RequestMapping(value = "/editNew", method = {RequestMethod.PUT, RequestMethod.POST})
|
public Result<String> editNew(@RequestBody CalibrationOrder calibrationOrder) {
|
calibrationOrderService.updateById(calibrationOrder);
|
List<CalibrationOrderDetail> calibrationOrderDetails = calibrationOrderDetailService.lambdaQuery().eq(CalibrationOrderDetail::getCalibrationOrderId, calibrationOrder.getId()).eq(CalibrationOrderDetail::getDelFlag, "0").list();
|
for (CalibrationOrderDetail calibrationOrderDetail : calibrationOrderDetails) {
|
calibrationOrderDetailService.removeById(calibrationOrderDetail);
|
}
|
List<Map<String, Object>> precisionParameterList = calibrationOrderService.getPrecisionParameterList(calibrationOrder.getEquipmentId());
|
CalibrationOrderDetail calibrationOrderDetail = null;
|
for (Map<String, Object> map : precisionParameterList) {
|
calibrationOrderDetail = new CalibrationOrderDetail();
|
calibrationOrderDetail.setCalibrationOrderId(calibrationOrder.getId());
|
calibrationOrderDetail.setEquipmentPrecisionParametersId((String)map.get("id"));
|
calibrationOrderDetail.setPrecisionParametersId((String)map.get("precisionParametersId"));
|
calibrationOrderDetailService.save(calibrationOrderDetail);
|
}
|
return Result.OK("编辑成功!");
|
}
|
|
/**
|
* 手动创建检定工单
|
* qsw 2023-7-18
|
*/
|
@PostMapping(value = "/addNew")
|
@Transactional(rollbackFor = {Exception.class})
|
public Result<String> addNew(@RequestBody CalibrationOrder calibrationOrder) {
|
calibrationOrder.setStatus("1");
|
calibrationOrderService.save(calibrationOrder);
|
List<Map<String, Object>> precisionParameterList = calibrationOrderService.getPrecisionParameterList(calibrationOrder.getEquipmentId());
|
CalibrationOrderDetail calibrationOrderDetail = null;
|
for (Map<String, Object> map : precisionParameterList) {
|
calibrationOrderDetail = new CalibrationOrderDetail();
|
calibrationOrderDetail.setCalibrationOrderId(calibrationOrder.getId());
|
calibrationOrderDetail.setEquipmentPrecisionParametersId((String)map.get("id"));
|
calibrationOrderDetail.setPrecisionParametersId((String)map.get("precisionParametersId"));
|
calibrationOrderDetailService.save(calibrationOrderDetail);
|
}
|
return Result.OK("添加成功！");
|
}
|
|
/**
|
* 设备检定工单 创建时通过设备获取设备精度参数
|
* qsw 2023-7-18
|
*/
|
@GetMapping("getPrecisionParameterList")
|
public Result<?> getPrecisionParameterList(@Param("equipmentId") String equipmentId) {
|
List<Map<String, Object>> precisionParameterList = calibrationOrderService.getPrecisionParameterList(equipmentId);
|
return Result.ok(precisionParameterList);
|
}
|
|
/**
|
*
|
*/
|
@RequestMapping(value = "/editStatus", method = {RequestMethod.PUT, RequestMethod.POST})
|
public Result<String> editStatus(@RequestBody CalibrationOrder calibrationOrder) {
|
calibrationOrder.setIssueTime(new Date());
|
boolean b = calibrationOrderService.updateById(calibrationOrder);
|
if (b) {
|
return Result.OK("下发成功!");
|
} else {
|
return Result.error("下发失败!");
|
}
|
}
|
|
@RequestMapping(value = "/report", method = {RequestMethod.PUT, RequestMethod.POST})
|
public Result<String> report(@RequestBody CalibrationOrder calibrationOrder) {
|
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
|
String userId = sysUser.getId();
|
calibrationOrder.setCalibrationUserId(userId);
|
calibrationOrder.setCalibrationTime(new Date());
|
boolean b = calibrationOrderService.updateById(calibrationOrder);
|
if (!b) {
|
return Result.error("报工失败!");
|
} else {
|
return Result.ok("报工成功!");
|
}
|
}
|
|
/**
|
* 通过id删除
|
*/
|
@DeleteMapping(value = "/deleteNew")
|
public Result<String> deleteNew(@RequestParam(name="id",required=true) String id) {
|
|
List<CalibrationOrderDetail> calibrationOrderDetails = calibrationOrderDetailService.lambdaQuery().eq(CalibrationOrderDetail::getCalibrationOrderId, id).eq(CalibrationOrderDetail::getDelFlag, "0").list();
|
for (CalibrationOrderDetail calibrationOrderDetail : calibrationOrderDetails) {
|
calibrationOrderDetailService.removeById(calibrationOrderDetail);
|
}
|
//删除文件管理与业务数据关系
|
List<CalibrationOrderReport> calibrationOrderReports = calibrationOrderReportService.lambdaQuery().eq(CalibrationOrderReport::getCalibrationOrderId, id).eq(CalibrationOrderReport::getDelFlag, "0").list();
|
for (CalibrationOrderReport calibrationOrderReport : calibrationOrderReports) {
|
String calibrationOrderReportId = calibrationOrderReport.getId();
|
List<SysUploadRela> sysUploadRelas = sysBaseApi.listByBusIdAndBusType(calibrationOrderReportId, null);
|
for (SysUploadRela sysUploadRela : sysUploadRelas) {
|
String uploadId = sysUploadRela.getUploadId();
|
sysBaseApi.removeUploadById(uploadId);
|
sysBaseApi.removeUploadRelaById(sysUploadRela.getId());
|
}
|
calibrationOrderReportService.removeById(calibrationOrderReportId);
|
}
|
calibrationOrderService.removeById(id);
|
return Result.OK("删除成功!");
|
}
|
}
|
