Cafienne version 1.1.16 has a couple of major enhancements to the core of the engine. Cafienne is built on the Akka runtime framework, giving the engine unique benefits that are fully exploited by the new features. First and foremost benefit is the fact that every case instance lives fully stand-alone in the engine. This enables functional scalability, fine grained authorization control and even dynamic upgrades at the level of an individual instance.
Important - The underlying akka-jdbc library has upgraded from version 4 to 5
This update comes with database schema changes for performance reasons and is not compatible with existing database schemas in Microsoft SQL Server and PostgreSQL.
Existing environments need to add some configuration changes to keep running (more details below)
Thank you sponsors!
- We are thankful to Visionplanner for sponsoring the new Consent Group feature.
- We are thankful to EVConsult for sponsoring the case migration support.
Case Team Authorizations: less restrictions - more control
Every case instance runs inside a so-called tenant. A tenant can be considered a representative of a legal person owning the case. Up to Cafienne 1.1.15, users accessing the case had to be registered within the tenant. This restriction has been removed. Access to a case can now be given to
- Tenant users, as before
- New: Consent Groups
- Any user with a valid IDP token
The consent group feature is a new mechanism to give access to a group of users outside of the tenant to a case instance. The case owner continues to determine which groups get access to the case, and also which roles they may fulfill within the case. But - they no longer can determine which group member can do which group-related task in the case, that control has shifted to the owner of the group. A practical example can be an advisor accessing a case belonging to one of their client companies. The client company owns the case, and gives access to the advisor on the advisory tasks (e.g., one to create a proposal and one to present the proposal to the client). Approval is done by the client, but the client cannot say which advisor user has to create the proposal or present it. That is up to the advisor. Through the new notion of Consent Group it is possible to handle such scenario's in the core of the case model.
Access with just an IDP token
The restriction to give only tenant users access to the case instance made it mandatory to register each and every user inside Cafienne. In a way this can be seen as an additional authentication layer, but there is actually no reason to have that, simply because the Open ID Connect (OIDC) standard already gives this. Therefore, with dropping the need to have only tenant users in the case team, it is also no longer necessary to register other types of users in Cafienne. It is now possible to add an external user with a valid IDP token to the case team.
Support for runtime migration
A key benefit of the Cafienne runtime is the fact that every case instance is fully stand-alone. And that includes the definition. We proudly present new, experimental support for migrating the definition of a running instance to a different version. Through the revised Cafienne UI (that comes with the getting started docker setup) you can quickly experience the power of this functionality by the click of a button. We are happy to receive feedback on this functionality.
The logback libraries have been updated to close a potential security breach.
The persistence plugin for akka jdbc has been updated to version 5.0.4, coming with a new database schema. The old schema is not compatible, but through a couple of configuration settings this can be achieved, see for more details the akka website on this, or contact us if you need help. When you start the engine with an existing schema, it will not corrupt anything but simply throw an error and stop.
The internal build street has been further optimized according to the fail-fast principle. The git history of the source code shows that we have used this change set to include quite a few low level refactoring to the Cafienne engine, both simplifying the code and enhancing the core robustness.