adding dashboard playground

frontend/src/app/api/fn/authentication/refresh-token.ts

@@ -0,0 +1,32 @@
+/* tslint:disable */
+/* eslint-disable */
+import { HttpClient, HttpContext, HttpResponse } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { filter, map } from 'rxjs/operators';
+import { StrictHttpResponse } from '../../strict-http-response';
+import { RequestBuilder } from '../../request-builder';
+
+import { AuthenticationResponse } from '../../models/authentication-response';
+import { RefreshTokenRequest } from '../../models/refresh-token-request';
+
+export interface RefreshToken$Params {
+      body: RefreshTokenRequest
+}
+
+export function refreshToken(http: HttpClient, rootUrl: string, params: RefreshToken$Params, context?: HttpContext): Observable<StrictHttpResponse<AuthenticationResponse>> {
+  const rb = new RequestBuilder(rootUrl, refreshToken.PATH, 'post');
+  if (params) {
+    rb.body(params.body, 'application/json');
+  }
+
+  return http.request(
+    rb.build({ responseType: 'json', accept: 'application/json', context })
+  ).pipe(
+    filter((r: any): r is HttpResponse<any> => r instanceof HttpResponse),
+    map((r: HttpResponse<any>) => {
+      return r as StrictHttpResponse<AuthenticationResponse>;
+    })
+  );
+}
+
+refreshToken.PATH = '/auth/refresh-token';

frontend/src/app/api/models.ts

@@ -17,5 +17,6 @@ export { MembersStatsResponse } from './models/members-stats-response';
 export { PointCaptureRequest } from './models/point-capture-request';
 export { PointCaptureResponse } from './models/point-capture-response';
 export { PointsCaptureAllResponse } from './models/points-capture-all-response';
+export { RefreshTokenRequest } from './models/refresh-token-request';
 export { RegisterRequest } from './models/register-request';
 export { ResetPasswordRequest } from './models/reset-password-request';

frontend/src/app/api/models/authentication-response.ts

@@ -1,5 +1,6 @@
 /* tslint:disable */
 /* eslint-disable */
 export interface AuthenticationResponse {
-  token?: string;
+  access_token?: string;
+  refresh_token?: string;
 }

frontend/src/app/api/models/refresh-token-request.ts

@@ -0,0 +1,6 @@
+/* tslint:disable */
+/* eslint-disable */
+export interface RefreshTokenRequest {
+  accessToken?: string;
+  refreshToken?: string;
+}

frontend/src/app/api/services/authentication.service.ts

@@ -30,6 +30,8 @@ import { logout5 } from '../fn/authentication/logout-5';
 import { Logout5$Params } from '../fn/authentication/logout-5';
 import { logout6 } from '../fn/authentication/logout-6';
 import { Logout6$Params } from '../fn/authentication/logout-6';
+import { refreshToken } from '../fn/authentication/refresh-token';
+import { RefreshToken$Params } from '../fn/authentication/refresh-token';
 import { register } from '../fn/authentication/register';
 import { Register$Params } from '../fn/authentication/register';
 import { resendActivationEmail } from '../fn/authentication/resend-activation-email';
@@ -113,6 +115,31 @@ export class AuthenticationService extends BaseService {
     );
   }
 
+  /** Path part for operation `refreshToken()` */
+  static readonly RefreshTokenPath = '/auth/refresh-token';
+
+  /**
+   * This method provides access to the full `HttpResponse`, allowing access to response headers.
+   * To access only the response body, use `refreshToken()` instead.
+   *
+   * This method sends `application/json` and handles request body of type `application/json`.
+   */
+  refreshToken$Response(params: RefreshToken$Params, context?: HttpContext): Observable<StrictHttpResponse<AuthenticationResponse>> {
+    return refreshToken(this.http, this.rootUrl, params, context);
+  }
+
+  /**
+   * This method provides access only to the response body.
+   * To access the full response (for headers, for example), `refreshToken$Response()` instead.
+   *
+   * This method sends `application/json` and handles request body of type `application/json`.
+   */
+  refreshToken(params: RefreshToken$Params, context?: HttpContext): Observable<AuthenticationResponse> {
+    return this.refreshToken$Response(params, context).pipe(
+      map((r: StrictHttpResponse<AuthenticationResponse>): AuthenticationResponse => r.body)
+    );
+  }
+
   /** Path part for operation `authenticate()` */
   static readonly AuthenticatePath = '/auth/authenticate';
 

frontend/src/app/app.component.spec.ts

@@ -27,3 +27,11 @@ describe('AppComponent', () => {
     expect(compiled.querySelector('.content span')?.textContent).toContain('frontend app is running!');
   });
 });
+
+
+
+
+
+
+
+

frontend/src/app/core/interceptors/auth.interceptor.ts

@@ -3,16 +3,20 @@ import {
   HttpRequest,
   HttpHandler,
   HttpEvent,
-  HttpInterceptor
+  HttpInterceptor,
+  HttpErrorResponse
 } from '@angular/common/http';
 import { HTTP_INTERCEPTORS } from '@angular/common/http';
-import { Observable } from 'rxjs';
+import { catchError, Observable } from 'rxjs';
 import { JwtTokenService } from '../services/jwt-token.service';
+import { RefreshTokenService } from '../services/refresh-token.service';
+import { refreshToken } from 'app/api/fn/authentication/refresh-token';
+import { from } from 'rxjs';
 
 @Injectable()
 export class AuthInterceptor implements HttpInterceptor {
 
-  constructor(private jwtTokenService: JwtTokenService) {}
+  constructor(private jwtTokenService: JwtTokenService, private refreshTokenService: RefreshTokenService) {}
 
   intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>> {
     request = request.clone({
@@ -22,8 +26,11 @@ export class AuthInterceptor implements HttpInterceptor {
     });
     return next.handle(request);
   }
+
 }
 
+
+
 export const authInterceptorProvider = {
   provide: HTTP_INTERCEPTORS,
   useClass: AuthInterceptor,

frontend/src/app/core/interceptors/refresh.interceptor.ts

@@ -0,0 +1,68 @@
+import { Injectable } from '@angular/core';
+import {
+  HttpRequest,
+  HttpHandler,
+  HttpEvent,
+  HttpInterceptor,
+  HttpErrorResponse,
+  HttpClient
+} from '@angular/common/http';
+import { HTTP_INTERCEPTORS } from '@angular/common/http';
+import { catchError, Observable, switchMap } from 'rxjs';
+import { JwtTokenService } from '../services/jwt-token.service';
+import { RefreshTokenService } from '../services/refresh-token.service';
+import { refreshToken } from 'app/api/fn/authentication/refresh-token';
+import { from } from 'rxjs';
+import { environment } from 'app/core/environments/environment';
+
+
+@Injectable()
+export class RefreshInterceptor implements HttpInterceptor {
+
+  constructor(private refreshTokenService: RefreshTokenService, private jwtTokenService: JwtTokenService, private http: HttpClient) {}
+
+  intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>> {
+    return next.handle(request).pipe(
+        catchError((error: HttpErrorResponse) => {
+            if (error.status === 401 || error.status === 403) {
+                const params = {
+                    body: {
+                        access_token: this.jwtTokenService.token,
+                        refresh_token: this.refreshTokenService.token
+                    }
+                }
+
+                return this.http.post(`${environment.apiBaseUrl}/auth/refresh-token`, params).pipe(
+                    switchMap((response: any) => {
+                        this.jwtTokenService.token = response.access_token!;
+                        this.refreshTokenService.token = response.refresh_token!;
+                        request = request.clone({
+                            setHeaders: {
+                                Authorization: `Bearer ${response.access_token}`
+                            }
+                        });
+                        return next.handle(request);
+                    }),
+                    catchError((error: HttpErrorResponse) => {
+                        this.refreshTokenService.removeToken();
+                        return from(Promise.reject(error));
+                    })
+                );
+            }else {
+                return from(Promise.reject(error));
+            }
+        }
+
+
+    ));
+  }
+
+}
+
+
+
+export const refreshInterceptorProvider = {
+  provide: HTTP_INTERCEPTORS,
+  useClass: RefreshInterceptor,
+  multi: true
+}

frontend/src/app/core/routeguards/auth.routeguards.ts

@@ -14,7 +14,7 @@ export class AuthActivateRouteGuard implements CanActivate {
   canActivate(route:ActivatedRouteSnapshot, state:RouterStateSnapshot)
   : boolean | Promise<boolean> {
     // @ts-ignore
-    this.token = localStorage.getItem("token");
+    this.token = localStorage.getItem("access_token");
     if(!this.token){
       console.log("User not authenticated");
       this.router.navigate(['/auth/authenticate']);

frontend/src/app/core/services/jwt-token.service.ts

@@ -10,15 +10,15 @@ export class JwtTokenService {
   constructor() { }
 
   set token(token: string) {
-    localStorage.setItem('token', token);
+    localStorage.setItem('access_token', token);
   }
 
   get token() {
-    return localStorage.getItem('token') as string;
+    return localStorage.getItem('access_token') as string;
   }
 
   removeToken(): void {
-    localStorage.removeItem('token');
+    localStorage.removeItem('access_token');
   }
 
   isTokenExist(): boolean {
@@ -32,7 +32,6 @@ export class JwtTokenService {
   getActiveUser(): User {
     const data = Object.entries(this.getPayload()).map(([key, value]) => value);
     let [fullName, email, iat, exp, authorities]: Array<string|Array<string>|undefined> = [...data] as Array<string|undefined>;
-    // let activeRole = authorities.find((role: string) => role.startsWith('ROLE_')).split('_')[1];
     if (authorities?.length! >= 1) {
       authorities = (authorities as any).filter((role: string) => role.startsWith('ROLE_'));
     }

frontend/src/app/core/services/refresh-token.service.ts

@@ -0,0 +1,28 @@
+import { Injectable } from '@angular/core';
+
+
+@Injectable({
+  providedIn: 'root'
+})
+export class RefreshTokenService {
+
+  constructor() { }
+
+  set token(token: string) {
+    localStorage.setItem('refresh_token', token);
+  }
+
+  get token() {
+    return localStorage.getItem('refresh_token') as string;
+  }
+
+  removeToken(): void {
+    localStorage.removeItem('refresh_token');
+  }
+
+  isTokenExist(): boolean {
+    return !!this.token;
+  }
+
+
+}

frontend/src/app/modules/auth/auth-user.module.ts

@@ -3,6 +3,7 @@ import { CommonModule } from '@angular/common';
 import {AuthUserRouting} from "./auth-user-routing.module";
 import { HttpClientModule } from '@angular/common/http';
 import { AuthInterceptor } from '../../core/interceptors/auth.interceptor';
+import { RefreshInterceptor } from 'app/core/interceptors/refresh.interceptor';
 
 
 // @ts-ignore
@@ -13,7 +14,8 @@ import { AuthInterceptor } from '../../core/interceptors/auth.interceptor';
     AuthUserRouting
   ],
   providers: [
-    AuthInterceptor
+    AuthInterceptor,
+    RefreshInterceptor
   ]
 })
 export class AuthUserModule { }

frontend/src/app/modules/auth/pages/activate-account/activate-account.component.html

@@ -1,7 +1,6 @@
 <app-modal [showModal]="showModal" [title]="alertTitle" [message]="alertMessage" [color]="alertColor"  ></app-modal>
 <app-card-center title="Two-Factor Authentication" description="Enter activation code sent to {{email_register}}, to pursuite to login.">
   <code-input  [isCodeHidden]="false" [codeLength]="6" [code]="token" (codeCompleted)="onCodeCompleted($event)" >
-
   </code-input>
   <div class="mt-4 mb-16 text-sm text-center">
     <p>Didn't get the code?

frontend/src/app/modules/auth/pages/login/login.component.ts

@@ -10,13 +10,14 @@ import {AuthenticationRequest} from "../../api/services/authentication-request";
 import {AuthenticationResponse} from "../../../../api/models/authentication-response";
 import {JwtTokenService} from "../../../../core/services/jwt-token.service";
 import { SharedModule } from '../../../../shared/shared.module';
+import { RefreshTokenService } from 'app/core/services/refresh-token.service';
 
 @Component({
   selector: 'app-login',
   templateUrl: './login.component.html',
   standalone: true,
   imports: [CommonModule,FormsModule, ReactiveFormsModule, HttpClientModule, RouterLink, SharedModule],
-  providers: [AuthenticationService, RouterLink, JwtTokenService]
+  providers: [AuthenticationService, RouterLink, JwtTokenService, RefreshTokenService]
 })
 export class LoginComponent implements OnInit {
   email = new FormControl('', [Validators.required, Validators.email]);
@@ -39,7 +40,7 @@ export class LoginComponent implements OnInit {
 
 
 
-  constructor(private authenticationService: AuthenticationService ,private tokenService: JwtTokenService ,private router: Router) {}
+  constructor(private authenticationService: AuthenticationService ,private tokenService: JwtTokenService, private refreshTokenService: RefreshTokenService ,private router: Router) {}
 
   ngOnInit(): void {}
 
@@ -77,7 +78,8 @@ export class LoginComponent implements OnInit {
     }).subscribe({
       next: (responseData: AuthenticationResponse) => {
         // Set Local Storage to Authorization Jwt Token
-        this.tokenService.token =  responseData.token as string;
+        this.tokenService.token =  responseData.access_token as string;
+        this.refreshTokenService.token = responseData.refresh_token as string;
         this.router.navigate(['dashboard']);
       },
       error: (error) => {