package org.jeecg.modules.eam.service.impl; import cn.hutool.core.collection.CollectionUtil; import cn.hutool.core.util.StrUtil; import com.alibaba.fastjson.JSON; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.baomidou.mybatisplus.core.metadata.IPage; import com.baomidou.mybatisplus.core.toolkit.CollectionUtils; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; import com.jeecg.weibo.exception.BusinessException; import org.apache.commons.lang3.StringUtils; import org.apache.poi.ss.usermodel.*; import org.apache.poi.xwpf.usermodel.*; import org.apache.shiro.SecurityUtils; import org.flowable.engine.TaskService; import org.flowable.task.api.Task; import org.jeecg.common.api.vo.Result; import org.jeecg.common.constant.CommonConstant; import org.jeecg.common.exception.JeecgBootException; import org.jeecg.common.system.vo.LoginUser; import org.jeecg.modules.eam.constant.BusinessCodeConst; import org.jeecg.modules.eam.constant.EamMaintenanceStandardDetailCategory; import org.jeecg.modules.eam.constant.MaintenanceStandardStatusEnum; import org.jeecg.modules.eam.entity.EamEquipment; import org.jeecg.modules.eam.entity.EamEquipmentExtend; import org.jeecg.modules.eam.entity.EamMaintenanceStandard; import org.jeecg.modules.eam.entity.EamMaintenanceStandardDetail; import org.jeecg.modules.eam.mapper.EamMaintenanceStandardMapper; import org.jeecg.modules.eam.request.EamMaintenanceStandardRequest; import org.jeecg.modules.eam.request.ImportException; import org.jeecg.modules.eam.service.IEamEquipmentExtendService; import org.jeecg.modules.eam.service.IEamEquipmentService; import org.jeecg.modules.eam.service.IEamMaintenanceStandardDetailService; import org.jeecg.modules.eam.service.IEamMaintenanceStandardService; import org.jeecg.modules.eam.vo.EamMaintenanceStandardVo; import org.jeecg.modules.flowable.apithird.business.entity.FlowMyBusiness; import org.jeecg.modules.flowable.apithird.business.service.IFlowMyBusinessService; import org.jeecg.modules.flowable.apithird.service.FlowCallBackServiceI; import org.jeecg.modules.flowable.apithird.service.FlowCommonService; import org.jeecg.modules.flowable.service.IFlowDefinitionService; import org.jeecg.modules.flowable.service.IFlowTaskService; import org.jeecg.modules.system.entity.BaseFactory; import org.jeecg.modules.system.entity.BaseFactoryUser; import org.jeecg.modules.system.entity.SysParams; import org.jeecg.modules.system.service.*; import org.jeecg.modules.system.vo.UserSelector; import org.springframework.beans.BeanUtils; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import org.springframework.web.multipart.MultipartFile; import javax.annotation.Resource; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.*; import java.util.regex.Matcher; import java.util.regex.Pattern; import java.util.stream.Collectors; /** * @Description: 保养标准 * @Author: jeecg-boot * @Date: 2025-03-26 * @Version: V1.0 */ @Service("IEamMaintenanceStandardService") public class EamMaintenanceStandardServiceImpl extends ServiceImpl implements IEamMaintenanceStandardService, FlowCallBackServiceI { @Resource private EamMaintenanceStandardMapper eamMaintenanceStandardMapper; @Autowired private IEamMaintenanceStandardDetailService eamMaintenanceStandardDetailService; @Autowired private IBaseFactoryUserService baseFactoryUserService; @Autowired private IBaseFactoryService baseFactoryService; @Resource private FlowCommonService flowCommonService; @Resource private IFlowDefinitionService flowDefinitionService; @Autowired private IFlowTaskService flowTaskService; @Autowired private TaskService taskService; @Autowired private IFlowMyBusinessService flowMyBusinessService; @Autowired private ISysUserService sysUserService; @Autowired private IEamEquipmentService eamEquipmentService; @Autowired private IEamEquipmentExtendService eamEquipmentExtendService; @Autowired private ISysBusinessCodeRuleService businessCodeRuleService; @Autowired private ISysParamsService sysParamsService; // 常量定义 private static final String REPAIR_TITLE = "维修人员保养内容"; private static final String OPERATOR_TITLE = "操作人员保养内容"; private static final Map SECOND_CATEGORY_MAPPING = new HashMap<>(); // 枚举映射初始化 static { SECOND_CATEGORY_MAPPING.put(REPAIR_TITLE, EamMaintenanceStandardDetailCategory.REPAIRER_MAINTENANCE); SECOND_CATEGORY_MAPPING.put(OPERATOR_TITLE, EamMaintenanceStandardDetailCategory.OPERATOR_MAINTENANCE); } @Override public IPage queryPageList(Page page, EamMaintenanceStandard eamMaintenanceStandard) { QueryWrapper queryWrapper = new QueryWrapper<>(); queryWrapper.eq("ems.del_flag", CommonConstant.DEL_FLAG_0); //用户数据权限 LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal(); if (sysUser == null) { return page; } if (StringUtils.isNotBlank(sysUser.getEamEquipmentIds())) { //选择了设备，根据设备id过滤设备 List equipArr = Arrays.asList(sysUser.getEamEquipmentIds().split(",")); queryWrapper.in("e.equipment_code", equipArr); } else { //没有选择设备，根据中心过滤设备 List baseFactoryUserList = baseFactoryUserService. list(new LambdaQueryWrapper().eq(BaseFactoryUser::getUserId, sysUser.getId())); if (!CollectionUtils.isEmpty(baseFactoryUserList)) { Set factoryIds = baseFactoryUserList.stream().map(BaseFactoryUser::getFactoryId).collect(Collectors.toSet()); Set factoryCode = baseFactoryService.listByIds(factoryIds).stream().map(BaseFactory::getOrgCode).collect(Collectors.toSet()); queryWrapper.in("e.factory_org_code", factoryCode); } else { return page; } } if (eamMaintenanceStandard != null) { //编码 模糊查询 if (StringUtils.isNotBlank(eamMaintenanceStandard.getStandardCode())) { queryWrapper.like("ems.standard_code", eamMaintenanceStandard.getStandardCode()); } //名称 模糊查询 if (StringUtils.isNotBlank(eamMaintenanceStandard.getStandardName())) { queryWrapper.like("ems.standard_name", eamMaintenanceStandard.getStandardName()); } //设备 if (StringUtils.isNotBlank(eamMaintenanceStandard.getEquipmentId())) { queryWrapper.eq("ems.equipment_id", eamMaintenanceStandard.getEquipmentId()); } //保养分类 if (StringUtils.isNotBlank(eamMaintenanceStandard.getMaintenanceCategory())) { queryWrapper.eq("ems.maintenance_category", eamMaintenanceStandard.getMaintenanceCategory()); } //保养分类 if (StringUtils.isNotBlank(eamMaintenanceStandard.getStandardStatus())) { queryWrapper.eq("ems.standard_status", eamMaintenanceStandard.getStandardStatus()); } //设备编码 if (StringUtils.isNotBlank(eamMaintenanceStandard.getKeyword())) { queryWrapper.and(wrapper -> wrapper.like("e.equipment_name", eamMaintenanceStandard.getKeyword()) .or() .like("e.equipment_code", eamMaintenanceStandard.getKeyword())); } //id if (StringUtils.isNotBlank(eamMaintenanceStandard.getId())) { queryWrapper.eq("ems.id", eamMaintenanceStandard.getId()); } } queryWrapper.orderByDesc("ems.create_time"); return eamMaintenanceStandardMapper.queryPageList(page, queryWrapper); } @Override @Transactional(rollbackFor = Exception.class) public boolean addMaintenanceStandard(EamMaintenanceStandardRequest standardRequest) { EamMaintenanceStandard entity = new EamMaintenanceStandard(); BeanUtils.copyProperties(standardRequest, entity); entity.setStandardStatus(MaintenanceStandardStatusEnum.WAIT_SUBMIT.name()); //版本递增 entity.setStandardVersion("v" + CommonConstant.OPERATE_TYPE_1); //设备处理 entity.setEquipmentId(standardRequest.getEquipmentId()); //删除标记 entity.setDelFlag(CommonConstant.DEL_FLAG_0); //重复性校验 EamMaintenanceStandard exist = checkDuplicate(entity.getEquipmentId(), entity.getMaintenanceCategory(), MaintenanceStandardStatusEnum.ABOLISH.name()); if (exist != null) { throw new JeecgBootException("设备标准已存在，不能重复添加！"); } eamMaintenanceStandardMapper.insert(entity); //处理明细数据 if (CollectionUtil.isNotEmpty(standardRequest.getTableDetailList())) { standardRequest.getTableDetailList().forEach(tableDetail -> { tableDetail.setStandardId(entity.getId()); }); eamMaintenanceStandardDetailService.saveBatch(standardRequest.getTableDetailList()); } return true; } @Override @Transactional(rollbackFor = Exception.class) public boolean editMaintenanceStandard(EamMaintenanceStandardRequest standardRequest) { EamMaintenanceStandard entity = eamMaintenanceStandardMapper.selectById(standardRequest.getId()); if (entity == null) { throw new JeecgBootException("编辑的数据已删除，请刷新重试！"); } entity.setStandardName(standardRequest.getStandardName()); entity.setMaintenancePeriod(standardRequest.getMaintenancePeriod()); eamMaintenanceStandardMapper.updateById(entity); //处理详情 if(CollectionUtil.isNotEmpty(standardRequest.getTableDetailList())) { List addList = new ArrayList<>(); //先删除原有 LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>(); queryWrapper.eq(EamMaintenanceStandardDetail::getStandardId, standardRequest.getId()); eamMaintenanceStandardDetailService.remove(queryWrapper); standardRequest.getTableDetailList().forEach(tableDetail -> { EamMaintenanceStandardDetail eamMaintenanceStandardDetail=new EamMaintenanceStandardDetail(); BeanUtils.copyProperties(tableDetail, eamMaintenanceStandardDetail); eamMaintenanceStandardDetail.setStandardId(entity.getId()); addList.add(eamMaintenanceStandardDetail); }); eamMaintenanceStandardDetailService.saveBatch(addList); } return true; } @Override @Transactional(rollbackFor = Exception.class) public boolean upgradeMaintenanceStandard(EamMaintenanceStandardRequest standardRequest) { EamMaintenanceStandard entity = eamMaintenanceStandardMapper.selectById(standardRequest.getId()); if (entity == null) { throw new JeecgBootException("编辑的数据已删除，请刷新重试！"); } //新增一个版本 EamMaintenanceStandard newEntity = new EamMaintenanceStandard(); newEntity.setStandardCode(standardRequest.getStandardCode()); newEntity.setStandardName(standardRequest.getStandardName()); newEntity.setMaintenanceCategory(standardRequest.getMaintenanceCategory()); newEntity.setMaintenancePeriod(standardRequest.getMaintenancePeriod()); newEntity.setInitialDate(standardRequest.getInitialDate()); newEntity.setPeriodUnit(standardRequest.getPeriodUnit()); newEntity.setStandardStatus(MaintenanceStandardStatusEnum.WAIT_SUBMIT.name()); //版本递增 //获取数字 Pattern pattern = Pattern.compile("(\\d+)(?:\\.\\d+)*$"); Matcher matcher = pattern.matcher(entity.getStandardVersion()); if (matcher.find()) { try { int mainVersion = Integer.parseInt(matcher.group(1)); newEntity.setStandardVersion("v" + (mainVersion + 1)); } catch (NumberFormatException ignored) { } } //设备处理 newEntity.setEquipmentId(standardRequest.getEquipmentId()); //删除标记 newEntity.setDelFlag(CommonConstant.DEL_FLAG_0); //重复性校验 EamMaintenanceStandard exist = checkDuplicate(newEntity.getEquipmentId(), newEntity.getMaintenanceCategory(), MaintenanceStandardStatusEnum.ABOLISH.name()); if (exist != null) { throw new JeecgBootException("设备标准已存在，不能重复添加！"); } eamMaintenanceStandardMapper.insert(newEntity); //处理明细数据 if (CollectionUtil.isNotEmpty(standardRequest.getTableDetailList())) { standardRequest.getTableDetailList().forEach(tableDetail -> { tableDetail.setId(null); tableDetail.setCreateBy(null); tableDetail.setUpdateBy(null); tableDetail.setCreateTime(null); tableDetail.setUpdateTime(null); tableDetail.setStandardId(newEntity.getId()); }); eamMaintenanceStandardDetailService.saveBatch(standardRequest.getTableDetailList()); } return true; } @Override public EamMaintenanceStandard checkDuplicate(String equipmentId, String maintenanceCategory, String standardStatus) { LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>(); queryWrapper.eq(EamMaintenanceStandard::getEquipmentId, equipmentId); queryWrapper.eq(EamMaintenanceStandard::getMaintenanceCategory, maintenanceCategory); queryWrapper.eq(EamMaintenanceStandard::getDelFlag, CommonConstant.DEL_FLAG_0); queryWrapper.ne(EamMaintenanceStandard::getStandardStatus, standardStatus); queryWrapper.orderByDesc(EamMaintenanceStandard::getStandardVersion); List list = eamMaintenanceStandardMapper.selectList(queryWrapper); if (CollectionUtil.isEmpty(list)) { return null; } return list.get(0); } /** * 查询标准列表-前端展示该用户拥有的标准 * * @param keyword 设备编号 * @param maintenanceCategory 保养类型 * @return */ @Override public List queryListByKeywordAndCategory(String keyword, String equipmentId, Integer pageSize, String maintenanceCategory) { Page page = new Page(1, pageSize); EamMaintenanceStandard query = new EamMaintenanceStandard(); query.setEquipmentId(equipmentId); query.setKeyword(keyword); query.setMaintenanceCategory(maintenanceCategory); query.setStandardStatus(MaintenanceStandardStatusEnum.START.name()); IPage pageData = this.queryPageList(page, query); return pageData.getRecords(); } @Override public List queryListByCategory(String maintenanceCategory) { LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>(); queryWrapper.eq(EamMaintenanceStandard::getDelFlag, CommonConstant.DEL_FLAG_0); queryWrapper.eq(EamMaintenanceStandard::getMaintenanceCategory, maintenanceCategory); queryWrapper.eq(EamMaintenanceStandard::getStandardStatus, MaintenanceStandardStatusEnum.START.name()); return eamMaintenanceStandardMapper.selectList(queryWrapper); } /*流程业务代码--------------------------开始*/ /** * 流程启动,保存对应的数据 * * @param id * @return */ @Override public Result saveEamMaintenanceStandardProcess(String id) { LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal(); EamMaintenanceStandard maintenanceStandard = this.getById(id); if (maintenanceStandard == null) { return Result.error("未找到对应保养标准"); } System.out.println("保养规范流程：" + maintenanceStandard.getId()); flowCommonService.initActBusiness(maintenanceStandard.getStandardName() + "规范进行流程审核", maintenanceStandard.getId(), "IEamMaintenanceStandardService", "eam_maintenance_standard", null); Map variables = new HashMap<>(); variables.put("dataId", maintenanceStandard.getId()); variables.put("organization", "保养规范启动流程"); variables.put("comment", "保养规范启动流程"); variables.put("proofreading", true); Result result = flowDefinitionService.startProcessInstanceByKey("eam_maintenance_standard", variables); if (!result.isSuccess()) { super.removeById(maintenanceStandard.getId()); } else { maintenanceStandard.setStandardStatus(MaintenanceStandardStatusEnum.WAIT_REPAIR_DIRECTOR.name()); maintenanceStandard.setDesigner(user.getUsername()); maintenanceStandard.setDesignTime(new Date()); eamMaintenanceStandardMapper.updateById(maintenanceStandard); //获取flow的流程实例id,设置下一步的处理人员 List businessList = flowMyBusinessService.list( new QueryWrapper() .eq("data_id", maintenanceStandard.getId()) ); if (businessList.isEmpty()) { return Result.error("流程记录不存在"); } FlowMyBusiness flowMyBusiness = businessList.get(0); EamEquipment eamEquipment = eamEquipmentService.getById(maintenanceStandard.getEquipmentId()); List userSelectorList = sysUserService.selectOperatorList(eamEquipment.getEquipmentCode(), eamEquipment.getFactoryOrgCode(), BusinessCodeConst.PCR0008); if (!CollectionUtils.isEmpty(userSelectorList)) { List usernameList = userSelectorList.stream().map(UserSelector::getUsername).collect(Collectors.toList()); flowMyBusiness.setTodoUsers(JSON.toJSONString(usernameList)); flowMyBusinessService.updateById(flowMyBusiness); } } return result; } /** * 审批操作 * * @param eamMaintenanceStandardVo * @return */ @Override @Transactional(rollbackFor = Exception.class) public Result auditEamMaintenanceStandard(EamMaintenanceStandardVo eamMaintenanceStandardVo) { try { // 参数校验 if (StrUtil.isEmpty(eamMaintenanceStandardVo.getTaskId()) || StrUtil.isEmpty(eamMaintenanceStandardVo.getDataId())) { return Result.error("参数错误"); } LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal(); String userId = user.getId(); eamMaintenanceStandardVo.setAssignee(user.getUsername()); if (StrUtil.isEmpty(userId)) { return Result.error("未找到对应用户"); } // 数据查询 EamMaintenanceStandard eamMaintenanceStandard = this.getById(eamMaintenanceStandardVo.getDataId()); if (eamMaintenanceStandard == null) { return Result.error("未找到对应保养标准"); } // 2. 查询流程业务记录（处理空结果） List businessList = flowMyBusinessService.list( new QueryWrapper() .eq("process_instance_id", eamMaintenanceStandardVo.getInstanceId()) ); if (businessList.isEmpty()) { return Result.error("流程记录不存在"); } FlowMyBusiness flowMyBusiness = businessList.get(0); // 3. 校验用户是否为候选处理人 List todoUsers = JSON.parseArray(flowMyBusiness.getTodoUsers(), String.class); if (todoUsers == null || !todoUsers.contains(user.getUsername())) { return Result.error("用户无权操作此任务"); } // 4. 认领任务（处理已被认领的情况） String taskId = flowMyBusiness.getTaskId(); Task task = taskService.createTaskQuery().taskId(taskId).singleResult(); if (task == null) { return Result.error("任务不存在或已完成"); } if (task.getAssignee() != null && !task.getAssignee().equals(user.getUsername())) { return Result.error("任务已被他人认领"); } taskService.claim(taskId, user.getUsername()); // 设置流程变量 Map values = setProcessVariables(eamMaintenanceStandard, userId, eamMaintenanceStandardVo); eamMaintenanceStandardVo.setValues(values); eamMaintenanceStandardVo.setComment(values.get("comment").toString()); // 完成流程任务 Result result = flowTaskService.complete(eamMaintenanceStandardVo); if (result.isSuccess()) { if (eamMaintenanceStandardVo.getRepairManagerApproveResult() != null) { if (eamMaintenanceStandardVo.getRepairManagerApproveResult().equals("1")) { List newbusinessList = flowMyBusinessService.list( new QueryWrapper() .eq("process_instance_id", eamMaintenanceStandardVo.getInstanceId())); FlowMyBusiness newflowMyBusiness = newbusinessList.get(0); eamMaintenanceStandard.setStandardStatus(MaintenanceStandardStatusEnum.WAIT_TECHNICAL_DIRECTOR.name()); //获取flow的流程实例id,设置下一步的处理人员 EamMaintenanceStandard maintenanceStandard = this.getById(eamMaintenanceStandardVo.getDataId()); EamEquipment eamEquipment = eamEquipmentService.getById(maintenanceStandard.getEquipmentId()); List userSelectorList = sysUserService.selectOperatorList(eamEquipment.getEquipmentCode(), eamEquipment.getFactoryOrgCode(), BusinessCodeConst.PCR0009); if (!CollectionUtils.isEmpty(userSelectorList)) { List usernameList = userSelectorList.stream().map(UserSelector::getUsername).collect(Collectors.toList()); newflowMyBusiness.setTodoUsers(JSON.toJSONString(usernameList)); flowMyBusinessService.updateById(newflowMyBusiness); } } else { eamMaintenanceStandard.setStandardStatus(MaintenanceStandardStatusEnum.WAIT_SUBMIT.name()); } eamMaintenanceStandard.setRepairManager(user.getUsername()); eamMaintenanceStandard.setRepairManagerApproveResult(eamMaintenanceStandardVo.getRepairManagerApproveResult()); eamMaintenanceStandard.setRepairManagerApproveTime(new Date()); eamMaintenanceStandard.setRepairManagerApproveComment(eamMaintenanceStandardVo.getComment()); } if (eamMaintenanceStandardVo.getTechnicalManagerApproveResult() != null) { if (eamMaintenanceStandardVo.getTechnicalManagerApproveResult().equals("1")) { eamMaintenanceStandard.setStandardStatus(MaintenanceStandardStatusEnum.START.name()); //判断是否进行升版，通过设备编号、保养分类、状态进行筛选 EamMaintenanceStandard maintenanceStandard = this.getById(eamMaintenanceStandardVo.getDataId()); QueryWrapper queryWrapper = new QueryWrapper<>(); queryWrapper.eq("equipment_id", maintenanceStandard.getEquipmentId()); queryWrapper.eq("maintenance_category", maintenanceStandard.getMaintenanceCategory()); queryWrapper.eq("standard_status", MaintenanceStandardStatusEnum.START.name()); List list = eamMaintenanceStandardMapper.selectList(queryWrapper); if (!CollectionUtils.isEmpty(list)) { //作废原有 for (EamMaintenanceStandard eamMaintenanceStandard1 : list) { eamMaintenanceStandard1.setStandardStatus(MaintenanceStandardStatusEnum.ABOLISH.name()); this.updateById(eamMaintenanceStandard1); } } } else { eamMaintenanceStandard.setStandardStatus(MaintenanceStandardStatusEnum.WAIT_SUBMIT.name()); } eamMaintenanceStandard.setTechnicalManager(user.getUsername()); eamMaintenanceStandard.setTechnicalManagerApproveResult(eamMaintenanceStandardVo.getTechnicalManagerApproveResult()); eamMaintenanceStandard.setTechnicalManagerApproveTime(new Date()); eamMaintenanceStandard.setTechnicalManagerApproveComment(eamMaintenanceStandardVo.getComment()); } this.updateById(eamMaintenanceStandard); } else { return result; } return Result.OK("操作成功"); } catch (Exception e) { return Result.error("操作失败：" + e.getMessage()); } } private Map setProcessVariables(EamMaintenanceStandard eamMaintenanceStandard, String userId, EamMaintenanceStandardVo eamMaintenanceStandardVo) { Map values = new HashMap<>(); values.put("dataId", eamMaintenanceStandard.getId()); values.put("assignee", userId); if (eamMaintenanceStandardVo.getRepairManagerApproveResult() != null) { values.put("repairManagerApproveResult", eamMaintenanceStandardVo.getRepairManagerApproveResult()); values.put("organization", eamMaintenanceStandardVo.getRepairManagerApproveComment()); values.put("comment", eamMaintenanceStandardVo.getRepairManagerApproveComment()); } if (eamMaintenanceStandardVo.getTechnicalManagerApproveResult() != null) { values.put("technicalManagerApproveResult", eamMaintenanceStandardVo.getTechnicalManagerApproveResult()); values.put("organization", eamMaintenanceStandardVo.getTechnicalManagerApproveComment()); values.put("comment", eamMaintenanceStandardVo.getTechnicalManagerApproveComment()); } return values; } @Override public void afterFlowHandle(FlowMyBusiness business) { business.getTaskNameId();//接下来审批的节点 business.getValues();//前端传进来的参数 business.getActStatus(); } @Override public Object getBusinessDataById(String dataId) { return this.getById(dataId); } @Override public Map flowValuesOfTask(String taskNameId, Map values) { return null; } @Override public List flowCandidateUsernamesOfTask(String taskNameId, Map values) { //业务是否干预流程，业务干预，流程干预，指定人员进行处理 return null; } /*流程业务代码--------------------------结束*/ /*导入点检文件Excel--------------------------开始*/ /** * 点检表导入入口 */ @Override @Transactional(rollbackFor = Exception.class) public Result importPointInspectionExcel(MultipartFile file) { try (Workbook workbook = WorkbookFactory.create(file.getInputStream())) { Sheet sheet = workbook.getSheetAt(0); // 提取名称 String name = extractInspectionTitle(file) + "点检表"; // 1. 提取设备信息 EamMaintenanceStandard eamMaintenanceStandard = extractDeviceInfo(sheet); if (eamMaintenanceStandard == null || eamMaintenanceStandard.getEquipmentId() == null) { return Result.error("设备信息提取失败"); } eamMaintenanceStandard.setStandardName(name); // 检查重复 EamMaintenanceStandard exist = checkDuplicate(eamMaintenanceStandard.getEquipmentId(), eamMaintenanceStandard.getMaintenanceCategory(), MaintenanceStandardStatusEnum.ABOLISH.name()); if (exist != null) { return Result.error(name + ": 设备标准已存在，不能重复添加"); } eamMaintenanceStandard.setInitialDate(new Date()); eamMaintenanceStandardMapper.insert(eamMaintenanceStandard); Map rowErrors = new HashMap<>(); // 2. 提取每日点检项目（优化空行和结束标记处理） List dailyDetails = extractDailyItems(sheet, eamMaintenanceStandard, rowErrors); if (dailyDetails.isEmpty()) { return Result.error("未找到每日点检项目"); } // 3. 提取周保养项目 List weeklyDetails = extractWeeklyItems(sheet, eamMaintenanceStandard, rowErrors); if (weeklyDetails.isEmpty()) { return Result.error("未找到周保养项目"); } // 合并并保存所有项目 List allDetails = new ArrayList<>(); allDetails.addAll(dailyDetails); allDetails.addAll(weeklyDetails); if (!CollectionUtils.isEmpty(allDetails)) { eamMaintenanceStandardDetailService.saveBatch(allDetails); } // 触发保养流程 SysParams sysParams = sysParamsService.getSysPramBySettingKey("maintenance_import_type"); if (sysParams != null) { if (sysParams.getSettingValue().equals("1")){ eamMaintenanceStandard.setStandardStatus(MaintenanceStandardStatusEnum.WAIT_SUBMIT.name()); eamMaintenanceStandardMapper.updateById(eamMaintenanceStandard); } } else { return Result.error("未找到保养流程导入相关配置,请联系管理员"); } return Result.OK("点检表导入成功"); } catch (Exception e) { throw new BusinessException("点检表导入失败: " + e.getMessage()); } } /** * 提取点检表标题 */ private String extractInspectionTitle(MultipartFile file) { try (Workbook workbook = WorkbookFactory.create(file.getInputStream())) { Sheet sheet = workbook.getSheetAt(0); Row firstRow = sheet.getRow(0); if (firstRow == null) { return "未找到标题"; } Cell firstCell = firstRow.getCell(0); if (firstCell == null) { return ""; } String title = getCellStringValue(firstCell); return extractTextBeforeInspection(title); } catch (Exception e) { return ""; } } /** * 提取点检表之前的文字 */ private String extractTextBeforeInspection(String title) { if (StringUtils.isBlank(title)) { return ""; } int index = title.indexOf("点检表"); return index > 0 ? title.substring(0, index).trim() : title; } /** * 提取设备信息 */ private EamMaintenanceStandard extractDeviceInfo(Sheet sheet) { Row headerRow = sheet.getRow(0); if (headerRow == null) { return null; } String headerText = getCellStringValue(headerRow.getCell(0)); if (StringUtils.isBlank(headerText)) { return null; } EamMaintenanceStandard standard = new EamMaintenanceStandard(); standard.setEquipmentName(extractField(headerText, "设备名称[:：]\\s*(\\S+)")); standard.setEquipmentCode(extractField(headerText, "统一编号[:：]\\s*(\\S+)")); // 日期处理 String dateStr = extractField(headerText, "日期[:：]\\s*(\\S+)"); if (StringUtils.isNotBlank(dateStr)) { try { // 支持多种日期格式 Date date = parseDate(dateStr); standard.setDesignTime(date); standard.setInitialDate(date); } catch (ParseException ignored) { } } // 关联设备ID if (StrUtil.isNotEmpty(standard.getEquipmentCode())) { EamEquipment equipments = eamEquipmentService.selectByEquipmentCode(standard.getEquipmentCode()); if (equipments == null) { return null; } else { standard.setEquipmentId(equipments.getId()); } } String codeSeq = businessCodeRuleService.generateBusinessCodeSeq(BusinessCodeConst.MAINTENANCE_STANDARD_CODE_RULE); standard.setStandardCode(codeSeq); standard.setMaintenanceCategory("POINT_INSPECTION"); standard.setPeriodUnit("天"); standard.setStandardStatus(MaintenanceStandardStatusEnum.START.name()); standard.setStandardVersion("v" + CommonConstant.OPERATE_TYPE_1); standard.setDelFlag(0); standard.setMaintenancePeriod(1); return standard; } /** * 解析日期字符串 */ private Date parseDate(String dateStr) throws ParseException { // 尝试多种日期格式 String[] patterns = { "yyyy年MM月", "yyyy-MM", "yyyy/MM", "yyyyMM", "yyyy年M月" }; for (String pattern : patterns) { try { SimpleDateFormat sdf = new SimpleDateFormat(pattern); sdf.setLenient(false); return sdf.parse(dateStr); } catch (ParseException e) { // 尝试下一个格式 } } throw new ParseException("无法解析日期: " + dateStr, 0); } /** * 使用正则提取字段 */ private String extractField(String text, String regex) { if (StringUtils.isBlank(text)) return ""; Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(text); return matcher.find() ? matcher.group(1) : ""; } /** * 提取每日点检项目 */ private List extractDailyItems(Sheet sheet, EamMaintenanceStandard standard, Map rowErrors) { // 使用多关键词匹配 String[] primaryHeaders = {"点检项目", "日常点检", "每日检查"}; String[] secondaryHeaders = {"完成数据/要求", "检查标准", "要求"}; return extractItems(sheet, standard, primaryHeaders, secondaryHeaders, "DAY_INSPECTION", rowErrors); } /** * 提取周保养项目 */ private List extractWeeklyItems(Sheet sheet, EamMaintenanceStandard standard, Map rowErrors) { // 使用多关键词匹配 String[] primaryHeaders = {"周保养项目", "周保养", "每周保养"}; String[] secondaryHeaders = {"检查标准", "保养要求", "标准"}; return extractItems(sheet, standard, primaryHeaders, secondaryHeaders, "WEEK_INSPECTION", rowErrors); } /** * 核心改进：优化表格区域识别和数据提取 */ private List extractItems(Sheet sheet, EamMaintenanceStandard standard, String[] primaryHeaders, String[] secondaryHeaders, String itemCategory, Map rowErrors) { // 1. 定位表格区域（精确匹配表头） int startRow = findHeaderRow(sheet, primaryHeaders, secondaryHeaders); if (startRow == -1) { rowErrors.put(-1, "未找到" + Arrays.toString(primaryHeaders) + "表头区域"); return Collections.emptyList(); } int endRow = findDataEnd(sheet, startRow + 1, "周保养项目"); // 提取日志（实际使用时可以去掉） System.out.println("提取区域: " + (startRow + 1) + "行到" + (endRow + 1) + "行"); // 2. 提取数据行 List details = new ArrayList<>(); for (int rowIdx = startRow + 1; rowIdx <= endRow; rowIdx++) { Row row = sheet.getRow(rowIdx); if (row == null) continue; try { // 序号列处理 Cell seqCell = row.getCell(0); if (seqCell == null || seqCell.getCellType() == CellType.BLANK) { continue; } // 获取序号值（支持数字和文本格式） int seqValue = 0; try { if (seqCell.getCellType() == CellType.NUMERIC) { seqValue = (int) seqCell.getNumericCellValue(); } else if (seqCell.getCellType() == CellType.STRING) { seqValue = Integer.parseInt(seqCell.getStringCellValue().trim()); } } catch (NumberFormatException e) { rowErrors.put(rowIdx + 1, "序号格式错误"); continue; } // 项目名称列（第二列） Cell nameCell = row.getCell(1); if (nameCell == null || nameCell.getCellType() == CellType.BLANK) { continue; } String itemName = getCellStringValue(nameCell).trim(); // 要求/标准列（第三列） String demand = ""; if (row.getLastCellNum() >= 3) { Cell demandCell = row.getCell(2); if (demandCell != null) { demand = getCellStringValue(demandCell).trim(); } } // 创建详情对象 EamMaintenanceStandardDetail detail = new EamMaintenanceStandardDetail(); detail.setStandardId(standard.getId()); detail.setItemCode(seqValue); detail.setItemName(itemName); detail.setItemDemand(demand); detail.setItemCategory(itemCategory); details.add(detail); } catch (Exception e) { rowErrors.put(rowIdx + 1, "解析错误: " + e.getMessage()); } } return details; } /** * 获取行中所有单元格的字符串值 */ private List getRowStringValues(Row row) { List values = new ArrayList<>(); if (row == null) return values; for (int cellIdx = 0; cellIdx < row.getLastCellNum(); cellIdx++) { Cell cell = row.getCell(cellIdx); if (cell != null) { values.add(getCellStringValue(cell)); } else { values.add(""); // 对于空单元格添加空字符串 } } return values; } /** * 获取单元格字符串值（增强公式处理） */ private String getCellStringValue(Cell cell) { if (cell == null) { return ""; } // 保持不变，但添加数字类型处理 if (cell.getCellType() == CellType.NUMERIC) { // 整数处理 double num = cell.getNumericCellValue(); if (num == (int) num) { return String.valueOf((int) num); } return String.valueOf(num); } switch (cell.getCellType()) { case STRING: return cell.getStringCellValue().trim(); case NUMERIC: if (DateUtil.isCellDateFormatted(cell)) { return new SimpleDateFormat("yyyy年MM月").format(cell.getDateCellValue()); } return String.valueOf((int) cell.getNumericCellValue()); case BOOLEAN: return String.valueOf(cell.getBooleanCellValue()); case FORMULA: return getFormulaCellValue(cell); default: return ""; } } /** * 精确查找表头行 */ private int findHeaderRow(Sheet sheet, String[] primaryHeaders, String[] secondaryHeaders) { for (int rowIdx = 0; rowIdx <= sheet.getLastRowNum(); rowIdx++) { Row row = sheet.getRow(rowIdx); if (row == null) continue; String rowText = getRowStringValues(row).stream().collect(Collectors.joining()); // 检查主标题和副标题 boolean hasPrimary = false; boolean hasSecondary = false; for (String header : primaryHeaders) { if (rowText.contains(header)) { hasPrimary = true; break; } } for (String header : secondaryHeaders) { if (rowText.contains(header)) { hasSecondary = true; break; } } if (hasPrimary && hasSecondary) { return rowIdx; } } return -1; } /** * 查找数据结束位置（根据您的Excel结构优化） */ private int findDataEnd(Sheet sheet, int startRow, String nextSectionKeyword) { int consecutiveEmptyRows = 0; final int MAX_EMPTY_ROWS = 3; for (int rowIdx = startRow; rowIdx <= sheet.getLastRowNum(); rowIdx++) { Row row = sheet.getRow(rowIdx); // 关键改进1：空行处理 if (isEssentiallyEmpty(row)) { consecutiveEmptyRows++; if (consecutiveEmptyRows >= MAX_EMPTY_ROWS) { return rowIdx - consecutiveEmptyRows; } continue; } else { consecutiveEmptyRows = 0; } // 关键改进2：结束标记检测 String rowText = getRowStringValues(row).stream().collect(Collectors.joining()); // 根据您的Excel结构，签字行有特定格式 if (rowText.contains("维护责任人签字")) { return rowIdx - 1; } // 检测下一个区域的开始（如周保养项目） if (StringUtils.isNotBlank(nextSectionKeyword) && rowText.contains(nextSectionKeyword)) { return rowIdx - 1; } } return sheet.getLastRowNum(); } /** * 判断条件：前两列为空即视为空行 */ private boolean isEssentiallyEmpty(Row row) { if (row == null) return true; // 检查序号列 Cell indexCell = row.getCell(0); if (indexCell != null && indexCell.getCellType() != CellType.BLANK) { return false; } // 检查项目名称列 Cell nameCell = row.getCell(1); if (nameCell != null && nameCell.getCellType() != CellType.BLANK) { return false; } return true; } /** * 获取公式单元格值 */ private String getFormulaCellValue(Cell cell) { try { Workbook workbook = cell.getSheet().getWorkbook(); FormulaEvaluator evaluator = workbook.getCreationHelper().createFormulaEvaluator(); CellValue cellValue = evaluator.evaluate(cell); if (cellValue == null) { return ""; } switch (cellValue.getCellType()) { case STRING: return cellValue.getStringValue(); case NUMERIC: return String.valueOf((int) cellValue.getNumberValue()); case BOOLEAN: return String.valueOf(cellValue.getBooleanValue()); default: return ""; } } catch (Exception e) { log.warn("解析公式单元格失败"); return ""; } } private int findDataEnd(Sheet sheet, int startRow) { int consecutiveEmptyRows = 0; final int MAX_EMPTY_ROWS = 2; boolean foundData = false; for (int rowIdx = startRow; rowIdx <= sheet.getLastRowNum(); rowIdx++) { Row row = sheet.getRow(rowIdx); // 关键优化1：先检查是否为空行 if (isEmptyRow(row)) { consecutiveEmptyRows++; if (consecutiveEmptyRows >= MAX_EMPTY_ROWS) { return foundData ? rowIdx - consecutiveEmptyRows : startRow; } continue; } else { consecutiveEmptyRows = 0; } // 关键优化2：严格限定结束标记的识别条件 if (isStrongEndMarker(row)) { return foundData ? rowIdx - 1 : startRow; } // 关键优化3：标记已找到有效数据 foundData = true; } return sheet.getLastRowNum(); } // 增强版结束标记识别 private boolean isStrongEndMarker(Row row) { String rowText = String.join("", getRowStringValues(row)).toLowerCase(); return // 精确匹配签字特征（出现在行首） (rowText.startsWith("维护责任人签字") || rowText.startsWith("执行人签字")) || // 精确匹配新板块标题 rowText.matches("^\\s*周保养项目\\s*$") || rowText.contains("年度保养项目"); } // 空行检测优化（允许部分列为空） private boolean isEmptyRow(Row row) { if (row == null) return true; // 只检查前3列（序号列+项目名+要求） for (int cellIdx = 0; cellIdx < Math.min(3, row.getLastCellNum()); cellIdx++) { Cell cell = row.getCell(cellIdx); if (cell != null && cell.getCellType() != CellType.BLANK) { return false; } } return true; } /*导入点检文件Excel--------------------------结束*/ /*导入二保三保文件Excel--------------------------开始*/ /** * 统一保养规范导入入口 * * @param file 上传文件 * @param type 保养类型 (SECOND/THIRD) * @return 导入结果（包含成功/失败信息） */ @Override @Transactional public Result importMaintenanceStandard(MultipartFile file, String type) { String fileName = file.getOriginalFilename(); try (XWPFDocument doc = new XWPFDocument(file.getInputStream())) { // 获取文档标题（第一个非空段落） String documentTitle = null; for (XWPFParagraph p : doc.getParagraphs()) { String text = p.getText(); if (text != null && !text.trim().isEmpty()) { documentTitle = text.trim(); break; // 找到第一个非空段落即退出 } } // 基础验证 if (doc.getTables().isEmpty()) { return Result.error(fileName + ": 文档中未找到表格"); } // 基础验证 if (doc.getTables().isEmpty()) { return Result.error(fileName + ": 文档中未找到表格"); } List tables = doc.getTables(); EamMaintenanceStandard standard = null; List items = new ArrayList<>(); String standardId = null; // 1. 处理所有表格 for (int i = 0; i < tables.size(); i++) { XWPFTable table = tables.get(i); if (i == 0) { // 第一页表格 // 验证设备信息表格 if (isWrongDocumentType(table, type)) { return Result.error(fileName + ": 文档类型不匹配 - " + ("SECOND".equals(type) ? "请导入二级保养文档" : "请导入三级保养文档")); } // 提取设备信息 standard = extractDeviceInfo(table, type); if (standard == null) { return Result.error(fileName + ": 设备信息提取失败"); } // 配置类型相关参数 configureStandard(standard, type, file); EamMaintenanceStandard exist = checkDuplicate(standard.getEquipmentId(), standard.getMaintenanceCategory(), MaintenanceStandardStatusEnum.ABOLISH.name()); if (exist != null) { return Result.error(fileName + ": 设备标准已存在，不能重复添加"); } standard.setStandardName(documentTitle); eamMaintenanceStandardMapper.insert(standard); standardId = standard.getId(); // 提取第一页的保养项目 if ("SECOND".equals(type)) { items.addAll(extractSecondMaintenanceItems(table, standardId, true)); } else if ("THIRD".equals(type)) { items.addAll(extractThirdMaintenanceItems(table, standardId, true)); } } else { // 后续页面 // 提取后续页面的保养项目 if ("SECOND".equals(type)) { items.addAll(extractSecondMaintenanceItems(table, standardId, false)); } else if ("THIRD".equals(type)) { items.addAll(extractThirdMaintenanceItems(table, standardId, false)); } } } // 验证设备信息提取 if (standard == null) { return Result.error(fileName + ": 设备信息提取失败"); } // 2. 后处理：根据不同类型进行处理 processItemsAfterExtraction(items, type); // 3. 项目验证 if (items.isEmpty()) { return Result.error(fileName + ": 未提取到任何保养项目"); } // 4. 保存项目 eamMaintenanceStandardDetailService.saveBatch(items); SysParams sysParams = sysParamsService.getSysPramBySettingKey("maintenance_import_type"); if (sysParams != null) { if (sysParams.getSettingValue().equals("1")) { standard.setStandardStatus(MaintenanceStandardStatusEnum.WAIT_SUBMIT.name()); eamMaintenanceStandardMapper.updateById(standard); } } else { return Result.error("未找到保养流程导入相关配置,请联系管理员"); } return Result.ok(fileName + ": 导入成功, 项目数: " + items.size()); } catch (ImportException e) { return Result.error(e.getMessage()); } catch (Exception e) { return Result.error(fileName + ": 系统错误 - " + e.getClass().getSimpleName()); } } /** * 后处理方法：根据不同类型进行处理 */ private void processItemsAfterExtraction(List items, String type) { if ("SECOND".equals(type)) { // 二级保养: 删除没有序号的数据 items.removeIf(item -> item.getItemCode() == null); } else { // 三级保养: // 1. 删除第一条数据（通常是标题行） if (!items.isEmpty()) { items.remove(0); } // 2. 为缺失部位的数据填充前一条的保养部位 String lastPart = ""; int i = 1; for (EamMaintenanceStandardDetail item : items) { item.setItemCode(i); if (item.getItemPart() != null && !item.getItemPart().isEmpty()) { lastPart = item.getItemPart(); } else if (!lastPart.isEmpty()) { item.setItemPart(lastPart); } i++; } } } /** * 提取二级保养项目（区分第一页和后续页面） */ private List extractSecondMaintenanceItems( XWPFTable table, String standardId, boolean isFirstTable) { List items = new ArrayList<>(); String currentCategory = null; int startRow = 0; // 对于第一页表格，跳过前两行（设备信息行） if (isFirstTable && table.getNumberOfRows() > 2) { startRow = 2; // 从第三行开始是保养内容 } for (int i = startRow; i < table.getNumberOfRows(); i++) { XWPFTableRow row = table.getRow(i); if (row == null) continue; // 检查是否是标题行（维修人员保养内容或操作人员保养内容） String firstCell = getCellText(row.getCell(0)); // 处理空行后的部位继承 if (firstCell.contains(REPAIR_TITLE)) { currentCategory = "REPAIRER_MAINTENANCE"; } else if (firstCell.contains(OPERATOR_TITLE)) { currentCategory = "OPERATOR_MAINTENANCE"; } // 处理普通项目行 if (currentCategory != null && isValidItemRow(row)) { EamMaintenanceStandardDetail item = new EamMaintenanceStandardDetail(); item.setItemCategory(currentCategory); item.setStandardId(standardId); // 提取序号（第二列） if (row.getTableCells().size() > 1) { String seqText = getCellText(row.getCell(1)); try { if (!seqText.equals("序号")) { item.setItemCode(Integer.parseInt(seqText.trim())); } } catch (NumberFormatException e) { // 忽略序号解析错误 } } // 提取内容（第三列） if (row.getTableCells().size() > 2) { String seqText = getCellText(row.getCell(2)); item.setItemName(seqText); } items.add(item); } } return items; } /** * 提取三级保养项目（解决跨页空行问题） */ private List extractThirdMaintenanceItems( XWPFTable table, String standardId, boolean isFirstTable) { List items = new ArrayList<>(); String currentPart = ""; int startRow = 0; // 对于第一页表格，跳过前两行（设备信息行） if (isFirstTable && table.getNumberOfRows() > 2) { startRow = 2; // 从第三行开始是保养内容 } for (int i = startRow; i < table.getNumberOfRows(); i++) { XWPFTableRow row = table.getRow(i); if (row == null) continue; // 确保行对象不为空 // 检查是否是空行（包含所有单元格都为空的情况） if (isRowEmpty(row)) { // 空行处理：保留当前位置但不创建项目 continue; } // 创建保养项目 EamMaintenanceStandardDetail item = new EamMaintenanceStandardDetail(); item.setStandardId(standardId); int colCount = row.getTableCells().size(); // 处理部位列（第一列） if (colCount > 0) { String firstCell = getCellText(row.getCell(0)).trim(); // 关键改进：正确处理空行后的部位继承 if (!firstCell.isEmpty() && !firstCell.equals("保养部位")) { // 更新当前部位 currentPart = firstCell; } item.setItemPart(currentPart); } else { // 如果没有单元格，使用当前部位 item.setItemPart(currentPart); } // 根据列数提取内容（考虑合并单元格情况） List cellContents = new ArrayList<>(); for (int j = 0; j < colCount; j++) { XWPFTableCell cell = row.getCell(j); String text = getCellText(cell).trim(); // 特殊处理：第二页第一行可能是空行后的内容 if (j == 0 && !text.isEmpty() && !text.equals(currentPart)) { // 如果不是部位列，则添加为内容 cellContents.add(text); } else if (j > 0) { // 其他列作为内容 cellContents.add(text); } } // 智能解析单元格内容 if (cellContents.size() >= 2) { // 默认处理方式：最后两个作为内容和标准 item.setItemName(cellContents.get(cellContents.size() - 2)); item.setItemDemand(cellContents.get(cellContents.size() - 1)); } else if (cellContents.size() == 1) { // 单列模式：视为内容 item.setItemName(cellContents.get(0)); } else if (!isRowEmpty(row)) { // 特殊处理：行非空但没有提取到内容（可能是复杂合并单元格） // 尝试提取整行文本作为内容 StringBuilder content = new StringBuilder(); for (XWPFTableCell cell : row.getTableCells()) { content.append(getCellText(cell).trim()).append(" "); } item.setItemName(content.toString().trim()); } items.add(item); } return items; } /** * 优化后的空行检测（解决跨页空行问题） */ private boolean isRowEmpty(XWPFTableRow row) { if (row == null || row.getTableCells().isEmpty()) { return true; } boolean allCellsEmpty = true; for (XWPFTableCell cell : row.getTableCells()) { String text = getCellText(cell).trim(); // 保留包含换行符等的单元格作为非空行 if (!text.isEmpty() && !text.replaceAll("\\s+", "").isEmpty()) { allCellsEmpty = false; break; } } return allCellsEmpty; } /** * 文档类型校验 - 防止二保传入三保或反之 */ private boolean isWrongDocumentType(XWPFTable table, String requestedType) { boolean hasRepairTitle = false; boolean hasOperatorTitle = false; boolean hasMaintenancePart = false; // 只检查前10行（通常标题在前几行） int maxRows = Math.min(table.getNumberOfRows(), 10); for (int i = 0; i < maxRows; i++) { XWPFTableRow row = table.getRow(i); if (row == null) continue; // 检查所有单元格内容 for (int j = 0; j < row.getTableCells().size(); j++) { String cellText = getCellText(row.getCell(j)); // 检查二级保养特征 if (cellText.contains(REPAIR_TITLE)) { hasRepairTitle = true; } if (cellText.contains(OPERATOR_TITLE)) { hasOperatorTitle = true; } // 检查三级保养特征 if (cellText.contains("保养部位")) { hasMaintenancePart = true; } } } // 逻辑判断 if ("SECOND".equals(requestedType)) { // 如果请求导入二级保养，但文档中有三级保养特征 return !(hasRepairTitle || hasOperatorTitle) || hasMaintenancePart; } else if ("THIRD".equals(requestedType)) { // 如果请求导入三级保养，但文档中有二级保养特征 return !hasMaintenancePart || (hasRepairTitle || hasOperatorTitle); } return false; } /** * 提取设备基本信息 */ private EamMaintenanceStandard extractDeviceInfo(XWPFTable table, String type) { if (table.getNumberOfRows() < 2) return null; // 提取前两行数据 Map row1Data = extractRowData(table.getRow(0)); Map row2Data = extractRowData(table.getRow(1)); // 创建设备标准对象 EamMaintenanceStandard standard = new EamMaintenanceStandard(); standard.setEquipmentText(row1Data.get("设备类别")); standard.setEquipmentCode(row1Data.get("设备编号")); standard.setEquipmentName(row2Data.get("设备名称")); standard.setEquipmentModel(row2Data.get("设备型号")); // 关联设备ID if (StrUtil.isNotEmpty(standard.getEquipmentCode())) { EamEquipment equipments = eamEquipmentService.selectByEquipmentCode(standard.getEquipmentCode()); if (equipments == null) { return null; } else { standard.setEquipmentId(equipments.getId()); } if (type.equals("THIRD")) { EamEquipmentExtend eamEquipmentExtend = eamEquipmentExtendService.getById(standard.getEquipmentId()); standard.setMaintenancePeriod(eamEquipmentExtend.getThirdMaintenancePeriod()); } } return standard; } /** * 表格行数据解析 */ private Map extractRowData(XWPFTableRow row) { Map data = new HashMap<>(); int cellCount = row.getTableCells().size(); try { // 键值对模式 (标签|值|标签|值) if (cellCount >= 4 && cellCount % 2 == 0) { for (int i = 0; i < cellCount; i += 2) { String key = cleanKey(getCellText(row.getCell(i))); String value = getCellText(row.getCell(i + 1)); if (!key.isEmpty()) data.put(key, value); } } // 连续单元格模式 else { for (int i = 0; i < cellCount; i++) { String text = getCellText(row.getCell(i)); int colonIndex = text.indexOf('：'); if (colonIndex > 0) { String key = cleanKey(text.substring(0, colonIndex)); String value = text.substring(colonIndex + 1); data.put(key, value); } } } } catch (Exception e) { log.error("行数据解析异常", e); } return data; } /** * 键名标准化处理 */ private String cleanKey(String key) { if (key == null) return ""; // 移除空格和中文冒号 return key.replaceAll("\\s", "").replace("：", ""); } /** * 配置保养标准参数 */ private void configureStandard(EamMaintenanceStandard standard, String type, MultipartFile file) { // 基础参数 String filename = file.getOriginalFilename(); if (filename != null && filename.contains(".")) { filename = filename.substring(0, filename.lastIndexOf('.')); } standard.setStandardName(filename) .setInitialDate(new Date()) .setStandardStatus(MaintenanceStandardStatusEnum.START.name()) .setStandardVersion("v" + CommonConstant.OPERATE_TYPE_1) .setDelFlag(0) .setStandardCode(businessCodeRuleService.generateBusinessCodeSeq( BusinessCodeConst.MAINTENANCE_STANDARD_CODE_RULE )); // 类型特定参数 if ("SECOND".equals(type)) { standard.setMaintenanceCategory("SECOND_MAINTENANCE") .setMaintenancePeriod(6) .setPeriodUnit("月"); } else { standard.setMaintenanceCategory("THIRD_MAINTENANCE") .setPeriodUnit("年"); // 获取三级保养周期 if (standard.getEquipmentId() != null) { EamEquipmentExtend extend = eamEquipmentExtendService.getById(standard.getEquipmentId()); if (extend != null) { standard.setMaintenancePeriod(extend.getThirdMaintenancePeriod()); } } } } /** * 兼容版单元格文本提取 */ private String getCellText(XWPFTableCell cell) { if (cell == null) return ""; StringBuilder text = new StringBuilder(); for (XWPFParagraph para : cell.getParagraphs()) { if (para != null) { for (XWPFRun run : para.getRuns()) { if (run != null) { String runText = run.getText(0); if (runText != null) { text.append(runText); } } } } } return text.toString(); } /** * 验证有效项目行 */ private boolean isValidItemRow(XWPFTableRow row) { return row != null && row.getTableCells().size() >= 2 && !getCellText(row.getCell(1)).trim().isEmpty(); } /*导入二保三保文件Excel--------------------------结束*/ }