Lizandro GuarnizoandClaude Opus 5
c4b0305112
Faltaba la tercera pata: audio pasaba por Whisper, imagen por OCR, y un PDF o
un Word adjunto se ignoraba en silencio. Ahora hay un interruptor por canal
—"Leer archivos adjuntos"— y los documentos que llegan por Telegram o WhatsApp
se convierten a texto antes de pasar al agente.
PDF se lee con stdlib cuando el documento es digital (facturas, cotizaciones,
lo exportado por cualquier programa) y cae al OCR si es un escaneo. Word .docx
es un zip con XML adentro; texto plano, CSV y JSON van directo.
El agente recibe el contenido con contexto ("el cliente adjuntó X, y escribió
Y"), no el chorizo pelado: sin eso el modelo contesta como si el cliente
hubiera tipeado una factura.
De paso la importación de plantillas gana PDF, que usa el mismo extractor.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
94 lines
3.5 KiB
Go
94 lines
3.5 KiB
Go
package models
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"fmt"
|
|
|
|
"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"`
|
|
}
|
|
|
|
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
|
|
}
|