Lizandro GuarnizoandClaude Opus 5
544cba6d34
Dos piezas que se necesitan mutuamente. ARCHIVOS — a nivel espacio y no de agente, porque los papeles son del negocio: si mañana crea un segundo agente, sus contratos no se mudan. Subir, descargar, borrar, cuota por plan, y un botón "usar como conocimiento" que lo manda por la ingesta que ya existe — un clic, no volver a subir el mismo PDF. Nunca se sirven por el estático: salen por su endpoint, que valida el tenant. La cuota se mira antes de escribir, porque rechazar después de copiar 25 MB al disco es cobrarle el espacio igual. PENDIENTES — no es un motor de workflows, es una tabla y una regla: lo que sale hacia afuera pedido por alguien que no es el dueño no se ejecuta, se encola. El eje es quién está del otro lado, no qué tan peligrosa suena la acción. En el widget público escribe cualquiera: ahí toda acción espera. En un canal interno el dueño ya autorizó al escribirlo, y mandarlo a aprobar su propio pedido sería fricción sin ninguna seguridad a cambio. (El plan decía aprobar siempre el envío de correo; esto es más flojo a propósito y la propiedad que importa se mantiene entera: desde un canal público no sale nada sin una persona.) Cuatro decisiones que valen más que el esquema: - Se guarda el payload EXACTO y se ejecuta eso. Aprobar no vuelve a llamar al modelo: si regenerara, aprobarías una cosa y saldría otra, y la diferencia aparecería recién en la mano del cliente. Hay un test que lo vigila. - Dos personas mirando la misma bandeja pueden aprobar a la vez; el reclamo es un UPDATE condicional, así la cotización no sale dos veces. - Vencen a los 7 días. Una cotización aprobada tres semanas tarde llega con precios de otro mes: es peor que ninguna. - Al cliente nunca se le dice "rechazado" ni se le menciona una aprobación interna — se le dice que le responde alguien del equipo. También con test. El correo de aviso lleva un enlace al panel CON login: un enlace que ejecuta algo irreversible sin autenticar es un enlace que reenviado por error firma. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
90 lines
2.9 KiB
Go
90 lines
2.9 KiB
Go
package controllers
|
|
|
|
import (
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/gofiber/fiber/v2"
|
|
"github.com/sujit-baniya/fiber-boilerplate/pkg/models"
|
|
"github.com/sujit-baniya/fiber-boilerplate/pkg/services"
|
|
)
|
|
|
|
// La bandeja de pendientes: lo que el asistente preparó y espera tu visto bueno.
|
|
|
|
// GetUmindAccionesHandler — GET /umind/acciones?tenant_id=N&historial=1
|
|
func GetUmindAccionesHandler(c *fiber.Ctx) error {
|
|
tenantID, _ := strconv.ParseUint(c.Query("tenant_id"), 10, 64)
|
|
if err := accesoTenant(c, uint(tenantID)); err != nil {
|
|
return err
|
|
}
|
|
items, err := models.GetUmindAccionesPendientes(uint(tenantID), c.Query("historial") == "1")
|
|
if err != nil {
|
|
return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
|
|
}
|
|
return c.JSON(fiber.Map{
|
|
"items": items,
|
|
"pendientes": models.ContarUmindAccionesPendientes(uint(tenantID)),
|
|
})
|
|
}
|
|
|
|
// AprobarUmindAccionHandler ejecuta el payload guardado, tal cual se aprobó.
|
|
// POST /umind/acciones/:id/aprobar
|
|
func AprobarUmindAccionHandler(c *fiber.Ctx) error {
|
|
accion, err := accionConAcceso(c)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if accion.Estado != "pendiente" {
|
|
return c.Status(fiber.StatusConflict).JSON(fiber.Map{"error": "esa solicitud ya fue resuelta"})
|
|
}
|
|
if err := services.EjecutarAccionAprobada(accion, quienResuelve(c)); err != nil {
|
|
return c.Status(fiber.StatusBadGateway).JSON(fiber.Map{"error": err.Error()})
|
|
}
|
|
return c.JSON(fiber.Map{"ok": true})
|
|
}
|
|
|
|
// RechazarUmindAccionHandler descarta la acción. El motivo es para el dueño,
|
|
// no para el cliente: al cliente se le dice que le responde una persona.
|
|
// POST /umind/acciones/:id/rechazar {motivo}
|
|
func RechazarUmindAccionHandler(c *fiber.Ctx) error {
|
|
accion, err := accionConAcceso(c)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if accion.Estado != "pendiente" {
|
|
return c.Status(fiber.StatusConflict).JSON(fiber.Map{"error": "esa solicitud ya fue resuelta"})
|
|
}
|
|
var req struct {
|
|
Motivo string `json:"motivo"`
|
|
}
|
|
_ = c.BodyParser(&req)
|
|
if err := models.CerrarAccion(accion.ID, "rechazada", quienResuelve(c), strings.TrimSpace(req.Motivo), ""); err != nil {
|
|
return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
|
|
}
|
|
return c.JSON(fiber.Map{"ok": true})
|
|
}
|
|
|
|
func accionConAcceso(c *fiber.Ctx) (*models.UmindAccionPendiente, error) {
|
|
id, err := strconv.ParseUint(c.Params("id"), 10, 64)
|
|
if err != nil {
|
|
return nil, c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "id inválido"})
|
|
}
|
|
accion, err := models.GetUmindAccionByID(uint(id))
|
|
if err != nil {
|
|
return nil, errSinAcceso(c)
|
|
}
|
|
if err := accesoTenant(c, accion.TenantID); err != nil {
|
|
return nil, err
|
|
}
|
|
return accion, nil
|
|
}
|
|
|
|
// quienResuelve deja registrado quién aprobó. No hay roles dentro de un
|
|
// cliente: aprueba cualquiera de sus usuarios, y por eso importa el nombre.
|
|
func quienResuelve(c *fiber.Ctx) string {
|
|
if u, ok := c.Locals("portal_user").(*models.PortalUser); ok && u != nil {
|
|
return u.Nombre + " <" + u.Email + ">"
|
|
}
|
|
return "staff"
|
|
}
|