chore: fix bug

backend/gestion/db/db_basket.go

@@ -48,27 +48,9 @@ func (d *Database) GetAllProductsInBasket(username string) ([]models.Panier, err
 func (d *Database) AddRewardsToBasket(username string, items []models.RewardItem, poolKey string) ([]models.Panier, error) {
 	var baskets []models.Panier
 	err := d.GDB.Transaction(func(tx *gorm.DB) error {
-		// Supprimer tout article récompense existant (remplacement)
-		tx.Exec(`DELETE FROM baskets WHERE username = ? AND is_reward = true`, username)
-		for _, item := range items {
-			if item.ProductID <= 0 || item.Quantity <= 0 {
-				continue
-			}
-			var productName string
-			if err := tx.Raw(`SELECT name FROM products WHERE id = ?`, item.ProductID).Scan(&productName).Error; err != nil || productName == "" {
-				return fmt.Errorf("produit récompense introuvable (id=%d)", item.ProductID)
-			}
-			var basket models.Panier
-			if err := tx.Raw(`
-				INSERT INTO baskets (username, product_id, quantity, price, is_reward, reward_pool_key, created_at)
-				VALUES (?, ?, ?, 0, true, ?, CURRENT_TIMESTAMP)
-				RETURNING id, username, product_id, quantity, price, is_reward, reward_pool_key, created_at`,
-				username, item.ProductID, item.Quantity, poolKey).Scan(&basket).Error; err != nil {
-				return err
-			}
-			baskets = append(baskets, basket)
-		}
-		return nil
+		var err error
+		baskets, err = addRewardsToBasketTx(tx, username, items, poolKey)
+		return err
 	})
 	if err != nil {
 		return nil, err
@@ -76,6 +58,36 @@ func (d *Database) AddRewardsToBasket(username string, items []models.RewardItem
 	return baskets, nil
 }
 
+// addRewardsToBasketTx contient la logique de remplacement des articles
+// récompense, factorisée pour être appelée soit seule (AddRewardsToBasket),
+// soit dans la même transaction qu'une autre opération (voir
+// ClaimPoolRewardAndAddToBasket) afin de garantir qu'une récompense n'est
+// jamais consommée sans que son produit soit effectivement livré.
+func addRewardsToBasketTx(tx *gorm.DB, username string, items []models.RewardItem, poolKey string) ([]models.Panier, error) {
+	// Supprimer tout article récompense existant (remplacement)
+	tx.Exec(`DELETE FROM baskets WHERE username = ? AND is_reward = true`, username)
+	var baskets []models.Panier
+	for _, item := range items {
+		if item.ProductID <= 0 || item.Quantity <= 0 {
+			continue
+		}
+		var productName string
+		if err := tx.Raw(`SELECT name FROM products WHERE id = ?`, item.ProductID).Scan(&productName).Error; err != nil || productName == "" {
+			return nil, fmt.Errorf("produit récompense introuvable (id=%d)", item.ProductID)
+		}
+		var basket models.Panier
+		if err := tx.Raw(`
+			INSERT INTO baskets (username, product_id, quantity, price, is_reward, reward_pool_key, created_at)
+			VALUES (?, ?, ?, 0, true, ?, CURRENT_TIMESTAMP)
+			RETURNING id, username, product_id, quantity, price, is_reward, reward_pool_key, created_at`,
+			username, item.ProductID, item.Quantity, poolKey).Scan(&basket).Error; err != nil {
+			return nil, err
+		}
+		baskets = append(baskets, basket)
+	}
+	return baskets, nil
+}
+
 // HasOnlyRewardItems retourne true si le panier ne contient que des articles récompense.
 func (d *Database) HasOnlyRewardItems(username string) (bool, error) {
 	var counts struct {
@@ -163,35 +175,6 @@ func (d *Database) ClearBasket(username string) error {
 	return d.GDB.Exec(`DELETE FROM baskets WHERE username = ?`, username).Error
 }
 
-// ClearBasketOnCheckout décrémente le stock pour chaque article du panier puis vide le panier.
-// C'est ici que le stock est effectivement consommé, au moment de la validation de la commande.
-func (d *Database) ClearBasketOnCheckout(username string) error {
-	return d.GDB.Transaction(func(tx *gorm.DB) error {
-		var items []struct {
-			ProductID int     `gorm:"column:product_id"`
-			Quantity  float64 `gorm:"column:quantity"`
-		}
-		if err := tx.Raw(`SELECT product_id, quantity FROM baskets WHERE username = ? FOR UPDATE`, username).Scan(&items).Error; err != nil {
-			return fmt.Errorf("erreur lecture panier: %w", err)
-		}
-
-		for _, item := range items {
-			var currentStock float64
-			if err := tx.Raw(`SELECT stock FROM products WHERE id = ? FOR UPDATE`, item.ProductID).Scan(&currentStock).Error; err != nil {
-				return fmt.Errorf("erreur lecture stock produit %d: %w", item.ProductID, err)
-			}
-			if currentStock < item.Quantity {
-				return fmt.Errorf("stock insuffisant pour le produit %d", item.ProductID)
-			}
-			if err := tx.Exec(`UPDATE products SET stock = stock - ? WHERE id = ?`, item.Quantity, item.ProductID).Error; err != nil {
-				return fmt.Errorf("erreur décrémentation stock produit %d: %w", item.ProductID, err)
-			}
-		}
-
-		return tx.Exec(`DELETE FROM baskets WHERE username = ?`, username).Error
-	})
-}
-
 func (d *Database) GetBasketItemOwner(basketID int) (string, error) {
 	var username string
 	err := d.GDB.Raw(`SELECT username FROM baskets WHERE id = ?`, basketID).Scan(&username).Error

backend/gestion/db/db_cancel_command.go

@@ -145,20 +145,23 @@ func (d *Database) CancelCommandAtomic(commandID int, username, reason string, f
 	return penalty, nil
 }
 
-// CheckCommandETAExistsAndValid vérifie si une ETA RÉELLE existe (> 0 minutes, non expirée)
+// CheckCommandETAExistsAndValid vérifie si une ETA RÉELLE existe (> 0 minutes, non expirée).
+// La clé command:eta:{id} est un hash (HSet) — un Redis.Get dessus renvoie
+// toujours une erreur WRONGTYPE, ce qui faisait échouer cette vérification à
+// chaque appel (aucune annulation n'était jamais détectée comme tardive via
+// ce chemin, seul le statut en_route/arrived était pris en compte).
 func (d *Database) CheckCommandETAExistsAndValid(commandID int) bool {
 	etaKey := fmt.Sprintf("command:eta:%d", commandID)
 
-	etaMinutesStr, err := Redis.Get(RedisCtx, etaKey).Result()
-	if err != nil {
+	etaData, err := Redis.HGetAll(RedisCtx, etaKey).Result()
+	if err != nil || len(etaData) == 0 {
 		log.Printf("⚠️ [CheckETA] Pas d'ETA trouvée pour cmd %d", commandID)
 		return false
 	}
 
 	var etaMinutes int
-	_, err = fmt.Sscanf(etaMinutesStr, "%d", &etaMinutes)
-	if err != nil || etaMinutes <= 0 {
-		log.Printf("⚠️ [CheckETA] ETA invalide pour cmd %d: %s", commandID, etaMinutesStr)
+	if _, err := fmt.Sscanf(etaData["eta_minutes"], "%d", &etaMinutes); err != nil || etaMinutes <= 0 {
+		log.Printf("⚠️ [CheckETA] ETA invalide pour cmd %d: %s", commandID, etaData["eta_minutes"])
 		return false
 	}
 
@@ -316,13 +319,40 @@ func (d *Database) AddClientPenalty(username string, points int) error {
 	return nil
 }
 
-func (d *Database) RestoreCommandStock(commandID int) error {
+// CancelCommandByAdminAtomic transitionne une commande vers 'cancelled' depuis le
+// panel admin/cabine de façon atomique (verrou FOR UPDATE sur la commande) : le
+// remboursement de stock et le changement de statut se font dans la même
+// transaction, conditionnés à une lecture du statut précédent faite sous verrou.
+// Corrige un double remboursement possible sur double-tap/appel concurrent —
+// l'ancien code (RestoreCommandStock + UpdateCommandStatus appelés séparément
+// par le handler) lisait le statut puis restaurait le stock hors transaction,
+// laissant une fenêtre où deux requêtes concurrentes lisaient toutes les deux
+// "pas encore annulée" et remboursaient chacune le stock.
+func (d *Database) CancelCommandByAdminAtomic(commandID int) error {
 	return d.GDB.Transaction(func(tx *gorm.DB) error {
-		return tx.Exec(`
-			UPDATE products p
-			SET stock = stock + ci.quantite, updated_at = CURRENT_TIMESTAMP
-			FROM command_items ci
-			WHERE ci.command_id = ? AND ci.product_id = p.id`, commandID).Error
+		var prevStatus string
+		if err := tx.Raw(`SELECT status FROM commandes WHERE id = ? FOR UPDATE`, commandID).Scan(&prevStatus).Error; err != nil {
+			return err
+		}
+		if prevStatus == "" {
+			return fmt.Errorf("commande non trouvée")
+		}
+
+		noRestoreStatuses := []string{"cancelled", "approved", "livre"}
+		if !slices.Contains(noRestoreStatuses, prevStatus) {
+			if err := tx.Exec(`
+				UPDATE products p
+				SET stock = stock + ci.quantite, updated_at = CURRENT_TIMESTAMP
+				FROM command_items ci
+				WHERE ci.command_id = ? AND ci.product_id = p.id`, commandID).Error; err != nil {
+				return fmt.Errorf("erreur remboursement stock: %w", err)
+			}
+		}
+
+		if err := tx.Exec(`UPDATE commandes SET status = 'cancelled', updated_at = CURRENT_TIMESTAMP WHERE id = ?`, commandID).Error; err != nil {
+			return fmt.Errorf("erreur mise à jour statut: %w", err)
+		}
+		return nil
 	})
 }
 

backend/gestion/db/db_clients.go

@@ -737,52 +737,88 @@ func (d *Database) GetClientPointsAndRewards(username string) (pointsExtra map[s
 	return pointsExtra, pointsRedeemed, nil
 }
 
+// claimPoolRewardTx vérifie l'éligibilité et consomme une récompense pour un
+// pool donné, dans la transaction fournie — factorisée pour être appelée
+// seule (ClaimPoolReward) ou combinée avec la livraison du produit dans la
+// même transaction (ClaimPoolRewardAndAddToBasket), afin qu'une récompense
+// ne soit jamais consommée sans que son produit soit effectivement livré.
+func claimPoolRewardTx(tx *gorm.DB, username, poolKey string, threshold int) (remainingAvailable int, err error) {
+	var row struct {
+		Points   int `gorm:"column:pts"`
+		Redeemed int `gorm:"column:redeemed"`
+	}
+	if err := tx.Raw(`
+		SELECT
+			COALESCE((points_extra->>?)::int, 0) as pts,
+			COALESCE((points_redeemed->>?)::int, 0) as redeemed
+		FROM clients WHERE username = ? FOR UPDATE`,
+		poolKey, poolKey, username).Scan(&row).Error; err != nil {
+		return 0, fmt.Errorf("erreur lecture: %w", err)
+	}
+
+	earned := row.Points / threshold
+	available := earned - row.Redeemed
+	if available <= 0 {
+		return 0, fmt.Errorf("pas de récompense disponible pour ce pool")
+	}
+
+	if err := tx.Exec(`
+		UPDATE clients
+		SET points_redeemed = jsonb_set(
+			COALESCE(points_redeemed, '{}'::jsonb),
+			ARRAY[?],
+			to_jsonb(COALESCE((points_redeemed->>?)::int, 0) + 1)
+		), updated_at = CURRENT_TIMESTAMP
+		WHERE username = ?`,
+		poolKey, poolKey, username).Error; err != nil {
+		return 0, err
+	}
+
+	return earned - (row.Redeemed + 1), nil
+}
+
 // ClaimPoolReward réclame une récompense pour un pool donné si le client a assez de points.
 // Retourne le nombre de récompenses disponibles restantes après la réclamation.
 func (d *Database) ClaimPoolReward(username, poolKey string, threshold int) (remainingAvailable int, err error) {
-	var points, redeemed int
-
 	err = d.GDB.Transaction(func(tx *gorm.DB) error {
-		var row struct {
-			Points   int `gorm:"column:pts"`
-			Redeemed int `gorm:"column:redeemed"`
-		}
-		if err := tx.Raw(`
-			SELECT
-				COALESCE((points_extra->>?)::int, 0) as pts,
-				COALESCE((points_redeemed->>?)::int, 0) as redeemed
-			FROM clients WHERE username = ? FOR UPDATE`,
-			poolKey, poolKey, username).Scan(&row).Error; err != nil {
-			return fmt.Errorf("erreur lecture: %w", err)
-		}
-		points = row.Points
-		redeemed = row.Redeemed
-
-		earned := points / threshold
-		available := earned - redeemed
-		if available <= 0 {
-			return fmt.Errorf("pas de récompense disponible pour ce pool")
-		}
-
-		return tx.Exec(`
-			UPDATE clients
-			SET points_redeemed = jsonb_set(
-				COALESCE(points_redeemed, '{}'::jsonb),
-				ARRAY[?],
-				to_jsonb(COALESCE((points_redeemed->>?)::int, 0) + 1)
-			), updated_at = CURRENT_TIMESTAMP
-			WHERE username = ?`,
-			poolKey, poolKey, username).Error
+		var err error
+		remainingAvailable, err = claimPoolRewardTx(tx, username, poolKey, threshold)
+		return err
 	})
 	if err != nil {
 		return 0, err
 	}
-
-	earned := points / threshold
-	remainingAvailable = earned - (redeemed + 1)
 	return remainingAvailable, nil
 }
 
+// ClaimPoolRewardAndAddToBasket réclame une récompense ET ajoute les articles
+// récompense au panier dans une seule transaction : si les articles ne
+// peuvent pas être ajoutés (produit supprimé/inexistant configuré par
+// l'admin), toute l'opération est annulée — la récompense n'est pas
+// consommée. Corrige un bug où ClaimPoolReward et AddRewardsToBasket,
+// appelés séparément, pouvaient consommer une récompense sans livrer aucun
+// produit au client si l'ajout au panier échouait après coup.
+func (d *Database) ClaimPoolRewardAndAddToBasket(username, poolKey string, threshold int, items []models.RewardItem) (remainingAvailable int, added []models.Panier, err error) {
+	err = d.GDB.Transaction(func(tx *gorm.DB) error {
+		var err error
+		remainingAvailable, err = claimPoolRewardTx(tx, username, poolKey, threshold)
+		if err != nil {
+			return err
+		}
+		if len(items) > 0 {
+			added, err = addRewardsToBasketTx(tx, username, items, poolKey)
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		return 0, nil, err
+	}
+	return remainingAvailable, added, nil
+}
+
 // ResetClientRedeemed remet à zéro les récompenses réclamées (admin).
 func (d *Database) ResetClientRedeemed(username, poolKey string) error {
 	if poolKey != "" {

backend/gestion/db/db_command_items.go

@@ -6,6 +6,8 @@ import (
 	"slices"
 	"strings"
 	"time"
+
+	"gorm.io/gorm"
 )
 
 // commandItemFull mappe toutes les colonnes de command_items pour les insertions batch avec infos client.
@@ -429,6 +431,12 @@ func ptrStr(s *string) string {
 	return *s
 }
 
+// DeleteCommandItem supprime un item d'une commande et restaure son stock si
+// la commande n'est pas déjà dans un état terminal. Le statut de la commande
+// est verrouillé (FOR UPDATE) avant toute décision, dans la même transaction
+// que la suppression et le remboursement, pour éviter une course avec une
+// annulation concurrente de la commande entière (qui rembourserait déjà cet
+// item) — même classe de bug que celle corrigée sur UpdateCommandStatusAdmin.
 func (d *Database) DeleteCommandItem(commandID, itemID int) error {
 	log.Printf("🗑️ [DeleteCommandItem] START - commandID=%d, itemID=%d", commandID, itemID)
 
@@ -439,61 +447,55 @@ func (d *Database) DeleteCommandItem(commandID, itemID int) error {
 		return err
 	}
 
-	var result struct {
-		Prix      float64 `gorm:"column:prix"`
-		Quantite  float64 `gorm:"column:quantite"`
-		ProductID int     `gorm:"column:product_id"`
-	}
-	if err := d.GDB.Raw(`SELECT prix, quantite, product_id FROM command_items WHERE id = ? AND command_id = ?`, itemID, commandID).Scan(&result).Error; err != nil {
-		return fmt.Errorf("erreur vérification item: %w", err)
-	}
-	if result.Prix == 0 && result.Quantite == 0 {
-		return fmt.Errorf("item %d non trouvé dans la commande %d", itemID, commandID)
-	}
-
-	var cmdStatus string
-	d.GDB.Raw(`SELECT status FROM commandes WHERE id = ?`, commandID).Scan(&cmdStatus)
-
-	noRestoreStatuses := []string{"cancelled", "approved", "livre"}
-	restoreStock := result.ProductID != 0 && !slices.Contains(noRestoreStatuses, cmdStatus)
-
-	tx := d.GDB.Begin()
-	if tx.Error != nil {
-		return fmt.Errorf("erreur démarrage transaction: %w", tx.Error)
-	}
-
-	if err := tx.Exec(`DELETE FROM command_items WHERE id = ?`, itemID).Error; err != nil {
-		tx.Rollback()
-		log.Printf("❌ Erreur DELETE command_items: %v", err)
-		return fmt.Errorf("erreur suppression item: %w", err)
-	}
-
-	if err := tx.Exec(
-		`UPDATE commandes SET total_prix = GREATEST(0, total_prix - ?) WHERE id = ?`,
-		result.Prix*result.Quantite, commandID,
-	).Error; err != nil {
-		tx.Rollback()
-		log.Printf("❌ [DeleteCommandItem] Erreur maj total commande: %v", err)
-		return fmt.Errorf("erreur mise à jour total commande: %w", err)
-	}
-
-	if restoreStock {
-		if err := tx.Exec(
-			`UPDATE products SET stock = stock + ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?`,
-			result.Quantite, result.ProductID,
-		).Error; err != nil {
-			tx.Rollback()
-			log.Printf("❌ [DeleteCommandItem] Erreur restauration stock: %v", err)
-			return fmt.Errorf("erreur restauration stock: %w", err)
+	return d.GDB.Transaction(func(tx *gorm.DB) error {
+		var cmdStatus string
+		if err := tx.Raw(`SELECT status FROM commandes WHERE id = ? FOR UPDATE`, commandID).Scan(&cmdStatus).Error; err != nil {
+			return fmt.Errorf("erreur vérification commande: %w", err)
+		}
+		if cmdStatus == "" {
+			return fmt.Errorf("commande %d non trouvée", commandID)
 		}
-		log.Printf("✅ [DeleteCommandItem] Stock restauré: +%.3f pour produit %d", result.Quantite, result.ProductID)
-	}
 
-	if err := tx.Commit().Error; err != nil {
-		return fmt.Errorf("erreur commit transaction: %w", err)
-	}
+		var result struct {
+			Prix      float64 `gorm:"column:prix"`
+			Quantite  float64 `gorm:"column:quantite"`
+			ProductID int     `gorm:"column:product_id"`
+		}
+		if err := tx.Raw(`SELECT prix, quantite, product_id FROM command_items WHERE id = ? AND command_id = ?`, itemID, commandID).Scan(&result).Error; err != nil {
+			return fmt.Errorf("erreur vérification item: %w", err)
+		}
+		if result.Prix == 0 && result.Quantite == 0 {
+			return fmt.Errorf("item %d non trouvé dans la commande %d", itemID, commandID)
+		}
 
-	return nil
+		if err := tx.Exec(`DELETE FROM command_items WHERE id = ?`, itemID).Error; err != nil {
+			log.Printf("❌ Erreur DELETE command_items: %v", err)
+			return fmt.Errorf("erreur suppression item: %w", err)
+		}
+
+		if err := tx.Exec(
+			`UPDATE commandes SET total_prix = GREATEST(0, total_prix - ?) WHERE id = ?`,
+			result.Prix*result.Quantite, commandID,
+		).Error; err != nil {
+			log.Printf("❌ [DeleteCommandItem] Erreur maj total commande: %v", err)
+			return fmt.Errorf("erreur mise à jour total commande: %w", err)
+		}
+
+		noRestoreStatuses := []string{"cancelled", "approved", "livre"}
+		restoreStock := result.ProductID != 0 && !slices.Contains(noRestoreStatuses, cmdStatus)
+		if restoreStock {
+			if err := tx.Exec(
+				`UPDATE products SET stock = stock + ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?`,
+				result.Quantite, result.ProductID,
+			).Error; err != nil {
+				log.Printf("❌ [DeleteCommandItem] Erreur restauration stock: %v", err)
+				return fmt.Errorf("erreur restauration stock: %w", err)
+			}
+			log.Printf("✅ [DeleteCommandItem] Stock restauré: +%.3f pour produit %d", result.Quantite, result.ProductID)
+		}
+
+		return nil
+	})
 }
 
 func (d *Database) UpdateCommandItemStatus(itemID int, status string) error {

backend/gestion/db/db_commands.go

@@ -77,103 +77,6 @@ func validateCommandStatus(status string) error {
 	return nil
 }
 
-func (d *Database) CreateCommand(username string) (*models.Command, error) {
-	adresse := "Adresse non spécifiée"
-	var clientCheck models.Client
-	if err := d.GDB.Select("username").Where("username = ?", username).First(&clientCheck).Error; err == nil && clientCheck.Username != "" {
-		adresse = clientCheck.Username
-	}
-
-	var command *models.Command
-	err := d.GDB.Transaction(func(tx *gorm.DB) error {
-		// Verrou sur le panier : un double-submit concurrent du même client se
-		// bloque ici puis échoue proprement ("panier vide") une fois le premier
-		// passage terminé, au lieu de créer une commande fantôme.
-		var basketItems []basketItem
-		if err := tx.Raw(`SELECT product_id, quantity, price, is_reward, reward_pool_key FROM baskets WHERE username = ? FOR UPDATE`, username).Scan(&basketItems).Error; err != nil {
-			return fmt.Errorf("erreur récupération panier: %w", err)
-		}
-		if len(basketItems) == 0 {
-			return fmt.Errorf("le panier est vide")
-		}
-		totalPrix := 0.0
-		for _, item := range basketItems {
-			totalPrix += item.Price
-		}
-
-		var cmdResult struct {
-			ID            int `gorm:"column:id"`
-			ClientOrderID int `gorm:"column:client_order_id"`
-		}
-		if err := tx.Raw(`
-			INSERT INTO commandes (username, status, adresse, total_prix, client_order_id, created_at, updated_at)
-			VALUES (?, ?, ?, ?, (SELECT COALESCE(MAX(client_order_id), 0) + 1 FROM commandes WHERE username = ?), CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
-			RETURNING id, client_order_id`,
-			username, "pending", adresse, totalPrix, username).Scan(&cmdResult).Error; err != nil {
-			return fmt.Errorf("erreur lors de la création de la commande: %w", err)
-		}
-		commandID := cmdResult.ID
-
-		productIDs := make([]int, 0, len(basketItems))
-		for _, item := range basketItems {
-			productIDs = append(productIDs, item.ProductID)
-		}
-		productNames, _ := d.GetProductNamesByIDs(productIDs)
-
-		cmdItems := make([]models.CommandItem, 0, len(basketItems))
-		for _, item := range basketItems {
-			productName := productNames[item.ProductID]
-			if productName == "" {
-				productName = "Produit inconnu"
-			}
-			cmdItems = append(cmdItems, models.CommandItem{
-				CommandID:     commandID,
-				Produit:       productName,
-				ProductID:     item.ProductID,
-				Quantity:      item.Quantity,
-				Price:         item.Price,
-				IsReward:      item.IsReward,
-				RewardPoolKey: item.RewardPoolKey,
-			})
-		}
-		if err := tx.Create(&cmdItems).Error; err != nil {
-			return fmt.Errorf("erreur lors de l'insertion des items: %w", err)
-		}
-
-		// Les articles récompense (payés en points) restent des produits physiques
-		// réellement distribués : le stock doit être décrémenté comme pour un
-		// article payant.
-		for _, item := range basketItems {
-			var currentStock float64
-			if err := tx.Raw(`SELECT stock FROM products WHERE id = ? FOR UPDATE`, item.ProductID).Scan(&currentStock).Error; err != nil {
-				return fmt.Errorf("erreur lecture stock produit %d: %w", item.ProductID, err)
-			}
-			if currentStock < item.Quantity {
-				return fmt.Errorf("stock insuffisant pour le produit %d", item.ProductID)
-			}
-			if err := tx.Exec(`UPDATE products SET stock = stock - ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?`, item.Quantity, item.ProductID).Error; err != nil {
-				return fmt.Errorf("erreur décrémentation stock produit %d: %w", item.ProductID, err)
-			}
-		}
-		if err := tx.Exec(`DELETE FROM baskets WHERE username = ?`, username).Error; err != nil {
-			return err
-		}
-
-		command = &models.Command{
-			ID:            commandID,
-			ClientOrderID: cmdResult.ClientOrderID,
-			Status:        "pending",
-			Total:         totalPrix,
-		}
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return command, nil
-}
-
 func (d *Database) CreateCommandWithAddress(username, deliveryAddress string) (*models.Command, error) {
 	if err := validateUsername(username); err != nil {
 		return nil, err

backend/gestion/db/db_notifications.go

@@ -36,7 +36,7 @@ func (d *Database) NotifyClient(username string, commandID int, notifType, messa
 	pipe := Redis.Pipeline()
 	pipe.LPush(RedisCtx, notifKey, notifJSON)
 	pipe.LTrim(RedisCtx, notifKey, 0, 199)
-	pipe.Expire(RedisCtx, notifKey, 7*24*time.Hour)
+	pipe.Expire(RedisCtx, notifKey, time.Hour)
 	pipe.Exec(RedisCtx) //nolint
 
 	if services.TelegramBot != nil && services.TelegramBot.IsNotificationsEnabled() {
@@ -69,7 +69,7 @@ func (d *Database) NotifyLivreur(username string, commandID int, notifType, mess
 	pipe2 := Redis.Pipeline()
 	pipe2.LPush(RedisCtx, notifKey, notifJSON)
 	pipe2.LTrim(RedisCtx, notifKey, 0, 199)
-	pipe2.Expire(RedisCtx, notifKey, 7*24*time.Hour)
+	pipe2.Expire(RedisCtx, notifKey, time.Hour)
 	pipe2.Exec(RedisCtx) //nolint
 
 	if services.TelegramBot != nil && services.TelegramBot.IsNotificationsEnabled() {
@@ -112,7 +112,7 @@ func (d *Database) NotifyAllAdminCabine(commandID int, clientUsername, deliveryA
 		notifKey := fmt.Sprintf("notifications:%s", u.Username)
 		pipe.LPush(RedisCtx, notifKey, notifJSON)
 		pipe.LTrim(RedisCtx, notifKey, 0, 199)
-		pipe.Expire(RedisCtx, notifKey, 7*24*time.Hour)
+		pipe.Expire(RedisCtx, notifKey, time.Hour)
 	}
 	pipe.Exec(RedisCtx) //nolint
 
@@ -153,7 +153,7 @@ func (d *Database) NotifyAllAdminCabineAlert(alertID int, livreurUsername, alert
 		notifKey := fmt.Sprintf("notifications:%s", u.Username)
 		pipe.LPush(RedisCtx, notifKey, notifJSON)
 		pipe.LTrim(RedisCtx, notifKey, 0, 199)
-		pipe.Expire(RedisCtx, notifKey, 7*24*time.Hour)
+		pipe.Expire(RedisCtx, notifKey, time.Hour)
 	}
 	pipe.Exec(RedisCtx) //nolint
 

backend/gestion/db/db_stat.go

@@ -223,7 +223,9 @@ func (d *Database) TopProducts(prodRows *[]models.ProductRow, resetAt time.Time,
 			ci.produit                              AS name,
 			SUM(ci.quantite)                        AS total_quantity,
 			COUNT(DISTINCT ci.command_id)           AS order_count,
-			SUM(CASE WHEN c.status = 'approved' THEN ci.prix ELSE 0 END) AS revenue,
+			SUM(CASE WHEN c.status = 'approved'
+			    THEN ci.prix * (c.total_prix - COALESCE(c.referral_used, 0)) / NULLIF(c.total_prix, 0)
+			    ELSE 0 END) AS revenue,
 			COALESCE(p.category, '')                AS category,
 			COALESCE(cat.color, '#7c3aed')          AS category_color
 		FROM command_items ci
@@ -251,7 +253,9 @@ func (d *Database) QuantityBreakdown(qtyRows *[]models.QuantityBreakdownRow, res
 			ci.quantite                          AS quantity,
 			COUNT(DISTINCT ci.command_id)        AS order_count,
 			SUM(ci.quantite)                     AS total_sold,
-			SUM(CASE WHEN c.status = 'approved' THEN ci.prix ELSE 0 END) AS revenue,
+			SUM(CASE WHEN c.status = 'approved'
+			    THEN ci.prix * (c.total_prix - COALESCE(c.referral_used, 0)) / NULLIF(c.total_prix, 0)
+			    ELSE 0 END) AS revenue,
 			COALESCE(cat.color, '#7c3aed')       AS category_color
 		FROM command_items ci
 		JOIN commandes c ON c.id = ci.command_id
@@ -277,7 +281,9 @@ func (d *Database) DailyProductDetail(dailyRows *[]models.DailyProductRow) error
 			COALESCE(cat.color, '#7c3aed')         AS category_color,
 			SUM(ci.quantite)                        AS total_quantity,
 			COUNT(DISTINCT ci.command_id)           AS order_count,
-			SUM(CASE WHEN c.status = 'approved' THEN ci.prix ELSE 0 END) AS revenue
+			SUM(CASE WHEN c.status = 'approved'
+			    THEN ci.prix * (c.total_prix - COALESCE(c.referral_used, 0)) / NULLIF(c.total_prix, 0)
+			    ELSE 0 END) AS revenue
 		FROM command_items ci
 		JOIN commandes c ON c.id = ci.command_id
 		LEFT JOIN products p   ON p.id = ci.product_id
@@ -302,7 +308,9 @@ func (d *Database) DailyProductDetailForDate(dailyRows *[]models.DailyProductRow
 			COALESCE(cat.color, '#7c3aed')         AS category_color,
 			SUM(ci.quantite)                        AS total_quantity,
 			COUNT(DISTINCT ci.command_id)           AS order_count,
-			SUM(CASE WHEN c.status = 'approved' THEN ci.prix ELSE 0 END) AS revenue
+			SUM(CASE WHEN c.status = 'approved'
+			    THEN ci.prix * (c.total_prix - COALESCE(c.referral_used, 0)) / NULLIF(c.total_prix, 0)
+			    ELSE 0 END) AS revenue
 		FROM command_items ci
 		JOIN commandes c ON c.id = ci.command_id
 		LEFT JOIN products p   ON p.id = ci.product_id

backend/gestion/db/redis_eta_management.go

@@ -163,8 +163,15 @@ func (d *Database) SetCommandETAWithDetails(commandID, totalETA, queuePosition i
 	arrivalTime := now.Add(time.Duration(totalETA) * time.Minute)
 
 	eta := map[string]any{
-		"command_id":        commandID,
+		"command_id": commandID,
+		// total_eta_minutes ET eta_minutes doivent tous les deux être présents :
+		// l'app mobile et le site web lisent eta_minutes (voir
+		// OrderTrackingScreen.tsx / api.ts), tandis que d'autres lecteurs
+		// backend (deleviry.go, validation_deleviry.go, geoloca.go) lisent
+		// total_eta_minutes. Un seul des deux absent reproduit le bug
+		// "le client ne voit pas le temps".
 		"total_eta_minutes": totalETA,
+		"eta_minutes":       totalETA,
 		"queue_position":    queuePosition,
 		"updated_at":        now.Unix(),
 		"arrival_time":      arrivalTime.Unix(),