projet_gestion_commande/backend/gestion/db/db_notifications.go

package db

import (
	"encoding/json"
	"fmt"
	"gestion/models"
	"gestion/services"
	"log"
	"time"
)

func (d *Database) NotifyClient(username string, commandID int, notifType, message string) error {
	notifKey := fmt.Sprintf("notifications:%s", username)

	notification := map[string]any{
		"command_id": commandID,
		"type":       notifType,
		"message":    message,
		"created_at": time.Now().Format(time.RFC3339),
		"read":       false,
	}

	notifJSON, _ := json.Marshal(notification)
	Redis.LPush(RedisCtx, notifKey, notifJSON)
	Redis.Expire(RedisCtx, notifKey, 7*24*time.Hour)

	if services.LBTelegram != nil && services.LBTelegram.IsConfigured() && services.TelegramBot != nil && services.TelegramBot.IsNotificationsEnabled() {
		if chatID, ok, err := d.GetClientTelegramChatID(username); err == nil && ok {
			go func(id int64, msg string) {
				if err := services.LBTelegram.SendNotification(id, fmt.Sprintf("🔔 <b>Notification</b>\n\n%s", msg)); err != nil {
					log.Printf("⚠️ [LB] notification client échouée pour %s: %v", username, err)
				}
			}(chatID, message)
		}
	}

	log.Printf("📬 Notification envoyée à %s: %s", username, message)
	return nil
}

// NotifyLivreur envoie une notification in-app (Redis) à un livreur
func (d *Database) NotifyLivreur(username string, commandID int, notifType, message string) error {
	notifKey := fmt.Sprintf("notifications:%s", username)

	notification := map[string]any{
		"command_id": commandID,
		"type":       notifType,
		"message":    message,
		"created_at": time.Now().Format(time.RFC3339),
		"read":       false,
	}

	notifJSON, _ := json.Marshal(notification)
	Redis.LPush(RedisCtx, notifKey, notifJSON)
	Redis.Expire(RedisCtx, notifKey, 7*24*time.Hour)

	if services.LBTelegram != nil && services.LBTelegram.IsConfigured() && services.TelegramBot != nil && services.TelegramBot.IsNotificationsEnabled() {
		if chatID, ok, err := d.GetUserTelegramChatID(username); err == nil && ok {
			go func(id int64, msg string) {
				if err := services.LBTelegram.SendNotification(id, fmt.Sprintf("🔔 <b>Notification</b>\n\n%s", msg)); err != nil {
					log.Printf("⚠️ [LB] notification livreur échouée pour %s: %v", username, err)
				}
			}(chatID, message)
		}
	}

	log.Printf("📬 [LIVREUR_NOTIF] Notification envoyée à %s: %s", username, message)
	return nil
}

// NotifyAllAdminCabine stocke une notification Redis pour tous les admins/cabines
func (d *Database) NotifyAllAdminCabine(commandID int, clientUsername, deliveryAddr string) {
	var users []struct {
		Username string `gorm:"column:username"`
	}
	if err := d.GDB.Model(&models.User{}).Select("username").Where("role IN ?", []string{"admin", "cabine"}).Scan(&users).Error; err != nil {
		log.Printf("❌ [ADMIN_NOTIF] Erreur lecture users admin/cabine: %v", err)
		return
	}

	msg := fmt.Sprintf("Nouvelle commande #%d de %s — %s", commandID, clientUsername, deliveryAddr)

	notification := map[string]any{
		"command_id": commandID,
		"type":       "new_order",
		"message":    msg,
		"created_at": time.Now().Format(time.RFC3339),
		"read":       false,
	}
	notifJSON, _ := json.Marshal(notification)

	count := 0
	for _, u := range users {
		notifKey := fmt.Sprintf("notifications:%s", u.Username)
		Redis.LPush(RedisCtx, notifKey, notifJSON)
		Redis.Expire(RedisCtx, notifKey, 7*24*time.Hour)

		if services.LBTelegram != nil && services.LBTelegram.IsConfigured() && services.TelegramBot != nil && services.TelegramBot.IsNotificationsEnabled() {
			if chatID, ok, err := d.GetUserTelegramChatID(u.Username); err == nil && ok {
				capturedChatID := chatID
				capturedMsg := msg
				go func(id int64, m string) {
					if err := services.LBTelegram.SendNotification(id, fmt.Sprintf("🔔 <b>Nouvelle commande</b>\n\n%s", m)); err != nil {
						log.Printf("⚠️ [LB] notification admin/cabine échouée: %v", err)
					}
				}(capturedChatID, capturedMsg)
			}
		}
		count++
	}
	log.Printf("📬 [ADMIN_NOTIF] Notif Redis (%d users) pour commande #%d", count, commandID)
}

// NotifyAllAdminCabineAlert envoie une notification Redis à tous les admins/cabines lors d'une alerte
func (d *Database) NotifyAllAdminCabineAlert(alertID int, livreurUsername, alertMessage string) {
	var users []struct {
		Username string `gorm:"column:username"`
	}
	if err := d.GDB.Model(&models.User{}).Select("username").Where("role IN ?", []string{"admin", "cabine"}).Scan(&users).Error; err != nil {
		log.Printf("❌ [ALERT_NOTIF] Erreur lecture users admin/cabine: %v", err)
		return
	}

	body := fmt.Sprintf("%s — livreur : %s", alertMessage, livreurUsername)

	notification := map[string]any{
		"alert_id":   alertID,
		"type":       "alert",
		"message":    body,
		"created_at": time.Now().Format(time.RFC3339),
		"read":       false,
	}
	notifJSON, _ := json.Marshal(notification)

	count := 0
	for _, u := range users {
		notifKey := fmt.Sprintf("notifications:%s", u.Username)
		Redis.LPush(RedisCtx, notifKey, notifJSON)
		Redis.Expire(RedisCtx, notifKey, 7*24*time.Hour)

		if services.LBTelegram != nil && services.LBTelegram.IsConfigured() && services.TelegramBot != nil && services.TelegramBot.IsNotificationsEnabled() {
			if chatID, ok, err := d.GetUserTelegramChatID(u.Username); err == nil && ok {
				capturedChatID := chatID
				capturedBody := body
				go func(id int64, m string) {
					if err := services.LBTelegram.SendNotification(id, fmt.Sprintf("🚨 <b>Alerte livreur</b>\n\n%s", m)); err != nil {
						log.Printf("⚠️ [LB] notification alerte échouée: %v", err)
					}
				}(capturedChatID, capturedBody)
			}
		}
		count++
	}
	log.Printf("🚨 [ALERT_NOTIF] Notif Redis (%d users) pour alerte #%d de %s", count, alertID, livreurUsername)
}