Referencia del Lenguaje Heptora

Este manual te guiará a través de los conceptos fundamentales y las mejores prácticas para crear automatizaciones de negocio robustas y seguras utilizando el lenguaje propietario de Heptora.

Filosofía del Lenguaje

El lenguaje de Heptora está diseñado para la simplicidad y la seguridad. Se basa en C#, pero con una restricción clave:

Principios de Diseño

Declarativo sobre imperativo: Define qué hacer, no cómo hacerlo
Seguro por defecto: Las restricciones previenen errores comunes
Modular: Bloques reutilizables en lugar de código monolítico
Auditable: Cada acción se registra automáticamente

Funciones Disponibles

A continuación se detallan todas las funciones que puedes utilizar para construir tus automatizaciones.

Log

Funciones para interactuar con el sistema de logging.

`heptora.log.info()`

void heptora.log.info(string message)

Descripción: Envía un mensaje de log informativo. Es útil para registrar el progreso y los hitos del proceso.

Parámetros:

message (string): El mensaje informativo a registrar

Ejemplo:

heptora.log.info("Iniciando el proceso de facturación.");
heptora.log.info("Procesando cliente: " + nombreCliente);

Cuándo usar:

Al inicio de cada bloque importante
Antes y después de operaciones críticas
Para marcar hitos en el proceso

`heptora.log.result()`

void heptora.log.result(string messageType, string message)

Descripción: Registra un resultado final del proceso, que puede ser de tipo ok, ko o error.

Parámetros:

messageType (string): Tipo de resultado: "ok", "ko" o "error"
message (string): Descripción del resultado

Ejemplo:

// Resultado exitoso
heptora.log.result("ok", "El informe se ha generado correctamente.");

// Error controlado (regla de negocio)
heptora.log.result("ko", "La factura ya está marcada como pagada.");

// Error inesperado
heptora.log.result("error", "No se pudo conectar con el servidor.");

Mejores prácticas:

Usa "ok" solo cuando el registro se procese completamente
Usa "ko" para errores controlados (datos incorrectos, reglas no cumplidas)
Usa "error" para fallos técnicos inesperados
Proporciona mensajes descriptivos que expliquen el resultado

`heptora.log.force_ko()`

void heptora.log.force_ko(string message)

Descripción: Registra un KO controlado en la ejecución y detiene el procesamiento del registro actual.

Parámetros:

message (string): Descripción del error controlado

Ejemplo:

heptora.log.force_ko("El número de la factura no es correcto");
heptora.log.force_ko("Falta el campo NIF requerido");

Cuándo usar:

Cuando detectes datos faltantes o incorrectos
Cuando una regla de negocio no se cumpla
Cuando el registro no deba procesarse por razones válidas

Report

Funciones para gestionar ficheros adjuntos que se enviarán al finalizar la ejecución del proceso.

`heptora.report.add_attachment()`

void heptora.report.add_attachment(string filePath)

Descripción: Adjunta un fichero a la ejecución actual. Este fichero se enviará también adjunto en el email de resumen de ejecución.

Parámetros:

filePath (string): Ruta completa del archivo a adjuntar

Ejemplo:

// Adjuntar un reporte generado
heptora.report.add_attachment("C:\\temp\\reporte_final.xlsx");

// Adjuntar múltiples archivos
heptora.report.add_attachment("C:\\reportes\\facturas_procesadas.pdf");
heptora.report.add_attachment("C:\\reportes\\errores_encontrados.csv");

Consideraciones:

El archivo debe existir antes de llamar a esta función
Usa rutas absolutas para mayor fiabilidad
Considera el tamaño de los archivos (límites de email)
Los archivos se adjuntarán al email de notificación

Browser

Funciones para la automatización de navegadores web.

`heptora.browser.open()`

void heptora.browser.open()

Descripción: Abre una instancia persistente del navegador Chromium, preparada para la automatización.

Ejemplo:

heptora.log.info("Abriendo navegador...");
heptora.browser.open();
heptora.time.pause(2);

Características:

Utiliza Chromium para máxima compatibilidad
La instancia persiste durante toda la ejecución
Mantiene cookies y sesión entre acciones

`heptora.browser.open_private()`

void heptora.browser.open_private()

Descripción: Abre una instancia persistente del navegador Chromium en modo privado/incógnito.

Ejemplo:

// Útil cuando necesitas múltiples sesiones simultáneas
heptora.browser.open_private();

Cuándo usar:

Cuando necesites iniciar sesión con diferentes usuarios
Para evitar caché o cookies de sesiones anteriores
Para procesos que requieren aislamiento de datos

`heptora.browser.go_to()`

void heptora.browser.go_to(string url)

Descripción: Navega a una URL específica en la página activa del navegador.

Parámetros:

url (string): URL completa a la que navegar

Ejemplo:

heptora.browser.go_to("https://miportal.com/login");
heptora.time.pause(3); // Esperar a que cargue la página

heptora.browser.go_to("https://www.google.com");

Mejores prácticas:

Siempre incluye el protocolo (https:// o http://)
Añade una pausa después para permitir la carga
Verifica que la URL sea accesible desde tu red

`heptora.browser.solve_captcha()`

void heptora.browser.solve_captcha()

Descripción: Resuelve automáticamente el captcha en la página actual del navegador.

Ejemplo:

heptora.browser.go_to("https://sitio-con-captcha.com");
heptora.time.pause(2);
heptora.browser.solve_captcha();
heptora.time.pause(5); // Esperar resolución

Consideraciones:

Requiere que el captcha sea del tipo compatible
El tiempo de resolución puede variar
Añade pausas suficientes después de llamar a esta función

Excel

Funciones para leer y escribir ficheros de Excel.

`heptora.excel.load()`

List<Dictionary<string, object>> heptora.excel.load(
    string filePath,
    string sheetName,
    List<string> columns,
    bool hasHeader
)

Descripción: Carga datos de una hoja de cálculo Excel.

Parámetros:

filePath (string): Ruta completa del archivo Excel
sheetName (string): Nombre de la hoja a leer
columns (List): Lista de nombres de columnas a extraer
hasHeader (bool): true si la primera fila contiene encabezados

Retorna: Una lista de diccionarios, donde cada diccionario representa una fila.

Ejemplo completo:

heptora.log.info("Cargando datos de clientes...");

// Definir las columnas que queremos procesar
List<string> columnasAProcesar = new List<string> {
    "Nombre",
    "Email",
    "Teléfono"
};

// Cargar el archivo Excel
List<Dictionary<string, object>> datos = heptora.excel.load(
    "C:\\datos\\clientes.xlsx",
    "Hoja1",
    columnasAProcesar,
    true
);

// Guardar los datos para uso posterior
heptora.data.set("clientes", datos);

heptora.log.info("Se cargaron " + datos.Count + " registros.");

Acceder a los datos:

// Recuperar los datos guardados
List<Dictionary<string, object>> clientes =
    (List<Dictionary<string, object>>)heptora.data.get("clientes");

// Acceder al primer cliente
Dictionary<string, object> primerCliente = clientes[0];
string nombre = (string)primerCliente["Nombre"];
string email = (string)primerCliente["Email"];

heptora.log.info("Procesando: " + nombre);

Consideraciones:

El archivo debe existir y ser accesible
Los nombres de columnas deben coincidir exactamente (case-sensitive)
Si hasHeader es false, usa índices: “Column1”, “Column2”, etc.

`heptora.excel.write()`

void heptora.excel.write(
    List<Dictionary<string, object>> excelData,
    string filePath,
    string sheetName
)

Descripción: Escribe una colección de datos en un fichero Excel, creando o sobrescribiendo el archivo.

Parámetros:

excelData (List<Dictionary<string, object>>): Datos a escribir
filePath (string): Ruta donde guardar el archivo
sheetName (string): Nombre de la hoja

Ejemplo:

// Crear datos para escribir
List<Dictionary<string, object>> nuevosClientes =
    new List<Dictionary<string, object>>();

Dictionary<string, object> cliente1 = new Dictionary<string, object>();
cliente1["Nombre"] = "Juan Pérez";
cliente1["Email"] = "juan@example.com";
cliente1["Estado"] = "Procesado";
nuevosClientes.Add(cliente1);

Dictionary<string, object> cliente2 = new Dictionary<string, object>();
cliente2["Nombre"] = "María López";
cliente2["Email"] = "maria@example.com";
cliente2["Estado"] = "Pendiente";
nuevosClientes.Add(cliente2);

// Escribir al archivo
heptora.excel.write(
    nuevosClientes,
    "C:\\reportes\\nuevos_clientes.xlsx",
    "Enero"
);

heptora.log.info("Archivo Excel generado correctamente.");

Mejores prácticas:

Asegúrate de que la carpeta destino existe
Todos los diccionarios deben tener las mismas claves
Usa nombres de hoja descriptivos
Considera adjuntar el archivo con heptora.report.add_attachment()

Time

Funciones para controlar el ritmo de la ejecución.

`heptora.time.pause()`

void heptora.time.pause(double? time = null)

Descripción: Pausa la ejecución durante un número específico de segundos. Si no se especifica un tiempo, utiliza un valor predefinido en el proceso.

Parámetros:

time (double?, opcional): Segundos a pausar. Acepta decimales.

Ejemplos:

// Pausa de 3.5 segundos
heptora.time.pause(3.5);

// Pausa de 1 segundo
heptora.time.pause(1);

// Pausa con valor predefinido del proceso
heptora.time.pause();

Cuándo usar pausas:

// Después de navegar a una URL
heptora.browser.go_to("https://ejemplo.com");
heptora.time.pause(2); // Esperar carga de página

// Después de hacer clic
heptora.windows.click_by_vision(imagenBoton);
heptora.time.pause(1); // Esperar respuesta

// Después de abrir una aplicación
heptora.windows.open_app("notepad.exe");
heptora.time.pause(2); // Esperar que se abra

Recomendaciones:

Empieza con pausas generosas (2-3 segundos)
Ajusta según el rendimiento observado
En conexiones lentas, aumenta los tiempos
Documenta por qué cada pausa es necesaria

Windows

Funciones para automatizar aplicaciones de escritorio en Windows.

`heptora.windows.open_app()`

void heptora.windows.open_app(string path)

Descripción: Abre una aplicación, la maximiza y la trae al frente.

Parámetros:

path (string): Ruta o nombre del ejecutable

Ejemplos:

// Abrir aplicación por nombre
heptora.windows.open_app("notepad.exe");

// Abrir con ruta completa
heptora.windows.open_app("C:\\Program Files\\MiApp\\app.exe");

// Abrir Excel
heptora.windows.open_app("excel.exe");
heptora.time.pause(3);

Consideraciones:

La aplicación se maximiza automáticamente
Se trae al frente para interacción
Añade una pausa después para asegurar que cargue completamente

`heptora.windows.type()`

void heptora.windows.type(string text)

Descripción: Simula la escritura de texto, carácter por carácter.

Parámetros:

text (string): Texto a escribir

Ejemplos:

// Escribir texto simple
heptora.windows.type("Este es un texto automático.");

// Escribir datos de variables
string nombreCliente = (string)heptora.data.get("nombreCliente");
heptora.windows.type(nombreCliente);

// Escribir en un formulario
heptora.windows.type("usuario@ejemplo.com");
heptora.windows.press("tab"); // Moverse al siguiente campo
heptora.windows.type("contraseña123");

Mejores prácticas:

Asegúrate de que el cursor esté en el campo correcto
Usa press("tab") para navegar entre campos
Añade pausas pequeñas si la aplicación es lenta

`heptora.windows.press()`

void heptora.windows.press(params string[] keys)

Descripción: Simula la pulsación de una o más teclas.

Parámetros:

keys (params string[]): Una o más teclas a pulsar simultáneamente

Ejemplos:

// Una sola tecla
heptora.windows.press("enter");
heptora.windows.press("tab");
heptora.windows.press("escape");

// Combinaciones de teclas (atajos)
heptora.windows.press("control", "s"); // Ctrl+S (Guardar)
heptora.windows.press("control", "c"); // Ctrl+C (Copiar)
heptora.windows.press("control", "v"); // Ctrl+V (Pegar)
heptora.windows.press("alt", "f4");    // Alt+F4 (Cerrar)

// Teclas especiales
heptora.windows.press("down");   // Flecha abajo
heptora.windows.press("up");     // Flecha arriba
heptora.windows.press("left");   // Flecha izquierda
heptora.windows.press("right");  // Flecha derecha

Teclas comunes:

Modificadores: "control", "alt", "shift", "win"
Navegación: "tab", "enter", "escape", "backspace"
Flechas: "up", "down", "left", "right"
Función: "f1", "f2", … "f12"
Especiales: "home", "end", "pageup", "pagedown", "delete"

`heptora.windows.click_by_vision()`

void heptora.windows.click_by_vision(string base64Image)

Descripción: Busca una imagen (codificada en base64) en la pantalla y hace clic sobre ella.

Parámetros:

base64Image (string): Imagen codificada en base64, incluyendo el prefijo data:image/png;base64,

Ejemplo:

// Imagen del botón "Aceptar" codificada en base64
string imagenBotonAceptar = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...";

heptora.windows.click_by_vision(imagenBotonAceptar);
heptora.time.pause(1);

Mejores prácticas:

Captura imágenes pequeñas y específicas (solo el botón, no toda la ventana)
Asegúrate de que la imagen sea única en la pantalla
Captura con la resolución final donde se ejecutará
Añade una pausa después del clic
Ten en cuenta cambios de tema o resolución

`heptora.windows.alert()`

void heptora.windows.alert(string message)

Descripción: Muestra un diálogo simple con un mensaje informativo al usuario.

Parámetros:

message (string): Mensaje a mostrar

Ejemplo:

heptora.windows.alert("El proceso ha finalizado correctamente.");
heptora.windows.alert("Por favor, revisa los resultados antes de continuar.");

Cuándo usar:

Para notificar al usuario de eventos importantes
Para requerir intervención manual
Para debugging durante desarrollo

`heptora.beta.windows.press_macro()`

void heptora.beta.windows.press_macro(
    string requiredKey1,
    string requiredKey2,
    params string[] optionalKeys
)

Descripción: Simula un atajo de teclado complejo con múltiples teclas simultáneas.

Parámetros:

requiredKey1 (string): Primera tecla requerida
requiredKey2 (string): Segunda tecla requerida
optionalKeys (params string[]): Teclas adicionales opcionales

Ejemplos:

// Ctrl+Shift+Esc (Administrador de tareas)
heptora.beta.windows.press_macro("control", "shift", "escape");

// Ctrl+Alt+Del
heptora.beta.windows.press_macro("control", "alt", "delete");

// Win+Shift+S (Captura de pantalla)
heptora.beta.windows.press_macro("win", "shift", "s");

Data

Funciones para pasar datos entre bloques del proceso.

`heptora.data.set()`

void heptora.data.set(string name, object value)

Descripción: Almacena un valor con un nombre único que puede ser recuperado en bloques posteriores.

Parámetros:

name (string): Nombre único de la variable
value (object): Valor a guardar (puede ser de cualquier tipo)

Ejemplos:

// Guardar texto
heptora.data.set("nombreCliente", "Ana García");

// Guardar número
heptora.data.set("totalFacturas", 150);

// Guardar lista
List<string> productos = new List<string> { "Laptop", "Mouse", "Teclado" };
heptora.data.set("listaCompra", productos);

// Guardar diccionario
Dictionary<string, object> cliente = new Dictionary<string, object>();
cliente["nombre"] = "Juan Pérez";
cliente["email"] = "juan@example.com";
heptora.data.set("datosCliente", cliente);

// Guardar datos de Excel
List<Dictionary<string, object>> facturas = heptora.excel.load(
    "C:\\datos\\facturas.xlsx",
    "Hoja1",
    new List<string> { "Numero", "Importe" },
    true
);
heptora.data.set("facturasAProcesar", facturas);

Scope de las variables:

Las variables persisten durante toda la ejecución del proceso
Son accesibles desde cualquier bloque posterior
Se pierden al finalizar la ejecución

`heptora.data.get()`

object? heptora.data.get(string name)

Descripción: Recupera un valor guardado previamente con heptora.data.set().

Parámetros:

name (string): Nombre de la variable a recuperar

Retorna: El valor almacenado como object?. Requiere casting al tipo original.

Ejemplos:

// Recuperar texto
string nombre = (string)heptora.data.get("nombreCliente");
heptora.log.info("Cliente: " + nombre);

// Recuperar número
int total = (int)heptora.data.get("totalFacturas");
heptora.log.info("Total de facturas: " + total);

// Recuperar lista
List<string> productos = (List<string>)heptora.data.get("listaCompra");
foreach (string producto in productos) {
    heptora.log.info("Producto: " + producto);
}

// Recuperar diccionario
Dictionary<string, object> cliente =
    (Dictionary<string, object>)heptora.data.get("datosCliente");
string email = (string)cliente["email"];

// Recuperar datos de Excel
List<Dictionary<string, object>> facturas =
    (List<Dictionary<string, object>>)heptora.data.get("facturasAProcesar");

Manejo de errores:

// Verificar si existe antes de usar
object? valor = heptora.data.get("nombreVariable");
if (valor != null) {
    string texto = (string)valor;
    // Usar el valor
} else {
    heptora.log.info("La variable no existe");
}

Buenas Prácticas

1. Modulariza tu Código

Divide los procesos grandes en bloques más pequeños y reutilizables.

❌ No hacer:

// Un solo bloque gigante que hace todo
heptora.browser.open();
heptora.browser.go_to("https://miportal.com");
// ... 200 líneas de código ...

✅ Hacer:

// Bloque 1: "Login"
heptora.browser.open();
heptora.browser.go_to("https://miportal.com/login");
// ... código de login ...
heptora.data.set("sesionIniciada", true);

// Bloque 2: "Procesar Factura"
bool sesion = (bool)heptora.data.get("sesionIniciada");
// ... código de procesamiento ...

// Bloque 3: "Enviar Notificación"
// ... código de notificación ...

Ventajas:

Más fácil de entender y mantener
Reutilizable en otros procesos
Más fácil de debuggear
Permite trabajo en equipo

2. Usa Logs Informativos

Registra los pasos clave de tu automatización.

heptora.log.info("=== INICIO: Proceso de Facturación ===");

heptora.log.info("Paso 1: Cargando datos de Excel...");
List<Dictionary<string, object>> facturas = heptora.excel.load(...);
heptora.log.info("Se cargaron " + facturas.Count + " facturas");

heptora.log.info("Paso 2: Abriendo portal web...");
heptora.browser.open();

heptora.log.info("Paso 3: Iniciando sesión...");
// ... código de login ...
heptora.log.info("Sesión iniciada correctamente");

heptora.log.info("=== FIN: Proceso completado ===");

Beneficios:

Vital para depurar problemas
Ayuda a entender el flujo de ejecución
Permite rastrear el progreso del proceso
Facilita el soporte técnico

3. Gestiona Datos de Forma Centralizada

Utiliza heptora.data.set() y heptora.data.get() para comunicar bloques.

❌ Evitar:

// Escribir datos temporales en archivos
heptora.excel.write(datos, "C:\\temp\\datos_temp.xlsx", "Temp");
// En otro bloque...
List<Dictionary<string, object>> datos = heptora.excel.load("C:\\temp\\datos_temp.xlsx", ...);

✅ Preferir:

// Guardar en memoria
heptora.data.set("datosClientes", datos);

// En otro bloque
List<Dictionary<string, object>> datos =
    (List<Dictionary<string, object>>)heptora.data.get("datosClientes");

Ventajas:

Más rápido (no requiere I/O de disco)
Más limpio (no deja archivos temporales)
Más seguro (los datos se pierden al finalizar)

4. Añade Pausas Estratégicas

Usa heptora.time.pause() después de acciones que requieran tiempo de carga.

// Después de navegar
heptora.browser.go_to("https://ejemplo.com");
heptora.time.pause(3); // Esperar carga completa

// Después de hacer clic
heptora.windows.click_by_vision(botonGuardar);
heptora.time.pause(1.5); // Esperar respuesta

// Después de escribir
heptora.windows.type("texto largo...");
heptora.time.pause(0.5); // Dejar que se procese

// Después de abrir aplicación
heptora.windows.open_app("app.exe");
heptora.time.pause(4); // Esperar inicio completo

Regla general:

Navegación web: 2-3 segundos
Clicks: 1-2 segundos
Abrir aplicaciones: 3-5 segundos
Escribir texto: 0.5-1 segundo

5. Nombres de Variables Claros

Usa nombres descriptivos para las variables.

❌ No hacer:

heptora.data.set("d", datos);
heptora.data.set("x", resultado);
heptora.data.set("temp", lista);

✅ Hacer:

heptora.data.set("facturasParaProcesar", facturas);
heptora.data.set("resultadoValidacion", esValido);
heptora.data.set("listaClientesPendientes", clientes);

Convenciones recomendadas:

Usa camelCase: nombreCliente, totalFacturas
Sé específico: facturasPendientes en lugar de facturas
Indica el tipo: listaProductos, datosCliente
Indica el propósito: urlLogin, rutaArchivo

6. Manejo de Resultados

Utiliza los diferentes tipos de log para resultados.

// Cargar datos a procesar
List<Dictionary<string, object>> facturas =
    (List<Dictionary<string, object>>)heptora.data.get("facturas");

Dictionary<string, object> factura = facturas[0];
string numeroFactura = (string)factura["Numero"];
string estado = (string)factura["Estado"];

heptora.log.info("Procesando factura: " + numeroFactura);

// Verificar reglas de negocio
if (estado == "Pagada") {
    heptora.log.force_ko("La factura ya está pagada. No requiere procesamiento.");
    // La ejecución se detiene aquí para este registro
}

// Continuar con el procesamiento
try {
    // ... lógica de procesamiento ...

    heptora.log.result("ok", "Factura " + numeroFactura + " procesada correctamente");
} catch (Exception ex) {
    heptora.log.result("error", "Error inesperado: " + ex.Message);
}

7. Documentación en el Código

Añade comentarios explicativos.

// ==============================================
// BLOQUE: Login en Portal FACe
// Descripción: Inicia sesión en el portal de
//              facturación electrónica
// ==============================================

heptora.log.info("Iniciando login en FACe...");

// Obtener credenciales desde secretos
string usuario = (string)heptora.data.get("face_usuario");
string password = (string)heptora.data.get("face_password");

// Navegar a la página de login
heptora.browser.go_to("https://face.gob.es/login");
heptora.time.pause(3);

// Resolver captcha si aparece
heptora.browser.solve_captcha();
heptora.time.pause(2);

// Introducir credenciales
heptora.windows.type(usuario);
heptora.windows.press("tab");
heptora.windows.type(password);
heptora.windows.press("enter");
heptora.time.pause(4); // Esperar redirección

heptora.log.info("Login completado correctamente");

Ejemplo Completo: Proceso de Facturación

Este ejemplo muestra un proceso completo dividido en bloques modulares.

Bloque 1: Cargar Datos

heptora.log.info("=== BLOQUE 1: Cargar Datos ===");

// Definir columnas a procesar
List<string> columnas = new List<string> {
    "NumeroFactura",
    "Cliente",
    "Importe",
    "Estado"
};

// Cargar archivo Excel
heptora.log.info("Cargando facturas desde Excel...");
List<Dictionary<string, object>> facturas = heptora.excel.load(
    "C:\\datos\\facturas_enero.xlsx",
    "Facturas",
    columnas,
    true
);

// Guardar para otros bloques
heptora.data.set("facturasAProcesar", facturas);
heptora.data.set("indiceActual", 0);

heptora.log.info("Total de facturas cargadas: " + facturas.Count);

heptora.log.info("=== BLOQUE 2: Login en Portal ===");

// Abrir navegador
heptora.browser.open();
heptora.time.pause(2);

// Navegar a login
heptora.browser.go_to("https://portal-facturas.com/login");
heptora.time.pause(3);

// Introducir credenciales
heptora.windows.type("usuario@empresa.com");
heptora.windows.press("tab");
heptora.windows.type("MiContraseña123");
heptora.windows.press("enter");
heptora.time.pause(4);

heptora.log.info("Login completado");
heptora.data.set("sesionIniciada", true);

Bloque 3: Procesar Factura Individual

heptora.log.info("=== BLOQUE 3: Procesar Factura ===");

// Recuperar datos
List<Dictionary<string, object>> facturas =
    (List<Dictionary<string, object>>)heptora.data.get("facturasAProcesar");
int indice = (int)heptora.data.get("indiceActual");

// Obtener factura actual
Dictionary<string, object> factura = facturas[indice];
string numero = (string)factura["NumeroFactura"];
string estado = (string)factura["Estado"];
double importe = (double)factura["Importe"];

heptora.log.info("Procesando factura: " + numero);

// Validar estado
if (estado == "Pagada") {
    heptora.log.force_ko("Factura ya pagada. No requiere procesamiento.");
}

// Navegar a formulario
heptora.browser.go_to("https://portal-facturas.com/nueva-factura");
heptora.time.pause(2);

// Rellenar formulario
heptora.windows.type(numero);
heptora.windows.press("tab");
heptora.windows.type(importe.ToString());
heptora.windows.press("tab");
// ... más campos ...

// Guardar
heptora.windows.press("control", "s");
heptora.time.pause(2);

heptora.log.result("ok", "Factura " + numero + " procesada correctamente");

// Incrementar índice para siguiente iteración
heptora.data.set("indiceActual", indice + 1);

Bloque 4: Generar Reporte

heptora.log.info("=== BLOQUE 4: Generar Reporte ===");

// Crear reporte con resultados
List<Dictionary<string, object>> reporte = new List<Dictionary<string, object>>();

// ... construir reporte ...

// Guardar Excel
string rutaReporte = "C:\\reportes\\reporte_" + DateTime.Now.ToString("yyyyMMdd") + ".xlsx";
heptora.excel.write(reporte, rutaReporte, "Resultados");

// Adjuntar al email
heptora.report.add_attachment(rutaReporte);

heptora.log.info("Reporte generado: " + rutaReporte);

Preguntas Frecuentes

¿Por qué no puedo usar `if` o `for`?

El lenguaje Heptora está diseñado para ser declarativo y seguro. Las estructuras de control tradicionales se manejan a nivel de la plataforma mediante la configuración de bloques y flujos. Esto previene errores comunes y hace que el código sea más auditable.

¿Cómo itero sobre una lista sin `foreach`?

Usa bloques iteradores configurados en la plataforma. Cada bloque se ejecutará automáticamente para cada elemento de la lista.

¿Puedo llamar APIs externas?

Actualmente el lenguaje Heptora no incluye funciones HTTP directas. Para integraciones API, contacta con soporte para evaluar opciones de bloques personalizados.

¿Qué hago si necesito lógica condicional compleja?

Utiliza múltiples bloques con condiciones configuradas en la plataforma, o contacta con soporte para evaluar si tu caso requiere un bloque Python personalizado.

¿Los datos se comparten entre diferentes ejecuciones?

No. Las variables guardadas con heptora.data.set() solo existen durante la ejecución actual y se pierden al finalizar.

¿Necesitas más ayuda?

Si esta guía no resolvió tu problema o encontraste algún error en la documentación:

Soporte técnico: help@heptora.com
Describe claramente el problema que encontraste
Incluye capturas de pantalla si es posible
Indica qué pasos de la documentación seguiste

Nuestro equipo de soporte te ayudará a resolver cualquier problema.

Recursos Relacionados

Resultados de Ejecución - Entiende OK, KO y ERROR
Gestión de Secretos - Almacena credenciales de forma segura
Instalación del Robot - Configura tu entorno

Referencia del Lenguaje Heptora

Filosofía del Lenguaje

Principios de Diseño

Funciones Disponibles

Log

heptora.log.info()

heptora.log.result()

heptora.log.force_ko()

Report

heptora.report.add_attachment()

Browser

heptora.browser.open()

heptora.browser.open_private()

heptora.browser.go_to()

heptora.browser.solve_captcha()

Excel

heptora.excel.load()

heptora.excel.write()

Time

heptora.time.pause()

Windows

heptora.windows.open_app()

heptora.windows.type()

heptora.windows.press()

heptora.windows.click_by_vision()

heptora.windows.alert()

heptora.beta.windows.press_macro()

Data

heptora.data.set()

heptora.data.get()

Buenas Prácticas

1. Modulariza tu Código

2. Usa Logs Informativos

3. Gestiona Datos de Forma Centralizada

4. Añade Pausas Estratégicas

5. Nombres de Variables Claros

6. Manejo de Resultados

7. Documentación en el Código

Ejemplo Completo: Proceso de Facturación

Bloque 1: Cargar Datos

Bloque 2: Login

Bloque 3: Procesar Factura Individual

Bloque 4: Generar Reporte

Preguntas Frecuentes

¿Por qué no puedo usar if o for?

¿Cómo itero sobre una lista sin foreach?

¿Puedo llamar APIs externas?

¿Qué hago si necesito lógica condicional compleja?

¿Los datos se comparten entre diferentes ejecuciones?

¿Necesitas más ayuda?

Recursos Relacionados

`heptora.log.info()`

`heptora.log.result()`

`heptora.log.force_ko()`

`heptora.report.add_attachment()`

`heptora.browser.open()`

`heptora.browser.open_private()`

`heptora.browser.go_to()`

`heptora.browser.solve_captcha()`

`heptora.excel.load()`

`heptora.excel.write()`

`heptora.time.pause()`

`heptora.windows.open_app()`

`heptora.windows.type()`

`heptora.windows.press()`

`heptora.windows.click_by_vision()`

`heptora.windows.alert()`

`heptora.beta.windows.press_macro()`

`heptora.data.set()`

`heptora.data.get()`

¿Por qué no puedo usar `if` o `for`?

¿Cómo itero sobre una lista sin `foreach`?