# Eximee Case Management

**Eximee Case Management** this is an Eximee platform module responsible for managing cases, tasks, and the users' work context.\
It enables full handling of the case lifecycle — from initiation, through execution and progress monitoring, to archiving the history of actions.\
This module integrates data from EximeeBPMS processes, data models, and external applications, creating a central place for managing business cases.

## Module role and architecture

### **General description**

`Eximee Case Management` it serves as an intermediate layer between business processes (EximeeBPMS), user forms (Eximee Forms), and operational applications (e.g., Eximee Dashboard, BackOffice).\
It provides a set of tools for displaying and executing tasks, browsing cases, and interacting with the user context.

### **Module objectives**

* Consolidation of case and task data from multiple sources.
* Providing users with a unified interface for performing tasks.
* Relieving the BPMS process engine from storing and presenting operational data.
* Support for the model *Case-Oriented Processing* — focused on the customer or case context, rather than on the process itself.

### **Logical architecture**

The module consists of the following layers:

1. **Presentation layer** — user interface (usually embedded in Eximee Dashboard).
2. **Application layer** — Case Management logic (task handling, lists, business actions).
3. **Integration layer** — communication with EximeeBPMS, Data Model Runtime, and Forms.
4. **Data layer** — repository of case states and event history (independent of BPMS).

## Functionality

### **User task handling**

* List of tasks assigned to a user or team.
* Filtering, sorting, and searching tasks.
* Configurable columns and list layouts.
* Handling priorities, deadlines, and statuses.
* Performing subsequent tasks in sequential mode (*Next Best Task*).
* Batch task handling.
* Ability to execute automatic tasks in the background (automation engine).
* Integration with forms **Eximee Forms** as the user interface.

### **Case handling (Case View)**

* Browsing cases and their statuses.
* Filtering and sorting the case list by business context (e.g., customer, product, process).
* Detailed case view with information about:
  * the history of actions and decisions,
  * attached documents,
  * related tasks,
  * contextual data (from the data model).
* Ability to launch forms and microapplications in the context of a given case.
* Creating new cases by the user (e.g., in FrontOffice or BackOffice).

### **History and event handling**

* Recording case history independently of the workflow engine (EximeeBPMS).
* Using events from business processes and applications (Event-Based Architecture).
* Recording user actions and status changes.
* Support for audit in compliance with regulatory requirements (e.g., KNF).

### **Business actions**

* Definable actions available to the user in the context of a case or task (e.g., “Approve”, “Reject”, “Forward”).
* Parameterization of available actions at the low-code application level.
* Handling system and custom actions (custom handlers).

### **Customer context handling**

* Presentation of customer data related to the case.
* Integration with CRM, KYC, scoring, etc. systems.
* Dynamic loading of contextual data.

## Integrations

### **Integration with EximeeBPMS**

* Passive use of the BPMS engine — Case Management does not execute processes, but monitors them.
* Subscription to process events (task created, task completed, incident occurred).
* Reading process data via the BPMS API.

### **Integration with Eximee Forms**

* Forms serve as the user interface for tasks in Case Management.
* Each task can launch an assigned low-code form.
* Shared data context (case ↔ form ↔ process).

### **Integration with Eximee Model Runtime**

* Fetching contextual case and customer data.
* Updating data during task execution.

### **Integration with Eximee Dashboard**

* Case Management is one of the key modules of Eximee Dashboard.
* It provides screens for lists of cases, tasks, and history.
* It enables embedding microapplications supporting work (e.g., notes, calendar, document list).

## Technical features

* Microfrontend architecture with the ability to expand with extension applications.
* Built-in filtering, sorting, and pagination mechanisms.
* Scalability and separation of user contexts.

## Example use cases

### **FrontOffice / BackOffice**

* The advisor opens the customer's case and sees a list of all related tasks.
* They perform subsequent process steps (e.g., “Data verification”, “Contract approval”) by launching a form.
* The case history is automatically updated based on BPMS events.

### **Operations manager**

* Reviews the team task list and prioritizes it.
* Performs group operations, e.g., task assignment or status changes.
* Analyzes employee workload based on metrics from Case Management.

### **External partner**

* Receives a view of their cases and tasks within the shared partner channel.
* Handles selected stages of the process, e.g., customer document verification.

## Common features and deployment parameters

* **Configuration flexibility:** list, detail, and action views defined low-code in Case Management Designer.
* **Reusability:** one Case Management component can support multiple applications.
* **Security:** full control over access to data and operations based on domain roles.
* **Personalization:** ability to adapt layout, filters, and actions to the specifics of the implementation.
* **Scalability:** separating presentation logic from process data enables independent scaling.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.eximee.com/documentation/documentation-en/wprowadzenie/architektura-platformy/moduly-wykonawcze/eximee-case-management.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
