chore: add point pool

backend/gestion/db/db_clients.go

@@ -867,36 +867,25 @@ func (d *Database) CalculateAndAddPointsForCommandTx(tx *sql.Tx, commandID int,
 		settings = DefaultSettings()
 	}
 
-	// Construire les sets de catégories par pool
-	weedCats := make(map[string]bool)
-	for _, cat := range settings.PointsCategoriesWeed {
-		weedCats[strings.ToLower(cat)] = true
-	}
-	zipetteCats := make(map[string]bool)
-	for _, cat := range settings.PointsCategoriesZipette {
-		zipetteCats[strings.ToLower(cat)] = true
-	}
-	// pool "total" → toujours compté dans le pool weed (point)
-	totalCats := make(map[string]bool)
-	for _, cat := range settings.PointsCategoriesTotal {
-		totalCats[strings.ToLower(cat)] = true
+	pools := settings.PointsPools
+	if len(pools) == 0 {
+		log.Printf("ℹ️ [CalcPointsTx] Aucun pool configuré → 0 points")
+		return 0, "", nil
 	}
 
-	// Si aucune catégorie configurée → pas de points
-	if !settings.PointsSeparated {
-		// Mode non-séparé : seul le pool Total est actif
-		if len(weedCats) == 0 && len(zipetteCats) == 0 && len(totalCats) == 0 {
-			log.Printf("ℹ️ [CalcPointsTx] Mode non-séparé : aucune catégorie configurée → 0 points")
-			return 0, "", nil
-		}
-	} else {
-		// Mode séparé : seuls W et Z sont actifs (T ignoré)
-		if len(weedCats) == 0 && len(zipetteCats) == 0 {
-			log.Printf("ℹ️ [CalcPointsTx] Mode séparé : aucune catégorie W/Z configurée → 0 points")
-			return 0, "", nil
+	// Construire la map catégorie → index de pool
+	catToPool := make(map[string]int)
+	for i, pool := range pools {
+		for _, cat := range pool.Categories {
+			catToPool[strings.ToLower(cat)] = i
 		}
 	}
 
+	if len(catToPool) == 0 {
+		log.Printf("ℹ️ [CalcPointsTx] Aucune catégorie assignée aux pools → 0 points")
+		return 0, "", nil
+	}
+
 	// ✅ ÉTAPE 1: Récupérer tous les items de la commande avec leurs catégories
 	rows, err := tx.Query(`
 		SELECT ci.quantite, ci.prix, COALESCE(p.category, '') as category
@@ -911,9 +900,7 @@ func (d *Database) CalculateAndAddPointsForCommandTx(tx *sql.Tx, commandID int,
 	defer rows.Close()
 
 	var itemCount int
-	totalPrixWeed := 0.0
-	totalPrixZipette := 0.0
-	totalPrixTotal := 0.0
+	poolTotals := make([]float64, len(pools))
 
 	for rows.Next() {
 		var quantite, prix float64
@@ -924,12 +911,8 @@ func (d *Database) CalculateAndAddPointsForCommandTx(tx *sql.Tx, commandID int,
 		}
 		itemCount++
 		catLower := strings.ToLower(category)
-		if weedCats[catLower] {
-			totalPrixWeed += prix
-		} else if zipetteCats[catLower] {
-			totalPrixZipette += prix
-		} else if totalCats[catLower] {
-			totalPrixTotal += prix
+		if poolIdx, ok := catToPool[catLower]; ok {
+			poolTotals[poolIdx] += prix
 		}
 	}
 
@@ -943,58 +926,49 @@ func (d *Database) CalculateAndAddPointsForCommandTx(tx *sql.Tx, commandID int,
 		return 0, "", nil
 	}
 
-	log.Printf("📊 [CalcPointsTx] %d items - weed: %.2f€, zipette: %.2f€, total: %.2f€",
-		itemCount, totalPrixWeed, totalPrixZipette, totalPrixTotal)
+	for i, t := range poolTotals {
+		log.Printf("📊 [CalcPointsTx] Pool[%d] (%s): %.2f€", i, pools[i].Name, t)
+	}
 
-	// ✅ ÉTAPE 2: Calculer les points
+	// ✅ ÉTAPE 2: Calculer les points par pool et mettre à jour les colonnes DB
+	// Pool[0] → colonne `point`, Pool[1] → colonne `point_zipette`
 	var totalPoints int
 	var pointCategory string
 	var result sql.Result
 
-	if !settings.PointsSeparated {
-		// ── Mode non-séparé : Barème Total appliqué sur W + Z + T ──────────────
-		allTotal := totalPrixWeed + totalPrixZipette + totalPrixTotal
-		totalPoints = CalcPointsFromTiers(allTotal, settings.PointsTotalTiers)
-		pointCategory = "total"
+	pts0 := CalcPointsFromTiers(poolTotals[0], pools[0].Tiers)
+	pts1 := 0
+	if len(pools) >= 2 {
+		pts1 = CalcPointsFromTiers(poolTotals[1], pools[1].Tiers)
+	}
+	totalPoints = pts0 + pts1
 
-		log.Printf("💰 [CalcPointsTx] Mode non-séparé - total: %.2f€ → %d pts (barème Total)",
-			allTotal, totalPoints)
+	log.Printf("💰 [CalcPointsTx] pool[0]=%d pts, pool[1]=%d pts", pts0, pts1)
 
-		if totalPoints == 0 {
-			return 0, "", nil
-		}
+	if totalPoints == 0 {
+		return 0, "", nil
+	}
 
+	if pts0 > 0 && pts1 > 0 {
+		pointCategory = pools[0].Name + " & " + pools[1].Name
+	} else if pts1 > 0 {
+		pointCategory = pools[1].Name
+	} else {
+		pointCategory = pools[0].Name
+	}
+
+	if len(pools) == 1 || pts1 == 0 {
 		result, err = tx.Exec(`
 			UPDATE clients
 			SET point = point + $1, updated_at = CURRENT_TIMESTAMP
 			WHERE username = $2
-		`, totalPoints, username)
+		`, pts0, username)
 	} else {
-		// ── Mode séparé : Barèmes W et Z, pool T ignoré ────────────────────────
-		pointsWeed := CalcPointsFromTiers(totalPrixWeed, settings.PointsWeedTiers)
-		pointsZipette := CalcPointsFromTiers(totalPrixZipette, settings.PointsZipetteTiers)
-		totalPoints = pointsWeed + pointsZipette
-
-		log.Printf("💰 [CalcPointsTx] Mode séparé - weed: %d pts, zipette: %d pts",
-			pointsWeed, pointsZipette)
-
-		if totalPoints == 0 {
-			return 0, "", nil
-		}
-
-		if pointsWeed > 0 && pointsZipette > 0 {
-			pointCategory = "mixed"
-		} else if pointsZipette > 0 {
-			pointCategory = "zipette&co"
-		} else {
-			pointCategory = "weed&hash"
-		}
-
 		result, err = tx.Exec(`
 			UPDATE clients
 			SET point = point + $1, point_zipette = point_zipette + $2, updated_at = CURRENT_TIMESTAMP
 			WHERE username = $3
-		`, pointsWeed, pointsZipette, username)
+		`, pts0, pts1, username)
 	}
 
 	if err != nil {

backend/gestion/db/db_settings.go

@@ -57,48 +57,57 @@ func CalcPointsFromTiers(total float64, tiers []PointsTier) int {
 	return 0
 }
 
+// PointsPool représente un type de point personnalisable par l'admin
+// Pool[0] → colonne `point`, Pool[1] → colonne `point_zipette`
+type PointsPool struct {
+	Key        string       `json:"key"`        // identifiant interne (ex: "pool_0")
+	Name       string       `json:"name"`       // nom affiché (ex: "Cannabis", "Accessoires")
+	Categories []string     `json:"categories"` // catégories de produits assignées à ce pool
+	Tiers      []PointsTier `json:"tiers"`      // barème de points
+}
+
 // AppSettings contient les paramètres globaux de l'application
 type AppSettings struct {
-	PenaltiesEnabled        bool     `json:"penalties_enabled"`
-	ShowAmendeScore         bool     `json:"show_amende_score"`         // afficher le score d'amendes aux clients/cabine
-	PointsEnabled           bool     `json:"points_enabled"`            // afficher/activer le système de points
-	PointsCategoriesWeed    []string `json:"points_categories_weed"`    // catégories → pool point (weed)
-	PointsCategoriesZipette []string `json:"points_categories_zipette"` // catégories → pool point_zipette
-	PointsCategoriesTotal   []string `json:"points_categories_total"`   // catégories → pool total (point, sans séparation)
-	PointsSeparated         bool     `json:"points_separated"`          // true = weed/zipette séparés, false = tout dans point
-	// Barème de points par paliers configurables
-	PointsWeedTiers    []PointsTier `json:"points_weed_tiers"`
-	PointsZipetteTiers []PointsTier `json:"points_zipette_tiers"`
-	PointsTotalTiers   []PointsTier `json:"points_total_tiers"`
-	ReferralEnabled    bool             `json:"referral_enabled"`    // activer/désactiver le système de parrainage
-	DeliverySchedule   DeliverySchedule `json:"delivery_schedule"`   // horaires de livraison par jour
-	PostalZones        []PostalZone     `json:"postal_zones"`        // zones de livraison avec minimum de commande
+	PenaltiesEnabled bool         `json:"penalties_enabled"`
+	ShowAmendeScore  bool         `json:"show_amende_score"` // afficher le score d'amendes aux clients/cabine
+	PointsEnabled    bool         `json:"points_enabled"`    // afficher/activer le système de points
+	PointsPools      []PointsPool `json:"points_pools"`      // types de points personnalisés
+	ReferralEnabled  bool         `json:"referral_enabled"`  // activer/désactiver le système de parrainage
+	DeliverySchedule DeliverySchedule `json:"delivery_schedule"` // horaires de livraison par jour
+	PostalZones      []PostalZone     `json:"postal_zones"`      // zones de livraison avec minimum de commande
 }
 
 // DefaultSettings retourne les paramètres par défaut
 func DefaultSettings() AppSettings {
 	return AppSettings{
-		PenaltiesEnabled:        true,
-		ShowAmendeScore:         true,
-		PointsEnabled:           true,
-		ReferralEnabled:         true,
-		PointsCategoriesWeed:    []string{},
-		PointsCategoriesZipette: []string{},
-		PointsCategoriesTotal:   []string{},
-		PointsSeparated:         true,
-		PointsWeedTiers: []PointsTier{
-			{Min: 30, Max: 50, Points: 1},
-			{Min: 60, Max: 150, Points: 2},
-			{Min: 160, Max: 300, Points: 3},
-			{Min: 310, Max: 400, Points: 5},
-			{Min: 401, Max: 0, Points: 10},
+		PenaltiesEnabled: true,
+		ShowAmendeScore:  true,
+		PointsEnabled:    true,
+		ReferralEnabled:  true,
+		PointsPools: []PointsPool{
+			{
+				Key:        "pool_0",
+				Name:       "Pool 1",
+				Categories: []string{},
+				Tiers: []PointsTier{
+					{Min: 30, Max: 50, Points: 1},
+					{Min: 60, Max: 150, Points: 2},
+					{Min: 160, Max: 300, Points: 3},
+					{Min: 310, Max: 400, Points: 5},
+					{Min: 401, Max: 0, Points: 10},
+				},
+			},
+			{
+				Key:        "pool_1",
+				Name:       "Pool 2",
+				Categories: []string{},
+				Tiers: []PointsTier{
+					{Min: 30, Max: 100, Points: 1},
+					{Min: 110, Max: 200, Points: 2},
+					{Min: 210, Max: 0, Points: 3},
+				},
+			},
 		},
-		PointsZipetteTiers: []PointsTier{
-			{Min: 30, Max: 100, Points: 1},
-			{Min: 110, Max: 200, Points: 2},
-			{Min: 210, Max: 0, Points: 3},
-		},
-		PointsTotalTiers: []PointsTier{},
 		DeliverySchedule: DefaultDeliverySchedule(),
 		PostalZones: []PostalZone{
 			{Name: "Zone 30€", MinAmount: 30, Codes: []string{"44000", "44100", "44200", "44300"}},
@@ -135,37 +144,10 @@ func (d *Database) GetSettings() (AppSettings, error) {
 			settings.ShowAmendeScore = value == "true"
 		case "points_enabled":
 			settings.PointsEnabled = value == "true"
-		case "points_categories_weed":
-			var cats []string
-			if err := json.Unmarshal([]byte(value), &cats); err == nil {
-				settings.PointsCategoriesWeed = cats
-			}
-		case "points_categories_zipette":
-			var cats []string
-			if err := json.Unmarshal([]byte(value), &cats); err == nil {
-				settings.PointsCategoriesZipette = cats
-			}
-		case "points_categories_total":
-			var cats []string
-			if err := json.Unmarshal([]byte(value), &cats); err == nil {
-				settings.PointsCategoriesTotal = cats
-			}
-		case "points_separated":
-			settings.PointsSeparated = value == "true"
-		case "points_weed_tiers":
-			var tiers []PointsTier
-			if err := json.Unmarshal([]byte(value), &tiers); err == nil {
-				settings.PointsWeedTiers = tiers
-			}
-		case "points_zipette_tiers":
-			var tiers []PointsTier
-			if err := json.Unmarshal([]byte(value), &tiers); err == nil {
-				settings.PointsZipetteTiers = tiers
-			}
-		case "points_total_tiers":
-			var tiers []PointsTier
-			if err := json.Unmarshal([]byte(value), &tiers); err == nil {
-				settings.PointsTotalTiers = tiers
+		case "points_pools":
+			var pools []PointsPool
+			if err := json.Unmarshal([]byte(value), &pools); err == nil {
+				settings.PointsPools = pools
 			}
 		case "referral_enabled":
 			settings.ReferralEnabled = value == "true"
@@ -192,27 +174,23 @@ func (d *Database) UpdateSettings(s AppSettings) error {
 		}
 		return "false"
 	}
-	if s.PointsCategoriesWeed == nil {
-		s.PointsCategoriesWeed = []string{}
+
+	if s.PointsPools == nil {
+		s.PointsPools = []PointsPool{}
 	}
-	if s.PointsCategoriesZipette == nil {
-		s.PointsCategoriesZipette = []string{}
-	}
-	if s.PointsCategoriesTotal == nil {
-		s.PointsCategoriesTotal = []string{}
+	// S'assurer que chaque pool a des slices non-nil
+	for i := range s.PointsPools {
+		if s.PointsPools[i].Categories == nil {
+			s.PointsPools[i].Categories = []string{}
+		}
+		if s.PointsPools[i].Tiers == nil {
+			s.PointsPools[i].Tiers = []PointsTier{}
+		}
 	}
 
-	weedJSON, err := json.Marshal(s.PointsCategoriesWeed)
+	poolsJSON, err := json.Marshal(s.PointsPools)
 	if err != nil {
-		return fmt.Errorf("erreur sérialisation weed: %w", err)
-	}
-	zipetteJSON, err := json.Marshal(s.PointsCategoriesZipette)
-	if err != nil {
-		return fmt.Errorf("erreur sérialisation zipette: %w", err)
-	}
-	totalJSON, err := json.Marshal(s.PointsCategoriesTotal)
-	if err != nil {
-		return fmt.Errorf("erreur sérialisation total: %w", err)
+		return fmt.Errorf("erreur sérialisation pools: %w", err)
 	}
 
 	tx, err := d.Begin()
@@ -224,39 +202,11 @@ func (d *Database) UpdateSettings(s AppSettings) error {
 	upsert := `INSERT INTO app_settings (key, value) VALUES ($1, $2)
 	           ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value`
 
-	if s.PointsWeedTiers == nil {
-		s.PointsWeedTiers = []PointsTier{}
-	}
-	if s.PointsZipetteTiers == nil {
-		s.PointsZipetteTiers = []PointsTier{}
-	}
-	if s.PointsTotalTiers == nil {
-		s.PointsTotalTiers = []PointsTier{}
-	}
-	weedTiersJSON, err := json.Marshal(s.PointsWeedTiers)
-	if err != nil {
-		return fmt.Errorf("erreur sérialisation weed tiers: %w", err)
-	}
-	zipetteTiersJSON, err := json.Marshal(s.PointsZipetteTiers)
-	if err != nil {
-		return fmt.Errorf("erreur sérialisation zipette tiers: %w", err)
-	}
-	totalTiersJSON, err := json.Marshal(s.PointsTotalTiers)
-	if err != nil {
-		return fmt.Errorf("erreur sérialisation total tiers: %w", err)
-	}
-
 	pairs := [][2]string{
 		{"penalties_enabled", boolStr(s.PenaltiesEnabled)},
 		{"show_amende_score", boolStr(s.ShowAmendeScore)},
 		{"points_enabled", boolStr(s.PointsEnabled)},
-		{"points_categories_weed", string(weedJSON)},
-		{"points_categories_zipette", string(zipetteJSON)},
-		{"points_categories_total", string(totalJSON)},
-		{"points_separated", boolStr(s.PointsSeparated)},
-		{"points_weed_tiers", string(weedTiersJSON)},
-		{"points_zipette_tiers", string(zipetteTiersJSON)},
-		{"points_total_tiers", string(totalTiersJSON)},
+		{"points_pools", string(poolsJSON)},
 		{"referral_enabled", boolStr(s.ReferralEnabled)},
 	}
 

backend/gestion/handlers/settings.go

@@ -24,7 +24,7 @@ func GetPublicSettings(c *gin.Context) {
 		"penalties_enabled": settings.PenaltiesEnabled,
 		"show_amende_score": settings.ShowAmendeScore,
 		"points_enabled":    settings.PointsEnabled,
-		"points_separated":  settings.PointsSeparated,
+		"points_separated":  len(settings.PointsPools) > 1,
 		"referral_enabled":  settings.ReferralEnabled,
 		"delivery_schedule": settings.DeliverySchedule,
 	})
@@ -60,8 +60,7 @@ func UpdateSettings(c *gin.Context) {
 		return
 	}
 
-	log.Printf("✅ [SETTINGS] Mise à jour: penalties=%v, points_separated=%v, weed=%v, zipette=%v, total=%v",
-		req.PenaltiesEnabled, req.PointsSeparated, req.PointsCategoriesWeed, req.PointsCategoriesZipette, req.PointsCategoriesTotal)
+	log.Printf("✅ [SETTINGS] Mise à jour: penalties=%v, pools=%d", req.PenaltiesEnabled, len(req.PointsPools))
 
 	c.JSON(http.StatusOK, gin.H{"success": true, "settings": req})
 }