sasp-flow-render 1.1.23 → 1.1.25-decoupling

package/src/components/flowInst/js/workflow.js

@@ -0,0 +1,2269 @@
+// utils/workflow.js
+
+import {AjaxUtil} from "sasp-base";
+
+/**
+ * 工作流引擎类
+ * 支持多步骤、异步操作、自定义弹窗内容、错误处理
+ */
+class WorkflowEngine {
+    initParams(component,flowAttrs = {}){
+        this.$this = component; // required
+        if(!this.$this){
+            console.error("初始化失败,component不能为空");
+            return;
+        }
+        this.flowId = flowAttrs.flowId; // required
+        this.tableviewId = flowAttrs.tableviewId; // 外部调用时初始化必须
+        this.formGloabalInfo = (this.$this.formGloabalInfo || {});
+        this.flowParams = {};
+        this.formComponent = this.formGloabalInfo.formComponent;
+        this.dataId = "";
+        this.formId = "";
+        this.currentInst = {};
+        this.installListObj = this.$this.EVENT_PLUGIN['installEventObj']||{}; //已经安装的流程事件
+        this.loginUser = this.$this.FLOW_CACHE_GLOBAL.getLoginUser();
+        this.skipAutoInit = false;
+        if(flowAttrs.skipAutoInit){
+            this.skipAutoInit = flowAttrs.skipAutoInit;
+        }
+        this.formInfo = {
+            dataId: this.dataId,
+            opt: "view",
+        }
+        this.$flowDialog = this.$this.$flowDialog;
+        this.flowDefine = {};
+        this.flowRecordObj = {};
+        this.flowChartObj = {};
+
+        // 初始化插入部分方法
+        let methods = flowAttrs["methods"] || {};
+        this.initTabNum = methods["initTabNum"];
+        this.tabCrudSearch = methods["tabCrudSearch"];
+        this.batchTabRemove = methods["batchTabRemove"];
+        this.setFlowTabInfo = methods["setFlowTabInfo"];
+        this.getFlowBatchDialog = methods["getFlowBatchDialog"];
+        this.closeFlowBatchDialog = methods["closeFlowBatchDialog"];
+        this.initFormInfo = methods["initFormInfo"];
+        this.saveFormInfo = methods["saveFormInfo"];
+        this.getFormInfo = methods["getFormInfo"];
+        this.flowNextOperation = methods["flowNextOperation"];
+        this.forceUpdateComponent = methods["forceUpdateComponent"];
+        this.nextStepAfterSave = methods["nextStepAfterSave"];
+        this.setParams = methods["setParams"];
+
+        if(!this.initFormInfo){
+            this.initFormInfo = this.$flowDialog.initFormInfo;
+        }
+
+        if(!this.saveFormInfo){
+            this.saveFormInfo = this.$flowDialog.saveFormInfo;
+        }
+
+        if(!this.getFormInfo){
+            this.getFormInfo = this.$flowDialog.getFormInfo;
+        }
+
+        // 流程的参数
+        this.flowInstDataDialog = false;
+        this.nextSteptUserDialog = false;
+        this.doMainDatasObj = {};
+        this.userMap = {};
+        this.userArr = [];
+        this.tabActive = "draft";
+        this.flowDefineByFlowId = {};
+        this.startNodeKey = "";
+        this.startNodeKeyObj = {};
+        this.allNodeInfo = {};
+        this.flowNodeIdToInfo = {};
+        this.flowNodeNameObj = {};
+        this.nodeListButtonObj = {};
+        this.listButtonObj = { // 列表按钮
+            add: "新增",
+            delete: "删除",
+            update: "修改",
+            view: "查看",
+            deal: "处理",
+            flowRecord: "流转记录",
+            flowChart: "流程图",
+        };
+        this.diyButtonsObj= {};
+        this.optColumnWidth = 336;
+        this.nodeFormButtonObj = {};
+        this.nodeFormBtnObj = {};
+        this.startNodeKeyObjByFlowId = {};
+        this.flowVersionNodeObj = {}; //版本号对应的节点对象
+        this.flowVersionNodeObjByFlowId = {};
+        this.flowEventScriptByFlowId = {};
+        this.operateType= {};
+
+        this.nextNode = {};
+        this.description = "";
+        this.saveInstId = "";
+        this.nowNode = {};
+        this.isProceedNext = false;
+        this.nextNodeName = "";
+        this.choosePosUserIds = "";
+        this.choosePosUserIdsObj = {};
+        this.chooseNextUserIdObj = {};
+        this.chooseNextUserNameObj = {};
+        this.chooseNextUserId = "";
+        this.chooseNextUserName = "";
+        this.nextSteptUserArr = [];
+
+        this.newEventObj = {};
+        this.newScriptObj = {};
+        this.scriptObj = {};
+        this.resourceTabOpts = ['draft','pending','processed','rescinded','finished','discontinue','flowQuery'];
+        //表单按钮
+        this.formButtonObj = {
+            saveDraft: "存草稿",
+                completeSign: "加签",
+                turnSign: "转签",
+                nextStep: "下一步",
+                back: "退回",
+                getBack: "取回",
+                cancel: "撤销",
+                stopped: "中止",
+                close: "关闭",
+        export: "导出",
+                retSpecified: "退回指定节点"
+        }
+
+        this.flowParams = {};
+        this.isDisabled = {
+            update: true,
+            deal: true,
+            flowRecord: true,
+            flowChart: true,
+            view: true,
+            saveDraft: true,
+            completeSign: true,
+            turnSign: true,
+            nextStep: true,
+            back: true,
+            cancel: true,
+            stopped: true,
+            close: true,
+            export: true,
+            retSpecified: true,
+            getBack: true,
+            record: true,
+            restore: true,
+        };
+
+        this.formBtnObjDefault = {
+            saveDraft: {
+                text: "存草稿",
+                    type: "success",
+                    icon: "el-icon-check",
+                    disabled: false,
+                    show: true,
+                    method: () => {
+                    this.saveDraft();
+                }
+            },
+
+            nextStep: {
+                text: "下一步",
+                    type: "primary",
+                    icon: "el-icon-d-arrow-right",
+                    disabled: false,
+                    show: true,
+                    method: () => {
+                    this.nextStep();
+                    // this.isDisabled1 = true;
+                    this.$flowDialog.fillFlowDialogParams({
+                        isDisabled1: true
+                    });
+                }
+            },
+
+            completeSign: {
+                text: "加签",
+                    type: "primary",
+                    icon: "saspiconfont pl-icon-jiaqian",
+                    disabled: false,
+                    show: false,
+                    method: () => {
+                    // this.completeSignDialog = true;  // todo加签
+                    this.$flowDialog.operateDialog('completeSignDialog',true);
+                }
+            },
+
+            turnSign: {
+                text: "转签",
+                    type: "primary",
+                    icon: "saspiconfont pl-icon-zhuanqian-icon",
+                    disabled: false,
+                    show: false,
+                    method: () => {
+                    // this.turnSignDialog = true;  // todo转签
+                    this.$flowDialog.operateDialog('turnSignDialog',true);
+                }
+            },
+
+            back: {
+                text: "退回",
+                    type: "danger",
+                    icon: "el-icon-d-arrow-left",
+                    disabled: false,
+                    show: false,
+                    method: () => {
+                    this.backToPrevious(this.currentInst);
+                }
+            },
+
+            retSpecified: {
+                text: "退回指定节点",
+                    type: "danger",
+                    icon: "el-icon-refresh-left",
+                    disabled: false,
+                    show: false,
+                    method: () => {
+                    this.retSpecified(this.currentInst); //退回指定节点
+                }
+            },
+
+            stopped: {
+                text: "中止",
+                    type: "danger",
+                    icon: "saspiconfont pl-icon-yizhongzhi",
+                    disabled: false,
+                    show: false,
+                    method: () => {
+                    this.$this.saspFlowAxios.post(this.$this.api.plFlowInst.stopFlow, {
+                        instId: this.currentInst.flowInstId, type: "0",
+                        procInstId: this.currentInst.linkProcId,
+                        taskId: this.currentInst.taskId
+                    }).then(res => {
+                        if (res && res.data) {
+                            if (res.data.operateSuccess) {
+                                this.$this.$message({type: "success", message: "中止成功！"});
+                                if (this.getFlowBatchDialog && this.getFlowBatchDialog()) {
+                                    this.batchTabRemove(this.currentInst.dataId);
+                                } else {
+                                    this.tabCrudSearch && this.tabCrudSearch();
+                                    this.flowInstDataDialog = false;
+                                    this.$flowDialog.operateDialog('flowInstDataDialog',false);
+                                }
+                                this.initTabNum && this.initTabNum();
+
+                                let remindParam = {
+                                    instId:this.currentInst.flowInstId,
+                                    flowId:this.flowDefine.id,
+                                    flowName:this.flowDefine.flowName,
+                                    // formId:this.formInfo.formId,
+                                    // listViewId:this.formInfo.listViewId,
+                                    dataId:this.formInfo.dataId,
+                                    instType:"stopped"
+                                };
+                                this.$this.saspFlowAxios.post(this.$this.api.plFlowInst.saveRemind,remindParam);
+
+                                //执行事件规则
+                                let currentNodeObj = this.flowNodeIdToInfo[this.currentInst.currentNode] ||{};
+                                if(currentNodeObj.openEvent == '1'){
+                                    this.exeNewFlowEvent("suspend",currentNodeObj.nodeLinkId||'');
+                                }
+                            } else {
+                                this.$this.$message({type: "error", message: res.data.operateMessage});
+                            }
+                        }
+                    });
+                }
+            },
+
+            cancel: {
+                text: "撤销",
+                    type: "danger",
+                    icon: "saspiconfont pl-icon-chexiao",
+                    disabled: false,
+                    show: false,
+                    isView: true,
+                    method: () => {
+                    this.$this.saspFlowAxios.post(this.$this.api.plFlowInst.revokeFlow, {
+                        instId: this.currentInst.flowInstId,
+                        taskId: this.currentInst.taskId
+                    }).then(res => {
+                        if (res && res.data) {
+                            if (res.data.operateSuccess) {
+                                this.$this.$message({type: "success", message: "撤销成功！"});
+                                this.tabCrudSearch && this.tabCrudSearch();
+                                this.flowInstDataDialog = false;
+                                this.$flowDialog.operateDialog('flowInstDataDialog',false);
+                                this.initTabNum && this.initTabNum();
+
+                                let remindParam = {
+                                    instId:this.currentInst.flowInstId,
+                                    flowId:this.flowDefine.id,
+                                    flowName:this.flowDefine.flowName,
+                                    // formId:this.formInfo.formId,
+                                    // listViewId:this.formInfo.listViewId,
+                                    dataId:this.formInfo.dataId,
+                                    instType:"cancel"
+                                };
+                                this.$this.saspFlowAxios.post(this.$this.api.plFlowInst.saveRemind,remindParam);
+
+
+                            } else {
+                                this.$this.$message({type: "error", message: res.data.operateMessage});
+                            }
+                        }
+                    });
+                }
+            },
+
+            getBack: {
+                text: "取回",
+                    type: "danger",
+                    icon: "el-icon-refresh-left",
+                    disabled: false,
+                    show: false,
+                    isView: true,
+                    method: () => {
+                    this.getBackPrevious();
+                }
+            },
+
+            restore: {
+                text: "恢复",
+                    type: "success",
+                    icon: "saspiconfont pl-icon-chexiao",
+                    disabled: false,
+                    show: false,
+                    isView: true,
+                    method: () => {
+                    this.restoreFlow();
+                }
+            },
+            record: {
+                text: "流转记录",
+                    type: "warning",
+                    icon: "saspiconfont pl-icon-liuchengtu",
+                    disabled: false,
+                    show: true,
+                    isView: true,
+                    method: () => {
+                    this.openFlowRecord(this.currentInst);
+                }
+            },
+            close: {
+                text: "关闭",
+                    type: "",
+                    icon: "el-icon-close",
+                    disabled: false,
+                    show: true,
+                    isView: true,
+                    method: () => {
+                    this.flowInstDataDialog = false;
+                    this.$flowDialog.operateDialog('flowInstDataDialog',false);
+                    this.closeFlowBatchDialog && this.closeFlowBatchDialog();
+                }
+            },
+        }
+        this.loadSuccess = false;
+    }
+
+    constructor(component,flowAttrs = {}) {
+        // 工作流配置
+        this.initParams(component,flowAttrs);
+    }
+
+    init(){
+        return new Promise(resolve => {
+            if(!this.skipAutoInit && !this.loadSuccess){
+                this.$this.saspFlowAxios.all([
+                    this.initFlowInfo(),
+                    this.initFlowFormInfo()
+                ]).then(this.$this.saspFlowAxios.spread((resFlow, resForm) => {
+                    this.loadSuccess = true;
+                    resolve();
+                }));
+            }else{
+                resolve();
+            }
+            this.initUserData();
+            this.initDialogProps();
+        })
+    }
+
+    initFlowFormInfo(){
+        return new Promise(resolve => {
+            if(!this.$this.FORM_GLOBAL){
+                this.$this.$message.error("未安装表单组件，请使用自定义表单开发");
+                return;
+            }
+            this.$this.FORM_GLOBAL.getTableViews(this.tableviewId).then(tableviewsData => {
+                if(!tableviewsData || !tableviewsData.id){
+                    this.$message.error("表单资源不存在！");
+                    return;
+                }
+                this.formId = tableviewsData.formId;
+                this.$flowDialog.fillFlowDialogParams({
+                    formId: this.formId,
+                    tableviewId: this.tableviewId,
+                    dataId: this.dataId
+                });
+                resolve();
+            });
+        });
+    }
+
+    initDialogProps() {
+        let dialogProps = {
+            flowNextOperation: this.flowNextOperation,
+            workFlowUtil: this
+        }
+        this.$flowDialog.initDialogProps(dialogProps);
+    }
+
+    // 初始化流程相关信息
+    initFlowInfo() {
+        return new Promise(resolve => {
+            if (this.flowId.includes(",")) {
+                this.getMultiFlowInfo().then(() => {
+                    resolve();
+                })
+            } else {
+                this.getFlowInfo().then(() => {
+                    resolve();
+                });
+            }
+        });
+    }
+
+    /**
+     * 多流程初始化
+     */
+    getMultiFlowInfo() {
+        return new Promise(resolve => {
+            let flowIdArr = this.flowId.split(",").filter(item => item);
+            flowIdArr.forEach(flowId => {
+                this.$this.FLOW_GLOBAL.getFlowDefineById(flowId).then(flowDefine => {
+                    this.flowDefineByFlowId[flowId] = flowDefine;
+                });
+            });
+
+            const initFlowNodeFunc = flowIdArr.map(flowId => (() => this.$this.FLOW_GLOBAL.getFlowNodesByFlowId(flowId)));
+            Promise.all(initFlowNodeFunc.map(func => func())).then(allFlowNodeArr => {
+                //工作流节点
+                this.startNodeKey = "Activity_draft"; // todo 确定startNodeKey的位置
+                for (const allFlowNode of allFlowNodeArr) {
+                    this.startNodeKeyObj = {};
+                    this.flowVersionNodeObj = {};
+                    let flowId = allFlowNode[0].flowId;
+                    this.flowDefine = this.flowDefineByFlowId[flowId];
+                    (allFlowNode || []).forEach(item => {
+                        if (item.nodeLinkId.indexOf("Activity_draft") > -1) {
+                            this.startNodeKey = item.nodeLinkId;
+                            this.startNodeKeyObj[item.version] = item.nodeLinkId; //开始节点对应版本号
+                        }
+                        if (!this.flowVersionNodeObj[item.version]) {
+                            this.$this.$set(this.flowVersionNodeObj, item.version, {});
+                        }
+                        this.$this.$set(this.flowVersionNodeObj[item.version], item.nodeLinkId, item); //版本节点对象
+
+                        this.allNodeInfo[item.id] = item;
+                        this.flowNodeIdToInfo[item.id] = item;
+                        let nodeArr = ['StartEvent', 'ParallelGateway', 'SequenceFlow', 'ExclusiveGateway', 'InclusiveGateway'];
+                        if (item.nodeType && nodeArr.indexOf(item.nodeType) === -1) {
+                            if (!this.flowNodeNameObj[item.nodeLinkId]) {
+                                let nodeName = item.nodeName;
+                                if (this.flowId.includes(",")) {
+                                    nodeName = this.flowDefine.flowName + "-" + item.nodeName;
+                                }
+                                this.$this.$set(this.flowNodeNameObj, item.nodeLinkId, nodeName);
+                            } else {
+                                if (this.flowNodeNameObj[item.nodeLinkId] !== item.nodeName) {
+                                    this.flowNodeNameObj[item.nodeLinkId] = this.flowNodeNameObj[item.nodeLinkId] + "," + item.nodeName;
+                                }
+                            }
+                        }
+                        if (item.nodeType === "UserTask" && (item.nodeLinkId || "").indexOf("Activity_draft") > -1) {
+                            this.draftNodeId = item.id; // 草稿节点id
+                        }
+                        // 行按钮
+                        let listButton = JSON.parse(item.listButton || "[]") || [];
+                        listButton.forEach(button => {
+                            button.showName = button.showName ? button.showName : this.listButtonObj[button.type];
+                        });
+                        this.nodeListButtonObj[item.id] = listButton;
+
+                        // 表单按钮
+                        let formButton = JSON.parse(item.formButton || "[]") || [];
+                        formButton.forEach(button => {
+                            button.showName = button.showName ? button.showName : this.formButtonObj[button.type];
+                        });
+
+                        this.nodeFormButtonObj[item.id] = this.sortButtonArr(formButton);
+                        this.nodeFormBtnObj[item.id] = this.formatterFormButton(formButton);
+                    });
+                    this.$this.$set(this.startNodeKeyObjByFlowId, flowId, this.startNodeKeyObj);
+                    this.$this.$set(this.flowVersionNodeObjByFlowId, flowId, this.flowVersionNodeObj);
+                    // this.initFlowScript().then(() => {
+                    //     resolve(true);
+                    // });
+                }
+                const initFlowScriptFunc = flowIdArr.map(flowId => () => this.initFlowScript(flowId));
+                Promise.all(initFlowScriptFunc.map(func => func())).then(scriptArr => {
+                    (scriptArr || []).forEach(scriptEventObj => {
+                        Object.keys(scriptEventObj).forEach(key => {
+                            if (key) {
+                                this.flowEventScriptByFlowId[key] = scriptEventObj[key];
+                            }
+                        });
+                    });
+                }).catch(reason => {
+                    console.log('流程脚本加载出错了', reason);
+                });
+                let result = {
+                    flowDefineByFlowId : this.flowDefineByFlowId,
+                    startNodeKeyObj : this.startNodeKeyObj,
+                    flowDefine :  this.flowDefineByFlowId[this.flowId],
+                    startNodeKey :  this.startNodeKey,
+                    allNodeInfo :  this.allNodeInfo,
+                    flowNodeIdToInfo :  this.flowNodeIdToInfo,
+                    flowNodeNameObj :  this.flowNodeNameObj,
+                    draftNodeId :  this.draftNodeId,
+                    nodeListButtonObj :  this.nodeListButtonObj,
+                    nodeFormButtonObj :  this.nodeFormButtonObj,
+                    nodeFormBtnObj :  this.nodeFormBtnObj,
+                    startNodeKeyObjByFlowId :  this.startNodeKeyObjByFlowId,
+                    flowVersionNodeObjByFlowId :  this.flowVersionNodeObjByFlowId,
+                    flowEventScriptByFlowId :  this.flowEventScriptByFlowId
+                };
+                resolve(result);
+            });
+        });
+    }
+
+    /**
+     * 初始化流程信息
+     */
+    getFlowInfo(){
+        this.flowDefine.id = this.flowId;
+        return new Promise(resolve => {
+            this.$this.FLOW_GLOBAL.getFlowDefineById(this.flowId).then(flowobj => {
+                this.flowDefine = flowobj;
+                this.$flowDialog.fillFlowDialogParams({
+                    flowDefine: this.flowDefine
+                });
+                let tabSetting = JSON.parse(this.flowDefine.tabSetting,"[]");
+                (tabSetting || []).forEach(item => {
+                    if(item.isUse == '1'){
+                        this.operateType[item.type] = true;
+                    }
+                })
+                let activeArr = [];
+                Object.keys(this.operateType).forEach(key => {
+                    if(this.operateType[key] && this.resourceTabOpts.indexOf(key) > -1){
+                        activeArr.push(key);
+                    }
+                })
+                if(activeArr.length > 0 && activeArr.indexOf("pending") == -1){
+                    this.tabActive = activeArr[0]; // todo 返回tabActive
+                }
+                // this.showModel = flowobj.showModel;
+                // this.showInfo = flowobj.showInfo;
+                // let formType = flowobj.formType;
+                //工作流节点
+                this.startNodeKey = "Activity_draft";
+                this.startNodeKeyObj = {};
+                // let flowVersion = this.flowDefine.flowVersion || '1.0';
+                this.$this.FLOW_GLOBAL.getFlowNodesByFlowId(this.flowId).then(nodeDatas => {
+                    if (nodeDatas) {
+                        nodeDatas.forEach(item => {
+                            if (item.nodeLinkId.indexOf("Activity_draft") > -1) {
+                                this.startNodeKey = item.nodeLinkId;
+                                this.startNodeKeyObj[item.version] = item.nodeLinkId; //开始节点对应版本号
+                            }
+                            if(!this.flowVersionNodeObj[item.version]){
+                                this.$this.$set(this.flowVersionNodeObj,item.version,{});
+                            }
+                            this.$this.$set(this.flowVersionNodeObj[item.version],item.nodeLinkId,item); //版本节点对象
+                            // if(item.version == this.flowDefine.releaseVersion){ //节点信息只取最新版本
+                            this.flowNodeIdToInfo[item.id] = item;
+                            if(item.nodeType&&['StartEvent','ParallelGateway','SequenceFlow','ExclusiveGateway','InclusiveGateway'].indexOf(item.nodeType) == -1){
+                                if(!this.flowNodeNameObj[item.nodeLinkId]){
+                                    this.$this.$set(this.flowNodeNameObj,item.nodeLinkId,item.nodeName);
+                                }else {
+                                    if(this.flowNodeNameObj[item.nodeLinkId] != item.nodeName){
+                                        this.flowNodeNameObj[item.nodeLinkId] = this.flowNodeNameObj[item.nodeLinkId] + "," + item.nodeName;
+                                    }
+                                }
+                            }
+                            if(item.nodeType == "UserTask" && (item.nodeLinkId || "").indexOf("Activity_draft") > -1){
+                                this.draftNodeId = item.id; // 草稿节点id
+                            }
+                            // }
+                            this.allNodeInfo[item.id] = item;
+                            // 行按钮
+                            let listButton = JSON.parse(item.listButton || "[]") || [];
+                            listButton = listButton.filter(item => !item.buttonId);
+                            listButton.forEach(button => {
+                                button.showName = button.showName ? button.showName : this.listButtonObj[button.type];
+                            });
+                            this.nodeListButtonObj[item.id] = listButton;
+
+                            // 表单按钮
+                            let formButton = JSON.parse(item.formButton || "[]") || [];
+                            formButton = formButton.filter(item => !item.buttonId);
+                            formButton.forEach(button => {
+                                button.showName = button.showName ? button.showName : this.formButtonObj[button.type];
+                            });
+
+                            this.nodeFormButtonObj[item.id] = this.sortButtonArr(formButton);
+                            this.nodeFormBtnObj[item.id] = this.formatterFormButton(formButton);
+
+                            // 自定义按钮
+                            if(item.plFlowButtons) {
+                                (item.plFlowButtons || []).forEach(button => {
+                                    this.diyButtonsObj[button.id] = button;
+                                })
+                            }
+
+                            let width = 0;
+                            (this.nodeListButtonObj[item.id] || []).forEach(item => {
+                                let nameLength = item.showName.length;
+                                if (nameLength > 2) {
+                                    width += 100 + (nameLength - 2) * 12;
+                                } else {
+                                    width += 100;
+                                }
+                            });
+                            if (this.optColumnWidth < width) {
+                                this.optColumnWidth = width;
+                            }
+                        });
+
+                        // 显示
+                        // this.isShowAgentSet = true;
+                        // this.$forceUpdate();
+                    }
+                    // 加载工作流脚本与工作流事件规则
+                    this.initFlowScript().then(() => {
+                        let result = {
+                            operateType : this.operateType,
+                            tabActive : this.tabActive,
+                            flowDefine : this.flowDefine,
+                            startNodeKey : this.startNodeKey,
+                            startNodeKeyObj : this.startNodeKeyObj,
+                            flowVersionNodeObj : this.flowVersionNodeObj,
+                            allNodeInfo : this.allNodeInfo,
+                            flowNodeNameObj : this.flowNodeNameObj,
+                            flowNodeIdToInfo : this.flowNodeIdToInfo,
+                            nodeListButtonObj : this.nodeListButtonObj,
+                            nodeFormButtonObj : this.nodeFormButtonObj,
+                            nodeFormBtnObj : this.nodeFormBtnObj,
+                            optColumnWidth : this.optColumnWidth,
+                            diyButtonsObj : this.diyButtonsObj,
+                        };
+                        this.initFlowObj();
+                        resolve(result);
+                    })
+                });
+            });
+        });
+    }
+
+    initFlowObj() {//处理流程定义对象
+        this.isRefreshGetNextUsers = [];
+        let gatewayFields = this.flowDefine.gatewayFields || "";
+        this.isRefreshGetNextUsers = gatewayFields.split(",");
+        Object.keys(this.allNodeInfo).forEach(key => {
+            let obj = this.allNodeInfo[key];
+            if (obj.nodeType === "UserTask" && (!obj.nodeLinkId || obj.nodeLinkId.indexOf('Activity_draft') === -1)) {
+                if (obj.dealerType === "form" && obj.formField) {
+                    this.isRefreshGetNextUsers.push(obj.formField);
+                }
+                if (obj.dealerType === "variable" && obj.variable) {
+                    this.isRefreshGetNextUsers.push(obj.variable);
+                }
+                if (obj.dealerType === "interface" && obj.dealerUrlParam) {
+                    let dealerUrlParam = JSON.parse(obj.dealerUrlParam || "[]");
+                    dealerUrlParam.forEach(param => {
+                        if (param.paramType === "variable") {
+                            this.isRefreshGetNextUsers.push(param.paramVal);
+                        }
+                    })
+                }
+            }
+        });
+        let tabTypeObj= {};
+        if (!this.flowId.includes(",")) {
+            let tabSetting = JSON.parse(this.flowDefine.tabSetting);
+            tabSetting.forEach(data => {
+                this.$this.$set(tabTypeObj, data.type, data);
+            });
+            Object.keys(tabTypeObj).forEach(key => {
+                let objTemp = tabTypeObj[key];
+                objTemp.tabName = objTemp["showName"] || objTemp["name"];
+            });
+            let tabTitleType = this.flowDefine.tabTitleType;
+            if (tabTitleType === "1") {
+                tabTypeObj["showtTabText"] = true;
+                tabTypeObj["showTabIcon"] = true;
+            } else if (tabTitleType === "2") {
+                tabTypeObj["showtTabText"] = true;
+            } else if (tabTitleType === "3") {
+                tabTypeObj["showTabIcon"] = true;
+            }
+        }
+
+        let result = {
+            isRefreshGetNextUsers : this.isRefreshGetNextUsers,
+            tabTypeObj: tabTypeObj
+        }
+        this.setFlowTabInfo && this.setFlowTabInfo(result);
+    }
+
+    // 初始化流程信息end
+
+    /**
+     * 下一步，保存数据以及获取处理人
+     */
+    nextStep() {
+        let afterClickResult;
+        let result;
+        let currentNodeObj = this.flowNodeIdToInfo[this.currentInst.currentNode || this.draftNodeId] ||{};
+        afterClickResult=this.exeFlowEvent("nextStep","afterClick", this.currentInst.currentNode || this.draftNodeId);
+
+        if(typeof afterClickResult == "boolean" && afterClickResult === false){
+            return;
+        }
+
+        if(currentNodeObj.openEvent === '1'){
+            afterClickResult = this.exeNewFlowEvent("nextClick",currentNodeObj.nodeLinkId);
+        }
+
+        if(typeof afterClickResult == "boolean" && afterClickResult === false){
+            return;
+        }
+
+        // let afterValidateResult;
+        // let currentNodeObj = this.flowNodeIdToInfo[this.currentInst.currentNode || this.draftNodeId] ||{};
+        result = this.exeFlowEvent("nextStep","afterValidate", this.currentInst.currentNode || this.draftNodeId);
+        if(typeof result == "boolean" && result === false){
+            return;
+        }
+        if(currentNodeObj.openEvent === '1'){
+            result = this.exeNewFlowEvent("nextCheck",currentNodeObj.nodeLinkId);
+            if(typeof result == "boolean" && result === false){
+                return;
+            }
+        }
+
+        this.isDisabled['nextStep'] = false;
+        this.$flowDialog.fillFlowDialogParams({
+            flowParams: this.flowParams,
+            isDisabled: this.isDisabled
+        });
+        this.saveDataFunc('nextStep').then(flowParams => {
+            this.flowParams = JSON.parse(JSON.stringify(flowParams));
+            this.setParams && this.setParams({
+                flowParams:this.flowParams
+            });
+            let instId = flowParams.flowInstId;
+            this.$this.$set(this.formInfo,"opt","update");
+            this.currentInst.id = instId;
+            this.description = "";
+            this.saveInstId = instId;
+            this.nowNode =  this.allNodeInfo[currentNodeObj.id] || {};
+            this.nextStepAfterSaveFunc().then(resultEvt => {
+                if(!resultEvt){
+                    this.isDisabled['nextStep'] = true;
+                    this.$flowDialog.fillFlowDialogParams({
+                        isDisabled: this.isDisabled
+                    });
+                    return;
+                }
+                this.isProceedNext = true;
+                //获取处理人
+                let obj = {instId: instId, taskId: this.currentInst.taskId,};
+                if(this.nowNode && this.nowNode.dealType && this.nowNode.dealType == 'multi'){
+                    this.$this.$set(obj,'passCondition',this.nowNode.passCondition)
+                }
+                let params = {"SASP_FLOW_USE_VARIABLES":"yes"};
+                // Object.assign(params,flowParams || {},obj);
+                Object.assign(params,obj);
+                let allParamKeys = Object.keys(flowParams || {});
+                allParamKeys.forEach(templateKey => {
+                    if(this.isRefreshGetNextUsers.indexOf(templateKey) > -1){
+                        params[templateKey] = flowParams[templateKey];
+                        if(allParamKeys.indexOf(templateKey + "_SASP_SYS_DATA") > -1){
+                            params[templateKey + "_SASP_SYS_DATA"] = flowParams[templateKey + "_SASP_SYS_DATA"];
+                        }
+                        if(allParamKeys.indexOf(templateKey + "_SASP_SYS_DATA_ID") > -1){
+                            params[templateKey + "_SASP_SYS_DATA_ID"] = flowParams[templateKey + "_SASP_SYS_DATA_ID"];
+                        }
+                    }
+                });
+                this.$flowDialog.fillFlowDialogParams({
+                    flowParams: this.flowParams,
+                    formInfo: this.formInfo,
+                    currentInst: this.currentInst,
+                    description: this.description,
+                    saveInstId: this.saveInstId,
+                    nowNode: this.nowNode,
+                    isProceedNext: this.isProceedNext,
+                });
+                this.$this.saspFlowAxios.post(this.$this.api.plFlowInst.getNextUsers, params).then(res => {
+                    if(!res.data.operateSuccess){
+                        this.isDisabled['nextStep'] = true;
+                        if(res.data.resultObject === 'requestException'){
+                            this.$this.$message.error(res.data.errorInfo);
+                        }else{
+                            this.$this.$message.error("未获取到处理人");
+                        }
+                        return;
+                    }
+                    let obj = {};
+                    if (res && res.data) {
+                        obj = res.data.operateObj || {};
+                        if(res.data.operateMap  && res.data.operateMap.isPassCondition == 0){
+                            this.isProceedNext = false;
+                            this.$flowDialog.fillFlowDialogParams({
+                                isProceedNext: this.isProceedNext,
+                            });
+                        }
+                    }
+                    this.nextNodeName = "";
+                    this.choosePosUserIds = "";
+                    this.choosePosUserIdsObj = {};
+                    this.nextNode = obj;
+                    this.chooseNextUserIdObj = {};
+                    this.chooseNextUserNameObj = {};
+                    this.chooseNextUserId = "";
+                    this.chooseNextUserName = "";
+                    let paramKeyArr = ["nextNodeName","choosePosUserIds","choosePosUserIdsObj","nextNode",
+                        "chooseNextUserIdObj","chooseNextUserNameObj","chooseNextUserId","chooseNextUserName",
+                        "nextSteptUserArr","nextSteptUserType"];
+                    let params = {};
+                    paramKeyArr.forEach(key => {
+                        params[key] = this[key];
+                    })
+                    this.$flowDialog.fillFlowDialogParams(params);
+                    if (obj.nextType == "inclusiveGateway") {
+                        let autoChooseUser = false;
+                        (obj.result || []).forEach(item => {
+                            //获取下一个节点信息
+                            let nextNodeTmp = this.flowNodeIdToInfo[item.nextNodeId] || {};
+                            if (nextNodeTmp.nodeType == "UserTask") {
+                                item.mulitiChooseUser = nextNodeTmp.dealType != "single";
+                                autoChooseUser = nextNodeTmp.autoChooseUser == "1";
+                                if (item.mulitiChooseUser) {
+                                    this.$this.$set(this.chooseNextUserIdObj, item.nodeKey, []);
+                                } else {
+                                    this.$this.$set(this.chooseNextUserIdObj, item.nodeKey, "");
+                                }
+                            } else if (this.nextNode.nodeType == "EndEvent") {
+                                return;
+                            }
+                            let userArr = item.userArr || [];
+                            //自动执行时的自动执行人
+                            if (autoChooseUser) {
+                                if (item.type == "user" && userArr.length == 0) {
+                                    // this.$this.$message({type:"error",message:"没有处理人！"});
+                                    return;
+                                } else {
+                                    let userIds = "";
+                                    let userNames = "";
+                                    userArr.forEach(userInfo => {
+                                        userIds += "," + userInfo.id;
+                                        userNames += "," + userInfo.userName;
+                                    });
+                                    this.chooseNextUserIdObj[item.nodeKey] = userIds.substring(1);
+                                    this.chooseNextUserId = userIds.substring(1);
+                                    this.chooseNextUserName = userNames.substring(1);
+                                    this.$flowDialog.fillFlowDialogParams({
+                                        chooseNextUserId: this.chooseNextUserId,
+                                        chooseNextUserName: this.chooseNextUserName,
+                                        chooseNextUserIdObj: this.chooseNextUserIdObj
+                                    });
+                                    this.$flowDialog.saveNextStept();
+                                }
+                            }
+                            item.nextSteptUserType = obj.type;
+                            if (item.type == "user" || item.type== 'all') {
+                                item.nextSteptUserArr = userArr;
+                            }
+                        });
+                        if(!autoChooseUser){
+                            this.nextSteptUserDialog = true;
+                            this.$flowDialog.operateDialog('nextSteptUserDialog',true);
+                        }
+                    } else {
+                        //获取下一个节点信息
+                        this.nextNode = this.allNodeInfo[obj.nextNodeId] || {};
+                        this.nextNodeName = obj.nextNodeName || "";
+                        let autoChooseUser = false;
+                        this.$flowDialog.fillFlowDialogParams({
+                            nextNode: this.nextNode,
+                            nextNodeName: this.nextNodeName
+                        });
+                        if (this.nextNode.nodeType == "UserTask") {
+                            this.mulitiChooseUser = this.nextNode.dealType != "single";
+                            autoChooseUser = this.nextNode.autoChooseUser == "1";
+                            this.chooseNextUserId = "";
+                            this.chooseNextUserName = "";
+                            this.$flowDialog.fillFlowDialogParams({
+                                chooseNextUserId: this.chooseNextUserId,
+                                chooseNextUserName: this.chooseNextUserName
+                            });
+                        } else if (this.nextNode.nodeType == "EndEvent") {
+                            this.nextSteptUserDialog = true;
+                            this.$flowDialog.operateDialog('nextSteptUserDialog',true);
+                            return;
+                        }
+                        let userArr = obj.userArr || [];
+                        //自动执行时的自动执行人
+                        if (autoChooseUser) {
+                            if (obj.type == "user" && userArr.length == 0) {
+                                this.$this.$message({type: "error", message: "没有处理人！"});
+                                return;
+                            } else {
+                                let userIds = "";
+                                let userNames = "";
+                                userArr.forEach(userInfo => {
+                                    userIds += "," + userInfo.id;
+                                    userNames += "," + userInfo.userName;
+                                });
+                                if (userIds) {
+                                    this.chooseNextUserId = userIds.substring(1);
+                                    this.chooseNextUserName = userNames.substring(1);
+                                }
+                                this.$flowDialog.fillFlowDialogParams({
+                                    chooseNextUserId: this.chooseNextUserId,
+                                    chooseNextUserName: this.chooseNextUserName
+                                });
+                                this.$flowDialog.saveNextStept();
+                            }
+                        }
+                        this.nextSteptUserType = obj.type;
+                        if (obj.type == "user" || obj.type == 'all') {
+                            this.nextSteptUserArr = userArr;
+                        }
+                        this.$flowDialog.fillFlowDialogParams({
+                            nextSteptUserType: this.nextSteptUserType,
+                            nextSteptUserArr: this.nextSteptUserArr
+                        });
+                        if(!autoChooseUser){
+                            this.nextSteptUserDialog = true;
+                            this.$flowDialog.operateDialog('nextSteptUserDialog',true);
+                        }
+                    }
+                    if(this.nextNode.nextType == 'inclusiveGateway'){
+                        (this.nextNode.result || []).forEach(item => {
+                            this.chooseNextUserIdObj[item.nodeKey] = (item.userArr || {}).id;
+                        });
+                        this.$flowDialog.fillFlowDialogParams({
+                            chooseNextUserIdObj: this.chooseNextUserIdObj,
+                        });
+                    }else{
+                        let userInfo = this.nextSteptUserArr[0] || {};
+                        if(this.nextNode.dealType=="single"){
+                            this.chooseNextUserId = userInfo.id;
+                            this.chooseNextUserName = userInfo.userName;
+                            this.$flowDialog.fillFlowDialogParams({
+                                chooseNextUserId: this.chooseNextUserId,
+                                chooseNextUserName: this.chooseNextUserName
+                            });
+                        }
+                        if(this.nextNode.dealType === "multi" && this.nextSteptUserArr.length === 1){
+                            this.chooseNextUserId = [userInfo.id];
+                            this.$flowDialog.fillFlowDialogParams({
+                                chooseNextUserId: this.chooseNextUserId
+                            });
+                        }
+                    }
+                });
+            })
+        });
+    }
+
+    nextStepAfterSaveFunc(){
+        return new Promise(resolve => {
+            if(this.nextStepAfterSave){
+                let result = this.nextStepAfterSave(this.$this,this);
+                if(result && result.then){
+                    result.then(res => {
+                        resolve(res);
+                    })
+                }else{
+                    resolve(result);
+                }
+            }else{
+                resolve(true);
+            }
+        })
+    }
+
+    saveDataFunc(type){ // 保存完成后返回流程的相关变量，通过变量传递到后台驱动流程运转
+        // 保存草稿、下一步保存
+        return new Promise(resolve => {
+            if(this.saveFormInfo){
+                let result = this.saveFormInfo(type);
+                if(result && result.then){
+                    result.then(res => {
+                        if(!res){
+                            this.isDisabled['nextStep'] = true;
+                            return;
+                        }
+                        if(typeof res !== 'object'){
+                            res = {};
+                        }
+                        this.saveFlowData(res).then(flowInstData => {
+                            res['flowInstId'] = flowInstData.id;
+                            resolve(res);
+                        })
+                    })
+                }else{
+                    if(!result){
+                        return;
+                    }
+                    if(typeof result !== 'object'){
+                        result = {};
+                    }
+                    this.saveFlowData(result).then(flowInstData => {
+                        result['flowInstId'] = flowInstData.id;
+                        resolve(result);
+                    })
+                }
+            }else{
+                this.saveFlowData().then(flowInstData => {
+                    let obj = {};
+                    obj['flowInstId'] = flowInstData.id;
+                    resolve(obj);
+                })
+            }
+        })
+    }
+
+    saveFlowData(flowParams){
+        return new Promise(resolve => {
+            flowParams = flowParams || {};
+            let flowSummary = this.getFlowSummary(flowParams);
+            let flowInst = {};
+            let dataId = (flowParams || {}).flowDataId || "";
+            this.dataId = dataId;
+            if(this.currentInst && this.currentInst.id){
+                this.$this.$set(this.formInfo,"opt","update");
+                flowInst = {
+                    "id": this.currentInst.id,
+                    "flowSummary": flowSummary,
+                    "updated": this.loginUser.id,
+                };
+                if(this.formInfo.opt == 'add' || !this.currentInst.linkProcId){  //版本号也要随之更新
+                    flowInst = Object.assign(flowInst,{"version":this.flowDefine.releaseVersion,"isRelease":this.flowDefine.isRelease})
+                }
+                this.$this.saspFlowAxios.post(this.$this.api.plFlowInst.url + "/" + this.formInfo.opt, flowInst).then(instRes => {
+                    this.runFlowEvt();
+                    resolve(instRes.data.operateObj);
+                });
+            }else{
+                let startNodeKey =  this.startNodeKeyObj[this.flowDefine.releaseVersion];
+                if (this.formInfo.opt == "add") {
+                    flowInst = {
+                        flowId: this.flowDefine.id,
+                        flowSummary: flowSummary,
+                        dataId: dataId,
+                        version:this.flowDefine.releaseVersion, //版本号
+                        startTime: this.$this.DATE_UTIL.getCurrentDateTime(), flowStatus: "0",
+                        created: this.loginUser.id,
+                        currentNode: this.flowVersionNodeObj[this.flowDefine.releaseVersion][startNodeKey].id,
+                        isRelease:this.flowDefine.isRelease
+                    };
+                } else {
+                    flowInst = {
+                        id: this.currentInst.id,
+                        flowSummary: flowSummary,
+                        version:this.flowDefine.releaseVersion, //版本号也要随之更新
+                        updated: this.loginUser.id,
+                    };
+                }
+                this.$this.saspFlowAxios.post(this.$this.api.plFlowInst.url + "/" + this.formInfo.opt, flowInst).then(instRes => {
+                    this.runFlowEvt();
+                    resolve(instRes.data.operateObj);
+                    this.currentInst=instRes.data.operateObj;
+                });
+            }
+        })
+    }
+
+    /**
+     * 获取流程概要
+     */
+    getFlowSummary(dataObj, summaryTemplate) {
+        let flowSummary = "";
+        let summarySet = summaryTemplate || this.flowDefine.flowSummary;
+        if (!this.currentInst.linkProcId) { // 草稿数据
+            flowSummary = this.$this.platStringUtil.replaceAll(summarySet, "${startUserName*}", this.loginUser.userName);
+            flowSummary = this.$this.platStringUtil.replaceAll(flowSummary, "${createTime*}", this.$this.DATE_UTIL.getCurrentDateTime());
+        } else {
+            flowSummary = this.$this.platStringUtil.replaceAll(summarySet, "${startUserName*}", this.currentStartUser);
+            flowSummary = this.$this.platStringUtil.replaceAll(flowSummary, "${createTime*}", this.currentStartTime);
+        }
+        flowSummary = this.$this.platStringUtil.replaceAll(flowSummary, "${flowName*}", this.flowDefine.flowName);
+        if (this.flowDefine.summaryNameId) {
+            // flowSummary = flowSummary.toUpperCase();
+            let summaryNameId = JSON.parse(this.flowDefine.summaryNameId);
+            Object.keys(summaryNameId).forEach(fieldName => {
+                let fieldId = summaryNameId[fieldName];
+                if (fieldName && dataObj.hasOwnProperty(fieldId)) {
+                    let replaceVal = dataObj[fieldId];
+                    if(dataObj[fieldId + "_SASP_SYS_DATA"]){
+                        replaceVal = dataObj[fieldId+ "_SASP_SYS_DATA"];
+                    }
+                    if(dataObj[fieldId + "_sequence"]){ // 自增序列
+                        replaceVal = dataObj[fieldId + "_sequence"];
+                    }
+                    flowSummary = this.$this.platStringUtil.replaceAll(flowSummary, "${" + fieldName + "}", replaceVal);
+                }else if(fieldName && dataObj.hasOwnProperty(fieldName)){
+                    let replaceVal = dataObj[fieldName];
+                    if(dataObj[fieldName + "_SASP_SYS_DATA"]){
+                        replaceVal = dataObj[fieldName+ "_SASP_SYS_DATA"];
+                    }
+                    if(dataObj[fieldName + "_sequence"]){ // 自增序列
+                        replaceVal = dataObj[fieldName + "_sequence"];
+                    }
+                    flowSummary = this.$this.platStringUtil.replaceAll(flowSummary, "${" + fieldName + "}", replaceVal);
+                }else{
+                    flowSummary = this.$this.platStringUtil.replaceAll(flowSummary, "${" + fieldName + "}", "");
+                }
+            });
+        }
+        return flowSummary;
+    }
+
+
+    /**
+     *  加载工作流脚本与工作流事件规则
+     */
+    initFlowScript(flowId){
+        if (flowId) {
+            this.flowDefine = this.flowDefineByFlowId[flowId] || {};
+        }
+        return new Promise(resolve => {
+            this.$this.saspFlowAxios.all([
+                this.$this.saspFlowAxios.post(this.$this.api.plFlowScript.find,{"flowId": this.flowDefine.id}),
+                this.$this.saspFlowAxios.post(this.$this.api.plFlowEventDetail.findByFlowAndLeadFunc,{"flowId": this.flowDefine.id,"version":this.flowDefine.flowVersion || "1.0"})
+            ]).then(this.$this.saspFlowAxios.spread((resScript, resEvent) => {
+                // 流程脚本
+                if(resScript){
+                    let scriptDatas = resScript.data || [];
+                    // 脚本order排序
+                    scriptDatas = scriptDatas.sort(sortScript);
+                    function sortScript(a,b){
+                        return Number(a.scriptOrder) - Number(b.scriptOrder);
+                    }
+                    // 根据节点区分
+                    let scriptObj = {};
+                    let arr = ['vm','axios','CTX','formData','LOGINUSER','Ajax','nextNode','resolve'];
+                    scriptDatas.forEach(item => {
+                        // 添加修改是单独区分开，没有节点概念
+                        if(item.executePosition == "add" || item.executePosition == "update"){
+                            if(!scriptObj[item.executePosition]){
+                                scriptObj[item.executePosition] = {};
+                            }
+                            if(!scriptObj[item.executePosition][item.executeTime]){
+                                scriptObj[item.executePosition][item.executeTime] = [];
+                            }
+                            try{
+                                if(item.content){
+                                    let value = item.content;
+                                    value = this.replaceUrl(value);
+                                    item.content = value;
+                                }
+                                scriptObj[item.executePosition][item.executeTime].push(new Function(...arr,item.content));
+                            }catch (e) {
+                                console.log(item.content);
+                                console.log("脚本编译失败！");
+                            }
+                        }else{
+                            if(!scriptObj[item.nodeId]){
+                                scriptObj[item.nodeId] = {};
+                            }
+                            let nodeObj = scriptObj[item.nodeId]; // 节点的所有内容
+                            if(!nodeObj[item.executePosition]){
+                                nodeObj[item.executePosition] = {};
+                            }
+                            let positionObj = nodeObj[item.executePosition]; // 脚本的执行位置，add，update,deal，等
+                            if(!positionObj[item.executeTime]){
+                                positionObj[item.executeTime] = [];
+                            }
+                            let executeTimeArr = positionObj[item.executeTime]; // 在该时间对应的脚本内容数组
+                            try{
+                                if(item.content){
+                                    let value = item.content;
+                                    value = this.replaceUrl(value);
+                                    item.content = value;
+                                }
+                                executeTimeArr.push(new Function(...arr,item.content));
+                            }catch (e) {
+                                console.log(item.content);
+                                console.log("脚本编译失败！");
+                            }
+                        }
+                    })
+                    this.scriptObj = scriptObj;
+                }
+                // 流程事件规则
+                if(resEvent){
+                    let eventDataArr = resEvent.data || [];
+                    let scriptObj = {};
+                    let eventObj = {};
+                    let arr = ['vm','axios','CTX','formData','LOGINUSER','Ajax','nextNode','resolve'];
+                    eventDataArr.forEach(item =>{
+                        let executeTypeArr = (item.executeType || '').split(",");
+                        executeTypeArr.forEach(executeType =>{
+                            if (item.source == 'diy'){
+                                //自定义
+                                // 添加是单独区分开，没有节点概念
+                                if(executeType == "addAfter"){
+                                    if(!scriptObj[executeType]){
+                                        scriptObj[executeType] = [];
+                                    }
+                                    try{
+                                        if(item.funcBody){ //方法体
+                                            let value = item.funcBody;
+                                            value = this.replaceUrl(value);
+                                            item.funcBody = value;
+                                        }
+                                        scriptObj[executeType].push(new Function(...arr,item.funcBody));
+                                    }catch (e) {
+                                        console.log(item.funcBody);
+                                        console.log("脚本编译失败！");
+                                    }
+                                }else{
+                                    if(!scriptObj[item.nodeKey]){
+                                        scriptObj[item.nodeKey] = {};
+                                    }
+                                    let nodeObj = scriptObj[item.nodeKey]; // 节点的所有内容
+                                    if(!nodeObj[executeType]){
+                                        nodeObj[executeType] = [];
+                                    }
+                                    let positionArr = nodeObj[executeType]; // 脚本的执行位置，add，update,deal，等
+                                    try{
+                                        if(item.funcBody){
+                                            let value = item.funcBody;
+                                            value = this.replaceUrl(value);
+                                            item.funcBody = value;
+                                        }
+                                        positionArr.push(new Function(...arr,item.funcBody));
+                                    }catch (e) {
+                                        console.log(item.funcBody);
+                                        console.log("脚本编译失败！");
+                                    }
+                                }
+                                this.newScriptObj = scriptObj;
+                            }else if(item.source == 'event'){ //事件规则
+                                //获取响应配置
+                                // 添加单独区分开，没有节点概念
+                                if(executeType == "addAfter"){
+                                    if(!eventObj[executeType]){
+                                        eventObj[executeType] = {};
+                                    }
+                                    try{
+                                        if(item.resConfigurateion){ //响应配置
+                                            let resConfigurateionObj = JSON.parse(item.resConfigurateion || "{}");
+                                            let eventKey = resConfigurateionObj.eventKey;
+                                            if(!eventObj[executeType][eventKey]){
+                                                eventObj[executeType][eventKey] = [];
+                                            }
+                                            eventObj[executeType][eventKey].push(resConfigurateionObj); //复制响应配置
+                                        }
+                                    }catch (e) {
+                                        console.log(item.funcBody);
+                                        console.log("脚本编译失败！");
+                                    }
+                                }else{
+                                    if(!eventObj[item.nodeKey]){
+                                        eventObj[item.nodeKey] = {};
+                                    }
+                                    let nodeObj = eventObj[item.nodeKey]; // 节点的所有内容
+                                    if(!nodeObj[executeType]){
+                                        nodeObj[executeType] = {};
+                                    }
+                                    let positionObj = nodeObj[executeType]; // 脚本的执行位置，add，update,deal，等
+                                    try{
+                                        if(item.resConfigurateion){//响应配置
+                                            let resConfigurateionObj = JSON.parse(item.resConfigurateion || "{}");
+                                            let eventKey = resConfigurateionObj.eventKey;
+                                            if(!positionObj[eventKey]){
+                                                positionObj[eventKey] = [];
+                                            }
+                                            positionObj[eventKey].push(resConfigurateionObj); //复制响应配\
+                                        }
+                                    }catch (e) {
+                                        console.log(item.funcBody);
+                                        console.log("脚本编译失败！");
+                                    }
+                                }
+                                this.newEventObj = eventObj;
+                            }
+                        });
+                    });
+                }
+                // 结束
+                let obj = {"scriptObj": this.scriptObj, "newScriptObj": this.newScriptObj, "newEventObj": this.newEventObj};
+                resolve({[flowId]: obj});
+            }));
+        })
+    }
+
+    /**
+     * 执行下一步
+     * @returns {Promise<boolean>} 是否继续流程
+     */
+    async executeNextStep() {
+
+    }
+
+    /**
+     * 取消当前流程
+     */
+    cancel() {
+
+    }
+
+    // 脚本执行区
+
+    setFlowScript(flowId) {
+        if (flowId) {
+            let scriptObj = this.flowEventScriptByFlowId[flowId] || {};
+            this.scriptObj = scriptObj.scriptObj || {};
+            this.newScriptObj = scriptObj.newScriptObj || {};
+            this.newEventObj = scriptObj.newEventObj || {};
+        }
+    }
+
+    runFlowEvt(){
+        // let afterClickResult;
+        let currentNodeObj = this.flowNodeIdToInfo[this.currentInst.currentNode || this.draftNodeId] ||{};
+        if(currentNodeObj.openEvent == '1'){
+            this.exeNewFlowEvent("saveAfter", currentNodeObj.nodeLinkId);
+        }
+    }
+
+    /**
+     * 执行工作流脚本，为兼容1.0版本定制
+     */
+    exeFlowEvent(executePosition,executeTime,nodeId){
+        // executePosition(为方便1.0转换，与1.0保持相同):add/update/handle/nextStep/view/columnFormatter
+        // executePosition:add:['afterClick'],update:['afterClick'],handle:['afterClick'],
+        // nextStep:['afterClick','afterValidate','submitSuccess'],view:['afterClick'],
+        // （columnFormatter:['finished','end']?暂时不用）
+        let formData = {};
+        if(this.getFormInfo){
+            formData = this.getFormInfo();
+        }
+        let CTX = "";
+        let paramValues = [this.$this,this.$this.saspFlowAxios,CTX,formData,this.loginUser,AjaxUtil,this.nextNode,null]; // 入参
+        if(executePosition == "add" || executePosition == "update"){
+            ((this.scriptObj[executePosition] || {})[executeTime] || []).forEach(event => {
+                event && event(...paramValues); // 执行事件
+            });
+            return;
+        }
+        let eventArr = ((this.scriptObj[nodeId] || {})[executePosition] || {})[executeTime] || [];
+        let result=true;
+        try{
+            eventArr.forEach(event => {
+                let eventResult=event && event(...paramValues); // 执行事件
+                if(eventResult ==false){
+                    throw new Error("ending");//报错，就跳出循环
+                }
+            })
+        }catch (e) {
+            console.log(e);
+            result=false;
+        }
+        return result;
+    }
+
+    /**
+     * 执行工作流新版本事件规则
+     */
+    exeNewFlowEvent(executeType,nodeKey){
+        let formData = {};
+        if(this.getFormInfo){
+            formData = this.getFormInfo();
+        }
+        //执行自定义脚本
+        // let CTX = window.JAVA_URL;
+        let CTX = "";
+        let paramValues = [this.$this,this.$this.saspFlowAxios,CTX,formData,this.loginUser,AjaxUtil,this.nextNode]; // 入参
+        if(executeType == "addAfter"){ //新增或后
+            (this.newScriptObj[executeType] || []).forEach(event => {
+                event && event(...paramValues); // 执行事件
+            });
+
+            //执行事件规则脚本
+            Object.keys(this.newEventObj[executeType] || {}).forEach(eventKey =>{
+                if(this.installListObj[eventKey]
+                    && this.installListObj[eventKey]["config"]
+                    && this.installListObj[eventKey]["config"].methods.renderFlowConfig){
+                    let affectContentArr = this.newEventObj[executeType][eventKey] || [];
+                    affectContentArr.forEach(affectContent =>{
+                        this.installListObj[eventKey]["config"].methods.renderFlowConfig(this.$this,this.$this.CTX,this.$this.saspFlowAxios,this.nextNode,formData,affectContent);
+                    });
+                }
+            });
+            return;
+        }
+        let eventArr = (this.newScriptObj[nodeKey] || {})[executeType] || [];
+        let result=true;
+        try{
+            eventArr.forEach(event => {
+                let eventResult=event && event(...paramValues); // 执行事件
+                if(eventResult ==false){
+                    throw new Error("ending");//报错，就跳出循环
+                }
+            });
+
+            let eventObj = (this.newEventObj[nodeKey] || {})[executeType] || {};
+            Object.keys(eventObj).forEach(eventKey =>{
+                if(this.installListObj[eventKey]
+                    && this.installListObj[eventKey]["config"]
+                    && this.installListObj[eventKey]["config"].methods.renderFlowConfig){
+                    let affectContentArr = eventObj[eventKey] || [];
+                    affectContentArr.forEach(affectContent =>{
+                        this.installListObj[eventKey]["config"].methods.renderFlowConfig(this.$this,this.$this.CTX,this.$this.saspFlowAxios,this.nextNode,formData,affectContent,executeType);
+                    });
+                }
+            });
+        }catch (e) {
+            console.log(e);
+            result=false;
+        }
+
+        return result;
+
+    }
+    // end脚本执行结束
+
+    
+    // buttonMethod,按钮方法
+
+    // 打开前方法
+    /**
+     * 打开[添加]窗口
+     */
+    openAddFlowForm() {
+        return new Promise(resolve => {
+            this.init().then(() => {
+                let nowVersion = this.flowDefine.releaseVersion; //只要已发布最小版本为1.0
+                this.currentRowData = {};
+                this.initFieldStatus(this.startNodeKeyObj[nowVersion],nowVersion).then(()=>{
+                    this.flowInstDataDialog = true;
+                    this.$flowDialog.operateDialog('flowInstDataDialog',true);
+                    this.$this.$nextTick(() => {
+                        this.initFormInfoFunc('add').then(() => {
+                            this.formBtnArr = this.getAddAndUpdateFormBtn({});
+                            Object.assign(this.formInfo, {
+                                dataId: "",
+                                opt: "add"
+                            });
+                            this.currentInst = {};
+                            this.$this.$nextTick(() => {
+                                this.exeFlowEvent("add","afterClick");
+                                let startNodeKey = this.startNodeKeyObj[nowVersion];
+                                let startNodeObj = this.flowVersionNodeObj[nowVersion][startNodeKey] || {};
+                                if(startNodeObj.openEvent == '1'){
+                                    this.exeNewFlowEvent("addAfter");//新事件规则
+                                }
+                            })
+                            let result = {
+                                currentRowData: this.currentRowData,
+                                formBtnArr: this.formBtnArr,
+                                currentInst: this.currentInst,
+                                formInfo: this.formInfo
+                            };
+                            this.$flowDialog.fillFlowDialogParams(result);
+                            resolve(result);
+                        })
+                    });
+                });
+            })
+        });
+    }
+
+    initFormInfoFunc(type,rowData){
+        if(!rowData){
+            rowData = {};
+        }
+        let dataId = rowData.dataId || "";
+        let nodeObjs = this.flowVersionNodeObj[this.flowDefine.releaseVersion];
+        let startNodeKey =  this.startNodeKeyObj[rowData.version];
+        let nodeKey = rowData.nodeKey;
+        let currentNode = nodeObjs[nodeKey || startNodeKey];
+        if(type === 'add'){
+            let version = this.flowDefine.releaseVersion;
+            currentNode = this.flowVersionNodeObj[version][this.startNodeKeyObj[version]];
+        }
+        return new Promise(resolve => {
+            if(this.initFormInfo){
+                let promise = this.initFormInfo(type,dataId,JSON.parse(currentNode.fieldOperate || "{}"),rowData);
+                this.forceUpdateComponent && this.forceUpdateComponent();
+                if(promise.then){
+                    promise.then(() => {
+                        resolve();
+                    })
+                }else{
+                    resolve();
+                }
+            } else{
+                resolve();
+            }
+        })
+    }
+    /**
+     * 打开[修改和处理]窗口
+     */
+    initUpdateFlowForm(row, type) {
+        this.currentRowData = row;
+        this.currNodeName = 'noEnd';
+        if (this.flowId.includes(',')) {
+            this.flowDefine = this.flowDefineByFlowId[row.flowId];
+            this.startNodeKeyObj = this.startNodeKeyObjByFlowId[row.flowId];
+            this.flowVersionNodeObj = this.flowVersionNodeObjByFlowId[row.flowId];
+            this.initFlowObj();
+            // 加载工作流脚本与工作流事件规则
+            // this.initFlowScript();
+            // Object.assign(this.formInfo, this.formInfoByFlowId[row.flowId]);
+        }
+
+        return new Promise(resolve => {
+            let startNodeKey =  this.startNodeKeyObj[row.version];
+            this.initFieldStatus(row.nodeKey || startNodeKey,row.version).then(()=>{
+                this.initFormInfoFunc(type,row).then(() => {
+                    this.currentStartUser = this.userMap[row.startUserId] || "";
+                    this.currentStartTime = row.startTime;
+                    this.currentInst = row;
+
+                    Object.assign(this.formInfo, {
+                        dataId: row.dataId,
+                        opt: "update"
+                    });
+                    this.formBtnArr = this.getAddAndUpdateFormBtn(row);
+                    let result = {
+                        currentRowData: this.currentRowData,
+                        currNodeName : this.currNodeName,
+                        flowDefine: this.flowDefine,
+                        startNodeKeyObj: this.startNodeKeyObj,
+                        flowVersionNodeObj: this.flowVersionNodeObj,
+                        currentStartUser : this.currentStartUser,
+                        currentStartTime : this.currentStartTime,
+                        currentInst : this.currentInst,
+                        formInfo : this.formInfo,
+                        formBtnArr : this.formBtnArr,
+                        dataId : row.dataId
+                    }
+                    resolve(result);
+                });
+            })
+        })
+    }
+
+    /**
+     * 打开[修改和处理]窗口
+     */
+    openUpdateFlowForm(row,executePosition) {
+        return new Promise(resolve => {
+            this.init().then(() => {
+                if (this.flowId.includes(",")) {
+                    this.setFlowScript(row.flowId);
+                }
+                this.currentRowData = row;
+                this.currNodeName = 'noEnd';
+                let currentNodeObj1 = this.flowNodeIdToInfo[row.currentNode] ||{};
+                let result = this.exeNewFlowEvent("editBefore",currentNodeObj1.nodeLinkId ||'');//新事件规则
+                if(result === false && typeof result == "boolean"){
+                    return;
+                }
+                this.flowInstDataDialog = true;
+                this.$flowDialog.fillFlowDialogParams({
+                    flowDefine: this.flowDefine,
+                    formInfo: this.formInfo
+                });
+                this.$flowDialog.operateDialog('flowInstDataDialog',true);
+                this.initUpdateFlowForm(row, 'update').then(() =>{
+                    this.$this.$nextTick(() => {
+                        this.exeFlowEvent(executePosition,"afterClick",row.currentNode);
+                        let currentNodeObj = this.flowNodeIdToInfo[row.currentNode] ||{};
+                        if(currentNodeObj.openEvent === '1'){ //开启事件
+                            this.exeNewFlowEvent("editAfter",currentNodeObj.nodeLinkId ||'');//新事件规则
+                        }
+                        let result = {
+                            currentRowData: this.currentRowData,
+                            currNodeName : this.currNodeName,
+                            flowDefine: this.flowDefine,
+                            startNodeKeyObj: this.startNodeKeyObj,
+                            flowVersionNodeObj: this.flowVersionNodeObj,
+                            currentStartUser : this.currentStartUser,
+                            currentStartTime : this.currentStartTime,
+                            currentInst : this.currentInst,
+                            formInfo : this.formInfo,
+                            formBtnArr : this.formBtnArr
+                        }
+                        this.$flowDialog.fillFlowDialogParams(result);
+                        resolve(result);
+                    })
+                });
+            });
+        });
+    }
+
+    /**
+     * 打开[查看]窗口
+     */
+    openViewFlowForm(row) {
+        return new Promise(resolve => {
+            this.init().then(() => {
+                this.currentRowData = row;
+                let startNodeKey =  this.startNodeKeyObj[row.version];
+                if (row.currentNodeName === "结束"){
+                    this.currNodeName = "end";
+                }
+                this.initFieldStatus(row.nodeKey || startNodeKey,row.version,row.flowStatus).then(() =>{
+                    this.$flowDialog.fillFlowDialogParams({
+                        flowDefine: this.flowDefine,
+                        formInfo: this.formInfo
+                    });
+                    this.flowInstDataDialog = true;
+                    this.$flowDialog.operateDialog('flowInstDataDialog',true);
+                    this.$this.$nextTick(() => {
+                        this.initFormInfoFunc('view',row).then(() => {
+                            this.currentStartUser = this.userMap[row.startUserId] || "";
+                            this.currentStartTime = row.startTime;
+                            this.currentInst = row;
+
+                            Object.assign(this.formInfo, {
+                                dataId: row.dataId,
+                                opt: "view",
+                            });
+                            this.formBtnArr = this.getViewFormBtn(row);
+                            let result = {
+                                currentRowData: this.currentRowData,
+                                currNodeName : this.currNodeName,
+                                currentStartUser : this.currentStartUser,
+                                currentStartTime : this.currentStartTime,
+                                currentInst : this.currentInst,
+                                formInfo : this.formInfo,
+                                formBtnArr : this.formBtnArr,
+                            }
+                            this.$flowDialog.fillFlowDialogParams(result);
+                            resolve(result);
+                        });
+                    });
+                });
+            });
+        })
+    }
+
+    // 打开前方法end
+
+
+
+    /**
+     * 存草稿
+     */
+    saveDraft() {
+        // let loading = this.$this.$loading({
+        //     lock: true,
+        //     spinner: 'el-icon-loading',
+        //     background: 'rgba(0, 0, 0, 0.7)'
+        // })
+
+        this.saveDataFunc('draft').then(resData => {
+            this.tabCrudSearch && this.tabCrudSearch(); // todo 回调刷新方法，初始化置入即可
+
+            this.flowInstDataDialog = false;
+            this.$flowDialog.operateDialog('flowInstDataDialog',false);
+            if (resData.flowInstId) {
+                this.$this.$message({type: "success", message: "保存成功！"});
+                if (this.getFlowBatchDialog && this.getFlowBatchDialog()) {//批量处理 需处理tab页
+                    this.batchSaveDraft();
+                }
+            } else {
+                this.$this.$message({type: "error", message: "保存失败！"});
+            }
+            // loading && loading.close();
+            this.currentInst={};
+        });
+    }
+
+    /**
+     * 批量处理存草稿
+     */
+    batchSaveDraft() {
+        this.batchTabRemove(this.currentInst.dataId);
+    }
+
+    /**
+     * 回退到上一步
+     */
+    backToPrevious() {
+        let loading = this.$this.$loading({
+            lock: true,
+            text: '正在退回，请稍后....',
+            spinner: 'el-icon-loading',
+            background: 'rgba(0, 0, 0, 0.7)'
+        })
+        let currentInst = this.currentInst;
+        this.$this.$prompt('退回备注', '确定要退回至上一个节点吗?', {
+            confirmButtonText: '确定',
+            cancelButtonText: '取消',
+            inputType: 'textarea',
+        }).then(({ value }) => {
+            this.$this.saspFlowAxios.post(this.$this.api.plFlowInst.backRewrite,
+                {
+                    taskId:currentInst.taskId,
+                    remarks: value
+                }).then(res => {
+                if (res && res.data && res.data.operateSuccess) {
+                    this.$this.$message({type: "success", message: "退回成功！"});
+                    this.initTabNum && this.initTabNum();
+                    if (this.getFlowBatchDialog && this.getFlowBatchDialog()) {
+                        this.batchTabRemove(this.currentInst.dataId);
+                    } else {
+                        this.tabCrudSearch && this.tabCrudSearch();
+                    }
+                } else {
+                    this.$this.$message({type: "error", message: res.data.operateMessage});
+                }
+                loading && loading.close();
+                this.flowInstDataDialog = false;
+                this.$flowDialog.operateDialog('flowInstDataDialog',false);
+            })
+        }).catch(() => {
+            loading && loading.close();
+        });
+    }
+
+
+    /**
+     * 取回
+     */
+    getBackPrevious() {
+        let loading = this.$this.$loading({
+            lock: true,
+            text: '正在取回，请稍后....',
+            spinner: 'el-icon-loading',
+            background: 'rgba(0, 0, 0, 0.7)'
+        })
+        let currentInst = this.currentInst;
+        this.$this.$confirm('确定要取回吗?', '警告', {
+            confirmButtonText: '确定',
+            cancelButtonText: '取消',
+        }).then(() => {
+            this.$this.saspFlowAxios.post(this.$this.api.plFlowInst.getBackRewrite,
+                {
+                    flowInstId: currentInst.flowInstId,
+                }).then(res => {
+                if (res && res.data && res.data.operateSuccess) {
+                    this.$this.$message({type: "success", message: "取回成功！"});
+                    this.initTabNum && this.initTabNum();
+                    if (this.getFlowBatchDialog && this.getFlowBatchDialog()) {
+                        this.batchTabRemove(this.currentInst.dataId);
+                    } else {
+                        this.tabCrudSearch && this.tabCrudSearch();
+                    }
+                } else {
+                    this.$this.$message({type: "error", message: res.data.operateMessage});
+                }
+                loading && loading.close();
+                this.flowInstDataDialog = false;
+                this.$flowDialog.operateDialog('flowInstDataDialog',false);
+            })
+        }).catch(() => {
+            loading && loading.close();
+        });
+    }
+
+    /**
+     * 打开退回节点窗口
+     */
+    retSpecified(currentInst){
+        let flowInstId = currentInst.flowInstId;
+        this.$this.saspFlowAxios.post(this.$this.api.plFlowInst.getBackData,{"flowInstId":flowInstId}).then(res => {
+            this.backNodeArr = [];
+            if(res.data.operateSuccess){
+                let result = res.data.resultObject || [];
+                if(result.length == 0){
+                    this.$this.$message.warning("没有可以退回的节点！");
+                    return;
+                }
+                let arr = [];
+                result.forEach((item,index) =>{
+                    // if(index != res.data.resultObject.length -1){
+                    //     this.backNodeArr.push(item);
+                    // }
+                    if(item["endTimeNull"]){
+                        arr.push(item);
+                    }else{
+                        this.backNodeArr.push(item);
+                    }
+                });
+                this.backNodeArr = this.backNodeArr.concat(arr);
+                this.backNodeArr.splice(this.backNodeArr.length - 1,1);
+                this.isDisabled2 = true;
+                this.backMsg = "";
+                this.backNodeId = "";
+                this.backDialogVisible = true;
+                this.$flowDialog.operateDialog('backDialogVisible',true);
+            }
+        })
+    }
+
+    /**
+     * 恢复方法
+     */
+    restoreFlow() {
+        this.$this.saspFlowAxios.post(this.$this.api.plFlowInst.stopFlow, {
+            instId: this.currentInst.flowInstId, type: "1",
+            procInstId: this.currentInst.linkProcId,
+            taskId: this.currentInst.taskId
+        }).then(res => {
+            if (res && res.data) {
+                if (res.data.operateSuccess) {
+                    this.$this.$message({type: "success", message: "恢复成功！"});
+                    this.flowInstDataDialog = false;
+                    this.$flowDialog.operateDialog('flowInstDataDialog',false);
+                    if (this.getFlowBatchDialog && this.getFlowBatchDialog()) {
+                        this.batchTabRemove(this.currentInst.dataId);
+                    } else {
+                        this.tabCrudSearch && this.tabCrudSearch();
+                    }
+                    this.initTabNum && this.initTabNum();
+                } else {
+                    this.$this.$message({type: "error", message: res.data.operateMessage});
+                }
+            }
+        })
+    }
+
+    /**
+     * 打开流转记录窗口
+     * @param row 流程行数据
+     */
+    openFlowRecord(row) {
+        let arr = ["2", "3", "4"]; // 旧版本的已办结已撤销以及已中止数据通过旧版接口查询流转记录
+        if (arr.indexOf(row.flowStatus) > -1 && row.isOldData === "1") {
+            this.flowRecordObj = {instId: row.flowInstId || "", oldDialogVisible: true};
+        } else {
+            this.flowRecordObj = {instId: row.flowInstId || "", dialogVisible: true};
+        }
+        this.$flowDialog.fillFlowDialogParams({
+            flowRecordObj: this.flowRecordObj
+        });
+    }
+
+    openFlowChart(row) {
+        let flowId = "";
+        let instId = "";
+        let linkProcId = "";
+        let isRelease = "";
+        if (row) {
+            flowId = row.flowId;
+            instId = row.flowInstId;
+            linkProcId = row.linkProcId;
+            isRelease = row.isRelease;
+        }
+        this.flowChartObj = {flowId: flowId,instId: instId,linkProcId:linkProcId,isRelease:isRelease, dialogVisible: true};
+        this.$flowDialog.fillFlowDialogParams({
+            flowChartObj: this.flowChartObj,
+        })
+    }
+    
+    // end of button methods 按钮方法结束
+
+    // 功能区域，用于作为一些方法处理数据
+
+    // 自定义按钮窗口回调函数
+    openDiyButtonEvent(type,row, button) {
+        let formData = {};
+        if(this.getFormInfo){
+            formData = this.getFormInfo();
+        }
+        if(type === 'list') {
+            this.execDiyBtnScripts(type,row,button.funcBody);
+        }else {
+            this.execDiyBtnScripts(type,formData,button.funcBody);
+        }
+    }
+
+    judeDiyButton(tabActive,button) {
+        if(tabActive === 'pending') {
+            return button.position === 'table' && button.nodeId === this.currentInst.currentNode;
+        }
+        return button.position === 'table' && button.buttonSign.indexOf(tabActive) > -1;
+    }
+
+    execDiyBtnScripts(type,data,fnBody) {
+        try {
+            fnBody = this.replaceUrl(fnBody);
+            fnBody = fnBody.replace(/\\'/g, "'").replace(/&quot;/g, "\"");
+            if(type === 'list') {
+                new Function('vm,rowData,Ajax', fnBody)(this.$this,data,AjaxUtil);
+            }else {
+                new Function('vm,formData,Ajax', fnBody)(this.$this,data,AjaxUtil);
+            }
+        } catch (e) {
+            console.log("自定义按钮事件执行错误！", e);
+        }
+    }
+
+    /**
+     * 获取[添加、修改和处理]的操作按钮
+     */
+    getAddAndUpdateFormBtn(row) {
+        //走版本
+        let arrNodeFormBtns = [];
+        if(row.version){
+            arrNodeFormBtns = this.nodeFormBtnObj[(this.flowVersionNodeObj[row.version][row.nodeKey || this.startNodeKeyObj[row.version]] || {}).id];
+        }else {
+            arrNodeFormBtns = this.nodeFormBtnObj[this.flowVersionNodeObj[this.flowDefine.releaseVersion][this.startNodeKeyObj[this.flowDefine.releaseVersion]].id];
+        }
+        let hideBtnTypes = new Set(["getBack","stopped"]);
+        if (this.tabActive == "draft") {
+            hideBtnTypes.add("flowRecord");
+            hideBtnTypes.add("record");
+        }else if(this.tabActive == "pending"){//待处理
+            hideBtnTypes.add("cancel");
+            if(row.operateStatus=='1'||row.operateStatus=='3'){//如果是加签转签 不需要部分按钮
+                hideBtnTypes.add("retSpecified");
+                hideBtnTypes.add("back");
+                hideBtnTypes.add("completeSign");
+                hideBtnTypes.add("turnSign");
+            }
+        }
+
+        return this.formatterFormBtnByHideBtnTypes(arrNodeFormBtns, hideBtnTypes);
+    }
+
+    /**
+     * 根据隐藏按钮类型格式化按钮信息
+     */
+    formatterFormBtnByHideBtnTypes(arrFormBtns, hideBtnTypes) {
+        let arrResults = [];
+        arrFormBtns.forEach(data => {
+            let objTmp = Object.assign({}, data);
+            hideBtnTypes.has(data.btnType) && (objTmp.show = false);
+            if(this.tabActive == "discontinue" && data.btnType == "restore" && !hideBtnTypes.has(data.btnType)){
+                objTmp.show = true;
+            }
+            if(this.tabActive == "processed" && data.btnType == "getBack" && !hideBtnTypes.has(data.btnType)){
+                objTmp.show = true;
+            }
+            if(this.tabActive == "processed" && data.btnType == "cancel" && !hideBtnTypes.has(data.btnType)){
+                objTmp.show = true;
+            }
+            arrResults.push(objTmp);
+        });
+        return arrResults;
+    }
+
+    /**
+     * 获取[查看]的操作按钮
+     */
+    getViewFormBtn(row) {
+        //走版本
+        let arrNodeFormBtns = [];
+        if(row.version){
+            arrNodeFormBtns = this.nodeFormBtnObj[(this.flowVersionNodeObj[row.version][row.nodeKey || this.startNodeKeyObj[row.version]] || {}).id];
+        }else {
+            arrNodeFormBtns = this.nodeFormBtnObj[this.flowVersionNodeObj[this.flowDefine.releaseVersion][this.startNodeKeyObj[this.flowDefine.releaseVersion]].id];
+        }
+        let hideBtnTypes = new Set(["getBack", "cancel", "restore"]);
+        if (this.tabActive == "processed") { // 已处理
+
+            // 上个节点的处理可以取回（已开启按钮的情况下）
+            if ((row.beforeDealer || "").split(",").indexOf(this.loginUser.id) > -1) {
+                hideBtnTypes.delete("getBack");
+            }
+
+            // 流程的发起人可以撤销（已开启按钮的情况下）
+            if (row.startUserId == this.loginUser.id) {
+                // hideBtnTypes.delete("cancel");
+            }
+            //被挂起数据只有查看按钮
+            if(row.hangUp == '1'){
+                hideBtnTypes.add("getBack");
+                hideBtnTypes.add("cancel");
+                hideBtnTypes.add("restore");
+            }
+        } else if (this.tabActive == "discontinue" && row.discontinueUserId == this.loginUser.id) { // 已中止
+            // 当前登陆用户是中止人才显示恢复按钮（已开启按钮的情况下）
+            hideBtnTypes.delete("restore");
+        }
+
+        return this.formatterFormBtnByHideBtnTypes(arrNodeFormBtns, hideBtnTypes);
+    }
+    
+    initFieldStatus(nodeKey,version,flowStatus) {
+        return new Promise(resolve => {
+            resolve();
+        });
+    }
+
+    replaceUrl(value){
+        if(window.ADMIN_URL && (value.indexOf("/admin/") > -1 || value.indexOf("/oaadmin/") > -1)){
+            if(value.indexOf("/admin/")  > -1){
+                value = this.$this.platStringUtil.replaceAll(value,"/admin/", window.ADMIN_URL + "/");
+            }else{
+                value = this.$this.platStringUtil.replaceAll(value,"/oaadmin/",window.ADMIN_URL + "/");
+            }
+        }
+        if(window.FLOW_URL && (value.indexOf("/flow/") > -1 || value.indexOf("/oaflow/") > -1)){
+            if(value.indexOf("/flow/")  > -1){
+                value = this.$this.platStringUtil.replaceAll(value,"/flow/", window.FLOW_URL + "/");
+            }else{
+                value = this.$this.platStringUtil.replaceAll(value,"/oaflow/",window.FLOW_URL + "/");
+            }
+        }
+        if(window.FORM_RENDER_URL && (value.indexOf("/form/")  > -1|| value.indexOf("/oaform/") > -1)){
+            if(value.indexOf("/form/")  > -1){
+                value = this.$this.platStringUtil.replaceAll(value,"/form/", window.FORM_RENDER_URL + "/");
+            }else{
+                value = this.$this.platStringUtil.replaceAll(value,"/oaform/",window.FORM_RENDER_URL + "/");
+            }
+        }
+        if(window.OA_URL && (value.indexOf("/project/") > -1 || value.indexOf("/oaproject/") > -1)){
+            if(value.indexOf("/project/")  > -1){
+                value = this.$this.platStringUtil.replaceAll(value,"/project/", window.OA_URL + "/");
+            }else{
+                value = this.$this.platStringUtil.replaceAll(value,"/oaproject/",window.OA_URL + "/");
+            }
+        }
+        value = this.$this.platStringUtil.replaceAll(value,"window.JAVA_URL","''");
+        value = this.$this.platStringUtil.replaceAll(value,"JAVA_URL","''");
+        value = this.$this.platStringUtil.replaceAll(value,"window.baseUrl","''");
+        value = this.$this.platStringUtil.replaceAll(value,"baseUrl","''");
+        return value;
+    }
+
+    /**
+     * 格式化表单操作按钮
+     */
+    formatterFormButton(formButton) {
+
+        let formBtnObj = {};
+        let formBtnArr = [];
+
+        for (let [key, data] of Object.entries(this.formBtnObjDefault)) {
+            formBtnObj[key] = Object.assign({btnType: key}, data);
+        }
+
+        let objTmp;
+        (formButton || []).forEach(data => {
+            if (formBtnObj[data.type]) {
+                objTmp = formBtnObj[data.type];
+                objTmp.show = (data.isUse != '0');
+                objTmp.text = data.showName || objTmp.text;
+            }
+        });
+
+        for (let [key, data] of Object.entries(formBtnObj)) {
+            formBtnArr.push(data);
+        }
+        return formBtnArr;
+    }
+
+    sortButtonArr(formButton) {
+        let objBtnOrder = {
+            "saveDraft": 1,
+            "nextStep": 2,
+            "completeSign": 3,
+            "turnSign": 4,
+            "retSpecified": 5,
+            "back": 6,
+            "stopped": 7,
+            "close": 8
+        };
+        (formButton || []).forEach(data => {
+            data.order = objBtnOrder[data.type] || data.order;
+        });
+        return formButton;
+    }
+
+    // 获取流程用户数据
+    initUserData(){
+        // 先载入系统接口数据
+        let userArr = this.$this.INTER_CACHE.getUserArr();
+        if(userArr && userArr.length > 0){
+            this.userMap = this.$this.INTER_CACHE.getUserMap();
+            this.userArr = userArr;
+        }else{
+            this.$this.saspFlowAxios.post(this.$this.api.plFlowInterface.find,{sysInterName:'userData',interType:'sys',interStatus:'1'}).then(res => {
+                if((res.data || []).length === 0){
+                    return;
+                }
+                let dataInter = res.data[0];
+                this.loadUserData(dataInter);
+            })
+        }
+    }
+    loadUserData(dataInter){
+        this.$this.saspFlowAxios.post(this.$this.api.plFlowDomain.findRealUrl,{status:'1'}).then(res => {
+            (res.data || []).forEach(item => {
+                this.doMainDatasObj[item.id] = item.domainUrl;
+            })
+            // 解析用户数据
+            this.analyseRequest(dataInter).then(data => {
+                let arr = [];
+                let userIdArr = [];
+                data.forEach(item => {
+                    item.dataUserId = item[dataInter["idCode"] || "userId"];
+                    item.dataKey = item.dataUserId;
+                    item.flowDataType = "user";
+                    item.dataLabel = item[dataInter["showCode"] || "userName"];
+                    item.dataOrgId = item[dataInter["orgCode"] || "orgId"];
+                    item.dataPosId = item[dataInter["posCode"] || "posId"];
+                    if(item.dataOrgId){
+                        item.dataParentId = item.orgId;
+                    }
+                    if(item.dataPosId){
+                        item.dataParentId = item.posId;
+                    }
+                    if(userIdArr.indexOf(item.dataKey) === -1){
+                        arr.push({
+                            id:item.dataKey,
+                            userName:item.dataLabel
+                        })
+                        userIdArr.push(item.dataKey);
+                    }
+                })
+                this.userArr = arr;
+                this.$this.INTER_CACHE.setUserArr(arr);
+                this.$this.userMap = this.$this.INTER_CACHE.getUserMap();
+            })
+        })
+    }
+    analyseRequest(dataInter){
+        return new Promise(resolve => {
+            let domainUrl = this.doMainDatasObj[dataInter.domainId] || "";
+            let url = domainUrl + dataInter.requestUrl;
+            let requestParam = JSON.parse(dataInter.requestParam || "[]");
+            let obj = {};
+            requestParam.forEach(item => {
+                if(!item.key){
+                    return;
+                }
+                obj[item.key] = item.value || ""; // 注意这里要replace ${userCode}
+            })
+            if(dataInter.requestType === 'post'){
+                this.$this.saspFlowAxios.post(url,obj).then(res => {
+                    this.$this.INTER_CACHE.setCacheInfo(dataInter.sysInterName,res.data);
+                    resolve(res.data || []);
+                })
+            }else{
+                let params = "";
+                let arr = []
+                Object.keys(obj).forEach(key => {
+                    arr.push(key + "=" + obj[key]);
+                })
+                params = arr.join("&");
+                if(params){
+                    if(url.indexOf("?") > -1){
+                        url += "&" + params;
+                    }else{
+                        url += "?" + params;
+                    }
+                }
+                this.$this.saspFlowAxios(url).then(res => {
+                    this.$this.INTER_CACHE.setCacheInfo(dataInter.sysInterName,res.data);
+                    resolve(res.data || []);
+                })
+            }
+        })
+    }
+
+    open(dataId,type,callback){
+        if(!this.tableviewId){
+            this.$this.$message.error("请先设置tableviewId");
+            return;
+        }
+        this.init().then(() => {
+            this.formInfo["dataId"] = dataId;
+            this.$flowDialog.fillFlowDialogParams({
+                formId: this.formId,
+                tableviewId: this.tableviewId,
+                dataId: dataId || "",
+                formInfo: this.formInfo
+            });
+            if(dataId){
+                this.$this.saspFlowAxios.post(this.$this.api.plFlowInst.getFlowInstByFlowDataId,{flowId:this.flowId,dataId:dataId}).then(res => {
+                    if(!res.data){
+                        this.$this.$message.error("未获取到此流程数据！");
+                        return;
+                    }
+                    let rowData = res.data || {};
+                    if(type !== "view" && rowData.operateAuth === "0"){
+                        console.log("当前登录用户无此流程数据操作权限，已自动切换为查看！");
+                        type = "view";
+                    }
+                    if(rowData.linkProcId){
+                        this.tabActive = "pending";
+                    }else{
+                        this.tabActive = "draft";
+                    }
+                    this.currentInst = rowData;
+                    if(type === "view"){
+                        this.openViewFlowForm(rowData).then(() => {
+                            callback && callback(this,this.$this);
+                        })
+                    }else{
+                        let executePosition = "update";
+                        if(rowData.linkProcId){
+                            executePosition = "handle";
+                        }
+                        this.openUpdateFlowForm(rowData,executePosition).then(() => {
+                            callback && callback(this,this.$this);
+                        })
+                    }
+                });
+            }else{
+                this.currentInst = {};
+                this.tabActive = "draft";
+                this.openAddFlowForm().then(() => {
+                    callback && callback(this,this.$this);
+                })
+            }
+        })
+    }
+
+    openFlowDialog(args){
+        this.$flowDialog.openFlowDialog(args);
+    }
+
+    openRecord(flowId,dataId){
+        this.$this.saspFlowAxios.post(this.$this.api.plFlowInst.getFlowInstByFlowDataId,{flowId:(flowId || this.flowId),dataId:dataId}).then(res => {
+            if (!res.data) {
+                this.$this.$message.error("未获取到此流程数据！");
+                return;
+            }
+            let currentInst = res.data || {};
+            this.openFlowRecord(currentInst);
+        });
+    }
+
+    openChart(flowId,dataId){
+        if(dataId){
+            this.$this.saspFlowAxios.post(this.$this.api.plFlowInst.getFlowInstByFlowDataId,{flowId:flowId || this.flowId,dataId:dataId}).then(res => {
+                if (!res.data) {
+                    this.$this.$message.error("未获取到此流程数据");
+                    return;
+                }
+                let currentInst = res.data || {};
+                this.openFlowChart(currentInst);
+            });
+        }else{
+            this.openFlowChart({flowId:(flowId || this.flowId)});
+        }
+    }
+}
+
+export default {
+    workflow: WorkflowEngine
+}