MyDinaup

El SDK de Dinaup para .NET te permite conectar tus aplicaciones directamente con la plataforma Dinaup.

Esta guía explica, paso a paso, cómo usar el SDK de 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.

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.

LogoDinaup 9.5.0.4nuget

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.

LogoReadyToGo.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.

LogoDemoUp.MyDinaup 9.5.0.9nuget

Iniciar: crear e inicializar el cliente

Para interactuar con Dinaup, primero crea una instancia de cliente, inicialízala y actualiza la sesión por defecto. Se recomienda reutilizar una única instancia del cliente durante todo el ciclo de vida de tu aplicación.

// Parámetros de conexión
var endpointUrl   = "https://api.dinaup.com/v2/xxxx";
var apiPublicKey  = "xxx";
var apiSecretKey  = "xxx";
var defaultUserId = "*"; // * = Usuario de Sistema

// Crear e inicializar el cliente
var dinaupClient = new Dinaup.DinaupClientC(
    endpoint: endpointUrl,
    apiPublicKey: apiPublicKey,
    apiSecretKey: apiSecretKey,
    defaultUserId: defaultUserId
);

await dinaupClient.InitializeAsync(timeoutseconds: 120);
await dinaupClient.DefaultSessionUpdateAsync();

// Verificar conexión
if (dinaupClient.IsConnected)
    Console.WriteLine("Conectado. PING OK.");
else
    Console.WriteLine("No se pudo conectar al endpoint.");

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.

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

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;

AnteriorAutocompletado de direcciones con Google Maps (Blazor)SiguienteEjemplo: Agregar un Recambio en Dinaup (.NET)

Última actualización