Documentation Complète - QuizMaker

┌─────────────────────────────────────────┐
│     Frontend (Angular)                  │
│     - Components                        │
│     - Services                          │
│     - Guards & Interceptors             │
└──────────────┬──────────────────────────┘
               │ HTTP/REST + JWT
┌──────────────▼──────────────────────────┐
│     API Layer (Controllers)             │
│     - UserController                    │
│     - QuizController                    │
│     - EpreuveController                 │
└──────────────┬──────────────────────────┘
               │
┌──────────────▼──────────────────────────┐
│     Service Layer                       │
│     - UserService                       │
│     - QuizService                       │
│     - JwtService                        │
└──────────────┬──────────────────────────┘
               │
┌──────────────▼──────────────────────────┐
│     Domain Layer                        │
│     - Entities (User, Question ...)     │
│     - DTOs                              │
│     - Business Logic                    │
└──────────────┬──────────────────────────┘
               │
┌──────────────▼──────────────────────────┐
│     Persistence Layer                   │
│     - JPA Repositories                  │
│     - Liquibase Migrations              │
└──────────────┬──────────────────────────┘
               │
┌──────────────▼──────────────────────────┐
│     Database (PostgreSQL/H2)            │
└─────────────────────────────────────────┘

quizmaker-backend/
├── pom.xml (parent)
├── quizmaker-api/

├── quizmaker-domain/       # Logique métier
│   └── src/main/java/
│       └── fr/nantes/quizmaker/domain/
│           ├── model/      # Entités JPA
│           ├── service/    # Interfaces services
│           └── exception/  # Exceptions métier
└── quizmaker-spring/       # Implémentation technique
    └── src/main/
        ├── java/
        │   └── fr/nantes/quizmaker/
        │       ├── QuizMakerApplication.java
        │       ├── controller/
        │       ├── service/impl/
        │       ├── repository/
        │       ├── security/
        │       └── config/
        └── resources/
            ├── application.yml
            ├── application-dev.yml
            ├── application-docker.yml
            └── db/changelog/

@Entity
@Table(name = "users")
@Data
@Builder
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true)
    private String email;

    @Column(nullable = false)
    private String password;  // Hashé avec BCrypt

    private String name;
    private String firstname;

    @Enumerated(EnumType.STRING)
    private Role role;  // STUDENT ou TEACHER

    private Boolean emailValidated = false;

    @CreatedDate
    private LocalDateTime createdAt;

    @LastModifiedDate
    private LocalDateTime updatedAt;

    public enum Role {
        STUDENT, TEACHER
    }
}

@Entity
public class Quiz {
    @Id
    @GeneratedValue
    private Long id;

    private String title;
    private String description;

    @ManyToOne
    private User teacher;

    @OneToMany(mappedBy = "quiz", cascade = CascadeType.ALL)
    private List<Question> questions;
}

@Entity
public class Question {
    @Id
    @GeneratedValue
    private Long id;

    @Column(columnDefinition = "TEXT")
    private String text;

    private Integer points = 10;

    @ManyToOne
    private Quiz quiz;

    @OneToMany(mappedBy = "question", cascade = CascadeType.ALL)
    private List<Answer> answers;
}

@Entity
public class Answer {
    @Id
    @GeneratedValue
    private Long id;

    private String text;
    private Boolean isCorrect;

    @ManyToOne
    private Question question;
}

@Service
public class JwtService {
    @Value("${spring.security.jwt.secret}")
    private String secretKey;

    @Value("${spring.security.jwt.expiration}")
    private Long expiration;

    public String generateToken(User user) {
        Map<String, Object> claims = new HashMap<>();
        claims.put("userId", user.getId());
        claims.put("email", user.getEmail());
        claims.put("role", user.getRole().name());

        return Jwts.builder()
                .setClaims(claims)
                .setSubject(user.getEmail())
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + expiration))
                .signWith(getSigningKey(), SignatureAlgorithm.HS384)
                .compact();
    }

    public boolean validateToken(String token) {
        try {
            Jwts.parserBuilder()
                .setSigningKey(getSigningKey())
                .build()
                .parseClaimsJws(token);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    // Méthodes d'extraction...
}

@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    private final JwtService jwtService;

    @Override
    protected void doFilterInternal(
            HttpServletRequest request,
            HttpServletResponse response,
            FilterChain filterChain
    ) throws ServletException, IOException {

        String authHeader = request.getHeader("Authorization");

        if (authHeader != null && authHeader.startsWith("Bearer ")) {
            String jwt = authHeader.substring(7);

            if (jwtService.validateToken(jwt)) {
                Long userId = jwtService.getUserIdFromToken(jwt);
                String role = jwtService.getRoleFromToken(jwt);

                List<SimpleGrantedAuthority> authorities =
                    List.of(new SimpleGrantedAuthority("ROLE_" + role));

                UsernamePasswordAuthenticationToken authentication =
                    new UsernamePasswordAuthenticationToken(userId, null, authorities);

                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
        }

        filterChain.doFilter(request, response);
    }
}

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .csrf(csrf -> csrf.disable())
            .cors(cors -> cors.configurationSource(corsConfigurationSource()))
            .authorizeHttpRequests(auth -> auth
                // Routes publiques
                .requestMatchers(
                    "/api/user/login",
                    "/api/user/register",
                    "/h2-console/**",
                    "/swagger-ui/**"
                ).permitAll()
                // Routes enseignants
                .requestMatchers("/api/quiz/**", "/api/epreuve/**")
                    .hasRole("TEACHER")
                // Routes étudiants
                .requestMatchers("/api/copie/**")
                    .hasRole("STUDENT")
                .anyRequest().authenticated()
            )
            .sessionManagement(session ->
                session.sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            )
            .addFilterBefore(jwtAuthenticationFilter,
                           UsernamePasswordAuthenticationFilter.class);

        return http.build();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

src/app/
├── core/                    # Services globaux (singleton)
│   ├── services/
│   │   ├── auth.service.ts
│   │   ├── user.service.ts
│   │   └── storage.service.ts
│   ├── interceptors/
│   │   ├── auth.interceptor.ts
│   │   └── error.interceptor.ts
│   └── guards/
│       ├── auth.guard.ts
│       └── role.guard.ts
│
├── shared/                  # Composants réutilisables
│   ├── components/
│   ├── models/
│   └── pipes/
│
└── features/                # Modules fonctionnels
    ├── auth/
    │   ├── login/
    │   └── register/
    ├── quiz/
    │   ├── quiz-list/
    │   ├── quiz-create/
    │   └── quiz-detail/
    └── dashboard/

@Injectable({ providedIn: 'root' })
export class AuthService {
  private readonly API_URL = `${environment.apiUrl}/user`;
  private readonly TOKEN_KEY = 'quizmaker_token';

  private currentUserSubject: BehaviorSubject<User | null>;
  public currentUser$: Observable<User | null>;

  constructor(
    private http: HttpClient,
    private router: Router
  ) {
    const storedUser = this.getStoredUser();
    this.currentUserSubject = new BehaviorSubject<User | null>(storedUser);
    this.currentUser$ = this.currentUserSubject.asObservable();
  }

  login(email: string, password: string): Observable<AuthResponse> {
    return this.http.post<AuthResponse>(`${this.API_URL}/login`, {
      email, password
    }).pipe(
      tap(response => {
        this.storeToken(response.token);
        this.storeUser({
          id: response.userId,
          email: response.email,
          role: response.role
        });
        this.currentUserSubject.next(this.getStoredUser());
      })
    );
  }

  logout(): void {
    localStorage.removeItem(this.TOKEN_KEY);
    this.currentUserSubject.next(null);
    this.router.navigate(['/login']);
  }

  getToken(): string | null {
    return localStorage.getItem(this.TOKEN_KEY);
  }

  isAuthenticated(): boolean {
    return this.getToken() !== null;
  }

  hasRole(role: string): boolean {
    const user = this.currentUserSubject.value;
    return user !== null && user.role === role;
  }
}

@Injectable()
export class AuthInterceptor implements HttpInterceptor {
  constructor(private authService: AuthService) {}

  intercept(
    request: HttpRequest<unknown>,
    next: HttpHandler
  ): Observable<HttpEvent<unknown>> {
    const token = this.authService.getToken();

    if (token) {
      request = request.clone({
        setHeaders: {
          Authorization: `Bearer ${token}`
        }
      });
    }

    return next.handle(request);
  }
}

@Injectable({ providedIn: 'root' })
export class AuthGuard implements CanActivate {
  constructor(
    private router: Router,
    private authService: AuthService
  ) {}

  canActivate(
    route: ActivatedRouteSnapshot,
    state: RouterStateSnapshot
  ): boolean {
    if (this.authService.isAuthenticated()) {
      return true;
    }

    this.router.navigate(['/login'], {
      queryParams: { returnUrl: state.url }
    });
    return false;
  }
}

# Stage 1: Build
FROM maven:3.9-eclipse-temurin-17 AS build
WORKDIR /app

COPY pom.xml .
COPY quizmaker-api/pom.xml quizmaker-api/
COPY quizmaker-domain/pom.xml quizmaker-domain/
COPY quizmaker-spring/pom.xml quizmaker-spring/

RUN mvn dependency:go-offline -B

COPY quizmaker-api quizmaker-api
COPY quizmaker-domain quizmaker-domain
COPY quizmaker-spring quizmaker-spring

RUN mvn clean package -DskipTests -B

# Stage 2: Runtime
FROM eclipse-temurin:17-jre
WORKDIR /app
COPY --from=build /app/quizmaker-spring/target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

version: '3.8'

services:
  db:
    image: postgres:15
    environment:
      POSTGRES_DB: quizmaker
      POSTGRES_USER: quizmaker
      POSTGRES_PASSWORD: quizmaker
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

  backend:
    build: ./quizmaker-backend
    ports:
      - "8080:8080"
    environment:
      - SPRING_PROFILES_ACTIVE=docker
      - SPRING_DATASOURCE_URL=jdbc:postgresql://db:5432/quizmaker
      - JWT_SECRET=mySecret
    depends_on:
      - db

  frontend:
    build: ./quizmaker-frontend/quizmaker-angular
    ports:
      - "4200:80"
    depends_on:
      - backend

  pgadmin:
    image: dpage/pgadmin4
    environment:
      PGADMIN_DEFAULT_EMAIL: admin@quizmaker.fr
      PGADMIN_DEFAULT_PASSWORD: admin
    ports:
      - "5050:80"

volumes:
  postgres_data:

@ExtendWith(MockitoExtension.class)
class UserServiceImplTest {
    @Mock
    private UserRepository userRepository;

    @Mock
    private PasswordEncoder passwordEncoder;

    @Mock
    private JwtService jwtService;

    @InjectMocks
    private UserServiceImpl userService;

    @Test
    void testRegister_Success() {
        // Given
        when(userRepository.existsByEmail(anyString())).thenReturn(false);
        when(passwordEncoder.encode(anyString())).thenReturn("encoded");
        when(userRepository.save(any())).thenReturn(testUser);
        when(jwtService.generateToken(any())).thenReturn("token");

        // When
        AuthResponse response = userService.register(/*...*/);

        // Then
        assertThat(response.getToken()).isEqualTo("token");
        verify(userRepository).save(any(User.class));
    }
}

describe('AuthService', () => {
  let service: AuthService;
  let httpMock: HttpTestingController;

  beforeEach(() => {
    TestBed.configureTestingModule({
      imports: [HttpClientTestingModule],
      providers: [AuthService]
    });
    service = TestBed.inject(AuthService);
    httpMock = TestBed.inject(HttpTestingController);
  });

  it('should login and store token', (done) => {
    const mockResponse = {
      token: 'fake-jwt',
      userId: 1,
      email: 'cheikh-tidiane.diop1@etu.univ-nantes.fr',
      role: 'STUDENT'
    };

    service.login('cheikh-tidiane.diop1@etu.univ-nantes.fr', 'password').subscribe(response => {
      expect(response).toEqual(mockResponse);
      expect(service.getToken()).toBe('fake-jwt');
      done();
    });

    const req = httpMock.expectOne(`${environment.apiUrl}/user/login`);
    req.flush(mockResponse);
  });
});

# Build et démarrage
docker-compose up -d --build

# Voir les logs
docker-compose logs -f

# Arrêter
docker-compose down