OAuthService for oauth2 token

api.service.ts

import { Injectable } from '@angular/core';
import { Headers, Http } from '@angular/http';

import { environment } from '../../environments/environment';

import { OAuthService } from './oauth.service';

@Injectable()

export class ApiService {

  constructor(private http: Http, private OAuthService: OAuthService) { }

  /**
   * name: get
   * params: {String} url
   * description: append header to the get request
   */
  get(url: string): Promise<any>{
    return this.OAuthService.getAccessToken()
      .then(response => {
        let headers = new Headers();
        headers.append('Authorization', 'Bearer ' + response);
        return this.http.get(`${environment.apiEndpoint}/${environment.apiVersion}${url}`, {
           headers: headers
        });
      })
      // Catch reject from OAuthService
      .catch(error => console.log('In ApiService : ' + error));
  }

  /**
   * name: get
   * params: {String}  url
   * params: {Object} data
   * description: append header to the post request
   */
  post(url: string, data: Object): Promise<any>{
    return this.OAuthService.getAccessToken()
      .then(response => {
        let headers = new Headers();
        headers.append('Authorization', 'Bearer ' + response);
        return this.http.post(`${environment.apiEndpoint}/${environment.apiVersion}${url}`, data, {
          headers: headers
        });
      })
      // Catch reject from OAuthService
      .catch(error => console.log('In ApiService : ' + error));
  }


}

oauth.service.ts

import { Injectable } from '@angular/core';
import { CookieService } from 'ng2-cookies';
import { Http } from '@angular/http';
import * as _ from "lodash";

import { environment } from '../../environments/environment';
import 'rxjs/add/operator/toPromise';

@Injectable()

export class OAuthService {

  private accessToken: any;

  constructor(public cookieService: CookieService, public http: Http) { }

  getAccessToken(): Promise<string> {

    return new Promise((resolve, reject) => {

      // Get stored access token
      let accessToken = this.cookieService.get('access_token');

      if(accessToken) {
        this.accessToken = JSON.parse(accessToken);
      }

      if(this.hasValidAccessToken()) {
        resolve(this.accessToken.access_token);
        return;
      }

      // Get grant type
      let grantParameters = this.getGrantParameters();

      // Get a new access token
      this.http.get(`${environment.apiEndpoint}/oauth/v2/token?client_id=${environment.clientId}&client_secret=${environment.clientSecret}&${grantParameters}`)
        .toPromise()
        .then(response =>  {
          this.accessToken = response.json();
          // Set access token
          this.setAccessToken();
          // Return access token
          resolve(this.accessToken.access_token);
          return;
        })
        .catch(error => console.log('In OAauthService : ' + error));

    });

  }

  getGrantParameters() {

    let grantParameters = '';

    // Get stored identity
    let identityJson = this.cookieService.get('identity');

    // If an identity is stored, return required parameter for an access token with an identity
    if(identityJson) {

      let identity = JSON.parse(identityJson);

      // If an identity is stored, use the refresh_token with grant type refresh_token
      if(_.has(this.accessToken, 'refresh_token')) {
        grantParameters = `grant_type=refresh_token&refresh_token=${this.accessToken.refresh_token}`;
      }
      // Otherwise get a new access token with identity
      else if (_.has(identity, 'api_key')) {
        grantParameters = `grant_type=https://api.swilo.co/grants/api_key&api_key=${identity.api_key}`;
      }

    }
    // Required for an anonymous access token
    else {
      grantParameters = 'grant_type=client_credentials';
    }

    return grantParameters;

  }

  hasValidAccessToken() {

    if(this.accessToken) {
      return !(this.accessTokenIsExpired() || !_.has(this.accessToken, 'access_token') || !_.has(this.accessToken, 'expires_at'));
    }

    return false;

  };

  accessTokenIsExpired() {
    let now = new Date();
    return this.accessToken.expires_at < now.getTime();
  }

  setAccessToken() {
    if(this.accessToken) {
      // Set expires_at
      let now = new Date();
      this.accessToken.expires_at = parseInt(this.accessToken.expires_in)*1000 + now.getTime();
      // Delete previous cookie
      this.cookieService.delete('access_token');
      // Store access token
      this.cookieService.set('access_token', JSON.stringify(this.accessToken));
    }
  }

}