taskana / taskanaadapter

Adapter to sync tasks between TASKANA and Camunda BPM

TASKANA - The open source task management library

TASKANA is a task management component open source library. It can be embedded into your application or be operated standalone if appropriate. Beside the basic task management functionalities, TASKANA adds workbaskets and classifications to control and monitor a large amount of Tasks within a larger organization.

• Web Site: http://taskana.pro/
• Demo Environment: https://taskana.azurewebsites.net/taskana
• Getting Started: https://taskana.atlassian.net/wiki/spaces/TAS/pages/228655109/Getting+started
• Issue Tracker: https://github.com/Taskana/taskana/issues
• Contribution Guildelines: https://taskana.atlassian.net/wiki/spaces/TAS/pages/274202625/Contribution+Guide
• License: Apache License, Version 2.0 https://www.apache.org/licenses/LICENSE-2.0

---

We're not aware of all installations of our Open Source project. However, we love

• listening to your feedback,
• discussing possible use cases with you,
• aligning the roadmap to your needs!

📨 Please contact us if you need consulting support.

---

Table of Contents

• ✨ Overview
  • Tasks
  • Workbasket
  • Classification
  • Routing
  • Prioritization
• Components
  • TASKANA Lib
  • TASKANA REST API
  • TASKANA workplace
  • TASKANA admin
  • TASKANA monitor
• 🚀 Getting Started
  • Requirements
  • Wrapper Application
    • Spring Boot Example
    • EJB Example
• Customize Behaviour
• 📚 Releases
• 📨 Contact

✨Overview

TASKS

Tasks are the main entity of TASKANA. Each Task has its describing attributes like priority and due date.

Furthermore each Task has a state.

And a Task holds a reference to the system and business object, it is associated with. This is important since is meant to be a standalone component.

All Tasks are placed in a Workbasket to control and direct the handling of the Tasks.

WORKBASKETS

Workbaskets are the main structure to distribute the Tasks to the available users. There are personal, group/team and topic Workbaskets.

Workbaskets indicate the responsibility for a Task. The concepts of Workbaskets allow to differentiate between the permissions or the skills required to complete a Tasks and the determination who should complete the Tasks. This can diverge a lot in a larger organization.

CLASSIFICATIONS

Classifications allow to identify the type of a Task. The Task derives some major attributes from the Classification, such as the service level and the priority.

Classifications can be configured by a responsible business administrator to control the handling of the Tasks.

Routing

It offers various routing and distribution functions to assign incoming Tasks to the correct Workbaskets, or to redistribute them between Workbaskets.

Prioritization

The dynamic prioritization functions in allow you to control the processing sequence of Tasks at any time. This ensures that the most important Tasks are always addressed first.

Components

It splits up into five components:

• TASKANA Lib
  • The Java library providing the Task management functions
• TASKANA REST API
  • REST API to allow remote access to the TASKANA system.
• TASKANA workplace
  • Angular based web application to work on the Tasks
  • Sample Tasklist application you can use if appropriate
• TASKANA admin
  • Angular based web application to configure the system
  • Supports Workbaskets and Classifications
• TASKANA monitor
  • Angular based web application to monitor the status of the entire Task pool
  • Provides views and statistics about the conformance with defined services levels
  • Shows the workload of your organization and the individual teams

Demo App Components Diagram

🚀Getting Started

As TASKANA is meant to be integrated in the development environment and process of your organisation, you have to create your own small integration project as a wrapper and starting point for your customisations.

We currently provide examples how to run TASKANA as a Spring Boot Application or as a an Enterprise Application on Wildfly Application Server.

If you are only interested in how TASKANA looks and feel, you can try our Demo Environment instead.

Requirements

Runtime Environment at least Java 17

Supported Databases:

• H2 (We test with 2.1.214*)
• Postgres (We test with 14.7*)
• DB2 (We test with 11.5.6*)
• Oracle (We test with 18c*)

* other versions of the named databases should work also, but haven't been tested

Wrapper Application

Spring Boot Example

We use the h2 database in this example.

See rest/taskana-rest-spring-example-boot and it dependencies

EJB Example

We use a Wildfly Application Server in this example.

See lib/taskana-cdi.

Customize Behaviour

TASKANA allows to customize and modify it’s behaviour through the use of dedicated Service Provider Interfaces (SPI). Each SPI defines an interface that can be implemented by custom code. This is a common approach for Java developers to extend their applications. You can find out more about the background and the details in the Java documentation: https://docs.oracle.com/javase/tutorial/sound/SPI-intro.html

In order to use an SPI within TASKANA, you must

• create a class that implements the relevant interface.

• place that class into the classpath of your application

• provide a control file with full name of the SPI (e. g. pro.taskana.spi.task.api.CreateTaskPreprocessor) in the subdirectory META-INF/services of the classpath. This control file must contain the fully qualified classname (including the package) of the class that implements the relevant interface. This control file is used by the ServiceLoader to load the custom class at runtime. The control file may contain multiple classes has implement the interface. Each implementation should be declared in a new line.

  All implementations will be used consecutively in the declaration order of the control file.

If you provide one or multiple implementations according to the description above, TASKANA will invoke the implementations at a specific point. The Javadoc of each SPI describes the conditions for the implementation to be executed.

Currently, TASKANA provides the following SPIs:

• pro.taskana.spi.history.api.TaskanaHistory
• pro.taskana.spi.priority.api.PriorityServiceProvider
• pro.taskana.spi.routing.api.TaskRoutingProvider
• pro.taskana.spi.task.api.AfterRequestChangesProvider
• pro.taskana.spi.task.api.AfterRequestReviewProvider
• pro.taskana.spi.task.api.BeforeRequestChangesProvider
• pro.taskana.spi.task.api.BeforeRequestReviewProvider
• pro.taskana.spi.task.api.CreateTaskPreprocessor
• pro.taskana.spi.task.api.ReviewRequiredProvider
• pro.taskana.spi.user.api.RefreshUserPostprocessor

📚Releases

The list of releases contains a detailed changelog.

We use Semantic Versioning.

The following compatibility matrix shows the officially supported Spring version for each release. Other combinations might also work but have not been tested.

Release	SpringBoot
7.0.0	2.7.16
6.3.2	2.7.14
6.2.2	2.7.12
6.1.1	2.7.10

📨Contact

If you have any questions or ideas feel free to create an issue or contact us via GitHub Discussions.

We love listening to your feedback, and of course also discussing the project roadmap and possible use cases with you!

This open source project is being developed by Novatec Consulting GmbH and envite consulting GmbH with the support of the open source community.

---

taskanaadapter's Issues

Integrate TaskanaConfiguration Changes

with version 6.1.0 from TASKANA the API from TaskanaConfiguration changed a bit.

With this ticket the API changes should work in the Adapter.

Refactore integration tests that they don't use Thread.sleep anymore

The integrationtests takes very long time because of hard coded Thread.sleep()

Switch to Awaitibility reduces the test time over 2 minutes.

Integrate TASKANA 6.2.0

Update TASKANA Version to 7.0.0

Make relevant modules compatible with Java 8

Integrate TASKANA 8.2.0

Update SpringBoot 3.3.1

Use "docker compose" instead of "docker-compose"

Adding own TaskanaConfiguration Bean not possible

TaskanaSystemConnectorConfiguration defines a taskanaConfigurationBean that has no @ConditionalOnMissingBean(TaskanaConfiguration.class). Add @ConditionalOnMissingBean(TaskanaConfiguration.class) to this Bean.

Upgrade to Spring Boot 3.1.X

Spring Boot 2.7.X and Spring Boot 3.0.X will end of life at the end of November. See the End of Life page: https://endoflife.date/spring-boot

Camunda upgraded the 7er line to Spring Boot 3.1.X already.

Taskana is close to being migrated to Spring Boot 3.1.x see Taskana/taskana#2421

So we can and have to upgrade TaskanaAdapter.

Please try to update all dependencies to the latest version.
for example
this

    <dependency>
      <groupId>javax.xml.bind</groupId>
      <artifactId>jaxb-api</artifactId>
      <version>2.3.1</version>
    </dependency>

will be

    <dependency>
      <groupId>jakarta.xml.bind</groupId>
      <artifactId>jakarta.xml.bind-api</artifactId>
      <version>4.0.1</version>
    </dependency>

Remove taskana-adapter-camunda-spring-boot-test module and distribute its tests to the corresponding/correct module

For the adapter repository we have a big module, which contains all tests.

The goal of this ticket is to remove that module and have each individual test belonging to the correct module.

Sonatype config

Handle adapter clustering

todos:

• Add "lock" column to events (update scripts and schema changes)
• Change of the outbox service: only work on unlocked events + lock events when working on them
• change of the taskana system connector:
  • lock Tasks
  • only synchronize unlocked Tasks

make adapter cluster capable

Enable the adapter to run on a cluster, i.e. allow multiple instances of the adapter to run concurrently

Update H2 to 2.x

Update H2 to the latest version. Since some Keywords are reserved now (e.g. KEY, VALUE) updates without changes are failing. To solve this, minor changes to the H2 configuration has to be done:

Add NON_KEYWORDS=KEY,VALUE to the H2 configuration.

Smoketest fails to access demo app and documentation

• Add sleep before the smoketest. This way, Azure should have enough time to upload new application

Flaky test

CamundaTaskEventErrorHandlerTest.should_CutErrorLog_When_ExceptionCauseTreeIsTooLong

Replace Thread.sleep with Awaitility

In our CoP we decided to replace Thread.sleep with the help of Awaititlity.

Java 17 Migration

As a developer I want to keep up with "new" Java LTS Releases.

Please compile everything with Java 17

Upgrade to Spring Boot 3.2

Upgrade to SpringBoot 3.2

https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-3.2-Release-Notes

Refactore RestTemplate to use new RestClient

https://docs.spring.io/spring-boot/docs/3.2.0-SNAPSHOT/reference/html//io.html#io.rest-client.restclient

Health check for Adapter

Add a Health Check Endpoint to the adapter to verify the adapter is still alive

Refactor README to make it more appealing

Currently our README does not contain detailed explanation about TaskanaAdapter.
This can be done by adding e.g. images.

Please refactor our README so that it will be more appealing to people who have no idea what TaskanaAdapter is and which problem TaskanaAdapter is trying to solve

GitHub Actions: new way to print to stdout

Currently our Workflow throws this warning:

The `set-output` command is deprecated and will be disabled soon. Please upgrade to using Environment Files. For more information see: https://github.blog/changelog/2022-10-11-github-actions-deprecating-save-state-and-set-output-commands/

We have to adjust the way we write to stdout in order to fix that warning.

Enhance Adapter performance by parallelizing Task creation in TASKANA

Todo:

• Parallelization of createTask
• Concurrency configurability (number of threads)
• Automated parallelization test
• Verification that the parallelism also brings a time advantage
• Documentation (incl. configuration recommendation)
• Tests and performance verification should include history and routing

Perform architecture & pojo test on every module

Currently our architecture- & pojo tests are only executed in taskana-core.

Please make them available for every single module in taskana-core to verify code quality.