chore: add ansible backend docker frontend-prep

backend/gestion/db/redis_queue_info.go

@@ -0,0 +1,169 @@
+package db
+
+import (
+	"encoding/json"
+	"fmt"
+	"gestion/models"
+	"time"
+)
+
+// GetDeliverymanQueueInfo récupère les infos de queue d'un livreur
+func (d *Database) GetDeliverymanQueueInfo(deliveryman string) (map[string]interface{}, error) {
+	queueKey := fmt.Sprintf("queue:deliveryman:%s", deliveryman)
+
+	// Nombre de commandes dans la queue
+	queueSize, _ := Redis.ZCard(RedisCtx, queueKey).Result()
+
+	// Récupérer toutes les commandes
+	commandIDs, _ := Redis.ZRange(RedisCtx, queueKey, 0, -1).Result()
+
+	// Vérifier le nombre de livreurs actifs pour déterminer la limite
+	activeCount, _ := d.CountActiveDeliverymen()
+
+	// Récupérer les détails de chaque commande
+	var commands []map[string]interface{}
+	for i, 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
+		}
+
+		commands = append(commands, map[string]interface{}{
+			"position":      i + 1,
+			"command_id":    commandID,
+			"address":       queueItem.Address,
+			"estimated_eta": queueItem.EstimatedETA,
+			"created_at":    queueItem.CreatedAt,
+			"lat":           queueItem.Lat,
+			"lng":           queueItem.Lng,
+		})
+	}
+
+	// Déterminer si le livreur peut accepter plus de commandes
+	canAcceptMore := true
+	if activeCount > 1 {
+		// Plusieurs livreurs: limite de 10
+		canAcceptMore = queueSize < MAX_COMMANDS_PER_DELIVERYMAN
+	}
+	// Si un seul livreur: pas de limite (canAcceptMore reste true)
+
+	return map[string]interface{}{
+		"deliveryman":        deliveryman,
+		"queue_size":         queueSize,
+		"commands":           commands,
+		"can_accept_more":    canAcceptMore,
+		"max_commands":       MAX_COMMANDS_PER_DELIVERYMAN,
+		"active_deliverymen": activeCount,
+	}, nil
+}
+
+func (d *Database) GetAllQueuesOverview() (map[string]interface{}, error) {
+	overview := make(map[string]interface{})
+
+	// Queue générale
+	generalQueueSize, _ := Redis.ZCard(RedisCtx, "queue:pending:sorted").Result()
+	overview["general_queue"] = generalQueueSize
+
+	// Queues par livreur avec détails
+	deliverymanQueues := make(map[string]interface{})
+	keys, _ := Redis.Keys(RedisCtx, "queue:deliveryman:*").Result()
+
+	for _, key := range keys {
+		if len(key) > 6 && key[len(key)-6:] == ":count" {
+			continue
+		}
+
+		username := key[len("queue:deliveryman:"):]
+		queueSize, _ := Redis.ZCard(RedisCtx, key).Result()
+
+		deliverymanQueues[username] = map[string]interface{}{
+			"queue_size":      queueSize,
+			"can_accept_more": queueSize < MAX_COMMANDS_PER_DELIVERYMAN,
+			"capacity":        fmt.Sprintf("%d/%d", queueSize, MAX_COMMANDS_PER_DELIVERYMAN),
+		}
+	}
+
+	overview["deliveryman_queues"] = deliverymanQueues
+
+	// Total
+	var totalPending int64 = generalQueueSize
+	for _, key := range keys {
+		if len(key) > 6 && key[len(key)-6:] == ":count" {
+			continue
+		}
+		size, _ := Redis.ZCard(RedisCtx, key).Result()
+		totalPending += size
+	}
+	overview["total_pending"] = totalPending
+
+	return overview, nil
+}
+
+// GetQueueStats - Statistiques détaillées
+func (d *Database) GetQueueStats() (map[string]interface{}, error) {
+	normalCount, _ := Redis.ZCard(RedisCtx, "queue:pending:sorted").Result()
+	priorityCount, _ := Redis.ZCard(RedisCtx, "queue:priority:sorted").Result()
+
+	// Compter les commandes dans les queues des livreurs
+	var deliverymanQueueCount int64
+	keys, _ := Redis.Keys(RedisCtx, "queue:deliveryman:*").Result()
+	for _, key := range keys {
+		if len(key) > 6 && key[len(key)-6:] == ":count" {
+			continue
+		}
+		count, _ := Redis.ZCard(RedisCtx, key).Result()
+		deliverymanQueueCount += count
+	}
+
+	// Calculer temps d'attente moyen
+	var totalWaitTime int64
+	var commandCount int64
+
+	normalResults, _ := Redis.ZRangeWithScores(RedisCtx, "queue:pending:sorted", 0, -1).Result()
+	for _, result := range normalResults {
+		commandID := extractCommandID(result.Member)
+		if commandID <= 0 {
+			continue
+		}
+
+		key := fmt.Sprintf("queue:pending:%d", commandID)
+		data, _ := Redis.Get(RedisCtx, key).Result()
+
+		var item models.CommandQueue
+		if json.Unmarshal([]byte(data), &item) == nil {
+			waitMinutes := int64(time.Since(item.CreatedAt).Minutes())
+			totalWaitTime += waitMinutes
+			commandCount++
+		}
+	}
+
+	avgWaitTime := 0
+	if commandCount > 0 {
+		avgWaitTime = int(totalWaitTime / commandCount)
+	}
+
+	stats := map[string]interface{}{
+		"total_pending":           normalCount + priorityCount,
+		"general_queue":           normalCount,
+		"priority_queue":          priorityCount,
+		"deliveryman_queues":      deliverymanQueueCount,
+		"avg_wait_time_min":       avgWaitTime,
+		"max_commands_per_driver": MAX_COMMANDS_PER_DELIVERYMAN,
+		"avg_delivery_time":       AVG_DELIVERY_TIME,
+		"last_updated":            time.Now().Format("2006-01-02 15:04:05"),
+	}
+
+	return stats, nil
+}