Press n or j to go to the next uncovered block, b, p or k for the previous block.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 | 1x 1x 1x 31x 31x 31x 31x 22x 22x 21x 21x 20x 31x 23x 1x 1x 22x 2x 2x 1x 1x 21x 18x 2x 2x 16x 2x 14x 14x 10x 4x 3x 4x 4x 4x 4x 4x 3x 2x 2x 2x 2x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x | import { HttpInterceptorFn, HttpErrorResponse } from '@angular/common/http';
import { inject } from '@angular/core';
import { Router } from '@angular/router';
import { Observable, throwError, BehaviorSubject } from 'rxjs';
import { catchError, filter, take, switchMap } from 'rxjs/operators';
import { AuthService } from '../services/auth.service';
let isRefreshing = false;
const refreshTokenSubject = new BehaviorSubject<string | null>(null);
export const authInterceptor: HttpInterceptorFn = (req, next) => {
const authService = inject(AuthService);
const router = inject(Router);
// Ajouter le token à toutes les requêtes (sauf auth et endpoints publics)
const isPublicEndpoint = req.url.includes('/api/auth/') ||
req.url.includes('/api/settings/') ||
req.url.includes('/api/rgpd/');
if (!isPublicEndpoint) {
const token = authService.getToken();
if (token) {
// Vérifier que le token n'est pas déjà présent (éviter les doublons)
const existingAuth = req.headers.get('Authorization');
if (!existingAuth) {
req = req.clone({
setHeaders: {
Authorization: `Bearer ${token}`
}
});
}
}
}
return next(req).pipe(
catchError((error: HttpErrorResponse) => {
// Gérer spécifiquement l'erreur 400 pour /api/draw/winner (ancien backend non redémarré)
// Transformer TOUS les 400 en 404 silencieuse pour cet endpoint
// Car un 400 sur cet endpoint signifie toujours "pas de gagnant" (cas normal)
if (error.status === 400 && req.url.includes('/api/draw/winner')) {
// Créer une erreur 404 personnalisée qui ne sera pas loggée
// On transforme systématiquement les 400 en 404 pour cet endpoint
const silentError: any = {
status: 404,
statusText: 'Not Found',
message: 'No winner found',
url: req.url,
error: { message: 'No winner found' },
silent: true // Flag pour indiquer que c'est une erreur "normale"
};
// Ne pas utiliser HttpErrorResponse pour éviter les logs automatiques
return throwError(() => silentError);
}
// Même chose pour /api/draw/final si c'est un 400 avec message "déjà effectué"
if (error.status === 400 && req.url.includes('/api/draw/final')) {
const errorMessage =
(error.error && typeof error.error === 'object' && error.error.error) ||
(error.error && typeof error.error === 'string' && error.error) ||
'';
if (errorMessage.includes('déjà été effectué') || errorMessage.includes('déjà effectué')) {
// Transformer en 409 Conflict silencieuse
const silentError: any = {
status: 409,
statusText: 'Conflict',
message: errorMessage,
url: req.url,
error: { message: errorMessage },
silent: false // On veut quand même voir cette erreur car c'est une vraie erreur métier
};
return throwError(() => silentError);
}
}
// Si erreur 401
// Les endpoints /api/auth/ peuvent retourner 401 normalement (token invalide, etc.)
// Ne JAMAIS rediriger pour ces erreurs car ce sont des erreurs métier normales
if (error.status === 401) {
// Si c'est un endpoint d'authentification, laisser le composant gérer l'erreur
// Ces erreurs sont normales (token OAuth invalide, credentials incorrects, etc.)
// Créer une erreur silencieuse pour éviter le spam dans la console
if (req.url.includes('/api/auth/')) {
const silentError: any = {
...error,
silent: true // Flag pour indiquer que c'est une erreur "normale"
};
return throwError(() => silentError);
}
// Si c'est un endpoint public, ne pas rediriger
if (req.url.includes('/api/settings/') || req.url.includes('/api/rgpd/')) {
return throwError(() => error);
}
// Si on est sur une page publique, ne JAMAIS rediriger
const isPublicPage = router.url === '/' ||
router.url.startsWith('/login') ||
router.url.startsWith('/register') ||
router.url.startsWith('/contact') ||
router.url.startsWith('/faq') ||
router.url.startsWith('/lots') ||
router.url.startsWith('/jeu-concours') ||
router.url.startsWith('/mentions-legales') ||
router.url.startsWith('/pos');
if (isPublicPage) {
return throwError(() => error);
}
// Sinon, gérer l'erreur 401 normalement (refresh token, etc.)
// Mais seulement pour les pages protégées
return handle401Error(req, next, authService, router);
}
// Si erreur 403, laisser le composant gérer l'erreur
// Ne pas déconnecter automatiquement car cela peut être une erreur métier
// (ex: code déjà utilisé, permissions insuffisantes pour cette action spécifique)
// Le composant peut afficher un message d'erreur approprié
// On ne déconnecte que si c'est vraiment un problème d'authentification (401)
return throwError(() => error);
})
);
};
function handle401Error(
req: any,
next: any,
authService: AuthService,
router: Router
): Observable<any> {
if (!isRefreshing) {
isRefreshing = true;
refreshTokenSubject.next(null);
const refreshToken = localStorage.getItem('refreshToken');
if (refreshToken) {
return authService.refreshToken().pipe(
switchMap((response) => {
isRefreshing = false;
refreshTokenSubject.next(response.accessToken);
const clonedReq = req.clone({
setHeaders: {
Authorization: `Bearer ${response.accessToken}`
}
});
return next(clonedReq);
}),
catchError((err) => {
isRefreshing = false;
authService.logout();
// Ne rediriger vers /login que si on n'est pas déjà sur une page publique
const isPublicPage = router.url === '/' ||
router.url.startsWith('/login') ||
router.url.startsWith('/register') ||
router.url.startsWith('/contact') ||
router.url.startsWith('/faq') ||
router.url.startsWith('/lots') ||
router.url.startsWith('/jeu-concours') ||
router.url.startsWith('/mentions-legales');
if (!isPublicPage) {
router.navigate(['/login']);
}
return throwError(() => err);
})
);
} else {
// Pas de refresh token
isRefreshing = false;
authService.logout();
// Ne rediriger vers /login que si on n'est pas déjà sur une page publique
const isPublicPage = router.url === '/' ||
router.url.startsWith('/login') ||
router.url.startsWith('/register') ||
router.url.startsWith('/contact') ||
router.url.startsWith('/faq') ||
router.url.startsWith('/lots') ||
router.url.startsWith('/jeu-concours') ||
router.url.startsWith('/mentions-legales');
if (!isPublicPage) {
router.navigate(['/login']);
}
return throwError(() => new Error('No refresh token available'));
}
} else E{
// Attendre que le refresh soit terminé
return refreshTokenSubject.pipe(
filter(token => token !== null),
take(1),
switchMap((token) => {
const clonedReq = req.clone({
setHeaders: {
Authorization: `Bearer ${token}`
}
});
return next(clonedReq);
})
);
}
}
|