Eventos Redis

Cómo publica el servidor de Dinaup cada alta y edición en tu Redis: la conexión, el canal, el formato del evento, las marcas de cambio por sección y la lectura con RedisClient del SDK.

El servidor de tu empresa publica al momento en tu Redis cada alta y edición de tus datos, con los valores nuevos y los anteriores. Tu aplicación se suscribe y reacciona sin preguntar. Es el mismo aviso que un webhook saliente, por un canal con más caudal y sin configurar nada por sección. Sirve para refrescar pantallas, invalidar cachés o enviar cambios a otro sistema con miles de cambios al día.

Antes de empezar

Un servidor Redis tuyo al que llegue el servidor de Dinaup.
Para leerlo desde .NET, el paquete NuGet Dinaup con Dinaup.Redis.RedisClient. Desde otro lenguaje, cualquier cliente Redis con pub/sub y un descompresor gzip.
La serie de tu licencia: es lo que nombra el canal y las claves.

Conectar tu Redis

El servidor lee la cadena de conexión del campo ConexionRedisEventos (pr_15020822_13532944) del registro de tu empresa principal en la sección Empresas administradas. Formato StackExchange.Redis:

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

abortConnect=false es obligatorio: sin ese ajuste el servidor no inicia la conexión. El cambio se aplica sin reiniciar el servidor. El servidor comprueba la cadena en cada vuelta, descarta la conexión anterior y conecta contra la nueva; vaciar el campo desconecta. Si tu Redis no responde, reintenta con una espera creciente que empieza en 15 segundos y llega a 5 minutos.

Lo que publica el servidor

Clave o canal	Qué es	Cuándo
`dinaup.srvs.events.{serie}.moni`	Canal pub/sub con los lotes de cambios, en JSON comprimido con gzip.	En cada reparto de cambios.
`dinaup.srvs.kv.{serie}.seccion.{seccion}`	La última fecha en que cambió algo de esa sección, en ISO 8601 UTC.	En cada cambio.
`dinaup.srvs.kv.{serie}.seccion.{seccion}.{campo}`	La última fecha en que cambió ese campo de esa sección.	En cada cambio.
`dinaup.srvs.status.{serie}`	Una instantánea del estado del servidor: operativo o deteniéndose.	Cada 100 segundos.
`dinaup.srvs.kv.{serie}.notavailablesystemisstarting`	La fecha hasta la que el servidor sigue arrancando. Vacía cuando ha terminado de arrancar.	Mientras arranca.

Las marcas de sección no caducan y nunca se borran. Un servidor parado o sin Redis no las actualiza: una marca que no cambia no distingue entre "nada ha cambiado" y "el servidor no ha publicado".

Leer los eventos con el SDK

RedisClient abre la conexión, se suscribe al canal y entrega cada lote descomprimido y deserializado. El evento ChangesReceived corre en un hilo de Redis: pasa el trabajo a tu propia cola y no hagas nada lento dentro.

using Dinaup.Redis;

using var redis = new RedisClient("tu-redis.tuempresa.com:6379,password=xxxx,abortConnect=false", "<serie>");

redis.ChangesReceived += lote =>
{
    foreach (var cambio in lote.Changes)
    {
        // cambio.SectionId, cambio.RowId, cambio.IsUpdate, cambio.NewValues, cambio.OldValues
    }
};

redis.MessageFailed += ex => Console.WriteLine(ex.Message);

if (await redis.SubscribeToChangesAsync() == false)
{
    // sin conexión: la cadena está vacía o Redis no responde
}

UnsubscribeFromChanges() para la escucha; Dispose() la para y cierra la conexión. Si la cadena no lleva abortConnect=false, RedisClient lo añade.

Para saber si hace falta volver a pedir un informe sin escuchar el canal, pregunta por la marca de la sección:

if (await redis.MayHaveChangesAsync(sectionId, ultimaLecturaUtc))
{
    // vuelve a consultar la API
}

Un false es seguro: hay marca y es anterior a tu fecha. Un true puede ser una falsa alarma, y es también lo que recibes cuando Redis no se puede leer. GetLastChangeAsync(sectionId, campo) devuelve la marca en sí. GetServerStatusAsync() e IsStartingAsync() leen la instantánea y el arranque.

El evento

Cada mensaje del canal es un lote. Descomprimido, es este JSON:

{
  "Type": 1,
  "LicSerie": "<serie>",
  "Timestamp": "2026-09-05T10:00:00Z",
  "Payload": [
    {
      "ID": "123e4567-e89b-12d3-a456-426614174000",
      "SectionId": "0f5d1c2a-...",
      "UserId": "9a1b...",
      "EsUpdate": true,
      "Nuevos": { "pr_importe": "150.00" },
      "Anteriores": { "pr_importe": "100.00" }
    }
  ]
}

Propiedad en el JSON	En `RedisClient`	Qué es
`Type`	`EventType`	`1`, lote de cambios de datos. Es el único tipo que se publica.
`LicSerie`	`LicenseSerial`	La serie de la licencia.
`Timestamp`	`TimestampUtc`	Cuándo publicó el servidor el lote.
`Payload`	`Changes`	Los registros que cambiaron.
`ID`	`RowId`	El registro.
`SectionId`	`SectionId`	La sección, como GUID en texto.
`UserId`	`UserId`	Quién hizo el cambio; vacío si fue el sistema.
`EsUpdate`	`IsUpdate`	`true` en una edición, `false` en un alta.
`Nuevos`	`NewValues`	Los valores tras el cambio, por nombre de campo, como texto.
`Anteriores`	`OldValues`	Los valores anteriores. `null` en un alta.

Desde otro lenguaje: suscríbete al canal, descomprime cada mensaje con gzip y deserializa ese JSON. Si no conoces la serie, suscríbete por patrón a dinaup.srvs.events.*.moni: el nombre del canal que recibes la contiene.

Qué no se publica

Quedan fuera del canal las plantillas base y las tablas de líneas como tales, y varias secciones, por confidencialidad o por volumen. Entre ellas:

Códigos de inicio de sesión.
Uso API, Registros de Actividad API y Registro de Errores API.
Anotaciones internas, registros de eliminación, historiales de actividad en registros y en informes, personalización de columnas.
Numeraciones y series.

Que una sección no aparezca en el canal no significa que no haya cambiado.

Es un canal de avisos, no una cola

Un lote publicado mientras tu suscriptor estaba desconectado no se reenvía: pub/sub no tiene historial. Para reconstruir estado, consulta la API o PG Sync; los eventos sirven para reaccionar, no como fuente de verdad.

Relacionado

Webhooks salientes: el mismo aviso por HTTP, gestionado por Dinaup y sin infraestructura tuya.
SDK .NET: el resto del paquete Dinaup.