Fixed build error and AcquireToken function

README.md

@@ -2,6 +2,8 @@
 
 To do authentication against Microsoft Windows Azure AD, using the Microsoft ADAL library underneath. Note this library is extracted from the <b>adal-angular</b> package.
 
-NPM Package: https://www.npmjs.com/package/angular2-adal
+This also provide AuthHttp class, which actually gets token in background for external webapis.
+
+NPM Package: 
 
 Example and guideline: https://github.com/alenny/angular2-adal-example

gulp/bundle.js

@@ -34,6 +34,11 @@ const bundleConfig = {
             main: 'index.js',
             defaultExtension: 'js'
         },
+
+        '@angular/http' : {
+            main: 'index.js',
+            defaultExtension: 'js'
+        },
         rxjs: {
             main: 'Rx.js',
             defaultExtension: 'js'

package.json

@@ -34,6 +34,7 @@
     "@angular/compiler": "^2.0.0-rc.1",
     "@angular/core": "^2.0.0-rc.1",
     "@angular/platform-browser": "^2.0.0-rc.1",
+    "@angular/http": "^2.0.0-rc.1",
     "reflect-metadata": "^0.1.3",
     "rxjs": "5.0.0-beta.6",
     "zone.js": "^0.6.12",

src/adal/index.d.ts

@@ -0,0 +1,163 @@
+declare module 'adal' {
+    export function inject(config: adal.Config): adal.AuthenticationContext;
+}
+
+declare namespace adal {
+
+    interface Config {
+        clientId: string,
+        anonymousEndpoints?: any,
+        cacheLocation?: string,
+        correlationId?: string,
+        displayCall?: (urlNavigate: string) => any,
+        endpoints?: any,  // If you need to send CORS api requests.
+        expireOffsetSeconds?: number,
+        extraQueryParameter?: string,
+        instance?: string,
+        localLoginUrl?: string,
+        loginResource?: string,
+        postLogoutRedirectUri?: string,
+        redirectUri?: string,
+        state?: string,
+        tenant?: string
+    }
+
+    interface User {
+        userName: string,
+        profile?: any
+    }
+
+    interface RequestInfo {
+        valid: boolean,
+        parameters: any,
+        stateMatch: boolean,
+        stateResponse: string,
+        requestType: string
+    }
+
+    interface AuthenticationContextStatic {
+        new (config: Config): AuthenticationContext;
+    }
+
+    interface AuthenticationContext {
+
+        REQUEST_TYPE: {
+            LOGIN: string,
+            RENEW_TOKEN: string,
+            UNKNOWN: string
+        };
+        instance: string;
+        config: Config;
+
+        /**
+         * Gets initial Idtoken for the app backend
+         * Saves the resulting Idtoken in localStorage.
+         */
+        login(): void;
+        loginInProgress(): boolean;
+
+        /**
+         * Gets token for the specified resource from local storage cache
+         * @param {string}   resource A URI that identifies the resource for which the token is valid.
+         * @returns {string} token if exists and not expired or null
+         */
+        getCachedToken(resource: string): string;
+
+        /**
+         * Retrieves and parse idToken from localstorage
+         * @returns {User} user object
+         */
+        getCachedUser(): User;
+
+        registerCallback(expectedState: string, resource: string, callback: (message: string, token: string) => any): void;
+
+        /**
+         * Acquire token from cache if not expired and available. Acquires token from iframe if expired.
+         * @param {string}   resource  ResourceUri identifying the target resource
+         * @param {requestCallback} callback
+         */
+        acquireToken(resource: string, callback: (message: string, token: string) => any): void;
+
+        /**
+         * Redirect the Browser to Azure AD Authorization endpoint
+         * @param {string}   urlNavigate The authorization request url
+         */
+        promptUser(urlNavigate: string): void;
+
+        /**
+         * Clear cache items.
+         */
+        clearCache(): void;
+
+        /**
+         * Clear cache items for a resource.
+         */
+        clearCacheForResource(resource: string): void;
+
+        /**
+         * Logout user will redirect page to logout endpoint.
+         * After logout, it will redirect to post_logout page if provided.
+         */
+        logOut(): void;
+
+        /**
+         * Gets a user profile
+         * @param {requestCallback} callback - The callback that handles the response.
+         */
+        getUser(callback: (message: string, user?: User) => any): void;
+
+        /**
+         * Checks if hash contains access token or id token or error_description
+         * @param {string} hash  -  Hash passed from redirect page
+         * @returns {Boolean}
+         */
+        isCallback(hash: string): boolean;
+
+        /**
+         * Gets login error
+         * @returns {string} error message related to login
+         */
+        getLoginError(): string;
+
+        /**
+         * Gets requestInfo from given hash.
+         * @returns {string} error message related to login
+         */
+        getRequestInfo(hash: string): RequestInfo;
+
+        /**
+         * Saves token from hash that is received from redirect.
+         */
+        saveTokenFromHash(requestInfo: RequestInfo): void;
+
+        /**
+         * Gets resource for given endpoint if mapping is provided with config.
+         * @param {string} endpoint  -  API endpoint
+         * @returns {string} resource for this API endpoint
+         */
+        getResourceForEndpoint(endpoint: string): string;
+
+        handleWindowCallback(): void;
+
+        callback : any;
+
+        _getItem : any;
+
+        _renewFailed : any;
+
+        CONSTANTS : any;
+
+        log(level: number, message: string, error: any): void;
+        error(message: string, error: any): void;
+        warn(message: string): void;
+        info(message: string): void;
+        verbose(message: string): void;
+    }
+
+}
+
+interface Window {
+    AuthenticationContext : any;
+    callBackMappedToRenewStates : any;
+}
+

src/services.ts

@@ -1,2 +1,3 @@
 export {AdalService} from './services/adal.service';
-export {OAuthData} from './services/oauthdata.model';
+export {OAuthData} from './services/oauthdata.model';
+export {AuthHttp} from './services/authHttp.service'

src/services/adal.service.ts

@@ -1,9 +1,13 @@
 import {Injectable} from '@angular/core';
 import 'rxjs/Rx';
 import {Observable} from "rxjs/Observable";
+import 'rxjs/Observable/bindCallback'
 import adalLib = require('adal');
 import {OAuthData} from "./oauthdata.model";
 
+
+
+
 @Injectable()
 export class AdalService {
 
@@ -33,6 +37,8 @@ export class AdalService {
         // create instance with given config
         this.adalContext = adalLib.inject(configOptions);
 
+        window.AuthenticationContext = this.adalContext.constructor;
+
         // loginresource is used to set authenticated status
         this.updateDataFromCache(this.adalContext.config.loginResource);
     }
@@ -64,7 +70,30 @@ export class AdalService {
             this.adalContext.saveTokenFromHash(requestInfo);
             if (requestInfo.requestType === this.adalContext.REQUEST_TYPE.LOGIN) {
                 this.updateDataFromCache(this.adalContext.config.loginResource);
+
             } else if (requestInfo.requestType === this.adalContext.REQUEST_TYPE.RENEW_TOKEN) {
+                this.adalContext.callback = window.parent.callBackMappedToRenewStates[requestInfo.stateResponse];
+            }
+
+            if(requestInfo.stateMatch)
+            {
+                if (typeof this.adalContext.callback === 'function')
+                {
+                    if (requestInfo.requestType === this.adalContext.REQUEST_TYPE.RENEW_TOKEN) 
+                    {
+                        // Idtoken or Accestoken can be renewed
+                        if (requestInfo.parameters['access_token']) 
+                        {
+                            this.adalContext.callback(this.adalContext._getItem(this.adalContext.CONSTANTS.STORAGE.ERROR_DESCRIPTION)
+                                                        , requestInfo.parameters['access_token']);
+                        }
+                        else if (requestInfo.parameters['error']) 
+                        {
+                            this.adalContext.callback(this.adalContext._getItem(this.adalContext.CONSTANTS.STORAGE.ERROR_DESCRIPTION), null);
+                            this.adalContext._renewFailed = true;
+                        }
+                    }
+                }
             }
         }
     }
@@ -74,7 +103,7 @@ export class AdalService {
     }
 
     public acquireToken(resource: string) {
-        return Observable.bindCallback(function (cb) {
+        return Observable.bindCallback((cb) => {
             this.adalContext.acquireToken(resource, function (error: string, tokenOut: string) {
                 if (error) {
                     this.adalContext.error('Error when acquiring token for resource: ' + resource, error);
@@ -83,7 +112,7 @@ export class AdalService {
                     cb(tokenOut);
                 }
             });
-        });
+        })();
     }
 
     public getUser(): Observable<adal.User> {
@@ -115,18 +144,18 @@ export class AdalService {
         this.adalContext.verbose(message);
     }
 
+    public GetResourceForEndpoint(url: string): string
+    {
+        return this.adalContext.getResourceForEndpoint(url);
+    }
+
     private updateDataFromCache(resource: string): void {
         let token = this.adalContext.getCachedToken(resource);
         this.oauthData.isAuthenticated = token !== null && token.length > 0;
-        var user = this.adalContext.getCachedUser();
-        if (user) {
-            this.oauthData.userName = user.userName;
-            this.oauthData.profile = user.profile;
-            this.oauthData.loginError = this.adalContext.getLoginError();
-        } else {
-            this.oauthData.userName = '';
-            this.oauthData.profile = {};
-            this.oauthData.loginError = '';
-        }
+        var user = this.adalContext.getCachedUser() || { userName: '' };
+        this.oauthData.userName = user.userName;
+        this.oauthData.profile = user.profile;
+        this.oauthData.loginError = this.adalContext.getLoginError();
+
     };
 }