chore: build

backend/gestion/handlers/points.go

@@ -23,72 +23,75 @@ func normalizeRewardCategoryType(t string) string {
 	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)
+// categoryRewardCandidate représente un produit éligible à la récompense pour
+// une config de catégorie donnée : son type ("free_product" |
+// "half_price_product") et la quantité configurée pour cette catégorie.
+type categoryRewardCandidate struct {
+	Category  string
+	Type      string
+	ProductID int
+	Name      string
+	Quantity  float64
+}
+
+// resolveCategoryRewardCandidates dérive, pour chaque config de catégorie de
+// la récompense, la liste des produits éligibles — tous ceux du catalogue si
+// AllProducts, sinon la sélection explicite — avec le type et la quantité
+// configurés directement dans le bloc catégorie (RewardCategoryConfig).
+// Il n'existe plus de liste "reward_items" saisie à part : la catégorie est
+// l'unique source de vérité (type + produits + quantité).
+func resolveCategoryRewardCandidates(database *db.Database, reward *models.PointsReward) ([]categoryRewardCandidate, error) {
+	candidates := make([]categoryRewardCandidate, 0)
 	if reward == nil {
-		return eligible
+		return candidates, nil
 	}
+
+	catalogCache := make(map[string][]models.Product)
 	for _, cfg := range reward.CategoryConfigs {
-		if !poolCategories[cfg.Category] {
-			continue
-		}
 		rewardType := normalizeRewardCategoryType(cfg.Type)
 		if cfg.AllProducts {
-			for pid, cat := range productCategories {
-				if cat == cfg.Category {
-					eligible[pid] = rewardType
+			products, ok := catalogCache[cfg.Category]
+			if !ok {
+				var err error
+				products, err = database.GetProductsByCategory(cfg.Category)
+				if err != nil {
+					return nil, fmt.Errorf("produits catégorie %q: %w", cfg.Category, err)
 				}
+				catalogCache[cfg.Category] = products
+			}
+			for _, p := range products {
+				candidates = append(candidates, categoryRewardCandidate{
+					Category: cfg.Category, Type: rewardType, ProductID: p.ID, Name: p.Name, Quantity: cfg.Quantity,
+				})
+			}
+		} else if len(cfg.ProductIDs) > 0 {
+			names, err := database.GetProductNamesByIDs(cfg.ProductIDs)
+			if err != nil {
+				return nil, fmt.Errorf("noms produits catégorie %q: %w", cfg.Category, err)
 			}
-		} else {
 			for _, pid := range cfg.ProductIDs {
-				eligible[pid] = rewardType
+				candidates = append(candidates, categoryRewardCandidate{
+					Category: cfg.Category, Type: rewardType, ProductID: pid, Name: names[pid], Quantity: cfg.Quantity,
+				})
 			}
 		}
 	}
-	return eligible
+	return candidates, nil
 }
 
-// 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
+// effectiveRewardPrice calcule le prix réellement facturé pour une quantité
+// donnée d'un produit récompense, selon le type de sa catégorie : 0€ pour
+// "free_product", 50% du prix catalogue actif (palier ≤ quantity) 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) {
+func effectiveRewardPrice(database *db.Database, productID int, quantity float64, rewardType string) (float64, error) {
 	if rewardType != "half_price_product" {
 		return 0, nil
 	}
-	catalogPrice, err := database.GetActiveProductPrice(item.ProductID, item.Quantity)
+	catalogPrice, err := database.GetActiveProductPrice(productID, quantity)
 	if err != nil {
-		return 0, fmt.Errorf("produit récompense introuvable (id=%d): %w", item.ProductID, err)
+		return 0, fmt.Errorf("produit récompense introuvable (id=%d): %w", productID, err)
 	}
 	return math.Round(catalogPrice/2*100) / 100, nil
 }
@@ -129,6 +132,7 @@ func GetMyPointsRewards(c *gin.Context) {
 		AllProducts  bool     `json:"all_products"`
 		ProductIDs   []int    `json:"product_ids"`
 		ProductNames []string `json:"product_names"`
+		Quantity     float64  `json:"quantity"`
 	}
 
 	type RewardItemResponse struct {
@@ -150,22 +154,10 @@ func GetMyPointsRewards(c *gin.Context) {
 		EligibleRewardItems []RewardItemResponse     `json:"eligible_reward_items"`
 	}
 
-	// Collecter tous les product_ids nécessaires en un seul passage
-	allProductIDs := make([]int, 0)
-	if reward != nil {
-		for _, cfg := range reward.CategoryConfigs {
-			if !cfg.AllProducts {
-				allProductIDs = append(allProductIDs, cfg.ProductIDs...)
-			}
-		}
-		for _, item := range reward.RewardItems {
-			if item.ProductID > 0 {
-				allProductIDs = append(allProductIDs, item.ProductID)
-			}
-		}
+	candidates, err := resolveCategoryRewardCandidates(database, reward)
+	if err != nil {
+		log.Printf("⚠️ [POINTS] Résolution candidats récompense: %v", err)
 	}
-	productNames, _ := database.GetProductNamesByIDs(allProductIDs)
-	productCategories, _ := database.GetProductCategoriesByIDs(allProductIDs)
 
 	pools := make([]PoolInfo, 0, len(settings.PointsPools))
 	for _, pool := range settings.PointsPools {
@@ -191,8 +183,11 @@ func GetMyPointsRewards(c *gin.Context) {
 				}
 				names := make([]string, 0, len(cfg.ProductIDs))
 				for _, pid := range cfg.ProductIDs {
-					if n, ok := productNames[pid]; ok {
-						names = append(names, n)
+					for _, cand := range candidates {
+						if cand.ProductID == pid && cand.Category == cfg.Category {
+							names = append(names, cand.Name)
+							break
+						}
 					}
 				}
 				eligibleConfigs = append(eligibleConfigs, EligibleConfigResponse{
@@ -201,31 +196,28 @@ func GetMyPointsRewards(c *gin.Context) {
 					AllProducts:  cfg.AllProducts,
 					ProductIDs:   cfg.ProductIDs,
 					ProductNames: names,
+					Quantity:     cfg.Quantity,
 				})
 			}
 		}
 
-		eligibleProducts := eligibleRewardProducts(reward, poolCats, productCategories)
 		eligibleRewardItems := make([]RewardItemResponse, 0)
-		if reward != nil {
-			for _, item := range reward.RewardItems {
-				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:       price,
-					Type:        rewardType,
-				})
+		for _, cand := range candidates {
+			if !poolCats[cand.Category] {
+				continue
 			}
+			price, err := effectiveRewardPrice(database, cand.ProductID, cand.Quantity, cand.Type)
+			if err != nil {
+				log.Printf("⚠️ [POINTS] Prix récompense introuvable, masqué de l'aperçu: %v", err)
+				continue
+			}
+			eligibleRewardItems = append(eligibleRewardItems, RewardItemResponse{
+				ProductID:   cand.ProductID,
+				ProductName: cand.Name,
+				Quantity:    cand.Quantity,
+				Price:       price,
+				Type:        cand.Type,
+			})
 		}
 
 		pools = append(pools, PoolInfo{
@@ -240,28 +232,22 @@ func GetMyPointsRewards(c *gin.Context) {
 		})
 	}
 
-	// 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).
+	// Aperçu global des produits récompense, 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))
-		for _, item := range reward.RewardItems {
-			if item.ProductID <= 0 {
+		rewardItems := make([]RewardItemResponse, 0, len(candidates))
+		for _, cand := range candidates {
+			price, err := effectiveRewardPrice(database, cand.ProductID, cand.Quantity, cand.Type)
+			if err != nil {
 				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,
+				ProductID:   cand.ProductID,
+				ProductName: cand.Name,
+				Quantity:    cand.Quantity,
 				Price:       price,
-				Type:        rewardType,
+				Type:        cand.Type,
 			})
 		}
 		rewardMeta = gin.H{
@@ -324,46 +310,40 @@ func ClaimMyReward(c *gin.Context) {
 	}
 
 	// Un produit récompense n'est éligible pour ce pool que si sa catégorie
-	// fait partie des catégories du pool (via CategoryConfigs) — sans ce
-	// filtre, un client pourrait réclamer n'importe quel produit récompense
-	// (toutes catégories confondues) avec les points d'un pool quelconque.
+	// fait partie des catégories du pool — sans ce filtre, un client pourrait
+	// réclamer n'importe quel produit récompense (toutes catégories
+	// confondues) avec les points d'un pool quelconque.
 	poolCategories := make(map[string]bool, len(selectedPool.Categories))
 	for _, cat := range selectedPool.Categories {
 		poolCategories[cat] = true
 	}
 
-	rewardProductIDs := make([]int, 0, len(reward.RewardItems))
-	for _, item := range reward.RewardItems {
-		if item.ProductID > 0 {
-			rewardProductIDs = append(rewardProductIDs, item.ProductID)
-		}
-	}
-	productCategories, err := database.GetProductCategoriesByIDs(rewardProductIDs)
+	candidates, err := resolveCategoryRewardCandidates(database, reward)
 	if err != nil {
-		utils.ServerErr(c, "Erreur lecture catégories produits", err)
+		utils.ServerErr(c, "Erreur résolution produits récompense", err)
 		return
 	}
 
-	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 {
-		rewardType, ok := eligibleProducts[item.ProductID]
-		if !ok {
+	eligibleItems := make([]models.RewardItem, 0, len(candidates))
+	for _, cand := range candidates {
+		if !poolCategories[cand.Category] {
 			continue
 		}
-		price, err := effectiveRewardPrice(database, item, rewardType)
+		price, err := effectiveRewardPrice(database, cand.ProductID, cand.Quantity, cand.Type)
 		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)
+		eligibleItems = append(eligibleItems, models.RewardItem{
+			ProductID: cand.ProductID,
+			Quantity:  cand.Quantity,
+			Price:     price,
+		})
 	}
 
 	itemsToAdd := eligibleItems