ldap-cesi/ldap-cesi/Controllers/UtilisateurController.cs

using System.Security.Claims;
using ldap_cesi.DTOs.Inputs;
using ldap_cesi.Services.Interfaces;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace ldap_cesi.Controllers;
[ApiController]
[Route("api/utilisateurs")]
public class UtilisateurController : ControllerBase
{
    private readonly IUtilisateurService _utilisateurService;
    private readonly IJwtService _jwtService;
    public UtilisateurController(IUtilisateurService utilisateurService, IJwtService jwtService)
    {
        _utilisateurService = utilisateurService;
        _jwtService = jwtService;
    }


    /// <summary>
    /// Endpoint pour la connexion des utilisateurs.
    /// </summary>
    /// <param name="utilisateurInput">Les informations de connexion de l'utilisateur.</param>
    /// <returns>Un token JWT si la connexion est réussie.</returns>
    [HttpPost("login")]
    public async Task<IActionResult> Login([FromBody] UtilisateurLoginDto utilisateurInput)
    {
        var result = await _utilisateurService.Login(utilisateurInput);
        return result.Success ? Ok(result) : BadRequest(result);
    }
    
    [HttpGet("me")]
    [Authorize]
    public async Task<IActionResult> GetCurrentUser()
    {
        try {
            // rçupère tous les claims de type NameIdentifier
            var nameIdClaims = User.FindAll(ClaimTypes.NameIdentifier).ToList();
        
            // cherche le claim qui contient un nombre entier
            int userId = 0;
            bool foundValidId = false;
        
            foreach (var claim in nameIdClaims)
            {
                if (int.TryParse(claim.Value, out userId))
                {
                    foundValidId = true;
                    break;
                }
            }
        
            if (!foundValidId)
            {
                return BadRequest(new { 
                    Success = false, 
                    Message = "Utilisateur non identifié. Aucun ID numérique trouvé."
                });
            }

            // rçupère les informations utilisateur
            var result = await _utilisateurService.GetById(userId);
            return result.Success ? Ok(result) : BadRequest(result);
        }
        catch (Exception ex) {
            return BadRequest(new { Success = false, Message = $"Erreur: {ex.Message}" });
        }
    }
    
    /// <summary>
    /// Endpoint pour déconnecter un utilisateur (invalider son token).
    /// </summary>
    /// <returns>Un statut indiquant que la déconnexion a réussi.</returns>
    [HttpPost("logout")]
    [Authorize]
    public async Task<IActionResult> Logout()
    {
        try
        {
            var authHeader = Request.Headers["Authorization"].ToString();
            if (string.IsNullOrEmpty(authHeader) || !authHeader.StartsWith("Bearer "))
            {
                return BadRequest(new { Success = false, Message = "Token non fourni" });
            }
        
            var token = authHeader.Substring("Bearer ".Length).Trim();
        
            // rendre le tokenm invalide
            var result = await _jwtService.InvalidateToken(token);
        
            if (result)
            {
                return Ok(new { Success = true, Message = "Déconnexion réussie" });
            }
            else
            {
                return BadRequest(new { Success = false, Message = "Échec de la déconnexion" });
            }
        }
        catch (Exception ex)
        {
            return StatusCode(500, new { Success = false, Message = "Erreur interne du serveur" });
        }
    }

    /// <summary>
    /// Endpoint pour récupérer tous les utilisateurs.
    /// </summary>
    /// <returns>Une liste d'utilisateurs.</returns>
    [HttpGet]
    [Authorize(Roles = "admin")]
    public async Task<IActionResult> GetUtilisateurs()
    {
        var result = await _utilisateurService.GetAll();
        return result.Success ? Ok(result) : BadRequest(result);
    }

    /// <summary>
    /// Endpoint pour récupérer un utilisateur par son ID.
    /// </summary>
    /// <param name="id">L'ID de l'utilisateur.</param>
    /// <returns>L'utilisateur correspondant à l'ID.</returns>
    [HttpGet("{id}")]
    [Authorize(Roles = "admin")]
    public async Task<IActionResult> GetUtilisateurById(int id)
    {
        var result = await _utilisateurService.GetById(id);
        return result.Success ? Ok(result) : BadRequest(result);
    }
}