修改word导入

lyh

2025-07-09 25b490eb79a0f64c9e0cd32d21b9178aa82929f8

 lxzn-module-eam/src/main/java/org/jeecg/modules/eam/service/impl/EamMaintenanceStandardServiceImpl.java

@@ -12,6 +12,7 @@
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;
@@ -19,17 +20,21 @@
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.modules.eam.base.entity.BaseFactory;
import org.jeecg.modules.eam.base.entity.BaseFactoryUser;
import org.jeecg.modules.eam.base.service.IBaseFactoryService;
import org.jeecg.modules.eam.base.service.IBaseFactoryUserService;
import org.jeecg.modules.system.entity.BaseFactory;
import org.jeecg.modules.system.entity.BaseFactoryUser;
import org.jeecg.modules.system.service.IBaseFactoryService;
import org.jeecg.modules.system.service.IBaseFactoryUserService;
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;
@@ -40,6 +45,7 @@
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.service.ISysBusinessCodeRuleService;
import org.jeecg.modules.system.service.ISysUserService;
import org.jeecg.modules.system.vo.UserSelector;
import org.springframework.beans.BeanUtils;
@@ -87,6 +93,22 @@
    private ISysUserService sysUserService;
    @Autowired
    private IEamEquipmentService eamEquipmentService;
    @Autowired
    private IEamEquipmentExtendService eamEquipmentExtendService;
    @Autowired
    private ISysBusinessCodeRuleService businessCodeRuleService;

    // 常量定义
    private static final String REPAIR_TITLE = "维修人员保养内容";
    private static final String OPERATOR_TITLE = "操作人员保养内容";
    private static final Map<String, EamMaintenanceStandardDetailCategory> 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<EamMaintenanceStandard> queryPageList(Page<EamMaintenanceStandard> page, EamMaintenanceStandard eamMaintenanceStandard) {
        QueryWrapper<EamMaintenanceStandard> queryWrapper = new QueryWrapper<>();
@@ -107,7 +129,7 @@
            if(!CollectionUtils.isEmpty(baseFactoryUserList)){
                List<String> factoryIds = baseFactoryUserList.stream().map(BaseFactoryUser::getFactoryId).collect(Collectors.toList());
                List<String> factoryCode= baseFactoryService.listByIds(factoryIds).stream().map(BaseFactory::getFactoryCode).collect(Collectors.toList());
                queryWrapper.in("e.factory_code", factoryCode);
                queryWrapper.in("e.factory_org_code", factoryCode);
            }
        }
        if(eamMaintenanceStandard != null) {
@@ -159,7 +181,7 @@
        //删除标记
        entity.setDelFlag(CommonConstant.DEL_FLAG_0);
        //重复性校验
        EamMaintenanceStandard exist = checkDuplicate(entity.getEquipmentId(), entity.getMaintenanceCategory());
        EamMaintenanceStandard exist = checkDuplicate(entity.getEquipmentId(), entity.getMaintenanceCategory(),MaintenanceStandardStatusEnum.WAIT_SUBMIT.name());
        if(exist != null){
            throw new JeecgBootException("设备标准已存在，不能重复添加！");
        }
@@ -225,6 +247,7 @@
        newEntity.setMaintenanceCategory(standardRequest.getMaintenanceCategory());
        newEntity.setMaintenancePeriod(standardRequest.getMaintenancePeriod());
        newEntity.setInitialDate(standardRequest.getInitialDate());
        newEntity.setPeriodUnit(standardRequest.getPeriodUnit());
        newEntity.setStandardStatus(MaintenanceStandardStatusEnum.WAIT_SUBMIT.name());
        //版本递增
        //获取数字
@@ -242,7 +265,7 @@
        //删除标记
        newEntity.setDelFlag(CommonConstant.DEL_FLAG_0);
        //重复性校验
        EamMaintenanceStandard exist = checkDuplicate(newEntity.getEquipmentId(), newEntity.getMaintenanceCategory());
        EamMaintenanceStandard exist = checkDuplicate(newEntity.getEquipmentId(), newEntity.getMaintenanceCategory(),MaintenanceStandardStatusEnum.WAIT_SUBMIT.name());
        if(exist != null){
            throw new JeecgBootException("设备标准已存在，不能重复添加！");
        }
@@ -263,12 +286,12 @@
    }

    @Override
    public EamMaintenanceStandard checkDuplicate(String equipmentId, String maintenanceCategory) {
    public EamMaintenanceStandard checkDuplicate(String equipmentId, String maintenanceCategory,String standardStatus) {
        LambdaQueryWrapper<EamMaintenanceStandard> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(EamMaintenanceStandard::getEquipmentId, equipmentId);
        queryWrapper.eq(EamMaintenanceStandard::getMaintenanceCategory, maintenanceCategory);
        queryWrapper.eq(EamMaintenanceStandard::getDelFlag, CommonConstant.DEL_FLAG_0);
        queryWrapper.eq(EamMaintenanceStandard::getStandardStatus, MaintenanceStandardStatusEnum.WAIT_SUBMIT.name());
        queryWrapper.eq(EamMaintenanceStandard::getStandardStatus, standardStatus);
        queryWrapper.orderByDesc(EamMaintenanceStandard::getStandardVersion);

        List<EamMaintenanceStandard> list = eamMaintenanceStandardMapper.selectList(queryWrapper);
@@ -301,7 +324,7 @@
        LambdaQueryWrapper<EamMaintenanceStandard> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(EamMaintenanceStandard::getDelFlag, CommonConstant.DEL_FLAG_0);
        queryWrapper.eq(EamMaintenanceStandard::getMaintenanceCategory, maintenanceCategory);
        queryWrapper.eq(EamMaintenanceStandard::getStandardStatus, MaintenanceStandardStatusEnum.WAIT_SUBMIT.name());
        queryWrapper.eq(EamMaintenanceStandard::getStandardStatus, MaintenanceStandardStatusEnum.START.name());
        return eamMaintenanceStandardMapper.selectList(queryWrapper);
    }

@@ -347,7 +370,7 @@
            FlowMyBusiness flowMyBusiness = businessList.get(0);
            EamEquipment eamEquipment=eamEquipmentService.getById(maintenanceStandard.getEquipmentId());
            BaseFactory baseFactory=baseFactoryService.getOne(new QueryWrapper<BaseFactory>().eq("org_code", eamEquipment.getFactoryOrgCode()));
            List<UserSelector> userSelectorList=sysUserService.selectOperatorFactoryList(eamEquipment.getEquipmentCode(),baseFactory.getId(), BusinessCodeConst.PCR0007);
            List<UserSelector> userSelectorList=sysUserService.selectOperatorFactoryList(eamEquipment.getEquipmentCode(),baseFactory.getId(), BusinessCodeConst.PCR0008);
            if (!CollectionUtils.isEmpty(userSelectorList)) {
                List<String> usernameList=userSelectorList.stream().map(UserSelector::getUsername).collect(Collectors.toList());
                flowMyBusiness.setTodoUsers(JSON.toJSONString(usernameList));
@@ -427,7 +450,7 @@
                        EamMaintenanceStandard maintenanceStandard=this.getById(eamMaintenanceStandardVo.getDataId());
                        EamEquipment eamEquipment=eamEquipmentService.getById(maintenanceStandard.getEquipmentId());
                        BaseFactory baseFactory=baseFactoryService.getOne(new QueryWrapper<BaseFactory>().eq("org_code", eamEquipment.getFactoryOrgCode()));
                        List<UserSelector> userSelectorList=sysUserService.selectOperatorFactoryList(eamEquipment.getEquipmentCode(),baseFactory.getId(), BusinessCodeConst.PCR0008);
                        List<UserSelector> userSelectorList=sysUserService.selectOperatorFactoryList(eamEquipment.getEquipmentCode(),baseFactory.getId(), BusinessCodeConst.PCR0009);
                        if (!CollectionUtils.isEmpty(userSelectorList)) {
                            List<String> usernameList=userSelectorList.stream().map(UserSelector::getUsername).collect(Collectors.toList());
                            newflowMyBusiness.setTodoUsers(JSON.toJSONString(usernameList));
@@ -520,7 +543,7 @@
    /*流程业务代码--------------------------结束*/


    /*导入文件--------------------------开始*/
    /*导入点检文件Excel--------------------------开始*/
    /**
        * 点检表导入入口
    */
@@ -536,17 +559,33 @@
            // 1. 提取设备信息
            EamMaintenanceStandard eamMaintenanceStandard = extractDeviceInfo(sheet);
            if (eamMaintenanceStandard == null) {
                throw new BusinessException("设备信息提取失败");
                return Result.error("设备信息提取失败");
            }else {
                if (eamMaintenanceStandard.getEquipmentId() == null) {
                    return Result.error("设备信息提取失败");
                }
            }

            eamMaintenanceStandard.setStandardName(name);

            EamMaintenanceStandard exist = checkDuplicate(eamMaintenanceStandard.getEquipmentId(), eamMaintenanceStandard.getMaintenanceCategory(),MaintenanceStandardStatusEnum.START.name());
            if(exist != null){
                return Result.error(name + ": 设备标准已存在，不能重复添加");
            }

            eamMaintenanceStandardMapper.insert(eamMaintenanceStandard);

            // 2. 提取每日点检项目
            List<EamMaintenanceStandardDetail> dailyDetails = extractDailyItems(sheet, eamMaintenanceStandard);
            if(dailyDetails.isEmpty()){
                return Result.error("未找到每日点检项目");
            }

            // 3. 提取周保养项目
            List<EamMaintenanceStandardDetail> weeklyDetails = extractWeeklyItems(sheet, eamMaintenanceStandard);
            if(weeklyDetails.isEmpty()){
                return Result.error("未找到周保养项目");
            }

            // 合并并保存所有项目
            List<EamMaintenanceStandardDetail> allDetails = new ArrayList<>();
@@ -617,8 +656,8 @@

        EamMaintenanceStandard standard = new EamMaintenanceStandard();
        standard.setEquipmentName(extractField(headerText, "设备名称[:：]\\s*(\\S+)"));
        standard.setEquipmentId(extractField(headerText, "设备型号[:：]\\s*(\\S+)"));
        standard.setStandardCode(extractField(headerText, "统一编号[:：]\\s*(\\S+)"));
        standard.setEquipmentCode(extractField(headerText, "统一编号[:：]\\s*(\\S+)"));


        // 日期处理
        String dateStr = extractField(headerText, "日期[:：]\\s*(\\S+)");
@@ -633,11 +672,23 @@
            }
        }

        // 关联设备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;
    }
@@ -800,7 +851,7 @@
    }

    /**
        * 识别新表头开始
     * 识别新表头开始
    */
    private boolean isNewHeaderStart(Row row) {
        for (int colIdx = 0; colIdx < row.getLastCellNum(); colIdx++) {
@@ -837,7 +888,6 @@
    */
    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) : "";
@@ -848,7 +898,6 @@
    */
    private String getCellStringValue(Cell cell) {
        if (cell == null) return "";

        switch (cell.getCellType()) {
            case STRING:
                return cell.getStringCellValue().trim();
@@ -886,5 +935,482 @@
            return "";
        }
    }
    /*导入文件--------------------------结束*/
    /*导入点检文件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())) {
            // 基础验证
            if (doc.getTables().isEmpty()) {
                return Result.error(fileName + ": 文档中未找到表格");
            }

            List<XWPFTable> tables = doc.getTables();
            EamMaintenanceStandard standard = null;
            boolean firstTableProcessed = false;
            List<EamMaintenanceStandardDetail> 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.START.name());
                    if(exist != null){
                        return Result.error(fileName + ": 设备标准已存在，不能重复添加");
                    }
                    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);

            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<EamMaintenanceStandardDetail> items, String type) {
        if ("SECOND".equals(type)) {
            // 二级保养: 删除没有序号的数据
            items.removeIf(item -> item.getItemCode() == null);
        } else {
            // 三级保养:
            // 1. 删除第一条数据（通常是标题行）
            if (!items.isEmpty()) {
                items.remove(0);
            }

            // 2. 为缺失部位的数据填充前一条的保养部位
            String lastPart = "";
            for (EamMaintenanceStandardDetail item : items) {
                if (item.getItemPart() != null && !item.getItemPart().isEmpty()) {
                    lastPart = item.getItemPart();
                } else if (!lastPart.isEmpty()) {
                    item.setItemPart(lastPart);
                }
            }
        }
    }
    /**
     * 提取二级保养项目（区分第一页和后续页面）
     */
    private List<EamMaintenanceStandardDetail> extractSecondMaintenanceItems(
            XWPFTable table, String standardId, boolean isFirstTable) {

        List<EamMaintenanceStandardDetail> 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<EamMaintenanceStandardDetail> extractThirdMaintenanceItems(
            XWPFTable table, String standardId, boolean isFirstTable) {

        List<EamMaintenanceStandardDetail> 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.setItemCategory("THIRD_MAINTENANCE");
            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<String> 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 (cellContents.isEmpty() && !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<String, String> row1Data = extractRowData(table.getRow(0));
        Map<String, String> 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<String, String> extractRowData(XWPFTableRow row) {
        Map<String, String> 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--------------------------结束*/

}