fix: [DHIS2-17854] validate the assigned values from rules engine

src/core_modules/capture-core/components/D2Form/FormBuilder/FormBuilder.component.js

@@ -11,24 +11,18 @@ import isObject from 'd2-utilizr/lib/isObject';
 import defaultClasses from './formBuilder.module.css';
 import type { ErrorData, PostProcessErrorMessage } from './formbuilder.types';
 import type { PluginContext } from '../FormFieldPlugin/FormFieldPlugin.types';
-import { getValidators } from '../field/validators';
+import { getValidators, validateField } from '../field/validators';
+import type { ValidatorContainer } from '../field/validators';
 import type { DataElement } from '../../../metaData';
 import type { QuerySingleResource } from '../../../utils/api';
 
-export type ValidatorContainer = {
-    validator: (value: any, validationContext: ?Object) => boolean | Promise<boolean>,
-    message: string,
-    validatingMessage?: ?string,
-    type?: ?string,
-    async?: ?boolean,
-};
 
 export type FieldConfig = {
     id: string,
     component: React.ComponentType<any>,
     plugin?: boolean,
     props: Object,
-    validators?: ?Array<ValidatorContainer>,
+    validators?: Array<ValidatorContainer>,
     commitEvent?: ?string,
     onIsEqual?: ?(newValue: any, oldValue: any) => boolean,
 };
@@ -47,7 +41,7 @@ type GetContainerPropsFn = (index: number, fieldsCount: number, field: FieldConf
 
 type FieldCommitConfig = {|
     fieldId: string,
-    validators?: ?Array<ValidatorContainer>,
+    validators?: Array<ValidatorContainer>,
     onIsEqual?: ?(newValue: any, oldValue: any) => boolean,
 |}
 
@@ -99,54 +93,6 @@ type FieldCommitOptions = {
 type FieldsValidatingPromiseContainer = { [fieldId: string]: ?{ cancelableValidatingPromise?: ?CancelablePromise<any>, validatingCompleteUid: string } };
 
 export class FormBuilder extends React.Component<Props> {
-    static async validateField(
-        { validators }: { validators?: ?Array<ValidatorContainer> },
-        value: any,
-        validationContext: ?Object,
-        onIsValidatingInternal: ?Function,
-    ): Promise<{ valid: boolean, errorMessage?: ?string, errorType?: ?string }> {
-        if (!validators || validators.length === 0) {
-            return {
-                valid: true,
-            };
-        }
-
-        const validatorResult = await validators
-            .reduce(async (passPromise, currentValidator) => {
-                const pass = await passPromise;
-                if (pass === true) {
-                    let result = currentValidator.validator(value, validationContext);
-                    if (result instanceof Promise) {
-                        result = onIsValidatingInternal ? onIsValidatingInternal(currentValidator.validatingMessage, result) : result;
-                        result = await result;
-                    }
-
-                    if (result === true || (result && result.valid)) {
-                        return true;
-                    }
-                    return {
-                        message: (result && result.errorMessage) || currentValidator.message,
-                        type: currentValidator.type,
-                        data: result && result.data,
-                    };
-                }
-                return pass;
-            }, Promise.resolve(true));
-
-        if (validatorResult !== true) {
-            return {
-                valid: false,
-                errorMessage: validatorResult.message,
-                errorType: validatorResult.type,
-                errorData: validatorResult.data,
-            };
-        }
-
-        return {
-            valid: true,
-        };
-    }
-
     static getAsyncUIState(fieldsUI: { [id: string]: FieldUI }) {
         return Object.keys(fieldsUI).reduce((accAsyncUIState, fieldId) => {
             const fieldUI = fieldsUI[fieldId];
@@ -219,7 +165,7 @@ export class FormBuilder extends React.Component<Props> {
 
                 let validationData;
                 try {
-                    validationData = await FormBuilder.validateField(
+                    validationData = await validateField(
                         field,
                         values[field.id],
                         validationContext,
@@ -429,7 +375,7 @@ export class FormBuilder extends React.Component<Props> {
         };
 
         this.commitUpdateTriggeredForFields[fieldId] = true;
-        const updatePromise = FormBuilder.validateField(
+        const updatePromise = validateField(
             { validators },
             value,
             onGetValidationContext && onGetValidationContext(),

src/core_modules/capture-core/components/D2Form/FormBuilder/index.js

@@ -1,4 +1,4 @@
 // @flow
 export { FormBuilder } from './FormBuilder.component';
 export type { PostProcessErrorMessage, ErrorData } from './formbuilder.types';
-export type { FieldConfig, ValidatorContainer } from './FormBuilder.component';
+export type { FieldConfig } from './FormBuilder.component';

src/core_modules/capture-core/components/D2Form/field/configs/base/configBase.js

@@ -1,6 +1,6 @@
 // @flow
 import { type ComponentType } from 'react';
-import type { ValidatorContainer } from '../../../FormBuilder';
+import type { ValidatorContainer } from '../../../field/validators';
 import { getValidators } from '../../validators';
 import type { DataElement } from '../../../../../metaData';
 import type { QuerySingleResource } from '../../../../../utils/api/api.types';

src/core_modules/capture-core/components/D2Form/field/validators/getValidators.js

@@ -30,7 +30,10 @@ import { dataElementTypes, type DateDataElement, type DataElement } from '../../
 import { validatorTypes } from './constants';
 import type { QuerySingleResource } from '../../../../utils/api/api.types';
 
-type Validator = (value: any) => Promise<boolean> | boolean | { valid: boolean, errorMessage?: any};
+type Validator = (
+    value: any,
+    contextProps: ?Object,
+) => Promise<boolean> | boolean | { valid: boolean, errorMessage?: any, data?: any };
 
 export type ValidatorContainer = {
     validator: Validator,
@@ -205,7 +208,7 @@ const validatorsForTypes = {
     }],
 };
 
-function buildTypeValidators(metaData: DataElement | DateDataElement): ?Array<ValidatorContainer> {
+function buildTypeValidators(metaData: DataElement | DateDataElement): Array<ValidatorContainer> {
     // $FlowFixMe dataElementTypes flow error
     let validatorContainersForType = validatorsForTypes[metaData.type] ? validatorsForTypes[metaData.type] : [];
 
@@ -226,7 +229,7 @@ function buildTypeValidators(metaData: DataElement | DateDataElement): ?Array<Va
     return validatorContainersForType;
 }
 
-function buildCompulsoryValidator(metaData: DataElement): Array<?ValidatorContainer> {
+function buildCompulsoryValidator(metaData: DataElement): Array<ValidatorContainer> {
     return metaData.compulsory
         ?
         [
@@ -243,7 +246,7 @@ function buildCompulsoryValidator(metaData: DataElement): Array<?ValidatorContai
 function buildUniqueValidator(
     metaData: DataElement,
     querySingleResource: QuerySingleResource,
-): Array<?ValidatorContainer> {
+): Array<ValidatorContainer> {
     return metaData.unique
         ?
         [
@@ -265,7 +268,7 @@ function buildUniqueValidator(
 }
 
 export const getValidators =
-(metaData: DataElement, querySingleResource: QuerySingleResource): Array<?ValidatorContainer> => [
+(metaData: DataElement, querySingleResource: QuerySingleResource): Array<ValidatorContainer> => [
     buildCompulsoryValidator,
     buildTypeValidators,
     buildUniqueValidator,

src/core_modules/capture-core/components/D2Form/field/validators/index.js

@@ -1,2 +1,7 @@
 // @flow
 export { getValidators } from './getValidators';
+export { validateField } from './validateField';
+export { validateAssignEffects } from './validateAssignEffects';
+
+export type { ValidatorContainer } from './getValidators';
+export type { AssignOutputEffectWithValidations } from './validateAssignEffects';

src/core_modules/capture-core/components/D2Form/field/validators/validateAssignEffects.js

@@ -0,0 +1,63 @@
+// @flow
+import { errorCreator } from 'capture-core-utils';
+import { effectActions } from '@dhis2/rules-engine-javascript';
+import log from 'loglevel';
+import type { AssignOutputEffect } from '@dhis2/rules-engine-javascript';
+import { type DataElement } from '../../../../metaData';
+import type { QuerySingleResource } from '../../../../utils/api';
+import { getValidators } from './getValidators';
+import type { Validations } from './validateField';
+import { validateField } from './validateField';
+
+export type AssignOutputEffectWithValidations = {
+    [metaDataId: string]: Array<AssignOutputEffect & Validations>,
+};
+
+export const validateAssignEffects = async ({
+    dataElements,
+    effects,
+    querySingleResource,
+    onGetValidationContext,
+}: {
+    dataElements: Array<DataElement>,
+    effects: Object,
+    querySingleResource: QuerySingleResource,
+    onGetValidationContext?: () => Object,
+}): Promise<?AssignOutputEffectWithValidations> => {
+    const assignEffects: {| [metaDataId: string]: Array<AssignOutputEffect> |} = effects[effectActions.ASSIGN_VALUE];
+    if (!assignEffects) {
+        return effects;
+    }
+
+    const assignEffectsWithValidations = await dataElements.reduce(async (passPromise, metaData: DataElement) => {
+        const acc = await passPromise;
+        if (!assignEffects[metaData.id]) {
+            return acc;
+        }
+
+        const effectsForId = assignEffects[metaData.id];
+        const lastEffect = effectsForId.length - 1;
+        const value = effectsForId[lastEffect].value;
+        const validators = getValidators(metaData, querySingleResource);
+        const validationContext = onGetValidationContext && onGetValidationContext();
+
+        try {
+            const validatorResult = await validateField({ validators }, value, validationContext);
+            const effectWithValidation = Object.assign({}, effectsForId[lastEffect], validatorResult);
+
+            acc[metaData.id] = [...effectsForId.slice(0, lastEffect - 1), effectWithValidation];
+            return acc;
+        } catch (error) {
+            log.error(
+                errorCreator('an error occured while validating the assigned program rule effect')({
+                    metaData,
+                    lastEffect,
+                    error,
+                }),
+            );
+            return acc;
+        }
+    }, Promise.resolve({}));
+
+    return { ...effects, [effectActions.ASSIGN_VALUE]: assignEffectsWithValidations };
+};

src/core_modules/capture-core/components/D2Form/field/validators/validateField.js

@@ -0,0 +1,58 @@
+// @flow
+import type { ValidatorContainer } from './getValidators';
+
+export type Validations = {
+    valid: boolean,
+    errorMessage?: ?string,
+    errorType?: ?string,
+    errorData?: Object,
+};
+
+export const validateField = async (
+    { validators }: { validators?: Array<ValidatorContainer> },
+    value: any,
+    validationContext: ?Object,
+    onIsValidatingInternal: ?Function,
+): Promise<Validations> => {
+    if (!validators || validators.length === 0) {
+        return {
+            valid: true,
+        };
+    }
+
+    const validatorResult = await validators.reduce(async (passPromise, currentValidator) => {
+        const pass = await passPromise;
+        if (pass === true) {
+            let result = currentValidator.validator(value, validationContext);
+            if (result instanceof Promise) {
+                result = onIsValidatingInternal
+                    ? onIsValidatingInternal(currentValidator.validatingMessage, result)
+                    : result;
+                result = await result;
+            }
+
+            if (result === true || (result && result.valid)) {
+                return true;
+            }
+            return {
+                message: (result && result.errorMessage) || currentValidator.message,
+                type: currentValidator.type,
+                data: result && result.data,
+            };
+        }
+        return pass;
+    }, Promise.resolve(true));
+
+    if (validatorResult !== true) {
+        return {
+            valid: false,
+            errorMessage: validatorResult.message,
+            errorType: validatorResult.type,
+            errorData: validatorResult.data,
+        };
+    }
+
+    return {
+        valid: true,
+    };
+};

src/core_modules/capture-core/components/D2Form/index.js

@@ -1,3 +1,5 @@
 // @flow
 export { asyncHandlerActionTypes, asyncUpdateFieldEpic } from './asyncHandlerHOC';
 export { D2Form } from './D2Form.container';
+export { validateAssignEffects } from './field/validators';
+export type { AssignOutputEffectWithValidations } from './field/validators';

src/core_modules/capture-core/components/DataEntries/Enrollment/EnrollmentDataEntry.component.js

@@ -419,17 +419,38 @@ export class EnrollmentDataEntryComponent extends React.Component<PreEnrollmentD
 
     handleUpdateField = (...args: Array<any>) => {
         const { programId, orgUnit, firstStageMetaData, formFoundation } = this.props;
-        this.props.onUpdateField(...args, programId, orgUnit, firstStageMetaData?.stage, formFoundation);
-    }
+        this.props.onUpdateField(
+            ...args,
+            programId,
+            orgUnit,
+            firstStageMetaData?.stage,
+            formFoundation,
+            this.getValidationContext,
+        );
+    };
 
     handleUpdateDataEntryField = (...args: Array<any>) => {
         const { programId, orgUnit, firstStageMetaData, formFoundation } = this.props;
-        this.props.onUpdateDataEntryField(...args, programId, orgUnit, firstStageMetaData?.stage, formFoundation);
+        this.props.onUpdateDataEntryField(
+            ...args,
+            programId,
+            orgUnit,
+            firstStageMetaData?.stage,
+            formFoundation,
+            this.getValidationContext,
+        );
     }
 
     handleStartAsyncUpdateField = (...args: Array<any>) => {
         const { programId, orgUnit, firstStageMetaData, formFoundation } = this.props;
-        this.props.onStartAsyncUpdateField(...args, programId, orgUnit, firstStageMetaData?.stage, formFoundation);
+        this.props.onStartAsyncUpdateField(
+            ...args,
+            programId,
+            orgUnit,
+            firstStageMetaData?.stage,
+            formFoundation,
+            this.getValidationContext,
+        );
     }
 
     render() {

src/core_modules/capture-core/components/DataEntries/Enrollment/EnrollmentDataEntry.container.js

@@ -14,17 +14,21 @@ const mapDispatchToProps = (dispatch: ReduxDispatch) => ({
         orgUnit: OrgUnit,
         stage?: ProgramStage,
         formFoundation: RenderFoundation,
+        onGetValidationContext: () => Object,
     ) => {
-        dispatch(updateDataEntryFieldBatch(innerAction, programId, orgUnit, stage, formFoundation));
+        dispatch(
+            updateDataEntryFieldBatch(innerAction, programId, orgUnit, stage, formFoundation, onGetValidationContext),
+        );
     },
     onUpdateField: (
         innerAction: ReduxAction<any, any>,
         programId: string,
         orgUnit: OrgUnit,
         stage?: ProgramStage,
         formFoundation: RenderFoundation,
+        onGetValidationContext: () => Object,
     ) => {
-        dispatch(updateFieldBatch(innerAction, programId, orgUnit, stage, formFoundation));
+        dispatch(updateFieldBatch(innerAction, programId, orgUnit, stage, formFoundation, onGetValidationContext));
     },
     onStartAsyncUpdateField: (
         innerAction: ReduxAction<any, any>,
@@ -34,9 +38,10 @@ const mapDispatchToProps = (dispatch: ReduxDispatch) => ({
         orgUnit: OrgUnit,
         stage?: ProgramStage,
         formFoundation: RenderFoundation,
+        onGetValidationContext: () => Object,
     ) => {
         const onAsyncUpdateSuccess = (successInnerAction: ReduxAction<any, any>) =>
-            asyncUpdateSuccessBatch(successInnerAction, dataEntryId, itemId, programId, orgUnit, stage, formFoundation);
+            asyncUpdateSuccessBatch(successInnerAction, dataEntryId, itemId, programId, orgUnit, stage, formFoundation, onGetValidationContext);
         const onAsyncUpdateError = (errorInnerAction: ReduxAction<any, any>) => errorInnerAction;
 
         dispatch(startAsyncUpdateFieldForNewEnrollment(innerAction, onAsyncUpdateSuccess, onAsyncUpdateError));