@huntsman-cancer-institute/authentication 12.5.0 → 14.1.0

package/authentication.component.d.ts

@@ -23,5 +23,5 @@ export declare class AuthenticationComponent {
     private clearLoginAndRetry;
     private beginAuthenticationProcess;
     static ɵfac: i0.ɵɵFactoryDeclaration<AuthenticationComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<AuthenticationComponent, "authentication-iframe", never, {}, {}, never, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AuthenticationComponent, "authentication-iframe", never, {}, {}, never, never, false>;
 }

package/directlogin.component.d.ts

@@ -1,13 +1,13 @@
 import { OnInit } from "@angular/core";
 import { AuthenticationService } from "./authentication.service";
-import { FormBuilder, FormGroup } from "@angular/forms";
+import { UntypedFormBuilder, UntypedFormGroup } from "@angular/forms";
 import * as i0 from "@angular/core";
 export declare class DirectLoginComponent implements OnInit {
     private _authenticationService;
     private _formBuilder;
-    _loginForm: FormGroup;
+    _loginForm: UntypedFormGroup;
     _errorMsg: string;
-    constructor(_authenticationService: AuthenticationService, _formBuilder: FormBuilder);
+    constructor(_authenticationService: AuthenticationService, _formBuilder: UntypedFormBuilder);
     /**
      * Initializes the authentication form.
      */
@@ -17,5 +17,5 @@ export declare class DirectLoginComponent implements OnInit {
      */
     login(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DirectLoginComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DirectLoginComponent, "hci-login-form", never, {}, {}, never, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DirectLoginComponent, "hci-login-form", never, {}, {}, never, never, false>;
 }

package/esm2020/authentication.component.mjs

@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2016 Huntsman Cancer Institute at the University of Utah, Confidential and Proprietary
+ */
+import { Component, ElementRef, ViewChild, Inject, Renderer2 } from "@angular/core";
+import { Location } from "@angular/common";
+import { Router } from "@angular/router";
+import { DomSanitizer } from "@angular/platform-browser";
+import { interval } from "rxjs";
+import { first } from "rxjs/operators";
+import { AuthenticationService, AUTHENTICATION_ROUTE } from "./authentication.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./authentication.service";
+import * as i2 from "@angular/platform-browser";
+import * as i3 from "@angular/router";
+import * as i4 from "@angular/common";
+export 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();
+        });
+    }
+}
+AuthenticationComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AuthenticationComponent, deps: [{ token: i1.AuthenticationService }, { token: i2.DomSanitizer }, { token: i3.Router }, { token: i4.Location }, { token: i0.Renderer2 }, { token: AUTHENTICATION_ROUTE }], target: i0.ɵɵFactoryTarget.Component });
+AuthenticationComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", 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">
+        <div class="alert alert-danger">
+          <h5 class="alert-heading">Authentication Failed</h5>
+          <span id="hci-login-error" class="alert-text">{{_errorMsg}}</span>
+        </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.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AuthenticationComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "authentication-iframe", template: `
+    <div class="container">
+      <iframe #iframe class="frame" [src]="url" (load)="handleChanges()"></iframe>
+      <div *ngIf="_errorMsg" class="alert-box">
+        <div class="alert alert-danger">
+          <h5 class="alert-heading">Authentication Failed</h5>
+          <span id="hci-login-error" class="alert-text">{{_errorMsg}}</span>
+        </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: i1.AuthenticationService }, { type: i2.DomSanitizer }, { type: i3.Router }, { type: i4.Location }, { type: i0.Renderer2 }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [AUTHENTICATION_ROUTE]
+                }] }]; }, propDecorators: { iframe: [{
+                type: ViewChild,
+                args: ["iframe", { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authentication.component.js","sourceRoot":"","sources":["../../../projects/authentication/src/authentication.component.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 {Component, ElementRef, ViewChild, Inject, Renderer2} from \"@angular/core\";\r\nimport {Location, PopStateEvent} from \"@angular/common\";\r\nimport {Router} from \"@angular/router\";\r\nimport {DomSanitizer} from \"@angular/platform-browser\";\r\n\r\nimport {interval, Subscription} from \"rxjs\";\r\nimport {first} from \"rxjs/operators\";\r\n\r\nimport {AuthenticationService, AUTHENTICATION_ROUTE} from \"./authentication.service\";\r\n\r\n@Component({\r\n  selector: \"authentication-iframe\",\r\n  template: `\r\n    <div class=\"container\">\r\n      <iframe #iframe class=\"frame\" [src]=\"url\" (load)=\"handleChanges()\"></iframe>\r\n      <div *ngIf=\"_errorMsg\" class=\"alert-box\">\r\n        <div class=\"alert alert-danger\">\r\n          <h5 class=\"alert-heading\">Authentication Failed</h5>\r\n          <span id=\"hci-login-error\" class=\"alert-text\">{{_errorMsg}}</span>\r\n        </div>\r\n      </div>\r\n    </div>\r\n    `,\r\n  styles: [`\r\n    \r\n    :host {\r\n      background-color: white;\r\n    }\r\n    \r\n    .container {\r\n      max-width: 100%;\r\n      margin-top: 60px;\r\n      padding-top: 15px;\r\n    }\r\n\r\n    .frame {\r\n      width: 100%;\r\n      height: 100%;\r\n      border: 0px;\r\n    }\r\n  `],\r\n  host: {class: \"outlet-row\"}\r\n})\r\nexport class AuthenticationComponent {\r\n\r\n  public url;\r\n  public _errorMsg: string;\r\n\r\n  @ViewChild(\"iframe\", {static: true}) iframe : ElementRef;\r\n\r\n  private resetSubscription: Subscription;\r\n  private popstateSubscription: Subscription;\r\n\r\n  constructor(private authenticationService: AuthenticationService,\r\n              private domSanitizer : DomSanitizer,\r\n              private router: Router,\r\n              private location: Location,\r\n              private renderer: Renderer2,\r\n              @Inject(AUTHENTICATION_ROUTE) private authenticationRoute: string) {\r\n  }\r\n\r\n  ngOnInit() {\r\n    /*\r\n     * Fix back bug\r\n     * 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\r\n     * Eventually the browser gets to the /authenticate route and going back from there loads the iframe history and Shibboleth displays\r\n     * an error relating to navigating back.\r\n     */\r\n    history.pushState(null, null, this.location.prepareExternalUrl(this.authenticationRoute));\r\n\r\n    this.popstateSubscription = <Subscription> this.location.subscribe((value: PopStateEvent) => {\r\n      //This is going to prevent back from working from the login component\r\n      history.go(1);\r\n    });\r\n\r\n    this.beginAuthenticationProcess();\r\n  }\r\n\r\n  handleChanges(): void {\r\n    if (!this.iframe.nativeElement.contentDocument) {\r\n      return;\r\n    }\r\n\r\n    try {\r\n      let element: HTMLElement = this.iframe.nativeElement.contentDocument.body;\r\n      if (element.querySelector(\"pre\")) {\r\n        element = element.querySelector(\"pre\");\r\n      }\r\n\r\n      this._errorMsg = null;\r\n      var jsonText = element.innerText;\r\n\r\n      var json = JSON.parse(jsonText);\r\n      this.authenticationService.storeToken(json.auth_token);\r\n      var authenticated = this.authenticationService.proceedIfAuthenticated();\r\n\r\n      if (!authenticated) {\r\n        this.resetSubscription.unsubscribe();\r\n        this.beginAuthenticationProcess();\r\n      }\r\n    } catch (error) {\r\n      if (this.iframe.nativeElement.contentDocument.title.toUpperCase() === \"ERROR\") {\r\n        if (this.iframe.nativeElement.contentDocument.body.innerHTML.toUpperCase() === \"FORBIDDEN\") {\r\n          this._errorMsg = \"You do not have permission to log into this application\";\r\n        } else {\r\n          this._errorMsg = null;\r\n        }\r\n\r\n        //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.\r\n        this.clearLoginAndRetry();\r\n      }\r\n    }\r\n\r\n    // After the iframe loads, make the background transparent so we use the implementation's background and not the sso background.\r\n    this.renderer.setStyle(this.iframe.nativeElement.contentDocument.body, \"background-color\", \"transparent\");\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.resetSubscription.unsubscribe();\r\n    this.popstateSubscription.unsubscribe();\r\n  }\r\n\r\n  private clearLoginAndRetry(): void {\r\n    this.resetSubscription.unsubscribe();\r\n    this.authenticationService.clearLogin().subscribe(\r\n      () => { this.beginAuthenticationProcess(); },\r\n      (error) => { this.beginAuthenticationProcess(); }\r\n    );\r\n  }\r\n\r\n  private beginAuthenticationProcess(): void {\r\n    var tokenEndpoint = this.authenticationService.tokenLocation();\r\n\r\n    if (tokenEndpoint !== \"\") {\r\n      this.url = this.domSanitizer.bypassSecurityTrustResourceUrl(tokenEndpoint);\r\n    }\r\n\r\n    /**\r\n     * If the user doesn't complete authentication before the IdP session times out, that will be a problem when they eventually\r\n     * 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\r\n     * their browser open, then attempt to log back in in the morning. In order to work around this, this component will re-request\r\n     * the token prior to IdP timeout, which will reset the  process. This will happen 1 minute before idpInactivityMinutes\r\n     **/\r\n    this.resetSubscription = interval((this.authenticationService.idpInactivityMinutes - 1) * 60 * 1000)\r\n      .pipe(first())\r\n      .subscribe((value) => {\r\n        this.beginAuthenticationProcess();\r\n      });\r\n  }\r\n}\r\n"]}

package/esm2020/authentication.module.mjs

@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2016 Huntsman Cancer Institute at the University of Utah, Confidential and Proprietary
+ */
+import { NgModule, Optional, SkipSelf } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { ReactiveFormsModule, FormsModule } from "@angular/forms";
+import { HTTP_INTERCEPTORS, HttpClientModule } from "@angular/common/http";
+import { RouterModule } from "@angular/router";
+import { CoolStorageModule } from "@angular-cool/storage";
+import { JWT_OPTIONS, JwtHelperService, JwtInterceptor, JwtModule } from "@auth0/angular-jwt";
+import { AuthenticationService } from "./authentication.service";
+import { RouteGuardService } from "./route-guard.service";
+import { AuthenticationComponent } from "./authentication.component";
+import { DirectLoginComponent } from "./directlogin.component";
+import { TimeoutNotificationComponent } from "./timeout-notification.component";
+import { AuthorizationInterceptor } from "./authorization.interceptor";
+import { AuthenticationProvider } from "./authentication.provider";
+import * as i0 from "@angular/core";
+import * as i1 from "@auth0/angular-jwt";
+/**
+ * Provide a single auth service and interceptor for the implementing application.  Also provide everything
+ * from the angular-jwt library.
+ *
+ * @since 1.0.0
+ */
+export class AuthenticationModule {
+    constructor(parentModule) {
+        if (parentModule) {
+            throw new Error("AuthenticationModule is already loaded.");
+        }
+    }
+    static forRoot() {
+        return {
+            providers: [
+                AuthenticationProvider,
+                JwtHelperService,
+                AuthenticationService,
+                RouteGuardService,
+                {
+                    provide: HTTP_INTERCEPTORS,
+                    useClass: AuthorizationInterceptor,
+                    multi: true
+                },
+                {
+                    provide: HTTP_INTERCEPTORS,
+                    useClass: JwtInterceptor,
+                    multi: true
+                },
+                {
+                    provide: JWT_OPTIONS,
+                    useClass: AuthenticationProvider
+                }
+            ],
+            ngModule: AuthenticationModule
+        };
+    }
+}
+AuthenticationModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AuthenticationModule, deps: [{ token: i1.JwtModule, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.NgModule });
+AuthenticationModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: AuthenticationModule, declarations: [AuthenticationComponent,
+        DirectLoginComponent,
+        TimeoutNotificationComponent], imports: [CommonModule,
+        HttpClientModule,
+        //JwtModule,
+        RouterModule,
+        FormsModule,
+        ReactiveFormsModule,
+        CoolStorageModule], exports: [AuthenticationComponent,
+        DirectLoginComponent,
+        TimeoutNotificationComponent] });
+AuthenticationModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AuthenticationModule, imports: [CommonModule,
+        HttpClientModule,
+        //JwtModule,
+        RouterModule,
+        FormsModule,
+        ReactiveFormsModule,
+        CoolStorageModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", 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: i1.JwtModule, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/authentication.provider.mjs

@@ -0,0 +1,36 @@
+import { Inject, Injectable, InjectionToken } from "@angular/core";
+import { CoolLocalStorage } from '@angular-cool/storage';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular-cool/storage";
+export let AUTHENTICATION_TOKEN_KEY = new InjectionToken("authentication_token_key");
+export 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);
+    }
+}
+AuthenticationProvider.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AuthenticationProvider, deps: [{ token: i1.CoolLocalStorage }, { token: AUTHENTICATION_TOKEN_KEY }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthenticationProvider.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AuthenticationProvider });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AuthenticationProvider, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.CoolLocalStorage }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [AUTHENTICATION_TOKEN_KEY]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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