统一接口添加

 Source/UBCS/ubcs-service-api/ubcs-code-api/src/main/java/com/vci/ubcs/code/vo/pagemodel/CodeImportResultVO.java

@@ -1,6 +1,8 @@
package com.vci.ubcs.code.vo.pagemodel;


import com.vci.ubcs.starter.revision.model.BaseModel;

import java.util.*;

/**
@@ -28,7 +30,10 @@
     * 关键属性校验后，重复的行号
     */
    private Set<String> keyAttrRepeatRowIndexList  = new HashSet<>();

    /***
     * 根据关键熟悉查询的重复的数据对象
     */
    private Map<String,  List<BaseModel>> indexTODataMap=new HashMap<>();
    /***
     * 根据关键熟悉查询的重复的数据对象
     */
@@ -89,6 +94,13 @@
        this.selfRepeatRowIndexList = selfRepeatRowIndexList;
    }

    public Map<String, List<BaseModel>> getIndexTODataMap() {
        return indexTODataMap;
    }

    public void setIndexTODataMap(Map<String, List<BaseModel>> indexTODataMap) {
        this.indexTODataMap = indexTODataMap;
    }
    /*public Map<String,List<ClientBusinessObject>> getIndexTODataMap() {
        return indexTODataMap;
    }

 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/MdmEngineService.java

@@ -14,6 +14,7 @@
import com.vci.ubcs.starter.revision.model.BaseModel;
import com.vci.ubcs.starter.revision.model.TreeQueryObject;
import com.vci.ubcs.starter.web.pagemodel.*;
import com.vci.ubcs.starter.web.util.VciQueryWrapperForDO;
import org.springblade.core.tool.api.R;

import java.beans.IntrospectionException;
@@ -411,4 +412,20 @@
     * @return 树形的数据
     */
    List<Tree> referTree(UIFormReferVO referConfigVO, TreeQueryObject queryObject);

    /**
     * 是否为修改忽略的属性
     * @param attrName 属性的名字
     * @return true 表示应该忽略
     */
    default boolean checkUnAttrUnEdit(String attrName){
        return  (VciQueryWrapperForDO.OID_FIELD.equalsIgnoreCase(attrName)
            ||"ts".equalsIgnoreCase(attrName)
            || "lastmodifier".equalsIgnoreCase(attrName)
            || "lastmodifytime".equalsIgnoreCase(attrName)
            || "createtime".equalsIgnoreCase(attrName)
            || "checkintime".equalsIgnoreCase(attrName)
            ||"checkouttime".equalsIgnoreCase(attrName));
    }

}

 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmIOServiceImpl.java

@@ -35,6 +35,7 @@
import com.vci.ubcs.starter.util.MdmBtmTypeConstant;
import com.vci.ubcs.starter.web.constant.QueryOptionConstant;
import com.vci.ubcs.starter.web.enumpck.BooleanEnum;
import com.vci.ubcs.starter.web.enumpck.UserSecretEnum;
import com.vci.ubcs.starter.web.enumpck.VciFieldTypeEnum;
import com.vci.ubcs.starter.web.pagemodel.DataGrid;
import com.vci.ubcs.starter.web.pagemodel.KeyValue;
@@ -62,6 +63,7 @@
import javax.annotation.Resource;
import java.io.File;
import java.io.IOException;
import java.text.MessageFormat;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
@@ -1621,7 +1623,7 @@
        if(!CollectionUtils.isEmpty(unExistAttrVOs)){
            throw new VciBaseException("【" + unExistAttrVOs.stream().map(CodeClassifyTemplateAttrVO::getName) + "】这些属性在excel中没有找到");
        }

        List<ClientBusinessObject> cboList = new ArrayList<>();
        String fullPath = getFullPath(classifyFullInfo);

        // List<CodeClassifyProcessTempVO> codeClassifyProcessTempVOS=codeClassifyProcessTempService.listProcessTemplate(templateVO.getOid(),"code_cls_flow_use_order");
@@ -1630,19 +1632,765 @@
        /** if(!CollectionUtils.isEmpty(codeClassifyProcessTempVOS)){
         isProcess=true;
         }***/
        //List<ClientBusinessObject> cboList = new ArrayList<>();
        //Map<String,String> codeOidToSystemOidMap=new HashMap<>();//存储编码数据和集成系统数据oid对照映射
        //excelToCbo(classifyFullInfo,titleRowData,fieldIndexMap,rowDataList,templateVO,cboList,fullPath,isProcess,"create",errorMap,codeOidToSystemOidMap);
        Map<String,String> codeOidToSystemOidMap=new HashMap<>();//存储编码数据和集成系统数据oid对照映射
        excelToCbo(classifyFullInfo,titleRowData,fieldIndexMap,rowDataList,templateVO,cboList,fullPath,isProcess,"create",errorMap,codeOidToSystemOidMap);

        //都转换完了。需要批量检查
        //如果出错了，我们依然执行有效的数据，无效的数据写回到excel中
        //2.判断必输项。。需要全部的属性，如果是必输，但是表单里面不显示的，只能是分类注入或者组合规则
        batchCheckRequiredAttrOnOrder(templateVO,cboList,errorMap);


        /**
         * 关键熟悉错误提示
         */
        Map<String,String> errorKeyMap=new HashMap<>();


        //3.判断关键属性
        CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, cboList);
        Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
        Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();
        if(!CollectionUtils.isEmpty(selfRepeatRowIndexList)){
            selfRepeatRowIndexList.stream().forEach(rowIndex->{
               /* //传入数据之间关键属性的校验
                RowDatas rowData= rowDataMap.get(rowIndex);
                XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
                resultDataObjectDetailDO.setCode("");
                resultDataObjectDetailDO.setId(rowData.getOid());
                resultDataObjectDetailDO.setErrorid("1");
                resultDataObjectDetailDO.setMsg(errorMap.getOrDefault(rowIndex,"") + ";关键属性重复");
                resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
                */
                errorKeyMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";传入的数据中关键属性重复");
            });
        }
        /****
         * 关键属性与系统中重复的判断
         */
        if(!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)){
            keyAttrRepeatRowIndexList.stream().forEach(rowIndex->{
                //传入数据之间关键属性的校验
               /* RowDatas rowData= rowDataMap.get(rowIndex);
                XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
                resultDataObjectDetailDO.setCode("");
                resultDataObjectDetailDO.setId(rowData.getOid());
                resultDataObjectDetailDO.setErrorid("1");
                resultDataObjectDetailDO.setMsg(errorMap.getOrDefault(rowIndex,"") + ";关键属性与系统中的重复" );
                resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
                */
                errorKeyMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";关键属性与系统中的重复" );
            });
        }
        //分类注入
        batchSwitchClassifyAttrOnOrder(attrVOS,cboList,classifyFullInfo,false);
        //boolean
        reSwitchBooleanAttrOnOrder(attrVOS,cboList);
        // cboList.stream().forEach(cbo->{
        //4.校验规则
        batchCheckVerifyOnOrder(attrVOS, cboList,errorMap);
        //5.校验枚举是否正确
        batchSwitchEnumAttrOnOrder(attrVOS,cboList,errorMap);
        //6.时间格式的验证
        //6.时间的，必须统一为yyyy-MM-dd HH:mm:ss
        batchSwitchDateAttrOnOrder(attrVOS,cboList,errorMap);
        //7.处理参照的情况
        batchSwitchReferAttrOnOrder(attrVOS,cboList,errorMap);
        //校验属性是否正确错误信息
        if(errorMap.size()>0){
            String[] newMsg = {""};
            cboList.stream().forEach(cbo -> {
                String rowIndex =cbo.getAttributeValue(IMPORT_ROW_INDEX);
                if(errorMap.containsKey(rowIndex)){
                    String oid=cbo.getOid();
                    String sourceOid=oid;
                    if(codeOidToSystemOidMap.containsKey(oid)){
                        sourceOid=codeOidToSystemOidMap.get(oid);
                    }
                    String code="";
                    String errorid="103";
                    String mes=errorMap.get(rowIndex);
                    XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
                    resultDataObjectDetailDO.setCode(code);
                    resultDataObjectDetailDO.setId(sourceOid);
                    resultDataObjectDetailDO.setErrorid(errorid);
                    resultDataObjectDetailDO.setMsg(mes);
                    resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
                }
            });

    }

        Map<String,String> newKeyMap=new HashedMap();
        if(errorKeyMap.size()>0 ) {
            errorKeyMap.keySet().forEach(key->{
                if(!errorMap.containsKey(key)){
                    newKeyMap.put(key,errorKeyMap.get(key));
                }
            });
            if(newKeyMap.size()>0) {
                List<BaseModel> editBoList = new ArrayList<>();
                Map<String, List<BaseModel>> indexTodataMap = keyResultVO.getIndexTODataMap();
                cboList.stream().forEach(cbo -> {
                    String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
                    if (indexTodataMap.containsKey(rowIndex)) {
                        String oid = cbo.getOid();
                        String sourceOid = oid;
                        String code = "";
                        String errorid = "201";
                        if(codeOidToSystemOidMap.containsKey(oid)){
                            sourceOid=codeOidToSystemOidMap.get(oid);
                        }
                        List<BaseModel> newCboList = indexTodataMap.get(rowIndex);
                        if (!CollectionUtils.isEmpty(newCboList)) {
                            BaseModel newCbo= newCboList.get(0);
                            String lcstatus =newCbo.getLcStatus();
                            String newOid =newCbo.getOid();
                            Date ts =newCbo.getTs();
                            code=newCbo.getId();
                            String lastmodifier=newCbo.getLastModifier();
                            if (!lcstatus.equals(CodeDefaultLC.RELEASED.getValue())) {
                                newCbo.setOid(newOid);
                                newCbo.setLastModifier(lastmodifier);
                                newCbo.setId(code);
                                newCbo.setTs(ts);
                                cbo.setLastModifier(cbo.getLastModifier());
                                editBoList.add(newCbo);
                            }
                            String mes = errorKeyMap.get(rowIndex);
                            XMLResultDataObjectDetailDO resultDataObjectDetailDO = new XMLResultDataObjectDetailDO();
                            resultDataObjectDetailDO.setCode(code);
                            resultDataObjectDetailDO.setId(sourceOid);
                            resultDataObjectDetailDO.setErrorid(errorid);
                            resultDataObjectDetailDO.setMsg(mes);
                            resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
                        }
                    }
                });
                //关键熟悉更改
                if (!CollectionUtils.isEmpty(editBoList)) {
                    engineService.updateBatchByBaseModel(classifyFullInfo.getTopClassifyVO().getBtmtypeid(),editBoList);//保存数据
                }
                errorMap.putAll(errorKeyMap);
            }
        }

        //  });
        //设置默认值
        batchSwitchAttrDefault(attrVOS, cboList);
        //最后弄组合规则
        batchSwitchComponentAttrOnOrder(attrVOS,cboList);
        //要把以上的错误的都抛出后，再继续处理时间和组合规则
        List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
            String rowIndex =cbo.getAttributeValue(IMPORT_ROW_INDEX);
            return !errorMap.containsKey(rowIndex);
        }).collect(Collectors.toList());
        List<String> needRowIndexList = new ArrayList<>();
        if(!CollectionUtils.isEmpty(needSaveCboList)) {
            //9.我们处理业务数据
            //生成编码的内容

            List<String>allNeedSaveCboList=new ArrayList<>();
            List<BaseModel> dataCBOList=new ArrayList<>();
            needSaveCboList.stream().forEach(clientBusinessObject -> {
                BaseModel baseModel=new BaseModel();
                BeanUtil.convert(clientBusinessObject,baseModel);
                baseModel.setData(VciBaseUtil.objectToMapString(clientBusinessObject));
                dataCBOList.add(baseModel);
                allNeedSaveCboList.add(baseModel.getOid());
            });
            try {
                productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(), dataCBOList);
                //如果是编码生成失败，则直接就失败了，其他的判断出来有错误的我们都统一返回到excel里面
                engineService.batchSaveSelectChar(templateVO, allNeedSaveCboList);
                // if(!isProcess){
                needSaveCboList.stream().forEach(needSaveCbo->{
                    XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
                    resultDataObjectDetailDO.setCode(needSaveCbo.getId());
                    String oid=needSaveCbo.getOid();
                    String sourceOid=oid;
                    if(codeOidToSystemOidMap.containsKey(oid)){
                        sourceOid=codeOidToSystemOidMap.get(oid);
                    }
                    resultDataObjectDetailDO.setId(sourceOid);
                    resultDataObjectDetailDO.setErrorid("0");
                    resultDataObjectDetailDO.setMsg("申请编码成功");
                    resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
                });
               /* }else{
                    needSaveCboList.stream().forEach(needSaveCbo->{
                        XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
                       // resultDataObjectDetailDO.setCode(needSaveCbo.getId());//不用返回编码
                        String oid=needSaveCbo.getOid();
                        String sourceOid=oid;
                        if(codeOidToSystemOidMap.containsKey(oid)){
                            sourceOid=codeOidToSystemOidMap.get(oid);
                        }
                        resultDataObjectDetailDO.setId(sourceOid);
                        resultDataObjectDetailDO.setErrorid("204");
                        resultDataObjectDetailDO.setMsg("申请编码成功，等待编码系统发布！");
                        resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
                    });

                }*/
            }catch (Throwable e){
                e.printStackTrace();
                needSaveCboList.stream().forEach(needSaveCbo->{
                    XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
                    resultDataObjectDetailDO.setCode("");
                    String oid=needSaveCbo.getOid();
                    String sourceOid=oid;
                    if(codeOidToSystemOidMap.containsKey(oid)){
                        sourceOid=codeOidToSystemOidMap.get(oid);
                    }
                    resultDataObjectDetailDO.setId(sourceOid);
                    resultDataObjectDetailDO.setErrorid("1");
                    resultDataObjectDetailDO.setMsg("保存出现问题:"+e.getMessage());
                    resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
                });

            }
        }

    }
    /***
     * 集成批量同步更新接口
     * @param codeClassifyVO;
     * @param dataObjectVO 数据信息
     * @param resultDataObjectDetailDOs 错误信息
     */
    @Override
    public void batchSyncEditDatas(CodeClassifyVO codeClassifyVO, DataObjectVO dataObjectVO, LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs) {
        String errorid="";
        String msg="";
        //查询分类和模板
        //先找到每一行的标题，然后根据标题来获取对应的属性
        List<RowDatas> rowDataList = dataObjectVO.getRowData();
        Map<String, RowDatas> rowDataMap = new LinkedHashMap<>();
        Map<String, RowDatas> codeDataMap = new LinkedHashMap<>();
        rowDataList.stream().forEach(rowData -> {
            rowDataMap.put(rowData.getRowIndex(), rowData);
            codeDataMap.put(rowData.getCode(), rowData);
        });
        //找第一行，为了找标题
        CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyVO.getOid());
        // 应该都是一个分类下的业务数据，找第一条的就行
        CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyVO.getOid());
        //校验模板是不是最新的
        //checkTemplateSync(sheetDataSetList,templateVO);
        //除去默认的属性.还有只有表单显示的字段才导入
        List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s -> !DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
        ).collect(Collectors.toList());
        Map<Integer/**列号**/, String/**字段的名称**/> fieldIndexMap = new HashMap<>();
        List<String> titleRowData = dataObjectVO.getColName();
        Map<String/**中文名称**/, String/**英文名称**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId().toLowerCase(Locale.ROOT), (o1, o2) -> o2));
        getFieldIndexMap(titleRowData, attrNameIdMap, fieldIndexMap);
        Map<String, String> cboOidMap = new HashMap<>();
        cboOidMap.put("id", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(codeDataMap.keySet().toArray(new String[0])) + ")");
        R<BtmTypeVO>  r= btmTypeClient.getDetail(templateVO.getBtmTypeId());
        BtmTypeVO btmTypeVO =r.getData();
        String tableName=btmTypeVO.getTableName();

        StringBuffer sb=new StringBuffer();
        sb.append(" select * from ");
        sb.append(tableName);
        sb.append(" where 1=1 ");
        sb.append(" id in (");
        sb.append(VciBaseUtil.toInSql(codeDataMap.keySet().toArray(new String[0])));
        sb.append(")");
        List<Map<String,String>> dataMapList=commonsMapper.queryByOnlySqlForMap(sb.toString());
        List<ClientBusinessObject> cboList=    ChangeMapTOClientBusinessObjects(dataMapList);
        Map<String, ClientBusinessObject> codeSystemObjectMap = cboList.stream().filter(systeDataObject -> systeDataObject != null && StringUtils.isNotBlank(systeDataObject.getId())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getId(), t -> t));
        Map<String, String> errorMap = new HashMap<>();
        List<CodeOrderDTO> codeOrderDTOList = new ArrayList<>();
        this.getCodeOrderDTOs(codeClassifyVO, templateVO, codeDataMap, codeSystemObjectMap, codeOrderDTOList, errorMap);
        // List<CodeClassifyProcessTempVO> codeClassifyProcessTempVOS=codeClassifyProcessTempService.listProcessTemplate(templateVO.getOid(),"code_cls_flow_use_order");
        boolean isProcess=false;
        /**  if(!CollectionUtils.isEmpty(codeClassifyProcessTempVOS)){
         isProcess=true;
         }**/

        Map<String, CodeOrderDTO> orderDTOMap = codeOrderDTOList.stream().filter(orderDTO -> orderDTO != null && StringUtils.isNotBlank(orderDTO.getId())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getId(), t -> t));
        List<BaseModel> updateList = new ArrayList<>();
        List<CodeAllCode> codeAllCodeList = new ArrayList<>();
        List<BaseModel> deleteList = new ArrayList<>();

        CodeClassifyTemplateVO firstTemplateVO = templateService.getObjectHasAttrByOid(orderDTOMap.values().stream().findFirst().get().getTemplateOid());
        Map<String, ClientBusinessObject> cboMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getId(), t -> t));
        //  boolean finalIsProcess = isProcess;
        orderDTOMap.keySet().stream().forEach(code -> {
            CodeOrderDTO orderDTO = orderDTOMap.get(code);
            ClientBusinessObject cbo = cboMap.get(code);
            String dataStatus=cbo.getLcStatus();
            RowDatas rowData=codeDataMap.get(code);
            String status=rowData.getStatus();
            String operation=rowData.getOperation();
            if (cbo.getTs().compareTo(orderDTO.getTs())==0?true:false) {
                // throw new VciBaseException("数据不是最新的，可能他人已经修改，请刷新后再试");
                errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+";数据不是最新的，可能他人已经修改，请刷新后再试");
            }
           /* if (!CodeDefaultLC.EDITING.getValue().equalsIgnoreCase(cbo.getLcStatus()) && !orderDTO.isEditInProcess()) {
                throw new VciBaseException("数据不是{0}的状态，不允许修改", new String[]{CodeDefaultLC.EDITING.getText()});
            }*/
            if(operation.equals("update")) {
                //1. 判断必输项
                checkRequiredAttrOnOrder(templateVO, orderDTO, errorMap);
                //2.先注入，再组合，最后校验
                switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO, errorMap);
                //3.处理组合规则。组合规则不能使用编码的属性，因为编码的生成可能是需要属性的
                switchComponentAttrOnOrder(templateVO, orderDTO);
                //4.校验规则
                checkVerifyOnOrder(templateVO, orderDTO, errorMap);
                //5.判断关键属性
                checkKeyAttrOnOrder(classifyFullInfo, templateVO, orderDTO, errorMap);
                //6.校验枚举的内容是否正确
                checkEnumOnOrder(templateVO, orderDTO, errorMap);
                //7.处理时间格式，在数据库里面不论是字符串还是日期格式，都使用相同的格式存储
                switchDateAttrOnOrder(templateVO, orderDTO);
                //默认的内容不能变，所以只需要拷贝自定义的相关属性即可
                copyValueToCBO(classifyFullInfo, cbo, orderDTO, templateVO, true, errorMap);
                //企业码和集团码的不修改
                cbo.setDescription(StringUtils.isBlank(orderDTO.getDescription())?"":orderDTO.getDescription());
                cbo.setName(orderDTO.getName());
                try {
                    cbo.setAttributeValueWithNoCheck("description", orderDTO.getDescription());
                    cbo.setAttributeValue("name", orderDTO.getName());
                    //  if(finalIsProcess){//在流程中不允许更改
                    //     errorMap.put(code,errorMap.getOrDefault(code, errorMap.getOrDefault(code,"")+";数据"+code+"在流程中，不允许更改!"));
                    //  }else{
                    cbo.setLcStatus(status);
                    cbo.setAttributeValue("lcstatus",status);
                    //  }
                } catch (VciBaseException e) {
                    e.printStackTrace();
                }
                BaseModel baseModel=new BaseModel();
                BeanUtil.convert(cbo,baseModel);
                baseModel.setData(VciBaseUtil.objectToMapString(cbo));
                updateList.add(baseModel);
            }else if(operation.equals("delete")){//如果在流程中不允许删除，不在流程中状态为发布或者停用的数据不允许删除，将其更改为停用，其他的情况直接删除
                //  if(finalIsProcess){
                //    errorMap.put(code,errorMap.getOrDefault(code, errorMap.getOrDefault(code,"")+";数据"+code+"在流程中，不允许删除!"));
                //}else {
                try {
                    Map<String, String> condtionMap = new HashMap<>();
                    condtionMap.put("createcodeoid", cbo.getOid());
                    log.info("oid:" + cbo.getOid());
                    List<CodeAllCode>newCodeAllCodeList= codeAllCodeService.selectByWrapper(Wrappers.<CodeAllCode>query().lambda().eq(CodeAllCode::getCreateCodeOid, cbo.getOid()));
                    log.info("codeCbos size:" + newCodeAllCodeList.size());
                    if (!CollectionUtils.isEmpty(newCodeAllCodeList)) {
                        CodeAllCode codeCbo = codeAllCodeList.get(0);
                        log.info("codeCbos code:" + codeCbo.getId());
                        codeCbo.setLcStatus(CodeDefaultLC.TASK_BACK.getValue());
                        codeAllCodeList.add(codeCbo);
                    }
                    deleteList.add(cbo);
                }catch (VciBaseException e) {
                    e.printStackTrace();
                }
                // }
            }else if(operation.equals("editstatus")){
                try {
                    //  if (finalIsProcess) {
                    //      errorMap.put(code, errorMap.getOrDefault(code, errorMap.getOrDefault(code, "") + ";数据" + code + "在流程中，不允许更改状态!"));
                    //   } else {
                    cbo.setLcStatus(status);
                    cbo.setAttributeValue("lcstatus", status);

                    //  }
                    BaseModel baseModel=new BaseModel();
                    BeanUtil.convert(cbo,baseModel);
                    baseModel.setData(VciBaseUtil.objectToMapString(cbo));
                    updateList.add(baseModel);
                }catch (VciBaseException e) {
                    e.printStackTrace();
                }
            }
        });
        /**
         * 错误信息输出
         */
        if(errorMap.size()>0){
            errorMap.keySet().forEach(code->{
                if(codeDataMap.containsKey(code)){
                    RowDatas rowDatas=  codeDataMap.get(code);
                    String dataMsg=errorMap.get(code);
                    String oid=rowDatas.getOid();
                    XMLResultDataObjectDetailDO xmlResultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
                    xmlResultDataObjectDetailDO.setErrorid("103");
                    xmlResultDataObjectDetailDO.setMsg(dataMsg);
                    xmlResultDataObjectDetailDO.setId(oid);
                    xmlResultDataObjectDetailDO.setCode(code);
                    resultDataObjectDetailDOs.add(xmlResultDataObjectDetailDO);
                }
            });
        }else {
            //存储数据
            try {
                engineService.updateBatchByBaseModel(classifyFullInfo.getTopClassifyVO().getBtmtypeid(),updateList);
                codeAllCodeService.saveBatch(codeAllCodeList);
                commonsMapper.deleteByTaleAndOid("",null);

            //    engineService.del(deleteList);
                errorid="0";
                msg="更新/状态更改/删除成功！";
            }catch (Throwable e){
                errorid="1";
                msg="保存失败："+e;
            }finally {
                String finalMsg = msg;
                String finalErrorid = errorid;
                cboList.stream().forEach(cbo->{
                    String code =cbo.getId();
                    if(codeDataMap.containsKey(code)) {
                        RowDatas rowDatas=codeDataMap.get(code);
                        String oid=rowDatas.getOid();
                        XMLResultDataObjectDetailDO xmlResultDataObjectDetailDO = new XMLResultDataObjectDetailDO();
                        xmlResultDataObjectDetailDO.setErrorid(finalErrorid);
                        xmlResultDataObjectDetailDO.setMsg(finalMsg);
                        xmlResultDataObjectDetailDO.setId(oid);
                        xmlResultDataObjectDetailDO.setCode(code);
                        resultDataObjectDetailDOs.add(xmlResultDataObjectDetailDO);
                    }
                });

            }
        }
    }
    /**
     * 校验属性是否为必输
     *
     * @param templateVO 模板的显示对象，需要包含模板属性
     * @param orderDTO   编码申请的信息
     */
    private void checkRequiredAttrOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
        Map<String, CodeClassifyTemplateAttrVO> requiredAttrMap = templateVO.getAttributes().stream().filter(
                s -> VciBaseUtil.getBoolean(s.getRequireFlag()) && StringUtils.isBlank(s.getComponentRule())
                    && StringUtils.isBlank(s.getClassifyInvokeAttr()))
            .collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
        if (!CollectionUtils.isEmpty(requiredAttrMap)) {
            requiredAttrMap.forEach((attrId, attrVO) -> {
                //只有企业编码，状态，备注，模板主键，分类主键这几个是固定的，其余都是自行配置的
                if (StringUtils.isBlank(getValueFromOrderDTO(orderDTO, attrId))) {
                    errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"") + ";属性【{"+attrVO.getName()+"}】必须要输入(选择)内容" );
                    //  throw new VciBaseException("属性【{0}】必须要输入(选择)内容", new String[]{attrVO.getName()});
                }
            });
        }
    }
    /**
     * 转换组合规则的值
     *
     * @param templateVO 模板的显示对象，需要包含模板属性
     * @param orderDTO   编码申请的信息
     */
    private void switchComponentAttrOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO) {
        Map<String, CodeClassifyTemplateAttrVO> compAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getComponentRule())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
        if (!CollectionUtils.isEmpty(compAttrVOMap)) {
            Map<String, String> dataMap = WebUtil.objectToMapString(orderDTO);

            Map<String, String> dataLowMap = new HashMap<>();
            if (!CollectionUtils.isEmpty(dataMap)) {
                dataMap.forEach((key, value) -> {
                    dataLowMap.put(key.toLowerCase(Locale.ROOT), value);
                });
            }
            dataLowMap.putAll(orderDTO.getData());
            compAttrVOMap.forEach((attrId, attrVO) -> {
                dataLowMap.put(attrId, formulaService.getValueByFormula(dataLowMap, attrVO.getComponentRule()));
            });
            dataLowMap.forEach((key, value) -> {
                setValueToOrderDTO(orderDTO, key, value);
            });
        }
    }

    /**
     * 校验正则表达式是否正确
     *
     * @param templateVO 模板的信息，必须包含属性的内容
     * @param orderDTO   编码申请的相关的信息
     */
    private void checkVerifyOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
        Map<String, CodeClassifyTemplateAttrVO> verifyAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getVerifyRule())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
        if (!CollectionUtils.isEmpty(verifyAttrVOMap)) {
            verifyAttrVOMap.forEach((attrId, attrVO) -> {
                String value = getValueFromOrderDTO(orderDTO, attrId);
                if (StringUtils.isNotBlank(value) && !value.matches(attrVO.getVerifyRule())) {
                    errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+";属性["+attrVO.getName()+"]的值不符合校验规则的要求");
                    //校验正则表达式
                    // throw new VciBaseException("属性[{0}]的值不符合校验规则的要求", new String[]{attrVO.getName()});
                }
            });
        }
    }
    /**
     * 校验关键属性
     *
     * @param classifyFullInfo 分类的全部信息
     * @param templateVO       模板的内容，必须包含模板属性
     * @param orderDTO         编码申请的相关的信息
     */
    private void checkKeyAttrOnOrder(CodeClassifyFullInfoBO classifyFullInfo, CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
        //先获取关键属性的规则，也利用继承的方式
        CodeKeyAttrRepeatVO keyRuleVO = keyRuleService.getRuleByClassifyFullInfo(classifyFullInfo);
        //注意的是keyRuleVO可能为空，表示不使用规则控制
        //获取所有的关键属性
        Map<String, CodeClassifyTemplateAttrVO> ketAttrMap = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getKeyAttrFlag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
        Map<String, String> conditionMap = new HashMap<>();
        boolean trimAll = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnoreallspaceflag());
        //全部去空的优先级大于去空
        boolean trim = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorespaceflag());
        boolean ignoreCase = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorecaseflag());
        boolean ignoreWidth = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorewidthflag());
        ketAttrMap.forEach((attrId, attrVO) -> {
            String value = getValueFromOrderDTO(orderDTO, attrId);
            if (value == null) {
                value = "";
            }
            engineService.wrapperKeyAttrConditionMap(value, keyRuleVO, attrId, trim, ignoreCase, ignoreWidth, trimAll, conditionMap);
        });

        //没有限制分类，但是一个模板只可能在一个业务类型里面，所以直接查询这个业务类型即可

        if (!CollectionUtils.isEmpty(conditionMap)) {
            final String[] sql = {"select count(*) from " + VciBaseUtil.getTableName(classifyFullInfo.getTopClassifyVO().getBtmtypeid()) + " where 1 = 1 "};
            conditionMap.forEach((key, value) -> {
                sql[0] += " and " + key + " = " + value;
            });
            if (StringUtils.isNotBlank(orderDTO.getOid())) {
                //修改的时候，需要排除自己
                sql[0] += " and oid != '" + orderDTO.getOid() + "'";
            } else if (StringUtils.isNotBlank(orderDTO.getCopyFromVersion())) {
                sql[0] += " and oid != '" + orderDTO.getCopyFromVersion() + "'";
            }
            sql[0] += " and islastR = '1' and islastV = '1' ";
            if (commonsMapper.queryCountBySql(sql[0]) > 0) {
                String ruleInfoMsg = keyRuleVO == null ? "" : "查询规则：去除空格--{0},忽略大小写--{1},忽略全半角--{2},忽略全部空格--{3}";
                String[] objs = new String[]{trim ? "是" : "否", ignoreCase ? "是" : "否", ignoreWidth ? "是" : "否", trimAll ? "是" : "否"};
                String defaultValue=";根据您填写的关键属性的内容，结合关键属性查询规则，发现这个数据已经在系统中存在了。请修正!。";
                String errormsg=defaultValue+ MessageFormat.format(ruleInfoMsg, objs);
                errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+errormsg);
                // throw new VciBaseException("根据您填写的关键属性的内容，结合关键属性查询规则，发现这个数据已经在系统中存在了。请修正!。" + ruleInfoMsg, objs);
            }
        }
    }
    /**
     * 校验枚举的内容
     *
     * @param templateVO 模板的显示对象，需要包含属性
     * @param orderDTO   编码申请的信息
     */
    private void checkEnumOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
        //如果枚举可以修改，则不需要校验是否符合枚举的选项
        Map<String, CodeClassifyTemplateAttrVO> enumAttrVOMap = templateVO.getAttributes().stream().filter(s -> (StringUtils.isNotBlank(s.getEnumString()) || StringUtils.isNotBlank(s.getEnumId())) && !VciBaseUtil.getBoolean(s.getEnumEditFlag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
        if (!CollectionUtils.isEmpty(enumAttrVOMap)) {
            enumAttrVOMap.forEach((attrId, attrVO) -> {
                String value = getValueFromOrderDTO(orderDTO, attrId);
                if (StringUtils.isNotBlank(value)) {
                    //有值才能校验
                    List<KeyValue> comboboxKVs = this.engineService.listComboboxItems(attrVO);
                    if (!comboboxKVs.stream().anyMatch(s -> value.equalsIgnoreCase(s.getKey()))) {
                        errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+";属性【"+attrVO.getName()+"】的值不符合枚举的要求");
                        //throw new VciBaseException("属性【{0}】的值不符合枚举的要求", new String[]{attrVO.getName()});
                    }
                }
            });
        }
    }
    /**
     * 转换时间的格式
     *
     * @param templateVO 模板的显示对象，需要包含属性
     * @param orderDTO   编码申请的信息
     */
    private void switchDateAttrOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO) {
        Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getCodeDateFormat())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
        if (!CollectionUtils.isEmpty(dateAttrVOMap)) {
            dateAttrVOMap.forEach((attrId, attrVO) -> {
                String value = getValueFromOrderDTO(orderDTO, attrId);
                if (StringUtils.isNotBlank(value)) {
                    DateConverter dateConverter = new DateConverter();
                    dateConverter.setAsText(value);
                    value = VciDateUtil.date2Str(dateConverter.getValue(), VciDateUtil.DateTimeMillFormat);
                    setValueToOrderDTO(orderDTO, attrId, value);
                }
            });
        }
    }

    /**
     * 拷贝数据到cbo对象上
     *
     * @param classifyFullInfo 分类的全部信息
     * @param cbo              业务数据
     * @param orderDTO         编码申请的信息
     * @param templateVO       模板的显示对象
     * @param edit             是否为修改
     */
    private void copyValueToCBO(CodeClassifyFullInfoBO classifyFullInfo, ClientBusinessObject cbo,
                                CodeOrderDTO orderDTO, CodeClassifyTemplateVO templateVO,
                                boolean edit,Map<String,String> errorMap) {
        String fullPath = "";
        if (!CollectionUtils.isEmpty(classifyFullInfo.getParentClassifyVOs())) {
            fullPath = classifyFullInfo.getParentClassifyVOs().stream().sorted(((o1, o2) -> o2.getDataLevel().compareTo(o1.getDataLevel())))
                .map(CodeClassifyVO::getOid).collect(Collectors.joining("##"));
        } else {
            fullPath = classifyFullInfo.getCurrentClassifyVO().getOid();
        }
        orderDTO.getData().forEach((key, value) -> {
            if (!edit || (!engineService.checkUnAttrUnEdit(key) &&
                !VciQueryWrapperForDO.LC_STATUS_FIELD.equalsIgnoreCase(key))) {
                try {
                    cbo.setAttributeValue(key, value);
                } catch (VciBaseException e) {
                    log.error("设置属性的值错误", e);
                }
            }
        });
        try {
            cbo.setAttributeValue(CODE_CLASSIFY_OID_FIELD, classifyFullInfo.getCurrentClassifyVO().getOid());
            cbo.setAttributeValue(CODE_TEMPLATE_OID_FIELD, templateVO.getOid());
            cbo.setAttributeValue(CODE_FULL_PATH_FILED, fullPath);
            if (!edit && StringUtils.isBlank(orderDTO.getLcStatus())) {
                //找生命周期的起始状态，
                if (StringUtils.isNotBlank(cbo.getLctid())) {
                    //OsLifeCycleVO lifeCycleVO = lifeCycleService.getLifeCycleById(cbo.getLctid());
//                    if (lifeCycleVO != null) {
//                        cbo.setLcStatus(lifeCycleVO.getStartStatus());
//                    } else {
                        cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
//                    }
                } else {
                    cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
                }

            }
            int secret = VciBaseUtil.getInt(cbo.getAttributeValue(SECRET_FIELD));
            /*if (secret == 0 || !secretService.checkDataSecret(secret)) {
                Integer userSecret = VciBaseUtil.getCurrentUserSecret();
                cbo.setAttributeValue(SECRET_FIELD, String.valueOf((userSecret == null || userSecret == 0) ? UserSecretEnum.NONE.getValue() : userSecret));
            }*/
        } catch (Throwable e) {
            log.error("设置默认的属性的值错误", e);
        }
    }
    /**
     * 设置新的值到申请对象上
     *
     * @param orderDTO 编码申请对象
     * @param attrId   属性的编号
     * @param value    值
     */
    private void setValueToOrderDTO(CodeOrderDTO orderDTO, String attrId, String value) {
        attrId = attrId.toLowerCase(Locale.ROOT);
        if (VciQueryWrapperForDO.BASIC_FIELD_MAP.containsKey(attrId)) {
            WebUtil.setValueToField(WebUtil.getFieldForObject(attrId, orderDTO.getClass()).getName(), orderDTO, value);
        } else {
            orderDTO.getData().put(attrId, value);
        }
    }
    /**
     * 从编码申请信息对象上获取某个属性的值
     *
     * @param orderDTO 编码申请对象
     * @param attrId   属性的编号
     * @return 值
     */
    private String getValueFromOrderDTO(CodeOrderDTO orderDTO, String attrId) {
        attrId = attrId.toLowerCase(Locale.ROOT);
        String value = null;
        if (VciQueryWrapperForDO.BASIC_FIELD_MAP.containsKey(attrId)) {
            value = WebUtil.getStringValueFromObject(WebUtil.getValueFromField(WebUtil.getFieldForObject(attrId, orderDTO.getClass()).getName(), orderDTO));
        } else {
            //说明是自行配置的
            //前端必须要传递小写的属性
            value = orderDTO.getData().getOrDefault(attrId, "");
        }
        return value;
    }
    /**
     * 处理分类注入的信息
     *
     * @param templateVO         模板的显示对象，必须要后模板的属性
     * @param classifyFullInfoBO 分类的全路径
     * @param orderDTO           编码申请的信息
     */
    private void switchClassifyLevelOnOrder(CodeClassifyTemplateVO templateVO, CodeClassifyFullInfoBO classifyFullInfoBO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
        Map<String, CodeClassifyTemplateAttrVO> classifyAttrVOMap = templateVO.getAttributes().stream().filter(
            s -> StringUtils.isNotBlank(s.getClassifyInvokeAttr()) && StringUtils.isNotBlank(s.getClassifyInvokeLevel())
        ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
        if (classifyFullInfoBO.getTopClassifyVO() == null) {
            //需要重新查询一下，因为这个是指定的分类进来的

        }
        if (!CollectionUtils.isEmpty(classifyAttrVOMap)) {
            classifyAttrVOMap.forEach((attrId, attrVO) -> {
                //分类注入的编号或者名称，
                //层级包含指定层和最小层
                CodeClassifyVO classifyVO = null;
                if (!CodeLevelTypeEnum.MIN.getValue().equalsIgnoreCase(attrVO.getClassifyInvokeLevel()) && !"min".equalsIgnoreCase(attrVO.getClassifyInvokeLevel())) {
                    //指定了层级的
                    //注意，因为查询上级分类出来的层级是倒序的，即顶层节点是最大的值
                    List<CodeClassifyVO> classifyVOS = classifyFullInfoBO.getParentClassifyVOs().stream().sorted(((o1, o2) -> o2.getDataLevel().compareTo(o1.getDataLevel()))).collect(Collectors.toList());
                    int level = VciBaseUtil.getInt(attrVO.getClassifyInvokeLevel());
                    if (classifyVOS.size() >= level && level > 0) {
                        classifyVO = classifyVOS.get(level - 1);
                    }
                } else {
                    //当前的分类
                    classifyVO = classifyFullInfoBO.getCurrentClassifyVO();
                }
                if (classifyVO == null) {
                    //说明层级有误
                    errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+";分类树上没有层级[" + attrVO.getClassifyInvokeLevel() + "]");
                    //orderDTO.getData().put(attrId, "分类树上没有层级[" + attrVO.getClassifyinvokelevel() + "]");
                    // classifyVO = classifyFullInfoBO.getCurrentClassifyVO();
                } else {
                    Map<String, String> classifyDataMap = VciBaseUtil.objectToMapString(classifyVO);
                    String value = classifyDataMap.getOrDefault(attrVO.getClassifyInvokeAttr(), "");
                    orderDTO.getData().put(attrId, value);
                }
            });
        }
    }
    /***
     *
     * @param codeClassifyVO
     * @param templateVO
     * @param codeDataMap
     * @param codeSystemObjectMap
     * @param codeOrderDTOList
     * @param errorMap
     * @return
     */
    private void   getCodeOrderDTOs(CodeClassifyVO codeClassifyVO,CodeClassifyTemplateVO templateVO,Map<String ,RowDatas>codeDataMap,Map<String, ClientBusinessObject> codeSystemObjectMap,List<CodeOrderDTO> codeOrderDTOList,Map<String,String> errorMap){
        codeDataMap.keySet().forEach(code->{
            RowDatas rowDatas=codeDataMap.get(code);
            Map<String, String> data= rowDatas.getFiledValue();
            CodeOrderDTO orderDTO = new CodeOrderDTO();
            if(codeSystemObjectMap.containsKey(code)){
                ClientBusinessObject sysDataObject= codeSystemObjectMap.get(code);
                orderDTO.setCodeClassifyOid(codeClassifyVO.getOid());//分类主键
                orderDTO.setOid(sysDataObject.getOid());//数据oid
                orderDTO.setLcStatus(rowDatas.getStatus());//状态
                orderDTO.setId(code);
                orderDTO.setTs(sysDataObject.getTs());
                orderDTO.setBtmname(codeClassifyVO.getBtmname());//业务类型
                orderDTO.setDescription("集成调用:更新");//数据描述
                if(data.containsKey("name")){
                    String name=data.get("name");
                    orderDTO.setName(name);//名称属性值
                }
                orderDTO.setData(data);//设置数据
                orderDTO.setSecDTOList(null);//分类码段
                orderDTO.setEditInProcess(false);//是否在流程中
                orderDTO.setTemplateOid(templateVO.getOid());
            }else{
                errorMap.put("code","编码为：【"+code+"】的数据在系统中不存在");
            }
            codeOrderDTOList.add(orderDTO);
        });
    }

    /**
@@ -1728,7 +2476,118 @@
            }
        });
    }
    /**
     * excel转换为cbo的对象
     * @param classifyFullInfo 分类的全部信息
     * @param fieldIndexMap 字段的位置
     * @param rowDataList excel里的行数据
     * @param templateVO 模板的显示对象
     * @param cboList 数据的列表
     * @param fullPath 全路径
     * @param operation 操作类型
     * @param errorMap 错误信息记录
     */
    private void excelToCbo(CodeClassifyFullInfoBO classifyFullInfo,List<String> titleRowData,Map<Integer,String> fieldIndexMap,List<RowDatas> rowDataList,
                            CodeClassifyTemplateVO templateVO,List<ClientBusinessObject> cboList,
                            String fullPath,boolean isProcess,String operation,Map<String,String> errorMap,Map<String,String> codeOidToSystemOidMap){
        rowDataList.stream().forEach(rowData -> {
            String oid=rowData.getOid();
            String rowNumber=rowData.getRowIndex();
            ClientBusinessObject cbo = new ClientBusinessObject();
            DefaultAttrAssimtUtil.addDefaultAttrAssimt(cbo, classifyFullInfo.getTopClassifyVO().getBtmtypeid());
            rowData.getData().forEach((index,value)->{
                String field = fieldIndexMap.get(index);
                if(StringUtils.isBlank(field)){
                    errorMap.put(rowNumber,"属性：【" +titleRowData.get(index)+ "】在系统中不存在");
                }
                try {
                    cbo.setAttributeValueWithNoCheck(field,value);
                    if(WebUtil.isDefaultField(field)){
                        WebUtil.setValueToField(field, cbo, value);
                    }
                } catch (VciBaseException e) {
                    log.error("设置属性的值错误",e);
                    errorMap.put(rowNumber,"属性：【" +titleRowData.get(index)+ "】在系统中不存在");
                }
            });
            try {
                cbo.setAttributeValue(IMPORT_ROW_INDEX,rowData.getRowIndex());
                cbo.setAttributeValue(CODE_TEMPLATE_OID_FIELD,templateVO.getOid());
                if(operation.equals("create")){
                    log.info("分类对象："+classifyFullInfo.getCurrentClassifyVO());
                    log.info("codeClassoid:"+classifyFullInfo.getCurrentClassifyVO().getOid());
                    cbo.setAttributeValue(CODE_CLASSIFY_OID_FIELD,classifyFullInfo.getCurrentClassifyVO().getOid());
                    cbo.setAttributeValue(CODE_FULL_PATH_FILED,fullPath);
                    int secret = VciBaseUtil.getInt(cbo.getAttributeValue(SECRET_FIELD));
                    /*if(secret == 0 || !secretService.checkDataSecret(secret) ){
                        Integer userSecret = VciBaseUtil.getCurrentUserSecret();
                        String secretValue= String.valueOf((userSecret==null || userSecret ==0)? UserSecretEnum.NONE.getValue():userSecret);
                        cbo.setAttributeValue(SECRET_FIELD,secretValue);
                    }*/
                    if(rowData.getStatus().equals(CodeDefaultLC.DISABLE.getValue())){//停用
                        cbo.setLcStatus(CodeDefaultLC.DISABLE.getValue());
                    }else if(rowData.getStatus().equals(CodeDefaultLC.EDITING.getValue())){//编辑
                        cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
                    }else if(rowData.getStatus().equals(CodeDefaultLC.AUDITING.getValue())) {//审批中
                        cbo.setLcStatus(CodeDefaultLC.AUDITING.getValue());
                    }else if(rowData.getStatus().equals(CodeDefaultLC.TASK_BACK.getValue())){//回收
                        cbo.setLcStatus(CodeDefaultLC.TASK_BACK.getValue());
                    }else{
                        cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());//发布
                    }
                    /**  if(!isProcess){
                     cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
                     }else {
                     if(rowData.getStatus().equals(CodeDefaultLC.DISABLE.getValue())){//停用
                     cbo.setLcStatus(CodeDefaultLC.DISABLE.getValue());
                     }else if(rowData.getStatus().equals(CodeDefaultLC.EDITING.getValue())){//编辑
                     cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
                     }else {//发布
                     cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
                     }
                     }***/
                    cbo.setCreator(rowData.getCreator());
                    cbo.setLastModifier(rowData.getEditor()==null?"":rowData.getEditor());
                }else if(operation.equals("update")){
                    //此时还没有转换路径
                    //cbo.setAttributeValue(CODE_FULL_PATH_FILED, childOidPathMap.getOrDefault(rowData.getData().getOrDefault(CODE_CLASSIFY_OID_FIELD,""),fullPath));
                    if(rowData.getStatus().equals(CodeDefaultLC.DISABLE.getValue())){//停用
                        cbo.setLcStatus(CodeDefaultLC.DISABLE.getValue());
                    }else if(rowData.getStatus().equals(CodeDefaultLC.RELEASED.getValue())){//发布
                        cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
                    }else if(rowData.getStatus().equals(CodeDefaultLC.EDITING.getValue())){//编辑
                        cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
                    }else if(rowData.getStatus().equals(CodeDefaultLC.AUDITING.getValue())) {//审批中
                        cbo.setLcStatus(CodeDefaultLC.AUDITING.getValue());
                    }else if(rowData.getStatus().equals(CodeDefaultLC.TASK_BACK.getValue())){//回收
                        cbo.setLcStatus(CodeDefaultLC.TASK_BACK.getValue());
                    }
                    cbo.setLastModifier(rowData.getEditor() == null ? "" : rowData.getEditor());//修改者
                }else if(operation.equals("delete")){
                    if(rowData.getStatus().equals(CodeDefaultLC.TASK_BACK.getValue())){//回收
                        cbo.setLcStatus(CodeDefaultLC.TASK_BACK.getValue());
                    }else{
                        cbo.setLcStatus(CodeDefaultLC.DISABLE.getValue());//停用
                    }
                }


            }catch (Throwable e){
                log.error("设置默认的属性的值错误",e);
                if(e instanceof  VciBaseException){
                    errorMap.put(rowNumber,"设置默认的属性的值错误"+((VciBaseException) e).getMessage());
                }else{
                    errorMap.put(rowNumber,"设置默认的属性的值错误"+e.getMessage());
                }

            }finally {
                codeOidToSystemOidMap.put(cbo.getOid(),oid);
            }
            cbo.setDescription("");
            cboList.add(cbo);
        });

    }
    /**
     * excel转换为cbo的对象
     * @param classifyFullInfo 分类的全部信息
@@ -2428,7 +3287,7 @@
        //2.判断关键属性在系统里是否重复
        //因为数据量很大，所以得想办法并行
        //SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
        Map<String,List<ClientBusinessObject>> indexTODataMap=new HashMap<>();
        Map<String,List<BaseModel>> indexTODataMap=new HashMap<>();
        List<ClientBusinessObject> repeatDataMap = cboList.parallelStream().filter(cbo -> {
            //每行都得查询.如果其中出现了错误，我们就直接抛出异常，其余的显示
            //VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
@@ -2446,8 +3305,16 @@
                boolean isKeyCheck= commonsMapper.queryCountBySql(sqlBO.getSqlCount()) > 0;
                if(isKeyCheck){
                    List<Map<String,String>> newDataList=  commonsMapper.queryByOnlySqlForMap(sqlBO.getSqlUnPage());
                    List<ClientBusinessObject> newCboList=    ChangeMapTOClientBusinessObjects(newDataList);
                    //List<ClientBusinessObject> newCboList=    ChangeMapTOClientBusinessObjects(newDataList);
                    List<BaseModel> newCboList=new ArrayList<>();
                    newDataList.stream().forEach(stringStringMap -> {
                        BaseModel baseModel=new BaseModel();
                        DefaultAttrAssimtUtil.copplyDefaultAttrAssimt(stringStringMap,baseModel);
                        newCboList.add(baseModel);
                    });
                    if(!CollectionUtils.isEmpty(newCboList)) {
                    indexTODataMap.put(cbo.getAttributeValue(IMPORT_ROW_INDEX),newCboList);
                    }
                }
                return isKeyCheck;
            }else{
@@ -2457,7 +3324,7 @@
        if(!CollectionUtils.isEmpty(repeatDataMap)){
            resultVO.setKeyAttrRepeatRowIndexList(repeatDataMap.stream().map(s->s.getAttributeValue(IMPORT_ROW_INDEX)).collect(Collectors.toSet()));
        }
        //resultVO.setIndexTODataMap(indexTODataMap);
        resultVO.setIndexTODataMap(indexTODataMap);
        //resultVO.setSuccess(true);
        return resultVO;
    }

 Source/UBCS/ubcs-service/ubcs-webservice/src/main/java/com/vci/ubcs/code/webservice/service/impl/GroupMdmInterServiceImpl.java

@@ -198,7 +198,7 @@
                }
                //保存表单数据
                dockingPreApplyFormService.saveOrUpdateBatch(dockingPreAttrMappings);
                mdmEngineClient.insertBatchByType(btmName,updateCbos);//保存数据
                mdmEngineClient.updateBatchByType(btmName,updateCbos);//保存数据
            }
            return R.success("申请接口调用成功");
        }catch (VciBaseException e){
@@ -312,7 +312,7 @@
                }
                //保存表单数据
                dockingPreApplyFormService.saveOrUpdateBatch(dockingPreAttrMappings);
                mdmEngineClient.insertBatchByType(btmName,updateCbos);//保存数据
                mdmEngineClient.updateBatchByType(btmName,updateCbos);//保存数据
            }
            return R.success("申请接口调用成功");
        }catch (VciBaseException e){