649 lines
22 KiB
Go
649 lines
22 KiB
Go
package handlers
|
|
|
|
import (
|
|
"fmt"
|
|
"gestion/db"
|
|
"gestion/models"
|
|
"gestion/services"
|
|
"gestion/utils"
|
|
"log"
|
|
"net/http"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
)
|
|
|
|
type BasketsRequest struct {
|
|
Username string `json:"username"`
|
|
ProductID int `json:"product_id"`
|
|
NameProduct string `json:"name_product"`
|
|
Category string `json:"category"`
|
|
Quantity float64 `json:"quantity"`
|
|
}
|
|
|
|
// ============================================
|
|
// ✅ SÉCURISÉ: AddProductsBasket
|
|
// ============================================
|
|
// POST /api/v1/panier/add
|
|
func AddProductsBasket(c *gin.Context) {
|
|
database := c.MustGet("database").(*db.Database)
|
|
|
|
var req BasketsRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
utils.BindErr(c, err)
|
|
return
|
|
}
|
|
|
|
username, ok := c.Get("username")
|
|
if !ok {
|
|
c.JSON(http.StatusUnauthorized, gin.H{"error": "Authentification requise"})
|
|
return
|
|
}
|
|
req.Username = username.(string)
|
|
|
|
if req.Quantity <= 0 {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "Quantité invalide"})
|
|
return
|
|
}
|
|
if req.ProductID <= 0 {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "product_id requis"})
|
|
return
|
|
}
|
|
|
|
if p, err := database.GetProductByID(req.ProductID); err == nil && p.ComingSoon {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "Ce produit n'est pas encore disponible"})
|
|
return
|
|
}
|
|
|
|
panier, err := database.AddToBasket(req.Username, req.ProductID, req.Quantity)
|
|
if err != nil {
|
|
log.Printf("❌ [ADD_PANIER] product_id=%d qty=%.3f: %v", req.ProductID, req.Quantity, err)
|
|
if err.Error() == "stock insuffisant" {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "Stock insuffisant"})
|
|
return
|
|
}
|
|
if strings.Contains(err.Error(), "prix introuvable") {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "Aucun prix configuré pour ce produit"})
|
|
return
|
|
}
|
|
utils.ServerErr(c, "Impossible d'ajouter le produit au panier", err)
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{
|
|
"success": true,
|
|
"message": "Produit ajouté au panier avec succès",
|
|
"panier": panier,
|
|
})
|
|
}
|
|
|
|
func GetAllBaskets(c *gin.Context) {
|
|
database := c.MustGet("database").(*db.Database)
|
|
username := c.Param("username")
|
|
|
|
log.Printf("📦 [GET_PANIER] Requête pour: %s", username)
|
|
|
|
if username == "" {
|
|
log.Printf("❌ [GET_PANIER] Username manquant")
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "Le paramètre 'username' est requis"})
|
|
return
|
|
}
|
|
|
|
// ✅ SÉCURITÉ 1: Récupérer username depuis le contexte (du JWT validé)
|
|
authUsername, hasAuth := c.Get("username")
|
|
if !hasAuth {
|
|
log.Printf("❌ [GET_PANIER] Username manquant dans JWT")
|
|
c.JSON(http.StatusUnauthorized, gin.H{"error": "Authentification requise"})
|
|
return
|
|
}
|
|
|
|
authUsernameStr := authUsername.(string)
|
|
|
|
// ✅ SÉCURITÉ 2: Vérifier que c'est bien l'utilisateur de la session
|
|
if username != authUsernameStr {
|
|
log.Printf("❌ [GET_PANIER] ⚠️ TENTATIVE D'ACCÈS AU PANIER NON AUTORISÉE!")
|
|
log.Printf(" Username du JWT: %s", authUsernameStr)
|
|
log.Printf(" Username demandé: %s", username)
|
|
c.JSON(http.StatusForbidden, gin.H{
|
|
"error": "Vous ne pouvez accéder qu'à votre panier",
|
|
})
|
|
return
|
|
}
|
|
|
|
// ✅ SÉCURITÉ 3: Forcer l'utilisation du username du JWT
|
|
username = authUsernameStr
|
|
|
|
// ✅ SÉCURITÉ 4: Vérifier que c'est un CLIENT
|
|
_, err := database.GetClientByUsername(username)
|
|
if err != nil {
|
|
log.Printf("❌ [GET_PANIER] Client inexistant: %s", username)
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "Utilisateur inexistant"})
|
|
return
|
|
}
|
|
|
|
baskets, err := database.GetAllProductsInBasket(username)
|
|
if err != nil {
|
|
utils.ServerErr(c, "Erreur lors de la récupération du panier", err)
|
|
return
|
|
}
|
|
|
|
var totalAmount float64
|
|
for _, item := range baskets {
|
|
totalAmount += item.Price // price = prix total de la ligne (cumul des ajouts)
|
|
}
|
|
|
|
log.Printf("✅ [GET_PANIER] Panier %s: %d articles, total=%.2f€", username, len(baskets), totalAmount)
|
|
|
|
c.JSON(http.StatusOK, gin.H{
|
|
"success": true,
|
|
"message": "Panier récupéré avec succès",
|
|
"panier": baskets,
|
|
"count": len(baskets),
|
|
"total_amount": totalAmount,
|
|
})
|
|
}
|
|
|
|
func DeleteProductFromBasket(c *gin.Context) {
|
|
database := c.MustGet("database").(*db.Database)
|
|
|
|
var req struct {
|
|
ID int `json:"id" binding:"required"`
|
|
}
|
|
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
utils.BindErr(c, err)
|
|
return
|
|
}
|
|
|
|
// ✅ SÉCURITÉ 1: Récupérer username depuis le contexte (du JWT validé)
|
|
authUsername, hasAuth := c.Get("username")
|
|
if !hasAuth {
|
|
log.Printf("❌ [DEL_PANIER] Username manquant dans JWT")
|
|
c.JSON(http.StatusUnauthorized, gin.H{"error": "Authentification requise"})
|
|
return
|
|
}
|
|
|
|
authUsernameStr := authUsername.(string)
|
|
|
|
log.Printf("🗑️ [DEL_PANIER] Suppression article: id=%d, client=%s", req.ID, authUsernameStr)
|
|
|
|
// ✅ SÉCURITÉ 2: Vérifier que l'article appartient à ce client
|
|
itemUsername, err := database.GetBasketItemOwner(req.ID)
|
|
|
|
if err != nil {
|
|
log.Printf("❌ [DEL_PANIER] Article non trouvé: id=%d", req.ID)
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "Article non trouvé"})
|
|
return
|
|
}
|
|
|
|
if itemUsername != authUsernameStr {
|
|
log.Printf("❌ [DEL_PANIER] ⚠️ TENTATIVE DE SUPPRESSION NON AUTORISÉE!")
|
|
log.Printf(" Client JWT: %s", authUsernameStr)
|
|
log.Printf(" Propriétaire article: %s", itemUsername)
|
|
c.JSON(http.StatusForbidden, gin.H{
|
|
"error": "Vous ne pouvez supprimer que vos articles",
|
|
})
|
|
return
|
|
}
|
|
|
|
// Supprimer l'article
|
|
err = database.DeleteProductFromBasket(req.ID)
|
|
if err != nil {
|
|
utils.ServerErr(c, "Erreur lors de la suppression", err)
|
|
return
|
|
}
|
|
|
|
log.Printf("✅ [DEL_PANIER] Article %d supprimé", req.ID)
|
|
c.JSON(http.StatusOK, gin.H{
|
|
"success": true,
|
|
"message": "Produit supprimé du panier avec succès",
|
|
"item_id": req.ID,
|
|
})
|
|
}
|
|
|
|
func ClearBasket(c *gin.Context) {
|
|
database := c.MustGet("database").(*db.Database)
|
|
|
|
// ✅ SÉCURITÉ 1: Récupérer username depuis le contexte (du JWT validé)
|
|
authUsername, hasAuth := c.Get("username")
|
|
if !hasAuth {
|
|
log.Printf("❌ [CLEAR_PANIER] Username manquant dans JWT")
|
|
c.JSON(http.StatusUnauthorized, gin.H{"error": "Authentification requise"})
|
|
return
|
|
}
|
|
|
|
authUsernameStr := authUsername.(string)
|
|
|
|
log.Printf("🧹 [CLEAR_PANIER] Vider panier de: %s", authUsernameStr)
|
|
|
|
baskets, err := database.GetAllProductsInBasket(authUsernameStr)
|
|
if err != nil {
|
|
log.Printf("❌ [CLEAR_PANIER] Erreur récupération: %v", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{
|
|
"error": "Erreur lors du vidage du panier",
|
|
})
|
|
return
|
|
}
|
|
|
|
err = database.ClearBasket(authUsernameStr)
|
|
if err != nil {
|
|
utils.ServerErr(c, "Erreur lors du vidage du panier", err)
|
|
return
|
|
}
|
|
|
|
log.Printf("✅ [CLEAR_PANIER] Panier %s vidé: %d articles supprimés", authUsernameStr, len(baskets))
|
|
c.JSON(http.StatusOK, gin.H{
|
|
"success": true,
|
|
"message": "Panier vidé avec succès",
|
|
})
|
|
}
|
|
|
|
// POST /api/v1/checkout
|
|
func ValidateBasket(c *gin.Context) {
|
|
database := c.MustGet("database").(*db.Database)
|
|
geoService := c.MustGet("geoService").(*services.GeoService)
|
|
|
|
username, exists := c.Get("username")
|
|
if !exists {
|
|
c.JSON(http.StatusUnauthorized, gin.H{"error": "Utilisateur non authentifié"})
|
|
return
|
|
}
|
|
usernameStr := username.(string)
|
|
|
|
lockKey := fmt.Sprintf("checkout_lock:%s", usernameStr)
|
|
locked, errLock := db.Redis.SetNX(db.RedisCtx, lockKey, "1", 30*time.Second).Result()
|
|
if errLock != nil || !locked {
|
|
c.JSON(http.StatusConflict, gin.H{"error": "Un checkout est déjà en cours pour ce compte"})
|
|
return
|
|
}
|
|
defer db.Redis.Del(db.RedisCtx, lockKey)
|
|
|
|
var req struct {
|
|
DeliveryAddress string `json:"delivery_address" binding:"required"`
|
|
UseReferralBalance bool `json:"use_referral_balance"`
|
|
PaymentMethod string `json:"payment_method"` // "cash" (défaut) ou "crypto"
|
|
PayCurrency string `json:"pay_currency"` // ex: "btc", "eth", "ltc" (requis si crypto)
|
|
}
|
|
if err := c.ShouldBindJSON(&req); err != nil || req.DeliveryAddress == "" {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "Adresse de livraison requise"})
|
|
return
|
|
}
|
|
|
|
cmd := &models.Command{DeliveryAddress: req.DeliveryAddress}
|
|
if err := database.CheckAddress(cmd); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "Adresse non reconnue", "corrected_address": cmd.DeliveryAddress})
|
|
return
|
|
}
|
|
req.DeliveryAddress = cmd.DeliveryAddress
|
|
|
|
// Vérifier que le client a lié son compte Telegram (seulement si les notifications sont activées)
|
|
if services.TelegramBot != nil && services.TelegramBot.IsNotificationsEnabled() {
|
|
if _, linked, err := database.GetClientTelegramChatID(usernameStr); err != nil || !linked {
|
|
c.JSON(http.StatusForbidden, gin.H{"error": "Vous devez lier votre compte Telegram avant de commander"})
|
|
return
|
|
}
|
|
}
|
|
|
|
log.Printf("🛒 [CHECKOUT] Début checkout pour: %s", usernameStr)
|
|
|
|
// ============================================
|
|
// 1️⃣ Vérifier que le panier n'est pas vide
|
|
// ============================================
|
|
items, err := database.GetBasketItems(usernameStr)
|
|
if err != nil {
|
|
utils.ServerErr(c, "Impossible de récupérer le panier", err)
|
|
return
|
|
}
|
|
|
|
if len(items) == 0 {
|
|
log.Printf("❌ [CHECKOUT] Panier vide")
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "Panier vide"})
|
|
return
|
|
}
|
|
|
|
log.Printf("🛒 [CHECKOUT] Panier: %d articles", len(items))
|
|
|
|
// ============================================
|
|
// 1️⃣b Calculer le total et vérifier la présence d'au moins un article payant
|
|
// ============================================
|
|
var cartTotal float64
|
|
for _, item := range items {
|
|
if price, ok := item["price"].(float64); ok {
|
|
cartTotal += price
|
|
}
|
|
}
|
|
|
|
// Détecter si le panier contient un article récompense (prix 0)
|
|
hasRewardItem := false
|
|
for _, item := range items {
|
|
if price, ok := item["price"].(float64); ok && price == 0 {
|
|
hasRewardItem = true
|
|
break
|
|
}
|
|
}
|
|
// Si récompense présente mais aucun produit payant → refuser
|
|
if hasRewardItem && cartTotal <= 0 {
|
|
log.Printf("❌ [CHECKOUT] Panier contient uniquement des récompenses pour %s", usernameStr)
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "Vous devez commander au moins un produit de la boutique pour bénéficier de votre récompense"})
|
|
return
|
|
}
|
|
|
|
// Récupérer les paramètres globaux (zones + parrainage)
|
|
appSettings, _ := database.GetSettings()
|
|
|
|
// Récupérer le solde parrainage disponible (seulement si le système est activé)
|
|
var referralBalance float64
|
|
if req.UseReferralBalance && appSettings.ReferralEnabled {
|
|
referralBalance, _ = database.GetClientReferralBalance(usernameStr)
|
|
}
|
|
|
|
zoneResult := checkDeliveryZone(req.DeliveryAddress, cartTotal, appSettings.PostalZones)
|
|
if !zoneResult.OK {
|
|
if zoneResult.ZoneName == "inconnue" {
|
|
log.Printf("❌ [CHECKOUT] Aucun code postal trouvé dans l'adresse: %s", req.DeliveryAddress)
|
|
c.JSON(http.StatusBadRequest, gin.H{
|
|
"error": "Adresse invalide : aucun code postal détecté",
|
|
})
|
|
} else if zoneResult.ZoneName == "hors zone" {
|
|
log.Printf("❌ [CHECKOUT] Code postal %s hors zone de livraison", zoneResult.PostalCode)
|
|
c.JSON(http.StatusBadRequest, gin.H{
|
|
"error": "Livraison non disponible pour ce code postal",
|
|
"postal_code": zoneResult.PostalCode,
|
|
})
|
|
} else {
|
|
log.Printf("❌ [CHECKOUT] Total %.2f€ insuffisant pour %s (minimum %.2f€)", cartTotal, zoneResult.ZoneName, zoneResult.MinAmount)
|
|
c.JSON(http.StatusBadRequest, gin.H{
|
|
"error": fmt.Sprintf("Montant minimum de commande non atteint pour votre zone (%.0f€ minimum)", zoneResult.MinAmount),
|
|
"zone": zoneResult.ZoneName,
|
|
"minimum": zoneResult.MinAmount,
|
|
"cart_total": cartTotal,
|
|
"missing": zoneResult.MinAmount - cartTotal,
|
|
"postal_code": zoneResult.PostalCode,
|
|
"referral_balance": referralBalance,
|
|
})
|
|
}
|
|
return
|
|
}
|
|
|
|
// Règle parrainage : après déduction du crédit, le client doit toujours payer au minimum le seuil de zone.
|
|
// Ex : zone 50€, crédit 50€ → panier doit être >= 100€
|
|
var referralUsed float64
|
|
if req.UseReferralBalance && referralBalance > 0 {
|
|
effectivePayment := cartTotal - referralBalance
|
|
if effectivePayment < zoneResult.MinAmount {
|
|
needed := zoneResult.MinAmount + referralBalance
|
|
log.Printf("❌ [CHECKOUT] Crédit parrainage %.2f€ mais panier insuffisant: %.2f€ < %.2f€ requis", referralBalance, cartTotal, needed)
|
|
c.JSON(http.StatusBadRequest, gin.H{
|
|
"error": fmt.Sprintf("Avec %.2f€ de crédit parrainage, votre commande doit atteindre %.2f€ (minimum zone %.0f€ + crédit utilisé)", referralBalance, needed, zoneResult.MinAmount),
|
|
"zone": zoneResult.ZoneName,
|
|
"minimum": needed,
|
|
"cart_total": cartTotal,
|
|
"missing": needed - cartTotal,
|
|
"referral_balance": referralBalance,
|
|
"postal_code": zoneResult.PostalCode,
|
|
})
|
|
return
|
|
}
|
|
referralUsed = referralBalance
|
|
}
|
|
|
|
log.Printf("✅ [CHECKOUT] Zone OK: %s, total=%.2f€ >= %.2f€, crédit parrainage utilisé: %.2f€", zoneResult.ZoneName, cartTotal, zoneResult.MinAmount, referralUsed)
|
|
|
|
if referralUsed > 0 {
|
|
if err := database.DebitReferralBalance(usernameStr, referralUsed); err != nil {
|
|
log.Printf("❌ [CHECKOUT] Solde parrainage insuffisant pour %s: %v", usernameStr, err)
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "Solde parrainage insuffisant ou déjà utilisé"})
|
|
return
|
|
}
|
|
log.Printf("✅ [CHECKOUT] Crédit parrainage -%.2f€ débité pour %s", referralUsed, usernameStr)
|
|
}
|
|
|
|
// Vérifier que tous les produits du panier ont encore un prix actif
|
|
unavailable, err := database.GetUnavailableBasketItems(usernameStr)
|
|
if err != nil {
|
|
utils.ServerErr(c, "Erreur vérification produits", err)
|
|
return
|
|
}
|
|
if len(unavailable) > 0 {
|
|
log.Printf("❌ [CHECKOUT] Produits sans prix actif: %v", unavailable)
|
|
c.JSON(http.StatusBadRequest, gin.H{
|
|
"error": "Certains produits de votre panier ne sont plus disponibles",
|
|
"products": unavailable,
|
|
})
|
|
return
|
|
}
|
|
|
|
// Vérification option crypto
|
|
isCrypto := req.PaymentMethod == "crypto"
|
|
if isCrypto {
|
|
np, npOk := c.MustGet("nowpayments").(*services.NowPaymentsClient)
|
|
if !npOk || np == nil {
|
|
c.JSON(http.StatusServiceUnavailable, gin.H{"error": "Paiement crypto non disponible"})
|
|
return
|
|
}
|
|
if req.PayCurrency == "" {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "pay_currency requis pour le paiement crypto (ex: btc, eth, ltc)"})
|
|
return
|
|
}
|
|
}
|
|
|
|
command, err := database.CreateCommandWithAddress(usernameStr, req.DeliveryAddress)
|
|
if err != nil {
|
|
if referralUsed > 0 {
|
|
_ = database.CreditClientReferral(usernameStr, referralUsed)
|
|
}
|
|
log.Printf("❌ [CHECKOUT] Erreur création commande: %v", err)
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur création commande"})
|
|
return
|
|
}
|
|
commandID := command.ID
|
|
|
|
if referralUsed > 0 {
|
|
if err := database.SetCommandReferralUsed(commandID, referralUsed); err != nil {
|
|
log.Printf("⚠️ [CHECKOUT] Impossible de sauvegarder referral_used sur commande: %v", err)
|
|
}
|
|
}
|
|
|
|
log.Printf("✅ [CHECKOUT] Commande %d créée", commandID)
|
|
|
|
// Pour le paiement crypto, le panier/stock sera décrémenté à la confirmation du webhook NowPayments.
|
|
if isCrypto {
|
|
np := c.MustGet("nowpayments").(*services.NowPaymentsClient)
|
|
ipnURL := fmt.Sprintf("%s/api/v1/webhooks/nowpayments", getBaseURL(c))
|
|
payReq := &services.CreatePaymentRequest{
|
|
PriceAmount: cartTotal,
|
|
PriceCurrency: "eur",
|
|
PayCurrency: req.PayCurrency,
|
|
OrderID: fmt.Sprintf("%d", commandID),
|
|
IPNCallbackURL: ipnURL,
|
|
}
|
|
payResp, err := np.CreatePayment(payReq)
|
|
if err != nil {
|
|
// Annuler la commande et restaurer le panier / parrainage
|
|
_ = database.CancelCryptoCommand(commandID)
|
|
if referralUsed > 0 {
|
|
_ = database.CreditClientReferral(usernameStr, referralUsed)
|
|
}
|
|
log.Printf("❌ [CHECKOUT] Erreur création paiement NowPayments: %v", err)
|
|
c.JSON(http.StatusBadGateway, gin.H{"error": "Impossible d'initier le paiement crypto"})
|
|
return
|
|
}
|
|
|
|
// Passer la commande en 'pending_payment' (attente confirmation)
|
|
if _, err := database.DB.Exec(`UPDATE commandes SET status = 'pending_payment', payment_method = 'crypto', updated_at = NOW() WHERE id = $1`, commandID); err != nil {
|
|
log.Printf("⚠️ [CHECKOUT] Erreur mise à jour statut pending_payment: %v", err)
|
|
}
|
|
|
|
priceAmt, _ := payResp.PriceAmount.Float64()
|
|
payAmt, _ := payResp.PayAmount.Float64()
|
|
_, _ = database.CreateCryptoPayment(commandID, payResp.PaymentID.String(), payResp.Status, payResp.PriceCurrency, payResp.PayCurrency, payResp.PayAddress, priceAmt, payAmt)
|
|
|
|
log.Printf("✅ [CHECKOUT] Commande %d en attente paiement crypto (%s)", commandID, req.PayCurrency)
|
|
c.JSON(http.StatusCreated, gin.H{
|
|
"success": true,
|
|
"command_id": commandID,
|
|
"payment_method": "crypto",
|
|
"payment_status": payResp.Status,
|
|
"pay_address": payResp.PayAddress,
|
|
"pay_amount": payAmt,
|
|
"pay_currency": payResp.PayCurrency,
|
|
"price_amount": priceAmt,
|
|
"price_currency": payResp.PriceCurrency,
|
|
"message": "Commande créée - En attente de paiement crypto",
|
|
})
|
|
return
|
|
}
|
|
|
|
// Notifier immédiatement tous les admins et agents cabine
|
|
go database.NotifyAllAdminCabine(commandID, usernameStr, req.DeliveryAddress)
|
|
|
|
// ============================================
|
|
// 3️⃣ Décrémenter le stock et vider le panier
|
|
// ============================================
|
|
err = database.ClearBasketOnCheckout(usernameStr)
|
|
if err != nil {
|
|
// Stock insuffisant au moment du checkout (concurrent) → annuler la commande
|
|
if strings.Contains(err.Error(), "stock insuffisant") {
|
|
_ = database.CancelCryptoCommand(commandID)
|
|
if referralUsed > 0 {
|
|
_ = database.CreditClientReferral(usernameStr, referralUsed)
|
|
}
|
|
log.Printf("❌ [CHECKOUT] Stock insuffisant au moment de la validation: %v", err)
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "Désolé ! Tu as trop attendu pour passer commande! Le stock ou le produit n'est plus disponible, repasse commande"})
|
|
return
|
|
}
|
|
utils.ServerErr(c, "Impossible de valider le panier", err)
|
|
return
|
|
}
|
|
log.Printf("🧹 [CHECKOUT] Stock décrémenté et panier vidé")
|
|
|
|
// ============================================
|
|
// 4️⃣ Auto-assignation livreur (optionnel)
|
|
// ============================================
|
|
var assigned bool
|
|
var assignInfo gin.H
|
|
|
|
location, err := geoService.GeocodeAddress(req.DeliveryAddress)
|
|
if err == nil {
|
|
log.Printf("📍 [CHECKOUT] Adresse géocodée: %.6f,%.6f", location.Latitude, location.Longitude)
|
|
|
|
usernames, errEligible := database.GetEligibleDeliverymenForCommand(commandID)
|
|
if errEligible == nil && len(usernames) > 0 {
|
|
log.Printf("🚚 [CHECKOUT] %d livreur(s) éligible(s) disponibles", len(usernames))
|
|
|
|
nearest, err := geoService.FindNearestDeliveryPersonFast(services.Coordinates{
|
|
Latitude: location.Latitude,
|
|
Longitude: location.Longitude,
|
|
}, usernames)
|
|
|
|
if err == nil {
|
|
log.Printf("👤 [CHECKOUT] Livreur le plus proche: %s (%.2f km)", nearest.Username, nearest.Distance)
|
|
|
|
// ✅ CORRECTION: Utiliser CalculateETAWithTomTom au lieu de GetETAWithTraffic
|
|
travelTime, distance, err := services.CalculateETAWithTomTom(
|
|
nearest.Location,
|
|
services.Coordinates{
|
|
Latitude: location.Latitude,
|
|
Longitude: location.Longitude,
|
|
},
|
|
)
|
|
|
|
if err != nil {
|
|
// Fallback sur ETA simple
|
|
travelTime = nearest.EstimatedTime
|
|
distance = nearest.Distance
|
|
log.Printf("⚠️ [CHECKOUT] Fallback ETA: %d min", travelTime)
|
|
}
|
|
|
|
log.Printf("⏱️ [CHECKOUT] ETA calculé: %d min, distance: %.2f km", travelTime, distance)
|
|
|
|
// Assigner la commande au livreur
|
|
err = database.AssignCommandToDeliverymanQueueWithCoords(
|
|
commandID,
|
|
nearest.Username,
|
|
travelTime,
|
|
location.Latitude,
|
|
location.Longitude,
|
|
req.DeliveryAddress,
|
|
)
|
|
|
|
if err != nil {
|
|
log.Printf("⚠️ [CHECKOUT] Erreur assignation: %v", err)
|
|
} else {
|
|
// Mettre à jour le statut du livreur
|
|
err = database.SetDeliveryPersonStatus(nearest.Username, "busy", commandID)
|
|
if err != nil {
|
|
log.Printf("⚠️ [CHECKOUT] Erreur mise à jour statut livreur: %v", err)
|
|
}
|
|
|
|
// Notifier le livreur de la nouvelle commande
|
|
notifMsg := fmt.Sprintf("Nouvelle commande #%d assignée - Livraison dans ~%d min (%.2f km)", commandID, travelTime, distance)
|
|
if referralUsed > 0 {
|
|
notifMsg += fmt.Sprintf(" | Parrainage client: -%.2f€", referralUsed)
|
|
}
|
|
if notifErr := database.NotifyLivreur(nearest.Username, commandID, "new_assignment", notifMsg); notifErr != nil {
|
|
log.Printf("⚠️ [CHECKOUT] Erreur notification livreur: %v", notifErr)
|
|
}
|
|
|
|
// Notifier le client
|
|
clientOrderID := database.GetClientOrderID(commandID)
|
|
clientMsg := fmt.Sprintf("Ta commande #%d est prise en compte ! Merci de rester branché et vigilant sur les notifs à venir.", clientOrderID)
|
|
database.NotifyClient(usernameStr, commandID, "assigned", clientMsg)
|
|
|
|
assigned = true
|
|
assignInfo = gin.H{
|
|
"username": nearest.Username,
|
|
"distance_km": distance,
|
|
"travel_time": travelTime,
|
|
}
|
|
log.Printf("✅ [CHECKOUT] Commande assignée à %s", nearest.Username)
|
|
}
|
|
} else {
|
|
log.Printf("⚠️ [CHECKOUT] Aucun livreur trouvé: %v", err)
|
|
}
|
|
} else {
|
|
log.Printf("⚠️ [CHECKOUT] Aucun livreur éligible disponible")
|
|
}
|
|
} else {
|
|
log.Printf("⚠️ [CHECKOUT] Erreur géocodage: %v", err)
|
|
}
|
|
|
|
// ============================================
|
|
// 5️⃣ Réponse
|
|
// ============================================
|
|
newBalance, _ := database.GetClientReferralBalance(usernameStr)
|
|
resp := gin.H{
|
|
"success": true,
|
|
"command_id": commandID,
|
|
"client_order_number": command.ClientOrderID,
|
|
"delivery_address": req.DeliveryAddress,
|
|
"status": "pending",
|
|
"referral_used": referralUsed,
|
|
"referral_balance": newBalance,
|
|
}
|
|
|
|
if assigned {
|
|
resp["message"] = "Commande créée et livreur assigné automatiquement"
|
|
resp["auto_assigned"] = true
|
|
resp["assigned_to"] = assignInfo
|
|
resp["status"] = "assigned"
|
|
log.Printf("✅ [CHECKOUT] Réponse 200 - Commande %d assignée", commandID)
|
|
} else {
|
|
resp["message"] = "Commande créée - En attente d'assignation"
|
|
resp["auto_assigned"] = false
|
|
log.Printf("✅ [CHECKOUT] Réponse 200 - Commande %d en attente", commandID)
|
|
}
|
|
|
|
c.JSON(http.StatusCreated, resp)
|
|
}
|
|
|
|
// getBaseURL construit l'URL de base depuis la requête en cours
|
|
func getBaseURL(c *gin.Context) string {
|
|
scheme := "https"
|
|
if c.Request.TLS == nil && c.GetHeader("X-Forwarded-Proto") != "https" {
|
|
scheme = "http"
|
|
}
|
|
return fmt.Sprintf("%s://%s", scheme, c.Request.Host)
|
|
}
|