@hmcts/ccd-case-ui-toolkit 5.0.3-angular11-upgrade → 5.0.4-angular11-upgrade

package/dist/ccd-case-ui-toolkit/esm2015/lib/shared/services/fields/fields.utils.js

@@ -0,0 +1,334 @@
+import { CurrencyPipe } from '@angular/common';
+import { Injectable } from '@angular/core';
+import { FormArray, FormControl, FormGroup } from '@angular/forms';
+import { plainToClassFromExist } from 'class-transformer';
+import { DatePipe } from '../../components/palette/utils/date.pipe';
+import { CaseField } from '../../domain/definition/case-field.model';
+import { FormatTranslatorService } from '../case-fields/format-translator.service';
+import * as i0 from "@angular/core";
+// @dynamic
+export class FieldsUtils {
+    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;
+    }
+    static getType(elem) {
+        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.
+        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;
+        }
+    }
+    /**
+     * 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 = Object.assign({}, value);
+                            field.formatted_value = Object.assign(Object.assign({}, 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;
+    }
+    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;
+    }
+}
+// EUI-4244. 3 dashes instead of 1 to make this less likely to clash with a real field.
+FieldsUtils.LABEL_SUFFIX = '---LABEL';
+// Handling of Dynamic Lists in Complex Types
+FieldsUtils.SERVER_RESPONSE_FIELD_TYPE_COLLECTION = 'Collection';
+FieldsUtils.SERVER_RESPONSE_FIELD_TYPE_COMPLEX = 'Complex';
+FieldsUtils.SERVER_RESPONSE_FIELD_TYPE_DYNAMIC_LIST_TYPE = ['DynamicList', 'DynamicRadioList'];
+FieldsUtils.currencyPipe = new CurrencyPipe('en-GB');
+FieldsUtils.datePipe = new DatePipe(new FormatTranslatorService());
+FieldsUtils.DEFAULT_MERGE_FUNCTION = function mergeFunction(field, result) {
+    if (!result.hasOwnProperty(field.id)) {
+        result[field.id] = field.value;
+    }
+};
+FieldsUtils.LABEL_MERGE_FUNCTION = function mergeFunction(field, result) {
+    if (!result.hasOwnProperty(field.id)) {
+        result[field.id] = field.value;
+    }
+    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) => {
+                    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;
+        }
+    }
+};
+FieldsUtils.ɵfac = function FieldsUtils_Factory(t) { return new (t || FieldsUtils)(); };
+FieldsUtils.ɵprov = i0.ɵɵdefineInjectable({ token: FieldsUtils, factory: FieldsUtils.ɵfac });
+(function () { (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';\n\nimport { WizardPage } from '../../components/case-editor/domain/wizard-page.model';\nimport { AbstractFormFieldComponent } from '../../components/palette/base-field/abstract-form-field.component';\nimport { DatePipe } from '../../components/palette/utils/date.pipe';\nimport { CaseEventTrigger } from '../../domain/case-view/case-event-trigger.model';\nimport { CaseTab } from '../../domain/case-view/case-tab.model';\nimport { CaseView } from '../../domain/case-view/case-view.model';\nimport { CaseField } from '../../domain/definition/case-field.model';\nimport { FieldTypeEnum } from '../../domain/definition/field-type-enum.model';\nimport { FieldType } from '../../domain/definition/field-type.model';\nimport { FixedListItem } from '../../domain/definition/fixed-list-item.model';\nimport { Predicate } from '../../domain/predicate.model';\nimport { FormatTranslatorService } from '../case-fields/format-translator.service';\n\n// @dynamic\n@Injectable()\nexport class FieldsUtils {\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  private static readonly currencyPipe: CurrencyPipe = new CurrencyPipe('en-GB');\n  private static readonly datePipe: DatePipe = new DatePipe(new FormatTranslatorService());\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    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\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.hasOwnProperty(field.id)) {\n      result[field.id] = field.value;\n    }\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            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\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 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"]}

package/dist/ccd-case-ui-toolkit/esm2015/lib/shared/services/fields/index.js

@@ -0,0 +1,3 @@
+export * from './fields.utils';
+export * from './fields.purger';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jY2QtY2FzZS11aS10b29sa2l0L3NyYy9saWIvc2hhcmVkL3NlcnZpY2VzL2ZpZWxkcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsaUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2ZpZWxkcy51dGlscyc7XG5leHBvcnQgKiBmcm9tICcuL2ZpZWxkcy5wdXJnZXInO1xuIl19

package/dist/ccd-case-ui-toolkit/esm2015/lib/shared/services/form/field-type-sanitiser.js

@@ -0,0 +1,75 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FieldTypeSanitiser {
+    /**
+     * This method finds dynamiclists in a form and replaces their string
+     * values, with a JSON object, as below:
+     * From: 'xyz'
+     * To  : {
+     *   value: { code:'xyz', label:'XYZ' },
+     *   list_items: [
+     *     { code:'xyz', label:'XYZ'},
+     *     { code:'abc', label:'ABC'}
+     *   ]
+     * }
+     * @param caseFields The CaseFields to assess.
+     * @param data The data in the form.
+     */
+    sanitiseLists(caseFields, data) {
+        if (!data || !caseFields) {
+            return;
+        }
+        caseFields.forEach(caseField => {
+            switch (caseField.field_type.type) {
+                case FieldTypeSanitiser.FIELD_TYPE_DYNAMIC_RADIO_LIST:
+                case FieldTypeSanitiser.FIELD_TYPE_DYNAMIC_LIST:
+                    this.convertStringToDynamicListOutput(caseField, data);
+                    break;
+                case FieldTypeSanitiser.FIELD_TYPE_COMPLEX:
+                    this.sanitiseLists(caseField.field_type.complex_fields, data[caseField.id]);
+                    break;
+                case FieldTypeSanitiser.FIELD_TYPE_COLLECTION:
+                    if (Array.isArray(data[caseField.id])) {
+                        data[caseField.id].forEach((formElement) => {
+                            this.sanitiseLists(caseField.field_type.collection_field_type.complex_fields, formElement.value);
+                        });
+                    }
+                    break;
+            }
+        });
+    }
+    convertStringToDynamicListOutput(field, data) {
+        const stringValue = data[field.id];
+        if (typeof stringValue === 'string') {
+            const listItems = this.getListItems(field);
+            const matches = listItems.filter(value => value.code === stringValue);
+            if (matches && matches.length > 0) {
+                data[field.id] = {
+                    value: matches[0],
+                    list_items: listItems
+                };
+            }
+        }
+    }
+    getListItems(field) {
+        if (field) {
+            if (field.list_items) {
+                return field.list_items;
+            }
+            if (field.formatted_value && field.formatted_value.list_items) {
+                return field.formatted_value.list_items;
+            }
+        }
+        return [];
+    }
+}
+FieldTypeSanitiser.FIELD_TYPE_COMPLEX = 'Complex';
+FieldTypeSanitiser.FIELD_TYPE_COLLECTION = 'Collection';
+FieldTypeSanitiser.FIELD_TYPE_DYNAMIC_LIST = 'DynamicList';
+FieldTypeSanitiser.FIELD_TYPE_DYNAMIC_RADIO_LIST = 'DynamicRadioList';
+FieldTypeSanitiser.ɵfac = function FieldTypeSanitiser_Factory(t) { return new (t || FieldTypeSanitiser)(); };
+FieldTypeSanitiser.ɵprov = i0.ɵɵdefineInjectable({ token: FieldTypeSanitiser, factory: FieldTypeSanitiser.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FieldTypeSanitiser, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ccd-case-ui-toolkit/esm2015/lib/shared/services/form/form-error.service.js

@@ -0,0 +1,46 @@
+import { Injectable } from '@angular/core';
+import { FormArray } from '@angular/forms';
+import * as i0 from "@angular/core";
+export class FormErrorService {
+    mapFieldErrors(errors, form, errorKey) {
+        errors.forEach(error => {
+            const formControl = this.getFormControl(form, error.id);
+            if (formControl) {
+                formControl.setErrors({
+                    [errorKey]: error.message
+                });
+            }
+        });
+    }
+    getFormControl(form, fieldId) {
+        const fields = fieldId.split('.');
+        let group = form;
+        let inArray = false;
+        let control;
+        fields.every((field, index) => {
+            if (index === fields.length - 1) {
+                control = group.controls[field];
+            }
+            else {
+                group = group.controls[field];
+                if (inArray && group.controls['value']) {
+                    group = group.controls['value'];
+                }
+                if (group && group.constructor && FormArray.name === group.constructor.name) {
+                    inArray = true;
+                }
+                else {
+                    inArray = false;
+                }
+            }
+            return !!group;
+        });
+        return control;
+    }
+}
+FormErrorService.ɵfac = function FormErrorService_Factory(t) { return new (t || FormErrorService)(); };
+FormErrorService.ɵprov = i0.ɵɵdefineInjectable({ token: FormErrorService, factory: FormErrorService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FormErrorService, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ccd-case-ui-toolkit/esm2015/lib/shared/services/form/form-validators.service.js

@@ -0,0 +1,56 @@
+import { Injectable } from '@angular/core';
+import { Validators } from '@angular/forms';
+import { Constants } from '../../commons/constants';
+import * as i0 from "@angular/core";
+export class FormValidatorsService {
+    static addValidators(caseField, control) {
+        if (caseField.display_context === Constants.MANDATORY &&
+            FormValidatorsService.CUSTOM_VALIDATED_TYPES.indexOf(caseField.field_type.type) === -1) {
+            const validators = [Validators.required];
+            if (caseField.field_type.type === 'Text') {
+                if (caseField.field_type.regular_expression) {
+                    validators.push(Validators.pattern(caseField.field_type.regular_expression));
+                }
+                else {
+                    validators.push(this.emptyValidator());
+                }
+                if (caseField.field_type.min && (typeof caseField.field_type.min === 'number')) {
+                    validators.push(Validators.minLength(caseField.field_type.min));
+                }
+                if (caseField.field_type.max && (typeof caseField.field_type.max === 'number')) {
+                    validators.push(Validators.maxLength(caseField.field_type.max));
+                }
+            }
+            if (control.validator) {
+                validators.push(control.validator);
+            }
+            control.setValidators(validators);
+        }
+        return control;
+    }
+    static emptyValidator() {
+        const validator = (control) => {
+            if (control && control.value && control.value.toString().trim().length === 0) {
+                return { required: {} };
+            }
+            return null;
+        };
+        return validator;
+    }
+    // TODO: Strip this out as it's only here for the moment because
+    // the service is being injected all over the place but it doesn't
+    // need to be as FormValidatorsService.addValidators is perfectly
+    // happy being static.
+    addValidators(caseField, control) {
+        return FormValidatorsService.addValidators(caseField, control);
+    }
+}
+FormValidatorsService.CUSTOM_VALIDATED_TYPES = [
+    'Date', 'MoneyGBP', 'Label'
+];
+FormValidatorsService.ɵfac = function FormValidatorsService_Factory(t) { return new (t || FormValidatorsService)(); };
+FormValidatorsService.ɵprov = i0.ɵɵdefineInjectable({ token: FormValidatorsService, factory: FormValidatorsService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FormValidatorsService, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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