chore: refacto

backend/gestion/db/db_sanction_client.go

@@ -7,7 +7,9 @@ package db
 
 import (
 	"fmt"
+	"gestion/models"
 	"log"
+	"sort"
 )
 
 // GetClientCancellationsCount récupère le nombre d'annulations tardives d'un client
@@ -45,51 +47,53 @@ func (d *Database) IncrementClientCancellationsCount(username string) error {
 		return fmt.Errorf("client non trouvé")
 	}
 
-	log.Printf("✅ [IncrementCancellations] Compteur incrémenté pour %s", username)
-
-	// Invalider le cache Redis
 	cacheKey := fmt.Sprintf("client:%s", username)
 	Redis.Del(RedisCtx, cacheKey)
 
 	return nil
 }
 
-// CalculateCancellationPenalty calcule la pénalité selon l'historique
-// 1ère fois: 20 points
-// 2ème fois: 50 points
-// 3ème fois: 100 points
-// 4ème+ fois: 150 points
+// penaltyForCount retourne le montant du palier applicable pour un nombre d'annulations donné
+func penaltyForCount(count int, tiers []models.PenaltyTier) int {
+	if len(tiers) == 0 {
+		return 0
+	}
+	sorted := make([]models.PenaltyTier, len(tiers))
+	copy(sorted, tiers)
+	sort.Slice(sorted, func(i, j int) bool {
+		return sorted[i].MinCancel > sorted[j].MinCancel
+	})
+	for _, t := range sorted {
+		if count >= t.MinCancel {
+			return t.Amount
+		}
+	}
+	return sorted[len(sorted)-1].Amount
+}
+
+// CalculateCancellationPenalty calcule la pénalité selon l'historique et le barème configuré
 func (d *Database) CalculateCancellationPenalty(username string) (int, error) {
 	count, err := d.GetClientCancellationsCount(username)
 	if err != nil {
 		return 0, err
 	}
 
-	var penalty int
-	switch {
-	case count == 0:
-		penalty = 20 // Première annulation tardive
-	case count == 1:
-		penalty = 50 // Deuxième annulation tardive
-	case count == 2:
-		penalty = 100 // Troisième annulation tardive
-	default:
-		penalty = 150 // À partir de la 4ème annulation
+	settings, err := d.GetSettings()
+	if err != nil {
+		log.Printf("⚠️ [CalculatePenalty] Impossible de charger les settings, barème par défaut: %v", err)
+		settings = DefaultSettings()
 	}
 
+	penalty := penaltyForCount(count, settings.PenaltyTiers)
+
 	log.Printf("💰 [CalculatePenalty] Client %s - Annulations: %d → Pénalité: %d points",
 		username, count, penalty)
 
 	return penalty, nil
 }
 
-// ApplyCancellationPenalty applique une pénalité, incrémente le compteur et REMET TOUS LES POINTS À ZÉRO
-// ✅ MODIFIÉ: Récupère les points AVANT de les remettre à zéro pour le log dans le handler
+// ApplyCancellationPenalty applique une pénalité et incrémente le compteur d'annulations
 func (d *Database) ApplyCancellationPenalty(username string) (int, error) {
-	// ✅ ÉTAPE 0: Récupérer les points AVANT modification (pour le handler)
-	// Note: Le handler récupère aussi les points, mais on garde cette fonction autonome
-
-	// Calculer la pénalité AVANT d'incrémenter
 	penalty, err := d.CalculateCancellationPenalty(username)
 	if err != nil {
 		return 0, err
@@ -97,16 +101,12 @@ func (d *Database) ApplyCancellationPenalty(username string) (int, error) {
 
 	log.Printf("⚠️  [ApplyCancellationPenalty] Client %s - Pénalité calculée: %d points", username, penalty)
 
-	// ✅ ÉTAPE 1: Incrémenter le compteur d'annulations
 	if err := d.IncrementClientCancellationsCount(username); err != nil {
 		return 0, err
 	}
 
-	// ✅ ÉTAPE 2: Mettre l'amende au montant de la pénalité ET remettre TOUS les points à zéro
 	query := `UPDATE clients
 	          SET amende = $1,
-	              point = 0,
-	              point_zipette = 0,
 	              updated_at = CURRENT_TIMESTAMP
 	          WHERE username = $2`
 
@@ -124,9 +124,8 @@ func (d *Database) ApplyCancellationPenalty(username string) (int, error) {
 		return 0, fmt.Errorf("client non trouvé")
 	}
 
-	log.Printf("✅ [ApplyCancellationPenalty] %d points d'amende appliqués à %s + TOUS points remis à 0 (weed + zipette)", penalty, username)
+	log.Printf("✅ [ApplyCancellationPenalty] Amende %d appliquée à %s", penalty, username)
 
-	// Invalider le cache Redis
 	cacheKey := fmt.Sprintf("client:%s", username)
 	Redis.Del(RedisCtx, cacheKey)
 
@@ -134,42 +133,30 @@ func (d *Database) ApplyCancellationPenalty(username string) (int, error) {
 }
 
 // GetClientCancellationHistory récupère l'historique d'annulations d'un client
-func (d *Database) GetClientCancellationHistory(username string) (map[string]interface{}, error) {
+func (d *Database) GetClientCancellationHistory(username string) (map[string]any, error) {
+	nextPenalty, err := d.CalculateCancellationPenalty(username)
+	if err != nil {
+		return nil, err
+	}
+
 	count, err := d.GetClientCancellationsCount(username)
 	if err != nil {
 		return nil, err
 	}
 
-	// Calculer la prochaine pénalité
-	var nextPenalty int
-	switch count {
-	case 0:
-		nextPenalty = 20
-	case 1:
-		nextPenalty = 50
-	case 2:
-		nextPenalty = 100
-	default:
-		nextPenalty = 150
-	}
+	settings, _ := d.GetSettings()
 
-	// Récupérer l'amende actuelle
 	client, err := d.GetClientByUsername(username)
 	var currentAmende float64
 	if err == nil {
 		currentAmende = client.Amende
 	}
 
-	return map[string]interface{}{
+	return map[string]any{
 		"cancellations_count": count,
 		"current_amende":      currentAmende,
 		"next_penalty":        nextPenalty,
-		"penalty_scale": map[string]int{
-			"1st":  20,
-			"2nd":  50,
-			"3rd":  100,
-			"4th+": 150,
-		},
-		"warning": "TOUS les points de fidélité (weed/hash ET zipette) seront remis à zéro lors de la prochaine annulation tardive",
+		"penalty_tiers":       settings.PenaltyTiers,
+		"warning":             "Une amende sera appliquée lors de la prochaine annulation tardive",
 	}, nil
 }