Merge branch 'main' into fix-import-bpmn-preview

Author: jjoderis

src/engine/universal/core/src/engine/engine.js

@@ -129,6 +129,16 @@ class Engine {
    * @param {string} the version of the process to deploy
    */
   async deployProcessVersion(definitionId, versionId) {
+    const otherVersions = this.versions.filter((version) => version !== versionId);
+    otherVersions.forEach((version) => {
+      const process = this._versionProcessMapping[version];
+
+      // deactivate other versions so they don't keep spawning new instances automatically
+      if (process) {
+        process.undeploy();
+      }
+    });
+
     if (!this._versionProcessMapping[versionId]) {
       // Fetch the stored BPMN
       const bpmn = await distribution.db.getProcessVersion(definitionId, versionId);
@@ -213,6 +223,22 @@ class Engine {
       this._versionProcessMapping[versionId] = process;
       this._versionBpmnMapping[versionId] = bpmn;
       this.versions.push(versionId);
+    } else if (!this._versionProcessMapping[versionId].isDeployed()) {
+      // activate the process so auto-start events like timer events are allowed to trigger new
+      // instances
+      this._versionProcessMapping[versionId].deploy();
+    }
+  }
+
+  /**
+   * Removes the deployed state from the process version in the NeoBPMN Engine preventing it from starting instances
+   *
+   * @param {string} the version of the process to undeploy
+   */
+  undeployProcessVersion(versionId) {
+    const process = this._versionProcessMapping[versionId];
+    if (process && process.isDeployed()) {
+      process.undeploy();
     }
   }
 
@@ -1014,6 +1040,9 @@ class Engine {
    * Clean up some data when the engine is supposed to be removed
    */
   destroy() {
+    for (const version of this.versions) {
+      this._versionProcessMapping[version].undeploy();
+    }
     for (const instanceId of this.instanceIDs) {
       this.deleteInstance(instanceId);
     }

src/engine/universal/core/src/management.js

@@ -55,9 +55,7 @@ const Management = {
     const engine = this.ensureProcessEngine(definitionId);
 
     // ensure that the version is deployed
-    if (!engine.versions.includes(version)) {
-      await engine.deployProcessVersion(definitionId, version);
-    }
+    await engine.deployProcessVersion(definitionId, version);
 
     return engine;
   },

src/engine/universal/distribution/src/routes/ProcessInstanceRoutes.js

@@ -393,4 +393,71 @@ module.exports = (path, management) => {
       });
     },
   );
+
+  network.put(`${path}/:definitionId/active`, { cors: true }, async (req) => {
+    const { definitionId } = req.params;
+
+    const {
+      body: { active },
+    } = req;
+
+    if (active === true) {
+      return {
+        statusCode: 400,
+        mimeType: 'text/plain',
+        response:
+          'Cannot set active true on a process. Please select a specific version to activate.',
+      };
+    } else if (active === false) {
+      const engine = await management.getEngineWithDefinitionId(definitionId);
+
+      if (engine) {
+        engine.versions.forEach((version) => engine.undeployProcessVersion(version));
+      }
+
+      return {
+        statusCode: 200,
+        mimeType: 'application/json',
+        response: '{}',
+      };
+    } else {
+      return {
+        statusCode: 400,
+        mimeType: 'text/plain',
+        response:
+          'This endpoint expects the request body to contain an entry called active with a boolean value of "false".',
+      };
+    }
+  });
+
+  network.put(`${path}/:definitionId/versions/:version/active`, { cors: true }, async (req) => {
+    const { definitionId, version } = req.params;
+
+    const {
+      body: { active },
+    } = req;
+
+    if (active === true) {
+      await management.ensureProcessEngineWithVersion(definitionId, version);
+    } else if (active === false) {
+      const engine = await management.getEngineWithDefinitionId(definitionId);
+
+      if (engine) {
+        engine.undeployProcessVersion(version);
+      }
+    } else {
+      return {
+        statusCode: 400,
+        mimeType: 'text/plain',
+        response:
+          'This endpoint expects the request body to contain an entry called active with a boolean value',
+      };
+    }
+
+    return {
+      statusCode: 200,
+      mimeType: 'application/json',
+      response: '{}',
+    };
+  });
 };

src/engine/universal/system/src/script-execution.js

@@ -172,7 +172,7 @@ class ScriptExecutor extends System {
                   path += '/organization';
                   dataPath = dataPath.split('.').slice(1).join('.');
                 } else {
-                  if (dataPath.startsWith('@user')) {
+                  if (dataPath.startsWith('@user') || dataPath.startsWith('@process-initiator')) {
                     dataPath = dataPath.split('.').slice(1).join('.');
                   } else if (dataPath.startsWith('@')) {
                     throw new Error(

src/engine/universal/ui/src/display-items/tasklist/TaskList-DisplayItem.js

@@ -424,15 +424,16 @@ export function getAllUserTaskFileNamesAndUserTaskIdsMapping(bpmn: string | obje
   [userTaskFileName: string]: string[];
 }>;
 /**
- * Get all fileName for all scriptTasks,
+ * Get all fileName and taskName for all scriptTasks,
  * (The attribute 'filename' is defined in the PROCEED XML Schema and not a standard BPMN attribute.)
  *
  * @param {(string|object)} bpmn - the process definition as XML string or BPMN-Moddle Object
- * @returns { Promise.<{ [scriptTaskId: string]: { fileName?: string }}> } an object (a map) with all scriptTaskIds as keys
+ * @returns { Promise.<{ [scriptTaskId: string]: { fileName?: string, taskName?: string }}> } an object (a map) with all scriptTaskIds as keys
  */
 export function getScriptTaskFileNameMapping(bpmn: string | object): Promise<{
   [scriptTaskId: string]: {
     fileName?: string;
+    taskName?: string;
   };
 }>;
 /**

src/helper-modules/bpmn-helper/src/getters.d.ts

@@ -235,7 +235,7 @@ async function getUserTaskFileNameMapping(bpmn) {
  * (The attribute 'filename' is defined in the PROCEED XML Schema and not a standard BPMN attribute.)
  *
  * @param {(string|object)} bpmn - the process definition as XML string or BPMN-Moddle Object
- * @returns { Promise.<{ [scriptTaskId: string]: { fileName?: string }}> } an object (a map) with all scriptTaskIds as keys
+ * @returns { Promise.<{ [scriptTaskId: string]: { fileName?: string, taskName?: string }}> } an object (a map) with all scriptTaskIds as keys
  */
 async function getScriptTaskFileNameMapping(bpmn) {
   const bpmnObj = typeof bpmn === 'string' ? await toBpmnObject(bpmn) : bpmn;

src/helper-modules/bpmn-helper/src/getters.js

@@ -223,6 +223,31 @@ export function getCorrectMilestoneState(
     value: number;
   }[]
 >;
+/**
+ * Function that returns all occurences of variables of the form "@global..." in placeholders
+ *
+ * @param {string | Buffer} html the html that contains placeholders that might reference global
+ * variables
+ * @returns {string[]} an array with all unique occurences of variable placholders
+ */
+export function getGlobalVariableReferences(html: string | Buffer): string[];
+/**
+ * Function that will create an object containing the values for global variables referenced in the
+ * given html
+ *
+ * @param {string | Buffer} html the html that contains placeholders that might reference global
+ * variables
+ * @param {(varPath: string) => Promise<any>} variableGetterFn a function that given a path to a
+ * specific global variable returns the value of that variable
+ * @returns {Promise<{ [key: string]: any }>} an object that maps the global variable paths in the html to
+ * values returned by the provided varaibleGetterFn
+ */
+export function getGlobalVariables(
+  html: string | Buffer,
+  variableGetterFn: (varPath: string) => Promise<any>,
+): Promise<{
+  [key: string]: any;
+}>;
 /**
  * Function that replaces the {{script}} placeholder in the html with the default script
  *

src/helper-modules/user-task-helper/index.d.ts

@@ -1,4 +1,5 @@
 const { render } = require('./src/render.js');
+const { tokenize } = require('./src/tokenize.js');
 
 const { getMilestonesFromElementById } = require('@proceed/bpmn-helper/src/getters');
 /**
@@ -446,9 +447,76 @@ function inlineUserTaskData(html, variables, milestones) {
   return finalHtml;
 }
 
+/**
+ * Function that returns all occurences of variables of the form "@global..." in placeholders
+ *
+ * @param {string | Buffer} html the html that contains placeholders that might reference global
+ * variables
+ * @returns {string[]} an array with all unique occurences of variable placholders
+ */
+function getGlobalVariableReferences(html) {
+  if (Buffer.isBuffer(html)) html = html.toString();
+
+  const globalDataVariables = tokenize(html);
+
+  const uniqueGlobalDataVariables = globalDataVariables
+    .filter(
+      (token, index) =>
+        token.type === 'variable' &&
+        token.variableName.startsWith('@global') &&
+        !globalDataVariables
+          .slice(0, index)
+          .some((entry) => entry.variableName === token.variableName),
+    )
+    .map(({ variableName }) => variableName.split('.').slice(1).join('.'));
+
+  return uniqueGlobalDataVariables;
+}
+
+/**
+ * Function that will create an object containing the values for global variables referenced in the
+ * given html
+ *
+ * @param {string | Buffer} html the html that contains placeholders that might reference global
+ * variables
+ * @param {(varPath: string) => Promise<any>} variableGetterFn a function that given a path to a
+ * specific global variable returns the value of that variable
+ * @returns {Promise<{ [key: string]: any }>} an object that maps the global variable paths in the html to
+ * values returned by the provided varaibleGetterFn
+ */
+async function getGlobalVariables(html, variableGetterFn) {
+  const variableReferences = getGlobalVariableReferences(html);
+
+  const globalVarPromises = variableReferences.map(async (varPath) => [
+    `@global.${varPath}`,
+    await variableGetterFn(varPath),
+  ]);
+
+  const globalVariables = await Promise.all(globalVarPromises);
+
+  const variables = {};
+
+  globalVariables.forEach(([varPath, value]) => {
+    const path = varPath.split('.');
+    const [varName] = path.splice(path.length - 1);
+    let current = variables;
+    for (const entry of path) {
+      if (!(entry in current)) {
+        current[entry] = {};
+      }
+      current = current[entry];
+    }
+    current[varName] = value;
+  });
+
+  return variables;
+}
+
 module.exports = {
   getCorrectVariableState,
   getCorrectMilestoneState,
+  getGlobalVariableReferences,
+  getGlobalVariables,
   inlineScript,
   inlineUserTaskData,
 };