chore: build

backend/gestion/db/db_cancel_command.go

@@ -325,3 +325,43 @@ func (d *Database) RestoreCommandStock(commandID int) error {
 			WHERE ci.command_id = ? AND ci.product_id = p.id`, commandID).Error
 	})
 }
+
+// CancelDeliveryByLivreurAtomic annule une commande côté livreur et restaure le stock
+// de manière atomique (verrou FOR UPDATE + transition conditionnée à l'ancien statut).
+// Idempotent : si la commande est déjà annulée, ne touche pas au stock et renvoie
+// alreadyCancelled=true — évite un remboursement en double en cas de double appel
+// (double-tap, retry réseau, ou commande déjà annulée par un autre canal).
+func (d *Database) CancelDeliveryByLivreurAtomic(commandID int) (alreadyCancelled bool, prevStatus string, err error) {
+	err = d.GDB.Transaction(func(tx *gorm.DB) error {
+		if e := tx.Raw(`SELECT status FROM commandes WHERE id = ? FOR UPDATE`, commandID).Scan(&prevStatus).Error; e != nil {
+			return e
+		}
+		if prevStatus == "" {
+			return fmt.Errorf("commande non trouvée")
+		}
+		if prevStatus == "cancelled" {
+			alreadyCancelled = true
+			return nil
+		}
+
+		result := tx.Exec(`
+			UPDATE commandes SET status = 'cancelled', updated_at = CURRENT_TIMESTAMP
+			WHERE id = ? AND status = ?`, commandID, prevStatus)
+		if result.Error != nil {
+			return result.Error
+		}
+		if result.RowsAffected == 0 {
+			return fmt.Errorf("commande déjà modifiée par une autre requête")
+		}
+
+		if e := 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; e != nil {
+			return fmt.Errorf("erreur remboursement stock: %w", e)
+		}
+		return nil
+	})
+	return
+}

backend/gestion/db/db_commands.go

@@ -96,64 +96,66 @@ func (d *Database) CreateCommand(username string) (*models.Command, error) {
 		adresse = clientCheck.Username
 	}
 
-	basketItems, totalPrix, err := d.fetchBasketItems(username)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(basketItems) == 0 {
-		return nil, fmt.Errorf("le panier est vide")
-	}
-
-	var cmdResult struct {
-		ID            int       `gorm:"column:id"`
-		ClientOrderID int       `gorm:"column:client_order_id"`
-		CreatedAt     time.Time `gorm:"column:created_at"`
-		UpdatedAt     time.Time `gorm:"column:updated_at"`
-	}
-	err = d.GDB.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, created_at, updated_at`,
-		username, "pending", adresse, totalPrix, username).Scan(&cmdResult).Error
-	if err != nil {
-		return nil, 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"
+	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)
 		}
-		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 := d.GDB.Create(&cmdItems).Error; err != nil {
-		return nil, fmt.Errorf("erreur lors de l'insertion des items: %w", err)
-	}
-
-	// Décrémenter le stock et vider le panier de manière atomique.
-	if err := d.GDB.Transaction(func(tx *gorm.DB) error {
+		if len(basketItems) == 0 {
+			return fmt.Errorf("le panier est vide")
+		}
+		totalPrix := 0.0
 		for _, item := range basketItems {
-			if item.IsReward {
-				continue
+			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)
@@ -165,16 +167,20 @@ func (d *Database) CreateCommand(username string) (*models.Command, error) {
 				return fmt.Errorf("erreur décrémentation stock produit %d: %w", item.ProductID, err)
 			}
 		}
-		return tx.Exec(`DELETE FROM baskets WHERE username = ?`, username).Error
-	}); err != nil {
-		return nil, 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,
+		command = &models.Command{
+			ID:            commandID,
+			ClientOrderID: cmdResult.ClientOrderID,
+			Status:        "pending",
+			Total:         totalPrix,
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, err
 	}
 
 	return command, nil
@@ -203,83 +209,84 @@ func (d *Database) CreateCommandWithAddress(username, deliveryAddress string) (*
 		clientTelephone = sanitizeString(client.Telephone)
 	}
 
-	basketItems, totalPrix, err := d.fetchBasketItems(username)
-	if err != nil {
-		log.Printf("❌ Erreur query basket: %v", err)
-		return nil, err
-	}
-
-	if len(basketItems) == 0 {
-		return nil, fmt.Errorf("le panier est vide")
-	}
-
-	for _, item := range basketItems {
-		if item.ProductID <= 0 || item.Quantity <= 0 || item.Price < 0 {
-			return nil, fmt.Errorf("données panier invalides")
+	var (
+		command   *models.Command
+		totalPrix float64
+	)
+	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 totalPrix <= 0 || totalPrix > 100000 {
-		return nil, fmt.Errorf("montant de commande invalide: %.2f€", totalPrix)
-	}
-
-	var cmdResult struct {
-		ID            int       `gorm:"column:id"`
-		ClientOrderID int       `gorm:"column:client_order_id"`
-		CreatedAt     time.Time `gorm:"column:created_at"`
-		UpdatedAt     time.Time `gorm:"column:updated_at"`
-	}
-	err = d.GDB.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, created_at, updated_at`,
-		username, "pending", deliveryAddress, totalPrix, username).Scan(&cmdResult).Error
-	if err != nil {
-		return nil, fmt.Errorf("erreur création commande: %w", err)
-	}
-
-	commandID := cmdResult.ID
-
-	productIDs2 := make([]int, 0, len(basketItems))
-	for _, item := range basketItems {
-		productIDs2 = append(productIDs2, item.ProductID)
-	}
-	productNames2, _ := d.GetProductNamesByIDs(productIDs2)
-
-	batchItems := make([]commandItemFull, 0, len(basketItems))
-	for _, item := range basketItems {
-		productName := productNames2[item.ProductID]
-		if productName == "" {
-			productName = fmt.Sprintf("Produit #%d", item.ProductID)
+		if len(basketItems) == 0 {
+			return fmt.Errorf("le panier est vide")
 		}
-		batchItems = append(batchItems, commandItemFull{
-			CommandID:       commandID,
-			Produit:         productName,
-			ProductID:       item.ProductID,
-			Quantite:        item.Quantity,
-			Prix:            item.Price,
-			IsReward:        item.IsReward,
-			RewardPoolKey:   item.RewardPoolKey,
-			ClientUsername:  username,
-			ClientNom:       clientNom,
-			ClientPrenom:    clientPrenom,
-			ClientTelephone: clientTelephone,
-			DeliveryAddress: deliveryAddress,
-			Status:          "pending",
-		})
-		// Stock déjà déduit à l'ajout au panier — ne pas déduire une seconde fois ici.
-	}
-	if err := d.InsertCommandItemsBatch(batchItems); err != nil {
-		log.Printf("❌ Erreur INSERT command_items batch: %v", err)
-		return nil, fmt.Errorf("erreur insertion items: %w", err)
-	}
 
-	// Décrémenter le stock et vider le panier de manière atomique.
-	if err := d.GDB.Transaction(func(tx *gorm.DB) error {
 		for _, item := range basketItems {
-			if item.IsReward {
-				continue
+			if item.ProductID <= 0 || item.Quantity <= 0 || item.Price < 0 {
+				return fmt.Errorf("données panier invalides")
 			}
+			totalPrix += item.Price
+		}
+
+		if totalPrix <= 0 || totalPrix > 100000 {
+			return fmt.Errorf("montant de commande invalide: %.2f€", totalPrix)
+		}
+
+		var cmdResult struct {
+			ID            int       `gorm:"column:id"`
+			ClientOrderID int       `gorm:"column:client_order_id"`
+			CreatedAt     time.Time `gorm:"column:created_at"`
+			UpdatedAt     time.Time `gorm:"column:updated_at"`
+		}
+		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, created_at, updated_at`,
+			username, "pending", deliveryAddress, totalPrix, username).Scan(&cmdResult).Error; err != nil {
+			return fmt.Errorf("erreur création commande: %w", err)
+		}
+		commandID := cmdResult.ID
+
+		productIDs2 := make([]int, 0, len(basketItems))
+		for _, item := range basketItems {
+			productIDs2 = append(productIDs2, item.ProductID)
+		}
+		productNames2, _ := d.GetProductNamesByIDs(productIDs2)
+
+		batchItems := make([]commandItemFull, 0, len(basketItems))
+		for _, item := range basketItems {
+			productName := productNames2[item.ProductID]
+			if productName == "" {
+				productName = fmt.Sprintf("Produit #%d", item.ProductID)
+			}
+			batchItems = append(batchItems, commandItemFull{
+				CommandID:       commandID,
+				Produit:         productName,
+				ProductID:       item.ProductID,
+				Quantite:        item.Quantity,
+				Prix:            item.Price,
+				IsReward:        item.IsReward,
+				RewardPoolKey:   item.RewardPoolKey,
+				ClientUsername:  username,
+				ClientNom:       clientNom,
+				ClientPrenom:    clientPrenom,
+				ClientTelephone: clientTelephone,
+				DeliveryAddress: deliveryAddress,
+				Status:          "pending",
+			})
+		}
+		if err := tx.Create(&batchItems).Error; err != nil {
+			return fmt.Errorf("erreur insertion 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)
@@ -291,29 +298,33 @@ func (d *Database) CreateCommandWithAddress(username, deliveryAddress string) (*
 				return fmt.Errorf("erreur décrémentation stock produit %d: %w", item.ProductID, err)
 			}
 		}
-		return tx.Exec(`DELETE FROM baskets WHERE username = ?`, username).Error
-	}); err != nil {
-		log.Printf("❌ Erreur décrément stock / vidage panier: %v", err)
+		if err := tx.Exec(`DELETE FROM baskets WHERE username = ?`, username).Error; err != nil {
+			return err
+		}
+
+		command = &models.Command{
+			ID:              commandID,
+			ClientOrderID:   cmdResult.ClientOrderID,
+			Username:        username,
+			Status:          "pending",
+			Total:           totalPrix,
+			DeliveryAddress: deliveryAddress,
+			CreatedAt:       cmdResult.CreatedAt,
+			UpdatedAt:       cmdResult.UpdatedAt,
+		}
+		return nil
+	})
+	if err != nil {
+		log.Printf("❌ Erreur création commande: %v", err)
 		return nil, err
 	}
 
 	sanitizedAddress := sanitizeLogMessage(deliveryAddress)
-	d.AddCommandLog(commandID, "created",
+	d.AddCommandLog(command.ID, "created",
 		fmt.Sprintf("Commande créée - Adresse: %s - Total: %.2f€ - Client: %s %s",
 			sanitizedAddress, totalPrix, sanitizeLogMessage(clientNom), sanitizeLogMessage(clientPrenom)),
 		username)
 
-	command := &models.Command{
-		ID:              commandID,
-		ClientOrderID:   cmdResult.ClientOrderID,
-		Username:        username,
-		Status:          "pending",
-		Total:           totalPrix,
-		DeliveryAddress: deliveryAddress,
-		CreatedAt:       cmdResult.CreatedAt,
-		UpdatedAt:       cmdResult.UpdatedAt,
-	}
-
 	return command, nil
 }
 

backend/gestion/db/db_stat.go

@@ -190,13 +190,17 @@ func (d *Database) StatsByDayForMonth(rows *[]DailyMonthStatRow, monthStart time
 	return d.GDB.Raw(query, args...).Scan(rows).Error
 }
 
+// OrdersAndRevenueByHour renvoie, par heure, le nombre de commandes non annulées
+// (volume d'activité) et le revenu confirmé (commandes approuvées uniquement —
+// cohérent avec TotalRevenue/RevenueByDayLast30, pour ne pas compter comme
+// "revenu" une commande encore en cours qui pourrait être annulée).
 func (d *Database) OrdersAndRevenueByHour(hourRows *[]models.HourRow, resetAt time.Time) error {
 	where, args := statusFilterClause("status != 'cancelled'", resetAt)
 	query := `
 		SELECT
 			EXTRACT(HOUR FROM created_at)::int AS hour,
 			COUNT(*)                           AS count,
-			COALESCE(SUM(total_prix - COALESCE(referral_used, 0)), 0) AS revenue
+			COALESCE(SUM(CASE WHEN status = 'approved' THEN total_prix - COALESCE(referral_used, 0) ELSE 0 END), 0) AS revenue
 		FROM commandes
 		WHERE ` + where + `
 		GROUP BY hour
@@ -207,6 +211,9 @@ func (d *Database) OrdersAndRevenueByHour(hourRows *[]models.HourRow, resetAt ti
 
 // ── Top produits (quantité vendue) ───────────────────────────────────────────
 
+// TopProducts renvoie les produits les plus commandés. La quantité/le nombre de
+// commandes reflètent l'activité (non annulées), le revenu ne compte que les
+// commandes approuvées (revenu confirmé, cohérent avec le résumé global).
 func (d *Database) TopProducts(prodRows *[]models.ProductRow, resetAt time.Time, limit int) error {
 	where, args := statusFilterClause("c.status != 'cancelled'", resetAt)
 	args = append(args, limit)
@@ -216,7 +223,7 @@ 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(ci.prix)              AS revenue,
+			SUM(CASE WHEN c.status = 'approved' THEN ci.prix ELSE 0 END) AS revenue,
 			COALESCE(p.category, '')                AS category,
 			COALESCE(cat.color, '#7c3aed')          AS category_color
 		FROM command_items ci
@@ -233,6 +240,8 @@ func (d *Database) TopProducts(prodRows *[]models.ProductRow, resetAt time.Time,
 
 // ── Répartition des doses/quantités par produit ──────────────────────────────
 
+// QuantityBreakdown : quantité/nombre de commandes reflètent l'activité (non
+// annulées), le revenu ne compte que les commandes approuvées (revenu confirmé).
 func (d *Database) QuantityBreakdown(qtyRows *[]models.QuantityBreakdownRow, resetAt time.Time) error {
 	where, args := statusFilterClause("c.status != 'cancelled'", resetAt)
 	query := `
@@ -242,7 +251,7 @@ 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(ci.prix)           AS revenue,
+			SUM(CASE WHEN c.status = 'approved' THEN ci.prix 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
@@ -257,6 +266,8 @@ func (d *Database) QuantityBreakdown(qtyRows *[]models.QuantityBreakdownRow, res
 
 // ── Détail du jour (catégorie → produits) ────────────────────────────────────
 
+// DailyProductDetail : quantité/nombre de commandes reflètent l'activité (non
+// annulées), le revenu ne compte que les commandes approuvées (revenu confirmé).
 func (d *Database) DailyProductDetail(dailyRows *[]models.DailyProductRow) error {
 	query := `
 		SELECT
@@ -266,7 +277,7 @@ 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(ci.prix)                            AS revenue
+			SUM(CASE WHEN c.status = 'approved' THEN ci.prix 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
@@ -291,7 +302,7 @@ 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(ci.prix)                            AS revenue
+			SUM(CASE WHEN c.status = 'approved' THEN ci.prix 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/handlers/crypto_payment.go

@@ -15,8 +15,9 @@ import (
 // IPNWebhook - POST /api/v1/webhooks/nowpayments
 func IPNWebhook(c *gin.Context) {
 	database := c.MustGet("database").(*db.Database)
-	np, ok := c.MustGet("nowpayments").(*services.NowPaymentsClient)
-	if !ok || np == nil {
+	npRaw, npExists := c.Get("nowpayments")
+	np, ok := npRaw.(*services.NowPaymentsClient)
+	if !npExists || !ok || np == nil {
 		c.JSON(http.StatusServiceUnavailable, gin.H{"error": "paiement crypto non configuré"})
 		return
 	}

backend/gestion/handlers/deleviry.go

@@ -272,22 +272,34 @@ func UpdateDeliveryStatus(c *gin.Context) {
 		}
 	}
 
-	// Mettre à jour le statut
-	if err := database.UpdateCommandStatus(commandID, req.Status); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Erreur mise à jour",
-		})
-		return
-	}
-
+	// Mettre à jour le statut.
+	// Le cas "cancelled" passe par une transaction atomique dédiée (transition +
+	// remboursement stock), pour empêcher tout double remboursement en cas de
+	// double appel (double-tap, retry réseau, commande déjà annulée ailleurs).
 	if req.Status == "cancelled" {
+		alreadyCancelled, prevStatus, cancelErr := database.CancelDeliveryByLivreurAtomic(commandID)
+		if cancelErr != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Erreur mise à jour",
+			})
+			return
+		}
+		if alreadyCancelled {
+			c.JSON(http.StatusOK, gin.H{
+				"success":    true,
+				"message":    "Commande déjà annulée",
+				"command_id": commandID,
+				"status":     "cancelled",
+			})
+			return
+		}
+
 		cancelMsg := req.Notes
 		if cancelMsg == "" {
 			cancelMsg = "Annulé par le livreur"
 		}
 		database.SetCommandCancelReason(commandID, fmt.Sprintf("[Livreur: %s] %s", usernameStr, cancelMsg))
 
-		prevStatus, _ := command["status"].(string)
 		if prevStatus == "arrived" || prevStatus == "livre" {
 			clientUsername, _ := command["username"].(string)
 			if clientUsername != "" {
@@ -298,6 +310,11 @@ func UpdateDeliveryStatus(c *gin.Context) {
 				}
 			}
 		}
+	} else if err := database.UpdateCommandStatus(commandID, req.Status); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"error": "Erreur mise à jour",
+		})
+		return
 	}
 
 	// ✅ SI PASSAGE EN "EN_ROUTE" → CALCULER ET DÉFINIR L'ETA
@@ -454,15 +471,8 @@ func UpdateDeliveryStatus(c *gin.Context) {
 		database.CompleteDeliveryAndProcessNext(usernameStr, commandID)
 
 	case "cancelled":
+		// Transition + remboursement stock déjà effectués atomiquement plus haut.
 		log.Printf("🚫 Livraison annulée par livreur - Nettoyage queue cmd %d", commandID)
-		prevStatus, _ := command["status"].(string)
-		if prevStatus == "cancelled" {
-			log.Printf("⏭️ [STATUS_LIVREUR] Stock NON restitué - commande déjà annulée (cmd %d)", commandID)
-		} else if err := database.RestoreCommandStock(commandID); err != nil {
-			log.Printf("⚠️ [STATUS_LIVREUR] Erreur restauration stock cmd %d: %v", commandID, err)
-		} else {
-			log.Printf("✅ [STATUS_LIVREUR] Stock restauré pour cmd %d", commandID)
-		}
 		database.CompleteDeliveryAndProcessNext(usernameStr, commandID)
 
 	case "arrived":

backend/gestion/handlers/panier.go

@@ -417,8 +417,9 @@ func ValidateBasket(c *gin.Context) {
 	// Vérification option crypto
 	isCrypto := req.PaymentMethod == "crypto"
 	if isCrypto {
-		np, npOk := c.MustGet("nowpayments").(*services.NowPaymentsClient)
-		if !npOk || np == nil {
+		npRaw, npExists := c.Get("nowpayments")
+		np, npOk := npRaw.(*services.NowPaymentsClient)
+		if !npExists || !npOk || np == nil {
 			c.JSON(http.StatusServiceUnavailable, gin.H{"error": "Paiement crypto non disponible"})
 			return
 		}