guards edited

src/app.module.ts

@@ -15,6 +15,7 @@
   import { ParentsModule } from './routes/parents/parents.module';
   import { JwtModule } from '@nestjs/jwt';
   import { AuthModule } from './routes/auth/auth.module';
+import { AuthGuard } from './common/guards/auth.guard';
 
   @Module({
     imports: [
@@ -53,7 +54,9 @@
     providers: [AppService,
       { provide: APP_FILTER, useClass: AllExceptionsFilter },
       { provide: APP_INTERCEPTOR, useClass: TransformInterceptor },
-      { provide: APP_GUARD, useClass: RolesGuard }
+      { provide: APP_GUARD, useClass: RolesGuard },
+      { provide: APP_GUARD, useClass: AuthGuard },
+
     ],
   })
   export class AppModule { }

src/common/guards/auth.guard.ts

@@ -3,13 +3,20 @@ import { Reflector } from "@nestjs/core";
 import { JwtService } from "@nestjs/jwt";
 import { Request } from 'express';
 import { IS_PUBLIC_KEY } from "../decorators/public.decorator";
+import { ConfigService } from "@nestjs/config";
+
+interface AuthenticatedRequest extends Request {
+    user?: any;
+}
 
 @Injectable()
 export class AuthGuard implements CanActivate {
     constructor(
         private readonly jwtService: JwtService,
         private readonly reflector: Reflector,
-    ) {}
+        private readonly configService: ConfigService,
+    ) { }
+
 
     async canActivate(context: ExecutionContext): Promise<boolean> {
         const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [
@@ -21,15 +28,15 @@ export class AuthGuard implements CanActivate {
         const request = context.switchToHttp().getRequest<Request>();
         const authHeader = request.headers['authorization'] as string | undefined;
 
-        if (!authHeader || !authHeader.startsWith('Bearer')) {
+        if (!authHeader || !authHeader.startsWith('Bearer ')) {
             throw new UnauthorizedException('Token manquant ou invalide');
         }
 
         const token = authHeader.split(' ')[1];
         try {
             const payload = await this.jwtService.verifyAsync(token,
-                { secret: process.env.JWT_SECRET },
+                { secret: this.configService.get<string>('jwt.secret') },
-            ); 
+            );
             request.user = payload;
             return true;
         } catch (error) {

src/common/guards/roles.guard.ts

@@ -4,18 +4,23 @@ import { Observable } from "rxjs";
 
 @Injectable()
 export class RolesGuard implements CanActivate {
-    constructor(private readonly reflector: Reflector) {}
+  constructor(private readonly reflector: Reflector) {}
-    canActivate(context: ExecutionContext): boolean | Promise<boolean> | Observable<boolean> {
-        const requiredRoles = this.reflector.get<string[]>('roles', context.getHandler());
-        if (!requiredRoles || requiredRoles.length === 0) {
-            return true; // Si aucun role est requis -> accès autorise
-        }
 
-        const request = context.switchToHttp().getRequest();
+  canActivate(context: ExecutionContext): boolean | Promise<boolean> | Observable<boolean> {
-        const user = request.user;
+    const requiredRoles = this.reflector.getAllAndOverride<string[]>('roles', [
-        if (!user || !user.role) {
+      context.getHandler(),
-            return false; // Si l'utilisateur est pas authentifie ou a pas de role -> accès refusé
+      context.getClass(),
-        }
+    ]);
-        return requiredRoles.includes(user.role);
+
+    if (!requiredRoles || requiredRoles.length === 0) {
+      return true;
     }
-}
+
+    const request = context.switchToHttp().getRequest();
+    const user = request.user;
+    if (!user || !user.role) {
+      return false;
+    }
+    return requiredRoles.includes(user.role);
+  }
+}