@hmcts/ccd-case-ui-toolkit 7.0.39-task-event-completion-fix → 7.0.40-rc1

package/esm2022/lib/shared/services/fields/fields.utils.mjs

@@ -0,0 +1,615 @@
+import { CurrencyPipe } from '@angular/common';
+import { Injectable } from '@angular/core';
+import { FormArray, FormControl, FormGroup } from '@angular/forms';
+import { plainToClassFromExist } from 'class-transformer';
+import { CaseFlagDisplayContextParameter, CaseFlagStatus } from '../../components/palette/case-flag/enums';
+import { DatePipe } from '../../components/palette/utils';
+import { CaseField } from '../../domain';
+import { FormatTranslatorService } from '../case-fields/format-translator.service';
+import * as i0 from "@angular/core";
+// @dynamic
+export class FieldsUtils {
+    static caseLevelCaseFlagsFieldId = 'caseFlags';
+    static currencyPipe = new CurrencyPipe('en-GB');
+    static datePipe = new DatePipe(new FormatTranslatorService());
+    // EUI-4244. 3 dashes instead of 1 to make this less likely to clash with a real field.
+    static LABEL_SUFFIX = '---LABEL';
+    // Handling of Dynamic Lists in Complex Types
+    static SERVER_RESPONSE_FIELD_TYPE_COLLECTION = 'Collection';
+    static SERVER_RESPONSE_FIELD_TYPE_COMPLEX = 'Complex';
+    static SERVER_RESPONSE_FIELD_TYPE_DYNAMIC_LIST_TYPE = ['DynamicList', 'DynamicRadioList'];
+    static isValidDisplayContext(ctx) {
+        return (ctx === 'MANDATORY' || ctx === 'READONLY'
+            || ctx === 'OPTIONAL' || ctx === 'HIDDEN'
+            || ctx === 'COMPLEX');
+    }
+    static convertToCaseField(obj) {
+        if (!(obj instanceof CaseField)) {
+            return plainToClassFromExist(new CaseField(), obj);
+        }
+        return obj;
+    }
+    static toValuesMap(caseFields) {
+        const valueMap = {};
+        caseFields.forEach(field => {
+            valueMap[field.id] = FieldsUtils.prepareValue(field);
+        });
+        return valueMap;
+    }
+    // public static getType(elem: any): string {
+    //   return Object.prototype.toString.call(elem).slice(8, -1);
+    // }
+    static isObject(elem) {
+        return typeof elem === 'object' && elem !== null;
+    }
+    static isNonEmptyObject(elem) {
+        return this.isObject(elem) && Object.keys(elem).length !== 0;
+    }
+    static isArray(elem) {
+        return Array.isArray(elem);
+    }
+    static areCollectionValuesSimpleFields(fieldValue) {
+        return !this.isObject(fieldValue[0]['value']) && !Array.isArray(fieldValue[0]['value']) && fieldValue[0]['value'] !== undefined;
+    }
+    static isCollectionOfSimpleTypes(fieldValue) {
+        return this.isCollection(fieldValue) && this.areCollectionValuesSimpleFields(fieldValue);
+    }
+    static isMultiSelectValue(form) {
+        return this.isNonEmptyArray(form) && !this.isCollectionWithValue(form);
+    }
+    static isNonEmptyArray(pageFormFields) {
+        return Array.isArray(pageFormFields) && pageFormFields[0] !== undefined;
+    }
+    static isCollection(pageFormFields) {
+        return this.isNonEmptyArray(pageFormFields) && this.isCollectionWithValue(pageFormFields);
+    }
+    static isCollectionWithValue(pageFormFields) {
+        return pageFormFields[0]['value'] !== undefined;
+    }
+    static cloneObject(obj) {
+        return Object.assign({}, obj);
+    }
+    // temporary function until this can be moved to CaseView class (RDM-2681)
+    static getCaseFields(caseView) {
+        const caseDataFields = caseView.tabs.reduce((acc, tab) => {
+            return acc.concat(tab.fields);
+        }, []);
+        const metadataFields = caseView.metadataFields;
+        return metadataFields.concat(caseDataFields.filter((caseField) => {
+            return metadataFields.findIndex(metadataField => metadataField.id === caseField.id) < 0;
+        }));
+    }
+    static addCaseFieldAndComponentReferences(c, cf, comp) {
+        c['caseField'] = cf;
+        c['component'] = comp;
+    }
+    /**
+     * Recursive check of an array or object and its descendants for the presence of any non-empty values.
+     *
+     * @param object The array or object to check
+     * @returns `true` if the array or object (or a descendant) contains at least one non-empty value; `false` otherwise
+     */
+    static containsNonEmptyValues(object) {
+        if (!object) {
+            return false;
+        }
+        const values = Object.keys(object).map(key => object[key]);
+        const objectRefs = [];
+        // Also test for numeric values, and length > 0 for non-numeric values because this covers both strings and arrays.
+        // Note: Deliberate use of non-equality (!=) operator for null check, to handle both null and undefined values.
+        // tslint:disable-next-line: triple-equals
+        const hasNonNullPrimitive = values.some(x => (x != null &&
+            ((typeof x === 'object' && x.constructor === Object) || Array.isArray(x)
+                ? !objectRefs.push(x)
+                : typeof x === 'number' || x.length > 0)));
+        return !hasNonNullPrimitive ? objectRefs.some(y => this.containsNonEmptyValues(y)) : hasNonNullPrimitive;
+    }
+    /**
+     * handleNestedDynamicLists()
+     * Reassigns list_item and value data to DynamicList children
+     * down the tree. Server response returns data only in
+     * the `value` object of parent complex type
+     *
+     * EUI-2530 Dynamic Lists for Elements in a Complex Type
+     *
+     * @param jsonBody - { case_fields: [ CaseField, CaseField ] }
+     */
+    static handleNestedDynamicLists(jsonBody) {
+        if (jsonBody.case_fields) {
+            jsonBody.case_fields.forEach(caseField => {
+                if (caseField.field_type) {
+                    this.setDynamicListDefinition(caseField, caseField.field_type, caseField);
+                }
+            });
+        }
+        return jsonBody;
+    }
+    static prepareValue(field) {
+        if (field.value) {
+            return field.value;
+        }
+        else if (field.isComplex()) {
+            const valueMap = {};
+            field.field_type.complex_fields.forEach(complexField => {
+                valueMap[complexField.id] = FieldsUtils.prepareValue(complexField);
+            });
+            return valueMap;
+        }
+    }
+    static DEFAULT_MERGE_FUNCTION = function mergeFunction(field, result) {
+        if (!result.hasOwnProperty(field.id)) {
+            result[field.id] = field.value;
+        }
+    };
+    static LABEL_MERGE_FUNCTION = function mergeFunction(field, result) {
+        if (!result) {
+            result = {};
+        }
+        if (!result.hasOwnProperty(field.id)) {
+            result[field.id] = field.value;
+        }
+        // tslint:disable-next-line: switch-default
+        switch (field.field_type.type) {
+            case 'FixedList':
+            case 'FixedRadioList': {
+                result[field.id] = FieldsUtils.getFixedListLabelByCodeOrEmpty(field, result[field.id] || field.value);
+                break;
+            }
+            case 'MultiSelectList': {
+                const fieldValue = result[field.id] || [];
+                result[field.id + FieldsUtils.LABEL_SUFFIX] = [];
+                fieldValue.forEach((code, idx) => {
+                    result[field.id + FieldsUtils.LABEL_SUFFIX][idx] = FieldsUtils.getFixedListLabelByCodeOrEmpty(field, code);
+                });
+                break;
+            }
+            case 'Label': {
+                result[field.id] = FieldsUtils.getLabel(field);
+                break;
+            }
+            case 'MoneyGBP': {
+                const fieldValue = (result[field.id] || field.value);
+                result[field.id] = FieldsUtils.getMoneyGBP(fieldValue);
+                break;
+            }
+            case 'Date': {
+                const fieldValue = (result[field.id] || field.value);
+                result[field.id] = FieldsUtils.getDate(fieldValue);
+                break;
+            }
+            case 'Complex': {
+                if (result[field.id] && field.field_type.complex_fields) {
+                    field.field_type.complex_fields.forEach((f) => {
+                        if (['Collection', 'Complex', 'MultiSelectList'].indexOf(f.field_type.type) > -1) {
+                            FieldsUtils.LABEL_MERGE_FUNCTION(f, result[field.id]);
+                        }
+                    });
+                }
+                break;
+            }
+            case 'Collection': {
+                const elements = (result[field.id] || field.value);
+                if (elements) {
+                    elements.forEach((elem) => {
+                        // tslint:disable-next-line:switch-default
+                        switch (field.field_type.collection_field_type.type) {
+                            case 'MoneyGBP': {
+                                elem.value = FieldsUtils.getMoneyGBP(elem.value);
+                                break;
+                            }
+                            case 'Date': {
+                                elem.value = FieldsUtils.getDate(elem.value);
+                                break;
+                            }
+                            case 'Complex': {
+                                if (field.field_type.collection_field_type.complex_fields) {
+                                    field.field_type.collection_field_type.complex_fields.forEach((f) => {
+                                        if (['Collection', 'Complex', 'MultiSelectList'].indexOf(f.field_type.type) > -1) {
+                                            FieldsUtils.LABEL_MERGE_FUNCTION(f, elem.value);
+                                        }
+                                    });
+                                }
+                                break;
+                            }
+                        }
+                    });
+                }
+                break;
+            }
+        }
+    };
+    /**
+     * Formats a `MoneyGBP` value to include currency units.
+     * @param fieldValue The CurrencyPipe expects an `any` parameter so this must also be `any`,
+     * but it should be "number-like" (e.g., '1234')
+     * @returns A formatted string (e.g., £12.34)
+     */
+    static getMoneyGBP(fieldValue) {
+        return fieldValue ? FieldsUtils.currencyPipe.transform(fieldValue / 100, 'GBP', 'symbol') : fieldValue;
+    }
+    static getLabel(fieldValue) {
+        return fieldValue ? fieldValue.label : '';
+    }
+    static getDate(fieldValue) {
+        try {
+            // Format specified here wasn't previously working and lots of tests depend on it not working
+            // Now that formats work correctly many test would break - and this could affect services which may depend on
+            // the orginal behaviour of returning dates in "d MMM yyyy"
+            // Note - replaced 'd' with 'D' as datepipe using moment to avoid timezone discrepancies
+            return FieldsUtils.datePipe.transform(fieldValue, null, 'D MMM yyyy');
+        }
+        catch (e) {
+            return this.textForInvalidField('Date', fieldValue);
+        }
+    }
+    static getFixedListLabelByCodeOrEmpty(field, code) {
+        const relevantItem = code ? field.field_type.fixed_list_items.find(item => item.code === code) : null;
+        return relevantItem ? relevantItem.label : '';
+    }
+    static textForInvalidField(type, invalidValue) {
+        return `{ Invalid ${type}: ${invalidValue} }`;
+    }
+    static setDynamicListDefinition(caseField, caseFieldType, rootCaseField) {
+        if (caseFieldType.type === FieldsUtils.SERVER_RESPONSE_FIELD_TYPE_COMPLEX) {
+            caseFieldType.complex_fields.forEach(field => {
+                try {
+                    const isDynamicField = FieldsUtils.SERVER_RESPONSE_FIELD_TYPE_DYNAMIC_LIST_TYPE.indexOf(field.field_type.type) !== -1;
+                    if (isDynamicField) {
+                        const dynamicListValue = this.getDynamicListValue(rootCaseField.value, field.id);
+                        if (dynamicListValue) {
+                            const list_items = dynamicListValue[0].list_items;
+                            const complexValue = dynamicListValue.map(data => data.value);
+                            const value = {
+                                list_items,
+                                value: complexValue.length > 0 ? complexValue : undefined
+                            };
+                            field.value = {
+                                ...value
+                            };
+                            field.formatted_value = {
+                                ...field.formatted_value,
+                                ...value
+                            };
+                        }
+                    }
+                    else {
+                        this.setDynamicListDefinition(field, field.field_type, rootCaseField);
+                    }
+                }
+                catch (error) {
+                    console.log(error);
+                }
+            });
+        }
+        else if (caseFieldType.type === FieldsUtils.SERVER_RESPONSE_FIELD_TYPE_COLLECTION) {
+            if (caseFieldType.collection_field_type) {
+                this.setDynamicListDefinition(caseField, caseFieldType.collection_field_type, rootCaseField);
+            }
+        }
+    }
+    static getDynamicListValue(jsonBlock, key) {
+        const data = jsonBlock ? this.getNestedFieldValues(jsonBlock, key, []) : [];
+        return data.length > 0 ? data : null;
+    }
+    static getNestedFieldValues(jsonData, key, output = []) {
+        if (jsonData && jsonData[key]) {
+            output.push(jsonData[key]);
+        }
+        else {
+            for (const elementKey in jsonData) {
+                if (typeof jsonData === 'object' && jsonData.hasOwnProperty(elementKey)) {
+                    this.getNestedFieldValues(jsonData[elementKey], key, output);
+                }
+            }
+        }
+        return output;
+    }
+    static isFlagsCaseField(caseField) {
+        if (!caseField) {
+            return false;
+        }
+        return this.isFlagsFieldType(caseField.field_type);
+    }
+    /**
+     * @deprecated Use {@link isCaseFieldOfType} instead, passing 'FlagLauncher' as the single type in the `types` array
+     */
+    static isFlagLauncherCaseField(caseField) {
+        if (!caseField) {
+            return false;
+        }
+        return caseField.field_type.type === 'FlagLauncher';
+    }
+    /**
+     * @deprecated Use {@link isCaseFieldOfType} instead, passing 'ComponentLauncher' as the single type in the `types`
+     * array
+     */
+    static isComponentLauncherCaseField(caseField) {
+        if (!caseField) {
+            return false;
+        }
+        return caseField.field_type.type === 'ComponentLauncher';
+    }
+    /**
+     * Checks if a {@link CaseField} is of one of the given field types.
+     *
+     * @param caseField The `CaseField` to check
+     * @param types An array of one or more field types
+     * @returns `true` if the `CaseField` type is one of those in the array of types to check against; `false`
+     * otherwise or if `caseField` or `types` are falsy
+     */
+    static isCaseFieldOfType(caseField, types) {
+        if (!caseField || !types) {
+            return false;
+        }
+        return types.some(type => type === caseField.field_type?.type || type === caseField.field_type?.id);
+    }
+    static isLinkedCasesCaseField(caseField) {
+        return FieldsUtils.isComponentLauncherCaseField(caseField) &&
+            caseField.id === 'LinkedCasesComponentLauncher';
+    }
+    static containsLinkedCasesCaseField(caseFields) {
+        return caseFields?.some(caseField => FieldsUtils.isLinkedCasesCaseField(caseField));
+    }
+    static isFlagsFieldType(fieldType) {
+        if (!fieldType) {
+            return false;
+        }
+        // Note: This implementation supports the dummy field type ID of "CaseFlag" for testing and the real field type
+        // ID of "Flags"
+        return (fieldType.type === 'Complex' && (fieldType.id === 'CaseFlag' || fieldType.id === 'Flags'));
+    }
+    /**
+     * Extract flags data from a `CaseField` instance, recursing and iterating through sub-fields of a Complex field or
+     * each field in a Collection field.
+     *
+     * @param flags An array for accumulating extracted flags data and derived `FormGroup` paths
+     * @param caseField A `CaseField` instance from which to extract the flags data
+     * @param pathToFlagsFormGroup A (dot-delimited) string for concatenating the name of each control that forms the path
+     * to the `FormGroup` for the `Flags` instance
+     * @param topLevelCaseField The top-level `CaseField` that contains the value property. This is required because _only
+     * top-level_ `CaseField`s contain actual values and a reference needs to be maintained to such a field
+     * @param currentValue The current value object of a `CaseField` that is a sub-field of a non root-level Complex field.
+     * Required for mapping the `CaseField` value to a `Flags` object if it is a "Flags" `CaseField`. (For Complex types,
+     * only the _root-level_ `CaseField` contains a value property - all sub-fields, including any nested Complex fields,
+     * do *not* contain any values themselves.)
+     * @returns An array of `FlagsWithFormGroupPath`, each instance comprising a `Flags` object derived from a `CaseField`
+     * of type "Flags", and the dot-delimited path string to the corresponding `FormGroup`
+     */
+    static extractFlagsDataFromCaseField(flags, caseField, pathToFlagsFormGroup, topLevelCaseField, currentValue) {
+        const fieldType = caseField.field_type;
+        switch (fieldType.type) {
+            case 'Complex':
+                // If the field is a Flags CaseField (these are implemented as Complex types), it can be mapped to a Flags
+                // object immediately
+                if (FieldsUtils.isFlagsCaseField(caseField)) {
+                    // If the Flags CaseField has a value, it is a root-level Complex field; if it does not, it is a Flags
+                    // CaseField that is a sub-field within another Complex field, so use the currentValue value (if any)
+                    // instead. The exception to this is the "caseFlags" Flags CaseField, which will have an empty object value
+                    // initially, because no party name is required
+                    if (caseField.value && FieldsUtils.isNonEmptyObject(caseField.value) ||
+                        caseField.id === this.caseLevelCaseFlagsFieldId) {
+                        flags.push(this.mapCaseFieldToFlagsWithFormGroupPathObject(caseField, pathToFlagsFormGroup));
+                    }
+                    else if (currentValue && FieldsUtils.isNonEmptyObject(currentValue)) {
+                        pathToFlagsFormGroup += `.${caseField.id}`;
+                        flags.push(this.mapValueToFlagsWithFormGroupPathObject(caseField.id, currentValue, pathToFlagsFormGroup, topLevelCaseField));
+                    }
+                }
+                else if (fieldType.complex_fields) {
+                    const value = caseField.value ? caseField.value : currentValue;
+                    if (value && FieldsUtils.isNonEmptyObject(value)) {
+                        flags = fieldType.complex_fields.reduce((flagsOfComplexField, subField) => {
+                            return this.extractFlagsDataFromCaseField(flagsOfComplexField, subField, pathToFlagsFormGroup, topLevelCaseField, value[subField.id]);
+                        }, flags);
+                    }
+                }
+                break;
+            // For a Collection field, the values are stored directly as key-value pairs in the CaseField's value property
+            // as an array, unless the collection is a sub-field of a Complex type - sub-fields never contain values
+            case 'Collection':
+                // If this is a collection of Flags CaseFields, these can be mapped to Flags objects immediately
+                if (FieldsUtils.isFlagsFieldType(fieldType.collection_field_type)) {
+                    // If the Collection CaseField has a value (an array), it is a root-level Collection field; if it does not,
+                    // it is a Collection CaseField that is a sub-field within a Complex field, so use the currentValue value
+                    // (if any) instead
+                    const pathFragment = pathToFlagsFormGroup += '.index.value';
+                    if (caseField.value) {
+                        caseField.value.forEach((item, index) => {
+                            // At each iteration, replace the "index" placeholder with the actual index
+                            pathToFlagsFormGroup = pathFragment.replace('index', index.toString(10));
+                            flags.push(this.mapValueToFlagsWithFormGroupPathObject(item.id, item.value, pathToFlagsFormGroup, caseField));
+                        });
+                    }
+                    else if (currentValue) {
+                        currentValue.forEach((item, index) => {
+                            pathToFlagsFormGroup = pathFragment.replace('index', index.toString(10));
+                            flags.push(this.mapValueToFlagsWithFormGroupPathObject(item.id, item.value, pathToFlagsFormGroup, topLevelCaseField));
+                        });
+                    }
+                }
+                else if (fieldType.collection_field_type.type === 'Complex' && fieldType.collection_field_type.complex_fields) {
+                    if (caseField.value) {
+                        // Perform a reduction over each Complex field's sub-fields (similar to what is done above for non-Flags
+                        // Complex fields)
+                        // (Cannot just call this function recursively for each Complex field in the collection because the CaseField
+                        // for each one is not part of the collection)
+                        const pathFragment = pathToFlagsFormGroup += '.index.value';
+                        caseField.value.forEach((item, index) => {
+                            // At each iteration, replace the "index" placeholder with the actual index
+                            pathToFlagsFormGroup = pathFragment.replace('index', index.toString(10));
+                            flags = fieldType.collection_field_type.complex_fields.reduce((flagsOfComplexField, subField) => {
+                                return this.extractFlagsDataFromCaseField(flagsOfComplexField, subField, pathToFlagsFormGroup, topLevelCaseField, item.value[subField.id]);
+                            }, flags);
+                        });
+                    }
+                }
+                break;
+            default:
+            // Ignore all other field types
+        }
+        return flags;
+    }
+    static mapCaseFieldToFlagsWithFormGroupPathObject(caseField, pathToFlagsFormGroup) {
+        return this.mapValueToFlagsWithFormGroupPathObject(caseField.id, caseField.value, pathToFlagsFormGroup, caseField);
+    }
+    static mapValueToFlagsWithFormGroupPathObject(id, value, pathToFlagsFormGroup, caseField) {
+        return {
+            flags: {
+                flagsCaseFieldId: id,
+                partyName: value ? value['partyName'] : null,
+                roleOnCase: value ? value['roleOnCase'] : null,
+                details: value && value['details'] && value['details'].length > 0
+                    ? value['details'].map(detail => {
+                        return Object.assign({}, ...Object.keys(detail.value).map((k) => {
+                            // The id property set below will be null for a new case flag, and a unique id returned from CCD when
+                            // updating an existing flag
+                            switch (k) {
+                                // These two fields are date-time fields
+                                case 'dateTimeModified':
+                                case 'dateTimeCreated':
+                                    return { [k]: detail.value[k] ? new Date(detail.value[k]) : null, id: detail.id };
+                                // This field is a "yes/no" field
+                                case 'hearingRelevant':
+                                    return detail.value[k].toUpperCase() === 'YES' ? { [k]: true, id: detail.id } : { [k]: false, id: detail.id };
+                                default:
+                                    return { [k]: detail.value[k], id: detail.id };
+                            }
+                        }));
+                    })
+                    : null,
+                visibility: value ? value['visibility'] : null,
+                groupId: value ? value['groupId'] : null
+            },
+            pathToFlagsFormGroup,
+            caseField
+        };
+    }
+    /**
+     * Count active flags in a `CaseField` instance, recursing and iterating through sub-fields of a Complex field or each
+     * field in a Collection field.
+     *
+     * @param activeCount An accumulation of the total number of active flags
+     * @param caseField A `CaseField` instance for which to count the active flags
+     * @param currentValue The current value object of a `CaseField` that is a sub-field of a non root-level Complex field.
+     * (For Complex types, only the _root-level_ `CaseField` contains a value property - all sub-fields, including any
+     * nested Complex fields, do *not* contain any values themselves.)
+     * @returns The count of active flags
+     */
+    static countActiveFlagsInCaseField(activeCount, caseField, currentValue) {
+        const fieldType = caseField.field_type;
+        switch (fieldType.type) {
+            case 'Complex':
+                if (FieldsUtils.isFlagsCaseField(caseField)) {
+                    // If the Flags CaseField has a value, it is a root-level Complex field; if it does not, it is a Flags
+                    // CaseField that is a sub-field within another Complex field, so use the currentValue value (if any) instead
+                    const value = caseField.value ? caseField.value : currentValue;
+                    if (value && FieldsUtils.isNonEmptyObject(value) && value.details) {
+                        activeCount = value.details.reduce((count, detail) => detail.value.status === CaseFlagStatus.ACTIVE ? count + 1 : count, activeCount);
+                    }
+                }
+                else if (fieldType.complex_fields) {
+                    const value = caseField.value ? caseField.value : currentValue;
+                    if (value && FieldsUtils.isNonEmptyObject(value)) {
+                        activeCount = fieldType.complex_fields.reduce((activeFlagsCountOfComplexField, subField) => {
+                            return this.countActiveFlagsInCaseField(activeFlagsCountOfComplexField, subField, value[subField.id]);
+                        }, activeCount);
+                    }
+                }
+                break;
+            // For a Collection field, the values are stored directly as key-value pairs in the CaseField's value property
+            // as an array, unless the collection is a sub-field of a Complex type - sub-fields never contain values
+            case 'Collection':
+                if (FieldsUtils.isFlagsFieldType(fieldType.collection_field_type)) {
+                    // If the Collection CaseField has a value (an array), it is a root-level Collection field; if it does not,
+                    // it is a Collection CaseField that is a sub-field within a Complex field, so use the currentValue value
+                    // (if any) instead
+                    const value = caseField.value ? caseField.value : currentValue;
+                    if (value) {
+                        value.forEach((item) => {
+                            if (item.value['details']) {
+                                activeCount = item.value['details'].reduce((count, detail) => detail.value.status === CaseFlagStatus.ACTIVE ? count + 1 : count, activeCount);
+                            }
+                        });
+                    }
+                }
+                else if (fieldType.collection_field_type.type === 'Complex' && fieldType.collection_field_type.complex_fields) {
+                    if (caseField.value) {
+                        // Perform a reduction over each Complex field's sub-fields (similar to what is done above for non-Flags
+                        // Complex fields)
+                        // (Cannot just call this function recursively for each Complex field in the collection because the CaseField
+                        // for each one is not part of the collection)
+                        caseField.value.forEach((item) => {
+                            activeCount = fieldType.collection_field_type.complex_fields.reduce((activeFlagsCountOfComplexField, subField) => {
+                                return this.countActiveFlagsInCaseField(activeFlagsCountOfComplexField, subField, item.value[subField.id]);
+                            }, activeCount);
+                        });
+                    }
+                }
+                break;
+            default:
+            // Ignore all other field types
+        }
+        return activeCount;
+    }
+    static getValidationErrorMessageForFlagLauncherCaseField(caseField) {
+        switch (caseField.display_context_parameter) {
+            case CaseFlagDisplayContextParameter.CREATE:
+            case CaseFlagDisplayContextParameter.CREATE_2_POINT_1:
+                return 'Please select Next to complete the creation of the case flag';
+            case CaseFlagDisplayContextParameter.CREATE_EXTERNAL:
+                return 'Please select Next to complete the creation of the support request';
+            case CaseFlagDisplayContextParameter.UPDATE:
+            case CaseFlagDisplayContextParameter.UPDATE_2_POINT_1:
+                return 'Please select Next to complete the update of the selected case flag';
+            case CaseFlagDisplayContextParameter.UPDATE_EXTERNAL:
+                return 'Please select Next to complete the update of the selected support request';
+            default:
+                return '';
+        }
+    }
+    buildCanShowPredicate(eventTrigger, form) {
+        const currentState = this.getCurrentEventState(eventTrigger, form);
+        return (page) => {
+            return page.parsedShowCondition.match(currentState);
+        };
+    }
+    getCurrentEventState(eventTrigger, form) {
+        return this.mergeCaseFieldsAndFormFields(eventTrigger.case_fields, form.controls['data'].value);
+    }
+    cloneCaseField(obj) {
+        return Object.assign(new CaseField(), obj);
+    }
+    mergeCaseFieldsAndFormFields(caseFields, formFields) {
+        return this.mergeFields(caseFields, formFields, FieldsUtils.DEFAULT_MERGE_FUNCTION);
+    }
+    mergeLabelCaseFieldsAndFormFields(caseFields, formFields) {
+        return this.mergeFields(caseFields, formFields, FieldsUtils.LABEL_MERGE_FUNCTION);
+    }
+    controlIterator(aControl, formArrayFn, formGroupFn, controlFn) {
+        if (aControl instanceof FormArray) { // We're in a collection
+            formArrayFn(aControl);
+        }
+        else if (aControl instanceof FormGroup) { // We're in a complex type.
+            formGroupFn(aControl);
+        }
+        else if (aControl instanceof FormControl) { // FormControl
+            controlFn(aControl);
+        }
+    }
+    mergeFields(caseFields, formFields, mergeFunction) {
+        const result = FieldsUtils.cloneObject(formFields);
+        caseFields.forEach(field => {
+            mergeFunction(field, result);
+            if (field.field_type && field.field_type.complex_fields && field.field_type.complex_fields.length > 0) {
+                result[field.id] = this.mergeFields(field.field_type.complex_fields, result[field.id], mergeFunction);
+            }
+        });
+        return result;
+    }
+    static ɵfac = function FieldsUtils_Factory(t) { return new (t || FieldsUtils)(); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: FieldsUtils, factory: FieldsUtils.ɵfac });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FieldsUtils, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fields.utils.js","sourceRoot":"","sources":["../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/services/fields/fields.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { CurrencyPipe } from '@angular/common';\nimport { Injectable } from '@angular/core';\nimport { AbstractControl, FormArray, FormControl, FormGroup } from '@angular/forms';\nimport { plainToClassFromExist } from 'class-transformer';\nimport { WizardPage } from '../../components/case-editor/domain';\nimport { AbstractFormFieldComponent } from '../../components/palette/base-field/abstract-form-field.component';\nimport { FlagDetail, FlagsWithFormGroupPath } from '../../components/palette/case-flag/domain/case-flag.model';\nimport { CaseFlagDisplayContextParameter, CaseFlagStatus } from '../../components/palette/case-flag/enums';\nimport { DatePipe } from '../../components/palette/utils';\nimport { CaseEventTrigger, CaseField, CaseTab, CaseView, FieldType, FieldTypeEnum, FixedListItem, Predicate } from '../../domain';\nimport { FormatTranslatorService } from '../case-fields/format-translator.service';\n\n// @dynamic\n@Injectable()\nexport class FieldsUtils {\n  private static readonly caseLevelCaseFlagsFieldId = 'caseFlags';\n  private static readonly currencyPipe: CurrencyPipe = new CurrencyPipe('en-GB');\n  private static readonly datePipe: DatePipe = new DatePipe(new FormatTranslatorService());\n  // EUI-4244. 3 dashes instead of 1 to make this less likely to clash with a real field.\n  public static readonly LABEL_SUFFIX = '---LABEL';\n  // Handling of Dynamic Lists in Complex Types\n  public static readonly SERVER_RESPONSE_FIELD_TYPE_COLLECTION = 'Collection';\n  public static readonly SERVER_RESPONSE_FIELD_TYPE_COMPLEX = 'Complex';\n  public static readonly SERVER_RESPONSE_FIELD_TYPE_DYNAMIC_LIST_TYPE: FieldTypeEnum[] = ['DynamicList', 'DynamicRadioList'];\n\n  public static isValidDisplayContext(ctx: string): boolean {\n    return (ctx === 'MANDATORY' || ctx === 'READONLY'\n      || ctx === 'OPTIONAL' || ctx === 'HIDDEN'\n      || ctx === 'COMPLEX');\n  }\n\n  public static convertToCaseField(obj: any): CaseField {\n    if (!(obj instanceof CaseField)) {\n      return plainToClassFromExist(new CaseField(), obj);\n    }\n    return obj;\n  }\n\n  public static toValuesMap(caseFields: CaseField[]): any {\n    const valueMap = {};\n    caseFields.forEach(field => {\n      valueMap[field.id] = FieldsUtils.prepareValue(field);\n    });\n    return valueMap;\n  }\n\n  // public static getType(elem: any): string {\n  //   return Object.prototype.toString.call(elem).slice(8, -1);\n  // }\n\n  public static isObject(elem: any): boolean {\n    return typeof elem === 'object' && elem !== null;\n  }\n\n  public static isNonEmptyObject(elem: any): boolean {\n    return this.isObject(elem) && Object.keys(elem).length !== 0;\n  }\n\n  public static isArray(elem: any): boolean {\n    return Array.isArray(elem);\n  }\n\n  public static areCollectionValuesSimpleFields(fieldValue: any[]): boolean {\n    return !this.isObject(fieldValue[0]['value']) && !Array.isArray(fieldValue[0]['value']) && fieldValue[0]['value'] !== undefined;\n  }\n\n  public static isCollectionOfSimpleTypes(fieldValue: any): boolean {\n    return this.isCollection(fieldValue) && this.areCollectionValuesSimpleFields(fieldValue);\n  }\n\n  public static isMultiSelectValue(form: any): boolean {\n    return this.isNonEmptyArray(form) && !this.isCollectionWithValue(form);\n  }\n\n  public static isNonEmptyArray(pageFormFields: any): boolean {\n    return Array.isArray(pageFormFields) && pageFormFields[0] !== undefined;\n  }\n\n  public static isCollection(pageFormFields: any): boolean {\n    return this.isNonEmptyArray(pageFormFields) && this.isCollectionWithValue(pageFormFields);\n  }\n\n  public static isCollectionWithValue(pageFormFields: any[]): boolean {\n    return pageFormFields[0]['value'] !== undefined;\n  }\n\n  public static cloneObject(obj: any): any {\n    return Object.assign({}, obj);\n  }\n\n  // temporary function until this can be moved to CaseView class (RDM-2681)\n  public static getCaseFields(caseView: CaseView): CaseField[] {\n    const caseDataFields: CaseField[] = caseView.tabs.reduce((acc: CaseField[], tab: CaseTab) => {\n      return acc.concat(tab.fields);\n    }, []);\n\n    const metadataFields: CaseField[] = caseView.metadataFields;\n    return metadataFields.concat(caseDataFields.filter((caseField: CaseField) => {\n      return metadataFields.findIndex(metadataField => metadataField.id === caseField.id) < 0;\n    }));\n  }\n\n  public static addCaseFieldAndComponentReferences(c: AbstractControl, cf: CaseField, comp: AbstractFormFieldComponent): void {\n    c['caseField'] = cf;\n    c['component'] = comp;\n  }\n\n  /**\n   * Recursive check of an array or object and its descendants for the presence of any non-empty values.\n   *\n   * @param object The array or object to check\n   * @returns `true` if the array or object (or a descendant) contains at least one non-empty value; `false` otherwise\n   */\n  public static containsNonEmptyValues(object: object): boolean {\n    if (!object) {\n      return false;\n    }\n    const values = Object.keys(object).map(key => object[key]);\n    const objectRefs = [];\n    // Also test for numeric values, and length > 0 for non-numeric values because this covers both strings and arrays.\n    // Note: Deliberate use of non-equality (!=) operator for null check, to handle both null and undefined values.\n    // tslint:disable-next-line: triple-equals\n    const hasNonNullPrimitive = values.some(x => (x != null &&\n      ((typeof x === 'object' && x.constructor === Object) || Array.isArray(x)\n        ? !objectRefs.push(x)\n        : typeof x === 'number' || x.length > 0)\n    ));\n    return !hasNonNullPrimitive ? objectRefs.some(y => this.containsNonEmptyValues(y)) : hasNonNullPrimitive;\n  }\n\n  /**\n   * handleNestedDynamicLists()\n   * Reassigns list_item and value data to DynamicList children\n   * down the tree. Server response returns data only in\n   * the `value` object of parent complex type\n   *\n   * EUI-2530 Dynamic Lists for Elements in a Complex Type\n   *\n   * @param jsonBody - { case_fields: [ CaseField, CaseField ] }\n   */\n  public static handleNestedDynamicLists(jsonBody: { case_fields: CaseField[] }): any {\n    if (jsonBody.case_fields) {\n      jsonBody.case_fields.forEach(caseField => {\n        if (caseField.field_type) {\n          this.setDynamicListDefinition(caseField, caseField.field_type, caseField);\n        }\n      });\n    }\n\n    return jsonBody;\n  }\n\n  private static prepareValue(field: CaseField): any {\n    if (field.value) {\n      return field.value;\n    } else if (field.isComplex()) {\n      const valueMap = {};\n      field.field_type.complex_fields.forEach(complexField => {\n        valueMap[complexField.id] = FieldsUtils.prepareValue(complexField);\n      });\n      return valueMap;\n    }\n  }\n\n  private static readonly DEFAULT_MERGE_FUNCTION = function mergeFunction(field: CaseField, result: object): void {\n    if (!result.hasOwnProperty(field.id)) {\n      result[field.id] = field.value;\n    }\n  };\n\n  private static readonly LABEL_MERGE_FUNCTION = function mergeFunction(field: CaseField, result: object): void {\n    if (!result) {\n      result = {};\n    }\n    if (!result.hasOwnProperty(field.id)) {\n      result[field.id] = field.value;\n    }\n\n    // tslint:disable-next-line: switch-default\n    switch (field.field_type.type) {\n      case 'FixedList':\n      case 'FixedRadioList': {\n        result[field.id] = FieldsUtils.getFixedListLabelByCodeOrEmpty(field, result[field.id] || field.value);\n        break;\n      }\n      case 'MultiSelectList': {\n        const fieldValue = result[field.id] || [];\n        result[field.id + FieldsUtils.LABEL_SUFFIX] = [];\n        fieldValue.forEach((code: any, idx: any) => {\n          result[field.id + FieldsUtils.LABEL_SUFFIX][idx] = FieldsUtils.getFixedListLabelByCodeOrEmpty(field, code);\n        });\n        break;\n      }\n      case 'Label': {\n        result[field.id] = FieldsUtils.getLabel(field);\n        break;\n      }\n      case 'MoneyGBP': {\n        const fieldValue = (result[field.id] || field.value);\n        result[field.id] = FieldsUtils.getMoneyGBP(fieldValue);\n        break;\n      }\n      case 'Date': {\n        const fieldValue = (result[field.id] || field.value);\n        result[field.id] = FieldsUtils.getDate(fieldValue);\n        break;\n      }\n      case 'Complex': {\n        if (result[field.id] && field.field_type.complex_fields) {\n          field.field_type.complex_fields.forEach((f: CaseField) => {\n            if (['Collection', 'Complex', 'MultiSelectList'].indexOf(f.field_type.type) > -1) {\n              FieldsUtils.LABEL_MERGE_FUNCTION(f, result[field.id]);\n            }\n          });\n        }\n        break;\n      }\n      case 'Collection': {\n        const elements = (result[field.id] || field.value);\n        if (elements) {\n          elements.forEach((elem: any) => {\n            // tslint:disable-next-line:switch-default\n            switch (field.field_type.collection_field_type.type) {\n              case 'MoneyGBP': {\n                elem.value = FieldsUtils.getMoneyGBP(elem.value);\n                break;\n              }\n              case 'Date': {\n                elem.value = FieldsUtils.getDate(elem.value);\n                break;\n              }\n              case 'Complex': {\n                if (field.field_type.collection_field_type.complex_fields) {\n                  field.field_type.collection_field_type.complex_fields.forEach((f: CaseField) => {\n                    if (['Collection', 'Complex', 'MultiSelectList'].indexOf(f.field_type.type) > -1) {\n                      FieldsUtils.LABEL_MERGE_FUNCTION(f, elem.value);\n                    }\n                  });\n                }\n                break;\n              }\n            }\n          });\n        }\n        break;\n      }\n    }\n  };\n\n  /**\n   * Formats a `MoneyGBP` value to include currency units.\n   * @param fieldValue The CurrencyPipe expects an `any` parameter so this must also be `any`,\n   * but it should be \"number-like\" (e.g., '1234')\n   * @returns A formatted string (e.g., £12.34)\n   */\n  private static getMoneyGBP(fieldValue: any): string {\n    return fieldValue ? FieldsUtils.currencyPipe.transform(fieldValue / 100, 'GBP', 'symbol') : fieldValue;\n  }\n\n  private static getLabel(fieldValue: CaseField): string {\n    return fieldValue ? fieldValue.label : '';\n  }\n\n  private static getDate(fieldValue: string): string {\n    try {\n      // Format specified here wasn't previously working and lots of tests depend on it not working\n      // Now that formats work correctly many test would break - and this could affect services which may depend on\n      // the orginal behaviour of returning dates in \"d MMM yyyy\"\n      // Note - replaced 'd' with 'D' as datepipe using moment to avoid timezone discrepancies\n      return FieldsUtils.datePipe.transform(fieldValue, null, 'D MMM yyyy');\n    } catch (e) {\n      return this.textForInvalidField('Date', fieldValue);\n    }\n  }\n\n  private static getFixedListLabelByCodeOrEmpty(field: CaseField, code: string): string {\n    const relevantItem: FixedListItem = code ? field.field_type.fixed_list_items.find(item => item.code === code) : null;\n    return relevantItem ? relevantItem.label : '';\n  }\n\n  private static textForInvalidField(type: string, invalidValue: string): string {\n    return `{ Invalid ${type}: ${invalidValue} }`;\n  }\n\n  private static setDynamicListDefinition(caseField: CaseField, caseFieldType: FieldType, rootCaseField: CaseField) {\n    if (caseFieldType.type === FieldsUtils.SERVER_RESPONSE_FIELD_TYPE_COMPLEX) {\n\n      caseFieldType.complex_fields.forEach(field => {\n        try {\n          const isDynamicField = FieldsUtils.SERVER_RESPONSE_FIELD_TYPE_DYNAMIC_LIST_TYPE.indexOf(field.field_type.type) !== -1;\n\n          if (isDynamicField) {\n            const dynamicListValue = this.getDynamicListValue(rootCaseField.value, field.id);\n            if (dynamicListValue) {\n              const list_items = dynamicListValue[0].list_items;\n              const complexValue = dynamicListValue.map(data => data.value);\n              const value = {\n                list_items,\n                value: complexValue.length > 0 ? complexValue : undefined\n              };\n              field.value = {\n                ...value\n              };\n              field.formatted_value = {\n                ...field.formatted_value,\n                ...value\n              };\n            }\n          } else {\n            this.setDynamicListDefinition(field, field.field_type, rootCaseField);\n          }\n        } catch (error) {\n          console.log(error);\n        }\n      });\n    } else if (caseFieldType.type === FieldsUtils.SERVER_RESPONSE_FIELD_TYPE_COLLECTION) {\n      if (caseFieldType.collection_field_type) {\n        this.setDynamicListDefinition(caseField, caseFieldType.collection_field_type, rootCaseField);\n      }\n    }\n  }\n\n  private static getDynamicListValue(jsonBlock: any, key: string) {\n    const data = jsonBlock ? this.getNestedFieldValues(jsonBlock, key, []) : [];\n\n    return data.length > 0 ? data : null;\n  }\n\n  private static getNestedFieldValues(jsonData: any, key: string, output: any[] = []) {\n    if (jsonData && jsonData[key]) {\n      output.push(jsonData[key]);\n    } else {\n      for (const elementKey in jsonData) {\n        if (typeof jsonData === 'object' && jsonData.hasOwnProperty(elementKey)) {\n          this.getNestedFieldValues(jsonData[elementKey], key, output);\n        }\n      }\n    }\n    return output;\n  }\n\n  public static isFlagsCaseField(caseField: CaseField): boolean {\n    if (!caseField) {\n      return false;\n    }\n\n    return this.isFlagsFieldType(caseField.field_type);\n  }\n\n  /**\n   * @deprecated Use {@link isCaseFieldOfType} instead, passing 'FlagLauncher' as the single type in the `types` array\n   */\n  public static isFlagLauncherCaseField(caseField: CaseField): boolean {\n    if (!caseField) {\n      return false;\n    }\n\n    return caseField.field_type.type === 'FlagLauncher';\n  }\n\n  /**\n   * @deprecated Use {@link isCaseFieldOfType} instead, passing 'ComponentLauncher' as the single type in the `types`\n   * array\n   */\n  public static isComponentLauncherCaseField(caseField: CaseField): boolean {\n    if (!caseField) {\n      return false;\n    }\n\n    return caseField.field_type.type === 'ComponentLauncher';\n  }\n\n  /**\n   * Checks if a {@link CaseField} is of one of the given field types.\n   *\n   * @param caseField The `CaseField` to check\n   * @param types An array of one or more field types\n   * @returns `true` if the `CaseField` type is one of those in the array of types to check against; `false`\n   * otherwise or if `caseField` or `types` are falsy\n   */\n  public static isCaseFieldOfType(caseField: CaseField, types: FieldTypeEnum[]): boolean {\n    if (!caseField || !types) {\n      return false;\n    }\n\n    return types.some(type => type === caseField.field_type?.type || type === caseField.field_type?.id);\n  }\n\n  public static isLinkedCasesCaseField(caseField: CaseField): boolean {\n    return FieldsUtils.isComponentLauncherCaseField(caseField) &&\n      caseField.id === 'LinkedCasesComponentLauncher';\n  }\n\n  public static containsLinkedCasesCaseField(caseFields: CaseField[]): boolean {\n    return caseFields?.some(caseField => FieldsUtils.isLinkedCasesCaseField(caseField));\n  }\n\n  public static isFlagsFieldType(fieldType: FieldType): boolean {\n    if (!fieldType) {\n      return false;\n    }\n\n    // Note: This implementation supports the dummy field type ID of \"CaseFlag\" for testing and the real field type\n    // ID of \"Flags\"\n    return (fieldType.type === 'Complex' && (fieldType.id === 'CaseFlag' || fieldType.id === 'Flags'));\n  }\n\n  /**\n   * Extract flags data from a `CaseField` instance, recursing and iterating through sub-fields of a Complex field or\n   * each field in a Collection field.\n   *\n   * @param flags An array for accumulating extracted flags data and derived `FormGroup` paths\n   * @param caseField A `CaseField` instance from which to extract the flags data\n   * @param pathToFlagsFormGroup A (dot-delimited) string for concatenating the name of each control that forms the path\n   * to the `FormGroup` for the `Flags` instance\n   * @param topLevelCaseField The top-level `CaseField` that contains the value property. This is required because _only\n   * top-level_ `CaseField`s contain actual values and a reference needs to be maintained to such a field\n   * @param currentValue The current value object of a `CaseField` that is a sub-field of a non root-level Complex field.\n   * Required for mapping the `CaseField` value to a `Flags` object if it is a \"Flags\" `CaseField`. (For Complex types,\n   * only the _root-level_ `CaseField` contains a value property - all sub-fields, including any nested Complex fields,\n   * do *not* contain any values themselves.)\n   * @returns An array of `FlagsWithFormGroupPath`, each instance comprising a `Flags` object derived from a `CaseField`\n   * of type \"Flags\", and the dot-delimited path string to the corresponding `FormGroup`\n   */\n  public static extractFlagsDataFromCaseField(flags: FlagsWithFormGroupPath[], caseField: CaseField,\n    pathToFlagsFormGroup: string, topLevelCaseField: CaseField, currentValue?: object): FlagsWithFormGroupPath[] {\n    const fieldType = caseField.field_type;\n    switch (fieldType.type) {\n      case 'Complex':\n        // If the field is a Flags CaseField (these are implemented as Complex types), it can be mapped to a Flags\n        // object immediately\n        if (FieldsUtils.isFlagsCaseField(caseField)) {\n          // If the Flags CaseField has a value, it is a root-level Complex field; if it does not, it is a Flags\n          // CaseField that is a sub-field within another Complex field, so use the currentValue value (if any)\n          // instead. The exception to this is the \"caseFlags\" Flags CaseField, which will have an empty object value\n          // initially, because no party name is required\n          if (caseField.value && FieldsUtils.isNonEmptyObject(caseField.value) ||\n            caseField.id === this.caseLevelCaseFlagsFieldId) {\n            flags.push(this.mapCaseFieldToFlagsWithFormGroupPathObject(caseField, pathToFlagsFormGroup));\n          } else if (currentValue && FieldsUtils.isNonEmptyObject(currentValue)) {\n            pathToFlagsFormGroup += `.${caseField.id}`;\n            flags.push(this.mapValueToFlagsWithFormGroupPathObject(\n              caseField.id, currentValue, pathToFlagsFormGroup, topLevelCaseField));\n          }\n        } else if (fieldType.complex_fields) {\n          const value = caseField.value ? caseField.value : currentValue;\n          if (value && FieldsUtils.isNonEmptyObject(value)) {\n            flags = fieldType.complex_fields.reduce((flagsOfComplexField, subField) => {\n              return this.extractFlagsDataFromCaseField(\n                flagsOfComplexField, subField, pathToFlagsFormGroup, topLevelCaseField, value[subField.id]);\n            }, flags);\n          }\n        }\n        break;\n      // For a Collection field, the values are stored directly as key-value pairs in the CaseField's value property\n      // as an array, unless the collection is a sub-field of a Complex type - sub-fields never contain values\n      case 'Collection':\n        // If this is a collection of Flags CaseFields, these can be mapped to Flags objects immediately\n        if (FieldsUtils.isFlagsFieldType(fieldType.collection_field_type)) {\n          // If the Collection CaseField has a value (an array), it is a root-level Collection field; if it does not,\n          // it is a Collection CaseField that is a sub-field within a Complex field, so use the currentValue value\n          // (if any) instead\n          const pathFragment = pathToFlagsFormGroup += '.index.value';\n          if (caseField.value) {\n            caseField.value.forEach((item: { id: string; value: object; }, index: number) => {\n              // At each iteration, replace the \"index\" placeholder with the actual index\n              pathToFlagsFormGroup = pathFragment.replace('index', index.toString(10));\n              flags.push(\n                this.mapValueToFlagsWithFormGroupPathObject(item.id, item.value, pathToFlagsFormGroup, caseField));\n            });\n          } else if (currentValue) {\n            (currentValue as []).forEach((item: { id: string; value: object; }, index: number) => {\n              pathToFlagsFormGroup = pathFragment.replace('index', index.toString(10));\n              flags.push(\n                this.mapValueToFlagsWithFormGroupPathObject(item.id, item.value, pathToFlagsFormGroup, topLevelCaseField));\n            });\n          }\n        } else if (fieldType.collection_field_type.type === 'Complex' && fieldType.collection_field_type.complex_fields) {\n          if (caseField.value) {\n            // Perform a reduction over each Complex field's sub-fields (similar to what is done above for non-Flags\n            // Complex fields)\n            // (Cannot just call this function recursively for each Complex field in the collection because the CaseField\n            // for each one is not part of the collection)\n            const pathFragment = pathToFlagsFormGroup += '.index.value';\n            caseField.value.forEach((item: { id: string; value: object; }, index: number) => {\n              // At each iteration, replace the \"index\" placeholder with the actual index\n              pathToFlagsFormGroup = pathFragment.replace('index', index.toString(10));\n              flags = fieldType.collection_field_type.complex_fields.reduce((flagsOfComplexField, subField) => {\n                return this.extractFlagsDataFromCaseField(\n                  flagsOfComplexField, subField, pathToFlagsFormGroup, topLevelCaseField, item.value[subField.id]);\n              }, flags);\n            });\n          }\n        }\n        break;\n      default:\n      // Ignore all other field types\n    }\n    return flags;\n  }\n\n  private static mapCaseFieldToFlagsWithFormGroupPathObject(caseField: CaseField,\n    pathToFlagsFormGroup: string): FlagsWithFormGroupPath {\n    return this.mapValueToFlagsWithFormGroupPathObject(caseField.id, caseField.value, pathToFlagsFormGroup, caseField);\n  }\n\n  private static mapValueToFlagsWithFormGroupPathObject(id: string, value: object,\n    pathToFlagsFormGroup: string, caseField: CaseField): FlagsWithFormGroupPath {\n    return {\n      flags: {\n        flagsCaseFieldId: id,\n        partyName: value ? value['partyName'] : null,\n        roleOnCase: value ? value['roleOnCase'] : null,\n        details: value && value['details'] && value['details'].length > 0\n          ? (value['details'] as any[]).map(detail => {\n            return Object.assign({}, ...Object.keys(detail.value).map((k) => {\n              // The id property set below will be null for a new case flag, and a unique id returned from CCD when\n              // updating an existing flag\n              switch (k) {\n                // These two fields are date-time fields\n                case 'dateTimeModified':\n                case 'dateTimeCreated':\n                  return { [k]: detail.value[k] ? new Date(detail.value[k]) : null, id: detail.id };\n                // This field is a \"yes/no\" field\n                case 'hearingRelevant':\n                  return detail.value[k].toUpperCase() === 'YES' ? { [k]: true, id: detail.id } : { [k]: false, id: detail.id };\n                default:\n                  return { [k]: detail.value[k], id: detail.id };\n              }\n            }));\n          }) as FlagDetail[]\n          : null,\n        visibility: value ? value['visibility'] : null,\n        groupId: value ? value['groupId'] : null\n      },\n      pathToFlagsFormGroup,\n      caseField\n    };\n  }\n\n  /**\n   * Count active flags in a `CaseField` instance, recursing and iterating through sub-fields of a Complex field or each\n   * field in a Collection field.\n   *\n   * @param activeCount An accumulation of the total number of active flags\n   * @param caseField A `CaseField` instance for which to count the active flags\n   * @param currentValue The current value object of a `CaseField` that is a sub-field of a non root-level Complex field.\n   * (For Complex types, only the _root-level_ `CaseField` contains a value property - all sub-fields, including any\n   * nested Complex fields, do *not* contain any values themselves.)\n   * @returns The count of active flags\n   */\n  public static countActiveFlagsInCaseField(activeCount: number, caseField: CaseField, currentValue?: object): number {\n    const fieldType = caseField.field_type;\n    switch (fieldType.type) {\n      case 'Complex':\n        if (FieldsUtils.isFlagsCaseField(caseField)) {\n          // If the Flags CaseField has a value, it is a root-level Complex field; if it does not, it is a Flags\n          // CaseField that is a sub-field within another Complex field, so use the currentValue value (if any) instead\n          const value = caseField.value ? caseField.value : currentValue;\n          if (value && FieldsUtils.isNonEmptyObject(value) && value.details) {\n            activeCount = value.details.reduce(\n              (count, detail) => detail.value.status === CaseFlagStatus.ACTIVE ? count + 1 : count,\n              activeCount\n            );\n          }\n        } else if (fieldType.complex_fields) {\n          const value = caseField.value ? caseField.value : currentValue;\n          if (value && FieldsUtils.isNonEmptyObject(value)) {\n            activeCount = fieldType.complex_fields.reduce((activeFlagsCountOfComplexField, subField) => {\n              return this.countActiveFlagsInCaseField(\n                activeFlagsCountOfComplexField,\n                subField,\n                value[subField.id]\n              );\n            }, activeCount);\n          }\n        }\n        break;\n      // For a Collection field, the values are stored directly as key-value pairs in the CaseField's value property\n      // as an array, unless the collection is a sub-field of a Complex type - sub-fields never contain values\n      case 'Collection':\n        if (FieldsUtils.isFlagsFieldType(fieldType.collection_field_type)) {\n          // If the Collection CaseField has a value (an array), it is a root-level Collection field; if it does not,\n          // it is a Collection CaseField that is a sub-field within a Complex field, so use the currentValue value\n          // (if any) instead\n          const value = caseField.value ? caseField.value : currentValue;\n          if (value) {\n            value.forEach((item: { id: string; value: object; }) => {\n              if (item.value['details']) {\n                activeCount = item.value['details'].reduce(\n                  (count, detail) => detail.value.status === CaseFlagStatus.ACTIVE ? count + 1 : count,\n                  activeCount\n                );\n              }\n            });\n          }\n        } else if (fieldType.collection_field_type.type === 'Complex' && fieldType.collection_field_type.complex_fields) {\n          if (caseField.value) {\n            // Perform a reduction over each Complex field's sub-fields (similar to what is done above for non-Flags\n            // Complex fields)\n            // (Cannot just call this function recursively for each Complex field in the collection because the CaseField\n            // for each one is not part of the collection)\n            caseField.value.forEach((item: { id: string; value: object; }) => {\n              activeCount = fieldType.collection_field_type.complex_fields.reduce(\n                (activeFlagsCountOfComplexField, subField) => {\n                  return this.countActiveFlagsInCaseField(activeFlagsCountOfComplexField, subField, item.value[subField.id]);\n                },\n                activeCount\n              );\n            });\n          }\n        }\n        break;\n      default:\n      // Ignore all other field types\n    }\n    return activeCount;\n  }\n\n  public static getValidationErrorMessageForFlagLauncherCaseField(caseField: CaseField): string {\n    switch(caseField.display_context_parameter) {\n      case CaseFlagDisplayContextParameter.CREATE:\n      case CaseFlagDisplayContextParameter.CREATE_2_POINT_1:\n        return 'Please select Next to complete the creation of the case flag';\n      case CaseFlagDisplayContextParameter.CREATE_EXTERNAL:\n        return 'Please select Next to complete the creation of the support request';\n      case CaseFlagDisplayContextParameter.UPDATE:\n      case CaseFlagDisplayContextParameter.UPDATE_2_POINT_1:\n        return 'Please select Next to complete the update of the selected case flag';\n      case CaseFlagDisplayContextParameter.UPDATE_EXTERNAL:\n        return 'Please select Next to complete the update of the selected support request';\n      default:\n        return '';\n    }\n  }\n\n  public buildCanShowPredicate(eventTrigger: CaseEventTrigger, form: any): Predicate<WizardPage> {\n    const currentState = this.getCurrentEventState(eventTrigger, form);\n    return (page: WizardPage): boolean => {\n      return page.parsedShowCondition.match(currentState);\n    };\n  }\n\n  public getCurrentEventState(eventTrigger: { case_fields: CaseField[] }, form: FormGroup): object {\n    return this.mergeCaseFieldsAndFormFields(eventTrigger.case_fields, form.controls['data'].value);\n  }\n\n  public cloneCaseField(obj: any): CaseField {\n    return Object.assign(new CaseField(), obj);\n  }\n\n  public mergeCaseFieldsAndFormFields(caseFields: CaseField[], formFields: object): object {\n    return this.mergeFields(caseFields, formFields, FieldsUtils.DEFAULT_MERGE_FUNCTION);\n  }\n\n  public mergeLabelCaseFieldsAndFormFields(caseFields: CaseField[], formFields: object): object {\n    return this.mergeFields(caseFields, formFields, FieldsUtils.LABEL_MERGE_FUNCTION);\n  }\n\n  public controlIterator(\n    aControl: AbstractControl,\n    formArrayFn: (array: FormArray) => void,\n    formGroupFn: (group: FormGroup) => void,\n    controlFn: (control: FormControl) => void\n  ): void {\n    if (aControl instanceof FormArray) { // We're in a collection\n      formArrayFn(aControl);\n    } else if (aControl instanceof FormGroup) { // We're in a complex type.\n      formGroupFn(aControl);\n    } else if (aControl instanceof FormControl) { // FormControl\n      controlFn(aControl);\n    }\n  }\n\n  private mergeFields(caseFields: CaseField[], formFields: object, mergeFunction: (field: CaseField, result: object) => void): object {\n    const result: object = FieldsUtils.cloneObject(formFields);\n    caseFields.forEach(field => {\n      mergeFunction(field, result);\n      if (field.field_type && field.field_type.complex_fields && field.field_type.complex_fields.length > 0) {\n        result[field.id] = this.mergeFields(field.field_type.complex_fields, result[field.id], mergeFunction);\n      }\n    });\n    return result;\n  }\n}\n"]}