fix routes 23

Author: doukoure2018

frontend/ultima-ng-19.0.0/src/app/interceptors/token.interceptor.ts

@@ -18,7 +18,7 @@ export const TokenInterceptor: HttpInterceptorFn = (request: HttpRequest<unknown
     // Get token from storage service
     const token = storage.get(Key.TOKEN);
 
-    // Add token to request
+    // Add token to request ONLY if token exists and is valid
     const authRequest = addAuthorizationTokenHeader(request, token);
 
     return next(authRequest).pipe(
@@ -42,10 +42,15 @@ function handleAuthFailure(storage: StorageService, router: Router): void {
     // Clear tokens and redirect to login
     storage.remove(Key.TOKEN);
     storage.remove(Key.REFRESH_TOKEN);
-    router.navigate(['/login']);
+    router.navigate(['/']); // Redirection vers la page d'accueil
 }
 
-function addAuthorizationTokenHeader(request: HttpRequest<unknown>, token: string): HttpRequest<unknown> {
+function addAuthorizationTokenHeader(request: HttpRequest<unknown>, token: any): HttpRequest<unknown> {
+    // CORRECTION : Vérifier si le token existe ET n'est pas vide
+    if (!token || token === '' || token === 'null' || token === 'undefined') {
+        return request; // Retourner la requête sans modification
+    }
+
     return request.clone({
         setHeaders: { Authorization: `Bearer ${token}` }
     });

frontend/ultima-ng-19.0.0/src/app/pages/home/home.component.ts

@@ -89,10 +89,15 @@ export class HomeComponent {
             .subscribe({
                 next: (response: IAuthentication) => {
                     console.log('Authentication successful:', response);
+                    // CRITIQUE : Sauvegarder d'abord le token
                     this.saveToken(response);
-                    this.isAuthenticatedAndRedirecting.set(true);
-                    const redirectUrl = this.storage.getRedirectUrl() || '/dashboards';
-                    this.router.navigate([redirectUrl]);
+
+                    // Petit délai pour s'assurer que le token est bien sauvegardé
+                    setTimeout(() => {
+                        this.isAuthenticatedAndRedirecting.set(true);
+                        const redirectUrl = this.storage.getRedirectUrl() || '/dashboards';
+                        this.router.navigate([redirectUrl]);
+                    }, 100);
                 },
                 error: (error) => {
                     console.error('Authentication error:', error);
@@ -118,10 +123,17 @@ export class HomeComponent {
         });
 
     private saveToken = (response: IAuthentication) => {
+        console.log('💾 Sauvegarde des tokens:');
+        console.log('Access Token:', response.access_token?.substring(0, 50) + '...');
+        console.log('Refresh Token:', response.refresh_token?.substring(0, 50) + '...');
+
         this.storage.set(Key.TOKEN, response.access_token);
         this.storage.set(Key.REFRESH_TOKEN, response.refresh_token || response.access_token);
-    };
 
+        // Vérification immédiate
+        const savedToken = this.storage.get(Key.TOKEN);
+        console.log('✅ Token sauvegardé et vérifié:', savedToken ? 'Oui' : 'Non');
+    };
     // Ajoutez les autres méthodes si elles sont utilisées dans le template
     demandesItems: MenuItem[] = [
         {

frontend/ultima-ng-19.0.0/src/app/service/storage.service.ts

@@ -2,18 +2,43 @@ import { Key } from '@/enum/cache.key';
 import { Inject, Injectable, InjectionToken } from '@angular/core';
 
 const CLIENT_STORAGE = new InjectionToken<Storage>('CLIENT_STORAGE', { factory: () => localStorage });
+
 @Injectable()
 export class StorageService {
     constructor(@Inject(CLIENT_STORAGE) private storage: Storage) {}
 
-    // we are going to get the storage key
-    get = (key: string): string => this.storage.getItem(key) || '';
+    // CORRECTION CRITIQUE : Parse le JSON et retourne null si pas trouvé
+    get = (key: string): any => {
+        try {
+            const item = this.storage.getItem(key);
+            if (item === null) {
+                return null; // Clé n'existe pas
+            }
+            // Essayer de parser le JSON, sinon retourner la string brute
+            try {
+                return JSON.parse(item);
+            } catch {
+                return item; // Si ce n'est pas du JSON, retourner la string
+            }
+        } catch (error) {
+            console.error('Erreur lors de la lecture du storage:', error);
+            return null;
+        }
+    };
 
-    set = (key: string, value: any) => this.storage.setItem(key, typeof value === 'string' ? value : JSON.stringify(value));
+    set = (key: string, value: any) => {
+        try {
+            const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
+            this.storage.setItem(key, stringValue);
+        } catch (error) {
+            console.error("Erreur lors de l'écriture dans le storage:", error);
+        }
+    };
 
     remove = (key: string) => this.storage.removeItem(key);
 
-    getRedirectUrl = () => this.get(Key.REDIRECT_URL) || '';
+    // CORRECTION : Utiliser la nouvelle méthode get
+    getRedirectUrl = (): string => this.get(Key.REDIRECT_URL) || '';
 
     setRedirectUrl = (redirect_url: string) => this.set(Key.REDIRECT_URL, redirect_url);
 

frontend/ultima-ng-19.0.0/src/app/service/user.service.ts

@@ -634,6 +634,41 @@ export class UserService {
         localStorage.removeItem(Key.REFRESH_TOKEN);
     }
 
-    isAuthenticated = (): boolean => (this.jwt.decodeToken<string>(this.storage.get(Key.TOKEN)) ? true : false);
-    isTokenExpired = (): boolean => this.jwt.isTokenExpired(this.storage.get(Key.TOKEN)) || false;
+    isTokenExpired = (): boolean => {
+        const token = this.storage.get(Key.TOKEN);
+
+        // Si pas de token ou token vide, considérer comme expiré
+        if (!token || token === '' || token === 'null' || token === 'undefined') {
+            return true;
+        }
+
+        try {
+            const result = this.jwt.isTokenExpired(token);
+            if (result instanceof Promise) {
+                // If a Promise is returned, consider token as expired (or handle async if needed)
+                console.warn('isTokenExpired returned a Promise, treating as expired.');
+                return true;
+            }
+            return result;
+        } catch (error) {
+            console.error("Erreur lors de la vérification d'expiration du token:", error);
+            return true; // En cas d'erreur, considérer comme expiré
+        }
+    };
+
+    isAuthenticated = (): boolean => {
+        const token = this.storage.get(Key.TOKEN);
+
+        // Vérifier si le token existe ET n'est pas expiré
+        if (!token || token === '' || token === 'null' || token === 'undefined') {
+            return false;
+        }
+
+        try {
+            return !this.jwt.isTokenExpired(token);
+        } catch (error) {
+            console.error("Erreur lors de la vérification d'authentification:", error);
+            return false;
+        }
+    };
 }