Source/plt-web/plt-web-parent/plt-web/src/main/java/com/vci/web/service/impl/UIManagerServiceImpl.java

@@ -1,22 +1,24 @@
package com.vci.web.service.impl;

import com.sun.jnlp.ApiDialog;
import com.vci.client.mw.ClientContextVariable;
import com.vci.common.utility.ObjectUtility;
import com.vci.corba.common.PLException;
import com.vci.corba.framework.data.RoleRightInfo;
import com.vci.corba.omd.btm.BizType;
import com.vci.corba.portal.PortalService;
import com.vci.corba.portal.data.*;
import com.vci.dto.RoleRightDTO;
import com.vci.dto.UIAuthorDTO;
import com.vci.frameworkcore.compatibility.SmRoleQueryServiceI;
import com.vci.pagemodel.OsBtmTypeVO;
import com.vci.model.PLDefination;
import com.vci.pagemodel.PLDefinationVO;
import com.vci.pagemodel.PLUILayoutCloneVO;
import com.vci.pagemodel.RoleRightVO;
import com.vci.starter.web.exception.VciBaseException;
import com.vci.starter.web.pagemodel.*;
import com.vci.starter.web.pagemodel.BaseQueryObject;
import com.vci.starter.web.pagemodel.BaseResult;
import com.vci.starter.web.pagemodel.DataGrid;
import com.vci.starter.web.pagemodel.SessionInfo;
import com.vci.starter.web.pagemodel.Tree;
import com.vci.starter.web.util.VciBaseUtil;
import com.vci.starter.web.util.VciDateUtil;
import com.vci.starter.web.util.WebThreadLocalUtil;
@@ -24,17 +26,23 @@
import com.vci.web.service.UIManagerServiceI;
import com.vci.web.util.*;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ss.formula.functions.T;
import com.vci.web.util.Func;
import com.vci.web.util.PlatformClientUtil;
import com.vci.web.util.UITools;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.regex.Pattern;

/**
 * UI定义服务界面相关接口
@@ -49,12 +57,17 @@
     */
    @Resource
    private PlatformClientUtil platformClientUtil;

    /**
     * 角色
     */
    @Resource
    private SmRoleQueryServiceI smRoleQueryServiceI;

    /***
     * 是否是管理员
     */
    @Autowired
    RightControlUtil rightControlUtil;
    /**
     * 业务类型
     */
@@ -111,16 +124,31 @@
    /**
     * ton通过业务类型和名称查询
     * @param btemName
     * @param code
     * @param context
     * @return
     * @throws PLException
     */
    public List<PLUILayout> getUIContextDataByBtName(String btemName,String code) throws PLException {
    public List<PLUILayout> getUIContextDataByBtName(String btemName,String context) throws PLException {
        VciBaseUtil.alertNotNull(btemName,"业务类型");
        List<PLUILayout> pluiLayoutList=new ArrayList<>();
        PLUILayout[]  pluiLayouts=   platformClientUtil.getUIService().getPLUILayoutEntityByTypeAndCode(btemName,code);
        if(pluiLayouts!=null&&pluiLayouts.length>0){
            pluiLayoutList= Stream.of(pluiLayouts).collect(Collectors.toList());
        List<String> contextList= VciBaseUtil.str2List(context);
        if(StringUtils.isNotBlank(context)){
            contextList=VciBaseUtil.str2List(context);
        }else{
            contextList.add("");
        }
        contextList.stream().forEach(code->{
            PLUILayout[]  pluiLayouts= new PLUILayout[0];
            try {
                pluiLayouts = platformClientUtil.getUIService().getPLUILayoutEntityByTypeAndCode(btemName,code);
            } catch (PLException e) {
                e.printStackTrace();
            }
            if(pluiLayouts!=null&&pluiLayouts.length>0) {
                pluiLayoutList.addAll(Arrays.stream(pluiLayouts).collect(Collectors.toList()));
            }
        });

        return pluiLayoutList;
    }

@@ -135,7 +163,6 @@
        try {
            //ui上下文对象校验
            canContinue(pluiLayout);

            String code = pluiLayout.plCode;
            String name = pluiLayout.plName;
            boolean isExist = nameOrCodeIsExist(pluiLayout, false);
@@ -216,9 +243,9 @@
     * @return
     */
    @Override
    public boolean delUIContextData(String[] oids) throws PLException {
    public boolean delUIContextData(String[] oids,String plRelatedType) throws PLException {
        VciBaseUtil.alertNotNull(oids,"待删除的对象列表");
        //删除方法中有关联数据删除的操作逻辑
        //删除方法中有关联数据删除的操作逻辑,但是这个方法存在问题就是删除的数据并没有将缓存的东西清理干净
        return platformClientUtil.getUIService().deletePLUILayoutByOidsForCascade(oids);
    }

@@ -228,7 +255,7 @@
     * @return
     */
    @Override
    public boolean cloneUiContextData(PLUILayoutCloneVO pluiLayoutCloneVO) throws PLException {
    public boolean cloneUIContextData(PLUILayoutCloneVO pluiLayoutCloneVO) throws PLException {
        VciBaseUtil.alertNotNull(
            pluiLayoutCloneVO,"克隆参数对象",
            pluiLayoutCloneVO.getSourcePLUILayout(),"克隆的源对象信息",
@@ -237,8 +264,9 @@
        );
        PLUILayout pluiLayout = new PLUILayout();
        PLUILayout sourcePLUILayout = pluiLayoutCloneVO.getSourcePLUILayout();
        pluiLayout.plRelatedType = pluiLayoutCloneVO.getCloneTargetName();
        //如果选择克隆目标，则克隆到选择的类型下，如果没有选择克隆目标，则克隆到当前类型下
        if(Func.isBlank(pluiLayoutCloneVO.getCloneTargetOid())){
        if(Func.isBlank(pluiLayoutCloneVO.getCloneTargetName())){
            pluiLayout.plRelatedType = sourcePLUILayout.plRelatedType;
        }
        //克隆的名称和ui上下文编号查重
@@ -258,6 +286,9 @@
        this.checkCodeName(pluiLayout);
        //1、先保存ui上下文
        boolean res = platformClientUtil.getUIService().savePLUILayout(pluiLayout);
        if(!res){
            return res;
        }
        //2、再考虑子节点的克隆
        PLTabPage[] pages = platformClientUtil.getUIService().getPLTabPagesByPageDefinationOId(sourcePLUILayout.plOId); //控制区节点及其子节点的克隆
        if(pages == null){
@@ -276,9 +307,477 @@
        }
    }

    /**
     * 导出ui上下文(勾选的要导出的控制区的数据)
     * oids
     * @return
     */
    @Override
    public void expUiContextData(String[] oids, HttpServletResponse response) throws PLException, IOException {
    public void expUIContextData(String[] oids, HttpServletResponse response) throws PLException, IOException {

    }

    /**
     * 导入UI上下文
     * @param file
     * @return
     */
    @Override
    public BaseResult impUIContextData(MultipartFile file) {
        return null;
    }

    /**
     * 根据上下文ID和区域类型，按顺序获取当前区域的tab页
     */
    @Override
    public List<PLTabPage> getTabByContextIdAndType(String contextId, int areaType) throws PLException {
        VciBaseUtil.alertNotNull(contextId,"上下文主键",areaType,"区域类型");
        PLTabPage[] plTabPages = platformClientUtil.getUIService().getTabPagesByContextIdAndType(contextId, (short) areaType);
        return Arrays.asList(plTabPages);
    }

    /**
     * 添加区域数据
     * @param plTabPage
     * @return
     */
    @Override
    public boolean addTabData(PLTabPage plTabPage) throws PLException {
        VciBaseUtil.alertNotNull(plTabPage,"添加区域数据");
        SessionInfo sessionInfo = WebThreadLocalUtil.getCurrentUserSessionInfoInThread();
        plTabPage.plCreateUser = sessionInfo.getUserId();
        plTabPage.plModifyUser = sessionInfo.getUserId();
        plTabPage.plOId = ObjectUtility.getNewObjectID36();
        //新增和修改前检查，出错直接抛出异常
        checkEdit(plTabPage);

        return platformClientUtil.getUIService().savePLTabPage(plTabPage);
    }

    /**
     * 修改区域数据
     * @param plTabPage
     * @return
     */
    @Override
    public boolean updateTabData(PLTabPage plTabPage) throws PLException {
        VciBaseUtil.alertNotNull(plTabPage,"添加区域数据");
        SessionInfo sessionInfo = WebThreadLocalUtil.getCurrentUserSessionInfoInThread();
        plTabPage.plModifyUser = sessionInfo.getUserId();

        //新增和修改前检查，出错直接抛出异常
        checkEdit(plTabPage);

        return platformClientUtil.getUIService().updatePLTabPage(plTabPage);
    }

    /**
     * 删除区域数据
     * @param oids
     * @return
     */
    @Override
    public boolean deleteTabData(String[] oids) throws PLException {
        VciBaseUtil.alertNotNull(oids,"待删除的主键列表");
        return platformClientUtil.getUIService().deletePLTabPageByOidsForCascade(oids);
    }

    /**
     * 扩展属性合规检测
     * @param extAttr
     * @return
     */
    public BaseResult checkTabPageExtAttrIsOk(String extAttr){
        // 数据格式：ext1:xx;ext2;ext3:xx;ext4:xxx;extn:xxx;
        boolean res = checkExtValIsOk(extAttr);
        return res ? BaseResult.success(true,"扩展属性数据格式正确！"):BaseResult.fail("扩展属性数据格式不正确！！");
    }

    /**
     * 查询页面设计定义
     * @param plPageContextOId
     * @return
     */
    @Override
    public List<PLPageDefination> getPLPageDefinations(String plPageContextOId) {

        return null;
    }

    /**
     * 添加页面定义
     * @param pdVO
     * @return
     */
    @Override
    public boolean addPageDefination(PLDefinationVO pdVO) throws Throwable {
        VciBaseUtil.alertNotNull(pdVO,"页面定义对象",pdVO.getSeq(),"编号",pdVO.getName(),"名称");

        PLDefination d = new PLDefination();
        PLPageDefination pd = new PLPageDefination();
        pd.plTabPageOId = pdVO.getTabPageOId();
        pd.plOId = ObjectUtility.getNewObjectID36();
        //不能为空属性检查
        if(!this.baseInfoIsOk(pd,false)){
            return false;
        }

        pd.name = pdVO.getName().trim();
        pd.seq = Short.valueOf(pdVO.getSeq().trim());
        pd.desc = pdVO.getDescription();
        pd.plType = Short.parseShort(pdVO.getTemplateType());

        d.setName(pdVO.getName().trim());
        d.setUiParser(pdVO.getUiParser().trim());
        d.setExtAttr(pdVO.getExtAttr().trim());
        d.setTemplateType(pdVO.getTemplateType());

        //名称和编号查重
        newPLDefinationIsOk(pdVO, false);

        // 检查各个类型下的数据是否输入或有效,一共6种类型按类型检验
        short plType = pd.plType;
        switch (plType){
            //Table(表格)
            case 1:
            //From(表单)
            case 4:
                TableComptCheckInput tci = new TableComptCheckInput(
                    pdVO.getSearchTarger()
                    ,pdVO.getBtmType()
                    ,pdVO.getLinkType()
                    ,pdVO.getTemplateId()
                    ,pdVO.getQueryTemplateName()
                );
                if(!tci.checkInputIsOk()){
                    return false;
                }
                d = tci.getNewPLDefination(d);
                break;
            //Custom(自定义模板)
            case 2:
                //只检查控制路径不能为空,有问题会直接报错
                CustomComptCheckInput ccci = new CustomComptCheckInput(pdVO.getControlPath());
                if(!ccci.checkInputIsOk()){
                    return false;
                }
                d = ccci.getNewPLDefination(d);
                break;
            //TreeTable(树表)
            case 3:
                TreeTableComptCheckInput ttcci = new TreeTableComptCheckInput(
                    pdVO.getSearchTarger()
                    ,pdVO.getBtmType()
                    ,pdVO.getLinkType()
                    ,pdVO.getTemplateId()
                    ,pdVO.getQueryTemplateName()
                    ,pdVO.getExpandCols()
                    ,pdVO.getExpandMode()
                );
                if(!ttcci.checkInputIsOk()){
                return false;
            }
                d = ttcci.getNewPLDefination(d);
                break;
            //Tree(树)
            case 5:
                TreeComptCheckInput tcci = new TreeComptCheckInput(
                    pdVO.getBtmType(),
                    pdVO.getLinkType(),
                    pdVO.getQueryTemplateName(),
                    pdVO.getShowExpressionRoot(),
                    pdVO.getShowExpression(),
                    pdVO.getRefTreeSet(),
                    pdVO.getSeparator(),
                    pdVO.getExpandMode()
                );
                if(!tcci.checkInputIsOk()){
                    return false;
                }
                d = tcci.getNewPLDefination(d);
                break;
            //UILayout(UI定义)
            case 6:
                UILayoutComptCheckInput ulci = new UILayoutComptCheckInput(
                    pdVO.getSearchTarger(),
                    pdVO.getBtmType(),
                    pdVO.getUiLayout(),
                    pdVO.getQueryTemplateName(),
                    pdVO.getQryType()
                );
                if(!ulci.checkInputIsOk()){
                    return false;
                }
                d = ulci.getNewPLDefination(d);
                break;
        }

        d = setEventDataToPLDefination(d,pdVO);
        //转xml赋值到plDefination中
        pd.plDefination = UITools.getPLDefinationText(d);

        //执行保存
        return platformClientUtil.getUIService().savePLPageDefination(pd);
    }

    /**
     * 修改页面定义
     * @param pdVO
     * @return
     */
    @Override
    public boolean updatePageDefination(PLDefinationVO pdVO) throws Throwable {
        /*PLPageDefination pd = getPageDefination();

        PLDefination d = UITools.getPLDefination(pd.plDefination);

        //不能为空属性检查
        if(!this.baseInfoIsOk(pd,true)){
            return false;
        }
        setUIValueToObject(pd, d);

        this.newPLDefinationIsOk(pdVO, true);

        // 检查各个组件内部的数据是否有效
        int plType = pdVO.getType();
        switch (plType){
            //Table(表格)
            case 1:
                //From(表单)
            case 4:
                TableComptCheckInput tci = new TableComptCheckInput(
                        pdVO.getSearchTarger()
                        ,pdVO.getBtmType()
                        ,pdVO.getLinkType()
                        ,pdVO.getTemplateId()
                        ,pdVO.getQueryTemplateName()
                );
                if(!tci.checkInputIsOk()){
                    return false;
                }
                d = tci.getNewPLDefination(d);
                break;
            //Custom(自定义模板)
            case 2:
                //只检查控制路径不能为空,有问题会直接报错
                CustomComptCheckInput ccci = new CustomComptCheckInput(pdVO.getControlPath());
                if(!ccci.checkInputIsOk()){
                    return false;
                }
                d = ccci.getNewPLDefination(d);
                break;
            //TreeTable(树表)
            case 3:
                TreeTableComptCheckInput ttcci = new TreeTableComptCheckInput(
                        pdVO.getSearchTarger()
                        ,pdVO.getBtmType()
                        ,pdVO.getLinkType()
                        ,pdVO.getTemplateId()
                        ,pdVO.getQueryTemplateName()
                        ,pdVO.getExpandCols()
                        ,pdVO.getExpandMode()
                );
                if(!ttcci.checkInputIsOk()){
                    return false;
                }
                d = ttcci.getNewPLDefination(d);
                break;
            //Tree(树)
            case 5:
                TreeComptCheckInput tcci = new TreeComptCheckInput(
                        pdVO.getBtmType(),
                        pdVO.getLinkType(),
                        pdVO.getQueryTemplateName(),
                        pdVO.getShowExpressionRoot(),
                        pdVO.getShowExpression(),
                        pdVO.getRefTreeSet(),
                        pdVO.getSeparator(),
                        pdVO.getExpandMode()
                );
                if(!tcci.checkInputIsOk()){
                    return false;
                }
                d = tcci.getNewPLDefination(d);
                break;
            //UILayout(UI定义)
            case 6:
                UILayoutComptCheckInput ulci = new UILayoutComptCheckInput(
                        pdVO.getSearchTarger(),
                        pdVO.getBtmType(),
                        pdVO.getUiLayout(),
                        pdVO.getQueryTemplateName(),
                        pdVO.getQryType()
                );
                if(!ulci.checkInputIsOk()){
                    return false;
                }
                d = ulci.getNewPLDefination(d);
                break;
        }

        d = comptPanel.getNewPLDefination(d);
        d = setEventDataToPLDefination(d,pdVO);
        pd.plDefination = UITools.getPLDefinationText(d);*/

        boolean res = true;//platformClientUtil.getUIService().updatePLPageDefination(pd);
        return res;
    }

    /**
     * 处理配置的event事件
     * @param d
     * @param pdVO
     * @return
     */
    private PLDefination setEventDataToPLDefination(PLDefination d,PLDefinationVO pdVO){
        Map<String, String> eventMap = pdVO.getEventMap();
        if(Func.isNotEmpty(eventMap)){
            String eventKey = eventMap.keySet().stream().collect(Collectors.joining(","));
            d.setEventKey(eventKey);
            String eventValue = eventMap.values().stream().collect(Collectors.joining(","));
            d.setEventValue(eventValue);
        }else{
            d.setEventKey("");
            d.setEventValue("");
        }
        return d;
    }

    private boolean baseInfoIsOk(PLPageDefination pd, boolean isEdit) throws PLException{
        boolean res = false;
        if(!checkRequiredIsOk("名称", pd.name)){
            return false;
        }
        //short类型的就不用检查了
        /*else if(!checkRequiredIsOk("编号", pd.seq)){
            return false;
        }*/
        res = true;
        return res;
    }

    private boolean checkRequiredIsOk(String tip, String txt) throws PLException {
        boolean res = false;
        if(Func.isBlank(txt)){
            throw new PLException("500", new String[]{tip + " 不能为空！"});
        } else {
            res = true;
        }
        return res;
    }

    /**
     * 删除页面定义
     * @param oids
     * @return
     */
    @Override
    public boolean delPageDefination(String[] oids) throws PLException {
        VciBaseUtil.alertNotNull(oids,"删除的页面定义主键");
        boolean res = platformClientUtil.getUIService().deletePLUILayoutByOidsForCascade(oids);
        return res;
    }

    /**
     * 页面定义名称和编号查重
     * @param pd
     * @param isEdit
     * @throws PLException
     */
    private void newPLDefinationIsOk(PLDefinationVO pd, boolean isEdit) throws PLException{
        boolean res = false;
        boolean nameExist = false;
        boolean seqExist = false;
        PLPageDefination[] pds = platformClientUtil.getUIService().getPLPageDefinationsByPageContextOId(pd.getTabPageOId());
        for (PLPageDefination pdGet : pds) {
            if(!isEdit){
                if(pd.getName().equals(pdGet.name)){
                    nameExist = true;
                } else if(Short.parseShort(pd.getSeq()) == pdGet.seq){
                    seqExist = true;
                }
            } else {
                if(!pd.getId().equals(pdGet.plOId)){
                    if(pd.getName().equals(pdGet.name)){
                        nameExist = true;
                    } else if(Short.parseShort(pd.getSeq()) == pdGet.seq){
                        seqExist = true;
                    }
                }
            }
            if(nameExist || seqExist){
                break;
            }
        }
        if(nameExist){
            throw new VciBaseException("名称已经存在！");
        }

        if(seqExist){
            throw new VciBaseException("编号已经存在！");
        }
    }

    /**
     * 给区域中添加数据前校验
     * @param plTabPage
     * @return
     */
    private void checkEdit(PLTabPage plTabPage) throws PLException {
        /*if(plTabPage.plSeq >= 0){
            throw new VciBaseException("序号不能为空!");
        }else if(!isNumber(plseq.getText().trim())){
            throw new VciBaseException("序号只能是数字，请重新填写!");
        }*/
        if(!checkTabPageUIParserIsOk(plTabPage)){
            throw new VciBaseException("UI解析类格式不正确，请重新填写!");
        }
        //独立出来单独做一个接口让前端进行调用
        /*else if(!checkTabPageExtAttrIsOk(plTabPage)){
            //给出提示，对于mpm配置可以允许其保存，具体解析mpm自己控制 by liucq
            int confirm = VCIOptionPane.showConfirmDialog(PLTApplication.frame, "扩展属性数据格式不正确\n是否继续保存？", "系统提示", JOptionPane.YES_NO_OPTION);
        }*/

        PLTabPage[] tps = platformClientUtil.getUIService().getTabPagesByContextIdAndType(plTabPage.plContextOId, plTabPage.plAreaType);
        for (PLTabPage tp : tps) {
            if(tp.plSeq == plTabPage.plSeq && !tp.plOId.equals(plTabPage.plOId)){
                throw new VciBaseException("序号重复！");
            }
            if(tp.plName.equalsIgnoreCase(plTabPage.plName) && !tp.plOId.equals(plTabPage.plOId)){
                throw new VciBaseException("名称重复！");
            }
            if(tp.plCode.equalsIgnoreCase(plTabPage.plCode) && !tp.plOId.equals(plTabPage.plOId)){
                throw new VciBaseException("页面编码重复！");
            }
        }
    }

    /**
     * 检查UI解析类是否合规
     * @param tabPage
     * @return
     */
    private boolean checkTabPageUIParserIsOk(PLTabPage tabPage){
        // 数据格式： java_cs:xxx;java_bs:xxx;net_cs:xxx;net_bs:xxx;mobile_cs:xx;mobile_bs:xxx;
        String uiParser = tabPage.plUIParser;
        return checkExtValIsOk(uiParser);
    }

    /**
     * UI解析类正则检查
     * @param value
     * @return
     */
    private boolean checkExtValIsOk(String value){
        boolean res = true;
        if(value == null || "".equals(value)){
            return res;
        }
        Pattern ptn = Pattern.compile("([\\w\\.\\_\\-\\+]+:[\\w\\.\\_\\-\\+]+(;)?)+");
        res = ptn.matcher(value).matches();
        return res;
    }

    /**
@@ -319,17 +818,229 @@
            bizTypeTree.setParentId(rootNode.getOid());
            bizTypeTree.setParentName(rootNode.getText());
            bizTypeTree.setShowCheckbox(true);
            bizTypeTree.setParentBtmName(bizTypes[i].name);
            childList.add(bizTypeTree);
            List<PLUILayout>contextList=getUIContextDataByBtName(bizTypes[i].name,context);
            List<Tree> btmChildList=new ArrayList<>();
            btmChildList.add(bizTypeTree);
            setChildNode(btmChildList,contextList,roleRightVOMap,showCheckBox);
            if(roleRightVOMap.containsKey(bizTypes[i].oid)){
                List<PLUILayout>contextList=getUIContextDataByBtName(bizTypes[i].name,context);
                List<Tree> btmChildList=new ArrayList<>();
                btmChildList.add(bizTypeTree);
                setChildNode(btmChildList,contextList,roleRightVOMap,showCheckBox);
            }
        }
        rootNode.setChildren(childList);
        treeList.add(rootNode);
        return treeList;
    }

    /***
     * UI授权
     * @param uiAuthorDTO
     * @return
     * @throws Exception
     */
    @Override
    public boolean authorizedUI(UIAuthorDTO uiAuthorDTO) throws Exception {
        boolean res=false;
        if(uiAuthorDTO==null||CollectionUtil.isEmpty(uiAuthorDTO.getSelectTreeList())){
            throw  new VciBaseException("请选择节点进行授权!");
        }
        BaseQueryObject treeQueryObject=new BaseQueryObject();
        Map<String,String> conditionMap = new HashMap<>();
        conditionMap.put("roleId",uiAuthorDTO.getRoleId());
        conditionMap.put("type",uiAuthorDTO.getType());
        conditionMap.put("context",uiAuthorDTO.getContext());
        conditionMap.put("showCheckBox","true");
        treeQueryObject.setConditionMap(conditionMap);
        List<Tree> treeList=this.getUIAuthor(treeQueryObject);
        HashMap<String,Tree> allTreeMap=new HashMap<>();
        Map<String,RoleRightVO> roleRightVOMap=new HashMap<>();
        if(!CollectionUtil.isEmpty(treeList)){
            if(StringUtils.isNotBlank(uiAuthorDTO.getRoleId())){
                String userName= WebThreadLocalUtil.getCurrentUserSessionInfoInThread().getUserId();
                RoleRightInfo[] rightInfos= platformClientUtil.getFrameworkService().getRoleRightList(uiAuthorDTO.getRoleId(),userName);
                List<RoleRightVO>  roleRightVOList=roleRightDOO2VOS(Arrays.asList(rightInfos));
                roleRightVOMap=roleRightVOList.stream().collect(Collectors.toMap(RoleRightVO::getFuncId,roleRightVO ->roleRightVO));
            }
            convertTreeDOO2Map(treeList,allTreeMap);
            List<RoleRightDTO> roleRightDTOList=new ArrayList<>();
            List<Tree>  selectTreeList= uiAuthorDTO.getSelectTreeList();
            getSelectedRoleRightObjs(uiAuthorDTO.getRoleId(),selectTreeList,allTreeMap,roleRightDTOList);
        }
        return res;
    }

    /**
     *
     * @param roleOid
     * @param selectTreeList
     * @param allTreeMap
     * @param roleRightDTOList
     */
    private void getSelectedRoleRightObjs(String roleOid,List<Tree>  selectTreeList,HashMap<String,Tree> allTreeMap,  List<RoleRightDTO> roleRightDTOList){
        Date date=new Date();
        Map<String,RoleRightDTO> roleRightDTOMap=new HashMap<>();
        selectTreeList.stream().forEach(tree -> {
            RoleRightDTO roleRightDTO=new RoleRightDTO();
            String id=ObjectUtility.getNewObjectID36();
            Object data=  tree.getData();
            if(data instanceof String){
                getRightValue(roleOid,tree,allTreeMap,false,roleRightDTOMap);//向下获取所有模块的权限值
            }else if (!(data instanceof PLTabButton)) {//业务类型
                getRightValue(roleOid,tree,allTreeMap,true,roleRightDTOMap);//向上处理
                getRightValue(roleOid,tree,allTreeMap,false,roleRightDTOMap);//向下处理（包含当前节点）
            }else if (data instanceof PLTabButton) {//按钮

            }
        });



    }
    /**
     * 获取权限
     * @param isUp 是否是向上获取，如果是向上获取，传进来的必然是模块节点，且上级模块必然是没有选中
     */
    private void getRightValue(String roleId,Tree node,HashMap<String,Tree> allTreeMap,boolean isUp,Map<String,RoleRightDTO> rightMap){
        SessionInfo sessionInfo = WebThreadLocalUtil.getCurrentUserSessionInfoInThread();
        String currentUserName = sessionInfo.getUserId();
        boolean isDeveloper= rightControlUtil.isDeveloper(currentUserName);
        String parentOid=node.getParentId();
        if(allTreeMap.containsKey(parentOid)){
            String id=ObjectUtility.getNewObjectID36();
            Tree parentNode =allTreeMap.get(parentOid);
            Object parentData=  parentNode.getData();
            if(isUp) {//向上获取，存储每个上级模块的权限值
                while (!"root".equals(parentNode.getData())){
                    String funcId = "";
                    if (parentData instanceof BizType) {
                        BizType bizType = (BizType) parentData;
                        funcId = bizType.name;
                    } else if (parentData instanceof PLUILayout) {
                        PLUILayout context = (PLUILayout)parentData;
                        funcId = context.plOId;
                    } else if (parentData instanceof PLTabPage) {
                        PLTabPage tab = (PLTabPage) parentData;
                        funcId = tab.plOId;
                    } else if (parentData instanceof PLPageDefination){
                        PLPageDefination pageDef = (PLPageDefination) parentData;
                        funcId = pageDef.plOId;
                    } else if (parentData instanceof PLTabButton) {
                        PLTabButton but = (PLTabButton)parentData;
                        funcId = but.plOId;
                    }
                    RoleRightDTO roleRightDTO = new RoleRightDTO();
                    roleRightDTO.setId(id);//主键
                    roleRightDTO.setFuncId(funcId);
                    if(isDeveloper) {
                        roleRightDTO.setRightType((short) 1);//权限类型 权限类型，超级管理员给管理员授权为1，管理员给普通用户授权为2
                    }else{
                        roleRightDTO.setRightType((short) 2);
                    }
                    roleRightDTO.setRightValue(1);// 权限值，没有操作的模块权限值存储为0
                    roleRightDTO.setRoleId(roleId);//角色ID
                    roleRightDTO.setCreateUser(currentUserName);//创建者
                    roleRightDTO.setCreateTime(new Date());//创建时间
                    roleRightDTO.setModifyUser(currentUserName);//修改者
                    roleRightDTO.setModifyTime(new Date());//修改时间
                    roleRightDTO.setLicensor("");
                    if(!rightMap.containsKey(funcId)){
                        rightMap.put(funcId, roleRightDTO);
                    }
                }
            }else{
                String funcId = "";
                if(parentData instanceof String){
                    funcId = (String)parentData;
                } else if (parentData instanceof BizType) {
                    BizType bizType = (BizType)parentData;
                    funcId = bizType.name;
                } else if (parentData instanceof PLUILayout) {
                    PLUILayout context = (PLUILayout)parentData;
                    funcId = context.plOId;
                } else if (parentData instanceof PLTabPage) {
                    PLTabPage tab = (PLTabPage) parentData;
                    funcId = tab.plOId;
                } else if (parentData instanceof PLPageDefination){
                    PLPageDefination pageDef = (PLPageDefination) parentData;
                    funcId = pageDef.plOId;
                } else if (parentData instanceof PLTabButton) {
                    PLTabButton but = (PLTabButton)parentData;
                    funcId = but.plOId;
                }
                if(!(parentData instanceof PLPageDefination)) {//子节点不是操作
                    if(!rightMap.containsKey(funcId)&&!funcId.equals("root")){
                        RoleRightDTO roleRightDTO = new RoleRightDTO();
                        roleRightDTO.setFuncId(funcId);
                        if(isDeveloper) {
                            roleRightDTO.setRightType((short) 1);//权限类型 权限类型，超级管理员给管理员授权为1，管理员给普通用户授权为2
                        }else{
                            roleRightDTO.setRightType((short) 2);
                        }
                        roleRightDTO.setRightValue(0);//没有操作的模块权限值存储为0
                        roleRightDTO.setRoleId(roleId);
                        roleRightDTO.setCreateUser(currentUserName);
                        roleRightDTO.setCreateTime(new Date());
                        roleRightDTO.setModifyUser(currentUserName);
                        roleRightDTO.setModifyTime(new Date());
                        roleRightDTO.setLicensor("");
                        rightMap.put(funcId, roleRightDTO);
                    }
                    for(int i = 0;i < parentNode.getChildren().size();i++){
                        //对每个子向下递归遍历
                        getRightValue(roleId,parentNode.getChildren().get(i),allTreeMap,false,rightMap);
                    }
                }else {
                    if(!rightMap.containsKey(funcId)){
                        RoleRightDTO roleRightDTO = new RoleRightDTO();
                        roleRightDTO.setFuncId(funcId);
                        roleRightDTO.setRightType((short)2); // 设置UI权限
                        roleRightDTO.setRightValue(countRightValue(parentNode,true));//没有操作的模块权限值存储为0
                        roleRightDTO.setRoleId(roleId);

                        roleRightDTO.setCreateUser(currentUserName);
                        roleRightDTO.setCreateTime(new Date());
                        roleRightDTO.setModifyUser(currentUserName);
                        roleRightDTO.setModifyTime(new Date());
                        roleRightDTO.setLicensor("");
                        rightMap.put(funcId, roleRightDTO);
                    }
                }
            }

        }
    }
    /**
     * 传入直接挂接操作的模块的节点,计算该节点的权限值
     * @param node 模块节点
     * @param isAll 是否子级全部选中
     * @return
     */
    private long countRightValue(Tree node,boolean isAll){
        long value = 0;
        for(int i = 0;i < node.getChildren().size();i++){
            Tree childNode = (Tree)node.getChildren().get(i);
            if(isAll && node.getData() instanceof PLTabButton ){
                PLTabButton obj = (PLTabButton)node.getData();
                value += (long)Math.pow(2, obj.plSeq);//累计加上各个操作的权限值
            }
        }
        return value;
    }

    /**
     *
     * @param treeList 树节点
     * @param allTreeMap，所有的节点
     */
    private void convertTreeDOO2Map(List<Tree> treeList,Map<String,Tree> allTreeMap){
        Optional.ofNullable(treeList).orElseGet(()->new ArrayList<Tree>()).stream().forEach(tree -> {
            List<Tree> childTreeList= tree.getChildren();
            allTreeMap.put(tree.getOid(),tree);
            if(!CollectionUtil.isEmpty(childTreeList)){
                convertTreeDOO2Map(childTreeList,allTreeMap);
            }
        });
    }
    private void setChildNode(List<Tree> parentTree, List<PLUILayout>contextList,Map<String,RoleRightVO> roleRightVOMap,boolean isShowCheckBox){
        Optional.ofNullable(parentTree).orElseGet(()->new ArrayList<Tree>()).stream().forEach(pTree -> {
            Object funcObj=  pTree.getData();
@@ -340,6 +1051,7 @@
                    contextList.stream().forEach(context->{
                        Tree childTree=new Tree(context.plOId,context.plName+"("+context.plCode+")",context);
                        childTree.setParentName(pTree.getText());
                        childTree.setParentBtmName(pTree.getParentBtmName());
                        childTree.setParentId(pTree.getOid());
                        childTree.setLevel(pTree.getLevel()+1);
                        childTree.setShowCheckbox(isShowCheckBox);
@@ -364,6 +1076,7 @@
                        Tree childTree=new Tree(plTabPage.plOId,plTabPage.plName,plTabPage);
                        childTree.setParentName(pTree.getText());
                        childTree.setParentId(pTree.getOid());
                        childTree.setParentBtmName(pTree.getParentBtmName());
                        childTree.setLevel(pTree.getLevel()+1);
                        childTree.setShowCheckbox(isShowCheckBox);
                        chiledTreeList.add(childTree);
@@ -385,6 +1098,7 @@
                            Tree childTree=new Tree(plPageDefination.plOId,plPageDefination.name,plPageDefination);
                            childTree.setParentName(pTree.getText());
                            childTree.setParentId(pTree.getOid());
                            childTree.setParentBtmName(pTree.getParentBtmName());
                            childTree.setLevel(pTree.getLevel()+1);
                            childTree.setShowCheckbox(isShowCheckBox);
                            chiledTreeList.add(childTree);
@@ -409,6 +1123,7 @@
                            Tree childTree=new Tree(plTabButton.plOId,plTabButton.plLabel,plTabButton);
                            childTree.setParentName(pTree.getText());
                            childTree.setParentId(pTree.getOid());
                            childTree.setParentBtmName(pTree.getParentBtmName());
                            childTree.setLevel(pTree.getLevel()+1);
                            childTree.setShowCheckbox(isShowCheckBox);
                            childTree.setLeaf(true);
@@ -424,9 +1139,18 @@
                }

            }else if (funcObj instanceof PLTabButton) {//按钮
                String id = ((PLTabButton) funcObj).plTableOId;
                PLTabButton plTabButton= (PLTabButton) funcObj;
                String id =plTabButton.plTableOId;
                if(roleRightVOMap.containsKey(id)){
                    pTree.setChecked(true);
                    RoleRightVO roleRightVO = roleRightVOMap.get(id);
                    Long rightValue =  roleRightVO.getRightValue();
                    int nodeValue = plTabButton.plSeq;
                    if (nodeValue >= 0 && nodeValue <= 63) {
                        long preValue = (rightValue >> nodeValue) & 1;
                        if (preValue == 1) {
                            pTree.setChecked(true);
                        }
                    }
                }else{
                    pTree.setChecked(false);
                }
@@ -566,7 +1290,7 @@
        //查询同一业务类型下的ui上下文，然后查重
        PLUILayout[] plpagelayoutdefinations = platformClientUtil.getUIService().getPLUILayoutsByRelatedType(pluiLayout.plRelatedType);
        int length = plpagelayoutdefinations.length;
        for (int i =0;i<length;i++){
        for (int i =0; i<length; i++){
            String code = plpagelayoutdefinations[i].plCode;
            String name = plpagelayoutdefinations[i].plName;
            String ids = plpagelayoutdefinations[i].plOId;
@@ -577,9 +1301,8 @@
                        break;
                    }
                }
            }
            else {
                if (code.equalsIgnoreCase(code) || name.equals(name)){
            }else {
                if (code.equalsIgnoreCase(pluiLayout.plCode) || name.equals(pluiLayout.plName)){
                    res = true;
                    break;
                }
@@ -588,4 +1311,679 @@
        return res;
    }

    //基础公共检查接口
    private abstract class BaseComptInter {

        /**
         * 公共校验方法
         * @return
         * @throws PLException
         */
        public abstract boolean checkInputIsOk() throws PLException;

        /**
         * 根据类型不同设置不同的属性
         * @param d
         * @return
         */
        public abstract PLDefination getNewPLDefination(PLDefination d);

        /**
         * 非空检查
         * @param tip
         * @param txt
         * @return
         */
        protected boolean checkRequiredIsOk(String tip, String txt){
            boolean res = false;
            if(Func.isBlank(txt)){
                throw new VciBaseException(tip + " 不能为空！");
            } else {
                res = true;
            }
            return res;
        }

        /**
         * 检查BtmType输入是否有效
         * @param tipName 提示的信息
         * @param btmName 业务类型名
         * @return
         */
        protected boolean checkBtmTypeTxtIsOk(String tipName, String btmName) throws PLException {
            boolean res = false;
            if(tipName == null) return true;
            if(btmName == null) return true;
            if(!checkRequiredIsOk(tipName, btmName)){
                res = false;
            } else if(!checkBtmNameIsExist(tipName, btmName)){
                res = false;
            } else {
                res = true;
            }
            return res;
        }

        /**
         * 检查业务类型是否存在
         * @param tip
         * @param btmName
         * @return
         */
        protected boolean checkBtmNameIsExist(String tip, String btmName) throws PLException {
            boolean res = false;
            String sql = "select count(1) count_ from plbtmtype bt where bt.name='" + btmName.trim() + "'";
            res = checkCountNotEqualZero(sql);
            if(!res){
                throw new PLException("500",
                        new String[]{String.format("%s %s 无效！", tip, btmName)});
            } else {
                res = true;
            }
            return res;
        }

        /**
         * 执行sql，检查是否有返回值
         * @param sql
         * @return
         */
        protected boolean checkCountNotEqualZero(String sql){
            boolean res = false;
            try{
                String[][] kvss = platformClientUtil.getQueryService().queryBySqlWithoutKey(sql);
                res = Integer.valueOf(kvss[0][0]) > 0;
            }catch(Exception ex){
                ex.printStackTrace();
            }
            return res;
        }

        /**
         * 检查表单输入是否有效
         * @param tip
         * @param txtVIName
         * @param btmLinkType
         * @return
         */
        protected boolean checkPortalVITxtIsOk(String tip, String txtVIName, String btmLinkType) throws PLException {
            boolean res = false;
            if(tip == null) return true;
            if(txtVIName == null) return true;
            if(!checkRequiredIsOk(tip, txtVIName)){
                res = false;
            } else if(!checkPortalVIIsExist(tip, txtVIName, btmLinkType)){
                res = false;
            } else {
                res = true;
            }
            return res;
        }

        /**
         * 检查模板
         * @param tip
         * @param txtVIName
         * @param btmLinkType
         * @return
         */
        protected boolean checkPortalVIIsExist(String tip, String txtVIName, String btmLinkType) throws PLException {
            boolean res = false;
            String sql = "select count(1) count_ from plportalvi vi " +
                    "where vi.typename='" + btmLinkType.trim() + "' " +
                    "and vi.viname='" + txtVIName.trim() + "'";
            res = checkCountNotEqualZero(sql);
            if(!res){
                throw new PLException("500",
                        new String[]{String.format("%s %s 无效！", tip, txtVIName)});
            } else {
                res = true;
            }
            return res;
        }

        /**
         * 检查查询模板输入是否有效
         * @param tip 输入框的名称，用来提示
         * @param txtQTName 查询模板
         * @param btmLinkType
         * @return
         */
        protected boolean checkQTNameTxtIsOk(String tip, String txtQTName, String btmLinkType) throws PLException {
            boolean res = false;
            if(tip == null) return true;
            if(txtQTName == null) return true;
            if(!checkRequiredIsOk(tip, txtQTName)){
                res = false;
            } else if(Func.isBlank(txtQTName) && !checkQTIsExist(tip, txtQTName, btmLinkType)){
                res = false;
            } else {
                res = true;
            }
            return res;
        }

        /**
         * 检查表单输入是否有效
         * @param tip
         * @param uiName
         * @param btmLinkType
         * @return
         */
        protected boolean checkUILayoutTxtIsOk(String tip, String uiName, String btmLinkType) throws PLException {
            boolean res = false;
            if(tip == null) return true;
            if(uiName == null) return true;
            if(!checkRequiredIsOk(tip, uiName)){
                res = false;
            } else if(!checkUILayoutIsExist(tip, uiName, btmLinkType)){
                res = false;
            } else {
                res = true;
            }
            return res;
        }

        private boolean checkUILayoutIsExist(String tip, String uiName, String txtType) throws PLException {
            boolean res = false;
            String sql = "select count(1) count_ from PLUILAYOUT ui " +
                    "where ui.PLRELATEDTYPE='" + txtType.trim() + "' " +
                    "and ui.plcode='" + uiName.trim() + "'";
            res = checkCountNotEqualZero(sql);
            if(!res){
                throw new PLException("500",
                        new String[]{String.format("%s %s 无效！", tip, uiName)});
            } else {
                res = true;
            }
            return res;
        }

        /**
         * 检查当前输入的查询模板是否存在
         * @param tip
         * @param txtQTName
         * @param txtType
         * @return
         */
        protected boolean checkQTIsExist(String tip, String txtQTName, String txtType) throws PLException {
            boolean res = false;

            String sql = "select count(1) count_ from PL_QTEMPLATE qt " +
                    "where qt.btmname ='" + txtType.trim() + "' " +
                    "and qt.qtname='" + txtQTName.trim() + "'";

            if(!res){
                throw new PLException("500",
                        new String[]{String.format("%s %s 无效！", tip, txtQTName)});
            } else {
                res = true;
            }
            return res;
        }

        /**
         * 检查LinkType输入是否有效
         * @param tip
         * @param linkTypeName
         * @return
         */
        protected boolean checkLinkTypeTxtIsOk(String tip, String linkTypeName) throws PLException {
            boolean res = false;
            if(tip == null) return true;
            if(linkTypeName == null) return true;
            if(!checkRequiredIsOk(tip, linkTypeName)){
                res = false;
            } else if(!checkLinkTypeIsExist(tip, linkTypeName)){
                res = false;
            } else {
                res = true;
            }
            return res;
        }

        private boolean checkLinkTypeIsExist(String tip, String linkTypeName) throws PLException {
            boolean res = false;
            String sql = "select count(1) count_ from pllinktype lt " +
                    "where lt.name ='" + linkTypeName.trim() + "'";
            res = checkCountNotEqualZero(sql);
            if(!res){
                throw new PLException("500",
                       new String[]{String.format("%s %s 无效！", tip, linkTypeName)});
            } else {
                res = true;
            }
            return res;
        }

    }

    //模板类型为Custom类型时校验输入
    @AllArgsConstructor
    @NoArgsConstructor
    private class CustomComptCheckInput extends BaseComptInter{

        /**
         * 控制路径
         */
        private String ctrlPath;

        @Override
        public boolean checkInputIsOk() throws PLException {
            boolean res = true;
            if(!checkRequiredIsOk(this.ctrlPath)){
                res = false;
            }
            return res;
        }

        /**
         * 控制路径必输检查
         * @param ctrlPath
         * @return
         */
        protected boolean checkRequiredIsOk(String ctrlPath) throws PLException {
            boolean res = false;
            String text = ctrlPath.trim();

            if(Func.isBlank(text)){
                throw new PLException("500", new String[]{"控制路径不能为空！"});
            } else {
                res = true;
            }
            return res;
        }

        @Override
        public PLDefination getNewPLDefination(PLDefination d) {
            if(d == null){
                d = new PLDefination();
            }
            d.setControlPath(ctrlPath);
            return d;
        }

    }

    @AllArgsConstructor
    @NoArgsConstructor
    private class TableComptCheckInput extends BaseComptInter{

        /**
         * 搜索类型：本对象属性：1，关联对象属性：2
         */
        private String searchTarger;

        /**
         * 业务类型
         */
        private String btmType;

        /**
         * 链接类型
         */
        private String linkType;

        /**
         * 选择模板
         */
        private String txtVIName;

        /**
         * 查询模板
         */
        private String txtQTName;

        @Override
        public boolean checkInputIsOk() throws PLException {
            boolean res = false;
            if(searchTarger.equals("1")){
                res = checkBtmTypeInputIsOk(btmType,txtVIName,txtQTName);
            } else if(searchTarger.equals("2")){
                res = checkLinkTypeInputIsOk(txtVIName,txtQTName,btmType);
            }
            return res;
        }

        @Override
        public PLDefination getNewPLDefination(PLDefination d) {
            if(d == null){
                d = new PLDefination();
            }
            if("1".equals(searchTarger)){
                d.setSearchTarger("1");
                d.setShowType(btmType.trim());
                d.setTemplateId(txtVIName);
                d.setQueryTemplateName(txtQTName);

            } else if("2".equals(searchTarger)){
                d.setSearchTarger("2");

                d.setShowType(btmType);
                d.setLinkType(linkType);
                d.setTemplateId(txtVIName);
                d.setQueryTemplateName(txtQTName);
            }
            return d;
        }

        /**
         * 检查业务类型是否输入，是否存在
         * @param txtVIName
         * @param btmType
         * @param txtQTName
         * @return
         */
        private boolean checkBtmTypeInputIsOk(String btmType,String txtVIName/*选择模板*/,String txtQTName/*查询模板*/) throws PLException {
            boolean res = false;
            if(!super.checkBtmTypeTxtIsOk("业务类型", btmType)){
                res = false;
            } else if(!super.checkPortalVITxtIsOk("选择模板", txtVIName, btmType)){
                res = false;
            } else if(!super.checkQTNameTxtIsOk("查询模板", txtQTName, btmType)){
                res = false;
            } else {
                res = true;
            }
            return res;
        }

        /**
         * 检查链接类型是否输入，是否存在
         * @param txtVIName
         * @param txtQTName
         * @param btmType
         * @return
         */
        private boolean checkLinkTypeInputIsOk(String txtVIName/*选择的模板*/,String txtQTName/*查询模板*/,String btmType) throws PLException {
            boolean res = false;
            if(!(this.checkBtmTypeTxtIsOk("目标对象", linkType))){
                res = false;
            } else if(!(this.checkPortalVITxtIsOk("选择模板", txtVIName, linkType))){
                res = false;
            } else if(!(this.checkQTNameTxtIsOk("查询模板", txtQTName, linkType))){
                res = false;
            } else {
                res = true;
            }
            return res;
        }

    }

    @AllArgsConstructor
    @NoArgsConstructor
    private class TreeTableComptCheckInput extends BaseComptInter{

        /**
         * 搜索类型：本对象属性：1，关联对象属性：2
         */
        private String searchTarger;

        /**
         * 业务类型
         */
        private String btmType;

        /**
         * 链接类型
         */
        private String linkType;

        /**
         * 选择模板
         */
        private String txtVIName;

        /**
         * 查询模板
         */
        private String txtQTName;

        /**
         * 树形结构展开列
         */
        private String expandCols;

        /**
         * 展开形式：逐级展开 1，全部展开 0
         */
        private String expandMode;

        @Override
        public boolean checkInputIsOk() throws PLException {
            boolean res = false;
            if(searchTarger.equals("1")){
                res = this.checkBtmTypeInputIsOk();
            } else if(searchTarger.equals("2")){
                res = checkLinkTypeInputIsOk();
            }
            return res;
        }

        @Override
        public PLDefination getNewPLDefination(PLDefination d) {
            if(d == null){
                d = new PLDefination();
            }
            //属性赋值重叠，所以这儿改变了逻辑
            d.setSearchTarger(searchTarger);
            d.setShowType(btmType);
            d.setTemplateId(txtVIName);
            d.setQueryTemplateName(txtQTName);
            d.setExpandCols(expandCols);
            d.setExpandMode(expandMode);
            if("2".equals(searchTarger)){
                d.setLinkType(linkType);
            }
            return d;
        }

        private boolean checkBtmTypeInputIsOk() throws PLException {
            boolean res = false;
            if(!(super.checkBtmTypeTxtIsOk("顶级节点显示类型", btmType))){
                res = false;
            } else if(!(super.checkPortalVITxtIsOk("选择模板", txtVIName, btmType))){
                res = false;
            } else if(!(super.checkQTNameTxtIsOk("查询模板", txtQTName , btmType))){
                res = false;
            } else {
                res = true;
            }
            return res;
        }

        private boolean checkLinkTypeInputIsOk() throws PLException {
            boolean res = false;
            if(!(super.checkBtmTypeTxtIsOk("顶级节点显示类型", linkType))){
                res = false;
            } else if(!(super.checkPortalVITxtIsOk("选择模板", txtVIName, linkType))){
                res = false;
            } else if(!(super.checkQTNameTxtIsOk("查询模板", txtQTName, linkType))){
                res = false;
            } else {
                res = true;
            }
            return res;
        }

    }

    @AllArgsConstructor
    @NoArgsConstructor
    private class TreeComptCheckInput extends BaseComptInter{

        /**
         * 业务类型
         */
        private String btmType;

        /**
         * 链接类型
         */
        private String linkType;

        /**
         * 查询模板
         */
        private String queryTemplateName;

        /**
         * 根节点显示表达式
         */
        private String showExpressionRoot;

        /**
         * 树节点显示表达式
         */
        private String showExpression;

        /**
         * 参照树设置
         */
        private String refTreeSet;


        /**
         * 分隔符
         */
        private String splitChar;

        /**
         * 展开方式：逐级展开 1，全部展开 0
         */
        private String expandMode;

        @Override
        public boolean checkInputIsOk() throws PLException {
            return checkBtmTypeInputIsOk();
        }

        @Override
        public PLDefination getNewPLDefination(PLDefination d) {
            if(d == null){
                d = new PLDefination();
            }
            d.setShowType(btmType);
            d.setLinkType(linkType);
            d.setTemplateId(queryTemplateName);
            d.setRootContent(showExpressionRoot.trim());
            d.setShowAbs(showExpression.trim());
            d.setShowLinkAbs(refTreeSet.trim());
            d.setSeparator(splitChar.trim());
            d.setExpandMode(expandMode);
            return d;
        }

        private boolean checkBtmTypeInputIsOk() throws PLException {
            boolean res = false;
            if(!(super.checkBtmTypeTxtIsOk("业务类型", btmType))){
                res = false;
                return res;
            }
            // 链接类型不为空时，需要同时检查链接类型及链接类型下的查询模板是否有效
            if(Func.isBlank(linkType)){
                if(!(super.checkLinkTypeTxtIsOk("链接类型", linkType))){
                    res = false;
                    return res;
                } else if(!(super.checkQTNameTxtIsOk("查询模板", queryTemplateName, linkType))){
                    res = false;
                    return res;
                }
            } else {
                // 链接类型为空时，只需要检查业务类型下的查询模板是否有效
                if(!(super.checkQTNameTxtIsOk("查询模板", queryTemplateName, btmType))){
                    res = false;
                    return res;
                }
            }

            if(!super.checkRequiredIsOk("根节点显示表达式", showExpressionRoot)){
                res = false;
            }
            else if(!super.checkRequiredIsOk("树节点显示表达式", showExpression)){
                res = false;
            }
            else if(!super.checkRequiredIsOk("参照树设置", refTreeSet)){
                res = false;
            }
            else {
                res = true;
            }
            return res;
        }

    }

    @AllArgsConstructor
    @NoArgsConstructor
    private class UILayoutComptCheckInput extends BaseComptInter{

        /**
         * 搜索类型：本对象属性：1，关联对象属性：2
         * 查询类型也是赋值到这个属性上： 业务类型：1，链接类型：2
         */
        private String searchTarger;

        /**
         * 对象类型
         */
        private String uiBtmType;

        /**
         * UI定义
         */
        private String uiLayout;

        /**
         * 查询模板
         */
        private String queryTemplateName;

        /**
         * 查询对象类型
         */
        private String qryType;

        @Override
        public boolean checkInputIsOk() throws PLException{
            return checkUILayoutInputIsOk();
        }

        @Override
        public PLDefination getNewPLDefination(PLDefination d) {
            if (d == null) {
                d = new PLDefination();
            }

            d.setSearchTarger(searchTarger);
            d.setSubUiObjType(uiBtmType.trim());
            d.setSubUILayout(uiLayout.trim());

            if (searchTarger.equals("1")) {
                d.setShowType(qryType.trim());
            } else {
                d.setLinkType(qryType.trim());
            }
            d.setQueryTemplateName(queryTemplateName.trim());

            return d;
        }

        private boolean checkUILayoutInputIsOk() throws PLException {
            boolean res = false;
            if (!(super.checkBtmTypeTxtIsOk("对象类型", uiBtmType))) {
                res = false;
            } else if (!(super.checkUILayoutTxtIsOk("UI定义", uiLayout, uiBtmType))) {
                res = false;
            } else if (!(super.checkQTNameTxtIsOk("查询模板", queryTemplateName, qryType))) {
                res = false;
            } else {
                res = true;
            }
            return res;
        }

    }

}