package org.jeecg.modules.eam.controller; import com.alibaba.fastjson.JSONObject; 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.ObjectUtils; 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.DateUtils; import org.jeecg.common.util.oConvertUtils; import org.jeecg.modules.eam.entity.*; import org.jeecg.modules.eam.mapper.RepairOrderMapper; import org.jeecg.modules.eam.service.*; import org.jeecg.modules.eam.vo.EquipmentAvailabilityVo; import org.jeecg.modules.eam.vo.RepairReportExportVo; import org.jeecg.modules.system.entity.SysUser; import org.jeecg.modules.system.mapper.SysUserMapper; 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.beans.factory.annotation.Value; 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.text.ParseException; import java.text.SimpleDateFormat; 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; @Autowired private RepairOrderMapper repairOrderMapper; @Autowired private SysUserMapper sysUserMapper; @Value("${jeecg.path.upload}") private String upLoadPath; /*---------------------------------主表处理-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); List records = pageList.getRecords(); for (RepairOrder record : records) { record.setFaultCauseCount("故障原因统计"); List> allFaultCause = repairOrderService.getAllFaultCause(); record.setAllFaultCause(allFaultCause); String equipmentId = record.getEquipmentId(); List> faultCause = repairOrderService.getFaultCause(equipmentId); record.setEquipmentFaultCause(faultCause); } // 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("批量删除成功!"); } @RequestMapping(value = "/exportXls") public ModelAndView exportXls(HttpServletRequest request, RepairOrder repairOrder) { // Step.1 组装查询条件 String title = "维修履历"; LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal(); // Step.2 获取导出数据 if(StringUtils.isNotBlank(repairOrder.getUserId())){ SysUser user = sysUserMapper.selectById(repairOrder.getUserId()); repairOrder.setTeamId(user.getTeamId()); }else{ repairOrder.setTeamId(""); } List equipNums = new ArrayList<>(); if(StringUtils.isNotBlank(repairOrder.getNums())){ equipNums = Arrays.asList(repairOrder.getNums().trim().split("\n")).stream().filter(num->!num.equals("\n")).collect(Collectors.toList()); } List exportList = repairOrderMapper.getRepairOrderList(null,repairOrder.getId(), repairOrder.getNum(), repairOrder.getEquipmentNum(), repairOrder.getEquipmentName(), repairOrder.getStatus(), repairOrder.getRepairOrderType(), repairOrder.getEquipmentCategoryId(), repairOrder.getFactoryModelId(), repairOrder.getSpecificEquipment(), repairOrder.getTeamId(), equipNums, repairOrder.getRepairOrderUda1(), repairOrder.getFaultStartTime(), repairOrder.getFaultEndTime(), repairOrder.getCreateStartTime(), repairOrder.getCreateEndTime(), repairOrder.getEquipmentImportanceId(), repairOrder.getFaultCause(), null ); // Step.3 AutoPoi 导出Excel ModelAndView mv = new ModelAndView(new JeecgEntityExcelView()); //此处设置的filename无效 ,前端会重更新设置一下 mv.addObject(NormalExcelConstants.FILE_NAME, title); mv.addObject(NormalExcelConstants.CLASS, RepairOrder.class); //update-begin--Author:liusq Date:20210126 for：图片导出报错，ImageBasePath未设置-------------------- ExportParams exportParams=new ExportParams(title + "报表", "导出人:" + sysUser.getRealname(), title); exportParams.setImageBasePath(upLoadPath); //update-end--Author:liusq Date:20210126 for：图片导出报错，ImageBasePath未设置---------------------- mv.addObject(NormalExcelConstants.PARAMS,exportParams); mv.addObject(NormalExcelConstants.DATA_LIST, exportList); return mv; } /** * 导入 * @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("2"); 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); } repairOrder .setStatus("3") .setActualStartTime(new Date()) .setRepairOrderUda1("normal"); repairOrderService.updateById(repairOrder); return Result.OK("开工成功"); } /** * 工单报工 * @param repairOrder * @return */ @PutMapping(value = "/report") @Transactional(rollbackFor = {Exception.class}) public Result orderReport(@RequestBody RepairOrder repairOrder){ String id = repairOrder.getId(); List hoursList = repairOrderActualWorkHoursService.list(new QueryWrapper().eq("repair_order_id",id).eq("del_flag",0)); List mainStuff = repairOrderActualWorkHoursService.list(new QueryWrapper().eq("repair_order_id",id).eq("del_flag",0).eq("principal_contractor","1")); if(hoursList.size()<2){ return Result.error("操作失败，请至少添加两个承修人，并且设置一个主承修人"); } if(mainStuff.size()!=1){ return Result.error("操作失败，请设置主承修人，有且只有一个"); } 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",4)); } Date now = new Date(); Date start = repairOrder.getActualStartTime(); long timeDifference = now.getTime() - start.getTime(); BigDecimal hours = new BigDecimal(timeDifference) .divide(new BigDecimal(60 * 60 * 1000), 3, BigDecimal.ROUND_HALF_EVEN); repairOrder.setStatus("4"); repairOrder.setActualEndTime(now); repairOrder.setActualHour(hours); repairOrder.setRecipientUserId(mainStuff.get(0).getUserId()); repairOrderService.updateById(repairOrder); if(StringUtils.isNotBlank(repairOrder.getEquipmentId())){ Equipment equipment = equipmentService.getById(repairOrder.getEquipmentId()); equipment.setEquipmentStatus("4"); equipmentService.updateById(equipment); } return Result.OK("报工成功"); } /** * 工单撤销 * @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("领取成功"); } /** * 工单等备件 * @param repairOrder * @return */ @PutMapping(value = "/handleSpare") @Transactional(rollbackFor = {Exception.class}) public Result handleSpare(@RequestBody RepairOrder repairOrder){ repairOrder.setRepairOrderUda2(new Date()); repairOrder.setRepairOrderUda1("needSpare"); repairOrderService.updateById(repairOrder); if(StringUtils.isNotBlank(repairOrder.getEquipmentId())){ Equipment equipment = equipmentService.getById(repairOrder.getEquipmentId()); equipment.setEquipmentStatus("8"); equipmentService.updateById(equipment); } return Result.OK("操作成功"); } /** * 工单停止等备件 * @param repairOrder * @return */ @PutMapping(value = "/handleSpareStop") @Transactional(rollbackFor = {Exception.class}) public Result handleSpareStop(@RequestBody RepairOrder repairOrder){ Date now = new Date(); Date start = repairOrder.getRepairOrderUda2(); long timeDifference = now.getTime() - start.getTime(); BigDecimal hours = new BigDecimal(timeDifference) .divide(new BigDecimal(60 * 60 * 1000), 3, BigDecimal.ROUND_HALF_EVEN); repairOrder.setRepairOrderUda3(now); repairOrder.setRepairOrderUda1("normal"); repairOrder.setSpareTime(hours); repairOrderService.updateById(repairOrder); if(StringUtils.isNotBlank(repairOrder.getEquipmentId())){ Equipment equipment = equipmentService.getById(repairOrder.getEquipmentId()); equipment.setEquipmentStatus("7"); equipmentService.updateById(equipment); } return Result.OK("操作成功"); } /** * 工单等加工件 * @param repairOrder * @return */ @PutMapping(value = "/handlePart") @Transactional(rollbackFor = {Exception.class}) public Result handlePart(@RequestBody RepairOrder repairOrder){ repairOrder.setRepairOrderUda4(new Date()); repairOrder.setRepairOrderUda1("needPart"); repairOrderService.updateById(repairOrder); if(StringUtils.isNotBlank(repairOrder.getEquipmentId())){ Equipment equipment = equipmentService.getById(repairOrder.getEquipmentId()); equipment.setEquipmentStatus("9"); equipmentService.updateById(equipment); } return Result.OK("操作成功"); } /** * 工单停止等加工件 * @param repairOrder * @return */ @PutMapping(value = "/handlePartStop") @Transactional(rollbackFor = {Exception.class}) public Result handlePartStop(@RequestBody RepairOrder repairOrder){ Date now = new Date(); Date start = repairOrder.getRepairOrderUda4(); long timeDifference = now.getTime() - start.getTime(); BigDecimal hours = new BigDecimal(timeDifference) .divide(new BigDecimal(60 * 60 * 1000), 3, BigDecimal.ROUND_HALF_EVEN); repairOrder.setRepairOrderUda5(now); repairOrder.setRepairOrderUda1("normal"); repairOrder.setPartTime(hours); repairOrderService.updateById(repairOrder); if(StringUtils.isNotBlank(repairOrder.getEquipmentId())){ Equipment equipment = equipmentService.getById(repairOrder.getEquipmentId()); equipment.setEquipmentStatus("7"); equipmentService.updateById(equipment); } return Result.OK("操作成功"); } /** * 设备完好率 * * @return */ @GetMapping("/equipmentAvailability") public JSONObject equipmentAvailability(@RequestParam Map query) throws ParseException { List list = repairOrderService.equipmentAvailability(query); JSONObject jsonObject = new JSONObject(); jsonObject.put("data",list); return jsonObject; } /** * 设备可开动率 * * @return */ @GetMapping("/getStartRate") public JSONObject getStartRate(@RequestParam Map query) throws ParseException { List list = repairOrderService.getStartRate(query); JSONObject jsonObject = new JSONObject(); jsonObject.put("data",list); return jsonObject; } /** * 设备维修柱状图 * qsw 2024-7-11 */ @GetMapping("getFaultCausePie") public Result getFaultCausePie(@RequestParam Map params) { List> faultCausePie = repairOrderService.getFaultCausePie(params); return Result.ok(faultCausePie); } /** * 设备维修扇形图 * qsw 2024-7-11 */ @GetMapping("getFaultCauseBar") public Result getFaultCauseBar(@RequestParam Map params) { List> faultCauseBar = repairOrderService.getFaultCauseBar(params); return Result.ok(faultCauseBar); } /** * 设备故障折现图 * qsw 2024-7-24 */ @GetMapping("getEquipmentFaultCause") public Result getEquipmentFaultCause(@RequestParam Map params) { String faultStartTime = (String)params.get("faultStartTime"); if(StringUtils.isBlank(faultStartTime)){ Date dayAfter = DateUtils.getDayAfter(new Date(),15); params.put("faultStartTime",DateUtils.date2Str(DateUtils.getDayAfter(new Date(),-15),new SimpleDateFormat("yyyy-MM-dd hh:MM:ss"))); params.put("faultEndTime", DateUtils.getCurrentDateStr()+" 23:59:59"); } List> equipmentFaultCause = repairOrderService.getEquipmentFaultCause(params); return Result.ok(equipmentFaultCause); } /** * MTPF * qsw 2024-7-11 */ @GetMapping("getMTPF") public Result getMTPF(@RequestParam("pageNo") Integer pageNo, @RequestParam("pageSize") Integer pageSize, @RequestParam Map params) { IPage> mtpf = repairOrderService.getMTPF(pageNo, pageSize, params); return Result.ok(mtpf); } }