You are viewing the documentation for Blueriq 13. Documentation for other versions is available in our documentation directory.
Project ZaakType_A
The project ZaakType_A
consists of the following modules:
The project ZaakType_A
contains a generic case dashboard and generic process that is shared between case types and a case type specific implementation and domain.
Module Zaak_Dashboard
and library Basis_ZaakDashboard
The library module Basis_ZaakDashboard
(English:base case dashboard) contains several shared case dashboard features. These features are the generic for all the case types. It contains functionality for case intake, case assignment, case dashboard and task execution. The module Zaak_Dashboard
(English: case dashboard) consists of three specialized containers to select the flows in the interaction modules. The entry point of the project has only one exposed flow that contains the same roles as the Main_Dashboard
.
Page WidgetIntake
This page is used to present the workflow that is used when a user creates a new case. It does not contain the workflow itself as this is a domain specific implementation. The implementation is decoupled from the dashboard using a Container type: AQ_Dashboard_FlowWidget. The container WidgetIntake
is specialized in the module Zaak_Dashboard
because the implementation is different for various case types.
Page WidgetNeemInBehandeling
The page WidgetNeemInBehandeling
(English: widget handle) is used to present the workflow that is used to assign a case to a user. The implementation is decoupled from the dashboard using a Container type: AQ_Dashboard_FlowWidget and is specialized in the module Zaak_Dashboard
.
Page ZaakOverzicht
The page ZaakOverzicht
(English: case overview) shows case type independent widgets, which are all on the right side such as tasks, stakeholders, documents, notes and history. The page shows also case type-dependent information about the case on the left side. The case-type dependent information is again decoupled using a Container type: AQ_Dashboard_FlowWidget and is specialized in the module Zaak_Dashboard
.
Page WidgetTaakUitvoering
The page WidgetTaakUitvoering
(English: widget task execution) shows a dashboard to show a task to a user. On the right side case-type independent widgets are shown again. On the left side the task is shown using an Container type: AQ_Dashboard_FlowWidget.
Module Zaak_Domein
The module Zaak_Domein
(English: case domain) contains the domain of the case. This domain is different for every case type but always contains the entities Mijlpaal
(English: milestone), Preconditie
(English:precondition), PrimaireBeslissing
(English: primary decision), Termijnbewaking
(English: time constraints) and Zaak_Stuurgegevens
(English: case steering data). The logic to determine the values of the attributes is located in this module and not in the process module. The aim is to keep the process model clean and free from all the domain models of all the case types.
Entity Mijlpaal
This entity contains the milestones that are used in the process.
Entity Preconditie
This entity contains the preconditions that are used in the process.
Entity PrimaireBeslissing
This entity contains the primary decisions that have to be made.
Entity Termijnbewaking
This entity contains the waiting times that are used in the process.
Entity Zaak_Stuurgegevens
This entity contains attributes that steer the process. For example request for additional information.
Module Zaak_Intake
The module Zaak_Intake
(English: case intake) contains the intake and creation of a case (aggregates and process). The case is created in the following order:
- The metadata of the case is set.
- The process is created by throwing a message event to the process engine, The id of the created process is returned and will be saved later.
- The aggregate
Zaak_dossier
is created. This aggregate contains the domain of the case. The id of the created aggregate is returned and will be saved later.- When the creation of the aggregate
Zaak_dossier
fails the process is deleted.
- When the creation of the aggregate
- The aggregate
Zaak
is created. This aggregate contains references to aggregates, processes, documents, comments and users.- When the creation of the aggregate
Zaak
fails the aggregateZaak_dossier
and the process is deleted.
- When the creation of the aggregate
- The process is started.
- The created case is opened by sending a portal message to the portal containing a dashboard event and a case id.
Note
The steps of creating aggregates and processes are not transactional as a whole. Therefore if one of the steps fails, the previous steps should be rolled back manually.
Modules Zaak_Implementatie
, Basis_ExecuteTask
, DashboardMapping
and ProcessMapping
This module Zaak_Implementatie
(English: case implementation) contains implementation of the actions, tasks and widgets. The actions and widgets are started from the module Zaak_Dashboard
using an Container type: AQ_Dashboard_FlowWidget attributes (case id and processs id) are mapped between the modules using the mapping DashboardImplementieMapping
. The tasks are started using the Service call type: AQ_ExecuteTask in the module Basis_ExecuteTask
. This service starts the process engine and the process engine starts the implementation of the task using a task mapping (TaskMapping
) and a data mapping (DataMapping
). Action-, task- and widget flows are prefixed with Actie_
, Taak_
and Widget_
respectively.
Library Basis_Proces
This module Basis_Proces
(English: base process) contains the processes of the application and is shared between all the case types. More about the process in the Chapter Process.