services/self-service/src/main/resources/webapp/src/app/core/services/applicationSecurity.service.ts

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

import { Injectable } from '@angular/core';
import { of as observableOf, Observable, BehaviorSubject } from 'rxjs';
import { catchError, map, tap } from 'rxjs/operators';

import { ApplicationServiceFacade } from './applicationServiceFacade.service';
import { AppRoutingService } from './appRouting.service';
import { StorageService } from './storage.service';
import { LoginModel } from '../../login/login.model';
import { ErrorUtils, HTTP_STATUS_CODES } from '../util';
import { DICTIONARY } from '../../../dictionary/global.dictionary';

@Injectable()
export class ApplicationSecurityService {
  private _loggedInStatus = new BehaviorSubject<boolean>(null);
  readonly DICTIONARY = DICTIONARY;

  emitter: BehaviorSubject<any> = new BehaviorSubject<any>('');
  emitter$ = this.emitter.asObservable();

  constructor(
    private serviceFacade: ApplicationServiceFacade,
    private appRoutingService: AppRoutingService,
    private storage: StorageService,
  ) { }

  get loggedInStatus() {
    return this._loggedInStatus.asObservable();
  }

  public locationCheck() {
    return this.serviceFacade.buildLocationCheck()
      .pipe(
        map(response => response),
        catchError(error => error));
  }

  public login(loginModel: LoginModel): Observable<boolean | {}> {
    return this.serviceFacade
      .buildLoginRequest(loginModel.toJsonString())
      .pipe(
        map(response => {
          if (response.status === HTTP_STATUS_CODES.OK) {
            this.storage.storeTokens(response.body);
            this.storage.setUserName(response.body.username);
            this._loggedInStatus.next(true);
            return true;
          }
          this._loggedInStatus.next(false);
          return false;
        }),
        catchError(ErrorUtils.handleServiceError));
  }

  public refreshToken() {
    const refreshToken = `/${this.storage.getRefreshToken()}`;
    return this.serviceFacade.buildRefreshToken(refreshToken)
      .pipe(
        tap((tokens) => this.storage.storeTokens(tokens)));
  }

  public logout(): Observable<boolean> {
    const authToken = this.storage.getToken();

    if (!!authToken) {
      return this.serviceFacade
        .buildLogoutRequest()
        .pipe(
          map(response => {
            this.storage.destroyTokens();
            this.storage.setBillingQuoteUsed('');
            this._loggedInStatus.next(false);
            return response;
          }, this));
    }

    return observableOf(false);
  }

  public isLoggedIn(): Observable<boolean> {
    const authToken = this.storage.getToken();
    const currentUser = this.storage.getUserName();
    if (authToken && currentUser) {
      return this.serviceFacade
        .buildAuthorizeRequest(currentUser)
        .pipe(
          map(response => {
            if (response.status === HTTP_STATUS_CODES.OK) {
              this._loggedInStatus.next(true);
              return true;
            }

            this.storage.destroyTokens();
            return false;
          }),
          catchError(error => {
            this.emmitMessage(error.message);
            this.storage.destroyTokens();

            return observableOf(false);
          }));
    }
    this._loggedInStatus.next(false);
    return observableOf(false);
  }

  public redirectParams(params): Observable<boolean> {
    const code = `?code=${params.code}`;

    return this.serviceFacade
      .buildGetAuthToken(code)
      .pipe(
        map((response: any) => {
          const data = response.body;
          if (response.status === HTTP_STATUS_CODES.OK && data.access_token) {
            this.storage.storeTokens(data);
            this.storage.setUserName(data.username);

            this.appRoutingService.redirectToHomePage();
            return true;
          }

          if (response.status !== 200) {
            const errObj = response.body;
            this.emmitMessage(errObj.message);
          }
          return false;

        }), catchError((error: any) => {
          this.emmitMessage(error.message);
          return observableOf(false);
        }));
  }

  private emmitMessage(message): void {
    this.appRoutingService.redirectToLoginPage();
    this.emitter.next(message);
  }
}