package com.vci.frameworkcore.compatibility.impl;

import com.vci.common.exception.VciException;
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.*;
import com.vci.frameworkcore.compatibility.SmHMSysModConfigServiceI;
import com.vci.pagemodel.*;
import com.vci.starter.poi.bo.SheetDataSet;
import com.vci.starter.poi.bo.SheetRowData;
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.constant.VConstant;
import com.vci.starter.web.exception.VciBaseException;
import com.vci.starter.web.pagemodel.BaseResult;
import com.vci.starter.web.pagemodel.SessionInfo;
import com.vci.starter.web.util.LocalFileUtil;
import com.vci.starter.web.util.VciBaseUtil;
import com.vci.starter.web.util.WebThreadLocalUtil;
import com.vci.starter.web.redis.RedisService;
import com.vci.web.util.Func;
import com.vci.web.util.PlatformClientUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 首页系统模块配置添加按钮、添加操作类型等接口服务
 * @author ludc
 * @date 2024/8/19 12:42
 */
@Service
public class SmHMSysModConfigServiceImpl implements SmHMSysModConfigServiceI {

    @Autowired
    private PlatformClientUtil platformClientUtil;

    private List<FunctionInfo> fileFunctionDatas = new ArrayList<FunctionInfo>();

    private int count = 0;

    /**
     * 包含保存模块方法等操作类
     */
    private static FunctionOperateDelegate foDelegate;

    /**
     * 初始化foDelegate
     */
    {
        if(Func.isEmpty(foDelegate)){
            foDelegate = new FunctionOperateDelegate();
        }
    }

    @Autowired
    private RedisService redisService;

    /**
     * 日志
     */
    private Logger logger = LoggerFactory.getLogger(getClass());

    /**
     * 添加模块
     * @param menuVO
     * @return
     */
    @Override
    public MenuVO addModule(MenuVO menuVO) throws VciBaseException {
        VciBaseUtil.alertNotNull(menuVO,"新增的模块对象");
        try {
            //往数据库里插入新建模块数据
            String puid = foDelegate.saveModule(menuVO);
            /**
             * 返回值：1，表示模块名称重复
             * 		   2，表示模块标识重复
             *         3, 模板别名存在重复
             */
            if(puid.equals("1")){
                throw new VciBaseException("模块名称重复，请修改！");
            }else if(puid.equals("2")){
                throw new VciBaseException("模块标识重复，请修改！");
            }else if(puid.equals("3")) {
                throw new VciBaseException("模块别名重复，请修改！");
            }
            menuVO.setId(puid);
            return menuVO;
        } catch (Exception e) {
            e.printStackTrace();
            String exceptionMessage = VciBaseUtil.getExceptionMessage(e);
            logger.error(exceptionMessage);
            throw new VciBaseException(exceptionMessage);
        }
    }

    /**
     * 修改模块
     * @param menuVO
     * @return
     */
    @Override
    public MenuVO updateModule(MenuVO menuVO) throws VciBaseException {
        VciBaseUtil.alertNotNull(menuVO,"修改的模块对象");
        try {
            String res = "";
            //更新数据库
            res = foDelegate.updateMod(menuVO);
            /**
             * 返回：1表示模块名重复。
             *       2表示模块标识重复。
             *       3标示模块别名重复。
             */
            if(res.equals("1")){
                throw new VciBaseException("模块名称重复，请修改！");
            }else if(res.equals("2")){
                throw new VciBaseException("模块标识重复，请修改！");
            }else if(res.equals("3")) {
                throw new VciBaseException("模块别名重复，请修改！");
            }/* else if (res.equals("4")) {
                throw new VciBaseException("模块编号重复，请修改！");
            }*/
            return menuVO;
        } catch (VciBaseException e) {
            e.printStackTrace();
            String exceptionMessage = VciBaseUtil.getExceptionMessage(e);
            logger.error(exceptionMessage);
            throw new VciBaseException(exceptionMessage);
        }
    }

    /**
     * 删除模块
     * @param menuVO
     * @return
     */
    @Override
    public boolean delModule(MenuVO menuVO) {
        VciBaseUtil.alertNotNull(menuVO,"添加操作类型的列表");
        String res = "";
        try {
            String puid = "";
            if("FunctionObject".equals(menuVO.getModeType())) {
                puid = menuVO.getId();
            }else if("modelManagmentNode".equals(menuVO.getId())) {
                puid = "modelManagmentNode";
            }else if("systemManagmentNode".equals(menuVO.getId())) {
                puid = "systemManagmentNode";
            }
            if(Func.isBlank(puid)){
                throw new VciBaseException("未找到要删除的模块！");
            }
            res = foDelegate.deleteModule(puid);
            /**
             * 返回值：1表示模块在权限模块已经有授权信息，无法删除
             */
            if(res.equals("1")){
               throw new VciBaseException("当前模块（或下级模块）已经存在授权信息，无法删除。");
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            String exceptionMessage = VciBaseUtil.getExceptionMessage(e);
            logger.error(exceptionMessage);
            throw new VciBaseException(exceptionMessage);
        }
    }

    /**
     * 删除模块下关联的操作类型
     * @param funcOperationInfo
     * @return
     */
    @Override
    public boolean delFuncOperation(FuncOperationInfo funcOperationInfo) {
        VciBaseUtil.alertNotNull(funcOperationInfo,"删除的操作类型列表");
        return foDelegate.deleteFuncOperation(funcOperationInfo);
    }

    /**
     * 增加操作类型
     * @return
     */
    @Override
    public boolean addFuncOperationType(List<FuncOperationInfo> funcOperationInfoList) {
        VciBaseUtil.alertNotNull(funcOperationInfoList,"添加的操作类型列表");//将操作类型组装成需要存储的对象
        List<FuncOperationInfo> objs = new ArrayList<>();
        funcOperationInfoList.stream().forEach(info -> {
            if(Func.isBlank(info.funcId)){
                throw new VciBaseException("父id不能为空！");
            }
            if(Func.isBlank(info.operId)){
                throw new VciBaseException("未获取操作名称！");
            }
            info.number = -1;
            info.isValid = true;
            objs.add(info);
        });

        //执行保存
        boolean res = true;
        try {
            res = this.saveFuncOperation(objs.toArray(new FuncOperationInfo[objs.size()]));
        } catch (Exception e) {
            res = false;
            e.printStackTrace();
            String exceptionMessage = "增加操作类型失败，原因：" + VciBaseUtil.getExceptionMessage(e);
            logger.error(exceptionMessage);
            throw new VciBaseException(exceptionMessage);
        }
        return res;
    }

    /**
     * 增加操作类型
     * @return
     */
    @Override
    public OperateInfo addOperationType(OperateInfo operateInfo) throws VciBaseException {
        try {
            //校验
            this.checkItem(operateInfo);
            String s = foDelegate.saveOperate(operateInfo);
            /**返回1表示名称有重复，返回2表示标识有重复,返回3表示顺序有重复**/
            if (s.equals("1")) {
                throw new VciBaseException("名称存在重复！");
            } else if (s.equals("2")) {
                throw new VciBaseException("标识存在重复！");
            } else if (s.equals("3")) {
                throw new VciBaseException("顺序存在重复！");
            }
            operateInfo.id = s;
            return operateInfo;
        }catch (Exception e) {
            e.printStackTrace();
            String exceptionMessage = VciBaseUtil.getExceptionMessage(e);
            logger.error(exceptionMessage);
            throw new VciBaseException(exceptionMessage);
        }
    }

    /**
     * 修改操作类型
     * @param operateInfo
     * @return
     */
    @Override
    public OperateInfo updateOperationType(OperateInfo operateInfo) throws VciBaseException {
        try {
            this.checkItem(operateInfo);
            String res = foDelegate.updateOperate(operateInfo);
            /**返回1表示名称有重复，返回2表示标识有重复,返回3表示顺序有重复**/
            if (res.equals("1")) {
                throw new VciBaseException("名称存在重复！");
            } else if (res.equals("2")) {
                throw new VciBaseException("标识存在重复！");
            } else if (res.equals("3")) {
                throw new VciBaseException("顺序存在重复！");
            }
            return operateInfo;
        } catch (Exception e) {
            e.printStackTrace();
            String exceptionMessage = VciBaseUtil.getExceptionMessage(e);
            logger.error(exceptionMessage);
            throw new VciBaseException(exceptionMessage);
        }
    }

    /**
     * 删除操作类型
     * @param operateInfo
     * @return
     */
    @Override
    public boolean delOperationType(OperateInfo operateInfo) throws VciBaseException {
        try {
            /**检查当前操作是否被引用,0表示无引用，1表示被模块引用，2表示已有权限信息**/
            int res = foDelegate.checkOperateIsReferenced(operateInfo.id);
            if(res == 1){
                throw new VciBaseException("当前操作已被模块引用，删除该操作的同时会将其从模块下移除，确认执行删除吗？");
            }else if(res == 2){
                throw new VciBaseException("当前操作已经在权限模块被分配过权限，删除该操作的同时会将其从用户的权限中移除，确认执行删除吗？");
            }
            return foDelegate.deleteOperate(operateInfo.id);
        } catch (VciBaseException e) {
            e.printStackTrace();
            String exceptionMessage = VciBaseUtil.getExceptionMessage(e);
            logger.error(exceptionMessage);
            throw new VciBaseException(exceptionMessage);
        }
    }

    /**
     * 校验
     * @param operateInfo
     * @return
     */
    private void checkItem(OperateInfo operateInfo) {
        if (Func.isBlank(operateInfo.name)) {
            throw new VciBaseException("名称不能为空！");
        }
        if (Func.isBlank(operateInfo.identify)) {
            throw new VciBaseException("标识不能为空！");
        }
        if (Func.isBlank(operateInfo.alias)) {
            throw new VciBaseException("别名不能为空！");
        }
        /*if (operateInfo.seq > -1){
            throw new VciBaseException("请输入正确的操作顺序值！");
        }*/
        /*long seq = operateInfo.seq;
        Pattern pattern = Pattern.compile("[0-9]*");
        Matcher isNum = pattern.matcher(seq);
        if( !isNum.matches() ){
            throw new VciBaseException("操作的顺序值只能是[0-9]之间的数字,并且必须是正整数.\n长度不允许输入小数或者负数!");
        }*/
        if (operateInfo.name.length() > 128) {
            throw new VciBaseException("名称长度不能超过128！");
        }
        if (operateInfo.desc.length() > 255) {
            throw new VciBaseException("描述长度不能超过255！");
        }
        if (operateInfo.alias.length() > 128) {
            throw new VciBaseException("别名长度不能超过255！");
        }
    }

    /**
     * 删除非系统模块
     * @return
     */
    @Override
    public boolean delNonsysModule() {
        try {
            if(platformClientUtil.getFrameworkService().deleteModules("nonsys")){
                return true;
            }
        } catch (PLException e) {
            e.printStackTrace();
            String exceptionMessage = "删除非系统模块失败,原因："+VciBaseUtil.getExceptionMessage(e);
            logger.error(exceptionMessage);
            throw new VciBaseException(exceptionMessage);
        }
        return false;
    }

    /**
     * 删除业务模块
     * @return
     */
    @Override
    public boolean delBusinessModule() {
        try {
            if(platformClientUtil.getFrameworkService().deleteModules("business")){
                return true;
            }
        } catch (PLException e) {
            e.printStackTrace();
            String exceptionMessage = "删除业务模块失败,原因："+VciBaseUtil.getExceptionMessage(e);
            logger.error(exceptionMessage);
            throw new VciBaseException(exceptionMessage);
        }
        return false;
    }

    /**
     * 导出sql
     * @return
     */
    @Override
    public File exportFunctionSql(HttpServletResponse response,String exportPath,boolean isFunction) throws PLException {
        String dir = Func.isBlank(exportPath) ?  LocalFileUtil.getDefaultTempFolder():exportPath;
        String[][] allDatas;
        int size;
        if(isFunction){
            size = (int)platformClientUtil.getFrameworkService().getAllModelManagementNum();
            allDatas = this.getAllDatas(size);
        }else{
            size = (int)platformClientUtil.getFrameworkService().getAllOperitionsNum();
            allDatas = this.getAllOperitions(size);
        }
        File file = expData(dir,isFunction, allDatas);
        return file;
    }

    /**
     * 导出
     * @return
     */
    @Override
    public String exportModule(HttpServletResponse response) throws IOException {
        String defaultTempFolder = LocalFileUtil.getDefaultTempFolder();
        //写excel
        String excelPath = defaultTempFolder + File.separator + "module.xls";
        final List<String> columns = new ArrayList<String>(Arrays.asList("PLNAME","PLRESOURCEC","PLSUFFIXC","PLRESOURCEB",
                "PLSUFFIXB","PLDESC","PLISVALID","PLIMAGE","PLMODULESEQUENCE","PLALIASNAME",
                "PLMODULENAME","PLRESOURCEDOTNET","PLRESOURCEMOBIL","级别","别名","PLNO","PLISVALID",
                "PLNAME","PLUNIQUEFLAG","PLDESC","PLALIAS","PLSEQUENCE"));// 设置表单列名
        //int count = transmitTreeObject.getCurrentTreeNode().getChildCount();
        new File(excelPath).createNewFile();
        //设置列
        List<WriteExcelData> excelDataList = new ArrayList<>(10000);
        //设置列头
        for (int index = 0; index < columns.size(); index++) {
            excelDataList.add(new WriteExcelData(0,index, columns.get(index)));
        }
        //查询要导出的数据
        String[][] firstLevel = new String[3000][23];
        try {
            firstLevel = this.checkLevel();
        } catch (VciBaseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        String[][] datas = new String[10000][columns.size()];
        for(int i=0;i<firstLevel.length;i++){
            datas[i] =firstLevel[i];
        }
        if(Func.isEmpty(datas)){
            excelDataList.add(new WriteExcelData(1,1, "导出的列表为空，请刷新后尝试重新导出！"));
        }else{
            for (int i = 0; i < firstLevel.length; i++) {
                int row = i + 1;
                excelDataList.add(new WriteExcelData(row,0, ""+datas[i][0]));
                excelDataList.add(new WriteExcelData(row,1, ""+datas[i][1]));
                excelDataList.add(new WriteExcelData(row,2, ""+datas[i][2]));
                excelDataList.add(new WriteExcelData(row,3, ""+datas[i][3]));
                excelDataList.add(new WriteExcelData(row,4, ""+datas[i][4]));
                excelDataList.add(new WriteExcelData(row,5, ""+datas[i][5]));
                excelDataList.add(new WriteExcelData(row,6, ""+datas[i][6]));
                excelDataList.add(new WriteExcelData(row,7, ""+datas[i][7]));
                excelDataList.add(new WriteExcelData(row,8, ""+datas[i][8]));
                excelDataList.add(new WriteExcelData(row,9,""+datas[i][9]));
                excelDataList.add(new WriteExcelData(row,10,""+datas[i][10]));
                excelDataList.add(new WriteExcelData(row,11,""+datas[i][11]));
                excelDataList.add(new WriteExcelData(row,12,""+datas[i][12]));
                excelDataList.add(new WriteExcelData(row,13,""+datas[i][13]));
                excelDataList.add(new WriteExcelData(row,14,""+datas[i][14]));
                excelDataList.add(new WriteExcelData(row,15,""+datas[i][15]));
                excelDataList.add(new WriteExcelData(row,16,""+datas[i][16]));
                excelDataList.add(new WriteExcelData(row,17,""+datas[i][17]));
                excelDataList.add(new WriteExcelData(row,18,""+datas[i][18]));
                excelDataList.add(new WriteExcelData(row,19,""+datas[i][19]));
                excelDataList.add(new WriteExcelData(row,20,""+datas[i][20]));
                excelDataList.add(new WriteExcelData(row,21,""+datas[i][21]));
            }
        }
        WriteExcelOption excelOption = new WriteExcelOption(excelDataList);
        ExcelUtil.writeDataToFile(excelPath, excelOption);
        return excelPath;
    }

    /**
     * 导入
     * @param files
     * @return
     * @throws PLException
     */
    @Override
    public BaseResult importModule(LinkedList<File> files) throws PLException, IOException {
        logger.info("正在收集表单数据......");
        boolean isSuccess = collectionDatas(files);
        logger.info("正在导入表单人员信息......");
        logger.info("count==="+count);
        if(isSuccess == false){
            isSuccess = importExcelData(count);
        }
        return isSuccess ? BaseResult.success("导入成功！"):BaseResult.fail("导入失败！");
    }

    /**
     * 管理功能模块、业务功能模块下的叶子节点—修改操作别名接口
     * @return
     */
    @Override
    public boolean updateAlias(MenuVO menuVO) throws VciBaseException {
        String alias = menuVO.getAlias();
        if ("".equals(alias)){
            throw new VciBaseException("请填写操作别名!");
        }
        boolean isValid = menuVO.getIsValid();
        String id = menuVO.getId();
        return foDelegate.updateFuncOperation(id , alias, isValid);
    }

    /**
     * 查询系统配置树
     * @return
     */
    @Override
    public List<AppConfigCategoryInfo> getAppConfigCategoryInfo() {
        try {
            AppConfigCategoryInfo[] appConfigCategorys = foDelegate.getAppConfigCategorys();
            return Arrays.asList(appConfigCategorys);
        } catch (VciBaseException e) {
            e.printStackTrace();
            String exceptionMessage = VciBaseUtil.getExceptionMessage(e);
            logger.error(exceptionMessage);
            throw new VciBaseException(exceptionMessage);
        }
    }

    /**
     * 根据分类ID返回全部的 AppConfigDetail 对象
     * @return
     */
    @Override
    public List<AppConfigDetailInfo> getAppConfigDetailsByID(String clsId) {
        try {
            AppConfigDetailInfo[] appConfigDetailInfos = foDelegate.getAppConfigDetailsByID(clsId);
            return Arrays.asList(appConfigDetailInfos);
        } catch (VciBaseException e) {
            e.printStackTrace();
            String exceptionMessage = VciBaseUtil.getExceptionMessage(e);
            logger.error(exceptionMessage);
            throw new VciBaseException(exceptionMessage);
        }
    }

    /**
     * 增加配置项分类或配置项
     * @return
     */
    @Override
    public boolean addAppConf(AppConfigDetailInfo appConfigDetailInfo,boolean isConfCategorys/*是否为操作配置项分配*/) {
        VciBaseUtil.alertNotNull(appConfigDetailInfo,"添加的操作类型");
        boolean rs = false;
        try {
            String id = "";
            if(isConfCategorys){
                AppConfigCategoryInfo appConfigCategoryInfo = new AppConfigCategoryInfo();
                appConfigCategoryInfo.name = appConfigDetailInfo.name;
                appConfigCategoryInfo.desc = appConfigDetailInfo.desc;
                this.checkConf(appConfigCategoryInfo);
                id = foDelegate.saveAppConfigCategory(appConfigCategoryInfo);
            }else{
                this.checkConfItem(appConfigDetailInfo);
                id = foDelegate.saveAppConfigDetail(appConfigDetailInfo);
            }
            appConfigDetailInfo.id = id;
            rs = true;
        } catch (VciBaseException e) {
            e.printStackTrace();
            String exceptionMessage = VciBaseUtil.getExceptionMessage(e);
            logger.error(exceptionMessage);
            rs = false;
            throw new VciBaseException(exceptionMessage);
        }
        return rs;
    }

    /**
     * 修改配置项分类或配置项
     * @return
     */
    @Override
    public boolean updateAppConf(AppConfigDetailInfo appConfigDetailInfo,boolean isConfCategorys/*是否为操作配置项分配*/) {
        VciBaseUtil.alertNotNull(appConfigDetailInfo,"添加的操作类型");
        boolean rs = false;
        try {
            if(isConfCategorys){
                AppConfigCategoryInfo appConfigCategoryInfo = new AppConfigCategoryInfo();
                appConfigCategoryInfo.id = appConfigDetailInfo.id;
                appConfigCategoryInfo.name = appConfigDetailInfo.name;
                appConfigCategoryInfo.desc = appConfigDetailInfo.desc;
                this.checkConf(appConfigCategoryInfo);
                rs = foDelegate.updateAppConfigCategory(appConfigCategoryInfo);
            }else{
                this.checkConfItem(appConfigDetailInfo);
                rs = foDelegate.updateAppConfigDetail(appConfigDetailInfo);
            }
        } catch (VciBaseException e) {
            e.printStackTrace();
            String exceptionMessage = VciBaseUtil.getExceptionMessage(e);
            logger.error(exceptionMessage);
            throw new VciBaseException(exceptionMessage);
        }
        return rs;
    }

    /**
     * 删除配置项分类或配置项
     * @return
     */
    @Override
    public boolean delAppConf(String[] ids,boolean isConfCategorys/*是否为操作配置项分配*/) {
        VciBaseUtil.alertNotNull(ids,"待删除的主键列表");
        boolean res = false;
        if(isConfCategorys){
            if (this.hasAppConfigDetail(ids)) {
                throw new VciBaseException("删除的配置项分类下存在关联数据！");
            }
            res = foDelegate.deleteAppConfigCategory(ids);
        }else {
            res = foDelegate.deleteAppConfigDetail(ids);
        }
        return res;
    }

    /**
     * 检查是否存在引用关系
     * @param ids
     * @return
     */
    private boolean hasAppConfigDetail(final String[] ids){
        for (int i = 0; i < ids.length; i++) {
            AppConfigDetailInfo[] appConfigDetailsByID = foDelegate.getAppConfigDetailsByID(ids[i]);
            if(Func.isNotEmpty(appConfigDetailsByID)){
                return true;
            }
        }
        return false;
    }

    /**
     * 配置项分类校验
     * @param obj
     */
    private void checkConf(AppConfigCategoryInfo obj) {
        if ("".equals(obj.name)) {
            throw new VciBaseException("名称不能为空！");
        }
    }

    /**
     * 配置项校验
     * @param obj
     */
    private void checkConfItem(AppConfigDetailInfo obj) {
        if ("".equals(obj.name)) {
            throw new VciBaseException("名称不能为空！");
        }
        /*AppConfigDetailInfo[] appConfigDetailInfoByName = foDelegate.getAppConfigDetailInfoByName(obj.name);
        if(appConfigDetailInfoByName != null && appConfigDetailInfoByName.length > 0){
            throw new VciBaseException("配置项名称重复！");
        }*/
        if ("".equals(obj.key)){
            throw new VciBaseException("主键不能为空！");
        }
        if ("".equals(obj.value)){
            throw new VciBaseException("键值不能为空!");
        }
    }

    /**
     * 导出系统配置
     * @param response
     * @return
     */
    @Override
    public String exportSysConf(ExpExcelConditionVO expExcelConditionVO, HttpServletResponse response) throws IOException {
        //设置文件名和路径
        String expFileName = expExcelConditionVO.getExpFileName();
        if(Func.isNotBlank(expFileName) && expFileName.contains(".xls")){
            throw new VciBaseException("设置的文件名中未设置文件后缀，或后缀设置有误，当前仅支持导出.xls格式！");
        }
        expFileName = Func.isBlank(expFileName) ? "appConfig.xls":expFileName;
        String defaultTempFolder = LocalFileUtil.getDefaultTempFolder();
        //写excel
        String excelPath = defaultTempFolder + File.separator + expFileName;
        //先判断是全部导出还是选择数据导出
        Map<String, Object> conditionMap = expExcelConditionVO.getConditionMap();
        if (Func.isEmpty(conditionMap)) {
            throw new VciBaseException("缺少必要导出条件！");
        }
        //指定导出的属性名
        List<String> expAttrNames = expExcelConditionVO.getExpAttrNames();
        if(Func.isEmpty(expAttrNames)){
            throw new VciBaseException("请选择您要导出的属性！");
        }
        //先区分是导出的配置项分类还是配置项详情
        boolean isExpAppConfDetail = (boolean) conditionMap.get("isExpAppConfDetail");
        //因为AppConfigDetailInfo中的属性包含了AppConfigCategoryInfo中的属性所以先通用了
        List<AppConfigDetailInfo> appConfigDetailInfos = new ArrayList<>();
        //选中导出数据的唯一标识
        List<String> selectDataIdentify = expExcelConditionVO.getSelectDataIdentify();
        //当前界面导出逻辑，只存在全部和选择导出
        String expType = expExcelConditionVO.getExpType();
        if(!isExpAppConfDetail){
            AppConfigCategoryInfo[] appConfigCategorys = foDelegate.getAppConfigCategorys();
            List<AppConfigCategoryInfo> filterAppConfigInfo = null;
            if("select".equals(expType)){
                filterAppConfigInfo = Arrays.stream(appConfigCategorys).filter(item -> {
                    if (selectDataIdentify.contains(item.id)) {
                        return true;
                    }
                    return false;
                }).collect(Collectors.toList());
            }else{
                filterAppConfigInfo = new ArrayList<>(Arrays.asList(appConfigCategorys));
            }
            if (Func.isNotEmpty(filterAppConfigInfo)) {
                filterAppConfigInfo.stream().forEach(item->{
                    AppConfigDetailInfo appConfigDetailInfo = new AppConfigDetailInfo();
                    appConfigDetailInfo.id = item.id;
                    appConfigDetailInfo.name = item.name;
                    appConfigDetailInfo.desc = item.desc;
                    appConfigDetailInfos.add(appConfigDetailInfo);
                });
            }
        }else{
            String clsId = (String)conditionMap.get("clsId");
            if(Func.isBlank(clsId)){
                throw new VciBaseException("未获取到查询配置项的配置项分类主键");
            }
            AppConfigDetailInfo[] configDetailInfos = foDelegate.getAppConfigDetailsByID(clsId);
            List<AppConfigDetailInfo> filterAppConfigInfo = null;
            if("select".equals(expType)){
                filterAppConfigInfo = Arrays.stream(configDetailInfos).filter(item -> {
                    if (selectDataIdentify.contains(item.id)) {
                        return true;
                    }
                    return false;
                }).collect(Collectors.toList());
            }else{
                filterAppConfigInfo = new ArrayList<>(Arrays.asList(configDetailInfos));
            }
            if (Func.isNotEmpty(filterAppConfigInfo)) {
                appConfigDetailInfos.addAll(filterAppConfigInfo);
            }
        }
        //设置列名
        List<String> columns = new ArrayList<>();
        //根据导出列设置列名
        Map<String,Integer> colAttrMap = new HashMap<>(); //导出的列和属性映射
        for (int i = 0; i < expAttrNames.size(); i++) {
            String attrName = expAttrNames.get(i);
            switch (attrName){
                case "name":
                    columns.add("名称");
                    break;
                case "key":
                    columns.add("key");
                    break;
                case "value":
                    columns.add("value");
                    break;
                case "desc":
                    columns.add("描述");
                    break;
            }
            colAttrMap.put(attrName,i);
        }

        new File(excelPath).createNewFile();
        //设置列
        List<WriteExcelData> excelDataList = new ArrayList<>();
        //设置列头
        for (int index = 0; index < columns.size(); index++) {
            excelDataList.add(new WriteExcelData(0,index, columns.get(index)));
        }
        //处理数据导出
        if(Func.isEmpty(appConfigDetailInfos)){
            excelDataList.add(new WriteExcelData(1,1, "未获取到要导出的数据，请刷新后尝试重新导出！"));
        }else{
            for (int i = 0; i < appConfigDetailInfos.size(); i++) {
                AppConfigDetailInfo appConfigDetailInfo = appConfigDetailInfos.get(i);
                int row = i+1;
                if(Func.isNotEmpty(colAttrMap.get("name"))){
                    excelDataList.add(new WriteExcelData(row,colAttrMap.get("name"), appConfigDetailInfo.name));
                }
                if(Func.isNotEmpty(colAttrMap.get("key"))){
                    excelDataList.add(new WriteExcelData(row,colAttrMap.get("key"), appConfigDetailInfo.key));
                }
                if(Func.isNotEmpty(colAttrMap.get("value"))){
                    excelDataList.add(new WriteExcelData(row,colAttrMap.get("value"), appConfigDetailInfo.value));
                }
                if(Func.isNotEmpty(colAttrMap.get("desc"))){
                    excelDataList.add(new WriteExcelData(row,colAttrMap.get("desc"), appConfigDetailInfo.desc));
                }
            }
        }
        WriteExcelOption excelOption = new WriteExcelOption(excelDataList);
        ExcelUtil.writeDataToFile(excelPath, excelOption);
        return excelPath;
    }

    /**
     * 获取当前在线人数
     * @return
     */
    @Override
    public long getOnlineUsersNum() {
        long currentLoggedUserCount = redisService.getCurrentOnlineUserCount(VConstant.CURRENT_LOGGED_USERS_KEY);
        return currentLoggedUserCount;
    }

    /**
     * 收集表单信息。
     * @param files
     * @return
     * @throws PLException
     * @throws IOException
     */
    private boolean collectionDatas(LinkedList<File> files) throws PLException, IOException{
        boolean b=false;
        for (File f : files) {
            List<SheetDataSet> sheetDataSets = this.getFileList(f);
            if (sheetDataSets != null && !sheetDataSets.isEmpty()) {
                for (SheetDataSet sheet : sheetDataSets) {
                    // sheet不能为空并且必须有出表头外的一条数据
                    if (sheet != null && sheet.getRowData() != null && sheet.getRowData().size() > 1) {
                        List<SheetRowData> dataSet = sheet.getRowData();
                        String fParentId=""; //第一级的id(第二级的parentid)
                        boolean boo=true;
                        boolean first=false;
                        String[] pd=new String[100];
                        int jibie=2;
                        for (int i = 0; i < dataSet.size(); i++) {
                            Map<Integer, String> oneData = dataSet.get(i).getData();
                            String id = ObjectUtility.getNewObjectID36();

                            FunctionInfo funObj=new FunctionInfo();
                            boolean onebl=false;
                            boolean twobl=false;
                            boolean same=false;
                            String plName = Func.isBlank(oneData.get(0)) ? "":oneData.get(0);
                            if(oneData.get(14).equals("1")) {
                                try {
                                    onebl = foDelegate.firstLevel(plName);
                                } catch (VciBaseException e) {
                                    // TODO Auto-generated catch block
                                    e.printStackTrace();
                                }
                                //如果第一级重名
                                if(onebl == true) {//第一级重名后覆盖第一级
                                    fuzhi(funObj,oneData);
                                    try {
                                        fParentId = foDelegate.changeFirstLevel(funObj,plName);
                                        pd[2]=fParentId;
                                    } catch (VciBaseException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                    }
                                    funObj.id = fParentId;
                                    fileFunctionDatas.add(funObj);
                                    first=true;

                                } else {
                                    funObj.id = id;
                                    funObj.parentId = "modelManagmentNode";
                                    fuzhi(funObj,oneData);
                                    fileFunctionDatas.add(funObj);
                                    first=false;
                                }

                                b=false;
                            }
                            //#########################     合并     #########################
                            for(jibie=2;jibie<100;jibie++){
                                if(oneData.get(14).equals(String.valueOf(jibie))){
                                    if(first == true && boo == true){
                                        try {
                                            if(pd[jibie]==null){
                                                pd[jibie]="";
                                            }
                                            twobl=foDelegate.secondLevel(plName,pd[jibie]);
                                        } catch (VciBaseException e) {
                                            // TODO Auto-generated catch block
                                            e.printStackTrace();
                                        }
                                        if(twobl==true) {//重名后覆盖
                                            fuzhi(funObj,oneData);
                                            try {
                                                fParentId=foDelegate.changeSecondLevel(funObj,plName,pd[jibie]);
                                                pd[jibie+1]=fParentId;
                                            } catch (VciException e) {
                                                // TODO Auto-generated catch block
                                                e.printStackTrace();
                                            }
                                            //funObj.setId(fParentId);
                                            funObj.id = pd[jibie+1];
                                            fileFunctionDatas.add(funObj);
                                            boo = true;

                                        }
                                    } else {
                                        funObj.id = id;
                                        b = false;
                                    }
                                }
                            }

                            if(oneData.get(14).equals("-1")) {
                                importExcelData(count);
                                FuncOperationInfo foObj = new FuncOperationInfo();
                                int len=fileFunctionDatas.size();
                                //**************同一节点下不能有相同的操作类型********************
                                String dataOperName=oneData.get(18);
                                String plFuncOid=fileFunctionDatas.get(len-1).id;
                                try {
                                    same = foDelegate.selSameOper(dataOperName,plFuncOid);
                                } catch (VciBaseException e1) {
                                    // TODO Auto-generated catch block
                                    e1.printStackTrace();
                                }
                                //******************************************************
                                if(same == false) {
                                    foObj.id = id;
                                    foObj.funcId = fileFunctionDatas.get(len-1).id;
                                    try {
                                        OperateInfo operObj = foDelegate.fetchOperateTypeByName(oneData.get(18));
                                        foObj.operId = operObj.id;
                                    } catch (VciBaseException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                    }
                                    foObj.number = Integer.parseInt(oneData.get(16));
                                    foObj.operAlias = oneData.get(15);
                                    foObj.isValid = Integer.parseInt(oneData.get(17)) != 0;
                                    try {
                                        foDelegate.saveFuncOperation2(foObj);
                                    } catch (VciBaseException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                    }

                                } else {
                                    foObj.number = Integer.parseInt(oneData.get(16));
                                    foObj.operAlias = oneData.get(15);
                                    foObj.isValid = Integer.parseInt(oneData.get(17)) != 0;
                                    try {
                                        foDelegate.updateOperation(foObj,dataOperName,plFuncOid);
                                    } catch (VciBaseException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                    }
                                }
                                count=fileFunctionDatas.size();
                                b=true;
                            }
                        }
                    }
                }
            }
        }
        return b;
    }

    /**
     * 导入表单数据
     * @throws VciException
     */
    private boolean importExcelData(int count) throws PLException {
        boolean b=false;
        try {
            b = foDelegate.importModules(fileFunctionDatas.toArray(new FunctionInfo[fileFunctionDatas.size()]),count);
        } catch (VciBaseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return b;
    }

    /**
     * 获取表单数据
     * @param f
     * @return
     * @throws IOException
     * @throws PLException
     * @autor caicong
     * @data 2014-3-11
     */
    private List<SheetDataSet> getFileList(File f) throws PLException, IOException {
        // 获取表list
        List<SheetDataSet> sheetDataSets = ExcelUtil.readDataObjectFromExcel(f);
        return sheetDataSets;
    }

    /**
     * 查询"功能模块管理"整个树结构并导出
     * add by caill start
     * */
    private String[][] checkLevel() throws VciBaseException{
        String[][] res = new String[3000][23];
        try{
            res = platformClientUtil.getFrameworkService().checkLevel();
        }catch (PLException e) {
            e.printStackTrace();
            throw new VciBaseException(String.valueOf(e.code), e.messages);
        }
        return res;
    }

    /**
     * 将查询出的数据转换成sql并写入指定路径下
     * @param dir
     * @param plDatas
     * @return
     */
    private File expData(String dir,boolean isFunction/*是否是导出管理功能模块sql*/, String[][] plDatas){
        new File(dir).mkdir();
        File file = new File(dir + (isFunction ? "/plfuncoperation.sql":"/ploperation.sql"));
        try {
            FileWriter w = new FileWriter(file);
            BufferedWriter bw = new BufferedWriter(w);
            System.out.println("长度为："+plDatas.length);
            for(int i=0;i<plDatas.length;i++){
                if(isFunction){
                    if(!plDatas[i][16].trim().equals("") && plDatas[i][16]!=null && !plDatas[i][16].equals("-1")){
                        bw.write("insert into plfunction values('"+plDatas[i][0]+"','"+plDatas[i][1]+"',"+"'"+plDatas[i][2]+"',"+"'"+plDatas[i][3]+"',"+"'"+plDatas[i][4]+"',"
                                +"',"+"'"+plDatas[i][5]+"',"+"'"+plDatas[i][6]+"',"+"'"+plDatas[i][7]+"',"+"'"+plDatas[i][8]+"',"+"'"+plDatas[i][9]+"',"+"'"+plDatas[i][10]+"',"
                                +"'"+plDatas[i][11]+"',"+"'"+plDatas[i][12]+"',"+"'"+plDatas[i][13]+"',"+"'"+plDatas[i][14]+"');");
                        bw.write("\r\n");
                    }
                    if(!plDatas[i][15].trim().equals("") && plDatas[i][15]!=null && plDatas[i][15].equals("-1")){
                        bw.write("insert into plfuncoperation values('"+plDatas[i][16]+"','"+plDatas[i][17]+"',"+"'"+plDatas[i][18]+"',"+"'"+plDatas[i][19]+"',"+"'"+plDatas[i][20]+"',"
                                +"'"+plDatas[i][21]+"');");
                        bw.write("\r\n");
                    }
                }else{
                    bw.write("insert into ploperation values('"+plDatas[i][0]+"','"+plDatas[i][1]+"',"+"'"+plDatas[i][2]+"',"+"'"+plDatas[i][3]+"',"+"'"+plDatas[i][4]+"',"
                            +"'"+plDatas[i][5]+"');");
                    bw.write("\r\n");
                }
            }

            bw.flush();
            bw.close();
            return file;
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 保存模块下的操作
     * @param funcOperationObjs
     * @return
     * @throws VciException
     */
    public boolean saveFuncOperation(FuncOperationInfo[] funcOperationObjs) throws VciException {
        if(funcOperationObjs == null || funcOperationObjs.length < 0){
            return false;
        }
        boolean res = true;
        try{
            res = platformClientUtil.getFrameworkService().saveFuncOperation(funcOperationObjs, foDelegate.getUserEntityInfo());
        }catch (PLException e) {
            e.printStackTrace();
            throw new VciException(String.valueOf(e.code),e.messages);
        }
        return res;
    }

    /**
     * 查询"功能模块管理"整个树结构并导出sql
     * @return
     * @throws PLException
     */
    public String[][] getAllDatas(int size) throws PLException {
        String[][] res = new String[size][23];
        try{
            res = platformClientUtil.getFrameworkService().getAllDatas(size);
        }catch (PLException e) {
            e.printStackTrace();
            throw new PLException(String.valueOf(e.code), e.messages);
        }
        return res;
    }

    /**
     * 获得所有的操作类型并导出到.sql文件中
     * add by caill start 2015.12.11
     * */
    private String[][] getAllOperitions(int size) throws VciBaseException{
        String[][] res = new String[size][6];
        try{
            res = platformClientUtil.getFrameworkService().getAllOperitions(size);
        }catch (PLException e) {
            e.printStackTrace();
            throw new VciBaseException(String.valueOf(e.code), e.messages);
        }
        return res;
    }

    public void fuzhi(FunctionInfo functionInfo,Map<Integer,String> oneData){
        functionInfo.name = oneData.get(0);
        functionInfo.resourceC = oneData.get(1);
        functionInfo.suffixC = oneData.get(2);
        functionInfo.desc = oneData.get(5);
        functionInfo.resourceB = oneData.get(3);
        functionInfo.suffixB = oneData.get(4);
        functionInfo.seq = Integer.parseInt(oneData.get(8));
        functionInfo.image = oneData.get(7);
        functionInfo.isValid = Integer.parseInt(oneData.get(6)) != 0;
        functionInfo.aliasName = oneData.get(9);
        functionInfo.resourceDotNet = oneData.get(11);
        functionInfo.resourceMobile = oneData.get(12);
    }

    /**
     * 包含保存模块方法等操作类
     */
    private class FunctionOperateDelegate {

        /**
         * 判断第一级数据有没有重名的
         * @param plName
         * @return
         * @throws VciException
         */
        public boolean firstLevel(String plName) throws VciBaseException{
            try{
                return platformClientUtil.getFrameworkService().firstLevel(plName);
            }catch (PLException e) {
                e.printStackTrace();
                throw new VciBaseException(String.valueOf(e.code), e.messages);
            }
        }

        /**
         * 覆盖重名的第一级数据
         * add by caill
         * */
        public String changeFirstLevel(FunctionInfo functionInfo,String plName) throws VciBaseException{
            String fParentId="";
            try {
                fParentId= platformClientUtil.getFrameworkService().changeFirstLevel(functionInfo, plName);
            } catch (PLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return fParentId;
        }

        /**
         * 判断第二级数据有没有重名的
         * add by caill
         * */
        public boolean secondLevel(String plName,String fParentId) throws VciBaseException{
            try{
                return platformClientUtil.getFrameworkService().secondLevel(plName,fParentId);
            }catch (PLException e) {
                e.printStackTrace();
                throw new VciBaseException(String.valueOf(e.code), e.messages);
            }
        }

        /**
         * 覆盖重名的第二级数据
         * add by caill
         * */
        public String changeSecondLevel(FunctionInfo functionInfo,String plName,String fParentId) throws VciException{
            String sParentId="";
            try {
                sParentId= platformClientUtil.getFrameworkService().changeSecondLevel(functionInfo, plName,fParentId);
            } catch (PLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return sParentId;
        }

        /**
         * 保存模块
         * @param object
         * @return
         * @throws VciException
         */
        public String saveModule(MenuVO object) throws VciBaseException {
            String res = "";
            try{
                res = platformClientUtil.getFrameworkService().saveModule(this.check(object,"add"),this.getUserEntityInfo());
            }catch (PLException e) {
                e.printStackTrace();
                throw new VciBaseException(String.valueOf(e.code), e.messages);
            }
            return res;
        }

        /**
         * 修改模块
         * @param object
         * @return
         * @throws VciException
         */
        public String updateMod(MenuVO object) throws VciBaseException {
            String res = "";
            try{
                res = platformClientUtil.getFrameworkService().updateModule(this.check(object,"update"),this.getUserEntityInfo());
            }catch (PLException e) {
                e.printStackTrace();
                throw new VciBaseException(String.valueOf(e.code), e.messages);
            }
            return res;
        }

        /**
         * 删除模块
         * @param puid
         * @return
         * @throws VciException
         */
        public String deleteModule(String puid) throws VciBaseException{
            String res = "";
            try{
                res = platformClientUtil.getFrameworkService().deleteModule(puid,this.getUserEntityInfo());
            }catch (PLException e) {
                e.printStackTrace();
                throw new VciBaseException(String.valueOf(e.code), e.messages);
            }
            return res;
        }

        /**
         * 移除模块下的操作
         * @param funcOperationInfo
         * @return
         * @throws VciException
         */
        public boolean deleteFuncOperation(FuncOperationInfo funcOperationInfo) throws VciBaseException{
            boolean res = true;
            try{
                res = platformClientUtil.getFrameworkService().deleteFuncOperation(funcOperationInfo, this.getUserEntityInfo());
            }catch (PLException e) {
                e.printStackTrace();
                throw new VciBaseException(String.valueOf(e.code), e.messages);
            }
            return res;
        }

        /**
         * VO转DO对象
         * @return
         */
        public FunctionInfo menuVO2FunctionInfo(MenuVO object){
            FunctionInfo info = new FunctionInfo();
            info.id = object.getId() == null ? "" : object.getId();
            info.name = object.getName() == null ? "" : object.getName();
            info.parentId = object.getParentId() == null ? "" : object.getParentId();
            info.resourceC = object.getPathC() == null ? "" : object.getPathC();
            //info.suffixC = object.getSuffixC() == null ? "" : object.getSuffixC();
            info.resourceB = object.getPath() == null ? "" : object.getPath();
            //info.suffixB = object.getSuffixB() == null ? "" : object.getSuffixB();
            info.desc = object.getRemark() == null ? "" : object.getRemark();
            info.seq = object.getSort();
            info.icon = object.getSource() == null ? "" : object.getSource();
            info.isValid = object.getIsValid();
            info.aliasName = object.getAlias() == null ? "" : object.getAlias();
            info.resourceDotNet = object.getResourceDotNet() == null ? "" : object.getResourceDotNet();
            info.resourceMobile = object.getResourceMobile() == null ? "" : object.getResourceMobile();
            info.desc = object.getRemark();
            return info;
        }

        /**
         * <p>Description: 页面输入的校验</p>
         *
         *@author xf
         *@time 2012-5-15
         *@return FunctionObject
         * @return
         */
        private FunctionInfo check(MenuVO menuVO,String type) {
            FunctionInfo obj = new FunctionInfo();
            //获取表单输入的值
            String modelName = menuVO.getName();
            String csIdentity = menuVO.getPathC();
            String bsIdentity = menuVO.getPath();
            String aliasName = menuVO.getAlias();
            String resDotNet = menuVO.getResourceDotNet();
            String resMobile = menuVO.getResourceMobile();

            int sequence = Func.isNotEmpty(menuVO.getSort()) ? menuVO.getSort():1;
            String description = menuVO.getRemark();

            if(Func.isBlank(modelName)) {
                throw new VciBaseException("模块名不能为空！");
            }else if(modelName.length() > 128) {
                throw new VciBaseException("模块名长度不能超过128！");
            }else if(Func.isNotBlank(description) && description.length() > 255) {
                throw new VciBaseException("描述长度不能超过255！");
            }else if(Func.isNotBlank(csIdentity) && csIdentity.length() > 255) {
                throw new VciBaseException("C/S标识长度不能超过255！");
            } else if(Func.isNotBlank(resDotNet) && resDotNet.length() > 255) {
                throw new VciBaseException(".NET标识长度不能超过255！");
            }else if(Func.isNotBlank(resMobile) && resMobile.length() > 255) {
                throw new VciBaseException("Mobile标识长度不能超过255！");
            } else if (sequence < 0) {
                throw new VciBaseException("序号不能小于0！");
            }
            if(type.equals("add")){
                //给object对象赋值
                /*String parentId = "";
                if(menuVO.getModeType().equals("FunctionObject")) {
                    parentId = menuVO.getParentId();
                }else if("modelManagmentNode".equals(menuVO.getParentId())) {
                    parentId = "modelManagmentNode";
                }else if("systemManagmentNode".equals(menuVO.getParentId())) {
                    parentId = "systemManagmentNode";
                }*/
                obj.parentId = menuVO.getParentId();
            }else{
                obj.id = menuVO.getId();
                obj.parentId = menuVO.getParentId();
            }
            obj.name = modelName;
            obj.resourceC = csIdentity;
            obj.desc = description;
            obj.resourceB = bsIdentity;
            /*obj.suffixC = "";
            obj.suffixB = "";*/
            obj.seq = sequence;
            obj.icon = menuVO.getSource();
            obj.isValid = Func.isNotEmpty(menuVO.getValid()) ? menuVO.getValid():false;
            obj.aliasName = aliasName;
            obj.resourceDotNet = resDotNet;
            obj.resourceMobile = resMobile;
            return obj;
        }

        /**
         * 获取UserEntityInfo对象
         * @return
         */
        public UserEntityInfo getUserEntityInfo(){
            SessionInfo sessionInfo = WebThreadLocalUtil.getCurrentUserSessionInfoInThread();
            UserEntityInfo userEntityInfo = new UserEntityInfo(sessionInfo.getUserId(), "");
            return userEntityInfo;
        }

        /**
         * 导入模块对象
         * add by caill
         * */
        public boolean importModules(FunctionInfo[] funObject,int count) throws VciBaseException{
            boolean b=false;
            int len = funObject.length;
            List<FunctionInfo> funInfoList = new ArrayList<FunctionInfo>();
            for(int i = count ; i<len ; i++){
                if(Func.isNotBlank(funObject[i].parentId)){
                    FunctionInfo funInfo = funObject[i];
                    funInfoList.add(funInfo);
                }
            }
            FunctionInfo[] funInfos = new FunctionInfo[funInfoList.size()];
            for(int j=0;j<funInfoList.size();j++){
                funInfos[j] = funInfoList.get(j);
            }

            try {
                b = platformClientUtil.getFrameworkService().importModules(funInfos,this.getUserEntityInfo());
            } catch (PLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            return b;
        }

        /**
         * 查询同一模块中是否已经存在相同的操作类型
         * add by caill
         * */
        public boolean selSameOper(String dataOperName,String plFuncOid) throws VciBaseException{
            boolean same=false;
            try {
                same = platformClientUtil.getFrameworkService().selSameOper(dataOperName,plFuncOid);
            } catch (PLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return same;
        }

        public OperateInfo fetchOperateTypeByName(String name) throws VciBaseException {
            try{
                OperateInfo info =  platformClientUtil.getFrameworkService().fetchOperateTypeByName(name);
                return info;
            }catch (PLException e) {
                e.printStackTrace();
                throw new VciBaseException(String.valueOf(e.code),e.messages);
            }
        }

        /**
         * 保存操作类型
         * add by caill
         * */
        public boolean saveFuncOperation2(FuncOperationInfo funcOperationInfo) throws VciBaseException{
            try {
                platformClientUtil.getFrameworkService().saveFuncOperation2(funcOperationInfo,this.getUserEntityInfo());
            } catch (PLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                throw new VciBaseException(String.valueOf(e.code), e.messages);
            }
            return true;
        }

        /**
         * 覆盖操作类型
         * add by caill
         * */
        public String updateOperation(FuncOperationInfo funcOperationInfo,String dataOperName,String plFuncOid) throws VciBaseException{
            try {
                platformClientUtil.getFrameworkService().updateOperation(funcOperationInfo,this.getUserEntityInfo(),dataOperName,plFuncOid);
            } catch (PLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                throw new VciBaseException(String.valueOf(e.code), e.messages);
            }
            return null;
        }

        public boolean updateFuncOperation(String id , String alias, boolean isSelected) throws VciBaseException {
            boolean res = false;
            try{
                res = platformClientUtil.getFrameworkService().updateFuncOperation(id, alias, isSelected, this.getUserEntityInfo());
            }catch(PLException e){
                throw new VciBaseException(String.valueOf(e.code), e.messages);
            }
            return res;
        }

        /**
         * 保存操作类型
         *
         * @param operateInfo
         * @return
         * @throws VciException
         */
        public String saveOperate(OperateInfo operateInfo) throws VciBaseException {
            String res = "";
            try{
                res = platformClientUtil.getFrameworkService().saveOperate(operateInfo,this.getUserEntityInfo());
            }catch (PLException e) {
                e.printStackTrace();
                throw new VciBaseException(String.valueOf(e.code), e.messages);
            }
            return res;
        }

        /**
         * 修改操作类型
         *
         * @param operateInfo
         * @return
         * @throws VciException
         */
        public String updateOperate(OperateInfo operateInfo) throws VciBaseException {
            String res = "";
            try{
                res = platformClientUtil.getFrameworkService().updateOperate(operateInfo,this.getUserEntityInfo());
            }catch (PLException e) {
                e.printStackTrace();
                throw new VciBaseException(String.valueOf(e.code), e.messages);
            }
            return res;
        }

        /**
         * 删除操作类型
         *
         * @param id
         * @return
         * @throws VciException
         */
        public boolean deleteOperate(String id) throws VciBaseException {
            boolean res = true;
            try{
                res = platformClientUtil.getFrameworkService().deleteOperate(id,this.getUserEntityInfo());
            }catch (PLException e) {
                e.printStackTrace();
                throw new VciBaseException(String.valueOf(e.code), e.messages);
            }
            return res;
        }

        /**
         * 检查操作是否被引用
         * @param operateId
         * @return 0表示无引用，1表示被模块引用，2表示有权限信息
         * @throws VciException
         */
        public int checkOperateIsReferenced(String operateId) throws VciBaseException {
            try{
                return (int)platformClientUtil.getFrameworkService().checkOperateIsReferenced(operateId);
            }catch (PLException e) {
                e.printStackTrace();
                throw new VciBaseException(String.valueOf(e.code),e.messages);
            }
        }

        /**
         * 返回全部的 AppConfigCategory 对象
         * @return
         * @throws VciException
         */
        public AppConfigCategoryInfo[] getAppConfigCategorys() throws VciBaseException{
            try{
                AppConfigCategoryInfo[] infos = platformClientUtil.getFrameworkService().getAppConfigCategorys(this.getUserEntityInfo());
                return infos;
            }catch(PLException e){
                throw new VciBaseException(String.valueOf(e.code), e.messages);
            }
        }

        /**
         * 根据分类ID返回全部的 AppConfigDetail 对象
         */
        public AppConfigDetailInfo[] getAppConfigDetailsByID(String clsfId) throws VciBaseException{
            try{
                AppConfigDetailInfo[] infos = platformClientUtil.getFrameworkService().getAppConfigDetailsByCatId(clsfId, this.getUserEntityInfo());
                return infos;
            }catch(PLException e){
                throw new VciBaseException(String.valueOf(e.code), e.messages);
            }
        }

        /**
         * 添加、保存 AppConfigCategory 对象
         * @param object AppConfigCategoryInfo 对象
         */
        public String saveAppConfigCategory(AppConfigCategoryInfo object) throws VciBaseException{
            try{
                return platformClientUtil.getFrameworkService().saveAppConfigCategory(object, this.getUserEntityInfo());
            }catch(PLException e){
                throw new VciBaseException(String.valueOf(e.code), e.messages);
            }
        }

        /**
         * 修改、更新 AppConfigCategory 对象
         * @param object AppConfigCategoryInfo 对象
         */
        public boolean updateAppConfigCategory(AppConfigCategoryInfo object) throws VciBaseException{
            try{
                return platformClientUtil.getFrameworkService().updateAppConfigCategory(object, this.getUserEntityInfo());
            }catch(PLException e){
                throw new VciBaseException(String.valueOf(e.code), e.messages);
            }
        }

        /**
         * 根据名称查询配置项
         * @param name
         * @return
         * @throws VciBaseException
         */
        public AppConfigDetailInfo[] getAppConfigDetailInfoByName(String name) throws VciBaseException{
            try{
                AppConfigDetailInfo[] appConfigDetailsByName = platformClientUtil.getFrameworkService().getAppConfigDetailsByName(name, this.getUserEntityInfo());
                return appConfigDetailsByName;
            }catch(PLException e){
                throw new VciBaseException(String.valueOf(e.code), e.messages);
            }
        }

        /**
         * 根据 ID 删除 AppConfigCategory 对象（批量）
         * @param ids AppConfigCategory 对象的 ID 列表
         */
        public boolean deleteAppConfigCategory(String[] ids) throws VciBaseException{
            try{
                return platformClientUtil.getFrameworkService().deleteAppConfigCategory(ids, this.getUserEntityInfo());
            }catch(PLException e){
                throw new VciBaseException(String.valueOf(e.code), e.messages);
            }
        }

        /** 添加、保存 AppConfigDetail 对象
		* @param info AppConfigDetailInfo 对象
		*/
        public String saveAppConfigDetail(AppConfigDetailInfo info) throws VciBaseException{
            try{
                return platformClientUtil.getFrameworkService().saveAppConfigDetail(info, this.getUserEntityInfo());
            }catch(PLException e){
                throw new VciBaseException(String.valueOf(e.code), e.messages);
            }
        }

        /**
         * 修改、更新 AppConfigDetail 对象
         * @param info AppConfigDetailInfo 对象
         */
        public boolean updateAppConfigDetail(AppConfigDetailInfo info) throws VciBaseException{
            try{
                return platformClientUtil.getFrameworkService().updateAppConfigDetail(info, this.getUserEntityInfo());
            }catch(PLException e){
                throw new VciBaseException(String.valueOf(e.code), e.messages);
            }
        }

        /**
         * 根据 ID 删除 AppConfigDetail 对象（批量）
         * @param ids AppConfigDetail 对象的 ID 列表
         */
        public boolean deleteAppConfigDetail(String[] ids) throws VciBaseException{
            try{
                return platformClientUtil.getFrameworkService().deleteAppConfigDetail(ids, this.getUserEntityInfo());
            }catch(PLException e){
                throw new VciBaseException(String.valueOf(e.code), e.messages);
            }
        }

    }

}