org.camunda.bpm.engine.impl.bpmn.parser.BpmnParseListener Java Examples

@Override
public ProcessEngineConfiguration configureEngine(ProcessEngineConfigurationImpl configuration) {
  List<BpmnParseListener> listeners = new ArrayList<>();
  listeners.add(new AbstractBpmnParseListener(){

    @Override
    public void parseServiceTask(Element serviceTaskElement, ScopeImpl scope, ActivityImpl activity) {
      activity.setAsyncBefore(false);
    }
  });

  configuration.setCustomPreBPMNParseListeners(listeners);
  return configuration;
}
 

@Override
public void preInit(SpringProcessEngineConfiguration processEngineConfiguration) {
    super.preInit(processEngineConfiguration);

    List<BpmnParseListener> preParseListeners = processEngineConfiguration.getCustomPreBPMNParseListeners();
    if (preParseListeners == null) {
        preParseListeners = new ArrayList<BpmnParseListener>();
        processEngineConfiguration.setCustomPreBPMNParseListeners(preParseListeners);
    }

    log.info("adding LocalBpmnParseListener:{}", processStartAndEndEventInitializer.getClass().getName());

    preParseListeners.add(processStartAndEndEventInitializer);
}
 

@Override
public void preInit(ProcessEngineConfigurationImpl processEngineConfiguration) {
	if (processEngineConfiguration.getCustomPostBPMNParseListeners() == null) {
		processEngineConfiguration.setCustomPostBPMNParseListeners(new ArrayList<BpmnParseListener>());
	}
	processEngineConfiguration.getCustomPostBPMNParseListeners().add(new AddSendEventListenerToBpmnParseListener());

}
 

@Override
public ProcessEngineConfiguration configureEngine(ProcessEngineConfigurationImpl configuration) {
  List<BpmnParseListener> listeners = new ArrayList<>();
  listeners.add(new AbstractBpmnParseListener(){

    @Override
    public void parseServiceTask(Element serviceTaskElement, ScopeImpl scope, ActivityImpl activity) {
      activity.setAsyncBefore(false);
      activity.setAsyncAfter(true);
    }
  });

  configuration.setCustomPreBPMNParseListeners(listeners);
  return configuration;
}
 

private static void initializePathCoverageParseListener(ProcessEngineConfigurationImpl configuration) {
    List<BpmnParseListener> bpmnParseListeners = configuration.getCustomPostBPMNParseListeners();
    if (bpmnParseListeners == null) {
        bpmnParseListeners = new LinkedList<BpmnParseListener>();
        configuration.setCustomPostBPMNParseListeners(bpmnParseListeners);
    }

    bpmnParseListeners.add(new PathCoverageParseListener());
}
 

@Override
public ProcessEngineConfiguration configureEngine(ProcessEngineConfigurationImpl configuration) {
  List<BpmnParseListener> listeners = new ArrayList<>();
  listeners.add(new AbstractBpmnParseListener(){

    @Override
    public void parseServiceTask(Element serviceTaskElement, ScopeImpl scope, ActivityImpl activity) {
      activity.setAsyncBefore(true);
    }
  });

  configuration.setCustomPreBPMNParseListeners(listeners);
  return configuration;
}
 

@Override
public ProcessEngineConfiguration configureEngine(ProcessEngineConfigurationImpl configuration) {
  List<BpmnParseListener> listeners = new ArrayList<>();
  listeners.add(new AbstractBpmnParseListener(){

    @Override
    public void parseServiceTask(Element serviceTaskElement, ScopeImpl scope, ActivityImpl activity) {
      activity.setAsyncBefore(true);
      activity.setAsyncAfter(true);
    }
  });

  configuration.setCustomPreBPMNParseListeners(listeners);
  return configuration;
}
 

private ProcessEngine createProcessEngine() {
  StandaloneInMemProcessEngineConfiguration configuration = new StandaloneInMemProcessEngineConfiguration();
  configuration.setCustomPreBPMNParseListeners(Collections.<BpmnParseListener> singletonList(eventBridgeActivator));
  configuration.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
  ProcessEngineFactoryWithELResolver engineFactory = new ProcessEngineFactoryWithELResolver();
  engineFactory.setProcessEngineConfiguration(configuration);
  engineFactory.setBundle(bundleContext.getBundle());
  engineFactory.setExpressionManager(new OSGiExpressionManager());
  engineFactory.init();
  return engineFactory.getObject();
}
 

private void addConnectorParseListener(ProcessEngineConfigurationImpl processEngineConfiguration) {
  List<BpmnParseListener> preParseListeners = processEngineConfiguration.getCustomPreBPMNParseListeners();
  if(preParseListeners == null) {
    preParseListeners = new ArrayList<BpmnParseListener>();
    processEngineConfiguration.setCustomPreBPMNParseListeners(preParseListeners);
  }
  preParseListeners.add(new ConnectorParseListener());
}
 

public void preInit(ProcessEngineConfigurationImpl processEngineConfiguration) {
  List<BpmnParseListener> preParseListeners = processEngineConfiguration.getCustomPreBPMNParseListeners();
  if(preParseListeners == null) {
    preParseListeners = new ArrayList<BpmnParseListener>();
    processEngineConfiguration.setCustomPreBPMNParseListeners(preParseListeners);
  }
  preParseListeners.add(new ProcessApplicationEventParseListener());
}
 

protected List<BpmnParseListener> getDefaultBPMNParseListeners() {
  List<BpmnParseListener> defaultListeners = new ArrayList<>();
  if (!HistoryLevel.HISTORY_LEVEL_NONE.equals(historyLevel)) {
    defaultListeners.add(new HistoryParseListener(historyEventProducer));
  }
  if (isMetricsEnabled) {
    defaultListeners.add(new MetricsBpmnParseListener());
  }
  return defaultListeners;
}
 

public List<BpmnParseListener> getCustomPreBPMNParseListeners() {
  return preParseListeners;
}
 

/**
 * @deprecated use {@link #setCustomPostBPMNParseListeners} instead.
 */
@Deprecated
public void setPostParseListeners(List<BpmnParseListener> postParseListeners) {
  this.postParseListeners = postParseListeners;
}
 

/**
 * @deprecated use {@link #getCustomPostBPMNParseListeners} instead.
 */
@Deprecated
public List<BpmnParseListener> getPostParseListeners() {
  return postParseListeners;
}
 

/**
 * @deprecated use {@link #setCustomPreBPMNParseListeners} instead.
 */
@Deprecated
public void setPreParseListeners(List<BpmnParseListener> preParseListeners) {
  this.preParseListeners = preParseListeners;
}
 

/**
 * @deprecated use {@link #getCustomPreBPMNParseListeners} instead.
 */
@Deprecated
public List<BpmnParseListener> getPreParseListeners() {
  return preParseListeners;
}
 

public void setCustomPostBPMNParseListeners(List<BpmnParseListener> postParseListeners) {
  this.postParseListeners = postParseListeners;
}
 

public List<BpmnParseListener> getCustomPostBPMNParseListeners() {
  return postParseListeners;
}
 

public void setCustomPreBPMNParseListeners(List<BpmnParseListener> preParseListeners) {
  this.preParseListeners = preParseListeners;
}
 

public ActivityImpl parseServiceTaskLike(String elementName, Element serviceTaskElement, ScopeImpl scope) {
    logger.debug("parse service task like element,elementName={}", elementName);

    ActivityImpl activity = createActivityOnScope(serviceTaskElement, scope);

    String type = serviceTaskElement.attributeNS(CAMUNDA_BPMN_EXTENSIONS_NS, TYPE);
    String className = serviceTaskElement.attributeNS(CAMUNDA_BPMN_EXTENSIONS_NS, PROPERTYNAME_CLASS);
    String expression = serviceTaskElement.attributeNS(CAMUNDA_BPMN_EXTENSIONS_NS, PROPERTYNAME_EXPRESSION);
    String delegateExpression = serviceTaskElement.attributeNS(CAMUNDA_BPMN_EXTENSIONS_NS,
            PROPERTYNAME_DELEGATE_EXPRESSION);
    String resultVariableName = parseResultVariable(serviceTaskElement);

    parseAsynchronousContinuationForActivity(serviceTaskElement, activity);

    parseServiceTaskLikeAttributes(elementName, serviceTaskElement, scope, activity, type, className, expression,
            delegateExpression, resultVariableName);

    parseExecutionListenersOnScope(serviceTaskElement, activity);

    for (BpmnParseListener parseListener : parseListeners) {
        parseListener.parseServiceTask(serviceTaskElement, scope, activity);
    }

    if (activity.getActivityBehavior() == null) {
        String defaultDelegateExpression = "${taskDispatcher}";
        if (resultVariableName != null) {
            addError(PREFIX_ERROR_MSG_VARIABLE_NAME + elementName + " elements using 'delegateExpression'",
                    serviceTaskElement);
        }

        activity.setActivityBehavior(new ServiceTaskDelegateExpressionActivityBehavior(
                expressionManager.createExpression(defaultDelegateExpression),
                parseFieldDeclarations(serviceTaskElement)));
    }

    // activity behavior could be set by a listener (e.g. connector); thus,
    // check is after listener invocation
    if (activity.getActivityBehavior() == null) {
        addError("One of the attributes 'class', 'delegateExpression', 'type', or 'expression' is mandatory on "
                + elementName + ".", serviceTaskElement);
    }

    return activity;
}
 

public void addCustomPostBpmnParseListener(final BpmnParseListener bpmnParseListener) {
  getCustomPostBPMNParseListeners().add(Objects.requireNonNull(bpmnParseListener));
}
 

private static List<BpmnParseListener> customPreBPMNParseListeners(final ProcessEngineConfigurationImpl processEngineConfiguration) {
  if (processEngineConfiguration.getCustomPreBPMNParseListeners() == null) {
    processEngineConfiguration.setCustomPreBPMNParseListeners(new ArrayList<>());
  }
  return processEngineConfiguration.getCustomPreBPMNParseListeners();
}
 

protected void parseEndEvent(Element parentElement, ScopeImpl scope, Element endEventElement) {
    ActivityImpl activity = createActivityOnScope(endEventElement, scope);

    Element errorEventDefinition = endEventElement.element(ERROR_EVENT_DEFINITION);
    Element cancelEventDefinition = endEventElement.element(CANCEL_EVENT_DEFINITION);
    Element terminateEventDefinition = endEventElement.element("terminateEventDefinition");
    Element messageEventDefinitionElement = endEventElement.element(MESSAGE_EVENT_DEFINITION);
    Element signalEventDefinition = endEventElement.element(SIGNAL_EVENT_DEFINITION);
    Element compensateEventDefinitionElement = endEventElement.element(COMPENSATE_EVENT_DEFINITION);
    Element escalationEventDefinition = endEventElement.element(ESCALATION_EVENT_DEFINITION);

    if (errorEventDefinition != null) { // error end event
        parseErrorEventDefinition(parentElement, scope, endEventElement, activity, errorEventDefinition);
    } else if (cancelEventDefinition != null) {
        parseCancelEventDefinition(parentElement, scope, endEventElement, activity, cancelEventDefinition);
    } else if (terminateEventDefinition != null) {
        parseTerminateEventDefinition(parentElement, scope, endEventElement, activity, terminateEventDefinition);
    } else if (messageEventDefinitionElement != null) {
        parseMessageEventDefinitionElement(parentElement, scope, endEventElement, activity,
                messageEventDefinitionElement);
    } else if (signalEventDefinition != null) {
        parseSignalEventDefinition(parentElement, scope, endEventElement, activity, signalEventDefinition);
    } else if (compensateEventDefinitionElement != null) {
        parseCompensateEventDefinitionElement(parentElement, scope, endEventElement, activity,
                compensateEventDefinitionElement);
    } else if (escalationEventDefinition != null) {
        parseEscalationEventDefinition(parentElement, scope, endEventElement, activity, escalationEventDefinition);
    } else { // default: none end event
        activity.getProperties().set(BpmnProperties.TYPE, ActivityTypes.END_EVENT_NONE);
        activity.setActivityBehavior(new NoneEndEventActivityBehavior());
    }

    if (activity != null) {
        parseActivityInputOutput(endEventElement, activity);
    }

    parseAsynchronousContinuationForActivity(endEventElement, activity);

    parseExecutionListenersOnScope(endEventElement, activity);

    for (BpmnParseListener parseListener : parseListeners) {
        parseListener.parseEndEvent(endEventElement, scope, activity);
    }
}
 

/**
 * Sets the test run state for the coverage listeners. logging.
 * {@see ProcessCoverageInMemProcessEngineConfiguration}
 */
private void initializeListenerRunState() {

    final ProcessEngineConfigurationImpl processEngineConfiguration = (ProcessEngineConfigurationImpl) processEngine.getProcessEngineConfiguration();

    // Configure activities listener

    final FlowNodeHistoryEventHandler historyEventHandler = (FlowNodeHistoryEventHandler) processEngineConfiguration.getHistoryEventHandler();
    historyEventHandler.setCoverageTestRunState(coverageTestRunState);

    // Configure sequence flow listener

    final List<BpmnParseListener> bpmnParseListeners = processEngineConfiguration.getCustomPostBPMNParseListeners();

    for (BpmnParseListener parseListener : bpmnParseListeners) {

        if (parseListener instanceof PathCoverageParseListener) {

            final PathCoverageParseListener listener = (PathCoverageParseListener) parseListener;
            listener.setCoverageTestRunState(coverageTestRunState);
        }
    }

    // Compensation event handler

    final EventHandler compensationEventHandler = processEngineConfiguration.getEventHandler("compensate");
    if (compensationEventHandler != null && compensationEventHandler instanceof CompensationEventCoverageHandler) {

        final CompensationEventCoverageHandler compensationEventCoverageHandler = (CompensationEventCoverageHandler) compensationEventHandler;
        compensationEventCoverageHandler.setCoverageTestRunState(coverageTestRunState);

    } else {
        logger.warning("CompensationEventCoverageHandler not registered with process engine configuration!"
                + " Compensation boundary events coverage will not be registered.");
    }

}