Program Start

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

Element Details

The Program Start element allows you to start a process by a custom trigger. Therefore, it is perfect to integrate legacy-systems or any java-implementation you can think of being useful in starting workflow-cases.

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.

Start Tab

On this tab you define the Java class to be executed.

Start tab

Java Class

Fully qualified name of the Java class that implements the IProcessStartEventBean interface. Use the New Bean Class Wizard to create a new Java source file with an example implementation of the bean class.

Permission

Defines the role that is required to be able to start a process. The bean will set up an authorized session that calls the fireProcessStartEventRequest() from the eventRuntime to trigger a process.

Editor Tab

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

A custom editor example

Implementation

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

API reference

The Program Start consumes a Java class that implements the IProcessStartEventBean interface. This implementation is responsible to initiate a new process by calling the method fireProcessStartEventRequest of IProcessStartEventBeanRuntime. The common way to implement a Start Event Bean is to extend from AbstractProcessStartEventBean.

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

Custom configuration

Very likely your Program Start implementation will accept configuration parameters to define 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 configs by providing an accessor to statically configured 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.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import ch.ivyteam.ivy.process.eventstart.AbstractProcessStartEventBean;
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.request.RequestException;
import ch.ivyteam.util.PropertiesUtil;

public class ErpInvoice extends AbstractProcessStartEventBean {

  public ErpInvoice() {
    super("ErpInvoice", "Integrates ERP updates driven by CSV files");
  }

  @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))) {
      List<Path> updates = csv.collect(Collectors.toList());
      startProcess("new stock items", Map.of("sheets", updates));
    } catch (IOException ex) {
      getEventBeanRuntime().getRuntimeLogLogger().error("Failed to check ERP for updates", ex);
    }
  }

  private void startProcess(String firingReason, Map<String, Object> parameters) {
    try {
      getEventBeanRuntime().fireProcessStartEventRequest(null, firingReason, parameters);
    } catch (RequestException ex) {
      getEventBeanRuntime().getRuntimeLogLogger().error("Failed to init ERP driven process", ex);
    }
  }

  public static class Editor extends UiEditorExtension {

    private IUiFieldEditor path;
    private IUiFieldEditor interval;

    @Override
    public void initUiFields(ExtensionUiBuilder ui) {
      ui.label("Path to read .CSV stock-item changes:").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";
  }

}