@huntsman-cancer-institute/authentication 16.0.1 → 17.0.1

package/fesm2022/huntsman-cancer-institute-authentication.mjs

@@ -17,502 +17,502 @@ import { map, catchError, first, takeWhile } from 'rxjs/operators';
 import * as i2$1 from '@angular/platform-browser';
 import { trigger, state, style, transition, animate } from '@angular/animations';
 
-let AUTHENTICATION_TOKEN_KEY = new InjectionToken("authentication_token_key");
-class AuthenticationProvider {
-    constructor(_localStorageService, _authenticationTokenKey) {
-        this._localStorageService = _localStorageService;
-        this._authenticationTokenKey = _authenticationTokenKey;
-        this.whitelistedDomains = [
-            "localhost",
-            new RegExp(".*[.]utah[.]edu")
-        ];
-        this.tokenGetter = () => {
-            return this.authToken;
-        };
-    }
-    get authenticationTokenKey() {
-        return this._authenticationTokenKey;
-    }
-    set authenticationTokenKey(_authenticationTokenKey) {
-        this._authenticationTokenKey = _authenticationTokenKey;
-    }
-    get authToken() {
-        return this._localStorageService.getItem(this._authenticationTokenKey);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthenticationProvider, deps: [{ token: i1.CoolLocalStorage }, { token: AUTHENTICATION_TOKEN_KEY }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthenticationProvider }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthenticationProvider, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: i1.CoolLocalStorage }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [AUTHENTICATION_TOKEN_KEY]
-                }] }]; } });
+let AUTHENTICATION_TOKEN_KEY = new InjectionToken("authentication_token_key");
+class AuthenticationProvider {
+    constructor(_localStorageService, _authenticationTokenKey) {
+        this._localStorageService = _localStorageService;
+        this._authenticationTokenKey = _authenticationTokenKey;
+        this.whitelistedDomains = [
+            "localhost",
+            new RegExp(".*[.]utah[.]edu")
+        ];
+        this.tokenGetter = () => {
+            return this.authToken;
+        };
+    }
+    get authenticationTokenKey() {
+        return this._authenticationTokenKey;
+    }
+    set authenticationTokenKey(_authenticationTokenKey) {
+        this._authenticationTokenKey = _authenticationTokenKey;
+    }
+    get authToken() {
+        return this._localStorageService.getItem(this._authenticationTokenKey);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AuthenticationProvider, deps: [{ token: i1.CoolLocalStorage }, { token: AUTHENTICATION_TOKEN_KEY }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AuthenticationProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AuthenticationProvider, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.CoolLocalStorage }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [AUTHENTICATION_TOKEN_KEY]
+                }] }] });
 
-/*
- * Copyright (c) 2016 Huntsman Cancer Institute at the University of Utah, Confidential and Proprietary
- */
-/**
- * The token used for injection of the server side endpoint for the currently authenticated subject.
- *
- * @type {InjectionToken}
- */
-let AUTHENTICATION_SERVER_URL = new InjectionToken("authentication_server_rest_api");
-let AUTHENTICATION_LOGOUT_PATH = new InjectionToken("authentication_logout_path");
-let AUTHENTICATION_DIRECT_ENDPOINT = new InjectionToken("authentication_direct_endpoint");
-let AUTHENTICATION_TOKEN_ENDPOINT = new InjectionToken("authentication_token_endpoint");
-let AUTHENTICATION_ROUTE = new InjectionToken("authentication_route");
-let AUTHENTICATION_MAX_INACTIVITY_MINUTES = new InjectionToken("authentication_max_inactivity");
-let AUTHENTICATION_USER_COUNTDOWN_SECONDS = new InjectionToken("authentication_user_countdown_seconds");
-let AUTHENTICATION_IDP_INACTIVITY_MINUTES = new InjectionToken("authentication_idp_inactivity_minutes");
-/**
- * @since 1.0.0
- */
-class AuthenticationService {
-    /**
-     * The generic error message used when a server error is thrown without a status.
-     *
-     * @type {string}
-     */
-    static { this.GENERIC_ERR_MSG = "Server error"; }
-    static { this.CONTENT_TYPE = "Content-Type"; }
-    static { this.SEC_GOV_CLASS_HEADER = "SecurityGovernorClass"; }
-    static { this.SEC_GOV_ID_HEADER = "SecurityGovernorId"; }
-    static { this.DEIDENT_HEADER = "DeidentifiedContext"; }
-    static { this.LIMITED_HEADER = "LimitedContext"; }
-    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);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthenticationService, deps: [{ token: i1$1.HttpClient }, { token: i2.Router }, { token: i1.CoolLocalStorage }, { token: i4.JwtHelperService }, { token: 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 }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthenticationService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthenticationService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: i1$1.HttpClient }, { type: i2.Router }, { type: i1.CoolLocalStorage }, { type: i4.JwtHelperService }, { type: 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: i4$1.LocationStrategy, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [LocationStrategy]
-                }] }]; } });
+/*
+ * Copyright (c) 2016 Huntsman Cancer Institute at the University of Utah, Confidential and Proprietary
+ */
+/**
+ * The token used for injection of the server side endpoint for the currently authenticated subject.
+ *
+ * @type {InjectionToken}
+ */
+let AUTHENTICATION_SERVER_URL = new InjectionToken("authentication_server_rest_api");
+let AUTHENTICATION_LOGOUT_PATH = new InjectionToken("authentication_logout_path");
+let AUTHENTICATION_DIRECT_ENDPOINT = new InjectionToken("authentication_direct_endpoint");
+let AUTHENTICATION_TOKEN_ENDPOINT = new InjectionToken("authentication_token_endpoint");
+let AUTHENTICATION_ROUTE = new InjectionToken("authentication_route");
+let AUTHENTICATION_MAX_INACTIVITY_MINUTES = new InjectionToken("authentication_max_inactivity");
+let AUTHENTICATION_USER_COUNTDOWN_SECONDS = new InjectionToken("authentication_user_countdown_seconds");
+let AUTHENTICATION_IDP_INACTIVITY_MINUTES = new InjectionToken("authentication_idp_inactivity_minutes");
+/**
+ * @since 1.0.0
+ */
+class AuthenticationService {
+    /**
+     * The generic error message used when a server error is thrown without a status.
+     *
+     * @type {string}
+     */
+    static { this.GENERIC_ERR_MSG = "Server error"; }
+    static { this.CONTENT_TYPE = "Content-Type"; }
+    static { this.SEC_GOV_CLASS_HEADER = "SecurityGovernorClass"; }
+    static { this.SEC_GOV_ID_HEADER = "SecurityGovernorId"; }
+    static { this.DEIDENT_HEADER = "DeidentifiedContext"; }
+    static { this.LIMITED_HEADER = "LimitedContext"; }
+    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);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AuthenticationService, deps: [{ token: i1$1.HttpClient }, { token: i2.Router }, { token: i1.CoolLocalStorage }, { token: i4.JwtHelperService }, { token: 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 }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AuthenticationService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AuthenticationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1$1.HttpClient }, { type: i2.Router }, { type: i1.CoolLocalStorage }, { type: i4.JwtHelperService }, { type: 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: i4$1.LocationStrategy, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [LocationStrategy]
+                }] }] });
 
-/*
- * Copyright (c) 2016 Huntsman Cancer Institute at the University of Utah, Confidential and Proprietary
- */
-class AuthenticationComponent {
-    constructor(authenticationService, domSanitizer, router, location, renderer, authenticationRoute) {
-        this.authenticationService = authenticationService;
-        this.domSanitizer = domSanitizer;
-        this.router = router;
-        this.location = location;
-        this.renderer = renderer;
-        this.authenticationRoute = authenticationRoute;
-    }
-    ngOnInit() {
-        /*
-         * Fix back bug
-         * Issue is that the browser will go back to the previous route. If it's guarded, the route guard will just load the login again
-         * Eventually the browser gets to the /authenticate route and going back from there loads the iframe history and Shibboleth displays
-         * an error relating to navigating back.
-         */
-        history.pushState(null, null, this.location.prepareExternalUrl(this.authenticationRoute));
-        this.popstateSubscription = this.location.subscribe((value) => {
-            //This is going to prevent back from working from the login component
-            history.go(1);
-        });
-        this.beginAuthenticationProcess();
-    }
-    handleChanges() {
-        if (!this.iframe.nativeElement.contentDocument) {
-            return;
-        }
-        try {
-            let element = this.iframe.nativeElement.contentDocument.body;
-            if (element.querySelector("pre")) {
-                element = element.querySelector("pre");
-            }
-            this._errorMsg = null;
-            var jsonText = element.innerText;
-            var json = JSON.parse(jsonText);
-            this.authenticationService.storeToken(json.auth_token);
-            var authenticated = this.authenticationService.proceedIfAuthenticated();
-            if (!authenticated) {
-                this.resetSubscription.unsubscribe();
-                this.beginAuthenticationProcess();
-            }
-        }
-        catch (error) {
-            if (this.iframe.nativeElement.contentDocument.title.toUpperCase() === "ERROR") {
-                if (this.iframe.nativeElement.contentDocument.body.innerHTML.toUpperCase() === "FORBIDDEN") {
-                    this._errorMsg = "You do not have permission to log into this application";
-                }
-                else {
-                    this._errorMsg = null;
-                }
-                //A bit of a workaround for a WildFly issue. Success on Pac4j authentication, but failure on DB load of user put things in a weird state. Just logout, and redo the login.
-                this.clearLoginAndRetry();
-            }
-        }
-        // After the iframe loads, make the background transparent so we use the implementation's background and not the sso background.
-        this.renderer.setStyle(this.iframe.nativeElement.contentDocument.body, "background-color", "transparent");
-    }
-    ngOnDestroy() {
-        this.resetSubscription.unsubscribe();
-        this.popstateSubscription.unsubscribe();
-    }
-    clearLoginAndRetry() {
-        this.resetSubscription.unsubscribe();
-        this.authenticationService.clearLogin().subscribe(() => { this.beginAuthenticationProcess(); }, (error) => { this.beginAuthenticationProcess(); });
-    }
-    beginAuthenticationProcess() {
-        var tokenEndpoint = this.authenticationService.tokenLocation();
-        if (tokenEndpoint !== "") {
-            this.url = this.domSanitizer.bypassSecurityTrustResourceUrl(tokenEndpoint);
-        }
-        /**
-         * If the user doesn't complete authentication before the IdP session times out, that will be a problem when they eventually
-         * attampt to log in. It is likely that users will do this often when they log out or are timed out in the evening, leave
-         * their browser open, then attempt to log back in in the morning. In order to work around this, this component will re-request
-         * the token prior to IdP timeout, which will reset the  process. This will happen 1 minute before idpInactivityMinutes
-         **/
-        this.resetSubscription = interval((this.authenticationService.idpInactivityMinutes - 1) * 60 * 1000)
-            .pipe(first())
-            .subscribe((value) => {
-            this.beginAuthenticationProcess();
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthenticationComponent, deps: [{ token: AuthenticationService }, { token: i2$1.DomSanitizer }, { token: i2.Router }, { token: i4$1.Location }, { token: i0.Renderer2 }, { token: AUTHENTICATION_ROUTE }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: AuthenticationComponent, selector: "authentication-iframe", host: { classAttribute: "outlet-row" }, viewQueries: [{ propertyName: "iframe", first: true, predicate: ["iframe"], descendants: true, static: true }], ngImport: i0, template: `
+/*
+ * Copyright (c) 2016 Huntsman Cancer Institute at the University of Utah, Confidential and Proprietary
+ */
+class AuthenticationComponent {
+    constructor(authenticationService, domSanitizer, router, location, renderer, authenticationRoute) {
+        this.authenticationService = authenticationService;
+        this.domSanitizer = domSanitizer;
+        this.router = router;
+        this.location = location;
+        this.renderer = renderer;
+        this.authenticationRoute = authenticationRoute;
+    }
+    ngOnInit() {
+        /*
+         * Fix back bug
+         * Issue is that the browser will go back to the previous route. If it's guarded, the route guard will just load the login again
+         * Eventually the browser gets to the /authenticate route and going back from there loads the iframe history and Shibboleth displays
+         * an error relating to navigating back.
+         */
+        history.pushState(null, null, this.location.prepareExternalUrl(this.authenticationRoute));
+        this.popstateSubscription = this.location.subscribe((value) => {
+            //This is going to prevent back from working from the login component
+            history.go(1);
+        });
+        this.beginAuthenticationProcess();
+    }
+    handleChanges() {
+        if (!this.iframe.nativeElement.contentDocument) {
+            return;
+        }
+        try {
+            let element = this.iframe.nativeElement.contentDocument.body;
+            if (element.querySelector("pre")) {
+                element = element.querySelector("pre");
+            }
+            this._errorMsg = null;
+            var jsonText = element.innerText;
+            var json = JSON.parse(jsonText);
+            this.authenticationService.storeToken(json.auth_token);
+            var authenticated = this.authenticationService.proceedIfAuthenticated();
+            if (!authenticated) {
+                this.resetSubscription.unsubscribe();
+                this.beginAuthenticationProcess();
+            }
+        }
+        catch (error) {
+            if (this.iframe.nativeElement.contentDocument.title.toUpperCase() === "ERROR") {
+                if (this.iframe.nativeElement.contentDocument.body.innerHTML.toUpperCase() === "FORBIDDEN") {
+                    this._errorMsg = "You do not have permission to log into this application";
+                }
+                else {
+                    this._errorMsg = null;
+                }
+                //A bit of a workaround for a WildFly issue. Success on Pac4j authentication, but failure on DB load of user put things in a weird state. Just logout, and redo the login.
+                this.clearLoginAndRetry();
+            }
+        }
+        // After the iframe loads, make the background transparent so we use the implementation's background and not the sso background.
+        this.renderer.setStyle(this.iframe.nativeElement.contentDocument.body, "background-color", "transparent");
+    }
+    ngOnDestroy() {
+        this.resetSubscription.unsubscribe();
+        this.popstateSubscription.unsubscribe();
+    }
+    clearLoginAndRetry() {
+        this.resetSubscription.unsubscribe();
+        this.authenticationService.clearLogin().subscribe(() => { this.beginAuthenticationProcess(); }, (error) => { this.beginAuthenticationProcess(); });
+    }
+    beginAuthenticationProcess() {
+        var tokenEndpoint = this.authenticationService.tokenLocation();
+        if (tokenEndpoint !== "") {
+            this.url = this.domSanitizer.bypassSecurityTrustResourceUrl(tokenEndpoint);
+        }
+        /**
+         * If the user doesn't complete authentication before the IdP session times out, that will be a problem when they eventually
+         * attampt to log in. It is likely that users will do this often when they log out or are timed out in the evening, leave
+         * their browser open, then attempt to log back in in the morning. In order to work around this, this component will re-request
+         * the token prior to IdP timeout, which will reset the  process. This will happen 1 minute before idpInactivityMinutes
+         **/
+        this.resetSubscription = interval((this.authenticationService.idpInactivityMinutes - 1) * 60 * 1000)
+            .pipe(first())
+            .subscribe((value) => {
+            this.beginAuthenticationProcess();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AuthenticationComponent, deps: [{ token: AuthenticationService }, { token: i2$1.DomSanitizer }, { token: i2.Router }, { token: i4$1.Location }, { token: i0.Renderer2 }, { token: AUTHENTICATION_ROUTE }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.1.2", type: AuthenticationComponent, selector: "authentication-iframe", host: { classAttribute: "outlet-row" }, viewQueries: [{ propertyName: "iframe", first: true, predicate: ["iframe"], descendants: true, static: true }], ngImport: i0, template: `
     <div class="container">
       <iframe #iframe class="frame" [src]="url" (load)="handleChanges()"></iframe>
       <div *ngIf="_errorMsg" class="alert-box">
@@ -522,10 +522,10 @@ class AuthenticationComponent {
         </div>
       </div>
     </div>
-    `, isInline: true, styles: [":host{background-color:#fff}.container{max-width:100%;margin-top:60px;padding-top:15px}.frame{width:100%;height:100%;border:0px}\n"], dependencies: [{ kind: "directive", type: i4$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthenticationComponent, decorators: [{
-            type: Component,
+    `, isInline: true, styles: [":host{background-color:#fff}.container{max-width:100%;margin-top:60px;padding-top:15px}.frame{width:100%;height:100%;border:0px}\n"], dependencies: [{ kind: "directive", type: i4$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AuthenticationComponent, decorators: [{
+            type: Component,
             args: [{ selector: "authentication-iframe", template: `
     <div class="container">
       <iframe #iframe class="frame" [src]="url" (load)="handleChanges()"></iframe>
@@ -536,48 +536,48 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
         </div>
       </div>
     </div>
-    `, host: { class: "outlet-row" }, styles: [":host{background-color:#fff}.container{max-width:100%;margin-top:60px;padding-top:15px}.frame{width:100%;height:100%;border:0px}\n"] }]
-        }], ctorParameters: function () { return [{ type: AuthenticationService }, { type: i2$1.DomSanitizer }, { type: i2.Router }, { type: i4$1.Location }, { type: i0.Renderer2 }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [AUTHENTICATION_ROUTE]
-                }] }]; }, propDecorators: { iframe: [{
-                type: ViewChild,
-                args: ["iframe", { static: true }]
+    `, host: { class: "outlet-row" }, styles: [":host{background-color:#fff}.container{max-width:100%;margin-top:60px;padding-top:15px}.frame{width:100%;height:100%;border:0px}\n"] }]
+        }], ctorParameters: () => [{ type: AuthenticationService }, { type: i2$1.DomSanitizer }, { type: i2.Router }, { type: i4$1.Location }, { type: i0.Renderer2 }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [AUTHENTICATION_ROUTE]
+                }] }], propDecorators: { iframe: [{
+                type: ViewChild,
+                args: ["iframe", { static: true }]
             }] } });
 
-/*
- * Copyright (c) 2016 Huntsman Cancer Institute at the University of Utah, Confidential and Proprietary
- */
-class DirectLoginComponent {
-    constructor(_authenticationService, _formBuilder) {
-        this._authenticationService = _authenticationService;
-        this._formBuilder = _formBuilder;
-    }
-    /**
-     * Initializes the authentication form.
-     */
-    ngOnInit() {
-        this._loginForm = this._formBuilder.group({
-            username: ["", Validators.required],
-            password: ["", Validators.required]
-        });
-    }
-    /**
-     * A function to submit the login form the the {@link UserService}.
-     */
-    login() {
-        this._authenticationService.login(this._loginForm.value.username, this._loginForm.value.password)
-            .subscribe((res) => {
-            if (res) {
-                this._errorMsg = null;
-                this._authenticationService.requestAccessToken(true);
-            }
-        }, (error) => {
-            this._errorMsg = "Please check your username and password.";
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DirectLoginComponent, deps: [{ token: AuthenticationService }, { token: i2$2.UntypedFormBuilder }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: DirectLoginComponent, selector: "hci-login-form", ngImport: i0, template: `
+/*
+ * Copyright (c) 2016 Huntsman Cancer Institute at the University of Utah, Confidential and Proprietary
+ */
+class DirectLoginComponent {
+    constructor(_authenticationService, _formBuilder) {
+        this._authenticationService = _authenticationService;
+        this._formBuilder = _formBuilder;
+    }
+    /**
+     * Initializes the authentication form.
+     */
+    ngOnInit() {
+        this._loginForm = this._formBuilder.group({
+            username: ["", Validators.required],
+            password: ["", Validators.required]
+        });
+    }
+    /**
+     * A function to submit the login form the the {@link UserService}.
+     */
+    login() {
+        this._authenticationService.login(this._loginForm.value.username, this._loginForm.value.password)
+            .subscribe((res) => {
+            if (res) {
+                this._errorMsg = null;
+                this._authenticationService.requestAccessToken(true);
+            }
+        }, (error) => {
+            this._errorMsg = "Please check your username and password.";
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: DirectLoginComponent, deps: [{ token: AuthenticationService }, { token: i2$2.UntypedFormBuilder }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.1.2", type: DirectLoginComponent, selector: "hci-login-form", ngImport: i0, template: `
     <div class="container">
       <div class="login-box" id="hci-login-form-box">
         <div class="login-heading" id="hci-login-form-heading">
@@ -602,10 +602,10 @@ class DirectLoginComponent {
         </div>
       </div>
     </div>
-    `, isInline: true, styles: [".container{max-width:400px;margin-top:20px;padding-top:15px}.login-box{border-radius:10px;box-shadow:0 0 2px #ccc;padding:15px}.login-box .login-heading h3{line-height:1.5;margin:0 0 10px}.login-box .form-control{padding:10px;border:1px solid #ccc}.login-box input[type=password]{margin-bottom:10px;border-top-left-radius:0;border-top-right-radius:0}.login-box input[type=text]{margin-bottom:-1px;border-bottom-right-radius:0;border-bottom-left-radius:0}.login-box .alert-box{margin:10px 0 -5px}.login-box .alert-text{font-size:small}.login-box .btn-box{margin:10px 0 0}\n"], dependencies: [{ kind: "directive", type: i4$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2$2.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i2$2.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i2$2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2$2.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i2$2.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i2$2.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DirectLoginComponent, decorators: [{
-            type: Component,
+    `, isInline: true, styles: [".container{max-width:400px;margin-top:20px;padding-top:15px}.login-box{border-radius:10px;box-shadow:0 0 2px #ccc;padding:15px}.login-box .login-heading h3{line-height:1.5;margin:0 0 10px}.login-box .form-control{padding:10px;border:1px solid #ccc}.login-box input[type=password]{margin-bottom:10px;border-top-left-radius:0;border-top-right-radius:0}.login-box input[type=text]{margin-bottom:-1px;border-bottom-right-radius:0;border-bottom-left-radius:0}.login-box .alert-box{margin:10px 0 -5px}.login-box .alert-text{font-size:small}.login-box .btn-box{margin:10px 0 0}\n"], dependencies: [{ kind: "directive", type: i4$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2$2.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i2$2.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i2$2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2$2.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i2$2.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i2$2.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: DirectLoginComponent, decorators: [{
+            type: Component,
             args: [{ selector: "hci-login-form", template: `
     <div class="container">
       <div class="login-box" id="hci-login-form-box">
@@ -631,51 +631,51 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
         </div>
       </div>
     </div>
-    `, styles: [".container{max-width:400px;margin-top:20px;padding-top:15px}.login-box{border-radius:10px;box-shadow:0 0 2px #ccc;padding:15px}.login-box .login-heading h3{line-height:1.5;margin:0 0 10px}.login-box .form-control{padding:10px;border:1px solid #ccc}.login-box input[type=password]{margin-bottom:10px;border-top-left-radius:0;border-top-right-radius:0}.login-box input[type=text]{margin-bottom:-1px;border-bottom-right-radius:0;border-bottom-left-radius:0}.login-box .alert-box{margin:10px 0 -5px}.login-box .alert-text{font-size:small}.login-box .btn-box{margin:10px 0 0}\n"] }]
-        }], ctorParameters: function () { return [{ type: AuthenticationService }, { type: i2$2.UntypedFormBuilder }]; } });
+    `, styles: [".container{max-width:400px;margin-top:20px;padding-top:15px}.login-box{border-radius:10px;box-shadow:0 0 2px #ccc;padding:15px}.login-box .login-heading h3{line-height:1.5;margin:0 0 10px}.login-box .form-control{padding:10px;border:1px solid #ccc}.login-box input[type=password]{margin-bottom:10px;border-top-left-radius:0;border-top-right-radius:0}.login-box input[type=text]{margin-bottom:-1px;border-bottom-right-radius:0;border-bottom-left-radius:0}.login-box .alert-box{margin:10px 0 -5px}.login-box .alert-text{font-size:small}.login-box .btn-box{margin:10px 0 0}\n"] }]
+        }], ctorParameters: () => [{ type: AuthenticationService }, { type: i2$2.UntypedFormBuilder }] });
 
-/*
- * Copyright (c) 2016 Huntsman Cancer Institute at the University of Utah, Confidential and Proprietary
- */
-class TimeoutNotificationComponent {
-    constructor(authenticationService) {
-        this.authenticationService = authenticationService;
-        this.openState = "hidden";
-        authenticationService.isAboutToTimeOut().subscribe((isAboutToTimeOut) => {
-            if (isAboutToTimeOut) {
-                this.openState = "opened";
-                this.startCountdown();
-            }
-            else {
-                this.openState = "hidden";
-                //If something changed mid-timeout, cancel the timeout/logout.
-                if (this.subscription != null && !this.subscription.closed) {
-                    this.subscription.unsubscribe();
-                }
-            }
-        });
-    }
-    startCountdown() {
-        this.seconds = timer(0, 1000)
-            .pipe(map(() => {
-            const elapsed = Math.round((Date.now() - this.authenticationService.getTimeoutStart()) / 1000);
-            return this.authenticationService.userCountdownSeconds - elapsed;
-        }), 
-        // The true argument emits the final value that completed the observable
-        takeWhile((value) => value > 0, true));
-        this.subscription = this.seconds.subscribe((value) => {
-            if (value < 1) {
-                this.subscription.unsubscribe();
-                this.authenticationService.logout(true);
-            }
-        });
-    }
-    click() {
-        this.subscription.unsubscribe();
-        this.authenticationService.updateUserActivity();
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TimeoutNotificationComponent, deps: [{ token: AuthenticationService }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: TimeoutNotificationComponent, selector: "timeout-notification", ngImport: i0, template: `
+/*
+ * Copyright (c) 2016 Huntsman Cancer Institute at the University of Utah, Confidential and Proprietary
+ */
+class TimeoutNotificationComponent {
+    constructor(authenticationService) {
+        this.authenticationService = authenticationService;
+        this.openState = "hidden";
+        authenticationService.isAboutToTimeOut().subscribe((isAboutToTimeOut) => {
+            if (isAboutToTimeOut) {
+                this.openState = "opened";
+                this.startCountdown();
+            }
+            else {
+                this.openState = "hidden";
+                //If something changed mid-timeout, cancel the timeout/logout.
+                if (this.subscription != null && !this.subscription.closed) {
+                    this.subscription.unsubscribe();
+                }
+            }
+        });
+    }
+    startCountdown() {
+        this.seconds = timer(0, 1000)
+            .pipe(map(() => {
+            const elapsed = Math.round((Date.now() - this.authenticationService.getTimeoutStart()) / 1000);
+            return this.authenticationService.userCountdownSeconds - elapsed;
+        }), 
+        // The true argument emits the final value that completed the observable
+        takeWhile((value) => value > 0, true));
+        this.subscription = this.seconds.subscribe((value) => {
+            if (value < 1) {
+                this.subscription.unsubscribe();
+                this.authenticationService.logout(true);
+            }
+        });
+    }
+    click() {
+        this.subscription.unsubscribe();
+        this.authenticationService.updateUserActivity();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: TimeoutNotificationComponent, deps: [{ token: AuthenticationService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.1.2", type: TimeoutNotificationComponent, selector: "timeout-notification", ngImport: i0, template: `
     <div class="flyout-max" [@openBacksplash]="openState">
       <div class="modal-dialog" [@openModal]="openState" role="document">
         <div class="modal-header">
@@ -691,40 +691,40 @@ class TimeoutNotificationComponent {
         </div>
       </div>
     </div>
-  `, isInline: true, styles: [".flyout-max{position:fixed;z-index:9999;top:0;bottom:0;background-color:#0006;width:100vw}.modal-dialog{position:fixed;max-width:50vw;min-width:50vw;left:-50vw;top:25vw;margin:0;background-color:#fff;border:black 1px solid;border-left:none;border-radius:20px;pointer-events:all}.modal-body{width:100%;display:inline-block}.modal-body-left{display:inline-block;overflow-y:auto;overflow-x:hidden;min-height:300px;max-height:300px}.modal-body-right{width:70%;vertical-align:top;padding-left:15px;border-left:black 1px solid;margin-left:15px;display:inline-block;overflow-y:auto;min-height:300px;max-height:300px}\n"], dependencies: [{ kind: "pipe", type: i4$1.AsyncPipe, name: "async" }], animations: [
-            trigger("openBacksplash", [
-                state("in", style({
-                    "display": "none"
-                })),
-                state("hidden", style({
-                    "display": "none"
-                })),
-                state("opened", style({
-                    "display": "inherit"
-                })),
-                transition("hidden => opened", animate(100)),
-                transition("opened => hidden", animate(200))
-            ]),
-            trigger("openModal", [
-                state("in", style({
-                    "opacity": "0",
-                    "left": "-50vw"
-                })),
-                state("hidden", style({
-                    "opacity": "0",
-                    "left": "-50vw"
-                })),
-                state("opened", style({
-                    "opacity": "1",
-                    "left": "25vw"
-                })),
-                transition("hidden => opened", animate(500)),
-                transition("opened => hidden", animate(300))
-            ])
-        ] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TimeoutNotificationComponent, decorators: [{
-            type: Component,
+  `, isInline: true, styles: [".flyout-max{position:fixed;z-index:9999;top:0;bottom:0;background-color:#0006;width:100vw}.modal-dialog{position:fixed;max-width:50vw;min-width:50vw;left:-50vw;top:25vw;margin:0;background-color:#fff;border:black 1px solid;border-left:none;border-radius:20px;pointer-events:all}.modal-body{width:100%;display:inline-block}.modal-body-left{display:inline-block;overflow-y:auto;overflow-x:hidden;min-height:300px;max-height:300px}.modal-body-right{width:70%;vertical-align:top;padding-left:15px;border-left:black 1px solid;margin-left:15px;display:inline-block;overflow-y:auto;min-height:300px;max-height:300px}\n"], dependencies: [{ kind: "pipe", type: i4$1.AsyncPipe, name: "async" }], animations: [
+            trigger("openBacksplash", [
+                state("in", style({
+                    "display": "none"
+                })),
+                state("hidden", style({
+                    "display": "none"
+                })),
+                state("opened", style({
+                    "display": "inherit"
+                })),
+                transition("hidden => opened", animate(100)),
+                transition("opened => hidden", animate(200))
+            ]),
+            trigger("openModal", [
+                state("in", style({
+                    "opacity": "0",
+                    "left": "-50vw"
+                })),
+                state("hidden", style({
+                    "opacity": "0",
+                    "left": "-50vw"
+                })),
+                state("opened", style({
+                    "opacity": "1",
+                    "left": "25vw"
+                })),
+                transition("hidden => opened", animate(500)),
+                transition("opened => hidden", animate(300))
+            ])
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: TimeoutNotificationComponent, decorators: [{
+            type: Component,
             args: [{ selector: "timeout-notification", template: `
     <div class="flyout-max" [@openBacksplash]="openState">
       <div class="modal-dialog" [@openModal]="openState" role="document">
@@ -741,222 +741,222 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
         </div>
       </div>
     </div>
-  `, animations: [
-                        trigger("openBacksplash", [
-                            state("in", style({
-                                "display": "none"
-                            })),
-                            state("hidden", style({
-                                "display": "none"
-                            })),
-                            state("opened", style({
-                                "display": "inherit"
-                            })),
-                            transition("hidden => opened", animate(100)),
-                            transition("opened => hidden", animate(200))
-                        ]),
-                        trigger("openModal", [
-                            state("in", style({
-                                "opacity": "0",
-                                "left": "-50vw"
-                            })),
-                            state("hidden", style({
-                                "opacity": "0",
-                                "left": "-50vw"
-                            })),
-                            state("opened", style({
-                                "opacity": "1",
-                                "left": "25vw"
-                            })),
-                            transition("hidden => opened", animate(500)),
-                            transition("opened => hidden", animate(300))
-                        ])
-                    ], styles: [".flyout-max{position:fixed;z-index:9999;top:0;bottom:0;background-color:#0006;width:100vw}.modal-dialog{position:fixed;max-width:50vw;min-width:50vw;left:-50vw;top:25vw;margin:0;background-color:#fff;border:black 1px solid;border-left:none;border-radius:20px;pointer-events:all}.modal-body{width:100%;display:inline-block}.modal-body-left{display:inline-block;overflow-y:auto;overflow-x:hidden;min-height:300px;max-height:300px}.modal-body-right{width:70%;vertical-align:top;padding-left:15px;border-left:black 1px solid;margin-left:15px;display:inline-block;overflow-y:auto;min-height:300px;max-height:300px}\n"] }]
-        }], ctorParameters: function () { return [{ type: AuthenticationService }]; } });
+  `, animations: [
+                        trigger("openBacksplash", [
+                            state("in", style({
+                                "display": "none"
+                            })),
+                            state("hidden", style({
+                                "display": "none"
+                            })),
+                            state("opened", style({
+                                "display": "inherit"
+                            })),
+                            transition("hidden => opened", animate(100)),
+                            transition("opened => hidden", animate(200))
+                        ]),
+                        trigger("openModal", [
+                            state("in", style({
+                                "opacity": "0",
+                                "left": "-50vw"
+                            })),
+                            state("hidden", style({
+                                "opacity": "0",
+                                "left": "-50vw"
+                            })),
+                            state("opened", style({
+                                "opacity": "1",
+                                "left": "25vw"
+                            })),
+                            transition("hidden => opened", animate(500)),
+                            transition("opened => hidden", animate(300))
+                        ])
+                    ], styles: [".flyout-max{position:fixed;z-index:9999;top:0;bottom:0;background-color:#0006;width:100vw}.modal-dialog{position:fixed;max-width:50vw;min-width:50vw;left:-50vw;top:25vw;margin:0;background-color:#fff;border:black 1px solid;border-left:none;border-radius:20px;pointer-events:all}.modal-body{width:100%;display:inline-block}.modal-body-left{display:inline-block;overflow-y:auto;overflow-x:hidden;min-height:300px;max-height:300px}.modal-body-right{width:70%;vertical-align:top;padding-left:15px;border-left:black 1px solid;margin-left:15px;display:inline-block;overflow-y:auto;min-height:300px;max-height:300px}\n"] }]
+        }], ctorParameters: () => [{ type: AuthenticationService }] });
 
-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);
-        }));
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthorizationInterceptor, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthorizationInterceptor }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthorizationInterceptor, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+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);
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AuthorizationInterceptor, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AuthorizationInterceptor }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AuthorizationInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i0.Injector }] });
 
-/*
- * Copyright (c) 2016 Huntsman Cancer Institute at the University of Utah, Confidential and Proprietary
- */
-/**
- * Provide a single auth service and interceptor for the implementing application.  Also provide everything
- * from the angular-jwt library.
- *
- * @since 1.0.0
- */
-class AuthenticationModule {
-    constructor(parentModule) {
-        if (parentModule) {
-            throw new Error("AuthenticationModule is already loaded.");
-        }
-    }
-    static forRoot() {
-        return {
-            providers: [
-                AuthenticationProvider,
-                JwtHelperService,
-                AuthenticationService,
-                {
-                    provide: HTTP_INTERCEPTORS,
-                    useClass: AuthorizationInterceptor,
-                    multi: true
-                },
-                {
-                    provide: HTTP_INTERCEPTORS,
-                    useClass: JwtInterceptor,
-                    multi: true
-                },
-                {
-                    provide: JWT_OPTIONS,
-                    useClass: AuthenticationProvider
-                }
-            ],
-            ngModule: AuthenticationModule
-        };
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthenticationModule, deps: [{ token: i4.JwtModule, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: AuthenticationModule, declarations: [AuthenticationComponent,
-            DirectLoginComponent,
-            TimeoutNotificationComponent], imports: [CommonModule,
-            HttpClientModule,
-            //JwtModule,
-            RouterModule,
-            FormsModule,
-            ReactiveFormsModule,
-            CoolStorageModule], exports: [AuthenticationComponent,
-            DirectLoginComponent,
-            TimeoutNotificationComponent] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthenticationModule, imports: [CommonModule,
-            HttpClientModule,
-            //JwtModule,
-            RouterModule,
-            FormsModule,
-            ReactiveFormsModule,
-            CoolStorageModule] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthenticationModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [
-                        CommonModule,
-                        HttpClientModule,
-                        //JwtModule,
-                        RouterModule,
-                        FormsModule,
-                        ReactiveFormsModule,
-                        CoolStorageModule
-                    ],
-                    declarations: [
-                        AuthenticationComponent,
-                        DirectLoginComponent,
-                        TimeoutNotificationComponent
-                    ],
-                    exports: [
-                        AuthenticationComponent,
-                        DirectLoginComponent,
-                        TimeoutNotificationComponent
-                    ]
-                }]
-        }], ctorParameters: function () { return [{ type: i4.JwtModule, decorators: [{
-                    type: Optional
-                }, {
-                    type: SkipSelf
-                }] }]; } });
+/*
+ * Copyright (c) 2016 Huntsman Cancer Institute at the University of Utah, Confidential and Proprietary
+ */
+/**
+ * Provide a single auth service and interceptor for the implementing application.  Also provide everything
+ * from the angular-jwt library.
+ *
+ * @since 1.0.0
+ */
+class AuthenticationModule {
+    constructor(parentModule) {
+        if (parentModule) {
+            throw new Error("AuthenticationModule is already loaded.");
+        }
+    }
+    static forRoot() {
+        return {
+            providers: [
+                AuthenticationProvider,
+                JwtHelperService,
+                AuthenticationService,
+                {
+                    provide: HTTP_INTERCEPTORS,
+                    useClass: AuthorizationInterceptor,
+                    multi: true
+                },
+                {
+                    provide: HTTP_INTERCEPTORS,
+                    useClass: JwtInterceptor,
+                    multi: true
+                },
+                {
+                    provide: JWT_OPTIONS,
+                    useClass: AuthenticationProvider
+                }
+            ],
+            ngModule: AuthenticationModule
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AuthenticationModule, deps: [{ token: i4.JwtModule, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.1.2", ngImport: i0, type: AuthenticationModule, declarations: [AuthenticationComponent,
+            DirectLoginComponent,
+            TimeoutNotificationComponent], imports: [CommonModule,
+            HttpClientModule,
+            //JwtModule,
+            RouterModule,
+            FormsModule,
+            ReactiveFormsModule,
+            CoolStorageModule], exports: [AuthenticationComponent,
+            DirectLoginComponent,
+            TimeoutNotificationComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AuthenticationModule, imports: [CommonModule,
+            HttpClientModule,
+            //JwtModule,
+            RouterModule,
+            FormsModule,
+            ReactiveFormsModule,
+            CoolStorageModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AuthenticationModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        HttpClientModule,
+                        //JwtModule,
+                        RouterModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        CoolStorageModule
+                    ],
+                    declarations: [
+                        AuthenticationComponent,
+                        DirectLoginComponent,
+                        TimeoutNotificationComponent
+                    ],
+                    exports: [
+                        AuthenticationComponent,
+                        DirectLoginComponent,
+                        TimeoutNotificationComponent
+                    ]
+                }]
+        }], ctorParameters: () => [{ type: i4.JwtModule, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }] });
 
-/*
- * Copyright (c) 2016 Huntsman Cancer Institute at the University of Utah, Confidential and Proprietary
- */
-const RouteGuardService = () => {
-    const authenticationService = inject(AuthenticationService);
-    const router = inject(Router);
-    const state = inject(RouterStateSnapshot);
-    const authenticationRoute = inject(AUTHENTICATION_ROUTE);
-    if (authenticationService.isAuthenticated()) {
-        return true;
-    }
-    else {
-        // Store the attempted URL for redirecting
-        authenticationService.redirectUrl = state.url;
-        // Navigate to the login page
-        return router.navigate([authenticationRoute]);
-    }
+/*
+ * Copyright (c) 2016 Huntsman Cancer Institute at the University of Utah, Confidential and Proprietary
+ */
+const RouteGuardService = () => {
+    const authenticationService = inject(AuthenticationService);
+    const router = inject(Router);
+    const state = inject(RouterStateSnapshot);
+    const authenticationRoute = inject(AUTHENTICATION_ROUTE);
+    if (authenticationService.isAuthenticated()) {
+        return true;
+    }
+    else {
+        // Store the attempted URL for redirecting
+        authenticationService.redirectUrl = state.url;
+        // Navigate to the login page
+        return router.navigate([authenticationRoute]);
+    }
 };
 
-/**
- * Generated bundle index. Do not edit.
+/**
+ * Generated bundle index. Do not edit.
  */
 
 export { AUTHENTICATION_DIRECT_ENDPOINT, AUTHENTICATION_IDP_INACTIVITY_MINUTES, AUTHENTICATION_LOGOUT_PATH, AUTHENTICATION_MAX_INACTIVITY_MINUTES, AUTHENTICATION_ROUTE, AUTHENTICATION_SERVER_URL, AUTHENTICATION_TOKEN_ENDPOINT, AUTHENTICATION_TOKEN_KEY, AUTHENTICATION_USER_COUNTDOWN_SECONDS, AuthenticationComponent, AuthenticationModule, AuthenticationService, AuthorizationInterceptor, DirectLoginComponent, RouteGuardService, TimeoutNotificationComponent };