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

@@ -42,8 +42,13 @@

   private String msg="";

   @Value("${docking.apply.unitCode:410-MDM}")

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

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

   @Autowired(required = false)
   private MdmApplyGroupCodeProvider mdmApplyGroupCodeProvider;
   /***
@@ -90,8 +95,8 @@
    * @return 返回结果信息
    * @throws Exception
    */
   @Transactional(rollbackFor = VciBaseException.class)
   @Override
   @Transactional
   public R applyGroupCode(String oids, String btmName) throws VciBaseException {
      try {
         List<BaseModel> updateCbos = new ArrayList<BaseModel>();
@@ -206,6 +211,7 @@
    * @return 返回结果信息
    * @throws Throwable
    */
   @Transactional(rollbackFor = VciBaseException.class)
   @Override
   public R receiveEditApply(String oids, String btmName) throws VciBaseException {
      List<BaseModel> updateCbos=new ArrayList<BaseModel>();
@@ -313,6 +319,400 @@
      }
   }

   /***
    * 获取集团模型详细信息执行保存
    * @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 dataOids
    * @return 执行结果
    */
   public R queryApplyState(String dataOids) {

      String message="执行成功！";
      log.info("查询申请单状态接口statr");
      try {
         VciBaseUtil.alertNotNull(dataOids,"所查申请单数据主键");
         VciBaseUtil.alertNotNull(dockingApplySysName,"系统标识配置：docking.apply.unitCode");

         List<DockingPreApplyForm> dockingPreApplyFormList=   this.dockingPreApplyFormService.list(Wrappers.<DockingPreApplyForm>query().lambda().in(DockingPreApplyForm::getDataOid, VciBaseUtil.str2List(dataOids)));
         dockingPreApplyFormList.stream().forEach(dockingPreApplyForm -> {
            dockingPreApplyForm.getId();

         });

      }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);
      }
   }




   /**
    * 组织数据
@@ -371,7 +771,7 @@
         }
         //根据数据模型，组织所需要数据
         DockingGroupDataVO postParameters=new DockingGroupDataVO();
         postParameters.setSysName("420-CODE");//系统标识
         postParameters.setSysName(dockingApplySysName);//系统标识
         postParameters.setMainData(mainDataList);//
         return postParameters;
      } catch (Throwable e) {