Cliente Dinaup

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, resultsPerPage: 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.
    }
}

• 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, resultsPerPage: 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, resultsPerPage: 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, resultsPerPage: 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, resultsPerPage: 25);

• Búsqueda de texto libre

  El parámetro querySearch de ExecuteQueryAsync busca en los campos de texto del informe, como el buscador de la interfaz web.

  var report = new APISeccionDePruebasAPIC();
  await report.ExecuteQueryAsync(dinaupClient, 1, 25, "iPhone Pro Max");

• Filtro IN (varios valores a la vez)

  // Con textos
  report.AddFilter(SeccionDePruebasAPIES.TextoPrincipal, new[] { "Valor A", "Valor B" });
  
  // Con Guids (relaciones)
  report.AddFilterIn(SeccionDePruebasAPIES.ReferenciaAutorDelAlta, new[] { id1, id2 });

• OR implícito

  Dos filtros sobre el mismo campo se combinan con OR, no con AND.

  report.AddFilter(PaisesD.PaisesES.CodigoDePaisAlfabeticoDe2Caracteres, "=", "ES");
  report.AddFilter(PaisesD.PaisesES.CodigoDePaisAlfabeticoDe2Caracteres, "=", "IT");
  // Devuelve España e Italia

• Variables de informe

  Si el informe define variables (por ejemplo, un rango de fechas parametrizado), pásalas con AddVariable. Admite string, Guid, int, decimal, bool, Date y DateOnly.

  report.AddVariable("ClienteId", clienteId);
  report.AddVariable("FechaDesde", new DateOnly(2026, 1, 1));

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());
 }

Para exportar o procesar todas las filas de un informe, usa LoadAllRowsAsync. Pagina por keyset (cursor sobre el id), sin OFFSET, con coste constante por página y sin filas repetidas ni saltadas. Escala a millones.

// Devuelve TODAS las filas del informe, ordenadas por id.
var report = new APISeccionDePruebasAPIC();
var todas = await report.LoadAllRowsAsync(dinaupClient, pageSize: 10000, adminMode: true);

Console.WriteLine($"{todas.Count} filas volcadas");

Ver la guía Listados de alto rendimiento para el detalle, los límites y las excepciones.

• Subir desde un array de bytes

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

• Subir desde una URL

  var upload = await dinaupClient.File_UploadURLAsync(
      "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

• Agregar un comentario (solo texto)

  Guid sectionId = /* tu sección */;
  Guid rowId     = /* registro al que agregas el comentario */;
  
  var anotacion = new AnotationParameters(sectionId, rowId, AnnotationTypeE.Comments)
      .WithText("¡Hola mundo! Este es mi primer comentario.");
  
  await dinaupClient.Annotation_PutAsync(anotacion);

• Agregar un comentario con archivo adjunto

  var bytes = System.Text.Encoding.UTF8.GetBytes("contenido adjunto");
  var upload = await dinaupClient.File_UploadBytesAsync(bytes, "nota.txt");
  
  var anotacion = new AnotationParameters(sectionId, rowId, AnnotationTypeE.Comments)
      .WithText("Comentario con adjunto")
      .WithFile(upload.FileId); // adjuntamos el archivo
  
  await dinaupClient.Annotation_PutAsync(anotacion);

• Leer anotaciones

  var resultado = await dinaupClient.Annotations_GetAsync(
      sectionId,
      rowId,
      AnnotationTypeE.Comments
  );
  
  foreach (var anotacion in resultado.Annotations)
  {
      var texto    = anotacion.Text;
      var adjuntos = anotacion.AttachedFiles; // si hay archivos adjuntos
  }

• Ejecutar un documento dinámico

  var documentoSesionExecutor = new DynamicDocuments.APID.SesionC();
  
  await documentoSesionExecutor.ExecuteAsync(dinaupClient);
  

• 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);
  
  // GetRowsAsync devuelve directamente una List<PaisesC>
  foreach (var p in paises)
  {
      // p.Propiedad...
  }

• Recibir cabecera y líneas en una llamada

  En secciones con lista (una factura y sus líneas), GetRowsWithListAsync devuelve cada registro como MainRow más su colección ListRows.

  var filas = await MyDinaup.SectionsD.FacturasD
      .GetRowsWithListAsync(dinaupClient, new RowsRequestParameters(facturaId.STR()));
  
  var factura = filas.FirstOrDefault();
  // factura.MainRow.Propiedad...
  foreach (var linea in factura.ListRows) { }

• 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
  
  // El sectionId es un Guid: usa _SectionIDGUID (no _SectionID, que es string)
  await dinaupClient.RunWriteOperationAsync(SeccionDePruebasAPIES._SectionIDGUID, wOp, false);
  
  // Lanza excepción si la operación falló o no se ejecutó
  wOp.EnsureSuccess();
  
  // Tras EnsureSuccess, WriteOperationResult está garantizado (no nulo)
  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);
  
  await dinaupClient.RunWriteOperationAsync(sectionId, wOp, false);
  
  // Lanza excepción si la operación falló o no se ejecutó
  wOp.EnsureSuccess();
  
  Guid updatedId = wOp.WriteOperationResult.RowID;

• Alta con líneas (cabecera + lista)

  En secciones con lista, añade cada línea como diccionario en DataListRows. Se guardan en la misma operación que la cabecera.

  var wOp = new WriteOperation("", data);
  
  wOp.DataListRows.Add(new Dictionary<string, string>
  {
      { SeccionDePruebasAPIListaES.TextoPrincipal, "Línea 1" }
  });
  
  await dinaupClient.RunWriteOperationAsync(SeccionDePruebasAPIES._SectionIDGUID, wOp, false);

• Editar un solo campo

  Para cambiar un valor sin montar el diccionario:

  await dinaupClient.RunInlineWriteOperationAsync(
      SeccionDePruebasAPIES._SectionIDGUID, rowId,
      SeccionDePruebasAPIES.TextoPrincipal, "Nuevo valor");

• Relación por texto (selector dinámico)

  Si no tienes el Guid del registro relacionado, escribe [Campo=Valor] y el servidor lo resuelve buscando por ese campo.

  var data = new Dictionary<string, string>
  {
      { ProductosES.UnidadMedidaID, $"[{UnidadesMedidaES.TextoPrincipal}=Litros]" }
  };

• 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 = await dinaupClient.RunWriteOperationAsync(sectionId, operaciones, false);
  batchAdd.EnsureSuccess();
  
  var ids = operaciones
      .Where(o => o.WriteOperationResult != null)
      .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 = await dinaupClient.RunWriteOperationAsync(sectionId, operacionesEdicion, false);
  batchEdit.EnsureSuccess();

La escritura virtualizada permite que Dinaup ejecute la lógica de negocio definida en una sección. Al activarla, cualquier operación de escritura se comporta como si se hubiera realizado desde la interfaz web: con scripts, validaciones, eventos, y cálculos incluidos.

¿Qué hace la virtualización?

Cuando se activa la virtualización en una operación de escritura (RunWriteOperationAsync con el tercer parámetro, ejecución de scripts, en true), Dinaup:

• Ejecuta scripts personalizados de la sección (onBeforeSave, onAfterSave, etc.)
• Recalcula campos automáticos (ej. totales, impuestos)
• Aplica reglas de validación y lógica de negocio
• Dispara eventos definidos en la sección

Cuando se desactiva (tercer parámetro en false), se guardan los valores tal como se reciben (creando histórico). No se ejecuta ningún comportamiento adicional.

¿Cuándo usar virtualización?

Usa escritura virtualizada cuando la sección contiene lógica de negocio activa que debe ejecutarse. Esto incluye cálculos automáticos de totales en ventas, generación de fechas de vencimiento, o scripts que actualizan otras entidades relacionadas. Por ejemplo, al registrar una nueva venta, al cerrar un pedido o al generar una factura, la virtualización asegura que todo se procese correctamente.

¿Cuándo evitar virtualización?

Evita la virtualización cuando realizas modificaciones simples que no requieren ejecutar lógica adicional. Esto incluye acciones como cambiar el estado de una venta, asignar un técnico a un ticket de soporte, registrar una nota interna o marcar una tarea como completada. En estos casos, desactivarla mejora el rendimiento sin afectar el comportamiento esperado.