@hmcts/ccd-case-ui-toolkit 7.0.34-angular-upgrade → 7.0.34-pre-release-markdown

package/esm2020/lib/shared/services/form/field-type-sanitiser.mjs

@@ -0,0 +1,91 @@
+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 => {
+            // tslint:disable-next-line:switch-default
+            switch (caseField.field_type.type) {
+                case FieldTypeSanitiser.FIELD_TYPE_DYNAMIC_MULTISELECT_LIST:
+                    this.convertArrayToDynamicListOutput(caseField, data);
+                    break;
+                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;
+            }
+        });
+    }
+    convertArrayToDynamicListOutput(field, data) {
+        const values = data[field.id];
+        if (Array.isArray(values)) {
+            const listItems = this.getListItems(field);
+            const matches = listItems.filter(item => values.map(v => v.code).indexOf(item.code) !== -1);
+            data[field.id] = {
+                value: matches,
+                list_items: listItems
+            };
+        }
+    }
+    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.FIELD_TYPE_DYNAMIC_MULTISELECT_LIST = 'DynamicMultiSelectList';
+FieldTypeSanitiser.ɵfac = function FieldTypeSanitiser_Factory(t) { return new (t || FieldTypeSanitiser)(); };
+FieldTypeSanitiser.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: FieldTypeSanitiser, factory: FieldTypeSanitiser.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FieldTypeSanitiser, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"field-type-sanitiser.js","sourceRoot":"","sources":["../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/services/form/field-type-sanitiser.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { CaseField } from '../../domain/definition/case-field.model';\nimport { FieldTypeEnum } from '../../domain/definition/field-type-enum.model';\n\n@Injectable()\nexport class FieldTypeSanitiser {\n  public static readonly FIELD_TYPE_COMPLEX: FieldTypeEnum = 'Complex';\n  public static readonly FIELD_TYPE_COLLECTION: FieldTypeEnum = 'Collection';\n  public static readonly FIELD_TYPE_DYNAMIC_LIST: FieldTypeEnum = 'DynamicList';\n  public static readonly FIELD_TYPE_DYNAMIC_RADIO_LIST: FieldTypeEnum = 'DynamicRadioList';\n  public static readonly FIELD_TYPE_DYNAMIC_MULTISELECT_LIST: FieldTypeEnum = 'DynamicMultiSelectList';\n  /**\n   * This method finds dynamiclists in a form and replaces their string\n   * values, with a JSON object, as below:\n   * From: 'xyz'\n   * To  : {\n   *   value: { code:'xyz', label:'XYZ' },\n   *   list_items: [\n   *     { code:'xyz', label:'XYZ'},\n   *     { code:'abc', label:'ABC'}\n   *   ]\n   * }\n   * @param caseFields The CaseFields to assess.\n   * @param data The data in the form.\n   */\n   public sanitiseLists(caseFields: CaseField[], data: any) {\n    if (!data || !caseFields) {\n      return;\n    }\n    caseFields.forEach(caseField => {\n      // tslint:disable-next-line:switch-default\n      switch (caseField.field_type.type) {\n        case FieldTypeSanitiser.FIELD_TYPE_DYNAMIC_MULTISELECT_LIST:\n          this.convertArrayToDynamicListOutput(caseField, data);\n          break;\n        case FieldTypeSanitiser.FIELD_TYPE_DYNAMIC_RADIO_LIST:\n        case FieldTypeSanitiser.FIELD_TYPE_DYNAMIC_LIST:\n          this.convertStringToDynamicListOutput(caseField, data);\n          break;\n\n        case FieldTypeSanitiser.FIELD_TYPE_COMPLEX:\n          this.sanitiseLists(caseField.field_type.complex_fields, data[caseField.id]);\n          break;\n\n        case FieldTypeSanitiser.FIELD_TYPE_COLLECTION:\n          if (Array.isArray(data[caseField.id])) {\n            data[caseField.id].forEach((formElement: any) => {\n              this.sanitiseLists(caseField.field_type.collection_field_type.complex_fields, formElement.value);\n            });\n          }\n          break;\n      }\n\n    });\n  }\n\n  private convertArrayToDynamicListOutput(field: CaseField, data: any): void {\n    const values = data[field.id];\n\n    if (Array.isArray(values)) {\n      const listItems = this.getListItems(field);\n      const matches = listItems.filter(item => values.map(v => v.code).indexOf(item.code) !== -1);\n\n      data[field.id] = {\n        value: matches,\n        list_items: listItems\n      };\n    }\n  }\n\n  private convertStringToDynamicListOutput(field: CaseField, data: any): void {\n    const stringValue = data[field.id];\n    if (typeof stringValue === 'string') {\n      const listItems = this.getListItems(field);\n      const matches = listItems.filter(value => value.code === stringValue);\n      if (matches && matches.length > 0) {\n        data[field.id] = {\n          value: matches[0],\n          list_items: listItems\n        };\n      }\n    }\n  }\n\n  private getListItems(field: CaseField): any[] {\n    if (field) {\n      if (field.list_items) {\n        return field.list_items;\n      }\n      if (field.formatted_value && field.formatted_value.list_items) {\n        return field.formatted_value.list_items;\n      }\n    }\n    return [];\n  }\n}\n"]}

package/esm2020/lib/shared/services/form/form-error.service.mjs

@@ -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 = /*@__PURE__*/ 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/esm2020/lib/shared/services/form/form-validators.service.mjs

@@ -0,0 +1,81 @@
+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') {
+                validators.push(this.markDownPatternValidator());
+                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 (caseField.field_type.type === 'TextArea') {
+                validators.push(this.emptyValidator());
+                validators.push(this.markDownPatternValidator());
+            }
+            if (control.validator) {
+                validators.push(control.validator);
+            }
+            control.setValidators(validators);
+        }
+        else if (caseField.display_context === 'OPTIONAL' && (caseField.field_type.type === 'Text' || caseField.field_type.type === 'TextArea')) {
+            control.setValidators(this.markDownPatternValidator());
+        }
+        return control;
+    }
+    static emptyValidator() {
+        const validator = (control) => {
+            if (control?.value?.toString().trim().length === 0) {
+                return { required: {} };
+            }
+            return null;
+        };
+        return validator;
+    }
+    static markDownPatternValidator() {
+        const pattern = /(\[[^\]]{0,500}\]\([^)]{0,500}\)|!\[[^\]]{0,500}\]\([^)]{0,500}\)|<img[^>]{0,500}>|<a[^>]{0,500}>.*?<\/a>)/;
+        return (control) => {
+            const value = control?.value?.toString().trim();
+            return (value && pattern.test(value)) ? { markDownPattern: {} } : null;
+        };
+    }
+    // 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);
+    }
+    addMarkDownValidators(formGroup, controlPath) {
+        const control = formGroup.get(controlPath);
+        if (control) {
+            control.setValidators(FormValidatorsService.markDownPatternValidator());
+            control.updateValueAndValidity();
+        }
+        return control;
+    }
+}
+FormValidatorsService.CUSTOM_VALIDATED_TYPES = [
+    'Date', 'MoneyGBP', 'Label', 'JudicialUser'
+];
+FormValidatorsService.DEFAULT_INPUT_TEXT = 'text';
+FormValidatorsService.DEFAULT_INPUT_TEXTAREA = 'textAreas';
+FormValidatorsService.ɵfac = function FormValidatorsService_Factory(t) { return new (t || FormValidatorsService)(); };
+FormValidatorsService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: FormValidatorsService, factory: FormValidatorsService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FormValidatorsService, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-validators.service.js","sourceRoot":"","sources":["../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/services/form/form-validators.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { AbstractControl, ValidationErrors, ValidatorFn, Validators } from '@angular/forms';\n\nimport { Constants } from '../../commons/constants';\nimport { CaseField } from '../../domain/definition/case-field.model';\nimport { FieldTypeEnum } from '../../domain/definition/field-type-enum.model';\n\n@Injectable()\nexport class FormValidatorsService {\n  private static readonly CUSTOM_VALIDATED_TYPES: FieldTypeEnum[] = [\n    'Date', 'MoneyGBP', 'Label', 'JudicialUser'\n  ];\n  private static readonly DEFAULT_INPUT_TEXT = 'text';\n  private static readonly DEFAULT_INPUT_TEXTAREA = 'textAreas';\n\n  public static addValidators(caseField: CaseField, control: AbstractControl): AbstractControl {\n    if (\n      caseField.display_context === Constants.MANDATORY &&\n      FormValidatorsService.CUSTOM_VALIDATED_TYPES.indexOf(caseField.field_type.type) === -1\n    ) {\n      const validators = [Validators.required];\n      if (caseField.field_type.type === 'Text') {\n        validators.push(this.markDownPatternValidator());\n        if (caseField.field_type.regular_expression) {\n          validators.push(Validators.pattern(caseField.field_type.regular_expression));\n        } else {\n          validators.push(this.emptyValidator());\n        }\n        if (caseField.field_type.min && (typeof caseField.field_type.min === 'number')) {\n          validators.push(Validators.minLength(caseField.field_type.min));\n        }\n        if (caseField.field_type.max && (typeof caseField.field_type.max === 'number')) {\n          validators.push(Validators.maxLength(caseField.field_type.max));\n        }\n      }\n\n      if (caseField.field_type.type === 'TextArea') {\n        validators.push(this.emptyValidator());\n        validators.push(this.markDownPatternValidator());\n      }\n\n      if (control.validator) {\n        validators.push(control.validator);\n      }\n      control.setValidators(validators);\n    } else if (caseField.display_context === 'OPTIONAL' && (caseField.field_type.type === 'Text' || caseField.field_type.type === 'TextArea')) {\n      control.setValidators(this.markDownPatternValidator());\n    }\n    return control;\n  }\n\n  public static emptyValidator(): ValidatorFn {\n    const validator = (control: AbstractControl):ValidationErrors | null => {\n      if (control?.value?.toString().trim().length === 0) {\n        return { required: {} };\n      }\n      return null;\n    };\n    return validator;\n  }\n\n  public static markDownPatternValidator(): ValidatorFn {\n    const pattern = /(\\[[^\\]]{0,500}\\]\\([^)]{0,500}\\)|!\\[[^\\]]{0,500}\\]\\([^)]{0,500}\\)|<img[^>]{0,500}>|<a[^>]{0,500}>.*?<\\/a>)/;\n\n    return (control: AbstractControl): ValidationErrors | null => {\n      const value = control?.value?.toString().trim();\n      return (value && pattern.test(value)) ? { markDownPattern: {} } : null;\n    };\n  }\n\n  // TODO: Strip this out as it's only here for the moment because\n  // the service is being injected all over the place but it doesn't\n  // need to be as FormValidatorsService.addValidators is perfectly\n  // happy being static.\n  public addValidators(caseField: CaseField, control: AbstractControl): AbstractControl {\n    return FormValidatorsService.addValidators(caseField, control);\n  }\n\n  public addMarkDownValidators(formGroup: AbstractControl, controlPath: string): AbstractControl {\n    const control = formGroup.get(controlPath);\n    if (control) {\n      control.setValidators(FormValidatorsService.markDownPatternValidator());\n      control.updateValueAndValidity();\n    }\n    return control;\n  }\n}\n"]}