Merge branch 'main' into flowable-release-8.1.0

Author: filiphr

modules/flowable-bpmn-converter/src/main/java/org/flowable/bpmn/converter/BaseBpmnXMLConverter.java

@@ -35,6 +35,7 @@
 import org.flowable.bpmn.model.CancelEventDefinition;
 import org.flowable.bpmn.model.CompensateEventDefinition;
 import org.flowable.bpmn.model.ConditionalEventDefinition;
+import org.flowable.bpmn.model.CustomBpmnEventDefinition;
 import org.flowable.bpmn.model.DataAssociation;
 import org.flowable.bpmn.model.DataObject;
 import org.flowable.bpmn.model.ErrorEventDefinition;
@@ -60,7 +61,6 @@
 import org.flowable.bpmn.model.TimerEventDefinition;
 import org.flowable.bpmn.model.UserTask;
 import org.flowable.bpmn.model.ValuedDataObject;
-import org.flowable.bpmn.model.VariableListenerEventDefinition;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -438,7 +438,13 @@ protected boolean writeListeners(BaseElement element, boolean didWriteExtensionS
     }
 
     protected void writeEventDefinitions(Event parentEvent, List<EventDefinition> eventDefinitions, BpmnModel model, XMLStreamWriter xtw) throws Exception {
+        // Custom (non-BPMN-spec) event definitions are emitted in writeExtensionChildElements via
+        // BpmnXMLUtil.writeCustomEventDefinitionExtensionElements. Only the BPMN-spec types are written here
+        // as direct children of the event element.
         for (EventDefinition eventDefinition : eventDefinitions) {
+            if (eventDefinition instanceof CustomBpmnEventDefinition) {
+                continue;
+            }
             if (eventDefinition instanceof TimerEventDefinition) {
                 writeTimerDefinition(parentEvent, (TimerEventDefinition) eventDefinition, model, xtw);
 
@@ -653,32 +659,6 @@ protected void writeTerminateDefinition(Event parentEvent, TerminateEventDefinit
         xtw.writeEndElement();
     }
 
-    protected boolean writeVariableListenerDefinition(Event parentEvent, boolean didWriteExtensionStartElement, XMLStreamWriter xtw) throws Exception {
-        if (parentEvent.getEventDefinitions().size() == 1) {
-            EventDefinition eventDefinition = parentEvent.getEventDefinitions().iterator().next();
-            if (eventDefinition instanceof VariableListenerEventDefinition variableListenerEventDefinition) {
-                if (!didWriteExtensionStartElement) {
-                    xtw.writeStartElement(ELEMENT_EXTENSIONS);
-                    didWriteExtensionStartElement = true;
-                }
-
-                xtw.writeStartElement(FLOWABLE_EXTENSIONS_PREFIX, ELEMENT_EVENT_VARIABLELISTENERDEFINITION, FLOWABLE_EXTENSIONS_NAMESPACE);
-
-                if (StringUtils.isNotEmpty(variableListenerEventDefinition.getVariableName())) {
-                    writeDefaultAttribute(ATTRIBUTE_VARIABLE_NAME, variableListenerEventDefinition.getVariableName(), xtw);
-                }
-                
-                if (StringUtils.isNotEmpty(variableListenerEventDefinition.getVariableChangeType())) {
-                    writeDefaultAttribute(ATTRIBUTE_VARIABLE_CHANGE_TYPE, variableListenerEventDefinition.getVariableChangeType(), xtw);
-                }
-
-                xtw.writeEndElement();
-            }
-        }
-        
-        return didWriteExtensionStartElement;
-    }
-
     protected void writeDefaultAttribute(String attributeName, String value, XMLStreamWriter xtw) throws Exception {
         BpmnXMLUtil.writeDefaultAttribute(attributeName, value, xtw);
     }

modules/flowable-bpmn-converter/src/main/java/org/flowable/bpmn/converter/BoundaryEventXMLConverter.java

@@ -21,7 +21,6 @@
 import javax.xml.stream.XMLStreamWriter;
 
 import org.apache.commons.lang3.StringUtils;
-import org.flowable.bpmn.constants.BpmnXMLConstants;
 import org.flowable.bpmn.converter.child.BaseChildElementParser;
 import org.flowable.bpmn.converter.child.InParameterParser;
 import org.flowable.bpmn.converter.child.VariableListenerEventDefinitionParser;
@@ -32,7 +31,6 @@
 import org.flowable.bpmn.model.ErrorEventDefinition;
 import org.flowable.bpmn.model.EventDefinition;
 import org.flowable.bpmn.model.ExtensionAttribute;
-import org.flowable.bpmn.model.ExtensionElement;
 
 /**
  * @author Tijs Rademakers
@@ -108,23 +106,14 @@ protected void writeAdditionalAttributes(BaseElement element, BpmnModel model, X
             if (!(eventDef instanceof ErrorEventDefinition)) {
                 writeDefaultAttribute(ATTRIBUTE_BOUNDARY_CANCELACTIVITY, String.valueOf(boundaryEvent.isCancelActivity()).toLowerCase(), xtw);
             }
-
-        } else if (!boundaryEvent.getExtensionElements().isEmpty()) {
-            List<ExtensionElement> eventTypeExtensionElements = boundaryEvent.getExtensionElements().get(BpmnXMLConstants.ELEMENT_EVENT_TYPE);
-            if (eventTypeExtensionElements != null && !eventTypeExtensionElements.isEmpty()) {
-                String eventTypeValue = eventTypeExtensionElements.get(0).getElementText();
-                if (StringUtils.isNotEmpty(eventTypeValue)) {
-                    writeDefaultAttribute(ATTRIBUTE_BOUNDARY_CANCELACTIVITY, String.valueOf(boundaryEvent.isCancelActivity()).toLowerCase(), xtw);
-                }
-            }
         }
     }
 
     @Override
     protected boolean writeExtensionChildElements(BaseElement element, boolean didWriteExtensionStartElement, XMLStreamWriter xtw) throws Exception {
         BoundaryEvent boundaryEvent = (BoundaryEvent) element;
         didWriteExtensionStartElement = BpmnXMLUtil.writeIOParameters(ELEMENT_IN_PARAMETERS, boundaryEvent.getInParameters(), didWriteExtensionStartElement, xtw);
-        didWriteExtensionStartElement = writeVariableListenerDefinition(boundaryEvent, didWriteExtensionStartElement, xtw);        
+        didWriteExtensionStartElement = BpmnXMLUtil.writeCustomEventDefinitionExtensionElements(boundaryEvent, didWriteExtensionStartElement, xtw);
         return didWriteExtensionStartElement;
     }
 

modules/flowable-bpmn-converter/src/main/java/org/flowable/bpmn/converter/BpmnXMLConverter.java

@@ -80,15 +80,20 @@
 import org.flowable.bpmn.model.BpmnModel;
 import org.flowable.bpmn.model.DateDataObject;
 import org.flowable.bpmn.model.DoubleDataObject;
+import org.flowable.bpmn.model.Event;
+import org.flowable.bpmn.model.EventRegistryEventDefinition;
 import org.flowable.bpmn.model.EventSubProcess;
+import org.flowable.bpmn.model.ExtensionElement;
 import org.flowable.bpmn.model.FlowElement;
 import org.flowable.bpmn.model.FlowNode;
 import org.flowable.bpmn.model.IntegerDataObject;
+import org.flowable.bpmn.model.IntermediateCatchEvent;
 import org.flowable.bpmn.model.JsonDataObject;
 import org.flowable.bpmn.model.LongDataObject;
 import org.flowable.bpmn.model.Pool;
 import org.flowable.bpmn.model.Process;
 import org.flowable.bpmn.model.SequenceFlow;
+import org.flowable.bpmn.model.StartEvent;
 import org.flowable.bpmn.model.StringDataObject;
 import org.flowable.bpmn.model.SubProcess;
 import org.flowable.bpmn.model.TextAnnotation;
@@ -479,6 +484,7 @@ public BpmnModel convertToBpmnModel(XMLStreamReader xtr) {
 
     protected void processFlowElements(Collection<FlowElement> flowElementList, BaseElement parentScope) {
         for (FlowElement flowElement : flowElementList) {
+
             if (flowElement instanceof SequenceFlow sequenceFlow) {
                 FlowNode sourceNode = getFlowNodeFromScope(sequenceFlow.getSourceRef(), parentScope);
                 if (sourceNode != null) {
@@ -498,14 +504,40 @@ protected void processFlowElements(Collection<FlowElement> flowElementList, Base
                     boundaryEvent.setAttachedToRef(attachedActivity);
                     attachedActivity.getBoundaryEvents().add(boundaryEvent);
                 }
+                promoteEventTypeExtensionToEventRegistryEventDefinition(boundaryEvent);
 
             } else if (flowElement instanceof SubProcess subProcess) {
                 Collection<FlowElement> childFlowElements = subProcess.getFlowElements();
                 processFlowElements(childFlowElements, subProcess);
+            } else if (flowElement instanceof Event event) {
+                promoteEventTypeExtensionToEventRegistryEventDefinition(event);
+
             }
         }
     }
 
+    /**
+     * Adds a typed {@link EventRegistryEventDefinition} on event hosts that carry a legacy
+     * {@code <flowable:eventType>X</flowable:eventType>} extension element. The extension element is left
+     * in place so external code that reads it via {@code event.getExtensionElements()} continues to work;
+     * the typed definition gives the engine and validators a class to dispatch on. Programmatic models that
+     * already attach the typed definition (or carry no extension element) are skipped.
+     */
+    protected void promoteEventTypeExtensionToEventRegistryEventDefinition(Event event) {
+        if (event.getEventDefinitions().stream().anyMatch(EventRegistryEventDefinition.class::isInstance)) {
+            return;
+        }
+        List<ExtensionElement> eventTypeElements = event.getExtensionElements().get(BpmnXMLConstants.ELEMENT_EVENT_TYPE);
+        if (eventTypeElements == null || eventTypeElements.isEmpty()) {
+            return;
+        }
+        String value = eventTypeElements.get(0).getElementText();
+        if (StringUtils.isEmpty(value)) {
+            return;
+        }
+        event.addEventDefinition(new EventRegistryEventDefinition(value));
+    }
+
     protected FlowNode getFlowNodeFromScope(String elementId, BaseElement scope) {
         FlowNode flowNode = null;
         if (StringUtils.isNotEmpty(elementId)) {

modules/flowable-bpmn-converter/src/main/java/org/flowable/bpmn/converter/CatchEventXMLConverter.java

@@ -72,8 +72,7 @@ protected void writeAdditionalAttributes(BaseElement element, BpmnModel model, X
     @Override
     protected boolean writeExtensionChildElements(BaseElement element, boolean didWriteExtensionStartElement, XMLStreamWriter xtw) throws Exception {
         IntermediateCatchEvent catchEvent = (IntermediateCatchEvent) element;
-        didWriteExtensionStartElement = writeVariableListenerDefinition(catchEvent, didWriteExtensionStartElement, xtw);        
-        return didWriteExtensionStartElement;
+        return BpmnXMLUtil.writeCustomEventDefinitionExtensionElements(catchEvent, didWriteExtensionStartElement, xtw);
     }
 
     @Override

modules/flowable-bpmn-converter/src/main/java/org/flowable/bpmn/converter/CustomEventDefinitionXmlWriter.java

@@ -0,0 +1,31 @@
+/* Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.flowable.bpmn.converter;
+
+import javax.xml.stream.XMLStreamWriter;
+
+import org.flowable.bpmn.model.Event;
+import org.flowable.bpmn.model.EventDefinition;
+
+/**
+ * Hook for serializing a {@link org.flowable.bpmn.model.CustomBpmnEventDefinition} back to XML — the
+ * write-side counterpart to {@link org.flowable.bpmn.converter.child.BaseChildElementParser} on the read
+ * side. A custom {@link EventDefinition} requires one parser (read) and one writer (write) to round-trip
+ * through {@code BpmnXMLConverter}. The writer is invoked inside an already-opened
+ * {@code <extensionElements>} wrapper.
+ */
+@FunctionalInterface
+public interface CustomEventDefinitionXmlWriter {
+
+    void write(Event parentEvent, EventDefinition eventDefinition, XMLStreamWriter xtw) throws Exception;
+}

modules/flowable-bpmn-converter/src/main/java/org/flowable/bpmn/converter/StartEventXMLConverter.java

@@ -117,8 +117,7 @@ protected void writeAdditionalAttributes(BaseElement element, BpmnModel model, X
             writeQualifiedAttribute(ATTRIBUTE_SAME_DEPLOYMENT, "false", xtw);
         }
 
-        if ((startEvent.getEventDefinitions() != null && startEvent.getEventDefinitions().size() > 0) ||
-                (startEvent.getExtensionElements() != null && startEvent.getExtensionElements().containsKey(ELEMENT_EVENT_TYPE))) {
+        if (startEvent.getEventDefinitions() != null && !startEvent.getEventDefinitions().isEmpty()) {
             writeDefaultAttribute(ATTRIBUTE_EVENT_START_INTERRUPTING, String.valueOf(startEvent.isInterrupting()), xtw);
         }
     }
@@ -127,7 +126,7 @@ protected void writeAdditionalAttributes(BaseElement element, BpmnModel model, X
     protected boolean writeExtensionChildElements(BaseElement element, boolean didWriteExtensionStartElement, XMLStreamWriter xtw) throws Exception {
         StartEvent startEvent = (StartEvent) element;
         didWriteExtensionStartElement = BpmnXMLUtil.writeIOParameters(ELEMENT_IN_PARAMETERS, startEvent.getInParameters(), didWriteExtensionStartElement, xtw);
-        didWriteExtensionStartElement = writeVariableListenerDefinition(startEvent, didWriteExtensionStartElement, xtw);
+        didWriteExtensionStartElement = BpmnXMLUtil.writeCustomEventDefinitionExtensionElements(startEvent, didWriteExtensionStartElement, xtw);
         didWriteExtensionStartElement = writeFormProperties(startEvent, didWriteExtensionStartElement, xtw);
         return didWriteExtensionStartElement;
     }