Eventos Redis en tiempo real

Recibe cada cambio de datos en tu propio Redis: canal, formato del evento y código de suscripción para reaccionar al momento.

Dinaup puede publicar cada alta y edición de tus datos en un servidor Redis tuyo, en el momento en que ocurre. El evento llega con los valores nuevos y los anteriores del registro: tu aplicación reacciona sin preguntar, sin polling y sin esperar a un webhook HTTP.

Es el mismo aviso que un webhook saliente, por un canal más rápido y con más caudal: pensado para refrescar pantallas en tiempo real, invalidar cachés o sincronizar otro sistema con miles de cambios al día.

Antes de empezar

Un servidor Redis tuyo, accesible desde Internet, donde Dinaup pueda publicar.
Tu app en .NET con el paquete StackExchange.Redis (y el paquete Dinaup para descomprimir).

Conectar tu Redis y suscribirte

Configura la conexión en tu empresa administrada

En la ficha de tu empresa administrada principal, rellena el campo Conexión Redis Eventos con la cadena de tu servidor, en formato StackExchange.Redis:

tu-redis.tuempresa.com:6379,password=xxxx,abortConnect=false

abortConnect=false es obligatorio. Si falta, Dinaup no inicia la conexión: sin ese flag, el conector fallaría al primer intento si tu Redis tarda en responder.

El cambio se aplica en caliente: el servidor detecta la cadena nueva en unos segundos, descarta la conexión anterior y conecta contra la nueva. Vaciar el campo desconecta.

Suscríbete al canal

Los eventos llegan por el canal dinaup.srvs.events.{serie}.moni, donde {serie} es la serie de tu licencia. El mensaje viene comprimido con gzip; el paquete Dinaup trae el descompresor.

using StackExchange.Redis;
using System.Text.Json;

var redis = await ConnectionMultiplexer.ConnectAsync(
    "tu-redis.tuempresa.com:6379,password=xxxx,abortConnect=false");

var canal = new RedisChannel($"dinaup.srvs.events.{serie}.moni",
    RedisChannel.PatternMode.Literal);

await redis.GetSubscriber().SubscribeAsync(canal, (channel, mensaje) =>
{
    byte[] bytes = mensaje;
    bytes = Dinaup.extensions.Gzip_Decompress(bytes);
    var texto = System.Text.Encoding.UTF8.GetString(bytes);

    var evento = JsonSerializer.Deserialize<RedisEvent<List<RedisMonitoringDTO>>>(texto);
    if (evento == null || evento.Type != 1) return;

    foreach (var cambio in evento.Payload)
    {
        // cambio.SectionId, cambio.NewValues, cambio.PreviousValues…
    }
});

Si no conoces tu serie, suscríbete por patrón (dinaup.srvs.events.*.moni con PatternMode.Pattern): el nombre del canal que recibas la contiene.

Deserializa el evento

El mensaje es un sobre con la lista de cambios dentro. Estas dos clases bastan para leerlo:

public class RedisEvent<TPayload>
{
    public int Type { get; set; }          // 1 = monitorización de cambios
    public string LicSerie { get; set; }
    public TPayload Payload { get; set; }
    public DateTime Timestamp { get; set; } // UTC
}

public class RedisMonitoringDTO
{
    public Guid ID { get; set; }                       // registro afectado
    public string SectionId { get; set; }              // sección (Guid en texto)

    [JsonPropertyName("Tabla")]
    public string Table { get; set; }

    public Guid UserId { get; set; }                   // quién hizo el cambio

    [JsonPropertyName("EsUpdate")]
    public bool IsUpdate { get; set; }                 // false = alta

    [JsonPropertyName("Nuevos")]
    public Dictionary<string, string> NewValues { get; set; }

    [JsonPropertyName("Anteriores")]
    public Dictionary<string, string> PreviousValues { get; set; }
}

Cada evento agrega los datos del registro: Nuevos trae los valores tras el cambio y Anteriores los que había. Comparándolos sabes qué campo cambió sin consultar nada.

Qué se publica y qué no

Se publica cada alta y edición de las secciones normales de tu licencia. Quedan fuera:

Secciones base y plantillas de tipo lista.
Secciones internas de alta actividad: registros de actividad, anotaciones internas, registros de eliminación, numeraciones y series, registros Verifactu y transacciones monetarias internas, entre otras. Inundarían el canal sin aportar señal.

Es un canal de avisos, no una cola con reintentos. Si tu Redis está caído, los eventos de ese intervalo no se reenvían. Para reconstruir estado usa informes o PGSync; los eventos sirven para reaccionar, no como fuente de verdad.

Para qué usarlo

Pantallas en tiempo real. Un kanban o un TPV que se refresca cuando otro usuario mueve una tarjeta o cobra un ticket. Así funcionan las pantallas de play.dinaup.com.
Cachés que se invalidan solas. Borra la entrada cuando llega el evento de su sección, en vez de expirar a ciegas.
Sincronización con otro sistema. Empuja el cambio a tu buscador, tu data warehouse o tu web al momento, con los valores nuevos y viejos incluidos.

Si prefieres avisos gestionados por Dinaup y sin infraestructura propia, usa webhooks salientes. Si necesitas la base de datos completa replicada, PGSync.