@huntsman-cancer-institute/authentication 12.5.0 → 14.1.0

package/esm2020/authentication.service.mjs

@@ -0,0 +1,393 @@
+/*
+ * Copyright (c) 2016 Huntsman Cancer Institute at the University of Utah, Confidential and Proprietary
+ */
+import { Injectable, InjectionToken, Inject, Optional, isDevMode } from "@angular/core";
+import { LocationStrategy } from "@angular/common";
+import { Router } from "@angular/router";
+import { HttpClient, HttpHeaders } from "@angular/common/http";
+import { interval, BehaviorSubject, throwError } from "rxjs";
+import { catchError, map } from "rxjs/operators";
+import { JwtHelperService } from "@auth0/angular-jwt";
+import { AuthenticationProvider } from "./authentication.provider";
+import { CoolLocalStorage } from "@angular-cool/storage";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@angular/router";
+import * as i3 from "@angular-cool/storage";
+import * as i4 from "@auth0/angular-jwt";
+import * as i5 from "./authentication.provider";
+import * as i6 from "@angular/common";
+/**
+ * The token used for injection of the server side endpoint for the currently authenticated subject.
+ *
+ * @type {InjectionToken}
+ */
+export let AUTHENTICATION_SERVER_URL = new InjectionToken("authentication_server_rest_api");
+export let AUTHENTICATION_LOGOUT_PATH = new InjectionToken("authentication_logout_path");
+export let AUTHENTICATION_DIRECT_ENDPOINT = new InjectionToken("authentication_direct_endpoint");
+export let AUTHENTICATION_TOKEN_ENDPOINT = new InjectionToken("authentication_token_endpoint");
+export let AUTHENTICATION_ROUTE = new InjectionToken("authentication_route");
+export let AUTHENTICATION_MAX_INACTIVITY_MINUTES = new InjectionToken("authentication_max_inactivity");
+export let AUTHENTICATION_USER_COUNTDOWN_SECONDS = new InjectionToken("authentication_user_countdown_seconds");
+export let AUTHENTICATION_IDP_INACTIVITY_MINUTES = new InjectionToken("authentication_idp_inactivity_minutes");
+/**
+ * @since 1.0.0
+ */
+export class AuthenticationService {
+    constructor(_http, _router, _localStorageService, _jwtHelper, authenticationProvider, _authenticationRoute, _logoutPath, _tokenEndpoint, _serverUrl, _directEndpoint, _maxInactivity, _userCountdownSeconds, _idpInactivityMinutes, locationStrategy) {
+        this._http = _http;
+        this._router = _router;
+        this._localStorageService = _localStorageService;
+        this._jwtHelper = _jwtHelper;
+        this.authenticationProvider = authenticationProvider;
+        this._authenticationRoute = _authenticationRoute;
+        this._logoutPath = _logoutPath;
+        this._tokenEndpoint = _tokenEndpoint;
+        this._serverUrl = _serverUrl;
+        this._directEndpoint = _directEndpoint;
+        this._maxInactivity = _maxInactivity;
+        this._userCountdownSeconds = _userCountdownSeconds;
+        this._idpInactivityMinutes = _idpInactivityMinutes;
+        this.locationStrategy = locationStrategy;
+        this.userCountdownSeconds = 60;
+        this.idpInactivityMinutes = 5;
+        this.contentType = "application/json";
+        this.limitedContext = false;
+        this.deidentifiedContext = false;
+        this.maxViewPermission = new BehaviorSubject("viewident");
+        this._isAuthenticatedSubject = new BehaviorSubject(false);
+        this._userIsAboutToTimeOut = new BehaviorSubject(false);
+        this._maxInactivityMinutes = 120;
+        this.contextRoot = "";
+        if (isDevMode()) {
+            console.debug("window.location.href: " + window.location.href);
+        }
+        if (window.location) {
+            let parts = window.location.href.split("/");
+            this.baseUrl = parts[0] + "//" + parts[2];
+            if (parts.length > 3) {
+                this.contextRoot = parts[3];
+            }
+        }
+        if (this._localStorageService.getItem("maxViewPermission")) {
+            this.maxViewPermission.next(this._localStorageService.getItem("maxViewPermission"));
+        }
+        if (_maxInactivity) {
+            this._maxInactivityMinutes = _maxInactivity;
+        }
+        if (_userCountdownSeconds) {
+            this.userCountdownSeconds = _userCountdownSeconds;
+        }
+        if (_idpInactivityMinutes) {
+            this.idpInactivityMinutes = _idpInactivityMinutes;
+        }
+        this.hasValidConfig();
+        //There could be a non-expired token in local storage.
+        let token = this.authenticationProvider.authToken;
+        this.storeToken(token);
+    }
+    getBaseUrl() {
+        return (this.baseUrl) ? this.baseUrl : "";
+    }
+    getContextRoot() {
+        return this.contextRoot;
+    }
+    getHeaders(req) {
+        let headers = req.headers;
+        //Don't set content type if already set
+        if (!req.headers.get(AuthenticationService.CONTENT_TYPE)) {
+            headers = headers.set(AuthenticationService.CONTENT_TYPE, this.contentType.toString());
+        }
+        if (headers.get(AuthenticationService.SEC_GOV_CLASS_HEADER) === "") {
+            headers = headers.delete(AuthenticationService.SEC_GOV_CLASS_HEADER);
+        }
+        else if (this.securityGovernorClass && !headers.get(AuthenticationService.SEC_GOV_CLASS_HEADER)) {
+            headers = headers.set(AuthenticationService.SEC_GOV_CLASS_HEADER, this.securityGovernorClass);
+        }
+        if (headers.get(AuthenticationService.SEC_GOV_ID_HEADER) === "") {
+            headers = headers.delete(AuthenticationService.SEC_GOV_ID_HEADER);
+        }
+        else if (this.securityGovernorId && !headers.get(AuthenticationService.SEC_GOV_ID_HEADER)) {
+            headers = headers.set(AuthenticationService.SEC_GOV_ID_HEADER, this.securityGovernorId.toString());
+        }
+        headers = headers.set(AuthenticationService.DEIDENT_HEADER, this.deidentifiedContext.toString());
+        headers = headers.set(AuthenticationService.LIMITED_HEADER, this.limitedContext.toString());
+        return headers;
+    }
+    get authenticationTokenKey() {
+        return this.authenticationProvider.authenticationTokenKey;
+    }
+    get authToken() {
+        return this.authenticationProvider.authToken;
+    }
+    updateUserActivity() {
+        if (this._isAuthenticatedSubject.value) {
+            this._lastUserInteraction = new Date();
+            this._userIsAboutToTimeOut.next(false);
+        }
+    }
+    /**
+     * A mutator for identifying the clients original request location. Setting this value will influence the end location
+     * navigated to by {@link #navigateToPath}.
+     *
+     * @param redirectUrl location of the users request before authentication
+     */
+    set redirectUrl(redirectUrl) {
+        this._redirectUrl = redirectUrl;
+    }
+    get redirectUrl() {
+        return this._redirectUrl;
+    }
+    requestAccessToken(redirectOnSuccess) {
+        this._http.get(this.tokenLocation(), { withCredentials: true })
+            .subscribe((response) => {
+            this.storeToken(response.auth_token);
+            if (redirectOnSuccess) {
+                this.proceedIfAuthenticated();
+            }
+        }, (error) => {
+            //Token refresh failed.
+            this.logout(true);
+        });
+    }
+    /**
+     * Verifies whether or not a current user session exists.
+     *
+     * @returns {Observable<boolean>} evaluates to true if the user is authenticated, false otherwise.
+     */
+    isAuthenticated() {
+        return this._isAuthenticatedSubject.asObservable();
+    }
+    isAboutToTimeOut() {
+        return this._userIsAboutToTimeOut.asObservable();
+    }
+    getTimeoutStart() {
+        if (this._lastUserInteraction) {
+            return this._lastUserInteraction.valueOf() + (((this._maxInactivityMinutes * 60) - this.userCountdownSeconds) * 1000);
+        }
+    }
+    tokenLocation() {
+        if (this._serverUrl) {
+            return this._serverUrl + this._tokenEndpoint;
+        }
+        else {
+            return this._tokenEndpoint;
+        }
+    }
+    directLoginLocation() {
+        if (this._serverUrl) {
+            return this._serverUrl + this._directEndpoint;
+        }
+        else {
+            return this._directEndpoint;
+        }
+    }
+    logoutLocation() {
+        if (this._serverUrl) {
+            return this._serverUrl + this._logoutPath;
+        }
+        else {
+            return this._logoutPath;
+        }
+    }
+    /**
+     * A function to authenticated the user with the provided credentials. Failure results in an error that describes the
+     * server response (status and status message) and should be actionable by the client application.
+     *
+     * @param username of the authenticating user to verify
+     * @param password of the authenticating user to verify
+     * @returns {Observable<R>} describing the result of the login action, true or an error
+     */
+    login(_username, _password) {
+        return this._http.post(this.directLoginLocation(), { username: _username, password: _password }, { observe: "response" }).pipe(map((resp) => {
+            if (resp.status === 201) {
+                return true;
+            }
+            else {
+                throw new Error("Authentication failed. " + resp.status + ": " + resp.statusText);
+            }
+        }), catchError(this.handleError));
+    }
+    clearLogin() {
+        //Front-end logout
+        try {
+            this._localStorageService.removeItem(this.authenticationProvider.authenticationTokenKey);
+            this.unsubscribeFromTokenRefresh();
+            this._isAuthenticatedSubject.next(false);
+            this._userIsAboutToTimeOut.next(false);
+        }
+        catch (Error) {
+        }
+        //Back-end logout
+        let headers = new HttpHeaders().set(AuthenticationService.CONTENT_TYPE, "text/plain");
+        return this._http.get(this.logoutLocation(), { headers: headers });
+    }
+    /**
+     * A function to signal the termination of the current session. Invoking this function will clean up any relevant state
+     * related to the last active session.
+     */
+    logout(keepCurrentRoute = false) {
+        //Prevent logout if already on authentication route. Doing otherwise screws up SAML
+        if (!this._router.routerState || this._router.routerState.snapshot.url !== this._authenticationRoute) {
+            this._redirectUrl = (keepCurrentRoute && this._router.routerState && this._router.routerState.snapshot) ? this._router.routerState.snapshot.url : "";
+            if (this._redirectUrl.startsWith("/")) {
+                this._redirectUrl = this._redirectUrl.substring(1);
+            }
+            this.clearLogin().subscribe((response) => {
+                window.location.replace(this._redirectUrl);
+            }, (error) => {
+                window.location.replace(this._redirectUrl);
+            });
+        }
+    }
+    storeToken(token) {
+        let valid = this.validateToken(token);
+        // unsubscribe from refesh before we decide wether to resubscribe
+        this.unsubscribeFromTokenRefresh();
+        if (valid) {
+            this._localStorageService.setItem(this.authenticationProvider.authenticationTokenKey, token);
+            this.subscribeToTokenRefresh(token);
+            //Change the BehaviorSubject if the user was not previously authenticated.
+            //Since other code may be subscribing to this observable, we don't want to cause new events to fire if just refreshing the JWT.
+            if (!this._isAuthenticatedSubject.value) {
+                this._isAuthenticatedSubject.next(true);
+            }
+        }
+        else {
+            this._localStorageService.removeItem(this.authenticationProvider.authenticationTokenKey);
+            this._isAuthenticatedSubject.next(false);
+        }
+    }
+    proceedIfAuthenticated() {
+        if (isDevMode()) {
+            console.debug("AuthenticationService.proceedIfAuthenticated: " + this._redirectUrl);
+        }
+        if (this._isAuthenticatedSubject.value) {
+            //Login counts as user activity, too
+            this.updateUserActivity();
+            if (this._redirectUrl && this._redirectUrl && this._redirectUrl !== "") {
+                this._router.navigateByUrl(this._redirectUrl);
+            }
+            else {
+                this._router.navigate([""]);
+            }
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    validateToken(token) {
+        return (token && !this._jwtHelper.isTokenExpired(token));
+    }
+    subscribeToTokenRefresh(token) {
+        let exp = this._jwtHelper.getTokenExpirationDate(token);
+        // Use a timer to periodically check timeouts
+        this._refreshSubscription = interval(1000)
+            .subscribe(() => {
+            // If a tab is inactive we can't know if our timer is accurate
+            // so when the interval hits check against timestamps
+            if (this._isAuthenticatedSubject.value && Date.now() > this.getTimeoutStart()) {
+                //Don't update the subject more than once! Doing so initializes more than one countdown timer!
+                if (this._userIsAboutToTimeOut.getValue() !== true) {
+                    this._userIsAboutToTimeOut.next(true);
+                }
+            }
+            // check for refresh token
+            let msToExpiry = (exp.valueOf() - new Date().valueOf());
+            // Refresh 60 seconds before expiry
+            if (msToExpiry <= 60000) {
+                this.refreshTokenIfUserIsActive();
+            }
+        });
+    }
+    unsubscribeFromTokenRefresh() {
+        if (this._refreshSubscription && !this._refreshSubscription.closed) {
+            this._refreshSubscription.unsubscribe();
+        }
+    }
+    getMaxViewPermission() {
+        return this.maxViewPermission.getValue();
+    }
+    getMaxViewPermissionSubject() {
+        return this.maxViewPermission;
+    }
+    setMaxViewPermission(maxViewPermission) {
+        this._localStorageService.setItem("maxViewPermission", maxViewPermission);
+        this.maxViewPermission.next(maxViewPermission);
+    }
+    refreshTokenIfUserIsActive() {
+        //Only refresh if the user has been active
+        if (this._lastUserInteraction && ((new Date().valueOf() - this._lastUserInteraction.valueOf()) <= (this._maxInactivityMinutes * 60 * 1000))) {
+            this.requestAccessToken(false);
+        }
+    }
+    hasValidConfig() {
+        if (this._tokenEndpoint == null && (this._serverUrl === null || this._logoutPath === null)) {
+            throw new Error("BUG ALERT! Invalid AuthenticationService configuration. No valid configuration for authentication endpoint(s).");
+        }
+        if (this._localStorageService === null || this.authenticationProvider.authenticationTokenKey === null) {
+            throw new Error("BUG ALERT! Invalid AuthenticationService configuration. No valid configuration for local storage");
+        }
+    }
+    handleError(error) {
+        let errMsg = (error.message) ? error.message : AuthenticationService.GENERIC_ERR_MSG;
+        return throwError(errMsg);
+    }
+}
+/**
+ * The generic error message used when a server error is thrown without a status.
+ *
+ * @type {string}
+ */
+AuthenticationService.GENERIC_ERR_MSG = "Server error";
+AuthenticationService.CONTENT_TYPE = "Content-Type";
+AuthenticationService.SEC_GOV_CLASS_HEADER = "SecurityGovernorClass";
+AuthenticationService.SEC_GOV_ID_HEADER = "SecurityGovernorId";
+AuthenticationService.DEIDENT_HEADER = "DeidentifiedContext";
+AuthenticationService.LIMITED_HEADER = "LimitedContext";
+AuthenticationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AuthenticationService, deps: [{ token: i1.HttpClient }, { token: i2.Router }, { token: i3.CoolLocalStorage }, { token: i4.JwtHelperService }, { token: i5.AuthenticationProvider }, { token: AUTHENTICATION_ROUTE }, { token: AUTHENTICATION_LOGOUT_PATH }, { token: AUTHENTICATION_TOKEN_ENDPOINT }, { token: AUTHENTICATION_SERVER_URL, optional: true }, { token: AUTHENTICATION_DIRECT_ENDPOINT, optional: true }, { token: AUTHENTICATION_MAX_INACTIVITY_MINUTES, optional: true }, { token: AUTHENTICATION_USER_COUNTDOWN_SECONDS, optional: true }, { token: AUTHENTICATION_IDP_INACTIVITY_MINUTES, optional: true }, { token: LocationStrategy, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthenticationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AuthenticationService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AuthenticationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.Router }, { type: i3.CoolLocalStorage }, { type: i4.JwtHelperService }, { type: i5.AuthenticationProvider }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [AUTHENTICATION_ROUTE]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [AUTHENTICATION_LOGOUT_PATH]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [AUTHENTICATION_TOKEN_ENDPOINT]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [AUTHENTICATION_SERVER_URL]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [AUTHENTICATION_DIRECT_ENDPOINT]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [AUTHENTICATION_MAX_INACTIVITY_MINUTES]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [AUTHENTICATION_USER_COUNTDOWN_SECONDS]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [AUTHENTICATION_IDP_INACTIVITY_MINUTES]
+                }] }, { type: i6.LocationStrategy, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [LocationStrategy]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authentication.service.js","sourceRoot":"","sources":["../../../projects/authentication/src/authentication.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\r\n * Copyright (c) 2016 Huntsman Cancer Institute at the University of Utah, Confidential and Proprietary\r\n */\r\nimport {Injectable, InjectionToken, Inject, Optional, isDevMode} from \"@angular/core\";\r\nimport {LocationStrategy} from \"@angular/common\";\r\nimport {Router} from \"@angular/router\";\r\nimport {HttpClient, HttpHeaders, HttpRequest, HttpResponse} from \"@angular/common/http\";\r\n\r\nimport {interval, Observable, BehaviorSubject, Subscription, throwError, of} from \"rxjs\";\r\nimport {catchError, first, map} from \"rxjs/operators\";\r\nimport {JwtHelperService} from \"@auth0/angular-jwt\";\r\n\r\nimport {AuthenticationProvider} from \"./authentication.provider\";\r\nimport { CoolLocalStorage } from \"@angular-cool/storage\";\r\n\r\n/**\r\n * The token used for injection of the server side endpoint for the currently authenticated subject.\r\n *\r\n * @type {InjectionToken}\r\n */\r\nexport let AUTHENTICATION_SERVER_URL = new InjectionToken<string>(\"authentication_server_rest_api\");\r\nexport let AUTHENTICATION_LOGOUT_PATH = new InjectionToken<string>(\"authentication_logout_path\");\r\nexport let AUTHENTICATION_DIRECT_ENDPOINT = new InjectionToken<string>(\"authentication_direct_endpoint\");\r\nexport let AUTHENTICATION_TOKEN_ENDPOINT = new InjectionToken<string>(\"authentication_token_endpoint\");\r\nexport let AUTHENTICATION_ROUTE = new InjectionToken<string>(\"authentication_route\");\r\nexport let AUTHENTICATION_MAX_INACTIVITY_MINUTES = new InjectionToken<number>(\"authentication_max_inactivity\");\r\nexport let AUTHENTICATION_USER_COUNTDOWN_SECONDS = new InjectionToken<number>(\"authentication_user_countdown_seconds\");\r\nexport let AUTHENTICATION_IDP_INACTIVITY_MINUTES = new InjectionToken<number>(\"authentication_idp_inactivity_minutes\");\r\n\r\n/**\r\n * @since 1.0.0\r\n */\r\n@Injectable()\r\nexport class AuthenticationService {\r\n\r\n  /**\r\n   * The generic error message used when a server error is thrown without a status.\r\n   *\r\n   * @type {string}\r\n   */\r\n  public static GENERIC_ERR_MSG: string = \"Server error\";\r\n\r\n  private static CONTENT_TYPE: string = \"Content-Type\";\r\n  private static SEC_GOV_CLASS_HEADER: string = \"SecurityGovernorClass\";\r\n  private static SEC_GOV_ID_HEADER: string = \"SecurityGovernorId\";\r\n  private static DEIDENT_HEADER: string = \"DeidentifiedContext\";\r\n  private static LIMITED_HEADER: string = \"LimitedContext\";\r\n\r\n  public userCountdownSeconds: number = 60;\r\n  public idpInactivityMinutes: number = 5;\r\n\r\n  public contentType: string = \"application/json\";\r\n  public securityGovernorClass: string;\r\n  public securityGovernorId: number;\r\n  public limitedContext: boolean = false;\r\n  public deidentifiedContext: boolean = false;\r\n\r\n  private maxViewPermission: BehaviorSubject<\"view\" | \"viewident\" | \"viewlimited\"> = new BehaviorSubject<\"view\" | \"viewident\" | \"viewlimited\">(\"viewident\");\r\n  private _isAuthenticatedSubject: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);\r\n  private _userIsAboutToTimeOut: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);\r\n  private _redirectUrl: string;\r\n  private _refreshSubscription: Subscription;\r\n  private _lastUserInteraction: Date;\r\n  private _maxInactivityMinutes: number = 120;\r\n\r\n  private baseUrl: string;\r\n  private contextRoot: string = \"\";\r\n\r\n  constructor(private _http: HttpClient,\r\n              private _router: Router,\r\n              private _localStorageService: CoolLocalStorage,\r\n              private _jwtHelper: JwtHelperService,\r\n              private authenticationProvider: AuthenticationProvider,\r\n              @Inject(AUTHENTICATION_ROUTE) private _authenticationRoute: string,\r\n              @Inject(AUTHENTICATION_LOGOUT_PATH) private _logoutPath: string,\r\n              @Inject(AUTHENTICATION_TOKEN_ENDPOINT) private _tokenEndpoint: string,\r\n              @Optional() @Inject(AUTHENTICATION_SERVER_URL) private _serverUrl: string,\r\n              @Optional() @Inject(AUTHENTICATION_DIRECT_ENDPOINT) private _directEndpoint: string,\r\n              @Optional() @Inject(AUTHENTICATION_MAX_INACTIVITY_MINUTES) private _maxInactivity: number,\r\n              @Optional() @Inject(AUTHENTICATION_USER_COUNTDOWN_SECONDS) private _userCountdownSeconds: number,\r\n              @Optional() @Inject(AUTHENTICATION_IDP_INACTIVITY_MINUTES) private _idpInactivityMinutes: number,\r\n              @Optional() @Inject(LocationStrategy) private locationStrategy: LocationStrategy) {\r\n    if (isDevMode()) {\r\n      console.debug(\"window.location.href: \" + window.location.href);\r\n    }\r\n\r\n    if (window.location) {\r\n      let parts: string[] = window.location.href.split(\"/\");\r\n      this.baseUrl = parts[0] + \"//\" + parts[2];\r\n      if (parts.length > 3) {\r\n        this.contextRoot = parts[3];\r\n      }\r\n    }\r\n\r\n    if (this._localStorageService.getItem(\"maxViewPermission\")) {\r\n      this.maxViewPermission.next(<\"view\" | \"viewident\" | \"viewlimited\">this._localStorageService.getItem(\"maxViewPermission\"));\r\n    }\r\n\r\n    if (_maxInactivity) {\r\n      this._maxInactivityMinutes = _maxInactivity;\r\n    }\r\n\r\n    if (_userCountdownSeconds) {\r\n      this.userCountdownSeconds = _userCountdownSeconds;\r\n    }\r\n\r\n    if (_idpInactivityMinutes) {\r\n      this.idpInactivityMinutes = _idpInactivityMinutes;\r\n    }\r\n\r\n    this.hasValidConfig();\r\n\r\n    //There could be a non-expired token in local storage.\r\n    let token: string = this.authenticationProvider.authToken;\r\n    this.storeToken(token);\r\n  }\r\n\r\n  getBaseUrl(): string {\r\n    return (this.baseUrl) ? this.baseUrl : \"\";\r\n  }\r\n\r\n  getContextRoot(): string {\r\n    return this.contextRoot;\r\n  }\r\n\r\n  getHeaders(req: HttpRequest<any>): HttpHeaders {\r\n    let headers: HttpHeaders = req.headers;\r\n\r\n    //Don't set content type if already set\r\n    if (!req.headers.get(AuthenticationService.CONTENT_TYPE)) {\r\n      headers = headers.set(AuthenticationService.CONTENT_TYPE, this.contentType.toString());\r\n    }\r\n\r\n    if (headers.get(AuthenticationService.SEC_GOV_CLASS_HEADER) === \"\") {\r\n      headers = headers.delete(AuthenticationService.SEC_GOV_CLASS_HEADER);\r\n    } else if (this.securityGovernorClass && !headers.get(AuthenticationService.SEC_GOV_CLASS_HEADER)) {\r\n      headers = headers.set(AuthenticationService.SEC_GOV_CLASS_HEADER, this.securityGovernorClass);\r\n    }\r\n\r\n    if (headers.get(AuthenticationService.SEC_GOV_ID_HEADER) === \"\") {\r\n      headers = headers.delete(AuthenticationService.SEC_GOV_ID_HEADER);\r\n    } else if (this.securityGovernorId && !headers.get(AuthenticationService.SEC_GOV_ID_HEADER)) {\r\n      headers = headers.set(AuthenticationService.SEC_GOV_ID_HEADER, this.securityGovernorId.toString());\r\n    }\r\n\r\n    headers = headers.set(AuthenticationService.DEIDENT_HEADER, this.deidentifiedContext.toString());\r\n    headers = headers.set(AuthenticationService.LIMITED_HEADER, this.limitedContext.toString());\r\n\r\n    return headers;\r\n  }\r\n\r\n  get authenticationTokenKey(): string {\r\n    return this.authenticationProvider.authenticationTokenKey;\r\n  }\r\n\r\n  get authToken(): string {\r\n    return this.authenticationProvider.authToken;\r\n  }\r\n\r\n  public updateUserActivity(): void {\r\n    if (this._isAuthenticatedSubject.value) {\r\n      this._lastUserInteraction = new Date();\r\n      this._userIsAboutToTimeOut.next(false);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * A mutator for identifying the clients original request location. Setting this value will influence the end location\r\n   * navigated to by {@link #navigateToPath}.\r\n   *\r\n   * @param redirectUrl location of the users request before authentication\r\n   */\r\n  set redirectUrl(redirectUrl: string) {\r\n    this._redirectUrl = redirectUrl;\r\n  }\r\n\r\n  get redirectUrl() {\r\n    return this._redirectUrl;\r\n  }\r\n\r\n  requestAccessToken(redirectOnSuccess: boolean): void {\r\n\r\n    this._http.get(this.tokenLocation(), {withCredentials: true})\r\n      .subscribe(\r\n        (response: any) => {\r\n          this.storeToken(response.auth_token);\r\n          if (redirectOnSuccess) {\r\n            this.proceedIfAuthenticated();\r\n          }\r\n        },\r\n        (error) => {\r\n          //Token refresh failed.\r\n          this.logout(true);\r\n        }\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Verifies whether or not a current user session exists.\r\n   *\r\n   * @returns {Observable<boolean>} evaluates to true if the user is authenticated, false otherwise.\r\n   */\r\n  isAuthenticated(): Observable<boolean> {\r\n    return this._isAuthenticatedSubject.asObservable();\r\n  }\r\n\r\n  isAboutToTimeOut(): Observable<boolean> {\r\n    return this._userIsAboutToTimeOut.asObservable();\r\n  }\r\n\r\n  getTimeoutStart(): number {\r\n    if (this._lastUserInteraction) {\r\n      return this._lastUserInteraction.valueOf() + (((this._maxInactivityMinutes * 60) - this.userCountdownSeconds) * 1000);\r\n    }\r\n  }\r\n\r\n  tokenLocation(): string {\r\n    if (this._serverUrl) {\r\n      return this._serverUrl + this._tokenEndpoint;\r\n    } else {\r\n      return this._tokenEndpoint;\r\n    }\r\n  }\r\n\r\n  directLoginLocation(): string {\r\n    if (this._serverUrl) {\r\n      return this._serverUrl + this._directEndpoint;\r\n    } else {\r\n      return this._directEndpoint;\r\n    }\r\n  }\r\n\r\n  logoutLocation(): string {\r\n    if (this._serverUrl) {\r\n      return this._serverUrl + this._logoutPath;\r\n    } else {\r\n      return this._logoutPath;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * A function to authenticated the user with the provided credentials. Failure results in an error that describes the\r\n   * server response (status and status message) and should be actionable by the client application.\r\n   *\r\n   * @param username of the authenticating user to verify\r\n   * @param password of the authenticating user to verify\r\n   * @returns {Observable<R>} describing the result of the login action, true or an error\r\n   */\r\n  login(_username: string, _password: string): Observable<boolean> {\r\n    return this._http.post(\r\n      this.directLoginLocation(),\r\n      {username: _username, password: _password},\r\n      {observe: \"response\"}\r\n    ).pipe(map((resp: HttpResponse<any>) => {\r\n      if (resp.status === 201) {\r\n        return true;\r\n      } else {\r\n        throw new Error(\"Authentication failed. \" + resp.status + \": \" + resp.statusText);\r\n      }\r\n    }),\r\n      catchError(this.handleError));\r\n  }\r\n\r\n\r\n  clearLogin(): Observable<Response> {\r\n    //Front-end logout\r\n    try {\r\n      this._localStorageService.removeItem(this.authenticationProvider.authenticationTokenKey);\r\n      this.unsubscribeFromTokenRefresh();\r\n      this._isAuthenticatedSubject.next(false);\r\n      this._userIsAboutToTimeOut.next(false);\r\n    } catch (Error) {\r\n    }\r\n\r\n    //Back-end logout\r\n    let headers = new HttpHeaders().set(AuthenticationService.CONTENT_TYPE, \"text/plain\");\r\n    return <Observable<Response>>this._http.get(this.logoutLocation(), {headers: headers});\r\n  }\r\n\r\n  /**\r\n   * A function to signal the termination of the current session. Invoking this function will clean up any relevant state\r\n   * related to the last active session.\r\n   */\r\n  logout(keepCurrentRoute: boolean = false): void {\r\n    //Prevent logout if already on authentication route. Doing otherwise screws up SAML\r\n    if (! this._router.routerState || this._router.routerState.snapshot.url !== this._authenticationRoute) {\r\n      this._redirectUrl = (keepCurrentRoute && this._router.routerState && this._router.routerState.snapshot) ? this._router.routerState.snapshot.url : \"\";\r\n\r\n      if (this._redirectUrl.startsWith(\"/\")) {\r\n        this._redirectUrl = this._redirectUrl.substring(1);\r\n      }\r\n\r\n      this.clearLogin().subscribe(\r\n        (response) => {\r\n          window.location.replace(this._redirectUrl);\r\n          },\r\n        (error) => {\r\n          window.location.replace(this._redirectUrl);\r\n        }\r\n      );\r\n    }\r\n  }\r\n\r\n  storeToken(token: string): void {\r\n    let valid = this.validateToken(token);\r\n\r\n    // unsubscribe from refesh before we decide wether to resubscribe\r\n    this.unsubscribeFromTokenRefresh();\r\n\r\n    if (valid) {\r\n      this._localStorageService.setItem(this.authenticationProvider.authenticationTokenKey, token);\r\n      this.subscribeToTokenRefresh(token);\r\n\r\n      //Change the BehaviorSubject if the user was not previously authenticated.\r\n      //Since other code may be subscribing to this observable, we don't want to cause new events to fire if just refreshing the JWT.\r\n      if (! this._isAuthenticatedSubject.value) {\r\n        this._isAuthenticatedSubject.next(true);\r\n      }\r\n    } else {\r\n      this._localStorageService.removeItem(this.authenticationProvider.authenticationTokenKey);\r\n      this._isAuthenticatedSubject.next(false);\r\n    }\r\n  }\r\n\r\n  proceedIfAuthenticated(): boolean {\r\n    if (isDevMode()) {\r\n      console.debug(\"AuthenticationService.proceedIfAuthenticated: \" + this._redirectUrl);\r\n    }\r\n\r\n    if (this._isAuthenticatedSubject.value) {\r\n      //Login counts as user activity, too\r\n      this.updateUserActivity();\r\n\r\n      if (this._redirectUrl && this._redirectUrl && this._redirectUrl !== \"\") {\r\n        this._router.navigateByUrl(this._redirectUrl);\r\n      } else {\r\n        this._router.navigate([\"\"]);\r\n      }\r\n\r\n      return true;\r\n    } else {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  validateToken(token: string): boolean {\r\n    return (token && !this._jwtHelper.isTokenExpired(token));\r\n  }\r\n\r\n  subscribeToTokenRefresh(token: any): void {\r\n    let exp = this._jwtHelper.getTokenExpirationDate(token);\r\n\r\n    // Use a timer to periodically check timeouts\r\n    this._refreshSubscription = interval(1000)\r\n      .subscribe(() => {\r\n\r\n        // If a tab is inactive we can't know if our timer is accurate\r\n        // so when the interval hits check against timestamps\r\n        if (this._isAuthenticatedSubject.value && Date.now() > this.getTimeoutStart()) {\r\n          //Don't update the subject more than once! Doing so initializes more than one countdown timer!\r\n          if (this._userIsAboutToTimeOut.getValue() !== true) {\r\n            this._userIsAboutToTimeOut.next(true);\r\n          }\r\n        }\r\n\r\n        // check for refresh token\r\n        let msToExpiry = (exp.valueOf() - new Date().valueOf());\r\n\r\n        // Refresh 60 seconds before expiry\r\n        if (msToExpiry <= 60000) {\r\n          this.refreshTokenIfUserIsActive();\r\n        }\r\n      });\r\n  }\r\n\r\n  unsubscribeFromTokenRefresh(): void {\r\n    if (this._refreshSubscription && ! this._refreshSubscription.closed) {\r\n      this._refreshSubscription.unsubscribe();\r\n    }\r\n  }\r\n\r\n  getMaxViewPermission(): \"view\" | \"viewident\" | \"viewlimited\" {\r\n    return this.maxViewPermission.getValue();\r\n  }\r\n\r\n  getMaxViewPermissionSubject(): BehaviorSubject<\"view\" | \"viewident\" | \"viewlimited\"> {\r\n    return this.maxViewPermission;\r\n  }\r\n\r\n  setMaxViewPermission(maxViewPermission: \"view\" | \"viewident\" | \"viewlimited\"): void {\r\n    this._localStorageService.setItem(\"maxViewPermission\", maxViewPermission);\r\n    this.maxViewPermission.next(maxViewPermission);\r\n  }\r\n\r\n  private refreshTokenIfUserIsActive(): void {\r\n    //Only refresh if the user has been active\r\n    if (this._lastUserInteraction && ((new Date().valueOf() - this._lastUserInteraction.valueOf()) <= (this._maxInactivityMinutes * 60 * 1000))) {\r\n      this.requestAccessToken(false);\r\n    }\r\n  }\r\n\r\n  private hasValidConfig(): void {\r\n    if (this._tokenEndpoint == null && (this._serverUrl === null || this._logoutPath === null)) {\r\n      throw new Error(\"BUG ALERT! Invalid AuthenticationService configuration. No valid configuration for authentication endpoint(s).\");\r\n    }\r\n    if (this._localStorageService === null || this.authenticationProvider.authenticationTokenKey === null) {\r\n      throw new Error(\"BUG ALERT! Invalid AuthenticationService configuration. No valid configuration for local storage\");\r\n    }\r\n  }\r\n\r\n  private handleError(error: any) : Observable<never> {\r\n    let errMsg = (error.message) ? error.message : AuthenticationService.GENERIC_ERR_MSG;\r\n    return throwError(errMsg);\r\n  }\r\n}\r\n"]}

package/esm2020/authorization.interceptor.mjs

@@ -0,0 +1,79 @@
+import { Injectable, Injector, isDevMode } from "@angular/core";
+import { throwError } from "rxjs";
+import { catchError } from "rxjs/operators";
+import { AuthenticationService } from "./authentication.service";
+import * as i0 from "@angular/core";
+export class AuthorizationInterceptor {
+    constructor(injector) {
+        this.injector = injector;
+    }
+    intercept(req, next) {
+        if (isDevMode()) {
+            console.debug("AuthorizationInterceptor.intercept");
+        }
+        let authService = this.injector.get(AuthenticationService);
+        //Don't want to include background token refreshes in considering the user 'active'
+        if (req.url !== authService.tokenLocation()) {
+            //Update user activity. Done here instead of the previous method using a subscription to a subject in AuthenticationProvider
+            authService.updateUserActivity();
+        }
+        let headers = authService.getHeaders(req);
+        let url = req.url;
+        if (url.startsWith("/")) {
+            url = authService.getBaseUrl() + url;
+        }
+        else if (!url.startsWith("http")) {
+            if (authService.getContextRoot().length > 0) {
+                url = authService.getBaseUrl() + "/" + authService.getContextRoot() + "/" + url;
+            }
+            else {
+                url = authService.getBaseUrl() + "/" + url;
+            }
+        }
+        let params = req.params;
+        if (url.indexOf("/crud/") > 0) {
+            params = params.set("maxViewPermission", authService.getMaxViewPermission());
+        }
+        let reqClone = req.clone({
+            url: url,
+            withCredentials: true,
+            headers: headers,
+            params: params
+        });
+        return next.handle(reqClone)
+            .pipe(catchError((error) => {
+            if (isDevMode()) {
+                console.error("AuthorizationInterceptor.error");
+                console.error(error);
+            }
+            /**
+             * If the token is not authenticated which angular does not know about, then a REST request to the backend will
+             * return a 401.  To duplicate this, open Core in two tabs.  In one tab, logout, in the other, perform a request
+             * that hits a protected resource.
+             */
+            if (error.status === 401) {
+                authService.isAuthenticated().subscribe((authenticated) => {
+                    if (authenticated) {
+                        // If authenticated, then logout which will redirect.
+                        authService.logout(true);
+                        return throwError(error.message);
+                    }
+                    else {
+                        // Otherwise, for example, when the user first opens Core, 401s are expected.
+                        return throwError(error);
+                    }
+                });
+            }
+            if (error.status === 403) {
+                // TODO: Trigger notification for unauthorized.
+            }
+            return throwError(error);
+        }));
+    }
+}
+AuthorizationInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AuthorizationInterceptor, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthorizationInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AuthorizationInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AuthorizationInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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