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

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,922 @@
package com.vci.ubcs.code.webservice.service.impl;

import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.vci.ubcs.code.webservice.entity.*;
import com.vci.ubcs.code.webservice.vo.*;
import com.vci.ubcs.starter.util.MdmBtmTypeConstant;
import com.vci.ubcs.code.webservice.feign.MdmApplyGroupCodeProvider;
import com.vci.ubcs.code.webservice.mapper.DockingPreAttrMappingMapper;
import com.vci.ubcs.code.webservice.service.*;
import com.vci.ubcs.starter.exception.VciBaseException;
import com.vci.ubcs.starter.revision.model.BaseModel;
import com.vci.ubcs.starter.util.DefaultAttrAssimtUtil;
import com.vci.ubcs.starter.web.util.BeanUtilForVCI;
import com.vci.ubcs.starter.web.util.VciBaseUtil;
import lombok.extern.slf4j.Slf4j;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.api.R;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

/***
 * ä¸Žé›†å›¢é›†æˆæœåŠ¡
 * @author xiejun
 * @date 2023-05-26
 */
@Service
@Slf4j
public class GroupMdmInterServiceImpl implements IGroupMdmInterService {

   private String code="";

   private String msg="";


   @Value("${docking.apply.unitCode:41000}")
   public String dockingApplyUnitCode;

   @Value("${docking.apply.sysName:410-MDM}")
   public String dockingApplySysName;

   @Autowired(required = false)
   private MdmApplyGroupCodeProvider mdmApplyGroupCodeProvider;
   /***
    * é›†å›¢åˆ†ç±»æœåŠ¡
    */
   @Autowired(required = false)
   private IDockingPreClassifyService dockingPreClassifyService;

   /***
    * ç”³è¯·å•æœåŠ¡
    */
   @Autowired(required = false)
   private IDockingPreApplyFormService dockingPreApplyFormService;


   /***
    * æ¨¡åž‹è§†å›¾å•æœåŠ¡
    */
   @Autowired(required = false)
   private IDockingPreViewModelService dockingPreViewModelService;


   /***
    * é›†å›¢åˆ†ç±»å±žæ€§å±žæ€§æ˜ å°„配置服务
    */
   @Autowired(required = false)
   private DockingPreAttrMappingMapper dockingPreAttrMappingMapper;
   /***
    * å±žæ€§å–值范围服务
    */
   @Autowired(required = false)
   private IDockingPreAttrRangeService dockingPreAttrRangeService;


   /***
    * é›†å›¢å±žæ€§æœåŠ¡
    */
   @Autowired(required = false)
   private IDockingPreMetaAttrService dockingPreMetaAttrService;
   /***
    * ä¸»æ•°æ®åƒé›†å›¢ç”³è¯·ç¼–码
    * @param oids éœ€è¦ç”³è¯·çš„数据主键数组
    * @param btmName ä¸šåŠ¡ç±»åž‹
    * @return è¿”回结果信息
    * @throws Exception
    */
   @Transactional(rollbackFor = VciBaseException.class)
   @Override
   public R applyGroupCode(String oids, String btmName) throws VciBaseException {
      try {
         List<BaseModel> updateCbos = new ArrayList<BaseModel>();

         List<DockingPreApplyForm> dockingPreAttrMappings = new ArrayList<>();
         VciBaseUtil.alertNotNull(oids, "选择的数据");
         VciBaseUtil.alertNotNull(btmName, "业务类型");
         //List<BaseModelVO> codeWupins=mdmEngineService.listByIds(VciBaseUtil.str2List(oids));
         List<BaseModelVO> dataModelList = new ArrayList<>();
         if (!CollectionUtils.isEmpty(dataModelList)) {
            DockingGroupDataVO dockingGroupDataVO = new DockingGroupDataVO();
            //申请单和申请单对象关系
            Map<String, DockingPreApplyForm> addDockingPreApplyFormMap = new HashMap<String, DockingPreApplyForm>();
            Map<String, DockingPreApplyForm> editDockingPreApplyFormMap = new HashMap<String, DockingPreApplyForm>();
            Map<String, BaseModelVO> baseModelVOMap = new HashMap<String, BaseModelVO>();
            //组织数据
            dockingGroupDataVO = queryApplycodeDataObjects(1, dataModelList, addDockingPreApplyFormMap, editDockingPreApplyFormMap, baseModelVOMap);
            DockingResultVO resultDataObject = mdmApplyGroupCodeProvider.receiveAddApply(dockingGroupDataVO);
            code = resultDataObject.getCode();
            msg = resultDataObject.getMsg();
            if ("1".equals(resultDataObject.getCode())) {//结果正确的情况
               List<DockingDataVO> dataObjectVOList = resultDataObject.getData();
               dataObjectVOList.stream().forEach(dataObject -> {
                  boolean isEditDatas = false;
                  String code2 = dataObject.getCode();
                  DockingMainDataVO data2 = dataObject.getData();
                  String applyId = data2.getApplyId();//申请单id
                  String customCoding = StringUtils.isBlank(data2.getCustomCoding()) ? "" : data2.getCustomCoding();//集团码段
                  msg = dataObject.getMsg();
                  if (code2.equals("1")) {//结果正确的情况
                     if (!"".equals(customCoding)) {
                        isEditDatas = true;
                     }
                  }
                  //需要修改的申请单数据
                  if (editDockingPreApplyFormMap.containsKey(applyId)) {
                     DockingPreApplyForm dockingPreApplyForm = editDockingPreApplyFormMap.get(applyId);
                     dockingPreApplyForm.setCode(code2);
                     dockingPreApplyForm.setMsg("申请：" + msg);
                     dockingPreApplyForm.setGroupCode(customCoding);
                     ObjectMapper mp = new ObjectMapper();
                     String writeValueAsString = null;
                     try {
                        writeValueAsString = mp.writeValueAsString(dataObject);
                        dockingPreApplyForm.setContent(writeValueAsString);
                     } catch (JsonProcessingException e) {
                     }
                  }
                  //新增的申请单数据
                  if (addDockingPreApplyFormMap.containsKey(applyId)) {
                     DockingPreApplyForm dockingPreApplyForm = addDockingPreApplyFormMap.get(applyId);
                     dockingPreApplyForm.setCode(code2);
                     dockingPreApplyForm.setMsg("申请：" + msg);
                     dockingPreApplyForm.setGroupCode(customCoding);
                     ObjectMapper mp = new ObjectMapper();
                     String writeValueAsString = null;
                     try {
                        writeValueAsString = mp.writeValueAsString(dataObject);
                        dockingPreApplyForm.setContent(writeValueAsString);
                     } catch (JsonProcessingException e) {
                     }
                  }
                  //如果有集团码则更新数据
                  if (isEditDatas) {
                     if (baseModelVOMap.containsKey(applyId)) {
                        BaseModelVO baseModelVO = baseModelVOMap.get(applyId);
                        BaseModel baseModel = new BaseModel();
                        BeanUtilForVCI.copyDeclaredIgnoreCase(baseModelVO, baseModel);
                        DefaultAttrAssimtUtil.updateDefaultAttrAssimt(baseModel);
                        DefaultAttrAssimtUtil.updateDefaultAttrAssimt(baseModel);
                        baseModelVO.setId(customCoding);
                        updateCbos.add(baseModel);//更新数据集团code
                     }
                  }
               });
            } else {
               editDockingPreApplyFormMap.forEach((key, dockingPreApplyForm) -> {
                  dockingPreApplyForm.setCode("2");
                  dockingPreApplyForm.setMsg("申请：" + msg);
                  dockingPreApplyForm.setContent("");
                  dockingPreApplyForm.setGroupCode("");
                  DefaultAttrAssimtUtil.updateDefaultAttrAssimt(dockingPreApplyForm);
               });
               addDockingPreApplyFormMap.forEach((key, dockingPreApplyForm) -> {
                  dockingPreApplyForm.setCode("2");
                  dockingPreApplyForm.setMsg("申请：" + msg);
                  dockingPreApplyForm.setContent("");
                  dockingPreApplyForm.setGroupCode("");
                  DefaultAttrAssimtUtil.addDefaultAttrAssimt(dockingPreApplyForm, MdmBtmTypeConstant.DOCKING_PRE_JAPPLYFORM);
               });
            }
            if (editDockingPreApplyFormMap.size() > 0) {
               dockingPreAttrMappings.addAll(editDockingPreApplyFormMap.values());//添加申请单数据
            }
            if (addDockingPreApplyFormMap.size() > 0) {
               dockingPreAttrMappings.addAll(addDockingPreApplyFormMap.values());//需要修改的申请单数据
            }
            //保存表单数据
            dockingPreApplyFormService.saveOrUpdateBatch(dockingPreAttrMappings);
            //mdmEngineService.saveBatch(updateCbos);//保存数据
         }
         return R.success("申请接口调用成功");
      }catch (VciBaseException e){
         return R.success("申请接口调用成功"+e);
      }
   }

   /***
    * ä¸»æ•°æ®åƒé›†å›¢æ›´æ”¹ç¼–码
    * @param oids éœ€è¦ä¿®æ”¹çš„数据主键数组
    * @param btmName ä¸šåŠ¡ç±»åž‹
    * @return è¿”回结果信息
    * @throws Throwable
    */
   @Transactional(rollbackFor = VciBaseException.class)
   @Override
   public R receiveEditApply(String oids, String btmName) throws VciBaseException {
      List<BaseModel> updateCbos=new ArrayList<BaseModel>();
      List<DockingPreApplyForm> dockingPreAttrMappings=new ArrayList<>();
      VciBaseUtil.alertNotNull(oids,"选择的数据");
      VciBaseUtil.alertNotNull(btmName,"业务类型");
      //List<BaseModelVO> codeWupins=mdmEngineService.listByIds(VciBaseUtil.str2List(oids));
      List<BaseModelVO> dataModelList = new ArrayList<>();
      try {
         if (!CollectionUtils.isEmpty(dataModelList)) {
            DockingGroupDataVO dockingGroupDataVO = new DockingGroupDataVO();
            //申请单和申请单对象关系
            Map<String, DockingPreApplyForm> addDockingPreApplyFormMap = new HashMap<String, DockingPreApplyForm>();
            Map<String, DockingPreApplyForm> editDockingPreApplyFormMap = new HashMap<String, DockingPreApplyForm>();
            Map<String, BaseModelVO> baseModelVOMap = new HashMap<String, BaseModelVO>();
            //组织数据
            dockingGroupDataVO = queryApplycodeDataObjects(2, dataModelList, addDockingPreApplyFormMap, editDockingPreApplyFormMap, baseModelVOMap);
            DockingResultVO resultDataObject = mdmApplyGroupCodeProvider.receiveEditApply(dockingGroupDataVO);
            code = resultDataObject.getCode();
            msg = resultDataObject.getMsg();
            if ("1".equals(resultDataObject.getCode())) {//结果正确的情况
               List<DockingDataVO> dataObjectVOList = resultDataObject.getData();
               dataObjectVOList.stream().forEach(dataObject -> {
                  boolean isEditDatas = false;
                  String code2 = dataObject.getCode();
                  DockingMainDataVO data2 = dataObject.getData();
                  String applyId = data2.getApplyId();//申请单id
                  String customCoding = StringUtils.isBlank(data2.getCustomCoding()) ? "" : data2.getCustomCoding();//集团码段
                  msg = dataObject.getMsg();
                  if (code2.equals("1")) {//结果正确的情况
                     if (!"".equals(customCoding)) {
                        isEditDatas = true;
                     }
                  }
                  //需要修改的申请单数据
                  if (editDockingPreApplyFormMap.containsKey(applyId)) {
                     DockingPreApplyForm dockingPreApplyForm = editDockingPreApplyFormMap.get(applyId);
                     dockingPreApplyForm.setCode(code2);
                     dockingPreApplyForm.setMsg("修改：" + msg);
                     dockingPreApplyForm.setGroupCode(customCoding);
                     ObjectMapper mp = new ObjectMapper();
                     String writeValueAsString = null;
                     try {
                        writeValueAsString = mp.writeValueAsString(dataObject);
                        dockingPreApplyForm.setContent(writeValueAsString);
                     } catch (JsonProcessingException e) {
                     }
                  }
                  //新增的申请单数据
                  if (addDockingPreApplyFormMap.containsKey(applyId)) {
                     DockingPreApplyForm dockingPreApplyForm = addDockingPreApplyFormMap.get(applyId);
                     dockingPreApplyForm.setCode(code2);
                     dockingPreApplyForm.setMsg("修改：" + msg);
                     dockingPreApplyForm.setGroupCode(customCoding);
                     ObjectMapper mp = new ObjectMapper();
                     String writeValueAsString = null;
                     try {
                        writeValueAsString = mp.writeValueAsString(dataObject);
                        dockingPreApplyForm.setContent(writeValueAsString);
                     } catch (JsonProcessingException e) {
                     }
                  }
                  //如果有集团码则更新数据
                  if (isEditDatas) {
                     if (baseModelVOMap.containsKey(applyId)) {
                        BaseModelVO baseModelVO = baseModelVOMap.get(applyId);
                        BaseModel baseModel = new BaseModel();
                        BeanUtilForVCI.copyDeclaredIgnoreCase(baseModelVO, baseModel);
                        DefaultAttrAssimtUtil.updateDefaultAttrAssimt(baseModel);
                        DefaultAttrAssimtUtil.updateDefaultAttrAssimt(baseModel);
                        baseModelVO.setId(customCoding);
                        updateCbos.add(baseModel);//更新数据集团code
                     }
                  }
               });
            } else {
               editDockingPreApplyFormMap.forEach((key, dockingPreApplyForm) -> {
                  dockingPreApplyForm.setCode("2");
                  dockingPreApplyForm.setMsg("修改：" + msg);
                  dockingPreApplyForm.setContent("");
                  dockingPreApplyForm.setGroupCode("");
                  DefaultAttrAssimtUtil.updateDefaultAttrAssimt(dockingPreApplyForm);
               });
               addDockingPreApplyFormMap.forEach((key, dockingPreApplyForm) -> {
                  dockingPreApplyForm.setCode("2");
                  dockingPreApplyForm.setMsg("修改：" + msg);
                  dockingPreApplyForm.setContent("");
                  dockingPreApplyForm.setGroupCode("");
                  DefaultAttrAssimtUtil.addDefaultAttrAssimt(dockingPreApplyForm, MdmBtmTypeConstant.DOCKING_PRE_JAPPLYFORM);
               });
            }
            if (editDockingPreApplyFormMap.size() > 0) {
               dockingPreAttrMappings.addAll(editDockingPreApplyFormMap.values());//添加申请单数据
            }
            if (addDockingPreApplyFormMap.size() > 0) {
               dockingPreAttrMappings.addAll(addDockingPreApplyFormMap.values());//需要修改的申请单数据
            }
            //保存表单数据
            dockingPreApplyFormService.saveOrUpdateBatch(dockingPreAttrMappings);
            //mdmEngineService.saveBatch(updateCbos);//保存数据
         }
         return R.success("申请接口调用成功");
      }catch (VciBaseException e){
         return R.fail("申请接口调用失败"+e.getMessage());
      }
   }

   /***
    * èŽ·å–集团模型详细信息执行保存
    * @param groupClassifyId
    * @return
    * @throws VciBaseException
    */
   @Override
   public R queryClassModel(String groupClassifyId) throws VciBaseException {
      log.info("获取集团模型详细信息执行保存start");
      String message="执行成功！";
      try {
         if (StringUtils.isBlank(groupClassifyId)) {
            message = "参数：集团分类主键，为空!";
            log.info(message);
            throw new Throwable(message);
         }
         if (StringUtils.isBlank(dockingApplySysName)) {
            message = "获取系统标识" + dockingApplySysName + "为空，请查看配置！";
            log.info(message);
            throw new Throwable(message);
         }
         DockingModelQueryVO dockingModelQueryVO = new DockingModelQueryVO();
         dockingModelQueryVO.setClassId(groupClassifyId);
         dockingModelQueryVO.setSysName(dockingApplySysName);
         DockingQueryClassModelVO dockingQueryClassifyModelVO = mdmApplyGroupCodeProvider.queryClassModel(dockingModelQueryVO);
         if (dockingQueryClassifyModelVO != null) {
            int code = dockingQueryClassifyModelVO.getCode();
            message = dockingQueryClassifyModelVO.getMsg();
            if (code == 1) {
               this.saveDatas(dockingQueryClassifyModelVO);
            } else {
               log.info(message);
               throw new Throwable(message);
            }
         }else{
            message="未获从集团获取到任何模型信息";
            log.info(message);
            throw new Throwable(message);
         }
         return R.success(message);
      }catch (Throwable e){
         e.printStackTrace();;
         log.error("获取数据模型详细信息失败"+e);
         R.fail(message);
      }
      log.info("获取集团模型详细信息执行保存end");
      return R.success(message);
   }

   /***
    * ä»Žé›†å›¢èŽ·å–主模型信息执行保存
    * @return
    * @throws Throwable
    */
   @Override
   public R queryMdmModel() throws Throwable {
      String message="执行成功！";
      log.info("从集团获取主模型信息执行保存接口statr");
      try {
         if (StringUtils.isBlank(dockingApplySysName)) {
            message = "获取系统标识" + dockingApplySysName + "为空，请查看配置！";
            log.info(message);
            throw new Throwable(message);
         }

         DockingModelQueryVO dockingModelQueryVO = new DockingModelQueryVO();
         dockingModelQueryVO.setSysName(dockingApplySysName);
         DockingQueryModelVO dockingQueryModelVO=  mdmApplyGroupCodeProvider.queryMdmModel(dockingModelQueryVO);
         if (dockingQueryModelVO != null) {
            int code = dockingQueryModelVO.getCode();
            message = dockingQueryModelVO.getMsg();
            if (code == 1) {
               List<DockingClassifyVO> dockingClassifyVOList=dockingQueryModelVO.getData();
               List<DockingPreClassify>dockingPreClassifyList=new ArrayList<>();
               dockingClassifyVOList.stream().forEach(dockingClassifyVO -> {
                  String id = StringUtils.isBlank(dockingClassifyVO.getId())?"":dockingClassifyVO.getId();
                  String className = StringUtils.isBlank(dockingClassifyVO.getClassName())?"":dockingClassifyVO.getClassName();
                  String classNumber = StringUtils.isBlank(dockingClassifyVO.getClassNumber())?"":dockingClassifyVO.getClassNumber();
                  String nodeLink = StringUtils.isBlank(dockingClassifyVO.getNodeLink())?"":dockingClassifyVO.getNodeLink();
                  String nodeLinkName = StringUtils.isBlank(dockingClassifyVO.getNodeLinkName())?"":dockingClassifyVO.getNodeLinkName();
                  String pid = StringUtils.isBlank(dockingClassifyVO.getPid())?"":dockingClassifyVO.getPid();
                  String version = StringUtils.isBlank(dockingClassifyVO.getVersion())?"":dockingClassifyVO.getVersion();
                  DockingPreClassify dockingPreClassify=   this.dockingPreClassifyService.getById(id);

                  log.info("classify:-------------->集团分类主机:"+id);
                  log.info("classify:-------------->集团分类名称:"+className);
                  log.info("classify:--------------> é›†å›¢åˆ†ç±»çˆ¶èŠ‚点:"+pid);
                  log.info("classify:-------------->链接:"+nodeLink);
                  log.info("classify:-------------->集团分类代号:"+classNumber);
                  log.info("classify:-------------->链接名称:"+nodeLinkName);
                  log.info("classify:-------------->链接版本:"+version);
                  if (dockingPreClassify == null || StringUtils.isBlank(dockingPreClassify.getOid())) {
                     DefaultAttrAssimtUtil.addDefaultAttrAssimt(dockingPreClassify,MdmBtmTypeConstant.DOCKING_PRE_JCLASSIFY);
                  } else {
                     DefaultAttrAssimtUtil.updateDefaultAttrAssimt(dockingPreClassify);
                  }
                  dockingPreClassify.setOid(id);
                  dockingPreClassify.setName(className);
                  dockingPreClassify.setPid(pid);
                  dockingPreClassify.setId(classNumber);
                  dockingPreClassify.setNodeLink(nodeLink);
                  dockingPreClassify.setGetNodeLinkName(nodeLinkName);
                  dockingPreClassify.setClassName(className);
                  dockingPreClassify.setVersionValue(version);
                  dockingPreClassifyList.add(dockingPreClassify);
               });
               boolean res=   dockingPreClassifyService.saveOrUpdateBatch(dockingPreClassifyList);
               if(res){
                  R.success(message);
               }else{
                  message="保存分类主模型失败";
                  throw new Throwable(message);
               }
            } else {
               log.info(message);
               throw new Throwable(message);
            }
         }else{
            message="未获从集团获取到任何模型信息";
            log.info(message);
            throw new Throwable(message);
         }
         return R.success(message);
      }catch (Throwable e){
         e.printStackTrace();;
         log.error("获取数据模型失败"+e);
         R.fail(message);
      }
      log.info("从集团获取主模型信息执行保存接口end");
      return R.success(message);
   }


   /***
    * ç»„织 ä¿å­˜æ•°æ®æ–¹æ³•
    *
    * @param dockingQueryClassifyModelVO
    * @return
    * @throws Throwable
    * @throws
    * @throws Throwable
    */
   private boolean saveDatas(DockingQueryClassModelVO dockingQueryClassifyModelVO) throws Throwable {
      try {
         DockingClassifyMainVO mainData = dockingQueryClassifyModelVO.getMainData();
         List<DockingClassifyVO> classList = mainData.getClassList();
         Map<String,List<DockingClassifyViewVO>>classInfoMap = mainData.getClassInfos();
         ////initVCIInvocationInfo("1");
         List<DockingPreClassify> dockingPreClassifyArrayList=new ArrayList<>();
         for (DockingClassifyVO jclassObject : classList) {
            String id =StringUtils.isBlank(jclassObject.getId())?"":jclassObject.getId();
            String className = StringUtils.isBlank(jclassObject.getClassName())?"":jclassObject.getClassName();
            String pid = StringUtils.isBlank(jclassObject.getPid())?"":jclassObject.getPid();
            String nodeLink = StringUtils.isBlank(jclassObject.getNodeLink())?"":jclassObject.getNodeLink();
            String nodeLinkName = StringUtils.isBlank(jclassObject.getNodeLinkName())?"":jclassObject.getNodeLinkName();
            String classNumber = StringUtils.isBlank(jclassObject.getClassNumber())?"":jclassObject.getClassNumber();
            //根据分类查询模型视图对象
            DockingPreClassify dockingPreClassify = dockingPreClassifyService.getById(id);
            log.info("classify:-------------->集团分类主机:"+id);
            log.info("classify:-------------->集团分类名称:"+className);
            log.info("classify:--------------> é›†å›¢åˆ†ç±»çˆ¶èŠ‚点:"+pid);
            log.info("classify:-------------->链接:"+nodeLink);
            log.info("classify:-------------->链接名称:"+nodeLinkName);

            if (dockingPreClassify == null || StringUtils.isBlank(dockingPreClassify.getOid())) {
               DefaultAttrAssimtUtil.addDefaultAttrAssimt(dockingPreClassify,MdmBtmTypeConstant.DOCKING_PRE_JCLASSIFY);
            } else {
               DefaultAttrAssimtUtil.updateDefaultAttrAssimt(dockingPreClassify);
            }
            dockingPreClassify.setOid(id);
            dockingPreClassify.setName(className);
            dockingPreClassify.setPid(pid);
            dockingPreClassify.setId(classNumber);
            dockingPreClassify.setNodeLink(nodeLink);
            dockingPreClassify.setGetNodeLinkName(nodeLinkName);
            dockingPreClassify.setClassName(className);
            dockingPreClassifyArrayList.add(dockingPreClassify);
            // èŽ·å–对应的分类视图模型
            if (classInfoMap.containsKey(id)) {
               List<DockingClassifyViewVO> list = classInfoMap.get(id);
               getVilewMode(jclassObject,list);
            }
         }
         boolean res= dockingPreClassifyService.saveOrUpdateBatch(dockingPreClassifyArrayList);
         return res;
      } catch (Throwable e) {
         e.printStackTrace();
         throw new Throwable("存储视图模型出现问题");
      }
   }

   /***
    * èŽ·å–分类视图
    *
    * @param jclassObject
    * @throws Throwable
    */
   private void getVilewMode(DockingClassifyVO jclassObject, List<DockingClassifyViewVO> list)
      throws Throwable {
      String nodeLinkName = jclassObject.getNodeLinkName();
      try {
         String jclassId = com.alibaba.cloud.commons.lang.StringUtils.isBlank(jclassObject.getId())?"":jclassObject.getId();
         Map<String, DockingPreViewModel> jviewmodelMap = new HashMap<String, DockingPreViewModel>();
         //Map<String, String> condtionMa = new HashMap<String, String>();
         //   condtionMa.put("jsourceclsfid", jclassId);
         List<DockingPreViewModel> dockingPreViewModelList= dockingPreViewModelService.list(Wrappers.<DockingPreViewModel>query().lambda().eq(DockingPreViewModel::getSourceClassifyId,false));// æ ¹æ®åˆ†ç±»æŸ¥è¯¢æ¨¡åž‹è§†å›¾å¯¹è±¡
         for (DockingPreViewModel dockingPreViewModel : dockingPreViewModelList) {
            jviewmodelMap.put(dockingPreViewModel.getViewName(),dockingPreViewModel);
         }

         for (DockingClassifyViewVO viewInfo : list) {
            String viewName = com.alibaba.cloud.commons.lang.StringUtils.isBlank(viewInfo.getViewName())?"":viewInfo.getViewName();
            String impactList = com.alibaba.cloud.commons.lang.StringUtils.isBlank(viewInfo.getImpactList())?"":viewInfo.getImpactList();
            log.info("VilewMode:-------------->视图名称:"+viewName);
            log.info("VilewMode:-------------->影响编码项:"+impactList);
            log.info("VilewMode:--------------> é›†å›¢åˆ†ç±»ä¸»é”®:"+jclassId);
            List<DockingClassifyMetaAttrVO> metaList = viewInfo.getMetaList();
            DockingPreViewModel jviewModelObject = null;
            if (jviewmodelMap.containsKey(viewName)) {
               jviewModelObject = jviewmodelMap.get(viewName);
               //影响编码项的数据
               jviewModelObject.setImpactList(impactList);
               DefaultAttrAssimtUtil.updateDefaultAttrAssimt(jviewModelObject);
            } else {
               jviewModelObject =new DockingPreViewModel();
               DefaultAttrAssimtUtil.addDefaultAttrAssimt(jviewModelObject,MdmBtmTypeConstant.DOCKING_PRE_JVIEWMODEL);
               jviewModelObject.setSourceClassifyId(jclassId);// é›†å›¢åˆ†ç±»id
               jviewModelObject.setViewName(viewName);// é›†å›¢è§†å›¾åç§°
               //影响编码项的数据
               jviewModelObject.setImpactList(impactList);
               dockingPreViewModelList.add(jviewModelObject);
            }
            // èŽ·å–模型视图下的属性集
            // String oid = jviewModelObject.getOid();
            List<DockingPreMetaAttr>allDockingPreMetaAttrList=new ArrayList<>();
            getMetaAttrObject(metaList, jclassId, jviewModelObject, "root",allDockingPreMetaAttrList);
            //保存模型视图属性
            dockingPreMetaAttrService.saveOrUpdateBatch(allDockingPreMetaAttrList);
            //保存模型视图
            dockingPreViewModelService.saveOrUpdateBatch(dockingPreViewModelList);
         }
      } catch (Throwable e) {
         e.printStackTrace();
         throw new Throwable("组织分类" + nodeLinkName + "模型视图存储出现问题");
      }
   }


   /***
    * èŽ·å–模型视图属性
    * @throws Throwable
    */
   private void getMetaAttrObject(List<DockingClassifyMetaAttrVO> metaList,
                           String jclassId, DockingPreViewModel jviewModelObject, String pid,List<DockingPreMetaAttr>allDockingPreMetaAttrList)throws Throwable {
      try {
         //// æ ¹æ®åˆ†ç±»æŸ¥è¯¢æ¨¡åž‹è§†å›¾å¯¹è±¡
         List<DockingPreMetaAttr> dockingPreMetaAttrList = dockingPreMetaAttrService.selectByWrapper(Wrappers.<DockingPreMetaAttr>query().lambda()
            .eq(DockingPreMetaAttr::getSourceClassifyId,jclassId).eq(DockingPreMetaAttr::getViewModelId,jviewModelObject.getOid())
            .eq(DockingPreMetaAttr:: getPid,pid));
         Map<String,DockingPreMetaAttr> jmetaattrMap = dockingPreMetaAttrList.stream().filter(
            s -> com.alibaba.cloud.commons.lang.StringUtils.isNotBlank(s.getEnglishName())).collect(Collectors.toMap(s -> s.getEnglishName().toLowerCase(Locale.ROOT), t -> t));

         for (DockingClassifyMetaAttrVO dockingClassifyMetaAttrVO : metaList) {
            String chineseName = com.alibaba.cloud.commons.lang.StringUtils.isBlank(dockingClassifyMetaAttrVO.getChineseName())?"":dockingClassifyMetaAttrVO.getChineseName();// å±žæ€§åç§°
            String englishName = com.alibaba.cloud.commons.lang.StringUtils.isBlank(dockingClassifyMetaAttrVO.getEnglishName())?"":dockingClassifyMetaAttrVO.getEnglishName();// è‹±æ–‡åç§°
            String defaultValue = com.alibaba.cloud.commons.lang.StringUtils.isBlank(dockingClassifyMetaAttrVO.getDefaultValue())?"":dockingClassifyMetaAttrVO.getDefaultValue();
            Integer metadataType =dockingClassifyMetaAttrVO.getMetadataType();// ç±»åž‹
            Integer necessaryConf = dockingClassifyMetaAttrVO.getNecessaryConf();// æ˜¯å¦å¿…å¡«
            Map<String, String> range = dockingClassifyMetaAttrVO.getRange()==null?new HashMap<String, String>():dockingClassifyMetaAttrVO.getRange();// å–值范围

            log.info("metaAttr:-------------->属性名称:"+chineseName);
            log.info("metaAttr:-------------->英文名称:"+englishName);
            log.info("metaAttr:-------------->默认值:"+defaultValue);
            log.info("metaAttr:--------------> ç±»åž‹:"+metadataType);
            log.info("metaAttr:-------------->  æ˜¯å¦å¿…å¡«:"+necessaryConf);
            DockingPreMetaAttr dockingPreMetaAttr = new DockingPreMetaAttr();
            if (jmetaattrMap.containsKey(englishName)) {
               dockingPreMetaAttr = jmetaattrMap.get(englishName);
               dockingPreMetaAttr.setChineseName(chineseName);
               dockingPreMetaAttr.setDefaultValue(defaultValue);
               DefaultAttrAssimtUtil.updateDefaultAttrAssimt(dockingPreMetaAttr);
            } else {
               DefaultAttrAssimtUtil.addDefaultAttrAssimt(dockingPreMetaAttr,MdmBtmTypeConstant.DOCKING_PRE_JMETAATRR);
               dockingPreMetaAttr.setSourceClassifyId(jclassId);// é›†å›¢åˆ†ç±»id
               dockingPreMetaAttr.setViewModelId(jviewModelObject.getOid());// é›†å›¢è§†å›¾æ¨¡åž‹id
               dockingPreMetaAttr.setChineseName(chineseName);// å±žæ€§åç§°
               dockingPreMetaAttr.setEnglishName(englishName);// å±žæ€§å­—段
               dockingPreMetaAttr.setDefaultValue(defaultValue);// å±žæ€§åç§°
               dockingPreMetaAttr.setMetaDataType(metadataType);// å±žæ€§ç±»åž‹
               dockingPreMetaAttr.setNecesSaryConf(necessaryConf);// å±žæ€§å¿…填项
               dockingPreMetaAttr.setPid(pid);// çˆ¶èŠ‚点id
            }
            if(range!=null&&range.size()>0){
               // èŽ·å–属性值域
               getRange(dockingPreMetaAttr, range);
            }
            /***
             * èŽ·å–子节点
             */
            DockingClassifyMetaAttrVO compositeMeta = dockingClassifyMetaAttrVO.getCompositeMeta();
            if (compositeMeta != null) {
               pid = com.alibaba.cloud.commons.lang.StringUtils.isBlank(dockingPreMetaAttr.getOid())?"":dockingPreMetaAttr.getOid();// å½“前oid
               List<DockingClassifyMetaAttrVO> childMetaList = new ArrayList<>();
               childMetaList.add(compositeMeta);
               getMetaAttrObject(childMetaList, jclassId,jviewModelObject, pid,allDockingPreMetaAttrList);
            }

         }

      } catch (Throwable e) {
         e.printStackTrace();
         log.error("组织模型视图"+ jviewModelObject.getViewName()
            + "属性存储出现问题" + e);
         throw new Throwable("组织模型视图"+ jviewModelObject.getViewName()
            + "属性存储出现问题" + e);
      }
   }

   /**
    * @throws Throwable
    *             * èŽ·å–值域
    * @param metaAttrObject
    * @param range
    * @throws
    */
   private void getRange(DockingPreMetaAttr metaAttrObject,Map<String, String> range) throws Throwable {
      String metaAttrOid = com.alibaba.cloud.commons.lang.StringUtils.isBlank(metaAttrObject.getOid())?"":metaAttrObject.getOid();// å±žæ€§çš„oid
      String jchinesename = com.alibaba.cloud.commons.lang.StringUtils.isBlank(metaAttrObject.getChineseName())?"":metaAttrObject.getChineseName();
      Map<String, DockingPreAttrRange> rangeMap = new HashMap<>();
      try {
         Map<String, String> condtionMa = new HashMap<String, String>();
         condtionMa.put("jmetalistid", metaAttrOid);
         List<DockingPreAttrRange> jmetaattrList = dockingPreAttrRangeService.selectByWrapper(Wrappers.<DockingPreAttrRange>query().lambda()
            .eq(DockingPreAttrRange::getMetaListId,metaAttrOid));// æ ¹æ®åˆ†ç±»æŸ¥è¯¢æ¨¡åž‹è§†å›¾å¯¹è±¡
         rangeMap= jmetaattrList.stream().collect(Collectors.toMap(s -> com.alibaba.cloud.commons.lang.StringUtils.isNotBlank(s.getNumText().toLowerCase(Locale.ROOT))?"":s.getNumText().toLowerCase(Locale.ROOT), t -> t));

         for (String rangeKey : range.keySet()) {
            DockingPreAttrRange rangeObject = new DockingPreAttrRange();
            String keyValue = com.alibaba.cloud.commons.lang.StringUtils.isBlank(range.get(rangeKey))?"":range.get(rangeKey);
            log.info("range:-------------->显示值"+rangeKey+",内部值"+keyValue);
            if (rangeMap.containsKey(rangeKey)) {
               rangeObject = rangeMap.get(rangeKey);
               rangeObject.setNumTextValue(keyValue);
               rangeObject.setNumText(rangeKey);
               DefaultAttrAssimtUtil.updateDefaultAttrAssimt(rangeObject);
            } else {
               DefaultAttrAssimtUtil.addDefaultAttrAssimt(rangeObject,MdmBtmTypeConstant.DOCKING_PRE_JRANGE);
               rangeObject.setNumTextValue(keyValue);
               rangeObject.setNumText(rangeKey);
               rangeObject.setTs(rangeObject.getLastModifyTime());
               rangeObject.setMetaListId(metaAttrOid);
               log.info("range:-------------->属性内部值:"+metaAttrOid);
               log.info("range:-------------->时间:"+rangeObject.getLastModifyTime());
               jmetaattrList.add(rangeObject);
            }
         }
         dockingPreAttrRangeService.saveOrUpdateBatch(jmetaattrList);
      } catch (Throwable e) {
         e.printStackTrace();
         log.info("组织属性：【" + jchinesename + "】值域出现问题"+ e);
         throw new Throwable("组织属性：【" + jchinesename + "】值域出现问题"+ e);
      }
   }




   /**
    * ç»„织数据
    * */
   private DockingGroupDataVO queryApplycodeDataObjects(int optationtype,List<BaseModelVO> codeWupins,Map<String,DockingPreApplyForm>   addDockingPreApplyFormMap,Map<String,DockingPreApplyForm>  editDockingPreApplyFormMap,Map<String,BaseModelVO>  codeWupinMap) throws VciBaseException{
      try {
         String curUserName = AuthUtil.getUser().getUserName();
         //申请的数据
         List<DockingMainData> mainDataList=new ArrayList<DockingMainData>();
         for (BaseModelVO dataBusinessObject : codeWupins) {
            String format = new SimpleDateFormat("yyyyMMddHHmmssSSS").format(new Date());
            String codeclsfid = dataBusinessObject.getData().getOrDefault("codeclsfid","");
            String btmName = dataBusinessObject.getBtmname();
            String oid = dataBusinessObject.getOid();

            DockingPreApplyForm dockingPreApplyForm = new DockingPreApplyForm();

            String dataOid = dataBusinessObject.getOid();
            Map<String, String> conditionsMap = new HashMap<String, String>();
            List<DockingPreApplyForm> applyFormObjects = dockingPreApplyFormService.list(Wrappers.<DockingPreApplyForm>query().lambda().eq(DockingPreApplyForm::getDataOid, dataOid).eq(DockingPreApplyForm::getOperationType, optationtype));
            String apllyCode = "";
            if (!CollectionUtils.isEmpty(applyFormObjects)) {
               dockingPreApplyForm = applyFormObjects.get(0);
               apllyCode = dockingPreApplyForm.getId();
               editDockingPreApplyFormMap.put(apllyCode, dockingPreApplyForm);//申请单和申请单对象关系
            } else {
               apllyCode = dockingApplyUnitCode + "-" + format;
               dockingPreApplyForm.setId(apllyCode);
               dockingPreApplyForm.setName("");
               dockingPreApplyForm.setOperationType(optationtype+"");
               dockingPreApplyForm.setDescription(dataBusinessObject.getDescription());//获取数据描述信息
               dockingPreApplyForm.setDataOid(oid);
               dockingPreApplyForm.setDataBtmName(btmName);
               addDockingPreApplyFormMap.put(apllyCode, dockingPreApplyForm);//申请单和申请单对象关系
            }

            codeWupinMap.put(apllyCode, dataBusinessObject);//申请单和对应数据关系
            conditionsMap = new HashMap<String, String>();
            conditionsMap.put("jtargetclsfid", codeclsfid);//视图oid

            List<DockingPreAttrMapping> dockingPreAttrMappingList = dockingPreAttrMappingMapper.selectList(Wrappers.<DockingPreAttrMapping>query().lambda().eq(DockingPreAttrMapping::getTargetClassifyId, codeclsfid));
            if (CollectionUtils.isEmpty(dockingPreAttrMappingList)) {
               throw new Exception("根据所选的数据，没有找到对应的集团分类设置，请核对!");
            }
            String jsourceclsfid = dockingPreAttrMappingList.get(0).getSourceClassifyId();
            //获取数据模型分类信息
            DockingPreClassify dockingPreClassify = dockingPreClassifyService.getById(jsourceclsfid);
            DockingMainData mainData = new DockingMainData();
            mainData.setApplyEntId(dockingApplyUnitCode);//申请单位代码
            mainData.setApplyId(apllyCode);//申请单号
            mainData.setClassName(dockingPreClassify.getGetNodeLinkName());//分类名称
            mainData.setCreateBy(curUserName);//
            mainData.setSecretLevel("内部");//密级，默认为内部
            mainData.setViewInfos(getviewInfos(optationtype,dockingPreClassify, dataBusinessObject));//获取视图模型
            mainDataList.add(mainData);
         }
         //根据数据模型，组织所需要数据
         DockingGroupDataVO postParameters=new DockingGroupDataVO();
         postParameters.setSysName(dockingApplySysName);//系统标识
         postParameters.setMainData(mainDataList);//
         return postParameters;
      } catch (Throwable e) {
         // TODO Auto-generated catch block
         throw new VciBaseException("查询数据出错"+e);
      }
   }

   /**
    * èŽ·å–模型视图
    * @param dockingPreClassify
    * @param dataBusinessObject
    * @throws VciBaseException
    */
   private List<DockingViewVO>getviewInfos(int type, DockingPreClassify dockingPreClassify, BaseModelVO dataBusinessObject) throws Throwable{
      List<DockingViewVO> viewInfoList=new ArrayList<>();
      String jclassOid=   dockingPreClassify.getOid();
      List<DockingPreViewModel> dockingPreViewModels=new ArrayList<>();
      if(type==1) {
         //根据分类查询模型视图对象
         dockingPreViewModels= dockingPreViewModelService.list(Wrappers.<DockingPreViewModel>query().lambda().eq(DockingPreViewModel::getSourceClassifyId,jclassOid).eq(DockingPreViewModel::getViewName,"编码视图"));
      }else{
         //根据分类查询模型视图对象
         dockingPreViewModels= dockingPreViewModelService.list(Wrappers.<DockingPreViewModel>query().lambda().eq(DockingPreViewModel::getSourceClassifyId,jclassOid));
      }
      for (DockingPreViewModel dockingPreViewModel : dockingPreViewModels) {
         //组织数据属性信息
         DockingViewVO viewInfo=new DockingViewVO();
         viewInfo.setViewName(dockingPreViewModel.getViewName());//视图名称
         viewInfo.setViewValue(getViewValueList(dockingPreViewModel,jclassOid,dataBusinessObject));//视图
         viewInfoList.add(viewInfo);
      }
      return viewInfoList;
   }

   /***
    * èŽ·å–配置信息
    * @param dockingPreViewModel
    * @param jclassOid
    * @param dataBusinessObject
    * @return
    * @throws VciBaseException
    */
   private List<Map<String, Object>> getViewValueList(DockingPreViewModel dockingPreViewModel,String jclassOid,BaseModelVO dataBusinessObject) throws Throwable{
      //构造模型视图数据
      List<Map<String, Object>> viewValueList=new ArrayList<Map<String,Object>>();
      String oid = dockingPreViewModel.getOid();
      Map<String,String> dataValueMap=dataBusinessObject.getData();
      String codeClassifyId=dataValueMap.get("codeclsfid");
      Map<String,String>conditionsMap=new HashMap<String, String>();



      List<DockingPreAttrMapping> dockingPreAttrMappingList = dockingPreAttrMappingMapper.selectList(Wrappers.<DockingPreAttrMapping>query().lambda()
         .eq(DockingPreAttrMapping::getSourceClassifyId, jclassOid).eq(DockingPreAttrMapping::getTargetClassifyId, codeClassifyId));
      if(CollectionUtils.isEmpty(dockingPreAttrMappingList)) {
         return viewValueList;
      }

      Map<String,DockingPreAttrMapping> jintegmappconfigMap=new HashMap<String, DockingPreAttrMapping>();
      for (DockingPreAttrMapping businessObject : dockingPreAttrMappingList) {
         jintegmappconfigMap.put(businessObject.getSourceAttrKey(), businessObject);
      }
      List<DockingPreMetaAttr> dockingPreMetaAttrList= dockingPreMetaAttrService.selectByWrapper(
         Wrappers.<DockingPreMetaAttr>query().lambda().eq(DockingPreMetaAttr::getViewModelId,dockingPreViewModel.getOid())
            .eq(DockingPreMetaAttr::getSourceClassifyId,dockingPreViewModel.getSourceClassifyId()));

      Map<String,Object> viewValueMap=new HashMap<String,Object>();
      for (DockingPreMetaAttr dockingPreMetaAttr : dockingPreMetaAttrList) {
         String jenglishname=dockingPreMetaAttr.getEnglishName();////集团配置属性
         if(jintegmappconfigMap.containsKey(jenglishname)){
            DockingPreAttrMapping dockingPreAttrMapping=jintegmappconfigMap.get(jenglishname);
            String attrId = dockingPreAttrMapping.getTargetAttrId();//编码属性id
            String jtargetattrkey = dockingPreAttrMapping.getTargetAttrKey();//编码属性id
            Object newVaue=null;
            if(StringUtils.isNotBlank(jtargetattrkey)){
               getAttrRange(dockingPreMetaAttr);//获取字段取值范围
               String value=dataValueMap.get(jtargetattrkey)==null?"":dataValueMap.getOrDefault(jtargetattrkey,"");
               newVaue = getVaue(dockingPreMetaAttr, value);
            }else{
               newVaue = getVaue(dockingPreMetaAttr, "");
            }
            if(newVaue==null||"".equals(newVaue)){
               newVaue= dockingPreMetaAttr.getDefaultValue();
            }
            viewValueMap.put(jenglishname, newVaue);
         }
      }

      viewValueList.add(viewValueMap);
      return viewValueList;
   }

   /***
    * èŽ·å–属性枚举映射配置
    */
   Map<String,Map<String, DockingPreAttrRange>> attrRangeMap=new HashMap<String, Map<String,DockingPreAttrRange>>();
   private void getAttrRange(DockingPreMetaAttr jmetaatter) throws Throwable{

      String jmetalistoid = jmetaatter.getOid();
      if(attrRangeMap.containsKey(jmetalistoid)) {
         return;
      }
      Map<String,String>conditionsMap=new HashMap<String, String>();
      conditionsMap.put("jmetalistid", jmetalistoid);//视图oid
      List<DockingPreAttrRange> dockingPreAttrRangeList = dockingPreAttrRangeService.selectByWrapper(Wrappers.<DockingPreAttrRange>query().lambda().eq(DockingPreAttrRange::getMetaListId, jmetalistoid));
      if (CollectionUtils.isEmpty(dockingPreAttrRangeList)) {
         return;
      }
      Map<String, DockingPreAttrRange> rangeMap = new HashMap<String, DockingPreAttrRange>();
      rangeMap = dockingPreAttrRangeList.stream().collect(Collectors.toMap(s -> s.getNumTextValue(), t -> t, (o1, o2) -> o2));
      attrRangeMap.put(jmetalistoid, rangeMap);

   }
   /****
    * å€¼ç±»åž‹è½¬æ¢
    * @param jmetaatter
    * @param value
    * @return
    * @throws Throwable
    */
   private Object getVaue(DockingPreMetaAttr jmetaatter,String value) throws Throwable{
      //jmetadatatype   å…ƒæ•°æ®ç±»åž‹ï¼ˆ1 å­—符型, 2 æ•´åž‹, 3 é•¿æ•´åž‹, 4 å•ç²¾åº¦, 5 åŒç²¾åº¦,6 æ—¥æœŸåž‹, 7 æ—¶é—´åž‹, 8 å¸ƒå°”åž‹, 9 æ–‡ä»¶, 10复合型）
      int jmetadatatype = jmetaatter.getMetaDataType();
      String jmetalistoid = jmetaatter.getOid();
      Map<String, DockingPreAttrRange> rangeMap=new HashMap<String, DockingPreAttrRange>();
      if(attrRangeMap.containsKey(jmetalistoid)){
         rangeMap = attrRangeMap.get(jmetalistoid);
         if(rangeMap.containsKey(value)){
            DockingPreAttrRange dockingPreAttrRange = rangeMap.get(value);
            value=dockingPreAttrRange.getNumText();//将编码属性域值转换成集团对应的域值
         }
      }

      if(jmetadatatype==1){//1 å­—符型
         return StringUtils.isBlank(value)?"":value;
      }else if(jmetadatatype==2){//2 æ•´åž‹
         return StringUtils.isBlank(value)?null:Integer.parseInt(value);
      }else if(jmetadatatype==3){//3 é•¿æ•´åž‹
         return StringUtils.isBlank(value)?null:Long.parseLong(value);
      }else if(jmetadatatype==4){//4 å•ç²¾åº¦,
         return StringUtils.isBlank(value)?null:Float.parseFloat(value);
      }else if(jmetadatatype==5){// 5 åŒç²¾åº¦
         return StringUtils.isBlank(value)?null:Double.parseDouble(value);
      }else if(jmetadatatype==6){//6 æ—¥æœŸåž‹
         SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd");
         if(StringUtils.isBlank(value)) {
            return null;
         }else {
            try {
               return simpleDateFormat.parse(value);
            } catch (ParseException e) {
               throw new VciBaseException("date", new String[]{"日期格式转换错误"});
            }
         }
      }else if(jmetadatatype==7){//7 æ—¶é—´åž‹
         SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH:mm:ss");
         if(StringUtils.isBlank(value)) {
            return null;
         }else{
            try {
               return simpleDateFormat.parse(value);
            } catch (ParseException e) {
               throw new VciBaseException("date", new String[]{"日期格式转换错误"});
            }
         }
      }else   if(jmetadatatype==8){//8 å¸ƒå°”åž‹
         return value;
      }else if(jmetadatatype==9){//9 æ–‡ä»¶,
         return value;
      }else if(jmetadatatype==10){//10复合型
         return value;//符合型是什么东东如何处理
      }
      return value;
   }
}