chore: build

backend/gestion/handlers/alert.go

@@ -92,6 +92,15 @@ func GetAlert(c *gin.Context) {
 		return
 	}
 
+	// Un livreur ne peut consulter que ses propres alertes — admin/cabine gardent l'accès complet pour le dispatch
+	if userRole == "livreur" {
+		username, exists := c.Get("username")
+		if !exists || alert.Username != username.(string) {
+			c.JSON(http.StatusForbidden, gin.H{"error": "Cette alerte ne vous appartient pas"})
+			return
+		}
+	}
+
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,
 		"alert":   alert,

backend/gestion/handlers/auth.go

@@ -73,112 +73,6 @@ func generateAdminToken(user *models.User) (string, error) {
 	return tokenString, nil
 }
 
-// RegisterClient crée un nouveau compte client
-func RegisterClient(c *gin.Context) {
-	var req models.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",
-		})
-		return
-	}
-
-	// Sanitize text inputs
-	req.Username = utils.StripHTML(req.Username)
-	req.Nom = utils.StripHTML(req.Nom)
-	req.Prenom = utils.StripHTML(req.Prenom)
-
-	// Validation téléphone
-	if !utils.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 := utils.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 = ""
-
-	c.JSON(http.StatusCreated, 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,
-		},
-	})
-}
-
 // 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" {
@@ -602,62 +496,6 @@ func LogoutAdmin(c *gin.Context) {
 // 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,
-			"amende":       client.Amende,
-			"points_extra": client.PointsExtra,
-		},
-	})
-}
-
-// 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": models.ProfileResponse{
-			Username: user.Username,
-			Role:     user.Role,
-		},
-	})
-}
-
 // GetAllUsers récupère tous les utilisateurs (Admin only)
 func GetAllUsers(c *gin.Context) {
 	database := c.MustGet("database").(*db.Database)

backend/gestion/handlers/cabine.go

@@ -1,165 +0,0 @@
-package handlers
-
-import (
-	"gestion/db"
-	"net/http"
-	"strconv"
-
-	"github.com/gin-gonic/gin"
-)
-
-func GetLivreurPosition(c *gin.Context) {
-	database := c.MustGet("database").(*db.Database)
-	livreurUsername := c.Param("username")
-
-	userRole := c.GetString("role")
-	if userRole != "admin" && userRole != "cabine" {
-		c.JSON(http.StatusForbidden, gin.H{
-			"error": "Accès refusé - Réservé aux administrateurs et cabines",
-		})
-		return
-	}
-
-	if livreurUsername == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Username livreur requis"})
-		return
-	}
-
-	position, err := database.GetLivreurPosition(livreurUsername)
-	if err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"livreur": livreurUsername,
-			"message": "Position non disponible (GPS désactivé ou livraison terminée)",
-		})
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{
-		"success":  true,
-		"livreur":  livreurUsername,
-		"position": position,
-	})
-}
-
-func GetDeliveryIssues(c *gin.Context) {
-	database := c.MustGet("database").(*db.Database)
-
-	status := c.Query("status")
-
-	userRole := c.GetString("role")
-	if userRole != "admin" && userRole != "cabine" {
-		c.JSON(http.StatusForbidden, gin.H{
-			"error": "Accès refusé - Réservé aux administrateurs et cabines",
-		})
-		return
-	}
-	issues, err := database.GetDeliveryIssues(status)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Erreur récupération problèmes",
-		})
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
-		"issues":  issues,
-		"count":   len(issues),
-	})
-}
-
-func CreateDeliveryIssue(c *gin.Context) {
-	database := c.MustGet("database").(*db.Database)
-
-	var req struct {
-		CommandID   int    `json:"command_id" binding:"required"`
-		IssueType   string `json:"issue_type" binding:"required"`
-		Description string `json:"description" binding:"required"`
-	}
-
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Données invalides"})
-		return
-	}
-
-	cabineUsername, _ := c.Get("username")
-
-	issue, err := database.CreateDeliveryIssue(
-		req.CommandID,
-		req.IssueType,
-		req.Description,
-		cabineUsername.(string),
-	)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Erreur création problème",
-		})
-		return
-	}
-
-	c.JSON(http.StatusCreated, gin.H{
-		"success": true,
-		"message": "Problème enregistré",
-		"issue":   issue,
-	})
-}
-
-func UpdateDeliveryIssue(c *gin.Context) {
-	database := c.MustGet("database").(*db.Database)
-
-	issueID, err := strconv.Atoi(c.Param("id"))
-	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "ID invalide"})
-		return
-	}
-
-	var req struct {
-		Status     string `json:"status"`
-		Resolution string `json:"resolution"`
-	}
-
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Données invalides"})
-		return
-	}
-
-	cabineUsername, _ := c.Get("username")
-
-	err = database.UpdateDeliveryIssue(issueID, req.Status, req.Resolution, cabineUsername.(string))
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Erreur mise à jour",
-		})
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
-		"message": "Problème mis à jour",
-	})
-}
-
-func GetCommandLogs(c *gin.Context) {
-	database := c.MustGet("database").(*db.Database)
-
-	commandID, err := strconv.Atoi(c.Param("id"))
-	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "ID commande invalide"})
-		return
-	}
-
-	logs, err := database.GetCommandLogs(commandID)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Erreur récupération logs",
-		})
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
-		"logs":    logs,
-		"count":   len(logs),
-	})
-}

backend/gestion/handlers/client_tracking.go

@@ -209,7 +209,7 @@ func buildTimeline(logs []map[string]any) []gin.H {
 	for _, logEntry := range logs {
 		status, _ := logEntry["status"].(string)
 		message, _ := logEntry["message"].(string)
-		createdAt, _ := logEntry["created_at"]
+		createdAt := logEntry["created_at"]
 
 		timeline = append(timeline, gin.H{
 			"status":     status,

backend/gestion/handlers/deleviry.go

@@ -627,6 +627,20 @@ func GetMyDeliveryStats(c *gin.Context) {
 		ORDER BY year, month_num
 	`, usernameStr).Scan(&monthRows)
 
+	type TodayRow struct {
+		Count   int     `gorm:"column:count"`
+		Revenue float64 `gorm:"column:revenue"`
+	}
+	var todayRow TodayRow
+	gdb.Raw(`
+		SELECT COUNT(*) AS count,
+		       COALESCE(SUM(total_prix - COALESCE(referral_used, 0)), 0) AS revenue
+		FROM commandes
+		WHERE livreur_assign = ?
+		  AND status IN ('livre', 'approved')
+		  AND DATE(updated_at) = CURRENT_DATE
+	`, usernameStr).Scan(&todayRow)
+
 	monthNames := [13]string{"", "Jan", "Fév", "Mar", "Avr", "Mai", "Jun", "Jul", "Aoû", "Sep", "Oct", "Nov", "Déc"}
 
 	byDay := make([]gin.H, len(dayRows))
@@ -661,9 +675,11 @@ func GetMyDeliveryStats(c *gin.Context) {
 	}
 
 	c.JSON(http.StatusOK, gin.H{
-		"success":  true,
-		"by_day":   byDay,
-		"by_week":  byWeek,
-		"by_month": byMonth,
+		"success":       true,
+		"by_day":        byDay,
+		"by_week":       byWeek,
+		"by_month":      byMonth,
+		"today_count":   todayRow.Count,
+		"today_revenue": todayRow.Revenue,
 	})
 }

backend/gestion/handlers/history.go

@@ -10,80 +10,6 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
-func GetMyCompletedOrders(c *gin.Context) {
-	database := c.MustGet("database").(*db.Database)
-
-	// ✅ SÉCURITÉ: Récupérer depuis JWT validé
-	username, exists := c.Get("username")
-	if !exists {
-		log.Printf("❌ [HISTORY] Utilisateur non authentifié")
-		c.JSON(http.StatusUnauthorized, gin.H{
-			"error": "Authentification requise",
-		})
-		return
-	}
-
-	usernameStr := username.(string)
-	log.Printf("📚 [HISTORY] Récupération historique pour: %s", usernameStr)
-
-	// ✅ Récupérer les commandes terminées (approved)
-	commands, err := database.GetCompletedCommandsByUsername(usernameStr)
-	if err != nil {
-		log.Printf("❌ [HISTORY] Erreur: %v", err)
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Erreur lors de la récupération de l'historique",
-		})
-		return
-	}
-
-	log.Printf("✅ [HISTORY] %d commandes terminées trouvées", len(commands))
-
-	// ✅ Récupérer les infos client pour statistiques
-	client, err := database.GetClientByUsername(usernameStr)
-
-	// ✅ Récupérer les noms et clés des pools de points
-	poolNames := []string{"Pool 1", "Pool 2"}
-	var poolKeys []string
-	if settings, sErr := database.GetSettings(); sErr == nil && len(settings.PointsPools) > 0 {
-		poolNames = make([]string, len(settings.PointsPools))
-		poolKeys = make([]string, len(settings.PointsPools))
-		for i, p := range settings.PointsPools {
-			poolNames[i] = p.Name
-			poolKeys[i] = p.Key
-		}
-	}
-
-	response := gin.H{
-		"success":  true,
-		"commands": commands,
-		"count":    len(commands),
-	}
-
-	if err == nil && client != nil {
-		// Construire le tableau depuis points_extra[poolKey] pour tous les pools (stockage dynamique)
-		poolPoints := make([]int, len(poolKeys))
-		for i, key := range poolKeys {
-			if key != "" {
-				poolPoints[i] = client.PointsExtra[key]
-			}
-		}
-
-		log.Printf("📊 [HISTORY] pool_names=%v pool_keys=%v pool_points=%v extra=%v",
-			poolNames, poolKeys, poolPoints, client.PointsExtra)
-
-		response["client_stats"] = gin.H{
-			"username":       client.Username,
-			"total_commands": client.Command,
-			"points_extra":   client.PointsExtra,
-			"pool_points":    poolPoints,
-			"pool_names":     poolNames,
-			"penalties":      client.Amende,
-		}
-	}
-
-	c.JSON(http.StatusOK, response)
-}
-
 // GetMyCompletedOrdersWithItems récupère l'historique avec les détails des items
 // GET /api/v1/my-commands/history/detailed
 func GetMyCompletedOrdersWithItems(c *gin.Context) {

backend/gestion/handlers/redis_services.go

@@ -947,36 +947,6 @@ func SubtractClientPointsAdmin(c *gin.Context) {
 	})
 }
 
-func GetRealtimeStats(c *gin.Context) {
-	userRole := c.GetString("role")
-	if userRole != "admin" {
-		c.JSON(http.StatusForbidden, gin.H{"error": "Accès refusé"})
-		return
-	}
-
-	stats, err := db.Redis.HGetAll(db.RedisCtx, "stats:realtime").Result()
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Erreur lors de la récupération des statistiques",
-		})
-		return
-	}
-
-	if len(stats) == 0 {
-		c.JSON(http.StatusOK, gin.H{
-			"success": true,
-			"message": "Aucune statistique disponible pour le moment",
-			"stats":   map[string]interface{}{},
-		})
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
-		"stats":   stats,
-	})
-}
-
 func refreshETAForActivDelivery(username string, lat, lon float64) {
 	// 1. Récupérer le statut actuel du livreur
 	statusKey := fmt.Sprintf("delivery:status:%s", username)

backend/gestion/handlers/traffic.go

@@ -1,52 +0,0 @@
-// ============================================
-// handlers/traffic_handlers.go - COMPLET
-// ============================================
-
-package handlers
-
-import (
-	"encoding/json"
-	"strconv"
-)
-
-// getFloatFromMap récupère un float64 depuis une map avec différents types
-func getFloatFromMap(m map[string]any, key string) (float64, bool) {
-	value, exists := m[key]
-	if !exists || value == nil {
-		return 0, false
-	}
-
-	switch v := value.(type) {
-	case float64:
-		return v, true
-	case float32:
-		return float64(v), true
-	case int:
-		return float64(v), true
-	case int64:
-		return float64(v), true
-	case int32:
-		return float64(v), true
-	case json.Number:
-		f, err := v.Float64()
-		if err != nil {
-			return 0, false
-		}
-		return f, true
-	case string:
-		f, err := strconv.ParseFloat(v, 64)
-		if err != nil {
-			return 0, false
-		}
-		return f, true
-	case []byte:
-		s := string(v)
-		f, err := strconv.ParseFloat(s, 64)
-		if err != nil {
-			return 0, false
-		}
-		return f, true
-	default:
-		return 0, false
-	}
-}

backend/gestion/handlers/update_profile.go

@@ -198,9 +198,6 @@ func UpdateClientByAdmin(c *gin.Context) {
 		return
 	}
 
-	// ✅ LOG DEBUG - Voir ce qui est reçu
-	log.Printf("📝 [UPDATE_CLIENT_ADMIN] Requête reçue: %+v", req)
-
 	// Récupérer le client actuel
 	client, err := database.GetClientByID(clientID)
 	if err != nil {