Fix/subprocess handling with QRM

components/bpmn-q/modeler-component/editor/util/TransformationUtilities.js

@@ -1,5 +1,5 @@
-import {isFlowLikeElement} from './ModellingUtilities';
-import {getDi, is} from 'bpmn-js/lib/util/ModelUtil';
+import { isFlowLikeElement } from './ModellingUtilities';
+import { getDi, is } from 'bpmn-js/lib/util/ModelUtil';
 
 /**
  * Insert the given element and all child elements into the diagram
@@ -30,18 +30,18 @@ export function insertShape(definitions, parent, newElement, idMap, replace, mod
         if (replace) {
 
             // replace old element to retain attached sequence flow, associations, data objects, ...
-            element = bpmnReplace.replaceElement(elementRegistry.get(oldElement.id), {type: newElement.$type});
+            element = bpmnReplace.replaceElement(elementRegistry.get(oldElement.id), { type: newElement.$type });
         } else {
 
             // create new shape for this element
-            element = modeling.createShape({type: newElement.$type}, {x: 50, y: 50}, parent, {});
+            element = modeling.createShape({ type: newElement.$type }, { x: 50, y: 50 }, parent, {});
         }
     } else {
 
         // create connection between two previously created elements
         let sourceElement = elementRegistry.get(idMap[newElement.sourceRef.id]);
         let targetElement = elementRegistry.get(idMap[newElement.targetRef.id]);
-        element = modeling.connect(sourceElement, targetElement, {type: newElement.$type});
+        element = modeling.connect(sourceElement, targetElement, { type: newElement.$type });
     }
 
     // store id to create sequence flows
@@ -52,13 +52,11 @@ export function insertShape(definitions, parent, newElement, idMap, replace, mod
 
         // get the shape element related to the subprocess
         let shape = getDi(element);
-        shape.isExpanded = true;
 
-        // TODO: fix the following if, as the access to the DI of the new element is not possible with the current BPMN-JS version
-        /*if (shape && shape.isExpanded) {
-            // expand the new element
-            elementRegistry.get(element.id).businessObject.di.isExpanded = true;
-        }*/
+        // expand the replacement subprocess if the detector subprocess was expanded
+        if (shape && (newElement.isExpanded === 'true')) {
+            shape.isExpanded = true;
+        }
 
         // preserve messages defined in ReceiveTasks
     } else if (newElement.$type === 'bpmn:ReceiveTask' && newElement.messageRef) {
@@ -71,21 +69,21 @@ export function insertShape(definitions, parent, newElement, idMap, replace, mod
             let message = bpmnFactory.create('bpmn:Message');
             message.name = oldMessage.name;
             definitions.rootElements.push(message);
-            modeling.updateProperties(element, {'messageRef': message});
+            modeling.updateProperties(element, { 'messageRef': message });
 
             // store id if other receive tasks reference the same message
             idMap[oldMessage.id] = message.id;
         } else {
 
             // reuse already created message and add it to receive task
-            modeling.updateProperties(element, {'messageRef': idMap[oldMessage.id]});
+            modeling.updateProperties(element, { 'messageRef': idMap[oldMessage.id] });
         }
     }
 
     // add element to which a boundary event is attached
     if (newElement.$type === 'bpmn:BoundaryEvent') {
         let hostElement = elementRegistry.get(idMap[newElement.attachedToRef.id]);
-        modeling.updateProperties(element, {'attachedToRef': hostElement.businessObject});
+        modeling.updateProperties(element, { 'attachedToRef': hostElement.businessObject });
         element.host = hostElement;
     }
 
@@ -109,7 +107,7 @@ export function insertShape(definitions, parent, newElement, idMap, replace, mod
     }
 
     // return success flag and idMap with id mappings of this element and all children
-    return {success: success, idMap: idMap, element: element};
+    return { success: success, idMap: idMap, element: element };
 }
 
 /**
@@ -162,7 +160,7 @@ export function insertChildElements(definitions, parent, newElement, idMap, mode
         }
     }
 
-    return {success: success, idMap: idMap, element: parent};
+    return { success: success, idMap: idMap, element: parent };
 }
 
 /**
@@ -229,7 +227,7 @@ export function getAllElementsInProcess(processBo, elementRegistry, elementType)
     for (let i = 0; i < flowElementBos.length; i++) {
         let flowElementBo = flowElementBos[i];
         if (flowElementBo.$type && flowElementBo.$type === elementType) {
-            elements.push({element: flowElementBo, parent: processElement});
+            elements.push({ element: flowElementBo, parent: processElement });
         }
 
         // recursively retrieve service tasks if subprocess is found
@@ -258,7 +256,7 @@ export function getAllElementsForProcess(processBo, elementRegistry, elementType
     for (let i = 0; i < flowElements.length; i++) {
         let flowElement = flowElements[i];
         if (is(flowElement, elementType)) {
-            elements.push({element: flowElement, parent: processElement});
+            elements.push({ element: flowElement, parent: processElement });
         }
     }
     return elements;

components/bpmn-q/modeler-component/extensions/quantme/replacement/QuantMETransformator.js

@@ -9,22 +9,24 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import {layout} from './layouter/Layouter';
-import {matchesQRM} from './QuantMEMatcher';
-import {addQuantMEInputParameters} from './InputOutputHandler';
+import { layout } from './layouter/Layouter';
+import { matchesQRM } from './QuantMEMatcher';
+import { addQuantMEInputParameters } from './InputOutputHandler';
 import * as Constants from '../Constants';
-import {replaceHardwareSelectionSubprocess} from './hardware-selection/QuantMEHardwareSelectionHandler';
-import {replaceCuttingSubprocess} from './circuit-cutting/QuantMECuttingHandler';
-import {insertShape} from '../../../editor/util/TransformationUtilities';
-import {createTempModelerFromXml} from '../../../editor/ModelerHandler';
+import { replaceHardwareSelectionSubprocess } from './hardware-selection/QuantMEHardwareSelectionHandler';
+import { replaceCuttingSubprocess } from './circuit-cutting/QuantMECuttingHandler';
+import { insertShape } from '../../../editor/util/TransformationUtilities';
+import { createTempModelerFromXml } from '../../../editor/ModelerHandler';
 import {
     getCamundaInputOutput,
     getDefinitionsFromXml,
     getRootProcess,
     getSingleFlowElement
 } from '../../../editor/util/ModellingUtilities';
-import {getXml} from '../../../editor/util/IoUtilities';
+import { getXml } from '../../../editor/util/IoUtilities';
 
+const { DOMParser } = require('xmldom');
+const xmlParser = require('xml-js');
 /**
  * Initiate the replacement process for the QuantME tasks that are contained in the current process model
  *
@@ -43,14 +45,14 @@ export async function startQuantmeReplacementProcess(xml, currentQRMs, endpointC
     console.log(rootElement);
     if (typeof rootElement === 'undefined') {
         console.log('Unable to retrieve root process element from definitions!');
-        return {status: 'failed', cause: 'Unable to retrieve root process element from definitions!'};
+        return { status: 'failed', cause: 'Unable to retrieve root process element from definitions!' };
     }
 
     // get all QuantME modeling constructs from the process
     let replacementConstructs = getQuantMETasks(rootElement, elementRegistry);
     console.log('Process contains ' + replacementConstructs.length + ' QuantME modeling constructs to replace...');
     if (!replacementConstructs || !replacementConstructs.length) {
-        return {status: 'transformed', xml: xml};
+        return { status: 'transformed', xml: xml };
     }
 
     // check for available replacement models for all QuantME modeling constructs
@@ -113,8 +115,34 @@ export async function startQuantmeReplacementProcess(xml, currentQRMs, endpointC
     // layout diagram after successful transformation
     layout(modeling, elementRegistry, rootElement);
     let updated_xml = await getXml(modeler);
-    console.log(updated_xml);
-    return {status: 'transformed', xml: updated_xml};
+
+    // Parse the XML string into a JavaScript object
+    let xmlDoc = xmlParser.xml2js(updated_xml, { compact: true });
+
+    // Get all bpmndi:BPMNDiagram elements
+    let bpmnDiagrams = xmlDoc['bpmn:definitions']['bpmndi:BPMNDiagram'];
+
+    let subprocesses = xmlDoc['bpmn:definitions']['bpmn:process']['bpmn:subProcess'];
+
+    // Remove all bpmndi:BPMNDiagram elements except the first one
+    if (Array.isArray(bpmnDiagrams)) {
+        if (bpmnDiagrams.length > 1) {
+            xmlDoc['bpmn:definitions']['bpmndi:BPMNDiagram'] = bpmnDiagrams.slice(0, 1);
+        }
+    }
+
+    // Remove the isExpanded attribute from the shapes
+    if (Array.isArray(subprocesses)) {
+        for (let i = 0; i < subprocesses.length; i++) {
+            let subprocessAttributes = subprocesses[i]['_attributes'];
+            delete subprocessAttributes.isExpanded;
+        }
+    }
+
+    // Serialize the modified JavaScript object back to XML string
+    let modifiedXmlString = xmlParser.js2xml(xmlDoc, { compact: true });
+
+    return { status: 'transformed', xml: modifiedXmlString };
 }
 
 /**
@@ -130,7 +158,7 @@ export function getQuantMETasks(process, elementRegistry) {
     for (let i = 0; i < flowElements.length; i++) {
         let flowElement = flowElements[i];
         if (flowElement.$type && flowElement.$type.startsWith('quantme:')) {
-            quantmeTasks.push({task: flowElement, parent: processBo});
+            quantmeTasks.push({ task: flowElement, parent: processBo });
         }
 
         // recursively retrieve QuantME tasks if subprocess is found
@@ -160,7 +188,6 @@ async function getMatchingQRM(task, currentQRMs) {
  */
 async function replaceByFragment(definitions, task, parent, replacement, modeler) {
     let bpmnFactory = modeler.get('bpmnFactory');
-
     if (!replacement) {
         console.log('Replacement fragment is undefined. Aborting replacement!');
         return false;
@@ -175,6 +202,31 @@ async function replaceByFragment(definitions, task, parent, replacement, modeler
     }
 
     console.log('Replacement element: ', replacementElement);
+
+    if (['bpmn:SubProcess', 'quantme:QuantumHardwareSelectionSubprocess', 'quantme:CircuitCuttingSubprocess'].includes(replacementElement.$type)) {
+
+        // Create a DOM parser
+        const parser = new DOMParser();
+
+        // Parse the XML string
+        const xmlDoc = parser.parseFromString(replacement, 'text/xml');
+
+        const bpmndiNamespace = 'http://www.omg.org/spec/BPMN/20100524/DI';
+        const bpmndiShapes = xmlDoc.getElementsByTagNameNS(bpmndiNamespace, 'BPMNShape');
+
+        let isExpanded = null;
+
+        for (let i = 0; i < bpmndiShapes.length; i++) {
+            const bpmnElement = bpmndiShapes[i].getAttribute('bpmnElement');
+            if (bpmnElement === replacementElement.id) {
+                isExpanded = bpmndiShapes[i].getAttribute('isExpanded');
+                replacementElement.isExpanded = isExpanded;
+                break;
+            }
+        }
+    }
+
+
     let result = insertShape(definitions, parent, replacementElement, {}, true, modeler, task);
 
     // add all attributes of the replaced QuantME task to the input parameters of the replacement fragment