829 lines
25 KiB
Go
829 lines
25 KiB
Go
package handlers
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"gestion/db"
|
|
"gestion/models"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/golang-jwt/jwt/v5"
|
|
"github.com/google/uuid"
|
|
"golang.org/x/crypto/bcrypt"
|
|
)
|
|
|
|
// ============================================
|
|
// TYPES JWT CLAIMS (Duplicés dans middleware aussi)
|
|
// ============================================
|
|
|
|
type ClientClaims struct {
|
|
ClientID int `json:"client_id"`
|
|
Username string `json:"username"`
|
|
Role string `json:"role"`
|
|
SessionID string `json:"session_id"`
|
|
jwt.RegisteredClaims
|
|
}
|
|
|
|
type AdminClaims struct {
|
|
UserID int `json:"user_id"`
|
|
Username string `json:"username"`
|
|
Role string `json:"role"`
|
|
SessionID string `json:"session_id"`
|
|
jwt.RegisteredClaims
|
|
}
|
|
|
|
// ============================================
|
|
// STRUCTURES REQUÊTE / RÉPONSE
|
|
// ============================================
|
|
|
|
type LoginRequest struct {
|
|
Username string `json:"username" binding:"required"`
|
|
Password string `json:"password" binding:"required"`
|
|
}
|
|
|
|
type RegisterClientRequest struct {
|
|
Username string `json:"username" binding:"required,min=3,max=50"`
|
|
Password string `json:"password" binding:"required,min=8"`
|
|
Nom string `json:"nom" binding:"required,min=2,max=100"`
|
|
Prenom string `json:"prenom" binding:"required,min=2,max=100"`
|
|
Telephone string `json:"telephone" binding:"required"`
|
|
}
|
|
|
|
type RegisterAdminRequest struct {
|
|
Username string `json:"username" binding:"required,min=3,max=50"`
|
|
Password string `json:"password" binding:"required,min=8"`
|
|
Role string `json:"role" binding:"required,oneof=admin cabine livreur"`
|
|
}
|
|
|
|
type LoginResponse struct {
|
|
AccessToken string `json:"access_token"`
|
|
TokenType string `json:"token_type"`
|
|
ExpiresIn int `json:"expires_in"`
|
|
User interface{} `json:"user"`
|
|
}
|
|
|
|
type ProfileResponse struct {
|
|
Username string `json:"username"`
|
|
Role string `json:"role"`
|
|
}
|
|
|
|
// ============================================
|
|
// VARIABLES & CONSTANTS
|
|
// ============================================
|
|
|
|
var (
|
|
clientTokenDuration = 5 * time.Hour
|
|
adminTokenDuration = 10 * time.Hour
|
|
userJWTSecret = []byte(os.Getenv("USER_JWT_SECRET")) // ✅ Pour clients
|
|
adminJWTSecret = []byte(os.Getenv("ADMIN_JWT_SECRET")) // ✅ Pour admin/cabine/livreur
|
|
)
|
|
|
|
// ============================================
|
|
// UTILITAIRES
|
|
// ============================================
|
|
|
|
func generateSessionID() string {
|
|
bytes := make([]byte, 16)
|
|
rand.Read(bytes)
|
|
return hex.EncodeToString(bytes)
|
|
}
|
|
|
|
// validatePhoneNumber valide le format du numéro de téléphone
|
|
func validatePhoneNumber(phone string) bool {
|
|
// Supprimer espaces/tirets
|
|
clean := regexp.MustCompile(`[\s\-\(\)]`).ReplaceAllString(phone, "")
|
|
|
|
// Format international ou national
|
|
validFormat := regexp.MustCompile(`^(\+33|0)[1-9]\d{8}$`)
|
|
return validFormat.MatchString(clean)
|
|
}
|
|
|
|
func normalizePhoneNumber(phone string) string {
|
|
clean := regexp.MustCompile(`[\s\-\(\)]`).ReplaceAllString(phone, "")
|
|
|
|
// Convertir 06... en +336...
|
|
if strings.HasPrefix(clean, "0") {
|
|
return "+33" + clean[1:]
|
|
}
|
|
return clean
|
|
}
|
|
|
|
// ============================================
|
|
// GENERATION TOKENS
|
|
// ============================================
|
|
|
|
func generateClientToken(client *models.Client) (string, error) {
|
|
sessionID := generateSessionID()
|
|
claims := ClientClaims{
|
|
ClientID: client.ID,
|
|
Username: client.Username,
|
|
Role: "client",
|
|
SessionID: sessionID,
|
|
RegisteredClaims: jwt.RegisteredClaims{
|
|
ExpiresAt: jwt.NewNumericDate(time.Now().Add(clientTokenDuration)),
|
|
IssuedAt: jwt.NewNumericDate(time.Now()),
|
|
NotBefore: jwt.NewNumericDate(time.Now()),
|
|
Issuer: "api-client",
|
|
Subject: strconv.Itoa(client.ID),
|
|
},
|
|
}
|
|
token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
|
|
tokenString, err := token.SignedString(userJWTSecret) // ✅ UTILISER userJWTSecret (CLIENT)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return tokenString, nil
|
|
}
|
|
|
|
func generateAdminToken(user *models.User) (string, error) {
|
|
sessionID := generateSessionID()
|
|
claims := AdminClaims{
|
|
UserID: user.ID,
|
|
Username: user.Username,
|
|
Role: user.Role, // ← "admin" ou "cabine" ou "livreur"
|
|
SessionID: sessionID,
|
|
RegisteredClaims: jwt.RegisteredClaims{
|
|
ExpiresAt: jwt.NewNumericDate(time.Now().Add(adminTokenDuration)),
|
|
IssuedAt: jwt.NewNumericDate(time.Now()),
|
|
NotBefore: jwt.NewNumericDate(time.Now()),
|
|
Issuer: "api-admin", // Même issuer pour tous les admins
|
|
Subject: strconv.Itoa(user.ID),
|
|
},
|
|
}
|
|
token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
|
|
tokenString, err := token.SignedString(adminJWTSecret) // ✅ UTILISER adminJWTSecret (ADMIN/CABINE/LIVREUR)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return tokenString, nil
|
|
}
|
|
|
|
// ============================================
|
|
// HANDLERS AUTHENTIFICATION CLIENT
|
|
// ============================================
|
|
|
|
// RegisterClient crée un nouveau compte client
|
|
// POST /api/v1/auth/register
|
|
func RegisterClient(c *gin.Context) {
|
|
var req RegisterClientRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
log.Printf("❌ [REGISTER_CLIENT] Erreur binding: %v", err)
|
|
c.JSON(http.StatusBadRequest, gin.H{
|
|
"error": "Données invalides",
|
|
"details": err.Error(),
|
|
})
|
|
return
|
|
}
|
|
|
|
// Validation téléphone
|
|
if !validatePhoneNumber(req.Telephone) {
|
|
log.Printf("❌ [REGISTER_CLIENT] Téléphone invalide: %s", req.Telephone)
|
|
c.JSON(http.StatusBadRequest, gin.H{
|
|
"error": "Numéro de téléphone invalide",
|
|
})
|
|
return
|
|
}
|
|
|
|
normalizedPhone := normalizePhoneNumber(req.Telephone)
|
|
database := c.MustGet("database").(*db.Database)
|
|
|
|
// Vérifier username unique
|
|
if existingClient, _ := database.GetClientByUsername(req.Username); existingClient != nil {
|
|
log.Printf("❌ [REGISTER_CLIENT] Username déjà utilisé: %s", req.Username)
|
|
c.JSON(http.StatusConflict, gin.H{"error": "Nom d'utilisateur déjà utilisé"})
|
|
return
|
|
}
|
|
|
|
// Vérifier téléphone unique
|
|
if existingClient, _ := database.GetClientByTelephone(normalizedPhone); existingClient != nil {
|
|
log.Printf("❌ [REGISTER_CLIENT] Téléphone déjà utilisé: %s", normalizedPhone)
|
|
c.JSON(http.StatusConflict, gin.H{"error": "Ce numéro de téléphone est déjà utilisé"})
|
|
return
|
|
}
|
|
|
|
// Hasher le mot de passe
|
|
hashed, err := bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost)
|
|
if err != nil {
|
|
log.Printf("❌ [REGISTER_CLIENT] Erreur bcrypt: %v", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur traitement mot de passe"})
|
|
return
|
|
}
|
|
|
|
// Créer le client
|
|
client := &models.Client{
|
|
Username: req.Username,
|
|
Password: string(hashed),
|
|
Nom: strings.TrimSpace(req.Nom),
|
|
Prenom: strings.TrimSpace(req.Prenom),
|
|
Telephone: normalizedPhone,
|
|
CreatedAt: time.Now(),
|
|
}
|
|
|
|
if err := database.CreateClient(client); err != nil {
|
|
log.Printf("❌ [REGISTER_CLIENT] Erreur création: %v", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur création client"})
|
|
return
|
|
}
|
|
|
|
// Générer le token
|
|
token, err := generateClientToken(client)
|
|
if err != nil {
|
|
log.Printf("❌ [REGISTER_CLIENT] Erreur génération token: %v", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur génération token"})
|
|
return
|
|
}
|
|
|
|
// Sauvegarder le token
|
|
expiresAt := time.Now().Add(clientTokenDuration)
|
|
if err := database.SaveToken(client.ID, "client", token, expiresAt); err != nil {
|
|
log.Printf("❌ [REGISTER_CLIENT] Erreur SaveToken: %v", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur enregistrement token"})
|
|
return
|
|
}
|
|
|
|
// Créer la session Redis
|
|
sessionID := uuid.New().String()
|
|
if err := database.CreateClientSession(client.ID, client.Username, sessionID); err != nil {
|
|
log.Printf("⚠️ [REGISTER_CLIENT] Erreur session Redis: %v", err)
|
|
}
|
|
|
|
client.Password = ""
|
|
|
|
log.Printf("✅ [REGISTER_CLIENT] Client créé: %s (ID=%d)", client.Username, client.ID)
|
|
|
|
c.JSON(http.StatusCreated, LoginResponse{
|
|
AccessToken: token,
|
|
TokenType: "Bearer",
|
|
ExpiresIn: int(clientTokenDuration.Seconds()),
|
|
User: gin.H{
|
|
"id": client.ID,
|
|
"username": client.Username,
|
|
"nom": client.Nom,
|
|
"prenom": client.Prenom,
|
|
"telephone": client.Telephone,
|
|
"role": "client",
|
|
"session_id": sessionID,
|
|
},
|
|
})
|
|
}
|
|
|
|
// LoginClient authentifie un client
|
|
// POST /api/v1/auth/login
|
|
func LoginClient(c *gin.Context) {
|
|
var req LoginRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
log.Printf("❌ [LOGIN_CLIENT] Erreur binding: %v", err)
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "Données invalides"})
|
|
return
|
|
}
|
|
|
|
database := c.MustGet("database").(*db.Database)
|
|
|
|
client, err := database.GetClientByUsername(req.Username)
|
|
if err != nil || client == nil {
|
|
log.Printf("❌ [LOGIN_CLIENT] Client non trouvé: %s", req.Username)
|
|
c.JSON(http.StatusUnauthorized, gin.H{"error": "Identifiants invalides"})
|
|
return
|
|
}
|
|
|
|
if err := bcrypt.CompareHashAndPassword([]byte(client.Password), []byte(req.Password)); err != nil {
|
|
log.Printf("❌ [LOGIN_CLIENT] Mot de passe invalide: %s", req.Username)
|
|
c.JSON(http.StatusUnauthorized, gin.H{"error": "Identifiants invalides"})
|
|
return
|
|
}
|
|
|
|
// ✅ LIGNE 302 CORRIGÉE - Gérer l'erreur !
|
|
token, err := generateClientToken(client)
|
|
if err != nil {
|
|
log.Printf("❌ [LOGIN_CLIENT] Erreur génération token: %v", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur génération token"})
|
|
return
|
|
}
|
|
|
|
expiresAt := time.Now().Add(clientTokenDuration)
|
|
if err := database.SaveToken(client.ID, "client", token, expiresAt); err != nil {
|
|
log.Printf("❌ [LOGIN_CLIENT] Erreur SaveToken: %v", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur enregistrement token"})
|
|
return
|
|
}
|
|
|
|
// Créer la session Redis
|
|
sessionID := uuid.New().String()
|
|
if err := database.CreateClientSession(client.ID, client.Username, sessionID); err != nil {
|
|
log.Printf("⚠️ [LOGIN_CLIENT] Erreur session Redis: %v", err)
|
|
}
|
|
|
|
log.Printf("✅ [LOGIN_CLIENT] Client authentifié: %s", req.Username)
|
|
|
|
c.JSON(http.StatusOK, LoginResponse{
|
|
AccessToken: token,
|
|
TokenType: "Bearer",
|
|
ExpiresIn: int(clientTokenDuration.Seconds()),
|
|
User: gin.H{
|
|
"id": client.ID,
|
|
"username": client.Username,
|
|
"nom": client.Nom,
|
|
"prenom": client.Prenom,
|
|
"telephone": client.Telephone,
|
|
"role": "client",
|
|
"session_id": sessionID,
|
|
"must_change_password": client.MustChangePassword,
|
|
},
|
|
})
|
|
}
|
|
|
|
// ChangePassword permet à un client de changer son mot de passe
|
|
// PUT /api/v1/auth/change-password
|
|
func ChangePassword(c *gin.Context) {
|
|
var req struct {
|
|
CurrentPassword string `json:"current_password" binding:"required"`
|
|
NewPassword string `json:"new_password" binding:"required,min=8"`
|
|
}
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "Données invalides", "details": err.Error()})
|
|
return
|
|
}
|
|
|
|
clientID := c.GetInt("client_id")
|
|
database := c.MustGet("database").(*db.Database)
|
|
|
|
client, err := database.GetClientByID(clientID)
|
|
if err != nil {
|
|
log.Printf("❌ [CHANGE_PASSWORD] Client non trouvé: ID=%d", clientID)
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "Client non trouvé"})
|
|
return
|
|
}
|
|
|
|
if err := bcrypt.CompareHashAndPassword([]byte(client.Password), []byte(req.CurrentPassword)); err != nil {
|
|
log.Printf("❌ [CHANGE_PASSWORD] Mot de passe actuel invalide: ID=%d", clientID)
|
|
c.JSON(http.StatusUnauthorized, gin.H{"error": "Mot de passe actuel incorrect"})
|
|
return
|
|
}
|
|
|
|
hashed, err := bcrypt.GenerateFromPassword([]byte(req.NewPassword), bcrypt.DefaultCost)
|
|
if err != nil {
|
|
log.Printf("❌ [CHANGE_PASSWORD] Erreur bcrypt: %v", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur traitement mot de passe"})
|
|
return
|
|
}
|
|
|
|
if err := database.UpdateClientPasswordAndClearFlag(clientID, string(hashed)); err != nil {
|
|
log.Printf("❌ [CHANGE_PASSWORD] Erreur update: %v", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur mise à jour mot de passe"})
|
|
return
|
|
}
|
|
|
|
log.Printf("✅ [CHANGE_PASSWORD] Mot de passe changé: ID=%d", clientID)
|
|
c.JSON(http.StatusOK, gin.H{"success": true, "message": "Mot de passe mis à jour avec succès"})
|
|
}
|
|
|
|
// LogoutClient déconnecte un client
|
|
// POST /api/v1/auth/logout
|
|
func LogoutClient(c *gin.Context) {
|
|
database := c.MustGet("database").(*db.Database)
|
|
|
|
// Invalider la session Redis
|
|
clientID, hasClientID := c.Get("client_id")
|
|
if hasClientID && clientID != nil {
|
|
if err := database.InvalidateSession(clientID.(int)); err != nil {
|
|
log.Printf("⚠️ [LOGOUT_CLIENT] Erreur invalidation session: %v", err)
|
|
}
|
|
}
|
|
|
|
// Révoquer le JWT token
|
|
authHeader := c.GetHeader("Authorization")
|
|
if authHeader != "" && strings.HasPrefix(authHeader, "Bearer ") {
|
|
tokenStr := strings.TrimPrefix(authHeader, "Bearer ")
|
|
database.RevokeToken(tokenStr)
|
|
}
|
|
|
|
log.Printf("✅ [LOGOUT_CLIENT] Client déconnecté")
|
|
|
|
c.JSON(http.StatusOK, gin.H{"message": "Déconnexion réussie"})
|
|
}
|
|
|
|
// ============================================
|
|
// HANDLERS AUTHENTIFICATION ADMIN
|
|
// ============================================
|
|
|
|
// RegisterAdmin crée un nouvel utilisateur admin/cabine/livreur
|
|
// POST /api/v1/auth/admin/register
|
|
func RegisterAdmin(c *gin.Context) {
|
|
var req RegisterAdminRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
log.Printf("❌ [REGISTER_ADMIN] Erreur binding: %v", err)
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "Données invalides"})
|
|
return
|
|
}
|
|
|
|
database := c.MustGet("database").(*db.Database)
|
|
|
|
// Vérifier que l'user n'existe pas
|
|
if existingUser, _ := database.GetUserByUsername(req.Username); existingUser != nil {
|
|
log.Printf("❌ [REGISTER_ADMIN] Username déjà utilisé: %s", req.Username)
|
|
c.JSON(http.StatusConflict, gin.H{"error": "Nom d'utilisateur déjà utilisé"})
|
|
return
|
|
}
|
|
|
|
hashed, _ := bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost)
|
|
user := &models.User{
|
|
Username: req.Username,
|
|
Password: string(hashed),
|
|
Role: req.Role,
|
|
}
|
|
|
|
if err := database.CreateUser(user); err != nil {
|
|
log.Printf("❌ [REGISTER_ADMIN] Erreur création: %v", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur création utilisateur"})
|
|
return
|
|
}
|
|
|
|
log.Printf("✅ [REGISTER_ADMIN] User créé: %s (role=%s, ID=%d)", user.Username, user.Role, user.ID)
|
|
|
|
// Générer le token
|
|
token, err := generateAdminToken(user)
|
|
if err != nil {
|
|
log.Printf("❌ [REGISTER_ADMIN] Erreur génération token: %v", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur génération token"})
|
|
return
|
|
}
|
|
|
|
log.Printf("✅ [REGISTER_ADMIN] Token généré: %s...", token[:50])
|
|
|
|
// ============================================
|
|
// ✅ CRITICAL FIX: ENREGISTRER LE TOKEN EN DB
|
|
// ============================================
|
|
expiresAt := time.Now().Add(adminTokenDuration)
|
|
if err := database.SaveToken(user.ID, user.Role, token, expiresAt); err != nil {
|
|
log.Printf("❌ [REGISTER_ADMIN] Erreur SaveToken: %v", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur enregistrement token"})
|
|
return
|
|
}
|
|
|
|
log.Printf("✅ [REGISTER_ADMIN] Token enregistré en DB pour user ID: %d", user.ID)
|
|
|
|
user.Password = ""
|
|
|
|
c.JSON(http.StatusCreated, LoginResponse{
|
|
AccessToken: token,
|
|
TokenType: "Bearer",
|
|
ExpiresIn: int(adminTokenDuration.Seconds()),
|
|
User: user,
|
|
})
|
|
}
|
|
|
|
// LoginAdmin authentifie un admin/cabine/livreur
|
|
// POST /api/v1/auth/admin/login
|
|
// ✅ AMÉLIORÉ: Meilleure gestion d'erreurs
|
|
func LoginAdmin(c *gin.Context) {
|
|
var req LoginRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
log.Printf("❌ [LOGIN_ADMIN] Erreur binding: %v", err)
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "Données invalides"})
|
|
return
|
|
}
|
|
|
|
database := c.MustGet("database").(*db.Database)
|
|
|
|
user, err := database.GetUserByUsername(req.Username)
|
|
if err != nil || user == nil {
|
|
log.Printf("❌ [LOGIN_ADMIN] User non trouvé: %s", req.Username)
|
|
c.JSON(http.StatusUnauthorized, gin.H{"error": "Identifiants invalides"})
|
|
return
|
|
}
|
|
|
|
// Vérifier que c'est un admin/cabine/livreur
|
|
if user.Role != "admin" && user.Role != "cabine" && user.Role != "livreur" {
|
|
log.Printf("❌ [LOGIN_ADMIN] Rôle invalide: %s", user.Role)
|
|
c.JSON(http.StatusUnauthorized, gin.H{"error": "Accès non autorisé"})
|
|
return
|
|
}
|
|
|
|
// Vérifier le mot de passe
|
|
if user.Password == "" {
|
|
log.Printf("❌ [LOGIN_ADMIN] Mot de passe vide en base")
|
|
c.JSON(http.StatusUnauthorized, gin.H{"error": "Identifiants invalides"})
|
|
return
|
|
}
|
|
|
|
if err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(req.Password)); err != nil {
|
|
log.Printf("❌ [LOGIN_ADMIN] Mot de passe invalide: %s", req.Username)
|
|
c.JSON(http.StatusUnauthorized, gin.H{"error": "Identifiants invalides"})
|
|
return
|
|
}
|
|
|
|
// Générer le token
|
|
token, _ := generateAdminToken(user)
|
|
|
|
expiresAt := time.Now().Add(adminTokenDuration)
|
|
if err := database.SaveToken(user.ID, user.Role, token, expiresAt); err != nil {
|
|
log.Printf("❌ [LOGIN_ADMIN] Erreur SaveToken: %v", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur enregistrement token"})
|
|
return
|
|
}
|
|
|
|
log.Printf("✅ [LOGIN_ADMIN] User authentifié: %s (role=%s)", user.Username, user.Role)
|
|
|
|
c.JSON(http.StatusOK, LoginResponse{
|
|
AccessToken: token,
|
|
TokenType: "Bearer",
|
|
ExpiresIn: int(adminTokenDuration.Seconds()),
|
|
User: gin.H{
|
|
"id": user.ID,
|
|
"username": user.Username,
|
|
"role": user.Role,
|
|
},
|
|
})
|
|
}
|
|
|
|
// LogoutAdmin déconnecte un admin/cabine/livreur
|
|
// POST /api/v1/auth/admin/logout
|
|
func LogoutAdmin(c *gin.Context) {
|
|
database := c.MustGet("database").(*db.Database)
|
|
|
|
// Révoquer le JWT token
|
|
authHeader := c.GetHeader("Authorization")
|
|
if authHeader != "" && strings.HasPrefix(authHeader, "Bearer ") {
|
|
tokenStr := strings.TrimPrefix(authHeader, "Bearer ")
|
|
database.RevokeToken(tokenStr)
|
|
}
|
|
|
|
log.Printf("✅ [LOGOUT_ADMIN] User déconnecté")
|
|
|
|
c.JSON(http.StatusOK, gin.H{"message": "Déconnexion réussie"})
|
|
}
|
|
|
|
// ============================================
|
|
// HELPERS
|
|
// ============================================
|
|
|
|
// GetCurrentClient récupère le client actuel
|
|
// GET /api/v1/profile/client
|
|
func GetCurrentClient(c *gin.Context) {
|
|
clientID := c.GetInt("client_id")
|
|
database := c.MustGet("database").(*db.Database)
|
|
|
|
client, err := database.GetClientByID(clientID)
|
|
if err != nil {
|
|
log.Printf("❌ [GET_CURRENT_CLIENT] Client non trouvé: ID=%d", clientID)
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "Client non trouvé"})
|
|
return
|
|
}
|
|
|
|
client.Password = ""
|
|
|
|
log.Printf("✅ [GET_CURRENT_CLIENT] Client récupéré: %s", client.Username)
|
|
|
|
c.JSON(http.StatusOK, gin.H{
|
|
"client": gin.H{
|
|
"id": client.ID,
|
|
"username": client.Username,
|
|
"nom": client.Nom,
|
|
"prenom": client.Prenom,
|
|
"telephone": client.Telephone,
|
|
"command": client.Command,
|
|
"point": client.Point,
|
|
"amende": client.Amende,
|
|
},
|
|
})
|
|
}
|
|
|
|
// GetCurrentAdmin récupère l'admin/user actuel
|
|
// GET /api/v1/profile/admin
|
|
func GetCurrentAdmin(c *gin.Context) {
|
|
userID := c.GetInt("user_id")
|
|
database := c.MustGet("database").(*db.Database)
|
|
|
|
user, err := database.GetUserByID(userID)
|
|
if err != nil {
|
|
log.Printf("❌ [GET_CURRENT_ADMIN] User non trouvé: ID=%d", userID)
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "Utilisateur non trouvé"})
|
|
return
|
|
}
|
|
|
|
user.Password = ""
|
|
|
|
log.Printf("✅ [GET_CURRENT_ADMIN] User récupéré: %s", user.Username)
|
|
|
|
c.JSON(http.StatusOK, gin.H{
|
|
"user": ProfileResponse{
|
|
Username: user.Username,
|
|
Role: user.Role,
|
|
},
|
|
})
|
|
}
|
|
|
|
// HealthCheck vérifie la santé de l'API
|
|
// GET /api/v1/health
|
|
func HealthCheck(c *gin.Context) {
|
|
database := c.MustGet("database").(*db.Database)
|
|
if err := database.DB.Ping(); err != nil {
|
|
log.Printf("⚠️ [HEALTH] Database down: %v", err)
|
|
c.JSON(http.StatusServiceUnavailable, gin.H{
|
|
"status": "unhealthy",
|
|
"database": "disconnected",
|
|
"timestamp": time.Now().Unix(),
|
|
})
|
|
return
|
|
}
|
|
|
|
log.Printf("✅ [HEALTH] API healthy")
|
|
|
|
c.JSON(http.StatusOK, gin.H{
|
|
"status": "healthy",
|
|
"database": "connected",
|
|
"timestamp": time.Now().Unix(),
|
|
"version": "2.0.0",
|
|
})
|
|
}
|
|
|
|
// GetAllUsers récupère tous les utilisateurs (Admin only)
|
|
func GetAllUsers(c *gin.Context) {
|
|
database := c.MustGet("database").(*db.Database)
|
|
userRole := c.GetString("role")
|
|
|
|
if userRole != "admin" && userRole != "cabine" {
|
|
c.JSON(http.StatusForbidden, gin.H{"error": "Accès réservé aux livreurs et aux administrateurs"})
|
|
return
|
|
}
|
|
users, err := database.GetAllUsers()
|
|
|
|
if err != nil {
|
|
log.Printf("❌ [GET_ALL_USERS] Erreur: %v", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur récupération"})
|
|
return
|
|
}
|
|
|
|
var sanitized []gin.H
|
|
for _, u := range users {
|
|
sanitized = append(sanitized, gin.H{
|
|
"id": u.ID,
|
|
"username": u.Username,
|
|
"role": u.Role,
|
|
})
|
|
}
|
|
|
|
log.Printf("✅ [GET_ALL_USERS] %d users récupérés", len(sanitized))
|
|
|
|
c.JSON(http.StatusOK, gin.H{
|
|
"users": sanitized,
|
|
"count": len(sanitized),
|
|
})
|
|
}
|
|
|
|
func GetAllDeliveryMen(c *gin.Context) {
|
|
database := c.MustGet("database").(*db.Database)
|
|
userRole := c.GetString("role")
|
|
if userRole != "cabine" && userRole != "admin" {
|
|
c.JSON(http.StatusForbidden, gin.H{"error": "Accès réservé aux livreurs et aux administrateurs"})
|
|
return
|
|
}
|
|
users, err := database.GetAllDeliveryMen()
|
|
if err != nil {
|
|
log.Printf("❌ [GET_ALL_USERS] Erreur: %v", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur récupération"})
|
|
return
|
|
}
|
|
var sanitized []gin.H
|
|
for _, u := range users {
|
|
sanitized = append(sanitized, gin.H{
|
|
"id": u.ID,
|
|
"username": u.Username,
|
|
"role": u.Role,
|
|
})
|
|
}
|
|
|
|
log.Printf("✅ [GET_ALL_USERS] %d users récupérés", len(sanitized))
|
|
|
|
c.JSON(http.StatusOK, gin.H{
|
|
"users": sanitized,
|
|
"count": len(sanitized),
|
|
})
|
|
}
|
|
|
|
// GetAllClients récupère tous les clients
|
|
// GET /api/v1/admin/clients
|
|
func GetAllClients(c *gin.Context) {
|
|
database := c.MustGet("database").(*db.Database)
|
|
userRole := c.GetString("role")
|
|
if userRole != "cabine" && userRole != "admin" {
|
|
c.JSON(http.StatusForbidden, gin.H{"error": "Accès réservé aux livreurs et aux administrateurs"})
|
|
return
|
|
}
|
|
clients, err := database.GetAllClients()
|
|
if err != nil {
|
|
log.Printf("❌ [GET_ALL_CLIENTS] Erreur: %v", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur récupération"})
|
|
return
|
|
}
|
|
|
|
var sanitized []gin.H
|
|
for _, cl := range clients {
|
|
sanitized = append(sanitized, gin.H{
|
|
"id": cl.ID,
|
|
"username": cl.Username,
|
|
"nom": cl.Nom,
|
|
"prenom": cl.Prenom,
|
|
"telephone": cl.Telephone,
|
|
"command": cl.Command,
|
|
"point": cl.Point,
|
|
"points_zipette": cl.PointZipette,
|
|
"amende": cl.Amende,
|
|
"cancellations_count": cl.CancellationsCount,
|
|
"last_penalty_reason": cl.LastPenaltyReason,
|
|
})
|
|
}
|
|
|
|
log.Printf("✅ [GET_ALL_CLIENTS] %d clients récupérés", len(sanitized))
|
|
|
|
c.JSON(http.StatusOK, gin.H{
|
|
"clients": sanitized,
|
|
"count": len(sanitized),
|
|
})
|
|
}
|
|
|
|
func DeleteUser(c *gin.Context) {
|
|
database := c.MustGet("database").(*db.Database)
|
|
|
|
idStr := c.Param("id")
|
|
id, err := strconv.Atoi(idStr)
|
|
if err != nil {
|
|
log.Printf("❌ [DELETE_USER] ID invalide: %v", err)
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "ID invalide"})
|
|
return
|
|
}
|
|
userRole := c.GetString("role")
|
|
if userRole != "admin" {
|
|
c.JSON(http.StatusForbidden, gin.H{"error": "Accès réservé aux livreurs et aux administrateurs"})
|
|
return
|
|
}
|
|
err = database.DeleteUser(id)
|
|
if err != nil {
|
|
log.Printf("❌ [DELETE_USER] Erreur: %v", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur suppression"})
|
|
return
|
|
}
|
|
|
|
log.Printf("✅ [DELETE_USER] Utilisateur %d supprimé", id)
|
|
c.JSON(http.StatusOK, gin.H{"message": "Utilisateur supprimé"})
|
|
}
|
|
|
|
// DeleteClient
|
|
func DeleteClient(c *gin.Context) {
|
|
database := c.MustGet("database").(*db.Database)
|
|
|
|
idStr := c.Param("id")
|
|
id, err := strconv.Atoi(idStr)
|
|
if err != nil {
|
|
log.Printf("❌ [DELETE_CLIENT] ID invalide: %v", err)
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "ID invalide"})
|
|
return
|
|
}
|
|
userRole := c.GetString("role")
|
|
if userRole != "cabine" && userRole != "admin" {
|
|
c.JSON(http.StatusForbidden, gin.H{"error": "Accès réservé aux livreurs et aux administrateurs"})
|
|
return
|
|
}
|
|
err = database.DeleteClient(id)
|
|
if err != nil {
|
|
log.Printf("❌ [DELETE_CLIENT] Erreur: %v", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur suppression"})
|
|
return
|
|
}
|
|
|
|
log.Printf("✅ [DELETE_CLIENT] Client %d supprimé", id)
|
|
c.JSON(http.StatusOK, gin.H{"message": "Client supprimé"})
|
|
}
|
|
|
|
func CreateUser(c *gin.Context) {
|
|
database := c.MustGet("database").(*db.Database)
|
|
|
|
var user models.User
|
|
if err := c.ShouldBindJSON(&user); err != nil {
|
|
log.Printf("❌ [CREATE_USER] Erreur de liaison JSON: %v", err)
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "Erreur de liaison JSON"})
|
|
return
|
|
}
|
|
userRole := c.GetString("role")
|
|
if userRole != "cabine" && userRole != "admin" {
|
|
c.JSON(http.StatusForbidden, gin.H{"error": "Accès réservé aux livreurs et aux administrateurs"})
|
|
return
|
|
}
|
|
err := database.CreateUser(&user)
|
|
if err != nil {
|
|
log.Printf("❌ [CREATE_USER] Erreur: %v", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur création"})
|
|
return
|
|
}
|
|
|
|
log.Printf("✅ [CREATE_USER] Utilisateur %d créé", user.ID)
|
|
c.JSON(http.StatusCreated, gin.H{"message": "Utilisateur créé"})
|
|
}
|