package org.jeecg.modules.eam.controller;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import io.swagger.annotations.Api;
|
import io.swagger.annotations.ApiOperation;
|
import lombok.extern.slf4j.Slf4j;
|
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.base.controller.JeecgController;
|
import org.jeecg.common.system.query.QueryGenerator;
|
import org.jeecg.common.system.vo.LoginUser;
|
import org.jeecg.common.util.oConvertUtils;
|
import org.jeecg.modules.eam.entity.*;
|
import org.jeecg.modules.eam.service.*;
|
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.factory.annotation.Autowired;
|
import org.springframework.context.annotation.Lazy;
|
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.math.BigDecimal;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* @Description: 维修工单
|
* @Author: jeecg-boot
|
* @Date: 2023-04-25
|
* @Version: V1.0
|
*/
|
@Api(tags="维修工单")
|
@RestController
|
@RequestMapping("/eam/repairOrder")
|
@Slf4j
|
public class RepairOrderController extends JeecgController<RepairOrder, IRepairOrderService> {
|
|
@Autowired
|
private IRepairOrderService repairOrderService;
|
|
@Autowired
|
private IRepairOrderDetailService repairOrderDetailService;
|
|
@Autowired
|
private IRepairOrderRiskPreventionService repairOrderRiskPreventionService;
|
|
@Autowired
|
private IRepairOrderFaultAnalysisService repairOrderFaultAnalysisService;
|
|
@Autowired
|
private IRepairOrderPlanMaterialService repairOrderPlanMaterialService;
|
|
@Autowired
|
private IRepairOrderActualMaterialService repairOrderActualMaterialService;
|
|
@Autowired
|
private IRepairOrderActualWorkHoursService repairOrderActualWorkHoursService;
|
|
@Autowired
|
private IEquipmentDocumentService equipmentDocumentService;
|
|
@Autowired
|
private IEamEquipmentService equipmentService;
|
|
@Autowired
|
private IEquipmentReportRepairService equipmentReportRepairService;
|
|
@Autowired
|
private IRepairOrderOperationGuidanceService repairOrderOperationGuidanceService;
|
@Autowired
|
private IFaultDescriptionService faultDescriptionService;
|
|
@Autowired
|
@Lazy
|
private IProjectMaintenanceOrderDetailService projectMaintenanceOrderDetailService;
|
|
@Autowired
|
@Lazy
|
private IProjectMaintenanceOrderService projectMaintenanceOrderService;
|
|
|
|
/*---------------------------------主表处理-begin-------------------------------------*/
|
|
/**
|
* 分页列表查询
|
* @param repairOrder
|
* @param pageNo
|
* @param pageSize
|
* @param req
|
* @return
|
*/
|
//@AutoLog(value = "维修工单-分页列表查询")
|
@ApiOperation(value="维修工单-分页列表查询", notes="维修工单-分页列表查询")
|
@GetMapping(value = "/list")
|
public Result<IPage<RepairOrder>> queryPageList(RepairOrder repairOrder,
|
@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
|
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
|
HttpServletRequest req) {
|
Page<RepairOrder> page = new Page<RepairOrder>(pageNo, pageSize);
|
IPage<RepairOrder> pageList = repairOrderService.getRepairOrderList(page, repairOrder);
|
for(RepairOrder repairOrder1 : pageList.getRecords()){
|
if(StringUtils.isNotBlank(repairOrder1.getReportRepairId())){
|
EquipmentReportRepair equipmentReportRepair = equipmentReportRepairService.getById(repairOrder1.getReportRepairId());
|
repairOrder1.setReportRepairNum(equipmentReportRepair.getNum());
|
}
|
if(StringUtils.isNotBlank(repairOrder1.getProjectMaintenanceOrderId())){
|
ProjectMaintenanceOrderDetail projectMaintenanceOrderDetail = projectMaintenanceOrderDetailService.getById(repairOrder1.getProjectMaintenanceOrderId());
|
repairOrder1.setProjectMaintenanceOrderNum(projectMaintenanceOrderDetail.getTaskNum());
|
}
|
|
String id = repairOrder1.getId();
|
QueryWrapper<RepairOrderActualWorkHours> wrapper = new QueryWrapper<>();
|
wrapper.eq("repair_order_id", id)
|
.eq("del_flag", 0);
|
wrapper.select("sum(actual_hour) as actualHour");
|
Map<String, Object> map = repairOrderActualWorkHoursService.getMap(wrapper);
|
BigDecimal actualHour = new BigDecimal(0);
|
if (map != null) {
|
actualHour = (BigDecimal) map.get("actualHour");
|
}
|
repairOrder1.setActualHour(actualHour);
|
}
|
return Result.OK(pageList);
|
}
|
|
/**
|
* 添加
|
* @param repairOrder
|
* @return
|
*/
|
@AutoLog(value = "维修工单-添加")
|
@ApiOperation(value="维修工单-添加", notes="维修工单-添加")
|
//@RequiresPermissions("org.jeecg.modules.demo:mom_eam_repair_order:add")
|
@PostMapping(value = "/add")
|
@Transactional
|
public Result<String> add(@RequestBody RepairOrder repairOrder) {
|
if(StringUtils.isNotBlank(repairOrder.getReportRepairId())){
|
EquipmentReportRepair equipmentReportRepair = equipmentReportRepairService.getById(repairOrder.getReportRepairId());
|
repairOrder.setEquipmentId(equipmentReportRepair.getEquipmentId())
|
.setFaultDescription(equipmentReportRepair.getFaultDescription())
|
.setPhoto(equipmentReportRepair.getPhoto())
|
.setFaultTime(equipmentReportRepair.getFaultTime())
|
.setIsStop(equipmentReportRepair.getIsStop());
|
}
|
repairOrder.setStatus("0").setRepairOrderType(0);
|
repairOrderService.save(repairOrder);
|
//参照故障报修
|
if(StringUtils.isNotBlank(repairOrder.getReportRepairId())){
|
EquipmentReportRepair equipmentReportRepair = equipmentReportRepairService.getById(repairOrder.getReportRepairId());
|
equipmentReportRepair.setIsCreateOrder(1);
|
equipmentReportRepairService.updateById(equipmentReportRepair);
|
}
|
//参照项目性维修
|
if(StringUtils.isNotBlank(repairOrder.getProjectMaintenanceOrderId())){
|
ProjectMaintenanceOrderDetail projectMaintenanceOrderDetail = projectMaintenanceOrderDetailService.getById(repairOrder.getProjectMaintenanceOrderId());
|
projectMaintenanceOrderDetail.setIsCreateOrder(1);
|
projectMaintenanceOrderDetailService.updateById(projectMaintenanceOrderDetail);
|
}
|
//添加故障描述信息
|
FaultDescription faultDescription = new FaultDescription();
|
faultDescription.setFaultDetails(repairOrder.getFaultDescription());
|
faultDescription.setFaultId(repairOrder.getId());
|
faultDescription.setPhoto(repairOrder.getPhoto());
|
faultDescriptionService.save(faultDescription);
|
return Result.OK("添加成功！");
|
}
|
|
|
|
|
|
/**
|
* 修后汇报工单添加
|
* @param repairOrder
|
* @return
|
*/
|
@PostMapping(value = "/addReport")
|
@Transactional
|
public Result<String> addReport(@RequestBody RepairOrder repairOrder) {
|
LoginUser user= (LoginUser)SecurityUtils.getSubject().getPrincipal();
|
if(StringUtils.isNotBlank(repairOrder.getReportRepairId())){
|
EquipmentReportRepair equipmentReportRepair = equipmentReportRepairService.getById(repairOrder.getReportRepairId());
|
repairOrder.setEquipmentId(equipmentReportRepair.getEquipmentId())
|
.setFaultDescription(equipmentReportRepair.getFaultDescription())
|
.setPhoto(equipmentReportRepair.getPhoto())
|
.setFaultTime(equipmentReportRepair.getFaultTime())
|
.setIsStop(equipmentReportRepair.getIsStop());
|
}
|
repairOrder.setStatus("0").setRepairOrderType(1).setReportUserId(user.getId()).setActualStartTime(new Date(System.currentTimeMillis()));
|
repairOrderDetailService.saveBatch(repairOrder.getOrderDetails());
|
repairOrderActualMaterialService.saveBatch(repairOrder.getActualMaterials());
|
repairOrderActualWorkHoursService.saveBatch(repairOrder.getActualHours());
|
repairOrderFaultAnalysisService.saveBatch(repairOrder.getFaultAnalysis());
|
repairOrderService.save(repairOrder);
|
return Result.OK("添加成功！");
|
}
|
/**
|
* 编辑
|
* @param repairOrder
|
* @return
|
*/
|
@AutoLog(value = "维修工单-编辑")
|
@ApiOperation(value="维修工单-编辑", notes="维修工单-编辑")
|
//@RequiresPermissions("org.jeecg.modules.demo:mom_eam_repair_order:edit")
|
@RequestMapping(value = "/edit", method = {RequestMethod.PUT,RequestMethod.POST})
|
public Result<String> edit(@RequestBody RepairOrder repairOrder) {
|
repairOrderService.updateById(repairOrder);
|
|
//删除原故障信息
|
List<FaultDescription> faultDescriptionList = faultDescriptionService.lambdaQuery().eq(FaultDescription::getFaultId,repairOrder.getId())
|
.eq(FaultDescription::getDelFlag,CommonConstant.DEL_FLAG_0).list();
|
for(FaultDescription fd : faultDescriptionList){
|
faultDescriptionService.removeById(fd);
|
}
|
|
//添加故障描述信息
|
FaultDescription faultDescription = new FaultDescription();
|
faultDescription.setFaultDetails(repairOrder.getFaultDescription());
|
faultDescription.setFaultId(repairOrder.getId());
|
faultDescription.setPhoto(repairOrder.getPhoto());
|
faultDescriptionService.save(faultDescription);
|
|
//参照故障报修
|
if(StringUtils.isNotBlank(repairOrder.getReportRepairId())){
|
EquipmentReportRepair equipmentReportRepair = equipmentReportRepairService.getById(repairOrder.getReportRepairId());
|
equipmentReportRepair.setIsCreateOrder(1);
|
equipmentReportRepairService.updateById(equipmentReportRepair);
|
}
|
//参照项目性维修
|
if(StringUtils.isNotBlank(repairOrder.getProjectMaintenanceOrderId())){
|
ProjectMaintenanceOrderDetail projectMaintenanceOrderDetail = projectMaintenanceOrderDetailService.getById(repairOrder.getProjectMaintenanceOrderId());
|
projectMaintenanceOrderDetail.setIsCreateOrder(1);
|
projectMaintenanceOrderDetailService.updateById(projectMaintenanceOrderDetail);
|
}
|
return Result.OK("编辑成功!");
|
}
|
/**
|
* 修后汇报编辑
|
* @param repairOrder
|
* @return
|
*/
|
@PutMapping("/editReport")
|
@Transactional
|
public Result<String> editReport(@RequestBody RepairOrder repairOrder) {
|
repairOrderService.updateById(repairOrder);
|
repairOrderDetailService.remove(new QueryWrapper<RepairOrderDetail>().eq("repair_order_id",repairOrder.getId()));
|
repairOrderActualMaterialService.remove(new QueryWrapper<RepairOrderActualMaterial>().eq("repair_order_id",repairOrder.getId()));
|
repairOrderActualWorkHoursService.remove(new QueryWrapper<RepairOrderActualWorkHours>().eq("repair_order_id",repairOrder.getId()));
|
repairOrderFaultAnalysisService.remove(new QueryWrapper<RepairOrderFaultAnalysis>().eq("repair_order_id",repairOrder.getId()));
|
repairOrderDetailService.saveBatch(repairOrder.getOrderDetails());
|
repairOrderActualMaterialService.saveBatch(repairOrder.getActualMaterials());
|
repairOrderActualWorkHoursService.saveBatch(repairOrder.getActualHours());
|
repairOrderFaultAnalysisService.saveBatch(repairOrder.getFaultAnalysis());
|
return Result.OK("编辑成功!");
|
}
|
/**
|
* 通过id删除
|
* @param id
|
* @return
|
*/
|
@AutoLog(value = "维修工单-通过id删除")
|
@ApiOperation(value="维修工单-通过id删除", notes="维修工单-通过id删除")
|
//@RequiresPermissions("org.jeecg.modules.demo:mom_eam_repair_order:delete")
|
@DeleteMapping(value = "/delete")
|
public Result<String> delete(@RequestParam(name="id",required=true) String id) {
|
/**
|
* 根据业务类型获取维修工单的来源 删除工单时恢复来源状态
|
* 2023-8-17
|
*/
|
RepairOrder repairOrder = repairOrderService.getById(id);
|
String businessType = repairOrder.getBusinessType();
|
if("2".equals(businessType)){//1:报修故障单 2：项目性维修
|
String projectMaintenanceOrderDetailId = repairOrder.getProjectMaintenanceOrderId();
|
projectMaintenanceOrderDetailService.update(new UpdateWrapper<ProjectMaintenanceOrderDetail>().set("is_create_order",0).eq("id",projectMaintenanceOrderDetailId));
|
}else if("1".equals(businessType)){
|
String reportRepairId = repairOrder.getReportRepairId();
|
equipmentReportRepairService.update(new UpdateWrapper<EquipmentReportRepair>().set("is_create_order",0).eq("id",reportRepairId));
|
}
|
|
repairOrderService.update(new UpdateWrapper<RepairOrder>().set("del_flag", CommonConstant.DEL_FLAG_1).eq("id",id));
|
return Result.OK("删除成功!");
|
}
|
|
/**
|
* 批量删除
|
* @param ids
|
* @return
|
*/
|
@AutoLog(value = "维修工单-批量删除")
|
@ApiOperation(value="维修工单-批量删除", notes="维修工单-批量删除")
|
//@RequiresPermissions("org.jeecg.modules.demo:mom_eam_repair_order:deleteBatch")
|
@DeleteMapping(value = "/deleteBatch")
|
public Result<String> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
|
this.repairOrderService.update(new UpdateWrapper<RepairOrder>().set("del_flag",CommonConstant.DEL_FLAG_1).in("id",Arrays.asList(ids.split(","))));
|
return Result.OK("批量删除成功!");
|
}
|
|
/**
|
* 导出
|
* @return
|
*/
|
//@RequiresPermissions("org.jeecg.modules.demo:mom_eam_repair_order:exportXls")
|
@RequestMapping(value = "/exportXls")
|
public ModelAndView exportXls(HttpServletRequest request, RepairOrder repairOrder) {
|
return super.exportXls(request, repairOrder, RepairOrder.class, "维修工单");
|
}
|
|
/**
|
* 导入
|
* @return
|
*/
|
//@RequiresPermissions("org.jeecg.modules.demo:mom_eam_repair_order:importExcel")
|
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
|
public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
|
return super.importExcel(request, response, RepairOrder.class);
|
}
|
/*---------------------------------主表处理-end-------------------------------------*/
|
|
|
/*--------------------------------子表处理-维修内容-begin----------------------------------------------*/
|
/**
|
* 通过主表ID查询
|
* @return
|
*/
|
@ApiOperation(value="维修内容-通过主表ID查询", notes="维修内容-通过主表ID查询")
|
@GetMapping(value = "/listRepairOrderDetailByMainId")
|
public Result<IPage<RepairOrderDetail>> listRepairOrderDetailByMainId(RepairOrderDetail repairOrderDetail,
|
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
|
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
|
HttpServletRequest req) {
|
repairOrderDetail.setDelFlag(0);
|
QueryWrapper<RepairOrderDetail> queryWrapper = QueryGenerator.initQueryWrapper(repairOrderDetail, req.getParameterMap());
|
Page<RepairOrderDetail> page = new Page<RepairOrderDetail>(pageNo, pageSize);
|
IPage<RepairOrderDetail> pageList = repairOrderDetailService.page(page, queryWrapper);
|
return Result.OK(pageList);
|
}
|
|
/**
|
* 添加
|
* @param repairOrderDetail
|
* @return
|
*/
|
@AutoLog(value = "维修内容-添加")
|
@ApiOperation(value="维修内容-添加", notes="维修内容-添加")
|
@PostMapping(value = "/addRepairOrderDetail")
|
public Result<String> addRepairOrderDetail(@RequestBody RepairOrderDetail repairOrderDetail) {
|
repairOrderDetailService.save(repairOrderDetail);
|
return Result.OK("添加成功！");
|
}
|
|
/**
|
* 编辑
|
* @param repairOrderDetail
|
* @return
|
*/
|
@AutoLog(value = "维修内容-编辑")
|
@ApiOperation(value="维修内容-编辑", notes="维修内容-编辑")
|
@RequestMapping(value = "/editRepairOrderDetail", method = {RequestMethod.PUT,RequestMethod.POST})
|
public Result<String> editRepairOrderDetail(@RequestBody RepairOrderDetail repairOrderDetail) {
|
repairOrderDetailService.updateById(repairOrderDetail);
|
return Result.OK("编辑成功!");
|
}
|
|
/**
|
* 通过id删除
|
* @param id
|
* @return
|
*/
|
@AutoLog(value = "维修内容-通过id删除")
|
@ApiOperation(value="维修内容-通过id删除", notes="维修内容-通过id删除")
|
@DeleteMapping(value = "/deleteRepairOrderDetail")
|
public Result<String> deleteRepairOrderDetail(@RequestParam(name="id",required=true) String id) {
|
repairOrderDetailService.removeById(id);
|
return Result.OK("删除成功!");
|
}
|
|
/**
|
* 批量删除
|
* @param ids
|
* @return
|
*/
|
@AutoLog(value = "维修内容-批量删除")
|
@ApiOperation(value="维修内容-批量删除", notes="维修内容-批量删除")
|
@DeleteMapping(value = "/deleteBatchRepairOrderDetail")
|
public Result<String> deleteBatchRepairOrderDetail(@RequestParam(name="ids",required=true) String ids) {
|
this.repairOrderDetailService.removeByIds(Arrays.asList(ids.split(",")));
|
return Result.OK("批量删除成功!");
|
}
|
|
/**
|
* 导出
|
* @return
|
*/
|
@RequestMapping(value = "/exportRepairOrderDetail")
|
public ModelAndView exportRepairOrderDetail(HttpServletRequest request, RepairOrderDetail repairOrderDetail) {
|
// Step.1 组装查询条件
|
QueryWrapper<RepairOrderDetail> queryWrapper = QueryGenerator.initQueryWrapper(repairOrderDetail, request.getParameterMap());
|
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
|
|
// Step.2 获取导出数据
|
List<RepairOrderDetail> pageList = repairOrderDetailService.list(queryWrapper);
|
List<RepairOrderDetail> exportList = null;
|
|
// 过滤选中数据
|
String selections = request.getParameter("selections");
|
if (oConvertUtils.isNotEmpty(selections)) {
|
List<String> selectionList = Arrays.asList(selections.split(","));
|
exportList = pageList.stream().filter(item -> selectionList.contains(item.getId())).collect(Collectors.toList());
|
} else {
|
exportList = pageList;
|
}
|
|
// Step.3 AutoPoi 导出Excel
|
ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
|
//此处设置的filename无效,前端会重更新设置一下
|
mv.addObject(NormalExcelConstants.FILE_NAME, "维修内容");
|
mv.addObject(NormalExcelConstants.CLASS, RepairOrderDetail.class);
|
mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("维修内容报表", "导出人:" + sysUser.getRealname(), "维修内容"));
|
mv.addObject(NormalExcelConstants.DATA_LIST, exportList);
|
return mv;
|
}
|
|
/**
|
* 导入
|
* @return
|
*/
|
@RequestMapping(value = "/importRepairOrderDetail/{mainId}")
|
public Result<?> importRepairOrderDetail(HttpServletRequest request, HttpServletResponse response, @PathVariable("mainId") String mainId) {
|
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<RepairOrderDetail> list = ExcelImportUtil.importExcel(file.getInputStream(), RepairOrderDetail.class, params);
|
for (RepairOrderDetail temp : list) {
|
temp.setRepairOrderId(mainId);
|
}
|
long start = System.currentTimeMillis();
|
repairOrderDetailService.saveBatch(list);
|
log.info("消耗时间" + (System.currentTimeMillis() - start) + "毫秒");
|
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.error("文件导入失败！");
|
}
|
|
/*--------------------------------子表处理-维修内容-end----------------------------------------------*/
|
|
/*--------------------------------子表处理-危险防控-begin----------------------------------------------*/
|
/**
|
* 通过主表ID查询
|
* @return
|
*/
|
//@AutoLog(value = "危险防控-通过主表ID查询")
|
@ApiOperation(value="危险防控-通过主表ID查询", notes="危险防控-通过主表ID查询")
|
@GetMapping(value = "/listRepairOrderRiskPreventionByMainId")
|
public Result<IPage<RepairOrderRiskPrevention>> listRepairOrderRiskPreventionByMainId(RepairOrderRiskPrevention repairOrderRiskPrevention,
|
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
|
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
|
HttpServletRequest req) {
|
QueryWrapper<RepairOrderRiskPrevention> queryWrapper = QueryGenerator.initQueryWrapper(repairOrderRiskPrevention, req.getParameterMap());
|
Page<RepairOrderRiskPrevention> page = new Page<RepairOrderRiskPrevention>(pageNo, pageSize);
|
IPage<RepairOrderRiskPrevention> pageList = repairOrderRiskPreventionService.selectByMainId(page, repairOrderRiskPrevention);
|
return Result.OK(pageList);
|
}
|
|
/**
|
* 添加
|
* @param repairOrderRiskPrevention
|
* @return
|
*/
|
@AutoLog(value = "危险防控-添加")
|
@ApiOperation(value="危险防控-添加", notes="危险防控-添加")
|
@PostMapping(value = "/addRepairOrderRiskPrevention")
|
public Result<String> addRepairOrderRiskPrevention(@RequestBody RepairOrderRiskPrevention repairOrderRiskPrevention) {
|
repairOrderRiskPreventionService.save(repairOrderRiskPrevention);
|
return Result.OK("添加成功！");
|
}
|
|
/**
|
* 编辑
|
* @param repairOrderRiskPrevention
|
* @return
|
*/
|
@AutoLog(value = "危险防控-编辑")
|
@ApiOperation(value="危险防控-编辑", notes="危险防控-编辑")
|
@RequestMapping(value = "/editRepairOrderRiskPrevention", method = {RequestMethod.PUT,RequestMethod.POST})
|
public Result<String> editRepairOrderRiskPrevention(@RequestBody RepairOrderRiskPrevention repairOrderRiskPrevention) {
|
repairOrderRiskPreventionService.updateById(repairOrderRiskPrevention);
|
return Result.OK("编辑成功!");
|
}
|
|
/**
|
* 通过id删除
|
* @param id
|
* @return
|
*/
|
@AutoLog(value = "危险防控-通过id删除")
|
@ApiOperation(value="危险防控-通过id删除", notes="危险防控-通过id删除")
|
@DeleteMapping(value = "/deleteRepairOrderRiskPrevention")
|
public Result<String> deleteRepairOrderRiskPrevention(@RequestParam(name="id",required=true) String id) {
|
repairOrderRiskPreventionService.removeById(id);
|
return Result.OK("删除成功!");
|
}
|
|
/**
|
* 批量删除
|
* @param ids
|
* @return
|
*/
|
@AutoLog(value = "危险防控-批量删除")
|
@ApiOperation(value="危险防控-批量删除", notes="危险防控-批量删除")
|
@DeleteMapping(value = "/deleteBatchRepairOrderRiskPrevention")
|
public Result<String> deleteBatchRepairOrderRiskPrevention(@RequestParam(name="ids",required=true) String ids) {
|
this.repairOrderRiskPreventionService.removeByIds(Arrays.asList(ids.split(",")));
|
return Result.OK("批量删除成功!");
|
}
|
|
/**
|
* 导出
|
* @return
|
*/
|
@RequestMapping(value = "/exportRepairOrderRiskPrevention")
|
public ModelAndView exportRepairOrderRiskPrevention(HttpServletRequest request, RepairOrderRiskPrevention repairOrderRiskPrevention) {
|
// Step.1 组装查询条件
|
QueryWrapper<RepairOrderRiskPrevention> queryWrapper = QueryGenerator.initQueryWrapper(repairOrderRiskPrevention, request.getParameterMap());
|
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
|
|
// Step.2 获取导出数据
|
List<RepairOrderRiskPrevention> pageList = repairOrderRiskPreventionService.list(queryWrapper);
|
List<RepairOrderRiskPrevention> exportList = null;
|
|
// 过滤选中数据
|
String selections = request.getParameter("selections");
|
if (oConvertUtils.isNotEmpty(selections)) {
|
List<String> selectionList = Arrays.asList(selections.split(","));
|
exportList = pageList.stream().filter(item -> selectionList.contains(item.getId())).collect(Collectors.toList());
|
} else {
|
exportList = pageList;
|
}
|
|
// Step.3 AutoPoi 导出Excel
|
ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
|
//此处设置的filename无效,前端会重更新设置一下
|
mv.addObject(NormalExcelConstants.FILE_NAME, "危险防控");
|
mv.addObject(NormalExcelConstants.CLASS, RepairOrderRiskPrevention.class);
|
mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("危险防控报表", "导出人:" + sysUser.getRealname(), "危险防控"));
|
mv.addObject(NormalExcelConstants.DATA_LIST, exportList);
|
return mv;
|
}
|
|
/**
|
* 导入
|
* @return
|
*/
|
@RequestMapping(value = "/importRepairOrderRiskPrevention/{mainId}")
|
public Result<?> importRepairOrderRiskPrevention(HttpServletRequest request, HttpServletResponse response, @PathVariable("mainId") String mainId) {
|
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<RepairOrderRiskPrevention> list = ExcelImportUtil.importExcel(file.getInputStream(), RepairOrderRiskPrevention.class, params);
|
for (RepairOrderRiskPrevention temp : list) {
|
temp.setRepairOrderId(mainId);
|
}
|
long start = System.currentTimeMillis();
|
repairOrderRiskPreventionService.saveBatch(list);
|
log.info("消耗时间" + (System.currentTimeMillis() - start) + "毫秒");
|
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.error("文件导入失败！");
|
}
|
|
/*--------------------------------子表处理-危险防控-end----------------------------------------------*/
|
|
/*--------------------------------子表处理-故障分析-begin----------------------------------------------*/
|
/**
|
* 通过主表ID查询
|
* @return
|
*/
|
//@AutoLog(value = "故障分析-通过主表ID查询")
|
@ApiOperation(value="故障分析-通过主表ID查询", notes="故障分析-通过主表ID查询")
|
@GetMapping(value = "/listRepairOrderFaultAnalysisByMainId")
|
public Result<IPage<RepairOrderFaultAnalysis>> listRepairOrderFaultAnalysisByMainId(RepairOrderFaultAnalysis repairOrderFaultAnalysis,
|
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
|
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
|
HttpServletRequest req) {
|
QueryWrapper<RepairOrderFaultAnalysis> queryWrapper = QueryGenerator.initQueryWrapper(repairOrderFaultAnalysis, req.getParameterMap());
|
Page<RepairOrderFaultAnalysis> page = new Page<RepairOrderFaultAnalysis>(pageNo, pageSize);
|
IPage<RepairOrderFaultAnalysis> pageList = repairOrderFaultAnalysisService.selectByMainId(page,repairOrderFaultAnalysis);
|
return Result.OK(pageList);
|
}
|
|
|
/**
|
* 获取人员班组信息
|
* @param pageNo
|
* @param pageSize
|
* @param params
|
* @return
|
*/
|
@GetMapping(value = "/listUserTeam")
|
public Result<?> getListUserTeam(@RequestParam("pageNo") Integer pageNo, @RequestParam("pageSize") Integer pageSize, @RequestParam Map<String, Object> params) {
|
IPage<Map<String, Object>> totalList = repairOrderService.getUserTeam(pageNo, pageSize, params);
|
|
return Result.ok(totalList);
|
}
|
|
|
|
/**
|
* 获取物料备件信息
|
* @param pageNo
|
* @param pageSize
|
* @param params
|
* @return
|
*/
|
@GetMapping(value = "/materialSpareList")
|
public Result<?> getMaterialSpareList(@RequestParam("pageNo") Integer pageNo, @RequestParam("pageSize") Integer pageSize, @RequestParam Map<String, Object> params) {
|
IPage<Map<String, Object>> totalList = repairOrderService.getMaterialSpareList(pageNo, pageSize, params);
|
return Result.ok(totalList);
|
}
|
|
|
|
/**
|
* 添加
|
* @param faultAnalysisInfo
|
* @return
|
*/
|
@AutoLog(value = "故障分析-添加")
|
@ApiOperation(value="故障分析-添加", notes="故障分析-添加")
|
@PostMapping(value = "/addRepairOrderFaultAnalysis")
|
@Transactional
|
public Result<?> addRepairOrderFaultAnalysis(@RequestBody Map<String,Object> faultAnalysisInfo) {
|
List<Map<String,Object>> faultAnalysisMapList = (List<Map<String,Object>>) faultAnalysisInfo.get("faultAnalysisList");
|
String repairOrderId = (String) faultAnalysisInfo.get("repairOrderId");
|
List<RepairOrderFaultAnalysis> faultAnalysisList = new ArrayList<>();
|
if(faultAnalysisMapList.size()==0){
|
repairOrderFaultAnalysisService.remove(new QueryWrapper<RepairOrderFaultAnalysis>().eq("repair_order_id",repairOrderId));
|
}
|
for(Map<String,Object> map : faultAnalysisMapList){
|
RepairOrderFaultAnalysis repairOrderFaultAnalysis = new RepairOrderFaultAnalysis();
|
repairOrderFaultAnalysis
|
.setId((String) map.get("id"))
|
.setFaultCause((String) map.get("faultCause"))
|
.setFaultType((String) map.get("faultType"))
|
.setSuggestion((String) map.get("suggestion"))
|
.setRepairOrderId(repairOrderId);
|
faultAnalysisList.add(repairOrderFaultAnalysis);
|
}
|
return Result.OK(repairOrderFaultAnalysisService.saveOrUpdateBatch(faultAnalysisList));
|
}
|
|
/**
|
* 编辑
|
* @param repairOrderFaultAnalysis
|
* @return
|
*/
|
@AutoLog(value = "故障分析-编辑")
|
@ApiOperation(value="故障分析-编辑", notes="故障分析-编辑")
|
@RequestMapping(value = "/editRepairOrderFaultAnalysis", method = {RequestMethod.PUT,RequestMethod.POST})
|
public Result<String> editRepairOrderFaultAnalysis(@RequestBody RepairOrderFaultAnalysis repairOrderFaultAnalysis) {
|
repairOrderFaultAnalysisService.updateById(repairOrderFaultAnalysis);
|
return Result.OK("编辑成功!");
|
}
|
|
/**
|
* 通过id删除
|
* @param id
|
* @return
|
*/
|
@AutoLog(value = "故障分析-通过id删除")
|
@ApiOperation(value="故障分析-通过id删除", notes="故障分析-通过id删除")
|
@DeleteMapping(value = "/deleteRepairOrderFaultAnalysis")
|
public Result<String> deleteRepairOrderFaultAnalysis(@RequestParam(name="id",required=true) String id) {
|
repairOrderFaultAnalysisService.removeById(id);
|
return Result.OK("删除成功!");
|
}
|
|
/**
|
* 批量删除
|
* @param ids
|
* @return
|
*/
|
@AutoLog(value = "故障分析-批量删除")
|
@ApiOperation(value="故障分析-批量删除", notes="故障分析-批量删除")
|
@DeleteMapping(value = "/deleteBatchRepairOrderFaultAnalysis")
|
public Result<String> deleteBatchRepairOrderFaultAnalysis(@RequestParam(name="ids",required=true) String ids) {
|
this.repairOrderFaultAnalysisService.removeByIds(Arrays.asList(ids.split(",")));
|
return Result.OK("批量删除成功!");
|
}
|
|
/**
|
* 导出
|
* @return
|
*/
|
@RequestMapping(value = "/exportRepairOrderFaultAnalysis")
|
public ModelAndView exportRepairOrderFaultAnalysis(HttpServletRequest request, RepairOrderFaultAnalysis repairOrderFaultAnalysis) {
|
// Step.1 组装查询条件
|
QueryWrapper<RepairOrderFaultAnalysis> queryWrapper = QueryGenerator.initQueryWrapper(repairOrderFaultAnalysis, request.getParameterMap());
|
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
|
|
// Step.2 获取导出数据
|
List<RepairOrderFaultAnalysis> pageList = repairOrderFaultAnalysisService.list(queryWrapper);
|
List<RepairOrderFaultAnalysis> exportList = null;
|
|
// 过滤选中数据
|
String selections = request.getParameter("selections");
|
if (oConvertUtils.isNotEmpty(selections)) {
|
List<String> selectionList = Arrays.asList(selections.split(","));
|
exportList = pageList.stream().filter(item -> selectionList.contains(item.getId())).collect(Collectors.toList());
|
} else {
|
exportList = pageList;
|
}
|
|
// Step.3 AutoPoi 导出Excel
|
ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
|
//此处设置的filename无效,前端会重更新设置一下
|
mv.addObject(NormalExcelConstants.FILE_NAME, "故障分析");
|
mv.addObject(NormalExcelConstants.CLASS, RepairOrderFaultAnalysis.class);
|
mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("故障分析报表", "导出人:" + sysUser.getRealname(), "故障分析"));
|
mv.addObject(NormalExcelConstants.DATA_LIST, exportList);
|
return mv;
|
}
|
|
/**
|
* 导入
|
* @return
|
*/
|
@RequestMapping(value = "/importRepairOrderFaultAnalysis/{mainId}")
|
public Result<?> importRepairOrderFaultAnalysis(HttpServletRequest request, HttpServletResponse response, @PathVariable("mainId") String mainId) {
|
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<RepairOrderFaultAnalysis> list = ExcelImportUtil.importExcel(file.getInputStream(), RepairOrderFaultAnalysis.class, params);
|
for (RepairOrderFaultAnalysis temp : list) {
|
temp.setRepairOrderId(mainId);
|
}
|
long start = System.currentTimeMillis();
|
repairOrderFaultAnalysisService.saveBatch(list);
|
log.info("消耗时间" + (System.currentTimeMillis() - start) + "毫秒");
|
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.error("文件导入失败！");
|
}
|
|
/*--------------------------------子表处理-故障分析-end----------------------------------------------*/
|
|
/*--------------------------------子表处理-计划用料-begin----------------------------------------------*/
|
/**
|
* 通过主表ID查询
|
* @return
|
*/
|
//@AutoLog(value = "计划用料-通过主表ID查询")
|
@ApiOperation(value="计划用料-通过主表ID查询", notes="计划用料-通过主表ID查询")
|
@GetMapping(value = "/listRepairOrderPlanMaterialByMainId")
|
public Result<IPage<RepairOrderPlanMaterial>> listRepairOrderPlanMaterialByMainId(RepairOrderPlanMaterial repairOrderPlanMaterial,
|
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
|
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
|
HttpServletRequest req) {
|
QueryWrapper<RepairOrderPlanMaterial> queryWrapper = QueryGenerator.initQueryWrapper(repairOrderPlanMaterial, req.getParameterMap());
|
Page<RepairOrderPlanMaterial> page = new Page<RepairOrderPlanMaterial>(pageNo, pageSize);
|
IPage<RepairOrderPlanMaterial> pageList = repairOrderPlanMaterialService.selectByMainId(page, repairOrderPlanMaterial);
|
return Result.OK(pageList);
|
}
|
|
/**
|
* 添加
|
* @param repairOrderPlanMaterial
|
* @return
|
*/
|
@AutoLog(value = "计划用料-添加")
|
@ApiOperation(value="计划用料-添加", notes="计划用料-添加")
|
@PostMapping(value = "/addRepairOrderPlanMaterial")
|
public Result<String> addRepairOrderPlanMaterial(@RequestBody RepairOrderPlanMaterial repairOrderPlanMaterial) {
|
repairOrderPlanMaterialService.save(repairOrderPlanMaterial);
|
return Result.OK("添加成功！");
|
}
|
|
/**
|
* 编辑
|
* @param repairOrderPlanMaterial
|
* @return
|
*/
|
@AutoLog(value = "计划用料-编辑")
|
@ApiOperation(value="计划用料-编辑", notes="计划用料-编辑")
|
@RequestMapping(value = "/editRepairOrderPlanMaterial", method = {RequestMethod.PUT,RequestMethod.POST})
|
public Result<String> editRepairOrderPlanMaterial(@RequestBody RepairOrderPlanMaterial repairOrderPlanMaterial) {
|
repairOrderPlanMaterialService.updateById(repairOrderPlanMaterial);
|
return Result.OK("编辑成功!");
|
}
|
|
/**
|
* 通过id删除
|
* @param id
|
* @return
|
*/
|
@AutoLog(value = "计划用料-通过id删除")
|
@ApiOperation(value="计划用料-通过id删除", notes="计划用料-通过id删除")
|
@DeleteMapping(value = "/deleteRepairOrderPlanMaterial")
|
public Result<String> deleteRepairOrderPlanMaterial(@RequestParam(name="id",required=true) String id) {
|
repairOrderPlanMaterialService.removeById(id);
|
return Result.OK("删除成功!");
|
}
|
|
/**
|
* 批量删除
|
* @param ids
|
* @return
|
*/
|
@AutoLog(value = "计划用料-批量删除")
|
@ApiOperation(value="计划用料-批量删除", notes="计划用料-批量删除")
|
@DeleteMapping(value = "/deleteBatchRepairOrderPlanMaterial")
|
public Result<String> deleteBatchRepairOrderPlanMaterial(@RequestParam(name="ids",required=true) String ids) {
|
this.repairOrderPlanMaterialService.removeByIds(Arrays.asList(ids.split(",")));
|
return Result.OK("批量删除成功!");
|
}
|
|
/**
|
* 导出
|
* @return
|
*/
|
@RequestMapping(value = "/exportRepairOrderPlanMaterial")
|
public ModelAndView exportRepairOrderPlanMaterial(HttpServletRequest request, RepairOrderPlanMaterial repairOrderPlanMaterial) {
|
// Step.1 组装查询条件
|
QueryWrapper<RepairOrderPlanMaterial> queryWrapper = QueryGenerator.initQueryWrapper(repairOrderPlanMaterial, request.getParameterMap());
|
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
|
|
// Step.2 获取导出数据
|
List<RepairOrderPlanMaterial> pageList = repairOrderPlanMaterialService.list(queryWrapper);
|
List<RepairOrderPlanMaterial> exportList = null;
|
|
// 过滤选中数据
|
String selections = request.getParameter("selections");
|
if (oConvertUtils.isNotEmpty(selections)) {
|
List<String> selectionList = Arrays.asList(selections.split(","));
|
exportList = pageList.stream().filter(item -> selectionList.contains(item.getId())).collect(Collectors.toList());
|
} else {
|
exportList = pageList;
|
}
|
|
// Step.3 AutoPoi 导出Excel
|
ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
|
//此处设置的filename无效,前端会重更新设置一下
|
mv.addObject(NormalExcelConstants.FILE_NAME, "计划用料");
|
mv.addObject(NormalExcelConstants.CLASS, RepairOrderPlanMaterial.class);
|
mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("计划用料报表", "导出人:" + sysUser.getRealname(), "计划用料"));
|
mv.addObject(NormalExcelConstants.DATA_LIST, exportList);
|
return mv;
|
}
|
|
/**
|
* 导入
|
* @return
|
*/
|
@RequestMapping(value = "/importRepairOrderPlanMaterial/{mainId}")
|
public Result<?> importRepairOrderPlanMaterial(HttpServletRequest request, HttpServletResponse response, @PathVariable("mainId") String mainId) {
|
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<RepairOrderPlanMaterial> list = ExcelImportUtil.importExcel(file.getInputStream(), RepairOrderPlanMaterial.class, params);
|
for (RepairOrderPlanMaterial temp : list) {
|
temp.setRepairOrderId(mainId);
|
}
|
long start = System.currentTimeMillis();
|
repairOrderPlanMaterialService.saveBatch(list);
|
log.info("消耗时间" + (System.currentTimeMillis() - start) + "毫秒");
|
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.error("文件导入失败！");
|
}
|
|
/*--------------------------------子表处理-计划用料-end----------------------------------------------*/
|
|
/*--------------------------------子表处理-实际用料-begin----------------------------------------------*/
|
/**
|
* 通过主表ID查询
|
* @return
|
*/
|
//@AutoLog(value = "实际用料-通过主表ID查询")
|
@ApiOperation(value="实际用料-通过主表ID查询", notes="实际用料-通过主表ID查询")
|
@GetMapping(value = "/listRepairOrderActualMaterialByMainId")
|
public Result<IPage<RepairOrderActualMaterial>> listRepairOrderActualMaterialByMainId(RepairOrderActualMaterial repairOrderActualMaterial,
|
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
|
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
|
HttpServletRequest req) {
|
QueryWrapper<RepairOrderActualMaterial> queryWrapper = QueryGenerator.initQueryWrapper(repairOrderActualMaterial, req.getParameterMap());
|
Page<RepairOrderActualMaterial> page = new Page<RepairOrderActualMaterial>(pageNo, pageSize);
|
IPage<RepairOrderActualMaterial> pageList = repairOrderActualMaterialService.selectByMainId(page,repairOrderActualMaterial);
|
return Result.OK(pageList);
|
}
|
|
/**
|
* 添加
|
* @param actualMaterialInfo
|
* @return
|
*/
|
@AutoLog(value = "实际用料-添加")
|
@ApiOperation(value="实际用料-添加", notes="实际用料-添加")
|
@PostMapping(value = "/addRepairOrderActualMaterial")
|
@Transactional
|
public Result<?> addRepairOrderActualMaterial(@RequestBody Map<String,Object> actualMaterialInfo) {
|
List<Map<String,Object>> actualMaterialMapList = (List<Map<String,Object>>) actualMaterialInfo.get("actualMaterialList");
|
String repairOrderId = (String) actualMaterialInfo.get("repairOrderId");
|
List<RepairOrderActualMaterial> actualMaterialList = new ArrayList<>();
|
if(actualMaterialMapList.size()==0){
|
repairOrderActualMaterialService.remove(new QueryWrapper<RepairOrderActualMaterial>().eq("repair_order_id",repairOrderId));
|
}
|
for(Map<String,Object> map : actualMaterialMapList){
|
RepairOrderActualMaterial repairOrderActualMaterial = new RepairOrderActualMaterial();
|
repairOrderActualMaterial
|
.setId((String) map.get("id"))
|
.setSparePartId((String) map.get("sparePartId"))
|
.setRepairOrderId((String) map.get("repairOrderId"))
|
.setActualQuantity(new BigDecimal(String.valueOf(map.get("actualQuantity"))));
|
actualMaterialList.add(repairOrderActualMaterial);
|
}
|
return Result.OK(repairOrderActualMaterialService.saveOrUpdateBatch(actualMaterialList));
|
}
|
|
/**
|
* 编辑
|
* @param repairOrderActualMaterial
|
* @return
|
*/
|
@AutoLog(value = "实际用料-编辑")
|
@ApiOperation(value="实际用料-编辑", notes="实际用料-编辑")
|
@RequestMapping(value = "/editRepairOrderActualMaterial", method = {RequestMethod.PUT,RequestMethod.POST})
|
public Result<String> editRepairOrderActualMaterial(@RequestBody RepairOrderActualMaterial repairOrderActualMaterial) {
|
repairOrderActualMaterialService.updateById(repairOrderActualMaterial);
|
return Result.OK("编辑成功!");
|
}
|
|
/**
|
* 通过id删除
|
* @param id
|
* @return
|
*/
|
@AutoLog(value = "实际用料-通过id删除")
|
@ApiOperation(value="实际用料-通过id删除", notes="实际用料-通过id删除")
|
@DeleteMapping(value = "/deleteRepairOrderActualMaterial")
|
public Result<String> deleteRepairOrderActualMaterial(@RequestParam(name="id",required=true) String id) {
|
repairOrderActualMaterialService.removeById(id);
|
return Result.OK("删除成功!");
|
}
|
|
/**
|
* 批量删除
|
* @param ids
|
* @return
|
*/
|
@AutoLog(value = "实际用料-批量删除")
|
@ApiOperation(value="实际用料-批量删除", notes="实际用料-批量删除")
|
@DeleteMapping(value = "/deleteBatchRepairOrderActualMaterial")
|
public Result<String> deleteBatchRepairOrderActualMaterial(@RequestParam(name="ids",required=true) String ids) {
|
this.repairOrderActualMaterialService.removeByIds(Arrays.asList(ids.split(",")));
|
return Result.OK("批量删除成功!");
|
}
|
|
/**
|
* 导出
|
* @return
|
*/
|
@RequestMapping(value = "/exportRepairOrderActualMaterial")
|
public ModelAndView exportRepairOrderActualMaterial(HttpServletRequest request, RepairOrderActualMaterial repairOrderActualMaterial) {
|
// Step.1 组装查询条件
|
QueryWrapper<RepairOrderActualMaterial> queryWrapper = QueryGenerator.initQueryWrapper(repairOrderActualMaterial, request.getParameterMap());
|
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
|
|
// Step.2 获取导出数据
|
List<RepairOrderActualMaterial> pageList = repairOrderActualMaterialService.list(queryWrapper);
|
List<RepairOrderActualMaterial> exportList = null;
|
|
// 过滤选中数据
|
String selections = request.getParameter("selections");
|
if (oConvertUtils.isNotEmpty(selections)) {
|
List<String> selectionList = Arrays.asList(selections.split(","));
|
exportList = pageList.stream().filter(item -> selectionList.contains(item.getId())).collect(Collectors.toList());
|
} else {
|
exportList = pageList;
|
}
|
|
// Step.3 AutoPoi 导出Excel
|
ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
|
//此处设置的filename无效,前端会重更新设置一下
|
mv.addObject(NormalExcelConstants.FILE_NAME, "实际用料");
|
mv.addObject(NormalExcelConstants.CLASS, RepairOrderActualMaterial.class);
|
mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("实际用料报表", "导出人:" + sysUser.getRealname(), "实际用料"));
|
mv.addObject(NormalExcelConstants.DATA_LIST, exportList);
|
return mv;
|
}
|
|
/**
|
* 导入
|
* @return
|
*/
|
@RequestMapping(value = "/importRepairOrderActualMaterial/{mainId}")
|
public Result<?> importRepairOrderActualMaterial(HttpServletRequest request, HttpServletResponse response, @PathVariable("mainId") String mainId) {
|
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<RepairOrderActualMaterial> list = ExcelImportUtil.importExcel(file.getInputStream(), RepairOrderActualMaterial.class, params);
|
for (RepairOrderActualMaterial temp : list) {
|
temp.setRepairOrderId(mainId);
|
}
|
long start = System.currentTimeMillis();
|
repairOrderActualMaterialService.saveBatch(list);
|
log.info("消耗时间" + (System.currentTimeMillis() - start) + "毫秒");
|
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.error("文件导入失败！");
|
}
|
|
/*--------------------------------子表处理-实际用料-end----------------------------------------------*/
|
|
/*--------------------------------子表处理-实际工时-begin----------------------------------------------*/
|
/**
|
* 通过主表ID查询
|
* @return
|
*/
|
//@AutoLog(value = "实际工时-通过主表ID查询")
|
@ApiOperation(value="实际工时-通过主表ID查询", notes="实际工时-通过主表ID查询")
|
@GetMapping(value = "/listRepairOrderActualWorkHoursByMainId")
|
public Result<IPage<RepairOrderActualWorkHours>> listRepairOrderActualWorkHoursByMainId(RepairOrderActualWorkHours repairOrderActualWorkHours,
|
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
|
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
|
HttpServletRequest req) {
|
QueryWrapper<RepairOrderActualWorkHours> queryWrapper = QueryGenerator.initQueryWrapper(repairOrderActualWorkHours, req.getParameterMap());
|
Page<RepairOrderActualWorkHours> page = new Page<RepairOrderActualWorkHours>(pageNo, pageSize);
|
IPage<RepairOrderActualWorkHours> pageList = repairOrderActualWorkHoursService.selectByMainId(page, repairOrderActualWorkHours);
|
return Result.OK(pageList);
|
}
|
|
/**
|
* 添加
|
* @param actualHourInfo
|
* @return
|
*/
|
@AutoLog(value = "实际工时-添加")
|
@ApiOperation(value="实际工时-添加", notes="实际工时-添加")
|
@PostMapping(value = "/addRepairOrderActualWorkHours")
|
public Result<?> addRepairOrderActualWorkHours(@RequestBody Map<String,Object> actualHourInfo) {
|
List<Map<String,Object>> actualHourMapList = (List<Map<String,Object>>) actualHourInfo.get("actualHourList");
|
String repairOrderId = (String) actualHourInfo.get("repairOrderId");
|
List<RepairOrderActualWorkHours> actualWorkHoursList = new ArrayList<>();
|
if(actualHourMapList.size()==0){
|
repairOrderActualWorkHoursService.remove(new QueryWrapper<RepairOrderActualWorkHours>().eq("repair_order_id",repairOrderId));
|
}
|
for(Map<String,Object> map : actualHourMapList){
|
RepairOrderActualWorkHours repairOrderActualWorkHours = new RepairOrderActualWorkHours();
|
repairOrderActualWorkHours
|
.setId((String) map.get("id"))
|
.setUserId((String) map.get("userId"))
|
.setRepairOrderId((String) map.get("repairOrderId"))
|
.setActualHour(new BigDecimal(String.valueOf(map.get("actualHour"))));
|
actualWorkHoursList.add(repairOrderActualWorkHours);
|
}
|
return Result.OK(repairOrderActualWorkHoursService.saveOrUpdateBatch(actualWorkHoursList));
|
}
|
|
/**
|
* 编辑
|
* @param repairOrderActualWorkHours
|
* @return
|
*/
|
@AutoLog(value = "实际工时-编辑")
|
@ApiOperation(value="实际工时-编辑", notes="实际工时-编辑")
|
@RequestMapping(value = "/editRepairOrderActualWorkHours", method = {RequestMethod.PUT,RequestMethod.POST})
|
public Result<String> editRepairOrderActualWorkHours(@RequestBody RepairOrderActualWorkHours repairOrderActualWorkHours) {
|
repairOrderActualWorkHoursService.updateById(repairOrderActualWorkHours);
|
return Result.OK("编辑成功!");
|
}
|
|
/**
|
* 通过id删除
|
* @param id
|
* @return
|
*/
|
@AutoLog(value = "实际工时-通过id删除")
|
@ApiOperation(value="实际工时-通过id删除", notes="实际工时-通过id删除")
|
@DeleteMapping(value = "/deleteRepairOrderActualWorkHours")
|
public Result<String> deleteRepairOrderActualWorkHours(@RequestParam(name="id",required=true) String id) {
|
repairOrderActualWorkHoursService.removeById(id);
|
return Result.OK("删除成功!");
|
}
|
|
/**
|
* 批量删除
|
* @param ids
|
* @return
|
*/
|
@AutoLog(value = "实际工时-批量删除")
|
@ApiOperation(value="实际工时-批量删除", notes="实际工时-批量删除")
|
@DeleteMapping(value = "/deleteBatchRepairOrderActualWorkHours")
|
public Result<String> deleteBatchRepairOrderActualWorkHours(@RequestParam(name="ids",required=true) String ids) {
|
this.repairOrderActualWorkHoursService.removeByIds(Arrays.asList(ids.split(",")));
|
return Result.OK("批量删除成功!");
|
}
|
|
/**
|
* 导出
|
* @return
|
*/
|
@RequestMapping(value = "/exportRepairOrderActualWorkHours")
|
public ModelAndView exportRepairOrderActualWorkHours(HttpServletRequest request, RepairOrderActualWorkHours repairOrderActualWorkHours) {
|
// Step.1 组装查询条件
|
QueryWrapper<RepairOrderActualWorkHours> queryWrapper = QueryGenerator.initQueryWrapper(repairOrderActualWorkHours, request.getParameterMap());
|
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
|
|
// Step.2 获取导出数据
|
List<RepairOrderActualWorkHours> pageList = repairOrderActualWorkHoursService.list(queryWrapper);
|
List<RepairOrderActualWorkHours> exportList = null;
|
|
// 过滤选中数据
|
String selections = request.getParameter("selections");
|
if (oConvertUtils.isNotEmpty(selections)) {
|
List<String> selectionList = Arrays.asList(selections.split(","));
|
exportList = pageList.stream().filter(item -> selectionList.contains(item.getId())).collect(Collectors.toList());
|
} else {
|
exportList = pageList;
|
}
|
|
// Step.3 AutoPoi 导出Excel
|
ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
|
//此处设置的filename无效,前端会重更新设置一下
|
mv.addObject(NormalExcelConstants.FILE_NAME, "实际工时");
|
mv.addObject(NormalExcelConstants.CLASS, RepairOrderActualWorkHours.class);
|
mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("实际工时报表", "导出人:" + sysUser.getRealname(), "实际工时"));
|
mv.addObject(NormalExcelConstants.DATA_LIST, exportList);
|
return mv;
|
}
|
|
/**
|
* 导入
|
* @return
|
*/
|
@RequestMapping(value = "/importRepairOrderActualWorkHours/{mainId}")
|
public Result<?> importRepairOrderActualWorkHours(HttpServletRequest request, HttpServletResponse response, @PathVariable("mainId") String mainId) {
|
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<RepairOrderActualWorkHours> list = ExcelImportUtil.importExcel(file.getInputStream(), RepairOrderActualWorkHours.class, params);
|
for (RepairOrderActualWorkHours temp : list) {
|
temp.setRepairOrderId(mainId);
|
}
|
long start = System.currentTimeMillis();
|
repairOrderActualWorkHoursService.saveBatch(list);
|
log.info("消耗时间" + (System.currentTimeMillis() - start) + "毫秒");
|
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.error("文件导入失败！");
|
}
|
|
/*--------------------------------子表处理-实际工时-end----------------------------------------------*/
|
|
/*--------------------------------子表处理-作业指导书-begin----------------------------------------------*/
|
/**
|
* 通过主表ID查询
|
* @return
|
*/
|
//@AutoLog(value = "作业指导书-通过主表ID查询")
|
@ApiOperation(value="作业指导书-通过主表ID查询", notes="作业指导书-通过主表ID查询")
|
@GetMapping(value = "/listEquipmentDocumentByMainId")
|
public Result<IPage<RepairOrderOperationGuidance>> listEquipmentDocumentByMainId(RepairOrderOperationGuidance repairOrderOperationGuidance,
|
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
|
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
|
HttpServletRequest req) {
|
QueryWrapper<RepairOrderOperationGuidance> queryWrapper = QueryGenerator.initQueryWrapper(repairOrderOperationGuidance, req.getParameterMap());
|
Page<RepairOrderOperationGuidance> page = new Page<RepairOrderOperationGuidance>(pageNo, pageSize);
|
IPage<RepairOrderOperationGuidance> pageList = repairOrderOperationGuidanceService.page(page, queryWrapper);
|
return Result.OK(pageList);
|
}
|
|
/**
|
* 添加
|
* @param repairOrderOperationGuidance
|
* @return
|
*/
|
@AutoLog(value = "作业指导书-添加")
|
@ApiOperation(value="作业指导书-添加", notes="作业指导书-添加")
|
@PostMapping(value = "/addEquipmentDocument")
|
public Result<String> addEquipmentDocument(@RequestBody RepairOrderOperationGuidance repairOrderOperationGuidance) {
|
repairOrderOperationGuidanceService.save(repairOrderOperationGuidance);
|
return Result.OK("添加成功！");
|
}
|
|
/**
|
* 编辑
|
* @param repairOrderOperationGuidance
|
* @return
|
*/
|
@AutoLog(value = "作业指导书-编辑")
|
@ApiOperation(value="作业指导书-编辑", notes="作业指导书-编辑")
|
@RequestMapping(value = "/editEquipmentDocument", method = {RequestMethod.PUT,RequestMethod.POST})
|
public Result<String> editEquipmentDocument(@RequestBody RepairOrderOperationGuidance repairOrderOperationGuidance) {
|
repairOrderOperationGuidanceService.updateById(repairOrderOperationGuidance);
|
return Result.OK("编辑成功!");
|
}
|
|
/**
|
* 通过id删除
|
* @param id
|
* @return
|
*/
|
@AutoLog(value = "作业指导书-通过id删除")
|
@ApiOperation(value="作业指导书-通过id删除", notes="作业指导书-通过id删除")
|
@DeleteMapping(value = "/deleteEquipmentDocument")
|
public Result<String> deleteEquipmentDocument(@RequestParam(name="id",required=true) String id) {
|
repairOrderOperationGuidanceService.removeById(id);
|
return Result.OK("删除成功!");
|
}
|
|
/**
|
* 批量删除
|
* @param ids
|
* @return
|
*/
|
@AutoLog(value = "作业指导书-批量删除")
|
@ApiOperation(value="作业指导书-批量删除", notes="作业指导书-批量删除")
|
@DeleteMapping(value = "/deleteBatchEquipmentDocument")
|
public Result<String> deleteBatchEquipmentDocument(@RequestParam(name="ids",required=true) String ids) {
|
repairOrderOperationGuidanceService.removeByIds(Arrays.asList(ids.split(",")));
|
return Result.OK("批量删除成功!");
|
}
|
|
/**
|
* 导出
|
* @return
|
*/
|
@RequestMapping(value = "/exportEquipmentDocument")
|
public ModelAndView exportEquipmentDocument(HttpServletRequest request, EquipmentDocument equipmentDocument) {
|
// Step.1 组装查询条件
|
QueryWrapper<EquipmentDocument> queryWrapper = QueryGenerator.initQueryWrapper(equipmentDocument, request.getParameterMap());
|
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
|
|
// Step.2 获取导出数据
|
List<EquipmentDocument> pageList = equipmentDocumentService.list(queryWrapper);
|
List<EquipmentDocument> exportList = null;
|
|
// 过滤选中数据
|
String selections = request.getParameter("selections");
|
if (oConvertUtils.isNotEmpty(selections)) {
|
List<String> selectionList = Arrays.asList(selections.split(","));
|
exportList = pageList.stream().filter(item -> selectionList.contains(item.getId())).collect(Collectors.toList());
|
} else {
|
exportList = pageList;
|
}
|
|
// Step.3 AutoPoi 导出Excel
|
ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
|
//此处设置的filename无效,前端会重更新设置一下
|
mv.addObject(NormalExcelConstants.FILE_NAME, "作业指导书");
|
mv.addObject(NormalExcelConstants.CLASS, EquipmentDocument.class);
|
mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("作业指导书报表", "导出人:" + sysUser.getRealname(), "作业指导书"));
|
mv.addObject(NormalExcelConstants.DATA_LIST, exportList);
|
return mv;
|
}
|
|
/**
|
* 导入
|
* @return
|
*/
|
@RequestMapping(value = "/importEquipmentDocument/{mainId}")
|
public Result<?> importEquipmentDocument(HttpServletRequest request, HttpServletResponse response, @PathVariable("mainId") String mainId) {
|
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<EquipmentDocument> list = ExcelImportUtil.importExcel(file.getInputStream(), EquipmentDocument.class, params);
|
for (EquipmentDocument temp : list) {
|
temp.setEquipmentId(mainId);
|
}
|
long start = System.currentTimeMillis();
|
equipmentDocumentService.saveBatch(list);
|
log.info("消耗时间" + (System.currentTimeMillis() - start) + "毫秒");
|
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.error("文件导入失败！");
|
}
|
|
/*--------------------------------子表处理-作业指导书-end----------------------------------------------*/
|
/*--------------------------------获取选择器的值----------------------------------------------*/
|
|
/**
|
* 获取设备列表
|
* @return
|
*/
|
@GetMapping(value = "/getEquipments")
|
public Result<?> getEquipments(){
|
return Result.OK(equipmentService.list(new QueryWrapper<Equipment>()
|
.eq("del_flag",0)
|
.eq("status",1)));
|
}
|
/*--------------------------------工单操作----------------------------------------------*/
|
/**
|
* 工单下发
|
* @param repairOrder
|
* @return
|
*/
|
@PutMapping(value = "/distribute")
|
public Result<?> orderDistribute(@RequestBody RepairOrder repairOrder){
|
if(StringUtils.isNotBlank(repairOrder.getReportRepairId())){
|
equipmentReportRepairService.update(new UpdateWrapper<EquipmentReportRepair>().set("status",2).eq("id",repairOrder.getReportRepairId()));
|
}
|
return Result.OK(repairOrderService.update(new UpdateWrapper<RepairOrder>().set("status",1).eq("id",repairOrder.getId())));
|
}
|
/**
|
* 工单撤回
|
* @param repairOrder
|
* @return
|
*/
|
@PutMapping(value = "/withdraw")
|
public Result<?> orderWithdraw(@RequestBody RepairOrder repairOrder){
|
if(StringUtils.isNotBlank(repairOrder.getReportRepairId())){
|
equipmentReportRepairService.update(new UpdateWrapper<EquipmentReportRepair>().set("status",1).eq("id",repairOrder.getReportRepairId()));
|
}
|
return Result.OK(repairOrderService.update(new UpdateWrapper<RepairOrder>().set("status",0).eq("id",repairOrder.getId())));
|
}
|
/**
|
* 工单派工
|
* @param repairOrderList
|
* @return
|
*/
|
@Transactional(rollbackFor = { Exception.class })
|
@PutMapping(value = "/orderAssign")
|
public Result<String> orderAssign(@RequestBody List<RepairOrder> repairOrderList) {
|
for (RepairOrder repairOrder : repairOrderList) {
|
if(StringUtils.isNotBlank(repairOrder.getReportRepairId())){
|
equipmentReportRepairService.update(new UpdateWrapper<EquipmentReportRepair>().eq("id",repairOrder.getReportRepairId()).set("status",2));
|
}
|
repairOrder.setStatus("2");
|
boolean b = repairOrderService.updateById(repairOrder);
|
if(!b){
|
return Result.error("工单指派失败!");
|
}
|
}
|
return Result.OK("工单指派成功!");
|
}
|
/**
|
* 工单领取
|
* @param repairOrder
|
* @return
|
*/
|
@PutMapping(value = "/receive")
|
public Result<?> orderReceive(@RequestBody RepairOrder repairOrder){
|
LoginUser user= (LoginUser)SecurityUtils.getSubject().getPrincipal();
|
return Result.OK(repairOrderService.update(new UpdateWrapper<RepairOrder>().set("status",2).set("responsibility_id",user.getId()).eq("id",repairOrder.getId())));
|
}
|
/**
|
* 工单开工
|
* @param repairOrder
|
* @return
|
*/
|
@PutMapping(value = "/start")
|
public Result<?> orderStart(@RequestBody RepairOrder repairOrder){
|
if(StringUtils.isNotBlank(repairOrder.getProjectMaintenanceOrderId())){
|
//判断项目性维修子表状态
|
ProjectMaintenanceOrderDetail projectMaintenanceOrderDetail = projectMaintenanceOrderDetailService.getById(repairOrder.getProjectMaintenanceOrderId());
|
projectMaintenanceOrderDetail.setTypeStatus("underExecution");
|
projectMaintenanceOrderDetail.setActualStartTime(new Date());
|
projectMaintenanceOrderDetailService.updateById(projectMaintenanceOrderDetail);
|
//判断项目性维修主表状态
|
ProjectMaintenanceOrder projectMaintenanceOrder = projectMaintenanceOrderService.getById(projectMaintenanceOrderDetail.getProjectMaintenanceOrderId());
|
/**
|
* 项目项维修主表维护首次开始时间，
|
* 逻辑：如果是null，明细生成的维修工单开工时，维护实际开始时间，
|
*/
|
Date actualStartTime = projectMaintenanceOrder.getActualStartTime();
|
if(actualStartTime == null){
|
projectMaintenanceOrder.setActualStartTime(new Date());
|
}
|
projectMaintenanceOrder.setTypeStatus("underExecution");
|
projectMaintenanceOrderService.updateById(projectMaintenanceOrder);
|
}
|
return Result.OK(repairOrderService.update(new UpdateWrapper<RepairOrder>().set("status",3).set("actual_start_time",new Date(System.currentTimeMillis())).eq("id",repairOrder.getId())));
|
}
|
/**
|
* 工单报工
|
* @param repairOrder
|
* @return
|
*/
|
@PutMapping(value = "/report")
|
public Result<?> orderReport(@RequestBody RepairOrder repairOrder){
|
if(StringUtils.isNotBlank(repairOrder.getProjectMaintenanceOrderId())){
|
//判断项目性维修子表状态
|
ProjectMaintenanceOrderDetail projectMaintenanceOrderDetail = projectMaintenanceOrderDetailService.getById(repairOrder.getProjectMaintenanceOrderId());
|
projectMaintenanceOrderDetail.setTypeStatus("completed");
|
projectMaintenanceOrderDetail.setActualEndTime(new Date());
|
projectMaintenanceOrderDetailService.updateById(projectMaintenanceOrderDetail);
|
//判断项目性维修主表状态
|
List<ProjectMaintenanceOrderDetail> projectMaintenanceOrderDetailList = projectMaintenanceOrderDetailService.lambdaQuery()
|
.eq(ProjectMaintenanceOrderDetail::getProjectMaintenanceOrderId,projectMaintenanceOrderDetail.getProjectMaintenanceOrderId())
|
.eq(ProjectMaintenanceOrderDetail::getDelFlag,CommonConstant.DEL_FLAG_0)
|
.list();
|
ProjectMaintenanceOrder projectMaintenanceOrder = projectMaintenanceOrderService.getById(projectMaintenanceOrderDetail.getProjectMaintenanceOrderId());
|
boolean flag = true;
|
for(ProjectMaintenanceOrderDetail projectMaintenanceOrderDetail1 : projectMaintenanceOrderDetailList){
|
if("completed".equals(projectMaintenanceOrderDetail1.getTypeStatus())){
|
continue;
|
}else {
|
flag = false;
|
}
|
}
|
if(flag){
|
projectMaintenanceOrder.setActualEndTime(new Date());
|
projectMaintenanceOrder.setTypeStatus("completed");
|
}else {
|
projectMaintenanceOrder.setTypeStatus("underExecution");
|
}
|
projectMaintenanceOrderService.updateById(projectMaintenanceOrder);
|
}
|
LoginUser user= (LoginUser)SecurityUtils.getSubject().getPrincipal();
|
if(StringUtils.isNotBlank(repairOrder.getReportRepairId())){
|
equipmentReportRepairService.update(new UpdateWrapper<EquipmentReportRepair>().eq("id",repairOrder.getReportRepairId()).set("status",3));
|
}
|
return Result.OK(repairOrderService.update(new UpdateWrapper<RepairOrder>().set("status",4).set("actual_end_time",new Date(System.currentTimeMillis())).set("recipient_user_id",user.getId()).eq("id",repairOrder.getId())));
|
}
|
/**
|
* 工单撤销
|
* @param repairOrder
|
* @return
|
*/
|
@PutMapping(value = "/revoke")
|
public Result<?> orderRevoke(@RequestBody RepairOrder repairOrder){
|
if(StringUtils.isNotBlank(repairOrder.getReportRepairId())){
|
equipmentReportRepairService.update(new UpdateWrapper<EquipmentReportRepair>().eq("id",repairOrder.getReportRepairId()).set("status",2));
|
}
|
return Result.OK(repairOrderService.update(new UpdateWrapper<RepairOrder>().set("status",3).set("actual_end_time",null)));
|
}
|
/**
|
* 工单确认
|
* @param repairOrder
|
* @return
|
*/
|
@PutMapping(value = "/confirm")
|
public Result<?> orderConfirm(@RequestBody RepairOrder repairOrder){
|
if(StringUtils.isNotBlank(repairOrder.getReportRepairId())){
|
equipmentReportRepairService.update(new UpdateWrapper<EquipmentReportRepair>().eq("id",repairOrder.getReportRepairId()).set("status",4));
|
}
|
return Result.OK(repairOrderService.update(new UpdateWrapper<RepairOrder>().set("status",7).eq("id",repairOrder.getId())));
|
}
|
|
}
|
