以及发布webservice接口功能搭建,将通通用接口移植过来

ludc

2023-05-17 b7a96fdc87ba86a100cd8fddbd03080f72703089

以及发布webservice接口功能搭建,将通通用接口移植过来

 Source/UBCS/ubcs-service/ubcs-code/pom.xml

@@ -25,6 +25,11 @@
        </dependency>
        <dependency>
            <groupId>com.vci.ubcs</groupId>
            <artifactId>ubcs-webservice</artifactId>
            <version>3.0.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.vci.ubcs</groupId>
            <artifactId>ubcs-ddl</artifactId>
            <version>3.0.1.RELEASE</version>
        </dependency>
@@ -50,6 +55,12 @@
            <artifactId>mybatis-plus-join-boot-starter</artifactId>
            <version>${mybatisplus.join.version}</version>
        </dependency>
        <dependency>
            <groupId>com.vci.ubcs</groupId>
            <artifactId>ubcs-webservice</artifactId>
            <version>3.0.1.RELEASE</version>
            <scope>compile</scope>
        </dependency>

    </dependencies>


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

@@ -0,0 +1,49 @@
package com.vci.ubcs.code.controller;

import com.vci.ubcs.code.service.UniversalInterfaceI;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springblade.core.tool.api.R;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * 主题库分类控制器
 *
 * @author xiejun
 * @date 2022-01-20
 */
@RestController
@RequestMapping("/codeSyncUniversalController")
public class CodeSyncUniversalController {
    /**
     * 日志
     */
    private Logger logger = LoggerFactory.getLogger(getClass());
    /**
     * 接口集成服务
     */
    @Autowired
    private UniversalInterfaceI universalInterfaceI;
    /****
     * 申请接口
     * @param dataString 属性信息
     * @param dataType 数据格式类型
     * @return
     * @throws Throwable
     */
    @PostMapping("/applyCode")
    public String applyCode(@RequestParam("dataString")String dataString, @RequestParam("dataType")String dataType)  {
        String result="";
        try {
            result = universalInterfaceI.applyCode(dataString, dataType);
        }catch (Throwable e){
            e.printStackTrace();
            logger.error("applyCode->"+e.getMessage());
        }
        return result;
    }
}

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

@@ -6,7 +6,6 @@
import com.vci.ubcs.code.dto.CodeOrderDTO;
import com.vci.ubcs.code.dto.CodeOrderSecDTO;
import com.vci.ubcs.code.dto.datapush.BaseModelDTO;
import com.vci.ubcs.code.service.MdmEngineService;
import com.vci.ubcs.code.service.MdmIOService;
import com.vci.ubcs.code.vo.pagemodel.CodeImProtRusultVO;
import com.vci.ubcs.code.vo.pagemodel.MdmUIInfoVO;

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

@@ -0,0 +1,14 @@
package com.vci.ubcs.code.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.vci.ubcs.code.entity.CodeWupinEntity;
import com.vci.ubcs.code.entity.DockingLog;
import com.vci.ubcs.code.vo.pagemodel.DockingLogeVO;
import org.springblade.core.mp.support.BaseEntityWrapper;
import org.springblade.core.tool.utils.BeanUtil;

import java.util.Objects;

public interface DockingLogeMapper extends BaseMapper<DockingLog> {

}

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

@@ -0,0 +1,27 @@
package com.vci.ubcs.code.service;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.conditions.query.QueryChainWrapper;
import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
import com.baomidou.mybatisplus.extension.conditions.update.UpdateChainWrapper;
import com.baomidou.mybatisplus.extension.kotlin.KtQueryChainWrapper;
import com.baomidou.mybatisplus.extension.kotlin.KtUpdateChainWrapper;
import com.baomidou.mybatisplus.extension.service.IService;
import com.vci.ubcs.code.entity.CodeWupinEntity;
import com.vci.ubcs.code.entity.DockingLog;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.function.Function;

/**
 * 主数据引擎服务
 * @author xiej
 * @date 2023-05-17
 */
public interface IDockingLogeService extends IService<DockingLog> {
    }

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

@@ -1,126 +1,136 @@
package com.vci.ubcs.code.service;


import com.baomidou.mybatisplus.extension.service.IService;
import com.vci.ubcs.code.entity.CodeAllCode;

/**
 * 主数据引擎服务
 * @author weidy
 * @date 2022-2-21
 */
public interface MdmEngineService extends IService<CodeAllCode> {
//  /**
//   * 使用分类的主键获取可以使用的模板对象
//   * @param codeClassifyOid 分类的主键
//   * @return 模板的显示对象
//   */
//  CodeClstemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid);
//package com.vci.ubcs.code.service;
//
//  /**
//   * 使用分类的主键获取可以使用的模板对象
//   * @param codeClassifyOid 分类的主键
//   * @param hasAttr 包含属性
//   * @return 模板的显示对象
//   */
//  CodeClstemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid, boolean hasAttr);
//
//  /**
//   * 获取枚举的下拉选项
//   * @param attrVO 模板属性的对象
//   * @return 下拉选项
//   */
//  List<KeyValue> listComboboxItems(CodeClassifyTemplateAttrVO attrVO);
//import com.baomidou.mybatisplus.extension.service.IService;
//import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
//import com.vci.ubcs.code.dto.CodeOrderDTO;
//import com.vci.ubcs.code.dto.datapush.BaseModelDTO;
//import com.vci.ubcs.code.entity.CodeAllCode;
//import com.vci.ubcs.code.vo.CodeClstemplateVO;
//import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateAttrVO;
//import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateVO;
//import com.vci.ubcs.code.vo.pagemodel.CodeRuleVO;
//import com.vci.ubcs.starter.web.pagemodel.KeyValue;
//
//  /**
//   * 修改状态
//   * @param baseModelDTO 数据传输对象
//   */
//  void changeStatus(BaseModelDTO baseModelDTO);
//import java.util.List;
//
//  /**
//   * 申请单一编码
//   * @param orderDTO 申请的信息，需要包含属性的内容和码段相关的内容
//   * @return 返回编码的内容
//   */
//  String addSaveCode(CodeOrderDTO orderDTO);
//
//  /**
//   * 判断编码的码段是否输入或者选择了码值
//   * @param ruleVO 规则的显示对象
//   * @param orderDTO 编码申请的内容
//   */
//  void checkSecValueOnOrder(CodeRuleVO ruleVO, CodeOrderDTO orderDTO);
//
//  /**
//   * 封装关键属性的查询语句
//   *
//   * @param value        当前的值
//   * @param keyRuleVO    关键属性的控制规则，可以为空
//   * @param attrId       属性的编号
//   * @param trim         是否去除空格
//   * @param ignoreCase   是否不区分大小写
//   * @param ignoreWidth  是否忽略全半角
//   * @param trimAll      是否忽略全部空格
//   * @param conditionMap 查询条件
//   */
//  void wrapperKeyAttrConditionMap(String value, CodeKeyattrrepeatVO keyRuleVO, String attrId,
//                             boolean trim, boolean ignoreCase, boolean ignoreWidth,
//                             boolean trimAll, Map<String, String> conditionMap);
//  /**
//   * 初始化业务类型
//   * --创建人默认为当前用户，如果需要修改，可以在获取后自行处理
//   * @param btmName 业务类型的名称，会自动变成小写
//   * @return CodeWupinEntity
//   * @throws VciBaseException 初始化出错的是会抛出异常
//   */
//  CodeWupinEntity createCBOByBtmName(String btmName);
//
//  /**
//   * 保存可输可选的信息
//   *
//   * @param templateVO 模板的对象
//   * @param cboList    数据的内容
//   */
//  void batchSaveSelectChar(CodeClstemplateVO templateVO, /*List<ClientBusinessObject> cboList*/
//                           List<String> cboList);
//
//  /**
//   * 使用模板的主键获取表单的信息
//   * @param templateOid 模板的主键
//   * @param codeClassifyOid 使用模板的分类的主键
//   * @return ui相关的内容
//   */
//    MdmUIInfoVO getFormDefineByTemplateOid(String templateOid, String codeClassifyOid);
//
//  /**
//   * 模板属性转换为表单的字段
//   *
//   * @param attrVO  模板属性
//   * @param btmType 业务类型
//   * @return 表单的字段
//   */
//  UIFormItemVO templateAttr2FormField(CodeClstempattrVO attrVO, String btmType) ;
//
//  /**
//   * 模板属性转换为表格显示的配置
//   *
//   * @param attrVO 模板属性
//   * @param forEdit 是否是编辑所需
//   * @return 表格的字段
//   */
//  UITableFieldVO templateAttr2TableField(CodeClstempattrVO attrVO, boolean forEdit);
//
//  /**
//   * 相似项查询
//   * @param orderDTO 编码的相关信息
//   * @return 数据列表
//   */
//  DataGrid<Map<String, String>> resembleQuery(CodeOrderDTO orderDTO);
//
//  /**
//   * 修改主题库数据
//   * @param orderDTO 数据的内容，不用包含码段的内容了
//   */
//  void editSaveCode(CodeOrderDTO orderDTO);
}
///**
// * 主数据引擎服务
// * @author weidy
// * @date 2022-2-21
// */
//public interface MdmEngineService extends IService<CodeAllCode> {
////    /**
////     * 使用分类的主键获取可以使用的模板对象
////     * @param codeClassifyOid 分类的主键
////     * @return 模板的显示对象
////     */
////    CodeClstemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid);
////
////    /**
////     * 使用分类的主键获取可以使用的模板对象
////     * @param codeClassifyOid 分类的主键
////     * @param hasAttr 包含属性
////     * @return 模板的显示对象
////     */
////    CodeClstemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid, boolean hasAttr);
////
////    /**
////     * 获取枚举的下拉选项
////     * @param attrVO 模板属性的对象
////     * @return 下拉选项
////     */
////    List<KeyValue> listComboboxItems(CodeClassifyTemplateAttrVO attrVO);
////
////    /**
////     * 修改状态
////     * @param baseModelDTO 数据传输对象
////     */
////    void changeStatus(BaseModelDTO baseModelDTO);
////
////    /**
////     * 申请单一编码
////     * @param orderDTO 申请的信息，需要包含属性的内容和码段相关的内容
////     * @return 返回编码的内容
////     */
////    String addSaveCode(CodeOrderDTO orderDTO);
////
////    /**
////     * 判断编码的码段是否输入或者选择了码值
////     * @param ruleVO 规则的显示对象
////     * @param orderDTO 编码申请的内容
////     */
////    void checkSecValueOnOrder(CodeRuleVO ruleVO, CodeOrderDTO orderDTO);
////
////    /**
////     * 封装关键属性的查询语句
////     *
////     * @param value        当前的值
////     * @param keyRuleVO    关键属性的控制规则，可以为空
////     * @param attrId       属性的编号
////     * @param trim         是否去除空格
////     * @param ignoreCase   是否不区分大小写
////     * @param ignoreWidth  是否忽略全半角
////     * @param trimAll      是否忽略全部空格
////     * @param conditionMap 查询条件
////     */
////    void wrapperKeyAttrConditionMap(String value, CodeKeyattrrepeatVO keyRuleVO, String attrId,
////                               boolean trim, boolean ignoreCase, boolean ignoreWidth,
////                               boolean trimAll, Map<String, String> conditionMap);
////    /**
////     * 初始化业务类型
////     * --创建人默认为当前用户，如果需要修改，可以在获取后自行处理
////     * @param btmName 业务类型的名称，会自动变成小写
////     * @return CodeWupinEntity
////     * @throws VciBaseException 初始化出错的是会抛出异常
////     */
////    CodeWupinEntity createCBOByBtmName(String btmName);
////
////    /**
////     * 保存可输可选的信息
////     *
////     * @param templateVO 模板的对象
////     * @param cboList    数据的内容
////     */
////    void batchSaveSelectChar(CodeClstemplateVO templateVO, /*List<ClientBusinessObject> cboList*/
////                             List<String> cboList);
////
////    /**
////     * 使用模板的主键获取表单的信息
////     * @param templateOid 模板的主键
////     * @param codeClassifyOid 使用模板的分类的主键
////     * @return ui相关的内容
////     */
////    MdmUIInfoVO getFormDefineByTemplateOid(String templateOid, String codeClassifyOid);
////
////    /**
////     * 模板属性转换为表单的字段
////     *
////     * @param attrVO  模板属性
////     * @param btmType 业务类型
////     * @return 表单的字段
////     */
////    UIFormItemVO templateAttr2FormField(CodeClstempattrVO attrVO, String btmType) ;
////
////    /**
////     * 模板属性转换为表格显示的配置
////     *
////     * @param attrVO 模板属性
////     * @param forEdit 是否是编辑所需
////     * @return 表格的字段
////     */
////    UITableFieldVO templateAttr2TableField(CodeClstempattrVO attrVO, boolean forEdit);
////
////    /**
////     * 相似项查询
////     * @param orderDTO 编码的相关信息
////     * @return 数据列表
////     */
////    DataGrid<Map<String, String>> resembleQuery(CodeOrderDTO orderDTO);
////
////    /**
////     * 修改主题库数据
////     * @param orderDTO 数据的内容，不用包含码段的内容了
////     */
////    void editSaveCode(CodeOrderDTO orderDTO);
//}

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

@@ -0,0 +1,52 @@
package com.vci.ubcs.code.service;
import javax.jws.WebService;

/**
 * 统一接口
 *
 * @author xiejun
 * @date 2022-11-27
 */

@WebService(targetNamespace = "http://code.ubcs.vci.com/",name = "universalInterface")
public interface UniversalInterfaceI {
    /**
     *统一申请编码接口
     * @param data 传递的数据参数
     * @param dataType 标识data是xml格式还是json格式，接口返回数据也是按照这个格式，以下接口类同
     * @return xml格式/json格式
     * @throws Throwable
     */
    public String applyCode(String data,String dataType)throws Throwable;

    /***
     * 统一更新接口
     * @param data
     * @param dataType
     * @return
     * @throws Throwable
     */
    public String syncEditData(String data,String dataType)throws Throwable;

    /***
     * 查询分类口
     * @param data
     * @param dataType
     * @throws Throwable
     */
    public String  queryClassify(String data,String dataType)throws Throwable;

    /***
     * 查询数据
     * @param data
     * @param dataType
     * @throws Throwable
     */
    public String  queryData(String data,String dataType)throws Throwable;

    /***
     * 返回编码规则接口
     */
    public String queryClassifyRule(String data,String datatype)throws Throwable;

}

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

@@ -0,0 +1,18 @@
package com.vci.ubcs.code.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.vci.ubcs.code.entity.DockingLog;
import com.vci.ubcs.code.mapper.DockingLogeMapper;
import com.vci.ubcs.code.service.IDockingLogeService;
import org.springframework.stereotype.Service;


/**
    * 编码信息 服务实现类
    *
    * @author xiej
    * @since 2023-05-17
    */
@Service
public class DockingLogeServiceImpl extends ServiceImpl<DockingLogeMapper, DockingLog> implements IDockingLogeService {

}

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

@@ -1,57 +1,61 @@
package com.vci.ubcs.code.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.vci.ubcs.code.entity.CodeAllCode;
import com.vci.ubcs.code.mapper.CodeAllCodeMapper;
import com.vci.ubcs.code.service.*;
import org.springframework.stereotype.Service;

/**
 * 主数据引擎服务
 *
 * @author weidy
 * @date 2022-2-22
 */
@Service
public class MdmEngineServiceImpl extends ServiceImpl<CodeAllCodeMapper, CodeAllCode> implements MdmEngineService {


//  /**
//   * 模板的服务
//   */
//  @Resource
//  private CodeClstemplateServiceImpl templateService;
//  /**
//   * 模板的服务
//   */
//  @Resource
//  private CodeOsbtmtypeMapper codeOsbtmtypeMapper;
//  /**
//   * 生成编码的服务
//   */
//  @Resource
//  private MdmProductCodeService productCodeService;
//  /**
//   * 字典的服务
//   */
//  @Resource
//  IDictBizClient iDictBizClient;
//  /**
//   * 公式的服务
//   */
//  @Autowired
//  private FormulaServiceImpl formulaService;
//package com.vci.ubcs.code.service.impl;
//
//  /**
//   * 通用查询
//   */
//  @Resource
//  CommonsMapper commonsMapper;
//  /**
//   * 编码规则的服务
//   */
//  @Autowired
//  private ICodeRuleService ruleService;
//import com.alibaba.fastjson.JSONObject;
//import com.alibaba.nacos.common.utils.StringUtils;
//import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
//import com.baomidou.mybatisplus.extension.service.IService;
//import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
//import com.sun.corba.se.impl.orbutil.ObjectUtility;
//import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
//import com.vci.ubcs.code.dto.CodeOrderDTO;
//import com.vci.ubcs.code.dto.datapush.BaseModelDTO;
//import com.vci.ubcs.code.entity.CodeAllCode;
//import com.vci.ubcs.code.entity.CodeOsbtmtypeEntity;
//import com.vci.ubcs.code.entity.CodeRule;
//import com.vci.ubcs.code.entity.CodeWupinEntity;
//import com.vci.ubcs.code.enumpack.CodeDefaultLC;
//import com.vci.ubcs.code.enumpack.CodeLevelTypeEnum;
//import com.vci.ubcs.code.enumpack.CodeSecTypeEnum;
//import com.vci.ubcs.code.mapper.CodeAllCodeMapper;
//import com.vci.ubcs.code.mapper.CodeOsbtmtypeMapper;
//import com.vci.ubcs.code.mapper.CodeRuleMapper;
//import com.vci.ubcs.code.service.*;
//import com.vci.ubcs.code.vo.CodeClstemplateVO;
//import com.vci.ubcs.code.vo.CodeKeyattrrepeatVO;
//import com.vci.ubcs.code.vo.pagemodel.CodeBasicSecVO;
//import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateAttrVO;
//import com.vci.ubcs.code.vo.pagemodel.CodeClassifyVO;
//import com.vci.ubcs.code.vo.pagemodel.CodeRuleVO;
//import com.vci.ubcs.omd.entity.Dict;
//import com.vci.ubcs.starter.exception.VciBaseException;
//import com.vci.ubcs.starter.revision.model.BaseModel;
//import com.vci.ubcs.starter.web.enumpck.UserSecretEnum;
//import com.vci.ubcs.starter.web.pagemodel.KeyValue;
//import com.vci.ubcs.starter.web.toolmodel.DateConverter;
//import com.vci.ubcs.starter.web.util.VciBaseUtil;
//import com.vci.ubcs.starter.web.util.VciDateUtil;
//import com.vci.ubcs.starter.web.util.VciQueryWrapperForDO;
//import com.vci.ubcs.starter.web.util.WebUtil;
//import com.vci.ubcs.system.entity.DictBiz;
//import com.vci.ubcs.system.feign.IDictBizClient;
//import org.slf4j.Logger;
//import org.slf4j.LoggerFactory;
//import org.springblade.core.mp.support.Query;
//import org.springblade.core.secure.utils.AuthUtil;
//import org.springblade.core.tool.api.R;
//import org.springframework.beans.BeanUtils;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.stereotype.Service;
//
///**
// * 主数据引擎服务
// *
// * @author weidy
// * @date 2022-2-22
// */
//@Service
//public class MdmEngineServiceImpl extends ServiceImpl<CodeAllCodeMapper, CodeAllCode> implements MdmEngineService {
//
//
//  /**
//   * 分类的服务
@@ -69,50 +73,8 @@
//   */
//  private Logger logger = LoggerFactory.getLogger(getClass());
//
//  /**
//   * 空格
//   */
//  public static final String SPACE = " ";
//
//  /**
//   * 密级的字段
//   */
//  public static final String SECRET_FILED = "secretgrade";
//  /**
//   * 用户新增数据的时候可以查看的密级
//   */
//  public static final String MY_DATA_SECRET = "myDataSecret";
//  /**
//   * 拷贝的版本
//   */
//  public static final String COPY_FROM_VERSION = "copyfromversion";
//  /**
//   * 只是sql
//   */
//  public static final String ONLY = "${vcionly}";
//
//  /**
//   * 默认的时间格式
//   */
//  private static final String DATETIME_FORMAT = "yyyy-mm-dd hh24:mi:ss";
//
//  /**
//   * 日期格式
//   */
//  private static final String DATE_FORMAT = "yyyy-mm-dd";
//
//  /**
//   * 必输
//   */
//  public static final String REQUIRED_CHAR = "*";
//  /**
//   * 替换字符
//   */
//  public static final String SPECIAL_CHAR  = "VCI";
////    @Autowired
////    private CodeOsbtmtypeMapper codeOsbtmtypeMapper;
//
//
//  //  @Autowired
//  //  private CodeOsbtmtypeMapper codeOsbtmtypeMapper;
//
//  /**
//   * 使用分类的主键获取可以使用的模板对象
@@ -190,14 +152,14 @@
//      List<CodeAllCode> codeCbos = baseMapper.selectList(allCodeWrapper);
////        List<ClientBusinessObject> codeCbos = boService.queryCBO(MdmBtmTypeConstant.CODE_ALL_CODE, conditionMap);
//      // 回收需要业务数据删除
//      if (CodeDefaultLC.TASK_BACK.getValue().equals(baseModelDTO.getLcStatus())) {
////            BatchCBO batchCBO = new BatchCBO();
////            batchCBO.getDeleteCbos().addAll(cboList);
//          codeOsbtmtypeMapper.deleteBatchIds(cboList);
////            boService.persistenceBatch(batchCBO);
//      } else {
////        if (CodeDefaultLC.TASK_BACK.getValue().equals(baseModelDTO.getLcStatus())) {
//////          BatchCBO batchCBO = new BatchCBO();
//////          batchCBO.getDeleteCbos().addAll(cboList);
////            codeOsbtmtypeMapper.deleteBatchIds(cboList);
//////          boService.persistenceBatch(batchCBO);
////        } else {
////            lifeCycleService.transCboStatus(cboList, baseModelDTO.getLcStatus());
//      }
////        }
////        lifeCycleService.transCboStatus(codeCbos, baseModelDTO.getLcStatus());
//  }
//
@@ -233,1598 +195,1597 @@
//      switchDateAttrOnOrder(templateVO, orderDTO);
//      //9.生成编码的信息
////        ClientBusinessObject cbo = boService.createCBOByBtmName(classifyFullInfo.getTopClassifyVO().getBtmtypeid());
//      CodeWupinEntity cbo = createCBOByBtmName(classifyFullInfo.getTopClassifyVO().getBtmtypeid());
////        //默认的属性都不用从前端拷贝
////        //设置编码需要的默认属性的内容
//      copyValueToCBO(classifyFullInfo, cbo, orderDTO, templateVO, false);
////        //TODO:因为默认的属性都不拷贝，目前集团码叫name，并没有从DTO拷贝到cbo里。增加一个单独处理，以后再看要不要调整
//      cbo.setName(orderDTO.getName() == null ? "" : orderDTO.getName());
////        //end -- modify by lihang @20220407
//      List<CodeWupinEntity> cboList = new ArrayList<>();
//
//      //备注
//      cbo.setDescription(orderDTO.getDescription());
//      cboList.add(cbo);
////        CodeWupinEntity cbo = createCBOByBtmName(classifyFullInfo.getTopClassifyVO().getBtmtypeid());
//////      //默认的属性都不用从前端拷贝
//////      //设置编码需要的默认属性的内容
////        copyValueToCBO(classifyFullInfo, cbo, orderDTO, templateVO, false);
//////      //TODO:因为默认的属性都不拷贝，目前集团码叫name，并没有从DTO拷贝到cbo里。增加一个单独处理，以后再看要不要调整
////        cbo.setName(orderDTO.getName() == null ? "" : orderDTO.getName());
//////      //end -- modify by lihang @20220407
////        List<CodeWupinEntity> cboList = new ArrayList<>();
////
////        //备注
////        cbo.setDescription(orderDTO.getDescription());
////
////        cboList.add(cbo);
//      List<String> codeList = productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(),cboList);
//
//
//      List<String> charList = new ArrayList<>();
//      for (CodeWupinEntity wupinEntity : cboList) {
//          charList.add(wupinEntity.getId());
//      }
//      batchSaveSelectChar(templateVO, charList);
//      return codeList.size() > 0 ? codeList.get(0) : "";
////        return null;
//  }
//
//  /**
//   * 处理分类注入的信息
//   *
//   * @param templateVO         模板的显示对象，必须要后模板的属性
//   * @param classifyFullInfoBO 分类的全路径
//   * @param orderDTO           编码申请的信息
//   */
//  private void switchClassifyLevelOnOrder(CodeClstemplateVO templateVO, CodeClassifyFullInfoBO classifyFullInfoBO, CodeOrderDTO orderDTO) {
//      Map<String,CodeClstempattrVO> 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) {
//                  //说明层级有误
//                  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 ruleVO   规则的显示对象
//   * @param orderDTO 编码申请的内容
//   */
//  @Override
//  public void checkSecValueOnOrder(CodeRuleVO ruleVO, CodeOrderDTO orderDTO) {
//      List<String> unSerialSecOidList = ruleVO.getSecVOList().stream().filter(
//          s -> !(CodeSecTypeEnum.CODE_SERIAL_SEC.getValue().equalsIgnoreCase(s.getSecType())
//              || CodeSecTypeEnum.CODE_ATTR_SEC.getValue().equalsIgnoreCase(s.getSecType())
//              || CodeSecTypeEnum.CODE_DATE_SEC.getValue().equalsIgnoreCase(s.getSecType())
//              || CodeSecTypeEnum.CODE_LEVEL_SEC.getValue().equalsIgnoreCase(s.getSecType())
//              || VciBaseUtil.getBoolean(s.getNullableFlag()))
//      ).map(CodeBasicSecVO::getOid).collect(Collectors.toList());
//      if (!CollectionUtils.isEmpty(unSerialSecOidList)) {
//          if (CollectionUtils.isEmpty(orderDTO.getSecDTOList())) {
//              throw new VciBaseException("非流水码段(或者必输码段）必须要输入(或选择)码值");
//          }
//          if (orderDTO.getSecDTOList().stream().anyMatch(s -> !unSerialSecOidList.contains(s.getSecOid())
//              && StringUtils.isBlank(s.getSecValue()))) {
//              throw new VciBaseException("非流水码段(或者必输码段）必须要输入(或选择)码值");
//          }
//      }
//  }
//
//  /**
//   * 校验属性是否为必输
//   *
//   * @param templateVO 模板的显示对象，需要包含模板属性
//   * @param orderDTO   编码申请的信息
//   */
//  private void checkRequiredAttrOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) {
//      Map<String, CodeClstempattrVO> 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))) {
//                  throw new VciBaseException("属性【{0}】必须要输入(选择)内容", new String[]{attrVO.getName()});
//              }
//          });
//      }
//  }
//
//  /**
//   * 从编码申请信息对象上获取某个属性的值
//   *
//   * @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 orderDTO   编码申请的信息
//   */
//  private void switchComponentAttrOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) {
//      Map<String, CodeClstempattrVO> 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 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 templateVO 模板的信息，必须包含属性的内容
//   * @param orderDTO   编码申请的相关的信息
//   */
//  private void checkVerifyOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) {
//      Map<String, CodeClstempattrVO> 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())) {
//                  //校验正则表达式
//                  throw new VciBaseException("属性[{0}]的值不符合校验规则的要求", new String[]{attrVO.getName()});
//              }
//          });
//      }
//  }
//
//  /**
//   * 校验关键属性
//   *
//   * @param classifyFullInfo 分类的全部信息
//   * @param templateVO       模板的内容，必须包含模板属性
//   * @param orderDTO         编码申请的相关的信息
//   */
//  private void checkKeyAttrOnOrder(CodeClassifyFullInfoBO classifyFullInfo, CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) {
//      //先获取关键属性的规则，也利用继承的方式
//      CodeKeyattrrepeatVO keyRuleVO = keyRuleService.getRuleByClassifyFullInfo(classifyFullInfo);
//      //注意的是keyRuleVO可能为空，表示不使用规则控制
//      //获取所有的关键属性
//      Map<String, CodeClstempattrVO> 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 = "";
//          }
//          wrapperKeyAttrConditionMap(value, keyRuleVO, attrId, trim, ignoreCase, ignoreWidth, trimAll, conditionMap);
//      });
//
//      //没有限制分类，但是一个模板只可能在一个业务类型里面，所以直接查询这个业务类型即可
//
//      if (!CollectionUtils.isEmpty(conditionMap)) {
//          final String[] sql = {"select count(*) from " + VciBaseUtil.getTableName(classifyFullInfo.getTopClassifyVO().getBtmtypeid()) + " t 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 (boService.queryCountBySql(sql[0], new HashMap<>()) > 0) {
//          if (Integer.parseInt(commonsMapper.selectById(sql[0]).get(0)) > 0) {
//              String ruleInfoMsg = keyRuleVO == null ? "" : "查询规则：去除空格--{0},忽略大小写--{1},忽略全半角--{2},忽略全部空格--{3}";
//              String[] objs = new String[]{trim ? "是" : "否", ignoreCase ? "是" : "否", ignoreWidth ? "是" : "否", trimAll ? "是" : "否"};
//              throw new VciBaseException("根据您填写的关键属性的内容，结合关键属性查询规则，发现这个数据已经在系统中存在了。请修正!。" + ruleInfoMsg, objs);
//          }
//      }
//  }
//
//  /**
//   * 封装关键属性的查询语句
//   *
//   * @param value        当前的值
//   * @param keyRuleVO    关键属性的控制规则，可以为空
//   * @param attrId       属性的编号
//   * @param trim         是否去除空格
//   * @param ignoreCase   是否不区分大小写
//   * @param ignoreWidth  是否忽略全半角
//   * @param trimAll      是否忽略全部空格
//   * @param conditionMap 查询条件
//   */
//  @Override
//  public void wrapperKeyAttrConditionMap(String value, CodeKeyattrrepeatVO keyRuleVO, String attrId,
//                                         boolean trim, boolean ignoreCase, boolean ignoreWidth,
//                                         boolean trimAll, Map<String, String> conditionMap) {
//      boolean ignoreSpace = trim || trimAll;
//      if (StringUtils.isBlank(value)) {
//          //为空的时候，不能用QueryOperation.ISNULL，平台不知道啥时候不处理这种了
//          conditionMap.put("t."+attrId, "null");
//      } else {
//          if (keyRuleVO != null) {
//              String queryKey = "";
//              String queryValue = "";
//
//              String temp = "";
//              if (ignoreCase && ignoreSpace && ignoreWidth) {
//                  //忽略大小写，且去空，忽略全半角
//                  temp = (trimAll ? "REPLACE" : "TRIM") + "(UPPER(to_single_byte(%s)) " + (trimAll ? ",' ','')" : ")");
//              } else if (ignoreCase && ignoreSpace && !ignoreWidth) {
//                  //忽略大小写、去空、不忽略全半角
//                  temp = (trimAll ? "REPLACE" : "TRIM") + "(UPPER(%s) " + (trimAll ? ",' ','')" : ")");
//              } else if (ignoreCase && !ignoreSpace && ignoreWidth) {
//                  //忽略大小写、不去空、忽略全半角
//                  temp = "UPPER(to_single_byte(%s))";
//              } else if (!ignoreCase && ignoreSpace && ignoreWidth) {
//                  //不忽略大小写、去空、忽略全半角
//                  temp = (trimAll ? "REPLACE" : "TRIM") + "(to_single_byte(%s) " + (trimAll ? ",' ','')" : ")");
//              } else if (ignoreCase && !ignoreSpace && !ignoreWidth) {
//                  //忽略大小写、不去空、不忽略全半角
//                  temp = "UPPER(%s)";
//              } else if (!ignoreCase && !ignoreCase && ignoreWidth) {
//                  //不忽略大小写、不去空、忽略全半角
//                  temp = "to_single_byte(%s)";
//              } else if (!ignoreCase && ignoreSpace && !ignoreWidth) {
//                  //不忽略大小写、去空、不忽略全半角
//                  temp = (trimAll ? "REPLACE" : "TRIM") + "(%s " + (trimAll ? ",' ','')" : ")");
//              } else if (!ignoreCase && !ignoreSpace && !ignoreWidth) {
//                  //不忽略大小写、不去空、不忽略全半角
//                  temp = "%s";
//              }
//              queryKey = String.format(temp, "t."+attrId);
//              queryValue = String.format(temp, "'" + (trim ? value.trim() : value) + "'");
//              conditionMap.put(queryKey, queryValue);
//          } else {
//              //为空的时候不代表不校验，只是不去除相关的信息
//              conditionMap.put("t."+attrId, value);
//          }
//      }
//  }
//
//  /**
//   * 校验枚举的内容
//   *
//   * @param templateVO 模板的显示对象，需要包含属性
//   * @param orderDTO   编码申请的信息
//   */
//  private void checkEnumOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) {
//      //如果枚举可以修改，则不需要校验是否符合枚举的选项
//
//      Map<String, CodeClstempattrVO> 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)) {
//                  CodeClassifyTemplateAttrVO codeClassifyTemplateAttrVO = new CodeClassifyTemplateAttrVO();
//                  BeanUtils.copyProperties(attrVO,codeClassifyTemplateAttrVO);
//                  //有值才能校验
//                  List<KeyValue> comboboxKVs = listComboboxItems(codeClassifyTemplateAttrVO);
//                  if (!comboboxKVs.stream().anyMatch(s -> value.equalsIgnoreCase(s.getKey()))) {
//                      throw new VciBaseException("属性【{0}】的值不符合枚举的要求", new String[]{attrVO.getName()});
//                  }
//              }
//          });
//      }
//  }
//
//  /**
//   * 转换时间的格式
//   *
//   * @param templateVO 模板的显示对象，需要包含属性
//   * @param orderDTO   编码申请的信息
//   */
//  private void switchDateAttrOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) {
//      Map<String, CodeClstempattrVO> 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, CodeWupinEntity cbo,
//                              CodeOrderDTO orderDTO, CodeClstemplateVO templateVO,
//                              boolean edit) {
//      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();
//      }
//
////        BeanUtils.
//      BeanUtils.copyProperties(orderDTO.getData(),cbo);
//      cbo.setMaterialtype(Short.valueOf("1001"));
////        orderDTO.getData().forEach((key, value) -> {
////            if (!edit || (!checkUnAttrUnEdit(key) &&
////                !VciQueryWrapperForDO.LC_STATUS_FIELD.equalsIgnoreCase(key))) {
////                try {
////                    cbo.setAttributeValue(key, value);
////                } catch (Exception e) {
////                    logger.error("设置属性的值错误", e);
////                }
////            }
////        });
//      try {
//
//          cbo.setCodeclsfid(classifyFullInfo.getCurrentClassifyVO().getOid());
//          cbo.setCodetemplateoid(templateVO.getOid());
//          cbo.setCodeclsfpath(fullPath);
////            cbo.setMaterialclassify("model_type");
////            cbo.setMaterialname(orderDTO.getData().get("materialname"));
////            cbo.setShifoupihaoguanli("true");
////            cbo.setKucunwl("true");
////            cbo.setXiaoshouwl("false");
//          if (!edit && StringUtils.isBlank(orderDTO.getLcStatus())) {
//              //找生命周期的起始状态，插个点，看生命周期是否需要创建
//              if (StringUtils.isNotBlank(cbo.getLctid())) {
////                    OsLifeCycleVO lifeCycleVO = lifeCycleService.getLifeCycleById(cbo.getLctid());
////                    if (lifeCycleVO != null) {
////                        cbo.setLcStatus("Editing");
//////                      cbo.setLcStatus(lifeCycleVO.getStartStatus());
////                    } else {
//                      cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
////        List<String> codeList = productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(),cboList);
////
////
////        List<String> charList = new ArrayList<>();
////        for (CodeWupinEntity wupinEntity : cboList) {
////            charList.add(wupinEntity.getId());
////        }
////        batchSaveSelectChar(templateVO, charList);
////        return codeList.size() > 0 ? codeList.get(0) : "";
//////      return null;
////    }
////
////    /**
////     * 处理分类注入的信息
////     *
////     * @param templateVO         模板的显示对象，必须要后模板的属性
////     * @param classifyFullInfoBO 分类的全路径
////     * @param orderDTO           编码申请的信息
////     */
////    private void switchClassifyLevelOnOrder(CodeClstemplateVO templateVO, CodeClassifyFullInfoBO classifyFullInfoBO, CodeOrderDTO orderDTO) {
////        Map<String,CodeClstempattrVO> 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 {
//                  cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
//              }
//
//          }
//
//          int secret = VciBaseUtil.getInt(cbo.getSecretGrade().toString());
//          //插个点，后续看密级服务是否可用
////            if (secret == 0 || !secretService.checkDataSecret(secret)) {
//          if (secret == 0 ) {
//              Integer userSecret = VciBaseUtil.getCurrentUserSecret();
////                cbo.setAttributeValue(SECRET_FIELD, String.valueOf((userSecret == null || userSecret == 0) ? UserSecretEnum.NONE.getValue() : userSecret));
//              cbo.setSecretGrade(userSecret == null || userSecret == 0 ? UserSecretEnum.NONE.getValue() : userSecret);
//          }
//      } catch (Throwable e) {
//          logger.error("设置默认的属性的值错误", e);
//      }
//  }
//
//
//  /**
//   * 初始化业务类型
//   * --创建人默认为当前用户，如果需要修改，可以在获取后自行处理
//   * @param btmName 业务类型的名称，会自动变成小写
//   * @return CodeWupinEntity
//   * @throws VciBaseException 初始化出错的是会抛出异常
//   */
//  @Override
//  public CodeWupinEntity createCBOByBtmName(String btmName)
//      throws VciBaseException {
//      if(btmName!=null){
//          btmName = btmName.trim().toLowerCase();
//      }
//      String userid = AuthUtil.getUser().getUserName();
////        if(!hasCreatedCbos.containsKey(btmName)){
////            if(StringUtils.isEmpty(userid)){
////                throw new VciBaseException(msgCodePrefix +"noHasUserid");
////                } else {
////                    //当前的分类
////                    classifyVO = classifyFullInfoBO.getCurrentClassifyVO();
////                }
////                if (classifyVO == null) {
////                    //说明层级有误
////                    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 ruleVO   规则的显示对象
////     * @param orderDTO 编码申请的内容
////     */
////    @Override
////    public void checkSecValueOnOrder(CodeRuleVO ruleVO, CodeOrderDTO orderDTO) {
////        List<String> unSerialSecOidList = ruleVO.getSecVOList().stream().filter(
////            s -> !(CodeSecTypeEnum.CODE_SERIAL_SEC.getValue().equalsIgnoreCase(s.getSecType())
////                || CodeSecTypeEnum.CODE_ATTR_SEC.getValue().equalsIgnoreCase(s.getSecType())
////                || CodeSecTypeEnum.CODE_DATE_SEC.getValue().equalsIgnoreCase(s.getSecType())
////                || CodeSecTypeEnum.CODE_LEVEL_SEC.getValue().equalsIgnoreCase(s.getSecType())
////                || VciBaseUtil.getBoolean(s.getNullableFlag()))
////        ).map(CodeBasicSecVO::getOid).collect(Collectors.toList());
////        if (!CollectionUtils.isEmpty(unSerialSecOidList)) {
////            if (CollectionUtils.isEmpty(orderDTO.getSecDTOList())) {
////                throw new VciBaseException("非流水码段(或者必输码段）必须要输入(或选择)码值");
////            }
////            try {
////                hasCreatedCbos.put(btmName, createBusinessObject(btmName));
////            } catch (Exception e) {
////                logger.error("创建业务类型对象",e);
////                throw new VciBaseException(msgCodePrefix + "initBoError",new String[]{btmName});
////            if (orderDTO.getSecDTOList().stream().anyMatch(s -> !unSerialSecOidList.contains(s.getSecOid())
////                && StringUtils.isBlank(s.getSecValue()))) {
////                throw new VciBaseException("非流水码段(或者必输码段）必须要输入(或选择)码值");
////            }
////        }
////        ClientBusinessObject cbo = cloneClientBusinessObject(hasCreatedCbos.get(btmName));
//
//      QueryWrapper<CodeOsbtmtypeEntity> btmWrapper = new QueryWrapper<>();
//      btmWrapper.eq("ID",btmName);
//      CodeOsbtmtypeEntity btmTypeVO = codeOsbtmtypeMapper.selectOne(btmWrapper);
////        OsBtmTypeVO btmTypeVO = btmService.getBtmById(boName);
//      String userName = AuthUtil.getUser().getUserName();
//      CodeWupinEntity wupinEntity = new CodeWupinEntity();
//      wupinEntity.setOid(null);
////        bo.setRevisionid((new ObjectUtility()).getNewObjectID36());
////        bo.setNameoid((new ObjectUtility()).getNewObjectID36());
//      wupinEntity.setBtmname(btmName);
//      wupinEntity.setLastR(String.valueOf(1));
//      wupinEntity.setFirstR(String.valueOf(1));
//      wupinEntity.setFirstV(String.valueOf(1));
//      wupinEntity.setLastV(String.valueOf(1));
//      wupinEntity.setCreator(userName);
//      wupinEntity.setCreateTime(new Date());
//      wupinEntity.setLastModifier(userName);
//      wupinEntity.setLastModifyTime(new Date());
//      wupinEntity.setRevisionRule(btmTypeVO.getRevisionruleid());
//      wupinEntity.setVersionRule(String.valueOf(btmTypeVO.getVersionRule()));
//      if(StringUtils.isNotBlank(btmTypeVO.getRevisionruleid())){
//          //插个点，需要问勇哥版本问题，展示默认为1
////            OsRevisionRuleVO revisionRuleVO = revisionRuleService.getRevisionRuleById(btmTypeVO.getRevisionruleid());
//          wupinEntity.setRevisionValue("1");
//      }
//
//      wupinEntity.setRevisionSeq(1);
//      wupinEntity.setVersionSeq(1);
//      //插个点，需要问勇哥版本问题，展示默认为1
//      wupinEntity.setVersionValue("1");
//      wupinEntity.setLctid("wupinLC");
//      wupinEntity.setLcStatus("Editing");
//      wupinEntity.setId("");
//      wupinEntity.setName("");
//      wupinEntity.setDescription("");
//      wupinEntity.setOwner(userName);
//      wupinEntity.setCheckinby(userName);
//      wupinEntity.setCopyFromVersion("");
//      wupinEntity.setMaterialtype((short) 1001);
//      wupinEntity.setCaigouwl("true");
//      wupinEntity.setShifoupihaoguanli("true");
//      wupinEntity.setKucunwl("true");
//      wupinEntity.setXiaoshouwl("false");
//      wupinEntity.setPassing("true");
//
////        this.initTypeAttributeValue(wupinEntity,btmTypeVO);
//      return wupinEntity;
//
//
////        return cbo;
//  }
//
//  /**
//   * 是否为修改忽略的属性
//   * @param attrName 属性的名字
//   * @return true 表示应该忽略
//   */
//  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));
//  }
//
//  /**
//   * 保存可输可选的信息
//   *
//   * @param templateVO 模板的对象
//   * @param cboList    数据的内容
//   */
//  @Override
//  public void batchSaveSelectChar(CodeClstemplateVO templateVO, /*List<ClientBusinessObject> cboList*/
//                                  List<String> cboList) {
//      if (templateVO != null && !CollectionUtils.isEmpty(cboList)) {
//          //是异步的，所以直接循环
//          List<CodeClstempattrVO> selectAttrVOs = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getLibraryidentification())).collect(Collectors.toList());
//
//          if (!CollectionUtils.isEmpty(selectAttrVOs)) {
////                SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
//              selectAttrVOs.parallelStream().forEach(attrVO -> {
//                  List<String> valuesList = cboList;
////                    cboList.parallelStream().forEach(cbo -> {
////                        String value = cbo.get.getAttributeValue(attrVO.getId());
////                        if (StringUtils.isNotBlank(value)) {
////                            valuesList.add(value);
////                        }
////                    });
//                  if (!CollectionUtils.isEmpty(valuesList)) {
//                      for (String s : valuesList) {
//                          DictBiz dictBiz = new DictBiz();
//                          dictBiz.setCode(templateVO.getBtmTypeId());
//                          dictBiz.setDictKey(s);
//                          dictBiz.setDictValue(s);
//                          //从原来的charService（可输可选）更改为调用omd中的接口来实现
//                          iDictBizClient.getCheck(dictBiz);
//                      }
////                        charService.saveBySameNamespaceAndFlag(templateVO.getBtmTypeId(), attrVO.getLibraryIdentification(), valuesList, sessionInfo);
//                  }
//              });
//          }
//      }
//  }
//
//    @Override
//    public MdmUIInfoVO getFormDefineByTemplateOid(String templateOid, String codeClassifyOid) {
//      CodeClstemplateVO templateVO = templateService.getObjectHasAttrByOid(templateOid);
//      MdmUIInfoVO uiInfoVO = new MdmUIInfoVO();
//      uiInfoVO.setTemplateVO(templateVO);
//      uiInfoVO.setFormDefineVO(wrapperFormDefineByTemplate(templateVO, codeClassifyOid));
//      wrapperResemble(templateVO, uiInfoVO);
//      return uiInfoVO;
//    }
//
//
//  /**
//   * 模板属性转换为表单定义的信息
//   *
//   * @param templateVO      模板的显示对象
//   * @param codeClassifyOid 分类的主键，为空的时候，获取模板所属的分类主键.用于产生分类注入
//   * @return 表格的信息
//   */
//  private UIFormDefineVO wrapperFormDefineByTemplate(CodeClstemplateVO templateVO, String codeClassifyOid) {
//      UIFormDefineVO formDefineVO = new UIFormDefineVO();
//      formDefineVO.setOid(templateVO.getOid());
//      formDefineVO.setBtmType(templateVO.getBtmTypeId());
//      if (StringUtils.isBlank(codeClassifyOid)) {
//          codeClassifyOid = templateVO.getCodeClassifyOid();
//      }
//      CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyOid);
//
//      List<UIFormItemVO> itemVOS = new ArrayList<>();
//      Map<String, List<CodeClstempattrVO>> attrGroupMap = templateVO.getAttributes().stream().
//          filter(s -> StringUtils.isNotBlank(s.getAttributegroup())).collect(Collectors.groupingBy(s -> s.getAttributegroup()));
//
//      templateVO.getAttributes().forEach(attrVO -> {
//          UIFormItemVO formItemVO = templateAttr2FormField(attrVO, templateVO.getBtmTypeId());
//          itemVOS.add(formItemVO);
//      });
//      //处理属性分组
//      if (!CollectionUtils.isEmpty(attrGroupMap)) {
//          //按照分组的属性排列，找到每一个分组的第一个属性
//          for (String key : attrGroupMap.keySet()) {
//              List<CodeClstempattrVO> value = attrGroupMap.get(key);
//              //找到这个分组的属性的第一个
//              CodeClstempattrVO attrVO = value.stream().sorted(((o1, o2) -> o1.getOrdernum().compareTo(o2.getOrdernum()))).findFirst().get();
//              //我们找到这个属性在最终的itemVOs里的位置
//              UIFormItemVO lineVO = new UIFormItemVO();
//              lineVO.setField(attrVO.getId() + "_line");
//              lineVO.setType("line");
//              lineVO.setText(key);
//              //找位置
//              for (int i = 0; i < itemVOS.size(); i++) {
//                  UIFormItemVO record = itemVOS.get(i);
//                  if (record.getField().equalsIgnoreCase(attrVO.getId())) {
//                      itemVOS.add(i, lineVO);
//                      break;
//                  }
//              }
//          }
//      }
//
//      CodeOrderDTO orderDTO = new CodeOrderDTO();
//      switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO);
//      if (!CollectionUtils.isEmpty(orderDTO.getData())) {
//          orderDTO.getData().forEach((key, value) -> {
//              for (int i = 0; i < itemVOS.size(); i++) {
//                  UIFormItemVO itemVO = itemVOS.get(i);
//                  if (itemVO.getField().equalsIgnoreCase(key)) {
//                      itemVO.setDefaultValue(value);
//                      break;
//                  }
//              }
//          });
//      }
//      formDefineVO.setItems(itemVOS);
//      //查询是否有分类注入的
//      return formDefineVO;
//  }
//  /**
//   * 属性类型与js中的字段类型的映射
//   */
//  private static Map<String, String> vciFieldTypeMap = new HashMap<String, String>() {{
//      put(VciFieldTypeEnum.VTString.name(), "text");
//      put(VciFieldTypeEnum.VTInteger.name(), "text");
//      put(VciFieldTypeEnum.VTLong.name(), "text");
//      put(VciFieldTypeEnum.VTDouble.name(), "text");
//      put(VciFieldTypeEnum.VTClob.name(), "text");
//      put(VciFieldTypeEnum.VTBoolean.name(), "truefalse");
//      put(VciFieldTypeEnum.VTDateTime.name(), "datetime");
//      put(VciFieldTypeEnum.VTDate.name(), "datetime");
//      put(VciFieldTypeEnum.VTTime.name(), "datetime");
//      put(VciFieldTypeEnum.VTFilePath.name(), "file");
//  }};
//
//  /**
//   * 模板属性转换为表单的字段
//   *
//   * @param attrVO  模板属性
//   * @param btmType 业务类型
//   * @return 表单的字段
//   */
//  @Override
//  public UIFormItemVO templateAttr2FormField(CodeClstempattrVO attrVO, String btmType) {
//
//      UIFormItemVO itemVO = new UIFormItemVO();
//      if (SECRET_FILED.equalsIgnoreCase(attrVO.getId())) {
////            attrVO.setEnumid(OsEnumServiceImpl.MY_DATA_SECRET);
//          attrVO.setEnumid(MY_DATA_SECRET);
//      }
//      itemVO.setField(attrVO.getId());
//      itemVO.setText(attrVO.getName());
//      itemVO.setType(vciFieldTypeMap.getOrDefault(attrVO.getAttributedatatype(), "text"));
//      if (VciBaseUtil.getBoolean(attrVO.getTextareaflag())) {
//          itemVO.setType("textarea");
//      }
//      if (VciFieldTypeEnum.VTLong.name().equalsIgnoreCase(attrVO.getAttributedatatype())
//          || VciFieldTypeEnum.VTInteger.name().equalsIgnoreCase(attrVO.getAttributedatatype())
//          || VciFieldTypeEnum.VTDouble.name().equalsIgnoreCase(attrVO.getAttributedatatype())) {
//          itemVO.setVerify("number");
//      }
//      itemVO.setReadOnly(VciBaseUtil.getBoolean(attrVO.getReadonlyflag()));
//      itemVO.setKeyAttr(VciBaseUtil.getBoolean(attrVO.getKeyattrflag()));
//      itemVO.setRequired(VciBaseUtil.getBoolean(attrVO.getRequireflag()));
//      itemVO.setDefaultValue(attrVO.getDefaultvalue());
//      itemVO.setDateFormate(attrVO.getCodedateformat());
//      itemVO.setHidden(!VciBaseUtil.getBoolean(attrVO.getFormdisplayflag()));
//      itemVO.setVerify(attrVO.getVerifyrule());
//      itemVO.setPrefix(attrVO.getPrefixvalue());
//      itemVO.setSuffix(attrVO.getSuffixvalue());
//      itemVO.setTooltips(attrVO.getExplain());
//      itemVO.setSelectLibFlag(attrVO.getLibraryidentification());
//      //看看是否有枚举
//      if ((StringUtils.isNotBlank(attrVO.getEnumstring())
//          && !"[]".equalsIgnoreCase(attrVO.getEnumstring())) ||
//          StringUtils.isNotBlank(attrVO.getEnumid())) {
//          itemVO.setType("combox");
//          itemVO.setComboxKey(attrVO.getEnumid());
//          if (StringUtils.isNotBlank(attrVO.getEnumstring())) {
//              //指定的下拉框内容
//              itemVO.setData(JSONObject.parseArray(attrVO.getEnumstring(), KeyValue.class));
//              if (StringUtils.isBlank(attrVO.getEnumid())) {
//                  itemVO.setComboxKey(itemVO.getField() + "_data");
//              }
//          }
//      }
//      //看是否有参照
//      if (StringUtils.isNotBlank(attrVO.getReferbtmid()) || StringUtils.isNotBlank(attrVO.getReferconfig())) {
//          itemVO.setType("refer");
//          itemVO.setShowField(itemVO.getField() + "name");
//          if (StringUtils.isNotBlank(attrVO.getReferconfig())) {
//              //配置的内容
//              itemVO.setReferConfig(JSONObject.parseObject(attrVO.getReferconfig(), UIFormReferVO.class));
//          } else {
//              UIFormReferVO formReferVO = new UIFormReferVO();
//              formReferVO.setType("default");
//              formReferVO.setReferType(attrVO.getReferbtmid());
//              itemVO.setReferConfig(formReferVO);
//          }
//      }
//
//      //如果是组合规则，分类注入的，显示为只读
//      if (StringUtils.isNotBlank(attrVO.getComponentrule())) {
//          itemVO.setReadOnly(true);
//          itemVO.setTooltips("本属性为组合规则");
//          itemVO.setRequired(false);
//      }
//      if (StringUtils.isNotBlank(attrVO.getClassifyinvokeattr())) {
//          itemVO.setReadOnly(!VciBaseUtil.getBoolean(attrVO.getClassifyinvokeeditflag()));
//          itemVO.setTooltips("本属性是分类注入");
//          itemVO.setRequired(false);
//      }
//
//      if (VciQueryWrapperForDO.LC_STATUS_FIELD.equalsIgnoreCase(itemVO.getField())) {
//          //是生命周期状态
//          itemVO.setType("combox");
//          itemVO.setComboxKey(btmType + LC_STATUS_SUBFIX);
//      }
//      return itemVO;
//  }
//
//
//  /**
//   * 封装相似项查询的列表
//   *
//   * @param templateVO 模板的显示对象
//   * @param uiInfoVO   页面的信息
//   */
//  private void wrapperResemble(CodeClstemplateVO templateVO, MdmUIInfoVO uiInfoVO) {
//      List<CodeClstempattrVO> resembleAttrList = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getSamerepeatattrflag())
//          || VciQueryWrapperForDO.ID_FIELD.equalsIgnoreCase(s.getId())).collect(Collectors.toList());
//      if (!CollectionUtils.isEmpty(resembleAttrList) && resembleAttrList.size() > 1) {
//          UITableDefineVO resembleTable = new UITableDefineVO();
//          resembleTable.setOid(templateVO.getOid());
//          resembleTable.setBtmType(templateVO.getBtmTypeId());
//          resembleTable.setDisplayQueryArea(false);
//          resembleTable.setPageVO(new UITablePageVO());
//          //处理所有的列，这个模板没有合并的表头的情况
//          List<UITableFieldVO> fieldVOList = new ArrayList<>();
//          resembleAttrList.forEach(attrVO -> {
//              UITableFieldVO tableFieldVO = templateAttr2TableField(attrVO,false);
//              tableFieldVO.setHidden(false);
//              fieldVOList.add(tableFieldVO);
//          });
//          List<List<UITableFieldVO>> cols = new ArrayList<>();
//          cols.add(fieldVOList);
//          resembleTable.setCols(cols);
//          uiInfoVO.setResembleTableVO(resembleTable);
//      }
//  }
//
//
//  /**
//   * 模板属性转换为表格显示的配置
//   *
//   * @param attrVO 模板属性
//   * @param forEdit 是否是编辑所需
//   * @return 表格的字段
//   */
//  @Override
//  public UITableFieldVO templateAttr2TableField(CodeClstempattrVO attrVO,boolean forEdit) {
//      UITableFieldVO fieldVO = new UITableFieldVO();
//      if (SECRET_FILED.equalsIgnoreCase(attrVO.getId())) {
//          attrVO.setEnumid(MY_DATA_SECRET);
//      }
//      fieldVO.setField(attrVO.getId());
//      fieldVO.setTitle(attrVO.getName());
//      fieldVO.setFieldType(vciFieldTypeMap.getOrDefault(attrVO.getAttributedatatype(), "text"));
//      fieldVO.setSort(true);
//      fieldVO.setSortField(fieldVO.getField());
//      fieldVO.setQueryField(fieldVO.getField());
//      if (forEdit){
//          fieldVO.setHidden(!VciBaseUtil.getBoolean(attrVO.getFormdisplayflag()));
//      }else {
//          fieldVO.setHidden(!VciBaseUtil.getBoolean(attrVO.getTabledisplayflag()));
//      }
//      if (attrVO.getAttrtablewidth() != null && attrVO.getAttrtablewidth() > 0) {
//          fieldVO.setMinWidth(Integer.valueOf(attrVO.getAttrtablewidth()));
//          fieldVO.setWidth(Integer.valueOf(attrVO.getAttrtablewidth()));
//      }
//      //看看是否有枚举
//      if ((StringUtils.isNotBlank(attrVO.getEnumstring())
//          && !"[]".equalsIgnoreCase(attrVO.getEnumstring())) ||
//          StringUtils.isNotBlank(attrVO.getEnumid())) {
//          fieldVO.setFieldType("combox");
//          fieldVO.setField(fieldVO.getField() + "Text");
//          fieldVO.setComboxKey(attrVO.getEnumid());
//          if (StringUtils.isNotBlank(attrVO.getEnumstring())) {
//              //指定的下拉框内容
//              fieldVO.setData(JSONObject.parseArray(attrVO.getEnumstring(), KeyValue.class));
//              if (StringUtils.isBlank(attrVO.getEnumid())) {
//                  fieldVO.setComboxKey(fieldVO.getField() + "_data");
//              }
//          }else {
//              List<KeyValue> osEnumItemVOList= enumService.getEnum(attrVO.getEnumid());
//              fieldVO.setData(osEnumItemVOList);
//          }
//      }
//      //看是否有参照
//      if (StringUtils.isNotBlank(attrVO.getReferbtmid()) || StringUtils.isNotBlank(attrVO.getReferconfig())) {
//          fieldVO.setFieldType("refer");
//          fieldVO.setQueryField(fieldVO.getField());
//          fieldVO.setField(fieldVO.getField() + "name");
//          fieldVO.setShowField(fieldVO.getField());
//          if (StringUtils.isNotBlank(attrVO.getReferconfig())) {
//              //配置的内容
//              fieldVO.setReferConfig(JSONObject.parseObject(attrVO.getReferconfig(), UIFormReferVO.class));
//          } else {
//              UIFormReferVO formReferVO = new UIFormReferVO();
//              formReferVO.setType("default");
//              formReferVO.setReferType(attrVO.getReferbtmid());
//              fieldVO.setReferConfig(formReferVO);
//          }
//      }
//      if (VciQueryWrapperForDO.LC_STATUS_FIELD.equalsIgnoreCase(fieldVO.getSortField())) {
//          fieldVO.setField("lcstatus_text");
//      }
//      Map<String, String> eventJsMap = new HashMap<>();
//      //超链接与模板是互斥
//      if (StringUtils.isNotBlank(attrVO.getTablehref())) {
//          String event = fieldVO.getSortField() + "_href";
//          eventJsMap.put(event, attrVO.getTablehref());
//          fieldVO.setTemplet("function(d){ return '<a class=\"layui-btn layui-btn-intable \" lay-event=\"" + event + "\">d." + fieldVO.getField() + "</a>';}");
//      }
//      if (StringUtils.isNotBlank(attrVO.getTabledisplayjs())) {
//          //直接写function(d){ return xxxxx;}
//          fieldVO.setTemplet(attrVO.getTabledisplayjs());
//      }
//      if (StringUtils.isBlank(fieldVO.getTemplet()) && VciFieldTypeEnum.VTBoolean.name().equalsIgnoreCase(attrVO.getAttributedatatype())) {
//          fieldVO.setTemplet("function(d){return $webUtil.formateBoolean(d." + fieldVO.getField() + ");}");
//      }
//      fieldVO.setOptionJsMap(eventJsMap);
//      fieldVO.setStyle(attrVO.getTabledisplaystyle());
//      //列表里不允许直接编辑
//      fieldVO.setDateFormate(attrVO.getCodedateformat());
//      return fieldVO;
//  }
//
//
//  /**
//   * 相似项查询
//   *
//   * @param orderDTO 编码的相关信息
//   * @return 数据列表
//   */
//  @Override
//  public DataGrid<Map<String, String>> resembleQuery(CodeOrderDTO orderDTO) {
//      VciBaseUtil.alertNotNull(orderDTO, "申请的信息", orderDTO.getCodeClassifyOid(), "分类主键", orderDTO.getTemplateOid(), "模板主键");
//      CodeClassifyFullInfoBO fullInfoBO = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
//      CodeClassifyTemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
//      switchClassifyLevelOnOrder(templateVO, fullInfoBO, orderDTO);
//      switchDateAttrOnOrder(templateVO, orderDTO);
//      switchComponentAttrOnOrder(templateVO, orderDTO);
//      //需要获取是否有相似查询属性
//      Map<String, CodeClassifyTemplateAttrVO> attrVOs = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getSamerepeatattrflag())).collect(Collectors.toMap(s -> s.getId(), t -> t));
//      if (CollectionUtils.isEmpty(attrVOs)) {
//          //都没有属性，肯定不能查询了
//          return new DataGrid<>();
//      }
//      Map<String, String> conditionMap = new HashMap<>();
//      //我们首先获取有没有查询规则
//      CodeResembleRuleVO resembleRuleVO = Optional.ofNullable(getUseResembleRule(fullInfoBO, fullInfoBO.getCurrentClassifyVO())).orElseGet(() -> new CodeResembleRuleVO());
//      attrVOs.forEach((attrId, attrVO) -> {
//          String value = getValueFromOrderDTO(orderDTO, attrId);
//          if (value == null) {
//              value = "";
//          }
//          wrapperResembleConditionMap(value, resembleRuleVO, attrId, conditionMap);
//      });
//
//      //没有限制分类，但是一个模板只可能在一个业务类型里面，所以直接查询这个业务类型即可
//      if (!CollectionUtils.isEmpty(conditionMap)) {
//          Map<String, String> andConditionMap = new HashMap<>();
//          andConditionMap.put("islastr", "1");
//          andConditionMap.put("islastv", "1");
//          if (StringUtils.isNotBlank(orderDTO.getOid())) {
//              andConditionMap.put("oid", QueryOptionConstant.NOTEQUAL + orderDTO.getOid());
//          }
//          conditionMap.putAll(andConditionMap);
//          PageHelper pageHelper = new PageHelper(-1);
//          pageHelper.addDefaultDesc("id");
//          return queryGrid(fullInfoBO.getTopClassifyVO().getBtmtypeid(), templateVO, conditionMap, pageHelper);
//      }
//      return new DataGrid<>();
//  }
//
//  /**
//   * 获取使用的相似查询规则
//   *
//   * @param fullInfoBO        类全部信息
//   * @param currentClassifyVO 当前的分类
//   * @return 规则，如果不存在会返回Null
//   */
//  @Override
//  public CodeResembleRuleVO getUseResembleRule(CodeClassifyFullInfoBO fullInfoBO, CodeClassifyVO currentClassifyVO) {
//      if (currentClassifyVO == null) {
//          return null;
//      }
//      if (currentClassifyVO != null && StringUtils.isNotBlank(currentClassifyVO.getCodeResembleRuleOid())) {
//          //说明已经存在
//          return resembleRuleService.getObjectByOid(currentClassifyVO.getCodeResembleRuleOid());
//      }
//      if (StringUtils.isBlank(currentClassifyVO.getParentcodeclassifyoid())) {
//          return null;
//      }
//      Map<String, CodeClassifyVO> classifyVOMap = fullInfoBO.getParentClassifyVOs().stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
//      return getUseResembleRule(fullInfoBO, classifyVOMap.getOrDefault(currentClassifyVO.getParentcodeclassifyoid(), null));
//  }
//
//  /**
//   * 封装相似项查询的查询条件的映射
//   *
//   * @param value          值
//   * @param resembleRuleVO 相似项规则
//   * @param attrId         属性的编号
//   * @param conditionMap   查询条件
//   */
//  @Override
//  public void wrapperResembleConditionMap(String value, CodeResembleRuleVO resembleRuleVO, String attrId, Map<String, String> conditionMap) {
//      boolean ignoreSpace = VciBaseUtil.getBoolean(resembleRuleVO.getIgnorespaceflag()) || VciBaseUtil.getBoolean(resembleRuleVO.getIgnoreallspaceflag());
//      if (StringUtils.isBlank(value)) {
//          //为空的时候就不查询它就是
//      } else {
//          String queryKey = "";
//          String queryValue = "";
//          boolean ignoreCase = VciBaseUtil.getBoolean(resembleRuleVO.getIgnorecaseflag());
//          boolean ignoreWidth = VciBaseUtil.getBoolean(resembleRuleVO.getIgnorewidthflag());
//          boolean trimAll = VciBaseUtil.getBoolean(resembleRuleVO.getIgnoreallspaceflag());
//          boolean trim = VciBaseUtil.getBoolean(resembleRuleVO.getIgnoreallspaceflag());
//          String temp = "";
//          if (ignoreCase && ignoreSpace && ignoreWidth) {
//              //忽略大小写，且去空，忽略全半角
//              temp = (trimAll ? "REPLACE" : "TRIM") + "(UPPER(to_single_byte('%s')) " + (trimAll ? ",' ','')" : ")");
//          } else if (ignoreCase && ignoreSpace && !ignoreWidth) {
//              //忽略大小写、去空、不忽略全半角
//              temp = (trimAll ? "REPLACE" : "TRIM") + "(UPPER(%s) " + (trimAll ? ",' ','')" : ")");
//          } else if (ignoreCase && !ignoreSpace && ignoreWidth) {
//              //忽略大小写、不去空、忽略全半角
//              temp = "UPPER(to_single_byte('%s'))";
//          } else if (!ignoreCase && ignoreSpace && ignoreWidth) {
//              //不忽略大小写、去空、忽略全半角
//              temp = (trimAll ? "REPLACE" : "TRIM") + "(to_single_byte('%s') " + (trimAll ? ",' ','')" : ")");
//          } else if (ignoreCase && !ignoreSpace && !ignoreWidth) {
//              //忽略大小写、不去空、不忽略全半角
//              temp = "UPPER(%s)";
//          } else if (!ignoreCase && !ignoreCase && ignoreWidth) {
//              //不忽略大小写、不去空、忽略全半角
//              temp = "to_single_byte('%s')";
//          } else if (!ignoreCase && ignoreSpace && !ignoreWidth) {
//              //不忽略大小写、去空、不忽略全半角
//              temp = (trimAll ? "REPLACE" : "TRIM") + "(%s " + (trimAll ? ",' ','')" : ")");
//          } else if (!ignoreCase && !ignoreSpace && !ignoreWidth) {
//              //不忽略大小写、不去空、不忽略全半角
//              temp = "%s";
//          }
//          if (StringUtils.isNotBlank(resembleRuleVO.getLinkCharacter())) {
//              List<String> chars = VciBaseUtil.str2List(resembleRuleVO.getLinkCharacter());
//              for (int i = 0; i < chars.size(); i++) {
//                  String s = chars.get(i);
//                  temp = "replace(" + temp + ",'" + s + "','')";
//              }
//          }
//          queryValue = String.format(temp, (trim ? value.trim() : value));
//          temp = temp.replace("to_single_byte('%s')","to_single_byte(%s)");
//          queryKey = String.format(temp, "t."+attrId);
//          conditionMap.put(queryKey, QueryOptionConstant.OR + queryValue);
//      }
//  }
//
//
//  /**
//   * 查询编码数据的列表
//   *
//   * @param btmType      业务类型
//   * @param templateVO   模板的对象，需要包含模板的属性
//   * @param conditionMap 查询条件
//   * @param pageHelper   分页对象
//   * @return 数据列表
//   */
//  @Override
//  public DataGrid<Map<String, String>> queryGrid(String btmType, CodeClassifyTemplateVO templateVO, Map<String, String> conditionMap, PageHelper pageHelper) {
//      CodeTemplateAttrSqlBO sqlBO = getSqlByTemplateVO(btmType, templateVO, conditionMap, pageHelper);
////        List<Map> maps = boService.queryByOnlySqlForMap(sqlBO.getSqlHasPage());
//      List<Map> maps = commonsMapper.selectBySql(sqlBO.getSqlHasPage());
//      DataGrid<Map<String, String>> dataGrid = new DataGrid<>();
//      List<Map<String, String>> dataList = new ArrayList<>();
//      if (!CollectionUtils.isEmpty(maps)) {
//          maps.stream().forEach(map -> {
//              Map<String, String> data = new HashMap<>();
//              map.forEach((key, value) -> {
//                  data.put(((String) key).toLowerCase(Locale.ROOT), (String) value);
//              });
//              dataList.add(data);
//          });
//      }
//      dataGrid.setData(dataList);
//      if (!CollectionUtils.isEmpty(dataList)) {
//          wrapperData(dataGrid.getData(), templateVO, sqlBO.getSelectFieldList(), false);
//          dataGrid.setTotal(Long.parseLong(commonsMapper.selectBySql(sqlBO.getSqlCount()).get(0).values().toArray()[0].toString()););
//      }
//      return dataGrid;
//  }
//
//
//  /**
//   * 封装查询出来的数据
//   *
//   * @param dataMap              数据的映射
//   * @param templateVO           模板的属性
//   * @param onlySelectAttrIdList 仅仅查询的属性字段
//   * @param form 表单里使用
//   */
//  @Override
//  public void wrapperData(List<Map<String, String>> dataMap, CodeClassifyTemplateVO templateVO,
//                          Collection<String> onlySelectAttrIdList, boolean form) {
//      if (onlySelectAttrIdList == null) {
//          onlySelectAttrIdList = new ArrayList<>();
//      }
//      //先转换一下时间格式
//      List<String> finalOnlySelectAttrIdList = onlySelectAttrIdList.stream().collect(Collectors.toList());
//      List<CodeClassifyTemplateAttrVO> dateFormatAttrVOs = templateVO.getAttributes().stream().filter(
//          s -> StringUtils.isNotBlank(s.getCodeDateFormat()) &&
//              (finalOnlySelectAttrIdList.size() == 0 || finalOnlySelectAttrIdList.contains(s.getId().toLowerCase(Locale.ROOT)))
//      ).collect(Collectors.toList());
//      //枚举的内容
//      List<CodeClassifyTemplateAttrVO> enumAttrVOs = templateVO.getAttributes().stream().filter(
//          s -> (StringUtils.isNotBlank(s.getEnumId()) || StringUtils.isNotBlank(s.getEnumString()))
//              &&
//              (finalOnlySelectAttrIdList.size() == 0 || finalOnlySelectAttrIdList.contains(s.getId().toLowerCase(Locale.ROOT)))
//      ).collect(Collectors.toList());
//
//      List<String> userIds = new ArrayList<>();
//      dataMap.stream().forEach(data -> {
//          //处理时间
//          if (!form) {
//              //表单的时候只能用统一的时间格式
//              wrapperDateFormat(dateFormatAttrVOs, data);
//          }
//          //处理枚举
//          wrapperEnum(enumAttrVOs, data);
//          String lcstatus = data.get(VciQueryWrapperForDO.LC_STATUS_FIELD);
//          String copyFromVersion = data.getOrDefault(COPY_FROM_VERSION,"");
//          if ((CodeDefaultLC.EDITING.getValue().equalsIgnoreCase(lcstatus) || CodeDefaultLC.AUDITING.getValue().equalsIgnoreCase(lcstatus))
//              && StringUtils.isBlank(copyFromVersion)
//          ) {
//              data.put(VciQueryWrapperForDO.ID_FIELD, "******");
//          }
//          data.put(VciQueryWrapperForDO.LC_STATUS_FIELD_TEXT.toLowerCase(Locale.ROOT), CodeDefaultLC.getTextByValue(lcstatus));
//          if(CodeDefaultLC.EDITING.getValue().equalsIgnoreCase(lcstatus)
//              && StringUtils.isNotBlank(copyFromVersion)){
//              data.put(VciQueryWrapperForDO.LC_STATUS_FIELD_TEXT.toLowerCase(Locale.ROOT), "修改中");
//          }
//          if (data.containsKey("creator")) {
//              userIds.add(data.get("creator"));
//          }
//          if (data.containsKey("lastmodifier")) {
//              userIds.add(data.get("lastmodifier"));
//          }
//      });
//      if (!CollectionUtils.isEmpty(userIds)) {
//          Map<String, SmUserVO> userVOMap = Optional.ofNullable(userQueryService.listUserByUserIds(userIds)).orElseGet(() -> new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
//          dataMap.stream().forEach(data -> {
//              String creator = data.getOrDefault("creator", null);
//              if (StringUtils.isNotBlank(creator) && userVOMap.containsKey(creator.toLowerCase(Locale.ROOT))) {
//                  data.put("creator", creator + "(" + userVOMap.get(creator.toLowerCase(Locale.ROOT)).getName() + ")");
//              }
//              String lastmodifier = data.getOrDefault("lastmodifier", null);
//              if (StringUtils.isNotBlank(lastmodifier) && userVOMap.containsKey(lastmodifier.toLowerCase(Locale.ROOT))) {
//                  data.put("lastmodifier", lastmodifier + "(" + userVOMap.get(lastmodifier.toLowerCase(Locale.ROOT)).getName() + ")");
//              }
//          });
//      }
//  }
//
//
//  /**
//   * 处理时间格式
//   *
//   * @param dateFormatAttrVOs 时间格式的属性
//   * @param data              当前行数据
//   */
//  private void wrapperDateFormat(Collection<CodeClassifyTemplateAttrVO> dateFormatAttrVOs, Map<String, String> data) {
//      if (!CollectionUtils.isEmpty(dateFormatAttrVOs)) {
//          dateFormatAttrVOs.stream().forEach(dateFormatAttrVO -> {
//              String attrId = dateFormatAttrVO.getId().toLowerCase(Locale.ROOT);
//              String oldValue = data.getOrDefault(attrId, null);
//              if (StringUtils.isNotBlank(oldValue)) {
//                  DateConverter dateConverter = new DateConverter();
//                  try {
//                      dateConverter.setAsText(oldValue);
//                      Date value = dateConverter.getValue();
//                      if (value != null) {
//                          data.put(attrId, VciDateUtil.date2Str(value, dateFormatAttrVO.getCodeDateFormat()));
//                      }
//                  } catch (Throwable e) {
//                      //转换可能有问题，这就使用原本存储的值
//                  }
//              }
//          });
//      }
//  }
//
//
//  /**
//   * 处理枚举的内容，如果不在枚举中，会返回原本的值
//   *
//   * @param enumAttrVOs 枚举属性
//   * @param data        当前行数据
//   */
//  private void wrapperEnum(Collection<CodeClassifyTemplateAttrVO> enumAttrVOs, Map<String, String> data) {
//      //处理枚举的内容，为了兼容以前的数据,如果数据不能使用枚举转换的话，那还是显示以前的值
//      if (!CollectionUtils.isEmpty(enumAttrVOs)) {
//          enumAttrVOs.stream().forEach(enumAttrVO -> {
//              String attrId = enumAttrVO.getId().toLowerCase(Locale.ROOT);
//              String oldValue = data.getOrDefault(attrId, null);
//              if (StringUtils.isNotBlank(oldValue)) {
//                  List<KeyValue> comboxKVs = listComboboxItems(enumAttrVO);
//                  String newValue = oldValue;
//                  KeyValue keyValue = Optional.ofNullable(comboxKVs).orElseGet(() -> new ArrayList<>()).stream().filter(s -> s.getKey().equalsIgnoreCase(oldValue)).findFirst().orElseGet(() -> null);
//                  if (keyValue != null) {
//                      newValue = keyValue.getValue();
//                  }
//                  data.put(attrId + "Text", newValue);
//              }
//          });
//      }
//  }
//
//
//  /**
//   * 根据模板属性生成相应的sql信息
//   *
//   * @param btmType      业务类型
//   * @param templateVO   模板显示对象，必须包含属性
//   * @param conditionMap 查询条件
//   * @param pageHelper   分页和排序对象
//   * @return sql的相关信息
//   */
//  @Override
//  public CodeTemplateAttrSqlBO getSqlByTemplateVO(String btmType, CodeClassifyTemplateVO templateVO, Map<String, String> conditionMap, PageHelper pageHelper) {
//      //因为参照不一定是在平台的属性池里面设置，所以我们得需要自行处理
//      //参考VciQueryWrapper来处理
//      //1. 找到所有的字段，
//      Map<String, CodeClassifyTemplateAttrVO> attrVOMap = templateVO.getAttributes().stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
//      List<String> selectFieldList = attrVOMap.keySet().stream().collect(Collectors.toList());
//
//      //所有的参照的字段
//      Map<String/**属性字段**/, String> joinTableList = new ConcurrentHashMap<>();
//      List<CodeClassifyTemplateAttrVO> referAttrVOs = templateVO.getAttributes().stream().filter(
//          s -> StringUtils.isNotBlank(s.getReferBtmId()) || StringUtils.isNotBlank(s.getReferConfig())
//      ).collect(Collectors.toList());
//      Map<String/**参照的属性**/, String/**实际的字段**/> referFieldMap = new HashMap<>();
//      if (!CollectionUtils.isEmpty(referAttrVOs)) {
//          referAttrVOs.parallelStream().forEach(attrVO -> {
//              UIFormReferVO referVO = null;
//              if (StringUtils.isNotBlank(attrVO.getReferConfig())) {
//                  referVO = JSONObject.parseObject(attrVO.getReferConfig(), UIFormReferVO.class);
//              } else {
//                  referVO = new UIFormReferVO();
//                  referVO.setReferType(attrVO.getReferBtmId());
//                  referVO.setValueField(VciQueryWrapperForDO.OID_FIELD);
//                  referVO.setTextField("name");
//              }
//
//              String referTable = VciBaseUtil.getTableName(referVO.getReferType());
//              String referTableNick = attrVO.getId() + "0";
//              String left = " left join " + referTable + " " + referTableNick + " on " + referTableNick + "." + referVO.getValueField() + " =  t." + attrVO.getId();
//              joinTableList.put(attrVO.getId(), left);
//              String referShowField = attrVO.getId() + "Name";
//              List<String> textFields = VciBaseUtil.str2List(referVO.getTextField());
//              String showFieldInSource = "";
//              if (textFields.contains("name")) {
//                  showFieldInSource = "name";
//              } else {
//                  showFieldInSource = textFields.get(0);
//              }
//              referFieldMap.put(attrVO.getId(), referTableNick + "." + showFieldInSource);
//              selectFieldList.add(referTableNick + "." + showFieldInSource + " as " + referShowField);
//          });
//      }
//      Optional.ofNullable(attributeService.getDefaultAttributeVOMap()).orElseGet(() -> new HashMap<>()).keySet().stream().forEach(attrId -> {
//          if (!selectFieldList.contains(attrId) && !"secretgrade".equalsIgnoreCase(attrId)) {
//              selectFieldList.add(attrId);
//          }
//      });
//      if (!selectFieldList.contains(CODE_FIELD)) {
//          selectFieldList.add(CODE_FIELD);
//      }
//      if (!selectFieldList.contains(CODE_CLASSIFY_OID_FIELD)) {
//          selectFieldList.add(CODE_CLASSIFY_OID_FIELD);
//      }
//      if (!selectFieldList.contains(CODE_TEMPLATE_OID_FIELD)) {
//          selectFieldList.add(CODE_TEMPLATE_OID_FIELD);
//      }
//      if (!selectFieldList.contains(CODE_FULL_PATH_FILED)) {
//          selectFieldList.add(CODE_FULL_PATH_FILED);
//      }
//
//      //处理查询条件
//      //TODO 验证sql注入
//      List<String> andSql = new ArrayList<>();
//      List<String> orSql = new ArrayList<>();
//      if (!CollectionUtils.isEmpty(conditionMap)) {
//          Map<String, String> orConditionMap = new HashMap<>();
//          Map<String, String> andCondtionMap = new HashMap<>();
//          //先分离or的查询条件，另外当查询条件是空的时候也不查询
//          conditionMap.forEach((k, v) -> {
//              if (StringUtils.isNotBlank(v)) {
//                  if (v.startsWith(QueryOptionConstant.OR)) {
//                      orConditionMap.put(k, v.substring(QueryOptionConstant.OR.length()));
//                  } else {
//                      andCondtionMap.put(k, v);
//                  }
//              }
//          });
//
//          andCondtionMap.forEach((k, v) -> {
//              andSql.add(getConditionSql(k.toLowerCase(), v, referFieldMap, attrVOMap));
//          });
//          orConditionMap.forEach((k, v) -> {
//              orSql.add(getConditionSql(k.toLowerCase(), v, referFieldMap, attrVOMap));
//          });
//      }
//      //组合起来
//      StringBuilder andSb = new StringBuilder();
//      andSql.stream().forEach(s -> {
//          andSb.append(s).append(SPACE).append(QueryOptionConstant.AND).append(SPACE);
//      });
//
//      String andString = andSb.toString().trim();
//      String endWithSql = QueryOptionConstant.AND;
//      if (andString.endsWith(endWithSql)) {
//          andString = andString.substring(0, andString.length() - endWithSql.length());
//      }
//
//      String orString = orSql.stream().collect(Collectors.joining(" or "));
//      String whereSql = "";
//      if (StringUtils.isNotBlank(orString)) {
//          if (StringUtils.isBlank(andString)) {
//              andString = " 1 = 1 ";
//          }
//          whereSql = SPACE + "(" + SPACE + andString + SPACE + ") and (" + SPACE + orString + SPACE + ")" + SPACE;
//      } else {
//          whereSql = andString + SPACE;
//      }
//      if (attrVOMap.keySet().contains("secretgrade")) {
//          Integer userSecret = VciBaseUtil.getCurrentUserSecret();
//          if (userSecret == null || userSecret == 0) {
//              userSecret = secretService.getMinUserSecret();
//          }
//          whereSql += " and ( t.secretGrade <= " + userSecret + ") ";
//      }
//      String tableName = VciBaseUtil.getTableName(btmType);
//      String sql = "select " + selectFieldList.stream().map(s -> (s.contains(".") ? s : ("t." + s))).collect(Collectors.joining(","))
//          + " from " + tableName + SPACE + "t" + SPACE
//          + joinTableList.values().stream().collect(Collectors.joining(SPACE))
//          + (StringUtils.isBlank(whereSql) ? "" : " where ") + whereSql;
//      if (pageHelper == null) {
//          pageHelper = new PageHelper(-1);
//      }
//      //看看排序
//      String orderSql = pageHelper.getOrderSql("t");
//      sql += (orderSql == null ? "" : orderSql);
//      String whereSubfixForPage = " ) A where rownum < " + (pageHelper.getLimit() * pageHelper.getPage() + 1) + ") where RN >= "
//          + (pageHelper.getLimit() * (pageHelper.getPage() - 1) + 1);
//      String sqlHasPage = pageHelper.getLimit() > 0 ? ("select * from (select A.*,rownum RN from (" + sql + whereSubfixForPage) : sql;
//      String sqlCount = "select count(1) from " + tableName + SPACE + "t" + SPACE + joinTableList.values().stream().collect(Collectors.joining(SPACE))
//          + (StringUtils.isBlank(whereSql) ? "" : " where ") + whereSql;
//      CodeTemplateAttrSqlBO sqlBO = new CodeTemplateAttrSqlBO();
//      sqlBO.setTableName(tableName);
//      sqlBO.setJoinTable(joinTableList);
//      sqlBO.setNickName("t");
////        sqlBO.setPageHelper(pageHelper);
//      sqlBO.setSqlHasPage(sqlHasPage);
//      sqlBO.setSqlCount(sqlCount);
//      sqlBO.setSqlUnPage(sql);
//      return sqlBO;
//  }
//
//
//  /**
//   * 组合查询条件的sql
//   *
//   * @param key           字段
//   * @param value         名字
//   * @param referFieldMap 参照的字段
//   * @param attrVOMap     属性的映射
//   * @return Sql语句
//   */
//  private String getConditionSql(String key, String value, Map<String/**参照的属性**/, String/**实际的属性**/> referFieldMap, Map<String, CodeClassifyTemplateAttrVO> attrVOMap) {
//      if (key.endsWith("_begin")) {
//          //说明是>=的。我们需要先获取一下
//          String field = (key.substring(0, key.length() - 6).toLowerCase().trim());
//          if (referFieldMap.containsKey(field)) {
//              //说明还是参照里面的，我们默认这种情况下都是字符串吧，因为参照的属性不一定用的平台的属性池里的，所以大部分情况下，显示的属性都是字符串吧
//              return referFieldMap.get(field) + SPACE + " >= '" + value + "'" + SPACE;
//          } else {
//              return (field.contains(".") ? "" : "t.") + field + SPACE + " >= " + getStringValueInWhere(value, field, attrVOMap);
//          }
//      } else if (key.endsWith("_end")) {
//          //说明是<=的。我们需要先获取一下
//          String field = (key.substring(0, key.length() - 6).toLowerCase().trim());
//          if (referFieldMap.containsKey(field)) {
//              //说明还是参照里面的，我们默认这种情况下都是字符串吧，因为参照的属性不一定用的平台的属性池里的，所以大部分情况下，显示的属性都是字符串吧
//              return referFieldMap.get(field) + SPACE + " <= '" + value + "'" + SPACE;
//          } else {
//              return (field.contains(".") ? "" : "t.") + field + SPACE + " <= " + getStringValueInWhere(field, value, attrVOMap);
//          }
//      } else {
//          if (referFieldMap.containsKey(key)) {
//              //说明是参照的，我们参照的查询都认为是字符串，如果是时间格式的查询肯定有问题，
//              String selectKey = referFieldMap.get(key);
//              return getSqlByValue(selectKey, value, null);
//          } else {
//              return getSqlByValue(key, value, attrVOMap);
//          }
//      }
//
//  }
//
//  /**
//   * 获取查询条件中的值的，处理不同的类型
//   *
//   * @param value 值
//   * @param field 字段名称
//   * @return 日期或者时间格式会包括to_date，字符串会加'
//   */
//  private String getStringValueInWhere(String field, String value, Map<String, CodeClassifyTemplateAttrVO> attrVOMap) {
//      if ((field.contains(".") && !field.toLowerCase(Locale.ROOT).startsWith("t.")) || attrVOMap == null
//          || !field.replace("t.", "").matches(RegExpConstant.LETTER) || value.startsWith(ONLY)) {
//          //说明可能是指定的某个条件，直接返回
//          if (value.startsWith(ONLY)) {
//              value = value.replace(ONLY, "");
//          }
//          if ((value.startsWith("(") && value.endsWith(")")) || (value.startsWith("'") && value.endsWith("'"))) {
//              return value;
//          }
//          if (field.contains(".") && attrVOMap != null && attrVOMap.containsKey(field.split("\\.")[0].toLowerCase(Locale.ROOT))) {
//              //是参照
//              return "'" + value + "'";
//          } else {
//              return value;
//          }
//      } else {
//          //看看是不是这个对象里的属性
//          if (attrVOMap.containsKey(field)) {
//              VciFieldTypeEnum fieldTypeEnum = VciFieldTypeEnum.valueOf(attrVOMap.get(field).getAttributeDataType());
//              if ("ts".equalsIgnoreCase(field)) {
//                  return "to_timestamp('" + value + "', '" + DATETIME_FORMAT + ".ff')";
//              }
//              DateConverter dateConverter = new DateConverter();
//              if (VciFieldTypeEnum.VTDateTime.equals(fieldTypeEnum)) {
//                  //实际上，数据库都是timestamp的类型.
//                  dateConverter.setAsText(value);
//                  return "to_date('" + dateConverter.getAsText(VciDateUtil.DateTimeFormat) + "','" + DATETIME_FORMAT + "')";
//              } else if (VciFieldTypeEnum.VTDate.equals(fieldTypeEnum)) {
//                  dateConverter.setAsText(value);
//                  return "to_date('" + dateConverter.getAsText(VciDateUtil.DateFormat) + "','" + DATE_FORMAT + "')";
//              } else if (VciFieldTypeEnum.VTDouble.equals(fieldTypeEnum)
//                  || VciFieldTypeEnum.VTLong.equals(fieldTypeEnum)
//                  || VciFieldTypeEnum.VTInteger.equals(fieldTypeEnum)) {
//                  return value;
//              } else {
//                  return "'" + value + "'";
//              }
//          } else {
//              if ((value.startsWith("(") && value.endsWith(")")) || (value.startsWith("'") && value.endsWith("'"))) {
//                  return value;
//              }
//              return "'" + value + "'";
//          }
//      }
//
//  }
//
//  /**
//   * 封装最终的sql语句中的值部分
//   *
//   * @param selectKey 查询的字段
//   * @param value     值
//   * @param attrVOMap 属性的显示对象映射
//   * @return sql里的值
//   */
//  private String getSqlByValue(String selectKey, String value, Map<String, CodeClassifyTemplateAttrVO> attrVOMap) {
//      StringBuilder sql = new StringBuilder();
//      if (!selectKey.contains(".") && (attrVOMap.containsKey(selectKey.toLowerCase(Locale.ROOT)) || attributeService.isDefaultAttr(selectKey) || selectKey.matches(RegExpConstant.LETTER))) {
//          sql.append("t.");
//      }
//      if (value.startsWith(QueryOptionConstant.IN)) {
//          sql.append(selectKey)
//              .append(SPACE)
//              .append("in")
//              .append(SPACE)
//              .append("(")
//              .append(value.replace(QueryOptionConstant.IN, ""))
//              .append(")");
//      } else if (value.startsWith(QueryOptionConstant.NOTIN)) {
//          sql.append(selectKey)
//              .append(SPACE)
//              .append("not in")
//              .append(SPACE)
//              .append("(")
//              .append(value.replace(QueryOptionConstant.NOTIN, ""))
//              .append(")");
//      } else if (value.startsWith(QueryOptionConstant.NOTEQUAL)) {
//          value = value.replace(QueryOptionConstant.NOTEQUAL, "");
//          value = getStringValueInWhere(selectKey, value, attrVOMap);
//          sql.append(selectKey)
//              .append(SPACE)
//              .append(QueryOptionConstant.NOTEQUAL)
//              .append(SPACE)
//              .append(value);
//      } else if (value.startsWith(QueryOptionConstant.MORETHAN)) {
//          value = value.replace(QueryOptionConstant.MORETHAN, "");
//          value = getStringValueInWhere(selectKey, value, attrVOMap);
//          sql.append(selectKey)
//              .append(SPACE)
//              .append(QueryOptionConstant.MORETHAN)
//              .append(SPACE)
//              .append(value);
//      } else if (value.startsWith(QueryOptionConstant.MORE)) {
//          value = value.replace(QueryOptionConstant.MORE, "");
//          value = getStringValueInWhere(selectKey, value, attrVOMap);
//          sql.append(selectKey)
//              .append(SPACE)
//              .append(QueryOptionConstant.MORE)
//              .append(SPACE)
//              .append(value);
//      } else if (value.startsWith(QueryOptionConstant.LESSTHAN)) {
//          value = value.replace(QueryOptionConstant.LESSTHAN, "");
//          value = getStringValueInWhere(selectKey, value, attrVOMap);
//
//          sql.append(selectKey)
//              .append(SPACE)
//              .append(QueryOptionConstant.LESSTHAN)
//              .append(SPACE)
//              .append(value);
//      } else if (value.startsWith(QueryOptionConstant.LESS)) {
//          value = value.replace(QueryOptionConstant.LESS, "");
//          value = getStringValueInWhere(selectKey, value, attrVOMap);
//
//          sql.append(selectKey)
//              .append(SPACE)
//              .append(QueryOptionConstant.LESS)
//              .append(SPACE)
//              .append(value);
//      } else if (value.startsWith(QueryOptionConstant.ISNOTNULL)) {
//          sql.append(selectKey)
//              .append(SPACE)
//              .append(" is not null");
//      } else if (value.startsWith(QueryOptionConstant.ISNULL)) {
//          sql.append(selectKey)
//              .append(SPACE)
//              .append(" is null");
//      } else if (value.contains("*")) {
//          //说明是like，或者lefe like ,right like
//          value = getStringValueInWhere(selectKey, value, attrVOMap);
//          sql.append(selectKey)
//              .append(SPACE)
//              .append("like")
//              .append(SPACE)
//              //   .append("'")
//              .append(value.replace("*", "%"))
//              //  .append("'")
//              .append(SPACE);
//      } else {
//          value= value.replace(SPECIAL_CHAR,REQUIRED_CHAR);
//          value = getStringValueInWhere(selectKey, value, attrVOMap);
//
//          sql.append(selectKey)
//              .append(SPACE)
//              .append(QueryOptionConstant.EQUAL)
//              .append(SPACE)
//              .append(value);
//      }
//      sql.append(SPACE);
//      return sql.toString();
//  }
//
//  /**
//   * 修改主题库数据
//   *
//   * @param orderDTO 数据的内容，不用包含码段的内容了
//   */
//  @Override
//  public void editSaveCode(CodeOrderDTO orderDTO) {
//      VciBaseUtil.alertNotNull(orderDTO, "编码申请相关的属性的内容都为空", orderDTO.getOid(), "数据主键",
//          orderDTO.getCodeClassifyOid(), "主题库分类的主键");
////        CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
//      CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
//      //找业务类型，然后使用主键去获取数据库里的数据
////        List<ClientBusinessObject> cbos = boService.queryCBO(classifyFullInfo.getTopClassifyVO().getBtmtypeid(), WebUtil.getOidQuery(orderDTO.getOid()));
//
//      QueryWrapper<CodeOsbtmtypeEntity> btmWrapper = new QueryWrapper<>();
//      btmWrapper.eq("OID",orderDTO.getOid());
//      CodeWupinEntity cbo = codeOsbtmtypeMapper.selectOne(btmWrapper);
//
////        CodeClstemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
////        CodeRuleVO ruleVO = ruleService.getObjectHasSecByOid(orderDTO.getCodeRuleOid());
//
//      if (cbo != null) {
//          throw new VciBaseException(DATA_OID_NOT_EXIST);
//      }
////        ClientBusinessObject cbo = cbos.get(0);
//      if (!cbo.getTs().toString().contains(VciDateUtil.date2Str(orderDTO.getTs(), VciDateUtil.DateTimeFormat))) {
//          throw new VciBaseException("数据不是最新的，可能他人已经修改，请刷新后再试");
//      }
//      if (!CodeDefaultLC.EDITING.getValue().equalsIgnoreCase(cbo.getLcStatus()) && !orderDTO.isEditInProcess()) {
//          throw new VciBaseException("数据不是{0}的状态，不允许修改", new String[]{CodeDefaultLC.EDITING.getText()});
//      }
//
//      //注意模板不能使用数据存储的时候的模板，因为可能会变化
//
//      //1. 判断必输项
//      CodeClassifyTemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
//      checkRequiredAttrOnOrder(templateVO, orderDTO);
//      //2.先注入，再组合，最后校验
//      switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO);
//      //3.处理组合规则。组合规则不能使用编码的属性，因为编码的生成可能是需要属性的
//      switchComponentAttrOnOrder(templateVO, orderDTO);
//      //4.校验规则
//      checkVerifyOnOrder(templateVO, orderDTO);
//      //5.判断关键属性
//      checkKeyAttrOnOrder(classifyFullInfo, templateVO, orderDTO);
//      //6.校验枚举的内容是否正确
//      checkEnumOnOrder(templateVO, orderDTO);
//      //7.处理时间格式，在数据库里面不论是字符串还是日期格式，都使用相同的格式存储
//      switchDateAttrOnOrder(templateVO, orderDTO);
//      //默认的内容不能变，所以只需要拷贝自定义的相关属性即可
//      copyValueToCBO(classifyFullInfo, cbo, orderDTO, templateVO, true);
//      //企业码和集团码的不修改
//      cbo.setDescription(orderDTO.getDescription());
//      cbo.setName(orderDTO.getName());
//      try {
//          cbo.setDescription(orderDTO.getDescription());
//          cbo.setName(orderDTO.getName());
//////          cbo.setAttributeValueWithNoCheck("description", orderDTO.getDescription());
////            cbo.setAttributeValue("name", orderDTO.getName());
//      } catch (Exception e) {
//          e.printStackTrace();
//      }
//
//
//      List<CodeWupinEntity> cboList = new ArrayList<>();
//
//      //备注
//      cbo.setDescription(orderDTO.getDescription());
//      cboList.add(cbo);
////    }
////
////    /**
////     * 校验属性是否为必输
////     *
////     * @param templateVO 模板的显示对象，需要包含模板属性
////     * @param orderDTO   编码申请的信息
////     */
////    private void checkRequiredAttrOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) {
////        Map<String, CodeClstempattrVO> 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))) {
////                    throw new VciBaseException("属性【{0}】必须要输入(选择)内容", new String[]{attrVO.getName()});
////                }
////            });
////        }
////    }
////
////    /**
////     * 从编码申请信息对象上获取某个属性的值
////     *
////     * @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 orderDTO   编码申请的信息
////     */
////    private void switchComponentAttrOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) {
////        Map<String, CodeClstempattrVO> 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 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 templateVO 模板的信息，必须包含属性的内容
////     * @param orderDTO   编码申请的相关的信息
////     */
////    private void checkVerifyOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) {
////        Map<String, CodeClstempattrVO> 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())) {
////                    //校验正则表达式
////                    throw new VciBaseException("属性[{0}]的值不符合校验规则的要求", new String[]{attrVO.getName()});
////                }
////            });
////        }
////    }
////
////    /**
////     * 校验关键属性
////     *
////     * @param classifyFullInfo 分类的全部信息
////     * @param templateVO       模板的内容，必须包含模板属性
////     * @param orderDTO         编码申请的相关的信息
////     */
////    private void checkKeyAttrOnOrder(CodeClassifyFullInfoBO classifyFullInfo, CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) {
////        //先获取关键属性的规则，也利用继承的方式
////        CodeKeyattrrepeatVO keyRuleVO = keyRuleService.getRuleByClassifyFullInfo(classifyFullInfo);
////        //注意的是keyRuleVO可能为空，表示不使用规则控制
////        //获取所有的关键属性
////        Map<String, CodeClstempattrVO> 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 = "";
////            }
////            wrapperKeyAttrConditionMap(value, keyRuleVO, attrId, trim, ignoreCase, ignoreWidth, trimAll, conditionMap);
////        });
////
////        //没有限制分类，但是一个模板只可能在一个业务类型里面，所以直接查询这个业务类型即可
////
////        if (!CollectionUtils.isEmpty(conditionMap)) {
////            final String[] sql = {"select count(*) from " + VciBaseUtil.getTableName(classifyFullInfo.getTopClassifyVO().getBtmtypeid()) + " t 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 (boService.queryCountBySql(sql[0], new HashMap<>()) > 0) {
////            if (Integer.parseInt(commonsMapper.selectById(sql[0]).get(0)) > 0) {
////                String ruleInfoMsg = keyRuleVO == null ? "" : "查询规则：去除空格--{0},忽略大小写--{1},忽略全半角--{2},忽略全部空格--{3}";
////                String[] objs = new String[]{trim ? "是" : "否", ignoreCase ? "是" : "否", ignoreWidth ? "是" : "否", trimAll ? "是" : "否"};
////                throw new VciBaseException("根据您填写的关键属性的内容，结合关键属性查询规则，发现这个数据已经在系统中存在了。请修正!。" + ruleInfoMsg, objs);
////            }
////        }
////    }
////
////    /**
////     * 封装关键属性的查询语句
////     *
////     * @param value        当前的值
////     * @param keyRuleVO    关键属性的控制规则，可以为空
////     * @param attrId       属性的编号
////     * @param trim         是否去除空格
////     * @param ignoreCase   是否不区分大小写
////     * @param ignoreWidth  是否忽略全半角
////     * @param trimAll      是否忽略全部空格
////     * @param conditionMap 查询条件
////     */
////    @Override
////    public void wrapperKeyAttrConditionMap(String value, CodeKeyattrrepeatVO keyRuleVO, String attrId,
////                                           boolean trim, boolean ignoreCase, boolean ignoreWidth,
////                                           boolean trimAll, Map<String, String> conditionMap) {
////        boolean ignoreSpace = trim || trimAll;
////        if (StringUtils.isBlank(value)) {
////            //为空的时候，不能用QueryOperation.ISNULL，平台不知道啥时候不处理这种了
////            conditionMap.put("t."+attrId, "null");
////        } else {
////            if (keyRuleVO != null) {
////                String queryKey = "";
////                String queryValue = "";
////
////                String temp = "";
////                if (ignoreCase && ignoreSpace && ignoreWidth) {
////                    //忽略大小写，且去空，忽略全半角
////                    temp = (trimAll ? "REPLACE" : "TRIM") + "(UPPER(to_single_byte(%s)) " + (trimAll ? ",' ','')" : ")");
////                } else if (ignoreCase && ignoreSpace && !ignoreWidth) {
////                    //忽略大小写、去空、不忽略全半角
////                    temp = (trimAll ? "REPLACE" : "TRIM") + "(UPPER(%s) " + (trimAll ? ",' ','')" : ")");
////                } else if (ignoreCase && !ignoreSpace && ignoreWidth) {
////                    //忽略大小写、不去空、忽略全半角
////                    temp = "UPPER(to_single_byte(%s))";
////                } else if (!ignoreCase && ignoreSpace && ignoreWidth) {
////                    //不忽略大小写、去空、忽略全半角
////                    temp = (trimAll ? "REPLACE" : "TRIM") + "(to_single_byte(%s) " + (trimAll ? ",' ','')" : ")");
////                } else if (ignoreCase && !ignoreSpace && !ignoreWidth) {
////                    //忽略大小写、不去空、不忽略全半角
////                    temp = "UPPER(%s)";
////                } else if (!ignoreCase && !ignoreCase && ignoreWidth) {
////                    //不忽略大小写、不去空、忽略全半角
////                    temp = "to_single_byte(%s)";
////                } else if (!ignoreCase && ignoreSpace && !ignoreWidth) {
////                    //不忽略大小写、去空、不忽略全半角
////                    temp = (trimAll ? "REPLACE" : "TRIM") + "(%s " + (trimAll ? ",' ','')" : ")");
////                } else if (!ignoreCase && !ignoreSpace && !ignoreWidth) {
////                    //不忽略大小写、不去空、不忽略全半角
////                    temp = "%s";
////                }
////                queryKey = String.format(temp, "t."+attrId);
////                queryValue = String.format(temp, "'" + (trim ? value.trim() : value) + "'");
////                conditionMap.put(queryKey, queryValue);
////            } else {
////                //为空的时候不代表不校验，只是不去除相关的信息
////                conditionMap.put("t."+attrId, value);
////            }
////        }
////    }
////
////    /**
////     * 校验枚举的内容
////     *
////     * @param templateVO 模板的显示对象，需要包含属性
////     * @param orderDTO   编码申请的信息
////     */
////    private void checkEnumOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) {
////        //如果枚举可以修改，则不需要校验是否符合枚举的选项
////
////        Map<String, CodeClstempattrVO> 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)) {
////                    CodeClassifyTemplateAttrVO codeClassifyTemplateAttrVO = new CodeClassifyTemplateAttrVO();
////                    BeanUtils.copyProperties(attrVO,codeClassifyTemplateAttrVO);
////                    //有值才能校验
////                    List<KeyValue> comboboxKVs = listComboboxItems(codeClassifyTemplateAttrVO);
////                    if (!comboboxKVs.stream().anyMatch(s -> value.equalsIgnoreCase(s.getKey()))) {
////                        throw new VciBaseException("属性【{0}】的值不符合枚举的要求", new String[]{attrVO.getName()});
////                    }
////                }
////            });
////        }
////    }
////
////    /**
////     * 转换时间的格式
////     *
////     * @param templateVO 模板的显示对象，需要包含属性
////     * @param orderDTO   编码申请的信息
////     */
////    private void switchDateAttrOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) {
////        Map<String, CodeClstempattrVO> 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, CodeWupinEntity cbo,
////                                CodeOrderDTO orderDTO, CodeClstemplateVO templateVO,
////                                boolean edit) {
////        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();
////        }
////
//////      BeanUtils.
////        BeanUtils.copyProperties(orderDTO.getData(),cbo);
////        cbo.setMaterialtype(Short.valueOf("1001"));
//////      orderDTO.getData().forEach((key, value) -> {
//////          if (!edit || (!checkUnAttrUnEdit(key) &&
//////              !VciQueryWrapperForDO.LC_STATUS_FIELD.equalsIgnoreCase(key))) {
//////              try {
//////                  cbo.setAttributeValue(key, value);
//////              } catch (Exception e) {
//////                  logger.error("设置属性的值错误", e);
//////              }
//////          }
//////      });
////        try {
////
////            cbo.setCodeclsfid(classifyFullInfo.getCurrentClassifyVO().getOid());
////            cbo.setCodetemplateoid(templateVO.getOid());
////            cbo.setCodeclsfpath(fullPath);
//////          cbo.setMaterialclassify("model_type");
//////          cbo.setMaterialname(orderDTO.getData().get("materialname"));
//////          cbo.setShifoupihaoguanli("true");
//////          cbo.setKucunwl("true");
//////          cbo.setXiaoshouwl("false");
////            if (!edit && StringUtils.isBlank(orderDTO.getLcStatus())) {
////                //找生命周期的起始状态，插个点，看生命周期是否需要创建
////                if (StringUtils.isNotBlank(cbo.getLctid())) {
//////                  OsLifeCycleVO lifeCycleVO = lifeCycleService.getLifeCycleById(cbo.getLctid());
//////                  if (lifeCycleVO != null) {
//////                      cbo.setLcStatus("Editing");
////////                        cbo.setLcStatus(lifeCycleVO.getStartStatus());
//////                  } else {
////                        cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
//////                  }
////                } else {
////                    cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
////                }
////
////            }
////
////            int secret = VciBaseUtil.getInt(cbo.getSecretGrade().toString());
////            //插个点，后续看密级服务是否可用
//////          if (secret == 0 || !secretService.checkDataSecret(secret)) {
////            if (secret == 0 ) {
////                Integer userSecret = VciBaseUtil.getCurrentUserSecret();
//////              cbo.setAttributeValue(SECRET_FIELD, String.valueOf((userSecret == null || userSecret == 0) ? UserSecretEnum.NONE.getValue() : userSecret));
////                cbo.setSecretGrade(userSecret == null || userSecret == 0 ? UserSecretEnum.NONE.getValue() : userSecret);
////            }
////        } catch (Throwable e) {
////            logger.error("设置默认的属性的值错误", e);
////        }
////    }
////
////
////    /**
////     * 初始化业务类型
////     * --创建人默认为当前用户，如果需要修改，可以在获取后自行处理
////     * @param btmName 业务类型的名称，会自动变成小写
////     * @return CodeWupinEntity
////     * @throws VciBaseException 初始化出错的是会抛出异常
////     */
////    @Override
////    public CodeWupinEntity createCBOByBtmName(String btmName)
////        throws VciBaseException {
////        if(btmName!=null){
////            btmName = btmName.trim().toLowerCase();
////        }
////        String userid = AuthUtil.getUser().getUserName();
//////      if(!hasCreatedCbos.containsKey(btmName)){
//////          if(StringUtils.isEmpty(userid)){
//////              throw new VciBaseException(msgCodePrefix +"noHasUserid");
//////          }
//////          try {
//////              hasCreatedCbos.put(btmName, createBusinessObject(btmName));
//////          } catch (Exception e) {
//////              logger.error("创建业务类型对象",e);
//////              throw new VciBaseException(msgCodePrefix + "initBoError",new String[]{btmName});
//////          }
//////      }
//////      ClientBusinessObject cbo = cloneClientBusinessObject(hasCreatedCbos.get(btmName));
////
////        QueryWrapper<CodeOsbtmtypeEntity> btmWrapper = new QueryWrapper<>();
////        btmWrapper.eq("ID",btmName);
////        CodeOsbtmtypeEntity btmTypeVO = codeOsbtmtypeMapper.selectOne(btmWrapper);
//////      OsBtmTypeVO btmTypeVO = btmService.getBtmById(boName);
////        String userName = AuthUtil.getUser().getUserName();
////        CodeWupinEntity wupinEntity = new CodeWupinEntity();
////        wupinEntity.setOid(null);
//////      bo.setRevisionid((new ObjectUtility()).getNewObjectID36());
//////      bo.setNameoid((new ObjectUtility()).getNewObjectID36());
////        wupinEntity.setBtmname(btmName);
////        wupinEntity.setLastR(String.valueOf(1));
////        wupinEntity.setFirstR(String.valueOf(1));
////        wupinEntity.setFirstV(String.valueOf(1));
////        wupinEntity.setLastV(String.valueOf(1));
////        wupinEntity.setCreator(userName);
////        wupinEntity.setCreateTime(new Date());
////        wupinEntity.setLastModifier(userName);
////        wupinEntity.setLastModifyTime(new Date());
////        wupinEntity.setRevisionRule(btmTypeVO.getRevisionruleid());
////        wupinEntity.setVersionRule(String.valueOf(btmTypeVO.getVersionRule()));
////        if(StringUtils.isNotBlank(btmTypeVO.getRevisionruleid())){
////            //插个点，需要问勇哥版本问题，展示默认为1
//////          OsRevisionRuleVO revisionRuleVO = revisionRuleService.getRevisionRuleById(btmTypeVO.getRevisionruleid());
////            wupinEntity.setRevisionValue("1");
////        }
////
////        wupinEntity.setRevisionSeq(1);
////        wupinEntity.setVersionSeq(1);
////        //插个点，需要问勇哥版本问题，展示默认为1
////        wupinEntity.setVersionValue("1");
////        wupinEntity.setLctid("wupinLC");
////        wupinEntity.setLcStatus("Editing");
////        wupinEntity.setId("");
////        wupinEntity.setName("");
////        wupinEntity.setDescription("");
////        wupinEntity.setOwner(userName);
////        wupinEntity.setCheckinby(userName);
////        wupinEntity.setCopyFromVersion("");
////        wupinEntity.setMaterialtype((short) 1001);
////        wupinEntity.setCaigouwl("true");
////        wupinEntity.setShifoupihaoguanli("true");
////        wupinEntity.setKucunwl("true");
////        wupinEntity.setXiaoshouwl("false");
////        wupinEntity.setPassing("true");
////
//////      this.initTypeAttributeValue(wupinEntity,btmTypeVO);
////        return wupinEntity;
////
////
//////      return cbo;
////    }
////
////    /**
////     * 是否为修改忽略的属性
////     * @param attrName 属性的名字
////     * @return true 表示应该忽略
////     */
////    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));
////    }
////
////    /**
////     * 保存可输可选的信息
////     *
////     * @param templateVO 模板的对象
////     * @param cboList    数据的内容
////     */
////    @Override
////    public void batchSaveSelectChar(CodeClstemplateVO templateVO, /*List<ClientBusinessObject> cboList*/
////                                    List<String> cboList) {
////        if (templateVO != null && !CollectionUtils.isEmpty(cboList)) {
////            //是异步的，所以直接循环
////            List<CodeClstempattrVO> selectAttrVOs = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getLibraryidentification())).collect(Collectors.toList());
////
////            if (!CollectionUtils.isEmpty(selectAttrVOs)) {
//////              SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
////                selectAttrVOs.parallelStream().forEach(attrVO -> {
////                    List<String> valuesList = cboList;
//////                  cboList.parallelStream().forEach(cbo -> {
//////                      String value = cbo.get.getAttributeValue(attrVO.getId());
//////                      if (StringUtils.isNotBlank(value)) {
//////                          valuesList.add(value);
//////                      }
//////                  });
////                    if (!CollectionUtils.isEmpty(valuesList)) {
////                        for (String s : valuesList) {
////                            DictBiz dictBiz = new DictBiz();
////                            dictBiz.setCode(templateVO.getBtmTypeId());
////                            dictBiz.setDictKey(s);
////                            dictBiz.setDictValue(s);
////                            //从原来的charService（可输可选）更改为调用omd中的接口来实现
////                            iDictBizClient.getCheck(dictBiz);
////                        }
//////                      charService.saveBySameNamespaceAndFlag(templateVO.getBtmTypeId(), attrVO.getLibraryIdentification(), valuesList, sessionInfo);
////                    }
////                });
////            }
////        }
////    }
////
////    @Override
////    public MdmUIInfoVO getFormDefineByTemplateOid(String templateOid, String codeClassifyOid) {
////        CodeClstemplateVO templateVO = templateService.getObjectHasAttrByOid(templateOid);
////        MdmUIInfoVO uiInfoVO = new MdmUIInfoVO();
////        uiInfoVO.setTemplateVO(templateVO);
////        uiInfoVO.setFormDefineVO(wrapperFormDefineByTemplate(templateVO, codeClassifyOid));
////        wrapperResemble(templateVO, uiInfoVO);
////        return uiInfoVO;
////    }
////
////
////    /**
////     * 模板属性转换为表单定义的信息
////     *
////     * @param templateVO      模板的显示对象
////     * @param codeClassifyOid 分类的主键，为空的时候，获取模板所属的分类主键.用于产生分类注入
////     * @return 表格的信息
////     */
////    private UIFormDefineVO wrapperFormDefineByTemplate(CodeClstemplateVO templateVO, String codeClassifyOid) {
////        UIFormDefineVO formDefineVO = new UIFormDefineVO();
////        formDefineVO.setOid(templateVO.getOid());
////        formDefineVO.setBtmType(templateVO.getBtmTypeId());
////        if (StringUtils.isBlank(codeClassifyOid)) {
////            codeClassifyOid = templateVO.getCodeClassifyOid();
////        }
////        CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyOid);
////
////        List<UIFormItemVO> itemVOS = new ArrayList<>();
////        Map<String, List<CodeClstempattrVO>> attrGroupMap = templateVO.getAttributes().stream().
////            filter(s -> StringUtils.isNotBlank(s.getAttributegroup())).collect(Collectors.groupingBy(s -> s.getAttributegroup()));
////
////        templateVO.getAttributes().forEach(attrVO -> {
////            UIFormItemVO formItemVO = templateAttr2FormField(attrVO, templateVO.getBtmTypeId());
////            itemVOS.add(formItemVO);
////        });
////        //处理属性分组
////        if (!CollectionUtils.isEmpty(attrGroupMap)) {
////            //按照分组的属性排列，找到每一个分组的第一个属性
////            for (String key : attrGroupMap.keySet()) {
////                List<CodeClstempattrVO> value = attrGroupMap.get(key);
////                //找到这个分组的属性的第一个
////                CodeClstempattrVO attrVO = value.stream().sorted(((o1, o2) -> o1.getOrdernum().compareTo(o2.getOrdernum()))).findFirst().get();
////                //我们找到这个属性在最终的itemVOs里的位置
////                UIFormItemVO lineVO = new UIFormItemVO();
////                lineVO.setField(attrVO.getId() + "_line");
////                lineVO.setType("line");
////                lineVO.setText(key);
////                //找位置
////                for (int i = 0; i < itemVOS.size(); i++) {
////                    UIFormItemVO record = itemVOS.get(i);
////                    if (record.getField().equalsIgnoreCase(attrVO.getId())) {
////                        itemVOS.add(i, lineVO);
////                        break;
////                    }
////                }
////            }
////        }
////
////        CodeOrderDTO orderDTO = new CodeOrderDTO();
////        switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO);
////        if (!CollectionUtils.isEmpty(orderDTO.getData())) {
////            orderDTO.getData().forEach((key, value) -> {
////                for (int i = 0; i < itemVOS.size(); i++) {
////                    UIFormItemVO itemVO = itemVOS.get(i);
////                    if (itemVO.getField().equalsIgnoreCase(key)) {
////                        itemVO.setDefaultValue(value);
////                        break;
////                    }
////                }
////            });
////        }
////        formDefineVO.setItems(itemVOS);
////        //查询是否有分类注入的
////        return formDefineVO;
////    }
////    /**
////     * 属性类型与js中的字段类型的映射
////     */
////    private static Map<String, String> vciFieldTypeMap = new HashMap<String, String>() {{
////        put(VciFieldTypeEnum.VTString.name(), "text");
////        put(VciFieldTypeEnum.VTInteger.name(), "text");
////        put(VciFieldTypeEnum.VTLong.name(), "text");
////        put(VciFieldTypeEnum.VTDouble.name(), "text");
////        put(VciFieldTypeEnum.VTClob.name(), "text");
////        put(VciFieldTypeEnum.VTBoolean.name(), "truefalse");
////        put(VciFieldTypeEnum.VTDateTime.name(), "datetime");
////        put(VciFieldTypeEnum.VTDate.name(), "datetime");
////        put(VciFieldTypeEnum.VTTime.name(), "datetime");
////        put(VciFieldTypeEnum.VTFilePath.name(), "file");
////    }};
////
////    /**
////     * 模板属性转换为表单的字段
////     *
////     * @param attrVO  模板属性
////     * @param btmType 业务类型
////     * @return 表单的字段
////     */
////    @Override
////    public UIFormItemVO templateAttr2FormField(CodeClstempattrVO attrVO, String btmType) {
////
////        UIFormItemVO itemVO = new UIFormItemVO();
////        if (SECRET_FILED.equalsIgnoreCase(attrVO.getId())) {
//////          attrVO.setEnumid(OsEnumServiceImpl.MY_DATA_SECRET);
////            attrVO.setEnumid(MY_DATA_SECRET);
////        }
////        itemVO.setField(attrVO.getId());
////        itemVO.setText(attrVO.getName());
////        itemVO.setType(vciFieldTypeMap.getOrDefault(attrVO.getAttributedatatype(), "text"));
////        if (VciBaseUtil.getBoolean(attrVO.getTextareaflag())) {
////            itemVO.setType("textarea");
////        }
////        if (VciFieldTypeEnum.VTLong.name().equalsIgnoreCase(attrVO.getAttributedatatype())
////            || VciFieldTypeEnum.VTInteger.name().equalsIgnoreCase(attrVO.getAttributedatatype())
////            || VciFieldTypeEnum.VTDouble.name().equalsIgnoreCase(attrVO.getAttributedatatype())) {
////            itemVO.setVerify("number");
////        }
////        itemVO.setReadOnly(VciBaseUtil.getBoolean(attrVO.getReadonlyflag()));
////        itemVO.setKeyAttr(VciBaseUtil.getBoolean(attrVO.getKeyattrflag()));
////        itemVO.setRequired(VciBaseUtil.getBoolean(attrVO.getRequireflag()));
////        itemVO.setDefaultValue(attrVO.getDefaultvalue());
////        itemVO.setDateFormate(attrVO.getCodedateformat());
////        itemVO.setHidden(!VciBaseUtil.getBoolean(attrVO.getFormdisplayflag()));
////        itemVO.setVerify(attrVO.getVerifyrule());
////        itemVO.setPrefix(attrVO.getPrefixvalue());
////        itemVO.setSuffix(attrVO.getSuffixvalue());
////        itemVO.setTooltips(attrVO.getExplain());
////        itemVO.setSelectLibFlag(attrVO.getLibraryidentification());
////        //看看是否有枚举
////        if ((StringUtils.isNotBlank(attrVO.getEnumstring())
////            && !"[]".equalsIgnoreCase(attrVO.getEnumstring())) ||
////            StringUtils.isNotBlank(attrVO.getEnumid())) {
////            itemVO.setType("combox");
////            itemVO.setComboxKey(attrVO.getEnumid());
////            if (StringUtils.isNotBlank(attrVO.getEnumstring())) {
////                //指定的下拉框内容
////                itemVO.setData(JSONObject.parseArray(attrVO.getEnumstring(), KeyValue.class));
////                if (StringUtils.isBlank(attrVO.getEnumid())) {
////                    itemVO.setComboxKey(itemVO.getField() + "_data");
////                }
////            }
////        }
////        //看是否有参照
////        if (StringUtils.isNotBlank(attrVO.getReferbtmid()) || StringUtils.isNotBlank(attrVO.getReferconfig())) {
////            itemVO.setType("refer");
////            itemVO.setShowField(itemVO.getField() + "name");
////            if (StringUtils.isNotBlank(attrVO.getReferconfig())) {
////                //配置的内容
////                itemVO.setReferConfig(JSONObject.parseObject(attrVO.getReferconfig(), UIFormReferVO.class));
////            } else {
////                UIFormReferVO formReferVO = new UIFormReferVO();
////                formReferVO.setType("default");
////                formReferVO.setReferType(attrVO.getReferbtmid());
////                itemVO.setReferConfig(formReferVO);
////            }
////        }
////
////        //如果是组合规则，分类注入的，显示为只读
////        if (StringUtils.isNotBlank(attrVO.getComponentrule())) {
////            itemVO.setReadOnly(true);
////            itemVO.setTooltips("本属性为组合规则");
////            itemVO.setRequired(false);
////        }
////        if (StringUtils.isNotBlank(attrVO.getClassifyinvokeattr())) {
////            itemVO.setReadOnly(!VciBaseUtil.getBoolean(attrVO.getClassifyinvokeeditflag()));
////            itemVO.setTooltips("本属性是分类注入");
////            itemVO.setRequired(false);
////        }
////
////        if (VciQueryWrapperForDO.LC_STATUS_FIELD.equalsIgnoreCase(itemVO.getField())) {
////            //是生命周期状态
////            itemVO.setType("combox");
////            itemVO.setComboxKey(btmType + LC_STATUS_SUBFIX);
////        }
////        return itemVO;
////    }
////
////
////    /**
////     * 封装相似项查询的列表
////     *
////     * @param templateVO 模板的显示对象
////     * @param uiInfoVO   页面的信息
////     */
////    private void wrapperResemble(CodeClstemplateVO templateVO, MdmUIInfoVO uiInfoVO) {
////        List<CodeClstempattrVO> resembleAttrList = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getSamerepeatattrflag())
////            || VciQueryWrapperForDO.ID_FIELD.equalsIgnoreCase(s.getId())).collect(Collectors.toList());
////        if (!CollectionUtils.isEmpty(resembleAttrList) && resembleAttrList.size() > 1) {
////            UITableDefineVO resembleTable = new UITableDefineVO();
////            resembleTable.setOid(templateVO.getOid());
////            resembleTable.setBtmType(templateVO.getBtmTypeId());
////            resembleTable.setDisplayQueryArea(false);
////            resembleTable.setPageVO(new UITablePageVO());
////            //处理所有的列，这个模板没有合并的表头的情况
////            List<UITableFieldVO> fieldVOList = new ArrayList<>();
////            resembleAttrList.forEach(attrVO -> {
////                UITableFieldVO tableFieldVO = templateAttr2TableField(attrVO,false);
////                tableFieldVO.setHidden(false);
////                fieldVOList.add(tableFieldVO);
////            });
////            List<List<UITableFieldVO>> cols = new ArrayList<>();
////            cols.add(fieldVOList);
////            resembleTable.setCols(cols);
////            uiInfoVO.setResembleTableVO(resembleTable);
////        }
////    }
////
////
////    /**
////     * 模板属性转换为表格显示的配置
////     *
////     * @param attrVO 模板属性
////     * @param forEdit 是否是编辑所需
////     * @return 表格的字段
////     */
////    @Override
////    public UITableFieldVO templateAttr2TableField(CodeClstempattrVO attrVO,boolean forEdit) {
////        UITableFieldVO fieldVO = new UITableFieldVO();
////        if (SECRET_FILED.equalsIgnoreCase(attrVO.getId())) {
////            attrVO.setEnumid(MY_DATA_SECRET);
////        }
////        fieldVO.setField(attrVO.getId());
////        fieldVO.setTitle(attrVO.getName());
////        fieldVO.setFieldType(vciFieldTypeMap.getOrDefault(attrVO.getAttributedatatype(), "text"));
////        fieldVO.setSort(true);
////        fieldVO.setSortField(fieldVO.getField());
////        fieldVO.setQueryField(fieldVO.getField());
////        if (forEdit){
////            fieldVO.setHidden(!VciBaseUtil.getBoolean(attrVO.getFormdisplayflag()));
////        }else {
////            fieldVO.setHidden(!VciBaseUtil.getBoolean(attrVO.getTabledisplayflag()));
////        }
////        if (attrVO.getAttrtablewidth() != null && attrVO.getAttrtablewidth() > 0) {
////            fieldVO.setMinWidth(Integer.valueOf(attrVO.getAttrtablewidth()));
////            fieldVO.setWidth(Integer.valueOf(attrVO.getAttrtablewidth()));
////        }
////        //看看是否有枚举
////        if ((StringUtils.isNotBlank(attrVO.getEnumstring())
////            && !"[]".equalsIgnoreCase(attrVO.getEnumstring())) ||
////            StringUtils.isNotBlank(attrVO.getEnumid())) {
////            fieldVO.setFieldType("combox");
////            fieldVO.setField(fieldVO.getField() + "Text");
////            fieldVO.setComboxKey(attrVO.getEnumid());
////            if (StringUtils.isNotBlank(attrVO.getEnumstring())) {
////                //指定的下拉框内容
////                fieldVO.setData(JSONObject.parseArray(attrVO.getEnumstring(), KeyValue.class));
////                if (StringUtils.isBlank(attrVO.getEnumid())) {
////                    fieldVO.setComboxKey(fieldVO.getField() + "_data");
////                }
////            }else {
////                List<KeyValue> osEnumItemVOList= enumService.getEnum(attrVO.getEnumid());
////                fieldVO.setData(osEnumItemVOList);
////            }
////        }
////        //看是否有参照
////        if (StringUtils.isNotBlank(attrVO.getReferbtmid()) || StringUtils.isNotBlank(attrVO.getReferconfig())) {
////            fieldVO.setFieldType("refer");
////            fieldVO.setQueryField(fieldVO.getField());
////            fieldVO.setField(fieldVO.getField() + "name");
////            fieldVO.setShowField(fieldVO.getField());
////            if (StringUtils.isNotBlank(attrVO.getReferconfig())) {
////                //配置的内容
////                fieldVO.setReferConfig(JSONObject.parseObject(attrVO.getReferconfig(), UIFormReferVO.class));
////            } else {
////                UIFormReferVO formReferVO = new UIFormReferVO();
////                formReferVO.setType("default");
////                formReferVO.setReferType(attrVO.getReferbtmid());
////                fieldVO.setReferConfig(formReferVO);
////            }
////        }
////        if (VciQueryWrapperForDO.LC_STATUS_FIELD.equalsIgnoreCase(fieldVO.getSortField())) {
////            fieldVO.setField("lcstatus_text");
////        }
////        Map<String, String> eventJsMap = new HashMap<>();
////        //超链接与模板是互斥
////        if (StringUtils.isNotBlank(attrVO.getTablehref())) {
////            String event = fieldVO.getSortField() + "_href";
////            eventJsMap.put(event, attrVO.getTablehref());
////            fieldVO.setTemplet("function(d){ return '<a class=\"layui-btn layui-btn-intable \" lay-event=\"" + event + "\">d." + fieldVO.getField() + "</a>';}");
////        }
////        if (StringUtils.isNotBlank(attrVO.getTabledisplayjs())) {
////            //直接写function(d){ return xxxxx;}
////            fieldVO.setTemplet(attrVO.getTabledisplayjs());
////        }
////        if (StringUtils.isBlank(fieldVO.getTemplet()) && VciFieldTypeEnum.VTBoolean.name().equalsIgnoreCase(attrVO.getAttributedatatype())) {
////            fieldVO.setTemplet("function(d){return $webUtil.formateBoolean(d." + fieldVO.getField() + ");}");
////        }
////        fieldVO.setOptionJsMap(eventJsMap);
////        fieldVO.setStyle(attrVO.getTabledisplaystyle());
////        //列表里不允许直接编辑
////        fieldVO.setDateFormate(attrVO.getCodedateformat());
////        return fieldVO;
////    }
////
////
////    /**
////     * 相似项查询
////     *
////     * @param orderDTO 编码的相关信息
////     * @return 数据列表
////     */
////    @Override
////    public DataGrid<Map<String, String>> resembleQuery(CodeOrderDTO orderDTO) {
////        VciBaseUtil.alertNotNull(orderDTO, "申请的信息", orderDTO.getCodeClassifyOid(), "分类主键", orderDTO.getTemplateOid(), "模板主键");
////        CodeClassifyFullInfoBO fullInfoBO = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
////        CodeClassifyTemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
////        switchClassifyLevelOnOrder(templateVO, fullInfoBO, orderDTO);
////        switchDateAttrOnOrder(templateVO, orderDTO);
////        switchComponentAttrOnOrder(templateVO, orderDTO);
////        //需要获取是否有相似查询属性
////        Map<String, CodeClassifyTemplateAttrVO> attrVOs = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getSamerepeatattrflag())).collect(Collectors.toMap(s -> s.getId(), t -> t));
////        if (CollectionUtils.isEmpty(attrVOs)) {
////            //都没有属性，肯定不能查询了
////            return new DataGrid<>();
////        }
////        Map<String, String> conditionMap = new HashMap<>();
////        //我们首先获取有没有查询规则
////        CodeResembleRuleVO resembleRuleVO = Optional.ofNullable(getUseResembleRule(fullInfoBO, fullInfoBO.getCurrentClassifyVO())).orElseGet(() -> new CodeResembleRuleVO());
////        attrVOs.forEach((attrId, attrVO) -> {
////            String value = getValueFromOrderDTO(orderDTO, attrId);
////            if (value == null) {
////                value = "";
////            }
////            wrapperResembleConditionMap(value, resembleRuleVO, attrId, conditionMap);
////        });
////
////        //没有限制分类，但是一个模板只可能在一个业务类型里面，所以直接查询这个业务类型即可
////        if (!CollectionUtils.isEmpty(conditionMap)) {
////            Map<String, String> andConditionMap = new HashMap<>();
////            andConditionMap.put("islastr", "1");
////            andConditionMap.put("islastv", "1");
////            if (StringUtils.isNotBlank(orderDTO.getOid())) {
////                andConditionMap.put("oid", QueryOptionConstant.NOTEQUAL + orderDTO.getOid());
////            }
////            conditionMap.putAll(andConditionMap);
////            PageHelper pageHelper = new PageHelper(-1);
////            pageHelper.addDefaultDesc("id");
////            return queryGrid(fullInfoBO.getTopClassifyVO().getBtmtypeid(), templateVO, conditionMap, pageHelper);
////        }
////        return new DataGrid<>();
////    }
////
////    /**
////     * 获取使用的相似查询规则
////     *
////     * @param fullInfoBO        类全部信息
////     * @param currentClassifyVO 当前的分类
////     * @return 规则，如果不存在会返回Null
////     */
////    @Override
////    public CodeResembleRuleVO getUseResembleRule(CodeClassifyFullInfoBO fullInfoBO, CodeClassifyVO currentClassifyVO) {
////        if (currentClassifyVO == null) {
////            return null;
////        }
////        if (currentClassifyVO != null && StringUtils.isNotBlank(currentClassifyVO.getCodeResembleRuleOid())) {
////            //说明已经存在
////            return resembleRuleService.getObjectByOid(currentClassifyVO.getCodeResembleRuleOid());
////        }
////        if (StringUtils.isBlank(currentClassifyVO.getParentcodeclassifyoid())) {
////            return null;
////        }
////        Map<String, CodeClassifyVO> classifyVOMap = fullInfoBO.getParentClassifyVOs().stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
////        return getUseResembleRule(fullInfoBO, classifyVOMap.getOrDefault(currentClassifyVO.getParentcodeclassifyoid(), null));
////    }
////
////    /**
////     * 封装相似项查询的查询条件的映射
////     *
////     * @param value          值
////     * @param resembleRuleVO 相似项规则
////     * @param attrId         属性的编号
////     * @param conditionMap   查询条件
////     */
////    @Override
////    public void wrapperResembleConditionMap(String value, CodeResembleRuleVO resembleRuleVO, String attrId, Map<String, String> conditionMap) {
////        boolean ignoreSpace = VciBaseUtil.getBoolean(resembleRuleVO.getIgnorespaceflag()) || VciBaseUtil.getBoolean(resembleRuleVO.getIgnoreallspaceflag());
////        if (StringUtils.isBlank(value)) {
////            //为空的时候就不查询它就是
////        } else {
////            String queryKey = "";
////            String queryValue = "";
////            boolean ignoreCase = VciBaseUtil.getBoolean(resembleRuleVO.getIgnorecaseflag());
////            boolean ignoreWidth = VciBaseUtil.getBoolean(resembleRuleVO.getIgnorewidthflag());
////            boolean trimAll = VciBaseUtil.getBoolean(resembleRuleVO.getIgnoreallspaceflag());
////            boolean trim = VciBaseUtil.getBoolean(resembleRuleVO.getIgnoreallspaceflag());
////            String temp = "";
////            if (ignoreCase && ignoreSpace && ignoreWidth) {
////                //忽略大小写，且去空，忽略全半角
////                temp = (trimAll ? "REPLACE" : "TRIM") + "(UPPER(to_single_byte('%s')) " + (trimAll ? ",' ','')" : ")");
////            } else if (ignoreCase && ignoreSpace && !ignoreWidth) {
////                //忽略大小写、去空、不忽略全半角
////                temp = (trimAll ? "REPLACE" : "TRIM") + "(UPPER(%s) " + (trimAll ? ",' ','')" : ")");
////            } else if (ignoreCase && !ignoreSpace && ignoreWidth) {
////                //忽略大小写、不去空、忽略全半角
////                temp = "UPPER(to_single_byte('%s'))";
////            } else if (!ignoreCase && ignoreSpace && ignoreWidth) {
////                //不忽略大小写、去空、忽略全半角
////                temp = (trimAll ? "REPLACE" : "TRIM") + "(to_single_byte('%s') " + (trimAll ? ",' ','')" : ")");
////            } else if (ignoreCase && !ignoreSpace && !ignoreWidth) {
////                //忽略大小写、不去空、不忽略全半角
////                temp = "UPPER(%s)";
////            } else if (!ignoreCase && !ignoreCase && ignoreWidth) {
////                //不忽略大小写、不去空、忽略全半角
////                temp = "to_single_byte('%s')";
////            } else if (!ignoreCase && ignoreSpace && !ignoreWidth) {
////                //不忽略大小写、去空、不忽略全半角
////                temp = (trimAll ? "REPLACE" : "TRIM") + "(%s " + (trimAll ? ",' ','')" : ")");
////            } else if (!ignoreCase && !ignoreSpace && !ignoreWidth) {
////                //不忽略大小写、不去空、不忽略全半角
////                temp = "%s";
////            }
////            if (StringUtils.isNotBlank(resembleRuleVO.getLinkCharacter())) {
////                List<String> chars = VciBaseUtil.str2List(resembleRuleVO.getLinkCharacter());
////                for (int i = 0; i < chars.size(); i++) {
////                    String s = chars.get(i);
////                    temp = "replace(" + temp + ",'" + s + "','')";
////                }
////            }
////            queryValue = String.format(temp, (trim ? value.trim() : value));
////            temp = temp.replace("to_single_byte('%s')","to_single_byte(%s)");
////            queryKey = String.format(temp, "t."+attrId);
////            conditionMap.put(queryKey, QueryOptionConstant.OR + queryValue);
////        }
////    }
////
////
////    /**
////     * 查询编码数据的列表
////     *
////     * @param btmType      业务类型
////     * @param templateVO   模板的对象，需要包含模板的属性
////     * @param conditionMap 查询条件
////     * @param pageHelper   分页对象
////     * @return 数据列表
////     */
////    @Override
////    public DataGrid<Map<String, String>> queryGrid(String btmType, CodeClassifyTemplateVO templateVO, Map<String, String> conditionMap, PageHelper pageHelper) {
////        CodeTemplateAttrSqlBO sqlBO = getSqlByTemplateVO(btmType, templateVO, conditionMap, pageHelper);
//////      List<Map> maps = boService.queryByOnlySqlForMap(sqlBO.getSqlHasPage());
////        List<Map> maps = commonsMapper.selectBySql(sqlBO.getSqlHasPage());
////        DataGrid<Map<String, String>> dataGrid = new DataGrid<>();
////        List<Map<String, String>> dataList = new ArrayList<>();
////        if (!CollectionUtils.isEmpty(maps)) {
////            maps.stream().forEach(map -> {
////                Map<String, String> data = new HashMap<>();
////                map.forEach((key, value) -> {
////                    data.put(((String) key).toLowerCase(Locale.ROOT), (String) value);
////                });
////                dataList.add(data);
////            });
////        }
////        dataGrid.setData(dataList);
////        if (!CollectionUtils.isEmpty(dataList)) {
////            wrapperData(dataGrid.getData(), templateVO, sqlBO.getSelectFieldList(), false);
////            dataGrid.setTotal(Long.parseLong(commonsMapper.selectBySql(sqlBO.getSqlCount()).get(0).values().toArray()[0].toString()););
////        }
////        return dataGrid;
////    }
////
////
////    /**
////     * 封装查询出来的数据
////     *
////     * @param dataMap              数据的映射
////     * @param templateVO           模板的属性
////     * @param onlySelectAttrIdList 仅仅查询的属性字段
////     * @param form 表单里使用
////     */
////    @Override
////    public void wrapperData(List<Map<String, String>> dataMap, CodeClassifyTemplateVO templateVO,
////                            Collection<String> onlySelectAttrIdList, boolean form) {
////        if (onlySelectAttrIdList == null) {
////            onlySelectAttrIdList = new ArrayList<>();
////        }
////        //先转换一下时间格式
////        List<String> finalOnlySelectAttrIdList = onlySelectAttrIdList.stream().collect(Collectors.toList());
////        List<CodeClassifyTemplateAttrVO> dateFormatAttrVOs = templateVO.getAttributes().stream().filter(
////            s -> StringUtils.isNotBlank(s.getCodeDateFormat()) &&
////                (finalOnlySelectAttrIdList.size() == 0 || finalOnlySelectAttrIdList.contains(s.getId().toLowerCase(Locale.ROOT)))
////        ).collect(Collectors.toList());
////        //枚举的内容
////        List<CodeClassifyTemplateAttrVO> enumAttrVOs = templateVO.getAttributes().stream().filter(
////            s -> (StringUtils.isNotBlank(s.getEnumId()) || StringUtils.isNotBlank(s.getEnumString()))
////                &&
////                (finalOnlySelectAttrIdList.size() == 0 || finalOnlySelectAttrIdList.contains(s.getId().toLowerCase(Locale.ROOT)))
////        ).collect(Collectors.toList());
////
////        List<String> userIds = new ArrayList<>();
////        dataMap.stream().forEach(data -> {
////            //处理时间
////            if (!form) {
////                //表单的时候只能用统一的时间格式
////                wrapperDateFormat(dateFormatAttrVOs, data);
////            }
////            //处理枚举
////            wrapperEnum(enumAttrVOs, data);
////            String lcstatus = data.get(VciQueryWrapperForDO.LC_STATUS_FIELD);
////            String copyFromVersion = data.getOrDefault(COPY_FROM_VERSION,"");
////            if ((CodeDefaultLC.EDITING.getValue().equalsIgnoreCase(lcstatus) || CodeDefaultLC.AUDITING.getValue().equalsIgnoreCase(lcstatus))
////                && StringUtils.isBlank(copyFromVersion)
////            ) {
////                data.put(VciQueryWrapperForDO.ID_FIELD, "******");
////            }
////            data.put(VciQueryWrapperForDO.LC_STATUS_FIELD_TEXT.toLowerCase(Locale.ROOT), CodeDefaultLC.getTextByValue(lcstatus));
////            if(CodeDefaultLC.EDITING.getValue().equalsIgnoreCase(lcstatus)
////                && StringUtils.isNotBlank(copyFromVersion)){
////                data.put(VciQueryWrapperForDO.LC_STATUS_FIELD_TEXT.toLowerCase(Locale.ROOT), "修改中");
////            }
////            if (data.containsKey("creator")) {
////                userIds.add(data.get("creator"));
////            }
////            if (data.containsKey("lastmodifier")) {
////                userIds.add(data.get("lastmodifier"));
////            }
////        });
////        if (!CollectionUtils.isEmpty(userIds)) {
////            Map<String, SmUserVO> userVOMap = Optional.ofNullable(userQueryService.listUserByUserIds(userIds)).orElseGet(() -> new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
////            dataMap.stream().forEach(data -> {
////                String creator = data.getOrDefault("creator", null);
////                if (StringUtils.isNotBlank(creator) && userVOMap.containsKey(creator.toLowerCase(Locale.ROOT))) {
////                    data.put("creator", creator + "(" + userVOMap.get(creator.toLowerCase(Locale.ROOT)).getName() + ")");
////                }
////                String lastmodifier = data.getOrDefault("lastmodifier", null);
////                if (StringUtils.isNotBlank(lastmodifier) && userVOMap.containsKey(lastmodifier.toLowerCase(Locale.ROOT))) {
////                    data.put("lastmodifier", lastmodifier + "(" + userVOMap.get(lastmodifier.toLowerCase(Locale.ROOT)).getName() + ")");
////                }
////            });
////        }
////    }
////
////
////    /**
////     * 处理时间格式
////     *
////     * @param dateFormatAttrVOs 时间格式的属性
////     * @param data              当前行数据
////     */
////    private void wrapperDateFormat(Collection<CodeClassifyTemplateAttrVO> dateFormatAttrVOs, Map<String, String> data) {
////        if (!CollectionUtils.isEmpty(dateFormatAttrVOs)) {
////            dateFormatAttrVOs.stream().forEach(dateFormatAttrVO -> {
////                String attrId = dateFormatAttrVO.getId().toLowerCase(Locale.ROOT);
////                String oldValue = data.getOrDefault(attrId, null);
////                if (StringUtils.isNotBlank(oldValue)) {
////                    DateConverter dateConverter = new DateConverter();
////                    try {
////                        dateConverter.setAsText(oldValue);
////                        Date value = dateConverter.getValue();
////                        if (value != null) {
////                            data.put(attrId, VciDateUtil.date2Str(value, dateFormatAttrVO.getCodeDateFormat()));
////                        }
////                    } catch (Throwable e) {
////                        //转换可能有问题，这就使用原本存储的值
////                    }
////                }
////            });
////        }
////    }
////
////
////    /**
////     * 处理枚举的内容，如果不在枚举中，会返回原本的值
////     *
////     * @param enumAttrVOs 枚举属性
////     * @param data        当前行数据
////     */
////    private void wrapperEnum(Collection<CodeClassifyTemplateAttrVO> enumAttrVOs, Map<String, String> data) {
////        //处理枚举的内容，为了兼容以前的数据,如果数据不能使用枚举转换的话，那还是显示以前的值
////        if (!CollectionUtils.isEmpty(enumAttrVOs)) {
////            enumAttrVOs.stream().forEach(enumAttrVO -> {
////                String attrId = enumAttrVO.getId().toLowerCase(Locale.ROOT);
////                String oldValue = data.getOrDefault(attrId, null);
////                if (StringUtils.isNotBlank(oldValue)) {
////                    List<KeyValue> comboxKVs = listComboboxItems(enumAttrVO);
////                    String newValue = oldValue;
////                    KeyValue keyValue = Optional.ofNullable(comboxKVs).orElseGet(() -> new ArrayList<>()).stream().filter(s -> s.getKey().equalsIgnoreCase(oldValue)).findFirst().orElseGet(() -> null);
////                    if (keyValue != null) {
////                        newValue = keyValue.getValue();
////                    }
////                    data.put(attrId + "Text", newValue);
////                }
////            });
////        }
////    }
////
////
////    /**
////     * 根据模板属性生成相应的sql信息
////     *
////     * @param btmType      业务类型
////     * @param templateVO   模板显示对象，必须包含属性
////     * @param conditionMap 查询条件
////     * @param pageHelper   分页和排序对象
////     * @return sql的相关信息
////     */
////    @Override
////    public CodeTemplateAttrSqlBO getSqlByTemplateVO(String btmType, CodeClassifyTemplateVO templateVO, Map<String, String> conditionMap, PageHelper pageHelper) {
////        //因为参照不一定是在平台的属性池里面设置，所以我们得需要自行处理
////        //参考VciQueryWrapper来处理
////        //1. 找到所有的字段，
////        Map<String, CodeClassifyTemplateAttrVO> attrVOMap = templateVO.getAttributes().stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
////        List<String> selectFieldList = attrVOMap.keySet().stream().collect(Collectors.toList());
////
////        //所有的参照的字段
////        Map<String/**属性字段**/, String> joinTableList = new ConcurrentHashMap<>();
////        List<CodeClassifyTemplateAttrVO> referAttrVOs = templateVO.getAttributes().stream().filter(
////            s -> StringUtils.isNotBlank(s.getReferBtmId()) || StringUtils.isNotBlank(s.getReferConfig())
////        ).collect(Collectors.toList());
////        Map<String/**参照的属性**/, String/**实际的字段**/> referFieldMap = new HashMap<>();
////        if (!CollectionUtils.isEmpty(referAttrVOs)) {
////            referAttrVOs.parallelStream().forEach(attrVO -> {
////                UIFormReferVO referVO = null;
////                if (StringUtils.isNotBlank(attrVO.getReferConfig())) {
////                    referVO = JSONObject.parseObject(attrVO.getReferConfig(), UIFormReferVO.class);
////                } else {
////                    referVO = new UIFormReferVO();
////                    referVO.setReferType(attrVO.getReferBtmId());
////                    referVO.setValueField(VciQueryWrapperForDO.OID_FIELD);
////                    referVO.setTextField("name");
////                }
////
////                String referTable = VciBaseUtil.getTableName(referVO.getReferType());
////                String referTableNick = attrVO.getId() + "0";
////                String left = " left join " + referTable + " " + referTableNick + " on " + referTableNick + "." + referVO.getValueField() + " =  t." + attrVO.getId();
////                joinTableList.put(attrVO.getId(), left);
////                String referShowField = attrVO.getId() + "Name";
////                List<String> textFields = VciBaseUtil.str2List(referVO.getTextField());
////                String showFieldInSource = "";
////                if (textFields.contains("name")) {
////                    showFieldInSource = "name";
////                } else {
////                    showFieldInSource = textFields.get(0);
////                }
////                referFieldMap.put(attrVO.getId(), referTableNick + "." + showFieldInSource);
////                selectFieldList.add(referTableNick + "." + showFieldInSource + " as " + referShowField);
////            });
////        }
////        Optional.ofNullable(attributeService.getDefaultAttributeVOMap()).orElseGet(() -> new HashMap<>()).keySet().stream().forEach(attrId -> {
////            if (!selectFieldList.contains(attrId) && !"secretgrade".equalsIgnoreCase(attrId)) {
////                selectFieldList.add(attrId);
////            }
////        });
////        if (!selectFieldList.contains(CODE_FIELD)) {
////            selectFieldList.add(CODE_FIELD);
////        }
////        if (!selectFieldList.contains(CODE_CLASSIFY_OID_FIELD)) {
////            selectFieldList.add(CODE_CLASSIFY_OID_FIELD);
////        }
////        if (!selectFieldList.contains(CODE_TEMPLATE_OID_FIELD)) {
////            selectFieldList.add(CODE_TEMPLATE_OID_FIELD);
////        }
////        if (!selectFieldList.contains(CODE_FULL_PATH_FILED)) {
////            selectFieldList.add(CODE_FULL_PATH_FILED);
////        }
////
////        //处理查询条件
////        //TODO 验证sql注入
////        List<String> andSql = new ArrayList<>();
////        List<String> orSql = new ArrayList<>();
////        if (!CollectionUtils.isEmpty(conditionMap)) {
////            Map<String, String> orConditionMap = new HashMap<>();
////            Map<String, String> andCondtionMap = new HashMap<>();
////            //先分离or的查询条件，另外当查询条件是空的时候也不查询
////            conditionMap.forEach((k, v) -> {
////                if (StringUtils.isNotBlank(v)) {
////                    if (v.startsWith(QueryOptionConstant.OR)) {
////                        orConditionMap.put(k, v.substring(QueryOptionConstant.OR.length()));
////                    } else {
////                        andCondtionMap.put(k, v);
////                    }
////                }
////            });
////
////            andCondtionMap.forEach((k, v) -> {
////                andSql.add(getConditionSql(k.toLowerCase(), v, referFieldMap, attrVOMap));
////            });
////            orConditionMap.forEach((k, v) -> {
////                orSql.add(getConditionSql(k.toLowerCase(), v, referFieldMap, attrVOMap));
////            });
////        }
////        //组合起来
////        StringBuilder andSb = new StringBuilder();
////        andSql.stream().forEach(s -> {
////            andSb.append(s).append(SPACE).append(QueryOptionConstant.AND).append(SPACE);
////        });
////
////        String andString = andSb.toString().trim();
////        String endWithSql = QueryOptionConstant.AND;
////        if (andString.endsWith(endWithSql)) {
////            andString = andString.substring(0, andString.length() - endWithSql.length());
////        }
////
////        String orString = orSql.stream().collect(Collectors.joining(" or "));
////        String whereSql = "";
////        if (StringUtils.isNotBlank(orString)) {
////            if (StringUtils.isBlank(andString)) {
////                andString = " 1 = 1 ";
////            }
////            whereSql = SPACE + "(" + SPACE + andString + SPACE + ") and (" + SPACE + orString + SPACE + ")" + SPACE;
////        } else {
////            whereSql = andString + SPACE;
////        }
////        if (attrVOMap.keySet().contains("secretgrade")) {
////            Integer userSecret = VciBaseUtil.getCurrentUserSecret();
////            if (userSecret == null || userSecret == 0) {
////                userSecret = secretService.getMinUserSecret();
////            }
////            whereSql += " and ( t.secretGrade <= " + userSecret + ") ";
////        }
////        String tableName = VciBaseUtil.getTableName(btmType);
////        String sql = "select " + selectFieldList.stream().map(s -> (s.contains(".") ? s : ("t." + s))).collect(Collectors.joining(","))
////            + " from " + tableName + SPACE + "t" + SPACE
////            + joinTableList.values().stream().collect(Collectors.joining(SPACE))
////            + (StringUtils.isBlank(whereSql) ? "" : " where ") + whereSql;
////        if (pageHelper == null) {
////            pageHelper = new PageHelper(-1);
////        }
////        //看看排序
////        String orderSql = pageHelper.getOrderSql("t");
////        sql += (orderSql == null ? "" : orderSql);
////        String whereSubfixForPage = " ) A where rownum < " + (pageHelper.getLimit() * pageHelper.getPage() + 1) + ") where RN >= "
////            + (pageHelper.getLimit() * (pageHelper.getPage() - 1) + 1);
////        String sqlHasPage = pageHelper.getLimit() > 0 ? ("select * from (select A.*,rownum RN from (" + sql + whereSubfixForPage) : sql;
////        String sqlCount = "select count(1) from " + tableName + SPACE + "t" + SPACE + joinTableList.values().stream().collect(Collectors.joining(SPACE))
////            + (StringUtils.isBlank(whereSql) ? "" : " where ") + whereSql;
////        CodeTemplateAttrSqlBO sqlBO = new CodeTemplateAttrSqlBO();
////        sqlBO.setTableName(tableName);
////        sqlBO.setJoinTable(joinTableList);
////        sqlBO.setNickName("t");
//////      sqlBO.setPageHelper(pageHelper);
////        sqlBO.setSqlHasPage(sqlHasPage);
////        sqlBO.setSqlCount(sqlCount);
////        sqlBO.setSqlUnPage(sql);
////        return sqlBO;
////    }
////
////
////    /**
////     * 组合查询条件的sql
////     *
////     * @param key           字段
////     * @param value         名字
////     * @param referFieldMap 参照的字段
////     * @param attrVOMap     属性的映射
////     * @return Sql语句
////     */
////    private String getConditionSql(String key, String value, Map<String/**参照的属性**/, String/**实际的属性**/> referFieldMap, Map<String, CodeClassifyTemplateAttrVO> attrVOMap) {
////        if (key.endsWith("_begin")) {
////            //说明是>=的。我们需要先获取一下
////            String field = (key.substring(0, key.length() - 6).toLowerCase().trim());
////            if (referFieldMap.containsKey(field)) {
////                //说明还是参照里面的，我们默认这种情况下都是字符串吧，因为参照的属性不一定用的平台的属性池里的，所以大部分情况下，显示的属性都是字符串吧
////                return referFieldMap.get(field) + SPACE + " >= '" + value + "'" + SPACE;
////            } else {
////                return (field.contains(".") ? "" : "t.") + field + SPACE + " >= " + getStringValueInWhere(value, field, attrVOMap);
////            }
////        } else if (key.endsWith("_end")) {
////            //说明是<=的。我们需要先获取一下
////            String field = (key.substring(0, key.length() - 6).toLowerCase().trim());
////            if (referFieldMap.containsKey(field)) {
////                //说明还是参照里面的，我们默认这种情况下都是字符串吧，因为参照的属性不一定用的平台的属性池里的，所以大部分情况下，显示的属性都是字符串吧
////                return referFieldMap.get(field) + SPACE + " <= '" + value + "'" + SPACE;
////            } else {
////                return (field.contains(".") ? "" : "t.") + field + SPACE + " <= " + getStringValueInWhere(field, value, attrVOMap);
////            }
////        } else {
////            if (referFieldMap.containsKey(key)) {
////                //说明是参照的，我们参照的查询都认为是字符串，如果是时间格式的查询肯定有问题，
////                String selectKey = referFieldMap.get(key);
////                return getSqlByValue(selectKey, value, null);
////            } else {
////                return getSqlByValue(key, value, attrVOMap);
////            }
////        }
////
////    }
////
////    /**
////     * 获取查询条件中的值的，处理不同的类型
////     *
////     * @param value 值
////     * @param field 字段名称
////     * @return 日期或者时间格式会包括to_date，字符串会加'
////     */
////    private String getStringValueInWhere(String field, String value, Map<String, CodeClassifyTemplateAttrVO> attrVOMap) {
////        if ((field.contains(".") && !field.toLowerCase(Locale.ROOT).startsWith("t.")) || attrVOMap == null
////            || !field.replace("t.", "").matches(RegExpConstant.LETTER) || value.startsWith(ONLY)) {
////            //说明可能是指定的某个条件，直接返回
////            if (value.startsWith(ONLY)) {
////                value = value.replace(ONLY, "");
////            }
////            if ((value.startsWith("(") && value.endsWith(")")) || (value.startsWith("'") && value.endsWith("'"))) {
////                return value;
////            }
////            if (field.contains(".") && attrVOMap != null && attrVOMap.containsKey(field.split("\\.")[0].toLowerCase(Locale.ROOT))) {
////                //是参照
////                return "'" + value + "'";
////            } else {
////                return value;
////            }
////        } else {
////            //看看是不是这个对象里的属性
////            if (attrVOMap.containsKey(field)) {
////                VciFieldTypeEnum fieldTypeEnum = VciFieldTypeEnum.valueOf(attrVOMap.get(field).getAttributeDataType());
////                if ("ts".equalsIgnoreCase(field)) {
////                    return "to_timestamp('" + value + "', '" + DATETIME_FORMAT + ".ff')";
////                }
////                DateConverter dateConverter = new DateConverter();
////                if (VciFieldTypeEnum.VTDateTime.equals(fieldTypeEnum)) {
////                    //实际上，数据库都是timestamp的类型.
////                    dateConverter.setAsText(value);
////                    return "to_date('" + dateConverter.getAsText(VciDateUtil.DateTimeFormat) + "','" + DATETIME_FORMAT + "')";
////                } else if (VciFieldTypeEnum.VTDate.equals(fieldTypeEnum)) {
////                    dateConverter.setAsText(value);
////                    return "to_date('" + dateConverter.getAsText(VciDateUtil.DateFormat) + "','" + DATE_FORMAT + "')";
////                } else if (VciFieldTypeEnum.VTDouble.equals(fieldTypeEnum)
////                    || VciFieldTypeEnum.VTLong.equals(fieldTypeEnum)
////                    || VciFieldTypeEnum.VTInteger.equals(fieldTypeEnum)) {
////                    return value;
////                } else {
////                    return "'" + value + "'";
////                }
////            } else {
////                if ((value.startsWith("(") && value.endsWith(")")) || (value.startsWith("'") && value.endsWith("'"))) {
////                    return value;
////                }
////                return "'" + value + "'";
////            }
////        }
////
////    }
////
////    /**
////     * 封装最终的sql语句中的值部分
////     *
////     * @param selectKey 查询的字段
////     * @param value     值
////     * @param attrVOMap 属性的显示对象映射
////     * @return sql里的值
////     */
////    private String getSqlByValue(String selectKey, String value, Map<String, CodeClassifyTemplateAttrVO> attrVOMap) {
////        StringBuilder sql = new StringBuilder();
////        if (!selectKey.contains(".") && (attrVOMap.containsKey(selectKey.toLowerCase(Locale.ROOT)) || attributeService.isDefaultAttr(selectKey) || selectKey.matches(RegExpConstant.LETTER))) {
////            sql.append("t.");
////        }
////        if (value.startsWith(QueryOptionConstant.IN)) {
////            sql.append(selectKey)
////                .append(SPACE)
////                .append("in")
////                .append(SPACE)
////                .append("(")
////                .append(value.replace(QueryOptionConstant.IN, ""))
////                .append(")");
////        } else if (value.startsWith(QueryOptionConstant.NOTIN)) {
////            sql.append(selectKey)
////                .append(SPACE)
////                .append("not in")
////                .append(SPACE)
////                .append("(")
////                .append(value.replace(QueryOptionConstant.NOTIN, ""))
////                .append(")");
////        } else if (value.startsWith(QueryOptionConstant.NOTEQUAL)) {
////            value = value.replace(QueryOptionConstant.NOTEQUAL, "");
////            value = getStringValueInWhere(selectKey, value, attrVOMap);
////            sql.append(selectKey)
////                .append(SPACE)
////                .append(QueryOptionConstant.NOTEQUAL)
////                .append(SPACE)
////                .append(value);
////        } else if (value.startsWith(QueryOptionConstant.MORETHAN)) {
////            value = value.replace(QueryOptionConstant.MORETHAN, "");
////            value = getStringValueInWhere(selectKey, value, attrVOMap);
////            sql.append(selectKey)
////                .append(SPACE)
////                .append(QueryOptionConstant.MORETHAN)
////                .append(SPACE)
////                .append(value);
////        } else if (value.startsWith(QueryOptionConstant.MORE)) {
////            value = value.replace(QueryOptionConstant.MORE, "");
////            value = getStringValueInWhere(selectKey, value, attrVOMap);
////            sql.append(selectKey)
////                .append(SPACE)
////                .append(QueryOptionConstant.MORE)
////                .append(SPACE)
////                .append(value);
////        } else if (value.startsWith(QueryOptionConstant.LESSTHAN)) {
////            value = value.replace(QueryOptionConstant.LESSTHAN, "");
////            value = getStringValueInWhere(selectKey, value, attrVOMap);
////
////            sql.append(selectKey)
////                .append(SPACE)
////                .append(QueryOptionConstant.LESSTHAN)
////                .append(SPACE)
////                .append(value);
////        } else if (value.startsWith(QueryOptionConstant.LESS)) {
////            value = value.replace(QueryOptionConstant.LESS, "");
////            value = getStringValueInWhere(selectKey, value, attrVOMap);
////
////            sql.append(selectKey)
////                .append(SPACE)
////                .append(QueryOptionConstant.LESS)
////                .append(SPACE)
////                .append(value);
////        } else if (value.startsWith(QueryOptionConstant.ISNOTNULL)) {
////            sql.append(selectKey)
////                .append(SPACE)
////                .append(" is not null");
////        } else if (value.startsWith(QueryOptionConstant.ISNULL)) {
////            sql.append(selectKey)
////                .append(SPACE)
////                .append(" is null");
////        } else if (value.contains("*")) {
////            //说明是like，或者lefe like ,right like
////            value = getStringValueInWhere(selectKey, value, attrVOMap);
////            sql.append(selectKey)
////                .append(SPACE)
////                .append("like")
////                .append(SPACE)
////                //   .append("'")
////                .append(value.replace("*", "%"))
////                //  .append("'")
////                .append(SPACE);
////        } else {
////            value= value.replace(SPECIAL_CHAR,REQUIRED_CHAR);
////            value = getStringValueInWhere(selectKey, value, attrVOMap);
////
////            sql.append(selectKey)
////                .append(SPACE)
////                .append(QueryOptionConstant.EQUAL)
////                .append(SPACE)
////                .append(value);
////        }
////        sql.append(SPACE);
////        return sql.toString();
////    }
////
////    /**
////     * 修改主题库数据
////     *
////     * @param orderDTO 数据的内容，不用包含码段的内容了
////     */
////    @Override
////    public void editSaveCode(CodeOrderDTO orderDTO) {
////        VciBaseUtil.alertNotNull(orderDTO, "编码申请相关的属性的内容都为空", orderDTO.getOid(), "数据主键",
////            orderDTO.getCodeClassifyOid(), "主题库分类的主键");
//////      CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
////        CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
////        //找业务类型，然后使用主键去获取数据库里的数据
//////      List<ClientBusinessObject> cbos = boService.queryCBO(classifyFullInfo.getTopClassifyVO().getBtmtypeid(), WebUtil.getOidQuery(orderDTO.getOid()));
////
////        QueryWrapper<CodeOsbtmtypeEntity> btmWrapper = new QueryWrapper<>();
////        btmWrapper.eq("OID",orderDTO.getOid());
////        CodeWupinEntity cbo = codeOsbtmtypeMapper.selectOne(btmWrapper);
////
//////      CodeClstemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
//////      CodeRuleVO ruleVO = ruleService.getObjectHasSecByOid(orderDTO.getCodeRuleOid());
////
////        if (cbo != null) {
////            throw new VciBaseException(DATA_OID_NOT_EXIST);
////        }
//////      ClientBusinessObject cbo = cbos.get(0);
////        if (!cbo.getTs().toString().contains(VciDateUtil.date2Str(orderDTO.getTs(), VciDateUtil.DateTimeFormat))) {
////            throw new VciBaseException("数据不是最新的，可能他人已经修改，请刷新后再试");
////        }
////        if (!CodeDefaultLC.EDITING.getValue().equalsIgnoreCase(cbo.getLcStatus()) && !orderDTO.isEditInProcess()) {
////            throw new VciBaseException("数据不是{0}的状态，不允许修改", new String[]{CodeDefaultLC.EDITING.getText()});
////        }
////
////        //注意模板不能使用数据存储的时候的模板，因为可能会变化
////
////        //1. 判断必输项
////        CodeClassifyTemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
////        checkRequiredAttrOnOrder(templateVO, orderDTO);
////        //2.先注入，再组合，最后校验
////        switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO);
////        //3.处理组合规则。组合规则不能使用编码的属性，因为编码的生成可能是需要属性的
////        switchComponentAttrOnOrder(templateVO, orderDTO);
////        //4.校验规则
////        checkVerifyOnOrder(templateVO, orderDTO);
////        //5.判断关键属性
////        checkKeyAttrOnOrder(classifyFullInfo, templateVO, orderDTO);
////        //6.校验枚举的内容是否正确
////        checkEnumOnOrder(templateVO, orderDTO);
////        //7.处理时间格式，在数据库里面不论是字符串还是日期格式，都使用相同的格式存储
////        switchDateAttrOnOrder(templateVO, orderDTO);
////        //默认的内容不能变，所以只需要拷贝自定义的相关属性即可
////        copyValueToCBO(classifyFullInfo, cbo, orderDTO, templateVO, true);
////        //企业码和集团码的不修改
////        cbo.setDescription(orderDTO.getDescription());
////        cbo.setName(orderDTO.getName());
////        try {
////            cbo.setDescription(orderDTO.getDescription());
////            cbo.setName(orderDTO.getName());
////////            cbo.setAttributeValueWithNoCheck("description", orderDTO.getDescription());
//////          cbo.setAttributeValue("name", orderDTO.getName());
////        } catch (Exception e) {
////            e.printStackTrace();
////        }
////
////
////        List<CodeWupinEntity> cboList = new ArrayList<>();
////
////        //备注
////        cbo.setDescription(orderDTO.getDescription());
////        cboList.add(cbo);
//      List<String> codeList = productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(),cboList);
//////
//////      cboList.add(cbo);
////        List<String> codeList = productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(),cboList);
////
////
////        List<String> charList = new ArrayList<>();
////        for (CodeWupinEntity wupinEntity : cboList) {
////            charList.add(wupinEntity.getId());
////        }
////        batchSaveSelectChar(templateVO, charList);
////        return codeList.size() > 0 ? codeList.get(0) : "";
////
////
////
////
////        //修改的时候，编码是不变的
//////      BatchCBO batchCBO = new BatchCBO();
//////      batchCBO.getUpdateCbos().add(cbo);
//////      List<ClientBusinessObject> cboList = new ArrayList<>();
//////      cboList.add(cbo);
//////      boService.persistenceBatch(batchCBO);
////        batchSaveSelectChar(templateVO, cboList);
////    }
//
//
//      List<String> charList = new ArrayList<>();
//      for (CodeWupinEntity wupinEntity : cboList) {
//          charList.add(wupinEntity.getId());
//      }
//      batchSaveSelectChar(templateVO, charList);
//      return codeList.size() > 0 ? codeList.get(0) : "";
//
//
//
//
//      //修改的时候，编码是不变的
////        BatchCBO batchCBO = new BatchCBO();
////        batchCBO.getUpdateCbos().add(cbo);
////        List<ClientBusinessObject> cboList = new ArrayList<>();
////        cboList.add(cbo);
////        boService.persistenceBatch(batchCBO);
//      batchSaveSelectChar(templateVO, cboList);
//  }

}
//}

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

@@ -0,0 +1,534 @@
package com.vci.ubcs.code.service.impl;

import com.alibaba.cloud.commons.lang.StringUtils;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;
import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
import com.vci.ubcs.code.dto.CodeOrderDTO;
import com.vci.ubcs.code.dto.CodeOrderSecDTO;
import com.vci.ubcs.code.entity.CodeBasicSec;
import com.vci.ubcs.code.entity.CodeClassify;
import com.vci.ubcs.code.entity.DockingLog;
import com.vci.ubcs.code.enumpack.CodeSecTypeEnum;
import com.vci.ubcs.code.service.*;
import com.vci.ubcs.code.util.gennerAttrMapUtil;
import com.vci.ubcs.code.vo.pagemodel.*;
import com.vci.ubcs.code.vo.webserviceModel.apply.*;
import com.vci.ubcs.code.vo.webserviceModel.attrmap.*;
import com.vci.ubcs.code.vo.webserviceModel.result.json.*;
import com.vci.ubcs.code.vo.webserviceModel.result.xml.XMLResultClassfyVO;
import com.vci.ubcs.code.vo.webserviceModel.result.xml.XMLResultDataObjectDetailDO;
import com.vci.ubcs.code.vo.webserviceModel.result.xml.XMLResultSystemVO;
import com.vci.ubcs.starter.web.pagemodel.SessionInfo;
import com.vci.ubcs.starter.web.util.BeanUtilForVCI;
import com.vci.ubcs.starter.web.util.VciBaseUtil;
import com.vci.ubcs.webservice.annotation.VciWebservice;
import com.vci.ubcs.webservice.config.AttributeMapConfig;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import javax.jws.WebService;
import java.util.*;
import java.util.stream.Collectors;

import static com.vci.ubcs.code.constant.MdmEngineConstant.DEFAULT_SYNC_ATTR_LIST;

/***
 * 统一接口
 */
@Service
@Slf4j
@VciWebservice(path = "/universalInterface")
public class UniversalInterfaceImpl<IDockingLogeServiceing> implements UniversalInterfaceI {

    /**
     * 日志
     */
    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired(required = false)
    private AttributeMapConfig attributeMapConfig;
    /**
     * 缓存服务
     */
    //@Autowired
    //private RedisService redisService;
    /**
     * 主题库分类的服务
     */
    @Autowired(required = false)
    private ICodeClassifyService classifyService;
    /**
     * 主数据引擎的服务
     */
    //@Resource
    //private MdmEngineService engineService;

    /**
     * 密级的服务
     */

    @Resource
    private MdmIOService mdmIOService;
    /***
     * 集成接口日志服务的配置
     */
    @Resource
    private IDockingLogeService dockingLogeService;

    private  static String separator="##VCI##";
    private  String errorid="0";
    private String msg="成功";
    private  String objerrorCode="0";
    private String objerrorMsg="成功";
    /***
     * 申请编码接口
     * @param data 传递的数据参数
     * @param dataType 标识data是xml格式还是json格式，接口返回数据也是按照这个格式，以下接口类同
     * @return
     * @throws Throwable
     */
    @Override
    public String applyCode(String data, String dataType) throws Throwable {
        {
//          String resultStr = "";
//          String errorid="0";
//          msg="成功";
//          objerrorCode="0";
//          objerrorMsg="成功";
//          logger.info("申请编码的数据参数:->"+data);
//          logger.info("申请编码的数据类型:->"+dataType);
//          String systemId="";
//          List<XMLResultClassfyVO> resultClassfyVOList = new ArrayList<>();
//          try {
//              if(StringUtils.isBlank(data)) {
//                  errorid="101";
//                  throw new Throwable("接口参数：传递为空");
//              }
//              InterParameterVO interParameterVO  =new InterParameterVO();
//              //如果dataType是xml则，通过xml序列化成对象形式，如果是json则通过json转换成对象格式
//              try {
//                  if ("xml".equals(dataType)) {
//                      XStream xStream = new XStream(new DomDriver());
//                      xStream.processAnnotations(RootDataVO.class);
//                      xStream.autodetectAnnotations(true);
//                      RootDataVO rootDataVO = (RootDataVO) xStream.fromXML(data);
//                      interParameterVO.setData(rootDataVO);
//                  } else {
//                      interParameterVO = JSONObject.toJavaObject(JSONObject.parseObject(data), InterParameterVO.class);
//                  }
//              }catch (Throwable e){
//                  errorid="101";
//                  throw new Throwable("接口参数：传入数据参数解析失败");
//              }
//              ClassfysVO classfysVO = interParameterVO.getData().getClassifys();
//              systemId = interParameterVO.getData().getSystemId();
//              UserVO userVo = interParameterVO.getData().getUser();
//              List<ClassfyVO> classVOList = classfysVO.getClassify();
//              InterParameterVO finalInterParameterVO = interParameterVO;
//
//              //这是账号信息
//              SessionInfo sessionInfo = new SessionInfo();
//              sessionInfo.setUserId(userVo.getUserName());
//              sessionInfo.setUserName(userVo.getTrueName());
//              sessionInfo.setIp(userVo.getIp());
//              VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
//
//              String finalSystemId = systemId;
//              classVOList.stream().forEach(classVO -> {
//                  logger.info("参数：分类COde:" + classVO.getClassCode());
//                  LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs = new LinkedList<>();
//                  //获取分类信息
//                  try {
//                      String libray = classVO.getLibrary();
//                      CodeClassifyVO codeClassifyVO = getClassfy(classVO);
//                      logger.info("end：分类查询完毕");
//                      //获取分类模板信息
//                      if(codeClassifyVO==null || StringUtils.isBlank(codeClassifyVO.getOid())){
//                          objerrorCode="100";
//                          throw  new  Throwable ("根据传输的分类，未获取到分类信息");
//                      }
//                      CodeClstemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyVO.getOid());
//                      if(templateVO==null||StringUtils.isBlank(templateVO.getOid())){
//                          objerrorCode="1";
//                          throw  new  Throwable ("根据传输的分类，未获取MDM系统中对应模板");
//                      }
//                      logger.info("end：模板查询完毕");
//                      ApplyDatasVO applyDatasVO = classVO.getObjects();
//                      DataObjectVO dataObjectVO = new DataObjectVO();
//                      List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s -> !DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
//                      ).collect(Collectors.toList());
//                      this.getConfigDatas(finalSystemId, libray, applyDatasVO, attrVOS, dataObjectVO);
//                      logger.info("end：数据组织完毕");
//                      //规则的主键需要去获取
//                      CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyVO.getOid());
//                      if(classifyFullInfo==null ||classifyFullInfo.getCurrentClassifyVO()==null || StringUtils.isBlank(classifyFullInfo.getCurrentClassifyVO().getOid())){
//                          objerrorCode="1";
//                          logger.info("classifyFullInfo:"+"根据传输的分类，未获取分类相关信息");
//                          throw  new  Throwable ("根据传输的分类，未获取分类相关信息");
//                      }
//                      CodeRuleVO ruleVO = engineService.getCodeRuleByClassifyFullInfo(classifyFullInfo);
//                      if(ruleVO==null|| StringUtils.isBlank(ruleVO.getOid())){
//                          objerrorCode="102";
//                          throw  new  Throwable ("根据传输的分类，未获取MDM系统中对应规则");
//                      }
//                      logger.info("end：规则获取完毕");
//                      List<CodeOrderSecDTO> codeOrderSecDTOList = getRuleCodeOrderSecDTOs(classVO.getSections().getSection(), ruleVO);
//                      logger.info("end：码段获取完毕");
//                      CodeOrderDTO orderDTO = new CodeOrderDTO();
//                      orderDTO.setCodeClassifyOid(codeClassifyVO.getOid());//分类主键
//                      orderDTO.setSecDTOList(codeOrderSecDTOList);//分类码段
//                      mdmIOService.batchSyncApplyCode(orderDTO, dataObjectVO, resultDataObjectDetailDOs);
//                      logger.info("end：申请获取完毕");
//                  } catch (Throwable e) {
//                      XMLResultDataObjectDetailDO xmlResultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
//                      xmlResultDataObjectDetailDO.setCode("");
//                      xmlResultDataObjectDetailDO.setId("");
//                      xmlResultDataObjectDetailDO.setErrorid(objerrorCode);
//                      xmlResultDataObjectDetailDO.setMsg("编码申请失败:"+e.getMessage());
//                      resultDataObjectDetailDOs.add(xmlResultDataObjectDetailDO);
//                      e.printStackTrace();
//                  }finally {
//                      XMLResultClassfyVO resultClassfyVO = new XMLResultClassfyVO();
//                      resultClassfyVO.setClassCode(classVO.getClassCode());
//                      resultClassfyVO.setLibrary(classVO.getLibrary());
//                      resultClassfyVO.setFullclsfNamePath(classVO.getFullclsfNamePath());
//                      resultClassfyVO.setObjects(resultDataObjectDetailDOs);
//                      resultClassfyVOList.add(resultClassfyVO);
//                  }
//              });
//              XMLResultSystemVO xmlResultSystemVO=new XMLResultSystemVO();
//              xmlResultSystemVO.setClassifys(resultClassfyVOList);
//              xmlResultSystemVO.setMsg(msg);
//              xmlResultSystemVO.setErrorid(errorid);
//              resultStr= transferResultXMl(xmlResultSystemVO,dataType);
//          }catch (Throwable e){
//              e.printStackTrace();;
//              msg="申请编码失败:"+e.getMessage();
//          }finally {
//              XMLResultSystemVO xmlResultSystemVO=new XMLResultSystemVO();
//              xmlResultSystemVO.setClassifys(resultClassfyVOList);
//              xmlResultSystemVO.setMsg(msg);
//              xmlResultSystemVO.setErrorid(errorid);
//              resultStr= transferResultXMl(xmlResultSystemVO,dataType);
//              final boolean[] issucess = {true};
//              if(!errorid.equals("0")) {
//                  issucess[0] = false;
//              }else {
//                  if(!CollectionUtils.isEmpty(resultClassfyVOList)) {
//                      resultClassfyVOList.stream().forEach(xMLResultClassfyVO -> {
//                          xMLResultClassfyVO.getObjects().stream().forEach(objec -> {
//                              if (!(objec.getErrorid().equals("0") || objec.getErrorid().equals("204"))) {
//                                  issucess[0] = false;
//                                  msg=objec.getMsg();
//                              }
//                          });
//                      });
//                  }
//
//              }
//              try {
//                  //记录日志
//                  this.saveLogs(systemId, systemId, data, resultStr, issucess[0], msg, "applyCode");
//              }catch (Throwable e){
//                  e.printStackTrace();
//              }
//          }
//          logger.info("返回参数:"+resultStr);

            return "";
        }
    }

    /***
     * 统一更新接口（更改状态，更改属性信息）接口
     * @param data
     * @param dataType
     * @return
     * @throws Throwable
     */
    @Override
    public String syncEditData(String data, String dataType) throws Throwable {

        return null;
    }

    /***
     * 分类查询
     * @param data
     * @param dataType
     * @return
     * @throws Throwable
     */
    @Override
    public String queryClassify(String data, String dataType) throws Throwable {
        return null;
    }

    /***
     * 数据查询
     * @param data
     * @param dataType
     * @return
     * @throws Throwable
     */
    @Override
    public String queryData(String data, String dataType) throws Throwable {
        return null;
    }

    @Override
    public String queryClassifyRule(String data, String datatype) throws Throwable {
        return null;
    }

    /***
     * 查询校验分类信息
     * @param classfyVO
     */
    private  CodeClassifyVO getClassfy(ClassfyVO classfyVO) throws Throwable{
        CodeClassifyVO classifyVO = new CodeClassifyVO();
        try {
            String classCode = classfyVO.getClassCode();
            String className = classfyVO.getFullclsfNamePath();
            //根据分类代号查询分类信息
            if (StringUtils.isNotBlank(classfyVO.getClassCode())) {
                Map<String, String> conditionMap = new HashMap<>();
                List<CodeClassify> codeClassifyList = classifyService.selectByWrapper(Wrappers.<CodeClassify>query().lambda().eq(CodeClassify::getId, classCode));
                if (!CollectionUtils.isEmpty(codeClassifyList)) {
                    CodeClassify classifyDO = codeClassifyList.get(0);
                    //将DTO转换为DO
                    classifyVO = new CodeClassifyVO();
                    BeanUtilForVCI.copyPropertiesIgnoreCase(classifyDO, classifyVO);
                    if(StringUtils.isBlank(classifyVO.getOid())){
                        throw new  Throwable("根据分类代号未查询到相应的分类信息");
                    }
                }else{
                    throw new  Throwable("根据分类代号未查询到相应的分类信息");
                }
            } else {
                //classifyVO = classifyService.getObjectByClsfNamePath(className.replace(separator, "/"));
                //if(StringUtils.isBlank(classifyVO.getOid())){
                //  throw new  Throwable("根据分类名称路径未查询到相应的分类信息");
                //}
            }
        }catch (Throwable e){
            objerrorCode="100";
            new  Throwable("获取分类信息失败:"+e.getMessage());
        }
        return classifyVO;
    }
    /***
     * 根据穿入的参数信息校验码段规则
     */
    private List<CodeOrderSecDTO> getRuleCodeOrderSecDTOs(List<SectionVO> SectionVOList,CodeRuleVO ruleVO) throws Throwable{
        List<CodeBasicSecVO>  codeBasicSecVOS= ruleVO.getSecVOList();
        Map<String,String> sectionVOMap=new HashMap<>();
        SectionVOList.stream().forEach(SectionVO->{
            sectionVOMap.put(SectionVO.getName(),SectionVO.getValue());
        });
        List<CodeOrderSecDTO> codeOrderSecDTOList=new ArrayList<>();
        for(CodeBasicSecVO codeBasicSecVO: codeBasicSecVOS) {
            String sectype = codeBasicSecVO.getSecType();
            if (!sectype.equals(CodeSecTypeEnum.CODE_SERIAL_SEC.getValue())) {
                String name = codeBasicSecVO.getName();
                String sectypeText = codeBasicSecVO.getSecTypeText();
                logger.info("码段名称:"+name);
                logger.info("描述:"+sectypeText);
                CodeOrderSecDTO CodeOrderSecDTO = new CodeOrderSecDTO();
                if (sectionVOMap.containsKey(name)) {
                    CodeOrderSecDTO.setSecOid(codeBasicSecVO.getOid());
                    String sectypeValue = sectionVOMap.get(name);
                    logger.info("码段值:"+sectypeValue);
                    CodeOrderSecDTO.setSecValue(sectypeValue);
                    codeOrderSecDTOList.add(CodeOrderSecDTO);
                } else {
                    objerrorCode="101";
                    throw new Throwable("传入的码段规则缺少" + name + "码段");
                }
            }
        }
        return codeOrderSecDTOList;
    }
    /***
     * 根据属性映射转换编码所需字段
     */
    public void getConfigDatas(String systemId,String libray, ApplyDatasVO applyDatasVO,List<CodeClassifyTemplateAttrVO> codeClassifyTemplateAttrVOList,DataObjectVO dataObjectVO) throws Throwable {
        List<ApplyDataVO> applyDataVOList=applyDatasVO.getObject();
        LinkedHashMap<String,LinkedHashMap<String,String>> dataKeyValueMap=new LinkedHashMap<>();
        //如果将数据转换成所需要的数据对象
        Map<String, String> attrMapConfigMap=new HashMap<>();
        Map<String, String> propMaps=new HashMap<>();
        try {
            Map<String, String> stringStringMap=attributeMapConfig.getSystem_attrmap();
            //stringStringMap.put("RLM","D:\\RLM.xml");
            LibraryDO libraryDO= gennerAttrMapUtil.getNewInstance().gennerAttrMapBySystem(systemId,stringStringMap);
            List<LibraryClsfDO> libraryClsfDOList=libraryDO.getClsf();
            Map<String, List<ClsfAttrMappingDO>> libPropMaps = libraryClsfDOList.stream().collect(Collectors.toMap(LibraryClsfDO::getLibrary, LibraryClsfDO::getProp, (key1, key2) -> key2));
            if(libPropMaps.containsKey(libray)){
                List<ClsfAttrMappingDO> clsfAttrMappingDOList=libPropMaps.get(libray);
                propMaps = clsfAttrMappingDOList.stream().collect(Collectors.toMap(ClsfAttrMappingDO::getSourceKey, ClsfAttrMappingDO::getTargetKey, (key1, key2) -> key2));
            }
        }catch (Throwable e){
            objerrorCode="1";
            throw new Throwable("MDM集成属性配置文件读取失败");
        }
        LinkedList<String> rowNameList=new LinkedList<>();
        LinkedHashMap<String,Integer> filedIndexMap=new LinkedHashMap<>();
        //根据分类模板组织数据
        final int[] index = {0};
        try {
            codeClassifyTemplateAttrVOList.stream().forEach(codeClassifyTemplateAttrVO -> {
                String attrName = codeClassifyTemplateAttrVO.getName();
                String field = codeClassifyTemplateAttrVO.getId();
                rowNameList.add(attrName);
                filedIndexMap.put(field, index[0]++);
            });
            dataObjectVO.setColName(rowNameList);//放入属性
            attrMapConfigMap.putAll(propMaps);
            LinkedList<RowDatas> rowDataList = new LinkedList<>();
            //Map<String, List<ProppertyVO>> dataPropMap = applyDataVOList.stream().collect(Collectors.toMap(ApplyDataVO::getId, ApplyDataVO::getProp, (key1, key2) -> key2));
            final int[] rowIndex = {0};
            applyDataVOList.stream().forEach(applyDataVO -> {
                rowIndex[0]++;
                RowDatas rowDatas = new RowDatas();
                rowDatas.setOid(applyDataVO.getId());
                rowDatas.setCreator(applyDataVO.getCreator());
                rowDatas.setEditor(applyDataVO.getEditor());
                rowDatas.setCode(applyDataVO.getCode());
                rowDatas.setOperation(applyDataVO.getOperate());
                rowDatas.setStatus(applyDataVO.getStatus());
                rowDatas.setRowIndex(rowIndex[0] + "");
                List<ProppertyVO> proppertyVOList = applyDataVO.getProp();

                LinkedHashMap<Integer, String> integerValueMap = new LinkedHashMap<>();
                Map<String, String> filedValueMap = new HashMap<>();
                if (!CollectionUtils.isEmpty(proppertyVOList)) {
                    Map<String, String> sourceKeyValueMap = proppertyVOList.stream().collect(Collectors.toMap(ProppertyVO::getKey, ProppertyVO::getValue, (key1, key2) -> key2));
                    Map<String, String> keyValueMap = new HashMap<>();
                    //判断attrMapConfigMap是否有值，如果没有则说明基础默认的是编码系统字段
                    if (!CollectionUtils.isEmpty(attrMapConfigMap)) {
                        sourceKeyValueMap.keySet().forEach(sourceKey -> {
                            String dataValue = sourceKeyValueMap.get(sourceKey);
                            if (attrMapConfigMap.containsKey(sourceKey)) {
                                String targetKey = attrMapConfigMap.get(sourceKey);
                                keyValueMap.put(targetKey, StringUtils.isBlank(dataValue)?"":dataValue);
                            }
                        });
                    } else {
                        sourceKeyValueMap.forEach((filed,value)->{
                            keyValueMap.put(filed,StringUtils.isBlank(value)?"":value) ;
                        });
                    }

                    filedIndexMap.forEach((attrKey, column) -> {
                        String keyValue = "";
                        if (keyValueMap.containsKey(attrKey)) {
                            keyValue =StringUtils.isBlank(keyValueMap.get(attrKey))?"":keyValueMap.get(attrKey);
                        }
                        integerValueMap.put(column, keyValue);
                        filedValueMap.put(attrKey, keyValue);
                    });
                }
                rowDatas.setData(integerValueMap);
                rowDatas.setFiledValue(filedValueMap);
                rowDataList.add(rowDatas);
            });
            dataObjectVO.setRowData(rowDataList);
        }catch (Throwable e){
            objerrorCode="1";
            throw new   Throwable("组织数据映射值失败");
        }
    }
    /***
     * 记录日志信息
     * @param systemId
     * @param parmaData
     * @param result
     * @return
     */
    private  void saveLogs(String systemId,String systemName,String parmaData, String result,boolean isSucess,String msg,String operation){
        //记录日志信息
        DockingLog dockingLoge=new DockingLog();
        //String oid=redisService.getUUIDEveryDay();
        dockingLoge.setSystemCode(StringUtils.isBlank(systemId)?"-":systemId);//设置系统标识
        dockingLoge.setSystemName(StringUtils.isBlank(systemName)?"-":systemName);
        dockingLoge.setMsg(msg);//日志消息
        dockingLoge.setClassifyId("-");//分类编号
        dockingLoge.setClassifyName("-");//分类名称
        dockingLoge.setClassifyOid("-");//分类主键
        dockingLoge.setUniqueCode("-");//唯一标识
        dockingLoge.setSystemOid("-");//系统标识
//        dockingLogeDO.setName(operation);
        //dockingLogeDO.setOid(oid);//日志主键
        dockingLoge.setParamString(parmaData);//参数信息
        dockingLoge.setReturnString(result);//返回信息
        dockingLoge.setType(operation);//日志操作类型
        if(isSucess) {
            dockingLoge.setInterfaceStatus("true");//接口集成状态
        }else{
            dockingLoge.setInterfaceStatus("false");//接口集成状态
        }
        dockingLogeService.save(dockingLoge);
        logger.info("集成推送数据成功,systemId:"+systemId+",systemname:"+systemName+",operation:"+operation+",param:"+parmaData);
    }

    /***
     * 数据维护与编码申请返回
     * @param resultSystemVO
     * @param dataType
     * @return
     */
    private String transferResultXMl(XMLResultSystemVO resultSystemVO,String dataType){
        String resultStr="";
        if ("xml".equals(dataType)) {
            //组织返回接口信息
            XStream xStream = new XStream(new DomDriver());
            xStream.processAnnotations(XMLResultSystemVO.class);
            xStream.autodetectAnnotations(true);
            resultStr = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" + xStream.toXML(resultSystemVO);
        } else {
            List<XMLResultClassfyVO> resultClassfyVOList =resultSystemVO.getClassifys();
            JSONResultDataVO resultDataVO = new JSONResultDataVO();
            JSONResultSystemVO jsonResultSystemVO = new JSONResultSystemVO();
            JSONResultClassfysVO jsonResultClassfysVO = new JSONResultClassfysVO();
            List<JSONResultClassfyVO> jSONResultClassfyVOList = new ArrayList<>();
            resultClassfyVOList.stream().forEach(resultClassfyVO -> {
                List<XMLResultDataObjectDetailDO> xmlResultDataObjectDetailDOS = resultClassfyVO.getObjects();
                List<JSONResultDataObjectDetailDO> JSONResultDataObjectDetailDOList = new ArrayList<>();
                xmlResultDataObjectDetailDOS.stream().forEach(xmlResultDataObjectDetail -> {
                    JSONResultDataObjectDetailDO jsonResultDataObjectDetail = new JSONResultDataObjectDetailDO();
                    BeanUtilForVCI.copyPropertiesIgnoreCase(xmlResultDataObjectDetail, jsonResultDataObjectDetail);
                    JSONResultDataObjectDetailDOList.add(jsonResultDataObjectDetail);
                });
                JSONResultClassfyVO jsonResultClassfyVO = new JSONResultClassfyVO();
                jsonResultClassfyVO.setClassCode(resultClassfyVO.getClassCode());
                jsonResultClassfyVO.setLibrary(resultClassfyVO.getLibrary());
                jsonResultClassfyVO.setFullclsfNamePath(resultClassfyVO.getFullclsfNamePath());
                JSONResultDataObjectDO JSONResultDataObjectDO = new JSONResultDataObjectDO();
                JSONResultDataObjectDO.setObject(JSONResultDataObjectDetailDOList);
                jsonResultClassfyVO.setObjects(JSONResultDataObjectDO);
                jSONResultClassfyVOList.add(jsonResultClassfyVO);
            });
            jsonResultClassfysVO.setClassify(jSONResultClassfyVOList);
            jsonResultSystemVO.setClassifys(jsonResultClassfysVO);
            jsonResultSystemVO.setErrorid(resultSystemVO.getErrorid());
            jsonResultSystemVO.setMsg(resultSystemVO.getMsg());
            resultDataVO.setData(jsonResultSystemVO);
            Object object = JSONObject.toJSON(resultDataVO);
            resultStr = object.toString();

        }
        return resultStr;
    }


}

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

@@ -0,0 +1,46 @@
package com.vci.ubcs.code.util;

import com.alibaba.cloud.commons.lang.StringUtils;
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;
import com.vci.ubcs.code.vo.webserviceModel.attrmap.LibraryDO;
import com.vci.ubcs.starter.util.LocalFileUtil;
import com.vci.ubcs.webservice.config.AttributeMapConfig;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.Map;

public class gennerAttrMapUtil {
    @Autowired(required = false)
    private AttributeMapConfig attributeMapConfig;
    private static  String fileName="";
    private static gennerAttrMapUtil newInstance=null;
    public static gennerAttrMapUtil getNewInstance() {
        if(newInstance==null){
            newInstance=new gennerAttrMapUtil();
        }
        return newInstance;
    }

    /****
     * 获取
     * @param systemId
     */
    public LibraryDO gennerAttrMapBySystem(String systemId, Map<String, String> system_attrmap) throws Throwable{
        if(StringUtils.isBlank(systemId)){
            throw new Throwable("系统标识为空");
        }
        LibraryDO rootDataVO=new LibraryDO();
        if(system_attrmap.containsKey(systemId)){
           String path=system_attrmap.get(systemId);
           String attributeMapData=  LocalFileUtil.readContentForFile(path);
           XStream xStream = new XStream(new DomDriver());
           xStream.processAnnotations(LibraryDO.class);
           xStream.autodetectAnnotations(true);
            rootDataVO = (LibraryDO) xStream.fromXML(attributeMapData);

        }
        return rootDataVO;
    }

}

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

@@ -0,0 +1,16 @@
package com.vci.ubcs.code.wrapper;

import com.vci.ubcs.code.entity.DockingLog;
import com.vci.ubcs.code.vo.pagemodel.DockingLogeVO;
import org.springblade.core.mp.support.BaseEntityWrapper;
import org.springblade.core.tool.utils.BeanUtil;

import java.util.Objects;

public class DockingLogeWrapper extends BaseEntityWrapper<DockingLog, DockingLogeVO> {
    @Override
    public DockingLogeVO entityVO(DockingLog entity) {
        DockingLogeVO dockingLogeVO = Objects.requireNonNull(BeanUtil.copy(entity, DockingLogeVO.class));
        return dockingLogeVO;
    }
}