Wait Program Intermediate Event

The Wait Program Intermediate Event element is located in the Event & Gateway drawer of the process editor palette.

Element Details

This element is one of Axon Ivy facilities to integrate custom-made software, legacy systems, proprietary applications or any other external system through an Axon Ivy Java interface. At an Intermediate Event element the process execution is interrupted and waits for an external event to occur. Technically spoken the current task will be ended and a new system task is created that waits for the intermediate event. If the intermediate event is fired the new task and therefore the process after the intermediate event will be executed.

Inscription

Name Tab

The Name Tab is included in the mask of all process elements and contains the name and a description of the element.

Event Tab

On this tab you define the Java class that the IntermediateEvent should instantiate, the identifier of the event, and the timeout behavior.

Java Class: Fully qualified name of the Java class that implements the IProcessIntermediateEventBean interface. Use the New Bean Class Wizard to create a new Java source file with an example implementation of the bean class.
Event ID: Because multiple cases (process instances) can wait on the same intermediate event you must specify which event belongs to which waiting case. Here, you specify the identifier of the event the current case should wait for.

Warning

The event identifier as a String must be unique. Do not use a static string like "myID". A good practice is to integrate the case identifier (ivy.case.getId()) into the event id.
Timeout: You can specify how long the current case should wait for an intermediate event, and what will happen if no event has been received after this time. You may optionally start an exception process, delete the waiting task, or continue the waiting task without receiving an intermediate event.

Editor Tab

The custom editor UI provided by the implementation of IProcessIntermediateEventBean allows to configure its execution.

Task Tab

On this tab you configure the task which is created when this element is executed by the awaited event. This task will not appear in any user task list and is exclusively handled by the system. The values on this tab are therefore only relevant for analyzing the finished tasks and not for the task list itself.

Custom fields: The values set on this table are only informational and have no effect on how this task is treated by Axon Ivy. See Custom Fields.
Code: This is a post construct code block for the Task that is defined in this tab. The created Task is provided as variable called task. See Code.

Output Tab

On Output Tab you can configure the output of the element (i.e. the data that leaves the element).

Implementation

To initiate a custom bean implementation for your third party system, you start most conveniently by using the New Class button on the Event Tab. The wizard will create a minimal sample implementation that works already. You can then adjust it to your needs.

API reference

The Intermediate Event consumes a Java class that implements the IProcessIntermediateEventBean interface. This implementation is responsible to continue the process by calling the method fireProcessIntermediateEventEx of IProcessIntermediateEventBeanRuntime. The common way to implement an Intermediate Event Bean is to extend from AbstractProcessIntermediateEventBean.

If you use an Axon Ivy Cluster, you may mark your implementation with the IMultiNodeCapable interface. This will enable your Intermediate Event to be processed not only on the master node, but on all available nodes.

Custom configuration

Very likely your Intermediate Event implementation will accept configuration parameters defining the local environment. For instance, a system specific file path to look for files being produced by a legacy system.

We help you with these configurations by providing an accessor for static element configuration via getConfiguration().

Custom editor

To define your custom configuration on the process inscription mask, you must supply an inner Editor class implementation. We recommend to extend your implementation from UiEditorExtension.

This editor class is responsible for two things: Firstly, to create UI widgets, which display configuration values. And secondly, to map configuration data onto these widgets:

1. The initUiFields method supports you in creating widgets for the editor. Currently labels, scriptEditors and textEditors are supported.

2. The ConfigurableExtensionEditor provides methods to read and write configurations, in order to bind them to previously created ui widgets.

Example implementation

package com.axonivy.wf.custom;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import java.util.Properties;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.apache.commons.lang3.StringUtils;

import ch.ivyteam.ivy.persistence.PersistencyException;
import ch.ivyteam.ivy.process.extension.ui.ExtensionUiBuilder;
import ch.ivyteam.ivy.process.extension.ui.IUiFieldEditor;
import ch.ivyteam.ivy.process.extension.ui.UiEditorExtension;
import ch.ivyteam.ivy.process.intermediateevent.AbstractProcessIntermediateEventBean;
import ch.ivyteam.util.PropertiesUtil;

public class ErpPrintJob extends AbstractProcessIntermediateEventBean {

  public ErpPrintJob() {
    super("ErpPrintJob", "Waits for ERP reports", File.class);
  }

  @Override
  public void poll() {
    Properties configs = PropertiesUtil.createProperties(getConfiguration());
    int seconds = Integer.parseInt(configs.getProperty(Config.INTERVAL, "60"));
    getEventBeanRuntime().setPollTimeInterval(TimeUnit.SECONDS.toMillis(seconds));

    String path = configs.getProperty(Config.PATH, "");
    try (Stream<Path> csv = Files.list(Path.of(path)).filter(f -> f.startsWith("erp-print"))) {
      List<Path> reports = csv.collect(Collectors.toList());
      for(Path report : reports) {
        String fileName = report.getFileName().toString();
        String eventId = StringUtils.substringBefore(fileName, ".pdf");
        continueProcess(report.toFile(), eventId);
      }
    } catch (IOException ex) {
      getEventBeanRuntime().getRuntimeLogLogger().error("Failed to check ERP for updates", ex);
    }
  }

  private void continueProcess(File report, String eventId) {
    try {
      getEventBeanRuntime().fireProcessIntermediateEventEx(eventId, report, "");
    } catch (PersistencyException ex) {
      getEventBeanRuntime().getRuntimeLogLogger().error("Failed to resume process with event"+ eventId, ex);
    }
  }

  public static class Editor extends UiEditorExtension {

    private IUiFieldEditor path;
    private IUiFieldEditor interval;

    @Override
    public void initUiFields(ExtensionUiBuilder ui) {
      ui.label("Path to read produced PDF files from:").create();
      path = ui.textField().create();

      ui.label("Interval in seconds to check for changes:").create();
      interval = ui.scriptField().requireType(Integer.class).create();
    }

    @Override
    protected void loadUiDataFromConfiguration() {
      path.setText(getBeanConfigurationProperty(Config.PATH));
      interval.setText(getBeanConfigurationProperty(Config.INTERVAL));
    }

    @Override
    protected boolean saveUiDataToConfiguration() {
      clearBeanConfiguration();
      setBeanConfigurationProperty(Config.PATH, path.getText());
      setBeanConfigurationProperty(Config.INTERVAL, interval.getText());
      return true;
    }
  }

  private interface Config {
    String PATH = "path";
    String INTERVAL = "interval";
  }

}