@softheon/armature 10.45.5 → 15.0.1

package/esm2020/lib/forms/forms.module.mjs

@@ -0,0 +1,83 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FlexLayoutModule } from '@angular/flex-layout';
+import { ReactiveFormsModule } from '@angular/forms';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatInputModule } from '@angular/material/input';
+import { MatSelectModule } from '@angular/material/select';
+import { MatSnackBarModule } from '@angular/material/snack-bar';
+import { SofAddressComponent } from './components/sof-address/sof-address.component';
+import { AlphaNumericDirective } from './directives/alphanumeric/alphanumeric.directive';
+import { InputTrimDirective } from './directives/input-trim/input-trim.directive';
+import { LettersOnlyDirective } from './directives/letters-only/letters-only.directive';
+import { NumbersOnlyDirective } from './directives/numbers-only/numbers-only.directive';
+import { PhoneFormatPipe } from './pipes/phone-format.pipe';
+import { AlertService } from './services/alert.service';
+import * as i0 from "@angular/core";
+/** The components */
+const components = [
+    SofAddressComponent
+];
+/** The directives */
+const directives = [
+    NumbersOnlyDirective,
+    LettersOnlyDirective,
+    AlphaNumericDirective,
+    InputTrimDirective
+];
+const pipes = [
+    PhoneFormatPipe
+];
+/** The material modules */
+const materialModules = [
+    MatInputModule,
+    MatFormFieldModule,
+    MatSelectModule,
+    MatSnackBarModule
+];
+/** Armature forms module */
+export class FormsModule {
+}
+FormsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: FormsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+FormsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.2", ngImport: i0, type: FormsModule, declarations: [SofAddressComponent, NumbersOnlyDirective,
+        LettersOnlyDirective,
+        AlphaNumericDirective,
+        InputTrimDirective, PhoneFormatPipe], imports: [CommonModule,
+        FlexLayoutModule,
+        ReactiveFormsModule, MatInputModule,
+        MatFormFieldModule,
+        MatSelectModule,
+        MatSnackBarModule], exports: [SofAddressComponent, NumbersOnlyDirective,
+        LettersOnlyDirective,
+        AlphaNumericDirective,
+        InputTrimDirective, PhoneFormatPipe] });
+FormsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: FormsModule, providers: [
+        AlertService
+    ], imports: [CommonModule,
+        FlexLayoutModule,
+        ReactiveFormsModule, materialModules] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: FormsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        ...components,
+                        ...directives,
+                        ...pipes
+                    ],
+                    imports: [
+                        CommonModule,
+                        FlexLayoutModule,
+                        ReactiveFormsModule,
+                        ...materialModules
+                    ],
+                    providers: [
+                        AlertService
+                    ],
+                    exports: [
+                        ...components,
+                        ...directives,
+                        ...pipes
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/forms/models/address.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWRkcmVzcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FybWF0dXJlL3NyYy9saWIvZm9ybXMvbW9kZWxzL2FkZHJlc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvdW50eSB9IGZyb20gJy4vY291bnR5JztcclxuXHJcbi8qKlxyXG4gKiBBZGRyZXNzIG1vZGVsXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIEFkZHJlc3Mge1xyXG5cclxuICAgIC8qKiBTdHJlZXQgMSAqL1xyXG4gICAgc3RyZWV0MT86IHN0cmluZztcclxuXHJcbiAgICAvKiogU3RyZWV0IDIgKi9cclxuICAgIHN0cmVldDI/OiBzdHJpbmc7XHJcblxyXG4gICAgLyoqIFRoZSBjaXR5ICovXHJcbiAgICBjaXR5Pzogc3RyaW5nO1xyXG5cclxuICAgIC8qKiBDb3VudHkgKi9cclxuICAgIGNvdW50eT86IENvdW50eTtcclxufVxyXG4iXX0=

package/esm2020/lib/forms/models/constants.mjs

@@ -0,0 +1,10 @@
+/** The validation key constants */
+export class ValidationKeys {
+}
+ValidationKeys.required = 'required';
+ValidationKeys.minLength = 'minlength';
+ValidationKeys.maxLength = 'maxlength';
+ValidationKeys.pattern = 'pattern';
+ValidationKeys.maskError = 'maskError';
+ValidationKeys.email = 'email';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYXJtYXR1cmUvc3JjL2xpYi9mb3Jtcy9tb2RlbHMvY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLG1DQUFtQztBQUNuQyxNQUFNLE9BQU8sY0FBYzs7QUFDVCx1QkFBUSxHQUFXLFVBQVUsQ0FBQztBQUM5Qix3QkFBUyxHQUFXLFdBQVcsQ0FBQztBQUNoQyx3QkFBUyxHQUFXLFdBQVcsQ0FBQztBQUNoQyxzQkFBTyxHQUFXLFNBQVMsQ0FBQztBQUM1Qix3QkFBUyxHQUFXLFdBQVcsQ0FBQztBQUNoQyxvQkFBSyxHQUFXLE9BQU8sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKiBUaGUgdmFsaWRhdGlvbiBrZXkgY29uc3RhbnRzICovXHJcbmV4cG9ydCBjbGFzcyBWYWxpZGF0aW9uS2V5cyB7XHJcbiAgICBwdWJsaWMgc3RhdGljIHJlcXVpcmVkOiBzdHJpbmcgPSAncmVxdWlyZWQnO1xyXG4gICAgcHVibGljIHN0YXRpYyBtaW5MZW5ndGg6IHN0cmluZyA9ICdtaW5sZW5ndGgnO1xyXG4gICAgcHVibGljIHN0YXRpYyBtYXhMZW5ndGg6IHN0cmluZyA9ICdtYXhsZW5ndGgnO1xyXG4gICAgcHVibGljIHN0YXRpYyBwYXR0ZXJuOiBzdHJpbmcgPSAncGF0dGVybic7XHJcbiAgICBwdWJsaWMgc3RhdGljIG1hc2tFcnJvcjogc3RyaW5nID0gJ21hc2tFcnJvcic7XHJcbiAgICBwdWJsaWMgc3RhdGljIGVtYWlsOiBzdHJpbmcgPSAnZW1haWwnO1xyXG59XHJcbiJdfQ==

package/esm2020/lib/forms/models/county.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY291bnR5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYXJtYXR1cmUvc3JjL2xpYi9mb3Jtcy9tb2RlbHMvY291bnR5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogQ291bnR5IG1vZGVsXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIENvdW50eSB7XHJcblxyXG4gICAgLyoqIFpJUCBDb2RlICovXHJcbiAgICB6aXBDb2RlPzogc3RyaW5nO1xyXG5cclxuICAgIC8qKiBGSVBTIENvZGUgKi9cclxuICAgIGZpcHNDb2RlPzogc3RyaW5nO1xyXG5cclxuICAgIC8qKiBTdGF0ZSBjb3VudHkgaXMgbG9jYXRlZCBpbiAqL1xyXG4gICAgc3RhdGU/OiBzdHJpbmc7XHJcblxyXG4gICAgLyoqIE5hbWUgb2YgdGhlIGNvdW50eSAqL1xyXG4gICAgbmFtZT86IHN0cmluZztcclxufVxyXG4iXX0=

package/esm2020/lib/forms/models/enums/states.mjs

@@ -0,0 +1,58 @@
+/**
+ * The States enum
+ */
+export var States;
+(function (States) {
+    States["AL"] = "Alabama";
+    States["AK"] = "Alaska";
+    States["AZ"] = "Arizona";
+    States["AR"] = "Arkansas";
+    States["CA"] = "California";
+    States["CO"] = "Colorado";
+    States["CT"] = "Connecticut";
+    States["DE"] = "Delaware";
+    States["DC"] = "District of Columbia";
+    States["FL"] = "Florida";
+    States["GA"] = "Georgia";
+    States["HI"] = "Hawaii";
+    States["ID"] = "Idaho";
+    States["IL"] = "Illinois";
+    States["IN"] = "Indiana";
+    States["IA"] = "Iowa";
+    States["KS"] = "Kansas";
+    States["KY"] = "Kentucky";
+    States["LA"] = "Louisiana";
+    States["ME"] = "Maine";
+    States["MD"] = "Maryland";
+    States["MA"] = "Massachusetts";
+    States["MI"] = "Michigan";
+    States["MN"] = "Minnesota";
+    States["MS"] = "Mississippi";
+    States["MO"] = "Missouri";
+    States["MT"] = "Montana";
+    States["NE"] = "Nebraska";
+    States["NV"] = "Nevada";
+    States["NH"] = "New Hampshire";
+    States["NJ"] = "New Jersey";
+    States["NM"] = "New Mexico";
+    States["NY"] = "New York";
+    States["NC"] = "North Carolina";
+    States["ND"] = "North Dakota";
+    States["OH"] = "Ohio";
+    States["OK"] = "Oklahoma";
+    States["OR"] = "Oregon";
+    States["PA"] = "Pennsylvania";
+    States["RI"] = "Rhode Island";
+    States["SC"] = "South Carolina";
+    States["SD"] = "South Dakota";
+    States["TN"] = "Tennessee";
+    States["TX"] = "Texas";
+    States["UT"] = "Utah";
+    States["VT"] = "Vermont";
+    States["VA"] = "Virginia";
+    States["WA"] = "Washington";
+    States["WV"] = "West Virginia";
+    States["WI"] = "Wisconsin";
+    States["WY"] = "Wyoming";
+})(States || (States = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/forms/pipes/phone-format.pipe.mjs

@@ -0,0 +1,33 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * A pipe that takes a simple string phone number and formats it
+ */
+export class PhoneFormatPipe {
+    transform(phoneNumber) {
+        // If input is undefined, then return empty string
+        if (!phoneNumber) {
+            return '';
+        }
+        // Check for more than 10 digits
+        let formattedPhoneNumber = ('' + phoneNumber).replace(/\D/g, '');
+        if (formattedPhoneNumber.length > 10) {
+            return '';
+        }
+        // Check for correct pattern
+        let formattedPhoneArray = formattedPhoneNumber.match(/^(1|)?(\d{3})(\d{3})(\d{4})$/);
+        if (!!formattedPhoneArray) {
+            return ['(', formattedPhoneArray[2], ') ', formattedPhoneArray[3], '-', formattedPhoneArray[4]].join('');
+        }
+        else {
+            return '';
+        }
+    }
+}
+PhoneFormatPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: PhoneFormatPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+PhoneFormatPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.2", ngImport: i0, type: PhoneFormatPipe, name: "sofArPhone" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: PhoneFormatPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'sofArPhone' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/forms/services/alert.service.mjs

@@ -0,0 +1,167 @@
+import { Injectable } from '@angular/core';
+import { FormArray, FormGroup } from '@angular/forms';
+import { MatSnackBarConfig } from '@angular/material/snack-bar';
+import { ValidationKeys } from '../models/constants';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/snack-bar";
+import * as i2 from "@ngx-translate/core";
+/**
+ * Service to handle error alerts
+ */
+export class AlertService {
+    /**
+     * The constructor
+     * @param snackBar the angular material snackbar
+     * @param translateService the translate service
+     */
+    constructor(snackBar, translateService) {
+        this.snackBar = snackBar;
+        this.translateService = translateService;
+        /** the translation ket for close text */
+        this.closeTextKey = 'common.dismiss';
+    }
+    /**
+     * Opens a generic snack bar alert
+     * @param detailsTextKey text to show in the alert
+     * @param durationLength how long the alert should be shown before it fades
+     */
+    openCustomSnackBarAlert(detailsTextKey, params = {}, durationLength = 3000) {
+        const snackBarConfig = new MatSnackBarConfig();
+        snackBarConfig.duration = durationLength;
+        snackBarConfig.panelClass = ['red-snackbar'];
+        this.snackBar.open(this.translateService.instant(detailsTextKey, params), this.translateService.instant(this.closeTextKey), snackBarConfig);
+    }
+    /**
+     * Opens an alert with a the specific form validation error
+     * @param form the form to validate
+     * @param el the element reference from the forms page, used to set focus on invalid form
+     * @param durationLength how long the alert should be shown before it fades
+     */
+    openFormInvalidSnackBarAlert(form, el, durationLength = 5000) {
+        this.getWhatIsNotFilledOut(form, el, durationLength);
+    }
+    /**
+     * Iterates through a form (form group/form array) recursively to get the individual form control that is invalid
+     * @param form the form to validate
+     * @param el the element reference from the forms page, used to set focus on invalid form
+     * @param durationLength how long the alert should be shown before it fades
+     */
+    getWhatIsNotFilledOut(form, el, durationLength) {
+        for (let field in form.controls) {
+            let control = form.get(field);
+            if (!control.invalid) {
+                continue;
+            }
+            if (control instanceof FormArray) {
+                for (let formArrayField in control.controls) {
+                    let formArrayControl = control.get(formArrayField);
+                    if (!formArrayControl.invalid) {
+                        continue;
+                    }
+                    if (formArrayControl instanceof FormGroup) {
+                        return this.getWhatIsNotFilledOut(formArrayControl, el, durationLength);
+                    }
+                    else {
+                        return this.getErrorMessage(formArrayControl, formArrayField, el, durationLength);
+                    }
+                }
+            }
+            else if (control instanceof FormGroup) {
+                for (let formGroupField in control.controls) {
+                    let formGroupControl = control.get(formGroupField);
+                    if (!formGroupControl.invalid) {
+                        continue;
+                    }
+                    if (formGroupControl instanceof FormGroup) {
+                        return this.getWhatIsNotFilledOut(formGroupControl, el, durationLength);
+                    }
+                    else {
+                        return this.getErrorMessage(formGroupControl, formGroupField, el, durationLength);
+                    }
+                }
+            }
+            else {
+                return this.getErrorMessage(control, field, el, durationLength);
+            }
+        }
+    }
+    /**
+     * Gets the error message based on the form control that is invalid
+     * @param control the invalid form control
+     * @param field the field name that is invalid
+     * @param el the element reference from the forms page, used to set focus on invalid form
+     * @param durationLength how long the alert should be shown before it fades
+     */
+    getErrorMessage(control, field, el, durationLength) {
+        let errorText = '';
+        const error = control.errors;
+        const errorKey = Object.keys(control.errors)[0]; // will only ever be one at a time even if multiple validation errors
+        const formattedFieldText = this.getFieldFormattedText(field);
+        switch (errorKey) {
+            case ValidationKeys.required: {
+                errorText = this.translateService.instant('error.requiredError', { 'fieldName': formattedFieldText });
+                break;
+            }
+            case ValidationKeys.maxLength: {
+                const errorValues = Object.values(error)[0];
+                const requiredLength = Object.values(errorValues)[0];
+                const actualValue = Object.values(errorValues)[1];
+                errorText = this.translateService.instant('error.maxLengthError', { 'fieldName': formattedFieldText, 'actualValue': actualValue, 'requiredLength': requiredLength });
+                break;
+            }
+            case ValidationKeys.minLength: {
+                let errorValues = Object.values(error)[0];
+                let requiredLength = Object.values(errorValues)[0];
+                let actualValue = Object.values(errorValues)[1];
+                errorText = this.translateService.instant('error.minLengthError', { 'fieldName': formattedFieldText, 'actualValue': actualValue, 'requiredLength': requiredLength });
+                break;
+            }
+            case ValidationKeys.pattern:
+            case ValidationKeys.maskError:
+            case ValidationKeys.email: {
+                errorText = this.translateService.instant('error.formatError', { 'fieldName': formattedFieldText });
+                break;
+            }
+            default: {
+                errorText = this.translateService.instant('error.allFieldsRequired');
+                break;
+            }
+        }
+        this.setFocusToFormControl(el);
+        this.openCustomSnackBarAlert(errorText, durationLength);
+        return;
+    }
+    /**
+     * Formats the form control name to readable text to display to the user in an error alert
+     * @param field The field
+     */
+    getFieldFormattedText(field) {
+        let split = field.split(/(?=[A-Z])/); // splits a string by word
+        let formattedFieldText = '';
+        for (let i = 0; i < split.length; i++) {
+            split[i] = split[i].charAt(0).toUpperCase() + split[i].substring(1);
+            formattedFieldText += split[i] + ' ';
+        }
+        return formattedFieldText;
+    }
+    /**
+     * Sets focus to the first invalid form control element
+     * @param el Element to focus on
+     */
+    setFocusToFormControl(el) {
+        // find all invalid controls and focus the first control found
+        const invalidElements = el.nativeElement.querySelectorAll('input.ng-invalid, select.ng-invalid');
+        if (invalidElements.length > 0) {
+            invalidElements[0].focus(); // [0] will always be the form itself [1] will be the first control
+        }
+    }
+}
+AlertService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: AlertService, deps: [{ token: i1.MatSnackBar }, { token: i2.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
+AlertService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: AlertService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: AlertService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MatSnackBar }, { type: i2.TranslateService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alert.service.js","sourceRoot":"","sources":["../../../../../../../projects/armature/src/lib/forms/services/alert.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ElementRef, Injectable } from '@angular/core';\r\nimport { AbstractControl, FormArray, FormGroup } from '@angular/forms';\r\nimport { MatSnackBar, MatSnackBarConfig } from '@angular/material/snack-bar';\r\nimport { TranslateService } from '@ngx-translate/core';\r\nimport { ValidationKeys } from '../models/constants';\r\n\r\n/**\r\n * Service to handle error alerts\r\n */\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class AlertService {\r\n\r\n  /** the translation ket for close text */\r\n  public readonly closeTextKey: string = 'common.dismiss';\r\n\r\n  /**\r\n   * The constructor\r\n   * @param snackBar the angular material snackbar\r\n   * @param translateService the translate service\r\n   */\r\n  constructor(\r\n    public snackBar: MatSnackBar,\r\n    private translateService: TranslateService\r\n  ) { }\r\n\r\n  /**\r\n   * Opens a generic snack bar alert\r\n   * @param detailsTextKey text to show in the alert\r\n   * @param durationLength how long the alert should be shown before it fades\r\n   */\r\n  public openCustomSnackBarAlert(detailsTextKey: string, params: any = {}, durationLength: number = 3000): void {\r\n\r\n    const snackBarConfig = new MatSnackBarConfig();\r\n    snackBarConfig.duration = durationLength;\r\n    snackBarConfig.panelClass = ['red-snackbar'];\r\n\r\n    this.snackBar.open(this.translateService.instant(detailsTextKey, params), this.translateService.instant(this.closeTextKey), snackBarConfig);\r\n  }\r\n\r\n  /**\r\n   * Opens an alert with a the specific form validation error\r\n   * @param form the form to validate\r\n   * @param el the element reference from the forms page, used to set focus on invalid form\r\n   * @param durationLength how long the alert should be shown before it fades\r\n   */\r\n  public openFormInvalidSnackBarAlert(form: FormGroup, el: ElementRef, durationLength: number = 5000): void {\r\n    this.getWhatIsNotFilledOut(form, el, durationLength);\r\n  }\r\n\r\n  /**\r\n   * Iterates through a form (form group/form array) recursively to get the individual form control that is invalid\r\n   * @param form the form to validate\r\n   * @param el the element reference from the forms page, used to set focus on invalid form\r\n   * @param durationLength how long the alert should be shown before it fades\r\n   */\r\n  public getWhatIsNotFilledOut(form: FormGroup, el: ElementRef, durationLength: number): string {\r\n    for (let field in form.controls) {\r\n      let control = form.get(field);\r\n      if (!control.invalid) {\r\n        continue;\r\n      }\r\n      if (control instanceof FormArray) {\r\n        for (let formArrayField in control.controls) {\r\n          let formArrayControl = control.get(formArrayField);\r\n          if (!formArrayControl.invalid) {\r\n            continue;\r\n          }\r\n          if (formArrayControl instanceof FormGroup) {\r\n            return this.getWhatIsNotFilledOut(formArrayControl, el, durationLength)\r\n          }\r\n          else {\r\n            return this.getErrorMessage(formArrayControl, formArrayField, el, durationLength);\r\n          }\r\n        }\r\n      }\r\n      else if (control instanceof FormGroup) {\r\n        for (let formGroupField in control.controls) {\r\n          let formGroupControl = control.get(formGroupField);\r\n          if (!formGroupControl.invalid) {\r\n            continue;\r\n          }\r\n          if (formGroupControl instanceof FormGroup) {\r\n            return this.getWhatIsNotFilledOut(formGroupControl, el, durationLength)\r\n          }\r\n          else {\r\n            return this.getErrorMessage(formGroupControl, formGroupField, el, durationLength);\r\n          }\r\n        }\r\n      }\r\n      else {\r\n        return this.getErrorMessage(control, field, el, durationLength);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Gets the error message based on the form control that is invalid\r\n   * @param control the invalid form control\r\n   * @param field the field name that is invalid\r\n   * @param el the element reference from the forms page, used to set focus on invalid form\r\n   * @param durationLength how long the alert should be shown before it fades\r\n   */\r\n  public getErrorMessage(control: AbstractControl, field: string, el: ElementRef, durationLength: number): string {\r\n    let errorText = '';\r\n    const error = control.errors;\r\n    const errorKey = Object.keys(control.errors)[0]; // will only ever be one at a time even if multiple validation errors\r\n\r\n    const formattedFieldText = this.getFieldFormattedText(field);\r\n    switch (errorKey) {\r\n      case ValidationKeys.required: {\r\n        errorText = this.translateService.instant('error.requiredError', { 'fieldName': formattedFieldText });\r\n        break;\r\n      }\r\n      case ValidationKeys.maxLength: {\r\n        const errorValues = Object.values(error)[0];\r\n        const requiredLength = Object.values(errorValues)[0];\r\n        const actualValue = Object.values(errorValues)[1];\r\n        errorText = this.translateService.instant('error.maxLengthError', { 'fieldName': formattedFieldText, 'actualValue': actualValue, 'requiredLength': requiredLength });\r\n        break;\r\n      }\r\n      case ValidationKeys.minLength: {\r\n        let errorValues = Object.values(error)[0];\r\n        let requiredLength = Object.values(errorValues)[0];\r\n        let actualValue = Object.values(errorValues)[1];\r\n        errorText = this.translateService.instant('error.minLengthError', { 'fieldName': formattedFieldText, 'actualValue': actualValue, 'requiredLength': requiredLength });\r\n        break;\r\n      }\r\n      case ValidationKeys.pattern:\r\n      case ValidationKeys.maskError:\r\n      case ValidationKeys.email: {\r\n        errorText = this.translateService.instant('error.formatError', { 'fieldName': formattedFieldText });\r\n        break;\r\n      }\r\n      default: {\r\n        errorText = this.translateService.instant('error.allFieldsRequired');\r\n        break;\r\n      }\r\n    }\r\n    this.setFocusToFormControl(el);\r\n    this.openCustomSnackBarAlert(errorText, durationLength);\r\n    return;\r\n  }\r\n\r\n  /**\r\n   * Formats the form control name to readable text to display to the user in an error alert\r\n   * @param field The field\r\n   */\r\n  public getFieldFormattedText(field: string): string {\r\n    let split = field.split(/(?=[A-Z])/); // splits a string by word\r\n    let formattedFieldText = '';\r\n    for (let i = 0; i < split.length; i++) {\r\n      split[i] = split[i].charAt(0).toUpperCase() + split[i].substring(1);\r\n      formattedFieldText += split[i] + ' ';\r\n    }\r\n\r\n    return formattedFieldText;\r\n  }\r\n\r\n  /**\r\n   * Sets focus to the first invalid form control element\r\n   * @param el Element to focus on\r\n   */\r\n  public setFocusToFormControl(el: ElementRef): void {\r\n    // find all invalid controls and focus the first control found\r\n    const invalidElements = el.nativeElement.querySelectorAll('input.ng-invalid, select.ng-invalid');\r\n    if (invalidElements.length > 0) {\r\n      invalidElements[0].focus(); // [0] will always be the form itself [1] will be the first control\r\n    }\r\n\r\n  }\r\n}\r\n"]}