Source/UBCS/ubcs-service/ubcs-webservice/src/main/java/com/vci/ubcs/code/webservice/feigh/MdmInterJtClient.java

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

import com.alibaba.cloud.commons.lang.StringUtils;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.vci.ubcs.code.webservice.entity.*;
import com.vci.ubcs.code.webservice.feign.IMdmInterJtClient;
import com.vci.ubcs.code.webservice.service.*;
import com.vci.ubcs.code.webservice.vo.*;
import com.vci.ubcs.starter.revision.model.BaseModel;
import com.vci.ubcs.starter.util.DefaultAttrAssimtUtil;
import com.vci.ubcs.starter.util.MdmBtmTypeConstant;
import com.vci.ubcs.starter.web.constant.MdmEnumIdConstant;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springblade.core.tenant.annotation.NonDS;
import org.springblade.core.tool.api.R;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.RestController;
import springfox.documentation.annotations.ApiIgnore;

import java.util.*;
import java.util.stream.Collectors;

/***
 * æä¾›ä¸Žé›†å›¢ç”³è¯·feigh
 */
@NonDS
@ApiIgnore
@RestController
@AllArgsConstructor
@Slf4j
public class MdmInterJtClient implements IMdmInterJtClient {
   /**
    * é›†å›¢ç”³è¯·å•æœåŠ¡
    */
   private final IDockingPreApplyFormService dockingPreApplyFormService;

   /**
    * é›†å›¢åˆ†ç±»æ¨¡åž‹è§†å›¾æœåŠ¡
    */
   private final IDockingPreViewModelService dockingPreViewModelService;

   /**
    * é›†å›¢åˆ†ç±»å±žæ€§æœåŠ¡
    */
   private final IDockingPreMetaAttrService dockingPreMetaAttrService;

   /**
    * é›†å›¢ç”³è¯·å•æœåŠ¡
    */
   private final IDockingPreClassifyService dockingPreClassifyService;


   /**
    * é›†å›¢ç”³è¯·å•æœåŠ¡
    */
   private final IDockingPreAttrRangeService dockingPreAttrRangeService;


   /*
    * ä¸»æ•°æ®ä¸šåŠ¡æœåŠ¡
    */

   /**
    * èŽ·å–集团集团码，赋值到主数据
    * @param dockingReturnStoreVO
    * @return è¿”回集成结果信息
    */
   @Override
   @Transactional(rollbackFor = Exception.class)
   public R getApplyGroupCode(DockingReturnStoreVO dockingReturnStoreVO) {
      log.info("获取集团集团码，赋值到主数据 start");
      try {
         List<BaseModel> editObjectList = new ArrayList();

         List<DockingPreApplyForm> dockingPreApplyFormList = new ArrayList();
         //String classId = javaObject.getClassId();
         //String sysName = javaObject.getSysName();
         List<MainData> mainDataList = dockingReturnStoreVO.getMainData();
         for (MainData mainData : mainDataList) {
            JSONObject jcontent = new JSONObject();
            //编码状态
            String formState = mainData.getFormState();
            //申请单
            String applyId = mainData.getApplyId();
            String customCoding = StringUtils.isBlank(mainData.getCustomCoding()) ? "" : mainData.getCustomCoding();//集团码
            String msg = "";
            log.info("申请单:"+applyId+",集团码："+customCoding);
            boolean res = false;
            if ("1".equals(formState)) {
               msg = "集团审核中";
            } else if ("2".equals(formState)) {
               msg = "驳回";
            } else if ("3".equals(formState)) {
               msg = "集团审核中";
            } else if ("4".equals(formState)) {
               msg = "审核结束，赋码失败";
            } else if ("5".equals(formState)) {
               res = true;
               msg = "审核结束，赋码成功";
            } else if ("6".equals(formState)) {
               msg = "待301赋码";
            } else if ("7".equals(formState)) {
               res = true;
               msg = "已赋码";
            } else if ("8".equals(formState)) {
               res = true;
               msg = "已赋码（沿用）";
            } else if ("9".equals(formState)) {
               msg = "审核中";
            }
            jcontent.put("applyId", applyId);
            jcontent.put("formState", formState);
            jcontent.put("customCoding", customCoding);
            jcontent.put("msg", msg);
            List<DockingPreApplyForm> oldDockingPreApplyFormList = dockingPreApplyFormService.list(Wrappers.<DockingPreApplyForm>query().lambda()
               .eq(DockingPreApplyForm::getId, applyId));
            if (CollectionUtils.isEmpty(oldDockingPreApplyFormList)) {
               continue; //// return false;
            }
            DockingPreApplyForm dockingPreApplyForm = oldDockingPreApplyFormList.get(0);
            dockingPreApplyForm.setMsg(msg);
            dockingPreApplyForm.setCode("1");
            if (res) {
               dockingPreApplyForm.setGroupCode(customCoding);
            }
            //返回结果信息
            dockingPreApplyForm.setContent(jcontent.toJSONString());
            dockingPreApplyFormList.add(dockingPreApplyForm);
            if (res) {
               String jdataid = dockingPreApplyForm.getDataOid();
               String jdatabtmname = dockingPreApplyForm.getDataBtmName();
               //此处需要查询业务数据，去更改
               BaseModel baseModel = new BaseModel();
               baseModel.setId(customCoding);
               log.info("申请单:"+applyId+",集团码："+customCoding+"编码："+baseModel.getId());
               editObjectList.add(baseModel);
            }
         }
         dockingPreApplyFormService.saveOrUpdateBatch(dockingPreApplyFormList);
         //调用主数据服务批量保存接口
      }catch (Throwable e){
         e.printStackTrace();
         return R.fail("集团码集成赋值失败"+e);
      }
      log.info("获取集团集团码，赋值到主数据 end");
      return R.success("集团码赋值成功");
   }

   /***
    * æŽ¥å—集团分类主模型数据
    * @param dockingClassifyModelAttrVO
    * @return
    */
   @Override
   @Transactional(rollbackFor = Exception.class)
   public R pubMdmModel(DockingClassifyModelAttrVO dockingClassifyModelAttrVO) {
      log.info("");
      try {
         this.saveDatas(dockingClassifyModelAttrVO);
      }catch (Throwable e){
         e.printStackTrace();
         return R.fail("接受集团分类主模型数据失败"+e);
      }
      log.info("接受集团分类主模型数据 end");
      return R.success("接受集团分类主模型数据成功");
   }

   /***
    * ç»„织 ä¿å­˜æ•°æ®æ–¹æ³•
    * @param dockingClassifyModelAttrVO
    * @throws Throwable
    */
   private boolean saveDatas(DockingClassifyModelAttrVO dockingClassifyModelAttrVO) throws Throwable {
      List<DockingPreClassify> dockingPreClassifyArrayList=new ArrayList<>();
      try {
         DockingClassifyMainVO mainData = dockingClassifyModelAttrVO.getDataStructure();
         List<DockingClassifyVO> classList = mainData.getClassList();
         Map<String, List<DockingClassifyViewVO>> classInfoMap = mainData.getClassInfos();
         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();
            //ClientBusinessObject classObject = objectOperation.readBusinessObjectById(id, "jclass");// èŽ·å–分类信息
             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())) {
               dockingPreClassify = new DockingPreClassify();
               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 =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 =StringUtils.isBlank(viewInfo.getViewName())?"":viewInfo.getViewName();
            String impactList = 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 -> StringUtils.isNotBlank(s.getEnglishName())).collect(Collectors.toMap(s -> s.getEnglishName().toLowerCase(Locale.ROOT), t -> t));

         for (DockingClassifyMetaAttrVO dockingClassifyMetaAttrVO : metaList) {
            String chineseName =StringUtils.isBlank(dockingClassifyMetaAttrVO.getChineseName())?"":dockingClassifyMetaAttrVO.getChineseName();// å±žæ€§åç§°
            String englishName = StringUtils.isBlank(dockingClassifyMetaAttrVO.getEnglishName())?"":dockingClassifyMetaAttrVO.getEnglishName();// è‹±æ–‡åç§°
            String defaultValue = 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 = 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 =StringUtils.isBlank(metaAttrObject.getOid())?"":metaAttrObject.getOid();// å±žæ€§çš„oid
      String jchinesename = 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 -> 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 = 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);
      }
   }

}