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

@@ -1,36 +1,33 @@
package com.vci.web.service.impl;

import com.sun.jnlp.ApiDialog;
import com.vci.client.mw.ClientContextVariable;
import com.vci.common.qt.object.QTConstants;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.JSON;
import com.vci.common.utility.ObjectUtility;
import com.vci.corba.common.PLException;
import com.vci.corba.common.data.UserEntityInfo;
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.pagemodel.*;
import com.vci.starter.poi.bo.WriteExcelData;
import com.vci.starter.poi.bo.WriteExcelOption;
import com.vci.starter.poi.util.ExcelUtil;
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.util.VciBaseUtil;
import com.vci.starter.web.util.VciDateUtil;
import com.vci.starter.web.util.WebThreadLocalUtil;
import com.vci.starter.web.util.*;
import com.vci.web.service.OsBtmServiceI;
import com.vci.web.service.UIManagerServiceI;
import com.vci.web.util.*;
import com.vci.web.util.BeanUtil;
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;
@@ -38,20 +35,16 @@
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 javax.swing.*;
import javax.swing.text.JTextComponent;
import java.io.IOException;
import java.io.File;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.*;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * UI定义服务界面相关接口
@@ -72,6 +65,11 @@
     */
    @Resource
    private SmRoleQueryServiceI smRoleQueryServiceI;
    /***
     * 是否是管理员
     */
    @Autowired
    RightControlUtil rightControlUtil;

    /**
     * 业务类型
@@ -91,6 +89,16 @@
        @Override
        public int compare(PLUILayout o1, PLUILayout o2) {
            return o1.plCode.compareTo(o2.plCode);
        }
    };

    /**
     * 排序比较器
     */
    private Comparator<PLDefinationVO> pageDefinationComparator = new Comparator<PLDefinationVO>() {
        @Override
        public int compare(PLDefinationVO o1, PLDefinationVO o2) {
            return new Integer(o1.getSeq()).compareTo(new Integer(o2.getSeq()));
        }
    };

@@ -136,7 +144,7 @@
    public List<PLUILayout> getUIContextDataByBtName(String btemName,String context) throws PLException {
        VciBaseUtil.alertNotNull(btemName,"业务类型");
        List<PLUILayout> pluiLayoutList=new ArrayList<>();
        List<String> contextList= VciBaseUtil.str2List(context);
        List<String> contextList= new ArrayList<>();
        if(StringUtils.isNotBlank(context)){
            contextList=VciBaseUtil.str2List(context);
        }else{
@@ -313,13 +321,133 @@
    }

    /**
     * 根据勾选的条件获取需要导出的ui上下文树
     * @param expDatas
     * @return
     */
    @Override
    public Tree getExpContextTree(List<String> expDatas) {
        VciBaseUtil.alertNotNull(expDatas,"导出查询列表");
        Tree tree = new Tree();
        String newObjectID36 = ObjectUtility.getNewObjectID36();
        tree.setOid(newObjectID36);
        tree.setText("区域");
        tree.setLevel(0);
        List<Tree> treeList = new ArrayList<>();
        expDatas.stream().forEach(oid->{
            try {
                PLUILayout pluiLayout = platformClientUtil.getUIService().getPLUILayoutById(oid);
                if(Func.isNotEmpty(pluiLayout) &&  Func.isNotBlank(pluiLayout.plOId)){
                    Tree tree1 = new Tree();
                    tree1.setText(pluiLayout.plName);
                    tree1.setOid(pluiLayout.plOId);
                    tree1.setLevel(1);
                    tree1.setParentId(newObjectID36);
                    //查询
                    PLTabPage[] plTabPages = platformClientUtil.getUIService().getPLTabPagesByPageDefinationOId(pluiLayout.plOId);
                    List<Tree> treeChildrens = new ArrayList<>();
                    Arrays.stream(plTabPages).forEach(item->{
                        Tree tree2 = new Tree();
                        tree2.setLeaf(true);
                        tree2.setOid(item.plOId);
                        tree2.setText(item.plName);
                        tree2.setLevel(2);
                        tree2.setParentId(item.plContextOId);
                        treeChildrens.add(tree2);
                    });
                    tree1.setChildren(treeChildrens);
                    treeList.add(tree1);
                }
            } catch (PLException e) {
                e.printStackTrace();
            }
        });

        tree.setChildren(treeList);
        return tree;
    }

    /**
     * 导出ui上下文(勾选的要导出的控制区的数据)
     * oids
     * @return
     */
    @Override
    public void expUIContextData(String[] oids, HttpServletResponse response) throws PLException, IOException {
    public String expUIContextData(Map<String,String> expConditionMap) throws PLException {
        if(Func.isEmpty(expConditionMap)){
            throw new PLException("500",new String[]{"请勾选要导出的UI上下文数据!"});
        }
        //界面没传名称，使用默认导出名称
        String exportFileName = "UI上下文导出_" + Func.format(new Date(),"yyyy-MM-dd HHmmss.sss");
        //设置列名
        List<String> columns = Arrays.asList(
                "所属业务类型","名称", "UI上下文", "导航区", "控制区","操作区",
                "页签序号","区域编码","区域名称","是否启用","显示表达式", "UI解析类",
                "扩展属性", "描述","页面设计信息","页面下配置的按钮"
        );

        //写excel
        String excelPath = LocalFileUtil.getDefaultTempFolder() + File.separator + exportFileName +  ".xls";
        try {
            new File(excelPath).createNewFile();
        } catch (Throwable e) {
            throw new VciBaseException(LangBaseUtil.getErrorMsg(e), new String[]{excelPath}, e);
        }
        //设置列
        List<WriteExcelData> excelDataList = new ArrayList<>();
        //设置列头
        for (int index = 0; index < columns.size(); index++) {
            excelDataList.add(new WriteExcelData(0,index, columns.get(index)));
        }
        AtomicInteger row = new AtomicInteger(1);
        expConditionMap.entrySet().stream().forEach(item->{
            //key存放的ui上下文的id
            try {
                PLUILayout pluiLayout = platformClientUtil.getUIService().getPLUILayoutById(item.getKey());
                //value中存放的多个以逗号间隔的页签id,通过这个id查询出其下的页面设计和按钮配置
                List<String> plTabPageOIds = Arrays.asList(item.getValue().split(","));
                if(Func.isNotEmpty(pluiLayout) && Func.isNotBlank(pluiLayout.plOId) && Func.isNotEmpty(plTabPageOIds)){
                    PLTabPage[] plTabPages = platformClientUtil.getUIService().getPLTabPagesByPageDefinationOId(pluiLayout.plOId);
                    List<PLTabPage> filterTabPages = Arrays.stream(plTabPages).filter(plTabPage -> plTabPageOIds.contains(plTabPage.plOId)).collect(Collectors.toList());
                    filterTabPages.stream().forEach(tabPage->{
                        excelDataList.add(new WriteExcelData(row.get(),0, pluiLayout.plRelatedType));
                        excelDataList.add(new WriteExcelData(row.get(),1, pluiLayout.plName));
                        excelDataList.add(new WriteExcelData(row.get(),2, pluiLayout.plCode));
                        excelDataList.add(new WriteExcelData(row.get(),3, pluiLayout.plIsShowForm));
                        excelDataList.add(new WriteExcelData(row.get(),4, pluiLayout.plIsShowNavigator));
                        excelDataList.add(new WriteExcelData(row.get(),5, pluiLayout.plIsShowTab));
                        excelDataList.add(new WriteExcelData(row.get(),6, tabPage.plSeq));
                        excelDataList.add(new WriteExcelData(row.get(),7, tabPage.plLabel));
                        excelDataList.add(new WriteExcelData(row.get(),8, tabPage.plName));
                        excelDataList.add(new WriteExcelData(row.get(),9, tabPage.plIsOpen));
                        excelDataList.add(new WriteExcelData(row.get(),10, tabPage.plOpenExpression));
                        excelDataList.add(new WriteExcelData(row.get(),11, tabPage.plUIParser));
                        excelDataList.add(new WriteExcelData(row.get(),12, tabPage.plExtAttr));
                        excelDataList.add(new WriteExcelData(row.get(),13, tabPage.plDesc));
                        try {
                            PLPageDefination[] plPageDefinations = platformClientUtil.getUIService().getPLPageDefinationsByPageContextOId(tabPage.plOId);
                            if(Func.isNotEmpty(plPageDefinations)){
                                excelDataList.add(new WriteExcelData(row.get(),14, JSON.toJSONString(plPageDefinations)));
                                List<PLTabButtonVO> tabButtonsTotal = new ArrayList<>();
                                Arrays.stream(plPageDefinations).forEach(plPageDefination->{
                                    List<PLTabButtonVO> tabButtons = this.getTabButtons(plPageDefination.plOId);
                                    tabButtonsTotal.addAll(tabButtons);
                                });
                                excelDataList.add(new WriteExcelData(row.get(),15, JSON.toJSONString(tabButtonsTotal)));
                            }
                        } catch (PLException e) {
                            e.printStackTrace();
                        }
                        row.getAndIncrement();
                    });
                }
            } catch (PLException e) {
                e.printStackTrace();
            }
        });
        WriteExcelOption excelOption = new WriteExcelOption(excelDataList);
        ExcelUtil.writeDataToFile(excelPath, excelOption);
        return excelPath;
    }

    /**
@@ -329,6 +457,10 @@
     */
    @Override
    public BaseResult impUIContextData(MultipartFile file) {




        return null;
    }

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

    /**
@@ -401,13 +536,53 @@

    /**
     * 查询页面设计定义
     * @param plPageContextOId
     * @param pageContextOId
     * @return
     */
    @Override
    public List<PLPageDefination> getPLPageDefinations(String plPageContextOId) {
    public DataGrid getPLPageDefinations(String pageContextOId) throws PLException {
        DataGrid dataGrid = new DataGrid();
        if(Func.isBlank(pageContextOId)) return dataGrid;
        PLPageDefination[] plPageDefinations = platformClientUtil.getUIService().getPLPageDefinationsByPageContextOId(pageContextOId);
        if(Func.isEmpty(plPageDefinations)){
            return dataGrid;
        }
        //DO2VO
        List<PLDefinationVO> plDefinationVOS = this.pageDefinations2PLDefinationVO(Arrays.asList(plPageDefinations));
        dataGrid.setTotal(plDefinationVOS.size());
        Collections.sort(plDefinationVOS, Comparator.comparing(PLDefinationVO::getSeq));
        //Arrays.sort(plDefinationVOS, pageDefinationComparator);
        dataGrid.setData(plDefinationVOS);
        return dataGrid;
    }

        return null;
    /**
     * 页面定义的DO2VO对象
     * @param plPageDefinations
     * @return
     */
    private List<PLDefinationVO> pageDefinations2PLDefinationVO(List<PLPageDefination> plPageDefinations){
        List<PLDefinationVO> plDefinationVOList = new ArrayList<>();
        plPageDefinations.stream().forEach(item->{
            try {
                PLDefinationVO plDefinationVO = new PLDefinationVO();
                PLDefination plDefination = UITools.getPLDefination(item.plDefination);
                BeanUtil.copy(plDefination,plDefinationVO);
                plDefinationVO.setDescription(item.desc);
                plDefinationVO.setSeq(String.valueOf(item.seq));
                plDefinationVO.setTabPageOId(item.plTabPageOId);
                plDefinationVO.setId(item.plOId);
                plDefinationVO.setName(item.name);
                plDefinationVO.setType(item.plType);
                plDefinationVO.setTemplateType(String.valueOf(plDefination.getTemplateType()));
                plDefinationVOList.add(plDefinationVO);
            } catch (Throwable e) {
                e.printStackTrace();
                logger.error(e.getMessage());
                throw new VciBaseException("页面定义DO对象转VO对象时出现错误,原因："+e.getMessage());
            }
        });
        return plDefinationVOList;
    }

    /**
@@ -424,14 +599,14 @@
        pd.plTabPageOId = pdVO.getTabPageOId();
        pd.plOId = ObjectUtility.getNewObjectID36();
        //不能为空属性检查
        if(!this.baseInfoIsOk(pd,false)){
        /*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());
        pd.plType = (short) pdVO.getType();

        d.setName(pdVO.getName().trim());
        d.setUiParser(pdVO.getUiParser().trim());
@@ -442,15 +617,15 @@
        newPLDefinationIsOk(pdVO, false);

        // 检查各个类型下的数据是否输入或有效,一共6种类型按类型检验
        short plType = pd.plType;
        switch (plType){
        String templateType = pdVO.getTemplateType();
        switch (templateType){
            //Table(表格)
            case 1:
            case "1":
            //From(表单)
            case 4:
            case "4":
                TableComptCheckInput tci = new TableComptCheckInput(
                    pdVO.getSearchTarger()
                    ,pdVO.getBtmType()
                    ,pdVO.getShowType()
                    ,pdVO.getLinkType()
                    ,pdVO.getTemplateId()
                    ,pdVO.getQueryTemplateName()
@@ -461,7 +636,7 @@
                d = tci.getNewPLDefination(d);
                break;
            //Custom(自定义模板)
            case 2:
            case "2":
                //只检查控制路径不能为空,有问题会直接报错
                CustomComptCheckInput ccci = new CustomComptCheckInput(pdVO.getControlPath());
                if(!ccci.checkInputIsOk()){
@@ -470,10 +645,10 @@
                d = ccci.getNewPLDefination(d);
                break;
            //TreeTable(树表)
            case 3:
            case "3":
                TreeTableComptCheckInput ttcci = new TreeTableComptCheckInput(
                    pdVO.getSearchTarger()
                    ,pdVO.getBtmType()
                    ,pdVO.getShowType()
                    ,pdVO.getLinkType()
                    ,pdVO.getTemplateId()
                    ,pdVO.getQueryTemplateName()
@@ -486,9 +661,9 @@
                d = ttcci.getNewPLDefination(d);
                break;
            //Tree(树)
            case 5:
            case "5":
                TreeComptCheckInput tcci = new TreeComptCheckInput(
                    pdVO.getBtmType(),
                    pdVO.getShowType(),
                    pdVO.getLinkType(),
                    pdVO.getQueryTemplateName(),
                    pdVO.getShowExpressionRoot(),
@@ -503,10 +678,10 @@
                d = tcci.getNewPLDefination(d);
                break;
            //UILayout(UI定义)
            case 6:
            case "6":
                UILayoutComptCheckInput ulci = new UILayoutComptCheckInput(
                    pdVO.getSearchTarger(),
                    pdVO.getBtmType(),
                    pdVO.getShowType(),
                    pdVO.getUiLayout(),
                    pdVO.getQueryTemplateName(),
                    pdVO.getQryType()
@@ -533,28 +708,41 @@
     */
    @Override
    public boolean updatePageDefination(PLDefinationVO pdVO) throws Throwable {
        /*PLPageDefination pd = getPageDefination();

        PLDefination d = UITools.getPLDefination(pd.plDefination);
        VciBaseUtil.alertNotNull(pdVO,"页面定义对象",pdVO.getSeq(),"编号",pdVO.getName(),"名称");
        PLPageDefination pd = new PLPageDefination();
        PLDefination d = new PLDefination();
        BeanUtil.copy(pdVO,d);

        //不能为空属性检查
        if(!this.baseInfoIsOk(pd,true)){
        /*if(!this.baseInfoIsOk(pd,true)){
            return false;
        }
        setUIValueToObject(pd, d);
        }*/
        pd.plOId = pdVO.getId();
        pd.plTabPageOId = pdVO.getTabPageOId();
        pd.name = pdVO.getName().trim();
        pd.seq = Short.valueOf(pdVO.getSeq().trim());
        pd.desc = pdVO.getDescription();
        pd.plType = (short) pdVO.getType();

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

        this.newPLDefinationIsOk(pdVO, true);

        // 检查各个组件内部的数据是否有效
        int plType = pdVO.getType();
        switch (plType){
        String templateType = pdVO.getTemplateType();
        switch (templateType){
            //Table(表格)
            case 1:
            case "1":
                //From(表单)
            case 4:
            case "4":
                TableComptCheckInput tci = new TableComptCheckInput(
                        pdVO.getSearchTarger()
                        ,pdVO.getBtmType()
                        ,pdVO.getShowType()
                        ,pdVO.getLinkType()
                        ,pdVO.getTemplateId()
                        ,pdVO.getQueryTemplateName()
@@ -565,7 +753,7 @@
                d = tci.getNewPLDefination(d);
                break;
            //Custom(自定义模板)
            case 2:
            case "2":
                //只检查控制路径不能为空,有问题会直接报错
                CustomComptCheckInput ccci = new CustomComptCheckInput(pdVO.getControlPath());
                if(!ccci.checkInputIsOk()){
@@ -574,10 +762,10 @@
                d = ccci.getNewPLDefination(d);
                break;
            //TreeTable(树表)
            case 3:
            case "3":
                TreeTableComptCheckInput ttcci = new TreeTableComptCheckInput(
                        pdVO.getSearchTarger()
                        ,pdVO.getBtmType()
                        ,pdVO.getShowType()
                        ,pdVO.getLinkType()
                        ,pdVO.getTemplateId()
                        ,pdVO.getQueryTemplateName()
@@ -590,9 +778,9 @@
                d = ttcci.getNewPLDefination(d);
                break;
            //Tree(树)
            case 5:
            case "5":
                TreeComptCheckInput tcci = new TreeComptCheckInput(
                        pdVO.getBtmType(),
                        pdVO.getShowType(),
                        pdVO.getLinkType(),
                        pdVO.getQueryTemplateName(),
                        pdVO.getShowExpressionRoot(),
@@ -607,10 +795,10 @@
                d = tcci.getNewPLDefination(d);
                break;
            //UILayout(UI定义)
            case 6:
            case "6":
                UILayoutComptCheckInput ulci = new UILayoutComptCheckInput(
                        pdVO.getSearchTarger(),
                        pdVO.getBtmType(),
                        pdVO.getShowType(),
                        pdVO.getUiLayout(),
                        pdVO.getQueryTemplateName(),
                        pdVO.getQryType()
@@ -622,12 +810,336 @@
                break;
        }

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

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

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

    /**
     * 获取页签区域按钮配置信息
     * @param pageDefinationOid
     * @return
     */
    @Override
    public List<PLTabButtonVO> getTabButtons(String pageDefinationOid) {
        VciBaseUtil.alertNotNull(pageDefinationOid,"页面定义主键");
        List<PLTabButton> buttonList = new ArrayList<>();
        try {
            PLTabButton[] plTabButtons = platformClientUtil.getUIService().getPLTabButtonsByTableOId(pageDefinationOid);
            buttonList = Arrays.asList(plTabButtons);
            List<PLTabButtonVO> plTabButtonVOList = this.tabButton2TabButtonVOS(buttonList);
            PLTabButtonVO plTabButtonVO = new PLTabButtonVO();
            for(int i = 0; i < plTabButtonVOList.size(); i++){
                plTabButtonVO = plTabButtonVOList.get(i);

                if(plTabButtonVO.getParentOid().equals("")){
                    plTabButtonVO.setChildren(plTabButtonVO2Children(plTabButtonVOList,plTabButtonVO.getOId()));
                }
            }
            return plTabButtonVOList;
        } catch (Exception e) {
            e.printStackTrace();
            throw new VciBaseException("加载页签区域按钮配置信息异常：" + e.getMessage());
        }
    }

    /**
     * 多个按钮配置DO对象转多个VO对象
     * @param listDO
     * @return
     */
    private List<PLTabButtonVO> tabButton2TabButtonVOS(List<PLTabButton> listDO){
        List<PLTabButtonVO> plTabButtonVOList = new ArrayList<PLTabButtonVO>();
        if(Func.isEmpty(listDO)){
            return plTabButtonVOList;
        }
        listDO.stream().forEach(item->{
            try {
                PLTabButtonVO plTabButtonVO = this.tabButton2TabButtonVO(item);
                plTabButtonVOList.add(plTabButtonVO);
            } catch (PLException e) {
                e.printStackTrace();
                String errorLog = "按钮配置DO TO VO时出现错误，原因："+VciBaseUtil.getExceptionMessage(e);
                logger.error(errorLog);
                throw new VciBaseException(errorLog);
            }
        });
        return plTabButtonVOList;
    }

    /**
     * 按钮配置DO对象转VO对象
     * @param tabButtonDO
     * @return
     */
    private PLTabButtonVO tabButton2TabButtonVO(PLTabButton tabButtonDO) throws PLException {
        PLTabButtonVO plTabButtonVO = new PLTabButtonVO();
        if(Func.isEmpty(tabButtonDO) && Func.isBlank(tabButtonDO.plOId)){
            return plTabButtonVO;
        }
        plTabButtonVO.setOId(tabButtonDO.plOId);
        plTabButtonVO.setTableOId(tabButtonDO.plTableOId);
        plTabButtonVO.setPageOId(tabButtonDO.plPageOId);
        plTabButtonVO.setActionOId(tabButtonDO.plActionOId);
        plTabButtonVO.setLabel(tabButtonDO.plLabel);
        plTabButtonVO.setAreaType(tabButtonDO.plAreaType);
        plTabButtonVO.setDesc(tabButtonDO.plDesc);
        plTabButtonVO.setSeq(tabButtonDO.plSeq);
        plTabButtonVO.setCreateUser(tabButtonDO.plCreateUser);
        plTabButtonVO.setCreateTime(tabButtonDO.plCreateTime);
        plTabButtonVO.setModifyUser(tabButtonDO.plModifyUser);
        plTabButtonVO.setModifyTime(tabButtonDO.plModifyTime);
        plTabButtonVO.setLicensOrs(tabButtonDO.plLicensOrs);
        plTabButtonVO.setParentOid(tabButtonDO.plParentOid);
        plTabButtonVO.setDisplayMode(tabButtonDO.displayMode);
        plTabButtonVO.setIconPath(tabButtonDO.iconPath);
        plTabButtonVO.setAuthorization(tabButtonDO.authorization);
        plTabButtonVO.setShow(tabButtonDO.show);
        //参数信息回填
        PLCommandParameter[] parameters = platformClientUtil.getUIService().getPLCommandParametersByCommandOId(tabButtonDO.plOId);
        if(Func.isNotEmpty(parameters)){
            LinkedHashMap<String, String> parameterMap = Arrays.stream(parameters)
                .collect(Collectors.toMap(
                        parm -> parm.plKey,
                        parm -> parm.plValue,
                        (existing, replacement) -> existing, // 处理重复键的情况
                        LinkedHashMap::new // 指定使用 LinkedHashMap
                ));
            plTabButtonVO.setButtonParams(parameterMap);
        }
        return plTabButtonVO;
    }

    /**
     * 按钮配置子节点查找
     * @param plOid
     * @param plTabButtonVOList
     * @return
     */
    private List<PLTabButtonVO> plTabButtonVO2Children(List<PLTabButtonVO> plTabButtonVOList, String plOid){
        ArrayList<PLTabButtonVO> plTabButtonVOS = new ArrayList<>();
        for (PLTabButtonVO plTabButtonVO : plTabButtonVOList) {
            if(StringUtils.isBlank(plTabButtonVO.getParentOid())){
                continue;
            }
            if(plTabButtonVO.getParentOid().equals(plOid)){
                plTabButtonVO.setChildren(plTabButtonVO2Children(plTabButtonVOList,plOid));
                plTabButtonVOS.add(plTabButtonVO);
            }
        }
        return plTabButtonVOS;
    }

    /**
     * 按钮配置VO对象转DO对象
     * @param tabButtonVO
     * @return
     * @throws PLException
     */
    private PLTabButton tabButtonVO2TabButton(PLTabButton plTabButton,PLTabButtonVO tabButtonVO) {
        plTabButton.plOId = tabButtonVO.getOId();
        plTabButton.plTableOId = tabButtonVO.getTableOId();
        plTabButton.plPageOId = tabButtonVO.getPageOId();
        plTabButton.plActionOId = tabButtonVO.getActionOId();
        plTabButton.plLabel = tabButtonVO.getLabel();
        plTabButton.plAreaType = tabButtonVO.getAreaType();
        plTabButton.plDesc = tabButtonVO.getDesc();
        plTabButton.plSeq = tabButtonVO.getSeq();
        plTabButton.plCreateUser = tabButtonVO.getCreateUser();
        plTabButton.plCreateTime = tabButtonVO.getCreateTime();
        plTabButton.plModifyUser = tabButtonVO.getModifyUser();
        plTabButton.plModifyTime = tabButtonVO.getModifyTime();
        plTabButton.plLicensOrs = tabButtonVO.getLicensOrs();
        plTabButton.plParentOid = tabButtonVO.getParentOid();
        plTabButton.displayMode = tabButtonVO.getDisplayMode();
        plTabButton.iconPath = tabButtonVO.getIconPath();
        plTabButton.authorization = tabButtonVO.getAuthorization();
        plTabButton.show = tabButtonVO.getShow();
        return plTabButton;
    }

    /**
     * 添加按钮配置信息
     * @param tabButtonVO
     * @return
     */
    @Override
    public BaseResult addTapButton(PLTabButtonVO tabButtonVO) {
        boolean res = this.saveOrUpdateTapButton(tabButtonVO, true);
        return res ? BaseResult.success("按钮配置添加成功！"):BaseResult.success("按钮配置添加失败！");
    }

    /**
     * 修改按钮配置信息
     * @param tabButtonVO
     * @return
     */
    @Override
    public BaseResult updateTapButton(PLTabButtonVO tabButtonVO) {
        boolean res = this.saveOrUpdateTapButton(tabButtonVO, false);
        return res ? BaseResult.success("按钮配置修改成功！"):BaseResult.success("按钮配置修改失败！");
    }

    /**
     * 保存或修改按钮配置信息
     * @param tabButtonVO
     * @return
     */
    @Override
    public boolean saveOrUpdateTapButton(PLTabButtonVO tabButtonVO,boolean isAdd){
        VciBaseUtil.alertNotNull(tabButtonVO,"按钮配置对象",tabButtonVO.getLabel(),"参数名称");
        //检查当前添加的列表是否重复，但是这儿只支持单条数据保存，所有当前列表判重可以前端来做
        //String btnParamValidate = this.geCheckRes();

        if (tabButtonVO.getSeq() < 1 || tabButtonVO.getSeq() > 63) {
            throw new VciBaseException("按序号超出范围，请修改，按钮【编号】只能在【1-63】范围内。");
        }
        //当前登录用户的信息
        SessionInfo sessionInfo = WebThreadLocalUtil.getCurrentUserSessionInfoInThread();
        //VO2DO
        PLTabButton plTabButton = this.tabButtonVO2TabButton(new PLTabButton(), tabButtonVO);
        if(isAdd) {
            //如果是增加操作，直接创建PLTabButton对象
            plTabButton.plOId = ObjectUtility.getNewObjectID36();
            plTabButton.plCreateUser = sessionInfo.getUserId();
            plTabButton.plModifyUser = sessionInfo.getUserId();
        } else {
            //修改操作
            plTabButton.plModifyUser = sessionInfo.getUserId();
        }

        try {
            if(isAdd){
                boolean success =  platformClientUtil.getUIService().savePLTabButton(plTabButton);
                if(success == false) {
                    throw new VciBaseException("编号重复，编号已经在当前页签下存在！");
                }
            } else if(!isAdd){
                platformClientUtil.getUIService().updatePLTabButton(plTabButton);
            }
        } catch (Exception e) {
            e.printStackTrace();
            String errorLog = "保存按钮信息时发生异常：" + e.getMessage();
            logger.error(errorLog);
            throw new VciBaseException(errorLog);
        }
        //复用以前的代码，对于参数一条一条删除，一条一条创建
        //数据量及并发较少，暂时这么处理没有什么问题
        if(!isAdd) {
            try {
                platformClientUtil.getUIService().deletePLCommandParameterByTabButtonId(plTabButton.plOId);
            } catch (PLException e) {
                e.printStackTrace();
            }
        }

        LinkedHashMap<String, String> buttonParams = tabButtonVO.getButtonParams();
        if(Func.isNotEmpty(buttonParams)) {
            Iterator<Map.Entry<String, String>> iterator = buttonParams.entrySet().iterator();
            while(iterator.hasNext()){
                Map.Entry<String, String> next = iterator.next();
                if(StringUtils.isEmpty(next.getKey()) || StringUtils.isEmpty(next.getValue())){
                    iterator.remove();
                }
            }
            Iterator<Map.Entry<String, String>> kvItor = buttonParams.entrySet().iterator();
            while(kvItor.hasNext()){
                Map.Entry<String, String> next = kvItor.next();
                PLCommandParameter plCommandParameter = new PLCommandParameter();
                plCommandParameter.plOId = ObjectUtility.getNewObjectID36();
                plCommandParameter.plCommandOId = plTabButton.plOId;
                plCommandParameter.plKey = next.getKey();
                plCommandParameter.plValue = next.getValue();
                plCommandParameter.plCreateUser = sessionInfo.getUserId();
                plCommandParameter.plModifyUser = sessionInfo.getUserId();
                try {
                    platformClientUtil.getUIService().savePLCommandParameter(plCommandParameter);
                } catch (PLException e) {
                    e.printStackTrace();
                    throw new VciBaseException("保存按钮信息时发生异常："+ e.getMessage());
                }
            }
        }
        return true;
    }

    /**
     * 删除单个按钮配置
     * @param tabButtonVO
     * @return
     */
    @Override
    public boolean deleteTapButton(PLTabButtonVO tabButtonVO) throws PLException {
        VciBaseUtil.alertNotNull(tabButtonVO,"删除的按钮配置对象");
        boolean success = platformClientUtil.getUIService().deletePLTabButton(this.tabButtonVO2TabButton(new PLTabButton(),tabButtonVO));
        if(success == false){
            throw new VciBaseException("该有子级按钮，不能删除！");
        }
        return true;
    }

    /**
     * 调整为下级按钮
     * @param tabButtonVO
     * @return
     */
    @Override
    public BaseResult joinBtn(PLTabButtonVO tabButtonVO) throws PLException {
        VciBaseUtil.alertNotNull(tabButtonVO,"需调整为下级按钮",tabButtonVO.getTableOId(),"当前按钮配置所在的页面主键");
        //同一页面下的按钮
        List<PLTabButtonVO> plTabButtons = this.getTabButtons(tabButtonVO.getTableOId());
        if(Func.isEmpty(plTabButtons)){
            return BaseResult.fail("未获取到按钮配置信息！");
        }
        //获取当前要移动的按钮的下标
        int index = 0;
        for (int i = 0; i < plTabButtons.size(); i++) {
            if (plTabButtons.get(i).getOId().equals(tabButtonVO.getOId())) {
                index = i; // 找到后记录下标
                break; // 找到后退出循环
            }
        }
        //当选择的按钮为树的第一个节点的时候，他的兄节点是他自己，导致调整为下级按钮时出错，故作此判断。
        if(index == 0){
            return BaseResult.fail("当前节点不存在兄节点，无法调整为下级按钮！");
        }
        //设置父id为上一个节点的
        tabButtonVO.setParentOid(plTabButtons.get(index-1).getOId());
        PLTabButton plTabButton = this.tabButtonVO2TabButton(new PLTabButton(), tabButtonVO);
        boolean success = platformClientUtil.getUIService().updatePLTabButton(plTabButton);
        if(success == false) {
            return BaseResult.fail("修改失败！");
        }
        return BaseResult.fail("修改成功！");
    }

    /**
     * 调整为上级按钮
     * @param tabButtonVO
     * @return
     */
    @Override
    public BaseResult exitBtn(PLTabButtonVO tabButtonVO) throws PLException {
        tabButtonVO.setParentOid("");
        PLTabButton plTabButton = this.tabButtonVO2TabButton(new PLTabButton(), tabButtonVO);
        boolean success = platformClientUtil.getUIService().updatePLTabButton(plTabButton);
        if(success == false) {
            BaseResult.fail("撤销失败！");
        }
        return BaseResult.success("撤销成功！");
    }

    /**
@@ -674,25 +1186,12 @@
    }

    /**
     * 删除页面定义
     * @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());
@@ -807,7 +1306,7 @@
          String userName= WebThreadLocalUtil.getCurrentUserSessionInfoInThread().getUserId();
            RoleRightInfo[] rightInfos= platformClientUtil.getFrameworkService().getRoleRightList(roleId,userName);
            List<RoleRightVO>  roleRightVOList=roleRightDOO2VOS(Arrays.asList(rightInfos));
            roleRightVOMap=roleRightVOList.stream().collect(Collectors.toMap(RoleRightVO::getFuncId,roleRightVO ->roleRightVO));
            roleRightVOMap=roleRightVOList.stream().collect(Collectors.toMap(RoleRightVO::getFuncId,roleRightVO ->roleRightVO,(oldValue,newOldValue)->oldValue));
        }
        BizType[] bizTypes=osBtmServiceI.getBizTypes(type);
        List<Tree> treeList=new ArrayList<>();
@@ -825,18 +1324,22 @@
            bizTypeTree.setShowCheckbox(true);
            bizTypeTree.setParentBtmName(bizTypes[i].name);
            childList.add(bizTypeTree);
            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);
            }
            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;
@@ -852,48 +1355,231 @@
        treeQueryObject.setConditionMap(conditionMap);
        List<Tree> treeList=this.getUIAuthor(treeQueryObject);
        HashMap<String,Tree> allTreeMap=new HashMap<>();
        Map<String,RoleRightDTO> 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 ->roleRightVOO2DTO(roleRightVO),(oldValue,newValue)->oldValue));
            }
            convertTreeDOO2Map(treeList,allTreeMap);
            List<RoleRightDTO> roleRightDTOList=new ArrayList<>();
            List<Tree>  selectTreeList= uiAuthorDTO.getSelectTreeList();
            getRoleRightDTOS(uiAuthorDTO.getRoleId(),selectTreeList,allTreeMap,roleRightDTOList);
            getSelectedRoleRightObjs(uiAuthorDTO.getRoleId(),selectTreeList,allTreeMap,roleRightVOMap,roleRightDTOList);
            SessionInfo sessionInfo = WebThreadLocalUtil.getCurrentUserSessionInfoInThread();
            String currentUserName = sessionInfo.getUserId();
            boolean isDeveloper= rightControlUtil.isDeveloper(currentUserName);
            List<RoleRightInfo>  roleRightInfoList= roleRightDTOO2InfoS(roleRightDTOList);
            UserEntityInfo info=new UserEntityInfo();
            info.modules="UI授权";
            info.userName=currentUserName;
            try {
             res= platformClientUtil.getFrameworkService().saveRoleRight(roleRightInfoList.toArray(new RoleRightInfo[]{}),uiAuthorDTO.getRoleId(),currentUserName,info);
            }catch (PLException e){
                throw  new Exception("保存失败："+e.getMessage());
            }
        }
        return res;
    }

    private void getRoleRightDTOS(String roleOid,List<Tree>  selectTreeList,HashMap<String,Tree> allTreeMap,  List<RoleRightDTO> roleRightDTOList){
        selectTreeList.stream().forEach(tree -> {
            RoleRightDTO roleRightDTO=new RoleRightDTO();
            String id=ObjectUtility.getNewObjectID36();
            Object data=  tree.getData();
    /**
     *根据权限计算上下权限
     * @param roleOid
     * @param selectTreeList
     * @param allTreeMap
     * @param roleRightDTOList
     */
    private void getSelectedRoleRightObjs(String roleOid,List<Tree>  selectTreeList,HashMap<String,Tree> allTreeMap,Map<String,RoleRightDTO> allRoleRightDTOMap,  List<RoleRightDTO> roleRightDTOList){
        Date date=new Date();
        Map<String,RoleRightDTO> roleRightDTOMap=new HashMap<>();
        if(!CollectionUtil.isEmpty(selectTreeList)){
            selectTreeList.stream().forEach(tree -> {
                String oid=tree.getOid();
                if(allTreeMap.containsKey(oid)){
                    tree=   allTreeMap.get(oid);
                   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) {//按钮
                        String parrentId=tree.getParentId();
                        if(allTreeMap.containsKey(parrentId)){
                            SessionInfo sessionInfo = WebThreadLocalUtil.getCurrentUserSessionInfoInThread();
                            String currentUserName = sessionInfo.getUserId();
                            boolean isDeveloper= rightControlUtil.isDeveloper(currentUserName);
                            Tree parentNode= allTreeMap.get(parrentId);
                            String funcId = parentNode.getOid();
                            getRightValue(roleOid,tree, allTreeMap, true, roleRightDTOMap);//向上处理该操作父级的上级模块权限(不包含父节点)
                            if(!roleRightDTOMap.containsKey(funcId)){
                                RoleRightDTO roleRightDTO = new RoleRightDTO();
                                roleRightDTO.setId(ObjectUtility.getNewObjectID36());//主键
                                roleRightDTO.setFuncId(funcId);
                                if(isDeveloper) {
                                    roleRightDTO.setRightType((short) 1);//权限类型 权限类型，超级管理员给管理员授权为1，管理员给普通用户授权为2
                                }else{
                                    roleRightDTO.setRightType((short) 2);
                                }
                                roleRightDTO.setRightValue(1);// 权限值，没有操作的模块权限值存储为0
                                roleRightDTO.setRoleId(roleOid);//角色ID
                                roleRightDTO.setCreateUser(currentUserName);//创建者
                                roleRightDTO.setCreateTime(VciDateUtil.date2Str(new Date(),""));//创建时间
                                roleRightDTO.setModifyUser(currentUserName);//修改者
                                roleRightDTO.setModifyTime(VciDateUtil.date2Str(new Date(),""));//修改时间
                                roleRightDTO.setLicensor("");
                                if(!roleRightDTOMap.containsKey(funcId)){
                                    roleRightDTOMap.put(funcId, roleRightDTO);
                                }
                                roleRightDTOMap.put(funcId, roleRightDTO);
                            }
                        }

            if (data instanceof BizType) {//业务类型
                BizType bizType=(BizType)data;
                roleRightDTO.setId(id);//主键
                roleRightDTO.setCreateUser(null);//创建者
                roleRightDTO.setCreateTime(null);//创建时间
                roleRightDTO.setModifyUser(null);//修改者
                roleRightDTO.setModifyTime(null);//修改时间
                roleRightDTO.setRoleId(roleOid);//角色ID
                roleRightDTO.setRightValue(1);// 权限值
                roleRightDTO.setRightType((short) -1);//权限类型 权限类型，超级管理员给管理员授权为1，管理员给普通用户授权为2
                roleRightDTO.setFuncId(null);
                roleRightDTO.setLicensor(null);
            }else  if (data instanceof PLUILayout){//UI
                    }

            }else if (data instanceof PLTabPage) {//UI上下文
                }
            });
          /*  allRoleRightDTOMap.putAll(roleRightDTOMap.entrySet().stream()
                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::  getValue)));*/
         List<RoleRightDTO>    newRoleRightDTOList=Optional.ofNullable(roleRightDTOMap).orElseGet(()->new HashMap<String,RoleRightDTO>()).values().stream().collect(Collectors.toList());
            roleRightDTOList.addAll(newRoleRightDTOList);
        }
    }


            }else if (data instanceof PLPageDefination) {//


            }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 id=ObjectUtility.getNewObjectID36();
        Object data=node.getData();
        if(isUp) {//向上获取，存储每个上级模块的权限值
            while (!"root".equals(node.getData())){
                data=node.getData();
               String oid=node.getOid();
                if(allTreeMap.containsKey(oid)){
                    String funcId = "";
                    if (data instanceof BizType) {
                        BizType bizType = (BizType) data;
                        funcId = bizType.name;
                    } else if (data instanceof PLUILayout) {
                        PLUILayout context = (PLUILayout)data;
                        funcId = context.plOId;
                    } else if (data instanceof PLTabPage) {
                        PLTabPage tab = (PLTabPage) data;
                        funcId = tab.plOId;
                    } else if (data instanceof PLPageDefination){
                        PLPageDefination pageDef = (PLPageDefination) data;
                        funcId = pageDef.plOId;
                    } else if (data instanceof PLTabButton) {
                        PLTabButton but = (PLTabButton)data;
                        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(VciDateUtil.date2Str(new Date(),""));//创建时间
                    roleRightDTO.setModifyUser(currentUserName);//修改者
                    roleRightDTO.setModifyTime(VciDateUtil.date2Str(new Date(),""));//修改时间
                    roleRightDTO.setLicensor("");
                    if(!rightMap.containsKey(funcId)){
                        rightMap.put(funcId, roleRightDTO);
                    }
                    oid= node.getParentId();
                    if(allTreeMap.containsKey(oid)) {
                        node=allTreeMap.get(oid);
                    }
                }
            }
        });
        }else {
            String funcId = "";
            if (data instanceof String) {
                funcId = (String) data;
            } else if (data instanceof BizType) {
                BizType bizType = (BizType) data;
                funcId = bizType.name;
            } else if (data instanceof PLUILayout) {
                PLUILayout context = (PLUILayout) data;
                funcId = context.plOId;
            } else if (data instanceof PLTabPage) {
                PLTabPage tab = (PLTabPage) data;
                funcId = tab.plOId;
            } else if (data instanceof PLPageDefination) {
                PLPageDefination pageDef = (PLPageDefination) data;
                funcId = pageDef.plOId;
            } else if (data instanceof PLTabButton) {
                PLTabButton but = (PLTabButton) data;
                funcId = but.plOId;
            }
            if (!(data 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(VciDateUtil.date2Str(new Date(),""));
                    roleRightDTO.setModifyUser(currentUserName);
                    roleRightDTO.setModifyTime(VciDateUtil.date2Str(new Date(),""));
                    roleRightDTO.setLicensor("");
                    rightMap.put(funcId, roleRightDTO);
                }
                for (int i = 0; i < node.getChildren().size(); i++) {
                    //对每个子向下递归遍历
                    getRightValue(roleId, node.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(node, true));//没有操作的模块权限值存储为0
                    roleRightDTO.setRoleId(roleId);

                    roleRightDTO.setCreateUser(currentUserName);
                    roleRightDTO.setCreateTime(VciDateUtil.date2Str(new Date(),""));
                    roleRightDTO.setModifyUser(currentUserName);
                    roleRightDTO.setModifyTime(VciDateUtil.date2Str(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;
    }

    /**
@@ -910,6 +1596,14 @@
            }
        });
    }

    /***
     * 遍历子节点
     * @param parentTree
     * @param contextList
     * @param roleRightVOMap
     * @param isShowCheckBox
     */
    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();
@@ -1026,6 +1720,25 @@
            }
        });
    }


    /**
     * UI角色对象转换
     * @param vos
     * @return
     */
    private List<RoleRightDTO> roleRightVOO2DTOS(List<RoleRightVO> vos){
        List<RoleRightDTO> roleRightVOS=new ArrayList<>();
        Optional.ofNullable(vos).orElseGet(()->new ArrayList<>()).stream().forEach(vo -> {
            RoleRightDTO dto=roleRightVOO2DTO(vo);
            roleRightVOS.add(dto);
        });

        return roleRightVOS;
    }



    /**
     * UI角色对象转换
     * @param infos
@@ -1040,7 +1753,25 @@

        return roleRightVOS;
    }
    /**
     * UI角色对象转换
     * @param dtos
     * @return
     */
    private List<RoleRightInfo> roleRightDTOO2InfoS(List<RoleRightDTO> dtos){
        List<RoleRightInfo> roleRightInfoList=new ArrayList<>();
        Optional.ofNullable(dtos).orElseGet(()->new ArrayList<>()).stream().forEach(dto -> {
            RoleRightInfo info= null;
            try {
                info = roleRightDTOO2Info(dto);
            } catch (Exception e) {
                e.printStackTrace();
            }
            roleRightInfoList.add(info);
        });

        return roleRightInfoList;
    }
    /**
     * UI角色对象转换
     * @param info
@@ -1059,6 +1790,45 @@
        vo.setModifyTime(VciDateUtil.date2Str(VciDateUtil.long2Date(info.modifyTime),""));
        vo.setModifyUser(info.modifyUser);
        return vo;
    }
    /**
     * UI角色对象转换
     * @param vo
     * @return
     */
    private RoleRightDTO  roleRightVOO2DTO(RoleRightVO vo){
        RoleRightDTO dto=new RoleRightDTO();
        dto.setId(vo.getId());
        dto.setCreateTime(vo.getCreateTime());
        dto.setCreateUser(vo.getCreateUser());
        dto.setRoleId(vo.getRoleId());
        dto.setRightType(vo.getRightType());
        dto.setLicensor(vo.getLicensor());
        dto.setRightValue(vo.getRightValue());
        dto.setFuncId(vo.getFuncId());
        dto.setModifyTime(vo.getModifyTime());
        dto.setModifyUser(vo.getModifyUser());
        return dto;
    }

    /**
     * UI角色对象转换
     * @param dto
     * @return
     */
    private RoleRightInfo  roleRightDTOO2Info(RoleRightDTO dto) throws Exception {
        RoleRightInfo info=new RoleRightInfo();
        info.id=StringUtils.isBlank(dto.getId())?"":dto.getId();
        info.createTime=StringUtils.isBlank(dto.getCreateTime())?new Date().getTime():VciDateUtil.getTime(VciDateUtil.str2Date(dto.getCreateTime(),""));
        info.createUser=StringUtils.isBlank(dto.getCreateUser())?"":dto.getCreateUser();
        info.roleId=StringUtils.isBlank(dto.getRoleId())?"":dto.getRoleId();
        info.rightType=dto.getRightType();
        info.licensor =StringUtils.isBlank(dto.getLicensor())?"":dto.getLicensor();
        info.rightValue=dto.getRightValue();
        info.funcId=StringUtils.isBlank(dto.getFuncId())?"":dto.getFuncId();
        info.modifyTime=StringUtils.isBlank(dto.getModifyTime())? new Date().getTime() :VciDateUtil.getTime(VciDateUtil.str2Date(dto.getModifyTime(),""));
        info.modifyUser=StringUtils.isBlank(dto.getModifyUser())?"":dto.getModifyUser();
        return info;
    }

    /**
@@ -1199,13 +1969,14 @@

        /**
         * 非空检查
         * @param tip
         * @param txt
         * @param tip 提示信息
         * @param txt 校验的内容
         * @param isRequired 是否必填
         * @return
         */
        protected boolean checkRequiredIsOk(String tip, String txt){
        protected boolean checkRequiredIsOk(String tip, String txt,boolean isRequired/*是否必填*/){
            boolean res = false;
            if(Func.isBlank(txt)){
            if(Func.isBlank(txt) && isRequired){
                throw new VciBaseException(tip + " 不能为空！");
            } else {
                res = true;
@@ -1219,11 +1990,11 @@
         * @param btmName 业务类型名
         * @return
         */
        protected boolean checkBtmTypeTxtIsOk(String tipName, String btmName) throws PLException {
        protected boolean checkBtmTypeTxtIsOk(String tipName, String btmName,boolean isRequired) throws PLException {
            boolean res = false;
            if(tipName == null) return true;
            if(btmName == null) return true;
            if(!checkRequiredIsOk(tipName, btmName)){
            if(!checkRequiredIsOk(tipName, btmName, isRequired)){
                res = false;
            } else if(!checkBtmNameIsExist(tipName, btmName)){
                res = false;
@@ -1275,11 +2046,11 @@
         * @param btmLinkType
         * @return
         */
        protected boolean checkPortalVITxtIsOk(String tip, String txtVIName, String btmLinkType) throws PLException {
        protected boolean checkPortalVITxtIsOk(String tip, String txtVIName, String btmLinkType, boolean isRequired) throws PLException {
            boolean res = false;
            if(tip == null) return true;
            if(txtVIName == null) return true;
            if(!checkRequiredIsOk(tip, txtVIName)){
            if(!checkRequiredIsOk(tip, txtVIName,isRequired)){
                res = false;
            } else if(!checkPortalVIIsExist(tip, txtVIName, btmLinkType)){
                res = false;
@@ -1318,13 +2089,13 @@
         * @param btmLinkType
         * @return
         */
        protected boolean checkQTNameTxtIsOk(String tip, String txtQTName, String btmLinkType) throws PLException {
        protected boolean checkQTNameTxtIsOk(String tip, String txtQTName, String btmLinkType, boolean isRequired) throws PLException {
            boolean res = false;
            if(tip == null) return true;
            if(txtQTName == null) return true;
            if(!checkRequiredIsOk(tip, txtQTName)){
            if(!checkRequiredIsOk(tip, txtQTName, isRequired)){
                res = false;
            } else if(Func.isBlank(txtQTName) && !checkQTIsExist(tip, txtQTName, btmLinkType)){
            } else if(Func.isNotBlank(txtQTName) && !checkQTIsExist(tip, txtQTName, btmLinkType)){
                res = false;
            } else {
                res = true;
@@ -1339,11 +2110,11 @@
         * @param btmLinkType
         * @return
         */
        protected boolean checkUILayoutTxtIsOk(String tip, String uiName, String btmLinkType) throws PLException {
        protected boolean checkUILayoutTxtIsOk(String tip, String uiName, String btmLinkType, boolean isRequired) throws PLException {
            boolean res = false;
            if(tip == null) return true;
            if(uiName == null) return true;
            if(!checkRequiredIsOk(tip, uiName)){
            if(!checkRequiredIsOk(tip, uiName,isRequired)){
                res = false;
            } else if(!checkUILayoutIsExist(tip, uiName, btmLinkType)){
                res = false;
@@ -1397,11 +2168,11 @@
         * @param linkTypeName
         * @return
         */
        protected boolean checkLinkTypeTxtIsOk(String tip, String linkTypeName) throws PLException {
        protected boolean checkLinkTypeTxtIsOk(String tip, String linkTypeName, boolean isRequired) throws PLException {
            boolean res = false;
            if(tip == null) return true;
            if(linkTypeName == null) return true;
            if(!checkRequiredIsOk(tip, linkTypeName)){
            if(!checkRequiredIsOk(tip, linkTypeName,isRequired)){
                res = false;
            } else if(!checkLinkTypeIsExist(tip, linkTypeName)){
                res = false;
@@ -1545,11 +2316,11 @@
         */
        private boolean checkBtmTypeInputIsOk(String btmType,String txtVIName/*选择模板*/,String txtQTName/*查询模板*/) throws PLException {
            boolean res = false;
            if(!super.checkBtmTypeTxtIsOk("业务类型", btmType)){
            if(!super.checkBtmTypeTxtIsOk("业务类型", btmType,true)){
                res = false;
            } else if(!super.checkPortalVITxtIsOk("选择模板", txtVIName, btmType)){
            } else if(!super.checkPortalVITxtIsOk("选择模板", txtVIName, btmType,true)){
                res = false;
            } else if(!super.checkQTNameTxtIsOk("查询模板", txtQTName, btmType)){
            } else if(!super.checkQTNameTxtIsOk("查询模板", txtQTName, btmType,false)){
                res = false;
            } else {
                res = true;
@@ -1566,11 +2337,11 @@
         */
        private boolean checkLinkTypeInputIsOk(String txtVIName/*选择的模板*/,String txtQTName/*查询模板*/,String btmType) throws PLException {
            boolean res = false;
            if(!(this.checkBtmTypeTxtIsOk("目标对象", linkType))){
            if(!(this.checkBtmTypeTxtIsOk("目标对象", linkType,true))){
                res = false;
            } else if(!(this.checkPortalVITxtIsOk("选择模板", txtVIName, linkType))){
            } else if(!(this.checkPortalVITxtIsOk("选择模板", txtVIName, linkType,true))){
                res = false;
            } else if(!(this.checkQTNameTxtIsOk("查询模板", txtQTName, linkType))){
            } else if(!(this.checkQTNameTxtIsOk("查询模板", txtQTName, linkType,false))){
                res = false;
            } else {
                res = true;
@@ -1650,11 +2421,11 @@

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

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

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

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

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