package com.vci.ubcs.code.applyjtcodeservice.feigh;
|
|
import com.alibaba.cloud.commons.lang.StringUtils;
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.JSONObject;
|
import com.alibaba.nacos.shaded.com.google.protobuf.ServiceException;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.vci.ubcs.code.applyjtcodeservice.entity.*;
|
import com.vci.ubcs.code.applyjtcodeservice.feign.IMdmInterJtClient;
|
import com.vci.ubcs.code.applyjtcodeservice.service.*;
|
import com.vci.ubcs.code.applyjtcodeservice.vo.*;
|
import com.vci.ubcs.code.feign.IMdmEngineClient;
|
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.util.SaveLogUtil;
|
import com.vci.ubcs.starter.web.util.VciBaseUtil;
|
import lombok.AllArgsConstructor;
|
import lombok.Data;
|
import lombok.extern.slf4j.Slf4j;
|
import org.jetbrains.annotations.NotNull;
|
import org.springblade.core.tenant.annotation.NonDS;
|
import org.springblade.core.tool.api.R;
|
import org.springblade.core.tool.utils.Func;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
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
|
@Data
|
@Slf4j
|
public class MdmInterJtClient implements IMdmInterJtClient {
|
|
@Value("${docking.apply.partCode:10}")
|
public String partCode;
|
|
/**
|
* 集团申请单服务
|
*/
|
private final IDockingPreApplyFormService dockingPreApplyFormService;
|
|
/**
|
* 集团分类模型视图服务
|
*/
|
private final IDockingPreViewModelService dockingPreViewModelService;
|
|
/**
|
* 集团分类属性服务
|
*/
|
private final IDockingPreMetaAttrService dockingPreMetaAttrService;
|
|
/**
|
* 集团分类申请单服务
|
*/
|
private final IDockingPreClassifyService dockingPreClassifyService;
|
|
/***
|
* 属性映射服务
|
*/
|
private final IDockingPreAttrMappingService dockingPreAttrMappingService;
|
|
/**
|
* 集团取值范围申请单服务
|
*/
|
private final IDockingPreAttrRangeService dockingPreAttrRangeService;
|
|
/**
|
* 集团属性映射配置属性
|
*/
|
private final IGroupMdmInterService groupMdmInterService;
|
|
@Autowired(required = false)
|
private IMdmEngineClient mdmEngineClient;
|
|
private final SaveLogUtil saveLogUtil;
|
|
/***
|
* 申请集团编码
|
* @return
|
*/
|
public R applyGroupCode(String oids,String btmName){
|
try {
|
return groupMdmInterService.applyGroupCode(oids,btmName);
|
}catch (Throwable e){
|
return R.fail("集团码申请失败："+e.getMessage());
|
}
|
}
|
|
/***
|
* 查询集团属性映射
|
* @param codeClassifyOid:编码分类oid
|
* @return
|
*/
|
@Override
|
public R<List<DockingPreAttrMappingVO>> list_mapping(String codeClassifyOid) {
|
List<DockingPreAttrMapping> dockingPreAttrMappings= dockingPreAttrMappingService.selectByWrapper(Wrappers.<DockingPreAttrMapping>query().lambda().eq(DockingPreAttrMapping::getTargetClassifyId,codeClassifyOid));
|
List<DockingPreAttrMappingVO> dockingPreAttrMappingVOList=new ArrayList<>();
|
if(!CollectionUtils.isEmpty(dockingPreAttrMappings)){
|
dockingPreAttrMappingVOList=dockingPreAttrMappingService.dockingPreAttrMappingDO2VOS(dockingPreAttrMappings,true);
|
}
|
return R.data(dockingPreAttrMappingVOList);
|
}
|
|
/***
|
* 申请集团编码数据维护
|
* @return
|
*/
|
@Override
|
public R receiveEditApply(String oids, String btmName) {
|
try {
|
return groupMdmInterService.receiveEditApply(oids,btmName);
|
}catch (Throwable e){
|
return R.fail("集团码数据修改失败："+e.getMessage());
|
}
|
}
|
|
/**
|
* 获取集团集团码，赋值到主数据
|
* @param dockingReturnStoreVO
|
* @return 返回集成结果信息
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R getApplyGroupCode(DockingReturnStoreVO dockingReturnStoreVO) {
|
log.info("获取集团集团码，赋值到主数据 start");
|
try {
|
Map<String,List<BaseModel>> editObjectMap = new HashMap<>();
|
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 = "审核中";
|
}
|
// 如果返回了审查意见就用返回的
|
msg = Func.isNotBlank(mainData.getExamineOpinion()) ? msg+"，意见："+mainData.getExamineOpinion():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");
|
dockingPreApplyForm.setLastModifyTime(new Date());
|
if (res) {
|
dockingPreApplyForm.setGroupCode(customCoding);
|
}
|
//返回结果信息
|
dockingPreApplyForm.setContent(jcontent.toJSONString());
|
dockingPreApplyFormList.add(dockingPreApplyForm);
|
String jdataid = dockingPreApplyForm.getDataOid();
|
String jdatabtmname = dockingPreApplyForm.getDataBtmName();
|
if (res) {
|
//此处需要查询业务数据，去更改
|
R<List<BaseModel>> R = mdmEngineClient.selectByTypeAndOid(jdatabtmname,jdataid);
|
// TODO:新增业务逻辑，需要根据集团返回的属性进行判断，如果集团对该属性进行了修改编码系统也就需要对属性进行修改
|
if(R.isSuccess()){
|
List<BaseModel> newDatalist=new ArrayList<>();
|
List<BaseModel> oldDatalist=R.getData();
|
if(!CollectionUtils.isEmpty(oldDatalist)){
|
if(editObjectMap.containsKey(jdatabtmname)){
|
newDatalist=editObjectMap.getOrDefault(jdatabtmname,new ArrayList<>());
|
}
|
BaseModel baseModel=oldDatalist.get(0);
|
//DefaultAttrAssimtUtil.updateDefaultAttrAssimt(baseModel);
|
baseModel.setLastModifyTime(new Date());
|
baseModel.getData().put("GROUPCODE",customCoding);
|
// 1、取到集团返回的ViewInfos中编码视图中的属性
|
List<Map<String, Object>> viewValueList = mainData.getViewInfos().stream().filter(item -> item.getViewName().equals("编码视图")).map(DockingViewVO::getViewValue).findFirst().orElse(null);
|
// 2、比对属性是否和oldDatalist属性一致，不一致就需要更改
|
if(Func.isNotEmpty(viewValueList)){
|
// 3、需要将集团属性转换为我们系统的属性，再和我们系统的现有属性比对
|
String codeclsfid = VciBaseUtil.getMapStrValueIgnoreCase(baseModel.getData(),"CODECLSFID");
|
// 3.1、通过该条数据的分类id，拿到集团属性映射配置，用来将集团的属性映射到我们系统的属性
|
List<DockingPreAttrMapping> dockingPreAttrMappings = dockingPreAttrMappingService.selectByWrapper(Wrappers.<DockingPreAttrMapping>query().lambda().eq(DockingPreAttrMapping::getTargetClassifyId, codeclsfid).eq(DockingPreAttrMapping::getViewName,"编码视图"));
|
if(Func.isNotEmpty(dockingPreAttrMappings)){
|
//根据集团属性映射将集团转到我们系统，并修改不一致的到我们系统中对应的该条记录的值
|
sourceAttrKey2TargetKey(dockingPreAttrMappings, viewValueList.get(0), oldDatalist, baseModel);
|
}
|
}
|
log.info("申请单:"+applyId+",集团码："+customCoding+"编码："+baseModel.getId());
|
newDatalist.add(baseModel);
|
editObjectMap.put(jdatabtmname,newDatalist);
|
}
|
}
|
}
|
}
|
if(!CollectionUtils.isEmpty(editObjectMap)) {
|
//调用主数据服务批量保存接口
|
editObjectMap.forEach((btmName, modeList) -> {
|
mdmEngineClient.updateBatchBtypeDatas(btmName, modeList);
|
});
|
}
|
if(!CollectionUtils.isEmpty(dockingPreApplyFormList)){
|
dockingPreApplyFormService.saveOrUpdateBatch(dockingPreApplyFormList);
|
}
|
saveLogUtil.operateLog("申请单结果返回",false, JSON.toJSONString(dockingReturnStoreVO.getMainData()));
|
}catch (Throwable e){
|
e.printStackTrace();
|
saveLogUtil.operateLog("申请单结果返回",true,"错误信息："+e.getMessage()+"\n"+ JSON.toJSONString(dockingReturnStoreVO.getMainData()));
|
return R.fail("集团码集成赋值失败，原因："+e.getMessage());
|
}
|
log.info("获取集团集团码，赋值到主数据 end");
|
return R.success("集团码赋值成功");
|
}
|
|
/**
|
* 根据集团属性映射将集团转到我们系统
|
* @param dockingPreAttrMappings
|
* @param viewValueMap
|
* @param oldDatalist
|
* @param baseModel
|
*/
|
private void sourceAttrKey2TargetKey(List<DockingPreAttrMapping> dockingPreAttrMappings,Map<String, Object> viewValueMap, List<BaseModel> oldDatalist,BaseModel baseModel){
|
Map<String, Object> targetKeyMap = new HashMap<>();
|
// 将集团属性转成我们系统属性的map
|
dockingPreAttrMappings.stream().forEach(item->{
|
targetKeyMap.put(item.getTargetAttrKey(),viewValueMap.get(item.getSourceAttrKey()));
|
});
|
// 比对baseModel的data中的属性是否和targetKeyMap不一致，不一致的话就需要将baseModel的data中的对应key的value值转成集团的
|
boolean isEdit = false;
|
for (Map.Entry<String, Object> entry : targetKeyMap.entrySet()) {
|
String key = entry.getKey();
|
Object targetValue = entry.getValue();
|
String dataValue = baseModel.getData().get(key);
|
|
if (targetValue != null && !targetValue.equals(dataValue)) {
|
baseModel.getData().put(key, targetValue.toString());
|
isEdit = true;
|
}
|
}
|
// 集团对我们系统属性做了调整，我们需要对老的业务数据做记录
|
if (isEdit) {
|
baseModel.getData().put("oldbusinessdata", JSON.toJSONString(oldDatalist));
|
}
|
}
|
|
/***
|
* 接受集团分类主模型数据
|
* @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.setNodeLinkName(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(@NotNull 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 = viewInfo.getImpactList() == null ? "" : viewInfo.getImpactList().get(0).get(0);
|
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);
|
}
|
}
|
|
}
|
