Added first app template

frontend/login-counter/src/app/modules/auth/components/forget-password/forget-password.component.html

@@ -0,0 +1,57 @@
+<section class="login-wrapper">
+    <div class="login-form-wrapper">
+        <div class="login-form">
+            <ng-container *ngIf="resetPasswordId === null; else resetPasswordForm">
+                <form [formGroup]="emailForm">
+                    <h1>{{'auth.header' | translate}}</h1>
+                    <div *ngIf="!ready" class="input-field">
+                        <input type="email" pInputText formControlName="email" placeholder="{{'auth.forgot_password.e_mail' | translate}}"
+                            autocomplete="username email">
+                    </div>
+                    <div *ngIf="ready" class="input-field-info-text">
+                        {{'auth.forgot_password.send_confirmation_url' | translate}}
+                    </div>
+                    <div class="login-form-submit">
+                        <button pButton label="{{'auth.forgot_password.reset_password' | translate}}" class="btn login-form-submit-btn"
+                            (click)="forgotPassword()" [disabled]="emailForm.invalid || ready"></button>
+                    </div>
+
+                    <div class="login-form-sub-button-wrapper">
+                        <div class="login-form-sub-btn-wrapper">
+                            <button pButton label="{{'auth.forgot_password.login' | translate}}" class="btn login-form-sub-btn" (click)="login()"></button>
+                        </div>
+                        <div class="login-form-sub-btn-wrapper">
+                            <button pButton label="{{'auth.forgot_password.register' | translate}}" class="btn login-form-sub-btn"
+                                (click)="register()"></button>
+                        </div>
+                    </div>
+                </form>
+            </ng-container>
+
+            <ng-template #resetPasswordForm>
+                <form [formGroup]="passwordForm">
+                    <h1>{{'auth.header' | translate}}</h1>
+
+                    <div class="input-field">
+                        <input type="password" pInputText formControlName="password" placeholder="{{'auth.forgot_password.password' | translate}}"
+                            autocomplete="new-password">
+                    </div>
+
+                    <div class="input-field">
+                        <input type="password" pInputText formControlName="passwordRepeat"
+                            placeholder="{{'auth.forgot_password.repeat_password' | translate}}"
+                            [ngClass]="{ 'invalid-feedback-input': submitted && repeatErrors.password}">
+                        <div *ngIf="submitted" class="invalid-feedback">
+                            <div *ngIf="repeatErrors.password">{{'auth.forgot_password.passwords_do_not_match' | translate}}</div>
+                        </div>
+                    </div>
+
+                    <div class="login-form-submit">
+                        <button pButton label="{{'auth.forgot_password.reset_password' | translate}}" class="btn login-form-submit-btn"
+                            (click)="resetPassword()" [disabled]="passwordForm.invalid || ready"></button>
+                    </div>
+                </form>
+            </ng-template>
+        </div>
+    </div>
+</section>

frontend/login-counter/src/app/modules/auth/components/forget-password/forget-password.component.spec.ts

@@ -0,0 +1,25 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+
+import { ForgetPasswordComponent } from './forget-password.component';
+
+describe('ForgetPasswordComponent', () => {
+  let component: ForgetPasswordComponent;
+  let fixture: ComponentFixture<ForgetPasswordComponent>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      declarations: [ ForgetPasswordComponent ]
+    })
+    .compileComponents();
+  });
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(ForgetPasswordComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

frontend/login-counter/src/app/modules/auth/components/forget-password/forget-password.component.ts

@@ -0,0 +1,136 @@
+import { Component, OnInit } from '@angular/core';
+import { FormBuilder, FormGroup, Validators } from '@angular/forms';
+import { ActivatedRoute, Router } from '@angular/router';
+import { TranslateService } from '@ngx-translate/core';
+import { catchError } from 'rxjs/operators';
+import { ResetPasswordDTO } from 'src/app/models/auth/reset-password.dto';
+import { AuthService } from 'src/app/services/auth/auth.service';
+import { SpinnerService } from 'src/app/services/spinner/spinner.service';
+import { ToastService } from 'src/app/services/toast/toast.service';
+
+@Component({
+  selector: 'app-forget-password',
+  templateUrl: './forget-password.component.html',
+  styleUrls: ['./forget-password.component.scss']
+})
+export class ForgetPasswordComponent implements OnInit {
+
+  emailForm: FormGroup;
+  passwordForm: FormGroup;
+  submitted = false;
+  ready = false;
+  repeatErrors = {
+    email: false,
+    password: false
+  };
+
+  resetPasswordId: string = null;
+
+  constructor(
+    private authService: AuthService,
+    private formBuilder: FormBuilder,
+    private router: Router,
+    private spinnerService: SpinnerService,
+    private route: ActivatedRoute,
+    private toastService: ToastService,
+    private translate: TranslateService
+  ) { }
+
+  ngOnInit(): void {
+    this.spinnerService.showSpinner();
+    this.authService.isUserLoggedInAsync().then(result => {
+      if (result) {
+        this.router.navigate(['/home']);
+      }
+
+      this.initForms();
+      this.checkResetPasswordId();
+      this.spinnerService.hideSpinner();
+    });
+  }
+
+  initForms(): void {
+    this.emailForm = this.formBuilder.group({
+      email: [null, [Validators.required, Validators.email]]
+    });
+
+    this.passwordForm = this.formBuilder.group({
+      password: [null, [Validators.required, Validators.minLength(8)]],
+      passwordRepeat: [null, [Validators.required, Validators.minLength(8)]]
+    });
+  }
+
+  login(): void {
+    this.router.navigate(['/auth/login']);
+  }
+
+  register(): void {
+    this.router.navigate(['/auth/register']);
+  }
+
+  forgotPassword(): void {
+    this.submitted = true;
+
+    if (this.emailForm.invalid) {
+      return;
+    }
+
+    this.spinnerService.showSpinner();
+    this.authService.forgotPassword(this.emailForm.value.email)
+      .pipe(catchError(err => {
+        this.spinnerService.hideSpinner();
+        throw err;
+      })).subscribe(res => {
+        this.spinnerService.hideSpinner();
+        this.ready = true;
+        setTimeout(() => { this.router.navigate(['/home']); }, 5000);
+      });
+  }
+
+  checkResetPasswordId(): void {
+    const id = this.route.snapshot.params.id;
+    if (id) {
+      this.resetPasswordId = id;
+      this.spinnerService.showSpinner();
+      this.authService.getEMailFromforgotPasswordId(id)
+        .pipe(catchError(err => {
+          this.spinnerService.hideSpinner();
+          this.router.navigate(['/auth/forgot-password']);
+          throw err;
+        })).subscribe(email => {
+          this.spinnerService.hideSpinner();
+          if (email) {
+            this.emailForm.value.email = email;
+          } else {
+            this.router.navigate(['/auth/forgot-password']);
+          }
+        });
+    }
+  }
+
+  resetPassword(): void {
+    const id = this.route.snapshot.params.id;
+    if (this.emailForm.value.password !== this.emailForm.value.passwordRepeat) {
+      this.repeatErrors.password = true;
+      return;
+    }
+    this.spinnerService.showSpinner();
+
+    const resetPasswordDTO: ResetPasswordDTO = {
+      id,
+      password: this.passwordForm.value.password
+    };
+
+    this.authService.resetPassword(resetPasswordDTO)
+      .pipe(catchError(error => {
+        this.router.navigate(['/auth/login']);
+        this.spinnerService.hideSpinner();
+        throw error;
+      }))
+      .subscribe(resp => {
+        this.spinnerService.hideSpinner();
+        this.toastService.success(this.translate.instant('auth.forgot_password.message.reset_password'), this.translate.instant('auth.forgot_password.message.reset_password_d'));
+        this.router.navigate(['/auth/login']);
+      });
+  }
+}

frontend/login-counter/src/app/modules/auth/components/login/login.component.html

@@ -0,0 +1,50 @@
+<section class="login-wrapper">
+    <div class="login-form-wrapper">
+        <div class="login-form">
+            <form [formGroup]="loginForm">
+                <h1>sh-edraft.de</h1>
+                <div class="input-field">
+                    <input type="email" pInputText formControlName="email" placeholder="E-Mail" [ngClass]="{ 'invalid-feedback-input': submitted && (
+                            (loginForm.controls.email.errors && loginForm.controls.email.errors.required || authUserAtrErrors.email.required) ||
+                            (authUserAtrErrors.email.wrongData) ||
+                            (authUserAtrErrors.email.notConfirmed)
+                        )}" autocomplete="username email">
+                    <div *ngIf="submitted" class="invalid-feedback">
+                        <div
+                            *ngIf="loginForm.controls.email.errors && loginForm.controls.email.errors.required || authUserAtrErrors.email.required">
+                            E-Mail wird benötigt</div>
+                        <div *ngIf="authUserAtrErrors.email.wrongData">Benutzer nicht gefunden</div>
+                        <div *ngIf="authUserAtrErrors.email.notConfirmed">E-Mail wurde nicht bestätigt</div>
+                    </div>
+                </div>
+                <div class="input-field">
+                    <p-password type="password" formControlName="password" placeholder="Passwort" [ngClass]="{ 'invalid-feedback-input': submitted && (
+                            (loginForm.controls.password.errors && loginForm.controls.password.errors.required || authUserAtrErrors.password.required) ||
+                            (authUserAtrErrors.password.wrongData)
+                        )}" autocomplete="current-password" [toggleMask]="true" [feedback]="false"></p-password>
+                    <div *ngIf="submitted" class="invalid-feedback">
+                        <div
+                            *ngIf="loginForm.controls.password.errors && loginForm.controls.password.errors.required || authUserAtrErrors.password.required">
+                            Password wird benötigt</div>
+                        <div *ngIf="authUserAtrErrors.password.wrongData">Falsches passwort</div>
+                    </div>
+                </div>
+                <div class="login-form-submit">
+                    <button pButton label="Anmelden" class="btn login-form-submit-btn" (click)="login()"
+                        [disabled]="loginForm.invalid"></button>
+                </div>
+                <div class="login-form-sub-button-wrapper">
+                    <div class="login-form-sub-btn-wrapper">
+                        <button pButton label="Registrieren" class="btn login-form-sub-btn"
+                            (click)="register()"></button>
+                    </div>
+                    <div class="login-form-sub-btn-wrapper">
+                        <button pButton label="Passwort vergessen?"
+                            class="btn login-form-sub-btn login-form-sub-login-btn p-button-text"
+                            (click)="forgotPassword()"></button>
+                    </div>
+                </div>
+            </form>
+        </div>
+    </div>
+</section>

frontend/login-counter/src/app/modules/auth/components/login/login.component.spec.ts

@@ -0,0 +1,25 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+
+import { LoginComponent } from './login.component';
+
+describe('LoginComponent', () => {
+  let component: LoginComponent;
+  let fixture: ComponentFixture<LoginComponent>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      declarations: [ LoginComponent ]
+    })
+    .compileComponents();
+  });
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(LoginComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

frontend/login-counter/src/app/modules/auth/components/login/login.component.ts

@@ -0,0 +1,111 @@
+import { Component, OnInit } from '@angular/core';
+import { FormBuilder, FormGroup, Validators } from '@angular/forms';
+import { AuthService } from 'src/app/services/auth/auth.service';
+import { AuthUserDTO } from 'src/app/models/auth/auth-user.dto';
+import { Router } from '@angular/router';
+import { catchError } from 'rxjs/operators';
+import { ErrorDTO } from 'src/app/models/error/error-dto';
+import { AuthErrorMessages } from 'src/app/models/auth/auth-error-messages.enum';
+import { ServiceErrorCode } from 'src/app/models/error/service-error-code.enum';
+import { AuthUserAtrErrors } from 'src/app/models/auth/auth-user-atr-errors';
+import { SpinnerService } from 'src/app/services/spinner/spinner.service';
+import { ThemeService } from 'src/app/services/theme/theme.service';
+
+@Component({
+  selector: 'app-login',
+  templateUrl: './login.component.html',
+  styleUrls: ['./login.component.scss']
+})
+export class LoginComponent implements OnInit {
+
+  loginForm: FormGroup;
+  submitted = false;
+
+  authUserAtrErrors: AuthUserAtrErrors;
+
+  constructor(
+    private authService: AuthService,
+    private formBuilder: FormBuilder,
+    private router: Router,
+    private spinnerService: SpinnerService,
+    private themeService: ThemeService
+  ) { }
+
+  ngOnInit(): void {
+    this.spinnerService.showSpinner();
+    this.authService.isUserLoggedInAsync().then(result => {
+      if (result) {
+        this.router.navigate(['/home']);
+      }
+
+      this.initLoginForm();
+      this.resetStateFlags();
+      this.spinnerService.hideSpinner();
+    });
+  }
+
+  resetStateFlags(): void {
+    this.authUserAtrErrors = new AuthUserAtrErrors();
+  }
+
+  initLoginForm(): void {
+    this.loginForm = this.formBuilder.group({
+      email: [null, [Validators.required, Validators.email]],
+      password: [null, [Validators.required, Validators.minLength(8)]]
+    });
+  }
+
+  register(): void {
+    this.router.navigate(['/auth/register']);
+  }
+
+  forgotPassword(): void {
+    this.router.navigate(['/auth/forgot-password']);
+  }
+
+  login(): void {
+    this.submitted = true;
+    this.resetStateFlags();
+
+    if (this.loginForm.invalid) {
+      return;
+    }
+
+    this.spinnerService.showSpinner();
+    const user: AuthUserDTO = {
+      firstName: '',
+      lastName: '',
+      eMail: this.loginForm.value.email,
+      password: this.loginForm.value.password
+    };
+
+    this.authService.login(user)
+      .pipe(catchError(error => {
+        if (error.error !== null) {
+          const err: ErrorDTO = error.error;
+
+          if (err.errorCode === ServiceErrorCode.InvalidData && err.message === AuthErrorMessages.UserIsEmpty) {
+            this.authUserAtrErrors.email.required = true;
+            this.authUserAtrErrors.password.required = true;
+          } else if (err.errorCode === ServiceErrorCode.InvalidUser && err.message === AuthErrorMessages.UserNotFound) {
+            this.authUserAtrErrors.email.wrongData = true;
+          } else if (err.errorCode === ServiceErrorCode.InvalidUser && err.message === AuthErrorMessages.WrongPassword) {
+            this.authUserAtrErrors.password.wrongData = true;
+          } else if (err.errorCode === ServiceErrorCode.InvalidUser && err.message === AuthErrorMessages.EMailNotConfirmed) {
+            this.authUserAtrErrors.email.notConfirmed = true;
+          }
+          error.error = null;
+        }
+        this.spinnerService.hideSpinner();
+        throw error;
+      }))
+      .subscribe(token => {
+        this.authService.saveToken(token);
+        this.themeService.loadTheme();
+        this.themeService.loadMenu();
+        this.spinnerService.hideSpinner();
+        this.router.navigate(['/home']);
+      });
+  }
+
+}

frontend/login-counter/src/app/modules/auth/components/registration/registration.component.html

@@ -0,0 +1,81 @@
+<section class="login-wrapper">
+    <div class="login-form-wrapper register-form-wrapper">
+        <div class="login-form">
+            <form [formGroup]="loginForm">
+                <h1>sh-edraft.de</h1>
+                <div class="input-field">
+                    <input type="text" pInputText formControlName="firstName" placeholder="Vorname"
+                        autocomplete="given-name">
+                    <div *ngIf="submitted" class="invalid-feedback">
+                        <div
+                            *ngIf="loginForm.controls.firstName.errors && loginForm.controls.firstName.errors.required || authUserAtrErrors.firstName.required">
+                            Vorname wird benötigt</div>
+                        <div *ngIf="authUserAtrErrors.firstName.wrongData">Vorname ist ungültig</div>
+                    </div>
+                </div>
+
+                <div class="input-field">
+                    <input type="text" pInputText formControlName="lastName" placeholder="Nachname"
+                        autocomplete="family-name">
+                    <div *ngIf="submitted" class="invalid-feedback">
+                        <div
+                            *ngIf="loginForm.controls.lastName.errors && loginForm.controls.lastName.errors.required || authUserAtrErrors.lastName.required">
+                            Nachname wird benötigt</div>
+                        <div *ngIf="authUserAtrErrors.lastName.wrongData">Nachname ist ungültig</div>
+                    </div>
+                </div>
+
+                <div class="input-field">
+                    <input type="email" pInputText formControlName="email" placeholder="E-Mail"
+                        [ngClass]="{ 'invalid-feedback-input': submitted && (authUserAtrErrors.email.wrongData || loginForm.controls.email.errors && loginForm.controls.email.errors.required || authUserAtrErrors.email.required)}"
+                        autocomplete="username email">
+                    <div *ngIf="submitted" class="invalid-feedback">
+                        <div
+                            *ngIf="loginForm.controls.email.errors && loginForm.controls.email.errors.required || authUserAtrErrors.email.required">
+                            E-Mail wird benötigt</div>
+                        <div *ngIf="authUserAtrErrors.email.wrongData">Benutzer existiert bereits</div>
+                    </div>
+                </div>
+
+                <div class="input-field">
+                    <input type="email" pInputText formControlName="emailRepeat" placeholder="E-Mail wiederholen"
+                        [ngClass]="{ 'invalid-feedback-input': submitted && repeatErrors.email}">
+                    <div *ngIf="submitted" class="invalid-feedback">
+                        <div *ngIf="repeatErrors.email">Die E-Mails stimmen nicht überein</div>
+                    </div>
+                </div>
+
+                <div class="input-field">
+                    <p-password type="password" formControlName="password" placeholder="Passwort"
+                        ngClass="{ 'invalid-feedback': submitted && loginForm.controls.password.errors && loginForm.controls.password.errors.required || authUserAtrErrors.password.required}"
+                        autocomplete="new-password" [toggleMask]="true" [feedback]="false"></p-password>
+                    <div *ngIf="submitted" class="invalid-feedback">
+                        <div
+                            *ngIf="loginForm.controls.password.errors && loginForm.controls.password.errors.required || authUserAtrErrors.password.required">
+                            Password wird benötigt</div>
+                    </div>
+                </div>
+
+                <div class="input-field">
+                    <p-password type="password" formControlName="passwordRepeat"
+                        placeholder="Passwort wiederholen"
+                        [ngClass]="{ 'invalid-feedback-input': submitted && repeatErrors.password}" [toggleMask]="true" [feedback]="false"></p-password>
+                    <div *ngIf="submitted" class="invalid-feedback">
+                        <div *ngIf="repeatErrors.password">Die Passwörter stimmen nicht überein</div>
+                    </div>
+                </div>
+
+                <div class="login-form-submit">
+                    <button pButton label="Registrieren" class="btn login-form-submit-btn" (click)="register()"
+                        [disabled]="loginForm.invalid"></button>
+                </div>
+
+                <div class="login-form-sub-button-wrapper">
+                    <div class="login-form-sub-btn-wrapper">
+                        <button pButton label="Einloggen" class="btn login-form-sub-btn" (click)="login()"></button>
+                    </div>
+                </div>
+            </form>
+        </div>
+    </div>
+</section>

frontend/login-counter/src/app/modules/auth/components/registration/registration.component.spec.ts

@@ -0,0 +1,25 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+
+import { RegistrationComponent } from './registration.component';
+
+describe('RegistrationComponent', () => {
+  let component: RegistrationComponent;
+  let fixture: ComponentFixture<RegistrationComponent>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      declarations: [ RegistrationComponent ]
+    })
+    .compileComponents();
+  });
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(RegistrationComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

frontend/login-counter/src/app/modules/auth/components/registration/registration.component.ts

@@ -0,0 +1,137 @@
+import { Component, OnInit } from '@angular/core';
+import { FormBuilder, FormGroup, Validators } from '@angular/forms';
+import { ActivatedRoute, Router } from '@angular/router';
+import { catchError } from 'rxjs/operators';
+import { AuthErrorMessages } from 'src/app/models/auth/auth-error-messages.enum';
+import { AuthUserDTO } from 'src/app/models/auth/auth-user.dto';
+import { AuthUserAtrErrors } from 'src/app/models/auth/auth-user-atr-errors';
+import { ErrorDTO } from 'src/app/models/error/error-dto';
+import { ServiceErrorCode } from 'src/app/models/error/service-error-code.enum';
+import { AuthService } from 'src/app/services/auth/auth.service';
+import { SpinnerService } from 'src/app/services/spinner/spinner.service';
+
+@Component({
+  selector: 'app-registration',
+  templateUrl: './registration.component.html',
+  styleUrls: ['./registration.component.scss']
+})
+export class RegistrationComponent implements OnInit {
+
+  loginForm: FormGroup;
+  submitted = false;
+  authUserAtrErrors: AuthUserAtrErrors;
+  repeatErrors = {
+    email: false,
+    password: false
+  };
+
+  showEMailConfirmation = false;
+  showEMailConfirmationError = false;
+
+  constructor(
+    private authService: AuthService,
+    private formBuilder: FormBuilder,
+    private router: Router,
+    private spinnerService: SpinnerService,
+    private route: ActivatedRoute
+  ) {
+    this.spinnerService.showSpinner();
+    this.authService.isUserLoggedInAsync().then(res => {
+      if (res) {
+        this.router.navigate(['/home']);
+      }
+      this.spinnerService.hideSpinner();
+    });
+  }
+
+  ngOnInit(): void {
+    this.initLoginForm();
+    this.resetStateFlags();
+    this.confirmEMail();
+  }
+
+  resetStateFlags(): void {
+    this.authUserAtrErrors = new AuthUserAtrErrors();
+    this.repeatErrors = {
+      email: false,
+      password: false
+    };
+  }
+
+  login(): void {
+    this.router.navigate(['/auth/login']);
+  }
+
+  initLoginForm(): void {
+    this.loginForm = this.formBuilder.group({
+      firstName: [null, Validators.required],
+      lastName: [null, Validators.required],
+      email: [null, [Validators.required, Validators.email]],
+      emailRepeat: [null, [Validators.required, Validators.email]],
+      password: [null, [Validators.required, Validators.minLength(8)]],
+      passwordRepeat: [null, [Validators.required, Validators.minLength(8)]]
+    });
+  }
+
+  register(): void {
+    this.submitted = true;
+    this.resetStateFlags();
+
+    // stop here if form is invalid
+    if (this.loginForm.invalid) {
+      return;
+    }
+
+    if (this.loginForm.value.email !== this.loginForm.value.emailRepeat) {
+      this.repeatErrors.email = true;
+      return;
+    }
+
+    if (this.loginForm.value.password !== this.loginForm.value.passwordRepeat) {
+      this.repeatErrors.password = true;
+      return;
+    }
+
+    this.spinnerService.showSpinner();
+    const user: AuthUserDTO = {
+      firstName: this.loginForm.value.firstName,
+      lastName: this.loginForm.value.lastName,
+      eMail: this.loginForm.value.email,
+      password: this.loginForm.value.password
+    };
+
+    this.authService.register(user)
+      .pipe(catchError(error => {
+        if (error.error !== null) {
+          const err: ErrorDTO = error.error;
+
+          if (err.errorCode === ServiceErrorCode.InvalidUser && err.message === AuthErrorMessages.UserAlreadyExists) {
+            this.authUserAtrErrors.email.wrongData = true;
+          }
+        }
+        this.spinnerService.hideSpinner();
+        throw error;
+      }))
+      .subscribe(resp => {
+        this.spinnerService.hideSpinner();
+        this.router.navigate(['/auth/login']);
+      });
+  }
+
+  confirmEMail(): void {
+    const id = this.route.snapshot.params.id;
+    if (id) {
+      this.spinnerService.showSpinner();
+      this.authService.confirmEMail(id)
+        .pipe(catchError(error => {
+          this.router.navigate(['/auth/login']);
+          this.spinnerService.hideSpinner();
+          throw error;
+        }))
+        .subscribe(resp => {
+          this.spinnerService.hideSpinner();
+          this.router.navigate(['/auth/login']);
+        });
+    }
+  }
+}