@hmcts/ccd-case-ui-toolkit 7.0.20 → 7.0.21-CVE-fix

package/esm2022/lib/shared/services/form/form-value.service.mjs

@@ -0,0 +1,552 @@
+import { Injectable } from '@angular/core';
+import { FieldsUtils } from '../fields';
+import { FieldTypeSanitiser } from './field-type-sanitiser';
+import * as i0 from "@angular/core";
+import * as i1 from "./field-type-sanitiser";
+export class FormValueService {
+    fieldTypeSanitiser;
+    /**
+     * Gets value of a field based on fieldKey which is a dot separated reference to value and collection index.
+     * There are two exceptions:
+     * 1) In case of a multiselect being identified as a leaf a '---LABEL' suffix is appended to the key and values of that key are returned
+     *      form= { 'list': ['code1', 'code2'],
+     *              'list---LABEL': ['label1', 'label2'] },
+     *      fieldKey=list,
+     *      colIndex=0,
+     *      value=label1, label2
+     * 2) In case of a collection of simple fields is identified as a leaf all values are joined seperated by a comma
+     *      form= { 'collection': [{ 'value': 'value1' }, { 'value': 'value2' }] }
+     *      fieldKey=collection
+     *      colIndex=1
+     *      value=value1, value2
+     *
+     * Other examples:
+     * 1) simple field reference: form={ 'PersonFirstName': 'John' }, fieldKey=PersonFirstName, value=John
+     * 2) complex field reference:
+     *      form= { complex1': { 'simple11': 'value11', 'simple12': 'value12', 'complex2': { 'simple21': 'value21' } }},
+     *      fieldKey=complex1.complex2.simple21
+     *      colIndex=0,
+     *      value=value21
+     * 3) complex field with collection field with complex field reference:
+     *      form= { 'complex1': {
+     *               'collection1': [
+     *               { 'value': {
+     *                   'complex2': {
+     *                     'simple1': 'value1',
+     *                     'complex3': {
+     *                       'complex4': {
+     *                         'simple2': 'value12'
+     *                       }
+     *                     }
+     *                   }
+     *                 }
+     *               },
+     *               { 'value': {
+     *                   'complex2': {
+     *                     'simple1': 'value2',
+     *                     'complex3': {
+     *                       'complex4': {
+     *                         'simple2': 'value21'
+     *                       }
+     *                     }
+     *                   }
+     *                 }
+     *               },
+     *               { 'value': {
+     *                   'complex2': {
+     *                     'simple1': 'value3',
+     *                     'complex3': {
+     *                       'complex4': {
+     *                         'simple2': 'value31'
+     *                       }
+     *                     }
+     *                   }
+     *                 }
+     *               }
+     *             ]}}
+     *      fieldKey=complex1.collection1.complex2.complex3.complex4.simple2
+     *      colIndex=2,
+     *      value=value21
+     * 4) collection of complex types
+     *      form= { 'collection1': [
+     *               { 'value': {'complex1': {
+     *                             'simple1': 'value11',
+     *                             'complex2': {
+     *                               'complex3': {
+     *                                 'simple2': 'value12'
+     *                               }
+     *                             }
+     *                         }}
+     *               },
+     *               { 'value': {'complex1': {
+     *                             'simple1': 'value21',
+     *                             'complex2': {
+     *                               'complex3': {
+     *                                 'simple2': 'value22'
+     *                               }
+     *                             }
+     *                         }}
+     *               },
+     *               { 'value': {'complex1': {
+     *                             'simple1': 'value31',
+     *                             'complex2': {
+     *                               'complex3': {
+     *                                 'simple2': 'value32'
+     *                               }
+     *                             }
+     *                           }}
+     *               }
+     *             ]}
+     *      fieldKey=collection1.complex1.complex2.complex3.simple2
+     *      colIndex=2
+     *      value=value32
+     *
+     * If key is pointing at a complex or collection leaf (not simple, collection of simple or multiselect types) then undefined is returned.
+     * Also no key referring a leaf that is contained within collection will contain index number. The index is passed as an argument to the
+     * method.
+     */
+    static getFieldValue(form, fieldKey, colIndex) {
+        const fieldIds = fieldKey.split('.');
+        const currentFieldId = fieldIds[0];
+        const currentForm = form[currentFieldId];
+        if (FieldsUtils.isMultiSelectValue(currentForm)) {
+            return form[currentFieldId + FieldsUtils.LABEL_SUFFIX].join(', ');
+        }
+        else if (FieldsUtils.isCollectionOfSimpleTypes(currentForm)) {
+            return currentForm.map(fieldValue => fieldValue['value']).join(', ');
+        }
+        else if (FieldsUtils.isCollection(currentForm)) {
+            return this.getFieldValue(currentForm[colIndex]['value'], fieldIds.slice(1).join('.'), colIndex);
+        }
+        else if (FieldsUtils.isNonEmptyObject(currentForm)) {
+            return this.getFieldValue(currentForm, fieldIds.slice(1).join('.'), colIndex);
+        }
+        else {
+            return currentForm;
+        }
+    }
+    /**
+     * A recursive method to remove anything with a `---LABEL` suffix.
+     * @param data The data to recurse through and remove MultiSelect labels.
+     */
+    static removeMultiSelectLabels(data) {
+        if (data && typeof data === 'object') {
+            if (Array.isArray(data)) {
+                for (const item of data) {
+                    FormValueService.removeMultiSelectLabels(item);
+                }
+            }
+            else {
+                const keys = Object.keys(data);
+                for (const key of keys) {
+                    // Have we found one a MultiSelect label?
+                    if (key.indexOf(FieldsUtils.LABEL_SUFFIX) > 0) {
+                        // If so, remove it.
+                        delete data[key];
+                    }
+                    else {
+                        FormValueService.removeMultiSelectLabels(data[key]);
+                    }
+                }
+            }
+        }
+    }
+    static isReadOnly(field) {
+        return field.display_context ? field.display_context.toUpperCase() === 'READONLY' : false;
+    }
+    static isOptional(field) {
+        return field.display_context ? field.display_context.toUpperCase() === 'OPTIONAL' : false;
+    }
+    static isLabel(field) {
+        if (field.field_type) {
+            return field.field_type.type === 'Label';
+        }
+        else {
+            return false;
+        }
+    }
+    static isEmptyData(data) {
+        if (data) {
+            let allEmpty = true;
+            for (const prop of Object.keys(data)) {
+                const value = data[prop];
+                if (value) {
+                    if (typeof (value) === 'object') {
+                        allEmpty = allEmpty && this.isEmptyData(value);
+                    }
+                    else {
+                        allEmpty = false;
+                    }
+                }
+            }
+            return allEmpty;
+        }
+        return true;
+    }
+    /**
+     * Should we clear out optional, empty, complex objects?
+     * @param clearEmpty False property if we simply want to skip it.
+     * @param data The data to assess for "emptiness".
+     * @param field The CaseField that will tell us if this is optional.
+     */
+    static clearOptionalEmpty(clearEmpty, data, field) {
+        if (clearEmpty) {
+            return FormValueService.isOptional(field) && FormValueService.isEmptyData(data);
+        }
+        return false;
+    }
+    constructor(fieldTypeSanitiser) {
+        this.fieldTypeSanitiser = fieldTypeSanitiser;
+    }
+    sanitise(rawValue) {
+        return this.sanitiseObject(rawValue);
+    }
+    sanitiseCaseReference(reference) {
+        // strip non digits
+        const s = reference.replace(/[\D]/g, '');
+        if (s.length > 16) {
+            return s.substr(s.length - 16, 16);
+        }
+        return s;
+    }
+    filterCurrentPageFields(caseFields, editForm) {
+        const cloneForm = JSON.parse(JSON.stringify(editForm));
+        Object.keys(cloneForm['data']).forEach((key) => {
+            if (caseFields.findIndex((element) => element.id === key) < 0) {
+                delete cloneForm['data'][key];
+            }
+        });
+        return cloneForm;
+    }
+    sanitiseDynamicLists(caseFields, editForm) {
+        return this.fieldTypeSanitiser.sanitiseLists(caseFields, editForm.data);
+    }
+    sanitiseObject(rawObject) {
+        if (!rawObject) {
+            return rawObject;
+        }
+        let sanitisedObject = {};
+        const documentFieldKeys = ['document_url', 'document_binary_url', 'document_filename'];
+        for (const key in rawObject) {
+            // If the key is one of documentFieldKeys, it means the field is of Document type. If the value of any of these
+            // properties is null, the entire sanitised object to be returned should be null
+            if (documentFieldKeys.indexOf(key) > -1 && rawObject[key] === null) {
+                sanitisedObject = null;
+                break;
+            }
+            else if ('CaseReference' === key) {
+                sanitisedObject[key] = this.sanitiseValue(this.sanitiseCaseReference(String(rawObject[key])));
+            }
+            else {
+                sanitisedObject[key] = this.sanitiseValue(rawObject[key]);
+                if (Array.isArray(sanitisedObject[key])) {
+                    // If the 'sanitised' array is empty, whereas the original array had 1 or more items
+                    // delete the property from the sanatised object
+                    if (sanitisedObject[key].length === 0 && rawObject[key].length > 0) {
+                        delete sanitisedObject[key];
+                    }
+                }
+            }
+        }
+        return sanitisedObject;
+    }
+    sanitiseArray(rawArray) {
+        if (!rawArray) {
+            return rawArray;
+        }
+        rawArray.forEach(item => {
+            if (item && item.hasOwnProperty('value')) {
+                item.value = this.sanitiseValue(item.value);
+            }
+        });
+        // Filter the array to ensure only truthy values are returned; double-bang operator returns the boolean true/false
+        // association of a value. In addition, if the array contains items with a "value" object property, return only
+        // those whose value object contains non-empty values, including for any descendant objects
+        return rawArray
+            .filter(item => !!item)
+            .filter(item => item.hasOwnProperty('value') ? FieldsUtils.containsNonEmptyValues(item.value) : true);
+    }
+    sanitiseValue(rawValue) {
+        if (Array.isArray(rawValue)) {
+            return this.sanitiseArray(rawValue);
+        }
+        switch (typeof rawValue) {
+            case 'object':
+                return this.sanitiseObject(rawValue);
+            case 'string':
+                return rawValue.trim();
+            case 'number':
+                return String(rawValue);
+            default:
+                return rawValue;
+        }
+    }
+    clearNonCaseFields(data, caseFields) {
+        for (const dataKey in data) {
+            if (!caseFields.find(cf => cf.id === dataKey)) {
+                delete data[dataKey];
+            }
+        }
+    }
+    // TODO refactor so that this and remove unnecessary fields have a common iterator that applies functions to each node visited
+    removeNullLabels(data, caseFields) {
+        if (data && caseFields && caseFields.length > 0) {
+            // check if there is any data at the top level of the form that's not in the caseFields
+            for (const field of caseFields) {
+                if (field.field_type) {
+                    switch (field.field_type.type) {
+                        case 'Label':
+                            // Delete any labels that are null
+                            if ((data[field.id] === null) || (data[field.id] === '')) {
+                                delete data[field.id];
+                            }
+                            break;
+                        case 'Complex':
+                            // Recurse and remove anything unnecessary from within a complex field.
+                            this.removeNullLabels(data[field.id], field.field_type.complex_fields);
+                            break;
+                        case 'Collection':
+                            // Get hold of the collection.
+                            const collection = data[field.id];
+                            // Check if we actually have a collection to work with.
+                            if (collection && Array.isArray(collection)) {
+                                // If this is a collection of complex object, we need to iterate through
+                                // and clear them out.
+                                if (field.field_type.collection_field_type.type === 'Complex') {
+                                    // Iterate through the elements and remove any unnecessary fields within.
+                                    for (const item of collection) {
+                                        this.removeNullLabels(item, field.field_type.collection_field_type.complex_fields);
+                                        this.removeNullLabels(item.value, field.field_type.collection_field_type.complex_fields);
+                                    }
+                                }
+                            }
+                            break;
+                        default:
+                            break;
+                    }
+                }
+            }
+        }
+    }
+    // TODO refactor so that this and remove unnecessary fields have a common iterator that applies functions to each node visited
+    removeEmptyDocuments(data, caseFields) {
+        if (data && caseFields && caseFields.length > 0) {
+            // check if there is any data at the top level of the form that's not in the caseFields
+            for (const field of caseFields) {
+                if (field.field_type) {
+                    switch (field.field_type.type) {
+                        case 'Complex':
+                            // Recurse and remove any empty documents from within a complex field.
+                            this.removeEmptyDocuments(data[field.id], field.field_type.complex_fields);
+                            break;
+                        case 'Collection':
+                            // Get hold of the collection.
+                            const collection = data[field.id];
+                            // Check if we actually have a collection to work with.
+                            if (collection && Array.isArray(collection)) {
+                                // If this is a collection of complex object, we need to iterate through
+                                // and clear out empty documents
+                                if (field.field_type.collection_field_type.type === 'Complex') {
+                                    // Iterate through the elements and remove any empty documents within.
+                                    for (const item of collection) {
+                                        this.removeEmptyDocuments(item, field.field_type.collection_field_type.complex_fields);
+                                        this.removeEmptyDocuments(item.value, field.field_type.collection_field_type.complex_fields);
+                                    }
+                                }
+                            }
+                            break;
+                        case 'Document':
+                            // Ensure this is executed only if the Document field is NOT hidden and is empty of data; hidden Document
+                            // fields are handled by the filterRawFormValues() function in CaseEditSubmit component
+                            if (field.hidden !== true && FormValueService.isEmptyData(data[field.id])) {
+                                delete data[field.id];
+                            }
+                            break;
+                        default:
+                            break;
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Clear out unnecessary fields from a data object, based on an array of CaseFields.
+     * This method is recursive and will call itself if it encounters particular field types.
+     *
+     * @param data The object to be tidied up.
+     * @param caseFields The CaseFields that need to be cleaned up.
+     * @param clearEmpty Whether or not we should clear out empty, optional, complex objects.
+     * @param clearNonCase Whether or not we should clear out non-case fields at the top level.
+     */
+    removeUnnecessaryFields(data, caseFields, clearEmpty = false, clearNonCase = false, fromPreviousPage = false, currentPageCaseFields = []) {
+        if (data && caseFields && caseFields.length > 0) {
+            // check if there is any data at the top level of the form that's not in the caseFields
+            if (clearNonCase) {
+                this.clearNonCaseFields(data, caseFields);
+            }
+            for (const field of caseFields) {
+                if (!FormValueService.isLabel(field) && FormValueService.isReadOnly(field)) {
+                    // Retain anything that is readonly and not a label.
+                    continue;
+                }
+                if (field.hidden === true && field.display_context !== 'HIDDEN' && field.display_context !== 'HIDDEN_TEMP' && field.id !== 'caseLinks' && !field.retain_hidden_value) {
+                    // Delete anything that is hidden (that is NOT readonly), and that
+                    // hasn't had its display_context overridden to make it hidden.
+                    delete data[field.id];
+                }
+                else if (field.field_type) {
+                    switch (field.field_type.type) {
+                        case 'Label':
+                            // Delete any labels.
+                            delete data[field.id];
+                            break;
+                        case 'Document':
+                            if (FormValueService.isEmptyData(data[field.id])) {
+                                delete data[field.id];
+                            }
+                            break;
+                        case 'Complex':
+                            this.removeUnnecessaryFields(data[field.id], field.field_type.complex_fields, clearEmpty);
+                            // Also remove any optional complex objects that are completely empty.
+                            // EUI-4244: Ritesh's fix, passing true instead of clearEmpty.
+                            if (FormValueService.clearOptionalEmpty(true, data[field.id], field)) {
+                                delete data[field.id];
+                            }
+                            if (data[field.id] && FormValueService.isEmptyData(data[field.id]) && fromPreviousPage
+                                && currentPageCaseFields.findIndex((cField) => cField.id === field.id) === -1) {
+                                delete data[field.id];
+                            }
+                            break;
+                        case 'Collection':
+                            // Check for valid collection data
+                            this.removeInvalidCollectionData(data, field);
+                            // Get hold of the collection.
+                            const collection = data[field.id];
+                            // Check if we actually have a collection to work with.
+                            if (collection && Array.isArray(collection)) {
+                                // If this is a collection of complex object, we need to iterate through
+                                // and clear them out.
+                                if (field.field_type.collection_field_type.type === 'Complex') {
+                                    // Iterate through the elements and remove any unnecessary fields within.
+                                    for (const item of collection) {
+                                        this.removeUnnecessaryFields(item, field.field_type.collection_field_type.complex_fields, clearEmpty);
+                                        this.removeUnnecessaryFields(item.value, field.field_type.collection_field_type.complex_fields, false);
+                                    }
+                                }
+                            }
+                            break;
+                        default:
+                            break;
+                    }
+                }
+            }
+        }
+        // Clear out any MultiSelect labels.
+        FormValueService.removeMultiSelectLabels(data);
+    }
+    removeInvalidCollectionData(data, field) {
+        if (data[field.id] && data[field.id].length > 0) {
+            for (const objCollection of data[field.id]) {
+                if (Object.keys(objCollection).length === 1 && Object.keys(objCollection).indexOf('id') > -1) {
+                    data[field.id] = [];
+                }
+            }
+        }
+    }
+    /**
+     * Remove any empty collection fields where a value of greater than zero is specified in the field's {@link FieldType}
+     * `min` attribute.
+     *
+     * @param data The object tree of form values on which to perform the removal
+     * @param caseFields The list of underlying {@link CaseField} domain model objects for each field
+     */
+    removeEmptyCollectionsWithMinValidation(data, caseFields) {
+        if (data && caseFields && caseFields.length > 0) {
+            for (const field of caseFields) {
+                if (field.field_type.type === 'Collection' && typeof field.field_type.min === 'number' && field.field_type.min > 0 &&
+                    data[field.id] && Array.isArray(data[field.id]) && data[field.id].length === 0) {
+                    delete data[field.id];
+                }
+            }
+        }
+    }
+    /**
+     * Remove from the top level of the form data any case fields of a given type or types that are not intended to be
+     * persisted. This function is intended to remove "special" case field types from the data, such as FlagLauncher or
+     * ComponentLauncher fields.
+     *
+     * @param data The object tree of form values on which to perform the removal at the top level only
+     * @param caseFields The list of underlying {@link CaseField} domain model objects for each field
+     * @param types An array of one or more field types
+     */
+    removeCaseFieldsOfType(data, caseFields, types) {
+        if (data && caseFields && caseFields.length > 0 && types.length > 0) {
+            const caseFieldsToRemove = caseFields.filter(caseField => FieldsUtils.isCaseFieldOfType(caseField, types));
+            for (const caseField of caseFieldsToRemove) {
+                delete data[caseField.id];
+            }
+        }
+    }
+    /**
+     * Re-populate the form data from the values held in the case fields. This is necessary in order to pick up, for
+     * each `Flags` field, any flag details data not currently present.
+     *
+     * `Flags` fields may be contained in other `CaseField` instances, either as a sub-field of a Complex field, or
+     * fields in a collection (or sub-fields of Complex fields in a collection). Therefore, it is necessary to
+     * iterate through all `CaseField`s.
+     *
+     * @param data The object tree of form values on which to perform the data population
+     * @param caseFields The list of underlying {@link CaseField} domain model objects for each field
+     */
+    repopulateFormDataFromCaseFieldValues(data, caseFields) {
+        if (data && caseFields && caseFields.length > 0 &&
+            caseFields.findIndex(caseField => FieldsUtils.isCaseFieldOfType(caseField, ['FlagLauncher'])) > -1) {
+            // Ignore the FlagLauncher CaseField because it does not hold any values
+            caseFields.filter(caseField => !FieldsUtils.isCaseFieldOfType(caseField, ['FlagLauncher']))
+                .forEach(caseField => {
+                // Ensure that the data object is populated for all CaseField keys it contains, even if for a given
+                // CaseField key, the data object has a falsy value (hence the use of hasOwnProperty() for the check below)
+                // See https://tools.hmcts.net/jira/browse/EUI-7377
+                if (data.hasOwnProperty(caseField.id) && caseField.value) {
+                    // Create new object for the CaseField ID within the data object, if necessary (i.e. if the current value
+                    // is falsy); populate from the corresponding CaseField
+                    if (!data[caseField.id]) {
+                        data[caseField.id] = {};
+                        Object.keys(caseField.value).forEach((key) => data[caseField.id][key] = caseField.value[key]);
+                    }
+                    else {
+                        // Copy all values from the corresponding CaseField; this ensures all nested flag data (for example, a
+                        // Flags field within a Complex field or a collection of Complex fields) is copied across
+                        Object.keys(data[caseField.id]).forEach((key) => {
+                            if (caseField.value.hasOwnProperty(key)) {
+                                data[caseField.id][key] = caseField.value[key];
+                            }
+                        });
+                    }
+                }
+            });
+        }
+    }
+    /**
+     * Populate the linked cases from the data held in its corresponding CaseField.
+     *
+     * @param data The object tree of form values on which to perform the data population
+     * @param caseFields The list of underlying {@link CaseField} domain model objects for each field
+     */
+    populateLinkedCasesDetailsFromCaseFields(data, caseFields) {
+        if (data && caseFields && caseFields.length > 0) {
+            caseFields.filter(caseField => !FieldsUtils.isCaseFieldOfType(caseField, ['ComponentLauncher']))
+                .forEach(caseField => {
+                if (data.hasOwnProperty('caseLinks') && caseField.value) {
+                    data[caseField.id] = caseField.value;
+                }
+            });
+        }
+    }
+    static ɵfac = function FormValueService_Factory(t) { return new (t || FormValueService)(i0.ɵɵinject(i1.FieldTypeSanitiser)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: FormValueService, factory: FormValueService.ɵfac });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FormValueService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.FieldTypeSanitiser }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-value.service.js","sourceRoot":"","sources":["../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/services/form/form-value.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { CaseField, FieldTypeEnum } from '../../domain';\nimport { FieldsUtils } from '../fields';\nimport { FieldTypeSanitiser } from './field-type-sanitiser';\n\n@Injectable()\nexport class FormValueService {\n  /**\n   * Gets value of a field based on fieldKey which is a dot separated reference to value and collection index.\n   * There are two exceptions:\n   * 1) In case of a multiselect being identified as a leaf a '---LABEL' suffix is appended to the key and values of that key are returned\n   *      form= { 'list': ['code1', 'code2'],\n   *              'list---LABEL': ['label1', 'label2'] },\n   *      fieldKey=list,\n   *      colIndex=0,\n   *      value=label1, label2\n   * 2) In case of a collection of simple fields is identified as a leaf all values are joined seperated by a comma\n   *      form= { 'collection': [{ 'value': 'value1' }, { 'value': 'value2' }] }\n   *      fieldKey=collection\n   *      colIndex=1\n   *      value=value1, value2\n   *\n   * Other examples:\n   * 1) simple field reference: form={ 'PersonFirstName': 'John' }, fieldKey=PersonFirstName, value=John\n   * 2) complex field reference:\n   *      form= { complex1': { 'simple11': 'value11', 'simple12': 'value12', 'complex2': { 'simple21': 'value21' } }},\n   *      fieldKey=complex1.complex2.simple21\n   *      colIndex=0,\n   *      value=value21\n   * 3) complex field with collection field with complex field reference:\n   *      form= { 'complex1': {\n   *               'collection1': [\n   *               { 'value': {\n   *                   'complex2': {\n   *                     'simple1': 'value1',\n   *                     'complex3': {\n   *                       'complex4': {\n   *                         'simple2': 'value12'\n   *                       }\n   *                     }\n   *                   }\n   *                 }\n   *               },\n   *               { 'value': {\n   *                   'complex2': {\n   *                     'simple1': 'value2',\n   *                     'complex3': {\n   *                       'complex4': {\n   *                         'simple2': 'value21'\n   *                       }\n   *                     }\n   *                   }\n   *                 }\n   *               },\n   *               { 'value': {\n   *                   'complex2': {\n   *                     'simple1': 'value3',\n   *                     'complex3': {\n   *                       'complex4': {\n   *                         'simple2': 'value31'\n   *                       }\n   *                     }\n   *                   }\n   *                 }\n   *               }\n   *             ]}}\n   *      fieldKey=complex1.collection1.complex2.complex3.complex4.simple2\n   *      colIndex=2,\n   *      value=value21\n   * 4) collection of complex types\n   *      form= { 'collection1': [\n   *               { 'value': {'complex1': {\n   *                             'simple1': 'value11',\n   *                             'complex2': {\n   *                               'complex3': {\n   *                                 'simple2': 'value12'\n   *                               }\n   *                             }\n   *                         }}\n   *               },\n   *               { 'value': {'complex1': {\n   *                             'simple1': 'value21',\n   *                             'complex2': {\n   *                               'complex3': {\n   *                                 'simple2': 'value22'\n   *                               }\n   *                             }\n   *                         }}\n   *               },\n   *               { 'value': {'complex1': {\n   *                             'simple1': 'value31',\n   *                             'complex2': {\n   *                               'complex3': {\n   *                                 'simple2': 'value32'\n   *                               }\n   *                             }\n   *                           }}\n   *               }\n   *             ]}\n   *      fieldKey=collection1.complex1.complex2.complex3.simple2\n   *      colIndex=2\n   *      value=value32\n   *\n   * If key is pointing at a complex or collection leaf (not simple, collection of simple or multiselect types) then undefined is returned.\n   * Also no key referring a leaf that is contained within collection will contain index number. The index is passed as an argument to the\n   * method.\n   */\n  public static getFieldValue(form, fieldKey, colIndex) {\n    const fieldIds = fieldKey.split('.');\n    const currentFieldId = fieldIds[0];\n    const currentForm = form[currentFieldId];\n    if (FieldsUtils.isMultiSelectValue(currentForm)) {\n      return form[currentFieldId + FieldsUtils.LABEL_SUFFIX].join(', ');\n    } else if (FieldsUtils.isCollectionOfSimpleTypes(currentForm)) {\n      return currentForm.map(fieldValue => fieldValue['value']).join(', ');\n    } else if (FieldsUtils.isCollection(currentForm)) {\n      return this.getFieldValue(currentForm[colIndex]['value'], fieldIds.slice(1).join('.'), colIndex);\n    } else if (FieldsUtils.isNonEmptyObject(currentForm)) {\n      return this.getFieldValue(currentForm, fieldIds.slice(1).join('.'), colIndex);\n    } else {\n      return currentForm;\n    }\n  }\n\n  /**\n   * A recursive method to remove anything with a `---LABEL` suffix.\n   * @param data The data to recurse through and remove MultiSelect labels.\n   */\n  public static removeMultiSelectLabels(data: any): void {\n    if (data && typeof data === 'object') {\n      if (Array.isArray(data)) {\n        for (const item of data) {\n          FormValueService.removeMultiSelectLabels(item);\n        }\n      } else {\n        const keys: string[] = Object.keys(data);\n        for (const key of keys) {\n          // Have we found one a MultiSelect label?\n          if (key.indexOf(FieldsUtils.LABEL_SUFFIX) > 0) {\n            // If so, remove it.\n            delete data[key];\n          } else {\n            FormValueService.removeMultiSelectLabels(data[key]);\n          }\n        }\n      }\n    }\n  }\n\n  private static isReadOnly(field: CaseField): boolean {\n    return field.display_context ? field.display_context.toUpperCase() === 'READONLY' : false;\n  }\n\n  private static isOptional(field: CaseField): boolean {\n    return field.display_context ? field.display_context.toUpperCase() === 'OPTIONAL' : false;\n  }\n\n  private static isLabel(field: CaseField): boolean {\n    if (field.field_type) {\n      return field.field_type.type === 'Label';\n    } else {\n      return false;\n    }\n  }\n\n  private static isEmptyData(data: object): boolean {\n    if (data) {\n      let allEmpty = true;\n      for (const prop of Object.keys(data)) {\n        const value = data[prop];\n        if (value) {\n          if (typeof (value) === 'object') {\n            allEmpty = allEmpty && this.isEmptyData(value);\n          } else {\n            allEmpty = false;\n          }\n        }\n      }\n      return allEmpty;\n    }\n    return true;\n  }\n\n  /**\n   * Should we clear out optional, empty, complex objects?\n   * @param clearEmpty False property if we simply want to skip it.\n   * @param data The data to assess for \"emptiness\".\n   * @param field The CaseField that will tell us if this is optional.\n   */\n  private static clearOptionalEmpty(clearEmpty: boolean, data: object, field: CaseField): boolean {\n    if (clearEmpty) {\n      return FormValueService.isOptional(field) && FormValueService.isEmptyData(data);\n    }\n    return false;\n  }\n\n  constructor(private readonly fieldTypeSanitiser: FieldTypeSanitiser) {\n  }\n\n  public sanitise(rawValue: object): object {\n    return this.sanitiseObject(rawValue);\n  }\n\n  public sanitiseCaseReference(reference: string): string {\n    // strip non digits\n    const s: string = reference.replace(/[\\D]/g, '');\n    if (s.length > 16) {\n      return s.substr(s.length - 16, 16);\n    }\n    return s;\n  }\n\n  public filterCurrentPageFields(caseFields: CaseField[], editForm: any): any {\n    const cloneForm = JSON.parse(JSON.stringify(editForm));\n    Object.keys(cloneForm['data']).forEach((key) => {\n      if (caseFields.findIndex((element) => element.id === key) < 0) {\n        delete cloneForm['data'][key];\n      }\n    });\n    return cloneForm;\n  }\n\n  public sanitiseDynamicLists(caseFields: CaseField[], editForm: any): any {\n    return this.fieldTypeSanitiser.sanitiseLists(caseFields, editForm.data);\n  }\n\n  private sanitiseObject(rawObject: object): object {\n    if (!rawObject) {\n      return rawObject;\n    }\n\n    let sanitisedObject = {};\n    const documentFieldKeys = ['document_url', 'document_binary_url', 'document_filename'];\n    for (const key in rawObject) {\n      // If the key is one of documentFieldKeys, it means the field is of Document type. If the value of any of these\n      // properties is null, the entire sanitised object to be returned should be null\n      if (documentFieldKeys.indexOf(key) > -1 && rawObject[key] === null) {\n        sanitisedObject = null;\n        break;\n      } else if ('CaseReference' === key) {\n        sanitisedObject[key] = this.sanitiseValue(this.sanitiseCaseReference(String(rawObject[key])));\n      } else {\n        sanitisedObject[key] = this.sanitiseValue(rawObject[key]);\n        if (Array.isArray(sanitisedObject[key])) {\n          // If the 'sanitised' array is empty, whereas the original array had 1 or more items\n          // delete the property from the sanatised object\n          if (sanitisedObject[key].length === 0 && rawObject[key].length > 0) {\n            delete sanitisedObject[key];\n          }\n        }\n      }\n    }\n    return sanitisedObject;\n  }\n\n  private sanitiseArray(rawArray: any[]): any[] {\n    if (!rawArray) {\n      return rawArray;\n    }\n\n    rawArray.forEach(item => {\n      if (item && item.hasOwnProperty('value')) {\n        item.value = this.sanitiseValue(item.value);\n      }\n    });\n\n    // Filter the array to ensure only truthy values are returned; double-bang operator returns the boolean true/false\n    // association of a value. In addition, if the array contains items with a \"value\" object property, return only\n    // those whose value object contains non-empty values, including for any descendant objects\n    return rawArray\n      .filter(item => !!item)\n      .filter(item => item.hasOwnProperty('value') ? FieldsUtils.containsNonEmptyValues(item.value) : true);\n  }\n\n  private sanitiseValue(rawValue: any): any {\n    if (Array.isArray(rawValue)) {\n      return this.sanitiseArray(rawValue);\n    }\n\n    switch (typeof rawValue) {\n      case 'object':\n        return this.sanitiseObject(rawValue);\n      case 'string':\n        return rawValue.trim();\n      case 'number':\n        return String(rawValue);\n      default:\n        return rawValue;\n    }\n  }\n\n  public clearNonCaseFields(data: object, caseFields: CaseField[]) {\n    for (const dataKey in data) {\n      if (!caseFields.find(cf => cf.id === dataKey)) {\n        delete data[dataKey];\n      }\n    }\n  }\n\n  // TODO refactor so that this and remove unnecessary fields have a common iterator that applies functions to each node visited\n  public removeNullLabels(data: object, caseFields: CaseField[]) {\n    if (data && caseFields && caseFields.length > 0) {\n      // check if there is any data at the top level of the form that's not in the caseFields\n      for (const field of caseFields) {\n        if (field.field_type) {\n          switch (field.field_type.type) {\n            case 'Label':\n              // Delete any labels that are null\n              if ((data[field.id] === null) || (data[field.id] === '')) {\n                delete data[field.id];\n              }\n              break;\n            case 'Complex':\n              // Recurse and remove anything unnecessary from within a complex field.\n              this.removeNullLabels(data[field.id], field.field_type.complex_fields);\n              break;\n            case 'Collection':\n              // Get hold of the collection.\n              const collection = data[field.id];\n              // Check if we actually have a collection to work with.\n              if (collection && Array.isArray(collection)) {\n                // If this is a collection of complex object, we need to iterate through\n                // and clear them out.\n                if (field.field_type.collection_field_type.type === 'Complex') {\n                  // Iterate through the elements and remove any unnecessary fields within.\n                  for (const item of collection) {\n                    this.removeNullLabels(item, field.field_type.collection_field_type.complex_fields);\n                    this.removeNullLabels(item.value, field.field_type.collection_field_type.complex_fields);\n                  }\n                }\n              }\n              break;\n            default:\n              break;\n          }\n        }\n      }\n    }\n  }\n  // TODO refactor so that this and remove unnecessary fields have a common iterator that applies functions to each node visited\n  public removeEmptyDocuments(data: object, caseFields: CaseField[]) {\n    if (data && caseFields && caseFields.length > 0) {\n      // check if there is any data at the top level of the form that's not in the caseFields\n      for (const field of caseFields) {\n        if (field.field_type) {\n          switch (field.field_type.type) {\n            case 'Complex':\n              // Recurse and remove any empty documents from within a complex field.\n              this.removeEmptyDocuments(data[field.id], field.field_type.complex_fields);\n              break;\n            case 'Collection':\n              // Get hold of the collection.\n              const collection = data[field.id];\n              // Check if we actually have a collection to work with.\n              if (collection && Array.isArray(collection)) {\n                // If this is a collection of complex object, we need to iterate through\n                // and clear out empty documents\n                if (field.field_type.collection_field_type.type === 'Complex') {\n                  // Iterate through the elements and remove any empty documents within.\n                  for (const item of collection) {\n                    this.removeEmptyDocuments(item, field.field_type.collection_field_type.complex_fields);\n                    this.removeEmptyDocuments(item.value, field.field_type.collection_field_type.complex_fields);\n                  }\n                }\n              }\n              break;\n            case 'Document':\n              // Ensure this is executed only if the Document field is NOT hidden and is empty of data; hidden Document\n              // fields are handled by the filterRawFormValues() function in CaseEditSubmit component\n              if (field.hidden !== true && FormValueService.isEmptyData(data[field.id])) {\n                delete data[field.id];\n              }\n              break;\n            default:\n              break;\n          }\n        }\n      }\n    }\n  }\n  /**\n   * Clear out unnecessary fields from a data object, based on an array of CaseFields.\n   * This method is recursive and will call itself if it encounters particular field types.\n   *\n   * @param data The object to be tidied up.\n   * @param caseFields The CaseFields that need to be cleaned up.\n   * @param clearEmpty Whether or not we should clear out empty, optional, complex objects.\n   * @param clearNonCase Whether or not we should clear out non-case fields at the top level.\n   */\n  public removeUnnecessaryFields(data: object, caseFields: CaseField[], clearEmpty = false, clearNonCase = false,\n    fromPreviousPage = false, currentPageCaseFields = []): void {\n    if (data && caseFields && caseFields.length > 0) {\n      // check if there is any data at the top level of the form that's not in the caseFields\n      if (clearNonCase) {\n        this.clearNonCaseFields(data, caseFields);\n      }\n      for (const field of caseFields) {\n        if (!FormValueService.isLabel(field) && FormValueService.isReadOnly(field)) {\n          // Retain anything that is readonly and not a label.\n          continue;\n        }\n        if (field.hidden === true && field.display_context !== 'HIDDEN' && field.display_context !== 'HIDDEN_TEMP' && field.id !== 'caseLinks' && !field.retain_hidden_value) {\n          // Delete anything that is hidden (that is NOT readonly), and that\n          // hasn't had its display_context overridden to make it hidden.\n          delete data[field.id];\n        } else if (field.field_type) {\n          switch (field.field_type.type) {\n            case 'Label':\n              // Delete any labels.\n              delete data[field.id];\n              break;\n            case 'Document':\n              if (FormValueService.isEmptyData(data[field.id])) {\n                delete data[field.id];\n              }\n              break;\n            case 'Complex':\n              this.removeUnnecessaryFields(data[field.id], field.field_type.complex_fields, clearEmpty);\n              // Also remove any optional complex objects that are completely empty.\n              // EUI-4244: Ritesh's fix, passing true instead of clearEmpty.\n              if (FormValueService.clearOptionalEmpty(true, data[field.id], field)) {\n                delete data[field.id];\n              }\n              if (data[field.id] && FormValueService.isEmptyData(data[field.id]) && fromPreviousPage\n                && currentPageCaseFields.findIndex((cField: any) => cField.id === field.id) === -1) {\n                delete data[field.id];\n              }\n              break;\n            case 'Collection':\n              // Check for valid collection data\n              this.removeInvalidCollectionData(data, field);\n              // Get hold of the collection.\n              const collection = data[field.id];\n              // Check if we actually have a collection to work with.\n              if (collection && Array.isArray(collection)) {\n                // If this is a collection of complex object, we need to iterate through\n                // and clear them out.\n                if (field.field_type.collection_field_type.type === 'Complex') {\n                  // Iterate through the elements and remove any unnecessary fields within.\n                  for (const item of collection) {\n                    this.removeUnnecessaryFields(item, field.field_type.collection_field_type.complex_fields, clearEmpty);\n                    this.removeUnnecessaryFields(item.value, field.field_type.collection_field_type.complex_fields, false);\n                  }\n                }\n              }\n              break;\n            default:\n              break;\n          }\n        }\n      }\n    }\n\n    // Clear out any MultiSelect labels.\n    FormValueService.removeMultiSelectLabels(data);\n  }\n\n  public removeInvalidCollectionData(data: object, field: CaseField) {\n    if (data[field.id] && data[field.id].length > 0) {\n      for (const objCollection of data[field.id]) {\n        if (Object.keys(objCollection).length === 1 && Object.keys(objCollection).indexOf('id') > -1) {\n          data[field.id] = [];\n        }\n      }\n    }\n  }\n\n  /**\n   * Remove any empty collection fields where a value of greater than zero is specified in the field's {@link FieldType}\n   * `min` attribute.\n   *\n   * @param data The object tree of form values on which to perform the removal\n   * @param caseFields The list of underlying {@link CaseField} domain model objects for each field\n   */\n  public removeEmptyCollectionsWithMinValidation(data: object, caseFields: CaseField[]): void {\n    if (data && caseFields && caseFields.length > 0) {\n      for (const field of caseFields) {\n        if (field.field_type.type === 'Collection' && typeof field.field_type.min === 'number' && field.field_type.min > 0 &&\n          data[field.id] && Array.isArray(data[field.id]) && data[field.id].length === 0) {\n          delete data[field.id];\n        }\n      }\n    }\n  }\n\n  /**\n   * Remove from the top level of the form data any case fields of a given type or types that are not intended to be\n   * persisted. This function is intended to remove \"special\" case field types from the data, such as FlagLauncher or\n   * ComponentLauncher fields.\n   *\n   * @param data The object tree of form values on which to perform the removal at the top level only\n   * @param caseFields The list of underlying {@link CaseField} domain model objects for each field\n   * @param types An array of one or more field types\n   */\n  public removeCaseFieldsOfType(data: object, caseFields: CaseField[], types: FieldTypeEnum[]): void {\n    if (data && caseFields && caseFields.length > 0 && types.length > 0) {\n      const caseFieldsToRemove = caseFields.filter(caseField => FieldsUtils.isCaseFieldOfType(caseField, types));\n      for (const caseField of caseFieldsToRemove) {\n        delete data[caseField.id];\n      }\n    }\n  }\n\n  /**\n   * Re-populate the form data from the values held in the case fields. This is necessary in order to pick up, for\n   * each `Flags` field, any flag details data not currently present.\n   *\n   * `Flags` fields may be contained in other `CaseField` instances, either as a sub-field of a Complex field, or\n   * fields in a collection (or sub-fields of Complex fields in a collection). Therefore, it is necessary to\n   * iterate through all `CaseField`s.\n   *\n   * @param data The object tree of form values on which to perform the data population\n   * @param caseFields The list of underlying {@link CaseField} domain model objects for each field\n   */\n  public repopulateFormDataFromCaseFieldValues(data: object, caseFields: CaseField[]): void {\n    if (data && caseFields && caseFields.length > 0 &&\n      caseFields.findIndex(caseField => FieldsUtils.isCaseFieldOfType(caseField, ['FlagLauncher'])) > -1) {\n      // Ignore the FlagLauncher CaseField because it does not hold any values\n      caseFields.filter(caseField => !FieldsUtils.isCaseFieldOfType(caseField, ['FlagLauncher']))\n        .forEach(caseField => {\n          // Ensure that the data object is populated for all CaseField keys it contains, even if for a given\n          // CaseField key, the data object has a falsy value (hence the use of hasOwnProperty() for the check below)\n          // See https://tools.hmcts.net/jira/browse/EUI-7377\n          if (data.hasOwnProperty(caseField.id) && caseField.value) {\n            // Create new object for the CaseField ID within the data object, if necessary (i.e. if the current value\n            // is falsy); populate from the corresponding CaseField\n            if (!data[caseField.id]) {\n              data[caseField.id] = {};\n              Object.keys(caseField.value).forEach((key) => data[caseField.id][key] = caseField.value[key]);\n            } else {\n              // Copy all values from the corresponding CaseField; this ensures all nested flag data (for example, a\n              // Flags field within a Complex field or a collection of Complex fields) is copied across\n              Object.keys(data[caseField.id]).forEach((key) => {\n                if (caseField.value.hasOwnProperty(key)) {\n                  data[caseField.id][key] = caseField.value[key];\n                }\n              });\n            }\n          }\n        });\n    }\n  }\n\n  /**\n   * Populate the linked cases from the data held in its corresponding CaseField.\n   *\n   * @param data The object tree of form values on which to perform the data population\n   * @param caseFields The list of underlying {@link CaseField} domain model objects for each field\n   */\n  public populateLinkedCasesDetailsFromCaseFields(data: object, caseFields: CaseField[]): void {\n    if (data && caseFields && caseFields.length > 0) {\n      caseFields.filter(caseField => !FieldsUtils.isCaseFieldOfType(caseField, ['ComponentLauncher']))\n        .forEach(caseField => {\n          if (data.hasOwnProperty('caseLinks') && caseField.value) {\n            data[caseField.id] = caseField.value;\n          }\n        });\n    }\n  }\n}\n"]}