748 lines
21 KiB
Go
748 lines
21 KiB
Go
package db
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"gestion/models"
|
|
"log"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/redis/go-redis/v9"
|
|
)
|
|
|
|
// ============================================
|
|
// 🆕 GESTION AUTOMATIQUE DU STATUT BUSY
|
|
// ============================================
|
|
|
|
// UpdateDeliverymanStatusBasedOnQueue met à jour automatiquement le statut
|
|
// ✅ Status = "busy" si queue >= 10
|
|
// ✅ Status = "available" si queue < 10
|
|
func (d *Database) UpdateDeliverymanStatusBasedOnQueue(deliveryman string) error {
|
|
queueKey := fmt.Sprintf("queue:deliveryman:%s", deliveryman)
|
|
queueSize, err := Redis.ZCard(RedisCtx, queueKey).Result()
|
|
if err != nil {
|
|
return fmt.Errorf("erreur récupération taille queue: %w", err)
|
|
}
|
|
|
|
// Récupérer le statut actuel
|
|
statusKey := fmt.Sprintf("delivery:status:%s", deliveryman)
|
|
data, err := Redis.Get(RedisCtx, statusKey).Result()
|
|
if err != nil {
|
|
log.Printf("⚠️ [STATUS] Livreur %s n'a pas de statut Redis", deliveryman)
|
|
return nil
|
|
}
|
|
|
|
var status models.DeliveryPersonStatus
|
|
if err := json.Unmarshal([]byte(data), &status); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Déterminer le nouveau statut
|
|
var newStatus string
|
|
var currentCommand int
|
|
|
|
if queueSize >= MAX_COMMANDS_PER_DELIVERYMAN {
|
|
// 🔴 BUSY car queue pleine (10 commandes ou plus)
|
|
newStatus = "busy"
|
|
currentCommand = 0
|
|
log.Printf("🔴 [STATUS] %s -> BUSY (queue pleine: %d/10)", deliveryman, queueSize)
|
|
} else {
|
|
// 🟢 AVAILABLE tant que queue < 10
|
|
// Exception: si le livreur est en train de livrer (delivering), on garde ce statut
|
|
if status.Status == "delivering" && status.CurrentCommand > 0 {
|
|
newStatus = "delivering"
|
|
currentCommand = status.CurrentCommand
|
|
log.Printf("🟡 [STATUS] %s -> DELIVERING (queue: %d/10, livraison en cours: cmd %d)",
|
|
deliveryman, queueSize, currentCommand)
|
|
} else {
|
|
newStatus = "available"
|
|
currentCommand = 0
|
|
log.Printf("🟢 [STATUS] %s -> AVAILABLE (queue: %d/10)", deliveryman, queueSize)
|
|
}
|
|
}
|
|
|
|
// Mettre à jour le statut
|
|
return d.SetDeliveryPersonStatus(deliveryman, newStatus, currentCommand)
|
|
}
|
|
|
|
// CanDeliverymanAcceptCommands vérifie si un livreur peut accepter de nouvelles commandes
|
|
// ✅ Retourne false si: status=busy ET queue>=10, ou status=offline
|
|
func (d *Database) CanDeliverymanAcceptCommands(deliveryman string) bool {
|
|
// 1. Vérifier le statut Redis
|
|
statusKey := fmt.Sprintf("delivery:status:%s", deliveryman)
|
|
data, err := Redis.Get(RedisCtx, statusKey).Result()
|
|
if err != nil {
|
|
log.Printf("⚠️ [CHECK] Livreur %s sans statut Redis", deliveryman)
|
|
return true // Fallback: autoriser si pas de statut
|
|
}
|
|
|
|
var status models.DeliveryPersonStatus
|
|
if err := json.Unmarshal([]byte(data), &status); err != nil {
|
|
return true
|
|
}
|
|
|
|
// 2. Si offline, refuser
|
|
if status.Status == "offline" {
|
|
log.Printf("⚫ [CHECK] %s REFUSÉ: offline", deliveryman)
|
|
return false
|
|
}
|
|
|
|
// 3. Vérifier la taille de la queue
|
|
queueKey := fmt.Sprintf("queue:deliveryman:%s", deliveryman)
|
|
queueSize, _ := Redis.ZCard(RedisCtx, queueKey).Result()
|
|
|
|
// 4. Si queue >= 10, refuser
|
|
if queueSize >= MAX_COMMANDS_PER_DELIVERYMAN {
|
|
log.Printf("🔴 [CHECK] %s REFUSÉ: queue pleine (%d/10)", deliveryman, queueSize)
|
|
return false
|
|
}
|
|
|
|
log.Printf("🟢 [CHECK] %s AUTORISÉ (%d/10)", deliveryman, queueSize)
|
|
return true
|
|
}
|
|
|
|
// GetAvailableDeliveryPersonsForAssignment récupère UNIQUEMENT les livreurs pouvant accepter
|
|
func (d *Database) GetAvailableDeliveryPersonsForAssignment() ([]models.DeliveryPersonStatus, error) {
|
|
keys, err := Redis.Keys(RedisCtx, "delivery:status:*").Result()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var available []models.DeliveryPersonStatus
|
|
|
|
for _, key := range keys {
|
|
data, err := Redis.Get(RedisCtx, key).Result()
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
var status models.DeliveryPersonStatus
|
|
if err := json.Unmarshal([]byte(data), &status); err != nil {
|
|
continue
|
|
}
|
|
|
|
// ✅ Vérifier si le livreur peut accepter des commandes
|
|
if d.CanDeliverymanAcceptCommands(status.Username) {
|
|
available = append(available, status)
|
|
}
|
|
}
|
|
|
|
log.Printf("📊 [AVAILABLE] %d livreur(s) disponible(s) pour assignation", len(available))
|
|
|
|
return available, nil
|
|
}
|
|
|
|
// ============================================
|
|
// 🔄 FONCTIONS MODIFIÉES AVEC AUTO-STATUS
|
|
// ============================================
|
|
|
|
// AddToDeliverymanQueue - VERSION MISE À JOUR avec auto-update du statut
|
|
func (d *Database) AddToDeliverymanQueue(deliveryman string, queueItem models.CommandQueue) error {
|
|
data, err := json.Marshal(queueItem)
|
|
if err != nil {
|
|
return fmt.Errorf("erreur serialisation: %w", err)
|
|
}
|
|
|
|
// Sauvegarder les données de la commande
|
|
commandKey := fmt.Sprintf("queue:pending:%d", queueItem.CommandID)
|
|
Redis.Set(RedisCtx, commandKey, data, 24*time.Hour)
|
|
|
|
// Ajouter à la queue sorted set du livreur (score = timestamp)
|
|
queueKey := fmt.Sprintf("queue:deliveryman:%s", deliveryman)
|
|
score := float64(time.Now().Unix())
|
|
|
|
err = Redis.ZAdd(RedisCtx, queueKey, redis.Z{
|
|
Score: score,
|
|
Member: queueItem.CommandID,
|
|
}).Err()
|
|
|
|
if err != nil {
|
|
return fmt.Errorf("erreur ajout queue Redis: %w", err)
|
|
}
|
|
|
|
// Incrémenter le compteur de commandes en attente pour ce livreur
|
|
counterKey := fmt.Sprintf("queue:deliveryman:%s:count", deliveryman)
|
|
Redis.Incr(RedisCtx, counterKey)
|
|
|
|
log.Printf("✅ Commande %d ajoutée à la queue de %s", queueItem.CommandID, deliveryman)
|
|
|
|
// ✅ NOUVEAU: Mettre à jour automatiquement le statut
|
|
go d.UpdateDeliverymanStatusBasedOnQueue(deliveryman)
|
|
|
|
return nil
|
|
}
|
|
|
|
// AddCommandToQueue ajoute une commande à la file d'attente Redis (version simple)
|
|
func (d *Database) AddCommandToQueue(commandID int) error {
|
|
if err := d.ValidateCommandBeforeQueue(commandID); err != nil {
|
|
log.Printf("❌ [QUEUE] Commande %d REFUSÉE: %v", commandID, err)
|
|
return fmt.Errorf("validation échouée: %w", err)
|
|
}
|
|
|
|
command, err := d.GetCommandByID(commandID)
|
|
if err != nil {
|
|
return fmt.Errorf("commande introuvable: %w", err)
|
|
}
|
|
|
|
// Gestion des coordonnées (NULL safe)
|
|
var lat, lng float64
|
|
if command["dest_latitude"] != nil {
|
|
if latVal, ok := command["dest_latitude"].(float64); ok {
|
|
lat = latVal
|
|
}
|
|
}
|
|
if command["dest_longitude"] != nil {
|
|
if lngVal, ok := command["dest_longitude"].(float64); ok {
|
|
lng = lngVal
|
|
}
|
|
}
|
|
|
|
// Récupérer le total_prix avec gestion de type
|
|
var totalPrice float64
|
|
if tp, ok := command["total_prix"].(float64); ok {
|
|
totalPrice = tp
|
|
}
|
|
|
|
// Récupérer l'adresse
|
|
var address string
|
|
if addr, ok := command["delivery_address"].(string); ok {
|
|
address = addr
|
|
}
|
|
|
|
queueItem := models.CommandQueue{
|
|
CommandID: commandID,
|
|
Username: command["username"].(string),
|
|
TotalPrice: totalPrice,
|
|
Address: address,
|
|
Lat: lat,
|
|
Lng: lng,
|
|
CreatedAt: time.Now(),
|
|
EstimatedETA: 0,
|
|
}
|
|
|
|
// Ajouter à la queue générale
|
|
return d.AddToGeneralQueue(queueItem)
|
|
}
|
|
|
|
// AddCommandToSmartQueue - Ajoute une commande avec attribution au livreur le moins chargé
|
|
func (d *Database) AddCommandToSmartQueue(commandID int, address string) error {
|
|
if err := d.ValidateCommandBeforeQueue(commandID); err != nil {
|
|
log.Printf("❌ [QUEUE] Commande %d REFUSÉE: %v", commandID, err)
|
|
return fmt.Errorf("validation échouée: %w", err)
|
|
}
|
|
command, err := d.GetCommandByID(commandID)
|
|
if err != nil {
|
|
return fmt.Errorf("commande introuvable: %w", err)
|
|
}
|
|
|
|
// Gestion des coordonnées (NULL safe)
|
|
var lat, lng float64
|
|
if command["dest_latitude"] != nil {
|
|
if latVal, ok := command["dest_latitude"].(float64); ok {
|
|
lat = latVal
|
|
}
|
|
}
|
|
if command["dest_longitude"] != nil {
|
|
if lngVal, ok := command["dest_longitude"].(float64); ok {
|
|
lng = lngVal
|
|
}
|
|
}
|
|
|
|
// Récupérer le total_prix avec gestion de type
|
|
var totalPrice float64
|
|
if tp, ok := command["total_prix"].(float64); ok {
|
|
totalPrice = tp
|
|
}
|
|
|
|
queueItem := models.CommandQueue{
|
|
CommandID: commandID,
|
|
Username: command["username"].(string),
|
|
TotalPrice: totalPrice,
|
|
Address: address,
|
|
Lat: lat,
|
|
Lng: lng,
|
|
CreatedAt: time.Now(),
|
|
EstimatedETA: 0,
|
|
}
|
|
|
|
// ✅ MODIFIÉ: Utiliser FindLeastLoadedDeliveryman qui respecte maintenant le statut
|
|
assignedDeliveryman, err := d.FindLeastLoadedDeliveryman()
|
|
if err != nil {
|
|
// Aucun livreur trouvé, ajouter à la queue générale
|
|
log.Printf("⚠️ Aucun livreur trouvé, ajout à la queue générale")
|
|
return d.AddToGeneralQueue(queueItem)
|
|
}
|
|
|
|
// Ajouter la commande à la queue spécifique du livreur (auto-update du statut)
|
|
err = d.AddToDeliverymanQueue(assignedDeliveryman, queueItem)
|
|
if err != nil {
|
|
return fmt.Errorf("erreur ajout à la queue du livreur: %w", err)
|
|
}
|
|
|
|
log.Printf("📋 Commande %d assignée à la queue de %s", commandID, assignedDeliveryman)
|
|
|
|
// Publier l'événement
|
|
d.PublishCommandEvent(commandID, "queued",
|
|
fmt.Sprintf("En attente dans la queue de %s", assignedDeliveryman))
|
|
|
|
return nil
|
|
}
|
|
|
|
// AddToGeneralQueue ajoute une commande à la queue générale (fallback)
|
|
func (d *Database) AddToGeneralQueue(queueItem models.CommandQueue) error {
|
|
data, err := json.Marshal(queueItem)
|
|
if err != nil {
|
|
return fmt.Errorf("erreur serialisation: %w", err)
|
|
}
|
|
|
|
score := float64(time.Now().Unix())
|
|
key := fmt.Sprintf("queue:pending:%d", queueItem.CommandID)
|
|
|
|
pipe := Redis.Pipeline()
|
|
pipe.Set(RedisCtx, key, data, 24*time.Hour)
|
|
pipe.ZAdd(RedisCtx, "queue:pending:sorted", redis.Z{
|
|
Score: score,
|
|
Member: queueItem.CommandID,
|
|
})
|
|
|
|
_, err = pipe.Exec(RedisCtx)
|
|
if err != nil {
|
|
return fmt.Errorf("erreur ajout queue générale: %w", err)
|
|
}
|
|
|
|
log.Printf("📥 Commande %d ajoutée à la queue générale", queueItem.CommandID)
|
|
return nil
|
|
}
|
|
|
|
// RemoveCommandFromQueue - VERSION AMÉLIORÉE avec auto-update du statut
|
|
func (d *Database) RemoveCommandFromQueue(commandID int) error {
|
|
key := fmt.Sprintf("queue:pending:%d", commandID)
|
|
commandIDStr := strconv.Itoa(commandID)
|
|
|
|
pipe := Redis.Pipeline()
|
|
pipe.Del(RedisCtx, key)
|
|
pipe.ZRem(RedisCtx, "queue:pending:sorted", commandIDStr)
|
|
pipe.ZRem(RedisCtx, "queue:priority:sorted", commandIDStr)
|
|
|
|
// Trouver et retirer de la queue du livreur
|
|
keys, _ := Redis.Keys(RedisCtx, "queue:deliveryman:*").Result()
|
|
var affectedDeliveryman string
|
|
|
|
for _, queueKey := range keys {
|
|
if len(queueKey) > 6 && queueKey[len(queueKey)-6:] == ":count" {
|
|
continue
|
|
}
|
|
|
|
// Vérifier si la commande est dans cette queue
|
|
_, err := Redis.ZRank(RedisCtx, queueKey, commandIDStr).Result()
|
|
if err == nil {
|
|
// Commande trouvée dans cette queue
|
|
affectedDeliveryman = queueKey[len("queue:deliveryman:"):]
|
|
pipe.ZRem(RedisCtx, queueKey, commandIDStr)
|
|
|
|
// Décrémenter le compteur
|
|
counterKey := fmt.Sprintf("queue:deliveryman:%s:count", affectedDeliveryman)
|
|
pipe.Decr(RedisCtx, counterKey)
|
|
break
|
|
}
|
|
}
|
|
|
|
_, err := pipe.Exec(RedisCtx)
|
|
if err != nil {
|
|
return fmt.Errorf("erreur suppression: %w", err)
|
|
}
|
|
|
|
log.Printf("✅ Commande %d retirée de la file", commandID)
|
|
|
|
// ✅ NOUVEAU: Mettre à jour le statut si un livreur était affecté
|
|
if affectedDeliveryman != "" {
|
|
go d.UpdateDeliverymanStatusBasedOnQueue(affectedDeliveryman)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (d *Database) GetNextCommandInQueue() (*models.CommandQueue, error) {
|
|
|
|
normalResults, err := Redis.ZRangeWithScores(RedisCtx, "queue:pending:sorted", 0, 0).Result()
|
|
|
|
if err != nil || len(normalResults) == 0 {
|
|
return nil, fmt.Errorf("aucune commande en attente")
|
|
}
|
|
|
|
commandID := extractCommandID(normalResults[0].Member)
|
|
if commandID <= 0 {
|
|
return nil, fmt.Errorf("ID commande invalide")
|
|
}
|
|
|
|
key := fmt.Sprintf("queue:pending:%d", commandID)
|
|
data, err := Redis.Get(RedisCtx, key).Result()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("commande introuvable: %w", err)
|
|
}
|
|
|
|
var queue models.CommandQueue
|
|
if err := json.Unmarshal([]byte(data), &queue); err != nil {
|
|
return nil, fmt.Errorf("erreur désérialisation: %w", err)
|
|
}
|
|
return &queue, nil
|
|
}
|
|
|
|
// GetLastCommandInQueue récupère la dernière commande dans la queue d'un livreur
|
|
func (d *Database) GetLastCommandInQueue(deliveryman string) (*models.CommandQueue, error) {
|
|
queueKey := fmt.Sprintf("queue:deliveryman:%s", deliveryman)
|
|
|
|
// Récupérer la dernière commande (index -1)
|
|
commandIDs, err := Redis.ZRange(RedisCtx, queueKey, -1, -1).Result()
|
|
if err != nil || len(commandIDs) == 0 {
|
|
return nil, fmt.Errorf("queue vide")
|
|
}
|
|
|
|
commandID := extractCommandID(commandIDs[0])
|
|
if commandID <= 0 {
|
|
return nil, fmt.Errorf("ID invalide")
|
|
}
|
|
|
|
commandKey := fmt.Sprintf("queue:pending:%d", commandID)
|
|
data, err := Redis.Get(RedisCtx, commandKey).Result()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var queueItem models.CommandQueue
|
|
if err := json.Unmarshal([]byte(data), &queueItem); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &queueItem, nil
|
|
}
|
|
|
|
// GetCommandQueuePosition récupère la position d'une commande dans la queue
|
|
func (d *Database) GetCommandQueuePosition(commandID int) (int, error) {
|
|
commandIDStr := strconv.Itoa(commandID)
|
|
|
|
// Chercher d'abord dans les queues des livreurs
|
|
keys, _ := Redis.Keys(RedisCtx, "queue:deliveryman:*").Result()
|
|
|
|
for _, queueKey := range keys {
|
|
// Éviter les clés de compteur
|
|
if len(queueKey) > 6 && queueKey[len(queueKey)-6:] == ":count" {
|
|
continue
|
|
}
|
|
|
|
rank, err := Redis.ZRank(RedisCtx, queueKey, commandIDStr).Result()
|
|
if err == nil {
|
|
return int(rank) + 1, nil
|
|
}
|
|
}
|
|
|
|
// Chercher dans la queue générale
|
|
rank, err := Redis.ZRank(RedisCtx, "queue:pending:sorted", commandIDStr).Result()
|
|
if err == nil {
|
|
return int(rank) + 1, nil
|
|
}
|
|
|
|
return 0, fmt.Errorf("commande non trouvée dans les queues")
|
|
}
|
|
|
|
func (d *Database) ClearDeliverymanQueue(deliveryman string) error {
|
|
queueKey := fmt.Sprintf("queue:deliveryman:%s", deliveryman)
|
|
|
|
// Récupérer toutes les commandes
|
|
commandIDs, _ := Redis.ZRange(RedisCtx, queueKey, 0, -1).Result()
|
|
|
|
// Redistribuer chaque commande
|
|
for _, cmdIDStr := range commandIDs {
|
|
commandID := extractCommandID(cmdIDStr)
|
|
if commandID <= 0 {
|
|
continue
|
|
}
|
|
|
|
// Récupérer les données de la commande
|
|
commandKey := fmt.Sprintf("queue:pending:%d", commandID)
|
|
data, err := Redis.Get(RedisCtx, commandKey).Result()
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
var queueItem models.CommandQueue
|
|
if err := json.Unmarshal([]byte(data), &queueItem); err != nil {
|
|
continue
|
|
}
|
|
|
|
// Trouver un nouveau livreur
|
|
newDeliveryman, err := d.FindLeastLoadedDeliveryman()
|
|
if err != nil {
|
|
// Fallback: queue générale
|
|
d.AddToGeneralQueue(queueItem)
|
|
continue
|
|
}
|
|
|
|
// Réassigner à un autre livreur
|
|
if newDeliveryman != deliveryman {
|
|
d.AddToDeliverymanQueue(newDeliveryman, queueItem)
|
|
log.Printf("🔄 Commande %d réassignée de %s à %s",
|
|
commandID, deliveryman, newDeliveryman)
|
|
}
|
|
}
|
|
|
|
// Vider la queue
|
|
Redis.Del(RedisCtx, queueKey)
|
|
Redis.Del(RedisCtx, fmt.Sprintf("queue:deliveryman:%s:count", deliveryman))
|
|
|
|
log.Printf("🗑️ Queue de %s vidée et redistribuée", deliveryman)
|
|
|
|
// ✅ NOUVEAU: Mettre à jour le statut
|
|
go d.UpdateDeliverymanStatusBasedOnQueue(deliveryman)
|
|
|
|
return nil
|
|
}
|
|
|
|
func (d *Database) SetDeliveryPersonStatus(username, status string, commandID int) error {
|
|
key := fmt.Sprintf("delivery:status:%s", username)
|
|
|
|
statusData := models.DeliveryPersonStatus{
|
|
Username: username,
|
|
Status: status,
|
|
CurrentCommand: commandID,
|
|
LastUpdate: time.Now(),
|
|
}
|
|
|
|
data, _ := json.Marshal(statusData)
|
|
err := Redis.Set(RedisCtx, key, data, 24*time.Hour).Err()
|
|
|
|
if err == nil {
|
|
log.Printf("✅ Statut livreur %s: %s", username, status)
|
|
}
|
|
|
|
return err
|
|
}
|
|
|
|
// GetAvailableDeliveryPersonsRedis récupère les livreurs disponibles (LEGACY)
|
|
func (d *Database) GetAvailableDeliveryPersonsRedis() ([]models.DeliveryPersonStatus, error) {
|
|
keys, err := Redis.Keys(RedisCtx, "delivery:status:*").Result()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var available []models.DeliveryPersonStatus
|
|
|
|
for _, key := range keys {
|
|
data, err := Redis.Get(RedisCtx, key).Result()
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
var status models.DeliveryPersonStatus
|
|
json.Unmarshal([]byte(data), &status)
|
|
|
|
if status.Status == "available" {
|
|
available = append(available, status)
|
|
}
|
|
}
|
|
|
|
return available, nil
|
|
}
|
|
|
|
// GetAllActiveDeliveryPersons - VERSION MISE À JOUR avec vérification capacité
|
|
func (d *Database) GetAllActiveDeliveryPersons() ([]models.DeliveryPersonStatus, error) {
|
|
keys, err := Redis.Keys(RedisCtx, "delivery:status:*").Result()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var active []models.DeliveryPersonStatus
|
|
|
|
for _, key := range keys {
|
|
data, err := Redis.Get(RedisCtx, key).Result()
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
var status models.DeliveryPersonStatus
|
|
json.Unmarshal([]byte(data), &status)
|
|
|
|
if status.Status != "offline" {
|
|
// ✅ Vérifier si le livreur peut accepter des commandes
|
|
if d.CanDeliverymanAcceptCommands(status.Username) {
|
|
active = append(active, status)
|
|
}
|
|
}
|
|
}
|
|
|
|
return active, nil
|
|
}
|
|
|
|
// CountActiveDeliverymen compte le nombre de livreurs actifs (non offline)
|
|
func (d *Database) CountActiveDeliverymen() (int, error) {
|
|
keys, err := Redis.Keys(RedisCtx, "delivery:status:*").Result()
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
count := 0
|
|
for _, key := range keys {
|
|
data, err := Redis.Get(RedisCtx, key).Result()
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
var status models.DeliveryPersonStatus
|
|
json.Unmarshal([]byte(data), &status)
|
|
|
|
if status.Status != "offline" {
|
|
count++
|
|
}
|
|
}
|
|
|
|
return count, nil
|
|
}
|
|
|
|
func (d *Database) GetSingleActiveDeliveryman() (string, error) {
|
|
keys, err := Redis.Keys(RedisCtx, "delivery:status:*").Result()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
for _, key := range keys {
|
|
data, err := Redis.Get(RedisCtx, key).Result()
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
var status models.DeliveryPersonStatus
|
|
json.Unmarshal([]byte(data), &status)
|
|
|
|
if status.Status != "offline" {
|
|
return status.Username, nil
|
|
}
|
|
}
|
|
|
|
return "", fmt.Errorf("aucun livreur actif trouvé")
|
|
}
|
|
|
|
// GetAllActiveDeliverymenUsernames retourne les usernames de tous les livreurs actifs
|
|
func (d *Database) GetAllActiveDeliverymenUsernames() ([]string, error) {
|
|
keys, err := Redis.Keys(RedisCtx, "delivery:status:*").Result()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var activeUsernames []string
|
|
|
|
for _, key := range keys {
|
|
data, err := Redis.Get(RedisCtx, key).Result()
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
var status models.DeliveryPersonStatus
|
|
json.Unmarshal([]byte(data), &status)
|
|
|
|
if status.Status != "offline" {
|
|
activeUsernames = append(activeUsernames, status.Username)
|
|
}
|
|
}
|
|
|
|
return activeUsernames, nil
|
|
}
|
|
|
|
// ============================================
|
|
// 🔄 SYNCHRONISATION DES STATUTS
|
|
// ============================================
|
|
|
|
// SyncAllDeliverymanStatuses synchronise tous les statuts (à appeler au démarrage)
|
|
func (d *Database) SyncAllDeliverymanStatuses() error {
|
|
keys, err := Redis.Keys(RedisCtx, "delivery:status:*").Result()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
log.Println("🔄 [SYNC] Synchronisation des statuts livreurs...")
|
|
|
|
for _, key := range keys {
|
|
data, err := Redis.Get(RedisCtx, key).Result()
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
var status models.DeliveryPersonStatus
|
|
if err := json.Unmarshal([]byte(data), &status); err != nil {
|
|
continue
|
|
}
|
|
|
|
// Mettre à jour le statut basé sur la queue
|
|
d.UpdateDeliverymanStatusBasedOnQueue(status.Username)
|
|
}
|
|
|
|
log.Println("✅ [SYNC] Synchronisation terminée")
|
|
|
|
return nil
|
|
}
|
|
|
|
// ============================================
|
|
// 📊 RAPPORT DE CAPACITÉ
|
|
// ============================================
|
|
|
|
// GetDeliverymanCapacityReport génère un rapport détaillé
|
|
func (d *Database) GetDeliverymanCapacityReport() (map[string]interface{}, error) {
|
|
keys, err := Redis.Keys(RedisCtx, "delivery:status:*").Result()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
report := map[string]interface{}{
|
|
"total_deliverymen": 0,
|
|
"available": 0,
|
|
"busy_full": 0, // BUSY car queue pleine
|
|
"busy_delivering": 0, // BUSY car en livraison
|
|
"offline": 0,
|
|
"details": []map[string]interface{}{},
|
|
}
|
|
|
|
for _, key := range keys {
|
|
data, err := Redis.Get(RedisCtx, key).Result()
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
var status models.DeliveryPersonStatus
|
|
if err := json.Unmarshal([]byte(data), &status); err != nil {
|
|
continue
|
|
}
|
|
|
|
queueKey := fmt.Sprintf("queue:deliveryman:%s", status.Username)
|
|
queueSize, _ := Redis.ZCard(RedisCtx, queueKey).Result()
|
|
|
|
canAccept := d.CanDeliverymanAcceptCommands(status.Username)
|
|
|
|
detail := map[string]interface{}{
|
|
"username": status.Username,
|
|
"status": status.Status,
|
|
"queue_size": queueSize,
|
|
"capacity": fmt.Sprintf("%d/10", queueSize),
|
|
"can_accept": canAccept,
|
|
"current_order": status.CurrentCommand,
|
|
}
|
|
|
|
report["total_deliverymen"] = report["total_deliverymen"].(int) + 1
|
|
|
|
if status.Status == "offline" {
|
|
report["offline"] = report["offline"].(int) + 1
|
|
} else if status.Status == "busy" {
|
|
if queueSize >= MAX_COMMANDS_PER_DELIVERYMAN {
|
|
report["busy_full"] = report["busy_full"].(int) + 1
|
|
} else {
|
|
report["busy_delivering"] = report["busy_delivering"].(int) + 1
|
|
}
|
|
} else if canAccept {
|
|
report["available"] = report["available"].(int) + 1
|
|
}
|
|
|
|
report["details"] = append(report["details"].([]map[string]interface{}), detail)
|
|
}
|
|
|
|
return report, nil
|
|
}
|