JS SDK

工作流组件提供两个 JS 库，提供前端流程相关接口，ProcessUtil 调用了新版 API，TaskUtil 调用了旧版 API，两个库中的方法不完全相同

• ProcessUtil：/UI2/comp/wfmui/components/wfmui/js/processUtil.js，调用了新版 API
• TaskUtil：/UI2/comp/wfmui/components/wfmui/js/taskUtil.js，调用了旧版 API

调用时添加如下引用，然后通过 ProcessUtil 和 TaskUtil 调用

import ProcessUtil from "$UI/comp/wfmui/components/wfmui/js/processUtil"
import TaskUtil from "$UI/comp/wfmui/components/wfmui/js/taskUtil"

相关的SDK中status参数的说明可以参考任务 API中"相关API中任务状态参数值说明"

判断是否添加企业工作流应用

函数名：    hasWF
参数 
    page    {Page} 页面对象
返回
    {Promise}
示例：
    const hasWf = await ProcessUtil.hasWF(this);

从流程或任务返回数据中获取总数

函数名：    getTotal
参数 
    res    流程或是任务返回数据，从返回数据中获取 content-range  
示例：
    onTaskDataCustomRefresh = async (event) => {
        event.async = true;
        event.promise = ProcessUtil.queryOwnerWaitTask(this, {}).then(async(res) => {
            await this.loadToTaskData(res.data,event.options.append,"taskData");  
            event.source.setTotal(ProcessUtil.getTotal(res));
        });  
    }

生成任务的表单地址

函数名 buildFormUrlByTask
参数
     row  {JSONObject}  任务数据, 必须有以下属性: id, sKindID, sStatusID, sEURL, sProcess, sActivity, sExecutorFID, sData1
    isReadonly 是否只读，默认false
返回 
    {String}
示例：
    let mainData = this.comp("mainData");
    let row=mainData.getCurrentRow().toJson({format: "simple"}); 
    let url = ProcessUtil.buildFormUrlByTask(row, true);

统计相关

根据流程统计流程实例数

函数名：countPIByProcess
参数
     option  {JSON} 选项，支持的选项有: limit, offset, orderBy
     page    {Page} 页面对象
返回  
    {Promise}
示例: 
    TaskUtil.countPIByProcess({limit: 20, offset: 0, orderBy: "sProcessName DESC"});

根据流程统计流程任务数

函数名 countTaskByProcess
参数
     option {JSON}  选项，支持的选项有: personFIDs，filter,kind,status,limit, offset, orderBy
     page   {Page}  页面对象
返回  
    {Promise}
示例: 
    TaskUtil.countTaskByProcess({kind:"task", status:"wait", limit: 20, offset: 0, orderBy: "sProcessName DESC"});

根据业务数据查询结束的流程实例

函数名：queryFinishPIByData
参数
     sData1   {String} 业务数据
     process  {String} 流程标识(可以为空)
     columns  {String} 返回的列(可以为空)
返回：
     流程实例数组
示例：
     taskUtil.queryFinishPIByData(id).then((result)=>{
          if (result.length > 0){
               //wfmui是流程组件
               wfmui.restartQuery(result[0].SA_Task);
          }else{
               message.info("没有找到结束的流程实例");
          }
     });

根据业务数据查询流程实例

函数名 queryPIByData
参数
     sData1   {String} 业务数据
     process  {String} 流程标识(可以为空)
     status   {String} 流程实例状态, 支持的值有空值, waiting, finished, 默认值是空值
     filter   {String} 过滤条件, 使用KSQL语法的过滤条件, 例如  SA_Task.sName like '张%'
     columns  {String} 返回的列(可以为空)
返回 
    {Promise}

根据流程实例 id 查询流程的活动任务

函数名 queryActiveTaskByPI
参数
     pi       {String} 流程实例id
     columns  {String} 返回的列(可以为空)
返回 
    {Promise}

根据任务 id 查询流程的活动任务

函数名 queryActiveTaskByPIForTask
参数
     task  {String} 任务id
返回 
    {Promise}

根据业务数据查询活动任务

函数 queryActiveTaskByData
参数
     sData1   {String} 业务数据
     process  {String} 流程标识(可以为空)
     columns  {String} 返回的列(可以为空)
返回 
    {Promise}

任务相关

新建单个任务

函数名 insertTask
说明
    新建一个任务，显示在我的待办中，结束任务调用 TaskUtil.finishExternalTask
参数
     name          {String} 名称
     executorFIDs  {List}   执行者, FID的形成的列表
     data          {String} 业务数据
     process       {String} 流程标识
     activity      {String} 环节标识
     curl          {String} 创建页面
     eurl          {String} 执行页面
     options       {JSON}   任务的其它扩展属性(json格式)
返回 
    {Promise}
示例
     TaskUtil.insertTask("新建任务", ["人的FID"], "页面数据", "流程标识", "环节标识","创建页面", "执行页面", {sData2: "业务数据2"}); 

    let fid = this.comp("wxContext0").getCurrentPersonMemberFID();
    TaskUtil.insertTask("新建任务", [fid], "123456789", 
            "/SA/wf/manager/managerProcess", "taskCenter",
            "/new/mobileapp/mobile/nengjian/xinjian_tz.w", 
            "/new/mobileapp/mobile/nengjian/xinjian_tz.w", {});

新建多个任务

函数名 insertTasks
参数
     name          {String} 名称
     executorFIDs  {List}   执行者, FID的形成的列表
     data          {String} 业务数据
     process       {String} 流程标识
     activity      {String} 环节标识
     curl          {String} 创建页面
     eurl          {String} 执行页面
     options       {JSON}   任务的其它扩展属性(json格式)
返回 
    {Promise}
示例
     TaskUtil.insertTasks("新建多个任务", ["人的FID"], "页面数据", "流程标识", "环节标识",    "创建页面", "执行页面", {sData2: "业务数据2"});

新建通知

函数名 insertNotice
说明
    新建一个通知，显示在我的待阅中
参数
     name          {String} 名称
     executorFIDs  {List}   执行者, FID的形成的列表
     data          {String} 业务数据
     process       {String} 流程标识
     activity      {String} 环节标识
     curl          {String} 创建页面
     eurl          {String} 执行页面
     options       {JSON}   任务的其它扩展属性
返回 
    {Promise}
示例
    TaskUtil.insertNotice("新建通知", ["人的FID"], "页面数据", "流程标识", "环节标识", "创建页面", "执行页面", {sData2: "业务数据2"});  

    let fid = this.comp("wxContext0").getCurrentPersonMemberFID();
    TaskUtil.insertNotice("新建通知", [fid], "123456", 
            "/SA/wf/manager/managerProcess", "taskCenter",
            "/new/mobileapp/mobile/nengjian/xinjian_tz.w", 
            "/new/mobileapp/mobile/nengjian/xinjian_tz.w", {});

结束外部任务

函数名 finishExternalTask
参数
     task  {String} 任务ID
返回 
    {Promise}
示例
    TaskUtil.finishExternalTask(this.params.task);

执行任务

函数名：executeTask
参数 
    page    {Page} 页面对象
    row    {JSONObject} 任务数据, 必须有以下属性: id, sExecutorFID
返回
    {Promise}
示例：
    const hasWf=await ProcessUtil.executeTask(this,row);

打开任务

函数名：openTask
参数 
    page    {Page} 页面对象
    row    {JSONObject} 任务数据
示例：
    ProcessUtil.openTask(this,row);

打开已办（只读）任务

函数名：openFinishTask
参数 
    page    {Page} 页面对象
    row    {JSONObject} 任务数据
示例：
    ProcessUtil.openFinishTask(this,row);

执行并打开任务

函数名：executeAndOpenTask
参数 
    page    {Page} 页面对象
    row    {JSONObject} 任务数据
示例：
    ProcessUtil.executeAndOpenTask(this,row);

查看当前人任务

函数名：viewTask
参数 
    page    {Page} 页面对象
    row    {JSONObject} 任务数据
    contextComp    上下文组件
示例：
    ProcessUtil.viewTask(this, row, this.comp("wxContext0"))

更新任务数据

函数名：updateTask
参数 
    row    任务数据
    page    页面对象
返回
    {Promise} 
示例：
    onEditTitleModalOk = async (event) => {
        var taskData = this.comp("taskData");
        let row = {
            "id": taskData.getCurrentRowID(),
            "sName": taskData.getValue("sName")
        }
        try{
            await ProcessUtil.updateTask(row,this);
            message.info(this.i18n("修改标题成功",import.meta.url));
            taskData.refreshData();
        }catch(e){
            message.error(this.i18n("修改标题失败",import.meta.url) + " : " + e);
        }
    }

回收任务

函数名：recycle
参数 
    row    任务数据，SA_Task及sCreatorFID必填
    page    页面对象
返回
    {Promise} 
示例：
    await ProcessUtil.recycle(row, this);

唤醒流程任务

函数名：resumeProcess
参数 
    taskId    任务标识
    page    页面对象
返回
    {Promise} 
示例：
    await ProcessUtil.resumeProcess("taskId", this);

查询当前人的待办、已办、待阅、已阅

函数名：queryOwnerWaitTask（待办）、queryOwnerFinishTask（已办）、queryOwnerWaitNotice（待阅）、queryOwnerFinishNotice（已阅）
参数 
    page    {Page} 页面对象
      option {JSON} 查询选项
         参数格式：
         {
             limit: 20,            分页大小
             offset: 0,            当前位置 
             process: "",        流程标识 
             filter: ""            过滤条件，例如: SA_Task.sName like '%张三%'
         }
返回
    {Promise}
示例：
    onTaskDataCustomRefresh = async (event) => {
        event.async = true;
        event.promise = ProcessUtil.queryOwnerWaitTask(this, {}).then(async(res) => {
            await this.loadToTaskData(res.data,event.options.append,"taskData");  
            event.source.setTotal(ProcessUtil.getTotal(res));
        });  
    }

更新任务变量、任务备份、任务从备份还原、任务归档

函数名：taskArchive
参数 
    page 页面对象
    action    动作，variable（更新任务变量）、backup（任务备份）、reset（任务从备份还原）、archive（任务归档）
    params    动作参数，variable:{
                    task，    流程实例标识
                    vars    任务变量
                },
                archive:{
                    begin,    开始日期
                    end    结束日期
                }
示例：
    let pageData=this.comp("pageData");
    let begin=pageData.getValue("stDateTime");
    let end=pageData.getValue("etDateTime");  
    let rsp=await ProcessUtil.taskArchive(this,"archive",{begin,end});
    let rsp=await ProcessUtil.taskArchive(this,"backup");
    let rsp=await ProcessUtil.taskArchive(this,"reset");

获取任务数据

函数名：queryTask
参数 
    page    {Page} 页面对象
      option {JSON} 查询选项
         参数格式：
         {
             limit: 20,            分页大小
             offset: 0,            当前位置 
             process: "",        流程标识 
            kind:"",        任务类型，task、notice、pi
            status:"",        任务状态，executing、finished、paused、aborted
             filter: "",        过滤条件，例如: SA_Task.sName like '%张三%'
            columns:"",        自定义查询返回字段，例如：sName,sCreateTime,sExecutorFName
            distinct:false,        是否去重，默认false
            orderBy:"",        排序，例如：sCreateTime DESC
            sData1:"",        业务数据id
            processName:"",        流程名称，精确查询
            piCreatorName:"",    实例创建人名称
            searchText:"",        关键词搜索，支持sName、sTypeName、sCreatorPersonName、sExecutorPersonName、sStatusName、sCreateTime、sActualFinishTime字段模糊查询
            flowId:"",        流程id
            variables:{},        过滤条件中变量
            rangeTime:{beginDate,endDate},    创建时间范围
            id:"",            任务id
            shard:""        查看归档数据，histroy
         }
返回
    {Promise}
示例：
    let res = await ProcessUtil.queryTask(this, { "id": task });

查询任务（待办、已办、已提交）数量

函数名：countTask
参数 
    page    页面对象
    params:{
        filter,    //过滤条件，例如 SA_Task.sName='张三'
        status,    //任务状态，取值范围["waiting"、 "finished"、 "submited"]，默认值"waiting"；
        org        //允许多值，使用“,”分隔;组织范围，可以是组织的ID或FID，默认是当前人；允许多值，使用“,”分隔
    }
返回：
    int
示例：
    let {data}=await ProcessUtil.countTask(this);

根据组织获取任务数据

函数名：queryTaskByOrg、queryOwnerTask
参数 
    page    {Page} 页面对象
      option {JSON} 查询选项
         参数格式：
         {
             limit: 20,            分页大小
             offset: 0,            当前位置 
             process: "",        流程标识 
            kind:"",        任务类型，task、notice、pi
            status:"",        任务状态，waiting、finished
             filter: "",        过滤条件，例如: SA_Task.sName like '%张三%'
            columns:"",        自定义查询返回字段，例如：sName,sCreateTime,sExecutorFName
            distinct:false,        是否去重，默认false
            orderBy:"",        排序，例如：sCreateTime DESC
            processName:"",        流程名称，精确查询
            piCreatorName:"",    实例创建人名称
            searchText:"",        关键词搜索，支持sName、sTypeName、sCreatorPersonName、sExecutorPersonName、sStatusName、sCreateTime、sActualFinishTime字段模糊查询
            taskName:"",        任务名称，模糊查询
            variables:{},        过滤条件中变量
            rangeTime:{beginDate,endDate},    创建时间范围
            org:""            组织
         }
返回
    {Promise}
示例：
    let info = ({ process: res.data[0].sProcess, activity: res.data[0].sActivity });
    var filter = "SA_Task<>'" + task + "' AND SA_Task.sKindID<>'tkNotice' AND SA_Task.sProcess='" + info.process + "' AND SA_Task.sActivity='" + info.activity + "'";
    let option={};
    option.limit = -1;
    option.offset = 0;
    option.status = "waiting";
    option.filter = filter;
    let res = await ProcessUtil.queryTaskByOrg(this, option);

获取流程实例任务

函数名：queryTaskByPI
参数 
    page    {Page} 页面对象
      option {JSON} 查询选项，同queryTask参数说明
示例：
    let flowData = this.comp("flowData");
    let filterData = this.comp("filterData");
    let {data}=await ProcessUtil.queryTaskByPI(this, {
        "searchText": filterData.getValue("searchTextTask"),
        "flowId": flowData.getCurrentRowID(),
        "shard": this.isHistroy() ? "histroy" : ""
    })

流程相关

获取流程定义

函数名：queryProcessDefine
参数 
    page    {Page} 页面对象
      option {JSON} 查询选项
         参数格式：
         {
             limit: 20,            分页大小
             offset: 0,            当前位置 
             process: "",        流程标识 
             filter: "",        过滤条件，例如: SA_Task.sName like '%张三%'
            orderBy:"",        排序，例如：sCreateTime DESC
            searchText:"",        关键词搜索，支持sName、sTypeName、sCreatorPersonName、sExecutorPersonName、sStatusName、sCreateTime、sActualFinishTime字段模糊查询
            isProcessSubadmin:false,        是否流程子管理员
            variables:{},        过滤条件中变量
            version:"",        版本号
            shard:""        查看归档数据，histroy
         }
返回
    {Promise} 
示例：
    onMainDataCustomRefresh = async (event) => {
        let searchText = this.comp("pageData").getValue("searchText");
        let self = this;
        event.async = true;

        event.promise = ProcessUtil.queryProcessDefine(this, {
            "offset": event.offset || 0,
            "limit": event.limit || 20,
            "version": -1,
            "isProcessSubadmin": true,
            //filter,
            searchText
        }).then((res) => {
            event.source.loadData(res.data || [], event.options.append);
            event.source.setTotal(ProcessUtil.getTotal(res));
        });
    }

更新流程

函数名：updateProcess
参数 
    row:[]    流程数据,数组支持更新多个，注意每条数据必须要有主键id
    page    页面对象
返回
    {Promise} 
示例：
    let updateData = { sDisabledAutoMainVersion: 0, id: row.id, version: row.version };
    let rsp = await ProcessUtil.updateProcess([updateData], this);

删除流程

函数名：deleteProcess
参数 
    id    流程主键id
    page    页面对象
返回
    {Promise} 
示例：
    let rsp = await ProcessUtil.deleteProcess(id, this);

发布流程

函数名：publishProcess
参数 
    ids    流程主键id,多个使用","隔开
    page    页面对象
返回
    {Promise} 
示例：
    await ProcessUtil.publishProcess("id1,id2", this);

更新流程拥有者

函数名：updateProcessOwner
参数 
    process    流程标识
    fid     拥有者fid
    fname     拥有者全路径名称
    page    页面对象
返回
    {Promise} 
示例：
     onOrgDialogMessage = async ({ message: msg }) => {
         if (!msg.isOk) {
             return;
         }
         let person = msg.data;
         let mainData = this.comp("mainData").getCurrentRow();
         try{
             await ProcessUtil.updateProcessOwner(mainData.sProcess, person.fid, person.fname, this);
             this.comp("mainData").refreshData();
             message.info(this.i18n("设置流程拥有者成功",import.meta.url));
         } catch(e) {
             message.error(this.i18n("设置流程拥有者失败",import.meta.url) + " : " + e);
         }
     }

更新指定版本流程

函数名：updateProcessMainVersion
参数 
    process    流程标识
    mainVersion    流程版本号
    page    页面对象
返回
    {Promise} 
示例：
     onSetMainVersionBtnClick = ({process,pversion}) => (event) => {
         let self=this;
         let rsp=await ProcessUtil.updateProcessMainVersion(process,pversion,self);  
         if(rsp.statusCode==200){
             self.comp("processData").refreshData();
             message.info(self.i18n("设置成功",import.meta.url));
         }else{
             message.error(self.i18n("设置失败",import.meta.url));
         }  
     }

获取流程实例

函数名：queryPI
参数 
    page    {Page} 页面对象
      option {JSON} 查询选项，同 queryTaskByOrg 参数说明
示例：
    let res = await ProcessUtil.queryPI(this, option);

删除流程实例

函数名：deletePI
参数 
    row    流程实例数据
    page    页面对象
返回
    {Promise} 
示例：
    await ProcessUtil.deletePI(row, this);

修改流程实例的流程版本号

函数名：updateProcessVersion
参数 
    params:{
        pi,        流程实例标识，多值，使用","分隔
        version    流程版本号
    }
    page    页面对象
示例：
    let pi=["pid1","pid2"];
    await ProcessUtil.updateProcessVersion({
        "pi": pi.join(","),
        "version": processVersion
    },this)

获取流程子管理员所管理的组织

函数名：queryManagedOrgByProcessSubAdmin
参数 
    page    页面对象
返回：
    {
        "组织1的FID": "组织1的FName",
        "组织2的FID": "组织2的FName",
    }
示例：
    let { data: managedOrgs } = await this.queryManagedOrgByProcessSubAdmin(this);

查询流程记录

函数名：queryRecord
参数 
    page    页面对象
    option {JSON} 查询选项
         参数格式：
         {
             limit: 20,            分页大小，默认值20，-1表示所有数据
             offset: 0,            当前位置 
             filter: "",        过滤条件，例如: SA_ServiceDefine.sName like '%张三%'
            variables:{},        变量，例如 {"justep.shard": "histroy"}
            task:"",        任务标识
            pi:"",        实例标识
            sData1:"",    业务数据id
            process:""    流程标识
         }
返回：
    数组
示例：
    onTaskDataCustomRefresh = (event) => {
        var option = {
            task: this.params.task,
            pi: this.params.pi,
            process: this.params.process||"",
            sData1: this.params.data,
            limit: event.limit,
            offset: event.offset
        };
        event.promise = ProcessUtil.queryRecord(this, option).then((res)=>{
            event.source.loadData(res.data);
            event.source.setTotal(ProcessUtil.getTotal(res));
        })
    }

查询批量流转

函数名：getBatchTasks
参数 
    page    页面对象
    task    任务标识
    option {JSON} 查询选项，参数内容同queryTaskByOrg函数 
返回：
    数组
示例：
    onTaskDataCustomRefresh = (event) => {
        event.promise = ProcessUtil.getBatchTasks(this, this.params.task, {
            "searchText": this.comp("pageData").getValue("searchText")
        }).then((data) => {
            event.source.loadData(data);
            event.source.setTotal(data.length);
        });
    }

自定义流程函数

查询自定义流程函数

函数名：queryProcessFn
参数 
    page    页面对象
    option {JSON} 查询选项
         参数格式：
         {
             limit: 20,            分页大小
             offset: 0,            当前位置 
             filter: "",        过滤条件，例如: SA_Task.sName like '%张三%'
            orderBy:"",        排序，例如：sCreateTime DESC
            searchText:"",        关键词搜索，支持sName字段模糊查询
            variables:{},        过滤条件中变量
            shard:""        查看归档数据，histroy
         }
返回
    {Promise} 
示例：
    let id="fnid";
    let rsp = await ProcessUtil.queryProcessFn(this, { "filter": `SA_ProcessFn='${id}'` });

新建自定义流程函数

函数名：saveProcessFn
参数 
    page    页面对象
    params:[{
        "id": "主键",
        "sName": "名称", 
        ...
    }]    流程函数信息，列信息请参考流程函数
返回：
    int
示例：
    const mainData = this.comp("mainData");
    let optData = mainData.find()[0];
    let rsp = await ProcessUtil.saveProcessFn(this, [optData]);

更新自定义流程函数

函数名：updateProcessFn
参数 
    page    页面对象
    params:[{
        "id": "主键",
        "sName": "名称", 
        ...
    }]    流程函数信息，列信息请参考流程函数
返回：
    int
示例：
    const mainData = this.comp("mainData");
    let optData = mainData.find()[0];
    let rsp = await ProcessUtil.updateProcessFn(this, [optData]);

删除自定义流程函数

函数名：deleteProcessFn
参数 
    page    页面对象
    id     函数标识
返回：
    int
示例：
    let rsp=await ProcessUtil.deleteProcessFn(this,"fnid");

服务定义

查询服务定义

函数名：queryServiceDefine
参数 
    page    页面对象
    option {JSON} 查询选项
         参数格式：
         {
             limit: 20,            分页大小，默认值20，-1表示所有数据
             offset: 0,            当前位置 
             filter: "",        过滤条件，例如: SA_ServiceDefine.sName like '%张三%'
            orderBy:"",        排序方式，例如 sName DESC,sCreateTime ASC
            searchText:"",        关键词搜索，支持sName字段模糊查询
            variables:{},        变量，例如 {"justep.shard": "histroy"}
            distinct:false        是否去重，
            columns:""        查询返回字段，例如：“sName”，默认所有列
         }
返回：
    数组
示例：
    onMainDataCustomRefresh = (event) => {
        let searchText = this.comp("pageData").getValue("searchTxt");
        let self = this;
        event.async = true;
        let params={
            "offset": event.offset || 0,
            "limit": event.limit || 20,
            "version": -1,
            searchText  
        }
        if(this.params.sScope){
            params.filter=`SA_ServiceDefine.sScope='${this.params.sScope}'`;
        }
        event.promise = ProcessUtil.queryServiceDefine(this, params).then((res) => {
            event.source.loadData(res.data || [], event.options.append);
            event.source.setTotal(ProcessUtil.getTotal(res));
        });
    }

新增服务定义

函数名：newServiceDefine
参数 
    page    页面对象
    row     服务定义数据,数组类型
返回：
    int
示例：
    let mainData = this.comp("mainData");
    let row=mainData.getCurrentRow().toJson({format: "simple"});   
    let {data}=await ProcessUtil.newServiceDefine(this,[row]);

更新服务定义

函数名：updateServiceDefine
参数 
    page    页面对象
    row     服务定义数据,数组类型
返回：
    int
示例：
    let mainData = this.comp("mainData");
    let row=mainData.getCurrentRow().toJson({format: "simple"});   
    let {data}=await ProcessUtil.updateServiceDefine(this,[row]);

删除服务定义

函数名：deleteServiceDefine
参数 
    page    页面对象
    id    服务定义主键id
返回：
    int
示例：
    let mainData = this.comp("mainData");
    let row=mainData.getCurrentRow().toJson({format: "simple"});   
    let { data } = await ProcessUtil.deleteServiceDefine(this, row.id);

消息相关

判断是否添加消息中心应用

函数名：hasMessage
参数 
    page    页面对象
返回：
    boolean 
示例：
    let flag = await ProcessUtil.hasMessage(this);

获取消息通道

函数名：getMessageChannel
参数 
    page    页面对象
返回：
    boolean 
示例：
    let flag = await ProcessUtil.getMessageChannel(this);//如果有消息中心应用则从消息中心远程获取，否则返回静态定义通道数据