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 Throwable {
|
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 classifyId
|
* @param operationType
|
* @return 返回执行结果
|
* @throws VciBaseException
|
*/
|
@Override
|
public R syncClassifyModel(String classifyId, String operationType) throws VciBaseException {
|
VciBaseUtil.alertNotNull(operationType,"集成操作类型");
|
try {
|
if(operationType.equals("all")){
|
return queryMdmModel();
|
}else{
|
VciBaseUtil.alertNotNull(classifyId,"集团分类主键");
|
return queryClassModel(classifyId);
|
}
|
} catch (Throwable e) {
|
throw new VciBaseException(e.getMessage());
|
}
|
}
|
|
// /**
|
// * 同步主模型
|
// * @return
|
// */
|
// private String queryMdmModel() throws VciBaseException {
|
// String message="执行成功！";
|
// try {
|
//
|
//
|
// }catch (VciBaseException e){
|
// message=e.getMessage();
|
// throw new VciBaseException(message);
|
// }finally {
|
// return message;
|
// }
|
//
|
//
|
// }
|
//
|
// /***
|
// * 同步模型详细信息
|
// * @param classifyId
|
// * @return
|
// */
|
// private String queryClassModel(String classifyId)throws VciBaseException{
|
// String message="执行成功！";
|
// try {
|
//
|
// }catch (VciBaseException e){
|
// message=e.getMessage();
|
// throw new VciBaseException(message);
|
// }finally {
|
// return 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;
|
}
|
}
|
