@messaia/cdk 12.3.5-rc21 → 13.0.0-rc02

package/esm2020/lib/base/base.module.mjs

@@ -0,0 +1,64 @@
+import { CommonModule } from '@angular/common';
+import { HTTP_INTERCEPTORS } from '@angular/common/http';
+import { NgModule } from '@angular/core';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { MatDialogModule } from '@angular/material/dialog';
+import { BaseComponent } from './components/base.component';
+import { GenericFormComponent } from './components/generic-form.component';
+import { GenericListComponent } from './components/generic-list.component';
+import { Common } from './constants/common';
+import { MessageType } from './enums/message-type';
+import { AuthHelper } from './helpers/auth-helper';
+import { BaseInterceptor } from './interceptors/base.interceptor';
+import { CachingInterceptor } from './interceptors/caching-interceptor';
+import { LoadingScreenInterceptor } from './interceptors/loading.interceptor';
+import { AuthUser } from './models/auth-user';
+import { FileService } from './services/file.service';
+import { LoadingScreenService } from './services/loading-screen.service';
+import { PrintService } from './services/print.service';
+import * as i0 from "@angular/core";
+export { AuthUser, MessageType, AuthHelper, BaseComponent, GenericListComponent, GenericFormComponent, Common, BaseInterceptor, CachingInterceptor, LoadingScreenInterceptor, FileService, LoadingScreenService, PrintService };
+const DECLARATIONS = [];
+const MATRIAL_DECLARATIONS = [];
+export class VdBaseModule {
+}
+/** @nocollapse */ /** @nocollapse */ VdBaseModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: VdBaseModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ /** @nocollapse */ VdBaseModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: VdBaseModule, imports: [CommonModule,
+        FormsModule,
+        ReactiveFormsModule,
+        MatDialogModule] });
+/** @nocollapse */ /** @nocollapse */ VdBaseModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: VdBaseModule, providers: [
+        { provide: HTTP_INTERCEPTORS, useClass: BaseInterceptor, multi: true },
+        { provide: HTTP_INTERCEPTORS, useClass: CachingInterceptor, multi: true },
+        { provide: HTTP_INTERCEPTORS, useClass: LoadingScreenInterceptor, multi: true },
+    ], imports: [[
+            CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            MatDialogModule,
+            MATRIAL_DECLARATIONS
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: VdBaseModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        MatDialogModule,
+                        MATRIAL_DECLARATIONS
+                    ],
+                    providers: [
+                        { provide: HTTP_INTERCEPTORS, useClass: BaseInterceptor, multi: true },
+                        { provide: HTTP_INTERCEPTORS, useClass: CachingInterceptor, multi: true },
+                        { provide: HTTP_INTERCEPTORS, useClass: LoadingScreenInterceptor, multi: true },
+                    ],
+                    declarations: [
+                        DECLARATIONS
+                    ],
+                    exports: [
+                        DECLARATIONS
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/base/components/base.component.mjs

@@ -0,0 +1,436 @@
+import { Location } from '@angular/common';
+import { HttpHeaders } from '@angular/common/http';
+import { ChangeDetectorRef, Directive, ElementRef, QueryList, ViewChildren } from '@angular/core';
+import { MatExpansionPanel } from '@angular/material/expansion';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { Title } from '@angular/platform-browser';
+import { ActivatedRoute, NavigationEnd, Router } from '@angular/router';
+import { of } from 'rxjs';
+import { ContextHelper } from '../../common/common.module';
+import { AppSetting } from '../../common/models/app-setting';
+import { ServiceLocator } from '../../common/services/service-locator';
+import { VdDialogService } from '../../dialogs/services/dialog.service';
+import { VdMediaService } from '../../media/services/media.service';
+import { Common } from '../constants/common';
+import { MessageType } from '../enums/message-type';
+import { AuthHelper } from '../helpers/auth-helper';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+/**
+ * A base list component for components with pagination support
+ */
+// @dynamic
+export class BaseComponent {
+    /**
+     * Constructor
+     */
+    constructor(route, changeDetectorRef) {
+        this.route = route;
+        this.changeDetectorRef = changeDetectorRef;
+        /**
+         * The subtitle of the current outlet
+         */
+        this.subtitle = '';
+        /**
+         * Represents the request errors
+         */
+        this.errors = new Array();
+        /**
+         * Allowed file extensions
+         */
+        this.allowedExtensions = Common.allowedExtensions;
+        /**
+         * tinyMCE plugins
+         */
+        this.editorPlugins = Common.editorPlugins;
+        /**
+         * tinyMCE editor
+         */
+        this.editorToolbar = Common.editorToolbar;
+        /**
+         * Editor configuration
+         */
+        this.editorConfig = {};
+        /**
+         * urlHash: string
+         */
+        this.urlHash = null;
+        /**
+         * Current user object
+         */
+        this.currentUser = AuthHelper.user;
+        /**
+         * If true, set url hash
+         */
+        this.setUrlHash = true;
+        this.titleService = this.getService(Title);
+        this.dialogService = this.getService(VdDialogService);
+        this.media = this.getService(VdMediaService);
+        this.snackBarService = this.getService(MatSnackBar);
+        this.router = this.getService(Router);
+        this.appSetting = this.getService(AppSetting);
+        this.location = this.getService(Location);
+        ContextHelper.activatedRoute = route;
+        ContextHelper.router = this.router;
+        ContextHelper.appSetting = this.appSetting;
+        this.initEditor();
+    }
+    get isSaving() { return this._isSaving || this.isLoading; }
+    set isSaving(isSaving) { this.isLoading = this._isSaving = isSaving; }
+    /**
+     * Lifecycle hook that is called after data-bound properties
+     * of a directive are initialized.
+     */
+    ngOnInit() {
+        /* Get menu items from route snapshot */
+        var mainRoute = this.getMainRoute(this.route.snapshot);
+        if (mainRoute) {
+            this.menu = mainRoute.data.menu;
+        }
+        /* Set project name & debug mode */
+        this.projectName = this.appSetting.projectName;
+        this.debug = this.appSetting.debug;
+        /* Get the hash from the url */
+        this.route.fragment.subscribe((fragment) => this.urlHash = fragment);
+        /**
+         * Check permissions
+         */
+        if (this.route.parent) {
+            this.route.parent.url.subscribe((url) => {
+                this.className = url[0].path.replace(/(.*)s$/, '$1').replace(/^./, (url[0].path[0] || '').toUpperCase());
+                this.canCreate = AuthHelper.isPermitted('Create', `Create${this.className}`);
+                this.canUpdate = AuthHelper.isPermitted('Update', `Update${this.className}`);
+            });
+        }
+        /* Set current route */
+        this.currentRoute = btoa(this.router.url);
+        /**
+         * Set page title
+         */
+        this.router.events.subscribe(x => {
+            if (x instanceof NavigationEnd) {
+                this.setTitles();
+                this.currentRoute = btoa(x.url);
+            }
+        });
+    }
+    /**
+     * Lifecycle hook that is called after a component's view has been fully initialized.
+     */
+    ngAfterViewInit() {
+        /* Broadcast to all listener observables when loading the page */
+        this.media.broadcast();
+        /* Set titles */
+        this.setTitles();
+        /*
+         * Force a new change detection cycle since change detections
+         * have finished when `ngAfterViewInit` is executed
+         */
+        this.changeDetectorRef.detectChanges();
+        /* Listen for expansion panel changes */
+        this.onExpansionPanelChanges();
+    }
+    /**
+     * Refreshs this page/component
+     */
+    reloadPage() {
+        let currentUrl = this.router.url;
+        this.router.navigateByUrl('/', { replaceUrl: true }).then(() => this.router.navigateByUrl(currentUrl, { replaceUrl: true }));
+    }
+    /**
+     * Listen for expansion panel changes
+     */
+    onExpansionPanelChanges() {
+        /* Listen for expansion panel changes */
+        this.matExpansionPanelQueryList?.changes.subscribe(_ => {
+            this.changeDetectorRef.detectChanges();
+            /* Find the index of the panel with the specified element ID */
+            this.urlHash?.split('.')
+                ?.reduce((accumulator, currentValue, index) => accumulator.concat((index > 0 ? (accumulator.slice(-1).join('.') + '.') : '') + currentValue), [])
+                ?.forEach((hash) => {
+                var expansionPanelIndex = this.matExpansionPanelElementQueryList?.toArray()?.findIndex(x => x.nativeElement.id == hash);
+                if (expansionPanelIndex >= 0) {
+                    this.matExpansionPanelQueryList?.toArray()[expansionPanelIndex]?.open();
+                    this.changeDetectorRef.detectChanges();
+                }
+            });
+            /* Detect changes for opened panels */
+            this.matExpansionPanelQueryList?.forEach(y => {
+                y.opened.subscribe(_ => {
+                    if (this.setUrlHash) {
+                        /* Get the id of the current opened panel */
+                        var currentPanelId = y['_viewContainerRef']?.element?.nativeElement?.id;
+                        /* If the panel ID is set, set it as url segment (hash) */
+                        if (currentPanelId) {
+                            this.router.navigate([], { fragment: currentPanelId, replaceUrl: true });
+                        }
+                        /* Otherwise remove the segment from the url */
+                        else {
+                            this.router.navigate([], { replaceUrl: true });
+                        }
+                    }
+                    /* Detect changes */
+                    this.changeDetectorRef.detectChanges();
+                });
+            });
+        });
+        /* Notify expansion panel list changes */
+        this.matExpansionPanelQueryList.notifyOnChanges();
+    }
+    /**
+     * Retrieves an instance from the injector based on the provided token.
+     * If not found:
+     * - Throws {@link NoProviderError} if no `notFoundValue` that is not equal to
+     * Injector.THROW_IF_NOT_FOUND is given
+     * - Returns the `notFoundValue` otherwise
+     */
+    getService(token) {
+        return ServiceLocator.getService(token);
+    }
+    /**
+     * Gets base route
+     * @param snapshot
+     */
+    getMainRoute(snapshot) {
+        if (snapshot && !snapshot.data.menu) {
+            return this.getMainRoute(snapshot.parent);
+        }
+        return snapshot;
+    }
+    /**
+         * Shows a confirm dialog to delete an item
+         */
+    showDeleteItemDialog() {
+        return this.dialogService.openConfirm({
+            message: $localize `:@@dialog.message.delete.one:Are you sure you want to delete this item?`,
+            title: $localize `:@@dialog.title.delete:Confirm Delete`,
+            cancelButton: $localize `:@@cancel:Cancel`,
+            acceptButton: $localize `:@@delete:Delete`,
+        }).afterClosed();
+    }
+    /**
+     * Shows a confirm dialog to delete multiple items
+     */
+    showDeleteItemsDialog() {
+        return this.dialogService.openConfirm({
+            message: $localize `:@@dialog.message.delete.list:Are you sure you want to delete the selected items?`,
+            title: $localize `:@@dialog.title.delete:Confirm Delete`,
+            cancelButton: $localize `:@@cancel:Cancel`,
+            acceptButton: $localize `:@@delete:Delete`,
+        }).afterClosed();
+    }
+    /**
+     * Shows a confirm dialog to send some data
+     * @param message The message to display
+     * @param observabe The observable instance
+     * @param successCallback A success callback
+     * @param errorCallback An error callback
+     */
+    showConfirmationDialog(message, observabe, successCallback = null, errorCallback = null) {
+        this.dialogService
+            .openConfirm({
+            message: message,
+            title: $localize `:@@dialog.title.confirm:Confirm`,
+            cancelButton: $localize `:@@cancel:Cancel`,
+            acceptButton: $localize `:@@ok:Ok`,
+        })
+            .afterClosed().subscribe((accept) => {
+            if (accept) {
+                observabe.subscribe(x => {
+                    this.showMessage($localize `:@@snackbar.send.success:Data sent successfully.`);
+                    if (successCallback) {
+                        successCallback(x);
+                    }
+                }, errors => {
+                    this.isSaving = false;
+                    if (errorCallback) {
+                        errorCallback(errors);
+                    }
+                });
+            }
+        });
+    }
+    /**
+     * Shows a message
+     * @param message The message to display
+     * @param type The type of the message
+     */
+    showMessage(message, type = MessageType.Success) {
+        var snackBarClass = 'primary';
+        switch (type) {
+            case MessageType.Success:
+                snackBarClass = 'primary';
+                break;
+            case MessageType.Warning:
+                snackBarClass = 'warn';
+                break;
+            case MessageType.Error:
+                snackBarClass = 'error';
+                break;
+            default:
+                break;
+        }
+        this.snackBarService.open(message || $localize `:@@snackbar.send.success:Data sent successfully.`, null, {
+            duration: 3000,
+            panelClass: [snackBarClass]
+        });
+    }
+    /**
+     * Initoalizes the tinymce editor
+     */
+    initEditor(editorConfig = {}) {
+        Object.assign(this.editorConfig, {
+            suffix: '.min',
+            skin: false,
+            height: '170px',
+            content_css: false,
+            plugins: this.editorPlugins,
+            toolbar: this.editorToolbar,
+            paste_as_text: true,
+            language: 'de',
+            language_url: '/assets/tinymce/langs/de.js',
+            document_base_url: `${this.appSetting.apiUrl}file/`,
+            automatic_uploads: true,
+            relative_urls: true,
+            convert_urls: false,
+            extended_valid_elements: 'span[id|class|style],+@[data-options]',
+            allow_html_in_named_anchor: true
+        }, editorConfig);
+        this.isEditorInitialzed = true;
+    }
+    /**
+     * Sets subtitle from curren menu
+     */
+    setTitles() {
+        if (this.menu) {
+            this.titleService.setTitle(this.menu.title);
+            this.title = this.titleService.getTitle();
+            if (this.menu.items) {
+                var submenu = this.menu.items.filter(x => x.path == this.router.url)[0];
+                if (submenu) {
+                    this.subtitle = submenu.title;
+                }
+            }
+        }
+    }
+    /**
+     * Navigate based on the provided array of commands and a starting point.
+     * @param commands
+     */
+    navigate(commands, queryParams) {
+        this.router.navigate(commands, { queryParams: Object.assign({ returnUrl: this.currentRoute }, queryParams || {}), relativeTo: this.route });
+    }
+    /**
+     * Convert Object to HttpHeaders
+     *
+     * @param body
+     */
+    toHttpHeaders(body) {
+        if (!body) {
+            return new HttpHeaders();
+        }
+        return Object.getOwnPropertyNames(body)
+            .filter(key => body[key] != null && body[key] != '')
+            .reduce((p, key) => p.set(key, body[key]), new HttpHeaders());
+    }
+    /**
+     * Parses http response errors
+     * @param errors
+     */
+    parseErrors(errors) {
+        this.errors = [];
+        this.isLoading = false;
+        this.isSaving = false;
+        if (errors) {
+            Object.keys(errors).forEach(el => {
+                let error = errors[el];
+                if (Array.isArray(error)) {
+                    error.forEach(err => {
+                        this.errors.push(err);
+                    });
+                }
+                else if (typeof error === "string") {
+                    this.errors.push(error);
+                }
+            });
+        }
+    }
+    /**
+     * Handle Http operation that failed.
+     * Let the app continue.
+     * @param operation - name of the operation that failed
+     * @param result - optional value to return as the observable result
+     */
+    handleError(operation = 'operation', result) {
+        return (error) => {
+            /* Parse the error messages */
+            this.parseErrors(error);
+            /* Log to console */
+            this.warn(`${operation} failed: ${error.message}`);
+            /* Let the app keep running by returning an empty result */
+            return of(result);
+        };
+    }
+    /**
+     * Log to console
+     * @param message
+     * @param optionalParams
+     */
+    log(message, ...optionalParams) {
+        if (this.debug) {
+            console.log(message, optionalParams);
+        }
+    }
+    /**
+     * Log to console
+     * @param message
+     * @param optionalParams
+     */
+    warn(message, ...optionalParams) {
+        if (this.debug) {
+            console.warn(message, optionalParams);
+        }
+    }
+    /**
+     * Cleans the objects
+     * Removes empty properties
+     * @param obj
+     */
+    clean(obj) {
+        try {
+            for (var propName in obj) {
+                if (obj[propName] === null || obj[propName] === undefined || obj[propName] === "") {
+                    delete obj[propName];
+                }
+            }
+        }
+        catch (error) { }
+        return obj;
+    }
+    /**
+     * Sanitizes the specified object
+     * @param obj
+     * @returns
+     */
+    sanitizeObject(obj, ...ignore) {
+        return Object.keys(obj)
+            .filter(x => obj[x])
+            .filter(x => !(ignore || []).map(x => x.toLowerCase()).includes(x.toLowerCase()))
+            .reduce((result, key) => {
+            result[key] = isNaN(+obj[key]) ? obj[key] : +obj[key];
+            return result;
+        }, {});
+    }
+}
+/** @nocollapse */ /** @nocollapse */ BaseComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: BaseComponent, deps: [{ token: i1.ActivatedRoute }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ /** @nocollapse */ BaseComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.3", type: BaseComponent, viewQueries: [{ propertyName: "matExpansionPanelElementQueryList", predicate: MatExpansionPanel, descendants: true, read: ElementRef }, { propertyName: "matExpansionPanelQueryList", predicate: MatExpansionPanel, descendants: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: BaseComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.ActivatedRoute }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { matExpansionPanelElementQueryList: [{
+                type: ViewChildren,
+                args: [MatExpansionPanel, { read: ElementRef }]
+            }], matExpansionPanelQueryList: [{
+                type: ViewChildren,
+                args: [MatExpansionPanel]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.component.js","sourceRoot":"","sources":["../../../../../../projects/cdk/src/lib/base/components/base.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Location } from '@angular/common';\r\nimport { HttpHeaders } from '@angular/common/http';\r\nimport { AfterViewInit, ChangeDetectorRef, Directive, ElementRef, OnInit, QueryList, Type, ViewChildren } from '@angular/core';\r\nimport { MatExpansionPanel } from '@angular/material/expansion';\r\nimport { MatSnackBar } from '@angular/material/snack-bar';\r\nimport { Title } from '@angular/platform-browser';\r\nimport { ActivatedRoute, ActivatedRouteSnapshot, NavigationEnd, Router, UrlSegment } from '@angular/router';\r\nimport { Observable, of } from 'rxjs';\r\nimport { ContextHelper } from '../../common/common.module';\r\nimport { AppSetting } from '../../common/models/app-setting';\r\nimport { ServiceLocator } from '../../common/services/service-locator';\r\nimport { VdDialogService } from '../../dialogs/services/dialog.service';\r\nimport { VdMediaService } from '../../media/services/media.service';\r\nimport { Menu } from '../../menu/models/menu';\r\nimport { Common } from '../constants/common';\r\nimport { MessageType } from '../enums/message-type';\r\nimport { AuthHelper } from '../helpers/auth-helper';\r\nimport { AuthUser } from '../models/auth-user';\r\n\r\n/**\r\n * A base list component for components with pagination support\r\n */\r\n// @dynamic\r\n@Directive()\r\nexport abstract class BaseComponent implements OnInit, AfterViewInit {\r\n\t/**\r\n\t * App settings\r\n\t */\r\n\tpublic appSetting: AppSetting;\r\n\r\n\t/**\r\n\t * Menu items\r\n\t */\r\n\tpublic menu: Menu;\r\n\r\n\t/**\r\n\t * The name of the project\r\n\t */\r\n\tpublic projectName: string;\r\n\r\n\t/**\r\n\t * The title of the current page\r\n\t */\r\n\tpublic title: string;\r\n\r\n\t/**\r\n\t * The subtitle of the current outlet\r\n\t */\r\n\tpublic subtitle: string = '';\r\n\r\n\t/**\r\n\t * If true, use some dummy data and show debug logs\r\n\t */\r\n\tpublic debug: boolean;\r\n\r\n\t/**\t \r\n\t * Loading status\r\n\t */\r\n\tpublic isLoading: boolean;\r\n\r\n\t/**\r\n\t * Saving status\r\n\t */\r\n\tpublic _isSaving: boolean;\r\n\tget isSaving(): boolean { return this._isSaving || this.isLoading; }\r\n\tset isSaving(isSaving: boolean) { this.isLoading = this._isSaving = isSaving; }\r\n\r\n\t/**\r\n\t * A flag eindicates that the editor is inited\r\n\t */\r\n\tpublic isEditorInitialzed: boolean;\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 * Used to evaluate whether a given media query is true or false given the current device's screen / window size.\r\n\t */\r\n\tpublic media: VdMediaService;\r\n\r\n\t/**\r\n\t * Allowed file extensions\r\n\t */\r\n\tpublic allowedExtensions: string[] = Common.allowedExtensions;\r\n\r\n\t/**\r\n\t * tinyMCE plugins\r\n\t */\r\n\tpublic editorPlugins: string = Common.editorPlugins;\r\n\r\n\t/**\r\n\t * tinyMCE editor\r\n\t */\r\n\tpublic editorToolbar: string = Common.editorToolbar;\r\n\r\n\t/**\r\n\t * Editor configuration\r\n\t */\r\n\tpublic editorConfig: any = {};\r\n\r\n\t/**\r\n\t * Provides the navigation and url manipulation capabilities.\r\n\t */\r\n\tpublic router: Router;\r\n\r\n\t/**\r\n\t * urlHash: string\r\n\t */\r\n\tpublic urlHash: string = null;\r\n\r\n\t/**\r\n\t * Class name\r\n\t */\r\n\tpublic className: string;\r\n\r\n\t/**\r\n\t * Create permission\r\n\t */\r\n\tpublic canCreate: boolean;\r\n\r\n\t/**\r\n\t * Update permission\r\n\t */\r\n\tpublic canUpdate: boolean;\r\n\r\n\t/**\r\n\t * Current route\r\n\t */\r\n\tpublic currentRoute: string;\r\n\r\n\t/**\r\n\t * Current user object\r\n\t */\r\n\tpublic currentUser: AuthUser = AuthHelper.user;\r\n\r\n\t/**\r\n\t * A service that can be used to get and set the title of a current HTML document.\r\n\t */\r\n\tprotected titleService: Title;\r\n\r\n\t/**\r\n\t * A service to dispatch Material Design snack bar messages.\r\n\t */\r\n\tprotected snackBarService: MatSnackBar;\r\n\r\n\t/**\r\n\t * A service to show conirm and prompt dialogs.\r\n\t */\r\n\tprotected dialogService: VdDialogService;\r\n\r\n\t/**\r\n\t * location: Location\r\n\t */\r\n\tprotected location: Location;\r\n\r\n\t/**\r\n\t * If true, set url hash\r\n\t */\r\n\tprotected setUrlHash: boolean = true;\r\n\r\n\t/**\r\n\t * MatExpansionPanel ref\r\n\t */\r\n\t@ViewChildren(MatExpansionPanel, { read: ElementRef })\r\n\tprotected matExpansionPanelElementQueryList: QueryList<ElementRef>;\r\n\r\n\t/**\r\n\t * MatExpansionPanel ref\r\n\t */\r\n\t@ViewChildren(MatExpansionPanel)\r\n\tprotected matExpansionPanelQueryList: QueryList<MatExpansionPanel>;\r\n\r\n\t/**\r\n\t * Constructor\r\n\t */\r\n\tconstructor(protected route: ActivatedRoute, protected changeDetectorRef: ChangeDetectorRef) {\r\n\t\tthis.titleService = this.getService(Title);\r\n\t\tthis.dialogService = this.getService(VdDialogService);\r\n\t\tthis.media = this.getService(VdMediaService);\r\n\t\tthis.snackBarService = this.getService(MatSnackBar);\r\n\t\tthis.router = this.getService(Router);\r\n\t\tthis.appSetting = this.getService(AppSetting);\r\n\t\tthis.location = this.getService(Location);\r\n\r\n\t\tContextHelper.activatedRoute = route;\r\n\t\tContextHelper.router = this.router;\r\n\t\tContextHelper.appSetting = this.appSetting;\r\n\r\n\t\tthis.initEditor();\r\n\t}\r\n\r\n\t/**\r\n\t * Lifecycle hook that is called after data-bound properties \r\n\t * of a directive are initialized.\r\n\t */\r\n\tngOnInit(): void {\r\n\t\t/* Get menu items from route snapshot */\r\n\t\tvar mainRoute = this.getMainRoute(this.route.snapshot);\r\n\t\tif (mainRoute) {\r\n\t\t\tthis.menu = mainRoute.data.menu;\r\n\t\t}\r\n\r\n\t\t/* Set project name & debug mode */\r\n\t\tthis.projectName = this.appSetting.projectName;\r\n\t\tthis.debug = this.appSetting.debug;\r\n\r\n\t\t/* Get the hash from the url */\r\n\t\tthis.route.fragment.subscribe((fragment: string) => this.urlHash = fragment);\r\n\r\n\t\t/**\r\n\t\t * Check permissions\r\n\t\t */\r\n\t\tif (this.route.parent) {\r\n\t\t\tthis.route.parent.url.subscribe((url: UrlSegment[]) => {\r\n\t\t\t\tthis.className = url[0].path.replace(/(.*)s$/, '$1').replace(/^./, (url[0].path[0] || '').toUpperCase());\r\n\t\t\t\tthis.canCreate = AuthHelper.isPermitted('Create', `Create${this.className}`);\r\n\t\t\t\tthis.canUpdate = AuthHelper.isPermitted('Update', `Update${this.className}`);\r\n\t\t\t});\r\n\t\t}\r\n\r\n\t\t/* Set current route */\r\n\t\tthis.currentRoute = btoa(this.router.url);\r\n\r\n\t\t/**\r\n\t\t * Set page title\r\n\t\t */\r\n\t\tthis.router.events.subscribe(x => {\r\n\t\t\tif (x instanceof NavigationEnd) {\r\n\t\t\t\tthis.setTitles();\r\n\t\t\t\tthis.currentRoute = btoa(x.url);\r\n\t\t\t}\r\n\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\t/* Broadcast to all listener observables when loading the page */\r\n\t\tthis.media.broadcast();\r\n\r\n\t\t/* Set titles */\r\n\t\tthis.setTitles();\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/* Listen for expansion panel changes */\r\n\t\tthis.onExpansionPanelChanges();\r\n\t}\r\n\r\n\t/**\r\n\t * Refreshs this page/component\r\n\t */\r\n\tpublic reloadPage(): void {\r\n\t\tlet currentUrl = this.router.url;\r\n\t\tthis.router.navigateByUrl('/', { replaceUrl: true }).then(() => this.router.navigateByUrl(currentUrl, { replaceUrl: true }));\r\n\t}\r\n\r\n\t/**\r\n\t * Listen for expansion panel changes\r\n\t */\r\n\tprotected onExpansionPanelChanges(): void {\r\n\t\t/* Listen for expansion panel changes */\r\n\t\tthis.matExpansionPanelQueryList?.changes.subscribe(_ => {\r\n\t\t\tthis.changeDetectorRef.detectChanges();\r\n\r\n\t\t\t/* Find the index of the panel with the specified element ID */\r\n\t\t\tthis.urlHash?.split('.')\r\n\t\t\t\t?.reduce((accumulator, currentValue, index) => accumulator.concat((index > 0 ? (accumulator.slice(-1).join('.') + '.') : '') + currentValue), [])\r\n\t\t\t\t?.forEach((hash: string) => {\r\n\t\t\t\t\tvar expansionPanelIndex = this.matExpansionPanelElementQueryList?.toArray()?.findIndex(x => x.nativeElement.id == hash);\r\n\t\t\t\t\tif (expansionPanelIndex >= 0) {\r\n\t\t\t\t\t\tthis.matExpansionPanelQueryList?.toArray()[expansionPanelIndex]?.open();\r\n\t\t\t\t\t\tthis.changeDetectorRef.detectChanges();\r\n\t\t\t\t\t}\r\n\t\t\t\t});\r\n\r\n\t\t\t/* Detect changes for opened panels */\r\n\t\t\tthis.matExpansionPanelQueryList?.forEach(y => {\r\n\t\t\t\ty.opened.subscribe(_ => {\r\n\t\t\t\t\tif (this.setUrlHash) {\r\n\t\t\t\t\t\t/* Get the id of the current opened panel */\r\n\t\t\t\t\t\tvar currentPanelId = y['_viewContainerRef']?.element?.nativeElement?.id;\r\n\r\n\t\t\t\t\t\t/* If the panel ID is set, set it as url segment (hash) */\r\n\t\t\t\t\t\tif (currentPanelId) {\r\n\t\t\t\t\t\t\tthis.router.navigate([], { fragment: currentPanelId, replaceUrl: true });\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t/* Otherwise remove the segment from the url */\r\n\t\t\t\t\t\telse {\r\n\t\t\t\t\t\t\tthis.router.navigate([], { replaceUrl: true });\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t/* Detect changes */\r\n\t\t\t\t\tthis.changeDetectorRef.detectChanges();\r\n\t\t\t\t});\r\n\t\t\t});\r\n\t\t});\r\n\r\n\t\t/* Notify expansion panel list changes */\r\n\t\tthis.matExpansionPanelQueryList.notifyOnChanges();\r\n\t}\r\n\r\n\t/**\r\n\t * Retrieves an instance from the injector based on the provided token.\r\n\t * If not found:\r\n\t * - Throws {@link NoProviderError} if no `notFoundValue` that is not equal to\r\n\t * Injector.THROW_IF_NOT_FOUND is given\r\n\t * - Returns the `notFoundValue` otherwise\r\n\t */\r\n\tprotected getService<T>(token: Type<T>): T {\r\n\t\treturn ServiceLocator.getService(token);\r\n\t}\r\n\r\n\t/**\r\n\t * Gets base route\r\n\t * @param snapshot \r\n\t */\r\n\tprotected getMainRoute(snapshot: ActivatedRouteSnapshot): ActivatedRouteSnapshot {\r\n\t\tif (snapshot && !snapshot.data.menu) {\r\n\t\t\treturn this.getMainRoute(snapshot.parent);\r\n\t\t}\r\n\r\n\t\treturn snapshot;\r\n\t}\r\n\r\n\t/**\r\n\t\t * Shows a confirm dialog to delete an item \r\n\t\t */\r\n\tprotected showDeleteItemDialog(): Observable<any> {\r\n\t\treturn this.dialogService.openConfirm({\r\n\t\t\tmessage: $localize`:@@dialog.message.delete.one:Are you sure you want to delete this item?`,\r\n\t\t\ttitle: $localize`:@@dialog.title.delete:Confirm Delete`,\r\n\t\t\tcancelButton: $localize`:@@cancel:Cancel`,\r\n\t\t\tacceptButton: $localize`:@@delete:Delete`,\r\n\t\t}).afterClosed();\r\n\t}\r\n\r\n\t/**\r\n\t * Shows a confirm dialog to delete multiple items\r\n\t */\r\n\tprotected showDeleteItemsDialog(): Observable<any> {\r\n\t\treturn this.dialogService.openConfirm({\r\n\t\t\tmessage: $localize`:@@dialog.message.delete.list:Are you sure you want to delete the selected items?`,\r\n\t\t\ttitle: $localize`:@@dialog.title.delete:Confirm Delete`,\r\n\t\t\tcancelButton: $localize`:@@cancel:Cancel`,\r\n\t\t\tacceptButton: $localize`:@@delete:Delete`,\r\n\t\t}).afterClosed();\r\n\t}\r\n\r\n\t/**\r\n\t * Shows a confirm dialog to send some data\r\n\t * @param message The message to display\r\n\t * @param observabe The observable instance\r\n\t * @param successCallback A success callback\r\n\t * @param errorCallback An error callback\r\n\t */\r\n\tpublic showConfirmationDialog(message: string, observabe: Observable<any>, successCallback: Function = null, errorCallback: Function = null) {\r\n\t\tthis.dialogService\r\n\t\t\t.openConfirm({\r\n\t\t\t\tmessage: message,\r\n\t\t\t\ttitle: $localize`:@@dialog.title.confirm:Confirm`,\r\n\t\t\t\tcancelButton: $localize`:@@cancel:Cancel`,\r\n\t\t\t\tacceptButton: $localize`:@@ok:Ok`,\r\n\t\t\t})\r\n\t\t\t.afterClosed().subscribe((accept: boolean) => {\r\n\t\t\t\tif (accept) {\r\n\t\t\t\t\tobservabe.subscribe(x => {\r\n\t\t\t\t\t\tthis.showMessage($localize`:@@snackbar.send.success:Data sent successfully.`);\r\n\r\n\t\t\t\t\t\tif (successCallback) {\r\n\t\t\t\t\t\t\tsuccessCallback(x);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}, errors => {\r\n\t\t\t\t\t\tthis.isSaving = false;\r\n\t\t\t\t\t\tif (errorCallback) {\r\n\t\t\t\t\t\t\terrorCallback(errors);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t});\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t}\r\n\r\n\t/**\r\n\t * Shows a message\r\n\t * @param message The message to display\r\n\t * @param type The type of the message\r\n\t */\r\n\tprotected showMessage(message?: string, type: MessageType = MessageType.Success): void {\r\n\t\tvar snackBarClass = 'primary';\r\n\t\tswitch (type) {\r\n\t\t\tcase MessageType.Success:\r\n\t\t\t\tsnackBarClass = 'primary';\r\n\t\t\t\tbreak;\r\n\r\n\t\t\tcase MessageType.Warning:\r\n\t\t\t\tsnackBarClass = 'warn';\r\n\t\t\t\tbreak;\r\n\r\n\t\t\tcase MessageType.Error:\r\n\t\t\t\tsnackBarClass = 'error';\r\n\t\t\t\tbreak;\r\n\r\n\t\t\tdefault:\r\n\t\t\t\tbreak;\r\n\t\t}\r\n\r\n\t\tthis.snackBarService.open(message || $localize`:@@snackbar.send.success:Data sent successfully.`, null, {\r\n\t\t\tduration: 3000,\r\n\t\t\tpanelClass: [snackBarClass]\r\n\t\t});\r\n\t}\r\n\r\n\t/**\r\n\t * Initoalizes the tinymce editor\r\n\t */\r\n\tprotected initEditor(editorConfig: any = {}) {\r\n\t\tObject.assign(this.editorConfig, {\r\n\t\t\tsuffix: '.min',\r\n\t\t\tskin: false,\r\n\t\t\theight: '170px',\r\n\t\t\tcontent_css: false,\r\n\t\t\tplugins: this.editorPlugins,\r\n\t\t\ttoolbar: this.editorToolbar,\r\n\t\t\tpaste_as_text: true,\r\n\t\t\tlanguage: 'de',\r\n\t\t\tlanguage_url: '/assets/tinymce/langs/de.js',\r\n\t\t\tdocument_base_url: `${this.appSetting.apiUrl}file/`,\r\n\t\t\tautomatic_uploads: true,\r\n\t\t\trelative_urls: true,\r\n\t\t\tconvert_urls: false,\r\n\t\t\textended_valid_elements: 'span[id|class|style],+@[data-options]',\r\n\t\t\tallow_html_in_named_anchor: true\r\n\t\t}, editorConfig);\r\n\r\n\t\tthis.isEditorInitialzed = true;\r\n\t}\r\n\r\n\t/**\r\n\t * Sets subtitle from curren menu\r\n\t */\r\n\tprotected setTitles(): void {\r\n\t\tif (this.menu) {\r\n\t\t\tthis.titleService.setTitle(this.menu.title);\r\n\t\t\tthis.title = this.titleService.getTitle();\r\n\r\n\t\t\tif (this.menu.items) {\r\n\t\t\t\tvar submenu = this.menu.items.filter(x => x.path == this.router.url)[0];\r\n\t\t\t\tif (submenu) {\r\n\t\t\t\t\tthis.subtitle = submenu.title;\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 * Navigate based on the provided array of commands and a starting point.\r\n\t * @param commands \r\n\t */\r\n\tprotected navigate(commands: any[], queryParams?: any): void {\r\n\t\tthis.router.navigate(commands, { queryParams: Object.assign({ returnUrl: this.currentRoute }, queryParams || {}), relativeTo: this.route });\r\n\t}\r\n\r\n\t/**\r\n\t * Convert Object to HttpHeaders\r\n\t * \r\n\t * @param body\r\n\t */\r\n\tprotected toHttpHeaders(body: Object): HttpHeaders {\r\n\t\tif (!body) {\r\n\t\t\treturn new HttpHeaders();\r\n\t\t}\r\n\r\n\t\treturn Object.getOwnPropertyNames(body)\r\n\t\t\t.filter(key => body[key] != null && body[key] != '')\r\n\t\t\t.reduce((p, key) => p.set(key, body[key]), new HttpHeaders());\r\n\t}\r\n\r\n\t/**\r\n\t * Parses http response errors\r\n\t * @param errors \r\n\t */\r\n\tprotected parseErrors(errors: Object): void {\r\n\t\tthis.errors = [];\r\n\t\tthis.isLoading = false;\r\n\t\tthis.isSaving = false;\r\n\r\n\t\tif (errors) {\r\n\t\t\tObject.keys(errors).forEach(el => {\r\n\t\t\t\tlet error = errors[el];\r\n\t\t\t\tif (Array.isArray(error)) {\r\n\t\t\t\t\terror.forEach(err => {\r\n\t\t\t\t\t\tthis.errors.push(err);\r\n\t\t\t\t\t});\r\n\t\t\t\t} else if (typeof error === \"string\") {\r\n\t\t\t\t\tthis.errors.push(error);\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 * Handle Http operation that failed.\r\n\t * Let the app continue.\r\n\t * @param operation - name of the operation that failed\r\n\t * @param result - optional value to return as the observable result\r\n\t */\r\n\tprotected handleError<T>(operation = 'operation', result?: T) {\r\n\t\treturn (error: any): Observable<T> => {\r\n\r\n\t\t\t/* Parse the error messages */\r\n\t\t\tthis.parseErrors(error);\r\n\r\n\t\t\t/* Log to console */\r\n\t\t\tthis.warn(`${operation} failed: ${error.message}`);\r\n\r\n\t\t\t/* Let the app keep running by returning an empty result */\r\n\t\t\treturn of(result as T);\r\n\t\t};\r\n\t}\r\n\r\n\t/**\r\n\t * Log to console\r\n\t * @param message \r\n\t * @param optionalParams \r\n\t */\r\n\tprotected log(message: string, ...optionalParams: any[]) {\r\n\t\tif (this.debug) {\r\n\t\t\tconsole.log(message, optionalParams);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Log to console\r\n\t * @param message \r\n\t * @param optionalParams \r\n\t */\r\n\tprotected warn(message: string, ...optionalParams: any[]) {\r\n\t\tif (this.debug) {\r\n\t\t\tconsole.warn(message, optionalParams);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Cleans the objects\r\n\t * Removes empty properties\r\n\t * @param obj \r\n\t */\r\n\tprotected clean(obj: any): any {\r\n\t\ttry {\r\n\t\t\tfor (var propName in obj) {\r\n\t\t\t\tif (obj[propName] === null || obj[propName] === undefined || obj[propName] === \"\") {\r\n\t\t\t\t\tdelete obj[propName];\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t} catch (error) { }\r\n\r\n\t\treturn obj;\r\n\t}\r\n\r\n\t/**\r\n\t * Sanitizes the specified object\r\n\t * @param obj \r\n\t * @returns \r\n\t */\r\n\tprotected sanitizeObject(obj: any, ...ignore: string[]): any {\r\n\t\treturn Object.keys(obj)\r\n\t\t\t.filter(x => obj[x])\r\n\t\t\t.filter(x => !(ignore || []).map(x => x.toLowerCase()).includes(x.toLowerCase()))\r\n\t\t\t.reduce((result, key) => {\r\n\t\t\t\tresult[key] = isNaN(+obj[key]) ? obj[key] : +obj[key];\r\n\t\t\t\treturn result;\r\n\t\t\t}, {});\r\n\t}\r\n}"]}