authorisation.service.ts

import { Injectable } from '@angular/core';
import { HttpClientModule, HttpClient, HttpHeaders, HttpErrorResponse } from '@angular/common/http';
import { Observable, Subject, BehaviorSubject } from 'rxjs';
import { catchError, map, tap, take,filter,skip, switchMap } from 'rxjs/operators';
import {LocationStrategy, Location} from '@angular/common';
// import { keypair } from 'keypair';
import * as keypair from 'keypair';
import * as forge from "node-forge";
import { Identity, AuthToken, KeyCert, SshAuthzServer } from './identity';
import { APIServer } from './apiserver';
import {BackendSelectionService} from './backend-selection.service';
import { throwError, of, combineLatest } from 'rxjs';
import {NotificationsService} from './notifications.service';


export class SshauthzServer {}

@Injectable({
  providedIn: 'root'
})
export class AuthorisationService {
  // public token: BehaviorSubject<AuthToken>;
  public readonly sshAuthzServers: BehaviorSubject<SshAuthzServer[]>;
  public readonly agentContents: BehaviorSubject<any>;
  public loggedInAuthZ: BehaviorSubject<SshAuthzServer[]>;
  public loggedOutAuthZ: BehaviorSubject<SshAuthzServer[]>;
  public loggedInAuthZ$: Observable<SshAuthzServer[]>;
  public loggedOutAuthZ$: Observable<SshAuthzServer[]>;
  //public progress: Subject<string>;
  // private keyCert: Subject<KeyCert>;
  public backendURI: string;
  public keys: KeyCert[];


  constructor(private http: HttpClient,
              private locationStrategy: LocationStrategy,
              private backendSelectionService: BackendSelectionService,
              private location: Location, 
              private notifications: NotificationsService) {
                this.sshAuthzServers = new BehaviorSubject<SshAuthzServer[]>([]);
                this.loggedInAuthZ = new BehaviorSubject<SshAuthzServer[]>(null);
                this.loggedOutAuthZ = new BehaviorSubject<SshAuthzServer[]>([]);
                this.backendURI = null;
                this.agentContents = new BehaviorSubject(null);
                this.keys = [];
                this.getSshAuthzServers();
                this.keys = [];
                
    this.backendSelectionService.apiserver.pipe(
      filter((v) => v !== null && v !== undefined),
    )
      .subscribe((value) => { this.backendURI = value.tes }); // Once we have a value for backend, store that value locally

    // Once we have backend server, check what our ssh agent has in it
    this.backendSelectionService.apiserver.pipe(
      filter((v) => v !== null && v !== undefined),
      switchMap((v) => this.updateAgentContents(v.tes)),
    ).subscribe((_) => { return }, (err) => console.error(err));  // An empty subscription is necessary for the observables to fire


    /* Once we have a value for agent Conents, and a list of servers, we can figure out which ones we hav elogged into and which ones we haven't */

    var authZ$: Observable<any>;
    authZ$ = combineLatest([this.agentContents.pipe(filter((v) => v !== null && v !== undefined)),this.sshAuthzServers.pipe(filter((v) => v !== null && v !== undefined))]).pipe(
      map(([agentContents,authzServers]) => { return this.updateLoggedAuthZ(agentContents,authzServers)}),
      catchError((e) => { console.error('errort getting values for logged in and out',e); return throwError(e) })
    );
    authZ$.subscribe(([loggedin,loggedout]) => { this.loggedInAuthZ.next(loggedin); this.loggedOutAuthZ.next(loggedout);  })
    this.loggedInAuthZ$ = authZ$[0];
    this.loggedOutAuthZ$ = authZ$[1];
 }


 storeLocalAuthZ(authz: any) {
   try {
     localStorage.setItem('localauthservers',JSON.stringify(authz));
   } catch {
   }
   this.getSshAuthzServers();
 }

 removeLocalAuthZ() {
   localStorage.removeItem('localauthservers');
   this.getSshAuthzServers();
 }

 getSshAuthzServers() {
   let headers = new HttpHeaders();
   let options = { headers: headers, withCredentials: false};
   this.http.get<SshAuthzServer[]>('./assets/config/authservers.json',options)
                    .pipe(catchError(this.handleError('getSshAuthzServers')))
                    .subscribe(resp => this.updateSshAuthzServers(resp));
 }

 private updateLoggedAuthZ(agentContents,authzServers) {
     let loggedin = []
     let loggedout = []
     var found: boolean;
     if (agentContents == null) {
       return
     }
     for (let s of authzServers) {
         found=false;
         for (let cert of agentContents) {
           if ('Signing CA' in cert) {
             for (let ca of cert['Signing CA']) {
               if (ca.indexOf(s.cafingerprint) != -1) {
                 loggedin.push(s)
                 found=true;
                 continue;
               }
             }
           }
           if (found) {
               continue;
           }
         }
         if (!found)  {
           loggedout.push(s)
         }
     }
     return [loggedin, loggedout]
 }
        

 updateSshAuthzServers(resp) {
   var auths: SshAuthzServer[];
   var localauths: SshAuthzServer[] = [];
   var server: SshAuthzServer;
   auths = <SshAuthzServer[]>resp;
   try {
       localauths = JSON.parse(localStorage.getItem('localauthservers'))
   } catch {
       localauths = []
   }
   if (localauths !== null) {
       for (server of localauths) {
           auths.push(server);
       }
   }
   this.sshAuthzServers.next(auths);
 }

public getKeys(id?: Identity) {
  try{
    return JSON.parse(sessionStorage.getItem('keys'));
  } catch {
    return [];
  }
}

    /* makeKeyCert(key: string, resp, sshauthzservice: SshAuthzServer) {
   let keyCert = new KeyCert()
   keyCert.key = key;
   keyCert.cert = resp['cert'];
   var keys: KeyCert[] = [];
   try{
     keys = JSON.parse(sessionStorage.getItem('keys'));
   } catch {
     keys = [];
   }
   if (keys === null) {
     keys = [];
   }
   keys.push(keyCert);
   sessionStorage.setItem('keys',JSON.stringify(keys))
   // this.tesService.keyCert.next(keyCert);
   // As soon as the certificate has been generated, we log back out of the signing server
   if (!(sshauthzservice.logout === null)) {
     window.open(sshauthzservice.logout);
   }
   let path=sessionStorage.getItem('path');
   //skip1 because loggedInAuthZ is a behaviour subject and we don't want the current value but the value
   this.loggedInAuthZ.pipe(skip(1),take(1)).subscribe( () => {this.readyToNavigate.next([true,path])});
   this.sshAdd(keyCert);
   // only navigate once the agent contents has been refreshed
 }*/

 public querySshAgentError(error: any) {
   this.agentContents.next([]);
   if (error.status == 0) {
     this.notifications.notify("A network error occured. Are you connected to the internet?")
   }
   this.notifications.notify("Error querying ssh agent");
 }

  public updateAgentContents(apiserver?: string): Observable<any> {
    /* Query ssh agent running on the apiserver 
     * Tap the even stream to update the notifications 
     */
   console.log('updateAgentContents called');
   if (apiserver === undefined) {
     if (this.backendURI == null) {
       throwError('no backend to query');
     } else {
       apiserver = this.backendURI
     }
   }
   console.log('updateAgentContents api server',apiserver);

   let headers = new HttpHeaders();
   let options = { headers: headers, withCredentials: true};
   var anyvar: any;
   let agentquery$ = this.http.get<any>(apiserver+'/sshagent',options)
   let agentpipe$ = agentquery$.pipe(
     tap((_) => this.notifications.notify("Updating the list of available accounts")),
     catchError((e) => { this.querySshAgentError(e); return of([])}),
     tap((resp) => { console.log('agent contents',resp) }),
     tap((resp) => { console.log('agent contents',resp) }),
     switchMap((resp) => of(this.addExpiryField(resp))),
     tap((resp) => { 
       if (this.agentContents.value !== null && this.agentContents.value.length > resp.length) {
         this.notifications.notify("Your login expired. Please login again");
       } else {
         this.notifications.notify("");
       };
       this.agentContents.next(resp)
     }),
     catchError((e) => { console.error('updateAGentContents error',e) ; return of([])})
     //tap((_) => this.notifications.notify(""))
   )
   return agentpipe$
 }

 private addExpiryField(resp): any[] {
  var res: any[]
  res = []
  for (let id of resp) {
    var validstr: String;
    validstr = id.Valid[0];
    id.expiry = Date.parse(validstr.split(" ")[3]+"Z")
    res.push(id);
  }
  return res
 }

 private killAgent() {
   this.notifications.notify("Logging out")
   let headers = new HttpHeaders();
   let options = { headers: headers, withCredentials: true};
   var anyvar: any;
   this.http.delete<any>(this.backendURI+'/sshagent',options)
     .pipe(
       catchError(this.handleError(anyvar)),
       switchMap((v) => this.updateAgentContents()))
     .subscribe((v) => {}, (error) => this.httperror(error));
 }

 public logout(): Boolean {
   this.killAgent();
   return true;
 }

 public login(authservice: SshAuthzServer) {
   let redirect_uri = window.location.origin+this.locationStrategy.getBaseHref()+"sshauthz_callback";
   let nonce=Math.random().toString(36).substring(2, 15)

   sessionStorage.setItem('authservice', JSON.stringify([authservice,nonce]));
   sessionStorage.setItem('path', '/launch');
   if (authservice.scope == null) {
     window.location.assign(authservice.authorise+"?response_type=token&redirect_uri="+redirect_uri+"&state="+nonce+"&client_id="+authservice.client_id);
   } else {
     window.location.assign(authservice.authorise+"?response_type=token&redirect_uri="+redirect_uri+"&state="+nonce+"&client_id="+authservice.client_id+"&scope="+authservice.scope);
   }
 }

 private httperror(error: any) {
   this.notifications.notify('There was an error logging in or generating crypto tokens');
   console.error(error);
 }

 private handleError<T> (result?: T) {
   return (error: any): Observable<T> => {
     if (error.status == 500) {
       return throwError("The backend server encountered and error. Please try again in a few minutes")
     }
     return throwError(error.message);
     // return of(result as T);
   };
 }
}