chore: build

backend/gestion/handlers/deleviry.go

@@ -155,9 +155,10 @@ func GetDeliveryDetails(c *gin.Context) {
 	itemsSummary := make([]gin.H, len(items))
 	for i, item := range items {
 		itemsSummary[i] = gin.H{
-			"produit":  item["produit"],
-			"quantite": item["quantite"],
-			"prix":     item["prix"],
+			"produit":   item["produit"],
+			"quantite":  item["quantite"],
+			"prix":      item["prix"],
+			"is_reward": item["is_reward"],
 		}
 	}
 

backend/gestion/handlers/points.go

@@ -1,22 +1,35 @@
 package handlers
 
 import (
+	"fmt"
 	"gestion/db"
 	"gestion/models"
 	"gestion/utils"
 	"log"
+	"math"
 	"net/http"
 	"strings"
 
 	"github.com/gin-gonic/gin"
 )
 
-// eligibleRewardProductIDs détermine, pour un pool donné, quels product_id de
-// reward.RewardItems sont éligibles : sa catégorie (via CategoryConfigs) doit
-// faire partie des catégories du pool, soit par whitelist explicite (ProductIDs)
-// soit par correspondance de catégorie produit (AllProducts).
-func eligibleRewardProductIDs(reward *models.PointsReward, poolCategories map[string]bool, productCategories map[int]string) map[int]bool {
-	eligible := make(map[int]bool)
+// normalizeRewardCategoryType retombe sur "free_product" pour toute valeur
+// vide ou inconnue — rétrocompatibilité avec les configurations enregistrées
+// avant l'introduction du type par catégorie (RewardCategoryConfig.Type).
+func normalizeRewardCategoryType(t string) string {
+	if t == "half_price_product" {
+		return "half_price_product"
+	}
+	return "free_product"
+}
+
+// eligibleRewardProducts détermine, pour un pool donné, quels product_id de
+// reward.RewardItems sont éligibles et avec quel type de récompense
+// ("free_product" | "half_price_product") : sa catégorie (via CategoryConfigs)
+// doit faire partie des catégories du pool, soit par whitelist explicite
+// (ProductIDs) soit par correspondance de catégorie produit (AllProducts).
+func eligibleRewardProducts(reward *models.PointsReward, poolCategories map[string]bool, productCategories map[int]string) map[int]string {
+	eligible := make(map[int]string)
 	if reward == nil {
 		return eligible
 	}
@@ -24,21 +37,62 @@ func eligibleRewardProductIDs(reward *models.PointsReward, poolCategories map[st
 		if !poolCategories[cfg.Category] {
 			continue
 		}
+		rewardType := normalizeRewardCategoryType(cfg.Type)
 		if cfg.AllProducts {
 			for pid, cat := range productCategories {
 				if cat == cfg.Category {
-					eligible[pid] = true
+					eligible[pid] = rewardType
 				}
 			}
 		} else {
 			for _, pid := range cfg.ProductIDs {
-				eligible[pid] = true
+				eligible[pid] = rewardType
 			}
 		}
 	}
 	return eligible
 }
 
+// categoryConfigTypeForProduct détermine le type de récompense applicable à un
+// produit à partir de sa catégorie catalogue, sans filtrer par pool — utilisé
+// pour l'aperçu global (rewardMeta) qui n'est pas rattaché à un pool précis.
+func categoryConfigTypeForProduct(reward *models.PointsReward, productID int, productCategory string) string {
+	for _, cfg := range reward.CategoryConfigs {
+		matches := false
+		if cfg.AllProducts {
+			matches = cfg.Category == productCategory
+		} else {
+			for _, pid := range cfg.ProductIDs {
+				if pid == productID {
+					matches = true
+					break
+				}
+			}
+		}
+		if matches {
+			return normalizeRewardCategoryType(cfg.Type)
+		}
+	}
+	return "free_product"
+}
+
+// effectiveRewardPrice calcule le prix réellement facturé pour un item
+// récompense selon le type de sa catégorie : 0€ pour "free_product", 50% du
+// prix catalogue actif (palier correspondant à la quantité) pour
+// "half_price_product". Erreur si le prix catalogue est introuvable (produit
+// désactivé, aucun palier actif ≤ quantity) — la récompense ne doit alors pas
+// être proposée/réclamée plutôt que de facturer un montant incorrect.
+func effectiveRewardPrice(database *db.Database, item models.RewardItem, rewardType string) (float64, error) {
+	if rewardType != "half_price_product" {
+		return 0, nil
+	}
+	catalogPrice, err := database.GetActiveProductPrice(item.ProductID, item.Quantity)
+	if err != nil {
+		return 0, fmt.Errorf("produit récompense introuvable (id=%d): %w", item.ProductID, err)
+	}
+	return math.Round(catalogPrice/2*100) / 100, nil
+}
+
 // GetMyPointsRewards retourne les points et les récompenses disponibles du client connecté.
 // La récompense est globale : son seuil s'applique indépendamment à chaque pool.
 func GetMyPointsRewards(c *gin.Context) {
@@ -71,6 +125,7 @@ func GetMyPointsRewards(c *gin.Context) {
 
 	type EligibleConfigResponse struct {
 		Category     string   `json:"category"`
+		Type         string   `json:"type"`
 		AllProducts  bool     `json:"all_products"`
 		ProductIDs   []int    `json:"product_ids"`
 		ProductNames []string `json:"product_names"`
@@ -81,6 +136,7 @@ func GetMyPointsRewards(c *gin.Context) {
 		ProductName string  `json:"product_name"`
 		Quantity    float64 `json:"quantity"`
 		Price       float64 `json:"price"`
+		Type        string  `json:"type"`
 	}
 
 	type PoolInfo struct {
@@ -141,6 +197,7 @@ func GetMyPointsRewards(c *gin.Context) {
 				}
 				eligibleConfigs = append(eligibleConfigs, EligibleConfigResponse{
 					Category:     cfg.Category,
+					Type:         normalizeRewardCategoryType(cfg.Type),
 					AllProducts:  cfg.AllProducts,
 					ProductIDs:   cfg.ProductIDs,
 					ProductNames: names,
@@ -148,18 +205,25 @@ func GetMyPointsRewards(c *gin.Context) {
 			}
 		}
 
-		eligibleProductIDs := eligibleRewardProductIDs(reward, poolCats, productCategories)
+		eligibleProducts := eligibleRewardProducts(reward, poolCats, productCategories)
 		eligibleRewardItems := make([]RewardItemResponse, 0)
 		if reward != nil {
 			for _, item := range reward.RewardItems {
-				if !eligibleProductIDs[item.ProductID] {
+				rewardType, ok := eligibleProducts[item.ProductID]
+				if !ok {
+					continue
+				}
+				price, err := effectiveRewardPrice(database, item, rewardType)
+				if err != nil {
+					log.Printf("⚠️ [POINTS] Prix récompense introuvable, masqué de l'aperçu: %v", err)
 					continue
 				}
 				eligibleRewardItems = append(eligibleRewardItems, RewardItemResponse{
 					ProductID:   item.ProductID,
 					ProductName: productNames[item.ProductID],
 					Quantity:    item.Quantity,
-					Price:       item.Price,
+					Price:       price,
+					Type:        rewardType,
 				})
 			}
 		}
@@ -176,7 +240,9 @@ func GetMyPointsRewards(c *gin.Context) {
 		})
 	}
 
-	// Construire la liste des produits récompense avec leurs noms
+	// Construire la liste des produits récompense avec leurs noms (aperçu
+	// global, indépendant d'un pool précis — le type/prix effectif par pool
+	// est celui exposé dans pools[].eligible_reward_items).
 	var rewardMeta gin.H
 	if reward != nil {
 		rewardItems := make([]RewardItemResponse, 0, len(reward.RewardItems))
@@ -184,17 +250,22 @@ func GetMyPointsRewards(c *gin.Context) {
 			if item.ProductID <= 0 {
 				continue
 			}
+			rewardType := categoryConfigTypeForProduct(reward, item.ProductID, productCategories[item.ProductID])
+			price, err := effectiveRewardPrice(database, item, rewardType)
+			if err != nil {
+				price = item.Price // fallback indicatif si le prix catalogue est momentanément indisponible
+			}
 			name := productNames[item.ProductID]
 			rewardItems = append(rewardItems, RewardItemResponse{
 				ProductID:   item.ProductID,
 				ProductName: name,
 				Quantity:    item.Quantity,
-				Price:       item.Price,
+				Price:       price,
+				Type:        rewardType,
 			})
 		}
 		rewardMeta = gin.H{
 			"threshold":    reward.Threshold,
-			"type":         reward.Type,
 			"description":  reward.Description,
 			"reward_items": rewardItems,
 		}
@@ -273,13 +344,26 @@ func ClaimMyReward(c *gin.Context) {
 		return
 	}
 
-	eligibleProductIDs := eligibleRewardProductIDs(reward, poolCategories, productCategories)
+	eligibleProducts := eligibleRewardProducts(reward, poolCategories, productCategories)
 
+	// Le prix effectif (0€ ou -50% du prix catalogue courant) est résolu ici,
+	// avant toute écriture — si un item ne peut pas être tarifé (produit sans
+	// palier de prix actif), la réclamation entière échoue proprement, avant
+	// même de démarrer la transaction de consommation de points.
 	eligibleItems := make([]models.RewardItem, 0, len(reward.RewardItems))
 	for _, item := range reward.RewardItems {
-		if eligibleProductIDs[item.ProductID] {
-			eligibleItems = append(eligibleItems, item)
+		rewardType, ok := eligibleProducts[item.ProductID]
+		if !ok {
+			continue
 		}
+		price, err := effectiveRewardPrice(database, item, rewardType)
+		if err != nil {
+			log.Printf("❌ [CLAIM] %s: %v", username, err)
+			c.JSON(http.StatusConflict, gin.H{"error": "Récompense momentanément indisponible, contactez le support"})
+			return
+		}
+		item.Price = price
+		eligibleItems = append(eligibleItems, item)
 	}
 
 	itemsToAdd := eligibleItems