ngx-cho-common 0.0.1

package/fesm2022/ngx-cho-common.mjs

@@ -0,0 +1,1196 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Injectable, Inject, Component } from '@angular/core';
+import { BehaviorSubject, lastValueFrom, take, retry, shareReplay } from 'rxjs';
+import { UserManager } from 'oidc-client';
+import * as i1 from '@angular/router';
+import { NavigationEnd } from '@angular/router';
+import * as i3 from 'ngx-spinner';
+import * as i2 from 'ngx-toastr';
+import { ZonedDateTime } from '@js-joda/core';
+import * as i1$1 from '@angular/common/http';
+import { HttpHeaders, HttpParams } from '@angular/common/http';
+import moment from 'moment';
+import { saveAs } from 'file-saver';
+import * as i2$1 from '@angular/common';
+import * as i1$2 from '@ng-bootstrap/ng-bootstrap';
+
+class AuthUser {
+    static { this.anonymous = new AuthUser(); }
+    /**
+     * Constructs a user object from a given oidc user object.
+     *
+     * @param oidcUser The oidc user object.
+     */
+    constructor(oidcUser = null) {
+        this.oidcUser = oidcUser;
+        this.oidcUser = oidcUser;
+        if (oidcUser == null) {
+            this.isAuthenticated = false;
+        }
+        else {
+            this.isAuthenticated = true;
+            this.authorizationHeader = `${oidcUser.token_type} ${oidcUser.access_token}`;
+            this.name = oidcUser.profile?.name;
+            this.firstName = oidcUser.profile?.given_name;
+            this.lastName = oidcUser.profile?.family_name;
+            this.fullName = `${this.firstName} ${this.lastName}`;
+        }
+    }
+    /**
+     * Gets the raw claims associated with the user.
+     */
+    get claims() {
+        return this.oidcUser?.profile || {};
+    }
+    /**
+     * Determines whether the currently authenticated user is in any of an
+     * array of roles.
+     *
+     * @param roles An array of required roles.
+     * @returns True if the user has any of the required roles, false otherwise.
+     */
+    hasAnyRole(...roles) {
+        const roleClaim = this.claims['role'];
+        if (roleClaim == null) {
+            return false;
+        }
+        const claimRoles = Array.isArray(roleClaim) ? roleClaim : [roleClaim];
+        return roles.some(r => claimRoles.some(cr => r.toLowerCase() === cr.toLowerCase()));
+    }
+    /**
+     * Determines whether the currently authenticated user has a claim,
+     * and optionally, whether the claim has a specific value.
+     *
+     * @param claimType Claim type to match
+     * @param claimValue Optional claim value to match
+     *
+     * @returns True if the user has the required claim, false otherwise.
+     */
+    hasClaim(claimType, claimValue) {
+        const value = this.claims[claimType];
+        return !!value && (!claimValue || value === claimValue);
+    }
+    /**
+     * Determines whether the currently authenticated user is a customer.
+     */
+    get isCustomer() {
+        return this.hasClaim('ch:customer');
+    }
+    /**
+     * Determines whether the currently authenticated user is an employee.
+     */
+    get isEmployee() {
+        return this.hasAnyRole('ch:Employee');
+    }
+    /**
+     * Creates a user object given an oidc user object.
+     *
+     * @param oidcUser The oidc user object.
+     * @returns A user object for the given oidc user object.  If no oidc
+     * user object is specified or it has expired, returns the anonymous
+     * user.
+     */
+    static from(oidcUser) {
+        if (oidcUser === null || oidcUser.expired) {
+            return AuthUser.anonymous;
+        }
+        return new AuthUser(oidcUser);
+    }
+}
+
+class AuthorizationContext {
+    constructor(user) {
+        this.user = user;
+    }
+}
+
+const SECURITY_POLICIES = new InjectionToken('');
+
+class SessionStorageService {
+    checkIfKeyExists(key) {
+        return globalThis.sessionStorage.getItem(key) !== null;
+    }
+    getItem(key) {
+        const valueString = globalThis.sessionStorage.getItem(key);
+        if (valueString === null) {
+            return undefined;
+        }
+        const value = JSON.parse(valueString);
+        return value;
+    }
+    setItem(key, value) {
+        const valueString = JSON.stringify(value);
+        globalThis.sessionStorage.setItem(key, valueString);
+    }
+    removeItem(key) {
+        globalThis.sessionStorage.removeItem(key);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SessionStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SessionStorageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SessionStorageService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+// function getClientSettings(): UserManagerSettings {
+//     return {
+//         authority: environment.auth.authority,
+//         client_id: environment.auth.clientId,
+//         redirect_uri: `${environment.webApp}/auth-callback`,
+//         post_logout_redirect_uri: environment.webApp,
+//         response_type: 'id_token token',
+//         scope: `openid profile ${environment.auth.resourceId}`,
+//         filterProtocolClaims: true,
+//         loadUserInfo: true,
+//         automaticSilentRenew: true,
+//         silent_redirect_uri: `${environment.webApp}/silent-refresh.html`,
+//         //extraQueryParams: { resource: environment.auth.resourceId }
+//         // This is useful for testing silent refresh.  Don't set this any lower, otherwise
+//         // the token authority will likely block you.
+//         //accessTokenExpiringNotificationTime: 3545
+//     };
+// }
+class AuthService {
+    constructor(securityPolicies, webAppUrl, userManagerSettings, router, sessionStorage, spinnerService) {
+        this.securityPolicies = securityPolicies;
+        this.webAppUrl = webAppUrl;
+        this.userManagerSettings = userManagerSettings;
+        this.router = router;
+        this.sessionStorage = sessionStorage;
+        this.spinnerService = spinnerService;
+        this.returnUrlKey = 'AuthService.returnUrl';
+        this.userManager = new UserManager(this.userManagerSettings);
+        this._currentUser = AuthUser.anonymous;
+        this.userStream = new BehaviorSubject(AuthUser.anonymous);
+        this.userManager.events.addSilentRenewError(err => {
+            console.error(err);
+        });
+        this.checkIsAuthenticated();
+    }
+    /**
+     * Gets the current user.
+     */
+    get currentUser() {
+        return this._currentUser;
+    }
+    /**
+     * Sets the current user.
+     */
+    set currentUser(user) {
+        this._currentUser = user;
+        const authContext = new AuthorizationContext(user);
+        this.securityPolicies.forEach(p => p.evaluate(authContext));
+        this.userStream.next(user);
+    }
+    /**
+     * Checks that the specified security policy is satisfied.
+     *
+     * @param name
+     * @returns
+     */
+    checkPolicy(name) {
+        return this.securityPolicies.some(p => p.name === name && p.succeeded);
+    }
+    /**
+     * Completes the authentication process, redirecting to the return URL if specified
+     * in the start authentication call.
+     *
+     * @returns A void promise.
+     */
+    async completeAuthentication() {
+        this.currentUser = AuthUser.from(await this.userManager.signinRedirectCallback());
+        let returnUrl = this.sessionStorage.getItem(this.returnUrlKey) || this.webAppUrl;
+        this.sessionStorage.removeItem(this.returnUrlKey);
+        if (returnUrl.endsWith('login')) {
+            returnUrl = this.webAppUrl;
+        }
+        this.router.navigateByUrl(returnUrl, { replaceUrl: true });
+    }
+    /**
+     * Determines whether the user is authenticated.
+     */
+    async checkIsAuthenticated() {
+        this.currentUser = AuthUser.from(await this.userManager.getUser());
+        return this.currentUser.isAuthenticated;
+    }
+    /**
+     * Signs the current user out of the sytem.
+     */
+    async signout() {
+        await this.userManager.signoutRedirect();
+        this.userManager.removeUser();
+        this.currentUser = AuthUser.anonymous;
+    }
+    /**
+     * Begins the authentication process.
+     *
+     * @param returnUrl Optional.  Destination after authentication is complete.
+     * @returns A void promise.
+     */
+    startAuthentication(returnUrl) {
+        if (returnUrl) {
+            this.sessionStorage.setItem(this.returnUrlKey, returnUrl);
+        }
+        this.spinnerService.show();
+        return this.userManager.signinRedirect().then(() => {
+            this.spinnerService.hide();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthService, deps: [{ token: SECURITY_POLICIES }, { token: 'webAppUrl' }, { token: 'userManagerSettings' }, { token: i1.Router }, { token: SessionStorageService }, { token: i3.NgxSpinnerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [SECURITY_POLICIES]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['webAppUrl']
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['userManagerSettings']
+                }] }, { type: i1.Router }, { type: SessionStorageService }, { type: i3.NgxSpinnerService }] });
+
+class AuthCallbackComponent {
+    constructor(authService) {
+        this.authService = authService;
+    }
+    ngOnInit() {
+        return this.authService.completeAuthentication();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthCallbackComponent, deps: [{ token: AuthService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: AuthCallbackComponent, selector: "app-auth-callback", ngImport: i0, template: "" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthCallbackComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-auth-callback', template: "" }]
+        }], ctorParameters: () => [{ type: AuthService }] });
+
+class AuthGuardService {
+    constructor(authService, toastr) {
+        this.authService = authService;
+        this.toastr = toastr;
+    }
+    async canActivate(route, state) {
+        if (await this.authService.checkIsAuthenticated()) {
+            const routePolicy = route.data['policy'];
+            if (!routePolicy) {
+                return true;
+            }
+            if (!this.authService.checkPolicy(routePolicy)) {
+                this.toastr.error("Oops! It doesn't look like you are authorized to access this page.");
+                return false;
+            }
+            return true;
+        }
+        await this.authService.startAuthentication(state.url);
+        return false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthGuardService, deps: [{ token: AuthService }, { token: i2.ToastrService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthGuardService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthGuardService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: AuthService }, { type: i2.ToastrService }] });
+
+class SecurityPolicy {
+    constructor(name, requirement) {
+        this.name = name;
+        this.requirement = requirement;
+        this._succeeded = false;
+    }
+    get succeeded() {
+        return this._succeeded;
+    }
+    evaluate(context) {
+        this._succeeded = this.requirement(context);
+        return this._succeeded;
+    }
+}
+
+class SigninComponent {
+    constructor(authService) {
+        this.authService = authService;
+    }
+    ngOnInit() {
+        this.authService.startAuthentication('/');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SigninComponent, deps: [{ token: AuthService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: SigninComponent, selector: "app-signin", ngImport: i0, template: "<section class=\"container-fluid\">\n    <p>Redirecting to sign in page...</p>\n</section>\n" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SigninComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-signin', template: "<section class=\"container-fluid\">\n    <p>Redirecting to sign in page...</p>\n</section>\n" }]
+        }], ctorParameters: () => [{ type: AuthService }] });
+
+class SignoutComponent {
+    constructor(authService) {
+        this.authService = authService;
+    }
+    ngOnInit() {
+        this.authService.signout();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SignoutComponent, deps: [{ token: AuthService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: SignoutComponent, selector: "app-signout", ngImport: i0, template: "<section class=\"container-fluid\">\n    <p>Signing out...</p>\n</section>\n" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SignoutComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-signout', template: "<section class=\"container-fluid\">\n    <p>Signing out...</p>\n</section>\n" }]
+        }], ctorParameters: () => [{ type: AuthService }] });
+
+var SeverityLevel;
+(function (SeverityLevel) {
+    SeverityLevel[SeverityLevel["verbose"] = 0] = "verbose";
+    SeverityLevel[SeverityLevel["information"] = 1] = "information";
+    SeverityLevel[SeverityLevel["warning"] = 2] = "warning";
+    SeverityLevel[SeverityLevel["error"] = 3] = "error";
+    SeverityLevel[SeverityLevel["critical"] = 4] = "critical";
+})(SeverityLevel || (SeverityLevel = {}));
+
+class ConsoleLoggerSink {
+    constructor(name, level) {
+        this.name = name;
+        this.level = level;
+        this.consoleMethods = new Map([
+            [SeverityLevel.verbose, console.log],
+            [SeverityLevel.information, console.info || console.log],
+            [SeverityLevel.warning, console.warn || console.log],
+            [SeverityLevel.error, console.error || console.log],
+            [SeverityLevel.critical, console.error || console.log],
+        ]);
+    }
+    write(logEntry) {
+        const consoleMethod = this.consoleMethods.get(logEntry.severityLevel) || console.log;
+        if (logEntry.stackTrace) {
+            const error = new Error(logEntry.message);
+            error.stack = logEntry.stackTrace;
+            consoleMethod(error);
+        }
+        else {
+            consoleMethod(logEntry.message);
+        }
+        return Promise.resolve();
+    }
+}
+
+class Logger {
+}
+
+class Uuid {
+    static create() {
+        const bytes = crypto.getRandomValues(new Uint8Array(16));
+        bytes[6] = (bytes[6] & 0x0f) | 0x40;
+        bytes[8] = (bytes[8] & 0x3f) | 0x80;
+        let index = 0;
+        return (Uuid.toHex(bytes[index++]) +
+            Uuid.toHex(bytes[index++]) +
+            Uuid.toHex(bytes[index++]) +
+            Uuid.toHex(bytes[index++]) +
+            '-' +
+            Uuid.toHex(bytes[index++]) +
+            Uuid.toHex(bytes[index++]) +
+            '-' +
+            Uuid.toHex(bytes[index++]) +
+            Uuid.toHex(bytes[index++]) +
+            '-' +
+            Uuid.toHex(bytes[index++]) +
+            Uuid.toHex(bytes[index++]) +
+            '-' +
+            Uuid.toHex(bytes[index++]) +
+            Uuid.toHex(bytes[index++]) +
+            Uuid.toHex(bytes[index++]) +
+            Uuid.toHex(bytes[index++]) +
+            Uuid.toHex(bytes[index++]) +
+            Uuid.toHex(bytes[index++]));
+    }
+    static toHex(byte) {
+        return (0x100 | byte).toString(16).substr(1);
+    }
+}
+
+class LoggerService {
+    static { this.overrideQueryStringRegex = /log\.(\w+)/; }
+    constructor(loggerSinkConfiguration, activatedRoute, authService, injector) {
+        this.loggerSinkConfiguration = loggerSinkConfiguration;
+        this.activatedRoute = activatedRoute;
+        this.authService = authService;
+        this.injector = injector;
+        this.sessionId = Uuid.create();
+        this.sinks = new Array();
+        this.minimumLevel = SeverityLevel.error;
+        this.readConfiguration();
+        this.activatedRoute.queryParams.subscribe(async (params) => {
+            const isDebug = this.authService.checkPolicy('debug');
+            if (isDebug) {
+                let updated = false;
+                for (const key of Object.keys(params)) {
+                    const match = key.match(LoggerService.overrideQueryStringRegex);
+                    if (match?.length === 2) {
+                        const [paramName, sinkName] = match;
+                        const sink = this.sinks.find(s => s.name === sinkName);
+                        if (!sink) {
+                            throw new Error(`Cannot find sink with name '${sinkName}'.`);
+                        }
+                        const value = params[paramName];
+                        let level;
+                        if (!value) {
+                            throw new Error(`Missing value for query string parameter '${paramName}'.`);
+                        }
+                        else if (!(level = parseInt(value))) {
+                            level =
+                                SeverityLevel[value.toLowerCase()];
+                        }
+                        sink.level = level;
+                        updated = true;
+                        console.log(`Logging sink '${sinkName}' set to '${value}'.`);
+                    }
+                }
+                if (updated) {
+                    this.refreshSinks();
+                }
+            }
+        });
+    }
+    logError(message, options) {
+        if (typeof message === 'string') {
+            this.logWrite(SeverityLevel.error, message, options);
+            return;
+        }
+        const error = message;
+        this.logWrite(SeverityLevel.error, error.message, Object.assign({ stackTrace: error.stack }, options));
+    }
+    logInfo(message, options) {
+        this.logWrite(SeverityLevel.information, message, options);
+    }
+    logVerbose(message, options) {
+        this.logWrite(SeverityLevel.verbose, message, options);
+    }
+    logWarning(message, options) {
+        this.logWrite(SeverityLevel.warning, message, options);
+    }
+    logWrite(level, message, options) {
+        if (level < this.minimumLevel) {
+            return;
+        }
+        const logEntry = {
+            createdDateTime: ZonedDateTime.now().withFixedOffsetZone().toString(),
+            sessionId: this.sessionId,
+            severityLevel: level,
+            message: message,
+            stackTrace: options?.stackTrace,
+            url: window.location.href,
+            userAgent: navigator.userAgent,
+            jsonData: options?.data ? JSON.stringify(options.data) : undefined,
+        };
+        for (const sink of this.sinks) {
+            if (level >= sink.level) {
+                try {
+                    sink.write(logEntry);
+                }
+                catch (error) {
+                    this.logError(`Error writing log entry to sink '${sink.name}'.`, {
+                        stackTrace: error.stack,
+                        data: { sink: sink.name },
+                    });
+                }
+            }
+        }
+    }
+    readConfiguration() {
+        const sinkConfigs = this.loggerSinkConfiguration;
+        if (sinkConfigs) {
+            for (const sinkConfig of sinkConfigs) {
+                this.requiredProperty(sinkConfig, 'name');
+                this.requiredProperty(sinkConfig, 'type');
+                this.requiredProperty(sinkConfig, 'level');
+                const sink = new sinkConfig.type(sinkConfig.name, sinkConfig.level, sinkConfig.args, this, this.injector);
+                this.sinks.push(sink);
+            }
+            this.refreshSinks();
+        }
+    }
+    refreshSinks() {
+        this.minimumLevel = this.sinks.reduce((l, s) => Math.min(l, s.level), SeverityLevel.critical);
+    }
+    requiredProperty(obj, propertyName) {
+        if (obj[propertyName] == null) {
+            throw new Error(`Missing required property '${propertyName}' in the logger section of environment.ts.`);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LoggerService, deps: [{ token: 'loggerSinkConfiguration' }, { token: i1.ActivatedRoute }, { token: AuthService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LoggerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LoggerService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['loggerSinkConfiguration']
+                }] }, { type: i1.ActivatedRoute }, { type: AuthService }, { type: i0.Injector }] });
+
+/* eslint-disable @typescript-eslint/ban-types */
+class RestClient {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+        this.defaultRetry = { count: 0, delay: 1000 };
+    }
+    /**
+     * Sends a delete request to the specified REST service
+     *
+     * @param url The service endpoint
+     * @param options Additional options
+     */
+    delete(url, options) {
+        return lastValueFrom(this.request('DELETE', url, options));
+    }
+    /**
+     * Retrieves data from the specified REST service
+     *
+     * @param url The service endpoint
+     * @param options Additional options
+     */
+    get(url, options) {
+        return lastValueFrom(this.request('GET', url, options));
+    }
+    /**
+     * Sends a patch request to the specified REST service
+     *
+     * @param url The service endpoint
+     * @param options Additional options
+     */
+    patch(url, options) {
+        return lastValueFrom(this.request('PATCH', url, options));
+    }
+    /**
+     * Sends a post request to the specified REST service
+     *
+     * @param url The service endpoint
+     * @param options Additional options
+     */
+    post(url, options) {
+        return lastValueFrom(this.request('POST', url, options));
+    }
+    /**
+     * Sends a put request to the specified REST service
+     *
+     * @param url The service endpoint
+     * @param options Additional options
+     */
+    put(url, options) {
+        return lastValueFrom(this.request('PUT', url, options));
+    }
+    request(method, url, options) {
+        return this.httpClient
+            .request(method, url, {
+            body: options?.body ? JSON.stringify(options.body) : undefined,
+            headers: this.createRequestHeaders(options),
+            params: this.createRequestParams(options?.queryParameters),
+        })
+            .pipe(take(1), retry(options?.retry || this.defaultRetry));
+    }
+    /**
+     *
+     * @param url
+     * @param options
+     * @returns
+     */
+    getResponse(method, url, options) {
+        return this.httpClient
+            .request(method, url, {
+            observe: 'response',
+            body: options?.body ? JSON.stringify(options.body) : undefined,
+            headers: this.createRequestHeaders(options),
+            params: this.createRequestParams(options?.queryParameters),
+        })
+            .pipe(take(1), retry(options?.retry || this.defaultRetry));
+    }
+    /**
+     * Creates request headers based on the provided options.
+     *
+     * @param options
+     * @returns
+     */
+    createRequestHeaders(options) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const headers = Object.assign({
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+        }, options?.headers);
+        if (options?.apiVersion) {
+            const versionString = `; version=${options.apiVersion}`;
+            headers.Accept += versionString;
+            headers['Content-Type'] += versionString;
+        }
+        if (options?.showSpinner === false) {
+            headers['x-spinner'] = 'false';
+        }
+        if (options?.cacheLifetimeSeconds) {
+            headers['x-cache-ttl'] = options?.cacheLifetimeSeconds;
+        }
+        return new HttpHeaders(headers);
+    }
+    /**
+     * Converts one or more objects to an HttpParams object.
+     *
+     * @param sources The objects to convert
+     * @returns
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    createRequestParams(...sources) {
+        let params = new HttpParams();
+        for (const source of sources) {
+            if (source == null) {
+                continue;
+            }
+            for (const key of Object.keys(source)) {
+                const value = source[key];
+                if (value != null) {
+                    params = params.set(key, value.toString());
+                }
+            }
+        }
+        return params;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RestClient, deps: [{ token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RestClient, providedIn: 'any' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RestClient, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'any' }]
+        }], ctorParameters: () => [{ type: i1$1.HttpClient }] });
+
+var FireImmediately;
+(function (FireImmediately) {
+    FireImmediately[FireImmediately["never"] = 0] = "never";
+    FireImmediately[FireImmediately["whenShown"] = 1] = "whenShown";
+    FireImmediately[FireImmediately["whenFocused"] = 2] = "whenFocused";
+})(FireImmediately || (FireImmediately = {}));
+class IntervalService {
+    static { this.defaultOptions = { fireImmediately: FireImmediately.never }; }
+    create(action, interval, options = IntervalService.defaultOptions) {
+        const timer = new IntervalTimer(action, interval, options);
+        timer.initialize();
+        return timer;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IntervalService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IntervalService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IntervalService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+class IntervalTimer {
+    constructor(action, interval, options) {
+        this.action = action;
+        this.interval = interval;
+        this.options = options;
+        this.currentInterval = 0;
+        this.isStopped = true;
+    }
+    initialize() {
+        if (this.options.hiddenInterval != null) {
+            document.addEventListener('visibilitychange', () => {
+                if (document.hidden) {
+                    this.onHidden();
+                }
+                else {
+                    this.onShown();
+                }
+            });
+        }
+        if (this.options.blurInterval != null) {
+            window.addEventListener('blur', () => this.onBlur());
+            window.addEventListener('focus', () => this.onFocus());
+        }
+    }
+    start() {
+        if (this.isStopped) {
+            if (!document.hidden) {
+                this.isStopped = false;
+                this.onShown();
+            }
+            else {
+                this.setInterval(this.interval);
+                this.isStopped = false;
+            }
+        }
+    }
+    stop() {
+        this.setInterval(0);
+        this.isStopped = true;
+    }
+    async callActionAndScheduleNext(nextInterval) {
+        this.setInterval(0); // pause while the action runs
+        await this.action();
+        this.setInterval(nextInterval);
+    }
+    onBlur() {
+        if (this.isStopped) {
+            return;
+        }
+        this.setInterval(this.options?.blurInterval);
+    }
+    onFocus() {
+        if (this.isStopped) {
+            return;
+        }
+        if (this.options?.fireImmediately === FireImmediately.whenFocused) {
+            this.callActionAndScheduleNext(this.interval);
+            return;
+        }
+        this.setInterval(this.interval);
+    }
+    onHidden() {
+        if (this.isStopped) {
+            return;
+        }
+        this.setInterval(this.options?.hiddenInterval);
+    }
+    onShown() {
+        if (this.isStopped) {
+            return;
+        }
+        if (this.options.fireImmediately === FireImmediately.whenShown) {
+            this.callActionAndScheduleNext(this.interval);
+            return;
+        }
+        this.setInterval(this.interval);
+    }
+    setInterval(interval) {
+        if (this.$handle) {
+            if (interval === this.currentInterval) {
+                return;
+            }
+            window.clearTimeout(this.$handle);
+            this.$handle = undefined;
+        }
+        if (!interval) {
+            return;
+        }
+        this.$handle = window.setTimeout(() => this.callActionAndScheduleNext(interval), interval);
+        this.currentInterval = interval;
+    }
+}
+
+class ServerLoggerSink {
+    constructor(name, level, args, logger, injector) {
+        this.name = name;
+        this.level = level;
+        this.args = args;
+        this.logger = logger;
+        this.injector = injector;
+        this.retryCount = 10;
+        this.postFrequency = 15 * 1000 /*15 seconds*/;
+        this.entryBuffer = new Array();
+        this.errorCount = 0;
+        if (!args?.url) {
+            throw new Error(`Missing required argument 'url' for sink ${this.constructor.name}.`);
+        }
+        const intervalService = injector.get(IntervalService);
+        this.$interval = intervalService.create(() => this.flush(), this.postFrequency);
+        this.$interval.start();
+    }
+    write(logEntry) {
+        this.entryBuffer.push(logEntry);
+    }
+    async flush() {
+        if (this.entryBuffer.length === 0) {
+            return;
+        }
+        const mark = this.entryBuffer.length;
+        try {
+            await this.postLogEntries(this.entryBuffer);
+            this.entryBuffer = this.entryBuffer.slice(mark);
+            this.errorCount = 0;
+        }
+        catch (error) {
+            this.logger.logError(error);
+            if (this.errorCount++ > this.retryCount) {
+                this.$interval.stop();
+                throw new Error(`Error posting log entries to server.  Retried ${this.retryCount} times and giving up.`);
+            }
+        }
+    }
+    postLogEntries(entries) {
+        const restClient = this.injector.get(RestClient);
+        const restOptions = Object.assign({}, this.args, {
+            body: entries,
+            showSpinner: false,
+        });
+        return restClient.post(this.args.url, restOptions);
+    }
+}
+
+class DateService {
+    getMonthItems(startMonth = 1, endMonth = 12) {
+        const items = [];
+        const d = moment().startOf('year');
+        let i = startMonth;
+        while (i <= endMonth) {
+            d.set('month', i - 1);
+            items.push({ value: i, name: d.format('MMMM') });
+            i++;
+        }
+        return items;
+    }
+    getYearItems(startYear, endYear) {
+        startYear = startYear || moment().year();
+        endYear = endYear || moment().year();
+        const items = [];
+        let i = startYear;
+        while (i <= endYear) {
+            items.push({ value: i, name: i.toString() });
+            i++;
+        }
+        return items;
+    }
+    toDateString(input) {
+        return moment(input).format('yyyy-MM-DD');
+    }
+    toISOString(input) {
+        return moment(input).toISOString();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DateService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DateService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class DownloadService {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+        this.octetStreamMime = 'application/octet-stream';
+    }
+    downloadFile(url, params) {
+        const download$ = this.httpClient
+            .get(url, {
+            responseType: 'arraybuffer',
+            observe: 'response',
+            params: params,
+        })
+            .pipe(shareReplay());
+        download$.subscribe(r => this.processDownload(r));
+        return download$;
+    }
+    processDownload(response) {
+        const filename = this.getFileNameFromResponse(response);
+        const contentType = response.headers.get('content-type') || this.octetStreamMime;
+        if (response.body) {
+            const blob = new Blob([response.body], { type: contentType });
+            saveAs(blob, filename);
+        }
+    }
+    getFileNameFromResponse(response) {
+        // attempt to get from response headers
+        let fileName = response.headers.get('x-filename') || response.headers.get('filename');
+        if (!fileName) {
+            // attempt to get from content disposition
+            const disposition = response.headers.get('content-disposition');
+            if (disposition) {
+                fileName = disposition.split(';')[1].split('=')[1].replace(/"/g, '');
+            }
+        }
+        return fileName || 'download.bin';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DownloadService, deps: [{ token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DownloadService, providedIn: 'any' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DownloadService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'any' }]
+        }], ctorParameters: () => [{ type: i1$1.HttpClient }] });
+
+class FeatureService {
+    constructor(webApiUrl, restClient) {
+        this.webApiUrl = webApiUrl;
+        this.restClient = restClient;
+        this.featureStream = new BehaviorSubject([]);
+        this._enabledFeatures = [];
+        this._isInitialized = false;
+        this.routePrefix = `${this.webApiUrl}/common/features`;
+        this.checkEnabledFeatures();
+    }
+    /**
+     * Gets the enabled features.
+     */
+    get enabledFeatures() {
+        return this._enabledFeatures;
+    }
+    /**
+     * Sets the enabled features.
+     */
+    set enabledFeatures(enabledFeatures) {
+        this._enabledFeatures = enabledFeatures;
+        this._isInitialized = true;
+        this.featureStream.next(enabledFeatures);
+    }
+    /**
+     * Gets whether features have been initialized
+     */
+    get isInitialized() {
+        return this._isInitialized;
+    }
+    /**
+     * Checks that the enabled features are set and returns the list.
+     *
+     * @param name
+     * @returns
+     */
+    async checkEnabledFeatures() {
+        if (!this._enabledFeatures) {
+            this.enabledFeatures = await this.restClient.get(`${this.routePrefix}/enabled`);
+        }
+        return this.enabledFeatures;
+    }
+    /**
+     * Checks that the specified feature is enabled.
+     *
+     * @param name
+     * @returns
+     */
+    checkFeatureIsEnabled(name) {
+        return this._enabledFeatures?.some(p => p === name);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FeatureService, deps: [{ token: 'webApiUrl' }, { token: RestClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FeatureService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FeatureService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['webApiUrl']
+                }] }, { type: RestClient }] });
+
+// from https://nils-mehlhorn.de/posts/angular-navigate-back-previous-page
+class NavigationService {
+    constructor(router, location) {
+        this.router = router;
+        this.location = location;
+        this.history = [];
+        this.router.events.subscribe(event => {
+            if (event instanceof NavigationEnd) {
+                this.history.push(event.urlAfterRedirects);
+            }
+        });
+    }
+    goBack() {
+        this.goBackOrDefault('/');
+    }
+    goBackOrDefault(defaultUrl) {
+        if (this.history.length > 0) {
+            this.history.pop();
+            this.location.back();
+        }
+        else {
+            this.router.navigateByUrl(defaultUrl);
+        }
+    }
+    setQueryParams(params) {
+        this.router.navigate([], {
+            queryParams: params,
+            queryParamsHandling: 'merge',
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NavigationService, deps: [{ token: i1.Router }, { token: i2$1.Location }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NavigationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NavigationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i2$1.Location }] });
+
+class FeatureGuardService {
+    constructor(featureService, navigationService, toastr) {
+        this.featureService = featureService;
+        this.navigationService = navigationService;
+        this.toastr = toastr;
+    }
+    async canActivate(route) {
+        const routeFeature = route.data['feature'];
+        if (!routeFeature) {
+            return true;
+        }
+        await this.featureService.checkEnabledFeatures();
+        if (!this.featureService.checkFeatureIsEnabled(routeFeature)) {
+            this.toastr.error("Oops! It doesn't look like this feature has been enabled.");
+            this.navigationService.goBack();
+            return false;
+        }
+        return true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FeatureGuardService, deps: [{ token: FeatureService }, { token: NavigationService }, { token: i2.ToastrService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FeatureGuardService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FeatureGuardService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: FeatureService }, { type: NavigationService }, { type: i2.ToastrService }] });
+
+class LocalStorageService {
+    checkIfKeyExists(key) {
+        return globalThis.localStorage.getItem(key) !== null;
+    }
+    getItem(key) {
+        const valueString = globalThis.localStorage.getItem(key);
+        if (valueString === null) {
+            return undefined;
+        }
+        const value = JSON.parse(valueString);
+        return value;
+    }
+    setItem(key, value) {
+        const valueString = JSON.stringify(value);
+        globalThis.localStorage.setItem(key, valueString);
+    }
+    removeItem(key) {
+        globalThis.localStorage.removeItem(key);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalStorageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalStorageService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class ModalService {
+    constructor(ngbModal) {
+        this.ngbModal = ngbModal;
+    }
+    async showModal(component, componentParameters, modalOptions = { backdrop: 'static' }) {
+        const modal = this.ngbModal.open(component, modalOptions);
+        const componentInstance = modal.componentInstance;
+        Object.assign(componentInstance, componentParameters);
+        let result;
+        try {
+            result = await modal.result;
+        }
+        catch (error) {
+            result = null;
+            if (error === undefined) {
+                throw 'modal dismiss';
+            }
+            throw error;
+        }
+        return { result, componentInstance };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ModalService, deps: [{ token: i1$2.NgbModal }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ModalService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ModalService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1$2.NgbModal }] });
+
+class ObjectService {
+    toValueObject(obj) {
+        const result = Object.getOwnPropertyNames(obj).reduce((p, key) => {
+            if (obj[key]) {
+                p[key] = obj[key];
+            }
+            return p;
+        }, new Object());
+        return result;
+    }
+    /**
+     * Convert Object to HttpParams
+     * @param {object} obj
+     * @returns {HttpParams}
+     * see: https://stackoverflow.com/questions/45210406/angular-4-3-httpclient-set-params
+     */
+    toHttpParams(obj) {
+        const temp = Object.getOwnPropertyNames(obj).reduce((p, key) => (obj[key] == null || obj[key].length === 0 ? p : p.set(key, obj[key])), new HttpParams());
+        return temp;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ObjectService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ObjectService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ObjectService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class RouteParamService {
+    constructor(route) {
+        this.route = route;
+    }
+    getParameterBoolean(params, paramKey) {
+        const value = this.getParameterValue(params, paramKey);
+        if (value) {
+            return !!value;
+        }
+        return null;
+    }
+    getParameterNumber(params, paramKey) {
+        const value = this.getParameterValue(params, paramKey);
+        if (value) {
+            return parseInt(value);
+        }
+        return null;
+    }
+    getParameterValue(params, paramKey) {
+        const value = params[paramKey];
+        return value || null;
+    }
+    getQueryParameterBoolean(paramKey) {
+        return this.getParameterBoolean(this.route.snapshot.queryParams, paramKey);
+    }
+    getQueryParameterNumber(paramKey) {
+        return this.getParameterNumber(this.route.snapshot.queryParams, paramKey);
+    }
+    getQueryParameterValue(paramKey) {
+        return this.getParameterValue(this.route.snapshot.queryParams, paramKey);
+    }
+    getRouteParameterBoolean(route, paramKey) {
+        return this.getParameterBoolean(route.snapshot.params, paramKey);
+    }
+    getRouteParameterNumber(route, paramKey) {
+        return this.getParameterNumber(route.snapshot.params, paramKey);
+    }
+    getRouteParameterValue(route, paramKey) {
+        return this.getParameterValue(route.snapshot.params, paramKey);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RouteParamService, deps: [{ token: i1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RouteParamService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RouteParamService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.ActivatedRoute }] });
+
+class UnsavedChangesGuard {
+    canDeactivate(component) {
+        return component.onDeactivate ? component.onDeactivate() : true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UnsavedChangesGuard, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UnsavedChangesGuard }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UnsavedChangesGuard, decorators: [{
+            type: Injectable
+        }] });
+
+/*
+ * Public API Surface of ngx-cho-common
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AuthCallbackComponent, AuthGuardService, AuthService, AuthUser, AuthorizationContext, ConsoleLoggerSink, DateService, DownloadService, FeatureGuardService, FeatureService, IntervalService, IntervalTimer, LocalStorageService, Logger, LoggerService, ModalService, NavigationService, ObjectService, RestClient, RouteParamService, SECURITY_POLICIES, SecurityPolicy, ServerLoggerSink, SessionStorageService, SeverityLevel, SigninComponent, SignoutComponent, UnsavedChangesGuard, Uuid };
+//# sourceMappingURL=ngx-cho-common.mjs.map