Merge remote-tracking branch 'origin/master'

code/swc/nckd-jxccl-swc/src/main/java/nckd/jxccl/swc/constants/SwcConstant.java

@@ -18,4 +18,6 @@ public class SwcConstant {
     public static final HRBaseServiceHelper AGENCYPAYBILL_ENTITY = new HRBaseServiceHelper("nckd_agencypaybill");
     /* 年收入统计单 */
     public static final HRBaseServiceHelper SALANNUALINCOMEBILL_ENTITY = new HRBaseServiceHelper("nckd_salannualincomebill");
+    /* 外单位导入项目 */
+    public static final HRBaseServiceHelper OUTIMPORTITEM_ENTITY = new HRBaseServiceHelper("nckd_outimportitem");
 }

code/swc/nckd-jxccl-swc/src/main/java/nckd/jxccl/swc/hsas/business/outdata/OutImportTaskGuideExportService.java

@@ -0,0 +1,491 @@
+package nckd.jxccl.swc.hsas.business.outdata;
+
+import com.google.common.collect.Lists;
+import com.kingdee.util.DateTimeUtils;
+import kd.bos.dataentity.entity.DynamicObject;
+import kd.bos.dataentity.resource.ResManager;
+import kd.bos.dataentity.utils.StringUtils;
+import kd.bos.exception.ErrorCode;
+import kd.bos.exception.KDException;
+import kd.bos.form.FormShowParameter;
+import kd.bos.form.IFormView;
+import kd.bos.logging.Log;
+import kd.bos.logging.LogFactory;
+import kd.bos.orm.query.QFilter;
+import kd.bos.orm.util.CollectionUtils;
+import nckd.jxccl.base.sit.helper.SITExportDataHelper;
+import nckd.jxccl.sit.hcsi.business.importtaskguide.utils.ImportTaskUtils;
+import nckd.jxccl.sit.hcsi.common.constant.enums.DataTypeEnum;
+import nckd.jxccl.sit.hcsi.common.constant.enums.SITShowType;
+import nckd.jxccl.sit.hcsi.formplugin.web.tp.enums.SinsurPresetItemEnum;
+import nckd.jxccl.swc.hsas.business.utils.OutImportTaskUtils;
+import nckd.jxccl.swc.hsas.common.OutImpPresetItem;
+import nckd.jxccl.swc.hsas.formplugin.web.outdata.helper.OutImpTemplateHelper;
+import org.apache.poi.hssf.util.HSSFColor;
+import org.apache.poi.ss.usermodel.*;
+import org.apache.poi.ss.util.CellRangeAddressList;
+import org.apache.poi.xssf.streaming.*;
+import org.apache.poi.xssf.usermodel.XSSFClientAnchor;
+import org.apache.poi.xssf.usermodel.XSSFRichTextString;
+
+import java.text.MessageFormat;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * Tyx 2025-10-21
+ * 导出Service，nckd_taskguideimport
+ */
+public class OutImportTaskGuideExportService {
+
+    private static final Log logger = LogFactory.getLog(OutImportTaskGuideExportService.class);
+    private static final int PAGE_SIZE = 500;
+    private static final String TPLERROR = "1";
+    private static final String IMPORT_ERROR_TEMPLATE = "外部数据导入任务_数据导入失败结果_{0}";
+    private static final String DATA_IMPORT_SHEET = "数据导入模板";
+    private static final String ERROR_CODE = "getImportErrorExcelFile_error";
+    private static final int COLUMN_WIDTH_MULTIPLIER = 3;
+    private static final int FIRST_COLUMN_WIDTH_MULTIPLIER = 4;
+
+    /**
+     * 导入模板方法
+     *
+     * @param view
+     */
+    public void exportExcelTemplate(IFormView view) {
+        logger.info("-------- begin exportExcelTemplate --------");
+
+        try {
+            SXSSFWorkbook wb = new SXSSFWorkbook(500);
+            Throwable exp = null;
+            try {
+                FormShowParameter parameter = view.getFormShowParameter();
+                // 外部系统数据导入模板
+                Long tplId = (Long) parameter.getCustomParam("outimpTplId");
+                // 导入任务ID
+                Long importTaskId = (Long) parameter.getCustomParam("importTaskId");
+                String dd = DateTimeUtils.format(new Date(), "yyyyMMdd");
+                String exportFileName = MessageFormat.format(ResManager.loadKDString("外单位数据导入任务_数据导入模板_{0}", "ImportTaskGuideExportService_1", "swc-hsas-business", new Object[0]), dd);
+                createImportTaskDataSheet(tplId, wb, importTaskId);
+                flushAllAndDownload(wb, exportFileName, view);
+            } catch (Throwable var18) {
+                exp = var18;
+                throw var18;
+            } finally {
+                if (wb != null) {
+                    if (exp != null) {
+                        try {
+                            wb.close();
+                        } catch (Throwable e1) {
+                            exp.addSuppressed(e1);
+                        }
+                    } else {
+                        wb.close();
+                    }
+                }
+
+            }
+        } catch (Exception e2) {
+            logger.error("ImportTaskGuideExportService  error : ", e2);
+            String str = ResManager.loadKDString("下载导入模板失败。", "ImportTaskGuideExportService_0", "swc-hsas-business", new Object[0]);
+            view.showErrorNotification(str);
+        }
+        logger.info("end exportExcelTemplate");
+    }
+
+    /**
+     * 创建Excel
+     *
+     * @param tplId
+     * @param wb
+     * @param importTaskId
+     */
+    private void createImportTaskDataSheet(Long tplId, SXSSFWorkbook wb, Long importTaskId) {
+        DynamicObject sinsurData = OutImportTaskUtils.getTplData(tplId, "id,number,nckd_startline", (QFilter) null);
+        int startLine = sinsurData.getInt("nckd_startline");
+        String sheetName = ResManager.loadKDString("数据导入模板", "ImportTaskGuideExportService_2", "swc-hsas-business", new Object[0]);
+        SXSSFSheet sheet = wb.createSheet(sheetName);
+        sheet.setRandomAccessWindowSize(-1);
+        SXSSFDrawing drawingPatriarch = sheet.createDrawingPatriarch();
+        SXSSFRow headRow = sheet.createRow(startLine - 2);
+        CellStyle headDateStyle = getColumnStyle(true, 0, 0, SITShowType.DATE.getCode(), HorizontalAlignment.LEFT, sheet.getWorkbook(), HSSFColor.HSSFColorPredefined.GREY_25_PERCENT.getIndex(), true);
+        CellStyle headTextStyle = getColumnStyle(true, 0, 0, SITShowType.TEXT.getCode(), HorizontalAlignment.LEFT, sheet.getWorkbook(), HSSFColor.HSSFColorPredefined.GREY_25_PERCENT.getIndex(), true);
+        CellStyle headRequriedNumStyle = getColumnStyle(true, 0, 0, SITShowType.NUM.getCode(), HorizontalAlignment.LEFT, sheet.getWorkbook(), HSSFColor.HSSFColorPredefined.GREY_25_PERCENT.getIndex(), true);
+        Font font = sheet.getWorkbook().createFont();
+        CellStyle requrriedStyle = getColumnStyle(true, 0, 0, SITShowType.TEXT.getCode(), HorizontalAlignment.LEFT, sheet.getWorkbook(), HSSFColor.HSSFColorPredefined.GREY_25_PERCENT.getIndex(), true);
+        font.setColor((short) 10);
+        requrriedStyle.setFont(font);
+        headRequriedNumStyle.setFont(font);
+        Map<Long, OutImpPresetItem> itemEnumMap = OutImpTemplateHelper.getPresetItemEnumMap();
+        List<Map<String, String>> columnHeadList = OutImportTaskUtils.getColumnHeadList(tplId, importTaskId);
+        List<Integer> textIndexList = new ArrayList(columnHeadList.size());
+        Set<Integer> allIndexSet = new HashSet(columnHeadList.size());
+        OutImpPresetItem presetItemEnum = null;
+        for (int i = 0; i < columnHeadList.size(); ++i) {
+            Map<String, String> columnHead = columnHeadList.get(i);
+            String columnIndexStr = (String) columnHead.get("columnIndex");
+            String dataTypeIdStr = (String) columnHead.get("datatypeid");
+            String name = (String) columnHead.get("name");
+            String itemType = (String) columnHead.get("itemType");
+            String comment = (String) columnHead.get("comment");
+            int columnIndex = Integer.parseInt(columnIndexStr);
+            if (allIndexSet.add(columnIndex) && !textIndexList.contains(columnIndex)) {
+                if (Long.parseLong(dataTypeIdStr) == DataTypeEnum.STRING.getDbId()) {
+                    textIndexList.add(columnIndex);
+                }
+                if ("0".equals(itemType)) {
+                    presetItemEnum = (OutImpPresetItem) itemEnumMap.get(Long.valueOf((String) columnHead.get("id")));
+                    CellStyle style = this.getFixCellStyle(presetItemEnum, requrriedStyle, headDateStyle, headTextStyle, headRequriedNumStyle);
+                    this.createCell(comment, headRow, columnIndex, presetItemEnum.getItemName(), true, style, this.getDataType(presetItemEnum), drawingPatriarch);
+                } else {
+                    this.createCell(comment, headRow, columnIndex, name, false, headTextStyle, dataTypeIdStr, drawingPatriarch);
+                }
+            }
+        }
+
+        Iterator<Integer> it = allIndexSet.iterator();
+        while (it.hasNext()) {
+            int index = (Integer) it.next();
+            int columnIndex = sheet.getColumnWidth(index);
+            sheet.setColumnWidth(index, columnIndex * 3);
+        }
+
+        // 添加数据验证（下拉列表）
+        //  TODO this.addDataValidations(sheet, columnHeadList, startLine - 1);
+
+        this.batchSetDefaulColumnStyle(sheet, textIndexList, this.getTextCellStyle(sheet));
+    }
+
+    private void addDataValidations(SXSSFSheet sheet, List<Map<String, String>> columnHeadList, int firstDataRowIndex) {
+        for (int i = 0; i < columnHeadList.size(); i++) {
+            Map<String, String> columnHead = columnHeadList.get(i);
+            String itemType = columnHead.get("itemType");
+
+            // 如果是预设项（itemType为"0"）
+            if ("0".equals(itemType)) {
+                Long itemId = Long.valueOf(columnHead.get("id"));
+                OutImpPresetItem presetItem = OutImpTemplateHelper.getPresetItemEnumMap().get(itemId);
+
+                // 检查是否有预定义的下拉选项
+                if (presetItem != null && hasDropdownOptions(presetItem)) {
+                    String[] options = getDropdownOptions(presetItem);
+                    if (options != null && options.length > 0) {
+                        // 创建数据验证
+                        int columnIndex = Integer.parseInt(columnHead.get("columnIndex"));
+                        setDataValidation(sheet, options, columnIndex, firstDataRowIndex);
+                    }
+                }
+            }
+        }
+    }
+
+
+    private boolean hasDropdownOptions(OutImpPresetItem presetItem) {
+        // 根据实际业务逻辑判断是否需要下拉列表
+        // 这里需要根据你的业务需求实现
+        return true;
+    }
+
+    private String[] getDropdownOptions(OutImpPresetItem presetItem) {
+        // 获取下拉选项数组
+        // 这里需要根据你的业务需求实现
+        return new String[]{"选项1", "选项2", "选项3"};
+    }
+
+    private void setDataValidation(SXSSFSheet sheet, String[] options, int columnIndex, int firstDataRowIndex) {
+        // 创建下拉列表约束
+        DataValidationHelper validationHelper = sheet.getDataValidationHelper();
+        DataValidationConstraint constraint = validationHelper.createExplicitListConstraint(options);
+
+        // 设置应用范围（从第一行数据开始到最后一行）
+        CellRangeAddressList addressList = new CellRangeAddressList(
+                firstDataRowIndex, 65535, columnIndex, columnIndex);
+
+        // 创建数据验证
+        DataValidation validation = validationHelper.createValidation(constraint, addressList);
+        validation.setSuppressDropDownArrow(true);
+        validation.setShowErrorBox(true);
+
+        // 添加到工作表
+        sheet.addValidationData(validation);
+    }
+
+    private CellStyle getFixCellStyle(OutImpPresetItem presetItemEnum, CellStyle requrriedStyle, CellStyle headDateStyle, CellStyle headTextStyle, CellStyle headRequriedNumStyle) {
+//        if (presetItemEnum.isRequire()) {
+//            return presetItemEnum.getDataTypeId() == DataTypeEnum.NUMBERIC.getDbId() ? headRequriedNumStyle : requrriedStyle;
+//        } else {
+//            return presetItemEnum.getDataTypeId() == DataTypeEnum.DATE.getDbId() ? headDateStyle : headTextStyle;
+//        }
+        return presetItemEnum.getDataTypeId() == DataTypeEnum.DATE.getDbId() ? headDateStyle : headTextStyle;
+    }
+
+    private void createCell(String comment, SXSSFRow headRow, int cellIndex, String name, boolean isRequried, CellStyle cellStyle, String dataType, SXSSFDrawing drawingPatriarch) {
+        SXSSFCell cell = headRow.createCell(cellIndex);
+        String value = "";
+        if (isRequried) {
+            value = "*" + name;
+        } else {
+            value = name;
+        }
+        cell.setCellValue(value);
+        cell.setCellStyle(cellStyle);
+        if (dataType != null) {
+            cell.setCellComment(this.getComment(comment, drawingPatriarch, cell));
+        }
+    }
+
+    private Comment getComment(String commentStr, SXSSFDrawing drawingPatriarch, SXSSFCell cell) {
+        Comment comment = drawingPatriarch.createCellComment(new XSSFClientAnchor(cell.getColumnIndex(), cell.getRowIndex(), cell.getColumnIndex() + 1, cell.getRowIndex() + 2, cell.getColumnIndex(), cell.getRowIndex(), cell.getColumnIndex() + 1, cell.getRowIndex() + 2));
+        comment.setString(new XSSFRichTextString(commentStr));
+        return comment;
+    }
+
+    private void batchSetDefaulColumnStyle(SXSSFSheet sheet, List<Integer> indexList, CellStyle cellStyle) {
+        Iterator var4 = indexList.iterator();
+        while (var4.hasNext()) {
+            int index = (Integer) var4.next();
+            sheet.setDefaultColumnStyle(index, cellStyle);
+        }
+    }
+
+    private CellStyle getTextCellStyle(SXSSFSheet sheet) {
+        CellStyle textCellStyle = sheet.getWorkbook().createCellStyle();
+        textCellStyle.setDataFormat((short) 49);
+        return textCellStyle;
+    }
+
+    private String getDataType(OutImpPresetItem presetItemEnum) {
+        if (presetItemEnum.getDataTypeId() == DataTypeEnum.DATE.getDbId()) {
+            return SITShowType.DATE.getCode();
+        } else {
+            return presetItemEnum.getDataTypeId() == DataTypeEnum.NUMBERIC.getDbId() ? SITShowType.NUM.getCode() : SITShowType.TEXT.getCode();
+        }
+    }
+
+    private void flushAllAndDownload(SXSSFWorkbook wb, String fileName, IFormView view) {
+        String url = SITExportDataHelper.storeFile(wb, fileName);
+        if (StringUtils.isNotEmpty(url)) {
+            view.download(url);
+        }
+    }
+
+    public String getImportErrorExcelFile(List<Map<Integer, String>> dataHeadList, List<Map<Integer, String>> dataRowList, List<Map<String, String>> errDataList,
+                                          int headIndex, String writeTaskType, Map<Integer, List<Map<String, String>>> columnIndexMap, boolean hasWorkStartDate) {
+        logger.info("getImportErrorExcelFile begin");
+        String url = "";
+        int rowNum = headIndex + dataRowList.size() + 2;
+
+        try {
+            SXSSFWorkbook wb = new SXSSFWorkbook(rowNum);
+
+            try {
+                String dd = DateTimeUtils.format(new Date(), "yyyyMMdd");
+                String exportFileName = MessageFormat.format(ResManager.loadKDString("历史数据迁移任务_数据导入失败结果_{0}", "ImportTaskGuideExportService_3", "swc-hsas-business", new Object[0]), dd);
+                String sheetName = ResManager.loadKDString("数据导入模板", "ImportTaskGuideExportService_2", "swc-hsas-business", new Object[0]);
+                SXSSFSheet sheet = wb.createSheet(sheetName);
+                sheet.setRandomAccessWindowSize(-1);
+                SXSSFDrawing drawingPatriarch = sheet.createDrawingPatriarch();
+                this.createHeadRow(dataHeadList, headIndex, sheet, drawingPatriarch, writeTaskType);
+                this.batchSetDefaulColumnStyle(sheet, this.getTextColumnIndexList(columnIndexMap), this.getTextCellStyle(sheet));
+                Set<Integer> allIndexSet = new HashSet(columnIndexMap.size() + 12);
+                Iterator var18 = columnIndexMap.keySet().iterator();
+
+                while (true) {
+                    int index;
+                    if (!var18.hasNext()) {
+                        allIndexSet.addAll(Lists.newArrayList(new Integer[]{1, 2, 3, 4}));
+                        sheet.setColumnWidth(0, sheet.getColumnWidth(0) * 4);
+                        var18 = allIndexSet.iterator();
+
+                        while (var18.hasNext()) {
+                            index = (Integer) var18.next();
+                            int columnWidth = sheet.getColumnWidth(index);
+                            sheet.setColumnWidth(index, columnWidth * 3);
+                        }
+
+                        this.addDataRow(dataRowList, errDataList, headIndex, wb, sheet);
+                        url = SITExportDataHelper.storeFile(wb, exportFileName);
+                        break;
+                    }
+
+                    index = (Integer) var18.next();
+                    allIndexSet.add(index + 1);
+                }
+            } catch (Throwable e) {
+                throw e;
+            }
+        } catch (Exception e) {
+            logger.error("getImportErrorExcelFile  error : ", e);
+            throw new KDException(e, new ErrorCode("getImportErrorExcelFile_error", e.getMessage()), new Object[0]);
+        }
+
+        logger.info("getImportErrorExcelFile end");
+        return url;
+    }
+
+    private void createHeadRow(List<Map<Integer, String>> dataHeadList, int headIndex, SXSSFSheet sheet, SXSSFDrawing drawingPatriarch, String writeTaskType) {
+        SXSSFRow headRow = sheet.createRow(headIndex);
+        CellStyle headTextStyle = getColumnStyle(true, 0, 0, SITShowType.TEXT.getCode(), HorizontalAlignment.LEFT, sheet.getWorkbook(), HSSFColor.HSSFColorPredefined.GREY_25_PERCENT.getIndex(), true);
+        SXSSFCell errMsgCell = headRow.createCell(0);
+        errMsgCell.setCellValue(ResManager.loadKDString("失败原因", "CalResultCoverImportService_58", "swc-hsas-business", new Object[0]));
+        errMsgCell.setCellStyle(headTextStyle);
+        Font font = sheet.getWorkbook().createFont();
+        CellStyle requrriedStyle = getColumnStyle(true, 0, 0, SITShowType.TEXT.getCode(), HorizontalAlignment.LEFT, sheet.getWorkbook(), HSSFColor.HSSFColorPredefined.GREY_25_PERCENT.getIndex(), true);
+        font.setColor((short)10);
+        requrriedStyle.setFont(font);
+        Set<Integer> requireFixColumnSet = ImportTaskUtils.getExportTplRequireColumnSet();
+        Map<Integer, String> headMap = (Map)dataHeadList.get(0);
+        CellStyle style = null;
+
+        Map.Entry entry;
+        for(Iterator var15 = headMap.entrySet().iterator(); var15.hasNext(); this.createCell("", headRow, (Integer)entry.getKey() + 1, (String)entry.getValue(), false, style, (String)null, drawingPatriarch)) {
+            entry = (Map.Entry)var15.next();
+            if (requireFixColumnSet.contains(entry.getKey())) {
+                style = requrriedStyle;
+            } else {
+                style = headTextStyle;
+            }
+        }
+    }
+
+    private List<Integer> getTextColumnIndexList(Map<Integer, List<Map<String, String>>> columnIndexMap) {
+        List<Integer> textIndexList = new ArrayList(columnIndexMap.size() + 12);
+        textIndexList.addAll(Lists.newArrayList(new Integer[]{1, 2, 3, 4}));
+        Iterator var5 = columnIndexMap.entrySet().iterator();
+        while(var5.hasNext()) {
+            Map.Entry<Integer, List<Map<String, String>>> entry = (Map.Entry)var5.next();
+            List<Map<String, String>> paramMapList = (List)entry.getValue();
+            if (!CollectionUtils.isEmpty(paramMapList)) {
+                String dataTypeIdStr = (String)((Map)paramMapList.get(0)).get("datatypeid");
+                if (!StringUtils.isEmpty(dataTypeIdStr) && Long.parseLong(dataTypeIdStr) == DataTypeEnum.STRING.getDbId()) {
+                    textIndexList.add((Integer)entry.getKey() + 1);
+                }
+            }
+        }
+        return textIndexList;
+    }
+
+    private void addDataRow(List<Map<Integer, String>> dataRowList, List<Map<String, String>> errDataList, int headIndex, SXSSFWorkbook wb, SXSSFSheet sheet) {
+        Map<Integer, List<String>> errorMap = this.getErrorMap(errDataList);
+        boolean isTplError = "1".equals(((Map)errDataList.get(0)).get("isAll"));
+        int tplIndex = headIndex++;
+        CellStyle errColumnStyle = getColumnStyle(true, 0, 0, "text", HorizontalAlignment.LEFT, wb, (short)9, true);
+        Font font = wb.createFont();
+        font.setColor((short)10);
+        errColumnStyle.setFont(font);
+        CellStyle columnStyle = getColumnStyle(true, 0, 0, "text", HorizontalAlignment.LEFT, wb, (short)9, true);
+        List<String> errorList = null;
+        Map<Integer, String> rowMap = null;
+        SXSSFRow dataRow = null;
+        SXSSFCell cell = null;
+        int index = 0;
+
+        for(int length = dataRowList.size(); index < length; ++index) {
+            errorList = (List)errorMap.get(index);
+            if (isTplError) {
+                errorList = (List)errorMap.get(tplIndex);
+            }
+
+            if (errorList != null) {
+                rowMap = (Map)dataRowList.get(index);
+                dataRow = sheet.createRow(headIndex);
+                ++headIndex;
+                cell = dataRow.createCell(0);
+                cell.setCellStyle(errColumnStyle);
+                cell.setCellValue(this.getErrorMsg(errorList));
+                Iterator var18 = rowMap.entrySet().iterator();
+
+                while(var18.hasNext()) {
+                    Map.Entry<Integer, String> entry = (Map.Entry)var18.next();
+                    cell = dataRow.createCell((Integer)entry.getKey() + 1);
+                    cell.setCellStyle(columnStyle);
+                    cell.setCellValue((String)entry.getValue());
+                }
+            }
+        }
+    }
+
+    private Map<Integer, List<String>> getErrorMap(List<Map<String, String>> errDataList) {
+        Map<Integer, List<String>> errorMap = new HashMap(16);
+        List<String> tempList = null;
+        Iterator var4 = errDataList.iterator();
+
+        while(var4.hasNext()) {
+            Map<String, String> tempMap = (Map)var4.next();
+            tempList = (List)errorMap.getOrDefault(Integer.valueOf((String)tempMap.get("dataIndex")), new ArrayList());
+            tempList.add(tempMap.get("errMsg"));
+            errorMap.put(Integer.valueOf((String)tempMap.get("dataIndex")), tempList);
+        }
+
+        return errorMap;
+    }
+
+    private String getErrorMsg(List<String> errorList) {
+        StringBuilder key = new StringBuilder();
+        int index = 1;
+
+        for(Iterator var4 = errorList.iterator(); var4.hasNext(); ++index) {
+            String msg = (String)var4.next();
+            key.append(index).append('.').append(' ').append(msg).append(' ');
+        }
+
+        return key.toString();
+    }
+
+
+    public static CellStyle getColumnStyle(boolean isTmpl, int precision, int scale, String columnType, HorizontalAlignment alignment, SXSSFWorkbook wb, short colorIndex, boolean needBoard) {
+        CellStyle headColumnStyle = wb.createCellStyle();
+        DataFormat dataFormat = wb.createDataFormat();
+        short format;
+        if (!isTmpl) {
+            if (StringUtils.equals(SITShowType.DATE.getCode(), columnType)) {
+                format = dataFormat.getFormat("yyyy-MM-dd");
+            } else {
+                String amountFormat;
+                if (StringUtils.equals(SITShowType.AMOUNT.getCode(), columnType)) {
+                    amountFormat = getAmountFormat(precision);
+                    format = dataFormat.getFormat(amountFormat);
+                } else if (StringUtils.equals(SITShowType.NUM.getCode(), columnType)) {
+                    amountFormat = getAmountFormat(scale);
+                    format = dataFormat.getFormat(amountFormat);
+                } else {
+                    format = dataFormat.getFormat("text");
+                }
+            }
+        } else if (StringUtils.equals(SITShowType.DATE.getCode(), columnType)) {
+            format = dataFormat.getFormat("yyyy-MM-dd");
+        } else {
+            format = dataFormat.getFormat("text");
+        }
+
+        headColumnStyle.setDataFormat(format);
+        if (needBoard) {
+            headColumnStyle.setBorderBottom(BorderStyle.HAIR);
+            headColumnStyle.setBorderTop(BorderStyle.HAIR);
+            headColumnStyle.setBorderLeft(BorderStyle.HAIR);
+            headColumnStyle.setBorderRight(BorderStyle.HAIR);
+        }
+
+        headColumnStyle.setFillForegroundColor(colorIndex);
+        headColumnStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
+        headColumnStyle.setAlignment(alignment);
+        headColumnStyle.setVerticalAlignment(VerticalAlignment.CENTER);
+        headColumnStyle.setHidden(true);
+        return headColumnStyle;
+    }
+
+    private static String getAmountFormat(int precision) {
+        StringBuilder format = new StringBuilder("0");
+        if (precision > 0) {
+            format.append('.');
+
+            for(int i = 0; i < precision; ++i) {
+                format.append('0');
+            }
+        }
+
+        return format.toString();
+    }
+
+
+}

code/swc/nckd-jxccl-swc/src/main/java/nckd/jxccl/swc/hsas/business/outdata/OutImportTaskGuideImportService.java

@@ -0,0 +1,454 @@
+package nckd.jxccl.swc.hsas.business.outdata;
+
+import com.google.common.collect.Lists;
+import com.kingdee.util.DateTimeUtils;
+import kd.bos.context.RequestContext;
+import kd.bos.dataentity.entity.DynamicObject;
+import kd.bos.dataentity.entity.DynamicObjectCollection;
+import kd.bos.dataentity.resource.ResManager;
+import kd.bos.dataentity.utils.StringUtils;
+import kd.bos.db.tx.TX;
+import kd.bos.db.tx.TXHandle;
+import kd.bos.entity.EntityMetadataCache;
+import kd.bos.entity.EntityType;
+import kd.bos.entity.MainEntityType;
+import kd.bos.exception.KDBizException;
+import kd.bos.fileservice.FileService;
+import kd.bos.fileservice.FileServiceFactory;
+import kd.bos.impt.ExcelReader;
+import kd.bos.impt.SheetHandler;
+import kd.bos.logging.Log;
+import kd.bos.logging.LogFactory;
+import kd.bos.orm.query.QFilter;
+import kd.bos.threads.ThreadPools;
+import kd.hr.hbp.business.bgtask.HRBackgroundTaskHelper;
+import kd.hr.hbp.business.servicehelper.HRBaseServiceHelper;
+import kd.hr.hbp.common.cache.HRAppCache;
+import kd.hr.hbp.common.cache.IHRAppCache;
+import nckd.jxccl.sit.hcsi.formplugin.web.tp.enums.SinsurPresetItemEnum;
+import nckd.jxccl.swc.hsas.business.utils.OutImportTaskUtils;
+import nckd.jxccl.swc.hsas.common.OutImpPresetItem;
+import nckd.jxccl.swc.hsas.formplugin.web.outdata.helper.OutImpTemplateHelper;
+import org.apache.commons.lang.exception.ExceptionUtils;
+
+import java.io.InputStream;
+import java.math.BigDecimal;
+import java.text.MessageFormat;
+import java.util.*;
+
+public class OutImportTaskGuideImportService {
+
+    private static final Log logger = LogFactory.getLog(OutImportTaskGuideImportService.class);
+    private Long importTaskId;
+    private Long tplId;
+    private Long welfarepayerId;
+    private Long periodId;
+    private String periodNumber;
+    private String url;
+    private static final long DATE_TYPE_ID = 1050L;
+    private static final long NUMBER_TYPE_ID = 1010L;
+    private static final long DECIMAL_TYPE_ID = 1020L;
+    private static final String DATE_FORMAT = "yyyy-MM-dd";
+
+    public OutImportTaskGuideImportService(String url, Long importTaskId, Long tplId, Long periodId, String periodNumber) {
+        this.url = url;
+        this.importTaskId = importTaskId;
+        this.tplId = tplId;
+        this.periodId = periodId;
+        this.periodNumber = periodNumber;
+    }
+
+    public Map<String, String> parseAndCheckExcelData(Long orgId, String pageId, String importTaskName) {
+        Map<String, String> resultMap = new HashMap(5);
+        List<Map<Integer, String>> dataHeadList = Lists.newArrayListWithCapacity(10);
+        List<Map<Integer, String>> dataRowList = Lists.newArrayListWithCapacity(10);
+        DynamicObject sinsurData = OutImportTaskUtils.getTplData(tplId, "id,number,nckd_startline,nckd_endline", (QFilter)null);
+        logger.info("readExcelData begin");
+        this.readExcelData(dataHeadList, dataRowList, sinsurData.getInt("nckd_startline") - 2, sinsurData.getInt("nckd_endline") - 1);
+        logger.info("readExcelData end");
+        if (dataHeadList.size() == 0) {
+            throw new KDBizException(ResManager.loadKDString("没有找到对应的列标题。", "ImportTaskGuideImportService_0", "swc-hsas-business", new Object[0]));
+        } else if (dataRowList.size() == 0) {
+            resultMap.put("errorMsg", ResManager.loadKDString("未解析到有效数据，请录入数据后再试。", "ImportTaskGuideImportService_17", "swc-hsas-business", new Object[0]));
+            return resultMap;
+        } else {
+            Set<String> errDataList = new HashSet(16);
+            List<Map<String, String>> columnList = OutImportTaskUtils.getColumnHeadList(this.tplId, this.importTaskId);
+            Map<Integer, OutImpPresetItem> tplFixItemMap = this.getTplFixItemMap(columnList);
+            this.checkExcelTemplate(dataHeadList, errDataList, tplFixItemMap);
+            String cacheKey;
+            if (errDataList.size() > 0) {
+                cacheKey = ResManager.loadKDString("模板列名“{0}”不能删除。", "ImportTaskGuideImportService_1", "swc-hsas-business", new Object[0]);
+                String errorMsg = OutImportTaskUtils.join(errDataList, "、");
+                throw new KDBizException(MessageFormat.format(cacheKey, errorMsg));
+            } else {
+                cacheKey = UUID.randomUUID().toString();
+                resultMap.put("totalCount", String.valueOf(dataRowList.size()));
+                resultMap.put("cacheKey", cacheKey);
+                Map<String, Object> params = new HashMap(16);
+                String name = ResManager.loadKDString("外部系统数据导入-%s", "ImportTaskGuideImportService_10", "swc-hsas-business", new Object[0]);
+                name = String.format(Locale.ROOT, name, importTaskName);
+                params.put("importTaskId", this.importTaskId);
+                params.put("verifyId", cacheKey);
+                params.put("totalCount", dataRowList.size());
+                params.put("startTime", DateTimeUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss"));
+                params.put("progressType", "22");
+                String bgTaskId = HRBackgroundTaskHelper.getInstance().createBaskgroundTask("swc_hsas_importtaskguide_import", name, true, pageId, params);
+                IHRAppCache appCache = HRAppCache.get(String.format(Locale.ROOT, "bggroud_taskid_%s", cacheKey));
+                appCache.put("bgTaskId", bgTaskId);
+                appCache.put("totalCount", dataRowList.size());
+                RequestContext ctx = RequestContext.get();
+                ThreadPools.executeOnce("IMPORTTASK_IMPORT_IN_POOL_ASYNC", () -> {
+                    RequestContext.copyAndSet(ctx);
+                    logger.info("parseAndCheckExcelData ,tranceId={}", ctx.getTraceId());
+                    this.importData(dataHeadList, dataRowList, sinsurData, cacheKey, null, orgId, tplFixItemMap);
+                });
+                return resultMap;
+            }
+        }
+    }
+
+    private void importData(List<Map<Integer, String>> dataHeadList, List<Map<Integer, String>> dataRowList, DynamicObject migrationTplData, String cacheKey, String writeTaskType, Long orgId, Map<Integer, OutImpPresetItem> tplFixItemMap) {
+        logger.info("importData begin,importTaskId={}", this.importTaskId);
+        List<Map<String, String>> errDataList = new ArrayList(10);
+        OutImportTaskGuideExportService service = new OutImportTaskGuideExportService();
+        if (!this.isCancel(cacheKey)) {
+            boolean hasWorkStartDate = tplFixItemMap.containsKey(11);
+            Map<Integer, List<Map<String, String>>> columnIndexMap = this.getColumnIndexMap();
+            Map<Integer, List<Map<String, String>>> commonColumnIndexMap = this.getCommonColumnIndexMap();
+            int defaultSize = 500;
+            List<List<Map<Integer, String>>> splitDataList = OutImportTaskUtils.split(dataRowList, defaultSize);
+            int lineIndex = 0;
+            List<Map<Integer, String>> tempList = null;
+            int index = 0;
+
+            for(int size = splitDataList.size(); index < size; ++index) {
+                tempList = (List)splitDataList.get(index);
+                lineIndex = index * defaultSize;
+                this.checkImportData(tempList, errDataList, commonColumnIndexMap, columnIndexMap, lineIndex, cacheKey, writeTaskType, orgId, hasWorkStartDate, false);
+            }
+
+            if (!this.isCancel(cacheKey)) {
+                if (errDataList.size() > 0) {
+                    String fileUrl = service.getImportErrorExcelFile(dataHeadList, dataRowList, errDataList, migrationTplData.getInt("nckd_startline") - 2, writeTaskType, columnIndexMap, hasWorkStartDate);
+                    OutImportTaskUtils.updateImportDataProgress(0, 0, cacheKey, fileUrl);
+                }
+
+                logger.info("importData end,importTaskId={}", this.importTaskId);
+            }
+        }
+    }
+
+    private Boolean isCancel(String cacheKey) {
+        String key = String.format(Locale.ROOT, "import_cache_%s", cacheKey);
+        IHRAppCache appCache = HRAppCache.get(key);
+        Boolean isCancel = (Boolean)appCache.get(String.format(Locale.ROOT, "isCancel_%s", cacheKey), Boolean.class);
+        return isCancel != null && isCancel ? Boolean.TRUE : Boolean.FALSE;
+    }
+
+    // TODO 校验导入数据
+    private void checkImportData(List<Map<Integer, String>> dataRowList, List<Map<String, String>> allErrDataList, Map<Integer, List<Map<String, String>>> commonColumnIndexMap, Map<Integer, List<Map<String, String>>> columnIndexMap, int lineIndex, String cacheKey, String writeTaskType, Long orgId, boolean hasWorkStartDate, boolean isMulTimeOnePeriod) {
+        Map<Integer, Map<Integer, Object>> passDataRowMap = new HashMap(16);
+        int lineIndexVer = lineIndex;
+        List<Map<String, String>> errDataList = new ArrayList(10);
+        int successCount = 0;
+        int failCount = 0;
+
+        try {
+            boolean isSuccess = true;
+            Iterator<Map<Integer, String>> it = dataRowList.iterator();
+            while(it.hasNext()) {
+                Map<Integer, Object> passRowMap = new HashMap(16);
+                Map<Integer, String> rowMap = (Map)it.next();
+                isSuccess = this.checkFieldRequriedForCommon(commonColumnIndexMap, rowMap, errDataList, lineIndex, passRowMap);
+                if(!isSuccess) {
+                    ++lineIndex;
+                } else if (!this.checkItemValue(columnIndexMap, passRowMap, errDataList, lineIndex, rowMap)) {
+                    ++lineIndex;
+                } else {
+                    if(isSuccess) {
+                        passDataRowMap.put(lineIndex, passRowMap);
+                    }
+                    ++lineIndex;
+                }
+            }
+
+            if (!this.isCancel(cacheKey)) {
+                this.saveData(passDataRowMap, commonColumnIndexMap, columnIndexMap);
+                successCount = passDataRowMap.size();
+                failCount = dataRowList.size() - successCount;
+                return;
+            }
+
+        } catch (Exception e) {
+            logger.error(e);
+            successCount = 0;
+            failCount = dataRowList.size();
+            errDataList.clear();
+            // TODO this.setErrorData(dataRowList.size(), lineIndexVer, errDataList, e.getMessage());
+            return;
+        } finally {
+            allErrDataList.addAll(errDataList);
+            OutImportTaskUtils.updateImportDataProgress(successCount, failCount, cacheKey, (String)null);
+        }
+    }
+
+    private void saveData(Map<Integer, Map<Integer, Object>> passDataRowMap, Map<Integer, List<Map<String, String>>> commonColumnIndexMap, Map<Integer, List<Map<String, String>>> columnIndexMap) {
+        if (passDataRowMap != null && passDataRowMap.size() != 0) {
+            DynamicObjectCollection result = new DynamicObjectCollection();
+            MainEntityType type = EntityMetadataCache.getDataEntityType("nckd_outtempdata");
+            EntityType entryType = (EntityType)type.getAllEntities().get("entryentity");
+            DynamicObject temporary = null;
+            Map<Integer, Object> rowMap = null;
+            Iterator<Map.Entry<Integer, Map<Integer, Object>>> it = passDataRowMap.entrySet().iterator();
+            while(it.hasNext()) {
+                Map.Entry<Integer, Map<Integer, Object>> entry = (Map.Entry)it.next();
+                temporary = (DynamicObject)type.createInstance();
+                rowMap = (Map)entry.getValue();
+                temporary.set("nckd_datastatus", "0");
+                //OutImportTaskUtils.setTemporaryValueForCommon(commonColumnIndexMap, temporary, rowMap, periodNumber);
+                temporary.set("nckd_importtask", this.importTaskId);
+                temporary.set("creator", RequestContext.get().getCurrUserId());
+                temporary.set("createtime", new Date());
+                temporary.set("modifier", RequestContext.get().getCurrUserId());
+                temporary.set("modifytime", new Date());
+                temporary.set("billstatus", "A");
+                temporary.set("entryentity", OutImportTaskUtils.getItemEntryList(rowMap, columnIndexMap, entryType));
+                result.add(temporary);
+            }
+            HRBaseServiceHelper helper = new HRBaseServiceHelper("nckd_outtempdata");
+            TXHandle txHandle = TX.requiresNew();
+
+            try {
+                helper.save(result);
+                helper.setEntityName("nckd_outimptask");
+                DynamicObject importTask = helper.queryOne(this.importTaskId);
+                importTask.set("nckd_taskstatus", "1");
+                importTask.set("modifytime", new Date());
+                importTask.set("modifier", RequestContext.get().getCurrUserId());
+                importTask.set("nckd_count", importTask.getInt("nckd_count") + result.size());
+                helper.updateOne(importTask);
+            } catch (Exception var18) {
+                logger.error("save error,", var18);
+                txHandle.markRollback();
+                throw new KDBizException(ExceptionUtils.getFullStackTrace(var18));
+            } finally {
+                txHandle.close();
+            }
+        }
+    }
+
+    private boolean checkItemValue(Map<Integer, List<Map<String, String>>> columnIndexMap,
+                                   Map<Integer, Object> passRowMap,
+                                   List<Map<String, String>> errDataList,
+                                   int lineIndex,
+                                   Map<Integer, String> rowMap) {
+        boolean isPass = true;
+        String errorMsgTemplate = ResManager.loadKDString("{0}：数据格式填写错误。",
+                "ImportTaskGuideImportService_4", "swc-hsas-business", new Object[0]);
+
+        for (Map.Entry<Integer, List<Map<String, String>>> columnEntry : columnIndexMap.entrySet()) {
+            Integer columnIndex = columnEntry.getKey();
+            String itemValue = rowMap.get(columnIndex);
+
+            if (StringUtils.isEmpty(itemValue)) {
+                continue;
+            }
+
+            for (Map<String, String> itemMap : columnEntry.getValue()) {
+                long dataTypeId = Long.parseLong(itemMap.get("datatypeid"));
+                String itemName = itemMap.get("name");
+
+                try {
+                    String processedValue = processValueByType(itemValue, dataTypeId);
+                    passRowMap.put(columnIndex, processedValue);
+                } catch (Exception e) {
+                    isPass = false;
+                    errDataList.add(assembleErrMap(lineIndex, false,
+                            MessageFormat.format(errorMsgTemplate, itemName)));
+                }
+            }
+        }
+        return isPass;
+    }
+
+    private String processValueByType(String value, long dataTypeId) throws Exception {
+        if (DATE_TYPE_ID == dataTypeId) {
+            return DateTimeUtils.format(DateTimeUtils.parseDate(value), DATE_FORMAT);
+        }
+
+        if (NUMBER_TYPE_ID == dataTypeId || DECIMAL_TYPE_ID == dataTypeId) {
+            return new BigDecimal(value).toPlainString();
+        }
+
+        return value;
+    }
+
+
+    private boolean checkFieldRequriedForCommon(Map<Integer, List<Map<String, String>>> commonColumnIndexMap, Map<Integer, String> rowMap, List<Map<String, String>> errDataList, int lineIndex, Map<Integer, Object> passRowMap) {
+        String msg = ResManager.loadKDString("请填写“{0}”。", "ImportTaskGuideImportService_2", "swc-hsas-business", new Object[0]);
+
+        for (Map.Entry<Integer, List<Map<String, String>>> columnEntry : commonColumnIndexMap.entrySet()) {
+            Integer columnIndex = columnEntry.getKey();
+            String itemValue = rowMap.get(columnIndex);
+
+            if (StringUtils.isEmpty(itemValue)) {
+                errDataList.add(this.assembleErrMap(lineIndex, false, MessageFormat.format(msg, columnEntry.getValue().get(0).get("name"))));
+                return false;
+            }
+
+            for (Map<String, String> itemMap : columnEntry.getValue()) {
+                passRowMap.put(columnIndex, itemValue);
+            }
+        }
+        return true;
+    }
+
+    private Map<Integer, List<Map<String, String>>> getColumnIndexMap() {
+        List<Map<String, String>> columnHeadList = OutImportTaskUtils.getColumnHeadList(this.tplId, this.importTaskId);
+        Map<Integer, List<Map<String, String>>> columnIndexMap = new HashMap(columnHeadList.size());
+        List<Map<String, String>> tempMapList = null;
+        Iterator var4 = columnHeadList.iterator();
+
+        while(var4.hasNext()) {
+            Map<String, String> obj = (Map)var4.next();
+            if (!"0".equals(obj.get("itemType"))) {
+                tempMapList = (List) columnIndexMap.get(Integer.valueOf((String) obj.get("columnIndex")));
+                if (tempMapList == null) {
+                    tempMapList = new ArrayList(10);
+                    columnIndexMap.put(Integer.valueOf((String) obj.get("columnIndex")), tempMapList);
+                }
+                ((List) tempMapList).add(obj);
+            }
+        }
+
+        return columnIndexMap;
+    }
+
+    /**
+     * 获取默认项目Map
+     * @return
+     */
+    private Map<Integer, List<Map<String, String>>> getCommonColumnIndexMap() {
+        List<Map<String, String>> columnHeadList = OutImportTaskUtils.getColumnHeadList(this.tplId, this.importTaskId);
+        Map<Integer, List<Map<String, String>>> columnIndexMap = new HashMap(columnHeadList.size());
+        List<Map<String, String>> tempMapList = null;
+        Iterator var4 = columnHeadList.iterator();
+
+        while(var4.hasNext()) {
+            Map<String, String> obj = (Map)var4.next();
+            if ("0".equals(obj.get("itemType"))) {
+                tempMapList = (List) columnIndexMap.get(Integer.valueOf((String) obj.get("columnIndex")));
+                if (tempMapList == null) {
+                    tempMapList = new ArrayList(10);
+                    columnIndexMap.put(Integer.valueOf((String) obj.get("columnIndex")), tempMapList);
+                }
+                ((List) tempMapList).add(obj);
+            }
+        }
+
+        return columnIndexMap;
+    }
+
+
+    private Map<String, String> assembleErrMap(int dataIndex, boolean isAll, String msg) {
+        Map<String, String> errMap = new HashMap(4);
+        errMap.put("errMsg", msg);
+        errMap.put("isAll", isAll ? "1" : "0");
+        errMap.put("dataIndex", String.valueOf(dataIndex));
+        return errMap;
+    }
+
+    private void checkExcelTemplate(List<Map<Integer, String>> dataHeadList, Set<String> errDataList, Map<Integer, OutImpPresetItem> tplFixItemMap) {
+        Map<Integer, String> dataHeadMap = (Map)dataHeadList.get(0);
+        String excelName = null;
+        StringBuilder tplName = new StringBuilder();
+        Iterator var7 = tplFixItemMap.entrySet().iterator();
+        while(var7.hasNext()) {
+            Map.Entry<Integer, OutImpPresetItem> entry = (Map.Entry)var7.next();
+            excelName = (String)dataHeadMap.get(entry.getKey());
+            if (StringUtils.isEmpty(excelName)) {
+                errDataList.add(((OutImpPresetItem)entry.getValue()).getItemName());
+            } else {
+                tplName.setLength(0);
+                tplName.append('*');
+//                if (((OutImpPresetItem)entry.getValue()).isRequire()) {
+//                    tplName.append('*');
+//                }
+                tplName.append(((OutImpPresetItem)entry.getValue()).getItemName());
+                if (!excelName.equals(tplName.toString())) {
+                    // 系统导出来的模板列名有*，线下的模板可能不会加*号，这里再判断一下，如果有*号，去掉*号再匹配一下
+                    if(tplName.toString().startsWith("*")) {
+                        if(!excelName.equals(tplName.toString().substring(1, tplName.toString().length()))) {
+                            errDataList.add(((OutImpPresetItem)entry.getValue()).getItemName());
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private Map<Integer, OutImpPresetItem> getTplFixItemMap(List<Map<String, String>> columnList) {
+        Map<Integer, OutImpPresetItem> map = new HashMap(16);
+        Map<Long, OutImpPresetItem> presetItemEnumMap = OutImpTemplateHelper.getPresetItemEnumMap();
+        OutImpPresetItem tempItemEnum = null;
+        Iterator it = columnList.iterator();
+        while(it.hasNext()) {
+            Map<String, String> temp = (Map)it.next();
+            if ("0".equals(temp.get("itemType"))) {
+                Long itemId = Long.valueOf((String)temp.get("id"));
+                String columnIndexStr = (String)temp.get("columnIndex");
+                tempItemEnum = (OutImpPresetItem)presetItemEnumMap.get(itemId);
+                map.put(Integer.valueOf(columnIndexStr), tempItemEnum);
+            }
+        }
+        return map;
+    }
+
+    /**
+     * 读excel数据
+     * @param dataHeadList
+     * @param dataRowList
+     * @param headIndex
+     * @param dataEndIndex
+     * @throws KDBizException
+     */
+    private void readExcelData(final List<Map<Integer, String>> dataHeadList, final List<Map<Integer, String>> dataRowList, final int headIndex, final int dataEndIndex) throws KDBizException {
+        FileService service = FileServiceFactory.getAttachmentFileService();
+        try {
+            InputStream in = service.getInputStream(this.url);
+            Throwable exp = null;
+            try {
+                (new ExcelReader()).read(in, new SheetHandler() {
+                    public void handleRow(ParsedRow row) {
+                        if (row.getRowNum() == headIndex) {
+                            dataHeadList.add(row.getData());
+                        } else if (row.getRowNum() > headIndex && row.getRowNum() <= dataEndIndex && row.getData().size() > 0) {
+                            dataRowList.add(row.getData());
+                        }
+
+                    }
+                });
+            } catch (Throwable e) {
+                exp = e;
+                throw e;
+            } finally {
+                if (in != null) {
+                    if (exp != null) {
+                        try {
+                            in.close();
+                        } catch (Throwable e1) {
+                            exp.addSuppressed(e1);
+                        }
+                    } else {
+                        in.close();
+                    }
+                }
+            }
+        } catch (Throwable e2) {
+            logger.error("parse excel error,", e2);
+            throw new KDBizException(ExceptionUtils.getFullStackTrace(e2));
+        }
+    }
+
+}

code/swc/nckd-jxccl-swc/src/main/java/nckd/jxccl/swc/hsas/business/utils/OutImportTaskUtils.java

@@ -0,0 +1,391 @@
+package nckd.jxccl.swc.hsas.business.utils;
+
+import kd.bos.context.RequestContext;
+import kd.bos.dataentity.entity.DynamicObject;
+import kd.bos.dataentity.entity.DynamicObjectCollection;
+import kd.bos.dataentity.serialization.SerializationUtils;
+import kd.bos.entity.EntityType;
+import kd.bos.orm.query.QFilter;
+import kd.bos.util.StringUtils;
+import kd.hr.hbp.business.bgtask.HRBackgroundTaskHelper;
+import kd.hr.hbp.business.servicehelper.HRBaseServiceHelper;
+import kd.hr.hbp.common.cache.HRAppCache;
+import kd.hr.hbp.common.cache.IHRAppCache;
+import nckd.jxccl.sit.hcsi.formplugin.web.tp.enums.SinsurPresetItemEnum;
+import nckd.jxccl.swc.hsas.common.OutImpPresetItem;
+import nckd.jxccl.swc.hsas.formplugin.web.outdata.helper.OutImpTemplateHelper;
+
+import java.util.*;
+
+public class OutImportTaskUtils {
+
+    private static final String TPL_ENTITY = "nckd_outimptpl";
+    private static final String SALARYITEM_ENTITY = "hsbs_salaryitem";
+
+
+    public static DynamicObject getTplData(Long sinsurTplId, String fields, QFilter qFilter) {
+        HRBaseServiceHelper helper = new HRBaseServiceHelper(TPL_ENTITY);
+        QFilter filter = new QFilter("id", "=", sinsurTplId);
+        if (qFilter != null) {
+            filter.and(qFilter);
+        }
+        return helper.queryOne(fields, new QFilter[]{filter});
+    }
+
+    private static DynamicObjectCollection getTplDataList(Long tplId) {
+        HRBaseServiceHelper helper = new HRBaseServiceHelper(TPL_ENTITY);
+        String fields = "nckd_outimptplentry.nckd_itemtype,nckd_outimptplentry.nckd_itemid,nckd_outimptplentry.nckd_matchcolumn,nckd_outimptplentry.nckd_comment";
+        QFilter qFilter = new QFilter("id", "=", tplId);
+        return helper.queryOriginalCollection(fields, new QFilter[]{qFilter}, "nckd_outimptplentry.seq asc");
+    }
+
+    public static List<Map<String, String>> getColumnHeadList(Long tplId, Long importTaskId) {
+        List<Map<String, String>> columnHeadList = new ArrayList(10);
+        if (tplId != null && tplId != 0L && importTaskId != null && importTaskId != 0L) {
+            String cacheKey = importTaskId + "_" + tplId;
+            IHRAppCache appCache = HRAppCache.get(cacheKey);
+            String json = (String)appCache.get("columnHeadList", String.class);
+            if (StringUtils.isNotEmpty(json)) {
+                columnHeadList = (List) SerializationUtils.fromJsonString(json, List.class);
+                return columnHeadList;
+            }
+        }
+        DynamicObjectCollection list = getTplDataList(tplId);
+        if (list.size() == 0) {
+            return columnHeadList;
+        } else {
+            List<String> itemList = new ArrayList(10);
+            Map<String, Map<String, String>> itemMap = new HashMap(list.size());
+            Set<Long> fixSet = new HashSet(16);
+            Set<Long> iiItemSet = new HashSet(16);
+            Map<String, Integer> indexMap = new HashMap(16);
+            String keyStr = "";
+            Map<String, String> commentMap = new HashMap(list.size());
+            String comment = null;
+            Iterator columnIndex;
+            DynamicObject obj;
+            for(columnIndex = list.iterator(); columnIndex.hasNext(); commentMap.put(keyStr, comment)) {
+                obj = (DynamicObject)columnIndex.next();
+                String itemType = obj.getString("nckd_outimptplentry.nckd_itemtype");
+                Long itemId = obj.getLong("nckd_outimptplentry.nckd_itemid");
+                comment = obj.getString("nckd_outimptplentry.nckd_comment");
+                if ("0".equals(itemType)) {
+                    keyStr = "fix" + itemId;
+                    itemList.add(keyStr);
+                    indexMap.put(keyStr, getExcelRowIndexByTitle(obj.getString("nckd_outimptplentry.nckd_matchcolumn")));
+                    fixSet.add(itemId);
+                }
+                else if ("1".equals(itemType)) {
+                    keyStr = "ii" + itemId;
+                    itemList.add(keyStr);
+                    indexMap.put(keyStr, getExcelRowIndexByTitle(obj.getString("nckd_outimptplentry.nckd_matchcolumn")));
+                    iiItemSet.add(itemId);
+                }
+            }
+            addFixValue(commentMap, fixSet, "fix", itemMap, "0");
+            addItemValue(commentMap, iiItemSet, "ii", itemMap, SALARYITEM_ENTITY, "1");
+            if (itemMap.size() == 0) {
+                return columnHeadList;
+            } else {
+                columnIndex = null;
+                obj = null;
+                Iterator it = itemList.iterator();
+                while(it.hasNext()) {
+                    String key = (String)it.next();
+                    Map<String, String> tempMap = (Map)itemMap.get(key);
+                    if (tempMap != null) {
+                        Integer index = (Integer)indexMap.get(key);
+                        tempMap.put("columnIndex", String.valueOf(index));
+                        columnHeadList.add(tempMap);
+                    }
+                }
+                if (tplId != null && tplId != 0L && importTaskId != null && importTaskId != 0L) {
+                    String cacheKey = importTaskId + "_" + tplId;
+                    IHRAppCache appCache = HRAppCache.get(cacheKey);
+                    appCache.put("columnHeadList", SerializationUtils.toJsonString(columnHeadList));
+                }
+                return columnHeadList;
+            }
+        }
+    }
+
+    /**
+     * 处理预置项目
+     * @param commentMap
+     * @param itemSet
+     * @param itemKey
+     * @param itemMap
+     * @param itemType
+     */
+    private static void addFixValue(Map<String, String> commentMap, Set<Long> itemSet, String itemKey, Map<String, Map<String, String>> itemMap, String itemType) {
+        if (itemSet.size() != 0) {
+            Map<Long, OutImpPresetItem> map = OutImpTemplateHelper.getPresetItemEnumMap();
+            OutImpPresetItem itemEnum = null;
+            Map<String, String> tempMap = null;
+            Iterator it = itemSet.iterator();
+            while(it.hasNext()) {
+                Long itemId = (Long)it.next();
+                itemEnum = (OutImpPresetItem)map.get(itemId);
+                tempMap = new HashMap(16);
+                tempMap.put("name", itemEnum.getItemName());
+                tempMap.put("datatypeid", String.valueOf(itemEnum.getDataTypeId()));
+                tempMap.put("id", String.valueOf(itemId));
+                tempMap.put("key", getFixColumnKeyByItemId(itemId.toString()));
+                tempMap.put("itemType", itemType);
+                tempMap.put("comment", commentMap.get(itemKey + itemId));
+                itemMap.put(itemKey + itemId, tempMap);
+            }
+        }
+    }
+
+
+
+    private static String getFixColumnKeyByItemId(String itemId) {
+        String columnKey = null;
+        switch (itemId) {
+            case "1":
+                columnKey = "nckd_idcard";
+                break;
+            case "2":
+                columnKey = "nckd_empname";
+                break;
+        }
+
+        return columnKey;
+    }
+
+    private static void addItemValue(Map<String, String> commentMap, Set<Long> itemSet, String itemKey, Map<String, Map<String, String>> itemMap, String entityId, String itemType) {
+        if (itemSet.size() != 0) {
+            HRBaseServiceHelper helper = new HRBaseServiceHelper(entityId);
+            String fields = "id,datatype.id,name";
+            DynamicObjectCollection result = helper.queryOriginalCollection(fields, new QFilter[]{new QFilter("id", "in", itemSet)});
+            Map<String, String> tempMap = null;
+            Iterator var11 = result.iterator();
+
+            while(var11.hasNext()) {
+                DynamicObject obj = (DynamicObject)var11.next();
+                tempMap = new HashMap(16);
+                String keyStr = itemKey + obj.getLong("id");
+                tempMap.put("name", obj.getString("name"));
+                tempMap.put("datatypeid", String.valueOf(obj.getLong("datatype.id")));
+                tempMap.put("id", String.valueOf(obj.getLong("id")));
+                tempMap.put("key", keyStr);
+                tempMap.put("itemType", itemType);
+                tempMap.put("comment", commentMap.get(keyStr));
+                itemMap.put(keyStr, tempMap);
+            }
+
+        }
+    }
+
+
+    public static int getExcelRowIndexByTitle(String columnTitle) {
+        int length = columnTitle.length();
+        int num = 0;
+        for(int i = 0; i < length; ++i) {
+            num = num * 26 + columnTitle.charAt(i) - 65 + 1;
+        }
+        return num - 1;
+    }
+
+    /**
+     * 处理预置字段
+     *
+     * @param commonColumnIndexMap
+     * @param temporary
+     * @param rowMap
+     * @param periodNumber
+     */
+    public static void setTemporaryValueForCommon(Map<Integer, List<Map<String, String>>> commonColumnIndexMap, DynamicObject temporary, Map<Integer, Object> rowMap, String periodNumber) {
+        for (Map.Entry<Integer, List<Map<String, String>>> entry : commonColumnIndexMap.entrySet()) {
+            Object itemValue = rowMap.get(entry.getKey());
+            if (itemValue == null) {
+                continue;
+            }
+            for (Map<String, String> itemMap : entry.getValue()) {
+                temporary.set(itemMap.get("key").toString(), itemValue);
+            }
+        }
+
+        temporary.set("nckd_periodname", periodNumber);
+
+    }
+
+    public static DynamicObjectCollection getItemEntryList(Map<Integer, Object> rowMap, Map<Integer, List<Map<String, String>>> columnIndexMap, EntityType entryType) {
+        DynamicObjectCollection itemEntryList = new DynamicObjectCollection();
+        int sequence = 0;
+        for (Map.Entry<Integer, List<Map<String, String>>> entry : columnIndexMap.entrySet()) {
+            Object itemValue = rowMap.get(entry.getKey());
+            if (itemValue == null) {
+                continue;
+            }
+            for (Map<String, String> itemMap : entry.getValue()) {
+                try {
+                    DynamicObject item = (DynamicObject) entryType.createInstance();
+
+                    item.set("nckd_itemvalue", itemValue);
+                    item.set("nckd_itemtype", itemMap.get("itemType"));
+                    item.set("nckd_itemname", itemMap.get("name"));
+                    item.set("seq", sequence);
+
+                    String id = itemMap.get("id");
+                    if (id != null) {
+                        item.set("nckd_itemid", Long.valueOf(id));
+                    }
+
+                    String datatypeId = itemMap.get("datatypeid");
+                    if (datatypeId != null) {
+                        item.set("nckd_datatype", Long.valueOf(datatypeId));
+                    }
+                    sequence++;
+                    itemEntryList.add(item);
+                } catch (Exception e) {
+                    // 记录错误日志，但继续处理其他条目
+                    System.err.println("Error processing item: " + e.getMessage());
+                }
+            }
+        }
+        return itemEntryList;
+    }
+
+    public static Set<Integer> getExportTplRequireColumnSet() {
+        Set<Integer> requireFixColumnSet = new HashSet(16);
+        requireFixColumnSet.add(0);
+        requireFixColumnSet.add(1);
+        requireFixColumnSet.add(2);
+        requireFixColumnSet.add(3);
+        return requireFixColumnSet;
+    }
+
+    public static void updateImportTaskStatus(Long importTaskId) {
+        HRBaseServiceHelper temporaryHelper = new HRBaseServiceHelper("nckd_sinsurtempdata");
+        QFilter filter = new QFilter("nckd_importtask", "=", importTaskId);
+        int count = temporaryHelper.count(temporaryHelper.getEntityName(), new QFilter[]{filter});
+        if (count == 0) {
+            updateImportTaskByDelete(importTaskId, "0", count);
+        } else {
+            QFilter statusFilter = new QFilter("nckd_datastatus", "=", "5");
+            int writedCount = temporaryHelper.count(temporaryHelper.getEntityName(), new QFilter[]{filter, statusFilter});
+            if (count == writedCount) {
+                updateImportTaskByDelete(importTaskId, "2", count);
+            } else {
+                updateImportTaskByDelete(importTaskId, (String)null, count);
+            }
+        }
+    }
+
+    private static void updateImportTaskByDelete(Long importTaskId, String taskStatus, int count) {
+        HRBaseServiceHelper taskHelper = new HRBaseServiceHelper("nckd_outimptask");
+        DynamicObject task = taskHelper.queryOne(importTaskId);
+        if (taskStatus != null) {
+            task.set("nckd_taskstatus", taskStatus);
+        }
+
+        task.set("nckd_count", count);
+        task.set("modifytime", new Date());
+        task.set("modifier", RequestContext.get().getCurrUserId());
+        taskHelper.updateOne(task);
+    }
+
+
+    public static synchronized void updateImportDataProgress(int successCount, int failCount, String cacheKey, String fileUrl) {
+        IHRAppCache appCache = HRAppCache.get(String.format(Locale.ROOT, "import_cache_%s", cacheKey));
+        Integer existSuccCount = (Integer)appCache.get("successCount", Integer.class);
+        Integer existFailCount = (Integer)appCache.get("failCount", Integer.class);
+        if (existSuccCount == null) {
+            existSuccCount = 0;
+        }
+
+        if (existFailCount == null) {
+            existFailCount = 0;
+        }
+
+        existSuccCount = existSuccCount + successCount;
+        existFailCount = existFailCount + failCount;
+        appCache.put("successCount", existSuccCount);
+        appCache.put("failCount", existFailCount);
+        if (fileUrl != null) {
+            appCache.put("fileUrl", fileUrl);
+        }
+
+        Integer sumCount = existSuccCount + existFailCount;
+        IHRAppCache bgAppCache = HRAppCache.get(String.format(Locale.ROOT, "bggroud_taskid_%s", cacheKey));
+        String bgTaskId = (String)bgAppCache.get("bgTaskId", String.class);
+        if (StringUtils.isNotEmpty(bgTaskId)) {
+            Integer totalCount = bgAppCache.get("totalCount", Integer.class) == null ? 0 : (Integer)bgAppCache.get("totalCount", Integer.class);
+            if (totalCount == 0) {
+                return;
+            }
+
+            int progress;
+            if (sumCount.equals(totalCount)) {
+                progress = 100;
+            } else {
+                progress = sumCount * 100 / totalCount;
+                if (progress == 100) {
+                    progress = 99;
+                }
+            }
+
+            HRBackgroundTaskHelper.getInstance().feedbackProgress(bgTaskId, progress, "", (Map)null);
+        }
+
+    }
+
+
+    public static String join(Set<String> set, String str) {
+        if (null != set && set.size() != 0) {
+            StringBuilder result = new StringBuilder();
+            Iterator var3 = set.iterator();
+
+            while(var3.hasNext()) {
+                String temp = (String)var3.next();
+                result.append(temp).append(str);
+            }
+
+            return result.substring(0, result.length() - 1);
+        } else {
+            return "";
+        }
+    }
+
+    public static <T> List<List<T>> split(List<T> resList, int count) {
+        List<List<T>> ret = new ArrayList(10);
+        if (resList != null && !resList.isEmpty() && count >= 1) {
+            int size = resList.size();
+            if (size <= count) {
+                ret.add(resList);
+            } else {
+                int pre = size / count;
+                int last = size % count;
+                List<T> itemList = null;
+
+                int i;
+                for(i = 0; i < pre; ++i) {
+                    itemList = new ArrayList(count);
+
+                    for(int j = 0; j < count; ++j) {
+                        itemList.add(resList.get(i * count + j));
+                    }
+
+                    ret.add(itemList);
+                }
+
+                if (last > 0) {
+                    itemList = new ArrayList(count);
+
+                    for(i = 0; i < last; ++i) {
+                        itemList.add(resList.get(pre * count + i));
+                    }
+
+                    ret.add(itemList);
+                }
+            }
+
+            return ret;
+        } else {
+            return ret;
+        }
+    }
+
+}

code/swc/nckd-jxccl-swc/src/main/java/nckd/jxccl/swc/hsas/common/OutImpPresetItem.java

@@ -0,0 +1,49 @@
+package nckd.jxccl.swc.hsas.common;
+public class OutImpPresetItem {
+
+    private String matchColumn;
+    private Long itemId;
+    private String itemName;
+    private Long dataTypeId;
+    private String comment;
+
+    public String getMatchColumn() {
+        return this.matchColumn;
+    }
+
+    public void setMatchColumn(String matchColumn) {
+        this.matchColumn = matchColumn;
+    }
+
+    public Long getItemId() {
+        return this.itemId;
+    }
+
+    public void setItemId(Long itemId) {
+        this.itemId = itemId;
+    }
+
+    public String getItemName() {
+        return this.itemName;
+    }
+
+    public void setItemName(String itemName) {
+        this.itemName = itemName;
+    }
+
+    public String getComment() {
+        return this.comment;
+    }
+
+    public void setComment(String comment) {
+        this.comment = comment;
+    }
+
+    public Long getDataTypeId() {
+        return this.dataTypeId;
+    }
+
+    public void setDataTypeId(Long dataTypeId) {
+        this.dataTypeId = dataTypeId;
+    }
+}

code/swc/nckd-jxccl-swc/src/main/java/nckd/jxccl/swc/hsas/formplugin/web/outdata/basedata/OutImpTaskListPlugin.java

@@ -0,0 +1,72 @@
+package nckd.jxccl.swc.hsas.formplugin.web.outdata.basedata;
+
+import kd.bos.dataentity.entity.DynamicObject;
+import kd.bos.dataentity.resource.ResManager;
+import kd.bos.dataentity.utils.StringUtils;
+import kd.bos.entity.datamodel.ListSelectedRow;
+import kd.bos.form.FormShowParameter;
+import kd.bos.form.ShowType;
+import kd.bos.form.events.HyperLinkClickArgs;
+import kd.bos.list.IListView;
+import kd.bos.list.ListShowParameter;
+import kd.bos.list.plugin.AbstractListPlugin;
+import kd.bos.orm.query.QFilter;
+import kd.hr.hbp.business.servicehelper.HRBaseServiceHelper;
+import kd.sdk.plugin.Plugin;
+
+import java.text.MessageFormat;
+
+/**
+ * Tyx 2025-12-09
+ * 外单位数据导入任务列表插件 【nckd_outimptask】
+ */
+public class OutImpTaskListPlugin extends AbstractListPlugin implements Plugin {
+
+    @Override
+    public void billListHyperLinkClick(HyperLinkClickArgs args) {
+        ListShowParameter listShowParameter = (ListShowParameter)this.getView().getFormShowParameter();
+        if (!listShowParameter.isLookUp()) {
+            String fieldName = args.getHyperLinkClickEvent().getFieldName();
+            if (StringUtils.equals("name", fieldName)) {
+                args.setCancel(true);
+                IListView listView = (IListView)this.getView();
+                ListSelectedRow selectRow = listView.getCurrentSelectedRowInfo();
+                Long importTaskId = (Long)selectRow.getPrimaryKeyValue();
+                this.openTempDataPage(importTaskId);
+            }
+        }
+    }
+
+    private void openTempDataPage(Long importTaskId) {
+        HRBaseServiceHelper helper = new HRBaseServiceHelper("nckd_outimptask");
+        DynamicObject data = helper.queryOne("id,name,nckd_org.id,nckd_period.id,creator.id,nckd_outimptpl.id,nckd_taskstatus", importTaskId);
+        String msg;
+        if (data == null) {
+            msg = ResManager.loadKDString("数据已不存在。", "ImportTaskList_0", "swc-hsas-formplugin", new Object[0]);
+            this.getView().showErrorNotification(msg);
+        } else if (StringUtils.equals("8", data.getString("nckd_taskstatus"))) {
+            msg = ResManager.loadKDString("所选任务已清除中间表数据，无法查看。", "ImportTaskList_4", "swc-hsas-formplugin", new Object[0]);
+            this.getView().showErrorNotification(msg);
+        } else {
+            ListShowParameter parameter = new ListShowParameter();
+            parameter.getOpenStyle().setShowType(ShowType.MainNewTabPage);
+            parameter.setBillFormId("nckd_outtempdata");
+            parameter.setFormId("bos_list");
+            String caption = MessageFormat.format(ResManager.loadKDString("外单位数据导入任务 - {0}", "ImportTaskList_1", "swc-hsas-formplugin", new Object[0]), data.getString("name"));
+            parameter.setCaption(caption);
+            parameter.setCustomParam("importTaskId", importTaskId);
+            parameter.setCustomParam("importTaskName", data.getString("name"));
+            parameter.setCustomParam("periodId", data.getLong("nckd_period.id"));
+            parameter.setCustomParam("periodNumber", data.getString("nckd_period.number"));
+            parameter.setCustomParam("outimpTplId", data.getLong("nckd_outimptpl.id"));
+            parameter.setCustomParam("orgId", String.valueOf(data.getLong("nckd_org.id")));
+            parameter.setCustomParam("creator", String.valueOf(data.getLong("creator.id")));
+            parameter.getListFilterParameter().getQFilters().add(new QFilter("nckd_importtask", "=", parameter.getCustomParam("importTaskId")));
+            String pageId = this.getView().getMainView() == null ? this.getView().getPageId() : this.getView().getMainView().getPageId();
+            pageId = pageId + '_' + importTaskId;
+            parameter.setPageId(pageId);
+            this.getView().showForm(parameter);
+        }
+    }
+
+}

code/swc/nckd-jxccl-swc/src/main/java/nckd/jxccl/swc/hsas/formplugin/web/outdata/basedata/OutImpTemplateEdit.java

@@ -0,0 +1,420 @@
+package nckd.jxccl.swc.hsas.formplugin.web.outdata.basedata;
+
+import kd.bos.dataentity.entity.DynamicObject;
+import kd.bos.dataentity.entity.DynamicObjectCollection;
+import kd.bos.dataentity.resource.ResManager;
+import kd.bos.dataentity.utils.StringUtils;
+import kd.bos.entity.datamodel.AbstractFormDataModel;
+import kd.bos.entity.datamodel.IDataModel;
+import kd.bos.entity.datamodel.TableValueSetter;
+import kd.bos.entity.datamodel.events.PropertyChangedArgs;
+import kd.bos.form.CloseCallBack;
+import kd.bos.form.FormShowParameter;
+import kd.bos.form.MessageBoxResult;
+import kd.bos.form.ShowType;
+import kd.bos.form.control.EntryGrid;
+import kd.bos.form.events.BeforeDoOperationEventArgs;
+import kd.bos.form.events.ClosedCallBackEvent;
+import kd.bos.form.events.MessageBoxClosedEvent;
+import kd.bos.form.operate.FormOperate;
+import kd.bos.form.plugin.AbstractFormPlugin;
+import kd.bos.orm.util.CollectionUtils;
+import kd.sdk.plugin.Plugin;
+import nckd.jxccl.sit.hcsi.formplugin.web.tp.enums.SinsurPresetItemEnum;
+import nckd.jxccl.swc.hsas.common.OutImpPresetItem;
+import nckd.jxccl.swc.hsas.formplugin.web.outdata.helper.OutImpTemplateHelper;
+
+import java.util.*;
+
+/**
+ * Tyx 2025-12-08
+ * 外单位数据导入模板 【nckd_outimptpl】
+ */
+public class OutImpTemplateEdit extends AbstractFormPlugin implements Plugin {
+
+    private static String ENTRYKEY = "nckd_outimptplentry";
+
+    public OutImpTemplateEdit() {
+
+    }
+
+    @Override
+    public void afterCreateNewData(EventObject e) {
+        super.afterCreateNewData(e);
+        // 添加预置数据：
+        createPresetItemData();
+    }
+
+    @Override
+    public void afterBindData(EventObject e) {
+        super.afterBindData(e);
+        this.loadMatchRelationInfo();
+    }
+
+    @Override
+    public void beforeDoOperation(BeforeDoOperationEventArgs args) {
+        super.beforeDoOperation(args);
+        FormOperate formOperate = (FormOperate)args.getSource();
+        String opKey = formOperate.getOperateKey();
+        int[] selectRowIndexs = ((EntryGrid)this.getControl(ENTRYKEY)).getSelectRows();
+        int[] rowIndexs;
+        switch (opKey) {
+            case "donothing_addmaprelation":
+                this.openAddMatchRelationPage();
+                break;
+            case "donothing_deleteentry":
+                if (selectRowIndexs.length == 0) {
+                    this.getView().showTipNotification(ResManager.loadKDString("请选择要执行的数据。", "MigrationTemplateEdit_4", "swc-hsas-formplugin", new Object[0]));
+                } else {
+                    rowIndexs = this.getChangeableRowIndexs(selectRowIndexs);
+                    if (rowIndexs.length < selectRowIndexs.length) {
+                        this.getView().showTipNotification(ResManager.loadKDString("预置字段不可删除。", "MigrationTemplateEdit_0", "swc-hsas-formplugin", new Object[0]));
+                    }
+
+                    this.deleteEntry(rowIndexs);
+                }
+                break;
+            case "donothing_moveup":
+                if (selectRowIndexs.length == 0) {
+                    this.getView().showTipNotification(ResManager.loadKDString("请选中一行再进行操作。", "MigrationTemplateEdit_3", "swc-hsas-formplugin", new Object[0]));
+                } else {
+                    rowIndexs = this.getChangeableRowIndexs(selectRowIndexs);
+                    this.moveUpEntry(rowIndexs);
+                }
+                break;
+            case "donothing_movedown":
+                if (selectRowIndexs.length == 0) {
+                    this.getView().showTipNotification(ResManager.loadKDString("请选中一行再进行操作。", "MigrationTemplateEdit_3", "swc-hsas-formplugin", new Object[0]));
+                } else {
+                    rowIndexs = this.getChangeableRowIndexs(selectRowIndexs);
+                    this.moveDownEntry(rowIndexs);
+                }
+                break;
+            case "save":
+                ((FormOperate)args.getSource()).getOption().setVariableValue("save", Boolean.TRUE.toString());
+                break;
+            case "submit":
+                ((FormOperate)args.getSource()).getOption().setVariableValue("save", Boolean.TRUE.toString());
+                ((FormOperate)args.getSource()).getOption().setVariableValue("isList", Boolean.FALSE.toString());
+        }
+    }
+
+    @Override
+    public void propertyChanged(PropertyChangedArgs e) {
+        super.propertyChanged(e);
+        switch (e.getProperty().getName()) {
+            case "org":
+                this.clearUnPresetItemData();
+                this.createPresetItemData();
+                this.getView().updateView(ENTRYKEY);
+                break;
+        }
+    }
+
+    @Override
+    public void closedCallBack(ClosedCallBackEvent evt) {
+        super.closedCallBack(evt);
+        switch (evt.getActionId()) {
+            case "donothing_addmaprelation":
+                this.addMatchRelationCloseEvent((DynamicObjectCollection)evt.getReturnData());
+            default:
+        }
+    }
+
+    public void confirmCallBack(MessageBoxClosedEvent messageBoxClosedEvent) {
+        super.confirmCallBack(messageBoxClosedEvent);
+        switch (messageBoxClosedEvent.getCallBackId()) {
+            case "write_task_type_change":
+                if (MessageBoxResult.Yes.equals(messageBoxClosedEvent.getResult())) {
+                    this.getPageCache().remove("write_task_type_change");
+                    this.changePresetItemData();
+                } else {
+                    this.getModel().setValue("writetasktype", this.getPageCache().get("write_task_type_change_old"));
+                }
+                this.getPageCache().remove("write_task_type_change_old");
+            default:
+        }
+    }
+
+    private void clearUnPresetItemData() {
+        int row = this.getModel().getEntryEntity(ENTRYKEY).getRowCount();
+        int[] allRowIndex = new int[row];
+        for(int index = 0; index < row; allRowIndex[index] = index++) {
+
+        }
+        this.deleteEntry(allRowIndex);
+    }
+
+    private TableValueSetter createTableValueSetter() {
+        TableValueSetter setter = new TableValueSetter(new String[0]);
+        setter.addField("nckd_matchcolumn", new Object[0]);
+        setter.addField("nckd_itemtype", new Object[0]);
+        setter.addField("nckd_itemid", new Object[0]);
+        setter.addField("nckd_salaryitem", new Object[0]);
+        setter.addField("nckd_bizitem", new Object[0]);
+        setter.addField("nckd_supportitem", new Object[0]);
+        setter.addField("nckd_fetchitem", new Object[0]);
+        setter.addField("nckd_itemnumber", new Object[0]);
+        setter.addField("nckd_itemname", new Object[0]);
+        setter.addField("nckd_datatype", new Object[0]);
+        setter.addField("nckd_comment", new Object[0]);
+        setter.addField("nckd_uniquecode", new Object[0]);
+        return setter;
+    }
+
+    private int[] getChangeableRowIndexs(int[] selectRowIndexs) {
+        int presetDataSize = this.getPresetDataSize();
+        List<Integer> selectRowIndexList = new ArrayList(selectRowIndexs.length);
+        int[] var4 = selectRowIndexs;
+        int var5 = selectRowIndexs.length;
+
+        for(int var6 = 0; var6 < var5; ++var6) {
+            int index = var4[var6];
+            if (index >= presetDataSize) {
+                selectRowIndexList.add(index);
+            }
+        }
+
+        selectRowIndexs = new int[selectRowIndexList.size()];
+
+        for(int index = 0; index < selectRowIndexList.size(); ++index) {
+            selectRowIndexs[index] = (Integer)selectRowIndexList.get(index);
+        }
+
+        return selectRowIndexs;
+    }
+
+    private void deleteEntry(int[] rowIndexs) {
+        if (rowIndexs.length != 0) {
+            this.getModel().deleteEntryRows(ENTRYKEY, rowIndexs);
+        }
+    }
+
+    private void moveUpEntry(int[] rowIndexs) {
+        if (rowIndexs.length != 0) {
+            int presetDataSize = this.getPresetDataSize();
+            if (rowIndexs[0] == presetDataSize) {
+                int continueIndex;
+                for(continueIndex = 0; continueIndex + 1 < rowIndexs.length && rowIndexs[continueIndex + 1] == rowIndexs[continueIndex] + 1; ++continueIndex) {
+                }
+
+                List<Integer> filterIndexList = new ArrayList(rowIndexs.length);
+
+                int index;
+                for(index = continueIndex + 1; index < rowIndexs.length; ++index) {
+                    filterIndexList.add(rowIndexs[index]);
+                }
+
+                rowIndexs = new int[filterIndexList.size()];
+
+                for(index = 0; index < filterIndexList.size(); ++index) {
+                    rowIndexs[index] = (Integer)filterIndexList.get(index);
+                }
+            }
+
+            if (rowIndexs.length != 0) {
+                this.getModel().moveEntryRowsUp(ENTRYKEY, rowIndexs);
+            }
+        }
+    }
+
+    private void moveDownEntry(int[] rowIndexs) {
+        if (rowIndexs.length != 0) {
+            this.getModel().moveEntryRowsDown(ENTRYKEY, rowIndexs);
+        }
+    }
+
+    private void openAddMatchRelationPage() {
+        if (this.getModel().getValue("org") == null) {
+            this.getView().showTipNotification(ResManager.loadKDString("请先选择算发薪管理组织后，再添加映射关系。", "MigrationTemplateEdit_1", "swc-hsas-formplugin", new Object[0]));
+        } else {
+            FormShowParameter showParameter = new FormShowParameter();
+            showParameter.setFormId("nckd_outitemselect");
+            //showParameter.setFormId("hsas_calitemselect");
+            showParameter.getOpenStyle().setShowType(ShowType.Modal);
+            showParameter.setParentPageId(this.getView().getPageId());
+            showParameter.setCaption(ResManager.loadKDString("添加项目", "MigrationTemplateEdit_2", "swc-hsas-formplugin", new Object[0]));
+            showParameter.setCloseCallBack(new CloseCallBack(this, "donothing_addmaprelation"));
+            this.getView().showForm(showParameter);
+        }
+    }
+
+    public void addMatchRelationCloseEvent(DynamicObjectCollection itemDatas) {
+        if (itemDatas != null && itemDatas.size() != 0) {
+            int presetDataSize = this.getPresetDataSize();
+            DynamicObjectCollection entryDatas = this.getModel().getEntryEntity(ENTRYKEY);
+            Map<Long, Map<String, Object>> existItemDataMap = new HashMap(entryDatas.size() - presetDataSize);
+            int[] deleteRowIndex = new int[entryDatas.size() - presetDataSize];
+
+            for(int index = presetDataSize; index < entryDatas.size(); deleteRowIndex[index - presetDataSize] = index++) {
+                DynamicObject entryData = (DynamicObject)entryDatas.get(index);
+                Map<String, Object> existItemData = new HashMap(2);
+                existItemData.put("nckd_matchcolumn", entryData.getString("nckd_matchcolumn"));
+                existItemData.put("nckd_comment", entryData.getString("nckd_comment"));
+                existItemDataMap.put(entryData.getLong("nckd_itemid"), existItemData);
+            }
+
+            if (deleteRowIndex.length != 0) {
+                this.getModel().deleteEntryRows(ENTRYKEY, deleteRowIndex);
+            }
+
+            Map<String, Map<String, Object>> itemParamMap = OutImpTemplateHelper.analyzeItemDatas(itemDatas, existItemDataMap);
+            AbstractFormDataModel model = (AbstractFormDataModel)this.getModel();
+            model.beginInit();
+            TableValueSetter tableValueSetter = this.createTableValueSetter();
+            Iterator it = itemDatas.iterator();
+
+            while(it.hasNext()) {
+                DynamicObject dataObj = (DynamicObject)it.next();
+                String unicode = dataObj.getString("nckd_itemnumber");
+                Map<String, Object> itemParam = (Map)itemParamMap.get(unicode);
+                if (itemParam != null) {
+                    Map<String, Object> existItemData = (Map)existItemDataMap.get(itemParam.get("id"));
+                    String common;
+                    String matchColumn;
+                    if (existItemData != null) {
+                        common = (String)existItemData.get("nckd_comment");
+                        matchColumn = (String)existItemData.get("nckd_matchcolumn");
+                    } else {
+                        common = (String)itemParam.get("nckd_comment");
+                        matchColumn = "";
+                    }
+
+                    String itemType = (String)itemParam.get("itemType");
+                    Long itemId = (Long)itemParam.get("id");
+                    if ("1".equals(itemType)) {
+                        tableValueSetter.addRow(new Object[]{matchColumn, itemParam.get("itemType"), itemId, itemId, 0L, 0L, 0L, dataObj.get("nckd_itemnumber"), dataObj.get("nckd_itemname"), itemParam.get("dataTypeId"), common, unicode});
+                    } else if ("2".equals(itemType)) {
+                        tableValueSetter.addRow(new Object[]{matchColumn, itemParam.get("itemType"), itemId, itemId, 0L, 0L, 0L, dataObj.get("nckd_itemnumber"), dataObj.get("nckd_itemname"), itemParam.get("dataTypeId"), common, unicode});
+                    } else if ("4".equals(itemType)) {
+                        tableValueSetter.addRow(new Object[]{matchColumn, itemParam.get("itemType"), itemId, 0L, 0L, 0L, itemId, dataObj.get("nckd_itemnumber"), dataObj.get("nckd_itemname"), itemParam.get("dataTypeId"), common, unicode});
+                    } else if ("3".equals(itemType)) {
+                        tableValueSetter.addRow(new Object[]{matchColumn, itemParam.get("itemType"), itemId, 0L, itemId, 0L, 0L, dataObj.get("nckd_itemnumber"), dataObj.get("nckd_itemname"), itemParam.get("dataTypeId"), common, unicode});
+                    }
+                }
+            }
+
+            model.batchCreateNewEntryRow(ENTRYKEY, tableValueSetter);
+            model.endInit();
+            this.getView().updateView(ENTRYKEY);
+        }
+    }
+
+    private void loadMatchRelationInfo() {
+        DynamicObjectCollection entryDatas = this.getModel().getEntryEntity(ENTRYKEY);
+        int presetDataSize = this.getPresetDataSize();
+        if (!CollectionUtils.isEmpty(entryDatas)) {
+            Map<String, Map<String, Object>> itemParamMap = OutImpTemplateHelper.analyzeMatchItem(entryDatas);
+            IDataModel model = this.getModel();
+
+            int index;
+            DynamicObject entry;
+            for(index = 0; index < presetDataSize; ++index) {
+                entry = (DynamicObject)entryDatas.get(index);
+                Long itemId = entry.getLong("nckd_itemid");
+                OutImpPresetItem presetItemEnum = OutImpTemplateHelper.getPresetItemEnum(itemId);
+                if (presetItemEnum != null) {
+                    model.setValue("nckd_itemnumber", '-', index);
+                    model.setValue("nckd_itemnumber", presetItemEnum.getItemName(), index);
+                    model.setValue("nckd_itemnumber", "", index);
+                }
+            }
+
+            for(index = presetDataSize; index < entryDatas.size(); ++index) {
+                entry = (DynamicObject)entryDatas.get(index);
+                String itemType = entry.getString("nckd_itemtype");
+                Long itemId = entry.getLong("nckd_itemid");
+                Map<String, Object> itemParam = (Map)itemParamMap.get(itemType + '-' + itemId);
+                if (itemParam != null) {
+                    model.setValue("nckd_itemnumber", itemParam.get("nckd_itemnumber"), index);
+                    model.setValue("nckd_itemnumber", itemParam.get("nckd_itemnumber"), index);
+                    model.setValue("nckd_itemnumber", itemParam.get("nckd_itemnumber"), index);
+                }
+            }
+
+            this.getView().updateView(ENTRYKEY);
+            this.getModel().setDataChanged(false);
+        }
+    }
+
+    private int getPresetDataSize() {
+        DynamicObjectCollection entryDatas = this.getModel().getEntryEntity(ENTRYKEY);
+        int index;
+        for(index = 0; index < entryDatas.size(); ++index) {
+            DynamicObject entry = (DynamicObject)entryDatas.get(index);
+            if (!StringUtils.equals(entry.getString("nckd_itemtype"), "0")) {
+                break;
+            }
+        }
+        return index;
+    }
+
+    private void createPresetItemData() {
+        AbstractFormDataModel model = (AbstractFormDataModel) this.getModel();
+        TableValueSetter tableValueSetter = this.createTableValueSetter();
+        List<OutImpPresetItem> presetItemEnumsList = OutImpTemplateHelper.getPresetItemEnumList();
+        if (!CollectionUtils.isEmpty(presetItemEnumsList)) {
+            for(OutImpPresetItem presetItemEnum : presetItemEnumsList) {
+                tableValueSetter.addRow(new Object[]{presetItemEnum.getMatchColumn(), "0", presetItemEnum.getItemId(), 0L, 0L, 0L, 0L, '-', presetItemEnum.getItemName(), presetItemEnum.getDataTypeId(), presetItemEnum.getComment(), ""});
+            }
+        }
+        model.beginInit();
+        model.batchCreateNewEntryRow(ENTRYKEY, tableValueSetter);
+        model.endInit();
+        this.getView().updateView(ENTRYKEY);
+    }
+
+    private void changePresetItemData() {
+//        DynamicObjectCollection entryDatas = this.getModel().getEntryEntity(ENTRYKEY);
+//        Iterator<DynamicObject> iterator = entryDatas.iterator();
+//
+//        while(iterator.hasNext()) {
+//            DynamicObject next = (DynamicObject)iterator.next();
+//            if (SWCStringUtils.equals(next.getString("nckd_itemtype"), "0")) {
+//                iterator.remove();
+//            }
+//        }
+//
+//        List<DynamicObject> entryList = new ArrayList(entryDatas.size());
+//        entryList.addAll(entryDatas);
+//        this.getModel().deleteEntryData(ENTRYKEY);
+//        AbstractFormDataModel model = (AbstractFormDataModel)this.getModel();
+//        DynamicObject data = model.getDataEntity();
+//        model.beginInit();
+//        TableValueSetter tableValueSetter = this.createTableValueSetter();
+//        List<PresetItemEnum> presetItemEnumsList = OutImpTemplateHelper.getPresetItemEnumList(data.getString("writetasktype"), data.getBoolean("ismultimeoneperiod"));
+//        if (!CollectionUtils.isEmpty(presetItemEnumsList)) {
+//            Iterator it = presetItemEnumsList.iterator();
+//
+//            while(it.hasNext()) {
+//                PresetItemEnum presetItemEnum = (PresetItemEnum)it.next();
+//                tableValueSetter.addRow(new Object[]{presetItemEnum.getMatchColumn(), "0", presetItemEnum.getItemId(), 0L, 0L, 0L, 0L, '-', presetItemEnum.getItemName(), presetItemEnum.getDataTypeId(), presetItemEnum.getComment().getLocaleString(), ""});
+//            }
+//
+//            it = entryList.iterator();
+//
+//            while(it.hasNext()) {
+//                DynamicObject entryData = (DynamicObject)it.next();
+//                tableValueSetter.addRow(new Object[]{
+//                        entryData.getString("nckd_matchcolumn"),
+//                        entryData.getString("nckd_itemtype"),
+//                        entryData.getLong("nckd_itemid"),
+//                        entryData.getLong("nckd_salaryitem.id"),
+//                        entryData.getLong("nckd_bizitem.id"),
+//                        entryData.getLong("nckd_supportitem.id"),
+//                        entryData.getLong("nckd_fetchitem.id"),
+//                        entryData.getString("nckd_itemnumber"),
+//                        entryData.getString("nckd_itemname"),
+//                        entryData.getLong("nckd_datatype.id"),
+//                        entryData.getString("nckd_comment"),
+//                        entryData.getString("nckd_uniquecode")
+//                });
+//            }
+//
+//            model.batchCreateNewEntryRow(ENTRYKEY, tableValueSetter);
+//            model.endInit();
+//            this.getView().updateView(ENTRYKEY);
+//        }
+    }
+
+}

code/swc/nckd-jxccl-swc/src/main/java/nckd/jxccl/swc/hsas/formplugin/web/outdata/basedata/OutImpTemplateSelectEdit.java

@@ -0,0 +1,130 @@
+package nckd.jxccl.swc.hsas.formplugin.web.outdata.basedata;
+
+import com.google.common.collect.Maps;
+import kd.bos.dataentity.resource.ResManager;
+import kd.bos.dataentity.utils.StringUtils;
+import kd.bos.entity.datamodel.IDataModel;
+import kd.bos.form.FormShowParameter;
+import kd.bos.form.IFormView;
+import kd.bos.form.MessageTypes;
+import kd.bos.form.control.Control;
+import kd.bos.form.control.Image;
+import kd.bos.form.control.Label;
+import kd.bos.form.control.events.UploadEvent;
+import kd.bos.form.control.events.UploadListener;
+import kd.bos.form.plugin.AbstractFormPlugin;
+import kd.bos.url.UrlService;
+import kd.sdk.plugin.Plugin;
+import nckd.jxccl.sit.hcsi.business.importtaskguide.ImportTaskGuideExportService;
+import nckd.jxccl.sit.hcsi.business.importtaskguide.ImportTaskGuideImportService;
+import nckd.jxccl.swc.hsas.business.outdata.OutImportTaskGuideExportService;
+import nckd.jxccl.swc.hsas.business.outdata.OutImportTaskGuideImportService;
+
+import java.util.EventObject;
+import java.util.Map;
+
+/**
+ * Tyx 2025-12-09
+ * 导入模板选择界面插件 【nckd_outimptplselect】
+ */
+public class OutImpTemplateSelectEdit extends AbstractFormPlugin implements UploadListener {
+    private static final String KEY_BTN_OK = "btnok";
+    private static final String KEY_BTN_DOWNLOAD = "btndownload";
+    private static final String KEY_BTN_RESETFILE = "btnresetfile";
+    private static final String KEY_BTN_UPLOAD = "btnupload";
+
+    public OutImpTemplateSelectEdit() {
+
+    }
+
+    @Override
+    public void initialize() {
+        this.addClickListeners(new String[]{KEY_BTN_OK, KEY_BTN_DOWNLOAD, KEY_BTN_RESETFILE});
+        Image label = (Image)this.getControl(KEY_BTN_UPLOAD);
+        label.addUploadListener(this);
+    }
+
+    @Override
+    public void afterCreateNewData(EventObject e) {
+        this.getView().setVisible(Boolean.FALSE, new String[]{"filepanel"});
+        this.getView().setEnable(Boolean.FALSE, new String[]{"keyfields"});
+        Label title = (Label)this.getControl("title");
+        title.setText(ResManager.loadKDString("导入任务", "TaskGuideImportViewPlugin_0", "swc-hsas-formplugin", new Object[0]));
+    }
+
+    @Override
+    public void click(EventObject evt) {
+        switch (((Control)evt.getSource()).getKey()) {
+            case KEY_BTN_OK:
+                this.importData();
+                break;
+            case KEY_BTN_DOWNLOAD:
+                OutImportTaskGuideExportService exportService = new OutImportTaskGuideExportService();
+                exportService.exportExcelTemplate(this.getView());
+                break;
+            case KEY_BTN_RESETFILE:
+                this.resetFileInfo();
+        }
+    }
+
+    public void upload(UploadEvent evt) {
+        Object[] urls = evt.getUrls();
+        if (urls.length > 0) {
+            IFormView view = this.getView();
+            String url = (String)urls[0];
+            view.setVisible(Boolean.TRUE, new String[]{"filepanel"});
+            view.setVisible(Boolean.FALSE, new String[]{"uploadpanel"});
+            IDataModel model = this.getModel();
+            model.setValue("filename", url.substring(url.lastIndexOf(47) + 1));
+            String fullUrl = UrlService.getAttachmentFullUrl(url);
+            model.setValue("filepath", url);
+            model.setValue("fullpath", fullUrl);
+        }
+    }
+
+    private void resetFileInfo() {
+        this.getModel().setValue("filename", "");
+        this.getModel().setValue("filepath", "");
+        this.getView().setVisible(Boolean.FALSE, new String[]{"filepanel"});
+        this.getView().setVisible(Boolean.TRUE, new String[]{"uploadpanel"});
+    }
+
+    private void importData() {
+        String url = this.getModel().getDataEntity().getString("filepath");
+        if (StringUtils.isBlank(url)) {
+            this.getView().showErrorNotification(ResManager.loadKDString("请先上传数据文件后操作。", "HSASCalTableImportStartPlugin_1", "swc-hsas-formplugin", new Object[0]));
+        } else {
+            FormShowParameter params = this.getView().getFormShowParameter();
+            Long importTaskId = (Long)params.getCustomParam("importTaskId");
+            Long tplId = (Long)params.getCustomParam("outimpTplId");
+            Long periodId = params.getCustomParam("periodId");
+            String periodNumber = params.getCustomParam("periodNumber");
+            Long orgId = Long.valueOf(params.getCustomParam("orgId").toString());
+            String importTaskName = (String)params.getCustomParam("importTaskName");
+            String pageId = this.getView().getParentView().getPageId();
+            OutImportTaskGuideImportService importService = new OutImportTaskGuideImportService(url, importTaskId, tplId, periodId, periodNumber);
+
+            try {
+                Map<String, String> result = importService.parseAndCheckExcelData(orgId, pageId, importTaskName);
+                String errorMsg = (String)result.get("errorMsg");
+                if (!StringUtils.isEmpty(errorMsg)) {
+                    this.getView().showErrorNotification(errorMsg);
+                    return;
+                }
+
+                Map<String, Object> returnData = Maps.newHashMapWithExpectedSize(16);
+                returnData.put("isOk", Boolean.TRUE);
+                returnData.put("totalCount", result.get("totalCount"));
+                returnData.put("cacheKey", result.get("cacheKey"));
+                returnData.put("importTaskId", importTaskId);
+                returnData.put("outimpTplId", tplId);
+                this.getView().returnDataToParent(returnData);
+                this.getView().close();
+            } catch (Exception e) {
+                String msg = ResManager.loadKDString("导入模板格式错误，请上传正确格式的数据模板。", "ImportConstants_3", "swc-hsbp-common", new Object[0]);
+                this.getView().showMessage(msg, e.getMessage(), MessageTypes.Default);
+            }
+
+        }
+    }
+}

code/swc/nckd-jxccl-swc/src/main/java/nckd/jxccl/swc/hsas/formplugin/web/outdata/basedata/OutItemSelectAddItemPlugin.java

@@ -0,0 +1,498 @@
+package nckd.jxccl.swc.hsas.formplugin.web.outdata.basedata;
+
+import com.kingdee.util.StringUtils;
+import kd.bos.dataentity.entity.DynamicObject;
+import kd.bos.dataentity.entity.DynamicObjectCollection;
+import kd.bos.dataentity.resource.ResManager;
+import kd.bos.dataentity.serialization.SerializationUtils;
+import kd.bos.dataentity.utils.ObjectUtils;
+import kd.bos.entity.datamodel.AbstractFormDataModel;
+import kd.bos.entity.datamodel.IDataModel;
+import kd.bos.entity.datamodel.TableValueSetter;
+import kd.bos.entity.tree.TreeNode;
+import kd.bos.form.CloseCallBack;
+import kd.bos.form.FormShowParameter;
+import kd.bos.form.ShowType;
+import kd.bos.form.control.Control;
+import kd.bos.form.control.EntryGrid;
+import kd.bos.form.control.TreeView;
+import kd.bos.form.events.AfterDoOperationEventArgs;
+import kd.bos.form.events.BeforeDoOperationEventArgs;
+import kd.bos.form.events.ClosedCallBackEvent;
+import kd.bos.form.operate.FormOperate;
+import kd.bos.form.plugin.AbstractFormPlugin;
+import kd.bos.util.CollectionUtils;
+import kd.hr.hbp.common.cache.HRPageCache;
+import kd.sdk.plugin.Plugin;
+import nckd.jxccl.swc.hsas.formplugin.web.outdata.helper.OutItemSelectAddItemServiceHelper;
+
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * Tyx 2025-12-08
+ * 外单位数据导入项目选择页面 【nckd_outitemselect】
+ */
+public class OutItemSelectAddItemPlugin extends AbstractFormPlugin implements Plugin {
+
+    private static final String BUTTON_CANCEL = "nckd_btncancel";
+    private static final String BUTTON_SAVE = "nckd_btnsave";
+    private static final String ENTRY_SELECT = "nckd_itemselectentry";
+    private static final String TREE_VIEW = "nckd_treeviewap";
+    private static final String FORM_MOVE_TO = "hsas_calitemmoveto";
+    private static final String ITEM_TYPE_II = "SI";
+    private static final String BASE_TYPE_II = "BI";
+    private static final Map<String, String> ITEM_TYPE_MAPPING = new HashMap();
+    private static final Map<String, String> ITEM_CATEGORY_MAPPING =  new HashMap();
+    static {
+        ITEM_TYPE_MAPPING.put("1", ITEM_TYPE_II);
+        ITEM_TYPE_MAPPING.put("2", BASE_TYPE_II);
+        ITEM_CATEGORY_MAPPING.put(ITEM_TYPE_II, ITEM_TYPE_II);
+        ITEM_CATEGORY_MAPPING.put(BASE_TYPE_II, BASE_TYPE_II);
+    }
+
+
+    @Override
+    public void registerListener(EventObject e) {
+        super.registerListener(e);
+        this.addClickListeners(BUTTON_CANCEL, BUTTON_SAVE);
+    }
+
+    @Override
+    public void beforeBindData(EventObject e) {
+        super.beforeBindData(e);
+        long orgId = getOrgId();
+        loadMainPageData();
+        OutItemSelectAddItemServiceHelper helper = new OutItemSelectAddItemServiceHelper();
+        Map<String, Map<String, Map<String, Object>>> dataMap = helper.getAllItemData(orgId);
+        initItemTree(dataMap);
+    }
+
+    private void initItemTree(Map<String, Map<String, Map<String, Object>>> dataMap) {
+        TreeView treeView = (TreeView)this.getView().getControl(TREE_VIEW);
+        List<TreeNode> nodeList = buildTreeNodeList(dataMap);
+
+        treeView.deleteAllNodes();
+        treeView.addNodes(nodeList);
+
+        updatePageCache(nodeList, dataMap);
+        checkSelectedTreeNode(treeView, nodeList);
+    }
+
+    private List<TreeNode> buildTreeNodeList(Map<String, Map<String, Map<String, Object>>> dataMap) {
+        List<TreeNode> list = new ArrayList<>();
+        list.addAll(OutItemSelectAddItemServiceHelper.loadSalaryItemChildNode(null, false, dataMap));
+        list.addAll(OutItemSelectAddItemServiceHelper.loadBaseItemChildNode(null, false, dataMap));
+        return list;
+    }
+
+    private void updatePageCache(List<TreeNode> nodeList, Map<String, Map<String, Map<String, Object>>> dataMap) {
+        HRPageCache pageCache = new HRPageCache(this.getView());
+        Map<String, TreeNode> treeNodeMap = nodeList.stream()
+                .collect(Collectors.toMap(TreeNode::getId, Function.identity()));
+
+        pageCache.put("tree", SerializationUtils.serializeToBase64(treeNodeMap));
+        pageCache.put("allItemData", dataMap);
+        pageCache.put("simpleAllItemData", rebuildData(dataMap));
+    }
+
+    private Map<String, Map<String, String>> rebuildData(Map<String, Map<String, Map<String, Object>>> dataMap) {
+        if (dataMap != null && dataMap.size() != 0) {
+            return Collections.emptyMap();
+        }
+
+        return dataMap.entrySet().stream()
+                .collect(Collectors.toMap(
+                        Map.Entry::getKey,
+                        entry -> entry.getValue().entrySet().stream()
+                                .collect(Collectors.toMap(
+                                        Map.Entry::getKey,
+                                        innerEntry -> (String)innerEntry.getValue().get("uniquecode")
+                                ))
+                ));
+    }
+
+    public void addColumn() {
+        TreeView treeView = (TreeView)this.getView().getControl(TREE_VIEW);
+        List<String> selectNodeIds = treeView.getTreeState().getCheckedNodeIds();
+        if (CollectionUtils.isEmpty(selectNodeIds)) {
+            this.getView().showTipNotification(ResManager.loadKDString("请先选中数据。", "CalResultTplAddItemPlugin_0", "swc-hsas-formplugin", new Object[0]));
+            return;
+        }
+
+        HRPageCache pageCache = new HRPageCache(this.getView());
+        Map<String, TreeNode> nodeMap = getNodeMapFromCache(pageCache);
+        Map<String, Map<String, Map<String, Object>>> dataMap = (Map)pageCache.get("allItemData", Map.class);
+
+        AbstractFormDataModel model = (AbstractFormDataModel)this.getModel();
+        model.beginInit();
+
+        try {
+            TableValueSetter vs = createTableValueSetter();
+            List<TreeNode> checkNodeList = new ArrayList<>(selectNodeIds.size());
+
+            for (String selectNodeId : selectNodeIds) {
+                TreeNode treeNode = getTreeNodeByTreeId(nodeMap, selectNodeId);
+//                TreeNode treeNode = nodeMap.get(selectNodeId);
+                if (!isValidNode(treeNode, selectNodeId)) {
+                    continue;
+                }
+
+                String itemCategory = getItemCategory(treeNode);
+                String itemNum = getItemNumber(dataMap, itemCategory, treeNode.getText(), treeNode);
+                String itemUnicodeId = getItemUnicodeId(treeNode.getId(), treeNode.getText());
+
+                vs.addRow(new Object[]{itemCategory, itemNum, treeNode.getText(), itemUnicodeId, treeNode.getId()});
+                checkNodeList.add(treeNode);
+            }
+
+            model.batchCreateNewEntryRow(ENTRY_SELECT, vs);
+            this.getView().updateView(ENTRY_SELECT);
+
+            if (CollectionUtils.isNotEmpty(checkNodeList)) {
+                treeView.checkNodes(checkNodeList);
+            }
+        } finally {
+            model.endInit();
+        }
+    }
+
+    private Map<String, TreeNode> getNodeMapFromCache(HRPageCache pageCache) {
+        String cacheTreeNodeStr = (String)pageCache.get("tree", String.class);
+        return (Map)SerializationUtils.deSerializeFromBase64(cacheTreeNodeStr);
+    }
+
+    private TableValueSetter createTableValueSetter() {
+        TableValueSetter vs = new TableValueSetter(new String[0]);
+        vs.addField("nckd_itemcategory", new Object[0]);
+        vs.addField("nckd_itemnumber", new Object[0]);
+        vs.addField("nckd_itemname", new Object[0]);
+        vs.addField("nckd_itemunicodeid", new Object[0]);
+        vs.addField("nckd_treenodeid", new Object[0]);
+        return vs;
+    }
+
+    private boolean isValidNode(TreeNode treeNode, String selectNodeId) {
+        if (treeNode == null || StringUtils.isEmpty(treeNode.getId())) {
+            return false;
+        }
+
+        String treeNodeId = treeNode.getId();
+
+        if(treeNode.getChildren() != null) {
+            return false;
+        }
+
+//        if (treeNodeId.equals("II") || treeNodeId.equals("BI")) {
+//            return false;
+//        }
+
+        return !isExistTreeNode(selectNodeId);
+    }
+
+    private String getItemCategory(TreeNode treeNode) {
+        //String treeNodeId = treeNode.getId();
+        String itemCategory = treeNode.getParentid().substring(0, 2);
+        return normalizeItemCategory(itemCategory);
+////        String itemCategory = ITEM_TYPE_II;
+//        if(treeNode.getId().equals("999990") || treeNode.getId().equals("999991")){
+//            return normalizeItemCategory(BASE_TYPE_II);
+//        }
+//        else {
+//            return normalizeItemCategory(ITEM_TYPE_II);
+//        }
+    }
+
+    private void removeCheckNode(int[] rows) {
+        DynamicObjectCollection selectDatas = this.getView().getModel().getEntryEntity(ENTRY_SELECT);
+        HRPageCache pageCache = new HRPageCache(this.getView());
+        Map<String, TreeNode> nodeMap = getNodeMapFromCache(pageCache);
+
+        List<String> removeCheckNodeList = Arrays.stream(rows)
+                .mapToObj(index -> {
+                    DynamicObject selectData = (DynamicObject)selectDatas.get(index);
+                    return nodeMap.get(selectData.getString("nckd_itemunicodeid"));
+                })
+                .filter(Objects::nonNull)
+                .map(TreeNode::getId)
+                .collect(Collectors.toList());
+
+        TreeView treeView = (TreeView)this.getView().getControl(TREE_VIEW);
+        treeView.uncheckNodes(removeCheckNodeList);
+    }
+
+    private String getItemNumber(Map<String, Map<String, Map<String, Object>>> dataMap, String itemCategory, String treeNodeName, TreeNode treeNode) {
+        String mapKey = getItemMapKey(itemCategory, treeNode);
+        Map<String, Map<String, Object>> itemMap = (Map)dataMap.get(mapKey);
+
+        if (itemMap == null) {
+            return "";
+        }
+
+        Map<String, Object> nameMap = itemMap.get(treeNodeName);
+        if (nameMap != null && nameMap.size() != 0) {
+            String number = (String)nameMap.get("number");
+            return StringUtils.isEmpty(number) ? "" : number;
+        }
+        else {
+            return "";
+        }
+    }
+
+    private String getItemMapKey(String itemCategory, TreeNode treeNode) {
+        switch (itemCategory) {
+            case ITEM_TYPE_II:
+                return "salaryitemkey";
+            case BASE_TYPE_II:
+                return "baseitemkey";
+            default:
+                return "";
+        }
+    }
+
+    public boolean isExistTreeNode(String selectTreeNodeId) {
+        DynamicObjectCollection itemDatas = this.getModel().getEntryEntity(ENTRY_SELECT);
+        return itemDatas.stream()
+                .anyMatch(itemData -> StringUtils.equals(
+                        itemData.getString("nckd_treenodeid"),
+                        selectTreeNodeId
+                ));
+    }
+
+    private long getOrgId() {
+        return ((DynamicObject)this.getView().getParentView().getModel().getValue("org")).getLong("id");
+    }
+
+    @Override
+    public void beforeDoOperation(BeforeDoOperationEventArgs args) {
+        super.beforeDoOperation(args);
+        FormOperate formOperate = (FormOperate)args.getSource();
+        if ("do_moveto".equals(formOperate.getOperateKey())) {
+            openMoveToPage(args);
+        }
+    }
+
+    @Override
+    public void afterDoOperation(AfterDoOperationEventArgs args) {
+        super.afterDoOperation(args);
+        switch (args.getOperateKey()) {
+            case "do_addcolumn":
+                addColumn();
+                break;
+            case "do_removecolumn":
+                removeColumn();
+        }
+    }
+
+    @Override
+    public void click(EventObject evt) {
+        super.click(evt);
+        Control source = (Control)evt.getSource();
+        switch (source.getKey()) {
+            case BUTTON_CANCEL:
+                this.getView().close();
+                break;
+            case BUTTON_SAVE:
+                btnOkClickEvent();
+        }
+    }
+
+    @Override
+    public void closedCallBack(ClosedCallBackEvent evt) {
+        if ("movetoclosed".equals(evt.getActionId())) {
+            moveToClosedEvent(evt);
+        }
+    }
+
+    private void checkSelectedTreeNode(TreeView treeView, List<TreeNode> nodeList) {
+        DynamicObjectCollection selectDatas = this.getView().getModel().getEntryEntity("nckd_itemselectentry");
+        Set<String> uniqueCodeSet = selectDatas.stream()
+                .map(selectData -> selectData.getString("nckd_treenodeid"))
+                .collect(Collectors.toSet());
+
+        List<TreeNode> checkNodeList = this.getCheckTreeNodeList(nodeList, uniqueCodeSet);
+        if (CollectionUtils.isNotEmpty(checkNodeList)) {
+            treeView.checkNodes(checkNodeList);
+        }
+    }
+
+    public List<TreeNode> getCheckTreeNodeList(List<TreeNode> nodeList, Set<String> uniqueCodeSet) {
+        if (org.apache.commons.collections4.CollectionUtils.isEmpty(uniqueCodeSet)) {
+            return new ArrayList(0);
+        } else {
+            Queue<TreeNode> waitToCheckQueue = new LinkedList();
+            waitToCheckQueue.addAll(nodeList);
+            List<TreeNode> checkNodeList = new ArrayList(10);
+
+            while(waitToCheckQueue.size() > 0) {
+                TreeNode treeNode = (TreeNode)waitToCheckQueue.poll();
+                List<TreeNode> childeList = treeNode.getChildren();
+                if (org.apache.commons.collections4.CollectionUtils.isNotEmpty(childeList)) {
+                    waitToCheckQueue.addAll(childeList);
+                } else if (uniqueCodeSet.contains(treeNode.getId())) {
+                    checkNodeList.add(treeNode);
+                }
+            }
+
+            return checkNodeList;
+        }
+    }
+
+    public void loadMainPageData() {
+        loadMainPageDataFromOutImpTempate();
+    }
+
+    private void loadMainPageDataFromOutImpTempate() {
+        DynamicObjectCollection matchRelationDatas = this.getView().getParentView().getModel()
+                .getEntryEntity("nckd_outimptplentry");
+        if (CollectionUtils.isEmpty(matchRelationDatas)) {
+            return;
+        }
+
+        IDataModel model = this.getModel();
+        for (DynamicObject matchRelationData : matchRelationDatas) {
+            String itemType = matchRelationData.getString("nckd_itemtype");
+            String itemCategory = ITEM_TYPE_MAPPING.get(itemType);
+
+            if (itemCategory != null) {
+                int detailIndex = model.createNewEntryRow(ENTRY_SELECT);
+                populateEntryData(model, matchRelationData, itemCategory, detailIndex);
+            }
+        }
+        this.getView().updateView(ENTRY_SELECT);
+    }
+
+    private void populateEntryData(IDataModel model, DynamicObject sourceData, String itemCategory, int detailIndex) {
+        model.setValue("nckd_itemnumber", sourceData.getString("nckd_itemnumber"), detailIndex);
+        model.setValue("nckd_itemcategory", itemCategory, detailIndex);
+        model.setValue("nckd_itemname", sourceData.getString("nckd_itemname"), detailIndex);
+        model.setValue("nckd_itemunicodeid", sourceData.getString("nckd_uniquecode"), detailIndex);
+        model.setValue("nckd_treenodeid", sourceData.getString("nckd_itemid"), detailIndex);
+    }
+
+    public void btnOkClickEvent() {
+        DynamicObjectCollection entryDatas = this.getModel().getEntryEntity(ENTRY_SELECT);
+        if (CollectionUtils.isEmpty(entryDatas)) {
+            this.getView().showTipNotification(ResManager.loadKDString("请先添加项目。", "CalResultTplAddItemPlugin_4", "swc-hsas-formplugin", new Object[0]));
+            return;
+        }
+        this.getView().returnDataToParent(entryDatas);
+        this.getView().close();
+    }
+
+    public void moveToClosedEvent(ClosedCallBackEvent evt) {
+        Map<String, Object> returnData = (Map)evt.getReturnData();
+        if (ObjectUtils.isEmpty(returnData) || !"ok".equals(returnData.get("clickStatus"))) {
+            return;
+        }
+
+        EntryGrid entryGrid = (EntryGrid)this.getView().getControl(ENTRY_SELECT);
+        int[] rows = entryGrid.getSelectRows();
+        int oldRow = rows[0];
+        int newRow = (Integer)returnData.get("rownumber") - 1;
+
+        IDataModel model = this.getModel();
+        DynamicObjectCollection datas = model.getEntryEntity(ENTRY_SELECT);
+        newRow = Math.min(newRow, datas.size() - 1);
+
+        if (oldRow != newRow) {
+            DynamicObject oldObj = (DynamicObject)datas.get(oldRow);
+            model.deleteEntryRow(ENTRY_SELECT, oldRow);
+            model.createNewEntryRow(ENTRY_SELECT, newRow, oldObj);
+            entryGrid.selectRows(newRow, true);
+        }
+    }
+
+    private String normalizeItemCategory(String itemCategory) {
+        return ITEM_CATEGORY_MAPPING.getOrDefault(itemCategory, itemCategory);
+    }
+
+    public String getItemUnicodeId(String treeNodeId, String treeNodeName) {
+        HRPageCache pageCache = new HRPageCache(this.getView());
+        Map<String, Map<String, String>> dataMap = (Map)pageCache.get("simpleAllItemData", Map.class);
+        if (ObjectUtils.isEmpty(dataMap)) {
+            return "";
+        }
+
+        return dataMap.values().stream()
+                .map(itemData -> itemData.get(treeNodeName))
+                .filter(uniqueCode -> StringUtils.equals(uniqueCode, treeNodeId))
+                .findFirst()
+                .orElse("");
+    }
+
+    public TreeNode getTreeNodeByTreeId(Map<String, TreeNode> nodeMap, String treeId) {
+        if (nodeMap == null || StringUtils.isEmpty(treeId)) {
+            return null;
+        }
+
+        for (Map.Entry<String, TreeNode> entry : nodeMap.entrySet()) {
+            TreeNode node = entry.getValue();
+            TreeNode result = getSubTreeNode(treeId, node);
+            if (result != null) {
+                return result;
+            }
+        }
+        return null;
+    }
+
+    private TreeNode getSubTreeNode(String treeId, TreeNode node) {
+        if (node == null) {
+            return null;
+        }
+        // 检查当前节点
+        if (treeId.equals(node.getId())) {
+            return node;
+        }
+        // 递归检查子节点
+        if (node.getChildren() != null) {
+            for (TreeNode child : node.getChildren()) {
+                TreeNode result = getSubTreeNode(treeId, child);
+                if (result != null) {
+                    return result;
+                }
+            }
+        }
+        return null;
+    }
+
+    public void removeColumn() {
+        EntryGrid entryGrid = (EntryGrid)this.getView().getControl(ENTRY_SELECT);
+        int[] rows = entryGrid.getSelectRows();
+
+        if (rows == null || rows.length == 0) {
+            this.getView().showTipNotification(ResManager.loadKDString("请选中一行再进行操作。", "CalResultTplAddItemPlugin_1", "swc-hsas-formplugin", new Object[0]));
+            return;
+        }
+
+        removeCheckNode(rows);
+        this.getModel().deleteEntryRows(ENTRY_SELECT, rows);
+    }
+
+    public void openMoveToPage(BeforeDoOperationEventArgs args) {
+        EntryGrid entryGrid = (EntryGrid)this.getView().getControl(ENTRY_SELECT);
+        int[] rows = entryGrid.getSelectRows();
+
+        if (rows == null || rows.length == 0) {
+            this.getView().showTipNotification(ResManager.loadKDString("请选择要执行的数据。", "CalResultTplAddItemPlugin_2", "swc-hsas-formplugin", new Object[0]));
+            args.setCancel(true);
+            return;
+        }
+
+        if (rows.length != 1) {
+            this.getView().showTipNotification(ResManager.loadKDString("只能选择一条记录。", "CalResultTplAddItemPlugin_3", "swc-hsas-formplugin", new Object[0]));
+            args.setCancel(true);
+            return;
+        }
+
+        FormShowParameter showParameter = new FormShowParameter();
+        showParameter.setFormId(FORM_MOVE_TO);
+        showParameter.getOpenStyle().setShowType(ShowType.Modal);
+        showParameter.setParentPageId(this.getView().getPageId());
+        showParameter.setCaption(ResManager.loadKDString("移动到", "CalResultTplAddItemPlugin_5", "swc-hsas-formplugin", new Object[0]));
+        showParameter.setCloseCallBack(new CloseCallBack(this, "movetoclosed"));
+        this.getView().showForm(showParameter);
+    }
+
+}

code/swc/nckd-jxccl-swc/src/main/java/nckd/jxccl/swc/hsas/formplugin/web/outdata/bill/OutTempDataListPlugin.java

@@ -0,0 +1,129 @@
+package nckd.jxccl.swc.hsas.formplugin.web.outdata.bill;
+
+import com.kingdee.util.DateTimeUtils;
+import kd.bos.dataentity.entity.DynamicObject;
+import kd.bos.dataentity.resource.ResManager;
+import kd.bos.dataentity.utils.StringUtils;
+import kd.bos.form.CloseCallBack;
+import kd.bos.form.FormShowParameter;
+import kd.bos.form.ShowType;
+import kd.bos.form.events.BeforeDoOperationEventArgs;
+import kd.bos.form.events.ClosedCallBackEvent;
+import kd.bos.form.operate.FormOperate;
+import kd.bos.list.plugin.AbstractListPlugin;
+import kd.bos.orm.query.QFilter;
+import kd.hr.hbp.business.servicehelper.HRBaseServiceHelper;
+import kd.sdk.plugin.Plugin;
+
+import java.util.Date;
+import java.util.Map;
+
+/**
+ * Tyx 2025-12-10
+ * 外单位导入数据列表插件 【nckd_outtempdata】
+ */
+public class OutTempDataListPlugin extends AbstractListPlugin implements Plugin {
+
+    @Override
+    public void beforeDoOperation(BeforeDoOperationEventArgs args) {
+        super.beforeDoOperation(args);
+        FormOperate formOperate = (FormOperate)args.getSource();
+        String opKey = formOperate.getOperateKey();
+        switch (opKey) {
+            case "donothing_import":
+                this.opeanImportStartPage();
+                break;
+        }
+    }
+
+    /**
+     * 打开选择导入模板界面
+     */
+    private void opeanImportStartPage() {
+        if (!this.checkTaskStatus(false, true)) {
+            FormShowParameter formShowParameter = new FormShowParameter();
+            formShowParameter.setShowTitle(false);
+            formShowParameter.setFormId("nckd_outimptplselect");
+            formShowParameter.getOpenStyle().setShowType(ShowType.Modal);
+            formShowParameter.setCustomParam("importTaskName", this.getView().getFormShowParameter().getCustomParam("importTaskName"));
+            formShowParameter.setCustomParam("outimpTplId", this.getView().getFormShowParameter().getCustomParam("outimpTplId"));
+            formShowParameter.setCustomParam("importTaskId", this.getView().getFormShowParameter().getCustomParam("importTaskId"));
+            formShowParameter.setCustomParam("periodId", this.getView().getFormShowParameter().getCustomParam("periodId"));
+            formShowParameter.setCustomParam("orgId", this.getView().getFormShowParameter().getCustomParam("orgId"));
+            formShowParameter.setCustomParam("periodNumber", this.getView().getFormShowParameter().getCustomParam("periodNumber"));
+            formShowParameter.setCloseCallBack(new CloseCallBack(this, "importData"));
+            this.getView().showForm(formShowParameter);
+        }
+    }
+
+    private boolean checkTaskStatus(boolean checkIsRunning, boolean checkIsClosed) {
+        Long importTaskId = (Long)this.getView().getFormShowParameter().getCustomParam("importTaskId");
+        HRBaseServiceHelper helper = new HRBaseServiceHelper("nckd_outimptask");
+        DynamicObject importTask = helper.queryOriginalOne("id,nckd_taskstatus", new QFilter[]{new QFilter("id", "=", importTaskId)});
+        String taskStatus = importTask.getString("nckd_taskstatus");
+        String msg = null;
+        if (checkIsRunning) {
+            if (StringUtils.equals(taskStatus, "4")) {
+                msg = ResManager.loadKDString("当前任务后台执行校验中，请稍后再试。", "ImportTaskGuideOpereateBillList_13", "swc-hsas-formplugin", new Object[0]);
+            } else if (StringUtils.equals(taskStatus, "3")) {
+                msg = ResManager.loadKDString("当前任务后台执行预处理中，请稍后再试。", "ImportTaskGuideOpereateBillList_14", "swc-hsas-formplugin", new Object[0]);
+            } else if (StringUtils.equals(taskStatus, "6")) {
+                msg = ResManager.loadKDString("当前任务后台执行反写中，请稍后再试。", "ImportTaskGuideOpereateBillList_15", "swc-hsas-formplugin", new Object[0]);
+            } else if (StringUtils.equals(taskStatus, "5")) {
+                msg = ResManager.loadKDString("当前任务后台执行写入中，请稍后再试。", "ImportTaskGuideOpereateBillList_16", "swc-hsas-formplugin", new Object[0]);
+            } else if (StringUtils.equals(taskStatus, "9")) {
+                msg = ResManager.loadKDString("当前任务后台执行清除中间表数据中，请稍后再试。", "ImportTaskGuideOpereateBillList_36", "swc-hsas-formplugin", new Object[0]);
+            }
+
+            if (msg != null) {
+                this.getView().showTipNotification(msg);
+                return true;
+            }
+        }
+
+        if (!checkIsClosed || !StringUtils.equals(taskStatus, "7") && !StringUtils.equals(taskStatus, "8")) {
+            return false;
+        } else {
+            msg = ResManager.loadKDString("任务已关闭，无法操作。", "ImportTaskGuideOpereateBillList_35", "swc-hsas-formplugin", new Object[0]);
+            this.getView().showErrorNotification(msg);
+            return true;
+        }
+    }
+
+    @Override
+    public void closedCallBack(ClosedCallBackEvent closedCallBackEvent) {
+        super.closedCallBack(closedCallBackEvent);
+        String actionId = closedCallBackEvent.getActionId();
+        if ("importData".equals(actionId)) {
+            Map<String, Object> returnData = (Map)closedCallBackEvent.getReturnData();
+            if (returnData == null) {
+                return;
+            }
+            if ((Boolean)returnData.get("isOk")) {
+                int totalCount = Integer.parseInt(returnData.get("totalCount").toString());
+                Long importTaskId = (Long)returnData.get("importTaskId");
+                String cacheKey = (String)returnData.get("cacheKey");
+                String caption = ResManager.loadKDString("导入看板", "ImportTaskGuideOpereateBillList_33", "swc-hsas-formplugin", new Object[0]);
+                this.openProgressPage(totalCount, importTaskId, "22", "importingData", caption, cacheKey);
+            }
+        }
+        else {
+            this.getView().invokeOperation("refresh");
+        }
+    }
+
+    private void openProgressPage(int totalCount, Long importTaskId, String progressType, String closeCalBackId, String caption, String verifyId) {
+        FormShowParameter formShowParameter = new FormShowParameter();
+        formShowParameter.setFormId("hsas_datacheckprogress");
+        formShowParameter.getOpenStyle().setShowType(ShowType.Modal);
+        formShowParameter.setCaption(caption);
+        formShowParameter.setCustomParam("importTaskId", importTaskId);
+        formShowParameter.setCustomParam("totalCount", totalCount);
+        formShowParameter.setCustomParam("verifyId", verifyId);
+        formShowParameter.setCustomParam("startTime", DateTimeUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss"));
+        formShowParameter.setCustomParam("progressType", progressType);
+        formShowParameter.setCloseCallBack(new CloseCallBack(this, closeCalBackId));
+        this.getView().showForm(formShowParameter);
+    }
+
+}

code/swc/nckd-jxccl-swc/src/main/java/nckd/jxccl/swc/hsas/formplugin/web/outdata/bill/OutTempDataViewBillListPlugin.java

@@ -0,0 +1,398 @@
+package nckd.jxccl.swc.hsas.formplugin.web.outdata.bill;
+
+import com.kingdee.util.DateTimeUtils;
+import kd.bos.dataentity.entity.DynamicObject;
+import kd.bos.dataentity.entity.DynamicObjectCollection;
+import kd.bos.dataentity.entity.LocaleString;
+import kd.bos.dataentity.metadata.dynamicobject.DynamicObjectType;
+import kd.bos.entity.EntityMetadataCache;
+import kd.bos.entity.MainEntityType;
+import kd.bos.entity.datamodel.events.GetEntityTypeEventArgs;
+import kd.bos.entity.property.DateProp;
+import kd.bos.entity.property.TextProp;
+import kd.bos.exception.KDBizException;
+import kd.bos.form.FormShowParameter;
+import kd.bos.form.container.Container;
+import kd.bos.form.control.Control;
+import kd.bos.form.events.BeforeCreateListColumnsArgs;
+import kd.bos.form.events.BeforeCreateListDataProviderArgs;
+import kd.bos.form.events.OnGetControlArgs;
+import kd.bos.list.BillList;
+import kd.bos.list.DateListColumn;
+import kd.bos.list.IListColumn;
+import kd.bos.list.ListColumn;
+import kd.bos.list.plugin.AbstractListPlugin;
+import kd.bos.logging.Log;
+import kd.bos.logging.LogFactory;
+import kd.bos.mvc.list.ListDataProvider;
+import kd.bos.mvc.list.ListView;
+import kd.bos.orm.query.QFilter;
+import kd.hr.hbp.business.servicehelper.HRBaseServiceHelper;
+import kd.sdk.plugin.Plugin;
+import nckd.jxccl.base.swc.helper.SWCHelper;
+import nckd.jxccl.sit.hcsi.formplugin.web.tp.SisurTempDataEntityTypeBillList;
+import nckd.jxccl.swc.hsas.business.utils.OutImportTaskUtils;
+import org.apache.commons.lang.exception.ExceptionUtils;
+
+import java.math.BigDecimal;
+import java.text.ParseException;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * Tyx 2025-12-10
+ * 外单位导入数据列表插件
+ * 根据模板配置的项目动态配置列
+ * 包含构建列及provider
+ */
+public class OutTempDataViewBillListPlugin extends AbstractListPlugin implements Plugin {
+    private static final Log logger = LogFactory.getLog(OutTempDataViewBillListPlugin.class);
+    private SisurTempDataEntityTypeBillList billList;
+    // 定义一个静态集合，存储常用列的key
+    private static final Set<String> COMMONCOLUMNSET = new HashSet(8);
+
+    // 静态代码块，初始化常用列集合
+    static {
+        COMMONCOLUMNSET.add("fseq");
+        COMMONCOLUMNSET.add("nckd_importtask.name");
+        COMMONCOLUMNSET.add("billstatus");
+        COMMONCOLUMNSET.add("nckd_importtask.nckd_outimptpl.name");
+        COMMONCOLUMNSET.add("nckd_importtask.nckd_period.number");
+        COMMONCOLUMNSET.add("nckd_datastatus");
+    }
+
+    /**
+     * 获取实体类型
+     * @param args 获取实体类型的事件参数
+     */
+    public void getEntityType(GetEntityTypeEventArgs args) {
+        super.getEntityType(args);
+        args.setNewEntityType(this.getEntityType());
+    }
+
+    /**
+     * 获取新的实体类型
+     * @return 返回处理后的实体类型
+     */
+    private MainEntityType getEntityType() {
+        MainEntityType mainType = EntityMetadataCache.getDataEntityType("nckd_outtempdata");
+        MainEntityType mainEntityType = null;
+
+        try {
+            mainEntityType = (MainEntityType)mainType.clone();
+        } catch (CloneNotSupportedException var4) {
+            logger.error("getNewEntityType: ", var4);
+            throw new KDBizException(ExceptionUtils.getFullStackTrace(var4));
+        }
+
+        if (mainEntityType == null) {
+            return mainType;
+        } else {
+            List<Map<String, String>> columnHeadList = this.getColumnHeadList();
+            this.addItemProp(mainEntityType, columnHeadList);
+            return mainEntityType;
+        }
+    }
+
+    /**
+     * 获取控件
+     * @param args 获取控件的事件参数
+     */
+    public void onGetControl(OnGetControlArgs args) {
+        super.onGetControl(args);
+        String key = args.getKey();
+        Control customControl = null;
+        if ("billlistap".equals(key)) {
+            customControl = this.createBillList(key);
+        }
+        if (customControl != null) {
+            args.setControl(customControl);
+        }
+    }
+
+
+    /**
+     * 构建列表
+     * @param key 列表的key值
+     * @return 返回构建好的BillList对象
+     */
+    protected BillList createBillList(String key) {
+        if (this.billList != null) {
+            return this.billList;
+        } else {
+            this.billList = new SisurTempDataEntityTypeBillList(this.getEntityType());
+            this.billList.setKey(key);
+            this.billList.setEntityId("nckd_outtempdata");
+            ListView listView = (ListView)this.getView();
+            this.billList.setBillFormId(listView.getBillFormId());
+            this.billList.setView(listView);
+            Container rootControl = (Container)this.getView().getRootControl();
+            this.replaceBillList(rootControl.getItems(), this.billList);
+            return this.billList;
+        }
+    }
+
+    /**
+     * 替换列表控件
+     * @param items 控件列表
+     * @param billList 要替换的列表控件
+     */
+    private void replaceBillList(List<Control> items, Control billList) {
+        for(int i = 0; i < items.size(); ++i) {
+            Control control = (Control)items.get(i);
+            if (control.getKey().equals(billList.getKey())) {
+                items.set(i, billList);
+                return;
+            }
+            if (control instanceof Container) {
+                this.replaceBillList(((Container)control).getItems(), billList);
+            }
+        }
+    }
+
+    /**
+     * 构建列表列之前方法
+     * @param args
+     */
+    @Override
+    public void beforeCreateListColumns(BeforeCreateListColumnsArgs args) {
+        List<IListColumn> columnList = args.getListColumns();
+        List<IListColumn> commonColumnList = new ArrayList(10);
+        Map<String, IListColumn> otherFixColumnMap = new HashMap(16);
+        Iterator it = columnList.iterator();
+
+        while(it.hasNext()) {
+            IListColumn obj = (IListColumn)it.next();
+            if (COMMONCOLUMNSET.contains(obj.getListFieldKey())) {
+                commonColumnList.add(obj);
+            } else {
+                otherFixColumnMap.put(obj.getListFieldKey(), obj);
+            }
+        }
+
+        columnList.clear();
+        columnList.addAll(commonColumnList);
+        List<Map<String, String>> columnHeadList = this.getColumnHeadList();
+        if (!SWCHelper.isEmpty(columnList)) {
+            int seq = columnList.size() + 1;
+            String key = null;
+            String itemType = null;
+            it = columnHeadList.iterator();
+
+            while(it.hasNext()) {
+                Map<String, String> tempMap = (Map)it.next();
+                Long dataTypeId = Long.valueOf((String)tempMap.get("datatypeid"));
+                String name = (String)tempMap.get("name");
+                key = (String)tempMap.get("key");
+                itemType = (String)tempMap.get("itemType");
+                if ("0".equals(itemType)) {
+                    if (!COMMONCOLUMNSET.contains(key)) {
+                        IListColumn tempColumn = (IListColumn)otherFixColumnMap.get(key);
+                        if (tempColumn != null) {
+                            columnList.add(tempColumn);
+                            ++seq;
+                        }
+                    }
+                } else {
+                    if (1050L == dataTypeId) {
+                        DateListColumn dateListColumn = new DateListColumn();
+                        dateListColumn.setDisplayFormatString("yyyy-MM-dd");
+                        dateListColumn.setCaption(new LocaleString(name));
+                        dateListColumn.setKey(key);
+                        dateListColumn.setListFieldKey(key);
+                        dateListColumn.setSeq(seq);
+                        columnList.add(dateListColumn);
+                    } else {
+                        ListColumn column = new ListColumn();
+                        column.setCaption(new LocaleString(name));
+                        column.setKey(key);
+                        column.setListFieldKey(key);
+                        column.setSeq(seq);
+                        columnList.add(column);
+                    }
+                    ++seq;
+                }
+            }
+
+        }
+    }
+
+    /**
+     * 获取导入任务模板上的字段
+     * @return
+     */
+    private List<Map<String, String>> getColumnHeadList() {
+        List<Map<String, String>> columnHeadList = new ArrayList(10);
+        Long tplId = (Long)this.getView().getFormShowParameter().getCustomParam("outimpTplId");
+        FormShowParameter parameter = this.getView().getFormShowParameter();
+        return (List)(tplId != null && tplId != 0L ? OutImportTaskUtils.getColumnHeadList(tplId, (Long)parameter.getCustomParam("importTaskId")) : columnHeadList);
+    }
+
+    /**
+     * 添加ListDataProvider
+     * @param args
+     */
+    @Override
+    public void beforeCreateListDataProvider(BeforeCreateListDataProviderArgs args) {
+        args.setListDataProvider(new OutTempDataViewBillListPlugin.ImportItemDataResultImpl());
+    }
+
+    private void addItemProp(DynamicObjectType mainEntityType, List<Map<String, String>> columnHeadList) {
+        String key = null;
+        Long dataTypeId = null;
+        String name = null;
+        String itemType = null;
+        Iterator it = columnHeadList.iterator();
+
+        while(true) {
+            while(true) {
+                Map temMap;
+                do {
+                    if (!it.hasNext()) {
+                        return;
+                    }
+                    temMap = (Map)it.next();
+                    key = (String)temMap.get("key");
+                    itemType = (String)temMap.get("itemType");
+                } while("0".equals(itemType));
+
+                dataTypeId = Long.valueOf((String)temMap.get("datatypeid"));
+                name = (String)temMap.get("name");
+                if (1030L != dataTypeId && 1010L != dataTypeId && 1020L != dataTypeId) {
+                    if (1050L == dataTypeId) {
+                        DateProp property = new DateProp();
+                        property.setName(key);
+                        property.setDisplayName(new LocaleString(name));
+                        mainEntityType.addProperty(property);
+                    }
+                } else {
+                    TextProp property = new TextProp();
+                    property.setName(key);
+                    property.setDisplayName(new LocaleString(name));
+                    property.setMaxLenth(200);
+                    mainEntityType.addProperty(property);
+                }
+            }
+        }
+    }
+
+
+    public class ImportItemDataResultImpl extends ListDataProvider {
+        public ImportItemDataResultImpl() {
+        }
+        @Override
+        public DynamicObjectCollection getData(int start, int limit) {
+            DynamicObjectCollection list = super.getData(start, limit);
+            if (this.getQueryBuilder().isSelectedAllRows()) {
+                return list;
+            } else {
+                List<Map<String, String>> columnHeadList = OutTempDataViewBillListPlugin.this.getColumnHeadList();
+                if (SWCHelper.isEmpty(columnHeadList)) {
+                    return list;
+                } else {
+                    OutTempDataViewBillListPlugin.this.addItemProp(list.getDynamicObjectType(), columnHeadList);
+                    List<Long> idList = (List)list.stream().map((objx) -> {
+                        return objx.getLong("id");
+                    }).collect(Collectors.toList());
+                    Map<Long, Map<String, Object>> itemDataMap = this.getItemDataMap(idList);
+                    if (itemDataMap.size() == 0) {
+                        return list;
+                    } else {
+                        Map<String, Object> tempMap = null;
+                        Iterator it = list.iterator();
+                        while(true) {
+                            DynamicObject obj;
+                            do {
+                                do {
+                                    if (!it.hasNext()) {
+                                        return list;
+                                    }
+                                    obj = (DynamicObject)it.next();
+                                    tempMap = (Map)itemDataMap.get(obj.getLong("id"));
+                                } while(tempMap == null);
+                            } while(tempMap.size() == 0);
+
+                            Iterator it1 = tempMap.entrySet().iterator();
+
+                            while(it1.hasNext()) {
+                                Map.Entry<String, Object> entry = (Map.Entry)it1.next();
+                                obj.set((String)entry.getKey(), entry.getValue());
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        private Map<Long, Map<String, Object>> getItemDataMap(List<Long> idList) {
+            Map<Long, Map<String, Object>> itemDataMap = new HashMap(16);
+            HRBaseServiceHelper helper = new HRBaseServiceHelper("nckd_outtempdata");
+            String fields = "id,entryentity.nckd_itemtype,entryentity.nckd_itemid,entryentity.nckd_datatype,entryentity.nckd_itemvalue";
+            QFilter qFilter = new QFilter("id", "in", idList);
+            DynamicObjectCollection itemData = helper.queryOriginalCollection(fields, new QFilter[]{qFilter});
+            if (itemData.size() == 0) {
+                return itemDataMap;
+            } else {
+                Map<String, Object> tempMap = null;
+                long dataTypeId = 0L;
+                String itemValue = null;
+                String columnKey = null;
+                Iterator var12 = itemData.iterator();
+
+                while(true) {
+                    while(true) {
+                        DynamicObject obj;
+                        do {
+                            if (!var12.hasNext()) {
+                                return itemDataMap;
+                            }
+
+                            obj = (DynamicObject)var12.next();
+                            tempMap = (Map)itemDataMap.get(obj.getLong("id"));
+                            if (tempMap == null) {
+                                tempMap = new HashMap(16);
+                                itemDataMap.put(obj.getLong("id"), tempMap);
+                            }
+
+                            dataTypeId = obj.getLong("entryentity.nckd_itemtype");
+                            itemValue = obj.getString("entryentity.nckd_itemvalue");
+                        } while(itemValue == null);
+
+                        columnKey = this.getColumnKey(obj.getString("entryentity.nckd_itemtype"), obj.getLong("entryentity.nckd_itemid"));
+                        if (1020L != dataTypeId && 1010L != dataTypeId) {
+                            if (1050L == dataTypeId) {
+                                try {
+                                    ((Map)tempMap).put(columnKey, DateTimeUtils.parseDate(itemValue, "yyyy-MM-dd"));
+                                } catch (ParseException var15) {
+                                    OutTempDataViewBillListPlugin.logger.error("parse itemValue error", var15);
+                                    throw new KDBizException(ExceptionUtils.getFullStackTrace(var15));
+                                }
+                            } else {
+                                ((Map)tempMap).put(columnKey, itemValue);
+                            }
+                        } else {
+                            ((Map)tempMap).put(columnKey, new BigDecimal(itemValue));
+                        }
+                    }
+                }
+            }
+        }
+
+        private String getColumnKey(String itemType, long itemId) {
+            String columnKey = "";
+            if ("4".equals(itemType)) {
+                columnKey = "ft" + itemId;
+            } else if ("1".equals(itemType)) {
+                columnKey = "ii" + itemId;
+            } else if ("3".equals(itemType)) {
+                columnKey = "bs" + itemId;
+            } else if ("2".equals(itemType)) {
+                columnKey = "sp" + itemId;
+            }
+
+            return columnKey;
+        }
+
+
+    }
+}

code/swc/nckd-jxccl-swc/src/main/java/nckd/jxccl/swc/hsas/formplugin/web/outdata/helper/OutImpTemplateHelper.java

@@ -0,0 +1,260 @@
+package nckd.jxccl.swc.hsas.formplugin.web.outdata.helper;
+
+import kd.bos.dataentity.entity.DynamicObject;
+import kd.bos.dataentity.entity.DynamicObjectCollection;
+import kd.bos.dataentity.utils.StringUtils;
+import kd.bos.orm.query.QFilter;
+import kd.bos.orm.util.CollectionUtils;
+import kd.bos.servicehelper.basedata.BaseDataServiceHelper;
+import kd.hr.hbp.business.servicehelper.HRBaseServiceHelper;
+import nckd.jxccl.swc.constants.SwcConstant;
+import nckd.jxccl.swc.hsas.common.OutImpPresetItem;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class OutImpTemplateHelper {
+
+    //private static List<OutImpPresetItem> outImpPresetItemEnumList = new ArrayList(12);
+    private static Map<Long, OutImpPresetItem> commonAndAddPresetItemEnumMap = new HashMap(4);
+
+
+    public void OutImpTemplateHelper(){
+        getPresetItemEnumList();
+    }
+
+
+    public static Map<String, Map<String, Object>> analyzeItemDatas(DynamicObjectCollection itemDatas, Map<Long, Map<String, Object>> existItemDataMap) {
+        List<String> SIUnicodeList = new ArrayList();
+        List<String> BIUnicodeList = new ArrayList();
+        for (DynamicObject itemData : itemDatas) {
+            String itemCategory = itemData.getString("nckd_itemcategory");
+            String uniCode = itemData.getString("nckd_itemnumber");
+            if (StringUtils.equals("SI", itemCategory)) {
+                SIUnicodeList.add(uniCode);
+            }
+            else if (StringUtils.equals("BI", itemCategory)) {
+                BIUnicodeList.add(uniCode);
+            }
+        }
+        Map<String, Map<String, Object>> itemParamMap = new HashMap(itemDatas.size());
+        // 添加薪酬项目
+        itemParamMap.putAll(getItemParamMap("number", SIUnicodeList, "1", "hsbs_salaryitem", existItemDataMap, (Long) null));
+        // 添加基本项目
+        itemParamMap.putAll(getBaseItemParamMap("number", BIUnicodeList, "2", "nckd_outimportitem", existItemDataMap, (Long) null));
+        return itemParamMap;
+    }
+
+    /**
+     * 获取基本项目
+     * @return
+     */
+    public static Map<String, Map<String, Object>> getBaseItemParamMap(String key, List<String> keyList, String itemType, String entityName, Map<Long, Map<String, Object>> existItemDataMap, Long orgId) {
+        if (CollectionUtils.isEmpty(keyList)) {
+            return new HashMap(0);
+        } else {
+            if (existItemDataMap == null) {
+                existItemDataMap = new HashMap(0);
+            }
+            Map<String, Map<String, Object>> itemParamMap = new HashMap(keyList.size());
+            HRBaseServiceHelper helper = new HRBaseServiceHelper(entityName);
+            String fields = "id,number,name,nckd_datatype.id";
+
+            QFilter filter = new QFilter(key, "in", keyList);
+            filter.and(new QFilter("enable", "=", "1"));
+            filter.and(new QFilter("nckd_ispreset", "=", "0"));
+            if (orgId != null) {
+                QFilter useOrgFilter = BaseDataServiceHelper.getBaseDataFilter(entityName, orgId);
+                filter.and(useOrgFilter);
+            }
+            DynamicObjectCollection items = helper.queryOriginalCollection(fields, new QFilter[]{filter});
+
+            for(DynamicObject item : items) {
+                Long itemId = item.getLong("id");
+                Long dataTypeId = item.getLong("nckd_datatype.id");
+                Map<String, Object> itemParam = new HashMap(6);
+                Map<String, Object> existItemData = (Map)((Map)existItemDataMap).get(itemId);
+                itemParam.put("id", itemId);
+                itemParam.put("dataTypeId", dataTypeId);
+                itemParam.put("itemType", itemType);
+                itemParam.put("itemname", item.getString("name"));
+                itemParam.put("entityName", entityName);
+
+                fillExistComment(entityName, item, existItemData, itemParam);
+                itemParamMap.put(item.getString(key), itemParam);
+            }
+
+            return itemParamMap;
+        }
+    }
+
+
+    /**
+     * 获取薪酬项目
+     * @param key
+     * @param keyList
+     * @param itemType
+     * @param entityName
+     * @param existItemDataMap
+     * @param orgId
+     * @return
+     */
+    public static Map<String, Map<String, Object>> getItemParamMap(String key, List<String> keyList, String itemType, String entityName, Map<Long, Map<String, Object>> existItemDataMap, Long orgId) {
+        if (CollectionUtils.isEmpty(keyList)) {
+            return new HashMap(0);
+        } else {
+            if (existItemDataMap == null) {
+                existItemDataMap = new HashMap(0);
+            }
+            Map<String, Map<String, Object>> itemParamMap = new HashMap(keyList.size());
+            HRBaseServiceHelper helper = new HRBaseServiceHelper(entityName);
+            String fields = "id,number,name,datatype.id";
+
+            QFilter filter = new QFilter(key, "in", keyList);
+            filter.and(new QFilter("enable", "=", "1"));
+            if (orgId != null) {
+                QFilter useOrgFilter = BaseDataServiceHelper.getBaseDataFilter(entityName, orgId);
+                filter.and(useOrgFilter);
+            }
+            DynamicObjectCollection items = helper.queryOriginalCollection(fields, new QFilter[]{filter});
+
+            for(DynamicObject item : items) {
+                Long itemId = item.getLong("id");
+                Long dataTypeId = item.getLong("datatype.id");
+                Map<String, Object> itemParam = new HashMap(6);
+                Map<String, Object> existItemData = (Map)((Map)existItemDataMap).get(itemId);
+                itemParam.put("id", itemId);
+                itemParam.put("dataTypeId", dataTypeId);
+                itemParam.put("itemType", itemType);
+                itemParam.put("itemname", item.getString("name"));
+                itemParam.put("entityName", entityName);
+
+                fillExistComment(entityName, item, existItemData, itemParam);
+                itemParamMap.put(item.getString(key), itemParam);
+            }
+
+            return itemParamMap;
+        }
+    }
+
+    private static void fillExistComment(String entityName, DynamicObject item, Map<String, Object> existItemData, Map<String, Object> itemParam) {
+        String itemCurrency;
+        String existComment;
+        if (existItemData != null && existItemData.size() > 0) {
+            itemCurrency = (String)existItemData.get("comment");
+            itemParam.put("matchcolumn", existItemData.get("matchcolumn"));
+            if (StringUtils.isNotEmpty(itemCurrency)) {
+                itemParam.put("comment", itemCurrency);
+            }
+        } else if (StringUtils.equals("hsbs_salaryitem", entityName)) {
+//            itemCurrency = item.getString("outputcurrency.name");
+//            if (StringUtils.isNotEmpty(itemCurrency)) {
+//                existComment = ResManager.loadKDString("币种：{0}", "MigrationTemplateHelper_0", "swc-hsas-business", new Object[]{itemCurrency});
+//                itemParam.put("comment", existComment);
+//            }
+        }
+    }
+
+    public static Map<String, Map<String, Object>> analyzeMatchItem(DynamicObjectCollection entryDatas) {
+        if (CollectionUtils.isEmpty(entryDatas)) {
+            return new HashMap(0);
+        } else {
+            List<Long> SLItemIdList = new ArrayList(entryDatas.size());
+            List<Long> SPItemIdList = new ArrayList(entryDatas.size());
+            List<Long> BSItemIdList = new ArrayList(entryDatas.size());
+            List<Long> FTItemIdList = new ArrayList(entryDatas.size());
+            Iterator var5 = entryDatas.iterator();
+
+            while(var5.hasNext()) {
+                DynamicObject entry = (DynamicObject)var5.next();
+                String itemType = entry.getString("nckd_itemtype");
+                Long itemId = entry.getLong("nckd_itemid");
+                if (StringUtils.equals("1", itemType)) {
+                    SLItemIdList.add(itemId);
+                } else if (StringUtils.equals("2", itemType)) {
+                    SPItemIdList.add(itemId);
+                } else if (StringUtils.equals("3", itemType)) {
+                    BSItemIdList.add(itemId);
+                } else if (StringUtils.equals("4", itemType)) {
+                    FTItemIdList.add(itemId);
+                }
+            }
+
+            Map<String, Map<String, Object>> itemParamMap = new HashMap(entryDatas.size());
+            //itemParamMap.putAll(getItemParamMap(SLItemIdList, "1", "hsbs_salaryitem", (Long)null, false));
+            //itemParamMap.putAll(getItemParamMap(SPItemIdList, "2", "hsbs_supportitem", (Long)null, false));
+            //itemParamMap.putAll(getItemParamMap(BSItemIdList, "3", "hsbs_bizitem", (Long)null, false));
+            //itemParamMap.putAll(getItemParamMap(FTItemIdList, "4", "hsbs_fetchitem", (Long)null, false));
+            return itemParamMap;
+        }
+    }
+
+    /**
+     * 获取预设项目 转成对象
+     * @param itemId
+     * @return
+     */
+    public static OutImpPresetItem getPresetItemEnum(Long itemId) {
+        OutImpPresetItem presetItemEnum = (OutImpPresetItem)commonAndAddPresetItemEnumMap.get(itemId);
+        return presetItemEnum;
+    }
+
+    /**
+     * 获取外单位导入项目中 是否预置项目 = 是 的数据，并转成OutImpPresetItem
+     * @return
+     */
+    public static List<OutImpPresetItem> getPresetItemEnumList() {
+        String fields = "id,number,name,nckd_datatype.id,nckd_ispreset,nckd_presetcomment";
+        QFilter filter = new QFilter("enable", "=", "1");
+        filter.and(new QFilter("nckd_ispreset", "=", true));
+
+        DynamicObjectCollection dyns = SwcConstant.OUTIMPORTITEM_ENTITY.queryOriginalCollection(fields, new QFilter[]{filter});
+        List<OutImpPresetItem> outImpPresetItemEnumList = new ArrayList(12);
+        dynToOutImpPresetItem(dyns, outImpPresetItemEnumList);
+        return outImpPresetItemEnumList;
+    }
+
+    /**
+     * 数据包转成OutImpPresetItem
+     * @param dyns
+     */
+    public static void dynToOutImpPresetItem (DynamicObjectCollection dyns, List<OutImpPresetItem> outImpPresetItemEnumList) {
+        for (DynamicObject dyn : dyns) {
+            OutImpPresetItem item = new OutImpPresetItem();
+            item.setItemId(dyn.getLong("id"));
+            item.setItemName(dyn.getString("name"));
+            item.setComment(dyn.getString("nckd_presetcomment"));
+            item.setDataTypeId(dyn.getLong("nckd_datatype.id"));
+            //item.setMatchColumn(dyn.);
+            outImpPresetItemEnumList.add(item);
+        }
+    }
+
+    public static Map<Long, OutImpPresetItem> getPresetItemEnumMap() {
+        List<OutImpPresetItem> itemEnumList = OutImpTemplateHelper.getPresetItemEnumList();
+        return itemEnumList.stream()
+                .collect(Collectors.toMap(
+                        item -> item.getItemId(),
+                        item -> item,
+                        (existing, replacement) -> existing  // 如果键重复，保留原有的值
+                ));
+    }
+
+
+    static {
+//        String fields = "id,number,name,nckd_datatype.id";
+//        QFilter filter = new QFilter("enable", "=", "1");
+//        filter.and(new QFilter("nckd_ispreset", "=", "0"));
+//        DynamicObjectCollection dyns = SwcConstant.OUTIMPORTITEM_ENTITY.queryOriginalCollection(fields, new QFilter[]{filter});
+//        for (DynamicObject dyn : dyns) {
+//            OutImpPresetItem item = new OutImpPresetItem();
+//            item.setItemId(dyn.getLong("id"));
+//            item.setItemName(dyn.getString("name"));
+//            item.setComment(dyn.getString("nckd_presetcomment"));
+//            item.setDataTypeId(dyn.getLong("nckd_datatype.id"));
+//            //item.setMatchColumn(dyn.);
+//            outImpPresetItemEnumList.add(item);
+//        }
+    }
+
+}

code/swc/nckd-jxccl-swc/src/main/java/nckd/jxccl/swc/hsas/formplugin/web/outdata/helper/OutItemSelectAddItemServiceHelper.java

@@ -0,0 +1,281 @@
+package nckd.jxccl.swc.hsas.formplugin.web.outdata.helper;
+
+import kd.bos.dataentity.entity.DynamicObject;
+import kd.bos.dataentity.entity.DynamicObjectCollection;
+import kd.bos.dataentity.resource.ResManager;
+import kd.bos.dataentity.utils.StringUtils;
+import kd.bos.entity.tree.TreeNode;
+import kd.bos.orm.query.QCP;
+import kd.bos.orm.query.QFilter;
+import kd.bos.servicehelper.basedata.BaseDataServiceHelper;
+import kd.bos.util.CollectionUtils;
+import kd.hr.hbp.business.servicehelper.HRBaseServiceHelper;
+import nckd.jxccl.sit.hcsi.formplugin.web.tp.helper.SitItemSelectAddItemServiceHelper;
+import nckd.jxccl.swc.constants.SwcConstant;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class OutItemSelectAddItemServiceHelper {
+
+    private static final String SALARYITEM_ENTITY = "hsbs_salaryitem";
+    private static final String QUERY_FIELDS = "id,number,name,statisticstag.name,statisticstag.number,statisticstag.id";
+    private static final String DEFAULT_ORDER = "number asc";
+
+    private static final String SALARYITEM_KEY = "salaryitemkey";
+    private static final String BASEITEM_KEY = "baseitemkey";
+    private static final String ITEM_TYPE_SI = "SI";
+    private static final String BASE_TYPE_BI = "BI";
+    private static final String PREFIX_SEPARATOR = "_@_";
+
+    /**
+     * 获取所有需要展示的项目，目前就险种
+     * @param orgId
+     * @return
+     */
+    public Map<String, Map<String, Map<String, Object>>> getAllItemData(long orgId) {
+        Map<String, Map<String, Map<String, Object>>> dataMap = new HashMap(4);
+        Map<String, Map<String, Object>> salaryItemMap = this.getSalaryItemList(false, (QFilter)null, (QFilter)null, orgId);
+        Map<String, Map<String, Object>> baseItemMap = this.getBaseItemList();
+        dataMap.put("salaryitemkey", salaryItemMap);
+        dataMap.put("baseitemkey", baseItemMap);
+        return dataMap;
+    }
+
+    private Map<String, Map<String, Object>> getBaseItemList() {
+        QFilter filter = new QFilter ("enable", QCP.equals, "1");
+        filter.and("nckd_ispreset", QCP.equals, false);
+        String queryFields = "id,number,name,group.name,group.number,group.id";
+        DynamicObjectCollection dyns = SwcConstant.OUTIMPORTITEM_ENTITY.queryOriginalCollection(queryFields, new QFilter[]{filter});
+        return dyns.stream()
+                .collect(Collectors.toMap(
+                        item -> item.getString("name"),
+                        item -> this.convertToItemMap(item, BASE_TYPE_BI),
+                        (existing, replacement) -> existing,
+                        LinkedHashMap::new
+                ));
+    }
+
+    public Map<String, Map<String, Object>> getBaseItemMap() {
+        return null;
+    }
+
+    private Map<String, Map<String, Object>> getSalaryItemList(boolean isProrationFormula, QFilter countryQFilter, QFilter calBlockQFilter, long orgId) {
+        if (isProrationFormula) {
+            return Collections.emptyMap();
+        }
+        List<QFilter> qFilters = buildFilters(countryQFilter, calBlockQFilter, orgId);
+        DynamicObjectCollection result = querySalaryItems(qFilters);
+        return result.stream()
+                .collect(Collectors.toMap(
+                        item -> item.getString("name"),
+                        item -> this.convertToItemMap(item, ITEM_TYPE_SI),
+                        (existing, replacement) -> existing,
+                        LinkedHashMap::new
+                ));
+    }
+
+    private static List<Map<String, Object>> getSalaryItemList(String name, String key,
+                                                                  Map<String, Map<String, Map<String, Object>>> dataMap) {
+        return StringUtils.isEmpty(name)
+                ? SitItemSelectAddItemServiceHelper.mapToList(dataMap.get(key))
+                : SitItemSelectAddItemServiceHelper.findItemByName(name, key, dataMap);
+    }
+
+    private List<QFilter> buildFilters(QFilter countryQFilter, QFilter calBlockQFilter, long orgId) {
+        List<QFilter> filters = new ArrayList<>();
+        Optional.ofNullable(countryQFilter).ifPresent(filters::add);
+        Optional.ofNullable(calBlockQFilter).ifPresent(filters::add);
+        QFilter baseFilter = new QFilter("enable", "=", "1")
+                .and(new QFilter("status", "=", "C"));
+                //.and(new QFilter("insurancetypeattr.number", QCP.not_in, new String[]{"1007_S","1008_S","1013_S","1014_S"}));
+        filters.add(baseFilter);
+        filters.add(BaseDataServiceHelper.getBaseDataFilter(SALARYITEM_ENTITY, orgId));
+        return filters;
+    }
+
+    private DynamicObjectCollection querySalaryItems(List<QFilter> filters) {
+        HRBaseServiceHelper helper = new HRBaseServiceHelper(SALARYITEM_ENTITY);
+        return helper.queryOriginalCollection(
+                QUERY_FIELDS,
+                filters.toArray(new QFilter[0]),
+                DEFAULT_ORDER
+        );
+    }
+
+    private Map<String, Object> convertToItemMap(DynamicObject item, String key) {
+        Map<String, Object> itemMap = new HashMap<>(3);
+        itemMap.put("id", item.getLong("id"));
+        itemMap.put("number", item.getString("number"));
+        itemMap.put("name", item.getString("name"));
+
+        if(key.equals(ITEM_TYPE_SI)) {
+            itemMap.put("group_name", item.getString("statisticstag.name"));
+            itemMap.put("group_number", item.getString("statisticstag.number"));
+            itemMap.put("group_id", item.getString("statisticstag.id"));
+        }
+        else {
+            itemMap.put("group_name", item.getString("group.name"));
+            itemMap.put("group_number", item.getString("group.number"));
+            itemMap.put("group_id", item.getString("group.id"));
+        }
+        return itemMap;
+    }
+
+    /**
+     * 构建薪酬项目树结构
+     * 顶层ID ： SI
+     * 分类节点ID：薪酬分类编码 + _@_
+     * 薪酬项目子节点ID：薪酬项目ID
+     * @param name
+     * @param isExpend
+     * @param dataMap
+     * @return
+     */
+    public static List<TreeNode> loadSalaryItemChildNode(String name, boolean isExpend,
+                                                            Map<String, Map<String, Map<String, Object>>> dataMap) {
+        // 所有险种项目
+        List<Map<String, Object>> salaryItemList = getSalaryItemList(name, SALARYITEM_KEY, dataMap);
+        List<TreeNode> tree = createRootNode(isExpend, SALARYITEM_KEY);
+        if (CollectionUtils.isEmpty(salaryItemList)) {
+            return tree;
+        }
+
+        // 最后返回树：
+        List<TreeNode> totalNodeList = new ArrayList<>(salaryItemList.size() + 1);
+
+        // 构建根节点：
+        TreeNode itemRoot = new TreeNode("", ITEM_TYPE_SI,
+                ResManager.loadKDString("薪酬项目-SI", "FormulaItemOrFuncTreeHelper_1",
+                        "swc-hsas-business", new Object[0]));
+        itemRoot.setExpend(isExpend);
+        itemRoot.setIsOpened(isExpend);
+        totalNodeList.add(itemRoot);
+
+        // 构建子节点：
+        if (!CollectionUtils.isEmpty(salaryItemList)) {
+            Map<String, TreeNode> itemTypeNodeMap = new LinkedHashMap(salaryItemList.size());
+            Map<String, List<TreeNode>> insuranceItemNodeMap = new HashMap(16);
+            List<TreeNode> treeNodeList = null;
+            String itemTypeNum = null;
+            for (Map<String, Object> map : salaryItemList) {
+                itemTypeNum = (String)map.get("group_number");
+                String itemTypeName = (String)map.get("group_name");
+                treeNodeList = (List)insuranceItemNodeMap.get(itemTypeNum);
+                if (treeNodeList == null) {
+                    treeNodeList = new ArrayList(10);
+                    insuranceItemNodeMap.put(itemTypeNum, treeNodeList);
+                }
+                ((List)treeNodeList).add(new TreeNode(ITEM_TYPE_SI + itemTypeNum + PREFIX_SEPARATOR, String.valueOf(map.get("id")), (String)map.get("name")));
+                if (!itemTypeNodeMap.containsKey(itemTypeNum)) {
+                    TreeNode itemTreeNode = new TreeNode(ITEM_TYPE_SI, ITEM_TYPE_SI + itemTypeNum + PREFIX_SEPARATOR, itemTypeName);
+                    itemTreeNode.setExpend(isExpend);
+                    itemTreeNode.setIsOpened(isExpend);
+                    itemTypeNodeMap.put(itemTypeNum, itemTreeNode);
+                }
+            }
+            treeNodeList = new ArrayList(itemTypeNodeMap.size());
+            Iterator it = itemTypeNodeMap.entrySet().iterator();
+            while (it.hasNext()) {
+                Map.Entry<String, TreeNode> entry = (Map.Entry)it.next();
+                TreeNode typeNode = (TreeNode)entry.getValue();
+                typeNode.setChildren((List)insuranceItemNodeMap.get(entry.getKey()));
+                treeNodeList.add(typeNode);
+            }
+            itemRoot.setChildren(treeNodeList);
+            return totalNodeList;
+        }
+        else {
+            return totalNodeList;
+        }
+    }
+
+    /**
+     * 构建基本项目树结构
+     * 顶层ID ： BI
+     * 基本项目分类节点ID：项目分类编码 + _@_
+     * 基本项目子节点ID：基本项目ID
+     * @param name
+     * @param isExpend
+     * @param dataMap
+     * @return
+     */
+    public static List<TreeNode> loadBaseItemChildNode(String name, boolean isExpend,
+                                                         Map<String, Map<String, Map<String, Object>>> dataMap) {
+        // 所有基本项目
+        List<Map<String, Object>> baseItemList = getSalaryItemList(name, BASEITEM_KEY, dataMap);
+        List<TreeNode> tree = createRootNode(isExpend, BASEITEM_KEY);
+        if (CollectionUtils.isEmpty(baseItemList)) {
+            return tree;
+        }
+
+        // 最后返回树：
+        List<TreeNode> totalNodeList = new ArrayList<>(baseItemList.size() + 1);
+
+        // 构建根节点：
+        TreeNode itemRoot = new TreeNode("", BASE_TYPE_BI,
+                ResManager.loadKDString("基本项目-BI", "FormulaItemOrFuncTreeHelper_1",
+                        "swc-hsas-business", new Object[0]));
+        itemRoot.setExpend(isExpend);
+        itemRoot.setIsOpened(isExpend);
+        totalNodeList.add(itemRoot);
+
+        // 构建子节点：
+        if (!CollectionUtils.isEmpty(baseItemList)) {
+            Map<String, TreeNode> itemTypeNodeMap = new LinkedHashMap(baseItemList.size());
+            Map<String, List<TreeNode>> baseItemNodeMap = new HashMap(16);
+            List<TreeNode> treeNodeList = null;
+            String itemTypeNum = null;
+            for (Map<String, Object> map : baseItemList) {
+                itemTypeNum = (String)map.get("group_number");
+                String itemTypeName = (String)map.get("group_name");
+                treeNodeList = (List)baseItemNodeMap.get(itemTypeNum);
+                if (treeNodeList == null) {
+                    treeNodeList = new ArrayList(10);
+                    baseItemNodeMap.put(itemTypeNum, treeNodeList);
+                }
+                ((List)treeNodeList).add(new TreeNode(BASE_TYPE_BI + itemTypeNum + PREFIX_SEPARATOR, String.valueOf(map.get("id")), (String)map.get("name")));
+                if (!itemTypeNodeMap.containsKey(itemTypeNum)) {
+                    TreeNode itemTreeNode = new TreeNode(BASE_TYPE_BI, BASE_TYPE_BI + itemTypeNum + PREFIX_SEPARATOR, itemTypeName);
+                    itemTreeNode.setExpend(isExpend);
+                    itemTreeNode.setIsOpened(isExpend);
+                    itemTypeNodeMap.put(itemTypeNum, itemTreeNode);
+                }
+            }
+            treeNodeList = new ArrayList(itemTypeNodeMap.size());
+            Iterator it = itemTypeNodeMap.entrySet().iterator();
+            while (it.hasNext()) {
+                Map.Entry<String, TreeNode> entry = (Map.Entry)it.next();
+                TreeNode typeNode = (TreeNode)entry.getValue();
+                typeNode.setChildren((List)baseItemNodeMap.get(entry.getKey()));
+                treeNodeList.add(typeNode);
+            }
+            itemRoot.setChildren(treeNodeList);
+            return totalNodeList;
+        }
+        else {
+            return totalNodeList;
+        }
+    }
+
+    private static List<TreeNode> createRootNode(boolean isExpend, String key) {
+        return createRootNode(isExpend, Collections.emptyList(), key);
+    }
+
+    private static List<TreeNode> createRootNode(boolean isExpend, List<TreeNode> children, String key) {
+        String str = null;
+        if(key.equals(BASE_TYPE_BI)) {
+            str = ResManager.loadKDString("基本项目-BI", "FormulaItemOrFuncTreeHelper_1",
+                    "swc-hsas-business", new Object[0]);
+        }
+        else if (key.equals(ITEM_TYPE_SI)) {
+            str = ResManager.loadKDString("薪酬项目-SI", "FormulaItemOrFuncTreeHelper_1",
+                    "swc-hsas-business", new Object[0]);
+        }
+        TreeNode itemRoot = new TreeNode("", key, str);
+        itemRoot.setExpend(isExpend);
+        itemRoot.setIsOpened(isExpend);
+        itemRoot.setChildren(children);
+        return Collections.singletonList(itemRoot);
+    }
+}