From ac3f3629a261770f573f27e5e23f7ec19d096c2a Mon Sep 17 00:00:00 2001
From: xiejun <xiejun@vci-tech.com>
Date: 星期三, 04 九月 2024 18:29:05 +0800
Subject: [PATCH] UI授权功能查询

---
 Source/plt-web/plt-web-parent/plt-web/src/main/java/com/vci/web/service/impl/OsBtmServiceImpl.java | 1265 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 1,250 insertions(+), 15 deletions(-)

diff --git a/Source/plt-web/plt-web-parent/plt-web/src/main/java/com/vci/web/service/impl/OsBtmServiceImpl.java b/Source/plt-web/plt-web-parent/plt-web/src/main/java/com/vci/web/service/impl/OsBtmServiceImpl.java
index ef49c4b..f573031 100644
--- a/Source/plt-web/plt-web-parent/plt-web/src/main/java/com/vci/web/service/impl/OsBtmServiceImpl.java
+++ b/Source/plt-web/plt-web-parent/plt-web/src/main/java/com/vci/web/service/impl/OsBtmServiceImpl.java
@@ -1,22 +1,54 @@
 package com.vci.web.service.impl;
 
+import cn.hutool.core.io.FileUtil;
+import cn.hutool.core.util.ZipUtil;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.vci.client.common.oq.OQTool;
+import com.vci.client.common.providers.ClientServiceProvider;
+import com.vci.client.mw.ClientSessionUtility;
+import com.vci.common.qt.object.Condition;
+import com.vci.common.qt.object.QueryTemplate;
+import com.vci.common.utility.ObjectUtility;
+import com.vci.constant.FrameWorkLangCodeConstant;
 import com.vci.corba.common.PLException;
 import com.vci.corba.omd.atm.AttributeDef;
 import com.vci.corba.omd.btm.BizType;
+import com.vci.corba.omd.data.AttributeValue;
+import com.vci.corba.omd.data.BusinessObject;
+import com.vci.corba.omd.etm.EnumType;
+import com.vci.corba.omd.lcm.Bound;
+import com.vci.corba.omd.lcm.LifeCycle;
 import com.vci.corba.omd.ltm.LinkType;
+import com.vci.corba.omd.stm.StatePool;
+import com.vci.corba.omd.vrm.VersionRule;
+import com.vci.dto.OsBtmTypeDTO;
+import com.vci.dto.OsBtmTypeLinkAttributesDTO;
+import com.vci.model.IndexObject;
+import com.vci.omd.constants.AttributeConstants;
+import com.vci.omd.constants.FileObjectType;
+import com.vci.omd.objects.OtherInfo;
+import com.vci.omd.utils.ObjectTool;
 import com.vci.pagemodel.*;
+import com.vci.po.OsBtmTypePO;
+import com.vci.po.OsLinkTypePO;
+import com.vci.starter.poi.bo.ReadExcelOption;
+import com.vci.starter.poi.bo.WriteExcelData;
+import com.vci.starter.poi.bo.WriteExcelOption;
+import com.vci.starter.poi.constant.ExcelLangCodeConstant;
+import com.vci.starter.poi.util.ExcelUtil;
 import com.vci.starter.web.annotation.log.VciUnLog;
+import com.vci.starter.web.constant.QueryOptionConstant;
 import com.vci.starter.web.enumpck.BooleanEnum;
 import com.vci.starter.web.exception.VciBaseException;
+import com.vci.starter.web.pagemodel.BaseResult;
 import com.vci.starter.web.pagemodel.DataGrid;
 import com.vci.starter.web.pagemodel.PageHelper;
+import com.vci.starter.web.pagemodel.Tree;
+import com.vci.starter.web.util.*;
 import com.vci.starter.web.util.BeanUtil;
-import com.vci.starter.web.util.VciBaseUtil;
-import com.vci.starter.web.util.VciDateUtil;
 import com.vci.web.service.*;
-import com.vci.web.util.ConcurrentDateFormat;
-import com.vci.web.util.Func;
-import com.vci.web.util.PlatformClientUtil;
+import com.vci.web.util.*;
 import org.apache.commons.lang3.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -24,7 +56,14 @@
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 import org.springframework.util.CollectionUtils;
+import org.springframework.web.multipart.MultipartFile;
 
+import javax.servlet.http.HttpServletResponse;
+import javax.swing.*;
+import java.io.File;
+import java.io.IOException;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -78,6 +117,31 @@
     @Autowired(required = false)
     @Lazy
     private OsBtmServiceI self;
+
+    /**
+     * 涓�浜涢粯璁ょ殑琛�
+     */
+    private final List<String> tableList = Arrays.asList("pl_qtemplate", "PL_QTEMPLATEDEF",
+            "pl_typeright", "plcommandparameter", "plpagedefination",
+            "pluilayout", "pltabbutton", "pltabpage", "plportalvi",
+            "plreleasedobj");
+
+    /**
+     * workFlowTables 涓殑琛ㄦ湁涓诲閿叧绯�,褰撹〃涓婚敭鎴栧敮涓�閿寮曠敤涓哄閿椂,
+     * 灏辩畻寮曠敤鏂规病鏈夋暟鎹�, truncate杩樹笉鏄笉鑳藉垹闄よ〃涓暟鎹�, 鑰� delete鍙互.
+     */
+    private final List<String> workFlowTableList = Arrays.asList(
+            //娴佺▼(鑷畾涔夎〃)
+            "PLPROCESSTEMPLATE", "PLPROCESSCATEGORY", "PLPROCESSTASK",//"PLRMTEMPLATEPROCESS",
+            "PLPROCESSTASKPROPERTY", "PLFLOWAPPROVEOPINION", "PLFLOWOBJECT", "PLFLOWINSTANCE",
+            "WORKFLOW_TASK_CC_TABLE", "PLTASKDESC", "PLTASKSASSIGNED", "JBPM_SUBPROCESSTEM",
+            "JBPM4_TASKANDUSERCONFIG", "PLREVOKEPOLICY", "JBPM4_TASKANDUSERCONFIGEX",
+            //娴佺▼(JBPM绯荤粺琛�)
+            "JBPM4_DEPLOYPROP", "JBPM4_HIST_DETAIL", "JBPM4_ID_MEMBERSHIP", "JBPM4_JOB",
+            "JBPM4_PARTICIPATION", "JBPM4_VARIABLE", "JBPM4_HIST_ACTINST", "JBPM4_HIST_VAR",
+            "JBPM4_ID_GROUP", "JBPM4_ID_USER", "JBPM4_LOB", "JBPM4_DEPLOYMENT",
+            "JBPM4_HIST_PROCINST", "JBPM4_HIST_TASK", "JBPM4_TASK", "JBPM4_SWIMLANE",
+            "JBPM4_EXECUTION", "JBPM4_PROPERTY");
 
     /**
      * 鏌ヨ鎵�鏈夌殑涓氬姟绫诲瀷
@@ -139,25 +203,29 @@
                 //vo.setCreateTime(VciDateUtil.str2Date(String.valueOf(btmItem.createTime),VciDateUtil.DateTimeFormat));
                 vo.setCreateTime(Func.parse(btmItem.createTime, ConcurrentDateFormat.of(VciDateUtil.DateTimeFormat)));
                 vo.setLastModifyTime( Func.parse(btmItem.modifyTime, ConcurrentDateFormat.of(VciDateUtil.DateTimeFormat)));
-                vo.setTs(Func.parse(btmItem.ts, ConcurrentDateFormat.of(VciDateUtil.DateTimeFormat)));
+                vo.setTs(Func.parse(btmItem.ts, ConcurrentDateFormat.of(VciDateUtil.DateTimeMillFormat)));
             } catch (Exception e) {
                 e.printStackTrace();
             }
             vo.setDescription(btmItem.description);
             vo.setId(btmItem.name);
-             vo.setName(btmItem.label);
+            vo.setName(btmItem.label);
             vo.setLifeCycleId(btmItem.lifeCycle);
             vo.setAbstractFlag(btmItem.isAbstract);
             vo.setImplClass(btmItem.implClass);
             vo.setShape(btmItem.shape);
+            vo.setRevLevel(btmItem.revLevel);
             vo.setRevisionRuleId(btmItem.revRuleName);
             vo.setTableName(VciBaseUtil.getTableName(vo.getId()));
             vo.setInputRevisionFlag(btmItem.revInput);
-            if(StringUtils.isNotBlank(vo.getRevisionRuleId()) || vo.isInputRevisionFlag()){
+            vo.setDelimiter(btmItem.delimiter);
+            vo.setfName(btmItem.fName);
+            vo.setVersionRule(String.valueOf(btmItem.verRuleName));
+            if(StringUtils.isNotBlank(vo.getRevisionRuleName()) || vo.isInputRevisionFlag()){
                 vo.setRevisionFlag(true);
             }
-            vo.setVersionRule(String.valueOf(btmItem.verRuleName));
-            vo.setSubLifeCycleId(Arrays.stream(btmItem.lifeCycles).collect(Collectors.joining(",")));
+            vo.setLifeCycleIds(Arrays.stream(btmItem.lifeCycles).collect(Collectors.joining(",")));
+            vo.setApNameArray(btmItem.apNameArray);
             List<OsAttributeVO> attributeVOS = attributeService.listAttrByIds(Arrays.stream(btmItem.apNameArray).collect(Collectors.toList()));
             List<OsBtmTypeAttributeVO> btmTypeAttributeVOS = new ArrayList<>();
             Optional.ofNullable(attributeVOS).orElseGet(()->new ArrayList<>()).stream().forEach(attributeVO->{
@@ -165,7 +233,7 @@
                 BeanUtil.convert(attributeVO,btmTypeAttributeVO);
                 btmTypeAttributeVO.setPkBtmType(vo.getOid());
                 btmTypeAttributeVO.setBtmTypeId(vo.getId());
-                btmTypeAttributeVO.setAttrDataType(attributeVO.getAttributeDataType());
+                btmTypeAttributeVO.setAttributeDataType(attributeVO.getAttributeDataType());
                 btmTypeAttributeVO.setAttributeLength(attributeVO.getAttrLength());
                 btmTypeAttributeVO.setDefaultValue(attributeVO.getDefaultValue());
                 if("secretgrade".equalsIgnoreCase(attributeVO.getId())){
@@ -291,9 +359,14 @@
      * @return 灞炴�х殑鍐呭
      */
     @Override
-    public List<OsBtmTypeAttributeVO> listAttributeByBtmId(String btmId) {
+    public List<OsBtmTypeAttributeVO> listAttributeByBtmId(String btmId) throws PLException {
         VciBaseUtil.alertNotNull(btmId,"涓氬姟绫诲瀷鐨勭紪鍙�");
-        OsBtmTypeVO btmTypeVO = getBtmById(btmId);
+        BizType[] bizTypes = platformClientUtil.getBtmService().getBizTypes(btmId);
+        if(Func.isEmpty(bizTypes)){
+            return new ArrayList<>();
+        }
+        BizType bizType = bizTypes[0];
+        OsBtmTypeVO btmTypeVO = btmDO2VO(bizType);
         List<OsBtmTypeAttributeVO> attributes = btmTypeVO.getAttributes();
         if(attributes == null){
             attributes = new ArrayList<>();
@@ -308,7 +381,7 @@
      * @return 灞炴�х殑鍐呭
      */
     @Override
-    public List<OsBtmTypeAttributeVO> listAttributeByBtmIdHasDefault(String btmId) {
+    public List<OsBtmTypeAttributeVO> listAttributeByBtmIdHasDefault(String btmId) throws PLException {
         List<OsBtmTypeAttributeVO> attrVOs = listAttributeByBtmId(btmId);
         if(attrVOs == null){
             attrVOs = new ArrayList<>();
@@ -318,7 +391,7 @@
             attributeService.getDefaultAttributeVOs().stream().forEach(attr->{
                 OsBtmTypeAttributeVO attributeVO = new OsBtmTypeAttributeVO();
                 BeanUtil.convert(attr, attributeVO);
-                attributeVO.setAttrDataType(attr.getAttributeDataType());
+                attributeVO.setAttributeDataType(attr.getAttributeDataType());
                 attributeVO.setAttributeLength(attr.getAttrLength());
                 attributeVO.setReferBtmTypeId(attr.getBtmTypeId());
                 attributeVO.setReferBtmTypeName(attr.getBtmTypeName());
@@ -417,6 +490,42 @@
             btmName = "";
         }
         return platformClientUtil.getBtmService().getBizTypes(btmName);
+    }
+
+    /**
+     * 涓氬姟绫诲瀷鍒楄〃鏌ヨ锛岄潪鏍戠粨鏋勶細鐢ㄤ簬UI瀹氫箟宸︿晶涓氬姟绫诲瀷鏌ヨ锛屽彧杩斿洖name鍜宭able
+     * @param btmName
+     * @return
+     * @throws PLException
+     */
+    @Override
+    public Tree getBizTree(String btmName) throws PLException {
+        if(null == btmName){
+            btmName = "";
+        }
+        Tree returnTree = new Tree();
+        BizType[] bizTypes = platformClientUtil.getBtmService().getBizTypes(btmName);
+        if(Func.isEmpty(bizTypes)){
+            return returnTree;
+        }
+        returnTree.setOid("");
+        returnTree.setText("涓氬姟绫诲瀷");
+        returnTree.setLeaf(false);
+        List<Tree> trees = new ArrayList<>();
+        Arrays.stream(bizTypes).forEach(bizType -> {
+            Tree tree = new Tree();
+            tree.setText(bizType.name + " " +bizType.label);
+            tree.setOid(bizType.oid);
+            tree.setLeaf(true);
+            tree.setParentName(bizType.fName);
+            Map<String, String> atrrMap = new HashMap<>();
+            atrrMap.put("name",bizType.name);
+            atrrMap.put("lable",bizType.label);
+            tree.setAttributes(atrrMap);
+            trees.add(tree);
+        });
+        returnTree.setChildren(trees);
+        return returnTree;
     }
 
     /**
@@ -521,6 +630,915 @@
         ervo.setTabViewList(nodeVOList);
         ervo.setTabRelViewList(relationVOList);
         return ervo;
+    }
+
+    /**
+     * 鑾峰彇鎵�鏈変笟鍔$被鍨嬶紙鏍戝舰缁撴瀯锛�
+     * @return 鏌ヨ缁撴灉
+     */
+    @Override
+    public List<Tree> getTreeBizTypes() throws PLException {
+        List<Tree> rootTreeList = new ArrayList<>();
+        BizType[] bizTypes = getBizTypes("");
+        OsBtmTypeVO osBtmTypeVO = null;
+        List<OsBtmTypeVO> osBtmTypeVOS = btmDO2VOs(Arrays.asList(bizTypes));
+        for(int i = 0; i < osBtmTypeVOS.size(); i++){
+            osBtmTypeVO = osBtmTypeVOS.get(i);
+
+            if(osBtmTypeVO.getfName().equals("")){
+                Tree tree = new Tree();
+                tree.setOid(osBtmTypeVO.getOid());
+                tree.setParentName(null);
+                tree.setParentId(null);
+                tree.setLeaf(true);
+                tree.setText(osBtmTypeVO.getDescription());
+                tree.setAttributes(WebUtil.objectToMapString(osBtmTypeVO));
+                tree.setChildren(getChildren(osBtmTypeVOS,osBtmTypeVO));
+                rootTreeList.add(tree);
+            }
+        }
+
+        return rootTreeList;
+    }
+
+    /**
+     * 鑾峰彇鎵�鏈変笟鍔$被鍨嬪悕绉伴泦鍚�
+     * @return
+     */
+    @Override
+    public List<String> getAllBtmName() throws PLException {
+        BizType[] bizTypes = platformClientUtil.getBtmService().getBizTypes("");
+        if(null != bizTypes && bizTypes.length > 0){
+            return Arrays.stream(bizTypes).map(bizType -> bizType.name).collect(Collectors.toList());
+        }
+        return null;
+    }
+
+    /**
+     * 鑾峰彇涓氬姟鍏ㄩ儴灞炴�х被鍨�
+     * @param btmName 涓氬姟绫诲瀷鍚嶇О
+     * @return 灞炴�х殑淇℃伅
+     */
+    @Override
+    public List<OsBtmTypeAttributeVO> getBizTypeQTDs(String btmName) throws PLException, ParseException {
+        VciBaseUtil.alertNotNull(btmName, "涓氬姟绫诲瀷缂栧彿");
+        List<OsBtmTypeAttributeVO> osBtms = new ArrayList<>();
+        //鏌ヨ绯荤粺榛樿灞炴��
+        Map<String, AttributeDef> collect = Arrays.stream(platformClientUtil.getBtmService().getSysAttributeDefs())
+                .collect(Collectors.toMap(str -> str.name, str -> str));
+        for (String attrName : platformClientUtil.getBtmService().getSysAttributeNames()) {
+            AttributeDef sysAttributeDef = collect.get(attrName.toLowerCase());
+            OsBtmTypeAttributeVO vo = new OsBtmTypeAttributeVO();
+            vo.setOid(sysAttributeDef.oid);
+            vo.setAttributeDataType(sysAttributeDef.vtDataType);
+            vo.setPkBtmType(btmName);
+            vo.setCreateTime(new Date(sysAttributeDef.createTime));
+            vo.setCreator(sysAttributeDef.creator);
+            vo.setDefaultValue(sysAttributeDef.defValue);
+            vo.setDescription(sysAttributeDef.description);
+            vo.setRange(sysAttributeDef.rage);
+            vo.setId(attrName);
+            vo.setName(sysAttributeDef.label);
+            vo.setLastModifier(sysAttributeDef.modifier);
+            vo.setLastModifyTime(new Date(sysAttributeDef.modifyTime));
+            osBtms.add(vo);
+        }
+        //鏌ヨ涓氬姟绫诲瀷涓嬬殑灞炴��
+        AttributeDef[] attributeDefs = platformClientUtil.getBtmService().getAttributeDefs(btmName);
+        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+        for (AttributeDef attribute : attributeDefs) {
+            OsBtmTypeAttributeVO vo = new OsBtmTypeAttributeVO();
+            vo.setOid(attribute.oid);
+            vo.setAttributeDataType(attribute.vtDataType);
+            vo.setPkBtmType(btmName);
+            vo.setCreateTime(new Date(attribute.createTime));
+            vo.setCreator(attribute.creator);
+            vo.setDefaultValue(attribute.defValue);
+            vo.setDescription(attribute.description);
+            vo.setRange(attribute.rage);
+            vo.setId(attribute.name);
+            vo.setName(attribute.label);
+            vo.setTs(formatter.parse(attribute.ts));
+            vo.setLastModifier(attribute.modifier);
+            vo.setOwner(attribute.creator);
+            vo.setLastModifyTime(new Date(attribute.modifyTime));
+            String maxLength = AttributeConstants.getOtherValueByType(attribute.other, AttributeConstants.LENGTH);
+            if(StringUtils.isNotBlank(maxLength)){
+                vo.setAttributeLength(Integer.valueOf(maxLength));
+            }
+            osBtms.add(vo);
+        }
+        return osBtms;
+    }
+
+    /**
+     * dto杞琩o瀵硅薄
+     * @return
+     */
+    private BizType dto2BizType(OsBtmTypeDTO dto){
+        BizType bizType = new BizType();
+        bizType.oid = dto.getOid();
+        bizType.name =dto.getId();
+        bizType.isAbstract = dto.isAbstractFlag();
+        bizType.label = dto.getName();
+        bizType.fName = dto.getfName();
+        bizType.implClass = dto.getImplClass();
+        bizType.shape = "";
+        bizType.lifeCycle = dto.getLifeCycleId();
+        List<String> lcList = Arrays.asList(dto.getSubLifeCycleId().split(","));
+        if (lcList != null) {
+            bizType.lifeCycles = lcList.toArray(new String[0]);
+        } else {
+            bizType.lifeCycles = new String[0];
+        }
+        bizType.description = dto.getDescription();
+        bizType.revLevel = dto.getRevLevel();
+        bizType.revRuleName = dto.getRevisionRuleId();
+        bizType.revInput = dto.isInputRevisionFlag();
+
+        bizType.delimiter = (dto.getDelimiter() == null ? "" : dto.getDelimiter());
+
+        bizType.verRuleName = Func.isBlank(dto.getVersionRule()) ? 0:Short.parseShort(dto.getVersionRule());
+
+        //bizType.imageName = dto.get;
+        //List<String> attrIdList = dto.getAttributesDTOList().stream().map(OsBtmTypeLinkAttributesDTO::getId).collect(Collectors.toList());
+
+        bizType.apNameArray = dto.getApNameArray().split(",");//attrIdList.toArray(new String[attrIdList.size()]);
+        String userId = WebThreadLocalUtil.getCurrentUserSessionInfoInThread().getUserId();
+        long timeMillis = System.currentTimeMillis();
+        bizType.creator = Func.isBlank(dto.getCreator()) ? userId:dto.getCreator();
+        bizType.createTime = Func.isEmpty(dto.getCreateTime()) ? timeMillis:dto.getCreateTime().getTime();
+        bizType.modifier = userId;
+        bizType.modifyTime = timeMillis;
+        bizType.ts = Func.isEmpty(dto.getTs())? timeMillis:dto.getTs().getTime();
+        return bizType;
+    }
+
+    /**
+     * 鍒涘缓鏂扮殑涓氬姟绫诲瀷
+     * @return
+     * @throws PLException
+     */
+    @Override
+    public boolean addBtmType(OsBtmTypeDTO btmTypeDTO) throws PLException {
+        VciBaseUtil.alertNotNull(btmTypeDTO,"鍒涘缓鐨勪笟鍔$被鍨嬪璞�");
+        //涓氬姟绫诲瀷鍚嶇О妫�鏌�
+        checkName(btmTypeDTO.getId());
+        //鐢熷懡鍛ㄦ湡妫�鏌�
+        checkLifeCycle(btmTypeDTO);
+        //鐗堟湰瑙勫垯妫�鏌�
+        checkVersionInfo(btmTypeDTO);
+        BizType bizType = this.dto2BizType(btmTypeDTO);
+        return platformClientUtil.getBtmService().addBizType(bizType);
+    }
+
+    /**
+     * 鎵归噺鏂板涓氬姟绫诲瀷
+     * @param bizTypes
+     * @return
+     */
+/*    @Override
+    public boolean addBtmTypes(List<BizType> bizTypes) {
+        VciBaseUtil.alertNotNull(bizTypes,"鍒涘缓鐨勪笟鍔$被鍨嬪璞″垪琛�");
+        bizTypes.stream().forEach(bizType->{
+            try {
+                platformClientUtil.getBtmService().addBizType(bizType);
+            } catch (PLException e) {
+                e.printStackTrace();
+                String exceptionMessage = VciBaseUtil.getExceptionMessage(e);
+                logger.error(exceptionMessage);
+                throw new VciBaseException(exceptionMessage);
+            }
+        });
+        return true;
+    }*/
+
+    /**
+     * 妫�鏌ヤ笟鍔$被鍨嬪悕绉版槸鍚﹀悎瑙�
+     * @param btmName
+     * @throws PLException
+     */
+    private void checkName(String btmName) throws PLException {
+        if (Func.isBlank(btmName)) {
+            throw new PLException("500",new String[]{"涓氬姟绫诲瀷鍚嶄笉鑳戒负绌�!"});
+        }
+
+        if (!btmName.matches("[a-z A-Z]*")) {
+            throw new PLException("500",new String[]{"涓氬姟绫诲瀷鍚嶅彧鑳戒负鑻辨枃瀛楁瘝!"});
+        }
+
+        int maxLength = platformClientUtil.getBtmService().getBTNameMaxLength();
+
+        if (btmName.length() > maxLength) {
+            throw new PLException("500",new String[]{"涓氬姟绫诲瀷鍚嶉暱搴︿笉鑳借秴杩�" + maxLength});
+        }
+
+        if (platformClientUtil.getBtmService().checkRowIsExists(btmName)) {
+            throw new PLException("500",new String[]{"涓氬姟绫诲瀷鍚嶅凡缁忓瓨鍦�"});
+        }
+    }
+
+    /**
+     * 鏄惁閫夋嫨鐢熷懡鍛ㄦ湡
+     *
+     * @return
+     */
+    private void checkLifeCycle(OsBtmTypeDTO btmTypeDTO) throws PLException {
+        if (Func.isBlank(btmTypeDTO.getLifeCycleId())) {
+            throw new PLException("500",new String[]{"鐢熷懡鍛ㄦ湡涓嶈兘涓虹┖"});
+        }
+    }
+
+    /**
+     * 閫夋嫨涓�绾х増鏈細蹇呴』閫夋嫨鎴栨墜宸ヨ緭鍏ョ増鏈彿瑙勫垯; 閫夋嫨浜岀骇鐗堟湰锛氬繀椤婚�夋嫨鎴栨墜宸ヨ緭鍏ョ増鏈彿瑙勫垯, (鐗堟鍙峰凡缁忛粯璁ら�夋嫨).
+     * @return
+     */
+    private void checkVersionInfo(OsBtmTypeDTO dto) throws PLException {
+        //闇�瑕佹墜鍔ㄨ緭鍏ョ増鏈椂revisionRuleId涓嶈兘涓虹┖
+        if (dto.getRevLevel() == 1 || dto.getRevLevel() == 2) {
+            if (Func.isBlank(dto.getRevisionRuleId()) && !dto.isInputRevisionFlag()) {
+                throw new PLException("500",new String[]{"鐗堟湰鍙疯鍒欎笉鑳戒负绌�"});
+            }
+        }
+    }
+
+    /**
+     * 鐗堟湰鏈哄埗淇敼: 浠呭厑璁哥被鍨嬩粠"涓嶅彲淇"鍙樻洿鑷�"涓�绾х増鏈鐞嗘満鍒�","浜岀骇鐗堟湰绠$悊鏈哄埗杩涜璋冩暣"; "涓�绾х増鏈鐞嗘満鍒�"鍙樻洿鑷�"浜岀骇鐗堟湰绠$悊鏈哄埗";
+     * 涓ょ鏂瑰紡.
+     * @param dbBizType 褰撳墠淇敼鍓嶇殑涓氬姟绫诲瀷锛堝簱涓瓨鍌ㄧ殑锛�
+     * @param dto 褰撳墠淇敼涓氬姟绫诲瀷
+     * @throws PLException
+     */
+    private void checkRevLevel(BizType dbBizType,OsBtmTypeDTO dto) throws PLException {
+        if (dbBizType.revLevel == 1 && dto.getRevLevel()==0) {
+            throw new PLException("500",new String[]{"鐗堟湰鍙樻洿閿欒锛氫笉鑳戒粠涓�绾у彉涓轰笉鍙慨璁�"});
+        }
+        if (dbBizType.revLevel == 2 && (dto.getRevLevel() == 1 || dto.getRevLevel() == 0)) {
+            throw new PLException("500",new String[]{"鐗堟湰鍙樻洿閿欒锛氫笉鑳戒粠浜岀骇鍙樹负涓�绾ф垨涓嶅彲淇"});
+        }
+    }
+
+    /**
+     * 淇敼涓氬姟绫诲瀷
+     * @param btmTypeDTO
+     * @return
+     * @throws PLException
+     */
+    @Override
+    public boolean updateBtmType(OsBtmTypeDTO btmTypeDTO) throws PLException {
+        VciBaseUtil.alertNotNull(btmTypeDTO,"淇敼鐨勪笟鍔$被鍨嬪璞�");
+        //妫�鏌ョ敓鍛藉懆鏈熸槸鍚﹀悎瑙�
+        checkLifeCycle(btmTypeDTO);
+        //鏌ヨ鏁版嵁搴撲腑鐨勪笟鍔$被鍨�
+        String id = btmTypeDTO.getId();
+        BizType dbBizType = platformClientUtil.getBtmService().getBizTypeByName(id);
+        if(Func.isEmpty(dbBizType) || Func.isBlank(dbBizType.oid)){
+            throw new PLException("500",new String[]{"褰撳墠淇敼鐨勪笟鍔$被鍨嬩笉瀛樺湪锛�"});
+        }
+        //妫�鏌ョ増鏈鍒欎慨鏀规槸鍚﹀悎瑙�
+        checkRevLevel(dbBizType,btmTypeDTO);
+        checkVersionInfo(btmTypeDTO);
+        //澶勭悊涓氬姟绫诲瀷涓嬬殑灞炴��
+        List<String> lastAttrList = new ArrayList<>(Arrays.asList(btmTypeDTO.getApNameArray().split(",")));
+        //涓嶈兘绉婚櫎鐨勫睘鎬�
+        String[] unRemovableFields = null;
+        List<String> unRemovableFields_ = null;
+        //闇�瑕佺Щ闄ょ殑灞炴��
+        List<String> removableFields = null;
+        //淇敼鍓嶄笟鍔$被鍨嬪湪鏁版嵁搴撲腑宸插瓨鍦ㄧ殑鎵�鏈夊睘鎬�
+        String[] apNameArray = btmTypeDTO.getApNameArray().split(",");
+        Set<String> dbApNameArray = Arrays.stream(dbBizType.apNameArray)
+                .collect(Collectors.toSet());
+        //杩囨护鍑洪渶瑕佺Щ闄ょ殑灞炴��
+        removableFields = Arrays.stream(apNameArray)
+                .filter(ap -> !dbApNameArray.contains(ap))   // 杩囨护涓嶅湪 dbApSet 涓殑鍏冪礌
+                .collect(Collectors.toList());
+        // 褰撲笟鍔$被鍨嬭〃涓煇灞炴�у凡缁忔湁鍊�, 涓嶅垹闄よ灞炴��, 灏嗗凡缁忕Щ闄ょ殑灞炴�ф坊鍔犲洖鏉�
+        unRemovableFields = platformClientUtil.getBtmService().getUnRemovableFields(id, removableFields.toArray(new String[0]));
+        if (removableFields.size() > 0) {
+            //妫�鏌ヤ笟鍔$被鍨嬫槸鍚﹀叿鏈夊疄渚�
+            if (this.hasInstanceByBtmName(id)) {
+                //涓氬姟绫诲瀷宸叉湁瀹炰緥, 鍙兘鍒犻櫎娌℃湁鏁版嵁鐨勫垪
+                if (unRemovableFields != null && unRemovableFields.length > 0) {
+                    unRemovableFields_ = Arrays.asList(unRemovableFields);
+                    for (int i = 0; i < removableFields.size(); i++) {
+                        String abName = removableFields.get(i);
+                        if (unRemovableFields_.contains(abName)) {
+                            if (!lastAttrList.contains(abName)) {
+                                lastAttrList.add(abName);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        BizType bizType = dto2BizType(btmTypeDTO);
+        bizType.apNameArray = lastAttrList.toArray(new String[lastAttrList.size()]);
+        return platformClientUtil.getBtmService().updateBizType(bizType);
+    }
+
+    /**
+     * 鍒犻櫎涓氬姟绫诲瀷
+     * @param btmTypeDTO
+     * @return
+     * @throws PLException
+     */
+    @Override
+    public boolean deleteBtmType(OsBtmTypeDTO btmTypeDTO) throws PLException {
+        VciBaseUtil.alertNotNull(btmTypeDTO,"鍒犻櫎鐨勪笟鍔$被鍨�");
+        String btmName = btmTypeDTO.getId();
+        //鍙兘鍒犻櫎鍙跺瓙鑺傜偣
+        if(Func.isNotBlank(btmTypeDTO.getfName())){
+            throw new PLException("500",new String[]{"鍙兘鍒犻櫎鍙跺瓙鑺傜偣"});
+        }
+        // 涓氬姟绫诲瀷琚摼鎺ョ被鍨嬩娇鐢�, 涓嶈兘鍒犻櫎
+        List<String> usedNameList = linkTypeService.getUsedBtmLinkList(btmName);
+        if (usedNameList != null && usedNameList.size() > 0) {
+            throw new PLException("500",new String[]{"璇ョ被鍨嬪凡琚摼鎺ョ被鍨嬩娇鐢紝绂佹鍒犻櫎"});
+        }
+        // 涓氬姟绫诲瀷宸茬粡鐢熸垚浜嗕笟鍔″璞�, 涓嶈兘鍒犻櫎
+        if (hasInstanceByBtmName(btmName)) {
+            throw new PLException("500",new String[]{"璇ョ被鍨嬪凡鏈夊疄渚嬶紝绂佹鍒犻櫎"});
+        }
+        
+        BizType bizType = new BizType();
+        bizType.ts = btmTypeDTO.getTs().getTime();
+        bizType.oid = btmTypeDTO.getOid();
+        bizType.name = btmTypeDTO.getId();
+        return platformClientUtil.getBtmService().deleteBizType(bizType);
+    }
+
+    /**
+     * 涓�鑷存�ф鏌�
+     * @return
+     * @throws PLException
+     */
+    @Override
+    public BaseResult checkBtmConsistency() throws PLException {
+        String[] result = platformClientUtil.getBtmService().btmConsistencyCheck();
+        Map<String, String> dbCheckMap = new HashMap<String, String>();
+        for(int i = 0; i < result.length; i++){
+            String info = result[i];
+            if(info.equals("")){
+                continue;
+            }
+            String[] infos = info.split("/DML");
+            String typeName = infos[0];
+            String dml = infos[1];
+            dbCheckMap.put(typeName, dml);
+        }
+        if(dbCheckMap.size() < 1){
+            return BaseResult.successMsg("鏁版嵁搴撲腑鐨勮〃缁撴瀯涓庣被鍨嬩竴鑷�,鏃犻渶淇!!");
+        }else{
+            //闇�瑕佷慨澶嶆椂灏遍渶瑕佺晫闈㈠敜璧峰璇濇杩涜澶勭悊
+            List<Map> list = new ArrayList<>();
+            list.add(dbCheckMap);
+            BaseResult<List<Map>> listBaseResult = BaseResult.dataList(200, list, "闇�瑕佽繘琛屽垪鐨勪慨澶嶏紒锛�");
+            listBaseResult.setSuccess(false);
+            return listBaseResult;
+        }
+    }
+
+    /**
+     * 涓�鑷存�ф鏌ヤ慨澶嶅姛鑳�
+     * @param repairData
+     * @return
+     */
+    @Override
+    public BaseResult executeRepair(String repairData) throws Exception {
+        Map<String, String> dbCheckMap = new ObjectMapper().readValue(repairData, new TypeReference<Map<String,String>>(){});
+        List<String> list = this.getRepairDML(dbCheckMap);
+        if(list.size() < 1){
+            return BaseResult.success();
+        }
+        try {
+            String[] result = platformClientUtil.getBtmService().executeRepair(list.toArray(new String[0]));
+            return BaseResult.success(result);
+        }catch (PLException e){
+            return BaseResult.fail("涓氬姟绫诲瀷淇澶辫触锛屽師鍥狅細"+VciBaseUtil.getExceptionMessage(e));
+        }
+    }
+
+    /**
+     * 鍒涘缓瑙嗗浘
+     * @return
+     * @throws PLException
+     */
+    @Override
+    public boolean createView() throws PLException {
+        return platformClientUtil.getBtmService().createView();
+    }
+
+    /**
+     * 鍒犻櫎鏁版嵁鐣岄潰鐨勬煡璇�
+     * @return 涓氬姟绫诲瀷锛岄摼鎺ョ被鍨�
+     */
+    @Override
+    public BaseResult getObjectData() throws PLException {
+        //鑾峰彇涓氬姟绫诲瀷鍚嶇О闆嗗悎
+        List<String> allBtmName = this.getAllBtmName();
+        //鑾峰彇閾炬帴绫诲瀷鍚嶇О闆嗗悎
+        List<String> allLinkType = linkTypeService.getAllLtName();
+        Map<String,List> map = new HashMap<>();
+        map.put("btmType",allBtmName);
+        map.put("linkType",allLinkType);
+        map.put("table",tableList);
+        map.put("workFlow",workFlowTableList);
+        List<Map> list = new ArrayList<>();
+        list.add(map);
+        return BaseResult.dataList(list);
+    }
+
+    /**
+     * 鍒犻櫎鏁版嵁
+     * @param btmNames 涓氬姟绫诲瀷鍚�
+     * @param linkNames 閾炬帴绫诲瀷鍚�
+     * @return
+     * @throws PLException
+     */
+    @Override
+    public List<Map> truncateTable(String[] btmNames,String[] linkNames) throws PLException {
+        List<Map> returnMapList = new ArrayList<>();
+        Map<String, List<String>> map = new HashMap<>();
+        map.put("btmSuccess",new ArrayList<>());
+        map.put("btmFail",new ArrayList<>());
+        map.put("linkSuccess",new ArrayList<>());
+        map.put("linkFail",new ArrayList<>());
+        if(Func.isNotEmpty(btmNames)){
+            for(int i = 0; i < btmNames.length; i++){
+                String btName = btmNames[i];
+                try {
+                    if(platformClientUtil.getBtmService().truncateTable(btName)){
+                        //淇敼鎴愬姛璁板綍涓嬫垚鍔熺殑涓氬姟绫诲瀷鍚�
+                        map.get("btmSuccess").add(btName);
+                    }
+                } catch (PLException e1) {
+                    e1.printStackTrace();
+                    logger.error(VciBaseUtil.getExceptionMessage(e1));
+                    //淇敼澶辫触璁板綍涓嬪け璐ョ殑涓氬姟绫诲瀷鍚�
+                    map.get("btmFail").add(btName);
+                }
+            }
+        }
+        if(Func.isNotEmpty(linkNames)){
+            //truncate閾炬帴绫诲瀷鏁版嵁
+            for(int i = 0; i < linkNames.length; i++){
+                String ltName = linkNames[i];
+                try {
+                    if(platformClientUtil.getLinkTypeService().truncateTable(ltName)){
+                        map.get("linkSuccess").add(ltName);
+                    }
+                } catch (PLException e1) {
+                    e1.printStackTrace();
+                    logger.error(VciBaseUtil.getExceptionMessage(e1));
+                    map.get("linkFail").add(ltName);
+                }
+            }
+        }
+        returnMapList.add(map);
+        return returnMapList;
+    }
+
+    /**
+     * 鍒犻櫎鍏ㄩ儴绫诲瀷
+     * @return
+     * @throws PLException
+     */
+    @Override
+    public BaseResult deleteAllType() throws PLException {
+        DeleteType deleteType = new DeleteType();
+        //鑾峰彇寰呭垹闄ょ殑涓氬姟绫诲瀷
+        List<BizType> delBtList =  deleteType.getDelBtList();
+        //鑾峰彇寰呭垹闄ょ殑閾炬帴绫诲瀷
+        List<LinkType> ltNames = deleteType.getDelLtList();
+        //鑾峰彇寰呭垹闄ょ殑灞炴��
+        List<String> delAbList = deleteType.getDelAbList();
+        //鑾峰彇寰呭垹闄ょ殑鏋氫妇绫诲瀷
+        List<EnumType> delEnumList = deleteType.getDelEnumList();
+        //鑾峰彇寰呭垹闄ょ殑鐢熷懡鍛ㄦ湡
+        List<LifeCycle> delLCList = deleteType.getDelLCList();
+        //鑾峰彇寰呭垹闄ょ殑鐘舵��
+        List<StatePool> delStateList = deleteType.getDelSPList();
+        //鑾峰彇寰呭垹闄ょ殑鐗堟湰瑙勫垯
+        List<VersionRule> delVRList = deleteType.getDelVRList();
+        try {
+            platformClientUtil.getBtmService().deleteBtsAndTables(delBtList.toArray(new BizType[0]));
+        } catch (PLException e) {
+            e.printStackTrace();
+            String exceptionMessage = "娓呴櫎涓氬姟绫诲瀷鍜屽搴旇〃鏍兼椂鍑虹幇寮傚父锛屽師鍥狅細"+VciBaseUtil.getExceptionMessage(e);
+            logger.error(exceptionMessage);
+            return BaseResult.fail(exceptionMessage);
+        }
+        try {
+            ClientServiceProvider.getOMDService().getLinkTypeService().deleteLtsAndTables(ltNames.toArray(new LinkType[0]));
+        } catch (PLException e) {
+            e.printStackTrace();
+            String exceptionMessage = "娓呴櫎閾炬帴绫诲瀷鏃跺嚭鐜板紓甯革紝鍘熷洜锛�"+VciBaseUtil.getExceptionMessage(e);
+            logger.error(exceptionMessage);
+            return BaseResult.fail(exceptionMessage);
+        }
+        try {
+            AttributeDef[] abs = platformClientUtil.getAttributeService().getAttributeDefsByNames(delAbList.toArray(new String[0]));
+            platformClientUtil.getAttributeService().deleteAttributeDefs(abs);
+        } catch (PLException e) {
+            e.printStackTrace();
+            String exceptionMessage = "娓呴櫎灞炴�ф睜灞炴�ф椂鍑虹幇寮傚父锛屽師鍥狅細"+VciBaseUtil.getExceptionMessage(e);
+            logger.error(exceptionMessage);
+            return BaseResult.fail(exceptionMessage);
+        }
+        try {
+            platformClientUtil.getEnumService().deleteEnumTypes(delEnumList.toArray(new EnumType[0]));
+        } catch (PLException e) {
+            e.printStackTrace();
+            String exceptionMessage = "娓呴櫎鏋氫妇绫诲瀷鏃跺嚭鐜板紓甯革紝鍘熷洜锛�"+VciBaseUtil.getExceptionMessage(e);
+            logger.error(exceptionMessage);
+            return BaseResult.fail(exceptionMessage);
+        }
+        try {
+            platformClientUtil.getLifeCycleService().deleteLifeCycles(delLCList.toArray(new LifeCycle[0]));
+        } catch (PLException e) {
+            e.printStackTrace();
+            String exceptionMessage = "娓呴櫎鐢熷懡鍛ㄦ湡鏃跺嚭鐜板紓甯革紝鍘熷洜锛�"+VciBaseUtil.getExceptionMessage(e);
+            logger.error(exceptionMessage);
+            return BaseResult.fail(exceptionMessage);
+        }
+        try {
+            platformClientUtil.getStatePoolService().deleteStatePools(delStateList.toArray(new StatePool[0]));
+        } catch (PLException e) {
+            e.printStackTrace();
+            String exceptionMessage = "娓呴櫎鐘舵�佹睜鐘舵�佹椂鍑虹幇寮傚父锛屽師鍥狅細"+VciBaseUtil.getExceptionMessage(e);
+            logger.error(exceptionMessage);
+            return BaseResult.fail(exceptionMessage);
+        }
+        try {
+            platformClientUtil.getVersionService().deleteVersionRules(delVRList.toArray(new VersionRule[0]));
+        } catch (PLException e) {
+            e.printStackTrace();
+            String exceptionMessage = "娓呴櫎鐗堟湰瑙勫垯鏃跺嚭鐜板紓甯革紝鍘熷洜锛�"+VciBaseUtil.getExceptionMessage(e);
+            logger.error(exceptionMessage);
+            return BaseResult.fail(exceptionMessage);
+        }
+        return BaseResult.success("娓呴櫎鏁版嵁瀹屾垚!");
+    }
+
+    /**
+     * 鏍规嵁涓氬姟绫诲瀷鍚嶇О鍜屽叾涓嬬殑灞炴�у悕绉拌幏鍙栧凡鏈夌殑绱㈠紩
+     * @param conditionMap 鏍规嵁鏌ヨ鏉′欢浼犲弬: typename:涓氬姟绫诲瀷鍚�;
+     * @return
+     */
+    @Override
+    public List<IndexObject> getIndexByCondition(Map<String,String> conditionMap) throws PLException {
+        if(Func.isEmpty(conditionMap)){
+            return new ArrayList<>();
+        }
+        List<String> indexNameList = new ArrayList<String>();
+        QueryTemplate qtl = new QueryTemplate();
+        List<String> list = new ArrayList<String>();
+        list.add("*");
+        qtl.setBtmType("indexobject");
+        qtl.setClauseList(list);
+        qtl.setId("p");
+        qtl.setType("btm");
+        qtl.setRightFlag(false);
+        Condition condition = OQTool.getCondition(conditionMap);
+        qtl.setCondition(condition);
+        //HashMap<String, String> indexmap = new HashMap<String, String>();
+        BusinessObject findBTMObjects[] = platformClientUtil.getQueryService().findBTMObjects(qtl.getId(), OQTool.qtTOXMl(qtl).asXML());
+        List<IndexObject> indexObjects = new ArrayList<>();
+        for(int i = 0; i < findBTMObjects.length; i++) {
+            BusinessObject findBTMObject = findBTMObjects[i];
+            IndexObject indexObject = new IndexObject();
+            indexObject.setOid(findBTMObject.oid);
+            indexObject.setDescription(findBTMObject.description);
+            indexObject.setCreateTime(Func.format(new Date(findBTMObject.createTime),DateUtil.PATTERN_DATE));
+            indexObject.setIndexName(ObjectTool.getBOAttributeValue(findBTMObject,"indexname"));
+            indexObject.setTypeName(ObjectTool.getBOAttributeValue(findBTMObject,"typename"));
+            indexObject.setAttrNames(ObjectTool.getBOAttributeValue(findBTMObject,"attrname"));
+            indexObjects.add(indexObject);
+        }
+        return indexObjects;
+    }
+
+    /**
+     * 鏍规嵁涓氬姟绫诲瀷鍚嶇О鍜屽叾涓嬬殑灞炴�у悕绉板垹闄ょ储寮�
+     * @param btmName
+     * @param indexName
+     * @return
+     */
+    @Override
+    public boolean delIndex(String btmName, String indexName) throws PLException {
+        VciBaseUtil.alertNotNull(btmName,"涓氬姟绫诲瀷鍚�",indexName,"绱㈠紩鍚�");
+        Map<String, String> conditionMap = new HashMap<>();
+        conditionMap.put("typename",btmName);
+        conditionMap.put("indexname",indexName);
+        List<IndexObject> bo2 = getIndexByCondition(conditionMap);
+        if(bo2!=null && bo2.size()>0) {
+            String[] indexAttr = {indexName};
+
+            boolean alterFlag = platformClientUtil.getBtmService().dropIndex(btmName, indexAttr);
+
+            if (!alterFlag) {
+                return false;
+            }
+            for (int i = 0; i < bo2.size(); i++) {
+                String oid = bo2.get(i).getOid();
+                BusinessObject bo = platformClientUtil.getBOFactoryService().readBusinessObject(oid, "indexobject");
+                platformClientUtil.getBOFactoryService().deleteBusinessObject(bo,1);
+            }
+        }
+        return true;
+    }
+
+    /**
+     * 缁欎笟鍔$被鍨嬩笅鐨勬寚瀹氬睘鎬ф柊澧炵储寮�
+     * @param indexObjectList
+     * @return
+     */
+    @Override
+    public boolean addIndex(List<IndexObject> indexObjectList) throws PLException {
+        VciBaseUtil.alertNotNull(indexObjectList,"鏂板鐨勭储寮曚俊鎭�");
+        String btmName = indexObjectList.get(0).getTypeName();
+        String indexNames = indexObjectList.stream().map(IndexObject::getIndexName).collect(Collectors.joining(","));
+        String[] oldindexAttr = {indexNames};
+        BusinessObject bo;
+        List<BusinessObject> boList = new ArrayList<>();
+        //鍏堟煡璇㈠綋鍓嶆坊鍔犵储寮曟槸鍚﹀凡缁忓瓨鍦紝濡傛灉瀛樺湪灏卞厛鍒犻櫎鍐嶆柊澧炲疄鐜版浛鎹㈡搷浣�
+        Map<String, String> conditionMap = new HashMap<>();
+        conditionMap.put("typename",btmName);
+        //鍏堣繖鏍峰鐞嗭紝鍓嶇鐜板湪鍙仛浜嗗崟娆′繚瀛橈紝鎵�浠ヤ笉鐢╥n
+        conditionMap.put("indexname", indexNames);
+        List<IndexObject> indexObjects = getIndexByCondition(conditionMap);
+        if(indexObjects!=null && indexObjects.size()>0){
+            //绱㈠紩涓嶅瓨鍦ㄦ椂鍒犻櫎灏变細鎶ラ敊绱㈠紩涓嶅瓨鍦紝鎵�浠ヨ繖閲屾湁绱㈠紩鎵嶅幓鍒犻櫎
+            boolean b = platformClientUtil.getBtmService().dropIndex(btmName, oldindexAttr);
+            if(b){
+                for(int i = 0; i < indexObjects.size(); i ++){
+                    String oid = (String) indexObjects.get(i).getOid();
+                    bo = platformClientUtil.getBOFactoryService().readBusinessObject(oid,"indexobject");
+                    platformClientUtil.getBOFactoryService().deleteBusinessObject(bo,1);
+                }
+            }
+        }
+
+        for(int i = 0; i < indexObjectList.size(); i ++){
+            IndexObject indexObject = indexObjectList.get(i);
+            //bo = platformClientUtil.getBOFService().initBusinessObject("indexobject");
+            bo = boService.createCBOByBtmName("indexobject");
+            List<AttributeValue> attributeValues = new ArrayList<>();
+            attributeValues.add(new AttributeValue("typename", btmName));
+            attributeValues.add(new AttributeValue("indexname", indexObject.getIndexName()));
+            attributeValues.add(new AttributeValue("attrname", indexObject.getAttrNames()));
+            bo.newAttrValList = attributeValues.toArray(new AttributeValue[attributeValues.size()]);
+            bo.description = indexObject.getDescription();
+            String[] indexAttr = {indexObject.getIndexName(),indexObject.getAttrNames()};
+            //缁欐寚瀹氫笟鍔$被鍨嬬殑鎸囧畾灞炴�у垱寤虹储寮�
+            boolean alterFlag = platformClientUtil.getBtmService().addIndex(btmName, indexAttr);
+            //绱㈠紩鍒涘缓鎴愬姛涔嬪悗锛岄渶瑕佸瓨鍌ㄦ垚鍔熺储寮曞埌绱㈠紩琛ㄤ腑
+            if(!alterFlag){
+                return false;
+            }
+            boList.add(bo);
+            //娣诲姞绱㈠紩淇℃伅鍒扮储寮曠殑涓氬姟琛ㄤ腑
+            //platformClientUtil.getBOFactoryService().createBusinessObject(bo,false,false);
+        }
+        //娣诲姞绱㈠紩淇℃伅鍒扮储寮曠殑涓氬姟琛ㄤ腑
+        platformClientUtil.getBOFactoryService().batchCreateBusinessObject(boList.toArray(new BusinessObject[boList.size()]),false,false);
+        return true;
+    }
+
+    /**
+     * 瀵煎嚭涓氬姟绫诲瀷
+     * oid 涓氬姟绫诲瀷鍚嶇О
+     * @return 鍒涘缓缁撴灉
+     */
+    @Override
+    public void expData(String names, HttpServletResponse response) throws PLException, IOException {
+        String defaultTempFolder = LocalFileUtil.getDefaultTempFolder();
+        //鍐檈xcel
+        String excelPath = defaultTempFolder + File.separator + "btm.xls";
+        //璁剧疆鍒楀悕
+        List<String> columns = new ArrayList<>(
+                Arrays.asList("绫诲瀷鍚嶇О", "鏍囩", "缁ф壙鑷�", "瀹炵幇绫�", "鎻忚堪", "鐗堟湰瑙勫垯", "鐗堟湰鍙疯鍒�",
+                        "鏄惁鎵嬪伐杈撳叆","鍒嗛殧绗�", "鐗堟鍙疯鍒�","鐢熷懡鍛ㄦ湡", "澶囬�夌敓鍛藉懆鏈熷垪琛�","灞炴�у垪琛�")
+        );
+        try {
+            new File(excelPath).createNewFile();
+            //璁剧疆鍒�
+            List<WriteExcelData> excelDataList = new ArrayList<>();
+            //璁剧疆鍒楀ご
+            for (int index = 0; index < columns.size(); index++) {
+                excelDataList.add(new WriteExcelData(0,index, columns.get(index)));
+            }
+            HashSet<String> attributes = new HashSet<>();
+            int i = 0;
+            for (String name : names.split(",")) {
+                BizType bizType = platformClientUtil.getBtmService().getBizTypeByName(name);
+                excelDataList.add(new WriteExcelData(i+1,0, bizType.name));
+                excelDataList.add(new WriteExcelData(i+1,1, bizType.label));
+                excelDataList.add(new WriteExcelData(i+1,2, bizType.fName));
+                excelDataList.add(new WriteExcelData(i+1,3, bizType.implClass));
+                excelDataList.add(new WriteExcelData(i+1,4, bizType.description));
+                excelDataList.add(new WriteExcelData(i+1,5, bizType.revLevel));
+                excelDataList.add(new WriteExcelData(i+1,6, bizType.revRuleName));
+                excelDataList.add(new WriteExcelData(i+1,7, bizType.revInput));
+                excelDataList.add(new WriteExcelData(i+1,8, bizType.delimiter));
+                excelDataList.add(new WriteExcelData(i+1,9, bizType.verRuleName));
+                excelDataList.add(new WriteExcelData(i+1,10, bizType.lifeCycle));
+                excelDataList.add(new WriteExcelData(i+1,11, String.join(",",bizType.lifeCycles)));
+                excelDataList.add(new WriteExcelData(i+1,12, String.join(",",bizType.apNameArray)));
+                attributes.addAll(Arrays.asList(bizType.apNameArray));
+                i++;
+            }
+            WriteExcelOption excelOption = new WriteExcelOption(excelDataList);
+            ExcelUtil.writeDataToFile(excelPath, excelOption);
+            //瀵煎嚭灞炴��
+            String attrPath = attributeService.exportAttributes("btmattr",
+                    attributes.stream().collect(Collectors.joining(",")),true);
+            //绉诲姩灞炴�у埌閾炬帴绫诲瀷鏂囦欢澶归噷闈㈠幓
+            FileUtil.move(new File(attrPath), new File(defaultTempFolder),true);
+            FileUtil.del(attrPath.substring(0,attrPath.lastIndexOf("\\")));
+        }catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        File zip = ZipUtil.zip(defaultTempFolder);
+        FileUtil.del(defaultTempFolder + File.separator);
+        ControllerUtil.writeFileToResponse(response,zip.getAbsoluteFile());
+    }
+
+    /**
+     * 瀵煎叆涓氬姟绫诲瀷
+     * @param file 涓婁紶鐨勬枃浠�
+     * @return
+     */
+    @Override
+    public BaseResult impData(MultipartFile file) throws Exception {
+        String defaultTempFolder = LocalFileUtil.getDefaultTempFolder();
+        String fileName = defaultTempFolder + File.separator + LocalFileUtil.getFileNameForIE(file.getOriginalFilename());
+        file.transferTo(new File(fileName));
+        if (file == null) {
+            return BaseResult.fail(FrameWorkLangCodeConstant.IMPORT_FAIL, new String[]{"鏃犲鍏ョ殑鏂囦欢"});
+        }
+        if (!fileName.endsWith(".zip") || !fileName.endsWith(".rar")) {
+            throw new VciBaseException("浠呰兘涓婁紶zip鍘嬬缉鏂囦欢锛岃閲嶆柊涓婁紶锛�");
+        }
+        File unzip = ZipUtil.unzip(fileName);
+        File btmExcel = new File(unzip.getAbsolutePath() + File.separator + "btm.xls");
+        File attrExcel = new File(unzip.getAbsolutePath() + File.separator + "btmattr.xls");
+        if (!attrExcel.exists()) {
+            //澧炲姞瑙e帇鐨勮矾寰勶紝鐪嬫枃浠惰繕鍦ㄦ病鏈�
+            attrExcel = new File(unzip.getAbsolutePath() + File.separator + unzip.getName() + File.separator + "btmattr.xls");
+            if (!attrExcel.exists()) {
+                return BaseResult.fail(FrameWorkLangCodeConstant.IMPORT_FAIL, new String[]{"娌℃湁瀵煎叆鐨勫睘鎬ф枃浠躲�傚鍏ョ粓姝紒"});
+            }
+        }
+        //TODO锛氬鍏ュ睘鎬э紝浣嗘槸杩欎釜閫昏緫瀹為檯涓婂瓨鍦ㄤ竴浜涢棶棰橈紝瀵煎叆鐨勫睘鎬у彧鏄笟鍔$被鍨嬬殑灞炴�т笉搴旇鍘荤粰灞炴�ф睜瀵煎叆锛屽彲鑳芥槸鎯崇殑灞炴�т笉瀛樺湪鐨勫氨鏂板涓�娆�
+        BaseResult baseResult = attributeService.importAttributes(attrExcel,true);
+        if(!baseResult.isSuccess()){
+            //鍒犻櫎涓婁紶鐨勬枃浠跺す
+            FileUtil.del(defaultTempFolder + File.separator);
+            return baseResult;
+        }
+        //鍏ヤ笟鍔$被鍨�
+        if (!btmExcel.exists()) {
+            //澧炲姞瑙e帇鐨勮矾寰勶紝鐪嬫枃浠惰繕鍦ㄦ病鏈�
+            btmExcel = new File(unzip.getAbsolutePath() + File.separator + unzip.getName() + File.separator + "btm.xls");
+            if (!btmExcel.exists()) {
+                //鍒犻櫎涓婁紶鐨勬枃浠跺す
+                FileUtil.del(defaultTempFolder + File.separator);
+                return BaseResult.fail(FrameWorkLangCodeConstant.IMPORT_FAIL, new String[]{"娌℃湁瀵煎叆鐨勯摼鎺ユ枃浠躲�傚鍏ョ粓姝紒"});
+            }
+        }
+        try{
+            //1銆佽鍙杄xcel涓殑鏁版嵁锛岀粍鎴愬璞�
+            ReadExcelOption excelOption = new ReadExcelOption();
+            List<OsBtmTypePO> poList = ExcelUtil.readDataObjectFromExcel(btmExcel, OsBtmTypePO.class,excelOption,(value, po, fieldName)->{});
+            //鍘婚櫎閮芥槸绌虹殑鎯呭喌
+            if(CollectionUtils.isEmpty(poList)){
+                return BaseResult.fail(ExcelLangCodeConstant.IMPORT_CONTENT_NULL,new String[]{});
+            }
+            //褰撳墠excel涓槸鍚﹂噸澶嶇敤鐨勫垽閲峂ap:锛坘ey锛氬垽閲嶅睘鎬э紝value锛氳鍙凤級
+            Map<String, String> excelReapeat = new HashMap<>();
+            int maxLength = platformClientUtil.getLinkTypeService().getLTNameMaxLength();
+
+            //鍒ゆ柇蹇呭~灞炴�ф槸鍚︿负绌猴紝鐢ㄦ埛鏄惁宸插瓨鍦紝浠ュ強閮ㄩ棬鏄惁濉敊绛夋牎楠岄�昏緫
+            poList.stream().forEach(osBtmTypePO -> {
+                if(Func.isBlank(osBtmTypePO.getName())){//灞炴�у悕鍒ょ┖
+                    throw new VciBaseException("绗��"+osBtmTypePO.getRowIndex()+"銆戣锛宯ame");
+                }else if(osBtmTypePO.getName().length() > maxLength){
+                    throw new VciBaseException("绗��"+osBtmTypePO.getRowIndex()+"銆戣锛屼笟鍔$被鍨嬪悕闀垮害涓嶈兘瓒呰繃" + maxLength);
+                }else if(!osBtmTypePO.getName().matches("^[A-Za-z]+$")){
+                    throw new VciBaseException("绗��"+osBtmTypePO.getRowIndex()+"銆戣锛屼笟鍔$被鍨嬪悕绉板彧鑳戒负鑻辨枃瀛楁瘝");
+                }else if (osBtmTypePO.getName().length() > maxLength) {
+                    throw new VciBaseException("绗��"+osBtmTypePO.getRowIndex()+"銆戣锛屼笟鍔$被鍨嬪悕闀垮害涓嶈兘瓒呰繃" + maxLength);
+                }else if(excelReapeat.containsKey(osBtmTypePO.getName())){//涓氬姟绫诲瀷鍚嶅湪琛ㄦ牸涓垽閲�
+                    throw new VciBaseException("绗��"+excelReapeat.get(osBtmTypePO.getName())+"銆戣鍜岀銆�"+osBtmTypePO.getRowIndex()+"銆戣鏁版嵁锛屼笟鍔$被鍨嬪悕閲嶅");
+                }else if (Func.isBlank(osBtmTypePO.getLifeCycle())) {
+                    throw new VciBaseException("绗��"+osBtmTypePO.getRowIndex()+"銆戣锛岀敓鍛藉懆鏈熶笉鑳戒负绌�");
+                }else if ("true".equalsIgnoreCase(osBtmTypePO.getRevInput()) && Func.isBlank(osBtmTypePO.getRevRuleName())) {
+                    throw new VciBaseException("绗��"+osBtmTypePO.getRowIndex()+"銆戣锛岀増鏈彿瑙勫垯涓嶈兘涓虹┖");
+                }
+                try {
+                    BizType historyBtm = platformClientUtil.getBtmService().getBizTypeByName(osBtmTypePO.getName());
+                    //宸叉湁姝ゆ暟鎹繘琛屽垹闄よ鐩�
+                    if(historyBtm != null && !historyBtm.name.equals("")){
+                        platformClientUtil.getBtmService().deleteBizType(historyBtm);
+                    }
+                } catch (PLException e) {
+                    throw new RuntimeException(e);
+                }
+
+                //灞炴�у悕excel涓垽閲嶅鐞�
+                excelReapeat.put(osBtmTypePO.getName(),osBtmTypePO.getRowIndex());
+                BizType bizType = new BizType();
+                bizType.name = osBtmTypePO.getName();
+                bizType.label = osBtmTypePO.getLable();
+                bizType.description = osBtmTypePO.getDescription();
+                bizType.fName = osBtmTypePO.getFName();
+                bizType.implClass = osBtmTypePO.getImplClass();
+                bizType.revLevel = osBtmTypePO.getRevLevel();
+                bizType.revRuleName = osBtmTypePO.getRevRuleName();
+                bizType.revInput = Boolean.parseBoolean(osBtmTypePO.getRevInput().toLowerCase(Locale.ROOT));
+                bizType.delimiter = osBtmTypePO.getDelimiter();
+                bizType.verRuleName = osBtmTypePO.getVerRuleName();
+                bizType.lifeCycle = osBtmTypePO.getLifeCycle();
+                bizType.lifeCycles = osBtmTypePO.getLifeCycles().split(",");
+                bizType.apNameArray = osBtmTypePO.getApNameArray().split(",");
+                String userId = WebUtil.getCurrentUserId();
+                bizType.modifier = userId;
+                bizType.creator = userId;
+                try {
+                    platformClientUtil.getBtmService().addBizType(bizType);
+                } catch (PLException e) {
+                    throw new RuntimeException(e);
+                }
+            });
+        }catch (Exception e){
+            if(logger.isErrorEnabled()){
+                logger.error("璇诲彇excel鍐呭鏃舵垨淇濆瓨涓氬姟绫诲瀷淇℃伅鏃跺嚭鐜颁簡閿欒锛屽叿浣撳師鍥狅細",VciBaseUtil.getExceptionMessage(e));
+            }
+            e.printStackTrace();
+            return BaseResult.fail(VciBaseUtil.getExceptionMessage(e),new String[]{},e);
+        }
+        //鍒犻櫎涓婁紶鐨勬枃浠跺す
+        FileUtil.del(defaultTempFolder + File.separator);
+        return BaseResult.success("涓氬姟绫诲瀷瀵煎叆鎴愬姛锛�");
+    }
+
+    /**
+     * 鑾峰彇闇�瑕佷慨澶嶇殑浼猻ql
+     * @param dbCheckMap
+     * @return
+     */
+    private List<String> getRepairDML(Map<String, String> dbCheckMap) {
+        List<String> list = new ArrayList<String>();
+        for(Iterator<String> ite = dbCheckMap.keySet().iterator(); ite.hasNext();){
+            String type = ite.next();
+            String dml = dbCheckMap.get(type);
+            list.add(type + "/DML" + dml);
+        }
+        return list;
+    }
+
+    /**
+     * 鏈夊疄渚嬶細true 鏃犲疄渚嬶細false
+     *
+     * @return
+     */
+    private boolean hasInstanceByBtmName(String btmName) throws PLException {
+        //String tableName = OmdTools.getBTMTableName(btmName);
+        //boolean flag = DDLToolClient.getService().hasInstanceOralce(tableName);
+        boolean flag = false;
+        try {
+            flag = ClientServiceProvider.getOMDService().getBTMService().hasData(btmName);
+        } catch (PLException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+            String exceptionMessage = VciBaseUtil.getExceptionMessage(e);
+            logger.error(exceptionMessage);
+            throw new PLException("500",new String[]{exceptionMessage});
+        }
+        return flag;
+    }
+
+    private List<Tree> getChildren(List<OsBtmTypeVO> osBtmTypeVOS,OsBtmTypeVO parentBIzType){
+        List<Tree> trees= new ArrayList<>();
+        for (OsBtmTypeVO bizType : osBtmTypeVOS) {
+            if(StringUtils.isBlank(bizType.getfName())){
+                continue;
+            }
+            if(bizType.getfName().equals(parentBIzType.getId())){
+                Tree tree = new Tree();
+                tree.setOid(bizType.getOid());
+                tree.setParentName(parentBIzType.getfName());
+                tree.setParentId(parentBIzType.getOid());
+                tree.setLeaf(true);
+                tree.setText(bizType.getDescription());
+                tree.setAttributes(WebUtil.objectToMapString(bizType));
+                tree.setChildren(getChildren(osBtmTypeVOS,bizType));
+                trees.add(tree);
+            }
+        }
+        return trees;
     }
 
     /**
@@ -754,4 +1772,221 @@
         }
     }
 
+    /**
+     * 灏佽鍒犻櫎鍏ㄩ儴绫诲瀷鐩稿叧鐨勬煡璇㈡柟娉曠殑鍐呴儴绫�
+     */
+    private class DeleteType{
+
+        private List<String> exceptBts, exceptAbs, exceptEnums, exceptRev, exceptLCs, exceptStates;
+
+        {
+            exceptBts.add("workitem");
+            exceptBts.add(FileObjectType.FILE_DATA_TABLE);
+        }
+
+        /**
+         * 鑾峰彇闇�瑕佸垹闄ょ殑涓氬姟绫诲瀷
+         * @return
+         */
+        public List<BizType> getDelBtList() throws PLException {
+            List<BizType> list = new ArrayList<>();
+            BizType[] bts = platformClientUtil.getBtmService().getBizTypes("");
+            for(BizType bt : bts){
+                boolean exceptFlag = false;
+                for(String except : exceptBts){
+                    if(except.equalsIgnoreCase(bt.name)){
+                        exceptFlag = true;
+                        break;
+                    }
+                }
+                if(!exceptFlag){
+                    list.add(bt);
+                }
+            }
+            return list;
+        }
+
+        /**
+         * 鑾峰彇闇�瑕佸垹闄ょ殑閾炬帴绫诲瀷
+         * @return
+         */
+        public List<LinkType> getDelLtList() throws PLException {
+            LinkType[] linkTypes = platformClientUtil.getLinkTypeService().getLinkTypes();
+            return Arrays.asList(linkTypes);
+        }
+
+        /**
+         * 鑾峰彇寰呭垹闄ょ殑灞炴��
+         * @return
+         */
+        public List<String> getDelAbList() {
+            List<String> list = new ArrayList<String>();
+            AttributeDef[] attribItems = null;
+            try {
+                attribItems = platformClientUtil.getAttributeService().getAttributeDefs("", 0, 0);
+            } catch (PLException e) {
+                e.printStackTrace();
+            }
+            //渚濇嵁淇濈暀鐨勭被鍨嬫瀯閫犱繚鐣欑殑灞炴��
+            exceptAbs = new ArrayList<String>();
+            for(String except : exceptBts){
+                String[] btmApNameArray = null;
+                try {
+                    btmApNameArray = platformClientUtil.getBtmService().getAttributeNames(except);
+                } catch (PLException e) {
+                    e.printStackTrace();
+                }
+                if(btmApNameArray != null){
+                    for(String abName : btmApNameArray){
+                        if(!exceptAbs.contains(abName)){
+                            exceptAbs.add(abName);
+                        }
+                    }
+                }
+            }
+            //鏋勯�犲彲鍒犻櫎鐨勫睘鎬�
+            if(attribItems != null){
+                for(AttributeDef ab : attribItems){
+                    String abName = ab.name;
+                    if(!exceptAbs.contains(abName)){
+                        list.add(abName);
+                    }
+                }
+            }
+            return list;
+        }
+
+        /**
+         * 鑾峰彇寰呭垹闄ょ殑鏋氫妇绫诲瀷
+         * @return
+         */
+        public List<EnumType> getDelEnumList() {
+            List<EnumType> list = new ArrayList<EnumType>();
+            try {
+                //渚濇嵁淇濈暀鐨勭被鍨嬫瀯閫犱繚鐣欑殑灞炴��
+                exceptEnums = new ArrayList<String>();
+                EnumType[] emItems = ClientServiceProvider.getOMDService().getEnumService().getEnumTypes("", 0, 0);
+                AttributeDef[] abs = platformClientUtil.getAttributeService().getAttributeDefsByNames(exceptAbs.toArray(new String[0]));
+                for(AttributeDef ab : abs){
+                    OtherInfo otherInfo = OtherInfo.getOtherInfoByText(ab.other);
+                    String enumName = otherInfo.getEnumName();
+                    if(enumName != null && !enumName.equals("") && !exceptEnums.contains(enumName)){
+                        exceptEnums.add(enumName);
+                    }
+                }
+                for(EnumType em : emItems){
+                    if(!exceptEnums.contains(em.name)){
+                        list.add(em);
+                    }
+                }
+            } catch (PLException e) {
+                e.printStackTrace();
+            }
+            return list;
+        }
+
+        /**
+         * 鑾峰彇寰呭垹闄ょ殑鐢熷懡鍛ㄦ湡
+         * @return
+         */
+        public List<LifeCycle> getDelLCList(){
+            List<LifeCycle> list = new ArrayList<LifeCycle>();
+            exceptLCs = new ArrayList<String>();
+            exceptStates = new ArrayList<String>();
+            for(String btName : exceptBts){
+                try {
+                    BizType bt = platformClientUtil.getBtmService().getBizTypeByName(btName);
+                    String lcName = bt.lifeCycle;
+                    if(lcName != null && !lcName.equals("") && !exceptLCs.contains(lcName)){
+                        exceptLCs.add(lcName);
+                    }
+                } catch (PLException e) {
+                    e.printStackTrace();
+                }
+            }
+
+            LifeCycle[] lcs = null;
+            try {
+                lcs = platformClientUtil.getLifeCycleService().getLifeCycles();
+            } catch (PLException e) {
+                e.printStackTrace();
+            }
+            if(lcs != null){
+                for(LifeCycle lc : lcs){
+                    String name = lc.name;
+                    if(name != null && !name.equals("") && !exceptLCs.contains(name)){
+                        list.add(lc);
+                    }else{
+                        //淇濈暀鐨勭姸鎬佹睜
+                        Bound[] bounds = lc.bounds;
+                        for(Bound bound : bounds){
+                            String sName = bound.name;
+                            exceptStates.add(sName);
+                        }
+                    }
+                }
+            }
+            return list;
+        }
+
+        /**
+         * 鑾峰彇寰呭垹闄ょ殑鐘舵��
+         * @return
+         */
+        public List<StatePool> getDelSPList(){
+            List<StatePool> list = new ArrayList<StatePool>();
+            StatePool[] states = null;
+            try {
+                states = platformClientUtil.getStatePoolService().getStatePools();
+            } catch (PLException e) {
+                e.printStackTrace();
+            }
+            if(states != null){
+                for(StatePool state : states){
+                    String name = state.name;
+                    if(name != null && !name.equals("") && !exceptStates.contains(name)){
+                        list.add(state);
+                    }
+                }
+            }
+            return list;
+        }
+
+        /**
+         * 鑾峰彇寰呭垹闄ょ殑鐗堟湰瑙勫垯
+         * @return
+         */
+        public List<VersionRule> getDelVRList(){
+            List<VersionRule> list = new ArrayList<VersionRule>();
+            exceptRev = new ArrayList<String>();
+            for(String btName : exceptBts){
+                try {
+                    BizType bt = platformClientUtil.getBtmService().getBizTypeByName(btName);
+                    String revName = bt.revRuleName;
+                    if(revName != null && !revName.equals("") && !exceptRev.contains(revName)){
+                        exceptRev.add(revName);
+                    }
+                } catch (PLException e) {
+                    e.printStackTrace();
+                }
+            }
+            VersionRule[] revs = null;
+            try {
+                revs = platformClientUtil.getVersionService().getVersionRules();
+            } catch (PLException e) {
+                e.printStackTrace();
+            }
+            if(revs != null){
+                for(VersionRule rev : revs){
+                    String name = rev.name;
+                    if(name != null && !name.equals("") && !exceptRev.contains(name)){
+                        list.add(rev);
+                    }
+                }
+            }
+            return list;
+        }
+
+    }
+
 }

--
Gitblit v1.9.3