From ebbd0efdfc7cad7043a0d4620d5f508fbea75683 Mon Sep 17 00:00:00 2001
From: 田源 <lastanimals@163.com>
Date: 星期三, 05 七月 2023 09:59:55 +0800
Subject: [PATCH] 发布流程增加参数

---
 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/UniversalInterfaceImpl.java | 1141 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 1,141 insertions(+), 0 deletions(-)

diff --git a/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/UniversalInterfaceImpl.java b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/UniversalInterfaceImpl.java
new file mode 100644
index 0000000..ef799e4
--- /dev/null
+++ b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/UniversalInterfaceImpl.java
@@ -0,0 +1,1141 @@
+package com.vci.ubcs.code.service.impl;
+
+import com.alibaba.cloud.commons.lang.StringUtils;
+import com.alibaba.fastjson.JSONObject;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.thoughtworks.xstream.XStream;
+import com.thoughtworks.xstream.io.xml.DomDriver;
+import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
+import com.vci.ubcs.code.dto.CodeOrderDTO;
+import com.vci.ubcs.code.dto.CodeOrderSecDTO;
+import com.vci.ubcs.code.entity.*;
+import com.vci.ubcs.code.enumpack.CodeDefaultLC;
+import com.vci.ubcs.code.enumpack.CodeSecTypeEnum;
+import com.vci.ubcs.code.mapper.CommonsMapper;
+import com.vci.ubcs.code.service.*;
+import com.vci.ubcs.code.util.ClientBusinessObject;
+import com.vci.ubcs.code.util.gennerAttrMapUtil;
+import com.vci.ubcs.code.vo.pagemodel.*;
+import com.vci.ubcs.code.vo.webserviceModel.apply.*;
+import com.vci.ubcs.code.vo.webserviceModel.attrmap.*;
+import com.vci.ubcs.code.vo.webserviceModel.attrmap.DataObjectVO;
+import com.vci.ubcs.code.vo.webserviceModel.classify.*;
+import com.vci.ubcs.code.vo.webserviceModel.data.*;
+import com.vci.ubcs.code.vo.webserviceModel.result.json.*;
+import com.vci.ubcs.code.vo.webserviceModel.result.xml.XMLResultClassfyVO;
+import com.vci.ubcs.code.vo.webserviceModel.result.xml.XMLResultDataObjectDetailDO;
+import com.vci.ubcs.code.vo.webserviceModel.result.xml.XMLResultSystemVO;
+import com.vci.ubcs.code.webService.annotation.VciWebservice;
+import com.vci.ubcs.code.webService.config.AttributeMapConfig;
+import com.vci.ubcs.code.wrapper.CodeClassifyWrapper;
+import com.vci.ubcs.omd.feign.IBtmTypeClient;
+import com.vci.ubcs.omd.vo.BtmTypeVO;
+import com.vci.ubcs.starter.revision.model.BaseModel;
+import com.vci.ubcs.starter.revision.model.TreeQueryObject;
+import com.vci.ubcs.starter.util.DefaultAttrAssimtUtil;
+import com.vci.ubcs.starter.web.constant.QueryOptionConstant;
+import com.vci.ubcs.starter.web.pagemodel.SessionInfo;
+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.tool.api.R;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+import javax.annotation.Resource;
+import java.util.*;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.stream.Collectors;
+
+import static com.vci.ubcs.code.constant.MdmEngineConstant.DEFAULT_SYNC_ATTR_LIST;
+import static com.vci.ubcs.code.enumpack.CodeSecTypeEnum.CODE_CLASSIFY_SEC;
+
+/***
+ * 缁熶竴鎺ュ彛
+ */
+@Service
+@Slf4j
+@VciWebservice(path = "/universalInterface")
+public class UniversalInterfaceImpl<IDockingLogeServiceing> implements UniversalInterfaceI {
+
+	@Autowired(required = false)
+	private AttributeMapConfig attributeMapConfig;
+	/**
+	 * 缂撳瓨鏈嶅姟
+	 */
+	//@Autowired
+	//private RedisService redisService;
+	/**
+	 * 涓婚搴撳垎绫荤殑鏈嶅姟
+	 */
+	@Autowired(required = false)
+	private ICodeClassifyService classifyService;
+
+	/**
+	 * 涓氬姟绫诲瀷鐨勬湇鍔�
+	 */
+	@Autowired
+	private IBtmTypeClient btmTypeClient;
+
+	/**
+	 * 閫氱敤鏌ヨ
+	 */
+	@Resource
+	private CommonsMapper commonsMapper;
+
+	/**
+	 * 涓绘暟鎹紩鎿庣殑鏈嶅姟
+	 */
+	@Resource
+	private MdmEngineService engineService;
+
+	/**
+	 * 瀵嗙骇鐨勬湇鍔�
+	 */
+
+	@Resource
+	private MdmIOService mdmIOService;
+
+	@Autowired
+	private ICodeClassifyValueService codeClassifyValueService;
+	/***
+	 * 闆嗘垚鎺ュ彛鏃ュ織鏈嶅姟鐨勯厤缃�
+	 */
+	@Resource
+	private IDockingLogeService dockingLogeService;
+
+	private  static String separator="##VCI##";
+	private  String errorid="0";
+	private String msg="鎴愬姛";
+	private  String objerrorCode="0";
+	private String objerrorMsg="鎴愬姛";
+	/***
+	 * 鐢宠缂栫爜鎺ュ彛
+	 * @param data 浼犻�掔殑鏁版嵁鍙傛暟
+	 * @param dataType 鏍囪瘑data鏄痻ml鏍煎紡杩樻槸json鏍煎紡锛屾帴鍙ｈ繑鍥炴暟鎹篃鏄寜鐓ц繖涓牸寮忥紝浠ヤ笅鎺ュ彛绫诲悓
+	 * @return
+	 * @throws Throwable
+	 */
+	@Override
+	public String applyCode(String data, String dataType) throws Throwable {
+		String resultStr = "";
+		String errorid="0";
+		msg="鎴愬姛";
+		objerrorCode="0";
+		objerrorMsg="鎴愬姛";
+		log.info("鐢宠缂栫爜鐨勬暟鎹弬鏁�:->"+data);
+		log.info("鐢宠缂栫爜鐨勬暟鎹被鍨�:->"+dataType);
+		String systemId="";
+		List<XMLResultClassfyVO> resultClassfyVOList = new ArrayList<>();
+		try {
+			if(StringUtils.isBlank(data)) {
+				errorid="101";
+				throw new Throwable("鎺ュ彛鍙傛暟锛氫紶閫掍负绌�");
+			}
+			InterParameterVO interParameterVO  =new InterParameterVO();
+			//濡傛灉dataType鏄痻ml鍒欙紝閫氳繃xml搴忓垪鍖栨垚瀵硅薄褰㈠紡锛屽鏋滄槸json鍒欓�氳繃json杞崲鎴愬璞℃牸寮�
+			try {
+				if ("xml".equals(dataType)) {
+					XStream xStream = new XStream(new DomDriver());
+					xStream.processAnnotations(RootDataVO.class);
+					xStream.autodetectAnnotations(true);
+					RootDataVO rootDataVO = (RootDataVO) xStream.fromXML(data);
+					interParameterVO.setData(rootDataVO);
+				} else {
+					interParameterVO = JSONObject.toJavaObject(JSONObject.parseObject(data), InterParameterVO.class);
+				}
+			}catch (Throwable e){
+				errorid="101";
+				throw new Throwable("鎺ュ彛鍙傛暟锛氫紶鍏ユ暟鎹弬鏁拌В鏋愬け璐�");
+			}
+			ClassfysVO classfysVO = interParameterVO.getData().getClassifys();
+			systemId = interParameterVO.getData().getSystemId();
+			UserVO userVo = interParameterVO.getData().getUser();
+			List<ClassfyVO> classVOList = classfysVO.getClassify();
+			InterParameterVO finalInterParameterVO = interParameterVO;
+
+			//杩欐槸璐﹀彿淇℃伅
+			SessionInfo sessionInfo = new SessionInfo();
+			sessionInfo.setUserId(userVo.getUserName());
+			sessionInfo.setUserName(userVo.getTrueName());
+			sessionInfo.setIp(userVo.getIp());
+			VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
+
+			String finalSystemId = systemId;
+			classVOList.stream().forEach(classVO -> {
+				log.info("鍙傛暟锛氬垎绫籆Ode:" + classVO.getClassCode());
+				LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs = new LinkedList<>();
+				//鑾峰彇鍒嗙被淇℃伅
+				try {
+					String libray = classVO.getLibrary();
+					CodeClassifyVO codeClassifyVO = getClassfy(classVO);
+					log.info("end锛氬垎绫绘煡璇㈠畬姣�");
+					//鑾峰彇鍒嗙被妯℃澘淇℃伅
+					if(codeClassifyVO==null || StringUtils.isBlank(codeClassifyVO.getOid())){
+						objerrorCode="100";
+						throw  new  Throwable ("鏍规嵁浼犺緭鐨勫垎绫伙紝鏈幏鍙栧埌鍒嗙被淇℃伅");
+					}
+					CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyVO.getOid());
+					if(templateVO==null||StringUtils.isBlank(templateVO.getOid())){
+						objerrorCode="1";
+						throw  new  Throwable ("鏍规嵁浼犺緭鐨勫垎绫伙紝鏈幏鍙朚DM绯荤粺涓搴旀ā鏉�");
+					}
+					log.info("end锛氭ā鏉挎煡璇㈠畬姣�");
+					ApplyDatasVO applyDatasVO = classVO.getObjects();
+					DataObjectVO dataObjectVO = new DataObjectVO();
+					List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s -> !DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
+					).collect(Collectors.toList());
+					this.getConfigDatas(finalSystemId, libray, applyDatasVO, attrVOS, dataObjectVO);
+					log.info("end锛氭暟鎹粍缁囧畬姣�");
+					//瑙勫垯鐨勪富閿渶瑕佸幓鑾峰彇
+					CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyVO.getOid());
+					if(classifyFullInfo==null ||classifyFullInfo.getCurrentClassifyVO()==null || StringUtils.isBlank(classifyFullInfo.getCurrentClassifyVO().getOid())){
+						objerrorCode="1";
+						log.info("classifyFullInfo:"+"鏍规嵁浼犺緭鐨勫垎绫伙紝鏈幏鍙栧垎绫荤浉鍏充俊鎭�");
+						throw  new  Throwable ("鏍规嵁浼犺緭鐨勫垎绫伙紝鏈幏鍙栧垎绫荤浉鍏充俊鎭�");
+					}
+					CodeRuleVO ruleVO = engineService.getCodeRuleByClassifyFullInfo(classifyFullInfo);
+					if(ruleVO==null||StringUtils.isBlank(ruleVO.getOid())){
+						objerrorCode="102";
+						throw  new  Throwable ("鏍规嵁浼犺緭鐨勫垎绫伙紝鏈幏鍙朚DM绯荤粺涓搴旇鍒�");
+					}
+					log.info("end锛氳鍒欒幏鍙栧畬姣�");
+					List<CodeOrderSecDTO> codeOrderSecDTOList = getRuleCodeOrderSecDTOs(classVO.getSections().getSection(), ruleVO,classifyFullInfo);
+					log.info("end锛氱爜娈佃幏鍙栧畬姣�");
+					CodeOrderDTO orderDTO = new CodeOrderDTO();
+					orderDTO.setCodeClassifyOid(codeClassifyVO.getOid());//鍒嗙被涓婚敭
+					orderDTO.setSecDTOList(codeOrderSecDTOList);//鍒嗙被鐮佹
+					mdmIOService.batchSyncApplyCode(orderDTO, dataObjectVO, resultDataObjectDetailDOs);
+					log.info("end锛氱敵璇疯幏鍙栧畬姣�");
+				} catch (Throwable e) {
+					XMLResultDataObjectDetailDO xmlResultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
+					xmlResultDataObjectDetailDO.setCode("");
+					xmlResultDataObjectDetailDO.setId("");
+					xmlResultDataObjectDetailDO.setErrorid(objerrorCode);
+					xmlResultDataObjectDetailDO.setMsg("缂栫爜鐢宠澶辫触:"+e.getMessage());
+					resultDataObjectDetailDOs.add(xmlResultDataObjectDetailDO);
+					e.printStackTrace();
+				}finally {
+					XMLResultClassfyVO resultClassfyVO = new XMLResultClassfyVO();
+					resultClassfyVO.setClassCode(classVO.getClassCode());
+					resultClassfyVO.setLibrary(classVO.getLibrary());
+					resultClassfyVO.setFullclsfNamePath(classVO.getFullclsfNamePath());
+					resultClassfyVO.setObjects(resultDataObjectDetailDOs);
+					resultClassfyVOList.add(resultClassfyVO);
+				}
+			});
+			XMLResultSystemVO xmlResultSystemVO=new XMLResultSystemVO();
+			xmlResultSystemVO.setClassifys(resultClassfyVOList);
+			xmlResultSystemVO.setMsg(msg);
+			xmlResultSystemVO.setErrorid(errorid);
+			resultStr= transferResultXMl(xmlResultSystemVO,dataType);
+		}catch (Throwable e){
+			e.printStackTrace();;
+			msg="鐢宠缂栫爜澶辫触:"+e.getMessage();
+          /*  XMLResultSystemVO XMLResultSystemVO=new XMLResultSystemVO();
+            XMLResultSystemVO.setErrorid(errorid);
+            XMLResultSystemVO.setMsg("鐢宠缂栫爜澶辫触锛�->"+e.getMessage());
+            XMLResultSystemVO.setClassifys(resultClassfyVOList);
+            resultStr=transferResultXMl(XMLResultSystemVO,dataType);
+
+            log.error("鐢宠缂栫爜澶辫触锛�->"+e);
+            return resultStr;*/
+		}finally {
+			XMLResultSystemVO xmlResultSystemVO=new XMLResultSystemVO();
+			xmlResultSystemVO.setClassifys(resultClassfyVOList);
+			xmlResultSystemVO.setMsg(msg);
+			xmlResultSystemVO.setErrorid(errorid);
+			resultStr= transferResultXMl(xmlResultSystemVO,dataType);
+			final boolean[] issucess = {true};
+			if(!errorid.equals("0")) {
+				issucess[0] = false;
+			}else {
+				if(!CollectionUtils.isEmpty(resultClassfyVOList)) {
+					resultClassfyVOList.stream().forEach(xMLResultClassfyVO -> {
+						xMLResultClassfyVO.getObjects().stream().forEach(objec -> {
+							if (!(objec.getErrorid().equals("0") || objec.getErrorid().equals("204"))) {
+								issucess[0] = false;
+								msg=objec.getMsg();
+							}
+						});
+					});
+				}
+
+			}
+			try {
+				//璁板綍鏃ュ織
+				this.saveLogs(systemId, systemId, data, resultStr, issucess[0], msg, "applyCode");
+			}catch (Throwable e){
+				e.printStackTrace();
+			}
+		}
+		log.info("杩斿洖鍙傛暟:"+resultStr);
+
+		return resultStr;
+	}
+
+	/***
+	 * 缁熶竴鏇存柊鎺ュ彛锛堟洿鏀圭姸鎬侊紝鏇存敼灞炴�т俊鎭級鎺ュ彛
+	 * @param data
+	 * @param dataType
+	 * @return
+	 * @throws Throwable
+	 */
+	@Override
+	public String syncEditData(String data, String dataType) throws Throwable {
+
+		String resultStr = "";
+		String errorid="0";
+		msg="鎴愬姛";
+		String systemId="";
+		objerrorCode="0";
+		objerrorMsg="鎴愬姛";
+		log.info("鏇存敼缂栫爜鐨勬暟鎹弬鏁�:->"+data);
+		log.info("鏇存敼缂栫爜鐨勬暟鎹被鍨�:->"+dataType);
+		List<XMLResultClassfyVO> resultClassfyVOList = new ArrayList<>();
+		try {
+			if (StringUtils.isBlank(data)) {
+				errorid = "101";
+				throw new Throwable("鎺ュ彛鍙傛暟锛氫紶閫掍负绌�");
+			}
+			InterParameterVO interParameterVO = new InterParameterVO();
+			//濡傛灉dataType鏄痻ml鍒欙紝閫氳繃xml搴忓垪鍖栨垚瀵硅薄褰㈠紡锛屽鏋滄槸json鍒欓�氳繃json杞崲鎴愬璞℃牸寮�
+			try {
+				if ("xml".equals(dataType)) {
+					XStream xStream = new XStream(new DomDriver());
+					xStream.processAnnotations(RootDataVO.class);
+					xStream.autodetectAnnotations(true);
+					RootDataVO rootDataVO = (RootDataVO) xStream.fromXML(data);
+					interParameterVO.setData(rootDataVO);
+				} else {
+					interParameterVO = JSONObject.toJavaObject(JSONObject.parseObject(data), InterParameterVO.class);
+				}
+			} catch (Throwable e) {
+				errorid = "101";
+				throw new Throwable("鎺ュ彛鍙傛暟锛氫紶鍏ユ暟鎹弬鏁拌В鏋愬け璐�");
+
+			}
+			ClassfysVO classfysVO = interParameterVO.getData().getClassifys();
+			systemId = interParameterVO.getData().getSystemId();
+			UserVO userVo = interParameterVO.getData().getUser();
+			List<ClassfyVO> classVOList = classfysVO.getClassify();
+			InterParameterVO finalInterParameterVO = interParameterVO;
+			//杩欐槸璐﹀彿淇℃伅
+			SessionInfo sessionInfo = new SessionInfo();
+			sessionInfo.setUserId(userVo.getUserName());
+			sessionInfo.setUserName(userVo.getTrueName());
+			sessionInfo.setIp(userVo.getIp());
+			VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
+			String finalSystemId = systemId;
+			classVOList.stream().forEach(classVO->{
+				log.info("鍙傛暟锛氬垎绫籆Ode:" + classVO.getClassCode());
+				LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs = new LinkedList<>();
+				//鑾峰彇鍒嗙被淇℃伅
+				try {
+					String libray = classVO.getLibrary();
+					CodeClassifyVO codeClassifyVO = getClassfy(classVO);
+					if(codeClassifyVO==null || StringUtils.isBlank(codeClassifyVO.getOid())){
+						objerrorCode="100";
+						throw  new  Throwable ("鏍规嵁浼犺緭鐨勫垎绫伙紝鏈幏鍙栧埌鍒嗙被淇℃伅");
+					}
+					log.info("end锛氬垎绫绘煡璇㈠畬姣�");
+					//鑾峰彇鍒嗙被妯℃澘淇℃伅
+					CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyVO.getOid());
+					if(templateVO==null||StringUtils.isBlank(templateVO.getOid())){
+						objerrorCode="102";
+						throw  new  Throwable ("鏍规嵁浼犺緭鐨勫垎绫伙紝鏈幏鍙朚DM绯荤粺涓搴旀ā鏉�");
+					}
+					log.info("end锛氭ā鏉挎煡璇㈠畬姣�");
+					ApplyDatasVO applyDatasVO = classVO.getObjects();
+					DataObjectVO dataObjectVO = new DataObjectVO();
+					//灏嗛粯璁ょ殑灞炴�у叏閮ㄦ浛鎹㈡帀
+					List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s -> !DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
+					).collect(Collectors.toList());
+					this.getConfigDatas(finalSystemId, libray, applyDatasVO, attrVOS, dataObjectVO);
+					log.info("end锛氭暟鎹瀯寤哄畬姣�");
+					log.info("start锛氫慨鏀规暟鎹墽琛屽畬姣�");
+					mdmIOService.batchSyncEditDatas(codeClassifyVO,dataObjectVO, resultDataObjectDetailDOs);
+					log.info("end锛氫慨鏀规暟鎹墽琛屽畬姣�");
+				} catch (Throwable e) {
+					XMLResultDataObjectDetailDO xmlResultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
+					xmlResultDataObjectDetailDO.setCode("");
+					xmlResultDataObjectDetailDO.setId("");
+					xmlResultDataObjectDetailDO.setErrorid(objerrorCode);
+					xmlResultDataObjectDetailDO.setMsg("缂栫爜鏇存敼/鐘舵�佹洿鏀�/鍒犻櫎:"+e.getMessage());
+					resultDataObjectDetailDOs.add(xmlResultDataObjectDetailDO);
+					e.printStackTrace();
+				}finally {
+					XMLResultClassfyVO resultClassfyVO = new XMLResultClassfyVO();
+					resultClassfyVO.setClassCode(classVO.getClassCode());
+					resultClassfyVO.setLibrary(classVO.getLibrary());
+					resultClassfyVO.setFullclsfNamePath(classVO.getFullclsfNamePath());
+					resultClassfyVO.setObjects(resultDataObjectDetailDOs);
+					resultClassfyVOList.add(resultClassfyVO);
+				}
+
+			});
+		}catch (Throwable e){
+			e.printStackTrace();;
+			msg="缂栫爜鏇存敼/鐘舵�佹洿鏀�/鍒犻櫎:"+e.getMessage();
+          /*  XMLResultSystemVO XMLResultSystemVO=new XMLResultSystemVO();
+            XMLResultSystemVO.setErrorid(errorid);
+            XMLResultSystemVO.setMsg("鐢宠缂栫爜澶辫触锛�->"+e.getMessage());
+            XMLResultSystemVO.setClassifys(resultClassfyVOList);
+            resultStr=transferResultXMl(XMLResultSystemVO,dataType);
+
+            log.error("鐢宠缂栫爜澶辫触锛�->"+e);
+            return resultStr;*/
+		}finally {
+			XMLResultSystemVO xmlResultSystemVO=new XMLResultSystemVO();
+			xmlResultSystemVO.setClassifys(resultClassfyVOList);
+			xmlResultSystemVO.setMsg(msg);
+			xmlResultSystemVO.setErrorid(errorid);
+			resultStr= transferResultXMl(xmlResultSystemVO,dataType);
+			final boolean[] issucess = {true};
+			if(!errorid.equals("0")) {
+				issucess[0] = false;
+			}else {
+				if(!CollectionUtils.isEmpty(resultClassfyVOList)) {
+					resultClassfyVOList.stream().forEach(xMLResultClassfyVO -> {
+						xMLResultClassfyVO.getObjects().stream().forEach(objec -> {
+							if (!(objec.getErrorid().equals("0") || objec.getErrorid().equals("204"))) {
+								issucess[0] = false;
+								msg=objec.getMsg();
+							}
+						});
+					});
+				}
+
+			}
+			try {
+				//璁板綍鏃ュ織
+				this.saveLogs(systemId, systemId, data, resultStr, issucess[0], msg, "syncEditData");
+			}catch (Throwable e){
+				e.printStackTrace();
+			}
+		}
+		log.info("杩斿洖鍙傛暟:"+resultStr);
+		//瀛樺偍鏃ュ織
+		return resultStr;
+	}
+
+	/***
+	 * 鍒嗙被鏌ヨ
+	 * @param data
+	 * @param dataType
+	 * @return
+	 * @throws Throwable
+	 */
+	@Override
+	public String queryClassify(String data, String dataType) throws Throwable {
+		boolean issucess=false;
+		String resultStr = "";
+		String errorid="0";
+		msg="鎴愬姛";
+		String systemId="";
+		log.info("鏌ヨ鍒嗙被鐨勬暟鎹弬鏁�:->"+data);
+		log.info("鏌ヨ鍒嗙被鐨勬暟鎹被鍨�:->"+dataType);
+		ResultClassifyVO resultClassifyVO =new ResultClassifyVO();
+		List<ClassifyVO> classifyVOList=new ArrayList<>();
+		ResultData resultData=new ResultData();
+		try {
+			if (StringUtils.isBlank(data)) {
+				errorid = "101";
+				throw new Throwable("鎺ュ彛鍙傛暟锛氫紶閫掍负绌�");
+			}
+			QueryClassifyVO queryClassifyVO = new QueryClassifyVO();
+			//濡傛灉dataType鏄痻ml鍒欙紝閫氳繃xml搴忓垪鍖栨垚瀵硅薄褰㈠紡锛屽鏋滄槸json鍒欓�氳繃json杞崲鎴愬璞℃牸寮�
+			try {
+				if ("xml".equals(dataType)) {
+					XStream xStream = new XStream(new DomDriver());
+					xStream.processAnnotations(QueryData.class);
+					xStream.autodetectAnnotations(true);
+					QueryData queryData = (QueryData) xStream.fromXML(data);
+					queryClassifyVO.setData(queryData);
+				} else {
+					queryClassifyVO = JSONObject.toJavaObject(JSONObject.parseObject(data), QueryClassifyVO.class);
+				}
+			} catch (Throwable e) {
+				errorid = "101";
+				msg="鎺ュ彛鍙傛暟锛氫紶鍏ユ暟鎹弬鏁拌В鏋愬け璐�";
+				e.printStackTrace();
+				throw new Throwable("鎺ュ彛鍙傛暟锛氫紶鍏ユ暟鎹弬鏁拌В鏋愬け璐�");
+			}
+			QueryData queryData=queryClassifyVO.getData();
+			UserVO userVo=queryData.getUser();
+			systemId=queryData.getSystemId();
+			QueryLibraryVO libraryVO= queryData.getLibrary();
+			String libId= libraryVO.getId();
+			List<String> classifyIdList=  libraryVO.getClassifyid();
+			List<CodeClassifyVO> codeClassifyVOS =new ArrayList<>();
+			//杩欐槸璐﹀彿淇℃伅
+			//杩欐槸璐﹀彿淇℃伅
+			if(userVo!=null) {
+				SessionInfo sessionInfo = new SessionInfo();
+				sessionInfo.setUserId(userVo.getUserName());
+				sessionInfo.setUserName(userVo.getTrueName());
+				sessionInfo.setIp(userVo.getIp());
+				VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
+			}else{
+				errorid = "101";
+				throw new Throwable("鎺ュ彛鍙傛暟锛氳处鍙蜂俊鎭幏鍙栧け璐�");
+			}
+			if(!CollectionUtils.isEmpty(classifyIdList)){
+				//鍏堢畝绉版槸鍚︽湁鍏宠仈妯℃澘锛屾湁妯℃澘瑕佸厛鍒犻櫎
+				List<CodeClassify> libIdDos = classifyService.selectByWrapper(Wrappers.<CodeClassify>query().lambda().in(CodeClassify::getId, classifyIdList));
+				codeClassifyVOS=classifyService.codeClassifyDO2VOs(libIdDos);
+			}else {
+				List<CodeClassify> libIdDos = classifyService.selectByWrapper(Wrappers.<CodeClassify>query().lambda().eq(CodeClassify::getId, libId));
+				String oid= libIdDos.get(0).getOid();
+				TreeQueryObject treeQueryObject=new TreeQueryObject();
+				treeQueryObject.setParentOid(oid);
+				treeQueryObject.setQueryAllLevel(true);
+				codeClassifyVOS=classifyService.selectCodeClassifyDOByTree(treeQueryObject);
+			}
+			LibraryVO libraryVo=new LibraryVO();
+			libraryVo.setId(libId);
+			libraryVo.setName("");
+			if(!CollectionUtils.isEmpty(codeClassifyVOS)){
+				errorid = "0";
+				msg="鎴愬姛!";
+				codeClassifyVOS.stream().forEach(codeClassifyDO -> {
+					ClassifyVO classifyVO=new ClassifyVO();
+					classifyVO.setId(codeClassifyDO.getOid());
+					classifyVO.setLcStatus(codeClassifyDO.getLcStatus());
+					classifyVO.setClassCode(codeClassifyDO.getId());
+					classifyVO.setDescription(codeClassifyDO.getDescription());
+					classifyVO.setName(codeClassifyDO.getName());
+					classifyVO.setPid(codeClassifyDO.getParentcodeclassifyoid());
+					classifyVO.setFullPathName(codeClassifyDO.getPath());
+					classifyVOList.add(classifyVO);
+				});
+				libraryVo.setClassify(classifyVOList);
+			}else{
+				errorid = "100";
+				msg="鏈煡璇㈠埌鐩稿叧鐨勫垎绫讳俊鎭�";
+			}
+			issucess=true;
+			resultData.setLibrary(libraryVo);
+		}catch (Throwable e){
+			e.printStackTrace();;
+			msg="鏌ヨ鍒嗙被澶辫触:"+e.getMessage();
+		}finally {
+			resultData.setErrorid(errorid);
+			resultData.setMsg(msg);
+			resultClassifyVO.setResultData(resultData);
+		}
+		if(dataType.equals("xml")){
+			//缁勭粐杩斿洖鎺ュ彛淇℃伅
+			XStream xStream = new XStream(new DomDriver());
+			xStream.processAnnotations(XMLResultSystemVO.class);
+			xStream.autodetectAnnotations(true);
+			resultStr = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" + xStream.toXML(resultData);
+
+		}else{
+			Object object = JSONObject.toJSON(resultClassifyVO);
+			resultStr = object.toString();
+		}
+		try {
+			//璁板綍鏃ュ織
+			this.saveLogs(systemId, systemId, data, resultStr, issucess, msg, "queryClassify");
+		}catch (Throwable e){
+			e.printStackTrace();
+		}
+		log.info("杩斿洖鍙傛暟:"+resultStr);
+		return resultStr;
+	}
+
+	/***
+	 * 鏁版嵁鏌ヨ
+	 * @param data
+	 * @param dataType
+	 * @return
+	 * @throws Throwable
+	 */
+	@Override
+	public String queryData(String data, String dataType) throws Throwable {
+		boolean issucess=false;
+		String resultStr = "";
+		String errorid="0";
+		msg="鎴愬姛";
+		String systemId="";
+		log.info("鏌ヨ鍒嗙被鐨勬暟鎹弬鏁�:->"+data);
+		log.info("鏌ヨ鍒嗙被鐨勬暟鎹被鍨�:->"+dataType);
+		DataCondtionsVO dataCondtionsVO=new DataCondtionsVO();
+		ResultDataVO resultDataVO=new ResultDataVO();
+		try {
+			try {
+				if ("xml".equals(dataType)) {
+					XStream xStream = new XStream(new DomDriver());
+					xStream.processAnnotations(CondtionsVO.class);
+					xStream.autodetectAnnotations(true);
+					CondtionsVO condtionsVO = (CondtionsVO) xStream.fromXML(data);
+					dataCondtionsVO.setCondtions(condtionsVO);
+				} else {
+					dataCondtionsVO = JSONObject.toJavaObject(JSONObject.parseObject(data), DataCondtionsVO.class);
+				}
+			} catch (Throwable e) {
+				errorid = "101";
+				msg = "鎺ュ彛鍙傛暟锛氫紶鍏ユ暟鎹弬鏁拌В鏋愬け璐�";
+				e.printStackTrace();
+				throw new Throwable("鎺ュ彛鍙傛暟锛氫紶鍏ユ暟鎹弬鏁拌В鏋愬け璐�");
+			}
+			CondtionsVO condtionsVO=dataCondtionsVO.getCondtions();
+			systemId=condtionsVO.getSystemId();
+			UserVO userVo=condtionsVO.getUser();
+			CondtionVO condtionVO= condtionsVO.getCondtion();
+			SessionInfo sessionInfo = new SessionInfo();
+			sessionInfo.setUserId(userVo.getUserName());
+			sessionInfo.setUserName(userVo.getTrueName());
+			sessionInfo.setIp(userVo.getIp());
+			VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
+
+			String classCode=condtionVO.getClassCode();
+			String library= condtionVO.getLibrary();
+			String queryFileds= condtionVO.getQueryFileds();
+			if(StringUtils.isBlank(library)){
+				errorid = "101";
+				msg = "鎺ュ彛鍙傛暟锛歭ibrary 涓簄ull";
+				throw new Throwable(msg);
+			}
+
+			//鍏堢畝绉版槸鍚︽湁鍏宠仈妯℃澘锛屾湁妯℃澘瑕佸厛鍒犻櫎
+
+			List<CodeClassify> libIdDos =classifyService.selectByWrapper(Wrappers.<CodeClassify>query().lambda().eq(CodeClassify::getId,library));
+			if(!CollectionUtils.isEmpty(libIdDos)){
+				CodeClassify libCodeClassify=libIdDos.get(0);
+				List<CodeClassify> codeClassifyList=classifyService.selectByWrapper(Wrappers.<CodeClassify>query().lambda().eq(CodeClassify::getId,classCode));
+				if(!CollectionUtils.isEmpty(codeClassifyList)){
+					final CodeClassify[] currentCodeClassify = {null};
+					codeClassifyList.stream().forEach(codeClassify -> {
+						CodeClassifyVO codeClassifyVO=  classifyService.getTopClassifyVO(codeClassify.getOid());
+						if(codeClassifyVO.getOid().equals(libCodeClassify.getOid())){
+							currentCodeClassify[0] =codeClassify;
+						}
+					});
+					if(currentCodeClassify[0]==null){
+						errorid = "101";
+						msg = "鎺ュ彛鍙傛暟锛歝lassCode 鏈煡璇㈠埌瀵瑰簲鐨勫垎绫讳俊鎭�";
+						throw new Throwable(msg);
+					}
+					List<CodeClassifyVO> dataCodeClassifyVOList =new ArrayList<>();
+					String oid= currentCodeClassify[0].getOid();
+					TreeQueryObject treeQueryObject=new TreeQueryObject();
+					treeQueryObject.setParentOid(oid);
+					treeQueryObject.setQueryAllLevel(true);
+					dataCodeClassifyVOList=classifyService.selectCodeClassifyDOByTree(treeQueryObject);
+					dataCodeClassifyVOList.add(CodeClassifyWrapper.build().entityVO(currentCodeClassify[0]));
+					Map<String, CodeClassifyVO> oidCodeclassifyDOMap = dataCodeClassifyVOList.stream().filter(systeDataObject -> systeDataObject != null && StringUtils.isNotBlank(systeDataObject.getOid())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
+
+					List<PropertyVO>  propertyVOS=condtionVO.getPro();
+					/*Map<String,String> condtionMap=new HashMap<>();
+					propertyVOS.stream().forEach(propertyVO -> {
+						condtionMap.put(propertyVO.getFiledName(),propertyVO.getFiledValue());
+					});
+					condtionMap.put("codeclsfid", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(oidCodeclassifyDOMap.keySet().toArray(new String[0])) + ")");
+					List<String>statusList=new ArrayList<>();
+					statusList.add(CodeDefaultLC.RELEASED.getValue());
+					statusList.add(CodeDefaultLC.DISABLE.getValue());
+					statusList.add(CodeDefaultLC.TASK_BACK.getValue());
+					condtionMap.put("Lcstatus",  QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(statusList.toArray(new String[]{})) + ")" );
+					condtionMap.put("islastr", "1");
+					condtionMap.put("islastv", "1");*/
+					List<String>statusList=new ArrayList<>();
+					statusList.add(CodeDefaultLC.RELEASED.getValue());
+					statusList.add(CodeDefaultLC.DISABLE.getValue());
+					statusList.add(CodeDefaultLC.TASK_BACK.getValue());
+					R<BtmTypeVO>  r= btmTypeClient.getDetail(libCodeClassify.getBtmTypeId());
+					BtmTypeVO btmTypeVO =r.getData();
+					String tableName=btmTypeVO.getTableName();
+
+					StringBuffer sb=new StringBuffer();
+					sb.append(" select * from  ");
+					sb.append(tableName);
+					sb.append(" where 1=1");
+					propertyVOS.stream().forEach(propertyVO -> {
+						sb.append( " and  "+propertyVO.getFiledName()+"='"+propertyVO.getFiledValue()+"'");
+					});
+					sb.append(" and lastr=1 and lastv=1" );
+					sb.append(" and codeclsfid in (" + VciBaseUtil.toInSql(oidCodeclassifyDOMap.keySet().toArray(new String[0])) +")");
+					sb.append(" and Lcstatus in (" + VciBaseUtil.toInSql(statusList.toArray(new String[]{})) +")");
+					List<Map<String,String>>  newDataList= commonsMapper.queryByOnlySqlForMap(sb.toString());
+					List<ClientBusinessObject>clientBusinessObjects=new ArrayList<>();
+					newDataList.stream().forEach(stringStringMap -> {
+						ClientBusinessObject clientBusinessObject=new ClientBusinessObject();
+						DefaultAttrAssimtUtil.copplyDefaultAttrAssimt(stringStringMap,clientBusinessObject);
+						clientBusinessObjects.add(clientBusinessObject);
+					});
+
+					List<com.vci.ubcs.code.vo.webserviceModel.data.DataObjectVO> dataObjectVOS=new ArrayList<>();
+					if(!CollectionUtils.isEmpty(clientBusinessObjects)){
+						CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(currentCodeClassify[0].getOid());
+						Map<String, CodeClassifyTemplateAttrVO> filedAttributeMap = templateVO.getAttributes().stream().filter(attribute -> attribute != null && StringUtils.isNotBlank(attribute.getId())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getId(), t -> t));
+
+						clientBusinessObjects.stream().forEach(cbo -> {
+							com.vci.ubcs.code.vo.webserviceModel.data.DataObjectVO dataObjectVO=new com.vci.ubcs.code.vo.webserviceModel.data.DataObjectVO();
+							dataObjectVO.setCode(cbo.getId());
+							dataObjectVO.setStatus(cbo.getLcStatus());
+							String codeclsfid=cbo.getAttributeValue("codeclsfid");
+							if(oidCodeclassifyDOMap.containsKey(codeclsfid)){
+								CodeClassifyVO codeClassifyVO=  oidCodeclassifyDOMap.get(codeclsfid);
+								dataObjectVO.setClassCode(codeClassifyVO.getId());
+							}
+							dataObjectVO.setLibrary(library);
+							String [] newQueryFileds=queryFileds.split(",");
+							List<PropertyVO> propertyVOList=new ArrayList<>();
+							for(String filed:newQueryFileds){
+								String value=cbo.getAttributeValue(filed);
+								if(filedAttributeMap.containsKey(filed)){
+									CodeClassifyTemplateAttrVO attrVO=  filedAttributeMap.get(filed);
+									PropertyVO propertyVO=new PropertyVO();
+									propertyVO.setFiledName(filed);
+									propertyVO.setFiledValue(value);
+									propertyVO.setOutname(attrVO.getName());
+									propertyVOList.add(propertyVO);
+								}
+							}
+							dataObjectVO.setPro(propertyVOList);
+							dataObjectVOS.add(dataObjectVO);
+						});
+						resultDataVO.setObject(dataObjectVOS);
+					}
+				}else{
+					errorid = "101";
+					msg = "鎺ュ彛鍙傛暟锛歝lassCode 鏈煡璇㈠埌瀵瑰簲鐨勫垎绫讳俊鎭�";
+					throw new Throwable(msg);
+				}
+			}else{
+				errorid = "101";
+				msg = "鎺ュ彛鍙傛暟锛歭ibrary 鏈煡璇㈠埌瀵瑰簲鐨勫簱鑺傜偣淇℃伅";
+			}
+			errorid = "0";
+			msg = "鏁版嵁鏌ヨ鎴愬姛";
+		}catch (Throwable e){
+			e.printStackTrace();;
+			msg="鏌ヨ鏁版嵁澶辫触:"+e.getMessage();
+		}finally {
+			resultDataVO.setErrorid(errorid);
+			resultDataVO.setMsg(msg);
+		}
+		ResultVO resultVO=new ResultVO();
+		resultVO.setData(resultDataVO);
+		if(dataType.equals("xml")){
+			//缁勭粐杩斿洖鎺ュ彛淇℃伅
+			XStream xStream = new XStream(new DomDriver());
+			xStream.processAnnotations(XMLResultSystemVO.class);
+			xStream.autodetectAnnotations(true);
+			resultStr = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" + xStream.toXML(resultDataVO);
+		}else{
+			Object object = JSONObject.toJSON(resultVO);
+			resultStr = object.toString();
+		}
+		try {    //璁板綍鏃ュ織
+			this.saveLogs(systemId, systemId, data, resultStr, issucess, msg, "queryClassify");
+		}catch (Throwable e){
+			e.printStackTrace();
+		}
+		log.info("杩斿洖鍙傛暟:"+resultStr);
+		return resultStr;
+	}
+
+
+
+	@Override
+	public String queryClassifyRule(String data, String dataType) throws Throwable {
+
+		boolean issucess=false;
+		String resultStr = "";
+		String errorid="0";
+		msg="鎴愬姛";
+		String systemId="";
+		log.info("鏌ヨ鍒嗙被鐨勬暟鎹弬鏁�:->"+data);
+		log.info("鏌ヨ鍒嗙被鐨勬暟鎹被鍨�:->"+dataType);
+		ResultClassifyVO resultClassifyVO =new ResultClassifyVO();
+		List<ClassifyVO> classifyVOList=new ArrayList<>();
+		ResultData resultData=new ResultData();
+		try {
+			if (StringUtils.isBlank(data)) {
+				errorid = "101";
+				throw new Throwable("鎺ュ彛鍙傛暟锛氫紶閫掍负绌�");
+			}
+			QueryClassifyVO queryClassifyVO = new QueryClassifyVO();
+			//濡傛灉dataType鏄痻ml鍒欙紝閫氳繃xml搴忓垪鍖栨垚瀵硅薄褰㈠紡锛屽鏋滄槸json鍒欓�氳繃json杞崲鎴愬璞℃牸寮�
+			try {
+				if ("xml".equals(dataType)) {
+					XStream xStream = new XStream(new DomDriver());
+					xStream.processAnnotations(QueryData.class);
+					xStream.autodetectAnnotations(true);
+					QueryData queryData = (QueryData) xStream.fromXML(data);
+					queryClassifyVO.setData(queryData);
+				} else {
+					queryClassifyVO = JSONObject.toJavaObject(JSONObject.parseObject(data), QueryClassifyVO.class);
+				}
+			} catch (Throwable e) {
+				errorid = "101";
+				msg = "鎺ュ彛鍙傛暟锛氫紶鍏ユ暟鎹弬鏁拌В鏋愬け璐�";
+				e.printStackTrace();
+				throw new Throwable("鎺ュ彛鍙傛暟锛氫紶鍏ユ暟鎹弬鏁拌В鏋愬け璐�");
+			}
+			QueryData queryData=queryClassifyVO.getData();
+			UserVO userVo=queryData.getUser();
+			systemId=queryData.getSystemId();
+			QueryLibraryVO libraryVO= queryData.getLibrary();
+			String libId= libraryVO.getId();
+			List<String> classifyIdList=  libraryVO.getClassifyid();
+			List<CodeClassifyVO> codeClassifyVOS =new ArrayList<>();
+			//杩欐槸璐﹀彿淇℃伅
+			//杩欐槸璐﹀彿淇℃伅
+			if(userVo!=null) {
+				SessionInfo sessionInfo = new SessionInfo();
+				sessionInfo.setUserId(userVo.getUserName());
+				sessionInfo.setUserName(userVo.getTrueName());
+				sessionInfo.setIp(userVo.getIp());
+				VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
+			}else{
+				errorid = "101";
+				throw new Throwable("鎺ュ彛鍙傛暟锛氳处鍙蜂俊鎭幏鍙栧け璐�");
+			}
+			if(!CollectionUtils.isEmpty(classifyIdList)){
+				//鍏堢畝绉版槸鍚︽湁鍏宠仈妯℃澘锛屾湁妯℃澘瑕佸厛鍒犻櫎
+				List<CodeClassify> libIdDos = classifyService.selectByWrapper(Wrappers.<CodeClassify>query().lambda().in(CodeClassify::getId, classifyIdList));
+				codeClassifyVOS=classifyService.codeClassifyDO2VOs(libIdDos);
+			}else {
+				List<CodeClassify> libIdDos = classifyService.selectByWrapper(Wrappers.<CodeClassify>query().lambda().eq(CodeClassify::getId, libId));
+				String oid= libIdDos.get(0).getOid();
+				TreeQueryObject treeQueryObject=new TreeQueryObject();
+				treeQueryObject.setParentOid(oid);
+				treeQueryObject.setQueryAllLevel(true);
+				codeClassifyVOS=classifyService.selectCodeClassifyDOByTree(treeQueryObject);
+			}
+			LibraryVO libraryVo=new LibraryVO();
+			libraryVo.setId(libId);
+			libraryVo.setName("");
+			if(!CollectionUtils.isEmpty(codeClassifyVOS)){
+				errorid = "0";
+				msg="鎴愬姛!";
+				codeClassifyVOS.stream().forEach(codeClassifyDO -> {
+					ClassifyVO classifyVO=new ClassifyVO();
+					classifyVO.setId(codeClassifyDO.getOid());
+					classifyVO.setLcStatus(codeClassifyDO.getLcStatus());
+					classifyVO.setClassCode(codeClassifyDO.getId());
+					classifyVO.setDescription(codeClassifyDO.getDescription());
+					classifyVO.setName(codeClassifyDO.getName());
+					classifyVO.setPid(codeClassifyDO.getParentcodeclassifyoid());
+					classifyVO.setFullPathName(codeClassifyDO.getPath());
+					classifyVOList.add(classifyVO);
+				});
+				libraryVo.setClassify(classifyVOList);
+			}else{
+				errorid = "100";
+				msg="鏈煡璇㈠埌鐩稿叧鐨勫垎绫讳俊鎭�";
+			}
+			issucess=true;
+			resultData.setLibrary(libraryVo);
+		}catch (Throwable e){
+			e.printStackTrace();;
+			msg="鏌ヨ鍒嗙被澶辫触:"+e.getMessage();
+		}finally {
+			resultData.setErrorid(errorid);
+			resultData.setMsg(msg);
+			resultClassifyVO.setResultData(resultData);
+		}
+		if(dataType.equals("xml")){
+			//缁勭粐杩斿洖鎺ュ彛淇℃伅
+			XStream xStream = new XStream(new DomDriver());
+			xStream.processAnnotations(XMLResultSystemVO.class);
+			xStream.autodetectAnnotations(true);
+			resultStr = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" + xStream.toXML(resultData);
+
+		}else{
+			Object object = JSONObject.toJSON(resultClassifyVO);
+			resultStr = object.toString();
+		}
+		try {
+			//璁板綍鏃ュ織
+			this.saveLogs(systemId, systemId, data, resultStr, issucess, msg, "queryClassify");
+		}catch (Throwable e){
+			e.printStackTrace();
+		}
+		log.info("杩斿洖鍙傛暟:"+resultStr);
+		return resultStr;
+	}
+
+	/***
+	 * 鏌ヨ鏍￠獙鍒嗙被淇℃伅
+	 * @param classfyVO
+	 */
+	private  CodeClassifyVO getClassfy(ClassfyVO classfyVO) throws Throwable{
+		CodeClassifyVO classifyVO = new CodeClassifyVO();
+		try {
+			String classCode = classfyVO.getClassCode();
+			String className = classfyVO.getFullclsfNamePath();
+			//鏍规嵁鍒嗙被浠ｅ彿鏌ヨ鍒嗙被淇℃伅
+			if (StringUtils.isNotBlank(classfyVO.getClassCode())) {
+				Map<String, String> conditionMap = new HashMap<>();
+				List<CodeClassify> codeClassifyList = classifyService.selectByWrapper(Wrappers.<CodeClassify>query().lambda().eq(CodeClassify::getId, classCode));
+				if (!CollectionUtils.isEmpty(codeClassifyList)) {
+					CodeClassify classifyDO = codeClassifyList.get(0);
+					//灏咲TO杞崲涓篋O
+					classifyVO = new CodeClassifyVO();
+					BeanUtilForVCI.copyPropertiesIgnoreCase(classifyDO, classifyVO);
+					if(StringUtils.isBlank(classifyVO.getOid())){
+						throw new  Throwable("鏍规嵁鍒嗙被浠ｅ彿鏈煡璇㈠埌鐩稿簲鐨勫垎绫讳俊鎭�");
+					}
+				}else{
+					throw new  Throwable("鏍规嵁鍒嗙被浠ｅ彿鏈煡璇㈠埌鐩稿簲鐨勫垎绫讳俊鎭�");
+				}
+			} else {
+				classifyVO = classifyService.getObjectByClsfNamePath(className.replace(separator, "/"));
+				if(StringUtils.isBlank(classifyVO.getOid())){
+					throw new  Throwable("鏍规嵁鍒嗙被鍚嶇О璺緞鏈煡璇㈠埌鐩稿簲鐨勫垎绫讳俊鎭�");
+				}
+			}
+		}catch (Throwable e){
+			objerrorCode="100";
+			new  Throwable("鑾峰彇鍒嗙被淇℃伅澶辫触:"+e.getMessage());
+		}
+		return classifyVO;
+	}
+
+	private List<ClientBusinessObject> ChangeMapTOClientBusinessObjects(List<Map<String,String>> oldDataMap){
+		List<ClientBusinessObject> clientBusinessObjectList=new CopyOnWriteArrayList<>();
+		oldDataMap.parallelStream().forEach(dataMap->{
+			ClientBusinessObject clientBusinessObject=new ClientBusinessObject();
+			DefaultAttrAssimtUtil.copplyDefaultAttrAssimt(dataMap,clientBusinessObject);
+			dataMap.forEach((key,value)->{
+				clientBusinessObject.setAttributeValue(key,value);
+			});
+		});
+		return clientBusinessObjectList;
+	}
+	/***
+	 * 鏍规嵁绌垮叆鐨勫弬鏁颁俊鎭牎楠岀爜娈佃鍒�
+	 */
+	private List<CodeOrderSecDTO> getRuleCodeOrderSecDTOs(List<SectionVO> SectionVOList,CodeRuleVO ruleVO,CodeClassifyFullInfoBO classifyFullInfo) throws Throwable{
+		List<CodeBasicSecVO>  codeBasicSecVOS= ruleVO.getSecVOList();
+		Map<String,String> sectionVOMap=new HashMap<>();
+		SectionVOList.stream().forEach(SectionVO->{
+			sectionVOMap.put(SectionVO.getName(),SectionVO.getValue());
+		});
+		Map<String,CodeClassifyVO> codeClassifyVOMap= classifyFullInfo.getParentClassifyVOs().stream().collect(Collectors.toMap(s -> s.getId(), t -> t,(o1, o2)->o2));
+		List<CodeOrderSecDTO> codeOrderSecDTOList=new ArrayList<>();
+		for(CodeBasicSecVO codeBasicSecVO: codeBasicSecVOS) {
+			String sectype = codeBasicSecVO.getSecType();
+			String classifySecOid= codeBasicSecVO.getOid();
+			if (!sectype.equals(CodeSecTypeEnum.CODE_SERIAL_SEC.getValue())) {
+				String name = codeBasicSecVO.getName();
+				String sectypeText = codeBasicSecVO.getSecTypeText();
+				log.info("鐮佹鍚嶇О:"+name);
+				log.info("鎻忚堪:"+sectypeText);
+				CodeOrderSecDTO CodeOrderSecDTO = new CodeOrderSecDTO();
+				if (sectionVOMap.containsKey(name)) {
+					CodeOrderSecDTO.setSecOid(codeBasicSecVO.getOid());
+					String sectypeValue = sectionVOMap.get(name);
+					log.info("鐮佹鍊�:"+sectypeValue);
+					CodeSecTypeEnum secType = CodeSecTypeEnum.forValue(sectype);
+					if(CODE_CLASSIFY_SEC.equals(secType)) {//濡傛灉鏄垎绫荤殑璇濓紝鍒欓渶瑕佸尮閰嶄紶杩囨潵鐨勫垎绫讳唬鍙蜂笌
+						//鍏堢畝绉版槸鍚︽湁鍏宠仈妯℃澘锛屾湁妯℃澘瑕佸厛鍒犻櫎
+						List<CodeClassifyValue> codeClassifyValueDOList = codeClassifyValueService.list(Wrappers.<CodeClassifyValue>query().lambda().eq(CodeClassifyValue::getCodeClassifySecOid,classifySecOid));
+
+						if (!CollectionUtils.isEmpty(codeClassifyValueDOList)) {
+							Map<String, CodeClassifyValue> codeClassifyValueDOMap = codeClassifyValueDOList.stream().collect(Collectors.toMap(s -> s.getId(), t -> t, (o1, o2) -> o2));
+							if(codeClassifyValueDOMap.containsKey(sectypeValue)){
+								CodeClassifyValue codeClassifyValue=   codeClassifyValueDOMap.get(sectypeValue);
+								sectypeValue=codeClassifyValue.getOid();
+							}else {
+								objerrorCode = "101";
+								throw new Throwable("浼犲叆鐨勫垎绫荤爜娈碉細銆�" + name + " 鍊硷細" + sectypeValue + "銆戯紝涓嶇鍚堝綋鍓嶅垎绫诲眰绾т唬鍙�");
+							}
+						}
+					}
+					CodeOrderSecDTO.setSecValue(sectypeValue);
+					codeOrderSecDTOList.add(CodeOrderSecDTO);
+				} else {
+					objerrorCode="101";
+					throw new Throwable("浼犲叆鐨勭爜娈佃鍒欑己灏�" + name + "鐮佹");
+				}
+			}
+		}
+		return codeOrderSecDTOList;
+	}
+	/***
+	 * 鏍规嵁灞炴�ф槧灏勮浆鎹㈢紪鐮佹墍闇�瀛楁
+	 */
+	public void getConfigDatas(String systemId,String libray, ApplyDatasVO applyDatasVO,List<CodeClassifyTemplateAttrVO> codeClassifyTemplateAttrVOList,DataObjectVO dataObjectVO) throws Throwable {
+		List<ApplyDataVO> applyDataVOList=applyDatasVO.getObject();
+		LinkedHashMap<String,LinkedHashMap<String,String>> dataKeyValueMap=new LinkedHashMap<>();
+		//濡傛灉灏嗘暟鎹浆鎹㈡垚鎵�闇�瑕佺殑鏁版嵁瀵硅薄
+		Map<String, String> attrMapConfigMap=new HashMap<>();
+		Map<String, String> propMaps=new HashMap<>();
+		try {
+			log.info("寮�濮嬭鍙栫郴缁熼厤缃枃浠� start");
+			Map<String, String> stringStringMap=attributeMapConfig.getSystem_attrmap();
+			log.info("闆嗘垚绯荤粺灞炴�ф槧灏勯厤缃枃浠舵潯鐩暟-銆�"+stringStringMap.size());
+			//stringStringMap.put("RLM","D:\\RLM.xml");
+			LibraryDO libraryDO=gennerAttrMapUtil.getNewInstance().gennerAttrMapBySystem(systemId,stringStringMap);
+			List<LibraryClsfDO> libraryClsfDOList=libraryDO.getClsf();
+			Map<String, List<ClsfAttrMappingDO>> libPropMaps = libraryClsfDOList.stream().collect(Collectors.toMap(LibraryClsfDO::getLibrary, LibraryClsfDO::getProp, (key1, key2) -> key2));
+			log.info("鏍规嵁鍙傛暟锛歭ibray锛�-銆�"+libray+"浠庨厤缃枃浠朵腑鎵惧搴斿睘鎬ф槧灏勯厤缃�");
+			if(libPropMaps.containsKey(libray)){
+				log.info("鏍规嵁鍙傛暟锛歭ibray锛�-銆�"+libray+"鍖归厤鍒扮浉搴旂殑灞炴�ф槧灏勪俊鎭�");
+				List<ClsfAttrMappingDO> clsfAttrMappingDOList=libPropMaps.get(libray);
+				propMaps = clsfAttrMappingDOList.stream().collect(Collectors.toMap(ClsfAttrMappingDO::getSourceKey, ClsfAttrMappingDO::getTargetKey, (key1, key2) -> key2));
+				log.info("鏍规嵁鍙傛暟锛歭ibray锛�-銆�"+libray+"鍖归厤鍒扮浉搴旂殑灞炴�ф槧灏勪俊鎭�,灞炴�ф槧灏勬潯鐩暟+"+clsfAttrMappingDOList.size());
+			}
+			log.info("鏍规嵁鍙傛暟锛歭ibray锛�-銆�"+libray+"浠庨厤缃枃浠朵腑鎵惧搴斿睘鎬ф槧灏勯厤缃� end ");
+		}catch (Throwable e){
+			objerrorCode="1";
+			e.printStackTrace();
+			throw new Throwable("MDM闆嗘垚灞炴�ч厤缃枃浠惰鍙栧け璐�");
+		}
+		LinkedList<String> rowNameList=new LinkedList<>();
+		LinkedHashMap<String,Integer> filedIndexMap=new LinkedHashMap<>();
+		//鏍规嵁鍒嗙被妯℃澘缁勭粐鏁版嵁
+		final int[] index = {0};
+		try {
+			codeClassifyTemplateAttrVOList.stream().forEach(codeClassifyTemplateAttrVO -> {
+				String attrName = codeClassifyTemplateAttrVO.getName();
+				String field = codeClassifyTemplateAttrVO.getId();
+				rowNameList.add(attrName);
+				filedIndexMap.put(field, index[0]++);
+			});
+			dataObjectVO.setColName(rowNameList);//鏀惧叆灞炴��
+			attrMapConfigMap.putAll(propMaps);
+			LinkedList<RowDatas> rowDataList = new LinkedList<>();
+			//Map<String, List<ProppertyVO>> dataPropMap = applyDataVOList.stream().collect(Collectors.toMap(ApplyDataVO::getId, ApplyDataVO::getProp, (key1, key2) -> key2));
+			final int[] rowIndex = {0};
+			applyDataVOList.stream().forEach(applyDataVO -> {
+				rowIndex[0]++;
+				RowDatas rowDatas = new RowDatas();
+				rowDatas.setOid(applyDataVO.getId());
+				rowDatas.setCreator(applyDataVO.getCreator());
+				rowDatas.setEditor(applyDataVO.getEditor());
+				rowDatas.setCode(applyDataVO.getCode());
+				rowDatas.setOperation(applyDataVO.getOperate());
+				rowDatas.setStatus(applyDataVO.getStatus());
+				rowDatas.setRowIndex(rowIndex[0] + "");
+				List<ProppertyVO> proppertyVOList = applyDataVO.getProp();
+
+				LinkedHashMap<Integer, String> integerValueMap = new LinkedHashMap<>();
+				Map<String, String> filedValueMap = new HashMap<>();
+				if (!CollectionUtils.isEmpty(proppertyVOList)) {
+					Map<String, String> sourceKeyValueMap = proppertyVOList.stream().collect(Collectors.toMap(ProppertyVO::getKey, ProppertyVO::getValue, (key1, key2) -> key2));
+					Map<String, String> keyValueMap = new HashMap<>();
+					//鍒ゆ柇attrMapConfigMap鏄惁鏈夊�硷紝濡傛灉娌℃湁鍒欒鏄庡熀纭�榛樿鐨勬槸缂栫爜绯荤粺瀛楁
+					if (!CollectionUtils.isEmpty(attrMapConfigMap)) {
+						sourceKeyValueMap.keySet().forEach(sourceKey -> {
+							String dataValue = sourceKeyValueMap.get(sourceKey);
+							if (attrMapConfigMap.containsKey(sourceKey)) {
+								String targetKey = attrMapConfigMap.get(sourceKey);
+								keyValueMap.put(targetKey, StringUtils.isBlank(dataValue)?"":dataValue);
+							}
+						});
+					} else {
+						sourceKeyValueMap.forEach((filed,value)->{
+							keyValueMap.put(filed,StringUtils.isBlank(value)?"":value) ;
+						});
+					}
+
+					filedIndexMap.forEach((attrKey, column) -> {
+						String keyValue = "";
+						if (keyValueMap.containsKey(attrKey)) {
+							keyValue =StringUtils.isBlank(keyValueMap.get(attrKey))?"":keyValueMap.get(attrKey);
+						}
+						integerValueMap.put(column, keyValue);
+						filedValueMap.put(attrKey, keyValue);
+					});
+				}
+				rowDatas.setData(integerValueMap);
+				rowDatas.setFiledValue(filedValueMap);
+				rowDataList.add(rowDatas);
+			});
+			dataObjectVO.setRowData(rowDataList);
+		}catch (Throwable e){
+			objerrorCode="1";
+			throw new   Throwable("缁勭粐鏁版嵁鏄犲皠鍊煎け璐�");
+		}
+	}
+	/***
+	 * 璁板綍鏃ュ織淇℃伅
+	 * @param systemId
+	 * @param parmaData
+	 * @param result
+	 * @return
+	 */
+	private  void saveLogs(String systemId,String systemName,String parmaData, String result,boolean isSucess,String msg,String operation){
+		//璁板綍鏃ュ織淇℃伅
+		DockingLog dockingLoge=new DockingLog();
+		//String oid=redisService.getUUIDEveryDay();
+		dockingLoge.setSystemCode(StringUtils.isBlank(systemId)?"-":systemId);//璁剧疆绯荤粺鏍囪瘑
+		dockingLoge.setSystemName(StringUtils.isBlank(systemName)?"-":systemName);
+		dockingLoge.setMsg(msg);//鏃ュ織娑堟伅
+		dockingLoge.setClassifyId("-");//鍒嗙被缂栧彿
+		dockingLoge.setClassifyName("-");//鍒嗙被鍚嶇О
+		dockingLoge.setClassifyOid("-");//鍒嗙被涓婚敭
+		dockingLoge.setUniqueCode("-");//鍞竴鏍囪瘑
+		dockingLoge.setSystemOid("-");//绯荤粺鏍囪瘑
+//        dockingLogeDO.setName(operation);
+		//dockingLogeDO.setOid(oid);//鏃ュ織涓婚敭
+		dockingLoge.setParamString(parmaData);//鍙傛暟淇℃伅
+		dockingLoge.setReturnString(result);//杩斿洖淇℃伅
+		dockingLoge.setType(operation);//鏃ュ織鎿嶄綔绫诲瀷
+		if(isSucess) {
+			dockingLoge.setInterfaceStatus("true");//鎺ュ彛闆嗘垚鐘舵��
+		}else{
+			dockingLoge.setInterfaceStatus("false");//鎺ュ彛闆嗘垚鐘舵��
+		}
+		dockingLogeService.save(dockingLoge);
+		log.info("闆嗘垚鎺ㄩ�佹暟鎹垚鍔�,systemId:"+systemId+",systemname:"+systemName+",operation:"+operation+",param:"+parmaData);
+	}
+
+	/***
+	 * 鏁版嵁缁存姢涓庣紪鐮佺敵璇疯繑鍥�
+	 * @param resultSystemVO
+	 * @param dataType
+	 * @return
+	 */
+	private String transferResultXMl(XMLResultSystemVO resultSystemVO,String dataType){
+		String resultStr="";
+		if ("xml".equals(dataType)) {
+			//缁勭粐杩斿洖鎺ュ彛淇℃伅
+			XStream xStream = new XStream(new DomDriver());
+			xStream.processAnnotations(XMLResultSystemVO.class);
+			xStream.autodetectAnnotations(true);
+			resultStr = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" + xStream.toXML(resultSystemVO);
+		} else {
+			List<XMLResultClassfyVO> resultClassfyVOList =resultSystemVO.getClassifys();
+			JSONResultDataVO resultDataVO = new JSONResultDataVO();
+			JSONResultSystemVO jsonResultSystemVO = new JSONResultSystemVO();
+			JSONResultClassfysVO jsonResultClassfysVO = new JSONResultClassfysVO();
+			List<JSONResultClassfyVO> jSONResultClassfyVOList = new ArrayList<>();
+			resultClassfyVOList.stream().forEach(resultClassfyVO -> {
+				List<XMLResultDataObjectDetailDO> xmlResultDataObjectDetailDOS = resultClassfyVO.getObjects();
+				List<JSONResultDataObjectDetailDO> JSONResultDataObjectDetailDOList = new ArrayList<>();
+				xmlResultDataObjectDetailDOS.stream().forEach(xmlResultDataObjectDetail -> {
+					JSONResultDataObjectDetailDO jsonResultDataObjectDetail = new JSONResultDataObjectDetailDO();
+					BeanUtilForVCI.copyPropertiesIgnoreCase(xmlResultDataObjectDetail, jsonResultDataObjectDetail);
+					JSONResultDataObjectDetailDOList.add(jsonResultDataObjectDetail);
+				});
+				JSONResultClassfyVO jsonResultClassfyVO = new JSONResultClassfyVO();
+				jsonResultClassfyVO.setClassCode(resultClassfyVO.getClassCode());
+				jsonResultClassfyVO.setLibrary(resultClassfyVO.getLibrary());
+				jsonResultClassfyVO.setFullclsfNamePath(resultClassfyVO.getFullclsfNamePath());
+				JSONResultDataObjectDO JSONResultDataObjectDO = new JSONResultDataObjectDO();
+				JSONResultDataObjectDO.setObject(JSONResultDataObjectDetailDOList);
+				jsonResultClassfyVO.setObjects(JSONResultDataObjectDO);
+				jSONResultClassfyVOList.add(jsonResultClassfyVO);
+			});
+			jsonResultClassfysVO.setClassify(jSONResultClassfyVOList);
+			jsonResultSystemVO.setClassifys(jsonResultClassfysVO);
+			jsonResultSystemVO.setErrorid(resultSystemVO.getErrorid());
+			jsonResultSystemVO.setMsg(resultSystemVO.getMsg());
+			resultDataVO.setData(jsonResultSystemVO);
+			Object object = JSONObject.toJSON(resultDataVO);
+			resultStr = object.toString();
+
+		}
+		return resultStr;
+	}
+
+
+}

--
Gitblit v1.9.3