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.apache.commons.collections4.map.CaseInsensitiveMap;
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.io.*;
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)){
									log.info("开始调用sourceAttrKey2TargetKey方法。");
									//根据集团属性映射将集团转到我们系统，并修改不一致的到我们系统中对应的该条记录的值
									sourceAttrKey2TargetKey(dockingPreAttrMappings, viewValueList.get(0), 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 baseModel
	 */
	private void sourceAttrKey2TargetKey(List<DockingPreAttrMapping> dockingPreAttrMappings,Map<String, Object> viewValueMap,BaseModel baseModel) throws ServiceException {
		log.info("开始根据集团属性映射，将集团属性转成编码系统属性，并进行是否修改的比对！");
		//深拷贝记录下原对象，如果有更改用来放在旧业务数据字段（oldbusinessdata）上
		BaseModel oldBaseModel = null;
		try {
			oldBaseModel = deepCopy(baseModel);
		} catch (Exception e) {
			log.error("记录旧的业务数据时，baseModel对象深拷贝出现错误，原因："+e.getMessage());
			e.printStackTrace();
			throw new ServiceException("记录旧的业务数据时，baseModel对象深拷贝出现错误，原因："+e.getMessage());
		}
		Map<String, Object> targetKeyMap = new CaseInsensitiveMap<>();
		// 将集团属性转成我们系统属性的map
		dockingPreAttrMappings.stream().forEach(item->{
			targetKeyMap.put(item.getTargetAttrKey(),viewValueMap.get(item.getSourceAttrKey()));
		});
		// 比对baseModel的data中的属性是否和targetKeyMap不一致，不一致的话就需要将baseModel的data中的对应key的value值转成集团的
		boolean isEdit = false;
		// 忽略大小写
		Map caseInsensitiveMap = new CaseInsensitiveMap(baseModel.getData());
		for (Map.Entry<String, Object> entry : targetKeyMap.entrySet()) {
			String key = entry.getKey();
			Object targetValue = entry.getValue();
			String dataValue = String.valueOf(caseInsensitiveMap.get(key));
			if (targetValue != null && !targetValue.equals(dataValue)) {
				caseInsensitiveMap.put(key, targetValue.toString());
				isEdit = true;
			}
		}
		// 集团对我们系统属性做了调整，我们需要对老的业务数据做记录
		if (isEdit) {
			log.info("集团返回的数据存在差异，开始执行对编码系统basemodel对象修改操作！");
			// 清空原先的map，使用新的不区分key大小写的map
			baseModel.getData().clear();
			baseModel.getData().putAll(caseInsensitiveMap);
			// 移除历史的oldbusinessdata字段，否则会超长
			oldBaseModel.getData().remove("oldbusinessdata");
			baseModel.getData().put("oldbusinessdata", JSON.toJSONString(oldBaseModel));
		}
	}

	/**
	 * 深拷贝
	 * @param baseModel
	 * @return
	 * @throws ClassNotFoundException
	 * @throws IOException
	 */
	public static BaseModel deepCopy(BaseModel baseModel) throws ClassNotFoundException, IOException {
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		ObjectOutputStream oos = new ObjectOutputStream(bos);
		oos.writeObject(baseModel);
		oos.close();

		ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
		ObjectInputStream ois = new ObjectInputStream(bis);
		BaseModel copy = (BaseModel) ois.readObject();
		ois.close();

		return copy;
	}

	/***
	 * 接受集团分类主模型数据
	 * @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);
		}
	}

}