Lizandro GuarnizoandClaude Opus 5
eddec45857
En "Dónde atiende", el canal correo: el agente lee una casilla y responde solo los correos que llegan, con su base de conocimiento, igual que atiende WhatsApp. Como el correo no tiene webhook, se revisa por intervalo — y el intervalo lo elige el cliente por canal (2 a 60 minutos): una inmobiliaria quiere 2, a un estudio contable con 30 le sobra. El cron corre cada minuto pero cada casilla se revisa solo cuando le toca, con un pool de 8 para que 100 casillas no salgan a la red en el mismo instante. Las guardas que separan "asistente" de "incidente", cada una con su test: nunca responde correo automático ni se responde a sí mismo (el bucle con otro autoresponder); la revisión se marca ANTES de conectar, así una contraseña cambiada no martilla el login cada minuto hasta que el host del cliente nos bloquea; y el correo se marca leído recién cuando la respuesta salió — si el envío falla, queda sin leer y se reintenta. En "Lo que sabe", las cuentas de correo: casillas que el agente consulta a pedido — "revisame los correos de hoy y haceme un resumen" — sin nada de fondo. Solo lectura en serio: Peek, INBOX en read-only, y un test que falla si alguien le agrega un marcado. Ahora se pueden conectar varias por agente; con más de una, el modelo pregunta cuál en vez de adivinar — resumirle a alguien la casilla que no pidió no es un error menor. El alta pide correo y contraseña: el host se deduce (mail.<dominio>) y el campo técnico aparece recién si eso falla. Se prueba la conexión antes de guardar, con la persona mirando. Enviar por una cuenta conectada está bloqueado a propósito: para responder correos está el canal, con sus guardas. Una tool de envío sin límites es una máquina de spam con el dominio del cliente. La navegación acompaña: "Lo que sabe" agrupa Información, Cuentas de correo y Herramientas — tres formas de saber, no tres pantallas sueltas — y Avanzado queda solo con Problemas. El SMTP se unificó en una sola implementación que comparten soporte y el canal: el bug de STARTTLS que abría dos conexiones ya se pagó una vez. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
91 lines
3.6 KiB
Go
91 lines
3.6 KiB
Go
package models
|
|
|
|
import (
|
|
"time"
|
|
|
|
"github.com/sujit-baniya/fiber-boilerplate/app"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
// UmindConexion es una cuenta de correo real (Gmail u Outlook) conectada por
|
|
// OAuth a un agente, para que pueda enviar y leer correo en su nombre (tools
|
|
// enviar_correo/leer_bandeja, ver pkg/services/umind_agent_service.go).
|
|
// AccessTokenEnc/RefreshTokenEnc viajan cifrados en reposo (ver
|
|
// pkg/services/umind_secrets.go) — a diferencia del site_key del widget,
|
|
// estos SÍ son secretos: quien los tenga puede leer/mandar correo como el
|
|
// dueño de la cuenta.
|
|
type UmindConexion struct {
|
|
gorm.Model
|
|
AgenteID uint `json:"agente_id" gorm:"column:agente_id;index"`
|
|
Proveedor string `json:"proveedor" gorm:"column:proveedor;size:20;not null"` // google | microsoft | imap
|
|
Email string `json:"email" gorm:"column:email;size:255"`
|
|
AccessTokenEnc string `json:"-" gorm:"column:access_token_enc;type:text"`
|
|
RefreshTokenEnc string `json:"-" gorm:"column:refresh_token_enc;type:text"`
|
|
ExpiraEn time.Time `json:"expira_en" gorm:"column:expira_en"`
|
|
Scopes string `json:"scopes" gorm:"column:scopes;type:text"`
|
|
Activo bool `json:"activo" gorm:"column:activo;default:true"`
|
|
// CredencialesEnc guarda el blob cifrado de una cuenta IMAP (host, puerto,
|
|
// usuario, contraseña, encriptación) — mismo esquema que los canales. Las
|
|
// conexiones OAuth no lo usan: sus tokens van en los campos de arriba.
|
|
CredencialesEnc string `json:"-" gorm:"column:credenciales_enc;type:text"`
|
|
}
|
|
|
|
func (UmindConexion) TableName() string { return "umind_conexiones" }
|
|
|
|
func CreateUmindConexion(c *UmindConexion) error {
|
|
return app.Http.Database.DB.Create(c).Error
|
|
}
|
|
|
|
func GetUmindConexionesByAgente(agenteID uint) ([]UmindConexion, error) {
|
|
var items []UmindConexion
|
|
err := app.Http.Database.DB.Where("agente_id = ?", agenteID).Order("id DESC").Find(&items).Error
|
|
return items, err
|
|
}
|
|
|
|
func GetUmindConexionByID(id uint) (*UmindConexion, error) {
|
|
var c UmindConexion
|
|
if err := app.Http.Database.DB.First(&c, id).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return &c, nil
|
|
}
|
|
|
|
// GetUmindConexionActiva retorna la primera conexión activa del agente —
|
|
// hoy se soporta una sola cuenta de correo conectada por agente, no una
|
|
// bandeja por proveedor a la vez.
|
|
// GetUmindConexionesActivas lista todas las cuentas conectadas de un agente.
|
|
// Antes se soportaba una sola; ahora un agente puede tener varias casillas y
|
|
// el modelo elige por dirección cuando el dueño se lo pide.
|
|
func GetUmindConexionesActivas(agenteID uint) ([]UmindConexion, error) {
|
|
var items []UmindConexion
|
|
err := app.Http.Database.DB.
|
|
Where("agente_id = ? AND activo = ?", agenteID, true).
|
|
Order("id ASC").Find(&items).Error
|
|
return items, err
|
|
}
|
|
|
|
func GetUmindConexionActiva(agenteID uint) (*UmindConexion, error) {
|
|
var c UmindConexion
|
|
err := app.Http.Database.DB.Where("agente_id = ? AND activo = ?", agenteID, true).First(&c).Error
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &c, nil
|
|
}
|
|
|
|
// DesactivarConexionesDelAgente se llama antes de crear una conexión nueva —
|
|
// hoy se soporta una sola cuenta de correo activa por agente a la vez.
|
|
func DesactivarConexionesDelAgente(agenteID uint) error {
|
|
return app.Http.Database.DB.Model(&UmindConexion{}).
|
|
Where("agente_id = ? AND activo = ?", agenteID, true).
|
|
Update("activo", false).Error
|
|
}
|
|
|
|
func UpdateUmindConexion(id uint, updates map[string]interface{}) error {
|
|
return app.Http.Database.DB.Model(&UmindConexion{}).Where("id = ?", id).Updates(updates).Error
|
|
}
|
|
|
|
func DeleteUmindConexion(id uint) error {
|
|
return app.Http.Database.DB.Delete(&UmindConexion{}, id).Error
|
|
}
|