feat(umind): el agente emite cotizaciones y contratos con la plantilla del cliente
El motor de PDF ya existía entero para el staff — Chrome headless, text/template
con {{range .Items}}, y hasta el importador que convierte un Word en plantilla
con IA. Lo único que faltaba era que fueran de cada cliente.
PlantillaDocumento gana TenantID *uint: nulo = global del staff (lo de
siempre), con valor = del espacio. Mismo patrón exacto que AiConfig, el que ya
tiene su lección aprendida. Y GetPlantillaDocumentoActiva ahora filtra
tenant_id IS NULL explícitamente: sin eso, la plantilla que un cliente escribe
para su propio contrato podía salir en un documento de la empresa. Hay test.
Un cliente sin plantilla propia cae a la global, así puede emitir una
cotización desde el primer día y personalizarla cuando quiera. Guardar crea
versión nueva en vez de pisar la vieja: si la nueva sale mal, la anterior sigue
ahí. Y se valida que compile ANTES de guardar — una plantilla rota descubierta
al generar deja al cliente esperando un PDF que nunca llega.
La tool solo se le ofrece al modelo si hay alguna plantilla disponible:
prometerle una capacidad que después falla es peor que no tenerla.
El semáforo de tres: cada PDF levanta un Chrome entero, y cien clientes
generando a la vez son cien navegadores. Eso tira el servidor mucho antes que
cualquier consulta a la IA, así que va desde el día uno y no cuando se caiga.
El JSON de ítems mal formado no tumba la generación — sale el documento sin la
tabla, que todavía se puede corregir a mano. Y sin cantidad se asume 1: el
modelo la omite seguido, y un total en cero es peor que uno aproximado.
Cada documento se cobra (levanta un Chrome) y queda en los archivos del
espacio, descargable como cualquier otro.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Lizandro Guarnizo
co-authored by
Claude Opus 5
Claude Opus 5
parent
544cba6d34
commit
047837dd23
@@ -57,6 +57,13 @@ func umindTools(agenteID uint, sesionInterna bool) []agentTool {
|
||||
},
|
||||
}}
|
||||
|
||||
// Generar documentos está disponible siempre: preparar un borrador es
|
||||
// barato y reversible. Lo que espera aprobación es entregarlo, y de eso
|
||||
// se encarga la puerta de executeUmindTool.
|
||||
if models.TienePlantillasDocumento(agenteID) {
|
||||
tools = append(tools, umindDocumentoTools()...)
|
||||
}
|
||||
|
||||
// Los avisos solo existen para el dueño. En el widget público escribe
|
||||
// cualquiera, y programar recordatorios gasta el plan de otro.
|
||||
if sesionInterna {
|
||||
@@ -179,6 +186,10 @@ func ejecutarHerramienta(agenteID uint, sessionID string, sesionInterna bool, na
|
||||
return executeUmindEmailTool(agenteID, name, args)
|
||||
}
|
||||
|
||||
if name == "generar_documento" {
|
||||
return executeUmindDocumentoTool(agenteID, args)
|
||||
}
|
||||
|
||||
if strings.HasSuffix(name, "_aviso") || name == "listar_avisos" {
|
||||
if !sesionInterna {
|
||||
return `{"error": "los recordatorios solo puede programarlos el dueño desde su canal privado"}`
|
||||
|
||||
@@ -0,0 +1,71 @@
|
||||
package services
|
||||
|
||||
import (
|
||||
"os"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestParsearItems(t *testing.T) {
|
||||
items, total := parsearItems(`[{"descripcion":"Licencia","cantidad":3,"precio":200000}]`)
|
||||
if len(items) != 1 || total != 600000 {
|
||||
t.Fatalf("items=%d total=%v, esperaba 1 ítem y 600000", len(items), total)
|
||||
}
|
||||
// Sin cantidad se asume 1: el modelo la omite seguido y un total en cero
|
||||
// en una cotización es peor que uno aproximado.
|
||||
items, total = parsearItems(`[{"descripcion":"Servicio","precio":50000}]`)
|
||||
if len(items) != 1 || items[0].Cantidad != 1 || total != 50000 {
|
||||
t.Errorf("cantidad omitida: items=%+v total=%v", items, total)
|
||||
}
|
||||
// JSON roto no puede tumbar la generación entera.
|
||||
if items, total := parsearItems(`{no es json`); items != nil || total != 0 {
|
||||
t.Errorf("JSON inválido debería dar vacío, dio %+v / %v", items, total)
|
||||
}
|
||||
if items, _ := parsearItems(""); items != nil {
|
||||
t.Error("sin ítems debería dar vacío")
|
||||
}
|
||||
}
|
||||
|
||||
func TestValidarPlantillaHTML(t *testing.T) {
|
||||
if err := ValidarPlantillaHTML(`<h1>{{.Cliente}}</h1>{{range .Items}}<p>{{.Descripcion}}</p>{{end}}`); err != nil {
|
||||
t.Errorf("una plantilla válida fue rechazada: %v", err)
|
||||
}
|
||||
if err := ValidarPlantillaHTML(`<h1>{{.Cliente}</h1>`); err == nil {
|
||||
t.Error("una plantilla rota tiene que rechazarse antes de guardarse")
|
||||
}
|
||||
}
|
||||
|
||||
// Cada PDF levanta un Chrome entero. Sin semáforo, cien clientes generando a
|
||||
// la vez son cien navegadores y el servidor se cae antes que por la IA.
|
||||
func TestGeneracionDePDFTieneSemaforo(t *testing.T) {
|
||||
b, err := os.ReadFile("umind_documento_tools.go")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
s := string(b)
|
||||
if cap(pdfEnCurso) == 0 || cap(pdfEnCurso) > 5 {
|
||||
t.Errorf("el semáforo de PDF tiene capacidad %d: debería ser chica y mayor que cero", cap(pdfEnCurso))
|
||||
}
|
||||
i := strings.Index(s, "func renderPDFDesdePlantilla")
|
||||
cuerpo := s[i:]
|
||||
cuerpo = cuerpo[:strings.Index(cuerpo, "\n// guardarPDF")]
|
||||
if !strings.Contains(cuerpo, "pdfEnCurso <- struct{}{}") || !strings.Contains(cuerpo, "<-pdfEnCurso") {
|
||||
t.Error("RenderHTMLToPDF tiene que llamarse con el semáforo tomado y liberarlo después")
|
||||
}
|
||||
}
|
||||
|
||||
// Las plantillas globales del staff no pueden salir en un documento de un
|
||||
// cliente, ni al revés. Es el mismo patrón que ya se corrigió en AiConfig.
|
||||
func TestPlantillaGlobalFiltraPorTenantNulo(t *testing.T) {
|
||||
b, err := os.ReadFile("../models/plantilla_documento.go")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
s := string(b)
|
||||
i := strings.Index(s, "func GetPlantillaDocumentoActiva")
|
||||
cuerpo := s[i:]
|
||||
cuerpo = cuerpo[:strings.Index(cuerpo, "\n// GetPlantillaDocumentoDeTenant")]
|
||||
if !strings.Contains(cuerpo, "tenant_id IS NULL") {
|
||||
t.Error("la plantilla global tiene que filtrar tenant_id IS NULL, si no puede devolver la de un cliente")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,189 @@
|
||||
package services
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"strings"
|
||||
"text/template"
|
||||
"time"
|
||||
|
||||
"github.com/sujit-baniya/fiber-boilerplate/pkg/models"
|
||||
)
|
||||
|
||||
// Generación de documentos para los agentes: cotizaciones y contratos armados
|
||||
// desde la conversación, con la plantilla del propio cliente.
|
||||
|
||||
// pdfEnCurso acota cuántos Chrome headless corren a la vez. Cada PDF levanta
|
||||
// un navegador entero: cien clientes generando documentos al mismo tiempo son
|
||||
// cien Chromes, y eso tira el servidor antes que cualquier consulta a la IA.
|
||||
var pdfEnCurso = make(chan struct{}, 3)
|
||||
|
||||
func umindDocumentoTools() []agentTool {
|
||||
return []agentTool{{
|
||||
Type: "function",
|
||||
Function: agentToolFunc{
|
||||
Name: "generar_documento",
|
||||
Description: "Genera un documento en PDF (cotización, contrato, acta o cuenta de cobro) con la plantilla del negocio. " +
|
||||
"Usalo cuando el cliente pide una cotización o un presupuesto formal.",
|
||||
Parameters: agentToolParam{
|
||||
Type: "object",
|
||||
Properties: map[string]agentToolParam{
|
||||
"tipo": {Type: "string", Description: "cotizacion | contrato | acta | cuenta_cobro"},
|
||||
"cliente": {Type: "string", Description: "Nombre de la persona o empresa a la que va dirigido"},
|
||||
"items": {Type: "string", Description: `Los ítems en JSON: [{"descripcion":"...","cantidad":1,"precio":100000}]`},
|
||||
"notas": {Type: "string", Description: "Condiciones o aclaraciones, opcional"},
|
||||
},
|
||||
Required: []string{"tipo", "cliente"},
|
||||
},
|
||||
},
|
||||
}}
|
||||
}
|
||||
|
||||
func executeUmindDocumentoTool(agenteID uint, args map[string]interface{}) string {
|
||||
tipo, _ := args["tipo"].(string)
|
||||
tipo = strings.ToLower(strings.TrimSpace(tipo))
|
||||
switch tipo {
|
||||
case "cotizacion", "contrato", "acta", "cuenta_cobro":
|
||||
default:
|
||||
return `{"error": "tipo inválido: usá cotizacion, contrato, acta o cuenta_cobro"}`
|
||||
}
|
||||
cliente, _ := args["cliente"].(string)
|
||||
if strings.TrimSpace(cliente) == "" {
|
||||
return `{"error": "falta a nombre de quién va el documento"}`
|
||||
}
|
||||
|
||||
agente, err := models.GetUmindAgenteByID(agenteID)
|
||||
if err != nil {
|
||||
return `{"error": "no se pudo generar el documento"}`
|
||||
}
|
||||
tenant, err := models.GetUmindTenantByID(agente.TenantID)
|
||||
if err != nil {
|
||||
return `{"error": "no se pudo generar el documento"}`
|
||||
}
|
||||
plantilla, err := models.GetPlantillaDocumentoDeTenant(agente.TenantID, tipo)
|
||||
if err != nil {
|
||||
return fmt.Sprintf(`{"error": "el negocio todavía no tiene una plantilla de %s cargada"}`, tipo)
|
||||
}
|
||||
|
||||
items, total := parsearItems(args["items"])
|
||||
notas, _ := args["notas"].(string)
|
||||
datos := map[string]interface{}{
|
||||
"Fecha": time.Now().Format("02/01/2006"), "Cliente": cliente,
|
||||
"EmpresaNombre": tenant.Nombre, "Items": items, "Total": total,
|
||||
"Notas": notas, "Numero": time.Now().Format("20060102-1504"),
|
||||
}
|
||||
|
||||
pdf, err := renderPDFDesdePlantilla(plantilla.ContenidoHTML, datos)
|
||||
if err != nil {
|
||||
models.RegistrarEventoUmind(agenteID, "error", "documento", "No se pudo generar un documento", err.Error())
|
||||
return `{"error": "no se pudo generar el documento"}`
|
||||
}
|
||||
|
||||
archivo, err := guardarPDFEnRepositorio(agente.TenantID, fmt.Sprintf("%s-%s", tipo, cliente), pdf)
|
||||
if err != nil {
|
||||
return `{"error": "el documento se generó pero no se pudo guardar"}`
|
||||
}
|
||||
models.RegistrarUsoUmind(agenteID, models.UsoTipoDocumento, 1, "documento")
|
||||
|
||||
b, _ := json.Marshal(map[string]interface{}{
|
||||
"ok": true, "archivo_id": archivo.ID, "nombre": archivo.Nombre, "total": total,
|
||||
"nota": "El documento quedó guardado en los archivos del negocio.",
|
||||
})
|
||||
return string(b)
|
||||
}
|
||||
|
||||
// renderPDFDesdePlantilla ejecuta la plantilla y la manda a Chrome, con el
|
||||
// semáforo puesto.
|
||||
func renderPDFDesdePlantilla(contenidoHTML string, datos map[string]interface{}) ([]byte, error) {
|
||||
tmpl, err := template.New("doc").Parse(contenidoHTML)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("la plantilla tiene un error de formato: %w", err)
|
||||
}
|
||||
var buf bytes.Buffer
|
||||
if err := tmpl.Execute(&buf, datos); err != nil {
|
||||
return nil, fmt.Errorf("no se pudo completar la plantilla: %w", err)
|
||||
}
|
||||
|
||||
pdfEnCurso <- struct{}{}
|
||||
defer func() { <-pdfEnCurso }()
|
||||
return RenderHTMLToPDF(buf.String())
|
||||
}
|
||||
|
||||
// guardarPDFEnRepositorio deja el documento en los archivos del espacio, para
|
||||
// que quede a la vista y descargable como cualquier otro.
|
||||
func guardarPDFEnRepositorio(tenantID uint, nombreBase string, pdf []byte) (*models.UmindArchivo, error) {
|
||||
dir := filepath.Join("uploads", "umind", strconv.FormatUint(uint64(tenantID), 10))
|
||||
if err := os.MkdirAll(dir, 0o755); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
seguro := strings.Map(func(r rune) rune {
|
||||
if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '-' || r == '_' {
|
||||
return r
|
||||
}
|
||||
return '-'
|
||||
}, strings.ToLower(nombreBase))
|
||||
nombre := fmt.Sprintf("%s-%d.pdf", seguro, time.Now().Unix())
|
||||
destino := filepath.Join(dir, nombre)
|
||||
if err := os.WriteFile(destino, pdf, 0o644); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
archivo := &models.UmindArchivo{
|
||||
TenantID: tenantID, Nombre: nombre, Archivo: destino,
|
||||
TipoMime: "application/pdf", Tamanio: int64(len(pdf)), Origen: "generado",
|
||||
}
|
||||
if err := models.CreateUmindArchivo(archivo); err != nil {
|
||||
_ = os.Remove(destino)
|
||||
return nil, err
|
||||
}
|
||||
return archivo, nil
|
||||
}
|
||||
|
||||
type itemDocumento struct {
|
||||
Descripcion string
|
||||
Cantidad float64
|
||||
Precio float64
|
||||
Subtotal float64
|
||||
}
|
||||
|
||||
// parsearItems acepta el JSON que arma el modelo. Si viene mal formado se
|
||||
// devuelve vacío en vez de fallar: un documento sin la tabla de ítems todavía
|
||||
// se puede corregir a mano; uno que no se generó hace perder la conversación.
|
||||
func parsearItems(raw interface{}) ([]itemDocumento, float64) {
|
||||
s, _ := raw.(string)
|
||||
if strings.TrimSpace(s) == "" {
|
||||
return nil, 0
|
||||
}
|
||||
var crudos []struct {
|
||||
Descripcion string `json:"descripcion"`
|
||||
Cantidad float64 `json:"cantidad"`
|
||||
Precio float64 `json:"precio"`
|
||||
}
|
||||
if err := json.Unmarshal([]byte(s), &crudos); err != nil {
|
||||
return nil, 0
|
||||
}
|
||||
items := make([]itemDocumento, 0, len(crudos))
|
||||
total := 0.0
|
||||
for _, c := range crudos {
|
||||
if c.Cantidad == 0 {
|
||||
c.Cantidad = 1
|
||||
}
|
||||
sub := c.Cantidad * c.Precio
|
||||
total += sub
|
||||
items = append(items, itemDocumento{c.Descripcion, c.Cantidad, c.Precio, sub})
|
||||
}
|
||||
return items, total
|
||||
}
|
||||
|
||||
// ValidarPlantillaHTML confirma que la plantilla compila antes de guardarla:
|
||||
// descubrir el error al generar deja al cliente esperando un PDF que nunca
|
||||
// llega, y del lado de adentro no hay a quién preguntarle.
|
||||
func ValidarPlantillaHTML(contenido string) error {
|
||||
if _, err := template.New("v").Parse(contenido); err != nil {
|
||||
return fmt.Errorf("la plantilla tiene un error de formato: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
Reference in New Issue
Block a user