Customizable BPMN EventDefinitions and CMMN EventListeners

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/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;
     }

modules/flowable-bpmn-converter/src/main/java/org/flowable/bpmn/converter/child/EventRegistryEventTypeParser.java

@@ -0,0 +1,71 @@
+/* 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.child;
+
+import javax.xml.stream.XMLStreamReader;
+
+import org.apache.commons.lang3.StringUtils;
+import org.flowable.bpmn.model.BaseElement;
+import org.flowable.bpmn.model.BoundaryEvent;
+import org.flowable.bpmn.model.BpmnModel;
+import org.flowable.bpmn.model.Event;
+import org.flowable.bpmn.model.EventRegistryEventDefinition;
+import org.flowable.bpmn.model.IntermediateCatchEvent;
+import org.flowable.bpmn.model.StartEvent;
+
+/**
+ * Reads {@code <flowable:eventType>X</flowable:eventType>} as a child of an event host (start /
+ * intermediate-catch / boundary) and produces a typed {@link EventRegistryEventDefinition} on the host's
+ * {@code eventDefinitions} list. The {@link EventRegistryEventDefinition} is the single source of truth in
+ * the model — the legacy XML form is re-emitted on serialization by the host's XML writer, no parallel
+ * extension-element representation is kept.
+ * <p>
+ * On non-event hosts (e.g. {@code receiveTask}, {@code sendEventServiceTask}, {@code process}) this parser
+ * declines via {@link #accepts(BaseElement)} so {@code BpmnXMLUtil.parseChildElements} falls through to the
+ * generic extension-element path and existing behavior is preserved.
+ */
+public class EventRegistryEventTypeParser extends BaseChildElementParser {
+
+    @Override
+    public String getElementName() {
+        return ELEMENT_EVENT_TYPE;
+    }
+
+    @Override
+    public boolean accepts(BaseElement element) {
+        return element instanceof IntermediateCatchEvent
+                || element instanceof BoundaryEvent
+                || element instanceof StartEvent;
+    }
+
+    @Override
+    public void parseChildElement(XMLStreamReader xtr, BaseElement parentElement, BpmnModel model) throws Exception {
+        if (!(parentElement instanceof Event event)) {
+            return;
+        }
+        // An empty <flowable:eventType> on an event host is almost always an authoring mistake — warn so it
+        // surfaces at parse time rather than failing silently at runtime.
+        String eventTypeValue = xtr.getElementText();
+        if (StringUtils.isEmpty(eventTypeValue)) {
+            LOGGER.warn("Empty <flowable:eventType> extension element on event '{}'; ignoring (no event-registry subscription will be created)",
+                    event.getId());
+            return;
+        }
+        if (event.getEventDefinitions().stream().anyMatch(EventRegistryEventDefinition.class::isInstance)) {
+            LOGGER.warn("Multiple <flowable:eventType> extension elements on event '{}'; only the first is used and the duplicate value '{}' is ignored",
+                    event.getId(), eventTypeValue);
+            return;
+        }
+        event.addEventDefinition(new EventRegistryEventDefinition(eventTypeValue));
+    }
+}