Added: Alembic for migrations

Moving from Pyramid to FastAPI

bookie/src/app/auth/auth.service.ts

@@ -1,64 +1,97 @@
 import { Injectable } from '@angular/core';
-import { HttpClient, HttpHeaders } from '@angular/common/http';
-import { Observable } from 'rxjs/internal/Observable';
-import { catchError, map, tap } from 'rxjs/operators';
-import { ErrorLoggerService } from '../core/error-logger.service';
+import { HttpClient } from '@angular/common/http';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+
 import { User } from '../core/user';
-import { merge, Subject } from 'rxjs';
+import { environment } from '../../environments/environment';
 
+const loginUrl = '/token';
+const refreshUrl = '/refresh';
+const JWT_USER = 'JWT_USER';
 
-const httpOptions = {
-  headers: new HttpHeaders({'Content-Type': 'application/json'})
-};
-
-const loginUrl = '/v1/login';
-const logoutUrl = '/logout';
-const checkUrl = '/v1/auth';
-
-@Injectable({
-  providedIn: 'root'
-})
+@Injectable({providedIn: 'root'})
 export class AuthService {
-  private readonly userSubject: Subject<User>;
-  private user: User;
-  public userObservable: Observable<User>;
-  constructor(private http: HttpClient, private log: ErrorLoggerService) {
-    this.userSubject = new Subject<User>();
-    this.userObservable = merge(this.checkObserver(), this.userSubject).pipe(
-      tap(x => this.user = x)
-    );
+  private currentUserSubject: BehaviorSubject<User>;
+  public currentUser: Observable<User>;
+
+  constructor(private http: HttpClient) {
+    this.currentUserSubject = new BehaviorSubject<User>(JSON.parse(localStorage.getItem(JWT_USER)));
+    this.currentUser = this.currentUserSubject.asObservable();
   }
 
-  checkObserver(): Observable<User> {
-    return <Observable<User>>this.http.get<User>(checkUrl, httpOptions);
-  }
-
-  login(name: string, password: string, otp?: string, clientName?: string): Observable<any> {
-    const data = {name: name, password: password};
-    if (otp) {
-      data['otp'] = otp;
+  public get user(): User {
+    const val = this.currentUserSubject.value;
+    if (val == null) {
+      return val;
     }
-
-    if (clientName) {
-      data['clientName'] = clientName;
+    const expired = Date.now() > val.exp * 1000;
+    if (expired) {
+      this.logout();
+      return null;
+    } else {
+      return this.currentUserSubject.value;
     }
-
-    return this.http.post(loginUrl, data, httpOptions)
-      .pipe(
-        tap((user: User) => this.userSubject.next(user)),
-        catchError(this.log.handleError('AuthService', 'login'))
-      );
   }
 
-  logout(): Observable<boolean> {
-    return <Observable<boolean>>this.http.post<User>(logoutUrl, {}, httpOptions)
-      .pipe(
-        tap((user: User) => this.userSubject.next(user)),
-        map(() => true)
-      );
+  login(username: string, password: string, otp: string) {
+    const formData: FormData = new FormData();
+    formData.append('username', username);
+    formData.append('password', password);
+    formData.append('otp', otp);
+    formData.append('grant_type', 'password');
+    return this.http.post<any>(loginUrl, formData)
+      .pipe(map(u => u.access_token))
+      .pipe(map(u => this.parseJwt(u)))
+      .pipe(map(user => {
+        // store user details and jwt token in local storage to keep user logged in between page refreshes
+        localStorage.setItem(JWT_USER, JSON.stringify(user));
+        this.currentUserSubject.next(user);
+        return user;
+      }));
   }
 
-  hasPermission(permission: string): boolean {
-    return this.user !== undefined && this.user.isAuthenticated && this.user.perms.indexOf(permission) !== -1;
+  parseJwt(token): User {
+    const base64Url = token.split('.')[1];
+    const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
+    const jsonPayload = decodeURIComponent(atob(base64).split('').map(function (c) {
+      return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
+    }).join(''));
+
+    const decoded = JSON.parse(jsonPayload);
+    return new User({
+      id: decoded.userId,
+      name: decoded.sub,
+      lockedOut: decoded.lockedOut,
+      perms: decoded.scopes,
+      access_token: token,
+      exp: decoded.exp
+    });
+  }
+
+  needsRefreshing(): boolean {
+    return Date.now() > (this.user.exp - (environment.ACCESS_TOKEN_REFRESH_MINUTES * 60)) * 1000;
+  }
+
+  expired(): boolean {
+    return Date.now() > this.user.exp * 1000;
+  }
+
+  logout() {
+    // remove user from local storage to log user out
+    localStorage.removeItem(JWT_USER);
+    this.currentUserSubject.next(null);
+  }
+
+  refreshToken() {
+    return this.http.post<any>(refreshUrl, {})
+      .pipe(map(u => u.access_token))
+      .pipe(map(u => this.parseJwt(u)))
+      .pipe(map(user => {
+        // store user details and jwt token in local storage to keep user logged in between page refreshes
+        localStorage.setItem(JWT_USER, JSON.stringify(user));
+        this.currentUserSubject.next(user);
+        return user;
+      }));
   }
 }