New and Noteworthy for Axon.ivy Designer 7.0 (Jakobshorn)

This document describes all new and noteworthy features of the Axon.ivy Designer 7.0 (Jakobshorn) release.

Only a brief overview of important new features is provided here. It is recommended that you consult the respective sections of the updated Designer Guide (via Help > Help Contents > Axon.ivy Designer Guide) if you desire more detailed information about individual new features.

If you are interested in features introduced in the previous releases have a look at Axon.ivy Designer 6.0 New and Noteworthy

The content of this file has been grouped into different sections with related content:


6.0 projects (and older) need to be converted for Axon.ivy 7.0!

See the separate Migration Notes to learn about what needs to be done to get your projects running with Axon.ivy 7.0 (Jakobshorn).

Selected Features

Adaptive Case Management

Axon.ivy supports you to build agile workflows. The times of strictly defined BPM processes are over.

Today the user often has the need to adapt the process flow during execution. Optional side tasks are required in addition to the normal process flow or a set of tasks must be skipped because of a special condition. Signals bring the power back to the user which has often more know-how about the domain and the current context of the process. The workflow history and context of a task is still clear trough the introduction of Business Cases.

Processes using Signals and Business Cases are demonstrated in the new WorkflowDemos project. And an introduction plus use cases for Adaptive Case Management can be found in the Designer Guide: See Help > Designer Guide > Concepts > Adaptive Case Management


Signals make the loose coupling of processes possible. Signals are sent application-wide without the need for project dependency between the sender and receiver.

Signal Boundary Event

The Signal Boundary Event allows you to destroy a User task by a signal.

See Help > Designer Guide > Process Modeling > Process Elements Reference > Signal Boundary Event for more information.

Signal Start Event

With the Signal Start Event you can start a process by sending a signal.

See Help > Designer Guide > Process Modeling > Process Elements Reference > Signal Start for more information.

API for sending Signals

Signals can be sent via API:

Example: Send signal "user:created":"user:created");

See Help > Designer Guide > Concepts > Signals > Sending Signals for more information about sending signals.

Signal receivers and history API

With the receiver's API active signal receivers can be queried.

Example: Query all Signal Start Events that listen to the signal code "user:created":

import ch.ivyteam.ivy.workflow.signal.IStartSignalEventElement;
List<IStartSignalEventElement> signalStarts =

With the history API sent signals can be queried.

Example: Query sent signals, whose signal code starts with "admin:quit:":

import ch.ivyteam.ivy.workflow.signal.ISignalEvent;
List<ISignalEvent> signalEvents =

See Public API ch.ivyteam.ivy.workflow.signal.IBpmSignalService for more information.

Business Case

The execution of adaptive cases can vary in every execution. Therefore, the workflow user needs a clear context and history for a task on which he is involved.

The entity that can glue multiple process cases together is the Business Case. All cases and tasks that belong to the same Business Case are presented to the user of a workflow screen as related cases.

Attach to Business Case

Every Signal Start event and triggerable Request Start can configure whether its cases should run in the context of the invoking Business Case or if they represent a completely new Case.

You can also use the Public API to attach the current case to an existing Business Case.

if (in.departement.equals("HR")){

Business Case API

For workflow front end developers there exists API to list all tasks or cases of a Business Case. So, showing the involved cases and tasks to a workflow user is a simple implementation. For more details see the Public API of ch.ivyteam.ivy.workflow.businesscase.IBusinessCase.; // get involved tasks that are active; // get all involved tasks

Case Map

In adaptive case management the loose coupling between the processes, which you can achieve easily with the concept of Signals, is cursing and blessing at the same time. The processes become highly flexible but the big picture of the hole business process from a business point of view get lost.

At this point the case map comes into play. A case map defines how the business process looks like in terms of stages, processes and side steps. A business process is divided into stages. Each stage defines a certain phase in the lifecycle of a business process. A business process is started with the first stage in the case map. The processes in a stage are executed from top to bottom. The execution of a process is conditional and control with a precondition. If the last process of a stage is executed then the stage is finished and the next stage gets started. A business process is finished if the last stage has been executed. However, a business process can jump from stage to stage in any order by setting the stage attribute of a business case.

New Case Map Wizard

To create a new case map, you can use the New Case Map Wizard.

Case Maps in the IvyProject tree

Case Maps are displayed in the IvyProject tree. Double click on them will open the Case Map editor.

Case Map Editor

To create and edit Case Maps you can use the Case Map Editor.

Designer Workflow UI support for Case Maps

A case map can be started from the engine start page.

The case map associated with a business case is displayed in the business case details.

Animation / Simulation of Case Maps

You can follow the execution of a Case Map in the Case Map Editor. It uses the simulation settings known from the BPM processes.

Business Data Store

The Business Data feature allows to store and load business data in a built-in repository without defining a schema. Compared to other ivy persistence features like database steps and JPA no additional database, database connection, schema or tables are needed.

The business data structure is defined by declaring normal data classes or Java classes. When storing a business data object all objects that are referenced from the root object are stored as well. Loading a business data object will recreate the whole object structure again. The data is stored in a schema less JSON based data format in the ivy standard System database. This allows to add fields to data classes over time and still be able to load old business data without migration.

The business data feature also allows to search the stored data by defining field based filters.

See Help > Designer Guide > Data Modeling > Business Data Store


Normal data classes and Java objects can be stored without defining a database schema!

Create and save:
Dossier dossier = ...
in.businessDataId =;


Load a business data object from the repository to modify it.

Load, modify and save:
Dossier storedDossier = ivy.repo.find(in.businessDataId, Dossier.class);


There is a new fluent API to search stored business data. The API supports filtering, ordering and limiting of the results.

Example: Search all dossiers that have a person.firstName starting with A, sort the dossiers by person.lastName and return the first 10 matching dossiers:

List<Dossier> result =

Example: Search all dossiers that have a field containing one of the words Alan, John or Wolfgang:

List<Dossier> result =
    .allFields().containsAnyWords("Alan John Wolfgang")

Store with own Id

Instead of using the auto generated id to identify a Business Data value, it is possible to set an own id. The Business Data class must contain a String field with name id and must be set before saving the Business Data value for the first time.

Dossier dossier = ...
String yourId = ... // generate your own id, be sure it is unique! = yourId; // set your id to the Business Data value;
ivy.repo.find(yourId, Dossier.class) // get your Business Data value 

Business Case Context

If you annotate a data class with BusinessCaseContext then the business data repository loads and saves objects of the data class attached to the current business case.

// Gets the Dossier which is attached to your current business case.
// Either loads it from the repository or if it does not exist yet it creates a new object.
Dossier dossier = ivy.repo.get(Dossier.class);
...; // save and attach the dossier to the current business case 

Fuzzy Search and Query String

Sometimes we don't know how a term like a name is correctly spelled, fuzzy search helps you with that by allowing you to search for incorrectly spelled names and still showing relevant entries.

Example: Search all dossiers for Meier.

List<Dossier> result =

The result will also display entries containing Maier or Meyer.

The possibility to make search queries that resemble queries performed on an internet search engine was introduced.

Example: Search all fields of a Dossier that contain Baldwin with the edit distance (fuzziness) of 1 and score documents higher that don't contain Alec.

List<Dossier> result =
    .query("Baldwin~1 -Alec")

A list of possible operators that can be used inside the query can be found in the Elasticsearch documentation for Simple Query String.

Elasticsearch 5.5

Elasticsearch which is used to index business data and provides the search functionality has been updated from 2.3.4 to 5.5.0.

REST Web-Services

Ivy supports JAX-RS, the Java specification for RESTful web services. How to use and provide REST services is demonstrated in the new ConnectivityDemos project.

The new chapter 3rd Party Integration in the Designer Guide gives you an overview, which options you have to integrate ivy with foreign systems.
See Help > Designer Guide > 3rd Party Integration

REST Client Process Element

There is a new process element called REST Client available. It can be used to call REST Services.

The element makes it simple to send dynamic process data to a remote REST service. Within the response tab you can easily consume the result and map it back to your process data.

The Rest Client element is always an excellent choice to model calls to a remote REST service. If you need to set a request option that is not configurable on the Inscription mask. You can switch to the JAX_RS mode which allows you to fine tune your request and use any logic that is available in the plain java client.

REST Client Editor

There is a new entry in the ivy project tree called 'REST Clients'.

The corresponding REST Client Editor can be used to configure REST Clients.

See Help > Designer Guide > Configuration > REST Clients Configuration for more information.

REST call logging and monitoring

For each REST call the HTTP request and response is logged to the Runtime Log.

Content-Type: application/json
<< 200 OK
Content-Length: 0
Date: Thu, 12 Jan 2017 10:33:06 GMT
Server: -
Set-Cookie: JSESSIONID=40F782DE16B4E87A21D2946A05532F80; Path=/ivy/; HttpOnly

REST calls are now also monitored. See Engine New and Noteworthy for details.

Provide custom REST Resources

To provide custom REST services from an ivy project, JAX-RS annotations can be used. A Java class that uses the corresponding annotations will be automatically detected and published as REST resource.

public class CustomProjectResource {
    public Person get() {
        Person p = new Person();
        return p;

Fluent SubProcessCall API

There is a new fluent SubProcessCall API to select a CallSubStart call it and get the result (could be used in a REST provider):
String name = SubProcessCall
    .withPath("Functional Processes/Customer")
    .withParam("id", 27)
    .get("name", String.class);

See Public API for more information.

Rule Engine

Drools integration

The Drools Rule Engine is now integrated in Axon.ivy. With a rule engine you can decouple your business rules from your code so that you can develop and test them independently. See the quote from the corresponding blog entry of Martin Fowler:

... is a set of production rules, each of which has a condition and an action - simplistically you can think of it as a bunch of if-then statements. The subtlety is that rules can be written in any order, the engine decides when to evaluate them using whatever order makes sense for it. A good way of thinking of it is that the system runs through all the rules, picks the ones for which the condition is true, and then evaluates the corresponding actions.

Just import the new demo project RuleEngineDemos to get a quick start into the world of rules in Axon.ivy.

See Help > Designer Guide > Concepts > Rule Engine for more information.

Create Rule files

New rule files can be created from the New button in the toolbar or with the menu entry File > New. You can create either a rule file in DRL (Drools Rule Language) or as a decision table. Use the namespace to organize rules.

See Help > Designer Guide > Concepts > Rule Engine for more information.

Rule files in project tree

The Axon.ivy project root has a new root folder Rules. Below that folder you can see, access and manipulate all your rule files. Double click on a rule file to open it in its editor. The internal DRL editor will open for DRL files. Excel is opened for decision tables in an external window (or in other words, the application that is responsible for opening .xls/.xlsx files)

See Help > Designer Guide > Concepts > Rule Engine for more information.

Execute rules

A Public API is provided to execute the rules. You have to create a rule base in which you load the rules. Then you pass an instance of a data class or Java class or a list thereof into a rule session and execute it. The results of the rules execution will be visible in the passed data or Java classes.

in.ruleBase = ivy.rules.engine.createRuleBase();

See Public API ch.ivyteam.ivy.rule.engine.api for more information.

Rule Resources

Since version 6.5, an alternative for Ivy managed rules is provided. Thus, the developer can manage rules that are not located in the Ivy project. This may be an external file system, a database, a web service ...

IRuleResource ruleFromDb = ... // Provide your own rule resource implementation here. E.g. a rule resource loaded from a db

See Public API ch.ivyteam.ivy.rule.engine.api.resource.IRuleResource for more information.

Hot rule replacement

If you change an existing rule file during the execution of an Axon.ivy project, then we unload the outdated version of the rule file and load the new changed version. You can continue testing/debugging and the changed/new rules are automatically applied.

Be aware that this feature is not active on the Axon.ivy Engine.

See Help > Designer Guide > Concepts > Rule Engine for more information.

Test rules

We support testing your rules too. Just write a plain normal unit test with JUnit. You only need to inherit from the class AbstractRuleEngineTest and you can access the rule engine like you do in production code. You can execute the tests in the Designer as usual. You can run them with our Maven plugin. No problem.

Html Dialog

Start last executed process

It is now possible to start the last executed process on an error page when working with JSF (especially useful when working with Managed Beans). When the button is clicked the last process launch configuration is executed.

Auto Initialization Data Classes

Data Classes are now automatically initialized if an Html Dialog sets a property on it.
E.g. If data.address is null and a form is submitted with a value for data.address.street, then a data.address object is automatically created.

This means no more problems with not initialized complex data structures in Html Dialogs (javax.el.PropertyNotFoundException: Target Unreachable).

See also Public API ch.ivyteam.ivy.scripting.objects.jsf.el.AutoInitializable.

Exception Handling

Ajax exception handlers can catch exceptions which occur in ajax based HTTP requests. By default, there are ajax exception handlers predefined in webContent/layouts/includes/exception.xhtml and used in standard layouts. Especially expired session or view exceptions can be treated correctly now.


<p:dialog id="viewExpiredExceptionDialog" header="View or Session Expired" widgetVar="viewExpiredExceptionDialog" height="50px">
  <h:outputText value="The view or session has expired."/>
  <h:outputLink value="#{ivy.html.loginRef()}">Please login again.</h:outputLink>

See Help > Designer Guide > User Dialogs > Html Dialogs > Error Handling for more information.

Html Dialog Editor

Manipulate components

It is possible to select embedded components with a left mouse click as usual. Use the DELETE key to delete the selected component(s) or use F3 to jump to the component. It is also possible to re-arrange the component in the view by drag and drop.

Configure components

You can now graphically configure the attributes and the start method of Ivy and JSF composite components directly in the editor. Double click on a component to open the default action for the component. In there you can choose which start method to use (only for Ivy components) and you can map all the attributes that are defined in the interface of the component.

See Help > Designer Guide > User Interface > Html Dialogs > Html Dialog View Types for more information about components.

Better Icon browser

The Font Awesome icons can now be selected from the Icon Browser as well. Furthermore, the icon is now magnified when you hover over it with the mouse and you have more options to filter your icons.

Furthermore, you can now use the Icon Browser as well in the source editor. Use Quick Fix (Ctrl + 1), Code Completion (Ctrl + Space) or the linking feature with F3 (or Ctrl and right mouse click) to invoke the Icon Browser when the caret is inside the icon property. Note, that you can navigate through the Icon browser with the keyboard.

DnD JSF composite components

You can now Drag and Drop as well JSF composite components from the palette into a dialog.


Facets are now rendered better and it is even possible to select and delete them. We too added drag and drop support for the facets so that you can insert elements from the palette into the facet of a table or panel grid (and more).

Smart buttons in property view

In the cell editors of the property view you can now use smart buttons to easily insert CMS content objects, a binding to a data class or a mapping to a logic element.

Smart buttons in the properties view

Task and Case Categorization

Case and Task Categories

A Case or a Task can be assigned to a Category. A category is a structured String (e.g. Finance/Invoices/Payables) and categorize them into a hierarchical structure. It is beside the name of a Task (or Case) an important identification attribute of a Case or Task.

Category API

There is a new category property for cases and tasks. A category is a structured String (e.g. Finance/Invoices) and categorize them into a hierarchical structure. The Category API allows to get localized information from the CMS. E.g. the name of the category Finance/Invoices is stored in the CMS at /Categories/Finance/Invoices/name.

The following example shows a simple usage of a category on Case level. The API on Task level is identical."Finance/Invoices");

String categoryName =; // EN: "Invoices", DE: "Rechnungen"
String categoryPath =; // EN: "Finance/Invoices", DE: "Finanzen/Rechnungen"


HTTP Basic Authentication

Web Service processes can now be authenticated using HTTP Basic. Therefore, it is now possible to use a common authentication mechanism between Web Service calls and Web Service processes.

Since HTTP Basic sends the password in clear text over the wire we strongly suggest that you use HTTPS to secure the communication.

Role Members

We have introduced the concept of Member Roles, which simplifies the configuration and administration of roles.

In the configuration example below the role First Level has linked member roles Team A and Team B. While resolving the role tree these member roles are handled like child roles. So users of group Team A or Team B have the role First Level too.

See Help > Designer Guide > Configuration > Roles and Users for more information.

Continuous Integration

Axon.ivy CI Plugin

The Maven project-build-plugin for ivy projects is now able to execute unit tests with maven-surefire, execute integration tests with Selenium, start & stop the test engine and to deploy projects to a running Axon.ivy Engine application.

For more information see:

New project version format

Axon.ivy projects now have a new version format. It is now possible to specify a version with major, minor and incremental parts: e.g. 1.2.3-SNAPSHOT

Mobile App - Geo Location

Location Service

The mobile app sends the current position of a mobile device to Axon.ivy. The information is then stored in location services that are available on the user that has worked with the mobile app and on tasks that have been worked on the mobile app.

Get latest position of task:

import ch.ivyteam.ivy.location.GeoPosition;
GeoPosition taskPosition = ivy.task.locations().search().findLatest().getPosition();

Get latest position of user:

import ch.ivyteam.ivy.location.GeoPosition;
GeoPosition userPosition = ivy.session.getSessionUser().locations().search().findLatest().getPosition();

The location service can also be used to store additional locations:

import ch.ivyteam.ivy.location.GeoPosition;
import ch.ivyteam.ivy.location.ILocation;
        .create(GeoPosition.inDegrees(47.171573, 8.516835))
        .withType("User Home")
        .withNote("My Home is my Castle")

See Help > Designer Guide > Concepts > Offline Tasks > Geo Location for more information.

Public API

API to get everything what is startable

There is a new API to get everything what is startable from an end user point of view. Based on the current session context you will receive all available process starts and additionally all case map starts.

import ch.ivyteam.ivy.workflow.start.IWebStartable;
for (IWebStartable startable : ivy.session.getStartables()) {
  startable.getLink(); // New WebLink value object
  startable.getActivator(); // ISecurityMember

Noteworthy is the new WebLink value object. It provides simple methods to build a link for the web.

import ch.ivyteam.ivy.model.value.WebLink;
WebLink link = new WebLink("üezi&ie=UTF-8");
link.getRelative(); // /search?q=grüezi&ie=UTF-8
link.getRelativeEncoded(); // /search?q=gr%C3%BCezi&ie=UTF-8
link.getAbsolute(); //üezi&ie=UTF-8
link.getAbsoluteEncoded(); //

Case insensitive methods in query API

There are new methods (isEqualIgnoreCase, isNotEqualIgnoreCase, isLikeIgnoreCase, isNotLikeIgnoreCase) on the query API (TaskQuery, CaseQuery, etc) which allow to filter data case insensitive.

import ch.ivyteam.ivy.workflow.query.TaskQuery;
import ch.ivyteam.ivy.workflow.ITask;

List<ITask> tasks = TaskQuery.create().where().name().isLikeIgnoreCase("%customer%").executor().results();

This will find all tasks that contain customer, CUSTOMER or CustoMer, etc. in the task name.

API to get login page url

ivy.html.loginRef() returns the url to the login page. Users can use the login page to authenticate. Consult the engine guide to learn how to customize the login page for your application.

Library Updates

Tomcat 8.5

The Tomcat Webserver of the Axon.ivy Engine has been updated to version 8.5. This updated version of Tomcat implements the Servlet 3.1 specification.

PrimeFaces 6.1

PrimeFaces, the component library for Html Dialogs, has been updated from version 5.3 to 6.1. This enables you to use new themes and widgets.

See the Migration Notes for a list of known migration issues.

JPA 2.1

The Java Persistence API (JPA) has been upgraded to 2.1. The JPA implementation Hibernate has been upgraded to 4.3.11.


Workflow demos

There is a new demo project delivered with the designer which shows some basic workflow control concepts as well as some advanced ones:

  • Self Service BPM example (known from the Portal)
  • Human Task Assignment examples (parallel/sequential task assignment, user tasks)
  • Signal examples
  • Trigger example

The project can be found in the applications/samples directory of the Designer.

Easy import of Axon.ivy sample projects

The new Samples icon on the welcome screen makes it easy to import the Axon.ivy sample projects.

Drag and Drop

You can drag and drop ivy archive files (*.iar) to the Ivy Project View. The dropped ivy archive files are then automatically imported to the workspace.

You can also drag and drop any other file to the Ivy Project View to easily copy or move the file into a project.

Development Mail SMTP

The Designer contains now a simple SMTP server. With the default E-Mail preferences, all mails generated from a Mail-Activity will be sent to this SMTP. You can easily view and inspect any of these mails in the 'Email Messages' view. So, it's no longer necessary to configure an external SMTP to develop your processes.

New Web-Service Call Options

There are two new options to control how Web-Service request parameters are mapped.

See Help > Designer Guide > Process Modeling > Process Elements Reference > Web Service Call Step for more information.

Customized Web-Service Process Endpoints

It's now possible to adapt the auto-generated Web-Service Java file manually, i.e. to add JAX-WS annotations. This is useful in exceptional use cases, when the auto-generated configuration does not fit.

See Help > Designer Guide > Process Modeling > Process Elements Reference > Web Service Start Element > Customization for more information.

Automatic Engine Start

It is now possible to deactivate the automatic start of all process engines on Designer start.

Deprecation Preferences

There is a new preference page to control the visibility of deprecated features.

Java Annotations on data classes and fields

Basic support for Java Annotations in data classes and fields has been added. You can now configure Java Annotations in the *.ivyclass file of a data class using a text editor.

Data #class
java.lang.Deprecated #classAnnotation
ch.ivyteam.demo #namespace
name String #field
name PERSISTENT #fieldModifier
name 'javax.validation.constraints.NotNull(message="Must not be null")' #fieldAnnotation

The generated java source looks like this:

public class Data extends ch.ivyteam.ivy.scripting.objects.CompositeObject
  @javax.validation.constraints.NotNull(message="Must not be null")
  private java.lang.String name;

Axon.ivy Extensions

The extension mechanism of the Axon.ivy Designer and the Engine is now the same since they both run in OSGi mode:

  • The installation of extensions like the BIRT process elements is now streamlined. Simply copy your JAR to dropins and it will be available at runtime. The plugins directory should only be used for automatically installed plugins.
  • Like in the Axon.ivy Designer the Engine now also supports the Eclipse extension point mechanism.
    Therefore, extensions can be registered in the plugin.xml that is in your Axon.ivy extension bundle (*.jar file).

See Help > Designer Guide > Concepts > Extensions for more information.