authentication.service.ts

import { Injectable } from '@angular/core';
import { Http, Response, Headers, RequestOptions } from '@angular/http';
import { AppConstant } from '../app.constant';
import { Router } from '@angular/router';
import { LoaderService } from './loader.service';
import { CommonService } from './common.service';

@Injectable()
export class AuthenticationService {

  private url = AppConstant.BASE_URL + "oauth/token";
  private oauth_bypass_url: string[] = ["about", "signup", "logoutuser", "validateResetLink",
    "validateSecurityQues", "resetPassword", "fetchQuestions", "savePassword", "sendResetLink",
    "passwordSettings", "upload", "fetchQuestionsBasedOnLoginDetails", "changePassword", "login","validateOTP","regenerateOTP"];
  static isSessionActive: boolean = true;


  constructor(
    private http: Http,
    private common: CommonService
  ) { }

  /**
   * Gets the access token from the browsers local storage
   */
  public getToken(): string {
    let access_token = localStorage.getItem('access_token');
    if (access_token !== undefined && access_token !== null) {
      access_token = access_token.split('"')[1] !== undefined && access_token.split('"')[1] !== null ? access_token.split('"')[1] : access_token;
    }
    return access_token;
  }
  /**
    * Gets the refresh token from the browsers local storage
    */
  public getRefreshToken(): string {
    let refresh_token = localStorage.getItem('refresh_token');

    if (refresh_token !== undefined && refresh_token !== null) {
      refresh_token = refresh_token.split('"')[1] !== undefined && refresh_token.split('"')[1] !== null ? refresh_token.split('"')[1] : refresh_token;
    }
    return refresh_token
  }

  public getSessionKey(): string {
    let sessionKey = localStorage.getItem(AppConstant.API_SESSION_KEY);
    if (sessionKey !== undefined && sessionKey !== null) {
      sessionKey = sessionKey.split('"')[1] !== undefined && sessionKey.split('"')[1] !== null ? sessionKey.split('"')[1] : sessionKey;
    }
    return sessionKey;
  }


  /**
   * Requests the server for the new access token
   */
  refreshToken() {
    let h = new Headers(
      {
        'Content-Type': 'application/x-www-form-urlencoded',
        'Authorization': 'Basic ' + btoa("foo:foo123"),
        "cache-control": "no-cache"
      });
    let options = new RequestOptions({ headers: h });
    let body = `refresh_token=${this.getRefreshToken()}&grant_type=refresh_token`;
    return this.http.post(this.url, body, options);
  }


  async  getRefreshTokenInSync(): Promise<any> {
    let promise = await new Promise((resolve, reject) => {
      this.refreshToken().subscribe(async  success => {
        console.log('response recieved for refresh token ', success);
        resolve(success);
      }, error => {
        console.error('Error while fetching response for refresh token', error);
        resolve(error);
      });
    });
    let result = await promise;
    return result;
  }


  isUrlNotOauthByPassed(url: string) {
    let extractedUrl = url.slice(AppConstant.BASE_URL.length);
    return this.oauth_bypass_url.indexOf(extractedUrl) < 0;
  }

  addUserSessionToken(request) {
    let session_token = this.getSessionKey();
    let userDetails = JSON.parse(localStorage.getItem(AppConstant.loginUserDetails));
    let activeKey = sessionStorage.getItem(AppConstant.IS_LOGGED_IN_SESSION_KEY);
    if (session_token !== undefined && session_token !== null && session_token !== '' && userDetails !== undefined && userDetails !== null) {
      let email = userDetails.email;
      request = request.clone({ headers: request.headers.set(AppConstant.API_SESSION_KEY, session_token) });
      request = request.clone({ headers: request.headers.set('User', email) });
      if (activeKey) {
        request = request.clone({ headers: request.headers.set('isUserActive', activeKey) });
      } return request;
    } else {
      return request;
    }
  }

  logout() {
    this.common.logoutUser(null);
  }

} 

token.interceptor.ts

import { Injectable, Injector } from '@angular/core';
import { HttpRequest, HttpHandler, HttpEvent, HttpInterceptor, HttpUserEvent, HttpErrorResponse } from '@angular/common/http';
import { AuthenticationService } from './authentication.service';
import { Observable } from 'rxjs/Observable';
import 'rxjs/add/operator/map';
import { Router } from '@angular/router';
import { StorageService } from './storage.service';
import { LoaderService } from './loader.service';
import { of } from 'rxjs/observable/of';
import { AppConstant } from '../app.constant';
import { AppComponent } from '../../../app.component';


@Injectable()
export class TokenInterceptor implements HttpInterceptor {
    authService;

    constructor(
        private storage: StorageService,
        private injector: Injector
    ) { }




    addAuthHeader(request) {
        //let auth = this.injector.get(AuthenticationService);
        const token: string = localStorage.getItem('access_token');


        if (this.authService.isUrlNotOauthByPassed(request.url)) {
            request = this.authService.addUserSessionToken(request);
            if (token) {
                request = request.clone({
                    headers: request.headers.set(
                        'Authorization', `Bearer ${this.authService.getToken()}`
                    )
                });

            } else {
                let header = 'Basic ' + btoa("foo:foo123");
                request = request.clone({
                    headers: request.headers.set(
                        // Accept: 'application/json',
                        //'Content-Type': 'application/x-www-form-urlencoded',
                        'Authorization', header
                    ),

                });
                request = request.clone({ headers: request.headers.set('Content-Type', 'application/x-www-form-urlencoded') });
            }
        }
        return request;
    }

    /**
     * 
     * @param request method intercepted for every request 
     * @param next 
     */

    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
        this.authService = this.injector.get(AuthenticationService);
        if (AppConstant.enable_oauth) {
            return Observable.fromPromise(this.handleAccess(request, next, false, 0));
        } else {
            return next.handle(request);
        }
    }



    /**
     * 
     * @param request Promise method which is used by the interceptor to manage the refresh token and last request's reinitiation
     * @param next 
     * @param flag 
     */
    private async handleAccess(request: HttpRequest<any>, next: HttpHandler, flag: boolean, processTime: number):
        Promise<HttpEvent<any>> {
        debugger
        let changedRequest = request;
        /**
         * If we are recursively calling the method add a delay
         * 
         * NOTE :  Further will add maximum delay for which we should retry else will logout the user,
         *         else the process will run continuosly if the server does not responds
         * 
         */
        /*   if (flag) {
              this.sleep(3000);
              processTime += 3000;
          } */
        /**
         * Add the authentication header to the request
         */
        changedRequest = this.addAuthHeader(changedRequest);
        console.log('Request to the method accessor ', changedRequest);
        let handle_reponse = await next.handle(changedRequest).toPromise().catch(async error => {
            console.log("Error from server to the interceptor", error)
            if (error.status === 401 && flag === false) {

                /**
                 * If the response status code is 401 try to get the new access token 
                 */
                let refresh_token_response_data = await this.authService.getRefreshTokenInSync();
                if (refresh_token_response_data.status === 401) {
                    if (changedRequest.url.includes('oauth/token')) {
                        throw error;
                    } else {
                        AuthenticationService.isSessionActive = false;
                        AppComponent.setInfoValuePopup(true,'Session Timed out.... Logging you out');
                        this.authService.logout();
                    }
                } else {
                    let data = JSON.parse(refresh_token_response_data._body);
                    this.storage.setItem("access_token", data['access_token']);
                    this.storage.setItem("refresh_token", data['refresh_token']);

                    let reinitiated_request = await this.handleAccess(changedRequest, next, true, processTime);
                    return reinitiated_request;
                }
            } else if (error.status === 511) {
                if (AuthenticationService.isSessionActive) {
                    AuthenticationService.isSessionActive = false;
                    if (error.error.status) {
                        AppComponent.setInfoValuePopup(true,error.error.status);
                    }
                    this.authService.logout();
                }
            } else {
                throw error;
            }

        });
        return handle_reponse;
    }


    sleep(milliseconds: number) {
        console.log("starting to sleep");
        let currentTime = new Date().getTime();
        while (currentTime + milliseconds >= new Date().getTime()) {

        }
        console.log("sleep completed");
    }


}