@messaia/cdk 0.0.0-CDK

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

@@ -0,0 +1,54 @@
+import { ChangeDetectorRef, Directive, Type } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { ServiceLocator } from '../../common/common.module';
+import { FormBuilderConfiguration } from '../../form-validators/models';
+import { RxFormBuilder } from '../../form-validators/public_api';
+import { GenericFormBaseComponent } from './generic-form-base.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+// @dynamic
+export class GenericReactiveFormComponent extends GenericFormBaseComponent {
+    /**
+     * Constructor
+     * @param service
+     */
+    constructor(entityCtor, service, route, changeDetectorRef) {
+        super(entityCtor, service, route, changeDetectorRef);
+        this.entityCtor = entityCtor;
+        this.service = service;
+        this.route = route;
+        this.changeDetectorRef = changeDetectorRef;
+        /**
+         * formBuilderConfig: FormBuilderConfiguration
+         */
+        this.formBuilderConfig = new FormBuilderConfiguration();
+        this.formBuilder = ServiceLocator.getService(RxFormBuilder);
+    }
+    /**
+     * Gets form value
+     */
+    get formValue() { return this.form.value; }
+    ;
+    /**
+     * Builds a new form
+     */
+    buildForm() {
+        this.onBeforeFormBuild();
+        this.form = this.formBuilder.formGroup(this.item, this.formBuilderConfig);
+        this.onAfterFormBuild();
+    }
+    /**
+     * Shows form errors
+     * @param form
+     */
+    debugForm(form = null) {
+        super.debugForm(form);
+        console.log(this.form.getErrorSummary(false));
+    }
+}
+/** @nocollapse */ /** @nocollapse */ GenericReactiveFormComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: GenericReactiveFormComponent, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ /** @nocollapse */ GenericReactiveFormComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.0", type: GenericReactiveFormComponent, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: GenericReactiveFormComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.Type }, { type: undefined }, { type: i1.ActivatedRoute }, { type: i0.ChangeDetectorRef }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/base/constants/common.mjs

@@ -0,0 +1,24 @@
+export const Common = {
+    allowedExtensions: [
+        ".png", ".gif", ".jpg", ".jpeg", ".doc", ".txt", ".mp3", ".mp4", ".mpeg", ".avi", ".wav",
+        ".xls", ".mpp", ".pdf", ".ppt", ".tiff", ".tif", ".bmp", ".docx", ".xlsx", ".csv", ".pptx",
+        ".ps", ".odt", ".ods", ".odp", ".odg", ".zip", ".rar", ".7z", ".tar"
+    ],
+    editorPlugins: 'link code image preview advlist lists fullscreen imagetools',
+    editorToolbar: 'undo redo | formatselect | bold italic strikethrough forecolor backcolor permanentpen formatpainter | link image media pageembed | alignleft aligncenter alignright alignjustify  | numlist bullist outdent indent | removeformat | code',
+    months: [
+        { name: 'Januar', id: 1 },
+        { name: 'Februar', id: 2 },
+        { name: 'März', id: 3 },
+        { name: 'April', id: 4 },
+        { name: 'Mai', id: 5 },
+        { name: 'Juni', id: 6 },
+        { name: 'Juli', id: 7 },
+        { name: 'August', id: 8 },
+        { name: 'September', id: 9 },
+        { name: 'Oktober', id: 10 },
+        { name: 'November', id: 11 },
+        { name: 'Dezember', id: 12 }
+    ]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/base/enums/message-type.mjs

@@ -0,0 +1,7 @@
+export var MessageType;
+(function (MessageType) {
+    MessageType[MessageType["Success"] = 0] = "Success";
+    MessageType[MessageType["Warning"] = 1] = "Warning";
+    MessageType[MessageType["Error"] = 2] = "Error";
+})(MessageType || (MessageType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVzc2FnZS10eXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2RrL3NyYy9saWIvYmFzZS9lbnVtcy9tZXNzYWdlLXR5cGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksV0FJWDtBQUpELFdBQVksV0FBVztJQUNuQixtREFBTyxDQUFBO0lBQ1AsbURBQU8sQ0FBQTtJQUNQLCtDQUFLLENBQUE7QUFDVCxDQUFDLEVBSlcsV0FBVyxLQUFYLFdBQVcsUUFJdEIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBNZXNzYWdlVHlwZSB7XHJcbiAgICBTdWNjZXNzLFxyXG4gICAgV2FybmluZyxcclxuICAgIEVycm9yLFxyXG59Il19

package/esm2020/lib/base/helpers/auth-helper.mjs

@@ -0,0 +1,46 @@
+import { AuthUser } from "../models/auth-user";
+//@dynamic
+export class AuthHelper {
+    /**
+     * Checks if the current user is authenticated
+     */
+    static isAuthenticated() {
+        return this.user && this.user.sub > 0;
+    }
+    /**
+     * Checks if the user has the specified permission
+     * @param permission The permission to check
+     */
+    static isPermitted(...permissions) {
+        /* Admins have full access */
+        permissions.push('Admin');
+        permissions.push('Administrator');
+        if (this.user && Array.isArray(this.user.permission)) {
+            return permissions.some(permission => {
+                return this.user.permission.indexOf(permission) >= 0;
+            });
+        }
+        return false;
+    }
+    /**
+     * Checks if the current user has on of the specified roles
+     * @param roles
+     */
+    static hasRole(...roles) {
+        return roles.some(role => {
+            return this.user && this.isString(this.user.role) && role && this.user.role.toLowerCase() === role.toLowerCase();
+        });
+    }
+    /**
+     * Checks if the specified variable is a string
+     * @param str
+     */
+    static isString(str) {
+        return typeof str === 'string' || str instanceof String;
+    }
+}
+/**
+ * Authenticated user
+ */
+AuthHelper.user = new AuthUser();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/base/interceptors/base.interceptor.mjs

@@ -0,0 +1,138 @@
+import { HttpResponse } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { tap } from 'rxjs/operators';
+import { AppSetting } from '../../common/models/app-setting';
+import * as i0 from "@angular/core";
+import * as i1 from "../../common/models/app-setting";
+import * as i2 from "@angular/material/snack-bar";
+/**
+ * Pass untouched request through to the next request handler.
+ */
+export class BaseInterceptor {
+    /**
+     * Constructor
+     */
+    constructor(appSetting, snackBar) {
+        this.appSetting = appSetting;
+        this.snackBar = snackBar;
+    }
+    /**
+     * Intercept an outgoing `HttpRequest` and optionally transform it or the
+     * response.
+     *
+     * Typically an interceptor will transform the outgoing request before returning
+     * `next.handle(transformedReq)`. An interceptor may choose to transform the
+     * response event stream as well, by applying additional Rx operators on the stream
+     * returned by `next.handle()`.
+     *
+     * More rarely, an interceptor may choose to completely handle the request itself,
+     * and compose a new event stream instead of invoking `next.handle()`. This is
+     * acceptable behavior, but keep in mind further interceptors will be skipped entirely.
+     *
+     * It is also rare but valid for an interceptor to return multiple responses on the
+     * event stream for a single request.
+     */
+    intercept(req, next) {
+        /* Clone the request and set the base url */
+        const authReq = req.clone({
+            url: req.url.startsWith('http') || req.url.startsWith('./assets') ? req.url : `${this.appSetting.apiUrl}${req.url}`,
+            headers: req.method == 'GET' ? req.headers.set('CheckIn', 'Yes') : req.headers
+        });
+        /* Send cloned request with header to the next handler */
+        return next.handle(authReq).pipe(tap(
+        /* Succeeds when there is a response; ignore other events */
+        event => {
+            if (event instanceof HttpResponse) {
+                if (req.headers.get('Show-Message')) {
+                    /* Show a success message for POST requests */
+                    if (req.method == 'POST') {
+                        this.snackBar.open($localize `:@@snackbar.create.success:Data saved successfully.`, null, {
+                            duration: 3000,
+                            panelClass: ['primary']
+                        });
+                    }
+                    /* Show a success message for PUT or PATCH requests */
+                    if (['PUT', 'PATCH'].indexOf(req.method) >= 0) {
+                        this.snackBar.open($localize `:@@snackbar.update.success:Changes saved successfully.`, null, {
+                            duration: 3000,
+                            panelClass: ['primary']
+                        });
+                    }
+                    /* Show a success message for PUT or PATCH requests */
+                    if (['DELETE'].indexOf(req.method) >= 0) {
+                        this.snackBar.open($localize `:@@snackbar.delete.success:Record(s) deleted successfully.`, null, {
+                            duration: 3000,
+                            panelClass: ['primary']
+                        });
+                    }
+                    /* Show warnings from headers, if any */
+                    var warning = event.headers.get("Warning");
+                    if (warning) {
+                        this.snackBar.open(warning, "OK", { duration: 6000, panelClass: ['warn'] });
+                    }
+                }
+            }
+        }, 
+        /* Operation failed; error is an HttpErrorResponse */
+        error => {
+            /* Status: 400 - Bad Request (i.e. validation errors) */
+            if (error.status == 400) {
+                let message = this.parseErrors(error.error);
+                if (message) {
+                    this.snackBar.open(message, "OK", { duration: 8000, panelClass: ['error'] });
+                }
+            }
+            /* Status: 403 -  Not permitted */
+            if (error.status == 403) {
+                this.snackBar.open($localize `:@@snackbar.error.not-allowed:You are not allowed to perform this request.`, null, {
+                    duration: 6000,
+                    panelClass: ['error']
+                });
+            }
+            /* Status: 404 -  Bad request, show some error messages */
+            if (error.status == 404) {
+                this.snackBar.open($localize `:@@snackbar.error.not-found:The resource could not be found.`, null, {
+                    duration: 6000,
+                    panelClass: ['error']
+                });
+            }
+            /* Custom error message */
+            if (error.status == 452) {
+                this.snackBar.open(error.text(), null, { duration: 6000, panelClass: ['error'] });
+            }
+            /* Internal server error */
+            if (error.status == 500) {
+                this.snackBar.open(error.text(), null, { duration: 6000, panelClass: ['error'] });
+            }
+        }));
+    }
+    /**
+     * Parses http response errors
+     * @param error
+     */
+    parseErrors(error) {
+        let errors = [];
+        if (error) {
+            Object.keys(error).forEach(el => {
+                let err = error[el];
+                if (Array.isArray(err)) {
+                    err.forEach(err => {
+                        errors.push(err);
+                    });
+                }
+                else if (typeof err === "string") {
+                    errors.push(err);
+                }
+            });
+        }
+        return errors.join('\n');
+    }
+}
+/** @nocollapse */ /** @nocollapse */ BaseInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: BaseInterceptor, deps: [{ token: i1.AppSetting }, { token: i2.MatSnackBar }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ BaseInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: BaseInterceptor, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: BaseInterceptor, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.AppSetting }, { type: i2.MatSnackBar }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.interceptor.js","sourceRoot":"","sources":["../../../../../../projects/cdk/src/lib/base/interceptors/base.interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest, HttpResponse } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { MatSnackBar } from '@angular/material/snack-bar';\r\nimport { Observable } from 'rxjs';\r\nimport { tap } from 'rxjs/operators';\r\nimport { AppSetting } from '../../common/models/app-setting';\r\n\r\n/**\r\n * Pass untouched request through to the next request handler.\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class BaseInterceptor implements HttpInterceptor {\r\n\r\n\t/**\r\n\t * Constructor\r\n\t */\r\n\tconstructor(private appSetting: AppSetting, private snackBar: MatSnackBar) { }\r\n\r\n\t/**\r\n\t * Intercept an outgoing `HttpRequest` and optionally transform it or the\r\n\t * response.\r\n\t *\r\n\t * Typically an interceptor will transform the outgoing request before returning\r\n\t * `next.handle(transformedReq)`. An interceptor may choose to transform the\r\n\t * response event stream as well, by applying additional Rx operators on the stream\r\n\t * returned by `next.handle()`.\r\n\t *\r\n\t * More rarely, an interceptor may choose to completely handle the request itself,\r\n\t * and compose a new event stream instead of invoking `next.handle()`. This is\r\n\t * acceptable behavior, but keep in mind further interceptors will be skipped entirely.\r\n\t *\r\n\t * It is also rare but valid for an interceptor to return multiple responses on the\r\n\t * event stream for a single request.\r\n\t */\r\n\tintercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\r\n\r\n\t\t/* Clone the request and set the base url */\r\n\t\tconst authReq = req.clone({\r\n\t\t\turl: req.url.startsWith('http') || req.url.startsWith('./assets') ? req.url : `${this.appSetting.apiUrl}${req.url}`,\r\n\t\t\theaders: req.method == 'GET' ? req.headers.set('CheckIn', 'Yes') : req.headers\r\n\t\t});\r\n\r\n\t\t/* Send cloned request with header to the next handler */\r\n\t\treturn next.handle(authReq).pipe(\r\n\t\t\ttap(\r\n\t\t\t\t/* Succeeds when there is a response; ignore other events */\r\n\t\t\t\tevent => {\r\n\t\t\t\t\tif (event instanceof HttpResponse) {\r\n\t\t\t\t\t\tif (req.headers.get('Show-Message')) {\r\n\t\t\t\t\t\t\t/* Show a success message for POST requests */\r\n\t\t\t\t\t\t\tif (req.method == 'POST') {\r\n\t\t\t\t\t\t\t\tthis.snackBar.open($localize`:@@snackbar.create.success:Data saved successfully.`, null, {\r\n\t\t\t\t\t\t\t\t\tduration: 3000,\r\n\t\t\t\t\t\t\t\t\tpanelClass: ['primary']\r\n\t\t\t\t\t\t\t\t});\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\t/* Show a success message for PUT or PATCH requests */\r\n\t\t\t\t\t\t\tif (['PUT', 'PATCH'].indexOf(req.method) >= 0) {\r\n\t\t\t\t\t\t\t\tthis.snackBar.open($localize`:@@snackbar.update.success:Changes saved successfully.`, null, {\r\n\t\t\t\t\t\t\t\t\tduration: 3000,\r\n\t\t\t\t\t\t\t\t\tpanelClass: ['primary']\r\n\t\t\t\t\t\t\t\t});\r\n\t\t\t\t\t\t\t}\r\n\r\n\r\n\t\t\t\t\t\t\t/* Show a success message for PUT or PATCH requests */\r\n\t\t\t\t\t\t\tif (['DELETE'].indexOf(req.method) >= 0) {\r\n\t\t\t\t\t\t\t\tthis.snackBar.open($localize`:@@snackbar.delete.success:Record(s) deleted successfully.`, null, {\r\n\t\t\t\t\t\t\t\t\tduration: 3000,\r\n\t\t\t\t\t\t\t\t\tpanelClass: ['primary']\r\n\t\t\t\t\t\t\t\t});\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\t/* Show warnings from headers, if any */\r\n\t\t\t\t\t\t\tvar warning = event.headers.get(\"Warning\");\r\n\t\t\t\t\t\t\tif (warning) {\r\n\t\t\t\t\t\t\t\tthis.snackBar.open(warning, \"OK\", { duration: 6000, panelClass: ['warn'] });\r\n\t\t\t\t\t\t\t}\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\t/* Operation failed; error is an HttpErrorResponse */\r\n\t\t\t\terror => {\r\n\t\t\t\t\t/* Status: 400 - Bad Request (i.e. validation errors) */\r\n\t\t\t\t\tif (error.status == 400) {\r\n\t\t\t\t\t\tlet message = this.parseErrors(error.error);\r\n\t\t\t\t\t\tif (message) {\r\n\t\t\t\t\t\t\tthis.snackBar.open(message, \"OK\", { duration: 8000, panelClass: ['error'] })\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t/* Status: 403 -  Not permitted */\r\n\t\t\t\t\tif (error.status == 403) {\r\n\t\t\t\t\t\tthis.snackBar.open($localize`:@@snackbar.error.not-allowed:You are not allowed to perform this request.`, null, {\r\n\t\t\t\t\t\t\tduration: 6000,\r\n\t\t\t\t\t\t\tpanelClass: ['error']\r\n\t\t\t\t\t\t});\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t/* Status: 404 -  Bad request, show some error messages */\r\n\t\t\t\t\tif (error.status == 404) {\r\n\t\t\t\t\t\tthis.snackBar.open($localize`:@@snackbar.error.not-found:The resource could not be found.`, null, {\r\n\t\t\t\t\t\t\tduration: 6000,\r\n\t\t\t\t\t\t\tpanelClass: ['error']\r\n\t\t\t\t\t\t});\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t/* Custom error message */\r\n\t\t\t\t\tif (error.status == 452) {\r\n\t\t\t\t\t\tthis.snackBar.open(error.text(), null, { duration: 6000, panelClass: ['error'] });\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t/* Internal server error */\r\n\t\t\t\t\tif (error.status == 500) {\r\n\t\t\t\t\t\tthis.snackBar.open(error.text(), null, { duration: 6000, panelClass: ['error'] });\r\n\t\t\t\t\t}\r\n\t\t\t\t})\r\n\t\t);\r\n\t}\r\n\r\n\t/**\r\n\t * Parses http response errors\r\n\t * @param error \r\n\t */\r\n\tprotected parseErrors(error: Object): string {\r\n\t\tlet errors: string[] = [];\r\n\t\tif (error) {\r\n\t\t\tObject.keys(error).forEach(el => {\r\n\t\t\t\tlet err = error[el];\r\n\t\t\t\tif (Array.isArray(err)) {\r\n\t\t\t\t\terr.forEach(err => {\r\n\t\t\t\t\t\terrors.push(err);\r\n\t\t\t\t\t});\r\n\t\t\t\t} else if (typeof err === \"string\") {\r\n\t\t\t\t\terrors.push(err);\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\t}\r\n\r\n\t\treturn errors.join('\\n');\r\n\t}\r\n}"]}

package/esm2020/lib/base/interceptors/caching-interceptor.mjs

@@ -0,0 +1,68 @@
+import { HttpResponse } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+/**
+ * Pass untouched request through to the next request handler.
+ */
+export class CachingInterceptor {
+    /**
+     * Constructor
+     */
+    constructor() {
+        /**
+         * Cache container
+         */
+        this.cache = new Map();
+    }
+    /**
+     * Intercept an outgoing `HttpRequest` and optionally transform it or the
+     * response.
+     *
+     * Typically an interceptor will transform the outgoing request before returning
+     * `next.handle(transformedReq)`. An interceptor may choose to transform the
+     * response event stream as well, by applying additional Rx operators on the stream
+     * returned by `next.handle()`.
+     *
+     * More rarely, an interceptor may choose to completely handle the request itself,
+     * and compose a new event stream instead of invoking `next.handle()`. This is
+     * acceptable behavior, but keep in mind further interceptors will be skipped entirely.
+     *
+     * It is also rare but valid for an interceptor to return multiple responses on the
+     * event stream for a single request.
+     */
+    intercept(req, next) {
+        /* Before doing anything, it's important to only cache GET requests. */
+        if (req.method !== 'GET' || req.responseType.toLowerCase() === 'arraybuffer') {
+            this.cache.clear();
+            return next.handle(req);
+        }
+        /* First, check the cache to see if this request exists. */
+        const cachedResponse = this.cache.get(req.urlWithParams);
+        if (cachedResponse && req.headers.get('Client-Cache')) {
+            /*
+            A cached response exists. Serve it instead of forwarding
+            the request to the next handler.
+            */
+            return of(cachedResponse.clone());
+        }
+        /* No cached response exists. Go to the network, and cache the response when it arrives. */
+        return next.handle(req).pipe(tap(
+        /* Succeeds when there is a response; ignore other events */
+        event => {
+            /* Remember, there may be other events besides just the response. */
+            if (event instanceof HttpResponse && req.headers.get('Client-Cache')) {
+                /* Update the cache. */
+                this.cache.set(req.urlWithParams, event.clone());
+            }
+        }));
+    }
+}
+/** @nocollapse */ /** @nocollapse */ CachingInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: CachingInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ CachingInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: CachingInterceptor, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: CachingInterceptor, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/base/interceptors/loading.interceptor.mjs

@@ -0,0 +1,63 @@
+import { Injectable } from "@angular/core";
+import { finalize } from "rxjs/operators";
+import { LoadingScreenService } from "../services/loading-screen.service";
+import * as i0 from "@angular/core";
+import * as i1 from "../services/loading-screen.service";
+export class LoadingScreenInterceptor {
+    /**
+     * Constructor
+     * @param loadingScreenService
+     */
+    constructor(loadingScreenService) {
+        this.loadingScreenService = loadingScreenService;
+        /**
+         * activeRequests: number
+         */
+        this.activeRequests = 0;
+        /**
+         * URLs for which the loading screen should not be enabled
+         */
+        this.skippUrls = ['/authrefresh'];
+    }
+    /**
+    * Identifies and handles a given HTTP request.
+    * @param req The outgoing request object to handle.
+    * @param next The next interceptor in the chain, or the backend
+    * if no interceptors remain in the chain.
+    * @returns An observable of the event stream.
+    */
+    intercept(request, next) {
+        let displayLoadingScreen = true;
+        /* Skip loading screen for folowed urls */
+        for (const skippUrl of this.skippUrls) {
+            if (new RegExp(skippUrl).test(request.url)) {
+                displayLoadingScreen = false;
+                break;
+            }
+        }
+        if (displayLoadingScreen) {
+            if (this.activeRequests === 0) {
+                this.loadingScreenService.startLoading();
+            }
+            /* Count the active requests */
+            this.activeRequests++;
+            /* handle the request */
+            return next.handle(request).pipe(finalize(() => {
+                this.activeRequests--;
+                if (this.activeRequests === 0) {
+                    this.loadingScreenService.stopLoading();
+                }
+            }));
+        }
+        else {
+            return next.handle(request);
+        }
+    }
+    ;
+}
+/** @nocollapse */ /** @nocollapse */ LoadingScreenInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: LoadingScreenInterceptor, deps: [{ token: i1.LoadingScreenService }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ LoadingScreenInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: LoadingScreenInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: LoadingScreenInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.LoadingScreenService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/base/models/auth-user.mjs

@@ -0,0 +1,3 @@
+export class AuthUser {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aC11c2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2RrL3NyYy9saWIvYmFzZS9tb2RlbHMvYXV0aC11c2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxRQUFRO0NBY3BCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIEF1dGhVc2VyIHtcclxuXHRpZDogbnVtYmVyO1xyXG5cdHN1YjogbnVtYmVyO1xyXG5cdG5hbWU6IHN0cmluZztcclxuXHRkaXNwbGF5TmFtZTogc3RyaW5nO1xyXG5cdGxldHRlcjogc3RyaW5nO1xyXG5cdGVtYWlsOiBzdHJpbmc7XHJcblx0cm9sZTogc3RyaW5nO1xyXG5cdHBlcm1pc3Npb246IEFycmF5PHN0cmluZz47XHJcblx0YWNjZXNzX3Rva2VuOiBzdHJpbmc7XHJcblx0aXNBdXRoZW50aWNhdGVkOiBib29sZWFuO1xyXG5cdHBvc3RMb2dpblJvdXRlOiBzdHJpbmc7XHJcblx0Y2xpZW50SWQ6IG51bWJlcjtcclxuXHRkZXBhcnRtZW50SWQ6IG51bWJlcjtcclxufSJdfQ==

package/esm2020/lib/base/public_api.mjs

@@ -0,0 +1,2 @@
+export * from './base.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Nkay9zcmMvbGliL2Jhc2UvcHVibGljX2FwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGVBQWUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYmFzZS5tb2R1bGUnO1xyXG4iXX0=

package/esm2020/lib/base/services/file.service.mjs

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import { GenericService } from '../../http/services/generic.service';
+import * as i0 from "@angular/core";
+export class FileService extends GenericService {
+    /**
+     * Constructor
+     */
+    constructor() {
+        super('file');
+    }
+}
+/** @nocollapse */ /** @nocollapse */ FileService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: FileService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ FileService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: FileService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: FileService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2RrL3NyYy9saWIvYmFzZS9zZXJ2aWNlcy9maWxlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0scUNBQXFDLENBQUM7O0FBR3JFLE1BQU0sT0FBTyxXQUFZLFNBQVEsY0FBbUI7SUFFbkQ7O09BRUc7SUFDSDtRQUNDLEtBQUssQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUNmLENBQUM7OzhJQVBXLFdBQVc7a0pBQVgsV0FBVyxjQURFLE1BQU07MkZBQ25CLFdBQVc7a0JBRHZCLFVBQVU7bUJBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBHZW5lcmljU2VydmljZSB9IGZyb20gJy4uLy4uL2h0dHAvc2VydmljZXMvZ2VuZXJpYy5zZXJ2aWNlJztcclxuXHJcbkBJbmplY3RhYmxlKHsgcHJvdmlkZWRJbjogJ3Jvb3QnIH0pXHJcbmV4cG9ydCBjbGFzcyBGaWxlU2VydmljZSBleHRlbmRzIEdlbmVyaWNTZXJ2aWNlPGFueT4ge1xyXG5cclxuXHQvKipcclxuXHQgKiBDb25zdHJ1Y3RvclxyXG5cdCAqL1xyXG5cdGNvbnN0cnVjdG9yKCkge1xyXG5cdFx0c3VwZXIoJ2ZpbGUnKTtcclxuXHR9XHJcbn0iXX0=

package/esm2020/lib/base/services/loading-screen.service.mjs

@@ -0,0 +1,47 @@
+import { Injectable } from '@angular/core';
+import { Subject } from "rxjs";
+import * as i0 from "@angular/core";
+export class LoadingScreenService {
+    constructor() {
+        /**
+         * _loading: boolean
+         */
+        this._loading = false;
+        /**
+         * loadingStatus: Subject<any>
+         */
+        this.loadingStatus = new Subject();
+    }
+    /**
+     * Gets the loading
+     */
+    get loading() {
+        return this._loading;
+    }
+    /**
+     * Sets the loading
+     */
+    set loading(value) {
+        this._loading = value;
+        this.loadingStatus.next(value);
+    }
+    /**
+     * Starts the loding
+     */
+    startLoading() {
+        this.loading = true;
+    }
+    /**
+     * Stops the loading
+     */
+    stopLoading() {
+        this.loading = false;
+    }
+}
+/** @nocollapse */ /** @nocollapse */ LoadingScreenService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: LoadingScreenService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ LoadingScreenService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: LoadingScreenService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: LoadingScreenService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/base/services/print.service.mjs

@@ -0,0 +1,40 @@
+import { Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class PrintService {
+    /**
+     * Constructor
+     * @param router
+     */
+    constructor(router) {
+        this.router = router;
+        this.isPrinting = false;
+    }
+    /**
+     * Print document
+     * @param documentName
+     * @param documentData
+     */
+    printDocument(documentName, documentData) {
+        this.isPrinting = true;
+        this.router.navigate(['/', { outlets: { 'print': ['print', documentName, documentData.join()] } }]);
+    }
+    /**
+     * On data ready
+     */
+    onDataReady() {
+        setTimeout(() => {
+            window.print();
+            this.isPrinting = false;
+            this.router.navigate([{ outlets: { print: null } }]);
+        });
+    }
+}
+/** @nocollapse */ /** @nocollapse */ PrintService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: PrintService, deps: [{ token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ PrintService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: PrintService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: PrintService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,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