chore: refacto

backend/gestion/db/db_clients.go

@@ -10,8 +10,8 @@ import (
 )
 
 func (d *Database) CreateClient(client *models.Client) error {
-	query := `INSERT INTO clients (username, password, nom, prenom, telephone, command, point, point_zipette, amende, must_change_password, created_at)
-	          VALUES ($1, $2, $3, $4, $5, 0, 0, 0, 0.0, $6, CURRENT_TIMESTAMP)
+	query := `INSERT INTO clients (username, password, nom, prenom, telephone, command, amende, must_change_password, created_at)
+	          VALUES ($1, $2, $3, $4, $5, 0, 0.0, $6, CURRENT_TIMESTAMP)
 	          RETURNING id, created_at`
 
 	err := d.QueryRow(query, client.Username, client.Password, client.Nom, client.Prenom, client.Telephone, client.MustChangePassword).Scan(
@@ -29,9 +29,10 @@ func (d *Database) CreateClient(client *models.Client) error {
 // GetClientByID récupère un client par son ID
 func (d *Database) GetClientByID(id int) (*models.Client, error) {
 	var client models.Client
-	query := `SELECT id, username, password, nom, prenom, telephone, command, point, point_zipette, amende, created_at
+	query := `SELECT id, username, password, nom, prenom, telephone, command, amende, COALESCE(points_extra, '{}'::jsonb), created_at
 	          FROM clients WHERE id = $1`
 
+	var pointsExtraJSON []byte
 	err := d.QueryRow(query, id).Scan(
 		&client.ID,
 		&client.Username,
@@ -40,9 +41,8 @@ func (d *Database) GetClientByID(id int) (*models.Client, error) {
 		&client.Prenom,
 		&client.Telephone,
 		&client.Command,
-		&client.Point,
-		&client.PointZipette,
 		&client.Amende,
+		&pointsExtraJSON,
 		&client.CreatedAt,
 	)
 
@@ -53,12 +53,16 @@ func (d *Database) GetClientByID(id int) (*models.Client, error) {
 		return nil, fmt.Errorf("erreur lors de la récupération du client: %w", err)
 	}
 
+	if len(pointsExtraJSON) > 0 {
+		json.Unmarshal(pointsExtraJSON, &client.PointsExtra)
+	}
+
 	return &client, nil
 }
 
 // GetAllClients récupère tous les clients
 func (d *Database) GetAllClients() ([]*models.Client, error) {
-	query := `SELECT id, username, password, nom, prenom, telephone, command, point, point_zipette, amende, referral_balance, COALESCE(points_extra, '{}'::jsonb), created_at
+	query := `SELECT id, username, password, nom, prenom, telephone, command, amende, referral_balance, COALESCE(points_extra, '{}'::jsonb), created_at
 	          FROM clients ORDER BY created_at DESC`
 
 	rows, err := d.Query(query)
@@ -79,8 +83,6 @@ func (d *Database) GetAllClients() ([]*models.Client, error) {
 			&client.Prenom,
 			&client.Telephone,
 			&client.Command,
-			&client.Point,
-			&client.PointZipette,
 			&client.Amende,
 			&client.ReferralBalance,
 			&pointsExtraJSON,
@@ -107,8 +109,8 @@ func (d *Database) GetAllClients() ([]*models.Client, error) {
 func (d *Database) UpdateClient(client *models.Client) error {
 	query := `UPDATE clients
 	          SET username = $1, password = $2, nom = $3, prenom = $4, telephone = $5,
-	              command = $6, point = $7, point_zipette = $8, amende = $9
-	          WHERE id = $10`
+	              command = $6, amende = $7
+	          WHERE id = $8`
 
 	result, err := d.Exec(query,
 		client.Username,
@@ -117,8 +119,6 @@ func (d *Database) UpdateClient(client *models.Client) error {
 		client.Prenom,
 		client.Telephone,
 		client.Command,
-		client.Point,
-		client.PointZipette,
 		client.Amende,
 		client.ID,
 	)
@@ -135,13 +135,11 @@ func (d *Database) UpdateClient(client *models.Client) error {
 		return fmt.Errorf("client non trouvé")
 	}
 
-	log.Printf("✅ Client mis à jour: %s (ID: %d)", client.Username, client.ID)
 	return nil
 }
 
 // DeleteClient supprime un client
 func (d *Database) DeleteClient(id int) error {
-	// ✅ MODIFIÉ : Supprimer tous les tokens du client avec le user_type "client"
 	_ = d.RevokeAllUserTokens(id, "client")
 
 	query := `DELETE FROM clients WHERE id = $1`
@@ -160,7 +158,6 @@ func (d *Database) DeleteClient(id int) error {
 		return fmt.Errorf("client non trouvé")
 	}
 
-	log.Printf("✅ Client supprimé (ID: %d)", id)
 	return nil
 }
 
@@ -182,7 +179,6 @@ func (d *Database) UpdateClientPassword(clientID int, hashedPassword string) err
 		return fmt.Errorf("client non trouvé")
 	}
 
-	log.Printf("✅ Mot de passe client mis à jour (ID: %d)", clientID)
 	return nil
 }
 
@@ -204,7 +200,6 @@ func (d *Database) UpdateClientPasswordAndClearFlag(clientID int, hashedPassword
 		return fmt.Errorf("client non trouvé")
 	}
 
-	log.Printf("✅ Mot de passe client mis à jour + must_change_password=false (ID: %d)", clientID)
 	return nil
 }
 
@@ -239,8 +234,7 @@ func (d *Database) GetClientStats(clientID int) (map[string]interface{}, error)
 		"total_commands":     totalCommands,
 		"pending_commands":   pendingCommands,
 		"completed_commands": completedCommands,
-		"points":             client.Point,
-		"points_zipette":     client.PointZipette,
+		"points_extra":       client.PointsExtra,
 		"amende":             client.Amende,
 		"member_since":       client.CreatedAt,
 	}
@@ -279,7 +273,6 @@ func (d *Database) PayClientPenalties(username string, amountPaid float64) error
 		return fmt.Errorf("montant insuffisant: %.2f payé, %.2f requis", amountPaid, currentAmount)
 	}
 
-	// Réinitialiser les pénalités
 	query := `UPDATE clients
 	          SET amende = 0, updated_at = CURRENT_TIMESTAMP
 	          WHERE username = $1`
@@ -298,9 +291,6 @@ func (d *Database) PayClientPenalties(username string, amountPaid float64) error
 		return fmt.Errorf("client non trouvé")
 	}
 
-	log.Printf("✅ [PayClientPenalties] Pénalités réglées pour %s", username)
-
-	// Invalider le cache Redis du client
 	cacheKey := fmt.Sprintf("client:%s", username)
 	Redis.Del(RedisCtx, cacheKey)
 
@@ -329,27 +319,22 @@ func (d *Database) IncrementClientCommandCount(username string) error {
 	return nil
 }
 
-// ✅ NOUVELLE FONCTION: Ajouter des points selon la catégorie
-func (d *Database) AddClientPointsByCategory(username string, points int, category string) error {
-	var query string
-
-	if category == "zipette&co" {
-		query = `UPDATE clients
-		          SET point_zipette = point_zipette + $1
-		          WHERE username = $2`
-		log.Printf("🎁 [ADD_POINTS] Ajout de %d points ZIPETTE à %s", points, username)
-	} else {
-		query = `UPDATE clients
-		          SET point = point + $1
-		          WHERE username = $2`
-		log.Printf("🎁 [ADD_POINTS] Ajout de %d points WEED/HASH à %s", points, username)
+func (d *Database) AddClientPointsByCategory(username string, points int, poolKey string) error {
+	if poolKey == "" {
+		poolKey = "pool_0"
 	}
-
-	result, err := d.Exec(query, points, username)
+	result, err := d.Exec(`
+		UPDATE clients
+		SET points_extra = jsonb_set(
+			COALESCE(points_extra, '{}'::jsonb),
+			ARRAY[$2],
+			to_jsonb(COALESCE((points_extra->>$2)::int, 0) + $3)
+		), updated_at = CURRENT_TIMESTAMP
+		WHERE username = $1
+	`, username, poolKey, points)
 	if err != nil {
 		return fmt.Errorf("erreur lors de l'ajout de points: %w", err)
 	}
-
 	rowsAffected, err := result.RowsAffected()
 	if err != nil {
 		return fmt.Errorf("erreur lors de la vérification: %w", err)
@@ -357,19 +342,31 @@ func (d *Database) AddClientPointsByCategory(username string, points int, catego
 	if rowsAffected == 0 {
 		return fmt.Errorf("client non trouvé")
 	}
-
-	log.Printf("✅ %d points (%s) ajoutés au client %s (EN DB)", points, category, username)
+	log.Printf("✅ %d points (key=%s) ajoutés au client %s", points, poolKey, username)
 	return nil
 }
 
-// ✅ ANCIENNE FONCTION CONSERVÉE POUR COMPATIBILITÉ (utilise weed/hash par défaut)
-func (d *Database) AddClientPoints(username string, points int) error {
-	return d.AddClientPointsByCategory(username, points, "weed_hash")
+func (d *Database) CalculateAndAddPointsForCommand(commandID int, username string) (int, error) {
+	tx, err := d.Begin()
+	if err != nil {
+		return 0, fmt.Errorf("erreur transaction: %w", err)
+	}
+	defer tx.Rollback()
+
+	points, _, err := d.CalculateAndAddPointsForCommandTx(tx, commandID, username)
+	if err != nil {
+		return 0, err
+	}
+
+	if err := tx.Commit(); err != nil {
+		return 0, fmt.Errorf("erreur commit: %w", err)
+	}
+	return points, nil
 }
 
 func (d *Database) GetClientByTelephone(telephone string) (*models.Client, error) {
 	client := &models.Client{}
-	query := `SELECT id, username, password, nom, prenom, telephone, command, point, point_zipette, amende, created_at
+	query := `SELECT id, username, password, nom, prenom, telephone, command, amende, created_at
 	          FROM clients WHERE telephone = $1`
 
 	err := d.QueryRow(query, telephone).Scan(
@@ -380,8 +377,6 @@ func (d *Database) GetClientByTelephone(telephone string) (*models.Client, error
 		&client.Prenom,
 		&client.Telephone,
 		&client.Command,
-		&client.Point,
-		&client.PointZipette,
 		&client.Amende,
 		&client.CreatedAt,
 	)
@@ -400,7 +395,7 @@ func (d *Database) GetClientByTelephone(telephone string) (*models.Client, error
 func (d *Database) GetClientByUsername(username string) (*models.Client, error) {
 	client := &models.Client{}
 	var pointsExtraJSON []byte
-	query := `SELECT id, username, password, nom, prenom, telephone, command, point, point_zipette, amende, must_change_password, COALESCE(points_extra, '{}'::jsonb), created_at
+	query := `SELECT id, username, password, nom, prenom, telephone, command, amende, must_change_password, COALESCE(points_extra, '{}'::jsonb), created_at
 	          FROM clients WHERE username = $1`
 
 	err := d.QueryRow(query, username).Scan(
@@ -411,8 +406,6 @@ func (d *Database) GetClientByUsername(username string) (*models.Client, error)
 		&client.Prenom,
 		&client.Telephone,
 		&client.Command,
-		&client.Point,
-		&client.PointZipette,
 		&client.Amende,
 		&client.MustChangePassword,
 		&pointsExtraJSON,
@@ -485,23 +478,25 @@ func (d *Database) CheckClientCanOrder(username string) (bool, float64, error) {
 }
 
 // ResetClientPoint réinitialise les points d'un client.
-// poolIdx=0 → point, poolIdx=1 → point_zipette, poolIdx=-1 → tous
-// poolIdx>=2 → points_extra[extraPoolKey]
+// extraPoolKey != "" → reset points_extra[extraPoolKey] uniquement
+// extraPoolKey == "" (poolIdx=-1) → reset total points_extra
 func (d *Database) ResetClientPoint(username string, poolIdx int, extraPoolKey string) error {
 	var query string
 	switch {
-	case poolIdx == 0:
-		query = `UPDATE clients SET point = 0, updated_at = CURRENT_TIMESTAMP WHERE username = $1`
-	case poolIdx == 1:
-		query = `UPDATE clients SET point_zipette = 0, updated_at = CURRENT_TIMESTAMP WHERE username = $1`
-	case poolIdx >= 2 && extraPoolKey != "":
+	case extraPoolKey != "":
 		_, err := d.Exec(
 			`UPDATE clients SET points_extra = points_extra - $2, updated_at = CURRENT_TIMESTAMP WHERE username = $1`,
 			username, extraPoolKey,
 		)
+		if err != nil {
+			log.Printf("❌ [ResetClientPointAdmin] Erreur UPDATE extra: %v", err)
+		} else {
+			cacheKey := fmt.Sprintf("client:%s", username)
+			Redis.Del(RedisCtx, cacheKey)
+		}
 		return err
-	default: // -1 → reset total
-		query = `UPDATE clients SET point = 0, point_zipette = 0, points_extra = '{}'::jsonb, updated_at = CURRENT_TIMESTAMP WHERE username = $1`
+	default: // -1 ou poolIdx sans clé → reset total
+		query = `UPDATE clients SET points_extra = '{}'::jsonb, updated_at = CURRENT_TIMESTAMP WHERE username = $1`
 	}
 
 	result, err := d.Exec(query, username)
@@ -649,240 +644,6 @@ func (d *Database) GetClientPenaltiesStats() (map[string]interface{}, error) {
 	return result, nil
 }
 
-// ✅ FONCTION MODIFIÉE: Calculer les points sans cumuler entre catégories
-// À remplacer dans db/clients.go à partir de la ligne 498
-
-// À remplacer dans db/clients.go
-
-func (d *Database) CalculatePointsForCommand(commandID int) (int, string, error) {
-	query := `
-		SELECT p.category, ci.prix, ci.quantite
-		FROM command_items ci
-		JOIN products p ON ci.product_id = p.id
-		WHERE ci.command_id = $1
-	`
-
-	rows, err := d.Query(query, commandID)
-	if err != nil {
-		return 0, "", fmt.Errorf("erreur récupération items: %w", err)
-	}
-	defer rows.Close()
-
-	zipetteTotal := 0.0
-	weedTotal := 0.0
-	grosSemiTotal := 0.0
-
-	for rows.Next() {
-		var category string
-		var prix float64
-		var quantite int
-
-		if err := rows.Scan(&category, &prix, &quantite); err != nil {
-			log.Printf("⚠️ Erreur scan item: %v", err)
-			continue
-		}
-
-		itemTotal := prix // Prix déjà calculé pour la quantité
-		categoryLower := strings.ToLower(category)
-
-		if categoryLower == "zipette&co" || categoryLower == "zipette_co" {
-			zipetteTotal += itemTotal
-		} else if categoryLower == "gros&semi" || categoryLower == "gros_semi" {
-			grosSemiTotal += itemTotal
-		} else {
-			weedTotal += itemTotal
-		}
-	}
-
-	log.Printf("💰 [CALC_POINTS] Cmd %d - Zipette: %.2f€, Weed: %.2f€, GrosSemi: %.2f€",
-		commandID, zipetteTotal, weedTotal, grosSemiTotal)
-
-	// ✅ CALCUL POINTS WEED&HASH
-	weedPoints := 0
-	if weedTotal > 0 {
-		switch {
-		case weedTotal >= 30 && weedTotal <= 50:
-			weedPoints = 1
-		case weedTotal >= 60 && weedTotal <= 150:
-			weedPoints = 2
-		case weedTotal >= 160 && weedTotal <= 300:
-			weedPoints = 3
-		case weedTotal >= 310 && weedTotal <= 400:
-			weedPoints = 5
-		case weedTotal >= 400:
-			weedPoints = 10
-		}
-		if weedPoints > 0 {
-			log.Printf("🎁 [CALC_POINTS] Weed: %.2f€ → %d points", weedTotal, weedPoints)
-		}
-	}
-
-	// ✅ CALCUL POINTS ZIPETTE&CO
-	zipettePoints := 0
-	if zipetteTotal > 0 {
-		switch {
-		case zipetteTotal >= 30 && zipetteTotal <= 100:
-			zipettePoints = 1
-		case zipetteTotal >= 110 && zipetteTotal <= 200:
-			zipettePoints = 2
-		case zipetteTotal >= 210:
-			zipettePoints = 3
-		}
-		if zipettePoints > 0 {
-			log.Printf("🎁 [CALC_POINTS] Zipette: %.2f€ → %d points", zipetteTotal, zipettePoints)
-		}
-	}
-
-	totalPoints := zipettePoints + weedPoints
-
-	if totalPoints == 0 {
-		if grosSemiTotal > 0 && zipetteTotal == 0 && weedTotal == 0 {
-			log.Printf("ℹ️ [CALC_POINTS] Cmd %d - Catégorie GROS&SEMI uniquement (%.2f€) → 0 points",
-				commandID, grosSemiTotal)
-			return 0, "gros&semi", nil
-		}
-		log.Printf("ℹ️ [CALC_POINTS] Cmd %d - Aucun montant éligible aux points", commandID)
-		return 0, "unknown", nil
-	}
-
-	var dominantCategory string
-	if zipetteTotal >= weedTotal {
-		dominantCategory = "zipette&co"
-	} else {
-		dominantCategory = "weed&hash"
-	}
-
-	log.Printf("✅ [CALC_POINTS] Cmd %d - Total: %d points (Zipette: %d, Weed: %d)",
-		commandID, totalPoints, zipettePoints, weedPoints)
-
-	return totalPoints, dominantCategory, nil
-}
-
-// ✅ FONCTION CORRIGÉE: Calculer et ajouter les points séparément avec le BON BARÈME
-func (d *Database) CalculateAndAddPointsForCommand(commandID int, username string) (int, error) {
-	query := `
-		SELECT p.category, ci.prix, ci.quantite
-		FROM command_items ci
-		JOIN products p ON ci.product_id = p.id
-		WHERE ci.command_id = $1
-	`
-
-	rows, err := d.Query(query, commandID)
-	if err != nil {
-		return 0, fmt.Errorf("erreur récupération items: %w", err)
-	}
-	defer rows.Close()
-
-	zipetteTotal := 0.0
-	weedTotal := 0.0
-	grosSemiTotal := 0.0
-
-	for rows.Next() {
-		var category string
-		var prix float64
-		var quantite int
-
-		if err := rows.Scan(&category, &prix, &quantite); err != nil {
-			log.Printf("⚠️ Erreur scan item: %v", err)
-			continue
-		}
-
-		// ✅ prix contient déjà le total pour la quantité
-		itemTotal := prix
-		categoryLower := strings.ToLower(category)
-
-		if categoryLower == "zipette&co" || categoryLower == "zipette_co" {
-			zipetteTotal += itemTotal
-		} else if categoryLower == "gros&semi" || categoryLower == "gros_semi" {
-			grosSemiTotal += itemTotal
-		} else {
-			weedTotal += itemTotal
-		}
-	}
-
-	log.Printf("💰 [CALC_POINTS] Cmd %d - Zipette: %.2f€, Weed: %.2f€, GrosSemi: %.2f€",
-		commandID, zipetteTotal, weedTotal, grosSemiTotal)
-
-	// ✅ CALCUL POINTS WEED&HASH - NOUVEAU BARÈME
-	// De 30 à 50€ -> 1 point
-	// De 60 à 150€ -> 2 points
-	// De 160 à 300€ -> 3 points
-	// De 310 à 400€ -> 5 points
-	// 400€ et + -> 10 points
-	weedPoints := 0
-	if weedTotal > 0 {
-		switch {
-		case weedTotal >= 30 && weedTotal <= 50:
-			weedPoints = 1
-		case weedTotal >= 60 && weedTotal <= 150:
-			weedPoints = 2
-		case weedTotal >= 160 && weedTotal <= 300:
-			weedPoints = 3
-		case weedTotal >= 310 && weedTotal <= 400:
-			weedPoints = 5
-		case weedTotal >= 400:
-			weedPoints = 10
-		}
-		if weedPoints > 0 {
-			log.Printf("🎁 [CALC_POINTS] Weed: %.2f€ → %d points", weedTotal, weedPoints)
-		}
-	}
-
-	// ✅ CALCUL POINTS ZIPETTE&CO - NOUVEAU BARÈME
-	// De 30 à 100€ -> 1 point
-	// De 110 à 200€ -> 2 points  (je suppose que c'est 110 et non 1100)
-	// De 210€ et + -> 3 points
-	zipettePoints := 0
-	if zipetteTotal > 0 {
-		switch {
-		case zipetteTotal >= 30 && zipetteTotal <= 100:
-			zipettePoints = 1
-		case zipetteTotal >= 110 && zipetteTotal <= 200:
-			zipettePoints = 2
-		case zipetteTotal >= 210:
-			zipettePoints = 3
-		}
-		if zipettePoints > 0 {
-			log.Printf("🎁 [CALC_POINTS] Zipette: %.2f€ → %d points", zipetteTotal, zipettePoints)
-		}
-	}
-
-	totalPoints := 0
-
-	// ✅ AJOUTER LES POINTS SÉPARÉMENT PAR CATÉGORIE
-	if zipettePoints > 0 {
-		if err := d.AddClientPointsByCategory(username, zipettePoints, "zipette&co"); err != nil {
-			log.Printf("❌ Erreur ajout points Zipette: %v", err)
-		} else {
-			totalPoints += zipettePoints
-			log.Printf("✅ %d points ZIPETTE ajoutés à %s", zipettePoints, username)
-		}
-	}
-
-	if weedPoints > 0 {
-		if err := d.AddClientPointsByCategory(username, weedPoints, "weed&hash"); err != nil {
-			log.Printf("❌ Erreur ajout points Weed: %v", err)
-		} else {
-			totalPoints += weedPoints
-			log.Printf("✅ %d points WEED ajoutés à %s", weedPoints, username)
-		}
-	}
-
-	if totalPoints == 0 {
-		if grosSemiTotal > 0 && zipetteTotal == 0 && weedTotal == 0 {
-			log.Printf("ℹ️ [CALC_POINTS] Cmd %d - Catégorie GROS&SEMI uniquement → 0 points", commandID)
-		} else {
-			log.Printf("ℹ️ [CALC_POINTS] Cmd %d - Aucun point éligible (Weed: %.2f€, Zipette: %.2f€)",
-				commandID, weedTotal, zipetteTotal)
-		}
-	}
-
-	log.Printf("✅ [CALC_POINTS] Cmd %d - Total: %d points (Zipette: %d, Weed: %d)",
-		commandID, totalPoints, zipettePoints, weedPoints)
-
-	return totalPoints, nil
-}
-
 func (d *Database) CalculateAndAddPointsForCommandTx(tx *sql.Tx, commandID int, username string) (int, string, error) {
 	log.Printf("💰 [CalcPointsTx] START - cmd=%d, user=%s", commandID, username)
 
@@ -982,8 +743,6 @@ func (d *Database) CalculateAndAddPointsForCommandTx(tx *sql.Tx, commandID int,
 		pointCategory = "points"
 	}
 
-	// Écrire tous les pools dans points_extra[pool.Key] (stockage dynamique)
-	// + maintenir les colonnes legacy point/point_zipette pour la compatibilité admin
 	for i, pool := range pools {
 		if poolPts[i] == 0 {
 			continue
@@ -1004,29 +763,6 @@ func (d *Database) CalculateAndAddPointsForCommandTx(tx *sql.Tx, commandID int,
 		log.Printf("💰 [CalcPointsTx] pool[%d] (%s / key=%s): +%d pts", i, pool.Name, pool.Key, poolPts[i])
 	}
 
-	// Maintenir colonnes legacy pour affichage admin
-	pts0 := poolPts[0]
-	pts1 := 0
-	if len(pools) >= 2 {
-		pts1 = poolPts[1]
-	}
-	var legacyErr error
-	var result sql.Result
-	if pts1 == 0 {
-		result, legacyErr = tx.Exec(`UPDATE clients SET point = point + $1, updated_at = CURRENT_TIMESTAMP WHERE username = $2`, pts0, username)
-	} else {
-		result, legacyErr = tx.Exec(`UPDATE clients SET point = point + $1, point_zipette = point_zipette + $2, updated_at = CURRENT_TIMESTAMP WHERE username = $3`, pts0, pts1, username)
-	}
-	if legacyErr != nil {
-		log.Printf("❌ [CalcPointsTx] Erreur UPDATE colonnes legacy: %v", legacyErr)
-		return 0, "", fmt.Errorf("erreur mise à jour points: %w", legacyErr)
-	}
-	affected, _ := result.RowsAffected()
-	if affected == 0 {
-		log.Printf("⚠️ [CalcPointsTx] Client %s non trouvé", username)
-		return 0, "", fmt.Errorf("client non trouvé")
-	}
-
 	log.Printf("🎉 [CalcPointsTx] SUCCÈS - %d points [%s] → %s", totalPoints, pointCategory, username)
 
 	return totalPoints, pointCategory, nil
@@ -1066,22 +802,3 @@ func (d *Database) CanUserAccessCommand(
 
 	return exists, err
 }
-
-// SaveClientPushToken enregistre le push token Expo d'un client
-func (d *Database) SaveClientPushToken(clientID int, pushToken string) error {
-	_, err := d.Exec(`UPDATE clients SET push_token = $1 WHERE id = $2`, pushToken, clientID)
-	return err
-}
-
-// DeleteClientPushToken supprime le push token d'un client
-func (d *Database) DeleteClientPushToken(clientID int) error {
-	_, err := d.Exec(`UPDATE clients SET push_token = NULL WHERE id = $1`, clientID)
-	return err
-}
-
-// GetClientPushToken retourne le push token d'un client par son username
-func (d *Database) GetClientPushToken(username string) (string, error) {
-	var token string
-	err := d.QueryRow(`SELECT COALESCE(push_token, '') FROM clients WHERE username = $1`, username).Scan(&token)
-	return token, err
-}