fix PR issues

Author: tsvetkovv

src/_constants/unions.ts

@@ -2,7 +2,8 @@ import {InjectionToken} from '@angular/core';
 
 export const unions: UnionMap = {
   mydata: {key: 'mydata', name: 'My Data', url: 'https://mydata.webtree.org/applyToken'},
-  imprint: {key: 'imprint', name: 'Imprint', url: 'https://imprint.webtree.org/applyToken'}
+  imprint: {key: 'imprint', name: 'Imprint', url: 'https://imprint.webtree.org/applyToken'},
+  unions: {key: 'unions', name: 'Unions', url: 'https://unions.webtree.org/!/applyToken'}
 };
 
 export interface Union {

src/_helpers/login.guard.ts

@@ -1,5 +1,5 @@
 import {Injectable} from '@angular/core';
-import {ActivatedRouteSnapshot, CanActivate, RouterStateSnapshot} from '@angular/router';
+import {ActivatedRouteSnapshot, CanActivate} from '@angular/router';
 import {Observable} from 'rxjs';
 import {map} from 'rxjs/operators';
 import {AuthenticationService} from '../_services/authentication.service';
@@ -13,15 +13,16 @@ export class LoginGuard implements CanActivate {
   ) {
   }
 
-  canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean> | boolean {
+  canActivate(route: ActivatedRouteSnapshot): Observable<boolean> | boolean {
     if (!this.tokenService.tokenExists()) {
       return true;
     }
 
     return this.tokenService.isTokenValid().pipe(
       map(isValid => {
-        if (isValid) {
-          return !this.authenticationService.redirectToUnionIfNeeded(route);
+        if (isValid && this.authenticationService.shouldRedirect(route.queryParamMap)) {
+          this.authenticationService.redirect(route.queryParamMap);
+          return true;
         }
         return true;
       })

src/_services/authentication.service.ts

@@ -1,40 +1,40 @@
 import {HttpClient, HttpErrorResponse} from '@angular/common/http';
 import {Inject, Injectable} from '@angular/core';
-import {Observable, of} from 'rxjs';
+import {Observable, throwError} from 'rxjs';
 import {catchError, map} from 'rxjs/operators';
 import {TokenService} from './token.service';
 import {environment} from '../environments/environment';
 import {User} from '../_models/User';
-import {AlertService} from './alert.service';
-import {ActivatedRouteSnapshot} from '@angular/router';
+import {ParamMap} from '@angular/router';
 import {Union, UnionMap, UNIONS_TOKEN} from '../_constants/unions';
 import {DOCUMENT} from '@angular/common';
 
 @Injectable({providedIn: 'root'})
 export class AuthenticationService {
   constructor(private http: HttpClient,
-              private alertService: AlertService,
               private tokenService: TokenService,
               @Inject(UNIONS_TOKEN) private unions: UnionMap,
               @Inject(DOCUMENT) private document: Document,
   ) {
   }
 
-  login(user: User): Observable<string | null> {
+  login(user: User): Observable<Login | null> {
     return this.http.post<{ token: string }>(environment.backendUrl + 'token/new', user)
       .pipe(
         map(res => {
           if ('token' in res) {
-            return res.token;
+            return { token: res.token };
           }
-          return null;
+          throw new Error(`Valid token is not returned. Got: ${res}`);
         }),
-        catchError((error: HttpErrorResponse) => {
-          console.log(error);
-          if (error.status === 401) {
-            this.alertService.error(error.error);
-            return of(null);
+        catchError((error: Error | HttpErrorResponse) => {
+          if ('status' in error) {
+            if (error.status === 401) {
+              return throwError('Invalid username or password');
+            }
+            return throwError(error.message || error.error);
           }
+          return throwError(error);
         })
       );
   }
@@ -43,25 +43,32 @@ export class AuthenticationService {
     this.tokenService.removeToken();
   }
 
-  redirectToUnionIfNeeded(route: ActivatedRouteSnapshot): boolean {
-    const returnUnion = route.queryParamMap.get('returnUnion');
+  shouldRedirect(queryParamMap: ParamMap): boolean {
+    const returnUnion = this.getReturnUnion(queryParamMap);
 
     if (typeof returnUnion === 'string') {
       if (returnUnion in this.unions) {
-        this.redirectToUnion(this.unions[returnUnion]);
         return true;
       } else {
-        this.alertService.error(`Unknown union: ${returnUnion}`);
+        throw new Error(`Unknown union: ${returnUnion}`);
       }
     }
 
     return false;
   }
 
-  redirectToUnion({url}: Union): void {
+  redirect(queryParamMap: ParamMap): void {
+    const returnUnion = this.getReturnUnion(queryParamMap);
+    this.redirectToUnion(this.unions[returnUnion]);
+  }
+
+  redirectToUnion({ url }: Union): void {
     const token = this.tokenService.getToken();
-    const tokenizedUrl = `${url}#token=${token}`;
 
-    this.document.location.href = tokenizedUrl;
+    this.document.location.href = `${url}#token=${token}`;
+  }
+
+  getReturnUnion(queryParamMap: ParamMap): string | null {
+    return queryParamMap.get('returnUnion');
   }
 }

src/_services/user.service.ts

@@ -5,24 +5,19 @@ import {HttpClient, HttpErrorResponse} from '@angular/common/http';
 import {Observable} from 'rxjs/Observable';
 import {environment} from '../environments/environment';
 import {catchError} from 'rxjs/operators';
-import {of, throwError} from 'rxjs';
+import {throwError} from 'rxjs';
 
 @Injectable({providedIn: 'root'})
 export class UserService {
   constructor(private http: HttpClient) {
   }
 
-  create(user: User): Observable<User | null> {
+  create(user: User): Observable<User> {
     const url = environment.backendUrl + 'user/register';
 
     return this.http.post<User | null>(url, user).pipe(
-      catchError((error: HttpErrorResponse) => {
-        console.error(error);
-        if (error.status === 400) {
-          return of(null);
-        } else {
-          return throwError(error);
-        }
+      catchError(({message}: HttpErrorResponse) => {
+          return throwError(`${message}`);
       })
     );
   }

src/login/login.component.ts

@@ -6,6 +6,7 @@ import {FormGroup, FormControl, Validators} from '@angular/forms';
 import {AlertService} from '../_services/alert.service';
 import {AuthenticationService} from '../_services/authentication.service';
 import {TokenService} from '../_services/token.service';
+import {finalize} from 'rxjs/operators';
 
 @Component({
   selector: 'app-login',
@@ -32,19 +33,21 @@ export class LoginComponent {
     this.loading = true;
     const user: User = {username, password: sha512(password)};
     return this.authenticationService.login(user)
-      .subscribe(token => {
-          this.loading = false;
-          if (token === null) {
-            this.alertService.error('Invalid username or password');
-            return;
-          }
-
+      .pipe(finalize(() => {
+        this.loading = false;
+      }))
+      .subscribe(({ token }) => {
           this.tokenService.saveToken(token);
           this.alertService.success('Logged in successfully');
-          if (!this.authenticationService.redirectToUnionIfNeeded(this.route.snapshot)) {
+
+          const queryParamMap = this.route.snapshot.queryParamMap;
+          if (this.authenticationService.shouldRedirect(queryParamMap)) {
+            this.authenticationService.redirect(queryParamMap);
+          } else {
             this.router.navigate(['/select-union']);
           }
-        }
-      );
+        }, (error: string) => {
+          this.alertService.error(error);
+      });
   }
 }

src/register/register.component.html

@@ -1,4 +1,4 @@
-<h2>Login</h2>
+<h2>Register</h2>
 <form [formGroup]="form" (ngSubmit)="onSubmit(form.value)">
   <p>
     <mat-form-field>

src/register/register.component.ts

@@ -4,6 +4,8 @@ import {UserService} from '../_services/user.service';
 import {User} from '../_models/User';
 import {sha512} from 'js-sha512';
 import {FormControl, FormGroup, Validators} from '@angular/forms';
+import {finalize} from 'rxjs/operators';
+import {Router} from '@angular/router';
 
 @Component({
   selector: 'app-register',
@@ -20,21 +22,23 @@ export class RegisterComponent {
   loading = false;
 
   constructor(private userService: UserService,
-              private alertService: AlertService) {
+              private alertService: AlertService,
+              private router: Router) {
   }
 
   onSubmit({username, password}) {
     this.loading = true;
     const user: User = {username, password: sha512(password)};
     this.userService.create(user)
+      .pipe(finalize(() => {
+        this.loading = false;
+      }))
       .subscribe(
-        data => {
-          if (data === null) {
-            this.alertService.error('Registration unsuccessful');
-          } else {
-            this.alertService.success('Registration successful');
-          }
-          // this.router.navigate(['/login']);
+        () => {
+          this.alertService.success('Registration successful');
+          this.router.navigate(['/login']);
+        }, (error: string) => {
+          this.alertService.error(error);
         });
   }
 }