Fix les interceptors

Front/skydivelogs-app/src/app/app.config.ts

@@ -2,7 +2,7 @@ import { inject, provideAppInitializer } from "@angular/core";
 import { ApplicationConfig, provideZoneChangeDetection } from "@angular/core";
 import { provideRouter } from "@angular/router";
 import { DatePipe } from "@angular/common";
-import { HTTP_INTERCEPTORS, provideHttpClient } from "@angular/common/http";
+import { provideHttpClient, withInterceptors } from "@angular/common/http";
 
 import { DateService } from "../services/date.service";
 import { AircraftService } from "../services/aircraft.service";
@@ -56,8 +56,7 @@ export const appConfig: ApplicationConfig = {
       const initializerFn = initConfig(inject(ConfigurationHelper));
       return initializerFn();
     }),
-    { provide: HTTP_INTERCEPTORS, useClass: JwtAuthInterceptor, multi: true },
+    provideHttpClient(withInterceptors([JwtAuthInterceptor, ErrorInterceptor])),
-    { provide: HTTP_INTERCEPTORS, useClass: ErrorInterceptor, multi: true },
     provideCharts(withDefaultRegisterables()),
     provideZoneChangeDetection({ eventCoalescing: true }),
     provideRouter(routes),

Front/skydivelogs-app/src/interceptor/error.interceptor.ts

@@ -1,29 +1,59 @@
-import { Injectable } from '@angular/core';
+// import { Injectable } from "@angular/core";
-import { HttpRequest, HttpHandler, HttpEvent, HttpInterceptor } from '@angular/common/http';
+// import {
-import { Observable, throwError } from 'rxjs';
+//   HttpRequest,
-import { catchError } from 'rxjs/operators';
+//   HttpHandler,
+//   HttpEvent,
+//   HttpInterceptor,
+// } from "@angular/common/http";
+// import { Observable, throwError } from "rxjs";
+// import { catchError } from "rxjs/operators";
 
-import { AuthenticationService } from '../services/authentication.service';
+// import { AuthenticationService } from "../services/authentication.service";
 
+// @Injectable()
+// export class ErrorInterceptor implements HttpInterceptor {
+//   constructor(private authenticationService: AuthenticationService) {}
 
-@Injectable()
+//   intercept(
-export class ErrorInterceptor implements HttpInterceptor {
+//     request: HttpRequest<any>,
+//     next: HttpHandler
+//   ): Observable<HttpEvent<any>> {
+//     return next.handle(request).pipe(
+//       catchError((err) => {
+//         if (err.status === 401) {
+//           // auto logout if 401 response returned from api
+//           this.authenticationService.logout();
+//           location.reload();
+//         }
 
-  constructor(private authenticationService: AuthenticationService) { }
+//         const error = err.error.message || err.statusText;
+//         return throwError(() => error);
+//       })
+//     );
+//   }
+// }
 
-  intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+import { HttpEvent, HttpHandlerFn, HttpRequest } from "@angular/common/http";
-    return next.handle(request)
+import { inject } from "@angular/core";
-               .pipe(
+import { catchError, Observable, throwError } from "rxjs";
-                 catchError(err => {
+import { AuthenticationService } from "../services/authentication.service";
+
+export function ErrorInterceptor(
+  request: HttpRequest<unknown>,
+  next: HttpHandlerFn
+): Observable<HttpEvent<unknown>> {
+  const authenticationService = inject(AuthenticationService);
+
+  return next(request).pipe(
+    catchError((err) => {
       if (err.status === 401) {
         // auto logout if 401 response returned from api
-                      this.authenticationService.logout();
+        authenticationService.logout();
         location.reload();
       }
 
       const error = err.error.message || err.statusText;
-                    return throwError(error);
+      return throwError(() => error);
     })
   );
 }
-}

Front/skydivelogs-app/src/interceptor/jwt-auth.interceptor.ts

@@ -1,27 +1,21 @@
-import { Injectable } from "@angular/core";
+import { HttpEvent, HttpHandlerFn, HttpRequest } from "@angular/common/http";
-import { HttpRequest, HttpHandler, HttpEvent, HttpInterceptor } from "@angular/common/http";
+import { inject } from "@angular/core";
 import { Observable } from "rxjs";
-
 import { AuthenticationService } from "../services/authentication.service";
 
-
+export function JwtAuthInterceptor(
-@Injectable()
+  request: HttpRequest<unknown>,
-export class JwtAuthInterceptor implements HttpInterceptor {
+  next: HttpHandlerFn
-  
+): Observable<HttpEvent<unknown>> {
-  constructor(private authenticationService: AuthenticationService) {}
+  const currentUser = inject(AuthenticationService).currentUserValue;
-
-  intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
-    // add authorization header with basic auth credentials if available
-    const currentUser = this.authenticationService.currentUserValue;
 
   if (currentUser && currentUser.token) {
     request = request.clone({
       setHeaders: {
-          Authorization: `Bearer ${currentUser.token}`
+        Authorization: `Bearer ${currentUser.token}`,
-        }
+      },
     });
   }
 
-    return next.handle(request);
+  return next(request);
-  }
 }