La flexibilidad de Excel, la potencia de un ERP

// Filtros y ordenación avanzada
var report = new APIVentasC();

report.AddFilterBetween(VentasES.Fecha, inicioMes, finMes);
report.AddFilter(VentasES.Estado, "=", EstadoE.Completada.INT());
report.AddOrder(VentasES.Total, descending: true);

await report.ExecuteQueryAsync(client);

foreach (var row in report.Rows)
{
    Console.WriteLine($"{row.Numero}: {row.Total}€");
}
// Página {report.CurrentPage} de {report.TotalPages}

// Recorrer todas las páginas de resultados
var report = new APIProductosC();
await report.ExecuteQueryAsync(client);

if (report.Rows.IsNotEmpty())
{
    do
    {
        foreach (var row in report.Rows)
        {
            // Procesar cada registro
        }
    } while (await report.ExecuteQuery_NextPageAsync());
}
// ✓ Todos los registros procesados

// Importar productos en bloques
var externos = await http.GetFromJsonAsync<List<ProductoDTO>>(url);

var chunks = externos.Chunk(DinaupClientC.MaxItemsPerWriteOperation);

foreach (var chunk in chunks)
{
    var lote = chunk.Select(e => new WriteOperation(Guid.Empty, new()
    {
        { ProductosES.CodigoExterno, e.SKU },
        { ProductosES.Nombre, e.Nombre },
        { ProductosES.Precio, e.Precio.STR() }
    })).ToList();

    client.RunWriteOperation(ProductosES._SectionID, lote, false);
}
// ✓ Productos sincronizados por bloques

// Actualizar precios masivamente
var cambios = productosIds.Select(id => new WriteOperation(id, new()
{
    { ProductosES.Precio, nuevoPrecio.STR() },
    { ProductosES.FechaActualizacion, DateTime.Now.STR() }
})).ToList();

client.RunWriteOperation(ProductosES._SectionID, cambios, false);
// ✓ 150 productos actualizados

// Subir desde una URL externa
var upload = await client.File_UploadURLAsync(
    "https://ejemplo.com/imagen.png",
    "imagen.png"
);

Guid fileId = upload.FileId;
// ✓ Archivo importado desde URL

// Obtener URL firmada para lectura
var signed = await client.File_SignURLGetAsync(fileId);

var url = signed?.url_original;
// ✓ URL lista para usar

// Subir archivo primero
var upload = await client.File_UploadBytesAsync(bytes, "documento.pdf");

// Agregar comentario con archivo
var params = new AnotationParameters(sectionId, rowId, AnnotationTypeE.Comments)
    .WithText("Adjunto el contrato firmado")
    .WithFile(upload.FileId);

await client.Annotation_PutAsync(params);
// ✓ Comentario con archivo adjunto

// Leer anotaciones de un registro
var resultado = await client.Annotations_GetAsync(
    sectionId,
    rowId,
    AnnotationTypeE.Comments
);

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

// Sincronizar productos desde API externa
public async Task SyncProductosAsync(List<ProductoExterno> externos)
{
    var operaciones = externos.Select(e => new WriteOperation(
        e.DinaupId ?? Guid.Empty,
        new() {
            { ProductosES.CodigoExterno, e.SKU },
            { ProductosES.Nombre, e.Nombre },
            { ProductosES.Precio, e.Precio.STR() }
        })).ToList();

    client.RunWriteOperation(ProductosES._SectionID, operaciones, false);
}
// ✓ Crea nuevos o actualiza existentes

// Worker para procesar tareas pendientes
public class TareasWorker : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        while (ct.IsCancellationRequested == false)
        {
            var pendientes = await GetPendientesAsync();
            foreach (var tarea in pendientes)
                await ProcesarAsync(tarea);

            await Task.Delay(TimeSpan.FromMinutes(5), ct);
        }
    }
}

// DynamicSelector - Buscar relación automáticamente
var op = new WriteOperation(Guid.Empty, new() {
    { ProductosES.Nombre, "Mi producto" },
    { ProductosES.UnidadMedidaID, $"[{UnidadesMedidaES.TextoPrincipal}=Litros]" }
});

// Editar por campo alternativo (ej: SKU)
client.RunWriteOperation(
    ProductosD._SectionIDGUID, op,
    runScripts: false,
    identifierFieldKey: ProductosES.CodigoExterno
);

// Actualizar un solo campo (más legible)
await client.RunInlineWriteOperationAsync(
    ProductosD._SectionIDGUID, productoId,
    ProductosES.Precio, 1299.00m.STR()
);

// Limpiar relación (string vacío)
valores.Add(ProductosES.ClienteID, "");

// Verificar resultado
op.WriteOperationResult.RowID      // Guid del registro
op.WriteOperationResult.Confirmed  // bool
op.WriteOperationResult.AError     // string (si hay error)

// Obtener cabecera + líneas en una llamada
var factura = await FacturasD.GetRowByIdWithListAsync(client, facturaId);
Console.WriteLine($"Factura: {factura.MainRow.Numero}");
foreach (var linea in factura.ListRows) { }

// GetRowsAsync con labels de relaciones
var productos = await ProductosD.GetRowsAsync(client, params);
foreach (var p in productos)
{
    Console.WriteLine($"{p.TextoPrincipal}: {p.ReferenciaCliente.Label}");
}

// Variables de informe
var report = new VentasPorClienteC();
report.AddVariable("ClienteId", clienteId.ToString());
report.AddVariable("FechaDesde", "2024-01-01");

// Propiedades del informe
report.Rows           // List<RowC>
report.RowsDic        // Dictionary<Guid, RowC>
report.TotalResults   // int
report.ExistNextPage  // bool

// Verificar conexión
if (client.IsConnected) { /* OK */ }

// Connect síncrono (alternativa a ConnectAsync)
var client = DinaupClientC.Connect(endpoint, publicKey, secretKey);

// Conversión de enums
{ FacturasES.Estado, EstadoFacturaE.Borrador.INT().STR() }

// Deduplicación con SHA1
string sha1 = Dinaup.extensions.ToSHA1(contenido);

// URL firmada con parámetros
var url = await client.File_SignURLGetAsync(fileId, cachear: false);

// Propiedades de archivo subido
upload.FileData.Id        // Guid
upload.FileData.CRC       // SHA1
upload.FileData.IsImage   // bool
upload.FileData.url_1080  // Redimensionado

// Ejecutar como usuario específico
// Afecta a: autor de alta, histórico, anotaciones, filtros de sesión

// Solo userId
using (DinaupContext.WithUser(userId))
{
    client.RunWriteOperation(...);
}

// Con IP
using (DinaupContext.WithUser(userId, "192.168.1.1"))
{
    client.RunWriteOperation(...);
}

// Con IP y UserAgent
using (DinaupContext.WithUser(userId, "192.168.1.1", "Mozilla/5.0..."))
{
    client.RunWriteOperation(...);
}