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 { @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; @Autowired @Lazy private IdentityService sysIdentityService; /*---------------------------------主表处理-begin-------------------------------------*/ /** * 分页列表查询 * @param repairOrder * @param pageNo * @param pageSize * @param req * @return */ //@AutoLog(value = "维修工单-分页列表查询") @ApiOperation(value="维修工单-分页列表查询", notes="维修工单-分页列表查询") @GetMapping(value = "/list") public Result> queryPageList(RepairOrder repairOrder, @RequestParam(name="pageNo", defaultValue="1") Integer pageNo, @RequestParam(name="pageSize", defaultValue="10") Integer pageSize, HttpServletRequest req) { Page page = new Page(pageNo, pageSize); IPage 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 wrapper = new QueryWrapper<>(); wrapper.eq("repair_order_id", id) .eq("del_flag", 0); wrapper.select("sum(actual_hour) as actualHour"); Map 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 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 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 edit(@RequestBody RepairOrder repairOrder) { repairOrderService.updateById(repairOrder); //删除原故障信息 List 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 editReport(@RequestBody RepairOrder repairOrder) { repairOrderService.updateById(repairOrder); repairOrderDetailService.remove(new QueryWrapper().eq("repair_order_id",repairOrder.getId())); repairOrderActualMaterialService.remove(new QueryWrapper().eq("repair_order_id",repairOrder.getId())); repairOrderActualWorkHoursService.remove(new QueryWrapper().eq("repair_order_id",repairOrder.getId())); repairOrderFaultAnalysisService.remove(new QueryWrapper().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 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().set("is_create_order",0).eq("id",projectMaintenanceOrderDetailId)); }else if("1".equals(businessType)){ String reportRepairId = repairOrder.getReportRepairId(); equipmentReportRepairService.update(new UpdateWrapper().set("is_create_order",0).eq("id",reportRepairId)); } repairOrderService.update(new UpdateWrapper().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 deleteBatch(@RequestParam(name="ids",required=true) String ids) { this.repairOrderService.update(new UpdateWrapper().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> listRepairOrderDetailByMainId(RepairOrderDetail repairOrderDetail, @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo, @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize, HttpServletRequest req) { repairOrderDetail.setDelFlag(0); QueryWrapper queryWrapper = QueryGenerator.initQueryWrapper(repairOrderDetail, req.getParameterMap()); Page page = new Page(pageNo, pageSize); IPage pageList = repairOrderDetailService.page(page, queryWrapper); return Result.OK(pageList); } @GetMapping(value = "/pageRepairOrderDetailByMainId") public Result> pageRepairOrderDetailByMainId(@RequestParam("pageNo") Integer pageNo, @RequestParam("pageSize") Integer pageSize, @RequestParam Map params) { IPage pageList = repairOrderDetailService.pageRepairOrderDetailByMainId(pageNo, pageSize, params); return Result.OK(pageList); } /** * 添加 * @param repairOrderDetail * @return */ @AutoLog(value = "维修内容-添加") @ApiOperation(value="维修内容-添加", notes="维修内容-添加") @PostMapping(value = "/addRepairOrderDetail") public Result 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 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 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 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 queryWrapper = QueryGenerator.initQueryWrapper(repairOrderDetail, request.getParameterMap()); LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal(); // Step.2 获取导出数据 List pageList = repairOrderDetailService.list(queryWrapper); List exportList = null; // 过滤选中数据 String selections = request.getParameter("selections"); if (oConvertUtils.isNotEmpty(selections)) { List 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 fileMap = multipartRequest.getFileMap(); for (Map.Entry entity : fileMap.entrySet()) { // 获取上传文件对象 MultipartFile file = entity.getValue(); ImportParams params = new ImportParams(); params.setTitleRows(2); params.setHeadRows(1); params.setNeedSave(true); try { List 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> listRepairOrderRiskPreventionByMainId(RepairOrderRiskPrevention repairOrderRiskPrevention, @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo, @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize, HttpServletRequest req) { QueryWrapper queryWrapper = QueryGenerator.initQueryWrapper(repairOrderRiskPrevention, req.getParameterMap()); Page page = new Page(pageNo, pageSize); IPage pageList = repairOrderRiskPreventionService.selectByMainId(page, repairOrderRiskPrevention); return Result.OK(pageList); } /** * 添加 * @param repairOrderRiskPrevention * @return */ @AutoLog(value = "危险防控-添加") @ApiOperation(value="危险防控-添加", notes="危险防控-添加") @PostMapping(value = "/addRepairOrderRiskPrevention") public Result 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 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 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 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 queryWrapper = QueryGenerator.initQueryWrapper(repairOrderRiskPrevention, request.getParameterMap()); LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal(); // Step.2 获取导出数据 List pageList = repairOrderRiskPreventionService.list(queryWrapper); List exportList = null; // 过滤选中数据 String selections = request.getParameter("selections"); if (oConvertUtils.isNotEmpty(selections)) { List 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 fileMap = multipartRequest.getFileMap(); for (Map.Entry entity : fileMap.entrySet()) { // 获取上传文件对象 MultipartFile file = entity.getValue(); ImportParams params = new ImportParams(); params.setTitleRows(2); params.setHeadRows(1); params.setNeedSave(true); try { List 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> listRepairOrderFaultAnalysisByMainId(RepairOrderFaultAnalysis repairOrderFaultAnalysis, @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo, @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize, HttpServletRequest req) { QueryWrapper queryWrapper = QueryGenerator.initQueryWrapper(repairOrderFaultAnalysis, req.getParameterMap()); Page page = new Page(pageNo, pageSize); IPage 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 params) { IPage> 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 params) { IPage> 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 faultAnalysisInfo) { List> faultAnalysisMapList = (List>) faultAnalysisInfo.get("faultAnalysisList"); String repairOrderId = (String) faultAnalysisInfo.get("repairOrderId"); List faultAnalysisList = new ArrayList<>(); if(faultAnalysisMapList.size()==0){ repairOrderFaultAnalysisService.remove(new QueryWrapper().eq("repair_order_id",repairOrderId)); } for(Map 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 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 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 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 queryWrapper = QueryGenerator.initQueryWrapper(repairOrderFaultAnalysis, request.getParameterMap()); LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal(); // Step.2 获取导出数据 List pageList = repairOrderFaultAnalysisService.list(queryWrapper); List exportList = null; // 过滤选中数据 String selections = request.getParameter("selections"); if (oConvertUtils.isNotEmpty(selections)) { List 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 fileMap = multipartRequest.getFileMap(); for (Map.Entry entity : fileMap.entrySet()) { // 获取上传文件对象 MultipartFile file = entity.getValue(); ImportParams params = new ImportParams(); params.setTitleRows(2); params.setHeadRows(1); params.setNeedSave(true); try { List 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> listRepairOrderPlanMaterialByMainId(RepairOrderPlanMaterial repairOrderPlanMaterial, @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo, @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize, HttpServletRequest req) { QueryWrapper queryWrapper = QueryGenerator.initQueryWrapper(repairOrderPlanMaterial, req.getParameterMap()); Page page = new Page(pageNo, pageSize); IPage pageList = repairOrderPlanMaterialService.selectByMainId(page, repairOrderPlanMaterial); return Result.OK(pageList); } /** * 添加 * @param repairOrderPlanMaterial * @return */ @AutoLog(value = "计划用料-添加") @ApiOperation(value="计划用料-添加", notes="计划用料-添加") @PostMapping(value = "/addRepairOrderPlanMaterial") public Result 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 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 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 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 queryWrapper = QueryGenerator.initQueryWrapper(repairOrderPlanMaterial, request.getParameterMap()); LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal(); // Step.2 获取导出数据 List pageList = repairOrderPlanMaterialService.list(queryWrapper); List exportList = null; // 过滤选中数据 String selections = request.getParameter("selections"); if (oConvertUtils.isNotEmpty(selections)) { List 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 fileMap = multipartRequest.getFileMap(); for (Map.Entry entity : fileMap.entrySet()) { // 获取上传文件对象 MultipartFile file = entity.getValue(); ImportParams params = new ImportParams(); params.setTitleRows(2); params.setHeadRows(1); params.setNeedSave(true); try { List 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> listRepairOrderActualMaterialByMainId(RepairOrderActualMaterial repairOrderActualMaterial, @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo, @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize, HttpServletRequest req) { QueryWrapper queryWrapper = QueryGenerator.initQueryWrapper(repairOrderActualMaterial, req.getParameterMap()); Page page = new Page(pageNo, pageSize); IPage 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 actualMaterialInfo) { List> actualMaterialMapList = (List>) actualMaterialInfo.get("actualMaterialList"); String repairOrderId = (String) actualMaterialInfo.get("repairOrderId"); List actualMaterialList = new ArrayList<>(); if(actualMaterialMapList.size()==0){ repairOrderActualMaterialService.remove(new QueryWrapper().eq("repair_order_id",repairOrderId)); } for(Map 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 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 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 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 queryWrapper = QueryGenerator.initQueryWrapper(repairOrderActualMaterial, request.getParameterMap()); LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal(); // Step.2 获取导出数据 List pageList = repairOrderActualMaterialService.list(queryWrapper); List exportList = null; // 过滤选中数据 String selections = request.getParameter("selections"); if (oConvertUtils.isNotEmpty(selections)) { List 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 fileMap = multipartRequest.getFileMap(); for (Map.Entry entity : fileMap.entrySet()) { // 获取上传文件对象 MultipartFile file = entity.getValue(); ImportParams params = new ImportParams(); params.setTitleRows(2); params.setHeadRows(1); params.setNeedSave(true); try { List 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> listRepairOrderActualWorkHoursByMainId(RepairOrderActualWorkHours repairOrderActualWorkHours, @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo, @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize, HttpServletRequest req) { QueryWrapper queryWrapper = QueryGenerator.initQueryWrapper(repairOrderActualWorkHours, req.getParameterMap()); Page page = new Page(pageNo, pageSize); IPage 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 actualHourInfo) { List> actualHourMapList = (List>) actualHourInfo.get("actualHourList"); String repairOrderId = (String) actualHourInfo.get("repairOrderId"); List actualWorkHoursList = new ArrayList<>(); if(actualHourMapList.size()==0){ repairOrderActualWorkHoursService.remove(new QueryWrapper().eq("repair_order_id",repairOrderId)); } for(Map 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 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 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 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 queryWrapper = QueryGenerator.initQueryWrapper(repairOrderActualWorkHours, request.getParameterMap()); LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal(); // Step.2 获取导出数据 List pageList = repairOrderActualWorkHoursService.list(queryWrapper); List exportList = null; // 过滤选中数据 String selections = request.getParameter("selections"); if (oConvertUtils.isNotEmpty(selections)) { List 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 fileMap = multipartRequest.getFileMap(); for (Map.Entry entity : fileMap.entrySet()) { // 获取上传文件对象 MultipartFile file = entity.getValue(); ImportParams params = new ImportParams(); params.setTitleRows(2); params.setHeadRows(1); params.setNeedSave(true); try { List 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> listEquipmentDocumentByMainId(RepairOrderOperationGuidance repairOrderOperationGuidance, @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo, @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize, HttpServletRequest req) { QueryWrapper queryWrapper = QueryGenerator.initQueryWrapper(repairOrderOperationGuidance, req.getParameterMap()); Page page = new Page(pageNo, pageSize); IPage pageList = repairOrderOperationGuidanceService.page(page, queryWrapper); return Result.OK(pageList); } /** * 添加 * @param repairOrderOperationGuidance * @return */ @AutoLog(value = "作业指导书-添加") @ApiOperation(value="作业指导书-添加", notes="作业指导书-添加") @PostMapping(value = "/addEquipmentDocument") public Result 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 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 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 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 queryWrapper = QueryGenerator.initQueryWrapper(equipmentDocument, request.getParameterMap()); LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal(); // Step.2 获取导出数据 List pageList = equipmentDocumentService.list(queryWrapper); List exportList = null; // 过滤选中数据 String selections = request.getParameter("selections"); if (oConvertUtils.isNotEmpty(selections)) { List 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 fileMap = multipartRequest.getFileMap(); for (Map.Entry entity : fileMap.entrySet()) { // 获取上传文件对象 MultipartFile file = entity.getValue(); ImportParams params = new ImportParams(); params.setTitleRows(2); params.setHeadRows(1); params.setNeedSave(true); try { List 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() .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().set("status",2).eq("id",repairOrder.getReportRepairId())); } return Result.OK(repairOrderService.update(new UpdateWrapper().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().set("status",1).eq("id",repairOrder.getReportRepairId())); } return Result.OK(repairOrderService.update(new UpdateWrapper().set("status",0).eq("id",repairOrder.getId()))); } /** * 工单派工 * @param repairOrderList * @return */ @Transactional(rollbackFor = { Exception.class }) @PutMapping(value = "/orderAssign") public Result orderAssign(@RequestBody List repairOrderList) { for (RepairOrder repairOrder : repairOrderList) { if(StringUtils.isNotBlank(repairOrder.getReportRepairId())){ equipmentReportRepairService.update(new UpdateWrapper().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().set("status",2).set("responsibility_id",user.getId()).eq("id",repairOrder.getId()))); } /** * 工单开工 * @param repairOrder * @return */ @PutMapping(value = "/start") @Transactional(rollbackFor = Exception.class) public Result orderStart(@RequestBody RepairOrder repairOrder){ if(StringUtils.isNotBlank(repairOrder.getReportRepairId())){ EquipmentReportRepair equipmentReportRepair = equipmentReportRepairService.getById(repairOrder.getReportRepairId()); equipmentReportRepair.setStatus("3"); equipmentReportRepairService.updateById(equipmentReportRepair); if(StringUtils.isNotBlank(equipmentReportRepair.getEquipmentId())){ Equipment equipment = equipmentService.getById(equipmentReportRepair.getEquipmentId()); equipment.setEquipmentStatus("7"); equipmentService.updateById(equipment); } } 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().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 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().eq("id",repairOrder.getReportRepairId()).set("status",3)); } return Result.OK(repairOrderService.update(new UpdateWrapper().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().eq("id",repairOrder.getReportRepairId()).set("status",2)); } return Result.OK(repairOrderService.update(new UpdateWrapper().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().eq("id",repairOrder.getReportRepairId()).set("status",4)); } return Result.OK(repairOrderService.update(new UpdateWrapper().set("status",7).eq("id",repairOrder.getId()))); } @PostMapping("addBySelectReport") public Result addBySelectReport(@RequestBody List equipmentReportRepairs){ LoginUser user= (LoginUser)SecurityUtils.getSubject().getPrincipal(); for(EquipmentReportRepair equipmentReportRepair:equipmentReportRepairs){ String num = sysIdentityService.getNumByTypeAndLength("RepairOrder",4); Equipment equipment = equipmentService.getById(equipmentReportRepair.getEquipmentId()); equipmentReportRepair.setStatus("2"); RepairOrder repairOrder = new RepairOrder(); repairOrder.setNum(num); repairOrder.setReportRepairId(equipmentReportRepair.getId()); repairOrder.setStatus("2"); repairOrder.setEquipmentId(equipment.getId()); repairOrder.setTeamId(equipment.getTeamId()); repairOrder.setDepartId(equipment.getUseId()); repairOrder.setFaultDescription(equipmentReportRepair.getFaultDescription()); repairOrder.setFaultTime(equipmentReportRepair.getFaultTime()); repairOrder.setResponsibilityId(user.getId()); repairOrder.setRepairOrderType(0); repairOrder.setDelFlag(0); repairOrderService.save(repairOrder); } equipmentReportRepairService.updateBatchById(equipmentReportRepairs); return Result.OK("领取成功"); } }