@steedos-labs/plugin-workflow 3.0.12 → 3.0.13

package/main/default/pages/instance_tasks_detail.page.amis.json

@@ -1,106 +1,6 @@
 {
   "type": "page",
   "body": [
-    {
-      "type": "wrapper",
-      "visibleOn": "${AND(display != 'split', ${window:innerWidth > 768})}",
-      "className": "bg-white p-0 flex-shrink-0 min-w-[240px] lg:order-first lg:flex lg:flex-col rounded shadow my-4 ml-4 mr-1 my-4 sm:rounded",
-      "body": [
-        {
-          "type": "service",
-          "className": "w-full h-full",
-          "onEvent": {
-            "@data.changed.steedos_keyvalues": {
-              "actions": [
-                {
-                  "actionType": "reload"
-                }
-              ]
-            }
-          },
-          "body": [
-            {
-              "type": "button",
-              "label": "刷新",
-              "className": "instance-nav-reload hidden",
-              "onEvent": {
-                  "click": {
-                    "actions": [{
-                    "actionType": "reload",
-                    "componentId": "u:instanceNav"
-                  }]
-                }
-              }
-            },
-            {
-              "type": "input-tree",
-              "treeContainerClassName": "h-full",
-              "name": "tree",
-              "className": "instance-box-tree w-full",
-              "id": "u:9f3dd961ca12",
-              "stacked": true,
-              "multiple": false,
-              "enableNodePath": false,
-              "hideRoot": true,
-              "showIcon": true,
-              "initiallyOpen": false,
-              "virtualThreshold": 100000,
-              "value":"/app/${appId}/${objectName}/grid/${listName}",
-              "size": "md",
-              "onEvent": {
-                "change": {
-                  "actions": [
-                    {
-                      "args": {
-                        "link": "${event.data.value}",
-                        "blank": false
-                      },
-                      "actionType": "link"
-                    }
-                  ]
-                }
-              },
-              "menuTpl": {
-                "type": "wrapper",
-                "className": "flex flex-row  p-0 m-0",
-                "body": [
-                  {
-                    "type": "tpl",
-                    "className": "flex-1 w-6/12",
-                    "tpl": "${label}"
-                  },
-                  {
-                    "type": "tpl",
-                    "className": "-mx-11 ",
-                    "tpl": "",
-                    "badge": {
-                      "className": "h-0",
-                      "offset": [
-                        -20,
-                        12
-                      ],
-                      "mode": "text",
-                      "text": "${tag}",
-                      "overflowCount": 999
-                    }
-                  }
-                ]
-              },
-              "unfoldedLevel": 2,
-              "source": "${options}"
-            }
-          ],
-          "id": "u:instanceNav",
-          "api": {
-            "method": "get",
-            "url": "${context.rootUrl}/api/${appId}/workflow/nav",
-            "headers": {
-              "Authorization": "Bearer ${context.tenantId},${context.authToken}"
-            }
-          }
-        }
-      ]
-    },
     {
       "type": "wrapper",
       "className": "steedos-instance-detail-wrapper m-0 p-0 flex-1 focus:outline-none lg:order-last sm:m-4 shadow sm:rounded",

package/main/default/pages/page_instance_view.page.amis.json

@@ -38,7 +38,7 @@
     "bodyClassName": "p-0 flex flex-1 overflow-hidden h-full",
     "name": "amis-root-workflow",
     "initApi": {
-        "url": "http://127.0.0.1:8443/api/workflow/v2/instance/${recordId}/permission",
+        "url": "/api/workflow/v2/instance/${recordId}/permission",
         "method": "get",
         "data": {},
         "requestAdaptor": "",

package/main/default/routes/api_auto_number.router.js

@@ -0,0 +1,233 @@
+const express = require("express");
+const router = express.Router();
+const { instanceNumberBuilder } = require("../manager/instance_number_rules");
+const objectql = require('@steedos/objectql');
+const _ = require('lodash');
+const UUFlowManager = require('../manager/uuflow_manager');
+const { requireAuthentication } = require("@steedos/auth");
+
+// 获取用户当前的 approve
+const getUserApprove = ({ instance, userId }) => {
+    const currentTrace = _.find(instance.traces, (trace) => {
+        return trace.is_finished != true;
+    });
+    let currentApprove = null;
+    if (currentTrace) {
+        currentApprove = _.find(currentTrace.approves, (approve) => {
+            return approve.is_finished != true && approve.handler == userId;
+        });
+    }
+
+    //传阅的approve返回最新一条
+    if (!currentApprove || currentApprove.type == "cc") {
+        // 当前是传阅
+        _.each(instance.traces, function (t) {
+            _.each(t.approves, function (a) {
+                if (a.type == "cc" && a.handler == userId && a.is_finished == false) {
+                    currentApprove = a;
+                }
+            });
+        });
+    }
+
+    if (!currentApprove) return;
+
+    if (currentApprove._id) {
+        currentApprove.id = currentApprove._id;
+    }
+    return currentApprove;
+};
+
+// 获取可编辑的自动编号字段
+const getEditableAutoNumberFields = async (step, formId, formVersion) => {
+    const permissions = step.permissions || {};
+    const form = await UUFlowManager.getForm(formId);
+    const formV = await UUFlowManager.getFormVersion(form, formVersion);
+    
+    const autoNumberFields = [];
+    
+    // 检查字段是否是自动编号字段（通过 formula 判断）
+    const isAutoNumberField = (field) => {
+        return field.default_value && typeof field.default_value === 'string' && field.default_value.trim().startsWith('auto_number(');
+    };
+    
+    // 从 formula 中提取自动编号规则名称
+    const extractAutoNumberName = (formula) => {
+        // 匹配 auto_number("xxx") 或 auto_number('xxx') 或 auto_number(xxx)
+        const match = formula.match(/auto_number\s*\(\s*['"]?([^'"()]+?)['"]?\s*\)/);
+        return match ? match[1].trim() : null;
+    };
+    for (const field of formV.fields || []) {
+        
+        if (field.type === "section") {
+            // 处理 section 中的字段
+            for (const sectionField of field.fields || []) {
+                if (isAutoNumberField(sectionField) && permissions[sectionField.code] === "editable") {
+                    const autoNumberName = extractAutoNumberName(sectionField.default_value);
+                    if (autoNumberName) {
+                        autoNumberFields.push({
+                            code: sectionField.code,
+                            auto_number_name: autoNumberName
+                        });
+                    }
+                }
+            }
+        } else {
+            // 处理普通字段
+            if (isAutoNumberField(field) && permissions[field.code] === "editable") {
+                const autoNumberName = extractAutoNumberName(field.default_value);
+                if (autoNumberName) {
+                    autoNumberFields.push({
+                        code: field.code,
+                        auto_number_name: autoNumberName
+                    });
+                }
+            }
+        }
+    }
+    
+    return autoNumberFields;
+};
+
+router.post('/api/workflow/v2/auto_number', requireAuthentication, async function (req, res) {
+    try {
+        const userSession = req.user;
+        const userId = userSession.userId;
+        const { instanceId } = req.body;
+        
+        if (!instanceId) {
+            return res.status(200).send({
+                error: '缺少必填参数: instanceId'
+            });
+        }
+
+        // 获取 instance 信息
+        const instancesCollection = await objectql.getObject('instances');
+        const instance = await instancesCollection.findOne(instanceId);
+        
+        if (!instance) {
+            return res.status(200).send({
+                error: '未找到该实例'
+            });
+        }
+
+        // 获取当前用户的 approve
+        const currentApprove = getUserApprove({ instance, userId });
+        
+        if (!currentApprove) {
+            return res.status(200).send({
+                error: '未找到当前用户的审批节点'
+            });
+        }
+
+        // 如果是传阅类型，则不处理自动编号
+        if (currentApprove.type === 'cc') {
+            return res.status(200).send({
+                success: true,
+                message: '传阅节点不处理自动编号'
+            });
+        }
+
+        // 查找当前 trace 和 approve 的位置
+        let traceIndex = -1;
+        let approveIndex = -1;
+        
+        for (let i = 0; i < instance.traces.length; i++) {
+            const trace = instance.traces[i];
+            if (trace.approves && trace.approves.length > 0) {
+                const index = trace.approves.findIndex(app => app._id === currentApprove._id);
+                if (index !== -1) {
+                    traceIndex = i;
+                    approveIndex = index;
+                    break;
+                }
+            }
+        }
+
+        if (traceIndex === -1 || approveIndex === -1) {
+            return res.status(200).send({
+                error: '未找到对应的 trace 和 approve'
+            });
+        }
+
+        const currentTrace = instance.traces[traceIndex];
+        
+        // 获取当前 step
+        const flowsCollection = await objectql.getObject('flows');
+        const flow = await flowsCollection.findOne(instance.flow);
+        
+        if (!flow) {
+            return res.status(200).send({
+                error: '未找到对应的流程'
+            });
+        }
+
+        let step = null;
+        if (flow.current && flow.current.steps) {
+            step = flow.current.steps.find(s => s._id === currentTrace.step);
+        }
+        
+        if (!step && flow.historys) {
+            for (const h of flow.historys) {
+                step = h.steps.find(s => s._id === currentTrace.step);
+                if (step) break;
+            }
+        }
+
+        if (!step) {
+            return res.status(200).send({
+                error: '未找到对应的步骤'
+            });
+        }
+
+        // 获取可编辑的自动编号字段
+        const autoNumberFields = await getEditableAutoNumberFields(step, instance.form, instance.form_version);
+        
+        if (autoNumberFields.length === 0) {
+            return res.status(200).send({
+                success: true,
+                message: '当前步骤没有可编辑的自动编号字段'
+            });
+        }
+
+        // 为每个自动编号字段生成编号
+        const result = {};
+        const updateObj = {};
+        
+        for (const field of autoNumberFields) {
+            // 检查字段是否已有值
+            if (currentApprove.values && currentApprove.values[field.code]) {
+                result[field.code] = currentApprove.values[field.code];
+                continue;
+            }
+            
+            // 生成自动编号
+            const autoNumber = await instanceNumberBuilder(instance.space, field.auto_number_name);
+            
+            if (autoNumber && autoNumber._error) {
+                throw autoNumber._error;
+            }
+            
+            result[field.code] = autoNumber;
+            updateObj[`traces.${traceIndex}.approves.${approveIndex}.values.${field.code}`] = autoNumber;
+        }
+
+        // 更新 approve 的 values
+        if (Object.keys(updateObj).length > 0) {
+            await instancesCollection.update(instanceId, updateObj);
+        }
+
+        res.status(200).send({
+            success: true,
+            fields: result
+        });
+    } catch (error) {
+        console.error(error);
+        res.status(200).send({
+            error: error.message
+        });
+    }
+});
+
+
+exports.default = router;

package/main/default/routes/api_files.router.js

@@ -0,0 +1,21 @@
+const express = require("express");
+const router = express.Router();
+const { requireAuthentication } = require("@steedos/auth");
+const { getObject } = require('@steedos/objectql')
+const _ = require('lodash');
+
+router.delete('/api/workflow/v2/attachment/:instanceId/:id', requireAuthentication, async function (req, res) {
+    try {
+        const { instanceId, id} = req.params;
+        await getObject('cfs_instances_filerecord').delete(id);
+        res.status(200).send({
+            status: 0
+        })
+    } catch (error) {
+        console.error(error);
+        res.status(200).send({
+            error: error.message
+        });
+    }
+});
+exports.default = router;

package/main/default/routes/api_have_read.router.js

@@ -30,6 +30,8 @@ router.post('/api/workflow/v2/set_have_read', requireAuthentication, async funct
                 success: true
             });
         }
+
+
         const db = {
             instances: await getCollection('instances'),
             instance_tasks: await getCollection('instance_tasks')
@@ -40,7 +42,8 @@ router.post('/api/workflow/v2/set_have_read', requireAuthentication, async funct
             fields: {
                 "instance": 1,
                 "is_read": 1,
-                "type": 1
+                "type": 1,
+                space: 1
             }
         });
         if(!instance_task){
@@ -48,6 +51,21 @@ router.post('/api/workflow/v2/set_have_read', requireAuthentication, async funct
                 success: true
             });
         }
+
+
+        // 更新当前用户相关的通知为已读
+        const notificationsObj = objectql.getObject('notifications');
+        await notificationsObj.directUpdateMany([
+            ['owner', '=', userId],
+            ['is_read', '!=', true],
+            ['related_to.o', '=', 'instances'],
+            ['related_to.ids', '=', instance_task.instance]
+        ], {
+            is_read: true
+        });
+        console.log(`b6-microservice.broadcast`, {name: '$notification.users', data: {tenantId: instance_task.space, users: [userId], message: null}});
+        await broker.call('b6-microservice.broadcast', {name: '$notification.users', data: {tenantId: instance_task.space, users: [userId], message: null}})
+
         if (instance_task.is_read){
             return res.status(200).send({
                 success: true
@@ -63,7 +81,7 @@ router.post('/api/workflow/v2/set_have_read', requireAuthentication, async funct
         }
         else{
             await set_approve_have_read(ins._id, myApprove.trace, myApprove._id, { userId });
-        }
+        }        
         return res.status(200).send({
             success: true
         });

package/main/default/routes/api_workflow_chart.router.js

@@ -450,6 +450,7 @@ const FlowversionAPI = {
         let query = req.query;
         let instance_id = query.instance_id;
         let direction = query.direction || 'TD';
+        let noAutoFit = query.noAutoFit === '1' || query.noAutoFit === 'true';
         const allowDirections = ['TB', 'BT', 'RL', 'LR', 'TD'];
         if (!_.includes(allowDirections, direction)) {
             return this.writeResponse(res, 500, "Invalid direction. The value of direction should be in ['TB', 'BT', 'RL', 'LR', 'TD']");
@@ -619,6 +620,7 @@ const FlowversionAPI = {
 						});
 						$(function(){
 							var graphNodes = ${JSON.stringify(graphSyntax)};
+							var noAutoFit = ${noAutoFit ? 'true' : 'false'};
 							//方便前面可以通过调用mermaid.currentNodes调式，特意增加currentNodes属性。
 							mermaid.currentNodes = graphNodes;
 							var graphSyntax = graphNodes.join("\\n");
@@ -634,12 +636,30 @@ const FlowversionAPI = {
 									callback(id);
 								}
 								bindFunctions(element[0]);
+								
+								// 修复SVG左侧内容被裁剪的问题
+								if(!noAutoFit) {
+									setTimeout(function() {
+										var svg = $("svg");
+										if(svg.length > 0) {
+											// 关键修复：允许SVG溢出显示,解决左侧节点被裁剪的问题
+											svg.css('overflow', 'visible');
+										}
+									}, 50);
+								}
 							};
 							mermaid.render(id, graphSyntax, insertSvg, element[0]);
+							
+							var currentZoom = 1;
 							var zoomSVG = function(zoom){
-								var currentWidth = $("svg").width();
-								var newWidth = currentWidth * zoom;
-								$("svg").css("maxWidth",newWidth + "px").width(newWidth);
+								var svg = $("svg");
+								currentZoom = currentZoom * zoom;
+								var baseWidth = svg.data('baseWidth') || svg.width();
+								if(!svg.data('baseWidth')) {
+									svg.data('baseWidth', baseWidth);
+								}
+								var newWidth = baseWidth * currentZoom;
+								svg.css("maxWidth",newWidth + "px").width(newWidth);
 							}
 							//支持鼠标滚轮缩放画布
 							$(window).on("mousewheel",function(event){

package/main/default/routes/api_workflow_next_step.router.js

@@ -11,6 +11,8 @@ const { requireAuthentication } = require("@steedos/auth");
 const _ = require('lodash');
 const objectql = require('@steedos/objectql');
 const UUFlowManager = require('../manager/uuflow_manager');
+const HandlersManager = require('../manager/handlers_manager');
+const WorkflowManager = require('../manager/workflow_manager');
 
 const getFlowVersion = (flow, flowVersionId) => {
     if (flow.current._id === flowVersionId) {
@@ -53,7 +55,7 @@ const isSkipStep = function (instance, step) {
     return _.includes(instance.skip_steps, step._id)
 }
 
-const getNextSteps = async (flow, flowVersionId, instance, currentStep, judge, autoFormDoc, fields, showSkipStep) => {
+const getNextSteps = async (flow, flowVersionId, instance, currentStep, judge, autoFormDoc, fields, showSkipStep, userId) => {
     if (!currentStep)
         return;
 
@@ -149,42 +151,39 @@ const getNextSteps = async (flow, flowVersionId, instance, currentStep, judge, a
     //去除重复
     nextSteps = _.compact(_.uniqBy(nextSteps, 'id'));
 
-    let condition_next_steps = [];
-    for (const nextStep of nextSteps) {
+    const conditionResults = await Promise.all(nextSteps.map(async (nextStep) => {
         if (nextStep.step_type == "condition") {
-            if (!judge && nextStep.step_type == 'sign') {
-                judge = 'approved';
+            let currentJudge = judge;
+            if (!currentJudge && nextStep.step_type == 'sign') {
+                currentJudge = 'approved';
             }
-            const conditionSteps = await getNextSteps(flow, flowVersionId, instance, nextStep, judge, autoFormDoc, fields, showSkipStep);
-            condition_next_steps = condition_next_steps.concat(conditionSteps);
+            return await getNextSteps(flow, flowVersionId, instance, nextStep, currentJudge, autoFormDoc, fields, showSkipStep, userId);
         }
-    }
+        return [];
+    }));
+    const condition_next_steps = _.flatten(conditionResults);
 
     nextSteps = nextSteps.concat(condition_next_steps);
 
-    let rev_nextSteps = [];
-
-    for (const nextStep of nextSteps) {
+    const skipStepPromises = nextSteps.map(async (nextStep) => {
         if (nextStep.step_type != "condition") {
             if (!showSkipStep && isSkipStep(instance, nextStep)) {
-                if (!judge && nextStep.step_type == 'sign') {
-                    judge = 'approved';
-                }
-                let nextStepsAfterSkipStep = await getNextSteps(flow, flowVersionId, instance, nextStep, judge, autoFormDoc, fields, showSkipStep);
-                let stepsWithOutCurrentStep = [];
-                for (const s of nextStepsAfterSkipStep) {
-                    if (currentStep.id == s.id) {
-                        continue;
-                    }
-                    stepsWithOutCurrentStep.push(s);
+                let currentJudge = judge;
+                if (!currentJudge && nextStep.step_type == 'sign') {
+                    currentJudge = 'approved';
                 }
+                let nextStepsAfterSkipStep = await getNextSteps(flow, flowVersionId, instance, nextStep, currentJudge, autoFormDoc, fields, showSkipStep, userId);
                 // 后续步骤不应包含当前步骤
-                rev_nextSteps = rev_nextSteps.concat(stepsWithOutCurrentStep);
+                return nextStepsAfterSkipStep.filter(s => currentStep.id != s.id);
             } else {
-                rev_nextSteps.push(nextStep);
+                return [nextStep];
             }
         }
-    }
+        return [];
+    });
+
+    const nestedSteps = await Promise.all(skipStepPromises);
+    let rev_nextSteps = _.flatten(nestedSteps);
 
     //去除重复
     rev_nextSteps = _.compact(_.uniqBy(rev_nextSteps, 'id'));
@@ -193,17 +192,98 @@ const getNextSteps = async (flow, flowVersionId, instance, currentStep, judge, a
     if (currentStep.step_type == "counterSign" && rev_nextSteps.length > 1 && !currentStep.oneClickRejection) {
         rev_nextSteps = [];
     }
+
+    // 如果步骤的 always_enter_step (始终进入此步骤（默认选中，历史流程如果未配置，也是选中）) 值为false，那么需要运行脚本 enter_step_condition (步骤条件)
+    // 如结果中包含条件节点则需要继续计算条件节点下一步
+    const needRemoveSteps = {}, needAddSteps = {};
+    await Promise.all(rev_nextSteps.map(step => 
+         caculateNextStepsByEnterStepCondition(flow, flowVersionId, instance, step, autoFormDoc, fields, needRemoveSteps, needAddSteps, userId)
+    ));
+    if (!_.isEmpty(needRemoveSteps) && !_.isEmpty(needAddSteps)) {
+        for (const id in needAddSteps) {
+            if (Object.hasOwnProperty.call(needAddSteps, id)) {
+                const index = rev_nextSteps.findIndex(item => item.id == id)
+                if (-1 === index) {
+                    rev_nextSteps.push(needAddSteps[id])
+                }
+            }
+        }
+        for (const id in needRemoveSteps) {
+            if (Object.hasOwnProperty.call(needRemoveSteps, id)) {
+                const index = rev_nextSteps.findIndex(item => item.id == id)
+                if (-1 != index) {
+                    rev_nextSteps.splice(index, 1)
+                }
+            }
+        }
+        var conditionNextSteps = new Array();
+            
+        for (const [idx, nextStep] of rev_nextSteps.entries()) {
+            if (nextStep.step_type == "condition") {
+                if(!judge && nextStep.step_type == 'sign'){
+                    judge = 'approved'
+                }
+                conditionNextSteps = conditionNextSteps.concat(await getNextSteps(instance, nextStep, judge, autoFormDoc, fields, showSkipStep, userId));
+                // 移除条件节点
+                rev_nextSteps.splice(idx, 1)
+            }
+        }
+        rev_nextSteps = rev_nextSteps.concat(conditionNextSteps);
+        //去除重复
+        rev_nextSteps = _.compact(_.uniqBy(rev_nextSteps, 'id'));
+    }
+
     return rev_nextSteps;
 }
 
+async function caculateNextStepsByEnterStepCondition(flow, flowVersionId, instance, step, autoFormDoc, fields, needRemoveSteps = {}, needAddSteps = {}, userId) {
+    if (false === step.always_enter_step) {
+        const stepId = step.id;
+        // 获取step处理人
+        const users = await HandlersManager.getHandlers(instance._id, stepId, userId);
+        const spaceId = instance.space;
+        const approvers = await Promise.all(users.map(user => WorkflowManager.getFormulaUserObject(spaceId, user)));
+
+        let enterStepCondition = step.enter_step_condition;
+        const fieldValues = await UUFlowManager.initFormulaValues(instance, autoFormDoc);
+        fieldValues.step = {
+            ...step,
+            approvers
+        };
+        fieldValues.loginUserId = userId; // 当前登录用户
+        if (!UUFlowManager.isAmisFormula(enterStepCondition)) {
+            throw new Error('Not Amis Formula, Contact Admin Please.')
+        }
+        let result = UUFlowManager.calculateConditionWithAmis(fieldValues, enterStepCondition);
+        if (false === result) {
+            needRemoveSteps[step.id] = step;
+            if (step.lines && step.lines.length > 0) {
+                const toStepIds = step.lines.map(function(s){ return s.to_step});
+                await Promise.all(toStepIds.map(async (stepId) => {
+                    const s = getStep(flow, flowVersionId, stepId);
+                    if (s) {
+                        await caculateNextStepsByEnterStepCondition(flow, flowVersionId, instance, s, autoFormDoc, fields, needRemoveSteps, needAddSteps, userId);
+                    }
+                }));
+            }
+        } else {
+            needAddSteps[step.id] = step;
+        }
+    } else {
+        needAddSteps[step.id] = step;
+    }
+}
+
+
 router.post('/api/workflow/v2/nextStep', requireAuthentication, async function (req, res) {
     try {
         const userSession = req.user;
+        const { userId } = userSession;
         const { instanceId, flowId, step, judge, values, flowVersionId } = req.body;
         const flow = await objectql.getObject('flows').findOne(flowId);
         const instance = await objectql.getObject('instances').findOne(instanceId);
         
-        const resNextSteps = await getNextSteps(flow, flowVersionId, instance, step, judge, values);
+        const resNextSteps = await getNextSteps(flow, flowVersionId, instance, step, judge, values, null, null, userId);
         res.status(200).send({
             'nextSteps': resNextSteps
         });
@@ -228,17 +308,18 @@ const calcSteps = async function(instance, flow, flowVersionId, formFields, valu
 	
 	_steps.push(step);
 	try {
-        var nextSteps = await getNextSteps(flow, flowVersionId, instance, step, judge, values);
-        for (const nextStep of nextSteps) {
+        var nextSteps = await getNextSteps(flow, flowVersionId, instance, step, judge, values, null, null, instance.submitter);
+        const recursiveResults = await Promise.all(nextSteps.map(async (nextStep) => {
             try {
                 if (!_.includes(track, nextStep._id)) {
-                    const __steps = await calcSteps(instance, flow, flowVersionId, formFields, values, nextStep, track.concat(_.map(_steps, '_id')));
-                    _steps = _steps.concat(__steps)
+                    return await calcSteps(instance, flow, flowVersionId, formFields, values, nextStep, track.concat(_.map(_steps, '_id')));
                 }
             } catch (e) {
                 console.log(e)
             }
-        }
+            return [];
+        }));
+        _steps = _steps.concat(_.flatten(recursiveResults));
     } catch (error) {
         console.log(error)
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steedos-labs/plugin-workflow",
-  "version": "3.0.12",
+  "version": "3.0.13",
   "main": "package.service.js",
   "license": "MIT",
   "scripts": {