Cliente Dinaup

El Cliente Dinaup conecta tus aplicaciones .NET con la plataforma Dinaup: conexión, sesiones, informes, archivos, anotaciones y WriteOperations.

Esta guía explica, paso a paso, cómo usar el cliente Dinaup en .NET para conectarte al servicio, consultar informes, gestionar archivos, añadir anotaciones, generar documentos dinámicos, leer/escribir datos de secciones y trabajar con paginación y filtros.

Sorprendentemente sencillo

Instala

Terminal

dotnet add package Dinaup
dotnet add package Demoup.MyDinaup

Conecta

var client = await DinaupClientC.ConnectAsync(
    endPoint: "https://api.dinaup.com/v2/tu-codigo",
    publicKey: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
    secretKey: "tu-secret-key-aqui"
);

if (client == null || client.IsConnected == false)
{
    throw new Exception("No se pudo conectar a Dinaup");
}

using Dinaup;

// Las unicas credenciales en variables de entorno
var vault = new VaultData(
    Environment.GetEnvironmentVariable("VAULT_URL"),
    Environment.GetEnvironmentVariable("VAULT_PASSWORD")
);
vault.Initialize();

// Todo lo demas viene del Vault
var client = await DinaupClientC.ConnectAsync(
    endPoint: vault.Read("dinaup.endpoint"),
    publicKey: vault.Read("dinaup.publickey"),
    secretKey: vault.Read("dinaup.secretkey")
);

if (client == null || client.IsConnected  == false)
{
    throw new Exception("No se pudo conectar a Dinaup");
}

program.cs


using Dinaup;

var builder = WebApplication.CreateBuilder(args);

// Cargar Vault
var vault = new VaultData(
    Environment.GetEnvironmentVariable("VAULT_URL"),
    Environment.GetEnvironmentVariable("VAULT_PASSWORD")
);
vault.Initialize();

// Conectar a Dinaup
var client = await DinaupClientC.ConnectAsync(
    endPoint: vault.Read("dinaup.endpoint"),
    publicKey: vault.Read("dinaup.publickey"),
    secretKey: vault.Read("dinaup.secretkey")
);

if (client == null || client.IsConnected == false)
    throw new Exception("No se pudo conectar a Dinaup");


// Registrar como Singleton
builder.Services.AddSingleton(client);

var app = builder.Build();

Opera

// Use pre-built reports from DemoUp.MyDinaup
using DemoUp.MyDinaup.Reports.FuncionalidadD;

// Create and execute the report
var ventasReport = new APIVentasC();
await ventasReport.ExecuteQueryAsync(
    dinaupClient: client,
    page: 1,
    resultsPerPage: 50
);

// Access results
Console.WriteLine($"Total: {ventasReport.TotalResults} records");
foreach (var row in ventasReport.Rows)
{
    Console.WriteLine($"- {row.NumerodefacturaCompleto}: {row.Total}");
}

Guid sectionId = /* sección destino */;

var data = new Dictionary<string, string>
{
    {
        SeccionDePruebasAPIES.TextoPrincipal,
        $"Prueba {Guid.NewGuid()}"
    }
};

var wOp = new WriteOperation("", data); // "" => alta

var result= dinaupClient.RunWriteOperation(
    dinaupClient.DefaultSession,
    SeccionDePruebasAPIES.SectionId,
    wOp,
    false  
);

// Lanza excepción si hubo errores globales
result.EnsureSuccess();

Guid newId = wOp.WriteOperationResult.RowID;

Guid rowId = /* Id del registro a editar */;

var data = new Dictionary<string, string>
{
    {
        SeccionDePruebasAPIES.TextoPrincipal,
        $"Prueba {Guid.NewGuid()}"
    }
};

var wOp= new WriteOperation(rowId, data);

var result= dinaupClient.RunWriteOperation(
    dinaupClient.DefaultSession,
    sectionId,
    wOp,
    false
);

// Lanza excepción si hubo errores globales
result.EnsureSuccess();

Guid updatedId = wOp.WriteOperationResult.RowID;

Referencias

Dinaup .NET

Antes de empezar necesitarás instalar el paquete Dinaup, que incluye el Cliente base: conexión, autenticación, sesiones, archivos, anotaciones, WriteOperations, etc.

Dinaup 10.15.0.11nuget

MyDinaup

Dinaup es una plataforma flexible: cada empresa cuenta con su propio modelo de datos (secciones, informes y documentos dinámicos). Para trabajar de forma tipada con ese modelo, necesitas la biblioteca MyDinaup específica de tu organización. MyDinaup incluye modelos y utilidades tipadas (Reports, SectionsD y DynamicDocuments) con los nombres reales de tus secciones y depende del paquete base Dinaup.

Modelo Ready to Go

Este Nuget únicamente incluye la modelización de la estructura Ready to Go. Ideal para desarrollos compatibles con varias empresas.

ReadyToGo.MyDinaup 9.1.0.58nuget

Modelo DemoUp

Este es un modelo de Pre-Producción que utiliza internamente el equipo de Dinaup. Su uso está desaconsejado ya que puede contener errores y estructuras incompatibles.

DemoUp.MyDinaup 10.15.0.11nuget

Informes

Los informes son consultas predefinidas y tipadas para acceder a datos de manera eficiente. Están en el espacio de nombres:

{Empresa}.MyDinaup.Reports.{CategoriaD}
Convención de nombres de clases: API + NombreDeSeccion + C
Los nombres de secciones/clases están en español porque se generan a partir de tu licencia (por ejemplo, “Ventas”, “Impuestos”, etc.).

Ejemplos de clases:

DemoUp.MyDinaup.Reports.FuncionalidadD.APISeccionDePruebasAPIC
DemoUp.MyDinaup.Reports.FuncionalidadD.APIEntidadesC
DemoUp.MyDinaup.Reports.VentasD.APIVentasC
DemoUp.MyDinaup.Reports.ImpuestosD.APIImpuestosC

Usa ExecuteQueryAsync para obtener resultados paginados. Accede a filas fuertemente tipadas desde report.Rows.

using DemoUp.MyDinaup.Reports.FuncionalidadD;

var report = new APISeccionDePruebasAPIC(); // 

await report.ExecuteQueryAsync(dinaupClient, page: 1, pageSize: 10);

Console.WriteLine($"Total resultados: {report.TotalResults}");

if (report.Rows.IsNotEmpty())
{
    foreach (var fila in report.Rows)
    {
        // Accede a propiedades tipadas de cada fila
        // Ej.: fila.TextoPrincipal, fila.ValorEntero, etc.
    }
}

Ajusta pageSize a tus necesidades. Si esperas muchos resultados, usa paginación.

Filtrar resultados Filtro simple por campo de la misma sección

var report = new APISeccionDePruebasAPIC();

// Igualdad estricta
report.AddFilter(
    SeccionDePruebasAPIES.ValorEntero,
    "=", 
    3);

await report.ExecuteQueryAsync(dinaupClient, page: 1, pageSize: 10);

if (report.Rows.IsNotEmpty())
{
    foreach (var fila in report.Rows)
    {
        // Usar fila...
    }
}

Filtrar utilizando datos relacionados (composición de rutas):

Construye una clave de relación combinando el ID de sección y el campo de interés en la entidad relacionada.

// Clave de relación (ruta compuesta)
var relationKey =
     SeccionDePruebasAPIES._SectionID.STR() + "." +
     SeccionDePruebasAPIES.ReferenciaAutorDelAlta + "." +
     EntidadesBaseES._SectionID.STR() + "." +
     EntidadesBaseES.VIP;
 
 
var report = new APISeccionDePruebasAPIC();
report.AddFilter(relationKey, "=", 3);

await report.ExecuteQueryAsync(dinaupClient, page: 1, pageSize: 10);

if (report.Rows.IsNotEmpty())
{
    foreach (var fila in report.Rows)
    {
        // Usar fila...
    }
}

Filtrado Between

// Between (ej.: 1 a 2999)
var reportBetween = new APISeccionDePruebasAPIC();
reportBetween.AddFilterBetween(
   SeccionDePruebasAPIES.ValorEntero,
    1,
    2999
);

await reportBetween.ExecuteQueryAsync(dinaupClient, page: 1, pageSize: 10);

Solapamiento de rangos de fechas (overlap)

var eventosReport = new APIEventosDeCRMC();

var campoInicio = EventosDeCRMES.InicioEvento_UTC;
var campoFin    = EventosDeCRMES.FinEvento_UTC;

var rangoInicio = DateOnly.FromDateTime(new DateTime(2000, 1, 1));
var rangoFin    = DateOnly.FromDateTime(DateTime.Today.AddYears(50));

eventosReport.AddFilterDateRangeOverlapFilter(campoInicio, campoFin, rangoInicio, rangoFin);

await eventosReport.ExecuteQueryAsync(dinaupClient, page: 1, pageSize: 25);

Cuando el informe tiene muchos resultados, recorre página a página con ExecuteQuery_NextPage_Async.

 var report = new APISeccionDePruebasAPIC();
 await report.ExecuteQueryAsync(_dinaupClient, 1, 300);

 if (report.Rows.IsNotEmpty())
 {
     do
     {


         foreach (var row in report.Rows)
         {
              
         }   


     } while (await report.ExecuteQuery_NextPageAsync());
 }

Archivos

Dinaup permite subir archivos desde memoria o URL y obtener URLs firmadas para su consumo.

Subir desde un array de bytes

var bytes = System.Text.Encoding.UTF8.GetBytes("hola " + Guid.NewGuid());
var upload = await dinaupClient.File_UploadBytesAsync(
    dinaupClient.DefaultSession,
    bytes,
    "prueba.txt"
);

Guid fileId = upload.FileId;

Subir desde una URL

var upload = await dinaupClient.File_UploadURLAsync(
    dinaupClient.DefaultSession,
    "https://cdn.dinaup.com/dinaup/web/portal/img/dinabot_marca.png",
    "dinabot.png"
);

Guid fileId = upload.FileId;

Obtener una URL firmada (lectura)

var signed = await dinaupClient.File_SignURLGetAsync(fileId);
var url = signed?.url_original; // URL lista para usar

Calcula el SHA1 en cliente y consulta antes de subir. Ahorra almacenamiento y ancho de banda.


private async Task<Dinaup.DinaupFileDTO> GetExistingFileAsync(string sha1)
{
    var report = new MyDinaup.Reports.FuncionalidadD.APIIndiceDeArchivosEnSistemaC();
    report.AddFilter("crcbase", "=", sha1);
    await report.ExecuteQueryAsync(_dinaupClient, 1, 1, "", true, true); 
    return report.Files.Values.FirstOrDefault();
}

private async Task<Dinaup.DinaupFileDTO> GetExistingFileAsync(byte[] data)
{
    string sha1 = Dinaup.extensions.ToSHA1(data);
    return await GetExistingFileAsync(sha1);
}

Anotaciones

Todas las filas (registros) de Dinaup soportan 3 tipos de anotaciones:

AnnotationTypeE.Comments: Mensajería tipo chat para el equipo, dentro del contexto del registro.
AnnotationTypeE.PublicGallery: Archivos públicos en el CDN (p. ej., fotos de productos).
AnnotationTypeE.Files: Documentos privados asociados (contratos, presupuestos, soportes, etc.).

Los archivos en PublicGallery son públicos: cualquiera con el enlace puede verlos.

A continuación, ejemplos usando AnnotationTypeE.Comments.

Agregar un comentario (solo texto)

Guid sectionId = /* tu sección */;
Guid rowId     = /* registro al que agregas el comentario */;

await dinaupClient.Annotation_PutAsync(
    dinaupClient.DefaultSession,
    sectionId,
    rowId.STR(), 
    Guid.Empty,       // sin archivo adjunto
    "¡Hola mundo! Este es mi primer comentario.",
    AnnotationTypeE.Comments
);

Agregar un comentario con archivo adjunto

var bytes = System.Text.Encoding.UTF8.GetBytes("contenido adjunto");
var upload = await dinaupClient.File_UploadBytesAsync(
    dinaupClient.DefaultSession,
    bytes,
    "nota.txt"
);

await dinaupClient.Annotation_PutAsync(
    dinaupClient.DefaultSession,
    sectionId,
    rowId.ToString(),
    upload.FileId, // adjuntamos el archivo
    "Comentario con adjunto",
    AnnotationTypeE.Comments
);

Leer anotaciones

var resultado = await dinaupClient.Annotations_GetAsync(
    dinaupClient.DefaultSession,
    sectionId,
    rowId,
    AnnotationTypeE.Comments
);

foreach (var anotacion in resultado.Annotations)
{
    var texto    = anotacion.Text;
    var adjuntos = anotacion.AttachedFiles; // si hay archivos adjuntos
}

Documentos dinámicos

Los Documentos Dinámicos permiten:

Agrupar varias consultas en una sola operación para reducir latencia.
Generar documentos de impresión (facturas, albaranes) delegando la composición en Dinaup.

Recomendación:

Para consultar datos en general, usa Reports siempre que sea posible. Documentos Dinámicos son útiles para orquestar múltiples consultas y componer resultados.

Ejecutar un documento dinámico

var documentoSesionExecutor = new DynamicDocuments.APID.SesionC();

// Pasa la sesión actual.
// Si dispones de una sesión de usuario distinta, úsala; en caso contrario, usa la sesión por defecto.
await documentoSesionExecutor.ExecuteAsync(dinaupClient, dinaupClient.DefaultSession);

Secciones

Las secciones son el equivalente a tablas/entidades por empresa (Clientes, Facturas, Empleados, etc.). En MyDinaup existen utilidades tipadas para trabajar con ellas:

Espacio de nombres: MyDinaup.SectionsD
Incluye métodos para leer registros por Id o por criterios.

Advertencia de rendimiento:

Las operaciones de lectura en SectionsD consultan todos los datos de la sección y los textos principales de los datos relacionados (p. ej., en una venta también recupera empleados, clientes, productos, impuestos, etc.). Esto tiene mayor coste computacional.
Para rendimiento óptimo, usa Reports. Para escenarios “super optimizados”, usa PGSync.
Usa SectionsD cuando el código se ejecute con poca frecuencia o para prototipos rápidos.

Recibir un dato por Id

Guid paisId = /* Id del país */;

var pais = await MyDinaup.SectionsD.PaisesD.GetRowByIdAsync(dinaupClient, paisId);

// Usa pais.Propiedad...

Recibir una lista

var filtros = new List<FilterCondition>
{
    new FilterCondition(
        MyDinaup.SectionsD.PaisesD.PaisesES.CodigoDePaisAlfabeticoDe2Caracteres,
        "=",
        "ES"
    )
};

var parametros = new RowsRequestParameters(filtros.ToArray());

var paises = await MyDinaup.SectionsD.PaisesD.GetRowsAsync(
    dinaupClient,
    parametros,
    dinaupClient.DefaultSession
);

// Iterar resultados
foreach (var p in paises.Rows)
{
    // p.Propiedad...
}

Escritura

Las operaciones de escritura usan WriteOperation para altas y ediciones.

El ID vacío ("") indica alta
Un ID válido indica edición.
Un ID que no existe provocará una excepción.

Alta simple (crear un registro)

Guid sectionId = /* sección destino */;

var data = new Dictionary<string, string>
{
    {
        SeccionDePruebasAPIES.TextoPrincipal,
        $"Prueba {Guid.NewGuid()}"
    }
};

var wOp = new WriteOperation("", data); // "" => alta

var result= dinaupClient.RunWriteOperation(
    dinaupClient.DefaultSession,
    SeccionDePruebasAPIES.SectionId,
    wOp,
    false  
);

// Lanza excepción si hubo errores globales
result.EnsureSuccess();

Guid newId = wOp.WriteOperationResult.RowID;

Edición (actualizar un registro existente)

Guid rowId = /* Id del registro a editar */;

var data = new Dictionary<string, string>
{
    {
        SeccionDePruebasAPIES.TextoPrincipal,
        $"Prueba {Guid.NewGuid()}"
    }
};

var wOp= new WriteOperation(rowId, data);

var result= dinaupClient.RunWriteOperation(
    dinaupClient.DefaultSession,
    sectionId,
    wOp,
    false
);

// Lanza excepción si hubo errores globales
result.EnsureSuccess();

Guid updatedId = wOp.WriteOperationResult.RowID;

Alta 10 registros de golpe

var operaciones = new List<WriteOperation>();

for (int i = 0; i < 10; i++)
{
    var fila = new Dictionary<string, string>
    {
        {
            SeccionDePruebasAPID.SeccionDePruebasAPIES.TextoPrincipal,
            $"Lote {i}: {Guid.NewGuid()}"
        }
    };

    operaciones.Add(new WriteOperation("", fila)); // alta
}

var batchAdd = dinaupClient.RunWriteOperation(
    dinaupClient.DefaultSession,
    sectionId,
    operaciones,
    false
);

var ids = operaciones.Select(o => o.WriteOperationResult.RowID).ToList();

Editar 10 registros

// Partiendo de la lista 'ids' creada en el ejemplo anterior
var operacionesEdicion = new List<WriteOperation>();

foreach (var id in ids)
{
    var actualizado = new Dictionary<string, string>
    {
        {
            SeccionDePruebasAPID.SeccionDePruebasAPIES.TextoPrincipal,
            $"Editado {DateTime.UtcNow.Ticks}"
        }
    };

    operacionesEdicion.Add(new WriteOperation(id.ToString(), actualizado)); // edición
}

var batchEdit = dinaupClient.RunWriteOperation(
    dinaupClient.DefaultSession,
    sectionId,
    operacionesEdicion,
    false
);

Si se vana procesar más de 20 registros, usa .Chunk(20) para dividir en bloques.

AnteriorSDK .NET SiguienteEjemplo: WriteOperations por Lotes

Última actualización hace 19 días

Cliente Dinaup

Sorprendentemente sencillo

Instala

Conecta

Opera

Referencias

Dinaup .NET

MyDinaup

Informes

Archivos

Anotaciones

Documentos dinámicos

Secciones

Escritura

¿Qué hace la virtualización?

¿Cuándo usar virtualización?

¿Cuándo evitar virtualización?

hashtagSorprendentemente sencillo

hashtagInstala

hashtagConecta

hashtagOpera

hashtagReferencias

hashtagDinaup .NET

hashtagMyDinaup

hashtagInformes

hashtagArchivos

hashtagAnotaciones

hashtagDocumentos dinámicos

hashtagSecciones

hashtagEscritura

hashtag¿Qué hace la virtualización?

hashtag¿Cuándo usar virtualización?

hashtag¿Cuándo evitar virtualización?

Sorprendentemente sencillo

Instala

Conecta

Opera

Referencias

Dinaup .NET

MyDinaup

Informes

Archivos

Anotaciones

Documentos dinámicos

Secciones

Escritura

¿Qué hace la virtualización?

¿Cuándo usar virtualización?

¿Cuándo evitar virtualización?