// import { observable, action, toJS } from "mobx";
// import * as API from "../apis/outter";

// import { Modal, message } from "antd";
// import { WeaTableNew, WeaForm,WeaLogView } from "comsMobx";

// const { TableStore } = WeaTableNew;
// const {LogStore} = WeaLogView;

// import { WeaLocaleProvider } from "ecCom";

// const getLabel = WeaLocaleProvider.getLabel;
// import ParamsType from "../components/outter/ParamsType";
// export class OutterStore {

//     @observable searchForm = new WeaForm();
//     @observable sysTableStore = new TableStore();
//     @observable encryptTableStore = new TableStore();
//     @observable sysShareTableStore = new TableStore();
//     @observable sysLogStore = new LogStore();
//     @observable testForm = new WeaForm();

//     @observable
//     status = {
//         //【集成登录设置】页签或【加密算法设置】页签
//         selectedKey:"0",
//         //【集成登录设置】列表右键菜单
//         sysListRightMenus: [],
//         //【加密算法设置】列表右键菜单
//         encryptListRightMenus: [],
//         rowSelectIds: [],
//         showNewFormDialog_sys: false,
//         showNewFormDialog_encrypt: false,
//         editEncryptForm: false,
//         editEncryptFormDatas: {},
//         logShow:false,
//         logId:"",
//         testVisible: false,
//         testTitle: '',
//         sysRowSelectIds: [],
//     };

//     @action
//     setState = (params = {}) => {
//         let status = { ...this.status };
//         Object.keys(params).forEach(key => {
//             status[key] = params[key];
//         });
//         this.status = status;
//     };

//     /**
//      * 【集成登录设置】页面状态
//      */
//     @observable
//     newFormStatus = {
//         isEdit: false,
//         sysTypeNameOptions: [],
//         sysIpAddressOptions: [],
//         sysEncryptTypeOptions: [],
//         sysneedpwd: [],
//         sysneediv: [],
//         isneedpwd:"",
//         isneediv:"",
//         isneedpwd: false,
//         showEncryptIV: false,
//         sysEncryptClassOptions: [],
//         defaultEntranceUrlList: [],
//         paramColumns:[],
//     };

//     /**
//      * 【集成登录设置】页面数据
//      */
//     @observable
//     newFormData = {
//         typeOption:{},
//         //类型
//         typename: "0",
//         //标识
//         sysid:"",
//         //名称
//         name:"",
//         //链接图标
//         filename:"",
//         urllinkimagid:"",
//         //图标大小
//         imagewidth:"32",
//         imageheight:"32",
//         //内外网自动登录
//         autologin:"0",
//         sysIpAddress:{},
//         outternetworks:[],
//         //内网地址
//         iurl:"",
//         //外网地址
//         ourl:"",
//         //请求方式
//         requesttype:{key:"1",showname:"GET"},
//         urlencodeflag:"1",
//         //登录系统编码
//         encodeflag:"0",
//         //加密算法
//         encrypttype:"0",
//         encryptclassId:"",
//         result:"0",
//         //账号参数名
//         baseparam1:"",
//         basetype1:"1",
//         urlparaencrypt1:"0",
//         encryptcode1:"",
//         encryptiv1:"",
//         //密码参数名
//         baseparam2:"",
//         basetype2:"1",
//         urlparaencrypt2:'0',
//         encryptcode2:"",
//         encryptiv2:"",
//         //账套
//         accountcode:"",
//         //企业id(corpid)
//         client_id:"",
//         //应用的凭证密钥(corpsecret)
//         client_secret:"",
//         //263邮箱参数
//         email263_domain:"",
//         email263_cid:"",
//         email263_key:"",
//         //单点登录地址
//         entranceurl:"",
//         //显示顺序
//         showorder:"0",
//         //参数列表数据
//         paramDatas:[],
//     };

//     @action
//     setNewFormStatus = (params = {}) => {
//         let newFormStatus = { ...this.newFormStatus };
//         Object.keys(params).forEach(key => {
//             newFormStatus[key] = params[key];
//         });
//         this.newFormStatus = newFormStatus;
//     };

//     @action
//     setNewFormData = (params = {}) => {
//         let newFormData = { ...this.newFormData };
//         Object.keys(params).forEach(key => {
//             newFormData[key] = params[key];
//         });
//         this.newFormData = newFormData;
//     };

//     @observable
//     sysShareStatus = {
//         shareDatas:[],
//         showAddShare:false,
//     }

//     @action
//     setSysShareStatus = (params = {}) => {
//         let sysShareStatus = { ...this.sysShareStatus };
//         Object.keys(params).forEach(key => {
//             sysShareStatus[key] = params[key];
//         });
//         this.sysShareStatus = sysShareStatus;
//     };

//     //加密算法界面数据
//     @observable
//     encryptClassStatus = {
//         encryptname:"",
//         encryptclass:"",
//         encryptmethod:"",
//         decryptmethod:"",
//         isneedpwd:"",
//         password:"",
//         isneediv:"",
//         ivparam:"",
//         datatype:"",
//         lableList:"",
//         id:"",
//         oldencryptname:"",
//         refInfo:"",
//     };

//     //加密算法测试界面数据
//     @observable
//     encryptClassTestStatus = {
//         plaintext: "test",
//         encryptclass: "",
//         isneedpwd: "",
//         password: "",
//         isneediv: "",
//         ivparam: "",
//         datatype: "",
//         testResult: {},
//         showTest:false,
//         id:"",
//         encryptSpan:"",
//         decryptSpan:"",
//         flag:1,
//     };

//     @action
//     setEncryptClassStatus = (params = {}) => {
//         let encryptClassStatus = { ...this.encryptClassStatus };
//         Object.keys(params).forEach(key => {
//             encryptClassStatus[key] = params[key];
//         });
//         this.encryptClassStatus = encryptClassStatus;
//     };

//     @action
//     setEncryptClassTestStatus = (params = {}) => {
//         let encryptClassTestStatus = { ...this.encryptClassTestStatus };
//         Object.keys(params).forEach(key => {
//             encryptClassTestStatus[key] = params[key];
//         });
//         this.encryptClassTestStatus = encryptClassTestStatus;
//     };

//     @action
//     doInit = (type) => {
//         this.status = {
//             selectedKey: "0",
//             sysListRightMenus: [],
//             encryptListRightMenus: [],
//             rowSelectIds: [],
//             showNewFormDialog_sys: false,
//             showNewFormDialog_encrypt: false,
//             sysRowSelectIds: [],
//             searchSysid: "",
//             searchName: "",
//             searchAllvalue: ""
//         };
//         this.initSys(type);
//         this.initEncryptClass();
//     };

//     @action
//     initSys = (type) => {
//         //集成登录设置
//         this.getOutterSysList(type);
//         this.getOutterSysRightMenu();
//         //获取内外网自动登录ip地址
//         this.getOutterSysIpAddressOperates();
//         this.getOutterSysTypeNameOperates();
//         this.getOutterSysEncryptTypeOperates();
//         this.getOutterSysEncryptClassOperates();
//         this.getOutterSysIsNeedPwdAndIv();
//         this.getOutterSysDefaultEntranceUrl();
//         this.getOutterSysShowOrder();
//     }

//     initEncryptClass = () => {
//         //加密算法设置
//         this.getOutterEncryptList();
//         this.getOutterEncryptRightMenu();
//     }

//     getOutterSysList = (param) => {
//         this.sysTableStore = new TableStore();
//         API.getOutterSysList(param).then(result => {
//             if (result.sessionkey) {
//                 this.sysTableStore.getDatas(result.sessionkey);
//             }
//         });
//     };

//     /**
//      * 共享范围列表
//      */
//     getOutterSysShareList = (params) => {
//         this.sysShareTableStore = new TableStore();
//         API.getOutterSysShareList(params).then(result => {
//             if (result.sessionkey) {
//                 this.sysShareTableStore.getDatas(result.sessionkey);
//             }
//         });
//       };

//     getOutterEncryptList = (params) => {
//       this.encryptTableStore = new TableStore();
//         API.getOutterEncryptList(params).then(result => {
//             if (result.sessionkey) {
//                 this.encryptTableStore.getDatas(result.sessionkey);
//             } else {
//                 this.status = { ...this.status, isAlertPage: true };
//             }
//         });
//     };

//     getOutterSysRightMenu = (params) => {
//         API.getOutterSysRightMenu(params).then(result => {
//             this.status = { ...this.status, sysListRightMenus: result.rightMenus };
//         });
//     };

//     getOutterEncryptRightMenu = (params) => {
//         API.getOutterEncryptRightMenu(params).then(result => {
//             this.status = { ...this.status, encryptListRightMenus: result.rightMenus };
//         });
//     };

//     @action
//     getOutterSysIpAddressOperates = (params) => {
//         API.getOutterSysIpAddressOperates().then(result => {
//             this.setNewFormStatus({sysIpAddressOptions: result.ipAddressOptions});
//             if (result.ipAddressOptions && result.ipAddressOptions.length > 0) {
//                 this.setNewFormData({sysIpAddress:{key:result.ipAddressOptions[0].key,showname:result.ipAddressOptions[0].showname}});
//             }
//         });
//     };

//     getOutterSysTypeNameOperates = (params) => {
//         API.getOutterSysTypeNameOperates().then(result => {
//             this.setNewFormStatus({sysTypeNameOptions: result.typeNameOperates});
//         });
//     };

//     getOutterSysEncryptTypeOperates = (params) => {
//         API.getOutterSysEncryptTypeOperates().then(result => {
//             this.setNewFormStatus({sysEncryptTypeOptions: result.encryptTypeOperates});
//         });
//     };

//     getOutterSysEncryptClassOperates = (params) => {
//         API.getOutterSysEncryptClassOperates().then(result => {
//             this.setNewFormStatus({sysEncryptClassOptions: result.encryptClassOperates});
//             this.setNewFormData({encryptclass: result.firstID});
//         });
//     };

//     getOutterSysIsNeedPwdAndIv = (params) => {
//         API.getOutterSysIsNeedPwdAndIv().then(result => {
//             this.setNewFormStatus({sysneedpwd: result.isneedpwd, sysneediv: result.isneediv});
//         });
//     };

//     getOutterSysDefaultEntranceUrl = (params) => {
//         API.getOutterSysDefaultEntranceUrl().then(result => {
//             this.setNewFormStatus({defaultEntranceUrlList: result.defaultEntranceUrl});
//             this.setDefaultEntranceUrl(0);
//         });
//     };

//     /**
//      * 设置默认单点登录地址
//      */
//     @action
//     setDefaultEntranceUrl = (typeID) => {
//       let list = this.newFormStatus.defaultEntranceUrlList;
//       for (let i = 0; list && i < list.length; i++) {
//         if (list[i].id == typeID) {
//             this.setNewFormData({entranceurl: list[i].value});
//         }
//       }
//     }

//     getOutterSysShowOrder = (params) => {
//         API.getOutterSysShowOrder().then(result => {
//             this.setNewFormData({showorder: result.showorder});
//         });
//     };

//     /**
//      * 设置是否显示加密向量
//      */
//     @action
//     setShowEncryptPwdAndIV = (paramID, flag) => {
//         if (flag == 'sys') {
//             let sysneedpwd = this.newFormStatus.sysneedpwd;
//             for (let i = 0; sysneedpwd && i < sysneedpwd.length; i++) {
//                 if (sysneedpwd[i].id == paramID) {
//                     this.setNewFormStatus({isneedpwd: sysneedpwd[i].value});
//                     break;
//                 }
//             }
//             let sysneediv = this.newFormStatus.sysneediv;
//             for (let i = 0; sysneediv && i < sysneediv.length; i++) {
//                 if (sysneediv[i].id == paramID) {
//                     this.setNewFormStatus({isneediv: sysneediv[i].value});
//                     break;
//                 }
//             }
//         } else if (flag = 'cus') {
//             API.GetCustomEncryptClass({id:paramID}).then(result => {
//                 let isneedpwd = result.isneedpwd;
//                 this.setNewFormStatus({isneedpwd: isneedpwd});

//                 let isneediv = result.isneediv;
//                 this.setNewFormStatus({isneediv: isneediv});
//             });
//         }
//     }

//     /**
//      * 设置参数列表数据
//      */
//     @action
//     setParamDatas = (param) => {
//         this.paramStatus.paramDatas = param;
//     }

//     /**
//      * 重置加密算法页面
//      */
//     @action
//     resetEncryptClass =() => {
//         let params = {
//             encryptname:"",
//             encryptclass:"",
//             encryptmethod:"",
//             decryptmethod:"",
//             isneedpwd:"",
//             password:"",
//             isneediv:"",
//             ivparam:"",
//             datatype:"",
//             lableList:"",
//             id:"",
//             oldencryptname:"",
//             refInfo:"",
//         };
//         this.setEncryptClassStatus(params);
//     }

//     /**
//      * 重置加密算法测试页面
//      */
//     @action
//     resetEncryptClassTest =() => {
//         let params = {
//             plaintext: "test",
//             encryptclass: "",
//             isneedpwd: "",
//             password: "",
//             isneediv: "",
//             ivparam: "",
//             datatype: "",
//             testResult: {},
//             showTest:false,
//             id:"",
//             encryptSpan:"",
//             decryptSpan:"",
//             flag:1,
//         };
//         this.setEncryptClassTestStatus(params);
//     }

//     @action
//     getOutterEncryptEditForm = (params) => {
//         API.getOutterEncryptEditForm(params).then(result => {
//             this.setEncryptClassStatus(result.data);
//         });
//     };

//     /**
//      * 获取加密算法测试页面数据
//      */
//     @action
//     getOutterEncryptClassTestForm = (params) => {
//         API.getOutterEncryptClassTestForm(params).then(result => {
//             this.setEncryptClassTestStatus(result.data);
//             this.testOutterEncryptClass();
//         });
//     };

//     /**
//      * 测试加密算法
//      */
//     @action
//     testOutterEncryptClass = () => {
//         const {plaintext,isneedpwd, password, isneediv, ivparam,datatype,flag,id} = toJS(this.encryptClassTestStatus);
//         if (flag == 0) {
//             Modal.info({
//                 title: getLabel(15172,'系统提示'),
//                 content: getLabel(129546,'规范性测试全部通过，才能进行功能性测试！'),
//                 okText: getLabel(826,'确定'),
//                 onOk() {},
//             });
//         } else {
//             if (!plaintext || (datatype == 1 && isneedpwd == 1 && !password)
//                 || (datatype == 1 && isneediv == 1 && !ivparam)) {
//                 Modal.info({
//                     title: getLabel(15172,'系统提示'),
//                     content: getLabel(384146,'必要信息不完整，红色*为必填项') + "!",
//                     okText: getLabel(826,'确定'),
//                     onOk() {},
//                 });
//             }
//             let params = {operation:"test",id:id,plaintext:plaintext,password:password,ivparam:ivparam};
//             this.operateOutterEncrypt(params);
//         }
//     }

//     //确认
//     confirmModal = (content, func, val) => {
//         //确认信息， 方法， 方法参数
//         Modal.confirm({
//             title: `${getLabel(131329,'信息确认')}`,
//             content: content,
//             okText: `${getLabel(382958,'确定')}`,
//             cancelText:`${getLabel(31129,'取消')}`,
//             onOk: () => func(val),
//         })
//     };

//     /**
//      * 保存加密算法
//      */
//     @action
//     operateOutterEncrypt = (params = {}) => {
//         API.operateOutterEncrypt({...params}).then(result => {
//             let msg = result.msg;
//             if (msg == "exist") {
//                 Modal.info({
//                     title: getLabel(15172,'系统提示'),
//                     content: getLabel(129932,'名称已存在，请重新填写') + "!",
//                     okText: getLabel(826,'确定'),
//                     onOk() {},
//                 });
//             } else if (msg == "success") {
//                 this.setState({showNewFormDialog_encrypt : false});
//                 this.getOutterEncryptList();
//                 this.resetEncryptClass();
//                 if (params.operation = "add") {
//                     //刷新【集成登录设置】页面中的【自定义加密算法】下拉框的数据
//                     this.getOutterSysEncryptClassOperates();
//                 }
//             }
//             if (params.operation == "test") {
//                 let testmsg = result.testmsg;
//                 if (testmsg) {
//                     let status = testmsg.status;
//                     if (status == 1) {// 加密异常
//                         this.setEncryptClassTestStatus({encryptSpan:""});
//                         this.setEncryptClassTestStatus({decryptSpan:""});
//                         Modal.info({
//                             title: getLabel(15172,'系统提示'),
//                             content: getLabel(129643,'加密异常，请确认加密方法是否正确，密钥和向量长度是否符合要求！'),
//                             okText: getLabel(826,'确定'),
//                             maskClosable:false,
//                             onOk() {},
//                         });
//                     } else if(status == 2) {// 解密异常
//                         this.setEncryptClassTestStatus({encryptSpan:""});
//                         this.setEncryptClassTestStatus({decryptSpan:""});
//                         Modal.info({
//                             title: getLabel(15172,'系统提示'),
//                             content: getLabel(129644,'解密异常，请确认解密方法是否正确，密钥和向量长度是否符合要求！'),
//                             okText: getLabel(826,'确定'),
//                             maskClosable:false,
//                             onOk() {},
//                         });
//                     } else if(status == 3) {// 没有解密方法，如MD5算法
//                         this.setEncryptClassTestStatus({encryptSpan:testmsg.encryptStr});
//                         this.setEncryptClassTestStatus({decryptSpan:testmsg.decryptStr});
//                         Modal.info({
//                             title: getLabel(15172,'系统提示'),
//                             content: getLabel(129596,'该算法没有解密方法！'),
//                             okText: getLabel(826,'确定'),
//                             maskClosable:false,
//                             onOk() {},
//                         });
//                     } else {
//                         this.setEncryptClassTestStatus({encryptSpan:testmsg.encryptStr});
//                         this.setEncryptClassTestStatus({decryptSpan:testmsg.decryptStr});
//                     }
//                 }
//             }
//         });
//     };

//     operateOutterSys = (params = {}) => {
//         API.operateOutterSys({...params}).then(result => {
//             let msg = result.msg;
//             if (msg == "success") {
//                 this.getOutterSysList();
//                 this.setState({showNewFormDialog_sys:false});
//                 this.resetNewFormData();
//             } else if (msg == "isDouble") {
//                 Modal.info({
//                     title: getLabel(15172,'系统提示'),
//                     content: getLabel(21011,'系统标识重复'),
//                     okText: getLabel(826,'确定'),
//                     onOk() {},
//                 });
//             }
//             if (params && params.operation == "getShare") {
//                 let shareResult = result.shareResult;
//                 if (shareResult) {
//                     this.setSysShareStatus({shareDatas: shareResult});
//                 }
//             } else if (params && params.operation == "delShare") {
//                 let shareResult = result.shareResult;
//                 if (shareResult == 'success') {
//                     this.operateOutterSys({operation:"getShare", sysid: this.newFormData.sysid});
//                 }
//             } else if (params && params.operation == "addShare") {
//                 this.operateOutterSys({operation:"getShare", sysid: this.newFormData.sysid});
//                 this.setSysShareStatus({showAddShare:false});
//             }
//         });
//     };

//     /**
//      * 重置加密算法页面
//      */
//     @action
//     resetNewFormData =() => {
//         let params = {
//             typeOption:{},
//             //类型
//             typename: "0",
//             //标识
//             sysid:"",
//             //名称
//             name:"",
//             //链接图标
//             filename:"",
//             urllinkimagid:"",
//             //图标大小
//             imagewidth:"32",
//             imageheight:"32",
//             //内外网自动登录
//             autologin:"0",
//             sysIpAddress:{},
//             outternetworks:[],
//             //内网地址
//             iurl:"",
//             //外网地址
//             ourl:"",
//             //请求方式
//             requesttype:{key:"1",showname:"GET"},
//             urlencodeflag:"1",
//             //登录系统编码
//             encodeflag:"0",
//             //加密算法
//             encrypttype:"0",
//             encryptclassId:"",
//             result:"0",
//             //账号参数名
//             baseparam1:"",
//             basetype1:"1",
//             urlparaencrypt1:"0",
//             encryptcode1:"",
//             encryptiv1:"",
//             //密码参数名
//             baseparam2:"",
//             basetype2:"1",
//             urlparaencrypt2:"0",
//             encryptcode2:"",
//             encryptiv2:"",
//             //账套
//             accountcode:"",
//             //企业id(corpid)
//             client_id:"",
//             //应用的凭证密钥(corpsecret)
//             client_secret:"",
//             //263邮箱参数
//             email263_domain:"",
//             email263_cid:"",
//             email263_key:"",
//             //单点登录地址
//             entranceurl:"",
//             //显示顺序
//             showorder:"0",
//             //参数列表数据
//             paramDatas:[],
//         };
//         this.setNewFormData(params);

//         this.setNewFormStatus({isEdit:false});
//     }

//     @action
//     getOutterSysEditForm = (params) => {
//         API.getOutterSysEditForm(params).then(result => {
//             this.setNewFormData(result.data);
//             //参数列表数据初始化
//             let paramDatas = [];
//             let {paramnames, labelnames, paramtypes, paramvalues, paraencrypts, encryptcodes, encryptivs} = result.data;
//             if (paramnames) {
//                 for (let i = 0; i < paramnames.length; i++) {
//                     let tempdata = {};
//                     //参数名
//                     tempdata.paramnames = paramnames[i];
//                     //标签
//                     if (labelnames && labelnames.length > i) {
//                         tempdata.labelnames = labelnames[i];
//                     } else {
//                         tempdata.labelnames = "";
//                     }

//                     //参数值
//                     let temptypes = [];
//                     if (paramtypes && paramtypes.length > i) {
//                         temptypes.push(paramtypes[i]);
//                     } else {
//                         temptypes.push("0");
//                     }
//                     if (paramtypes[i] == 0 || paramtypes[i] == 5) {
//                         if (paramtypes && paramtypes.length > i) {
//                             temptypes.push(paramvalues[i]);
//                         } else {
//                             temptypes.push("0");
//                         }
//                     } else if (paramtypes[i] == 4) {
//                         temptypes.push("");
//                         if (paramtypes && paramtypes.length > i) {
//                             temptypes.push(paramvalues[i]);
//                         } else {
//                             temptypes.push("0");
//                         }
//                     }
//                     tempdata.paramtypes = temptypes;
//                     //是否加密
//                     if (paraencrypts && paraencrypts.length > i) {
//                         tempdata.paraencrypts = paraencrypts[i];
//                     } else {
//                         tempdata.paraencrypts = "";
//                     }
//                     //加密密钥
//                     if (encryptcodes && encryptcodes.length > i) {
//                         tempdata.encryptcodes = encryptcodes[i];
//                     } else {
//                         tempdata.encryptcodes = "";
//                     }
//                     //加密向量
//                     if (encryptivs && encryptivs.length > i) {
//                         tempdata.encryptivs = encryptivs[i];
//                     } else {
//                         tempdata.encryptivs = "";
//                     }
//                     paramDatas.push(tempdata);
//                 }
//             }
//             this.setNewFormData({paramDatas:paramDatas});

//             if (this.newFormData.encrypttype == 2) {
//                 this.setShowEncryptPwdAndIV(this.newFormData.encryptclassId,'cus');
//             } else {
//                 this.setShowEncryptPwdAndIV(this.newFormData.encrypttype,'sys');
//             }
//             this.refreshDatas();
//         });
//     };

//     /**
//      * 刷新数据
//      */
//     @action
//     refreshDatas(datas) {
//         const {paramDatas} = this.newFormData;

//         if (!datas) {
//             datas = paramDatas
//         }
//         datas.map((row) => {
//             //当参数值为表达式参数时
//             if (row.paramtypes && row.paramtypes.length > 0 && row.paramtypes[0] == 5) {
//                 if (!row.com) {
//                     row.com = {
//                         paraencrypts:[],
//                         encryptcodes:[],
//                         encryptivs:[]
//                     };
//                 } else {
//                     row.com.paraencrypts = [];
//                     row.com.encryptcodes = [];
//                     row.com.encryptivs = [];
//                 }
//             } else {
//                 if (!row.com) {
//                     row.com = {
//                         paraencrypts:[{ type: 'checkbox', otherParams:{display:'switch'}, key: 'paraencrypts'}],
//                         encryptcodes:[{ label: '', type: 'INPUT', viewAttr: 2, key: 'encryptcodes'}],
//                         encryptivs:[{ label: '', type: 'INPUT', viewAttr: 2, key: 'encryptivs'}]
//                     };
//                 } else {
//                     row.com.paraencrypts = [{ type: 'checkbox', otherParams:{display:'switch'}, key: 'paraencrypts'}];
//                     row.com.encryptcodes = [{ label: '', type: 'INPUT', viewAttr: 2, key: 'encryptcodes'}];
//                     row.com.encryptivs = [{ label: '', type: 'INPUT', viewAttr: 2, key: 'encryptivs'}];
//                 }

//                 //当是否加密为是时
//                 if (row.paraencrypts == 1) {
//                     if (!row.com) {
//                         row.com = {
//                             encryptcodes:[{ label: '', type: 'INPUT', viewAttr: 2, key: 'encryptcodes',otherParams:{type:'password'}}],
//                             encryptivs:[{ label: '', type: 'INPUT', viewAttr: 2, key: 'encryptivs',otherParams:{type:'password'}}]
//                         };
//                     } else {
//                         row.com.encryptcodes = [{ label: '', type: 'INPUT', viewAttr: 2, key: 'encryptcodes',otherParams:{type:'password'}}];
//                         row.com.encryptivs = [{ label: '', type: 'INPUT', viewAttr: 2, key: 'encryptivs',otherParams:{type:'password'}}];
//                     }
//                 } else {
//                     if (!row.com) {
//                         row.com = {
//                             encryptcodes:[],encryptivs:[]
//                         };
//                     } else {
//                         row.com.encryptcodes = [];
//                         row.com.encryptivs = [];
//                     }
//                 }
//             }
//         });
//         this.setNewFormData({paramDatas:datas});
//         this.refreshParamColumns();
//     }

//     /**
//      * 刷新列是否显示
//      */
//     @action
//     refreshParamColumns() {
//         const {encrypttype, paramDatas} = this.newFormData;
//         const {isneedpwd, isneediv} = this.newFormStatus;
//         let paramColumns = [];

//         paramColumns.push({
//           title: getLabel(20968,'参数名'),
//           dataIndex: 'paramnames',
//           useRecord: true,
//           key: 'paramnames',
//           width: 160,
//           com: [
//             { label: '', type: 'INPUT', viewAttr: 3, key: 'paramnames'},
//           ],
//         });
//         paramColumns.push({
//           title: getLabel(176,'标签'),
//           dataIndex: 'labelnames',
//           useRecord: true,
//           key: 'labelnames',
//           width: 160,
//           com: [
//             { label: '', type: 'INPUT', viewAttr: 2, key: 'labelnames'},
//           ],
//         });

//         let isEncrypt = false;
//         //是不是参数值都是表达式参数
//         let isAllFive = true;
//         paramDatas.map((row) => {
//             if (row.paraencrypts == 1) {
//                 isEncrypt = true;
//             }
//             if (row.paramtypes && row.paramtypes[0] && row.paramtypes[0] != 5) {
//                 isAllFive = false;
//             }
//         });

//         paramColumns.push({
//             title: getLabel(20969,'参数值'),
//             dataIndex: 'paramtypes',
//             useRecord: true,
//             key: 'paramtypes',
//             width: 480,
//             com: [
//               { label:'', type: 'custom', key: 'paramtypes',
//               render: (text, record, index, onEdit) => (
//                 <ParamsType ecId={`${this && this.props && this.props.ecId || ''}_ParamsType@fswgq2@${diffKey}`} record={{...record}} index={index} onParamChange={onEdit}/>
//             )},],
//           });

//         if (encrypttype!="0") {
//             paramColumns.push({
//               title: getLabel(28640,'是否加密'),
//               dataIndex: 'paraencrypts',
//               useRecord: true,
//               key: 'paraencrypts',
//               width: 120,
//               style: {float: 'right'},
//               com: [
//                 { type: 'checkbox', otherParams:{display:'switch'}, key: 'paraencrypts'},
//               ],
//             });
//         }
//         if (encrypttype!="0" && isEncrypt && isAllFive == false && isneedpwd == 1) {
//             paramColumns.push({
//               title: getLabel(32348,'加密密钥'),
//               dataIndex: 'encryptcodes',
//               useRecord: true,
//               key: 'encryptcodes',
//               width: 160,
//               style: {display: 'inline-block', float: 'right'},
//               com: [
//                 { label: '', type: 'INPUT', viewAttr: 2, key: 'encryptcodes'},
//               ],
//             });
//         }
//         if (encrypttype!="0" && isEncrypt && isAllFive == false && isneedpwd == 1 && isneediv == 1) {
//             paramColumns.push({
//               title: getLabel(129315,'加密向量'),
//               dataIndex: 'encryptivs',
//               useRecord: true,
//               key: 'encryptivs',
//               width: 160,
//               visible: false,
//               style: {display: 'inline-block', float: 'right'},
//               com: [
//                 { label: '', type: 'INPUT', viewAttr: 2, key: 'encryptivs'},
//               ],
//             });
//         }
//         this.setNewFormStatus({paramColumns: paramColumns});
//         return paramColumns;
//     }

//     getTest(id) {
//         this.status.testVisible = true;
//         API.operateOutterSys({operation: 'getTestForm', id}).then(res => {
//             this.testForm = new WeaForm();
//             this.testForm.setCondition(res.condition);
//             if (res.msg) {
//                 message.info(res.msg);
//             }
//         });
//     }

//     doTest() {
//         this.testForm.validateForm().then(f=>{
//             if(f.isValid){
//                 const params = this.testForm.getFormParams();
//                 params.operation = 'test';
//                 API.operateOutterSys(params).then(res => {
//                     res.otherPageUrlString && window.open(res.otherPageUrlString)
//                     if (res.msg) {
//                         message.info(res.msg);
//                     }
//                 });
//             } else {
//                 f.showErrors();
//             }
//         });
//     }
// }
