#827 | Evaluate Enrolment Eligibility Check rule.

Author: mahalakshme

src/RuleExecutor.js

@@ -2,14 +2,15 @@ import {mapProgramEncounter} from './models/programEncounterModel';
 import {createEncounterType, mapEncounter} from './models/encounterModel';
 import {mapIndividual} from './models/individualModel';
 import {mapProgramEnrolment} from './models/programEnrolmentModel';
+import {createProgram} from "./models/programModel";
 import {
     checkListRule,
     decisionRule,
     isEligibleForEncounter,
     programSummaryRule,
     subjectSummaryRule,
     visitScheduleRule,
-    messagingRule
+    messagingRule, isEligibleForProgramEnrolment
 } from './services/RuleEvalService';
 import {map} from 'lodash';
 
@@ -35,6 +36,16 @@ const summaryRule = {
     "SubjectSummary": subjectSummaryRule,
 };
 
+const createTypeMapper = {
+    "EncounterType": createEncounterType,
+    "Program": createProgram
+}
+
+const eligibilityCheckMapper = {
+    "EncounterType": isEligibleForEncounter,
+    "Program": isEligibleForProgramEnrolment
+}
+
 export const executeRule = async (requestBody) => {
     const mapEntity = mappers[requestBody.rule.workFlowType];
     if (!mapEntity)
@@ -58,10 +69,10 @@ export const executeSummaryRule = async (requestBody) => {
     }
 };
 
-export const executeEncounterEligibilityRule = async (requestBody) => {
-    const {individual, encounterTypes} = requestBody;
+export const executeEligibilityCheckRule = async (requestBody) => {
+    const {individual, entityTypes, ruleEntityType} = requestBody;
     const individualModel = mapIndividual(individual);
-    const eligibilityRuleEntities = await Promise.all(map(encounterTypes, et => isEligibleForEncounter(individualModel, createEncounterType(et))));
+    const eligibilityRuleEntities = await Promise.all(map(entityTypes, et => eligibilityCheckMapper[ruleEntityType](individualModel, createTypeMapper[ruleEntityType](et))));
     return {eligibilityRuleEntities};
 };
 

src/controllers/rulesController.js

@@ -1,5 +1,5 @@
 import {
-    executeEncounterEligibilityRule,
+    executeEligibilityCheckRule,
     executeRule,
     executeSummaryRule,
     executeMessagingRule,
@@ -72,4 +72,4 @@ export const buildObservationAndRunRules = async (req, res, next) => {
 export const rulesController = delegateTo(executeRule);
 export const summary = delegateTo(executeSummaryRule);
 export const messagingResponse = delegateTo(executeMessagingRule);
-export const encounterEligibility = delegateTo(executeEncounterEligibilityRule);
+export const encounterEligibility = delegateTo(executeEligibilityCheckRule);

src/models/encounterModel.js

@@ -66,7 +66,7 @@ export const createEncounterType = (encounterTypeParam) => {
     encounterType.operationalEncounterTypeName = encounterTypeParam.operationalEncounterTypeName;
     encounterType.displayName = encounterTypeParam.displayName;
     encounterType.voided = encounterTypeParam.voided;
-    encounterType.encounterEligibilityCheckRule = encounterTypeParam.encounterEligibilityCheckRule;
+    encounterType.entityEligibilityCheckRule = encounterTypeParam.entityEligibilityCheckRule;
     encounterType.active = encounterTypeParam.active;
     return encounterType;
 };

src/models/programModel.js

@@ -0,0 +1,11 @@
+import {Program} from "openchs-models";
+
+export const createProgram = (programParam) => {
+    const program = new Program();
+    program.uuid = programParam.uuid;
+    program.name = programParam.name;
+    program.voided = programParam.voided;
+    program.entityEligibilityCheckRule = programParam.entityEligibilityCheckRule;
+    program.active = programParam.active;
+    return program;
+};

src/services/RuleEvalService.js

@@ -129,8 +129,8 @@ export const subjectSummaryRule = async (rule, entity) => {
 export const isEligibleForEncounter = async (individual, encounterType) => {
     let eligible = true;
     const rulesFromTheBundle = await getAllRuleItemsFor(encounterType.uuid, "EncounterEligibilityCheck", "EncounterType");
-    if (!_.isNil(encounterType.encounterEligibilityCheckRule) && !_.isEmpty(_.trim(encounterType.encounterEligibilityCheckRule))) {
-        const code = removeStrictFromRuleCode(encounterType.encounterEligibilityCheckRule);
+    if (!_.isNil(encounterType.entityEligibilityCheckRule) && !_.isEmpty(_.trim(encounterType.entityEligibilityCheckRule))) {
+        const code = removeStrictFromRuleCode(encounterType.entityEligibilityCheckRule);
         const ruleFunc = eval(code);
         eligible = ruleFunc({
             params: {entity: individual, services},
@@ -145,6 +145,25 @@ export const isEligibleForEncounter = async (individual, encounterType) => {
     };
 };
 
+export const isEligibleForProgramEnrolment = async (individual, program) => {
+    let eligible = true;
+    const rulesFromTheBundle = await getAllRuleItemsFor(program.uuid, "EnrolmentEligibilityCheck", "Program");
+    if (!_.isNil(program.entityEligibilityCheckRule) && !_.isEmpty(_.trim(program.entityEligibilityCheckRule))) {
+        const code = removeStrictFromRuleCode(program.entityEligibilityCheckRule);
+        const ruleFunc = eval(code);
+        eligible = ruleFunc({
+            params: {entity: individual, services},
+            imports: {rulesConfig, lodash, moment}
+        });
+    } else if (!_.isEmpty(rulesFromTheBundle)) {
+        eligible = runRuleAndSaveFailure(_.last(rulesFromTheBundle), 'Program', {individual}, true);
+    }
+    return {
+        "isEligible": eligible,
+        "typeUUID": program.uuid,
+    };
+};
+
 export const messagingRule = async (rule, entity) => {
     const code = removeStrictFromRuleCode(rule);
     const ruleFunc = eval(code);