chore: build

2026-06-14 17:50:35 +02:00
parent 3c92a0371f
commit 3a0f725159
93 changed files with 5311 additions and 4224 deletions
@@ -1,8 +1,11 @@
 package handlers

 import (
+	"crypto/rand"
+	"fmt"
 	"gestion/db"
 	"gestion/models"
+	"gestion/services"
 	"gestion/utils"
 	"log"
 	"net/http"
@@ -76,7 +79,7 @@ func RegisterClient(c *gin.Context) {
 	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",
+			"error": "Données invalides",
 		})
 		return
 	}
@@ -178,6 +181,11 @@ func RegisterClient(c *gin.Context) {

 // AdminCreateClient crée un client depuis l'interface admin (sans session ni token)
 func AdminCreateClient(c *gin.Context) {
+	if userRole := c.GetString("role"); userRole != "admin" {
+		c.JSON(http.StatusForbidden, gin.H{"error": "Seul un administrateur peut créer des clients"})
+		return
+	}
+
 	var req models.RegisterClientRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
 		log.Printf("❌ [ADMIN_CREATE_CLIENT] Binding error: %v | body: username=%q nom=%q prenom=%q tel=%q", err, req.Username, req.Nom, req.Prenom, req.Telephone)
@@ -242,8 +250,16 @@ func AdminCreateClient(c *gin.Context) {
 	})
 }

+func cryptoRandInt() int {
+	b := make([]byte, 4)
+	rand.Read(b)
+	return int(b[0])<<24 | int(b[1])<<16 | int(b[2])<<8 | int(b[3])
+}
+
 // LoginClient authentifie un client
 func LoginClient(c *gin.Context) {
+	database := c.MustGet("database").(*db.Database)
+
 	var req models.LoginRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
 		log.Printf("❌ [LOGIN_CLIENT] Erreur binding: %v", err)
@@ -251,8 +267,6 @@ func LoginClient(c *gin.Context) {
 		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)
@@ -266,6 +280,33 @@ func LoginClient(c *gin.Context) {
 		return
 	}

+	settings, err := database.GetSettings()
+	if err != nil {
+		log.Printf("❌ [LOGIN_CLIENT] Erreur récupération des paramètres: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur interne"})
+		return
+	}
+
+	if settings.Telegram2FAEnabled && client.TwoFAEnabled {
+		chatID, linked, _ := database.GetClientTelegramChatID(client.Username)
+		if linked {
+			code := fmt.Sprintf("%06d", cryptoRandInt()%1000000)
+			sessionToken := uuid.New().String()
+			if err := db.Store2FASession(sessionToken, client.Username, code); err != nil {
+				log.Printf("❌ [2FA] Erreur stockage session Redis: %v", err)
+				c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur interne"})
+				return
+			}
+			msg := fmt.Sprintf("🔐 Code de vérification : <b>%s</b>\n\nValable 5 minutes.", code)
+			services.TelegramBot.SendMessage(chatID, msg)
+			c.JSON(http.StatusOK, gin.H{
+				"requires_2fa":  true,
+				"session_token": sessionToken,
+			})
+			return
+		}
+	}
+
 	token, err := generateClientToken(client)
 	if err != nil {
 		log.Printf("❌ [LOGIN_CLIENT] Erreur génération token: %v", err)
@@ -280,7 +321,6 @@ func LoginClient(c *gin.Context) {
 		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)
@@ -303,6 +343,125 @@ func LoginClient(c *gin.Context) {
 	})
 }

+func Verify2FAClient(c *gin.Context) {
+	database := c.MustGet("database").(*db.Database)
+
+	var req struct {
+		SessionToken string `json:"session_token" binding:"required"`
+		Code         string `json:"code" binding:"required"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Données invalides"})
+		return
+	}
+
+	username, err := db.Verify2FASession(req.SessionToken, req.Code)
+	if err != nil {
+		log.Printf("❌ [2FA] Échec vérification: %v", err)
+		c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()})
+		return
+	}
+
+	client, err := database.GetClientByUsername(username)
+	if err != nil || client == nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur interne"})
+		return
+	}
+
+	token, err := generateClientToken(client)
+	if err != nil {
+		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 {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur enregistrement token"})
+		return
+	}
+
+	sessionID := uuid.New().String()
+	if err := database.CreateClientSession(client.ID, client.Username, sessionID); err != nil {
+		log.Printf("⚠️  [2FA] Erreur session Redis: %v", err)
+	}
+
+	c.JSON(http.StatusOK, models.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,
+		},
+	})
+}
+
+func GetClient2FAStatus(c *gin.Context) {
+	clientID := c.GetInt("client_id")
+	database := c.MustGet("database").(*db.Database)
+
+	client, err := database.GetClientByID(clientID)
+	if err != nil || client == nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "Client non trouvé"})
+		return
+	}
+
+	_, tgLinked, _ := database.GetClientTelegramChatID(client.Username)
+
+	settings, _ := database.GetSettings()
+
+	c.JSON(http.StatusOK, gin.H{
+		"two_fa_enabled":    client.TwoFAEnabled,
+		"telegram_linked":   tgLinked,
+		"admin_2fa_enabled": settings.Telegram2FAEnabled,
+	})
+}
+
+func ToggleClient2FA(c *gin.Context) {
+	clientID := c.GetInt("client_id")
+	database := c.MustGet("database").(*db.Database)
+
+	var req struct {
+		Enabled bool `json:"enabled"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Données invalides"})
+		return
+	}
+
+	client, err := database.GetClientByID(clientID)
+	if err != nil || client == nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "Client non trouvé"})
+		return
+	}
+
+	if req.Enabled {
+		_, linked, _ := database.GetClientTelegramChatID(client.Username)
+		if !linked {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "Telegram non lié — impossible d'activer la 2FA"})
+			return
+		}
+		settings, _ := database.GetSettings()
+		if !settings.Telegram2FAEnabled {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "La 2FA n'est pas activée par l'administrateur"})
+			return
+		}
+	}
+
+	if err := database.SetClientTwoFAEnabled(clientID, req.Enabled); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur mise à jour"})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"success": true, "two_fa_enabled": req.Enabled})
+}
+
 // ChangePassword permet à un client de changer son mot de passe
 func ChangePassword(c *gin.Context) {
 	var req struct {
@@ -366,60 +525,6 @@ func LogoutClient(c *gin.Context) {
 	c.JSON(http.StatusOK, gin.H{"message": "Déconnexion réussie"})
 }

-// RegisterAdmin crée un nouvel utilisateur admin/cabine/livreur
-func RegisterAdmin(c *gin.Context) {
-	var req models.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)
-
-	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
-	}
-
-	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
-	}
-
-	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
-	}
-
-	user.Password = ""
-
-	c.JSON(http.StatusCreated, models.LoginResponse{
-		AccessToken: token,
-		TokenType:   "Bearer",
-		ExpiresIn:   int(adminTokenDuration.Seconds()),
-		User:        user,
-	})
-}
-
 // LoginAdmin authentifie un admin/cabine/livreur
 func LoginAdmin(c *gin.Context) {
 	var req models.LoginRequest
@@ -553,30 +658,6 @@ func GetCurrentAdmin(c *gin.Context) {
 	})
 }

-// 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)
@@ -744,18 +825,25 @@ func CreateUser(c *gin.Context) {
 		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"})
+	if c.GetString("role") != "admin" {
+		c.JSON(http.StatusForbidden, gin.H{"error": "Seul un administrateur peut créer des utilisateurs"})
 		return
 	}
-	err := database.CreateUser(&user)
-	if err != nil {
+	if user.Role == "admin" {
+		c.JSON(http.StatusForbidden, gin.H{"error": "La création d'un compte administrateur n'est pas autorisée via l'application"})
+		return
+	}
+	if user.Role != "livreur" && user.Role != "cabine" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Rôle invalide, valeurs acceptées : livreur, cabine"})
+		return
+	}
+
+	if err := database.CreateUser(&user); 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)
+	log.Printf("✅ [CREATE_USER] Utilisateur %s (%s) créé", user.Username, user.Role)
 	c.JSON(http.StatusCreated, gin.H{"message": "Utilisateur créé"})
 }