soft_usite/pkg/models/umind_canal.go

package models

import (
	"crypto/rand"
	"encoding/hex"
	"fmt"
	"strings"
	"time"

	"github.com/sujit-baniya/fiber-boilerplate/app"
	"gorm.io/gorm"
)

// UmindCanal es un canal de mensajería adicional (Telegram, WhatsApp) que
// alimenta al mismo agente del tenant que ya atiende el widget web. Los
// secretos reales (bot token, access token de WhatsApp, etc.) viven cifrados
// en CredencialesEnc (ver pkg/services/umind_secrets.go) — el modelo solo
// persiste el string ya cifrado, no conoce la clave.
//
// WebhookSecret es un identificador público generado por nosotros, distinto
// del secreto real del proveedor, usado SOLO para enrutar el webhook
// entrante al canal correcto (va en la URL que se registra en
// Telegram/Meta). Evita que el token real del proveedor termine en logs de
// acceso o de un proxy intermedio.
type UmindCanal struct {
	gorm.Model
	AgenteID        uint   `json:"agente_id" gorm:"column:agente_id;index"`
	Tipo            string `json:"tipo" gorm:"column:tipo;size:20;not null"` // telegram | whatsapp
	Activo          bool   `json:"activo" gorm:"column:activo;default:true"`
	WebhookSecret   string `json:"webhook_secret" gorm:"column:webhook_secret;uniqueIndex;size:40;not null"`
	CredencialesEnc string `json:"-" gorm:"column:credenciales_enc;type:text"`
	UltimoError     string `json:"ultimo_error" gorm:"column:ultimo_error;type:text"`
	// Si están activos, los mensajes de voz/audio e imágenes que llegan por
	// este canal se transcriben (Whisper) o se les extrae el texto (OCR)
	// antes de pasarlos al agente, en vez de ignorarse.
	UsarWhisperAudio bool `json:"usar_whisper_audio" gorm:"column:usar_whisper_audio;default:false"`
	UsarOcrImagenes  bool `json:"usar_ocr_imagenes" gorm:"column:usar_ocr_imagenes;default:false"`
	// Documentos adjuntos (PDF, Word, texto): se les extrae el contenido y se
	// le pasa al agente como si el cliente lo hubiera escrito.
	UsarArchivosDocs bool `json:"usar_archivos_docs" gorm:"column:usar_archivos_docs;default:false"`
	// Solo para el canal correo: cada cuántos minutos se revisa la casilla.
	// Lo elige el cliente — una inmobiliaria quiere 2, un estudio contable con
	// 30 le sobra. Telegram y WhatsApp no lo usan: a ellos les llega webhook.
	IntervaloMinutos int `json:"intervalo_minutos" gorm:"column:intervalo_minutos;default:5"`
	// UltimaRevision es lo que decide si ya le toca — en la base y no en
	// memoria, por la misma razón que el aviso de tope: los despliegues borran
	// la RAM varias veces por día.
	UltimaRevision *time.Time `json:"ultima_revision" gorm:"column:ultima_revision"`
	// FiltroRemitentes acota a quién le responde el canal correo: direcciones
	// o dominios separados por coma. Vacío = responde a todos. Un correo que
	// no pasa el filtro se marca leído y no se contesta — el agente decidió,
	// no está pendiente.
	FiltroRemitentes string `json:"filtro_remitentes" gorm:"column:filtro_remitentes;type:text"`
	// EsInterno marca que este canal es la línea privada del dueño y no una
	// puerta a sus clientes. En un canal interno el agente ejecuta acciones
	// directo; en uno público toda acción queda esperando aprobación.
	EsInterno bool `json:"es_interno" gorm:"column:es_interno;default:false"`
}

// MarcarRevisionCanal deja constancia de que la casilla se acaba de revisar.
func MarcarRevisionCanal(id uint) {
	ahora := time.Now()
	app.Http.Database.DB.Model(&UmindCanal{}).Where("id = ?", id).
		Update("ultima_revision", &ahora)
}

// GetCanalesCorreoPendientes devuelve los canales de correo activos a los que
// ya les toca revisión según su propio intervalo.
func GetCanalesCorreoPendientes() ([]UmindCanal, error) {
	var items []UmindCanal
	err := app.Http.Database.DB.
		Where("tipo = ? AND activo = ?", "correo", true).
		Where("ultima_revision IS NULL OR ultima_revision < NOW() - (intervalo_minutos || ' minutes')::interval").
		Find(&items).Error
	return items, err
}

func (UmindCanal) TableName() string { return "umind_canales" }

func GenerarWebhookSecret() (string, error) {
	b := make([]byte, 16)
	if _, err := rand.Read(b); err != nil {
		return "", fmt.Errorf("no se pudo generar el webhook_secret: %w", err)
	}
	return "umc_" + hex.EncodeToString(b), nil
}

func CreateUmindCanal(c *UmindCanal) error {
	if c.WebhookSecret == "" {
		secret, err := GenerarWebhookSecret()
		if err != nil {
			return err
		}
		c.WebhookSecret = secret
	}
	return app.Http.Database.DB.Create(c).Error
}

func GetUmindCanalesByAgente(agenteID uint) ([]UmindCanal, error) {
	var items []UmindCanal
	err := app.Http.Database.DB.Where("agente_id = ?", agenteID).Order("id DESC").Find(&items).Error
	return items, err
}

func GetUmindCanalByID(id uint) (*UmindCanal, error) {
	var c UmindCanal
	if err := app.Http.Database.DB.First(&c, id).Error; err != nil {
		return nil, err
	}
	return &c, nil
}

// GetUmindCanalByWebhookSecret resuelve el canal a partir del identificador
// público que viene en la URL del webhook. Solo matchea si está activo.
func GetUmindCanalByWebhookSecret(tipo, webhookSecret string) (*UmindCanal, error) {
	var c UmindCanal
	err := app.Http.Database.DB.Where("tipo = ? AND webhook_secret = ? AND activo = ?", tipo, webhookSecret, true).First(&c).Error
	if err != nil {
		return nil, err
	}
	return &c, nil
}

func UpdateUmindCanal(id uint, updates map[string]interface{}) error {
	return app.Http.Database.DB.Model(&UmindCanal{}).Where("id = ?", id).Updates(updates).Error
}

func DeleteUmindCanal(id uint) error {
	return app.Http.Database.DB.Delete(&UmindCanal{}, id).Error
}

// GetUmindCanalPorTipo devuelve el canal activo de ese tipo del agente.
func GetUmindCanalPorTipo(agenteID uint, tipo string) (*UmindCanal, error) {
	var c UmindCanal
	err := app.Http.Database.DB.
		Where("agente_id = ? AND tipo = ? AND activo = ?", agenteID, tipo, true).
		First(&c).Error
	return &c, err
}

// EsSesionInterna dice si esa conversación es con el dueño y no con un
// cliente suyo. Es lo que decide si el agente puede ejecutar acciones
// directamente o si tienen que esperar aprobación: en el widget público
// escribe cualquiera, y "cualquiera" no puede programar avisos ni gastar
// el plan del dueño.
func EsSesionInterna(agenteID uint, sessionID string) bool {
	// El chat de prueba del panel: del otro lado hay una sesión autenticada.
	if strings.HasPrefix(sessionID, "panel:") {
		return true
	}
	var tipo string
	switch {
	case strings.HasPrefix(sessionID, "tg:"):
		tipo = "telegram"
	case strings.HasPrefix(sessionID, "mail:"):
		tipo = "correo"
	case strings.HasPrefix(sessionID, "wa:"):
		tipo = "whatsapp"
	default:
		return false // widget web: siempre público
	}
	canal, err := GetUmindCanalPorTipo(agenteID, tipo)
	if err != nil {
		return false
	}
	return canal.EsInterno
}