@messaia/cdk 12.3.5-rc21 → 13.0.0-rc02

package/esm2020/lib/base/components/generic-form.component.mjs

@@ -0,0 +1,482 @@
+import { ChangeDetectorRef, Directive, HostListener, ViewChild, ViewChildren } from '@angular/core';
+import { MatStepper } from '@angular/material/stepper';
+import { ActivatedRoute } from '@angular/router';
+import { combineLatest } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { Utils } from '../../common/functions/utils';
+import { SaveAction } from '../../common/models/save-action';
+import { BaseComponent } from './base.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+// @dynamic
+export class GenericFormComponent extends BaseComponent {
+    /**
+     * Constructor
+     * @param service
+     */
+    constructor(entityCtor, service, route, changeDetectorRef) {
+        super(route, changeDetectorRef);
+        this.entityCtor = entityCtor;
+        this.service = service;
+        this.route = route;
+        this.changeDetectorRef = changeDetectorRef;
+        /**
+         * The action of the form (add | edit)
+         */
+        this.action = 'add';
+        /**
+         * Save action
+         */
+        this.SaveAction = SaveAction;
+        /**
+         * Routes
+         */
+        this.editSaveAndCloseRoute = '../../';
+        this.addSaveAndCloseRoute = '../';
+        this.addSaveAndEditRoute = '../edit/';
+        this.addSaveAndNewRoute = '../add';
+        this.listRoute = this.addSaveAndCloseRoute;
+        /**
+         * Represents the request errors
+         */
+        this.errors = new Array();
+        /**
+         * Includes
+         */
+        this.includes = [];
+        /**
+         * Update includes
+         */
+        this.updateIncludes = [];
+        /**
+         * Get params
+         */
+        this.query = {};
+        /**
+         * The current date
+         */
+        this.currentDate = new Date();
+        /**
+         * Date & time mask
+         */
+        this.dateTimeMask = [/[0-3]/, /[0-9]/, '.', /[0-1]/, /[0-9]/, '.', 2, 0, /[1-2]/, /[0-9]/, ' ', /[0-2]/, /[0-9]/, ':', /[0-5]/, /[0-9]/];
+        /**
+         * Date mask
+         */
+        this.dateMask = [/[0-3]/, /[0-9]/, '.', /[0-1]/, /[0-9]/, '.', 2, 0, /[1-2]/, /[0-9]/];
+        /**
+         * Time mask
+         */
+        this.timeMask = [/[0-2]/, /[0-9]/, ':', /[0-5]/, /[0-9]/];
+        /**
+         * A pattern to validate dates
+         */
+        this.datePattern = `(?:(?:31(\\/|-|\\.)(?:0?[13578]|1[02]))\\1|(?:(?:29|30)(\\/|-|\\.)(?:0?[1,3-9]|1[0-2])\\2))(?:(?:1[6-9]|[2-9]\\d)?\\d{2})$|^(?:29(\\/|-|\\.)0?2\\3(?:(?:(?:1[6-9]|[2-9]\\d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00))))$|^(?:0?[1-9]|1\\d|2[0-8])(\\/|-|\\.)(?:(?:0?[1-9])|(?:1[0-2]))\\4(?:(?:1[6-9]|[2-9]\\d)?\\d{2})`;
+        /**
+         * Phone prefix validation pattern
+         */
+        this.phonePrefixPattern = '^(0\\d{2,6})$';
+        /**
+         * Phone number validation pattern
+         */
+        this.phoneNumberPattern = '^(\\d{3,30})$';
+        /**
+         * Password validation pattern
+         */
+        this.passwordPattern = '^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[$@$!%*?&])[A-Za-z\\d$@$!%*?&]{6,}';
+        /**
+         * Defaults modules and toolbar
+         */
+        this.editorOptions = {
+            modules: {
+                toolbar: [
+                    ['bold', 'italic', 'underline'],
+                    [{ 'list': 'ordered' }, { 'list': 'bullet' }],
+                    [{ 'indent': '-1' }, { 'indent': '+1' }],
+                    [{ 'size': ['small', false, 'large', 'huge'] }],
+                    [{ 'header': [1, 2, 3, 4, 5, 6, false] }],
+                    [{ 'color': new Array() }, { 'background': new Array() }],
+                    ['link', 'image']
+                ],
+                clipboard: {
+                    matchVisual: false
+                }
+            }
+        };
+        this.listRoute = this.addSaveAndCloseRoute;
+    }
+    /**
+     * Called after the constructor, initializing input properties,
+     * and the first call to ngOnChanges.
+     */
+    ngOnInit() {
+        super.ngOnInit();
+        /* Get id from the url */
+        let id = this.route.snapshot.paramMap.get('id');
+        if (id > 0) {
+            this.id = id;
+        }
+        else if (!this.id && this.route.snapshot?.data?.id) {
+            this.id = this.route.snapshot?.data?.id;
+        }
+        /* Set some variable for edit mode */
+        if (this.id) {
+            this.action = 'edit';
+            this.isEditMode = true;
+            this.listRoute = this.editSaveAndCloseRoute;
+        }
+        /* Get the return url if any */
+        this.route.queryParams.subscribe(x => {
+            this.returnUrl = x.returnUrl ? decodeURIComponent(atob(x.returnUrl)) : null;
+            this.listRoute = this.returnUrl || this.listRoute;
+        });
+        /* Get route params */
+        var params = this.route.params.pipe(map((x) => {
+            let params = {};
+            /* Get the return url if any */
+            this.returnUrl = x.returnUrl ? decodeURIComponent(atob(x.returnUrl)) : this.returnUrl;
+            this.listRoute = this.returnUrl || this.listRoute;
+            /* Clone params to query */
+            for (let [key, value] of Object.entries(x)) {
+                if (!['id', 'returnurl', 'panelId'].includes(key.toLocaleLowerCase())) {
+                    params[key] = isNaN(+value) ? value : +value;
+                }
+            }
+            return params;
+        }));
+        /* Combine the data */
+        combineLatest([params, this.route.data.pipe(map((data) => data.query || {}))])
+            .pipe(map(([a, b]) => Object.assign(a, b)))
+            .subscribe(x => {
+            Object.assign(this.query, x);
+            /* Create a new instance of the TEntity */
+            if (!this.isEditMode) {
+                this.item = Object.assign(this.newInstance(), this.query);
+            }
+        });
+    }
+    /**
+     * Lifecycle hook that is called after a component's view has been fully initialized.
+     */
+    ngAfterViewInit() {
+        super.ngAfterViewInit();
+        /* Set page title */
+        this.title = this.titleService.getTitle();
+        /* Set focus */
+        this.focus();
+        /*
+         * Force a new change detection cycle since change detections
+         * have finished when `ngAfterViewInit` is executed
+         */
+        this.changeDetectorRef.detectChanges();
+        /* Load item from server */
+        this.loadItem();
+        /* Listen for stepper selection changes */
+        this.matStepper?.selectionChange?.subscribe((event) => this.onAfterStepChange(event));
+    }
+    /**
+     * Loads an item by ID
+     */
+    loadItem() {
+        if (this.isEditMode && this.id > 0) {
+            this.isLoading = true;
+            this.changeDetectorRef.detectChanges();
+            this.service.get(this.id, Object.assign(this.query || {}, { includes: this.includes }), { 'Disable-Cache': 'Yes' })
+                .subscribe(item => {
+                this.item = Object.assign(this.newInstance(), item);
+                this.isLoading = false;
+                this.afterItemLoaded();
+            }, _ => this.isLoading = false);
+        }
+    }
+    /**
+     * Saves data into database.
+     * @param action
+     */
+    save(action = SaveAction.SaveAndClose, form = null) {
+        if (form && !this.isFormValid(form)) {
+            return;
+        }
+        this.isSaving = true;
+        this.beforeSubmit(action);
+        if (this.isEditMode) {
+            this.update({ params: Utils.toHttpParams({ includes: this.updateIncludes }) })
+                .subscribe(_ => {
+                this.afterSubmit(action);
+            }, error => this.parseErrors(error));
+        }
+        else {
+            this.create()
+                .subscribe(response => {
+                if (action == SaveAction.SaveAndEdit) {
+                    this.id = response.id;
+                }
+                this.afterSubmit(action);
+                if (form) {
+                    Object.keys(form.controls).forEach(key => {
+                        let ctr = form.controls[key];
+                        ctr.markAsPristine();
+                        ctr.markAsUntouched();
+                        ctr.updateValueAndValidity();
+                    });
+                }
+            }, error => this.parseErrors(error));
+        }
+    }
+    /**
+     * Validates the form
+     * @param form
+     */
+    isFormValid(form = null) {
+        /* Print some debug information */
+        if (this.debug) {
+            console.log('Form:', form);
+            Object.keys(form.controls).forEach(key => {
+                const controlErrors = form.controls[key].errors;
+                if (controlErrors != null) {
+                    Object.keys(controlErrors).forEach(keyError => {
+                        console.log('Key control: ' + key + ', keyError: ' + keyError + ', err value: ', controlErrors[keyError]);
+                    });
+                }
+            });
+        }
+        /* If the form ist not valid.. */
+        if (!form.valid) {
+            /* Mark invalid controls as dirtty and touched */
+            Object.keys(form.controls)
+                .filter(x => !form.controls[x].valid)
+                .forEach(key => this.invalidateControl(form.controls[key]));
+            /* Show error messages */
+            (async () => {
+                /* Wait until 'mat-error' displayed */
+                await new Promise(y => setTimeout(y, 200));
+                /* Parse the error messages */
+                var errors = Array();
+                Object.keys(form.controls)
+                    .filter(x => !form.controls[x].valid)
+                    .forEach(key => {
+                    /* Get error text */
+                    var error = this.getElementError(form.controls[key].nativeElement);
+                    if (error) {
+                        errors.push(error);
+                    }
+                });
+                /* Build error message */
+                var message = errors.length ? errors.slice(0, 3).join('\n') : `Bitte überprüfen Sie Ihre Abgaben und korrigieren fehlerhafte Eingaben!`;
+                /* show a notice */
+                this.snackBarService.open(message, 'Ok', { duration: 3000, panelClass: ['error'] });
+            })();
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Resets form controls
+     * @param form
+     * @returns
+     */
+    resetForm(form) {
+        if (!form) {
+            return;
+        }
+        Object.keys(form.controls).forEach(key => {
+            let ctr = form.controls[key];
+            ctr.markAsPristine();
+            ctr.markAsUntouched();
+            ctr.updateValueAndValidity();
+        });
+    }
+    /**
+     * Invalidate controls recursively
+     * @param control
+     */
+    invalidateControl(control) {
+        /* Check the control against null */
+        if (!control) {
+            return;
+        }
+        /* Check if the control is a group */
+        let formGroup = control;
+        if (formGroup && formGroup.controls) {
+            Object.keys(formGroup.controls)
+                .filter(x => !formGroup.controls[x].valid)
+                .forEach(x => this.invalidateControl(formGroup.controls[x]));
+        }
+        else {
+            control.markAsDirty();
+            control.markAsTouched();
+        }
+    }
+    /**
+     * Saves data and navigates to edit view
+     */
+    apply() {
+        this.save(SaveAction.SaveAndEdit);
+    }
+    /**
+     * Loads the previous URL in the history list.
+     * @param action
+     */
+    back(action = SaveAction.SaveAndClose) {
+        if (action == SaveAction.SaveAndClose && this.returnUrl) {
+            var urlParts = Utils.getUrlParts(this.returnUrl);
+            this.router.navigate([urlParts.url], { queryParams: urlParts.params, fragment: urlParts.hash });
+        }
+        else {
+            if (this.isEditMode) {
+                if (action == SaveAction.SaveAndClose) {
+                    this.location.back();
+                }
+                else if (action == SaveAction.SaveAndEdit) {
+                    this.reloadPage();
+                }
+            }
+            else {
+                if (action == SaveAction.SaveAndClose) {
+                    this.location.back();
+                }
+                else if (action == SaveAction.SaveAndEdit && this.id > 0) {
+                    this.router.navigate([`${this.addSaveAndEditRoute}${this.id}`], { relativeTo: this.route });
+                }
+                else if (action == SaveAction.SaveAndNew) {
+                    this.afterReload();
+                }
+            }
+        }
+    }
+    /**
+     * Creates a new instance of the TEntity
+     */
+    newInstance() {
+        return this.item = new this.entityCtor();
+    }
+    /**
+     * Creates the entity
+     */
+    create(httpOptions) {
+        this.beforeCreate();
+        return this.service.create(this.item, null, Object.assign(httpOptions || {}, { headers: this.toHttpHeaders({ 'Show-Message': 'yes' }) }), false);
+    }
+    /**
+     * updates the entity
+     */
+    update(httpOptions) {
+        this.beforeUpdate();
+        return this.service.update(this.id, this.item, null, Object.assign(httpOptions || {}, { headers: this.toHttpHeaders({ 'Show-Message': 'yes' }) }), false);
+    }
+    /**
+     * Includes some navigations
+     * @param inc
+     * @param update
+     */
+    include(inc, update = false) {
+        this.includes.push(inc);
+        if (update) {
+            this.updateIncludes.push(inc);
+        }
+    }
+    /**
+     * Event emitted when the selected step has changed.
+     * @param $event
+     */
+    onAfterStepChange($event) { }
+    /**
+     * Called after the item is loaded
+     */
+    afterItemLoaded() { }
+    ;
+    /**
+     * Called before the entity get created
+     */
+    beforeCreate() { }
+    ;
+    /**
+     * Called before the entity get updated
+     */
+    beforeUpdate() { }
+    ;
+    /**
+     * Called before data submition
+     */
+    beforeSubmit(_ = SaveAction.SaveAndClose) { }
+    /**
+     * Called after data submition
+     */
+    afterSubmit(action = SaveAction.SaveAndClose) {
+        this.isSaving = false;
+        this.back(action);
+    }
+    /**
+     * Called after page reloaded
+     */
+    afterReload() {
+        this.item = Object.assign(this.newInstance(), this.query);
+    }
+    /**
+     * Sets focus to first input
+     */
+    focus() {
+        /* Set focus to first element */
+        if (this.input && this.input.first && this.input.first.nativeElement) {
+            this.input.first.nativeElement.focus();
+        }
+    }
+    /**
+     * Gets element error
+     * @param nativeElement
+     */
+    getElementError(nativeElement) {
+        /* Get paranet element 'mat-form-field' */
+        var matFormField = nativeElement.closest('.mat-form-field');
+        if (!matFormField) {
+            return null;
+        }
+        /* Get child element 'mat-error' */
+        var matError = matFormField.querySelector('.mat-error');
+        if (!matError) {
+            return null;
+        }
+        return matError.textContent;
+    }
+    /**
+     * Responds to user-initiated events
+     * @param event
+     */
+    handleKeyboardEvent(event) {
+        if (event.ctrlKey || event.metaKey) {
+            switch (String.fromCharCode(event.which).toLowerCase()) {
+                case 's':
+                    event.preventDefault();
+                    this.save(SaveAction.SaveAndClose);
+                    break;
+                case 'd':
+                    event.preventDefault();
+                    this.save(SaveAction.SaveAndNew);
+                    break;
+                case 'e':
+                    event.preventDefault();
+                    this.save(SaveAction.SaveAndEdit);
+                    break;
+            }
+        }
+        /* Cancel the form, if the user press the ESC key */
+        if (event.keyCode == 27) {
+            this.back();
+        }
+    }
+}
+/** @nocollapse */ /** @nocollapse */ GenericFormComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: GenericFormComponent, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ /** @nocollapse */ GenericFormComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.3", type: GenericFormComponent, host: { listeners: { "document:keydown": "handleKeyboardEvent($event)" } }, viewQueries: [{ propertyName: "matStepper", first: true, predicate: MatStepper, descendants: true }, { propertyName: "input", predicate: ["focus"], descendants: true }], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: GenericFormComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: undefined }, { type: undefined }, { type: i1.ActivatedRoute }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { matStepper: [{
+                type: ViewChild,
+                args: [MatStepper]
+            }], input: [{
+                type: ViewChildren,
+                args: ['focus']
+            }], handleKeyboardEvent: [{
+                type: HostListener,
+                args: ['document:keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generic-form.component.js","sourceRoot":"","sources":["../../../../../../projects/cdk/src/lib/base/components/generic-form.component.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAEpG,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAc,MAAM,MAAM,CAAC;AACjD,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAErD,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAE7D,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;;;AAEjD,WAAW;AAEX,MAAM,OAAgB,oBAAwF,SAAQ,aAAa;IAoIlI;;;OAGG;IACH,YACQ,UAA8B,EAC3B,OAAiB,EACjB,KAAqB,EACrB,iBAAoC;QAE9C,KAAK,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC;QALzB,eAAU,GAAV,UAAU,CAAoB;QAC3B,YAAO,GAAP,OAAO,CAAU;QACjB,UAAK,GAAL,KAAK,CAAgB;QACrB,sBAAiB,GAAjB,iBAAiB,CAAmB;QA3I/C;;WAEG;QACI,WAAM,GAAW,KAAK,CAAC;QAY9B;;WAEG;QACI,eAAU,GAAsB,UAAU,CAAC;QAElD;;WAEG;QACI,0BAAqB,GAAW,QAAQ,CAAC;QACzC,yBAAoB,GAAW,KAAK,CAAC;QACrC,wBAAmB,GAAW,UAAU,CAAC;QACzC,uBAAkB,GAAW,QAAQ,CAAC;QACtC,cAAS,GAAW,IAAI,CAAC,oBAAoB,CAAC;QAYrD;;WAEG;QACI,WAAM,GAAkB,IAAI,KAAK,EAAU,CAAC;QAEnD;;WAEG;QACI,aAAQ,GAAa,EAAE,CAAC;QAE/B;;WAEG;QACI,mBAAc,GAAa,EAAE,CAAC;QAErC;;WAEG;QACI,UAAK,GAAQ,EAAE,CAAC;QAEvB;;WAEG;QACI,gBAAW,GAAS,IAAI,IAAI,EAAE,CAAC;QAEtC;;WAEG;QACI,iBAAY,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;QAE3I;;WAEG;QACI,aAAQ,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;QAEzF;;WAEG;QACI,aAAQ,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;QAE5D;;WAEG;QACI,gBAAW,GAAW,sVAAsV,CAAC;QAEpX;;WAEG;QACI,uBAAkB,GAAW,eAAe,CAAC;QAEpD;;WAEG;QACI,uBAAkB,GAAW,eAAe,CAAC;QAEpD;;WAEG;QACI,oBAAe,GAAW,yEAAyE,CAAC;QAE3G;;WAEG;QACI,kBAAa,GAAG;YACtB,OAAO,EAAE;gBACR,OAAO,EAAE;oBACR,CAAC,MAAM,EAAE,QAAQ,EAAE,WAAW,CAAC;oBAC/B,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;oBAC7C,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;oBACxC,CAAC,EAAE,MAAM,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,CAAC;oBAC/C,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,CAAC;oBACzC,CAAC,EAAE,OAAO,EAAE,IAAI,KAAK,EAAO,EAAE,EAAE,EAAE,YAAY,EAAE,IAAI,KAAK,EAAO,EAAE,CAAC;oBACnE,CAAC,MAAM,EAAE,OAAO,CAAC;iBACjB;gBACD,SAAS,EAAE;oBACV,WAAW,EAAE,KAAK;iBAClB;aACD;SACD,CAAC;QAyBD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,oBAAoB,CAAC;IAC5C,CAAC;IAED;;;OAGG;IACH,QAAQ;QACP,KAAK,CAAC,QAAQ,EAAE,CAAC;QAEjB,yBAAyB;QACzB,IAAI,EAAE,GAAQ,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACrD,IAAI,EAAE,GAAG,CAAC,EAAE;YACX,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;SACb;aAAM,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,IAAI,EAAE,EAAE,EAAE;YACrD,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,IAAI,EAAE,EAAE,CAAC;SACxC;QAED,qCAAqC;QACrC,IAAI,IAAI,CAAC,EAAE,EAAE;YACZ,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;YACrB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;YACvB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC;SAC5C;QAED,+BAA+B;QAC/B,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE;YACpC,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;YAC5E,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,CAAC;QACnD,CAAC,CAAC,CAAC;QAEH,sBAAsB;QACtB,IAAI,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE;YAClD,IAAI,MAAM,GAAG,EAAE,CAAC;YAEhB,+BAA+B;YAC/B,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC;YACtF,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,CAAC;YAElD,2BAA2B;YAC3B,KAAK,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;gBAC3C,IAAI,CAAC,CAAC,IAAI,EAAE,WAAW,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,iBAAiB,EAAE,CAAC,EAAE;oBACtE,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;iBAC7C;aACD;YAED,OAAO,MAAM,CAAC;QACf,CAAC,CAAC,CAAC,CAAC;QAEJ,sBAAsB;QACtB,aAAa,CAAC,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAoB,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;aAC5F,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;aAC1C,SAAS,CAAC,CAAC,CAAC,EAAE;YACd,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YAE7B,0CAA0C;YAC1C,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;gBACrB,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;aAC1D;QACF,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,eAAe;QACd,KAAK,CAAC,eAAe,EAAE,CAAC;QAExB,oBAAoB;QACpB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;QAE1C,eAAe;QACf,IAAI,CAAC,KAAK,EAAE,CAAC;QAEb;;;WAGG;QACH,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,CAAC;QAEvC,2BAA2B;QAC3B,IAAI,CAAC,QAAQ,EAAE,CAAC;QAEhB,0CAA0C;QAC1C,IAAI,CAAC,UAAU,EAAE,eAAe,EAAE,SAAS,CAAC,CAAC,KAA4B,EAAE,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC;IAC9G,CAAC;IAED;;OAEG;IACI,QAAQ;QACd,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,EAAE,GAAG,CAAC,EAAE;YACnC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;YACtB,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,CAAC;YAEvC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,EAAE,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,EAAE,EAAE,eAAe,EAAE,KAAK,EAAE,CAAC;iBACjH,SAAS,CAAC,IAAI,CAAC,EAAE;gBACjB,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,EAAW,IAAI,CAAC,CAAC;gBAC7D,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;gBAEvB,IAAI,CAAC,eAAe,EAAE,CAAC;YACxB,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC,CAAC;SACjC;IACF,CAAC;IAED;;;OAGG;IACI,IAAI,CAAC,SAAqB,UAAU,CAAC,YAAY,EAAE,OAAe,IAAI;QAC5E,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE;YACpC,OAAO;SACP;QAED,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;QAE1B,IAAI,IAAI,CAAC,UAAU,EAAE;YACpB,IAAI,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,YAAY,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,cAAc,EAAE,CAAC,EAAE,CAAC;iBAC5E,SAAS,CAAC,CAAC,CAAC,EAAE;gBACd,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;YAC1B,CAAC,EAAE,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;SACtC;aAAM;YACN,IAAI,CAAC,MAAM,EAAW;iBACpB,SAAS,CAAC,QAAQ,CAAC,EAAE;gBACrB,IAAI,MAAM,IAAI,UAAU,CAAC,WAAW,EAAE;oBACrC,IAAI,CAAC,EAAE,GAAG,QAAQ,CAAC,EAAE,CAAC;iBACtB;gBAED,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;gBAEzB,IAAI,IAAI,EAAE;oBACT,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;wBACxC,IAAI,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;wBAC7B,GAAG,CAAC,cAAc,EAAE,CAAC;wBACrB,GAAG,CAAC,eAAe,EAAE,CAAC;wBACtB,GAAG,CAAC,sBAAsB,EAAE,CAAC;oBAC9B,CAAC,CAAC,CAAC;iBACH;YACF,CAAC,EAAE,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;SACtC;IACF,CAAC;IAED;;;OAGG;IACO,WAAW,CAAC,OAAe,IAAI;QACxC,kCAAkC;QAClC,IAAI,IAAI,CAAC,KAAK,EAAE;YACf,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;YAE3B,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;gBACxC,MAAM,aAAa,GAAqB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;gBAClE,IAAI,aAAa,IAAI,IAAI,EAAE;oBAC1B,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;wBAC7C,OAAO,CAAC,GAAG,CAAC,eAAe,GAAG,GAAG,GAAG,cAAc,GAAG,QAAQ,GAAG,eAAe,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC;oBAC3G,CAAC,CAAC,CAAC;iBACH;YACF,CAAC,CAAC,CAAC;SACH;QAED,iCAAiC;QACjC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE;YAChB,iDAAiD;YACjD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;iBACxB,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;iBACpC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YAE7D,yBAAyB;YACzB,CAAC,KAAK,IAAI,EAAE;gBACX,sCAAsC;gBACtC,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;gBAE3C,8BAA8B;gBAC9B,IAAI,MAAM,GAAG,KAAK,EAAU,CAAC;gBAC7B,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;qBACxB,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;qBACpC,OAAO,CAAC,GAAG,CAAC,EAAE;oBACd,oBAAoB;oBACpB,IAAI,KAAK,GAAG,IAAI,CAAC,eAAe,CAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAS,CAAC,aAAa,CAAC,CAAC;oBAC5E,IAAI,KAAK,EAAE;wBACV,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;qBACnB;gBACF,CAAC,CAAC,CAAC;gBAEJ,yBAAyB;gBACzB,IAAI,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,yEAAyE,CAAC;gBAExI,mBAAmB;gBACnB,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;YACrF,CAAC,CAAC,EAAE,CAAC;YAEL,OAAO,KAAK,CAAC;SACb;QAED,OAAO,IAAI,CAAC;IACb,CAAC;IAED;;;;OAIG;IACI,SAAS,CAAC,IAAY;QAC5B,IAAI,CAAC,IAAI,EAAE;YACV,OAAO;SACP;QAED,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;YACxC,IAAI,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;YAC7B,GAAG,CAAC,cAAc,EAAE,CAAC;YACrB,GAAG,CAAC,eAAe,EAAE,CAAC;YACtB,GAAG,CAAC,sBAAsB,EAAE,CAAC;QAC9B,CAAC,CAAC,CAAC;IACJ,CAAC;IAED;;;OAGG;IACO,iBAAiB,CAAC,OAAwB;QACnD,oCAAoC;QACpC,IAAI,CAAC,OAAO,EAAE;YACb,OAAO;SACP;QAED,qCAAqC;QACrC,IAAI,SAAS,GAAG,OAAoB,CAAC;QACrC,IAAI,SAAS,IAAI,SAAS,CAAC,QAAQ,EAAE;YACpC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC;iBAC7B,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;iBACzC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;SAC9D;aAAM;YACN,OAAO,CAAC,WAAW,EAAE,CAAC;YACtB,OAAO,CAAC,aAAa,EAAE,CAAC;SACxB;IACF,CAAC;IAED;;OAEG;IACI,KAAK;QACX,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;IACnC,CAAC;IAED;;;OAGG;IACI,IAAI,CAAC,SAAqB,UAAU,CAAC,YAAY;QACvD,IAAI,MAAM,IAAI,UAAU,CAAC,YAAY,IAAI,IAAI,CAAC,SAAS,EAAE;YACxD,IAAI,QAAQ,GAAG,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACjD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,EAAE,WAAW,EAAE,QAAQ,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;SAChG;aAAM;YACN,IAAI,IAAI,CAAC,UAAU,EAAE;gBACpB,IAAI,MAAM,IAAI,UAAU,CAAC,YAAY,EAAE;oBACtC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;iBACrB;qBAAM,IAAI,MAAM,IAAI,UAAU,CAAC,WAAW,EAAE;oBAC5C,IAAI,CAAC,UAAU,EAAE,CAAC;iBAClB;aACD;iBAAM;gBACN,IAAI,MAAM,IAAI,UAAU,CAAC,YAAY,EAAE;oBACtC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;iBACrB;qBAAM,IAAI,MAAM,IAAI,UAAU,CAAC,WAAW,IAAI,IAAI,CAAC,EAAE,GAAG,CAAC,EAAE;oBAC3D,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,GAAG,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,UAAU,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;iBAC5F;qBAAM,IAAI,MAAM,IAAI,UAAU,CAAC,UAAU,EAAE;oBAC3C,IAAI,CAAC,WAAW,EAAE,CAAC;iBACnB;aACD;SACD;IACF,CAAC;IAED;;OAEG;IACO,WAAW;QACpB,OAAO,IAAI,CAAC,IAAI,GAAG,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;IAC1C,CAAC;IAED;;OAEG;IACO,MAAM,CAAU,WAAoB;QAC7C,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAU,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,WAAW,IAAI,EAAE,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,aAAa,CAAC,EAAE,cAAc,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;IAC3J,CAAC;IAED;;OAEG;IACO,MAAM,CAAC,WAAoB;QACpC,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,WAAW,IAAI,EAAE,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,aAAa,CAAC,EAAE,cAAc,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;IAC3J,CAAC;IAED;;;;OAIG;IACO,OAAO,CAAC,GAAW,EAAE,SAAkB,KAAK;QACrD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACxB,IAAI,MAAM,EAAE;YACX,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;SAC9B;IACF,CAAC;IAED;;;OAGG;IACO,iBAAiB,CAAC,MAA6B,IAAU,CAAC;IAEpE;;OAEG;IACO,eAAe,KAAW,CAAC;IAAA,CAAC;IAEtC;;OAEG;IACO,YAAY,KAAW,CAAC;IAAA,CAAC;IAEnC;;OAEG;IACO,YAAY,KAAW,CAAC;IAAA,CAAC;IAEnC;;OAEG;IACO,YAAY,CAAC,IAAgB,UAAU,CAAC,YAAY,IAAU,CAAC;IAEzE;;OAEG;IACO,WAAW,CAAC,SAAqB,UAAU,CAAC,YAAY;QACjE,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACnB,CAAC;IAED;;OAEG;IACO,WAAW;QACpB,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IAC3D,CAAC;IAED;;OAEG;IACO,KAAK;QACd,gCAAgC;QAChC,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,aAAa,EAAE;YACrE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;SACvC;IACF,CAAC;IAED;;;OAGG;IACO,eAAe,CAAC,aAAkB;QAC3C,0CAA0C;QAC1C,IAAI,YAAY,GAAG,aAAa,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC;QAC5D,IAAI,CAAC,YAAY,EAAE;YAClB,OAAO,IAAI,CAAC;SACZ;QAED,mCAAmC;QACnC,IAAI,QAAQ,GAAG,YAAY,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC;QACxD,IAAI,CAAC,QAAQ,EAAE;YACd,OAAO,IAAI,CAAC;SACZ;QAED,OAAO,QAAQ,CAAC,WAAW,CAAC;IAC7B,CAAC;IAED;;;OAGG;IAEH,mBAAmB,CAAC,KAAoB;QACvC,IAAI,KAAK,CAAC,OAAO,IAAI,KAAK,CAAC,OAAO,EAAE;YACnC,QAAQ,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,EAAE;gBACvD,KAAK,GAAG;oBACP,KAAK,CAAC,cAAc,EAAE,CAAC;oBACvB,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;oBACnC,MAAM;gBAEP,KAAK,GAAG;oBACP,KAAK,CAAC,cAAc,EAAE,CAAC;oBACvB,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;oBACjC,MAAM;gBAEP,KAAK,GAAG;oBACP,KAAK,CAAC,cAAc,EAAE,CAAC;oBACvB,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;oBAClC,MAAM;aACP;SACD;QAED,oDAAoD;QACpD,IAAI,KAAK,CAAC,OAAO,IAAI,EAAE,EAAE;YACxB,IAAI,CAAC,IAAI,EAAE,CAAC;SACZ;IACF,CAAC;;uJAviBoB,oBAAoB;2IAApB,oBAAoB,kJA2H9B,UAAU;2FA3HA,oBAAoB;kBADzC,SAAS;+KA6HC,UAAU;sBADnB,SAAS;uBAAC,UAAU;gBAOd,KAAK;sBADX,YAAY;uBAAC,OAAO;gBA8YrB,mBAAmB;sBADlB,YAAY;uBAAC,kBAAkB,EAAE,CAAC,QAAQ,CAAC","sourcesContent":["import { StepperSelectionEvent } from '@angular/cdk/stepper';\r\nimport { ChangeDetectorRef, Directive, HostListener, ViewChild, ViewChildren } from '@angular/core';\r\nimport { AbstractControl, FormGroup, NgForm, ValidationErrors } from '@angular/forms';\r\nimport { MatStepper } from '@angular/material/stepper';\r\nimport { ActivatedRoute } from '@angular/router';\r\nimport { combineLatest, Observable } from 'rxjs';\r\nimport { map } from 'rxjs/operators';\r\nimport { Utils } from '../../common/functions/utils';\r\nimport { IEntity } from '../../common/models/entity';\r\nimport { SaveAction } from '../../common/models/save-action';\r\nimport { GenericService } from '../../http/services/generic.service';\r\nimport { BaseComponent } from './base.component';\r\n\r\n// @dynamic\r\n@Directive()\r\nexport abstract class GenericFormComponent<TEntity extends IEntity, TService extends GenericService<TEntity>> extends BaseComponent {\r\n\t/**\r\n\t * The action of the form (add | edit)\r\n\t */\r\n\tpublic action: string = 'add';\r\n\r\n\t/**\r\n\t * A url to return to after save\r\n\t */\r\n\tpublic returnUrl: string;\r\n\r\n\t/**\r\n\t * Action = edit?\r\n\t */\r\n\tpublic isEditMode: boolean;\r\n\r\n\t/**\r\n\t * Save action\r\n\t */\r\n\tpublic SaveAction: typeof SaveAction = SaveAction;\r\n\r\n\t/**\r\n\t * Routes\r\n\t */\r\n\tpublic editSaveAndCloseRoute: string = '../../';\r\n\tpublic addSaveAndCloseRoute: string = '../';\r\n\tpublic addSaveAndEditRoute: string = '../edit/';\r\n\tpublic addSaveAndNewRoute: string = '../add';\r\n\tpublic listRoute: string = this.addSaveAndCloseRoute;\r\n\r\n\t/**\r\n\t * The id of the item to load\r\n\t */\r\n\tpublic id: number;\r\n\r\n\t/**\r\n\t * The current item to add or edit\r\n\t */\r\n\tpublic item: TEntity;\r\n\r\n\t/**\r\n\t * Represents the request errors\r\n\t */\r\n\tpublic errors: Array<string> = new Array<string>();\r\n\r\n\t/**\r\n\t * Includes\r\n\t */\r\n\tpublic includes: string[] = [];\r\n\r\n\t/**\r\n\t * Update includes\r\n\t */\r\n\tpublic updateIncludes: string[] = [];\r\n\r\n\t/**\r\n\t * Get params\r\n\t */\r\n\tpublic query: any = {};\r\n\r\n\t/**\r\n\t * The current date\r\n\t */\r\n\tpublic currentDate: Date = new Date();\r\n\r\n\t/**\r\n\t * Date & time mask\r\n\t */\r\n\tpublic dateTimeMask = [/[0-3]/, /[0-9]/, '.', /[0-1]/, /[0-9]/, '.', 2, 0, /[1-2]/, /[0-9]/, ' ', /[0-2]/, /[0-9]/, ':', /[0-5]/, /[0-9]/];\r\n\r\n\t/**\r\n\t * Date mask\r\n\t */\r\n\tpublic dateMask = [/[0-3]/, /[0-9]/, '.', /[0-1]/, /[0-9]/, '.', 2, 0, /[1-2]/, /[0-9]/];\r\n\r\n\t/**\r\n\t * Time mask\r\n\t */\r\n\tpublic timeMask = [/[0-2]/, /[0-9]/, ':', /[0-5]/, /[0-9]/];\r\n\r\n\t/**\r\n\t * A pattern to validate dates\r\n\t */\r\n\tpublic datePattern: string = `(?:(?:31(\\\\/|-|\\\\.)(?:0?[13578]|1[02]))\\\\1|(?:(?:29|30)(\\\\/|-|\\\\.)(?:0?[1,3-9]|1[0-2])\\\\2))(?:(?:1[6-9]|[2-9]\\\\d)?\\\\d{2})$|^(?:29(\\\\/|-|\\\\.)0?2\\\\3(?:(?:(?:1[6-9]|[2-9]\\\\d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00))))$|^(?:0?[1-9]|1\\\\d|2[0-8])(\\\\/|-|\\\\.)(?:(?:0?[1-9])|(?:1[0-2]))\\\\4(?:(?:1[6-9]|[2-9]\\\\d)?\\\\d{2})`;\r\n\r\n\t/**\r\n\t * Phone prefix validation pattern\r\n\t */\r\n\tpublic phonePrefixPattern: string = '^(0\\\\d{2,6})$';\r\n\r\n\t/**\r\n\t * Phone number validation pattern\r\n\t */\r\n\tpublic phoneNumberPattern: string = '^(\\\\d{3,30})$';\r\n\r\n\t/**\r\n\t * Password validation pattern\r\n\t */\r\n\tpublic passwordPattern: string = '^(?=.*[a-z])(?=.*[A-Z])(?=.*\\\\d)(?=.*[$@$!%*?&])[A-Za-z\\\\d$@$!%*?&]{6,}';\r\n\r\n\t/**\r\n\t * Defaults modules and toolbar\r\n\t */\r\n\tpublic editorOptions = {\r\n\t\tmodules: {\r\n\t\t\ttoolbar: [\r\n\t\t\t\t['bold', 'italic', 'underline'],\r\n\t\t\t\t[{ 'list': 'ordered' }, { 'list': 'bullet' }],\r\n\t\t\t\t[{ 'indent': '-1' }, { 'indent': '+1' }],\r\n\t\t\t\t[{ 'size': ['small', false, 'large', 'huge'] }],\r\n\t\t\t\t[{ 'header': [1, 2, 3, 4, 5, 6, false] }],\r\n\t\t\t\t[{ 'color': new Array<any>() }, { 'background': new Array<any>() }],\r\n\t\t\t\t['link', 'image']\r\n\t\t\t],\r\n\t\t\tclipboard: {\r\n\t\t\t\tmatchVisual: false\r\n\t\t\t}\r\n\t\t}\r\n\t};\r\n\r\n\t/**\r\n\t * MatStepper ref\r\n\t */\r\n\t@ViewChild(MatStepper)\r\n\tprotected matStepper: MatStepper;\r\n\r\n\t/**\r\n\t * A reference to the input element\r\n\t */\r\n\t@ViewChildren('focus')\r\n\tpublic input: any;\r\n\r\n\t/**\r\n\t * Constructor\r\n\t * @param service \r\n\t */\r\n\tconstructor(\r\n\t\tpublic entityCtor: { new(): TEntity },\r\n\t\tprotected service: TService,\r\n\t\tprotected route: ActivatedRoute,\r\n\t\tprotected changeDetectorRef: ChangeDetectorRef\r\n\t) {\r\n\t\tsuper(route, changeDetectorRef);\r\n\t\tthis.listRoute = this.addSaveAndCloseRoute;\r\n\t}\r\n\r\n\t/**\r\n\t * Called after the constructor, initializing input properties, \r\n\t * and the first call to ngOnChanges.\r\n\t */\r\n\tngOnInit(): void {\r\n\t\tsuper.ngOnInit();\r\n\r\n\t\t/* Get id from the url */\r\n\t\tlet id = <any>this.route.snapshot.paramMap.get('id');\r\n\t\tif (id > 0) {\r\n\t\t\tthis.id = id;\r\n\t\t} else if (!this.id && this.route.snapshot?.data?.id) {\r\n\t\t\tthis.id = this.route.snapshot?.data?.id;\r\n\t\t}\r\n\r\n\t\t/* Set some variable for edit mode */\r\n\t\tif (this.id) {\r\n\t\t\tthis.action = 'edit';\r\n\t\t\tthis.isEditMode = true;\r\n\t\t\tthis.listRoute = this.editSaveAndCloseRoute;\r\n\t\t}\r\n\r\n\t\t/* Get the return url if any */\r\n\t\tthis.route.queryParams.subscribe(x => {\r\n\t\t\tthis.returnUrl = x.returnUrl ? decodeURIComponent(atob(x.returnUrl)) : null;\r\n\t\t\tthis.listRoute = this.returnUrl || this.listRoute;\r\n\t\t});\r\n\r\n\t\t/* Get route params */\r\n\t\tvar params = this.route.params.pipe(map((x: any) => {\r\n\t\t\tlet params = {};\r\n\r\n\t\t\t/* Get the return url if any */\r\n\t\t\tthis.returnUrl = x.returnUrl ? decodeURIComponent(atob(x.returnUrl)) : this.returnUrl;\r\n\t\t\tthis.listRoute = this.returnUrl || this.listRoute;\r\n\r\n\t\t\t/* Clone params to query */\r\n\t\t\tfor (let [key, value] of Object.entries(x)) {\r\n\t\t\t\tif (!['id', 'returnurl', 'panelId'].includes(key.toLocaleLowerCase())) {\r\n\t\t\t\t\tparams[key] = isNaN(+value) ? value : +value;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\treturn params;\r\n\t\t}));\r\n\r\n\t\t/* Combine the data */\r\n\t\tcombineLatest([params, this.route.data.pipe(map((data: { query: any }) => data.query || {}))])\r\n\t\t\t.pipe(map(([a, b]) => Object.assign(a, b)))\r\n\t\t\t.subscribe(x => {\r\n\t\t\t\tObject.assign(this.query, x);\r\n\r\n\t\t\t\t/* Create a new instance of the TEntity */\r\n\t\t\t\tif (!this.isEditMode) {\r\n\t\t\t\t\tthis.item = Object.assign(this.newInstance(), this.query);\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t}\r\n\r\n\t/**\r\n\t * Lifecycle hook that is called after a component's view has been fully initialized.\r\n\t */\r\n\tngAfterViewInit(): void {\r\n\t\tsuper.ngAfterViewInit();\r\n\r\n\t\t/* Set page title */\r\n\t\tthis.title = this.titleService.getTitle();\r\n\r\n\t\t/* Set focus */\r\n\t\tthis.focus();\r\n\r\n\t\t/* \r\n\t\t * Force a new change detection cycle since change detections \r\n\t\t * have finished when `ngAfterViewInit` is executed\r\n\t\t */\r\n\t\tthis.changeDetectorRef.detectChanges();\r\n\r\n\t\t/* Load item from server */\r\n\t\tthis.loadItem();\r\n\r\n\t\t/* Listen for stepper selection changes */\r\n\t\tthis.matStepper?.selectionChange?.subscribe((event: StepperSelectionEvent) => this.onAfterStepChange(event));\r\n\t}\r\n\r\n\t/**\r\n\t * Loads an item by ID\r\n\t */\r\n\tpublic loadItem(): void {\r\n\t\tif (this.isEditMode && this.id > 0) {\r\n\t\t\tthis.isLoading = true;\r\n\t\t\tthis.changeDetectorRef.detectChanges();\r\n\r\n\t\t\tthis.service.get(this.id, Object.assign(this.query || {}, { includes: this.includes }), { 'Disable-Cache': 'Yes' })\r\n\t\t\t\t.subscribe(item => {\r\n\t\t\t\t\tthis.item = Object.assign(this.newInstance(), <TEntity>item);\r\n\t\t\t\t\tthis.isLoading = false;\r\n\r\n\t\t\t\t\tthis.afterItemLoaded();\r\n\t\t\t\t}, _ => this.isLoading = false);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Saves data into database.\r\n\t * @param action\r\n\t */\r\n\tpublic save(action: SaveAction = SaveAction.SaveAndClose, form: NgForm = null): void {\r\n\t\tif (form && !this.isFormValid(form)) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tthis.isSaving = true;\r\n\t\tthis.beforeSubmit(action);\r\n\r\n\t\tif (this.isEditMode) {\r\n\t\t\tthis.update({ params: Utils.toHttpParams({ includes: this.updateIncludes }) })\r\n\t\t\t\t.subscribe(_ => {\r\n\t\t\t\t\tthis.afterSubmit(action);\r\n\t\t\t\t}, error => this.parseErrors(error));\r\n\t\t} else {\r\n\t\t\tthis.create<TEntity>()\r\n\t\t\t\t.subscribe(response => {\r\n\t\t\t\t\tif (action == SaveAction.SaveAndEdit) {\r\n\t\t\t\t\t\tthis.id = response.id;\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tthis.afterSubmit(action);\r\n\r\n\t\t\t\t\tif (form) {\r\n\t\t\t\t\t\tObject.keys(form.controls).forEach(key => {\r\n\t\t\t\t\t\t\tlet ctr = form.controls[key];\r\n\t\t\t\t\t\t\tctr.markAsPristine();\r\n\t\t\t\t\t\t\tctr.markAsUntouched();\r\n\t\t\t\t\t\t\tctr.updateValueAndValidity();\r\n\t\t\t\t\t\t});\r\n\t\t\t\t\t}\r\n\t\t\t\t}, error => this.parseErrors(error));\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Validates the form\r\n\t * @param form \r\n\t */\r\n\tprotected isFormValid(form: NgForm = null): boolean {\r\n\t\t/* Print some debug information */\r\n\t\tif (this.debug) {\r\n\t\t\tconsole.log('Form:', form);\r\n\r\n\t\t\tObject.keys(form.controls).forEach(key => {\r\n\t\t\t\tconst controlErrors: ValidationErrors = form.controls[key].errors;\r\n\t\t\t\tif (controlErrors != null) {\r\n\t\t\t\t\tObject.keys(controlErrors).forEach(keyError => {\r\n\t\t\t\t\t\tconsole.log('Key control: ' + key + ', keyError: ' + keyError + ', err value: ', controlErrors[keyError]);\r\n\t\t\t\t\t});\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\t}\r\n\r\n\t\t/* If the form ist not valid.. */\r\n\t\tif (!form.valid) {\r\n\t\t\t/* Mark invalid controls as dirtty and touched */\r\n\t\t\tObject.keys(form.controls)\r\n\t\t\t\t.filter(x => !form.controls[x].valid)\r\n\t\t\t\t.forEach(key => this.invalidateControl(form.controls[key]));\r\n\r\n\t\t\t/* Show error messages */\r\n\t\t\t(async () => {\r\n\t\t\t\t/* Wait until 'mat-error' displayed */\r\n\t\t\t\tawait new Promise(y => setTimeout(y, 200));\r\n\r\n\t\t\t\t/* Parse the error messages */\r\n\t\t\t\tvar errors = Array<string>();\r\n\t\t\t\tObject.keys(form.controls)\r\n\t\t\t\t\t.filter(x => !form.controls[x].valid)\r\n\t\t\t\t\t.forEach(key => {\r\n\t\t\t\t\t\t/* Get error text */\r\n\t\t\t\t\t\tvar error = this.getElementError((form.controls[key] as any).nativeElement);\r\n\t\t\t\t\t\tif (error) {\r\n\t\t\t\t\t\t\terrors.push(error);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t});\r\n\r\n\t\t\t\t/* Build error message */\r\n\t\t\t\tvar message = errors.length ? errors.slice(0, 3).join('\\n') : `Bitte überprüfen Sie Ihre Abgaben und korrigieren fehlerhafte Eingaben!`;\r\n\r\n\t\t\t\t/* show a notice */\r\n\t\t\t\tthis.snackBarService.open(message, 'Ok', { duration: 3000, panelClass: ['error'] });\r\n\t\t\t})();\r\n\r\n\t\t\treturn false;\r\n\t\t}\r\n\r\n\t\treturn true;\r\n\t}\r\n\r\n\t/**\r\n\t * Resets form controls\r\n\t * @param form \r\n\t * @returns \r\n\t */\r\n\tpublic resetForm(form: NgForm): void {\r\n\t\tif (!form) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tObject.keys(form.controls).forEach(key => {\r\n\t\t\tlet ctr = form.controls[key];\r\n\t\t\tctr.markAsPristine();\r\n\t\t\tctr.markAsUntouched();\r\n\t\t\tctr.updateValueAndValidity();\r\n\t\t});\r\n\t}\r\n\r\n\t/**\r\n\t * Invalidate controls recursively\r\n\t * @param control \r\n\t */\r\n\tprotected invalidateControl(control: AbstractControl): void {\r\n\t\t/* Check the control against null */\r\n\t\tif (!control) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\t/* Check if the control is a group */\r\n\t\tlet formGroup = control as FormGroup;\r\n\t\tif (formGroup && formGroup.controls) {\r\n\t\t\tObject.keys(formGroup.controls)\r\n\t\t\t\t.filter(x => !formGroup.controls[x].valid)\r\n\t\t\t\t.forEach(x => this.invalidateControl(formGroup.controls[x]));\r\n\t\t} else {\r\n\t\t\tcontrol.markAsDirty();\r\n\t\t\tcontrol.markAsTouched();\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Saves data and navigates to edit view\r\n\t */\r\n\tpublic apply(): void {\r\n\t\tthis.save(SaveAction.SaveAndEdit);\r\n\t}\r\n\r\n\t/**\r\n\t * Loads the previous URL in the history list.\r\n\t * @param action\r\n\t */\r\n\tpublic back(action: SaveAction = SaveAction.SaveAndClose): void {\r\n\t\tif (action == SaveAction.SaveAndClose && this.returnUrl) {\r\n\t\t\tvar urlParts = Utils.getUrlParts(this.returnUrl);\r\n\t\t\tthis.router.navigate([urlParts.url], { queryParams: urlParts.params, fragment: urlParts.hash });\r\n\t\t} else {\r\n\t\t\tif (this.isEditMode) {\r\n\t\t\t\tif (action == SaveAction.SaveAndClose) {\r\n\t\t\t\t\tthis.location.back();\r\n\t\t\t\t} else if (action == SaveAction.SaveAndEdit) {\r\n\t\t\t\t\tthis.reloadPage();\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\tif (action == SaveAction.SaveAndClose) {\r\n\t\t\t\t\tthis.location.back();\r\n\t\t\t\t} else if (action == SaveAction.SaveAndEdit && this.id > 0) {\r\n\t\t\t\t\tthis.router.navigate([`${this.addSaveAndEditRoute}${this.id}`], { relativeTo: this.route });\r\n\t\t\t\t} else if (action == SaveAction.SaveAndNew) {\r\n\t\t\t\t\tthis.afterReload();\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Creates a new instance of the TEntity\r\n\t */\r\n\tprotected newInstance(): TEntity {\r\n\t\treturn this.item = new this.entityCtor();\r\n\t}\r\n\r\n\t/**\r\n\t * Creates the entity\r\n\t */\r\n\tprotected create<TEntity>(httpOptions?: Object): Observable<TEntity> {\r\n\t\tthis.beforeCreate();\r\n\t\treturn this.service.create<TEntity>(this.item, null, Object.assign(httpOptions || {}, { headers: this.toHttpHeaders({ 'Show-Message': 'yes' }) }), false);\r\n\t}\r\n\r\n\t/**\r\n\t * updates the entity\r\n\t */\r\n\tprotected update(httpOptions?: Object): Observable<TEntity> {\r\n\t\tthis.beforeUpdate();\r\n\t\treturn this.service.update(this.id, this.item, null, Object.assign(httpOptions || {}, { headers: this.toHttpHeaders({ 'Show-Message': 'yes' }) }), false);\r\n\t}\r\n\r\n\t/**\r\n\t * Includes some navigations\r\n\t * @param inc \r\n\t * @param update \r\n\t */\r\n\tprotected include(inc: string, update: boolean = false) {\r\n\t\tthis.includes.push(inc);\r\n\t\tif (update) {\r\n\t\t\tthis.updateIncludes.push(inc);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Event emitted when the selected step has changed.\r\n\t * @param $event \r\n\t */\r\n\tprotected onAfterStepChange($event: StepperSelectionEvent): void { }\r\n\r\n\t/**\r\n\t * Called after the item is loaded\r\n\t */\r\n\tprotected afterItemLoaded(): void { };\r\n\r\n\t/**\r\n\t * Called before the entity get created\r\n\t */\r\n\tprotected beforeCreate(): void { };\r\n\r\n\t/**\r\n\t * Called before the entity get updated\r\n\t */\r\n\tprotected beforeUpdate(): void { };\r\n\r\n\t/**\r\n\t * Called before data submition\r\n\t */\r\n\tprotected beforeSubmit(_: SaveAction = SaveAction.SaveAndClose): void { }\r\n\r\n\t/**\r\n\t * Called after data submition\r\n\t */\r\n\tprotected afterSubmit(action: SaveAction = SaveAction.SaveAndClose): void {\r\n\t\tthis.isSaving = false;\r\n\t\tthis.back(action);\r\n\t}\r\n\r\n\t/**\r\n\t * Called after page reloaded\r\n\t */\r\n\tprotected afterReload(): void {\r\n\t\tthis.item = Object.assign(this.newInstance(), this.query);\r\n\t}\r\n\r\n\t/**\r\n\t * Sets focus to first input\r\n\t */\r\n\tprotected focus(): void {\r\n\t\t/* Set focus to first element */\r\n\t\tif (this.input && this.input.first && this.input.first.nativeElement) {\r\n\t\t\tthis.input.first.nativeElement.focus();\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Gets element error\r\n\t * @param nativeElement \r\n\t */\r\n\tprotected getElementError(nativeElement: any): string {\r\n\t\t/* Get paranet element 'mat-form-field' */\r\n\t\tvar matFormField = nativeElement.closest('.mat-form-field');\r\n\t\tif (!matFormField) {\r\n\t\t\treturn null;\r\n\t\t}\r\n\r\n\t\t/* Get child element 'mat-error' */\r\n\t\tvar matError = matFormField.querySelector('.mat-error');\r\n\t\tif (!matError) {\r\n\t\t\treturn null;\r\n\t\t}\r\n\r\n\t\treturn matError.textContent;\r\n\t}\r\n\r\n\t/**\r\n\t * Responds to user-initiated events\r\n\t * @param event \r\n\t */\r\n\t@HostListener('document:keydown', ['$event'])\r\n\thandleKeyboardEvent(event: KeyboardEvent) {\r\n\t\tif (event.ctrlKey || event.metaKey) {\r\n\t\t\tswitch (String.fromCharCode(event.which).toLowerCase()) {\r\n\t\t\t\tcase 's':\r\n\t\t\t\t\tevent.preventDefault();\r\n\t\t\t\t\tthis.save(SaveAction.SaveAndClose);\r\n\t\t\t\t\tbreak;\r\n\r\n\t\t\t\tcase 'd':\r\n\t\t\t\t\tevent.preventDefault();\r\n\t\t\t\t\tthis.save(SaveAction.SaveAndNew);\r\n\t\t\t\t\tbreak;\r\n\r\n\t\t\t\tcase 'e':\r\n\t\t\t\t\tevent.preventDefault();\r\n\t\t\t\t\tthis.save(SaveAction.SaveAndEdit);\r\n\t\t\t\t\tbreak;\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t/* Cancel the form, if the user press the ESC key */\r\n\t\tif (event.keyCode == 27) {\r\n\t\t\tthis.back();\r\n\t\t}\r\n\t}\r\n}"]}