417 lines
12 KiB
Go
417 lines
12 KiB
Go
package handlers
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"gestion/db"
|
|
"gestion/utils"
|
|
"log"
|
|
"net/http"
|
|
"slices"
|
|
"strconv"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
)
|
|
|
|
func GetMyDeliveries(c *gin.Context) {
|
|
database := c.MustGet("database").(*db.Database)
|
|
|
|
username, exists := c.Get("username")
|
|
if !exists {
|
|
c.JSON(http.StatusUnauthorized, gin.H{"error": "Non authentifié"})
|
|
return
|
|
}
|
|
|
|
if c.GetString("role") != "livreur" {
|
|
c.JSON(http.StatusForbidden, gin.H{"error": "Accès réservé aux livreurs"})
|
|
return
|
|
}
|
|
|
|
usernameStr := username.(string)
|
|
status := c.Query("status")
|
|
|
|
commands, err := database.GetDeliveryPersonCommands(usernameStr, status)
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{
|
|
"error": "Erreur récupération",
|
|
})
|
|
return
|
|
}
|
|
|
|
filteredCommands := make([]gin.H, len(commands))
|
|
for i, cmd := range commands {
|
|
commandID, _ := strconv.Atoi(fmt.Sprintf("%v", cmd["id"]))
|
|
items, _ := database.GetCommandItems(commandID)
|
|
|
|
// Client info SANS téléphone
|
|
clientUsername, _ := cmd["username"].(string)
|
|
client, _ := database.GetClientByUsername(clientUsername)
|
|
|
|
clientInfo := gin.H{"nom": "Client", "prenom": ""}
|
|
if client != nil {
|
|
clientInfo = gin.H{
|
|
"nom": client.Nom,
|
|
"prenom": client.Prenom,
|
|
}
|
|
}
|
|
|
|
itemsSummary := make([]gin.H, len(items))
|
|
for j, item := range items {
|
|
itemsSummary[j] = gin.H{
|
|
"produit": item["produit"],
|
|
"quantite": item["quantite"],
|
|
"prix": item["prix"],
|
|
}
|
|
}
|
|
|
|
etaData, _ := database.GetCommandETA(commandID)
|
|
|
|
filteredCommands[i] = gin.H{
|
|
"id": cmd["id"],
|
|
"status": cmd["status"],
|
|
"adresse": cmd["adresse"],
|
|
"total_prix": cmd["total_prix"],
|
|
"created_at": cmd["created_at"],
|
|
"client_info": clientInfo,
|
|
"items": itemsSummary,
|
|
"items_count": len(items),
|
|
"eta": etaData,
|
|
}
|
|
}
|
|
|
|
log.Printf("✅ [MY_DELIVERIES] %d livraisons (données filtrées)", len(filteredCommands))
|
|
|
|
c.JSON(http.StatusOK, gin.H{
|
|
"success": true,
|
|
"deliveries": filteredCommands,
|
|
"count": len(filteredCommands),
|
|
})
|
|
}
|
|
|
|
// ============================================
|
|
// GetDeliveryDetails
|
|
// ============================================
|
|
func GetDeliveryDetails(c *gin.Context) {
|
|
database := c.MustGet("database").(*db.Database)
|
|
|
|
username := c.GetString("username")
|
|
if c.GetString("role") != "livreur" {
|
|
c.JSON(http.StatusForbidden, gin.H{"error": "Accès réservé aux livreurs"})
|
|
return
|
|
}
|
|
|
|
commandID, err := strconv.Atoi(c.Param("id"))
|
|
if err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "ID invalide"})
|
|
return
|
|
}
|
|
|
|
command, err := database.GetCommandByID(commandID)
|
|
if err != nil {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "Commande non trouvée"})
|
|
return
|
|
}
|
|
|
|
// ✅ VÉRIFIER PROPRIÉTÉ
|
|
livreurAssign, _ := command["livreur_assign"].(string)
|
|
if livreurAssign != username {
|
|
log.Printf("❌ Accès refusé - cmd assignée à %s", livreurAssign)
|
|
c.JSON(http.StatusForbidden, gin.H{
|
|
"error": "Cette livraison ne vous est pas assignée",
|
|
})
|
|
return
|
|
}
|
|
|
|
items, _ := database.GetCommandItems(commandID)
|
|
|
|
clientUsername, _ := command["username"].(string)
|
|
client, _ := database.GetClientByUsername(clientUsername)
|
|
|
|
clientInfo := gin.H{"nom": "Client", "prenom": ""}
|
|
if client != nil {
|
|
clientInfo = gin.H{
|
|
"nom": client.Nom,
|
|
"prenom": client.Prenom,
|
|
}
|
|
}
|
|
|
|
itemsSummary := make([]gin.H, len(items))
|
|
for i, item := range items {
|
|
itemsSummary[i] = gin.H{
|
|
"produit": item["produit"],
|
|
"quantite": item["quantite"],
|
|
"prix": item["prix"],
|
|
}
|
|
}
|
|
|
|
etaData, _ := database.GetCommandETA(commandID)
|
|
|
|
c.JSON(http.StatusOK, gin.H{
|
|
"success": true,
|
|
"delivery": gin.H{
|
|
"id": command["id"],
|
|
"status": command["status"],
|
|
"adresse": command["adresse"],
|
|
"total_prix": command["total_prix"],
|
|
"referral_used": command["referral_used"],
|
|
"created_at": command["created_at"],
|
|
"client_info": clientInfo,
|
|
"items": itemsSummary,
|
|
"items_count": len(items),
|
|
"eta": etaData,
|
|
},
|
|
})
|
|
}
|
|
|
|
func UpdateDeliveryStatus(c *gin.Context) {
|
|
database := c.MustGet("database").(*db.Database)
|
|
|
|
username, exists := c.Get("username")
|
|
if !exists || c.GetString("role") != "livreur" {
|
|
c.JSON(http.StatusForbidden, gin.H{"error": "Accès réservé aux livreurs"})
|
|
return
|
|
}
|
|
|
|
usernameStr := username.(string)
|
|
commandID, err := strconv.Atoi(c.Param("id"))
|
|
if err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "ID invalide"})
|
|
return
|
|
}
|
|
|
|
var req struct {
|
|
Status string `json:"status" binding:"required"`
|
|
Notes string `json:"notes"`
|
|
Latitude float64 `json:"latitude"`
|
|
Longitude float64 `json:"longitude"`
|
|
}
|
|
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{
|
|
"error": "Données invalides",
|
|
})
|
|
return
|
|
}
|
|
|
|
log.Printf("📝 [UPD_STATUS] %s update cmd %d: %s", usernameStr, commandID, req.Status)
|
|
|
|
command, err := database.GetCommandByID(commandID)
|
|
if err != nil {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "Commande non trouvée"})
|
|
return
|
|
}
|
|
|
|
livreurAssign, _ := command["livreur_assign"].(string)
|
|
if livreurAssign != usernameStr {
|
|
log.Printf("❌ Accès refusé - assigné à %s", livreurAssign)
|
|
c.JSON(http.StatusForbidden, gin.H{
|
|
"error": "Cette commande ne vous est pas assignée",
|
|
})
|
|
return
|
|
}
|
|
|
|
validStatuses := []string{
|
|
"assigned",
|
|
"en_route",
|
|
"arrived",
|
|
"livre",
|
|
"cancelled",
|
|
}
|
|
|
|
if !slices.Contains(validStatuses, req.Status) {
|
|
c.JSON(http.StatusBadRequest, gin.H{
|
|
"error": "Statut invalide",
|
|
"valid_statuses": validStatuses,
|
|
"received": req.Status,
|
|
})
|
|
return
|
|
}
|
|
|
|
if req.Status == "livre" {
|
|
if req.Latitude == 0 || req.Longitude == 0 {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "Coordonnées GPS requises pour confirmer la livraison"})
|
|
return
|
|
}
|
|
|
|
destLat, _ := command["dest_latitude"].(float64)
|
|
destLon, _ := command["dest_longitude"].(float64)
|
|
|
|
if destLat != 0 && destLon != 0 {
|
|
distance := utils.CalculateDistance(req.Latitude, req.Longitude, destLat, destLon)
|
|
log.Printf("📍 [GPS] Distance: %.2f m", distance)
|
|
|
|
if distance > 100 {
|
|
c.JSON(http.StatusBadRequest, gin.H{
|
|
"error": "Vous êtes trop loin de la destination",
|
|
"current_distance": fmt.Sprintf("%.2f", distance),
|
|
"unit": "meters",
|
|
})
|
|
return
|
|
}
|
|
|
|
log.Printf("✅ [GPS] Validation OK")
|
|
} else {
|
|
log.Printf("⚠️ [GPS] Coordonnées de destination non disponibles, validation ignorée")
|
|
}
|
|
}
|
|
|
|
// Mettre à jour le statut
|
|
if err := database.UpdateCommandStatus(commandID, req.Status); err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{
|
|
"error": "Erreur mise à jour",
|
|
})
|
|
return
|
|
}
|
|
|
|
// ✅ SI PASSAGE EN "EN_ROUTE" → CALCULER ET DÉFINIR L'ETA
|
|
var etaMinutes int
|
|
var etaMessage string
|
|
|
|
if req.Status == "en_route" {
|
|
log.Printf("🚗 [STATUS_LIVREUR] Passage en 'en_route' - Calcul ETA...")
|
|
|
|
var destLat, destLon float64
|
|
|
|
destCacheKey := fmt.Sprintf("command:destination:%d", commandID)
|
|
destData, err := db.Redis.Get(db.RedisCtx, destCacheKey).Result()
|
|
if err == nil && destData != "" {
|
|
var coords struct {
|
|
Lat float64 `json:"lat"`
|
|
Lon float64 `json:"lon"`
|
|
}
|
|
if err := json.Unmarshal([]byte(destData), &coords); err == nil && coords.Lat != 0 && coords.Lon != 0 {
|
|
destLat = coords.Lat
|
|
destLon = coords.Lon
|
|
log.Printf("📍 [STATUS_LIVREUR] Coords depuis cache Redis: (%.6f, %.6f)", destLat, destLon)
|
|
}
|
|
}
|
|
|
|
// 2. Fallback: récupérer depuis la DB
|
|
if destLat == 0 || destLon == 0 {
|
|
if dLat, ok := command["dest_latitude"].(float64); ok && dLat != 0 {
|
|
destLat = dLat
|
|
}
|
|
if dLon, ok := command["dest_longitude"].(float64); ok && dLon != 0 {
|
|
destLon = dLon
|
|
}
|
|
if destLat != 0 && destLon != 0 {
|
|
log.Printf("📍 [STATUS_LIVREUR] Coords depuis DB: (%.6f, %.6f)", destLat, destLon)
|
|
}
|
|
}
|
|
|
|
if destLat != 0 && destLon != 0 {
|
|
etaMinutes = database.CalculateETAForDeliveryman(usernameStr, destLat, destLon)
|
|
|
|
if err := database.SetCommandETA(commandID, etaMinutes); err != nil {
|
|
log.Printf("⚠️ [STATUS_LIVREUR] Erreur définition ETA: %v", err)
|
|
} else {
|
|
log.Printf("✅ [STATUS_LIVREUR] ETA défini: %d minutes", etaMinutes)
|
|
if etaMinutes >= 60 {
|
|
h := etaMinutes / 60
|
|
m := etaMinutes % 60
|
|
if m > 0 {
|
|
etaMessage = fmt.Sprintf("Arrivée prévue dans %dh%02d", h, m)
|
|
} else {
|
|
etaMessage = fmt.Sprintf("Arrivée prévue dans %dh", h)
|
|
}
|
|
} else {
|
|
etaMessage = fmt.Sprintf("Arrivée prévue dans %d minutes", etaMinutes)
|
|
}
|
|
}
|
|
} else {
|
|
log.Printf("⚠️ [STATUS_LIVREUR] Coordonnées destination manquantes - ETA par défaut")
|
|
etaMinutes = 30
|
|
database.SetCommandETA(commandID, etaMinutes)
|
|
}
|
|
|
|
// Mettre à jour le statut du livreur en "delivering"
|
|
database.SetDeliveryPersonStatus(usernameStr, "delivering", commandID)
|
|
log.Printf("🚗 [STATUS_LIVREUR] Statut livreur mis à jour: delivering")
|
|
}
|
|
|
|
// Log
|
|
message := req.Notes
|
|
if message == "" {
|
|
message = utils.GetDeliveryStatusMessage(req.Status)
|
|
}
|
|
if etaMessage != "" {
|
|
message += fmt.Sprintf(" - %s", etaMessage)
|
|
}
|
|
database.AddCommandLog(commandID, req.Status, message, usernameStr)
|
|
|
|
// ✅ NOTIFICATION CLIENT
|
|
clientUsername, _ := command["username"].(string)
|
|
if clientUsername != "" {
|
|
var clientMsg string
|
|
switch req.Status {
|
|
case "en_route":
|
|
notifETA := etaMinutes
|
|
if notifETA == 0 {
|
|
if etaData, err := database.GetCommandETA(commandID); err == nil {
|
|
if v, ok := etaData["total_eta_minutes"]; ok {
|
|
if n, err2 := strconv.Atoi(v); err2 == nil && n > 0 {
|
|
notifETA = n
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if notifETA > 0 {
|
|
var etaStr string
|
|
if notifETA >= 60 {
|
|
h := notifETA / 60
|
|
m := notifETA % 60
|
|
if m > 0 {
|
|
etaStr = fmt.Sprintf("%dh%02d", h, m)
|
|
} else {
|
|
etaStr = fmt.Sprintf("%dh", h)
|
|
}
|
|
} else {
|
|
etaStr = fmt.Sprintf("%d min", notifETA)
|
|
}
|
|
clientMsg = fmt.Sprintf("Un livreur vient de prendre en charge ta commande #%d, il est en route (~%s)", database.GetClientOrderID(commandID), etaStr)
|
|
} else {
|
|
clientMsg = fmt.Sprintf("Un livreur vient de prendre en charge ta commande #%d, il est en route.", database.GetClientOrderID(commandID))
|
|
}
|
|
case "arrived":
|
|
clientMsg = fmt.Sprintf("Descend, le livreur est là dans 3min (commande #%d) 🛵", database.GetClientOrderID(commandID))
|
|
case "livre":
|
|
clientMsg = fmt.Sprintf("Ta commande #%d a bien été livrée ! Bonne dégustation l'ami et à bientôt 😊", database.GetClientOrderID(commandID))
|
|
case "cancelled":
|
|
clientMsg = fmt.Sprintf("Votre commande #%d a été annulée par le livreur", database.GetClientOrderID(commandID))
|
|
}
|
|
if clientMsg != "" {
|
|
database.NotifyClient(clientUsername, commandID, req.Status, clientMsg)
|
|
}
|
|
}
|
|
|
|
// ✅ GESTION SPÉCIALE SELON LE STATUT
|
|
switch req.Status {
|
|
case "livre":
|
|
// Livraison terminée - Optimiser la queue
|
|
log.Printf("📦 Livraison marquée 'livre' - Optimisation queue...")
|
|
database.CompleteDeliveryAndProcessNext(usernameStr, commandID)
|
|
|
|
case "cancelled":
|
|
// Annulation par le livreur - Nettoyer la queue
|
|
log.Printf("🚫 Livraison annulée par livreur - Nettoyage queue cmd %d", commandID)
|
|
database.CompleteDeliveryAndProcessNext(usernameStr, commandID)
|
|
|
|
case "arrived":
|
|
log.Printf("📍 Livreur arrivé à destination - Commande %d", commandID)
|
|
}
|
|
|
|
response := gin.H{
|
|
"success": true,
|
|
"message": "Statut mis à jour",
|
|
"command_id": commandID,
|
|
"status": req.Status,
|
|
}
|
|
|
|
if req.Status == "en_route" && etaMinutes > 0 {
|
|
response["eta_minutes"] = etaMinutes
|
|
response["eta_message"] = etaMessage
|
|
}
|
|
|
|
c.JSON(http.StatusOK, response)
|
|
}
|