This scoping document defines the narrative and technical requirements for dynamic task generation and entity persistence for the Reveal platform. The contents of this document relates to dynamic form configuration, but is not wholly dependent on that feature set. In essence dynamic task generation and entity persistence can take place independently of which form is opened when a task is assigned.
...
Plans will be updated to include action criteria that supports defining templated logic that should be evaluated when generating tasks in the server and client. This will be used at multiple steps across the system.
We will move bulk task generation from Nifi into the OpenSRP server, adding a business layer and queue that supports the evaluation of plans and generation of tasks. This process will walk the relationship tree for all affected entities that are affected in the jurisdiction, evaluating the logic defined in the plan action at each step.
(CRAIG CHECK THIS AGAIN AFTER YOU FINISH THIS DOC) We will not implement a state machine in the OpenSRP Server.
Configurable forms will be able to define the task’s business status as a hidden value in the bottom of the form labeled business_status.
This allows for configuration of the business logic, color coding, and task processing
We will implement a task state machine in the Android client that is able to execute logic on task state changes.
This allows us to respond to changes in task state independent of form submissions. A post save action on a form may or may not change the state of an assigned task. This allows us to chain actions in the event we need to execute multiple, independent, actions based on task state changes.
Plans will be evaluated in the Android client after a task state has changed to identify if follow-on actions should be taken. Each action will include evaluation criteria that determines the action.
The Android client will be able to display multiple tasks assigned to a structure in the map view. This will allow implementers to assign multiple action items and independent forms at the structure level.
(I’m not sure if we want to do this or solve it another way) We will provide access to view and edit locations, families and family members in the Android client even if a task is not assigned to that entity.
The location is the primary unit of navigation from the map view. A user can not access the information at a location if a task is not assigned. We will lift that constraint and allow users to view the underlying entity.
...
Forms (Upload Web UI)
System administrators will be able to add, edit, and update fields for forms that are available in the system. This includes changing the business status that impacts task generation
Plan Templates (No Web UI)
This is a new item that will allow system administrators to define plan templates for certain workflows. We currently hard code this into the OpenSRP Web UI for IRS and Focus Investigation. These templates allow a user to select from a drop down menu and control the actions that show up. Ultimately, the template creator has the capacity to create any action they wish.
Creating, updating, and archiving Plan Templates will not be accessible through the web UI.
Plans (Web UI)
Users are currently able to create plans in the Web UI. We will expand this to support adding criteria to action.
Task State Change Logic (No Web UI)
This will allow us to define logic that executes when the task state changes
(Placeholder: I’m not sure if we need to do this) Post form save logic (No Web UI)
We want to standardize the post form save logic so that it can be templated and eventually defined server side. This would allow us to define what happens after a form is saved.
(I’m not sure if we want to do this, or if MapBox provides this for us) Map View Styles (No Web UI)
System administrators will be able to define color coding for business status combinations available in the Android client and Web UI’s map views. This will allow system administrators to define color coding combinations on state
...
User creates a plan in the Web UI
They select from a drop down of plan templates, choosing (IRS Zambia 2020 plan template)
They complete the online form, confirm the default dates are correct and click Save
(optional) The user walks through the map based planning UI
The plan’s status is changed to “active” which triggers an action that generates all tasks for the plan in the OpenSRP Server
The user assigns a team to the plan if it wasn’t done in the map based planning UI
The spray operator logs into the Android client and the data syncs to their device
The user drops a point to add a location
The form is saved
The post form save action generates a task with status=”complete” and business_status defined by the form.
The task state change triggers an evaluation of the actions in the plan
The spray action evaluates to true because the location is marked as a residential structure.
The task state machine generates a “spray” task based on the spray task template that was configured with status “Ready”
The color coding is reflected as it was defined for this type of task in the Map View Styles configuration
The user taps the structure
If multiple tasks were assigned, they would be presented with a list of those tasks so they could choose which one to complete. The user should also be able to archive a task if it’s not relevant.
The form opens, they complete the form, and save it.
The post save action executes, updating the business status of the task
The task state change in status and business_status triggers an evaluation of the actions of the plan
All criteria evaluates to false for each action, so nothing is changed in the system
The user is returned to the map view. The color coding is reflected as it was defined for this type of task in the Map View Styles configuration.
...
User creates a plan in the Web UI
They select from a drop down of plan templates, choosing (Thailand Routine FI 2020 plan template)
They complete the online form, confirm the default dates are correct.
They make sure to check the plan as active
The plan’s status is changed to “active” which triggers an action that generates all tasks for the plan in the OpenSRP Server
The user assigns a team to the plan
The frontline worker logs into the Android client and the data syncs to their device
The user drops a point to add a location
The form is saved
The post form save action generates a task with status=”complete” and business_status defined by the form.
The task state change triggers an evaluation of the actions in the plan
The spray action evaluates to true because the location is marked as a residential structure.
The task state machine generates a “register family” task based on the register family task template that was configured with status “Ready”
The color coding is reflected as it was defined for this type of task in the Map View Styles configuration
The user taps the structure
If multiple tasks were assigned, they would be presented with a list of those tasks so they could choose which one to complete. The user should also be able to archive a task if it’s not relevant.
The form opens, they complete the form, and save it.
The post save action executes, updating the business status of the task.
The task state change in status and business_status triggers an evaluation of the actions of the plan
The criteria for the “Bednet Distribution” action evaluates to true so a bednet distribution task is created
The criteria for the “Blood Screening” action evaluates to true so a blood screening task is created for the head of household.
The criteria for all other actions evaluate to false.
The user is forwarded to the household view
The user registers the spouse of the head of household and saves the form.
The post save action executes, creating a task with status=”complete” and business_status based on the register family member form. (This allows us to count that work, even though it wasn’t initially assigned)
The task state change in status and business_status triggers an evaluation of the actions of the plan
The criteria for the “Blood Screening” action evaluates to true so a blood screening task is created for the recently added family member.
The criteria for all other actions evaluate to false.
The user returns to the household view.
The user completes the blood screening form for the head of household.
The post save action executes, updating the business status of the task.
The task state change in status and business_status triggers an evaluation of the actions of the plan
The criteria for all actions evaluate to false.
The user returns to the household view.
The user edits the blood screening form for the head of household.
The post save action executes, updating the business status of the task.
The task state change in business_status triggers an evaluation of the actions of the plan
The criteria for all actions evaluate to false.
The user returns to the household view.
The user navigates back to the map view and the color of that structure changes to the color defined in the configurable Map View Style
...
We don’t need a UI for creating planDefinitions, but we need a REST API to POST, PUT and GET these templates.
Software to be Developed
This section outlines the software packages that need to be developed in order to deliver these features. The target is to break out these items into tangible chunks of work that can be scheduled and delivered within two weeks.
(This section is still a work in progress)
1. Develop Plan Evaluator Java Library
We need to develop a Java library that can be run both in the Android client and OpenSRP server. This library will be responsible for evaluating plans and generating tasks. The inputs vary depending on the location where the library is deployed. This library is responsible for consistently executing the logic that generates tasks.
Inputs:
planIdentifier - This is the identifier of the plan that needs to be executed
trigger -
(optional) Entity - This is an entity to be evaluated against the plan. This allows us to evaluate a specific
Triggers:
Server - This library gets triggered the single time that a plan transitions from status:draft to status:active
Android Client - This library gets triggered through an asynchronous call
Logic: (See section above)
2. Update Event Processor to Evaluate Plans
We need to update the event processor to evaluate plans for a given trigger.
3. Update App logic to make sure it’s truly dynamic
...
Update of the task business status and status. This will be derived from the business_status hidden status
Evaluate tasks that should be generated after events are submitted
Create tasks that should be generated after events are submitted
Refresh the map or task list
4. Update
5. Add a the ability to define plan templates so the web UI can load these in
Don’t evaluate anything below this
Dynamic Task Generation
We need to update the flow in the Android client so that tasks are generated based on the actions in the plan. In order to do this, we need to develop the following feature:
Evaluate all plan actions during post form save action
Develop a way to identify the template for tasks based on the action. In other words, if you have a “register family” action, provide a way to identify how to fill out that task before it’s generated
We will likely need to accomplish this by generating templates in the server that are synchronized down to the Android client.
Loosen the constraints on the plan action so that we can configure the action criteria and codes that are available in the server. This will allow us to provide actions on different intervention units.
Identify how to handle multiple tasks assigned to a single structure for different task actions. In other words, what should we do if action 1 creates a task on the structure and action 2 creates a task on that structure. Reveal doesn’t currently handle this in the Android client.
Support entity persistence in the local task generation process.
Link the task information to the configurable form name and version that’s developed for the configurable form feature
Entity Persistence
We inherently create a conflict in the Android client across plans if a task has been generated server side and the Android client hasn’t synced. This is the case when we have multiple plans working in the same operational area and a new plan is created in that same operational area. Additionally, The current process requires a duplicate registration of that family in the second plan.
Below is a list of entities that must persist across plans:
Jurisdiction Location (We may need to edit jurisdiction locations at some time in the future in the Android client)
Non-Jurisdiction Location
Family
Family Member
Problems we need to solve
Entity Persistence
We inherently create a conflict in the Android client across plans if a task has been generated server side and the Android client hasn’t synced. This is the case when we have multiple plans working in the same operational area and a new plan is created in that same operational area. Additionally, The current process requires a duplicate registration of that family in the second plan.
Below is a list of entities that must persist across plans:
Jurisdiction Location (We may need to edit jurisdiction locations at some time in the future in the Android client)
Non-Jurisdiction Location
Family
Family Member
Illustrative Use Case
Plan A (Activation Date 2020-01-01 T00:00.000+00:00) for Jurisdiction X, which has 10 residential structures.
The user synced on January 1st at 10:00AM and got to work.
The user worked offline registering 10 families and 20 family members (2 at each residential structure)
The user found 5 additional residential structures, dropped points in the field and registered families against them, each with 2 family members.
(Current totals: 15 residential structures with 15 families and 30 family members)
The user is still offline and Plan B kicks off with Activation Date 2020-01-05 T00:00.000+00:00 for Jurisdiction X
The server runs through the plan and created 10 register family tasks because the state still shows 10 residential structures.
The user gets online and syncs on 2020-01-10 T10:00.000+00:00
The following events sync up: 5 Register_Structure events, 15 Family Registration and 15 Family Member Registration
5 new locations, 15 families and 30 family members sync up to the server (families and family members as clients)
Plan B syncs down with 10 register family tasks.
The user, looking at Plan B does not have access to the underlying families that were created in Plan A. Also, no tasks are assigned to the 5 new locations that they dropped in Plan A
Problems we need to solve
There is a disparity between the local state and the server state of locations, families and family members when a plan is generated. Plans are generated at a point in time and we don't evaluate them against entities that may already exist in the Android client at any time in the future. We need to provide a way to update tasks based on
Proposed Solutions
We need to develop a pattern that generically identifies existing tasks that should be canceled based on differences in state from the time a plan was turned to active and the time an entity reached the server. Ultimately, we would like the OpenSRP server to evaluate the events or clients that were recently received against Plan B, cancel the 10 register family tasks and evaluate the plan against all 15 locations, 15 families and 30 family members.
In order to do this, we will add the ability to create plan actions that support updating tasks. We will accomplish this by creating a plan.action.type: “Update” and implementing a plan.action.type: “create” for the existing plans that are generated for the dynamic tasking feature. These new plan types are going to be responsible for updating tasks based on the events that are passed in. Ultimately, these new action types will allow us to update tasks in the current plan.
Below is a sample of the Register Family Action from Plan A
Notice that we added a high level “type” to the action with value “create” This signifies that we will create a task when we evaluate the plan.
| Code Block | ||
|---|---|---|
| ||
{
"identifier": "3802af3a-f40c-4705-849e-1727b603bd4e",
"prefix": 1,
"title": "Family Registration",
"description": "Register all families and family members in all residential structures enumerated (100%) within the operational area",
"code": "RACD Register Family",
"type": "create",
"trigger": [
{
"type": "named-event",
"name": "plan-activation"
},
{
"type": "named-event",
"name": "event-submission",
"expression": {
"expression": "questionnaire = 'Register_Structure'"
}
}
],
"condition": [
{
"kind": "applicability",
"expression": {
"description": "Structure is residential",
"reference": "plan-activation",
"expression": "Location.type.where(id='locationType').text = 'Residential Structure'"
}
},
{
"kind": "applicability",
"expression": {
"description": "Family does not exist for structure",
"reference": "plan-activation",
"expression": "$this.contained.exists()",
"subjectCodableConcept": {
"text": "Family"
}
}
},
{
"kind": "applicability",
"expression": {
"reference": "event-submission",
"expression": "questionnaire = 'Register_Structure' AND item.where(linkId='structureType').answer.value ='Residential Structure'"
}
}
],
"timingPeriod": {
"start": "2020-06-04",
"end": "2020-10-01"
},
"reason": "Routine",
"goalId": "RACD_register_all_families",
"subjectCodableConcept": {
"text": "Location"
},
"definitionUri": "family_register.json"
}, |
Below is a sample action that updates register family tasks
Note that the expressions in this sample are just to illustrate and we have not clearly defined a patter at this moment.
| Code Block | ||
|---|---|---|
| ||
{
"identifier": "NEW_IDENTIFIER",
"prefix": 10,
"title": "Cancel Duplicate Register Family Tasks",
"description": "Cancel tasks that are generated against locations that already have families against them",
"code": "RACD Register Family",
"type": "update",
"trigger": [
{
"type": "named-event",
"name": "event-submission",
"expression": {
"expression": "questionnaire = 'Register_Structure'"
}
}
],
"condition": [
{
"kind": "applicability",
"expression": {
"reference": "event-submission",
"expression": "task.code = 'RACD Register Family' and task.for = QuestionnaireResponse.location_id",
"subjectCodableConcept": {
"text": "global.task"
}
}
}
],
"timingPeriod": {
"start": "2020-06-04",
"end": "2020-10-01"
},
"reason": "Routine",
"goalId": "RACD_register_all_families",
"subjectCodableConcept": {
"text": "Location"
},
"definitionUri": "family_register.json",
"dynamicValue": [
{
"expression": {
"expression": "INSERT_SOME_EXPRESSION_HERE"
}
}
]
}, |
Business Logic
We expect to execute business logic generically as follows.
The Family registration Event will evaluate false to all triggers except for the “Cancel Duplicate Register Family Tasks” action. At this moment, we only have the event itself. We don’t have any client information.
The system will evaluate the condition and identify that we need to query the database for all tasks that have the following fields:
task.groupIdentifier = QuestionnaireResponse. jurisdiction (Whatever field this is mapped to in the Questionnaire)
task.code = plan.action.code (For this action)
task.for = QuestionnaireResponse.item.where(linkId=”locationId”).answer.text (This is the id of the location)
task.status = “Ready” (We only want to query ready tasks because they can be adjusted. Completed and Cancelled tasks can not be changed in this way)
The system returns the results and each task is evaluated against the criteria.
If evaluated to true, the system changes the status of the task to Cancelled regardless of the plan that it was assigned to.
Next, the event submission is evaluated against the task.planIdentifier if the status is “active” and the effectivePeriod is still valid. This allows us to ensure that any downstream “create” plan.action.type actions are honored with this new entity.
Illustrative Example:
Unsynced events from Plan A hit the OpenSRP server.
Each event is evaluated against Plan A’s triggers.
(We need to decide if we need to augment the trigger in some way to ensure we don’t duplicate tasks by evaluating all actions and re-firing the “create” action.type in this step)
The Family Registration Event for Plan A, Location 123 in Jurisdiction X is evaluated against the entire Plan A
The “Cancel Duplicate Register Family Tasks” action trigger evaluates to true.
The system queries all tasks with the following criteria:
task.groupIdentifier = “Jurisdiction X”
task.code = “RACD Register Family”
task.for = “Location 123”
task.status = “Ready”
The system returns one task with this criteria where task.planIdentifier: “Plan B”
The condition is evaluated against this task and it evaluates to true.
The system reads the dynamicValue.expression.expression and identifies that we need to change task.status to “Cancelled” and task.businessStatus to “Cancelled-Duplicate” (or something like that)
The system saves the task change and queries the database for plans where plan.id = task.planIdentifier (“Plan B”), status = “Active” and the event dateTime falls within the plan.effectivePeriod
The system returns one plan
The event submission is evaluated against all “create” actions
The task creates a Blood screening task for the head of household and a bednet distribution task
Software to be Developed
This section outlines the software packages that need to be developed in order to deliver these features. The target is to break out these items into tangible chunks of work that can be scheduled and delivered within two weeks.
(This section is still a work in progress)
1. Develop Plan Evaluator Java Library
We need to develop a Java library that can be run both in the Android client and OpenSRP server. This library will be responsible for evaluating plans and generating tasks. The inputs vary depending on the location where the library is deployed. This library is responsible for consistently executing the logic that generates tasks.
Inputs:
planIdentifier - This is the identifier of the plan that needs to be executed
trigger -
(optional) Entity - This is an entity to be evaluated against the plan. This allows us to evaluate a specific
Triggers:
Server - This library gets triggered the single time that a plan transitions from status:draft to status:active
Android Client - This library gets triggered through an asynchronous call
Logic: (See section above)
2. Update Event Processor to Evaluate Plans
We need to update the event processor to evaluate plans for a given trigger.
3. Update App logic to make sure it’s truly dynamic
Sam G There are post save actions that executed on the device
Update of the task business status and status. This will be derived from the business_status hidden status
Evaluate tasks that should be generated after events are submitted
Create tasks that should be generated after events are submitted
Refresh the map or task list
4. Update
5. Add a the ability to define plan templates so the web UI can load these in
...
Don’t evaluate anything below this
...
Dynamic Task Generation Discussion Notes
We need to update the flow in the Android client so that tasks are generated based on the actions in the plan. In order to do this, we need to develop the following feature:
Evaluate all plan actions during post form save action
Develop a way to identify the template for tasks based on the action. In other words, if you have a “register family” action, provide a way to identify how to fill out that task before it’s generated
We will likely need to accomplish this by generating templates in the server that are synchronized down to the Android client.
Loosen the constraints on the plan action so that we can configure the action criteria and codes that are available in the server. This will allow us to provide actions on different intervention units.
Identify how to handle multiple tasks assigned to a single structure for different task actions. In other words, what should we do if action 1 creates a task on the structure and action 2 creates a task on that structure. Reveal doesn’t currently handle this in the Android client.
Support entity persistence in the local task generation process.
Link the task information to the configurable form name and version that’s developed for the configurable form feature
Entity Persistence Discussion Notes
This section includes notes on the Entity Persistence discussion
A “register family” task has been created against a location in the server, but the Android client already has a family registered against that location when the new plan is activated
User is operating on FI Plan1 offline
User has a task for Plan1 to register family for Structure A
User registers this family
Plan2 is created on the server
StructureA has a new task generated against Plan2
User goes online
Conflict:
The structure has two tasks associated with the same entity (family) against different plans
the task for the new plan should not have been generated (if the device had been online and the family registration had synced before the new plan was created)
Solution Options:
We could add logic server side when new clients are synced, we could analyze any tasks that exist against the family registration when the client hits the OpenSRP server and changes “status”: “Cancelled” for the task that was created.
We have an issue with follow-on task generation. So if you registered a family, you need to run through the plan again and generate the appropriate tasks.
Business Logic: Evaluate against a single entity server side.
We sync an event
For this specific event type, we evaluate it against all known plans that were active when the event was created
Identify if there are any tasks linked to it with a status “Ready” for any plan that is active (this includes doing a structure look-up)
We cancel the associated task based on the task.code and then immediately trigger plan evaluation for plans that are affected
Note:
It’s possible that users have done double family registrations.
It would be valuable to configure this in the plan, including adding a look-up for other tasks that exist
Events are synced by jurisdiction, so that means other devices have a copy of all events against that jurisdiction over time
We need to do this for the following eventTypes
Family Registration
Family Member Registration
Register_Structure
Feature:
Evaluate the family member event in the OpenSRP server
Evaluate the action against
The task that was first marked as Done first wins, the other task is archived?
Archive needs to cascade down to all devices
A point is added locally and it hasn’t been synced
Is this an issue?
Point in added locally
Task is created locally
Family is registered
Device syncs location, task and event to server
location is synced down to other devices
Problem: A new plan is generated and this point isn’t evaluated
We don’t provide access to perform life cycle events on locations (update, archive)
We don’t provide access to underlying families if we don’t have a register family task
Note
We need to consider the color coding for families that are registered but don’t have a task
We don’t have a clear process for handling duplicate registrations and tasks that are generated on multiple offline devices
The current strategy is latest wins. That should be fine, but we need a clear audit path to show what happened. If possible, see if we can reverse it.
Users change an entity in one plan and expects that to persist across other plans in the operational area when offline. For example, if a user has two plans in the same operational area and they register a family at structure A, they expect that family to show up in structure A in both plans.
if this is happening locally when offline, this should be catered for by removing the restriction on accessing entities without tasks. The location is associated to the jurisdiction, the entity (family) is associated to the location.
A user removes a family member in one plan and expects it to persist across plans
Ditto above
There’s a case
Business Logic
A “register family” task has been created against a location in the server, but the Android client already has a family registered against that location when the new plan is activated
Is it possible to generate the same task client and server side?
We don’t provide generic access to the underlying family or family member registered at a location regardless of task assignment for that particular plan.
We need to be able to
...
Issue: We don’t evaluate the difference in state between the OpenSRP server and the Android client upon sync. There’s an underlying Issue where we evaluate plans only once when they are made active based on the state in the server at that time. (PD: does ‘evaluate’ equate to ‘generate tasks for’?)
PD: What currently happens if there is a task of the same type for the same location, one generated server side and one generated on the client? Is this even possible? - should tasks be marked as 'generated server side or generated android? seems useful))
Option 1:
Evaluate the entity state of certain task types before they are opened. For example, if you have a register family task type, you could evaluate it and see that there’s already a relationship available for that structure. If so, run through the plan locally and generate the appropriate tasks.
Option 2:
Evaluate all tasks of a certain type when they are received by the Android client and update the state as part of the sync process
We don’t address state of entities across plans. In other words, the completion of certain types of events could trigger changes in other plans.
We aren’t sure if it should. I need help with this
e.g there a dynamic ‘ante-natal visit’ task created for pregnant women when a family member who is pregnant is registered….
If we stick to the set of entities that are persistent (locations, families, family members) then this is is not an issue - events are plan specific.
Ideally, an entity (specifically clients in this case UPDATE: I had originally thought that ‘Clients’ referred to families and family members only, but this seems to be incorrect as for IRS implementations the ‘sprayed_structure’ is a client, I don’t think spray information should be persisted) can be recreated by replaying all of the events that have that entity as the baseEntity (this is not currently the case as some client information does not get captured as part of the event)
Structures and Jurisdictions are also not generated through a task, ever. Register structure tasks are ‘after the fact’ events that are generated when a user drops a pin (Craig Appl is this true?)
It feel like there should be some events which are able to modify baseEntitiy attributes, and some that aren’t … does this fit into the DHIS2 paradigm of tracked entities with attribute values, who have events with data elements ? in that case, events CANNOT modify tracked entity attributes - it is a different process to set the attributes
Issue: We don’t provide generic access to the underlying family or family member registered at a location regardless of task assignment for that particular plan
Logic:
Any user should be able to tap on any location to open a view of the family regardless of task assignment.
We need to determine the impact of this across plans and in the reporting system
We don’t have a clear process for handling duplicate registrations and tasks that are generated on multiple offline devices
Logic:
We don’t allow users to archive locations or change the state of a location
Logic:
Any user should be able to tap a location regardless of task status, view and edit information about the location.
We need to determine the impact of this across plans and in the reporting system
...