DENODO ITPILOT 4.0 MANUAL DEL ENTORNO DE...

DENODO ITPILOT 4.0 MANUAL DEL ENTORNO DE GENERACIÓN

NOTA Este documento es confidencial y propiedad de denodo technologies (en adelante denodo). Ninguna de las partes del documento puede ser copiada, fotografiada, fotocopiada, transmitida electrónicamente, almacenada en un sistema de gestión documental o reproducida mediante cualquier otro mecanismo sin la autorización previa o por escrito de denodo.

copyright © 2007 Queda prohibida la reproducción total o parcial de este documento sin la autorización por escrito de denodo technologies

ITPilot 4.0 Manual del Entorno de Generación

ÍNDICE

PREFACIO........................................................................................................................................................................... I ALCANCE DEL DOCUMENTO ................................................................................................................................... I QUIÉN DEBERÍA USAR ESTE DOCUMENTO.......................................................................................................... I RESUMEN DE CONTENIDOS.................................................................................................................................... I

1 INTRODUCCIÓN ..................................................................................................................................... 1 1.1 PRESENTACIÓN ..................................................................................................................................... 1 1.2 DESARROLLO DE PROGRAMAS ENVOLTORIO BASADO EN COMPONENTES........................... 1

2 INSTALACIÓN Y CONFIGURACIÓN .................................................................................................... 3 2.1 INSTALACIÓN......................................................................................................................................... 3

2.1.1 Requisitos Hardware................................................................................................................................. 3 2.1.2 Requisitos Software.................................................................................................................................. 3 2.1.3 Instalación................................................................................................................................................. 3 2.1.4 Tareas de Post-Instalación........................................................................................................................ 4

2.1.4.1 Instalación de la Licencia de Utilización de Denodo ITPilot....................................................... 4 2.1.4.2 Comprobación ............................................................................................................................. 4 2.1.4.3 Desinstalación del Software....................................................................................................... 5

2.1.5 Introducción a las herramientas ............................................................................................................... 5

3 MANUAL DE GENERACIÓN DE ESPECIFICACIONES....................................................................... 8 3.1 INTRODUCCIÓN ..................................................................................................................................... 8

PARTE I.............................................................................................................................................................................. 9 3.2 PRESENTACIÓN DEL EJEMPLO .......................................................................................................... 9 3.3 ARRANQUE DE LA HERRAMIENTA DE GENERACIÓN DE ESPECIFICACIONES ....................... 10 3.4 CREACIÓN DE UN WRAPPER ............................................................................................................ 11 3.5 COMPONENTES EN ITPILOT.............................................................................................................. 13

3.5.1 Parámetros de Entrada y Salida.............................................................................................................. 15 3.6 INICIALIZACIÓN DEL PROCESO ........................................................................................................ 15

3.6.1 Utilización del Explorador del Catálogo.................................................................................................. 17 3.7 AUTOMATIZACIÓN DE LA NAVEGACIÓN WEB ............................................................................. 18

3.7.1 Creación del Componente en el Área de Trabajo................................................................................... 18 3.7.2 Configuración del Componente............................................................................................................... 19 3.7.3 Configuración de Datos de Salida y Tratamiento de Errores ................................................................. 25

3.8 DEFINICIÓN DE LA ESTRUCTURA DE LOS DATOS A EXTRAER................................................... 26 3.8.1 Generación de Especificación de Extracción de Datos........................................................................... 28 3.8.2 Niveles Anidados en la estructura del componente............................................................................... 31

3.9 ASIGNACIÓN DE EJEMPLOS DE LOS RESULTADOS..................................................................... 31 3.10 GENERACIÓN DE PATRONES ............................................................................................................ 34 3.11 GENERACIÓN DE LA ESPECIFICACIÓN............................................................................................ 37 3.12 ITERACIÓN DE RESULTADOS OBTENIDOS..................................................................................... 38

3.12.1 Utilización del componente Iterator........................................................................................................ 38 3.12.2 Gestión de los registros individuales...................................................................................................... 39

3.12.2.1 Edición de Nuevos Campos de Registro ................................................................................... 41 3.12.3 Devolución de resultados........................................................................................................................ 44

3.13 OPCIONES AVANZADAS DEL WRAPPER: SECUENCIA DE VUELTA ATRÁS Y LOCALE .......... 46 3.13.1 Secuencia de Vuelta Atrás...................................................................................................................... 47


3.13.2 Localización............................................................................................................................................. 48 3.14 GENERACIÓN DEL WRAPPER, PRUEBAS Y EXPORTACIÓN........................................................ 50

3.14.1 Generación del Wrapper......................................................................................................................... 50 3.14.2 Ejecución del Wrapper............................................................................................................................ 51 3.14.3 Exportación del Wrapper ........................................................................................................................ 53

3.14.3.1 Despliegue en el servidor de ejecución.................................................................................... 53 3.14.3.2 Generación de VQL para posterior carga.................................................................................. 54

PARTE II .......................................................................................................................................................................... 56 3.15 EXTRACCIÓN DE DATOS MULTIPAGINADOS ................................................................................ 56 3.16 ACCESO A PÁGINAS DE DETALLE.................................................................................................... 59

3.16.1 Introducción............................................................................................................................................. 59 3.16.2 Modificación de Campos en el componente Extractor: campo DATE .................................................... 59

3.16.2.1 Asignación de Valores de Atributos de Marcas ....................................................................... 60 3.16.3 Acceso a la Página de Detalle desde la Página Principal ...................................................................... 62 3.16.4 Secuencia de Vuelta en los Componentes de Navegación .................................................................... 66 3.16.5 Prueba Individual del Componente Record Sequence............................................................................ 66 3.16.6 Extracción de información de la página de detalle ................................................................................ 68 3.16.7 Generación de la Especificación de acceso a la Página de Detalle....................................................... 69 3.16.8 Iteración sobre las estructuras de las páginas de detalle y creación del registro de salida................. 70

3.17 JUEGOS DE MARCAS Y ESCÁNERS................................................................................................. 72 3.18 PATRONES DE DELIMITACIÓN FROM/UNTIL................................................................................. 74 3.19 GENERACIÓN MANUAL DE LAS ESPECIFICACIONES DE EXTRACCIÓN DE DATOS............... 76 3.20 EXPORTACIÓN DE UN FLUJO COMO UN COMPONENTE A MEDIDA ........................................ 77 3.21 COMPROBACIÓN DE MANTENIMIENTO DEL PROGRAMA ENVOLTORIO................................ 80

4 MANUAL DE GENERACIÓN DE SECUENCIAS ................................................................................ 82 4.1 INTRODUCCIÓN ................................................................................................................................... 82 4.2 DESCRIPCIÓN DE LA INTERFAZ DEL GENERADOR DE SECUENCIAS DE NAVEGACIÓN ....... 82 4.3 PASOS PARA LA GENERACIÓN DE UNA SECUENCIA DE NAVEGACIÓN ................................. 84

4.3.1 Probando Secuencias de Navegación en Sistemas con Autenticación y Mantenimiento de Sesión Basado en Cookies...................................................................................................................... 85

4.4 EL BOTÓN SELECTFRAME.................................................................................................................. 86 4.5 EL BOTÓN TRANSPOSETABLE.......................................................................................................... 86 4.6 EL BOTÓN SELECTANCHOR............................................................................................................... 87 4.7 CONFIGURANDO Y UTILIZANDO DOMINIOS ................................................................................. 87

4.7.1 Creación de Dominios ............................................................................................................................. 87 4.7.2 Uso de Dominios ..................................................................................................................................... 88

4.8 PROPIEDADES DE LA BARRA DE NAVEGACIÓN ........................................................................... 89 4.8.1 Generando Secuencias utilizando un Proxy Autenticado ....................................................................... 89 4.8.2 Criterio de elección de comandos NSEQL .............................................................................................. 90 4.8.3 Elección de Tipo de Secuencia de Navegación ...................................................................................... 91

4.9 SELECCIÓN DE CONVERSORES DE PDF Y HTML ........................................................................... 92

5 ANEXO A: FUNCIONES ITPILOT ........................................................................................................ 94 5.1 FUNCIONES ARITMÉTICAS................................................................................................................ 94 5.2 FUNCIONES DE MANEJO DE TEXTO................................................................................................ 95 5.3 FUNCIONES DE MANEJO DE LISTAS............................................................................................... 96 5.4 FUNCIONES DE MANEJO DE FECHAS ............................................................................................. 96 5.5 FUNCIONES DE TRATAMIENTO DE URLS ....................................................................................... 97 5.6 FUNCIONES DE TRATAMIENTO DE PÁGINAS ............................................................................... 97


6 ANEXO B: CATÁLOGO DE COMPONENTES..................................................................................... 98

6.1 ADD RECORD TO LIST ......................................................................................................................... 98 6.1.1 Descripción.............................................................................................................................................. 98 6.1.2 Parámetros de Entrada............................................................................................................................ 98 6.1.3 Valores de Salida .................................................................................................................................... 98

6.2 CONDITION ........................................................................................................................................... 99 6.2.1 Descripción.............................................................................................................................................. 99 6.2.2 Parámetros de Entrada............................................................................................................................ 99 6.2.3 Valores de Salida .................................................................................................................................... 99 6.2.4 Ejemplo.................................................................................................................................................... 99 6.2.5 Utilización del Editor de Condiciones ................................................................................................... 100

6.2.5.1 Creación de valores para las condiciones .............................................................................. 101 6.2.5.2 Creación de condiciones simples............................................................................................ 102 6.2.5.3 Creación de condiciones booleanas ....................................................................................... 102

6.3 CREATE LIST ....................................................................................................................................... 103 6.3.1 Descripción............................................................................................................................................ 103 6.3.2 Parámetros de Entrada.......................................................................................................................... 103 6.3.3 Valores de Salida .................................................................................................................................. 103

6.4 DIFF....................................................................................................................................................... 104 6.4.1 Descripción............................................................................................................................................ 104 6.4.2 Parámetros de Entrada.......................................................................................................................... 104 6.4.3 Valores de Salida .................................................................................................................................. 104 6.4.4 Utilización.............................................................................................................................................. 104

6.5 EXECUTE JAVASCRIPT ..................................................................................................................... 106 6.5.1 Descripción............................................................................................................................................ 106 6.5.2 Parámetros de Entrada.......................................................................................................................... 106 6.5.3 Valores de Salida .................................................................................................................................. 106

6.6 EXPRESSION....................................................................................................................................... 107 6.6.1 Descripción............................................................................................................................................ 107 6.6.2 Parámetros de Entrada.......................................................................................................................... 107 6.6.3 Valores de Salida .................................................................................................................................. 107 6.6.4 Ejemplo.................................................................................................................................................. 107 6.6.5 Utilización del Editor de Expresiones.................................................................................................... 107

6.7 EXTRACTOR ........................................................................................................................................ 110 6.7.1 Descripción............................................................................................................................................ 110 6.7.2 Parámetros de Entrada.......................................................................................................................... 110 6.7.3 Valores de Salida .................................................................................................................................. 110 6.7.4 Detalles del componente ...................................................................................................................... 110

6.8 FETCH................................................................................................................................................... 111 6.8.1 Descripción............................................................................................................................................ 111 6.8.2 Parámetros de Entrada.......................................................................................................................... 111 6.8.3 Valores de Salida .................................................................................................................................. 111

6.9 FILTER .................................................................................................................................................. 112 6.9.1 Descripción............................................................................................................................................ 112 6.9.2 Parámetros de Entrada.......................................................................................................................... 112 6.9.3 Valores de Salida .................................................................................................................................. 112 6.9.4 Ejemplo.................................................................................................................................................. 112

6.10 FORM ITERATOR ................................................................................................................................ 116 6.10.1 Descripción............................................................................................................................................ 116 6.10.2 Parámetros de Entrada.......................................................................................................................... 116 6.10.3 Valores de Salida .................................................................................................................................. 116 6.10.4 Ejemplo.................................................................................................................................................. 116

6.11 ITERATOR ............................................................................................................................................ 121 6.11.1 Descripción............................................................................................................................................ 121 6.11.2 Parámetros de Entrada.......................................................................................................................... 121


6.11.3 Valores de Salida .................................................................................................................................. 121 6.11.4 Detalles del componente ...................................................................................................................... 121

6.12 JDBCEXTRACTOR .............................................................................................................................. 122 6.12.1 Descripción............................................................................................................................................ 122 6.12.2 Parámetros de Entrada.......................................................................................................................... 122 6.12.3 Valores de Salida .................................................................................................................................. 122 6.12.4 Ejemplo.................................................................................................................................................. 122

6.13 LOOP..................................................................................................................................................... 125 6.13.1 Descripción............................................................................................................................................ 125 6.13.2 Parámetros de Entrada.......................................................................................................................... 125 6.13.3 Valores de Salida .................................................................................................................................. 125 6.13.4 Ejemplo.................................................................................................................................................. 125

6.14 NEXT INTERVAL ITERATOR.............................................................................................................. 127 6.14.1 Descripción............................................................................................................................................ 127 6.14.2 Parámetros de Entrada.......................................................................................................................... 127 6.14.3 Valores de Salida .................................................................................................................................. 127 6.14.4 Detalles del componente ...................................................................................................................... 127

6.15 OUTPUT ............................................................................................................................................... 128 6.15.1 Descripción............................................................................................................................................ 128 6.15.2 Parámetros de Entrada.......................................................................................................................... 128 6.15.3 Valores de Salida .................................................................................................................................. 128 6.15.4 Detalles del componente ...................................................................................................................... 128

6.16 RECORD CONSTRUCTOR .................................................................................................................. 129 6.16.1 Descripción............................................................................................................................................ 129 6.16.2 Parámetros de Entrada.......................................................................................................................... 129 6.16.3 Valores de Salida .................................................................................................................................. 129 6.16.4 Detalles del componente ...................................................................................................................... 129

6.17 RECORD SEQUENCE .......................................................................................................................... 130 6.17.1 Descripción............................................................................................................................................ 130 6.17.2 Parámetros de Entrada.......................................................................................................................... 130 6.17.3 Valores de Salida .................................................................................................................................. 130 6.17.4 Detalles del componente ...................................................................................................................... 130

6.18 REPEAT ................................................................................................................................................ 131 6.18.1 Descripción............................................................................................................................................ 131 6.18.2 Parámetros de Entrada.......................................................................................................................... 131 6.18.3 Valores de Salida .................................................................................................................................. 131 6.18.4 Ejemplo.................................................................................................................................................. 131

6.19 SCRIPT ................................................................................................................................................. 132 6.19.1 Descripción............................................................................................................................................ 132 6.19.2 Parámetros de Entrada.......................................................................................................................... 132 6.19.3 Valores de Salida .................................................................................................................................. 132

6.20 SEQUENCE .......................................................................................................................................... 133 6.20.1 Descripción............................................................................................................................................ 133 6.20.2 Parámetros de Entrada.......................................................................................................................... 133 6.20.3 Valores de Salida .................................................................................................................................. 133 6.20.4 Detalles del componente ...................................................................................................................... 133

6.21 STORE FILE.......................................................................................................................................... 134 6.21.1 Descripción............................................................................................................................................ 134 6.21.2 Parámetros de Entrada.......................................................................................................................... 134 6.21.3 Valores de Salida .................................................................................................................................. 134 6.21.4 Ejemplo.................................................................................................................................................. 134

BIBLIOGRAFÍA ............................................................................................................................................................. 136


ÍNDICE DE FIGURAS Figura 1 Pantalla inicial de instalación de ITPilot................................................................................................... 4 Figura 2 Herramienta de Generación de Especificaciones. Áreas ......................................................................... 6 Figura 3 Herramienta de Generación de Secuencias de Navegación .................................................................... 6 Figura 4 Página de entrada de Denodo WebMail .................................................................................................. 9 Figura 5 Primera pantalla de mensajes ................................................................................................................ 10 Figura 6 Contenido de un mensaje ....................................................................................................................... 10 Figura 7 Creación de Proyectos............................................................................................................................. 11 Figura 8 Nuevo Proyecto Creado........................................................................................................................... 12 Figura 9 Creación de un nuevo proceso................................................................................................................ 13 Figura 10 Diálogo de carga exitosa del proceso..................................................................................................... 13 Figura 11 Área de Trabajo para Generación de Procesos ...................................................................................... 14 Figura 12 Selección del Componente de Inicialización .......................................................................................... 15 Figura 13 Editor de Inicialización ............................................................................................................................ 16 Figura 14 Pestaña “Wizard” del área de configuración de componentes con el registro de inicialización ya

creado 17 Figura 15 Explorador del Catálogo.......................................................................................................................... 18 Figura 16 Relacionando componentes entre sí....................................................................................................... 19 Figura 17 Barra de Tareas de Denodo .................................................................................................................... 20 Figura 18 URL de inicio ........................................................................................................................................... 20 Figura 19 Página de Inicio....................................................................................................................................... 21 Figura 20 Editor de Dominios.................................................................................................................................. 22 Figura 21 Selección de Dominio de Búsqueda ....................................................................................................... 22 Figura 22 Barra de Datos de Dominio de Búsqueda............................................................................................... 23 Figura 23 Operación de Drag&Drop sobre la Página Principal............................................................................... 23 Figura 24 Editor de Secuencias con Secuencia Cargada........................................................................................ 24 Figura 25 Resultado del Editor de Secuencias ....................................................................................................... 25 Figura 26 Utilización de un Componente de Extracción ......................................................................................... 27 Figura 27 Página de Entrada del Componente Extractor ........................................................................................ 27 Figura 28 Generador de Especificaciones............................................................................................................... 28 Figura 29 Estructura de Extracción ......................................................................................................................... 30 Figura 30 Tienda Electrónica de Música................................................................................................................. 31 Figura 31 Estructura de Tienda de Música ............................................................................................................. 31 Figura 32 Pestaña de Ejemplos de Resultados....................................................................................................... 32 Figura 33 Asignación de Valor a un Elemento........................................................................................................ 33 Figura 34 Asignación de Varios Ejemplos............................................................................................................... 34 Figura 35 Ventana de Generación de Patrones ...................................................................................................... 35 Figura 36 Generación de un Programa DEXTL ........................................................................................................ 36 Figura 37 Prueba de Ejecución de la Especificación............................................................................................... 37 Figura 38 Pestaña de Generación de Especificaciones .......................................................................................... 38 Figura 39 Utilización del Componente de Iteración................................................................................................ 39 Figura 40 Utilización del componente Record Constructor..................................................................................... 40 Figura 41 Editor de Registros.................................................................................................................................. 41 Figura 42 Editor de nuevos campos de registro...................................................................................................... 42 Figura 43 Creación de un atributo derivado a partir de la función GETDAY .......................................................... 43 Figura 44 Resultado Final del Registro de Salida................................................................................................... 44 Figura 45 Utilización del Componente de Salida.................................................................................................... 45 Figura 46 Proceso Completo de la primera parte del ejemplo ............................................................................... 46 Figura 47 Opciones del Wrapper ............................................................................................................................ 47 Figura 48 Código JavaScript del Wrapper generado.............................................................................................. 51 Figura 49 Herramienta de Pruebas del Wrapper .................................................................................................... 52 Figura 50 Resultados devueltos por el Wrapper .................................................................................................... 53 Figura 51 Despliegue de un wrapper en el servidor de ejecución de ITPilot ......................................................... 54 Figura 52 Almacenamiento del wrapper en sistema de ficheros local .................................................................. 55


Figura 53 Utilización del componente Next Interval Iterator para navegar por más páginas de resultados......... 57 Figura 54 Página de Resultados de Correo............................................................................................................. 58 Figura 55 Asignación de ejemplos en la nueva estructura del componente Extractor .......................................... 60 Figura 56 Pestaña de Asignación de Valores de Atributos de Marcas .................................................................. 61 Figura 57 Utilización del componente Record Sequence ....................................................................................... 63 Figura 58 Editor de Secuencias de Registro ........................................................................................................... 64 Figura 59 Editor de Comandos del componente Record Sequence........................................................................ 65 Figura 60 Pestaña Avanzada para definición de Secuencia de Vuelta Atrás......................................................... 66 Figura 61 Configuración de Secuencias del componente Record Sequence ......................................................... 67 Figura 62 Ventana de prueba del componente Record Sequence.......................................................................... 68 Figura 63 Utilización del componente Extractor para la obtención de información de páginas de detalle........... 69 Figura 64 Adición de Iterador de datos procedentes de las páginas de detalle.................................................... 70 Figura 65 Configuración de valores de entrada del componente Record Constructor........................................... 71 Figura 66 Registro de Salida del componente Record Constructor........................................................................ 71 Figura 67 Herramienta de Generación de Juegos de Marca y Escáners ............................................................... 72 Figura 68 Escáner y Juego de Marcas Generado ................................................................................................... 74 Figura 69 Resultados Tabulados de una Tienda de Libros ..................................................................................... 75 Figura 70 Delimitando el Comienzo de la Extracción ............................................................................................. 75 Figura 71 Pestaña de Utilidades ............................................................................................................................. 76 Figura 72 Selección de Datos a Extraer.................................................................................................................. 76 Figura 73 Obtención de Información de Tokens ..................................................................................................... 77 Figura 74 Creación de un componente a medida ................................................................................................... 78 Figura 75 Asignación de nombre de componente a medida .................................................................................. 79 Figura 76 Selección del tipo de salida del componente a medida......................................................................... 79 Figura 77 Ejemplo de utilización de un componente a medida .............................................................................. 80 Figura 78 Área de Configuración de Componentes ................................................................................................ 81 Figura 79 Diálogo de comprobación de mantenimiento de wrappers.................................................................... 81 Figura 80 Barra de Tareas del Generador de Secuencias de Navegación ............................................................. 83 Figura 81 Selección Inicial de URL.......................................................................................................................... 83 Figura 82 Utilización del Botón “Transpose Table”................................................................................................ 86 Figura 83 Resultado de la Ejecución de la Transposición de Tablas...................................................................... 87 Figura 84 Selección de tipo de transformación en el comando Select Anchor...................................................... 87 Figura 85 Definición del Dominio BOOK ................................................................................................................. 88 Figura 86 Barra de Tareas con un Ejemplo Seleccionado ...................................................................................... 88 Figura 87 Asignando Valores de Ejemplos a Campos de Formularios ................................................................... 89 Figura 88 Pantalla de Opciones de Proxy................................................................................................................ 90 Figura 89 Pantalla de Opciones de NSEQL ............................................................................................................. 91 Figura 90 Pantalla de Opciones de Lenguaje de Secuencias de Navegación........................................................ 92 Figura 91 Utilización del componente Condition .................................................................................................. 100 Figura 92 Editor de Condiciones ........................................................................................................................... 101 Figura 93 Editor de Condiciones ........................................................................................................................... 105 Figura 94 Componente Expresión de inicialización de variable ........................................................................... 107 Figura 95 Utilización de un componente Expression como contador de páginas ................................................ 107 Figura 96 Creación de un valor constante en el Editor de Expresiones ............................................................... 108 Figura 97 Creación de un valor constante en el Editor de Expresiones ............................................................... 109 Figura 98 Utilización del componente Filter ......................................................................................................... 112 Figura 99 Creación de las constantes de tipo cadena.......................................................................................... 113 Figura 100 Creación de la fecha de comparación................................................................................................... 114 Figura 101 Creación de la condición de filtrado ..................................................................................................... 115 Figura 102 Generación de la condición resultado .................................................................................................. 115 Figura 103 Utilización del componente FormIterator.............................................................................................. 117 Figura 104 Marcado de parte del formulario .......................................................................................................... 117 Figura 105 Importación de información del formulario .......................................................................................... 118 Figura 106 Selección de valores en los campos del formulario ............................................................................. 118 Figura 107 Selección de valores en los campos del formulario ............................................................................. 119 Figura 108 Pestaña de configuración del componente Form Iterator..................................................................... 120


Figura 109 Proceso de acceso a información en una base de datos relacional..................................................... 123 Figura 110 Obtención de estructura del registro de salida en el componente JDBCExtractor.............................. 124 Figura 111 Ejemplo de funcionamiento del componente Loop............................................................................... 126 Figura 112 Parámetros de entrada del componente StoreFile ............................................................................... 134 Figura 113 Ejemplo de funcionamiento del componente Store File....................................................................... 135


ÍNDICE DE TABLAS Tabla 1 Lista de Palabras Reservadas ................................................................................................................. 29 Tabla 2 Caracteres reservados para el formato de una fecha ............................................................................ 50


PREFACIO

ALCANCE DEL DOCUMENTO

Este documento explica como generar visualmente programas envoltorio (wrappers) utilizando Denodo ITPilot.

QUIÉN DEBERÍA USAR ESTE DOCUMENTO

Este documento está dirigido a desarrolladores y administradores que pretendan realizar alguna de las siguientes tareas: generar programas envoltorio HTML para su uso dentro de Denodo Virtual DataPort, y/o utilizar Denodo ITPilot para tareas de automatización o extracción de datos de la web.

RESUMEN DE CONTENIDOS

Más concretamente, en este documento se describen ambas herramientas de generación:

• Generador de Especificaciones:

o El envoltorio será modelado como un flujo de proceso compuesto de diversos componentes. Cada componente realiza una función determinada sobre un conjunto de entradas y produce un conjunto de salidas. Este documento describe la estructura de los flujos y los componentes que los forman.

o Se describe, mediante una serie de ejemplos, el funcionamiento de la herramienta de creación de flujos y cómo utilizarla para generar envoltorios sobre fuentes de diferentes niveles de dificultad.

o Se explica cómo exportar el envoltorio recién generado al entorno de ejecución de ITPilot.

• Generador de Secuencias de Navegación:

o Se describen los objetivos principales de la generación visual de Secuencias de Navegación.

o Se ofrece una visión de su arquitectura y procedimientos de instalación.

o Se describe cómo utilizarlo para generar visualmente secuencias de navegación de cualquier grado de complejidad.

Prefacio i


1 INTRODUCCIÓN

1.1 PRESENTACIÓN

Este documento presenta las herramientas gráficas de Denodo Technologies que permiten extraer visualmente información de fuentes web. También pueden utilizarse para extraer información de documentos en formato Word y/o PDF. En concreto, existen dos herramientas complementarias: o La herramienta de Generación de Especificaciones, que permite crear “wrappers” o envoltorios web de una

manera fácil e intuitiva a usuarios no técnicos. Esta herramienta genera automáticamente programas envoltorio en JavaScript [JSDENODO], con la comodidad y ahorro de tiempo que ello conlleva.

o La herramienta de Generación de Secuencias de Navegación, utilizada para la definición de secuencias de navegación complejas sobre fuentes web (p.e. la obtención de listas de resultados de una fuente web que requiere de autentificación previa, navegación a través de diferentes páginas, y rellenado de un formulario de consulta). Esta herramienta genera de manera automática programas NSEQL ([NSEQL]), que podrán ser utilizados en los envoltorios creados con el Generador de Especificaciones.

1.2 DESARROLLO DE PROGRAMAS ENVOLTORIO BASADO EN COMPONENTES

La mayor parte de la información que se obtiene de fuentes WWW (Worldwide Web) se expone utilizando el lenguaje de etiquetas HTML, centrado en la visualización de datos por parte de seres humanos. Sin embargo, el crecimiento constante de la web hace imposible acceder a sus datos si no es de manera mecánica. Muchas de las fuentes web generan sus registros también de forma automática –con repositorios de datos cuyo acceso se realiza a través de frontales HTML-. Denodo ITPilot basa el desarrollo de los “wrappers”, programas envoltorio encargados de automatizar el proceso de navegación y extracción de información de fuentes web, en la utilización y configuración de componentes - cada uno de los cuáles cumple una tarea específica - y de la relación entre ellos, de manera que el comportamiento de cada uno de ellos depende de los datos de entrada que reciba. Los componentes de Denodo permiten virtualmente cualquier operación sobre fuentes web basadas en HTML, así como cierta capacidad de extracción de información de ficheros Microsoft Word [WORD] y Adobe PDF [PDF]. Gráficamente, el usuario podrá seleccionar de una paleta los componentes requeridos para un proceso concreto de automatización web. Cada componente podrá ligarse con otros, a través de relaciones de entrada y salida de información. De esta manera, el resultado de un componente podrá servir de entrada de información para otros. Por ejemplo, el componente de extracción (el “extractor”) devolverá una lista de resultados, que podrá servir de entrada a un componente de iteración (el “iterator”); este componente, a su vez, devolverá en cada iteración uno de los elementos que componen la lista. Existen también otros componentes de bifurcación, de transformación y de salida. Una descripción completa de cada uno de los componentes, y que sirve de guía de referencia, puede encontrarse en el apartado 6. A partir de esta descripción gráfica de componentes, Denodo ITPilot genera un programa envoltorio en JavaScript [JSDENODO]. Este programa contiene la declaración de cada uno de los componentes, así como sus relaciones. Los componentes de ITPilot relacionados con secuencias de navegación y tareas de extracción de información también utilizan los lenguajes específicos de navegación y extracción de ITPilot, denominados, respectivamente, NSEQL (ver [NSEQL] para más información) y DEXTL (ver [DEXTL] para más información). La herramienta de generación de especificaciones de ITPilot permite probar y depurar el envoltorio generado, antes de desplegarse en el servidor de ejecución, tal y como será descrito en este manual. La sección de este manual que se ocupa del Generador de Especificaciones se organiza a partir de un ejemplo de utilización de la herramienta y en dos partes diferenciadas. En la primera parte se presenta en detalle un pequeño

Introducción 1


ejemplo de extracción de información de correos electrónicos de una aplicación web. En la segunda parte, se amplia ese ejemplo para observar y practicar con funcionalidades tales como extracción de datos dispersos en diferentes páginas de detalle, la navegación a través de páginas de “más resultados” y otras capacidades avanzadas. La siguiente sección describirá el proceso de instalación y configuración del Entorno de Generación.

Introducción 2


2 INSTALACIÓN Y CONFIGURACIÓN

2.1 INSTALACIÓN

2.1.1 Requisitos Hardware

La configuración mínima recomendada para la instalación del entorno de generación de flujos de navegación es un PC Pentium IV 2.4 GHz 1 GB o equivalente, si bien normalmente el sistema podrá funcionar sobre hardware de prestaciones inferiores. La instalación inicial necesita aproximadamente 60 MB de espacio en disco. No se considera el espacio requerido por la instalación del navegador Microsoft Internet Explorer [MSIE].

2.1.2 Requisitos Software

Se requiere la preinstalación del siguiente software :

- Sistema Operativo Microsoft Windows instalado (2000 Server, 2000 Advanced Server, 2003, XP, Vista).

- Navegador de Internet Microsoft Internet Explorer 6.x o 7.x para su utilización del entorno de generación de flujos de navegación.

- Es necesario también disponer de Java 2 SDK Standard Edition (J2SE) 1.4.2_09 o superior (probado exitosamente también con J2SE 1.5.0_05 y J2SE 1.6.0).

- Si se desea hacer uso de la funcionalidad de extracción de información de recursos Adobe PDF, se puede utilizar un convertidor basado en la tecnología de Adobe Acrobat; en ese caso, se requiere que el sistema se ejecute en una máquina Microsoft Windows, y la instalación previa de Adobe Acrobat Professional 7 [ADOBE].

- Si se desea hacer uso de la funcionalidad de extracción de información de recursos Microsoft Word, se requiere la instalación previa de OpenOffice 2.0.x [OO].

2.1.3 Instalación

El proceso de instalación de la herramienta de generación de ITPilot se realiza a través del instalador de Denodo que se arranca ejecutando el fichero install.bat (en el caso de estar realizando la instalación en un entorno Windows) o install.sh (en caso de instalar en entorno Linux, aunque para poder hacer uso de las capacidades avanzadas de navegación, es necesario que la instalación se realice en sistemas operativos Windows, tal y como se indica en el apartado 2.1.2). Aunque una descripción detallada del proceso de instalación puede ser encontrada en el Manual de Usuario de ITPilot [USU], se procede aquí a explicar rápidamente los pasos principales. La primera pantalla que aparece ante el usuario es la que se puede ver en la Figura 1.

Instalación Y Configuración 3


Figura 1 Pantalla inicial de instalación de ITPilot

Tras pasar esta pantalla y la de aceptación de licencia, se selecciona el conjunto de módulos de la Plataforma Denodo y qué componentes dentro de cada módulo se desea instalar en ese momento. En concreto, para la instalación de la herramienta de generación es necesario seleccionar los siguientes componentes dentro del módulo ITPilot: “Navigation Sequence Generator”, “Wrapper Specification Generator” y opcionalmente “Sequence executor ActiveX Control” si se desea ejecutar las secuencias de navegación en modo cliente (para más información, se recomienda la lectura del Manual de Usuario de ITPilot [USU]). Si también se desea que el servidor de wrappers se encuentre en la misma máquina, seleccione también “Wrapper Server”. Para más información acerca de la utilidad de cada uno de estos componentes, consulte el Manual de Usuario de ITPilot [USU]. Después, se permite seleccionar la ruta donde se encuentran instalados los programas OpenOffice y Adobe Acrobat Professional.

2.1.4 Tareas de Post-Instalación

2.1.4.1 Instalación de la Licencia de Utilización de Denodo ITPilot

Coloque el fichero de licencia que le habrá sido entregado (denodo.lic), en el directorio “conf” de la distribución de la herramienta. Sin ese fichero, la herramienta de Generación no arrancará.

2.1.4.2 Comprobación

Para comprobar la correcta instalación del software se ha efectuado correctamente, realice los siguientes pasos:

1. Arranque el MSIE 2. La barra de tareas del Generador de secuencias de navegación debería aparecer visible en el navegador. En

caso de que no aparezca, actívela seleccionando el menú Ver – Barras de Herramientas –



SequenceGenerator (o View – Toolbars – SequenceGenerator si su navegador está instalado en el idioma inglés).

Desde el mismo directorio “bin” desde donde se ha instalado la herramienta, pulse sobre el fichero “itpadmintool_startup” o, si lo ha elegido así en el proceso de instalación, pulse sobre el icono que se encontrará en su escritorio. Aparecerá una interfaz gráfica (como la de la Figura 2).

2.1.4.3 Desinstalación del Software

En primer lugar, cierre todas las instancias de MSIE. En caso contrario, el proceso de desinstalación no podrá eliminar la carpeta dónde el software fue instalado y mostrará un mensaje que indica dicha situación. En el directorio <PATH DE INSTALACIÓN>/Uninstaller, se encuentra el programa de desinstalación de ITPilot. Otras opciones son, por una parte, utilizar el icono ‘Uninstall ITPilot’ creado en el escritorio durante la instalación del software, y otra,la entrada añadida en la carpeta correspondiente a ITPilot del menú “Inicio”.

2.1.5 Introducción a las herramientas

Si ha realizado los pasos de comprobación descritos en el apartado 2.1.4.2, habrá podido observar ya la apariencia gráfica de las herramientas que componen el entorno de generación de ITPilot. Este apartado describe las características básicas de ambas, aunque se explicarán en detalle en sus respectivas secciones (apartados 3 y 4 de este manual). La pantalla principal de la herramienta de generación de especificaciones se muestra en la Figura 2, y se divide en tres áreas principales:

1. Menú: permite grabar wrappers, lanzar navegadores que asistan en la generación de wrappers, y gestionar la visualización de diferentes barras de tareas.

2. Área de Navegación: este es el lugar donde se visualizan los proyectos creados, así como los wrappers de cada uno de los proyectos. También muestra la lista de componentes que se pueden utilizar, tanto los provistos por defecto por la herramienta, como aquellos creados por el usuario (ver sección 3.20 para más información). Esta área permite asimismo exportar los wrappers al servidor de ejecución de ITPilot a través de la pestaña de “Data Export Tool”. La pestaña “Tools” permite funciones avanzadas en la generación de wrappers, tal y como se explicará en la sección 3.17.

3. Área de Trabajo: es el área principal de la herramienta; aquí es donde se crea gráficamente el wrapper mediante la utilización, configuración y relación entre sí de los componentes gráficos.



Figura 2 Herramienta de Generación de Especificaciones. Áreas

Por otra parte, la herramienta de generación de secuencias de navegación se muestra en la Figura 3. La funcionalidad de cada uno de los botones y opciones se explicará en detalle en el apartado 4, pero principalmente podemos encontrar las siguientes áreas:

- Configuración: gestión y configuración de algunos de los comandos de generación de secuencias de ITPilot.

- Generación de Secuencias: estos botones son los que permiten, de manera gráfica, realizar la grabación de la secuencia de navegación que se desea utilizar.

- Selección de Valores de Dominio: una segunda barra aparece cuando es necesario seleccionar valores de un dominio previamente creado en ITPilot para rellenar campos concretos en una secuencia de navegación (puede encontrar más información sobre Dominios en el apartado 4.7.2).

Figura 3 Herramienta de Generación de Secuencias de Navegación



A continuación se describirán en detalle ambas herramientas, y cómo se complementan entre sí. Primeramente, y a través de una serie de ejemplos, se explicará el funcionamiento de la herramienta de Generación de Especificaciones (donde se encuentra ya una primera aproximación a la generación de secuencias). En la segunda parte del manual, será la herramienta de Generación de Secuencias de Navegación la que será tratada en detalle.



3 MANUAL DE GENERACIÓN DE ESPECIFICACIONES

3.1 INTRODUCCIÓN

Este apartado describe la herramienta de Generación de Especificaciones de Denodo ITPilot, que permite crear “wrappers” o envoltorios web de una manera fácil e intuitiva a usuarios no técnicos, a través de una aplicación gráfica. El funcionamiento básico consiste en la utilización de componentes gráficos que permiten la generación de flujos de trabajo para la automatización de accesos a las fuentes web. Estos componentes implementan tareas tales como la navegación a una página determinada, la extracción de información útil a partir de la provisión de ejemplos de resultados etiquetados por parte del usuario, la iteración de los resultados obtenidos para su posterior procesamiento, o la descripción de flujos condicionales. En las siguientes páginas se explicará el funcionamiento de esta herramienta mediante la generación de un wrapper de acceso a una fuente web de correo electrónico. La primera parte del ejemplo (a partir de la sección 3.2) mostrará las capacidades básicas y comunes a prácticamente cualquier envoltorio web, mientras que la segunda (que comienza en la sección 3.15) se centrará en cuestiones más avanzadas que dotan de mayor potencia y versatilidad a la herramienta.

Manual de Generación de Especificaciones 8


PARTE I

En esta primera parte, estudiaremos, mediante un ejemplo completo, el funcionamiento básico de la herramienta de generación de especificaciones.

3.2 PRESENTACIÓN DEL EJEMPLO

La Figura 4 muestra la página de entrada de una web de correo electrónico de Denodo Technologies (accesible desde la URL http://mail.demos.denodo.com). En este manual utilizaremos la herramienta de generación de especificaciones para obtener la lista de correos recibidos (con un nivel de detalle creciente) y de una manera estructurada.

Figura 4 Página de entrada de Denodo WebMail

Introduzca el UserName “demos” y el Password “DeMo.04” para acceder a la aplicación web de correo. Se encontrará con la siguiente ventana (Figura 5):

Parte I 9

http://mail.demos.denodo.com/


Figura 5 Primera pantalla de mensajes

Pulsando sobre el asunto (Subject) de cualquiera de los correos, podrá acceder a su contenido (Figura 6)

Figura 6 Contenido de un mensaje

La aplicación web muestra los mensajes de 20 en 20, de manera que si se desea acceder a los siguientes mensajes,

hay que pulsar sobre la flecha derecha en .

3.3 ARRANQUE DE LA HERRAMIENTA DE GENERACIÓN DE ESPECIFICACIONES

Al arrancar la herramienta (ejecutando el programa <DENODO_HOME>/bin/ itpadmintool_startup.bat/.sh o haciendo doble clic en el icono “Start Wrapper Generator Tool” si así fue creado en el proceso de instalación), aparecerá una ventana como la que se muestra en la Figura 2.

A continuación se mostrará el funcionamiento de la aplicación mediante un ejemplo. El objetivo será la obtención automática y estructurada de la lista de correos.

Parte I 10


3.4 CREACIÓN DE UN WRAPPER

Los programas envoltorios han de ser creados en el contexto de un proyecto. Estos proyectos pueden ser creados, modificados y borrados desde la herramienta de generación de especificaciones de ITPilot. En este caso, vamos a crear un proyecto “MAILWRAPPERS”, desde el cuál crear el wrapper requerido. Para ello, pulsamos en “Project Management”, en el área de Navegación de la herramienta, pudiendo observar los proyectos existentes en la actualidad (ver Figura 7).

Figura 7 Creación de Proyectos

Para crear un nuevo proyecto, pulsamos en el icono en “Projects”. El área de trabajo mostrará un campo de texto donde poner nombre al proyecto; en este caso, le llamaremos “MAILWRAPPERS”, y pulsaremos el botón OK. Ahora

podemos observar cómo aparece el proyecto en el Área de Navegación (ver Figura 8). El símbolo a la derecha del nombre del proyecto permite borrarlo cuando no sea necesario. Borrar un proyecto implica la eliminación de todos los wrappers asociados, por lo que hay que ser cuidadoso con su selección; al borrar un proyecto, la herramienta permite especificar si los wrappers eliminados son borrados sólo de la herramienta de visualización, o también de disco; si sólo son borrados de la herramienta, desaparecerán de la vista del proyecto. Pueden ser recuperados seleccionando la opción Refresh del menú contextual del proyecto (pulsando el botón derecho del ratón sobre el proyecto concreto) o seleccionando la opción Add Processes, y después eligiendo el proceso concreto que se desea recuperar. Denodo ITPilot provee dos plantillas de utilidad para no tener que empezar desde cero cada vez que se desea crear un programa envoltorio. La plantilla “StandardTemplate” crea un programa envoltorio de acceso a una fuente y obtención de la información de la página destino y las de “más resultados”. La plantilla “StandardDetailTemplate” añade a la primera la posibilidad de acceder a una página de detalle para cada uno de los resultados de la página principal. Aunque en el apartado 3.21 se explica con más detalle, si el programa envoltorio a crear no requiere más componentes, éste será mantenible automáticamente por ITPilot. Por último, las plantillas pueden ser eliminadas por parte del usuario, si así lo desea.

Parte I 11


Los procesos pueden moverse de un proyecto a otro, a través de las opciones “Copy to Project” o “Move to Project” del menú contextual de cada proceso. Además, los procesos pueden copiarse a diferentes entornos de trabajo mediante la copia manual del fichero <DENODO_HOME>/metadata/itp-admin-tool/<project_name>/<process_name>.xml, donde “project_name” es el nombre del proyecto donde se encuentra el proceso, y “process_name” es el nombre del proyecto que se desea copiar. También es posible migrar un proyecto completo, mediante la copia del directorio <DENODO_HOME>/metadata/itp-admin-tool/<project_name> y el fichero de gestión del proyecto, <DENODO_HOME>/metadata/itp-admin-tool/<project_name>.xml.

Figura 8 Nuevo Proyecto Creado

Una vez el proyecto ha sido creado, podemos pulsar sobre él y crear un proceso nuevo. Este proceso será el que nos

permitirá generar finalmente un wrapper al término de este ejemplo. Pulsando sobre el icono se podrá asignar un nombre a este proceso. En nuestro caso, le llamaremos WEBMAIL. La Figura 9 muestra el resultado en el área de navegación.

Parte I 12


Figura 9 Creación de un nuevo proceso

3.5 COMPONENTES EN ITPILOT

Una vez el proyecto y el proceso han sido creados, podemos comenzar su desarrollo. Para ello, hemos de pulsar sobre el nombre del proceso recién creado, WEBMAIL, para que se cargue en la herramienta. Tras un breve período de tiempo, aparecerá un diálogo como el de la Figura 10 indicándonos que el proceso se ha creado exitosamente; tras aceptar este diálogo, la herramienta muestra el área de trabajo donde empezar a asignar componentes (Figura 11).

Figura 10 Diálogo de carga exitosa del proceso

Parte I 13


Figura 11 Área de Trabajo para Generación de Procesos

En el área de navegación se puede observar cómo se ha abierto automáticamente la sección “Process Builder”->”Components”, donde aparece una lista de componentes genéricos, que son los distribuidos por defecto por ITPilot, y una lista “Custom” inicialmente vacía, que es donde se listarán aquellos componentes creados por el usuario. Los componentes genéricos más habituales serán explicados a lo largo de este manual. También puede encontrarse una guía de referencia en el apartado 6 de este mismo manual. El porqué de la conveniencia de contar con componentes “custom” así como una descripción acerca de cómo crearlos, serán explicados en la sección 3.20. El área de trabajo se divide en tres partes, que se comentan a continuación:

1. Sección de componentes: los componentes genéricos también se muestran gráficamente en la propia área de trabajo, en la parte superior. En ambos casos, y como se verá ahora, la utilización de estos componentes en el área de trabajo se realiza mediante operaciones de arrastre (“drag&drop”).

2. Sección de generación de procesos: es el área de trabajo propiamente dicha, donde el usuario puede arrastrar los componentes, relacionarlos entre sí, y configurarlos.

3. Sección de configuración de componentes: esta área contextual permite configurar el componente que haya sido seleccionado. La configuración de cada componente se divide en tres partes: “Inputs”, donde se indica la entrada de datos al componente concreto; “Wizard”, donde se configura cada componente con sus características específicas; y “Details”, donde se describe su salida (que podrá ser recogida como entrada por otro u otros componentes) y otras características que se mostrarán a continuación.

El área de trabajo muestra ya dos componentes como parte del proceso en marcha. Son los componentes que indican los estados de inicialización y finalización del proceso. El componente de inicialización se describe en la siguiente sección, pero antes es necesario explicar qué tipos de parámetros de entrada y salida pueden existir.

Parte I 14


3.5.1 Parámetros de Entrada y Salida

Los tipos de parámetros que pueden ser utilizados por los componentes tanto a la entrada como a la salida son los siguientes:

- Páginas: algunos componentes, tales como el de secuencia de navegación (Sequence), devuelven como resultado una página, que es la que otro componente utilizará para, por ejemplo, extraer información.

- Registros: otros componentes (p.e. el Record Constructor) devuelven un conjunto estructurado de información (en este ejemplo, puede ser la representación estructurada de un ítem de información).

- Listas de registros: ITPilot permite que algunos componentes (p.e. el componente Extractor) devuelvan a su salida o acepten a su entrada listas de registros.

- Valores: otros componentes devuelven valores concretos en su salida, como el componente Expression.

3.6 INICIALIZACIÓN DEL PROCESO

El componente de inicialización no recibe parámetros de ningún otro componente, ya que es siempre el que inicia el proceso. Es el responsable de almacenar la estructura de los datos de entrada, aquellos datos que el wrapper recibirá de la aplicación llamante. Por ejemplo, en el caso que nos ocupa, hay cierta información requerida por la aplicación de correo electrónico para poder acceder a los mensajes, concretamente los valores de usuario y contraseña del usuario concreto. Estos datos pueden ser fijos, o variables, de manera que consultas diferentes sobre la aplicación web empleen valores diferentes de estos parámetros. En este ejemplo se considera que van a ser variables, por lo que es necesario definirlas. Para ello, hemos de realizar los siguientes pasos: primero, seleccionar el componente de inicialización con el botón izquierdo del ratón (ver Figura 12).

Figura 12 Selección del Componente de Inicialización

Pulsando la pestaña “Wizard” del área de configuración de componentes, y, una vez allí, pulsando el botón “Open Init Editor”, accedemos al Editor de Inicialización, que nos permite crear un registro de entrada (ver Figura 13). Primeramente, asignaremos un nombre a este registro para que sea accesible al resto del proceso: MAILPARAMS.

Después, procedemos a la creación de los elementos del registro, pulsando el botón junto a la sección “Add New Field” para cada elemento, y asignando un nombre y un tipo de dato a cada uno de ellos. En este caso, crearemos dos elementos:

- LOGIN, de tipo “string”, de utilización obligatoria, lo cuál conseguiremos marcando la casilla de selección denominada “Mandatory”.

Parte I 15


- PASSWORD, de tipo “string”, de utilización obligatoria. Hemos marcado ambos elementos como obligatorios ya que la aplicación web nos obliga a rellenar ambos campos. Por tanto cualquier ejecución que el usuario desee hacer contra este wrapper, una vez esté generado, deberá contener como argumentos de entrada valores para ambos elementos del registro. El resultado de nuestra acción se puede observar en la Figura 13.

Figura 13 Editor de Inicialización

Ahora ya podemos pulsar “OK” para volver a la ventana principal, y vemos cómo en la pestaña “Wizard” del área de configuración de componentes aparecen los dos campos recién creados (ver Figura 14).

Parte I 16


Figura 14 Pestaña “Wizard” del área de configuración de componentes con el registro de inicialización ya creado

3.6.1 Utilización del Explorador del Catálogo

Antes de continuar con la generación del proceso, es un buen momento para introducir una herramienta muy útil para conocer en cada momento qué elementos de información están siendo tratados en la generación del proceso, por cada uno de sus componentes. El explorador del Catálogo nos permite ver en una única ventana, qué registros, páginas, vistas o listas existen en el momento actual, en un proceso concreto. Así, ahora mismo podríamos ver si el registro MAILPARAMS ha sido creado adecuadamente.

Para arrancar el Explorador, hemos de pulsar el botón que aparece por defecto en el lado izquierdo del área de configuración de componentes1. Aparecerá una ventana como la de la Figura 15.

1 En caso de que no lo encuentre, compruebe que está visible. Para ello, vaya al menú View->Toolbars y verifique que la casilla “General” está marcada. También puede pulsar la combinación de teclas Ctrl+Shift+3. Parte I 17


Figura 15 Explorador del Catálogo

La información disponible para cada tipo de elemento de catálogo es la siguiente: - Inputs: lista de componentes que tienen como entrada este elemento. - Outputs: lista de componentes que tienen como salida este elemento. - Structure: utilizado en los elementos Registro,y Lista, contiene la descripción de la estructura del

registro (o del registro inherente, en caso de la lista).

3.7 AUTOMATIZACIÓN DE LA NAVEGACIÓN WEB

3.7.1 Creación del Componente en el Área de Trabajo

Una vez definidos los parámetros de entrada, el siguiente paso es configurar el proceso para que el envoltorio sepa cómo navegar hasta los primeros correos electrónicos del usuario. Para ello, el sistema tiene que saber cómo acceder a la página principal de la aplicación de correo electrónico, introducir los valores de Clave y Contraseña del usuario, y cualquier otro tipo de navegación adicional hasta acceder a la primera página de resultados. En ITPilot, las tareas de navegación son realizadas principalmente por el componente Sequence. Este componente está intrínsecamente relacionado con la Herramienta de Generación de Secuencias de Navegación, ya que es ésta la que permite al usuario generar la secuencia de manera gráfica, sin necesidad de utilizar en la mayor parte de los casos el lenguaje interno, NSEQL (ver [NSEQL] para más información acerca de este lenguaje). La herramienta de generación de wrappers está integrada con la herramienta de generación de secuencias de Denodo ITPilot de manera que se pueden generar secuencias de navegación en esta fase de descripción de la fuente –por supuesto, esta secuencia puede haberse grabado anteriormente, por lo que este paso puede saltarse; aún así, es interesante detenerse en este punto para comprobar cómo esta integración de herramientas permite crear dominios en la herramienta de secuencias de navegación de manera automática-.

Parte I 18


El proceso es el siguiente. Primero, arrastramos el componente Sequence, ya sea desde el área de navegación o

desde la barra de componentes del área de trabajo2, utilizando el icono . El componente Sequence aparece en el área de trabajo; el nombre por defecto puede ser modificado haciendo doble clic sobre el componente (en nuestro ejemplo lo llamaremos “InitialSeq”). Ahora ligaremos el componente inicial con el de secuencia, para comenzar a crear el flujo del proceso. Para ello, y tal como se muestra en la Figura 16, hacemos clic con el botón izquierdo del ratón sobre el conector del componente de inicialización y, sin soltar el botón del ratón, arrastramos hasta el puerto de entrada (con forma redonda) del componente de secuencia. Soltando el ratón, veremos la conexión entre ambos componentes.

Figura 16 Relacionando componentes entre sí

3.7.2 Configuración del Componente

Ahora se puede pasar a configurar el componente de secuencia. Para ello, una vez más, seleccionamos el componente para que se cargue su área de configuración. En este caso, la pestaña “Inputs” sí se encuentra activada, ya que puede recibir entradas de otros parámetros, en concreto:

- Input Values: valores de entrada que serán utilizados en la navegación web. En este caso sí que es

necesario seleccionar el registro creado en la sección 3.6. Para ello pulsamos el icono del elemento “Input Values”, y seleccionamos el registro “MAILPARAMS”.

- Input Page: el componente Sequence también permite indicarle una página de entrada, a partir de la cuál realizar la navegación. Esta página ha de provenir de algún otro componente cuyo valor de salida sea una página web, como otro componente Sequence, o un componente Next Interval Iterator. En este ejemplo, no es necesario.

La pestaña Wizard nos permite acceder, pulsando el botón “Open Sequence Editor”, al Editor de Secuencias. Es aquí donde hemos de cargar la secuencia de navegación esperada. Una secuencia de navegación es un conjunto de comandos NSEQL (ver [NSEQL] para más información) que describe diferentes eventos sobre un navegador web (ITPilot 4.0 utiliza Microsoft Internet Explorer 6.x en el entorno de generación). La secuencia de navegación puede ser creada de dos diferentes maneras:

2 En caso de que no lo encuentre, compruebe que está visible. Para ello, vaya al menú View->Toolbars y verifique que la casilla “Components” está marcada. También puede pulsar la combinación de teclas Ctrl+Shift+1. Parte I 19


- Utilizando la herramienta de generación de secuencias de navegación, incluída en ITPilot. Esta herramienta (descrita en detalle en el apartado 4 de este mismo manual), integrada como barra de tareas en el navegador Internet Explorer, permite grabar el programa NSEQL mediante la operación del usuario en el navegador. Es la manera recomendada por ser la más eficiente y rápida.

- Escribiendo a mano la secuencia, en NSEQL. NSEQL es un lenguaje bastante sencillo de utilizar, y usuarios avanzados pueden preferir esta opción. Existen también algunas páginas web que requieren comandos avanzados no proporcionados gráficamente por la herramienta de generación de secuencias.

En este ejemplo utilizaremos la herramienta de generación de secuencias. Para ello, abriremos un navegador Internet Explorer (directamente, a través de la opción Browser->New Browser del menú principal, o pulsando la combinación de teclas Ctrl-B). En ese momento aparecerá una ventana del navegador Internet Explorer, con la barra de grabación de secuencias de navegación (ver Figura 17). Si la barra no aparece, compruebe que se encuentra marcada la opción de menú “Ver -> Barras de Herramientas -> Sequence Generator”. Aunque no es objetivo de esta sección explicar en detalle el funcionamiento de esta herramienta, se mostrarán los diferentes pasos a realizar de manera gráfica. Para mayor información, se recomienda la lectura del apartado 4, que explica el funcionamiento de la herramienta de generación de secuencias, y [NSEQL].

Figura 17 Barra de Tareas de Denodo

Se inicia la grabación pulsando el botón y escribiendo la dirección de inicio de secuencia de navegación (Figura 18):

Figura 18 URL de inicio

La lista de selección “Converter” permite indicar si el recurso al que se va a acceder a través de la URL es un documento Word o uno PDF (por defecto está en blanco, lo cuál significa que se espera un recurso HTML). ITPilot es capaz de procesar documentos de estos dos tipos mediante la conversión automática a HTML. Tras pulsar OK, el navegador mostrará la página de inicio (Figura 19):

Parte I 20


Figura 19 Página de Inicio

Si ahora introducimos directamente los valores de los campos “UserName” y “Password”, la herramienta de generación de secuencias los almacenará tal cual; sin embargo, queremos que la secuencia grabada sea tan genérica como sea posible, es decir, que sea dependiente de los valores de los parámetros de entrada. Para ello, podemos crear un “Dominio” en ITPilot; un dominio es un conjunto de pares clave-valor, de manera que la herramienta de generación de secuencias pueda asignar variables a elementos de entrada de páginas web (e.g. formularios). De esta manera, el wrapper generado podrá aceptar diferentes valores para diferentes ejecuciones. La creación de dominios es muy sencilla, y se realiza gráficamente desde la ventana principal de la herramienta de generación de wrappers de ITPilot. A la izquierda del área de configuración de componentes pulsamos el botón

“Domain Editor” , que abrirá la ventana del Editor de Dominios (ver ). A continuación pulsamos el botón para añadir un ejemplo al dominio. Se pueden añadir tantos ejemplos como sean necesarios, aunque en este caso sólo necesitaremos uno. En pantalla aparecerá el nombre del ejemplo (MAILPARAMS), que proviene de los datos de inicialización que creamos en el apartado 3.6. Debajo, se escribirán valores concretos de ejemplo de cada parámetro. En este caso utilizaremos los valores de entrada de la aplicación web de correo electrónico comentados en el apartado 3.2:

- LOGIN: demos - PASSWORD: DeMo.04

Ver la Figura 20 para comprobarlo.

Parte I 21


Figura 20 Editor de Dominios

Una vez añadidos los ejemplos, el dominio ha de ser exportado para que la herramienta de generación de secuencias

pueda hacer uso de él. Para ello, pulsamos (“Export Domain”) y seleccionamos el nombre con el cuál será almacenado (por defecto: MAILPARAMS.xml). Cerramos el Editor de Dominios pulsando “Close”.

Ahora haremos uso del Dominio de Búsqueda recientemente exportado. Pulsando el botón de la herramienta de generación de secuencias, aparece un diálogo como el que se muestra en la Figura 21:

Figura 21 Selección de Dominio de Búsqueda

La lista muestra los dominios existentes. Si pulsamos sobre el Dominio “MAILPARAMS”, aparece una segunda barra de tareas en el navegador, en la cuál aparecen los datos del Dominio de Búsqueda exportados de la herramienta de generación de especificaciones (Figura 22).

Parte I 22


Figura 22 Barra de Datos de Dominio de Búsqueda

Ahora, en lugar de escribir directamente los datos sobre los campos de búsqueda “Username” y “Password” del formulario de la página principal de la herramienta de correo electrónico, se realizará una operación de “Drag&Drop” desde los valores que aparecen en la barra hacia los campos concretos (áreas de texto o de selección) del formulario. El resultado se puede observar en la Figura 23:

Figura 23 Operación de Drag&Drop sobre la Página Principal

De esta manera, la herramienta es capaz de generar las relaciones necesarias entre los parámetros de entrada y los campos del formulario HTML. Se continúa con la navegación hasta que se llega a la página de resultados (Figura 5). Una vez se haya comprobado que el icono del semáforo está en verde, estamos en disposición de grabar la secuencia para después cargarla en el wizard del componente de secuencia, o de importar la secuencia directamente, pulsando el botón “Import from Browser” de ese mismo wizard. Se recomienda grabar la secuencia si se va a reutilizar en otros

procesos. Para ello, se pulsa el botón de la herramienta de generación de secuencias (nombrándolo, por

ejemplo, webMail.nsq), y se para el proceso de grabación ( ); una vez se ha grabado la secuencia, se carga en la herramienta de generación de wrappers pulsando el botón “Load from file” y seleccionando el fichero generado. La Figura 24 muestra el resultado de esta acción. Una vez cargada, la secuencia podría ser modificada si fuera necesario –lo cuál también implica que, tal y como se comentaba anteriormente, la secuencia de navegación también puede ser escrita a mano, aunque se recomienda en ese caso la lectura previa de [NSEQL]-. Para ello, sólo hay que escribir en el área donde reside la secuencia de navegación.

Parte I 23


Figura 24 Editor de Secuencias con Secuencia Cargada

En esta misma figura se puede observar cómo existen algunos parámetros de configuración. En concreto, la primera pestaña cuenta con las siguientes posibilidades de configuración:

- Sequence Type: ITPilot permite acceder a recursos web a través de diferentes protocolos de comunicación. Los principales son browser pool y http, mientras que también es posible utilizar el protocolo ftp, y acceder a un recurso almacenado en el sistema de ficheros local. En este ejemplo se ha utilizado el tipo browser pool al tratarse de una fuente web con estado. A continuación se describe cada uno de ellos: o browser pool: es la opción por defecto. En este caso la secuencia se ejecutará haciendo uso del

pool de browsers configurado en el servidor de ejecución en el que se ejecute el envoltorio (ver [USU]). El pool de browsers utiliza navegadores para ejecutar la secuencia NSEQL. Estos navegadores pueden basarse en Microsoft Internet Explorer, Firefox o en el uso de un mini-navegador construido en base a un cliente http. En los dos primeros casos, el usuario no ha de preocuparse de tareas tales como el tratamiento de JavaScript, etc. Cuando la fuente no utiliza JavaScript, normalmente el uso de la implementación basada en clientes http es igual de efectiva, pero considerablemente más eficiente. El pool de browsers incorporado en el entorno de generación de wrappers utiliza mini-navegadores basados en Microsoft Internet Explorer, por lo que si se escoge esta opción, las pruebas del wrapper (ver sección 3.14.2) se realizarán con estos mini-navegadores.

o http: Esta opción permite utilizar el cliente http incorporado en ITPilot para efectuar las secuencias de navegación, sin utilizar el concepto de pool. Como ya se ha comentado, el uso del cliente http es más eficiente y normalmente funcionará correctamente si la fuente no utiliza JavaScript,. Utilizando esta opción, es también posible usar una sintaxis alternativa a NSEQL para especificar las secuencias de navegación, especificando simplemente el modo de la petición (GET|POST) y el patrón de acceso. En general, el patrón de acceso será la URL de acceso, que puede incluir variables en la misma forma que los programas NSEQL (ver [NSEQL]). Ejemplo:

Parte I 24


POST http://server.acme.com/login.jsp?login=@LOGIN&&pass=@PASSWORD

o ftp: permite acceder al recurso mediante el protocolo ftp. El formato en el que hay que escribir el acceso al recurso en el área de escritura es el siguiente: ftp://usuario:contraseña@dominio:puerto, donde:

usuario: nombre del usuario contraseña: contraseña de acceso al servidor ftp dominio: dirección concreta del servidor ftp. puerto: puerto donde está corriendo el servidor (por defecto, es el puerto 21).

o local: de la misma manera, ITPilot permite acceder al recurso si éste se encuentra en el sistema de ficheros local. El formato a utilizar es: file://dirección3, donde:

dirección: ruta de acceso y nombre del recurso - Reuse Connection: marcado por defecto, indica si se reutiliza el navegador utilizado hasta ese

momento, o se lanza un nuevo navegador, manteniendo la información de sesión. Generalmente se marcará esta opción, aunque en algunos casos (como cuando se utiliza el componente Iterator, explicado en el apartado 3.12) puede no ser útil.

- Maximum retries: en caso de que, como se verá en el siguiente apartado, el tratamiento de errores de algún tipo de error de este componente se encuentre configurado a ON_ERROR_RETRY, este parámetro determina el número de reintentos a realizar.

- Time between retries: indica el tiempo de espera entre un reintento y el siguiente en caso de que el primero falle. El tiempo se define en milisegundos.

Figura 25

Resultado del Editor de Secuencias

3.7.3 Configuración de Datos de Salida y Tratamiento de Errores

Para terminar con la configuración de este parámetro, sólo queda la pestaña “Details”, en la que se determina, por una parte, el nombre de su elemento de salida y por otro, las condiciones de error:

- Nombre del elemento de salida (Output Name): la salida de un componente Sequence es una página. La elección del nombre es importante, ya que ha de ser fácilmente accesible por los componentes posteriores que lo utilicen como entrada. En este caso se ha elegido INITSEQOUTPUT.

- Condiciones de error: en este apartado se configura cuál debe ser el comportamiento de este componente ante ciertos tipos de errores: o RUNTIME_ERROR: ante un error en tiempo de ejecución del propio componente, se puede elegir

entre ignorar el error, actuar ante el error realizando un reintento, o publicarlo y propagarlo. o CONNECTION_ERROR: este es el error que ocurre cuando hay algún tipo de problema de

conexión con la fuente. o SEQUENCE_ERROR: error que se produce cuando hay algún problema con la secuencia (la

secuencia no está bien escrita, algún comando no ha podido ser ejecutado, etc.) o HTTP_ERROR; error producido por un error http.

3 Nótese que las direcciones pueden comenzar con un símbolo “/”. Por ejemplo, en Windows las rutas también comienzan por “/”, por lo que para acceder a un directorio haría falta escribir ftp:///c:/directorio. Parte I 25

http://server.acme.com/login.jsp?login=@LOGIN&&pass=@PASSWORD

ftp://usuario:contrase�a@dominio/


o TIMEOUT_ERROR: si la fuente web tarda en contestar, se produce este error. El tiempo de espera es configurable. Si el wrapper se utiliza en el entorno de ejecución, este parámetro se configura en el pool de navegadores utilizado (ver [USU]). En el entorno de generación que nos ocupa, este valor se configura en el fichero ITPAdminConfiguration.properties disponible en <DENODO_HOME>/conf/itp-admin-tool, con la propiedad IEBrowser.MAX_DOWNLOAD_TIME.

Para este ejemplo, mantendremos todos los valores como ON_ERROR_RAISE, indicando que cualquier error sea reportado y la ejecución finalice.

3.8 DEFINICIÓN DE LA ESTRUCTURA DE LOS DATOS A EXTRAER

Inicialmente, el objetivo va a ser la obtención de la lista de correos tal y como aparecen en la página principal, y sin preocuparnos todavía de obtener más detalles (como los que se podrían obtener pulsando el botón izquierdo del ratón sobre cada uno de los mensajes). Es necesario por tanto que, a partir de la página destino que el componente Sequence obtuvo como resultado, tras la navegación, se realice un proceso de estructuración de su información relevante. Para ello, se hace uso de otro de los componentes principales de ITPilot, denominado Extractor, y cuyo icono es

. Este componente permite generar una especificación de extracción de información de páginas HTML mediante la provisión de ejemplos por parte del usuario. Esto permite que no sea necesario que el usuario utilice el lenguaje interno, DEXTL (ver [DEXTL] para mayor inf ormación) sino que sencillamente indicándole a la herramienta algunos ejemplos, ésta sea capaz de generar automáticamente el programa DEXTL. Como siempre, procedemos a arrastrarlo al área de trabajo. Partirá de la información provista por el componente Sequence, por lo que será necesario relacionarlos entre sí. Por último, el componente se renombra a “MainPageExtractor”. El resultado esperado se muestra en la Figura 26.

Parte I 26


Figura 26 Utilización de un Componente de Extracción

El primer paso a realizar en el proceso de configuración del componente es la selección de la página de entrada a partir de la cuál el componente extraerá información estructurada. Esta página procede del componente Sequence (es decir, es su valor de salida INITSEQOUTPUT), y así lo encontramos en la lista de selección (ver Figura 27). Una vez elegida, la pestaña de Wizard es la que permite generar la especificación de esa página a partir de ejemplos provistos por el usuario. Dediquemos algo de tiempo a este apartado en la siguiente subsección.

Figura 27 Página de Entrada del Componente Extractor

Parte I 27


3.8.1 Generación de Especificación de Extracción de Datos

Pulsando el botón “Open Extractor Configuration”, ITPilot abre una nueva ventana, el Generador de Especificaciones, tal y como se muestra en la Figura 28.

Figura 28 Generador de Especificaciones

El primer paso a realizar es la definición de la estructura de salida de los datos que se extraen de la página (es decir, qué tipos de datos tienen estos ítems). La estructura de un elemento puede contener campos simples o subelementos anidados definidos jerárquicamente. El usuario realiza esta acción en la primera pestaña de la ventana –a la que se accede directamente al arrancarla por primera vez-, denominada “Structure”. En este paso, y a través de las opciones provistas por la interfaz gráfica, se crea un árbol que representa la estructura de los elementos. Considerando de nuevo la Figura 5, la información que nos interesa de cada correo es la siguiente:

- SENDER: quién ha enviado el correo - SUBJECT: título del mensaje - MESSAGEDATE: fecha de recepción del correo. - SIZE: tamaño del mensaje en Kb.

NOTA: Existe un conjunto de palabras reservadas por ITPilot que no pueden ser utilizadas como nombres de los elementos de la estructura creada. Estas palabras clave se muestran en la Tabla 1.

Parte I 28

ADD, ADD_OBJECT_TO_LIST, ADMIN, ALL, ALTER, AND, ANY, ARRAY, AS, ASC, BASE, CACHE, CATCH, CLEAR, CONDITION, CONNECT, CONSTRAINTS, CONTEXT, CREATE, CREATE_LIST, CROSS, DATABASE, DATABASES, DATASOURCE, DATASOURCES, DESC, DF, DISTINCT, DROP, ENCODED, ENUMERATED, EXCEL, EXISTS, EXPRESSION, EXTRACTOR, FALSE, FETCH, FIELD, FILTER, FLATTEN, FOR, FORM_ITERATOR, FROM, FULL, GENERIC,


GRANT, HASH, HELP, HTML, I18N, I18NS, IF, INIT, INNER, INPUT, INPUTREWRITE, INVALIDATE, IS, ITEM, ITERATOR, JDBC, JOIN, LEFT, LIST, MAP, MAPS, MERGE, MY, NATURAL, NESTED, NEXT_INTERVAL_ITERATOR, NOS, NOT, NULL, OBL, ODBC, OF, OFF, ON, ONE, OPERATOR, OPERATORS, OPT, OR, ORDERED, OUTER, OUTPUT, OUTPUTLIST, OUTPUTREWRITE, PAGE, PATTERNS, POST, PRIVILEGES, QUERY, QUERYPLAN, RAW, RAWPATTERNS, READ, RECORD, RECORD_CONSTRUCTOR, RECORD_SEQUENCE, RECORD_STRUCTURE, REGISTER, REVERSEORDER, REVOKE, RIGHT, SEARCHMETHOD, SELECT, SEQUENCE, SESSION, SIMPLE, STOREFILE, SWAP, TABLE, TRACE, TRUE, TRY, TTL, TYPE, TYPES, UNION, USER, USERS, USING, VAR, VDB, VIEW, VIEWS, VQL, WHERE, WHILE, WRAPPER, WRAPPERS, WRITE, WS, XML, XML2BIN, ZERO

Tabla 1 Lista de Palabras Reservadas

Estos elementos conforman la estructura de extracción de información de la fuente web. A continuación se muestra cómo representarlo en la herramienta de generación de especificaciones: al posicionarnos en la pestaña de estructura debemos utilizar el escáner StandardHTMLLexer; si no aparece por defecto (debajo del texto “Current Scanner”), debemos seleccionarlo y pulsar el botón “Change Scanner”

para establecerlo. Aunque no es necesario en este momento, para más información acerca de los escáners se recomienda al usuario que lea [DEXTL] y la sección 3.17 de este mismo manual. Una vez realizado este paso, se procede a la creación de la estructura. Primero, daremos un nombre al tipo de registro que se va a crear, haciendo doble clic sobre el texto “(record name not set)” y escribiendo “WEBMAIL”; automáticamente, el nombre del tipo de registro es actualizado, así como el nombre de la estructura concreta; este nombre puede cambiarse, haciendo doble clic sobre él (en este caso sobre “WEBMAIL_LIST”): en este ejemplo lo llamaremos WEBMAILINSTANCE. Después, situándose sobre cada ítem y pulsando el botón derecho del ratón podemos invocar la acción “AddChild”, que permite crear un ítem nuevo, la opción “Change name” (“Cambiar Nombre”) o mediante el doble clic, nos permite nombrar cada ítem como deseemos. También se puede definir el tipo de dato de cada uno de los elementos mediante la opción “Change type”. Creamos una estructura como la que se ve en la Figura 29.

Parte I 29


Figura 29 Estructura de Extracción

Como veremos en el ejemplo avanzado, esta estructura jerárquica puede ser todo lo completa que deseemos, añadiendo nuevos niveles jerárquicos dependiendo de cómo deseemos modelar la estructura de salida del componente, En cada nivel podemos seleccionar el juego de marcas (“Tag Set”) que se requiere. Una marca representa una expresión regular definida sobre etiquetas HTML. Típicamente, las marcas se utilizan para especificar de una única forma primitivas básicas de representación que pueden ser expresadas de diferentes formas en HTML. Por ejemplo, podríamos definir un separador FINLINEA como sigue: FINLINEA = ("<br>"| "</p>"| "</tr>" | ”</td>” ([ \n\r\t])* </tr>”). Un juego de marcas es, sencillamente, una agrupación de marcas. Por defecto se utiliza el lenguaje de marcas “Standard” (Clásico), válido para la inmensa mayoría de las extracciones de fuentes web, y es el que utilizaremos en este primer ejemplo. Para más información, consulte [DEXTL] y la sección 3.17. Pulsando el botón derecho del ratón sobre los elementos de la estructura, aparece un menú contextual con opciones de cambio de nombre, adición de un nuevo nodo hijo, borrado del nodo, y tres opciones más, que se describen a continuación:

- Aliases: algunos tipos de wrappers pueden ser mantenidos automáticamente por ITPilot (ver [USU] para más información). En esos casos, este campo permite al usuario asignar palabras como sinónimos o etiquetas que pueden describir este campo en diferentes entornos, de manera que ayude al sistema de mantenimiento automático a generar de nuevo la especificación en caso de que la fuente web cambie.

- Options: este diálogo modal permite dos operaciones concretas: o Regular Expression: permite añadir una expresión regular que define el formato de

representación de este elemento. Esto es útil cuando el wrapper a generar va a ser mantenido por el servidor de mantenimiento de ITPilot, y se conoce que el valor obtenido varía con mucha frecuencia (continuamente e.g. un valor de cotización en bolsa). Para más información sobre mantenimiento, se recomienda la lectura de [USU]. La expresión regular se define en [REGEX]. En este ejemplo no haremos uso de esta opción.

Parte I 30


o Date Pattern: en el caso de que el tipo de dato sea Date, aquí se puede representar el patrón concreto, mediante el formato definido en [DATEFORMAT]. En este ejemplo, y para el caso del campo MESSAGEDATE, el DatePattern se define como dd/MM/yyyy.

- Flat Level: cuando un registro es multinivel (ver sección 3.8.2 para una explicación de este tema), es posible indicar que se desea que los valores de un nivel determinado sean aplanados, es decir, que los atributos de los niveles inferiores aparezcan en los niveles superiores.

Una vez se ha creado la estructura completa, se pulsa sobre el botón (“Set Structure”), abajo a la derecha, para establecerla (siempre se puede modificar la estructura volviendo atrás, aunque hay que tener en cuenta que se borrarán todos los ejemplos que se hayan creado hasta ese momento). La aplicación pasa automáticamente a la siguiente pestaña, la de Asignación de Ejemplos de Búsqueda.

3.8.2 Niveles Anidados en la estructura del componente

Pueden existir niveles anidados en el esquema de los datos a extraer. Por ejemplo, la Figura 30 muestra un ejemplo de una tienda electrónica de música cuya información puede modelarse como conforme al esquema ALBUM={TITULO, AUTOR, FECHA, EDICION:{FORMATO, PRECIO}}, donde EDICION es un elemento compuesto. De acuerdo a esta definición, un valor de EDICION estará compuesto por una lista de registros, dónde cada registro tiene dos campos llamados FORMATO y PRECIO. En la herramienta de generación de especificaciones, quedaría tal y como se puede ver en la Figura 31.

Figura 30 Tienda Electrónica de Música

Figura 31 Estructura de Tienda de Música

A este respecto, la herramienta de generación de especificaciones permite una opción de “aplanamiento de nivel”. Pulsando el botón derecho del ratón sobre un elemento compuesto, aparece la opción “Flatten Level”. En casos como el que nos ocupa, puede ser deseable que los datos sean “aplanados” para pertenecer a un único nivel. Esta selección afecta solamente a la estructura de salida de los datos. Se recomienda, para más información, la consulta de [DEXTL].

3.9 ASIGNACIÓN DE EJEMPLOS DE LOS RESULTADOS

En la segunda pestaña, el usuario, si lo desea, puede proveer diferentes ejemplos de resultados, de manera que el sistema extraiga datos conformes a la estructura generada anteriormente. Se pueden insertar cuantos ejemplos se

Parte I 31


deseen, y se recomienda que se provean al menos tantos ejemplos como diferencias entre elementos existan (p.e. en una página con 10 elementos, en 1 de los cuáles no aparece un campo que sí aparece en el resto, se recomienda la asignación de al menos dos ejemplos: uno de un elemento que sí contenga ese campo, y otro que no) para cada uno de los niveles definidos. Si el usuario es lo suficientemente avanzado y desea escribir por sí mismo la especificación utilizando el lenguaje

DEXTL (ver [DEXTL]), puede saltarse este paso pulsando el botón para pasar a la siguiente pestaña. En este ejemplo utilizaremos la posibilidad de generación automática de la especificación mediante ejemplos. Inicialmente, aparece una ventana como la que se muestra en la Figura 32.

Figura 32 Pestaña de Ejemplos de Resultados

En la ventana ya aparece una estructura donde especificar los valores del primer ejemplo. Se pueden agregar tantos ejemplos como se desee; para ello, basta con seleccionar la opción “Add Item” (“Añadir Item”) del menú contextual del botón derecho sobre el elemento raíz. Cada ítem atómico de la estructura tiene una opción “Assign Selected Text” (“Asignar Texto Seleccionado”) en su menú contextual del botón derecho que permite añadir un valor a ese campo concreto de dos posibles maneras:

1. Asociando texto de un navegador Internet Explorer abierto mediante la pulsación de la opción de menú “Browser->New Browser” de la ventana principal de la herramienta de generación de especificaciones. En esta ventana se puede navegar a la página de resultados y marcar con el ratón el texto de cada uno de los valores. Después, pulsando la anteriormente mencionada opción “Assign Selected Text”, se añadirá el valor al campo deseado, apareciendo el valor a la derecha del nombre del campo (CAMPO = ‘VALOR’).

2. Escribiendo antes el valor en el área de texto que aparece tras hacer doble clic con el ratón sobre el campo. Inmediatamente aparecerá el valor asignado a la derecha del nombre del campo (CAMPO = ‘VALOR’).

Parte I 32


Se aconseja, siempre que sea posible, la utilización de la primera opción, ya que así ITPilot es capaz de obtener información adicional del árbol DOM de la página HTML, permitiendo una generación de más adecuada del programa DEXTL; además, si se usa exclusivamente la segunda, todos los ejemplos han de proceder de la misma página web. Recordando la Figura 5, podemos marcar uno a uno los elementos del primer correo electrónico del listado y relacionarlos con los elementos de la estructura: REMITENTE (John Smith), ASUNTO (Data Integration Approach), TAMANO (1) y FECHA (01/31/2007). Para ello, marcamos con el ratón el valor “John Smith” en la ventana del navegador y seguidamente nos situamos sobre el elemento REMITENTE del primer ejemplo de la tercera pestaña, en la herramienta de generación de especificaciones, pulsando a continuación el botón derecho y seleccionando la opción “Assign Selected Text” (“Asignar Texto Seleccionado”). El resultado será el que aparece en la Figura 33: el elemento REMITENTE tiene como valor asignado (“Assigned Value”, “Valor Asignado”), “John Smith”.

Figura 33 Asignación de Valor a un Elemento

Es importante tener en cuenta que no es posible asignar el texto de cualquier selección del navegador, pues esto viene determinado por el juego de marcas elegido en la primera pestaña (ver apartado 3.4). Los valores también se pueden eliminar con la opción “Clear Value” (“Borrar Valor”) del mismo menú contextual. Además, se pueden eliminar ejemplos completos con la opción “Delete” (“Eliminar”) del menú contextual del elemento raíz. De igual forma que se pueden añadir nuevos ejemplos, también se pueden añadir ocurrencias de los niveles jerárquicos, situándose encima del nodo que representa al nivel y seleccionando “Add Item” (“Añadir Item”) en su menú contextual. La manera de añadir nuevos ejemplos es siempre la misma, pero la mayor parte de las veces es recomendable que estos ejemplos provengan de diferentes consultas a la fuente web (p.e. en tiendas electrónicas de venta de libros, buscar por diferentes conceptos), y cuidando siempre que la especificación generada (como se verá posteriormente) extraiga correctamente todos los resultados de cada una de ellas; si esto no ocurre, habrá que proveer al sistema de nuevos ejemplos representando aquellos resultados de la consulta que no es capaz de extraer adecuadamente (no sirve de mucho dar más ejemplos de elementos que sí obtiene). En nuestro ejemplo tras haber proporcionado como ejemplo el primer correo electrónico, podemos proseguir con más ejemplos para dotar de mayor fiabilidad al proceso de generación del patrón de acceso (Figura 34).

Parte I 33


Figura 34 Asignación de Varios Ejemplos

Finalmente, pulsamos el botón para comprobar que los ejemplos han sido insertados adecuadamente, y pasar a la siguiente fase: generación de patrones.

3.10 GENERACIÓN DE PATRONES

La introducción de resultados de ejemplos permite al sistema generar los patrones de extracción necesarios. Esta acción se realiza en la pestaña de Generación (“Generation”, “Patrones”). La vista inicial de esta ventana se muestra en la Figura 35.

Parte I 34


Figura 35 Ventana de Generación de Patrones

Se supone que en este punto el usuario ha provisto ya un número adecuado de ejemplos (ver apartado 3.9); en caso de que el usuario haya escrito todos los valores de los ejemplos, la herramienta pedirá al usuario que especifique el documento de donde extraer esos ejemplos (para ello deberá seleccionar con su ratón algún texto en el frame que contiene los ejemplos, en un browser abierto desde la herramienta de generación). Si, por el contrario, el usuario no llegó a proveer ningún ejemplo a la herramienta de generación, será

responsabilidad del usuario el generar la especificación manualmente, pulsando el botón y escribiendo el programa DEXTL en la ventana principal (esta acción sólo se recomienda a usuarios avanzados y/o en situaciones en las que es necesario acceder a funcionalidades avanzadas de DEXTL, no disponibles directamente desde la herramienta gráfica; se recomienda la lectura de [DEXTL] en estos casos). En este ejemplo proseguiremos con la generación automática de la especificación.

Con el elemento cuyo patrón se desea generar ya seleccionado, el botón invoca el proceso que, a partir de la porción de ejemplos correspondientes a ese nivel y de los documentos que contienen esos ejemplos, devuelve un programa DEXTL (para más información, ver [DEXTL]). Antes de pulsar ese botón, existen cuatro opciones que el usuario ha de tener en cuenta:

- Eliminación de ejemplos falsos (pulsando la casilla de selección: ): al seleccionar esta opción, el sistema intenta automáticamente detectar ejemplos falsos, es decir, ejemplos que el usuario ha introducido erróneamente. Esta detección puede, en algunos casos, eliminar todos los ejemplos aún correctamente introducidos, por lo que es recomendable no marcar esta opción a menos que se sospeche que los ejemplos pueden estar mal introducidos.

- Patrones Estrictos (pulsando la casilla de selección: ): si se encuentra marcada esta opción, el sistema intenta generar patrones lo más restrictivos posible. Más concretamente los patrones contendrán el mayor número posible de separadores de texto en lugar de reemplazarlos con elementos del

Parte I 35


tipo IRRELEVANT (que son menos restrictivos) cuando sea posible. Si el usuario no la marca, el sistema maximiza el número de elementos IRRELEVANT y minimiza la utilización de separadores de texto generando patrones más generales. Ver [DEXTL] para más información. ¿Cuándo utilizar esta opción? En circunstancias parecidas a la opción ‘Disambiguate’: cuando se están recibiendo más resultados de los esperados.

- Eliminación de ambigüedades (pulsando la casilla de selección: ): cuando el usuario elige esta opción, el analizador modifica los patrones del programa DEXTL generados añadiendo elementos al comienzo y final de cada uno para reconocer únicamente aquellos elementos que se corresponden más fielmente con los ejemplos seleccionados –es decir, se hacen más restrictivos los patrones generados para evitar que los patrones extraigan incorrectamente datos que no concuerden con los ejemplos provistos-. ¿Cuándo utilizar esta opción? Cuando, al probar la especificación generada, observamos que está cogiendo más resultados de los que realmente se desea. Otras alternativas son utilizar la opción anterior (‘Patrones Estrictos’) y/o la introducción manual de elementos FROM y UNTIL que delimiten el comienzo y finalización del área de extracción (para más información sobre estos elementos, ver sección 3.18).

- Combinación de patrones (pulsando la casilla de selección: ): Esta opción se encuentra marcada por defecto. Esta es una opción extremadamente útil cuando la página origen exige la generación de gran cantidad de elementos de datos opcionales, ya que puede reducir en gran medida el número necesario de ejemplos a introducir. Además, el programa DEXTL resultante de utilizar esta opción es más compacto.

Al pulsar sobre el botón de Generación, aparece en pantalla el texto del programa DEXTL de ese nivel determinado. Véase la Figura 36 para un ejemplo concreto sobre la página principal de la aplicación de correo web.

Figura 36 Generación de un Programa DEXTL

Para comprobar que el sistema reconoce correctamente todos los datos deseados en las páginas utilizadas para

proporcionar los ejemplos, puede utilizarse el botón . La Figura 37 muestra el resultado

Parte I 36


correcto de esta prueba. Se puede observar en la parte de abajo cómo el número total de elementos obtenidos coincide con el número de mensajes en la primera página de resultados, mientras que no hay elementos fallidos; también se muestra el número de ejemplos reconocidos, que coincide con el número de ejemplos generados. Los números entre paréntesis indican cuáles de los ejemplos generados han sido encontrados (en este caso, los tres: 0, 1, y 2).

Figura 37 Prueba de Ejecución de la Especificación

Si los resultados obtenidos no son los deseados, tenemos diferentes opciones a evaluar:

• Si se obtienen menos resultados de los esperados pueden añadirse nuevos ejemplos de los datos que el sistema no ha extraído. También es posible modificar los ejemplos existentes.

• Si se obtienen más resultados de los esperados, pueden utilizarse las opciones ‘Disambiguate’ y ‘Strict Patterns’ explicadas previamente.

• Alternativamente, el programa DEXTL generado puede modificarse manualmente (si se opta por ello, se

recomienda leer [DEXTL]); esta opción es seleccionada haciendo clic en el botón . El programa DEXTL generado automáticamente podrá entonces ser modificado.

Una vez hemos generado satisfactoriamente los programas DEXTL de cada uno de los niveles, pulsamos el botón

y nos saltamos la pestaña de “Marks”, ya que no la utilizaremos hasta la segunda parte de este ejemplo. Así, pasamos directamente a la fase de generación de la especificación.

3.11 GENERACIÓN DE LA ESPECIFICACIÓN

En la pestaña de especificación (Figura 38) se genera el programa DEXTL.

Parte I 37


Figura 38 Pestaña de Generación de Especificaciones

En nuestro ejemplo, como ya hemos probado la especificación en la pestaña de Generación, podemos pulsar el botón

. Ya hemos terminado con la configuración del componente de extracción. Sólo queda cambiar el nombre del elemento de salida del componente a EXTRACTIONOUTPUT desde la pestaña Details del área de configuración del componente.

3.12 ITERACIÓN DE RESULTADOS OBTENIDOS

3.12.1 Utilización del componente Iterator

El componente Extractor devuelve como resultado una lista de registros, cada uno de los cuáles contiene uno de los elementos obtenidos; en el ejemplo que nos ocupa, cada registro es un mensaje, con sus campos de emisor, mensaje, fecha y tamaño. Para poder gestionarlos adecuadamente, es necesario obtener cada uno de ellos; así, podrán realizarse filtros sobre campos concretos, sobre registros, condiciones, etc. Para ello, se utiliza el componente Iterator, que se utiliza para iterar sobre cada uno de los registros de la lista de entrada. En cada iteración, el componente devolverá un registro de la lista. Como siempre, el componente de iteración puede arrastrarse desde el área de navegación o desde la barra de

componentes del área de trabajo. El icono del componente es . La Figura 39 muestra el aspecto gráfico del componente en el área de trabajo.

Parte I 38


Figura 39

Utilización del Componente de Iteración

La configuración de este componente es muy sencilla. Por una parte, hay que seleccionar qué lista de entrada alimentará el proceso de iteración; en este caso, y tal y como se observa en la figura anterior, la lista se corresponde con la salida del componente de extracción descrito en el apartado 3.11, EXTRACTIONOUTPUT. Por otra, desde la pestaña de Wizard se puede configurar cómo se desea el modo de ejecución del iterador; por una parte, se puede optar por una ejecución paralela, en la que cada elemento iterado se propaga concurrentemente a los componentes posteriores. La otra opción es que la ejecución sea secuencial. En la pestaña Details, se observa cómo el nombre del registro de salida se corresponde con el nombre asignado por nosotros en el componente de extracción, tal y como se explicó en el apartado 3.8.1.

3.12.2 Gestión de los registros individuales

Tras la configuración de este componente, se procede a añadir el componente que reciba ese registro de resultados por iteración. En este caso concreto, sólo deseamos obtener cada uno de los resultados para irlos devolviendo asíncronamente a la aplicación (es decir, a medida que están disponibles, sin esperar a que el procesamiento del envoltorio haya finalizado). Para ello, otro de los componentes más importantes de ITPilot es el denominado “Record Constructor” (constructor de registros), que, tras recibir un conjunto de registros, se encarga de generar un registro de salida, que puede ser, o la combinación simple de los recibidos, o una versión modificada mediante la edición y transformación/eliminación de los campos de cada uno de ellos4. En este ejemplo sencillo, devolveremos los datos de interés del único registro de entrada: emisor, tema, fecha y tamaño del mensaje, aunque añadiendo nuevos atributos a partir del que devuelve la fecha para que los valores del día, mes y año se devuelvan separadamente.

4 Si no se desea realizar ninguna modificación a los registros devueltos por el componente Iterator, no es necesario utilizar el componente Record Constructor, pudiendo ligar directamente la salida del Iterator con la entrada del componente de salida Output que se explicará a continuación. Parte I 39


Como siempre, arrastraremos el componente (cuyo icono en la barra de componentes es , y lo añadiremos al proceso tal y como se muestra en la Figura 40. De esta manera, los registros de salida que el iterador devuelve tras cada iteración serán tomados como elementos de entrada en el componente Record Constructor.

Figura 40 Utilización del componente Record Constructor

La configuración del componente se realiza como sigue: en la pestaña de Inputs se selecciona el conjunto de registros que pueden combinarse en este componente. En este caso, sólo utilizaremos uno, el denominado

WEBMAIL. Pulsando el icono a la derecha de “Input Values”, aparecerá una lista de selección de donde elegiremos “WEBMAIL”. Una vez hecho esto, podemos acceder al Editor de Registros, desde la pestaña “Wizard”, para construir el registro de salida del componente. En este caso estamos interesados en devolver los campos de WEBMAIL: SENDER, SUBJECT, y SIZE, y en crear tres campos nuevos: MESSAGEDAY (que devolverá el día en que el mensaje fue entregado), MESSAGEMONTH (el mes) y MESSAGEYEAR (el año). Por defecto, todos los campos están deshabilitados; para que

se utilicen en el registro de salida, sólo hay que pulsar una vez con el botón izquierdo del ratón en el icono de

cada uno de ellos. Pulsando el icono , el campo vuelve a deshabilitarse.

Pulsando el icono a la derecha del mensaje “Add new field”, se permite la creación de nuevos atributos derivados. Lo pulsaremos tres veces y nombraremos cada uno como MESSAGEDAY, MESSAGEMONTH y MESSAGEYEAR respectivamente. La Figura 41 muestra el resultado de la operación tras nombrar el registro de salida.

Parte I 40


Figura 41 Editor de Registros

Como se puede observar, en la parte de arriba de la ventana aparece un error advirtiéndonos de que algunos atributos no han sido definidos todavía. Desde el editor de registros se pueden añadir nuevos campos, creados a

partir de los ya existentes; para ello, pulsamos el icono de cualquier de ellos (p.e. MESSAGEDAY) para proceder a su edición.

3.12.2.1 Edición de Nuevos Campos de Registro

Al pulsar el icono , aparece una nueva ventana, tal y como la que se muestra en la Figura 42. En esta ventana podremos hacer uso de las funciones definidas en ITPilot para aplicarlas sobre los campos accesibles desde el componente Record Constructor para generar nuevos atributos derivados. El capítulo 5 describe cada una de las funciones disponibles en ITPilot. En los casos que nos ocupan, utilizaremos la función de tratamiento de fechas: GETDAY, que acepta como entrada un parámetro de tipo DATE y devuelve un entero que indica el día. En la parte izquierda de la pantalla encontramos menús para crear diversos valores que pueden aparecer como operandos en las expresiones:

• Constantes (Constants). Este menú permite crear constantes de los diversos tipos de dato soportados por Virtual DataPort.

• Funciones de atributo derivado (Functions). Este menú permite crear una invocación a una de las funciones de atributo derivado permitidas por Virtual DataPort. Las funciones pueden recibir como parámetros constantes, atributos o el resultado de evaluar otras funciones. Devuelven un único resultado. La lista de funciones disponibles y el uso de cada una de ellas puede consultarse en el capítulo 6.

• Valores de Entrada (Input Values). Se corresponde con la lista de atributos de la vista sobre la que se aplica la proyección. Los atributos pueden actuar como parámetros de funciones.

El área central de la pantalla (Values) permite la construcción de expresiones. La caja de la izquierda es un espacio de trabajo para la creación de nuevas expresiones mientras que la caja de la derecha muestra las expresiones ya creadas. Por último, la caja “Expression” contendrá la expresión finalmente creada.

Parte I 41


Para crear una nueva expresión constante deben realizarse las siguientes acciones:

1. Seleccionar el tipo de dato de la constante en el desplegable ‘Constants’ de la parte izquierda de la pantalla y hacer ‘click’ o drag & drop sobre el espacio de trabajo de creación de expresiones (caja izquierda).

2. Aparecerá en el espacio de trabajo el tipo seleccionado, junto con un área de texto para rellenar el valor de la constante. El valor deseado puede escribirse directamente en el área de texto.

3. Al pulsar el botón ‘>’ la nueva constante aparecerá en la lista de valores creados (caja superior derecha). Para crear una nueva expresión de tipo función, deben realizarse las siguientes acciones:

1. Seleccionar la función deseada en el desplegable ‘Functions’ de la parte izquierda de la pantalla y hacer ‘click’ o drag & drop sobre el espacio de trabajo de creación de expresiones (caja izquierda). Pasar el puntero del ratón sobre el nombre de la función permite ver su sintaxis.

2. Aparecerá en el espacio de trabajo la función seleccionada, junto con un área para rellenar el valor de los parámetros de la función. Los valores de los parámetros deben ser o bien expresiones presentes en la lista de valores creados (caja derecha) o bien atributos. Para asignar una expresión ya creada como parámetro de una función, se hará una operación de drag & drop que lleve la expresión creada al área del parámetro. Al pulsar el botón ‘>’ que aparece al lado de la función, ésta aparecerá en la lista de expresiones creadas (caja derecha).

Figura 42 Editor de nuevos campos de registro

En este caso, seleccionaremos la función GETDAY del área Functions, tras lo cuál arrastraremos el atributo MESSAGEDATE del registro WEBMAIL sobre la función GETDAY que aparece en la caja “Values”. El resultado se observa en la Figura 43.

Parte I 42


Figura 43 Creación de un atributo derivado a partir de la función GETDAY

Ahora sólo queda ya pulsar el botón para que pase a la caja de la derecha. Como ya no necesitamos más, podemos arrastrar el resultado al campo “Expression Value”, y pulsar OK. Realizando esta misma acción con los otros dos atributos del registro, pero utilizando las funciones GETMONTH y GETYEAR, se habrán generado los tres nuevos atributos del registro de salida. El resultado será parecido al mostrado en la Figura 44. Pulsando OK, volveremos a la ventana principal del Entorno de Generación.

Parte I 43


Figura 44 Resultado Final del Registro de Salida

3.12.3 Devolución de resultados

Estamos a punto de terminar. Una vez el registro de salida ha sido generado, sólo queda utilizar el componente que

nos permite colocar el registro a la salida del proceso. Este componente “Output” (icono ) es muy sencillo de utilizar, ya que sólo hay que indicarle qué registro ha de colocar. En este caso, el registro MAILMESSAGEOUT devuelto por el componente RecordConstructor o, si no hubiese sido necesaria ninguna transformación, el registro devuelto por el componente Iterator. La Figura 45 muestra la utilización y configuración del componente.

Parte I 44


Figura 45 Utilización del Componente de Salida

La Figura 46 muestra el proceso completo.

Parte I 45


Figura 46 Proceso Completo de la primera parte del ejemplo

3.13 OPCIONES AVANZADAS DEL WRAPPER: SECUENCIA DE VUELTA ATRÁS Y LOCALE

Antes de terminar con la creación del proceso, se pueden configurar algunas capacidades añadidas del wrapper. En concreto, ITPilot permite añadir una “Secuencia de Vuelta Atrás” para optimizar el tiempo de respuesta de los programas envoltorio en diferentes ejecuciones, además de la información de localización por defecto del wrapper. Para ello, hacemos uso de la última opción del lado izquierdo del área de configuración de componentes, denominado

“Wrapper Options” (opciones del programa envoltorio) e indicado con el icono . Aparecerá una ventana como la de la Figura 47.

Parte I 46


Figura 47 Opciones del Wrapper

3.13.1 Secuencia de Vuelta Atrás

En esta ventana es posible definir una secuencia de navegación que nos permita volver a un estado concreto de esa fuente. Esta acción es utilizada cuando definimos una estrategia de reutilización de navegadores para aumentar la eficiencia del sistema. Es muy frecuente que las secuencias de navegación que son ejecutadas por un "wrapper" determinado compartan una serie de pasos iniciales comunes; por ejemplo, supongamos que se ha creado un wrapper para automatizar el proceso de búsqueda en una determinada fuente web. La fuente requiere de un proceso de autenticación que involucra la introducción de un nombre de usuario y de una contraseña. En nuestro ejemplo, supondremos que el wrapper utiliza el mismo par clave/contraseña para todos sus accesos a la fuente. Utilizando Denodo ITPilot para la creación de este "wrapper", se crearía un componente Sequence que realizaría, aproximadamente, los siguientes pasos:

1. Conectarse a la página "home" o inicial de la fuente. 2. Rellenar el formulario de autenticación con el login/password y pulsar el botón "Submit" o "Entrar"

para autenticarse. 3. Una vez realizada la autenticación, pulsar sobre el enlace que permite acceder a la página de

búsqueda. 4. Rellenar el formulario de búsqueda con la consulta deseada. 5. El servidor devuelve una página con los resultados de la consulta.

Los tres primeros pasos son comunes para todas las consultas que se hagan al wrapper. La diferencia entre una consulta y otra surge sólo en el cuarto paso, cuando el formulario de búsqueda es rellenado de acuerdo a la consulta específica que se desea realizar en cada momento. Sería deseable no tener que pagar el coste temporal de esos tres primeros pasos en cada consulta: idealmente, al recibir una nueva consulta habría un navegador ya autenticado y situado en la página de búsqueda de la fuente al que se podría asignar la nueva petición. El browser realizaría directamente la búsqueda (paso 4) y devolvería los resultados (paso 5), evitando el coste temporal de los pasos 1-3.

Parte I 47


Una secuencia de navegación de vuelta atrás se encarga de devolver a un browser a un estado en el que sea susceptible de ser reutilizado por futuras peticiones del mismo wrapper. Así, cuando el wrapper de nuestro ejemplo ha realizado una consulta sobre la fuente, el browser que ha sido utilizado para ejecutar la secuencia de navegación se queda en la página de resultados de la consulta (paso 5). Para que el browser pueda ser utilizado para una nueva consulta del mismo wrapper es necesario hacerle regresar a la página de búsqueda (paso 4). La secuencia encargada de lograr esto es la mencionada secuencia de vuelta atrás. Un wrapper puede obtener una secuencia de vuelta atrás de dos formas:

• Explícitamente: el creador del wrapper puede especificar una secuencia de navegación de vuelta atrás para un wrapper en la ventana “Wrapper Options”, en el campo de texto “Back Sequence”.

• Implícitamente: si se ha activado en el pool de browsers la estrategia de asignación STATE (ASSIGNMENT_STRATEGY=STATE, ver [USU]) y un wrapper no tiene una secuencia de vuelta atrás definida explícitamente, entonces Denodo ITPilot intentará obtener por sí mismo una secuencia de vuelta atrás adecuada para el wrapper en función de sus ejecuciones anteriores. Normalmente Denodo ITPilot requerirá al menos dos ejecuciones del wrapper antes de poder determinar si hay una secuencia de vuelta atrás adecuada para el wrapper.

Esta secuencia de vuelta atrás será tomada por ITPilot como el primer componente Sequence del wrapper. Es importante tener esto en cuenta para la elaboración de los programas envoltorio. Además, el tipo de navegador utilizado en esta secuencia de vuelta atrás es elegido implícitamente como aquél seleccionado por el primer componente Sequence del programa envoltorio. Para más información acerca de la reutilización de navegadores, se recomienda consultar el Manual de Usuario de Denodo ITPilot [USU].

3.13.2 Localización

Esta área permite configurar la información de localización del programa envoltorio. Permite la integración de información de diferentes países o áreas geográficas, expresando los datos de salida en los formatos esperados por el país en cuestión. Además, cada componente Extractor permite contener su propia configuración de localización, que se tendrá en cuenta aunque sea diferente a la localización por defecto. Para cada uno de los paises/localizaciones de los que pueden proceder los datos, existe una configuración de internacionalización. Existen varios parámetros configurables para cada una de las localizaciones contempladas. Algunos ejemplos de parámetros configurables son: moneda, símbolos utilizados como separadores decimales y de miles para la moneda, formato de fecha, etc. ITPilot incluye configuraciones de internacionalización para las zonas más comunes. Los nombres de zonas se corresponden con los códigos definidos por la norma ISO-639 [ISO639]. Ejemplos: ES (España), ES_EURO (España con moneda EURO), GB (Inglaterra),… En la ruta $DENODO_HOME/setup/vdp/metadata/properties/i18n existe un fichero con los parámetros configurados para cada zona utilizados por la herramienta de generación de ITPilot. Los parámetros de una localización se pueden dividir en varios grupos. A continuación se citan los diferentes grupos y se describen en detalle cada uno de los parámetros que los componen: NOTA: Los parámetros de internacionalización no son sensibles a mayúsculas y minúsculas; por ejemplo, “timeZone” y “timezone” corresponden a la misma clave.

• Genéricos

a. language – Indica el lenguaje que se utiliza en esta localización. Es un código ISO de lenguaje válido. Estos códigos se especifican con dos letras en minúsculas tal y como se define en la norma ISO-639 [ISO639]

Parte I 48


b. country – Especifica el país asociado a esta localización. Es un código ISO de país válido. Estos códigos se corresponden con dos letras en mayúsculas, definidos por ISO-3166 [ISO3166]. Ejemplos: ES (España), ES_EURO (España con moneda EURO), GB (Inglaterra), FR (Francia), FR_EURO (Francia con moneda EURO), US (Estados Unidos).

c. timeZone – Indica la franja horaria de la localización (e.g., Europe/Madrid para España = GMT+01:00 = MET = CET).

• Configuración de la moneda: Permite configurar diferentes propiedades de los valores de tipo money.

a. currencyDecimalPosition – Número de decimales que admite la moneda de la localización. Por ejemplo, para el euro este valor es 2.

b. currencyDecimalSeparator – Carácter que se utiliza como separador decimal en la moneda. Por ejemplo, el separador decimal para el euro es la coma.

c. currencyGroupSeparator – Separador de grupos en la moneda que se utiliza para la localización. Por ejemplo, para el euro el separador de grupos es el punto.

d. currency – Nombre de la moneda. Ejemplo: EURO, LIBRA, FRANCO.

e. moneyPattern – Especifica el formato para las monedas. Para el formato de monedas siempre se utiliza la coma como separador de miles y el punto como separador de decimales. El carácter ‘¤’ representa el símbolo de la moneda, e indica en qué lugar se debe posicionar el carácter o caracteres que lo representa. Ejemplo: ###,###,###.## ¤. Para analizar las monedas se utilizan los patrones que define la clase java.text.DecimalFormat, de la API estándar Java Developer Kit (véase su documentación Javadoc [JAVADOC] para más información).

• Configuración del tipo de dato time:

a. timePattern – Unidad de tiempo en la que se expresan los valores de este tipo en esta localización. Los valores posibles son: SECOND, MINUTE, HOUR, DAY, WEEK, MONTH y YEAR.

• Configuración de fechas: Configuración del tipo de dato date.

a. datePattern – Indica el formato para las fechas. Para especificar el formato de fechas, se utilizan caracteres ASCII para indicar las diferentes unidades de tiempo. En la Tabla 2 se muestra el significado de cada uno de los caracteres reservados que se utilizan en el formato de una fecha, su presentación y un ejemplo de su utilización. Ejemplo de un formato de fecha: d-MMM-yyyy H'h' m'm'. Para más información, ver [DATEFORMAT], clases java.text.DateFormat y/o java.text.SimpleDateFormat.

Símbolo Significado Presentación Ejemplo G Especifica una Era (Texto) AD y Año (Número) 1996 M Mes en año (Texto & Número) July & 07 d Día en mes (Número) 10 h Hora en am/pm (1~12) (Número) 12 H Hora en día (0~23) (Número) 0 m Minuto en hora (Número) 30 s Segundo en minuto (Número) 55 S Milisegundo (Número) 978 E Día de la semana (Texto) Tuesday D Día del año (Número) 189 F Día de la semana en el mes (Número) 2(2nd Web in July) w Semana del año (Número) 27 W Semana en mes (Número) 2 a Marca de am/pm (Texto) PM k Hora en el día (1~24) (Número) 24 K Hora en am/pm (0~11) (Número) 0

Parte I 49


z Zona horario (Texto) Pacific Standard Time ' Carácter de escape para texto (Delimitador) '' Comilla simple (Literal) ‘

Tabla 2 Caracteres reservados para el formato de una fecha

En la Tabla 2, para indicar la presentación de los caracteres reservados, se utilizan diferentes valores. El formato concreto de representación de salida depende del número de repeticiones de los diferentes elementos:

o Texto: con 4 o más caracteres para utilizar forma completa; menos de 4 caracteres para utilizar la forma abreviada.

o Número: utiliza el mínimo número de dígitos posibles. A los números más cortos se le añaden los 0’s a su izquierda. El año es un caso especial: si el número de ‘y’ es 2, el año se truncará a 2 dígitos.

o Texto & Número: 3 o más caracteres para representarlo como texto; en otro caso usa un número.

En un formato de fecha, los caracteres que no se encuentran en los rangos ['a'..'z'] ni ['A'..'Z'], se consideran como texto entrecomillado. Es decir, caracteres como ':', '.', ' ', '#' y '@' aparecerán en la fecha resultante incluso aunque no vayan entrecomillados en el texto de formato.

• Configuración de los números reales: Permiten configurar los tipos de datos float y double.

a. doubleDecimalPosition – Indica el número de posiciones decimales a utilizar para representar un valor de tipo double o float (un número real).

b. doubleDecimalSeparator – Representa al separador de decimales que se utiliza en un número real.

c. doubleGroupSeparator – Especifica cual es el separador de grupos para los números reales.

3.14 GENERACIÓN DEL WRAPPER, PRUEBAS Y EXPORTACIÓN

3.14.1 Generación del Wrapper

Una vez terminada la creación gráfica del proceso, podemos proceder a probarlo. Para ello, el wrapper ha de ser generado; ITPilot compila los flujos que definen los envoltorios a programas expresados en el lenguaje JavaScript

[JS]. La generación se realiza pulsando el botón (“JavaScript”) en la barra General a la izquierda del área de configuración de componentes. Si todo ha ido bien, aparecerá una ventana modal informando de que el código JavaScript ha sido generado exitosamente; pulsando OK sobre esa ventana, aparecerá otra con el código, tal y como se muestra en la Figura 48. Desde esta ventana se puede editar el código, si se desea realizar alguna modificación, o regenerarlo. Sin embargo, es necesario tener en cuenta que los cambios realizados en el código JavaScript no tendrán efecto en el flujo de componentes. Si se decide regenerar el JavaScript asociado al flujo, los posibles cambios realizados en el código se perderán. Se recomienda la lectura de[JSDENODO] para más información acerca del código generado por ITPilot.

Parte I 50


Figura 48 Código JavaScript del Wrapper generado

3.14.2 Ejecución del Wrapper

Con el wrapper generado, podemos proceder a probarlo. Para ello, desde la ventana principal, pulsamos el botón

(“Test Wrapper”). Una ventana como la mostrada en la Figura 49 aparece. Esta herramienta de pruebas consta de tres pestañas. La primera, “Input Values” (Valores de Entrada) permite al usuario introducir valores de ejemplo de cada uno de los parámetros de entrada del wrapper (tal y como se definieron en el componente de inicialización, en el apartado 3.6).

Parte I 51


Figura 49 Herramienta de Pruebas del Wrapper

Además, también permite seleccionar el nivel de traza de la ejecución del wrapper. Se puede elegir entre FATAL, ERROR, WARN, INFO, DEBUG y TRACE. Se recomienda la utilización del nivel DEBUG cuando se prueba el wrapper por primera vez.

Pulsando el botón de Ejecución del Wrapper, , el editor pasa a la pestaña “Execution Trace”, y lanza un navegador (ya que definimos el tipo de navegación como ‘pool de browsers’ en el apartado 3.7.2 y la herramienta de generación utiliza un pool de browsers basado en Microsoft Internet Explorer) que comienza a navegar por las páginas definidas en el componente Sequence (sección 3.7); al llegar a la página de mensajes, el componente Extractor (sección 3.8) obtiene la lista de registros, tras lo cuál el iterador (sección 3.12.1) va pasando los registros individuales al RecordConstructor (sección 3.12.2), y éste a su vez al Output (sección 3.12.3). La pestaña va mostrando los diferentes mensajes de trazas que permiten seguir el flujo concreto. El botón, durante la ejecución,

se transforma en , permitiendo su aborto en cualquier momento. Por último, la pestaña “Results” muestra, tras la ejecución del wrapper, los resultados devueltos por éste. En este caso (Figura 50) se puede observar cómo el wrapper devuelve todos los resultados existentes en la página web de mensajes de correo electrónico. La generación del wrapper ha sido un éxito. Los valores de los parámetros de entrada del programa envoltorio se mantienen de una ejecución a la siguiente. Además, es posible importar valores desde el editor de dominios, mediante el proceso de arrastre del nombre del campo en el editor hacia el nombre del campo en el diálogo de ejecución del wrapper.

Parte I 52


Figura 50 Resultados devueltos por el Wrapper

Antes de continuar, se recomienda la grabación del proceso (File->Save) para evitar la pérdida de información valiosa, y para permitir la modificación o adición de funcionalidad en un futuro.

3.14.3 Exportación del Wrapper

Con todo funcionando correctamente, el último paso consiste en preparar el wrapper para su operación en el entorno de ejecución de ITPilot. Para ello existen dos alternativas: la exportación directa desde el entorno de generación al entorno de ejecución (lo que exige que el entorno de ejecución esté arrancado en el momento de la exportación), o el almacenamiento del wrapper en el sistema de ficheros local en formato VQL (que es el formato de ejecución de wrappers de ITPilot) para su posterior carga en el entorno de ejecución.

3.14.3.1 Despliegue en el servidor de ejecución

Desde la ventana principal del entorno de generación de wrappers de ITPilot, pulsamos “Data Export Tool” en el área de navegación. Esta acción abre dos elementos más en ese mismo área, “VQL Generator” y “Server Deploy”. Hacemos clic sobre la segunda opción, tras lo cuál aparece información de configuración en el área de trabajo, tal y como se muestra en la Figura 51).

Parte I 53


Figura 51 Despliegue de un wrapper en el servidor de ejecución de ITPilot

Ahora deberemos introducir los datos de acceso al servidor, como su URL (por defecto, //localhost:9999/itpilot), usuario y contraseña. Los datos del servidor pueden corresponderse con los de un servidor Denodo Virtual DataPort [VDP], de manera que el wrapper puede utilizarse como una fuente más en cualquier proceso de integración de datos; para ello, se debe pulsar la opción “Create Base Relation” (Crear una Relación Base) y rellenar el campo nombrado como “Base View Name” (Nombre de la Vista Base) con el nombre de la vista base que a partir de ese momento referenciará en Virtual DataPort al wrapper recientemente creado. Para más información, se recomienda acceder a la documentación de Denodo Virtual DataPort [VDP]. Además, ITPilot permite configurar si se desea que este programa envoltorio sea mantenible o no. Pulsando OK, y con la premisa de que el servidor de ejecución esté arrancado, el wrapper será desplegado. Para más información acerca del servidor de ejecución de ITPilot, se recomienda la lectura de [USU].

3.14.3.2 Generación de VQL para posterior carga

Desde la ventana principal del entorno de generación de wrappers de ITPilot, pulsamos “Data Export Tool” en el área de navegación. Esta acción abre dos elementos más en ese mismo área, “VQL Generator” y “Server Deploy”. Hacemos clic sobre la primera opción, tras lo cuál aparece información de configuración en el área de trabajo, tal y como se muestra en la Figura 52).

Parte I 54


Figura 52 Almacenamiento del wrapper en sistema de ficheros local

Ahora deberemos introducir el nombre con el que se quiere denominar el wrapper (p.e. WEBMAIL). Posteriormente, los wrappers pueden cargarse en el servidor de ejecución de ITPilot utilizando la opción ‘Load VQL File’ de la herramienta de administración web de ITPilot. Ver [USU] para más detalle. El wrapper puede utilizarse como una fuente más en cualquier proceso de integración de datos en Denodo Virtual DataPort [VDP]; para ello, se debe pulsar la opción “Create Base Relation” (Crear una Relación Base) y rellenar el campo nombrado como “Base View Name” (Nombre de la Vista Base) con el nombre de la vista base que a partir de ese momento referenciará en Virtual DataPort al wrapper recientemente creado. Para más información, se recomienda acceder a la documentación de Denodo Virtual DataPort [VDP]. Además, ITPilot permite configurar si se desea que este programa envoltorio sea mantenible o no. Pulsando OK, ITPilot permitirá almacenar el fichero en cualquier lugar del sistema de ficheros local. Este es el fichero que habrá de ser utilizado posteriormente para desplegar el wrapper en el servidor de ejecución. Para más información acerca del servidor de ejecución de ITPilot, se recomienda la lectura de [USU].

Parte I 55


PARTE II

En esta segunda parte se aprenderá a sacar un mayor partido a la herramienta para obtener envoltorios más complejos.

3.15 EXTRACCIÓN DE DATOS MULTIPAGINADOS

La mayoría de las fuentes web ofrecen sus resultados en varias páginas consecutivas, todas con el mismo formato. Cualquier tienda electrónica, o buscador en Internet puede llegar a devolver cientos o miles de resultados de esta forma, de manera que si deseamos obtener un subconjunto amplio de datos de una fuente determinada, hemos de poder navegar a través de esta secuencia de páginas de “más resultados”. Para ello, la herramienta de generación de especificaciones de ITPilot provee un componente de navegación, denominado “Next Interval Iterator”, que permite iterar sobre diferentes páginas que tengan una estructura similar. Por tanto, en lugar de navegar a una página determinada mediante el componente Sequence, y ejecutar el componente Extractor sobre él, se navegará a esa página con el componente Sequence, y se comenzará un bucle en el que, cada vez que el componente Extractor termine de extraer información de una página, el componente de iteración de intervalo siguiente se ocupará de acceder a la siguiente página de resultados, utilizando una secuencia de navegación definida en ese componente. Veamos cómo se realizan estos pasos en la herramienta de generación.

Arrastraremos el componente Next Interval Iterator ( ) sobre el área de trabajo, y lo uniremos al proceso anteriormente creado de la manera mostrada en la Figura 53. Los cambios realizados han sido los siguientes:

1. El componente Sequence envía su salida al elemento de comienzo (“Next_Interval_Iterator”) del componente Next Interval Iterator.

2. Este elemento de comienzo se relaciona con el componente Extractor que, en el ejemplo anterior, estaba conectado directamente con el componente Sequence.

3. El componente de finalización ya no está conectado con el elemento de finalización del Iterator, sino con el elemento de finalización del Next Interval Iterator (“Begin_Next_Interval_Iterator”).

Parte II 56


Figura 53 Utilización del componente Next Interval Iterator para navegar por más páginas de resultados

Procedamos por tanto a la configuración del componente. En la pestaña Inputs de su área de configuración del elemento “Next_Interval_Iterator” del componente, podemos indicar la página de entrada a partir de la cuál se va a realizar la navegación por más intervalos. Además, también se puede asignar al componente registros de entrada; estos registros son utilizados cuando la secuencia de navegación tiene variables; ITPilot utilizará los valores de los atributos de registros cuyos nombres coincidan con el nombre de la variable utilizada en la secuencia. La pestaña Wizard permite al usuario acceder al editor de intervalos siguientes. Este editor es muy parecido al editor de secuencias descrito en el apartado 3.7.2, aunque con algunas características diferenciadoras que se comentarán enseguida. Primero, veamos cómo generar una secuencia de navegación para obtener más información de mensajes que no residen en la página principal, sino en las siguientes páginas de resultados. La Figura 54 muestra la página inicial de resultados. En la parte de abajo, a la derecha, podemos observar cómo hay una serie de enlaces que permiten navegar a las siguientes páginas de resultados; lo que haremos, por tanto, será grabar una secuencia de navegación que pulse el botón de página siguiente. Esta secuencia será utilizada por el componente al final de cada iteración, para acceder a la siguiente página, de manera que el componente Extractor siga obteniendo resultados.

Para ello, abriremos de nuevo un navegador Microsoft Internet Explorer. Pulsamos el botón y cuando nos aparece el diálogo donde escribir la dirección de inicio de secuencia de navegación, la cerramos pulsando sobre

o dejando la URL en blanco y pulsando OK. Ya estamos grabando sobre la página actual. En el panel de

navegación ( ) pulsamos sobre la flecha , “Next Page”, que nos lleva a la siguiente página

Parte II 57


de resultados. Pulsamos el botón para grabar la secuencia (p.e. correoWeb.siguiente.nsq) y paramos

el proceso de grabación con .

Figura 54 Página de Resultados de Correo

Volvemos ahora el editor de intervalos siguientes y cargamos la nueva secuencia pulsando el botón

. El resto del editor cuenta con las siguientes capacidades de configuración:

- Sequence Type: al igual que con el componente Sequence, en este componente también se puede determinar que tipo de acceso se va a realizar, si a través de un navegador, de un cliente http, del protocolo FTP o sobre un recurso residente en el sistema de ficheros local.

- Repeated Sequence/Different Sequences: aunque en general las fuentes web suelen replicar el modo de acceder a los siguientes resultados de una página a otra, esto no tiene que ser así. Por ello, ITPilot permite generar un conjunto de secuencias de navegación diferentes, una para cada iteración realizada. En este ejemplo esto no es necesario, por lo que dejaremos marcada la opción “Repeated Sequence”.

- Sequence Repetitions: con este parámetro se determina el número de veces que se desea ejecutar la secuencia de navegación (es decir, el número de páginas de resultados que se desea recorrer a partir de la principal). Por ejemplo, si escribimos “2”, ITPilot intentará pulsar dos veces (por lo que el wrapper extraería información de tres páginas de resultados en total).

- Reuse connection: marcado por defecto, indica si se reutiliza el navegador utilizado hasta ese momento, o se lanza un nuevo navegador, manteniendo la información de sesión. Generalmente se marcará esta opción, aunque en algunos casos (como cuando se utiliza el componente Iterator, explicado en el apartado 3.12) puede no ser útil.

- Maximum Retries: este parámetro determina el número de reintentos a realizar. - Time between retries: indica el tiempo de espera entre un reintento y el siguiente en caso de que el

primero falle. El tiempo se define en milisegundos. Se puede observar ahora el efecto de estas últimas acciones, volviendo a probar el wrapper tal y como se realizó en el apartado 3.13.

Parte II 58


3.16 ACCESO A PÁGINAS DE DETALLE

3.16.1 Introducción

Hasta ahora hemos desarrollado una especificación que permite obtener de manera estructurada la lista de mensajes que aparecen en un conjunto de páginas de una aplicación de correo web. Sin embargo, ya sabemos que en esa página sólo se nos muestra un subconjunto de datos de cada mensaje. Elementos tales como el cuerpo del mensaje, los remitentes en copia o los datos adjuntos, aparecen sólo en la página de detalle de cada uno de los mensajes. En esta sección comenzaremos con las modificaciones necesarias al ejemplo previamente realizado, para conseguir disponer de toda esta información. La estructura que deseamos ahora se muestra a continuación:

- MESSAGEDATE: fecha de recepción del correo - SENDER: quién ha enviado el correo - SUBJECT: título del mensaje - SIZE: tamaño del mensaje - MESSAGE: contenido del correo

Como se puede observar, los elementos SENDER, SUBJECT y SIZE se mantienen. Sin embargo, hay nuevos campos que se añaden, como MESSAGE (que será obtenido de las páginas de detalle). Por otra parte, el campo MESSAGEDATE se mantiene, pero ahora será obtenido de la página de detalle. Hemos de modificar, por tanto, nuestro proceso, añadiendo aquellos componentes que nos permitan navegar a cada una de las páginas de detalle; por otra parte, requeriremos la modificación de alguno de los ya creados.

3.16.2 Modificación de Campos en el componente Extractor: campo DATE

El componente Extractor creado en el apartado 3.8 obtenía los valores de los campos de SENDER, SUBJECT, MESSAGEDATE y SIZE del mensaje. Ahora modificaremos ese componente para eliminar el campo MESSAGEDATE (que va a ser obtenido de la página de detalle). Después hemos de volver a generar el programa DEXTL mediante la provisión de ejemplos. ITPilot lo requiere ya que la adición o eliminación de campos puede modificar algunos de los patrones de la especificación. Por suerte, el proceso sigue siendo igual de sencillo que en el apartado 3.8:

1. Abrir un navegador desde la opción Browser->New Browser (o pulsando Ctrl-B) del menú de la página principal de la herramienta de generación de wrappers.

2. Navegar hasta la página de resultados (la mostrada en la Figura 5). 3. Arrastrar los valores de ejemplo a los campos concretos de la estructura que aparece en la pestaña

“Examples” del editor del componente Extractor. 4. Generar tantos ejemplos como se desee. En este caso, generaremos tres ejemplos, ya que la estructura de

todos los resultados es similar.

5. Pasar a la siguiente pestaña mediante la pulsación del botón . La Figura 55 muestra la asignación de los ejemplos en la nueva estructura antes de pasar a la siguiente pestaña.

Parte II 59


Figura 55 Asignación de ejemplos en la nueva estructura del componente Extractor

La generación del programa DEXTL se realiza de la misma manera, y se prueba igualmente que en el apartado 3.8.

3.16.2.1 Asignación de Valores de Atributos de Marcas

Hasta ahora, la herramienta de generación de especificaciones nos ha permitido extraer datos que se podían obtener directamente de la visualización en el navegador de la página web. Sin embargo, en algunas ocasiones nos puede interesar extraer valores de atributos de marcas HTML. Por ejemplo, se puede querer recoger en un campo simple el valor de la etiqueta “href” de un enlace (recordamos que, si el valor de esta etiqueta es un enlace relativo, el nivel correspondiente habrá de almacenar la URL base de la que parte). En nuestro caso, podríamos estar interesados en almacenar la URL de acceso a la información de detalle del mensaje. Para ello haremos uso de la pestaña Marks del wizard del componente Extractor (ver Figura 56).

Parte II 60


Figura 56 Pestaña de Asignación de Valores de Atributos de Marcas

En este paso se asignan los valores de los atributos de marca deseados a campos simples de los elementos extraídos. El usuario realiza los siguientes pasos:

1. Seleccionar el patrón en el que se encuentra el atributo de marca (DEXTL permite utilizar diferentes patrones dentro de una misma especificación para, por ejemplo, permitir opcionalidad. Ver [DEXTL] ).

2. Seleccionar la marca de la que se desea recoger el atributo en el área de trabajo. 3. Seleccionar, de entre todos los posibles, el atributo deseado para este tipo de marca (p.e. para los

ANCHORs se define únicamente el atributo URL). 4. Por último, elegir el campo en el que se recoge el valor de la marca.

Para el ejemplo de la aplicación de correo web, las acciones concretas que se han de realizar son las que se describen a continuación. Como paso previo, habremos de crear un nuevo atributo en el registro del componente extractor. Le podremos llamar SUBJECT_URL5:

1. En la lista de selección de , se elige el único patrón disponible en este ejemplo.

2. Como se puede observar en la Figura 56, la ventana principal de la pestaña muestra los diferentes tokens de los que está compuesto el patrón seleccionado, pudiendo seleccionar con el ratón la marca de la que se quiere recoger el atributo. En este caso, se pincha sobre el ANCHOR() que aparece en

(se ve que cambia de color). 3. El atributo deseado en este caso es “URL” –el único posible-, y se selecciona en la lista

.

5 La modificación de la estructura de un componente Extractor implica la repetición de todos los pasos (asignación de ejemplos, generación de la especificación y asignación de marcas). Parte II 61


4. En se elige el campo en el que se quiere recoger el valor de la marca (en este caso, SUBJECT_URL).

5. Para finalizar, se pulsa el botón . El resultado de la asignación aparece en la ventana principal como modificación del programa DEXTL mostrado con anterioridad.

Eligiendo la opción se pueden borrar las asignaciones de los atributos de la marca seleccionada. Como siempre, una vez hayamos asignado los valores de atributos de marcas deseados, pulsamos el botón

, para pasar a la pestaña de Especificación.

3.16.3 Acceso a la Página de Detalle desde la Página Principal

Nuestro objetivo ahora es la construcción de la relación de navegación entre la página principal de resultados y la página de detalle de cada uno de los mensajes. Una vez el componente Sequence ha obtenido la página de resultados, es enviada al componente Extractor para la generación de una lista de registros, cada uno de los cuáles representa uno de los mensajes de correo electrónico en esa página. Es en ese momento cuando podemos utilizar un nuevo componente, denominado Record Sequence, cuya responsabilidad es la de ofrecer acceso a páginas relacionadas con otras, o cuyo acceso es provisto por registros extraídos anteriormente. En este caso, la entrada del componente será la página de salida del componente Sequence creado en la sección 3.7 (nombrado INITSEQOUTPUT)

y el registro de salida del iterador (WEBMAIL). Este componente, representado por el icono , se muestra en el área de trabajo de la Figura 57.

Parte II 62


Figura 57 Utilización del componente Record Sequence

En la pestaña Wizard procedemos a configurar la secuencia de acceso a las páginas de detalle mediante el editor de secuencias de registro. Este editor se divide en dos pestañas:

1. Commands: en esta pestaña se configura el o los comandos necesarios para realizar la navegación desde la página o registro de origen a la página de detalle deseada.

2. Sequences: esta pestaña se ocupa de tareas de configuración de características tales como la secuencia de vuelta atrás, o lo que en ITPilot se denomina “secuencias de gestión de formulario global”, que se explicará más adelante.

La pestaña Commands muestra, en el área de arriba de la ventana, la especificación DEXTL de un registro obtenido de la página principal, a partir de la información provista por la especificación del Extractor (para ello, se requiere que el Record Sequence se encuentre ya conectado, directa o indirectamente, con el Iterator que provee cada uno de los registros de ese extractor). Aunque se recomienda la lectura de [DEXTL] para la completa comprensión de este lenguaje, es lo suficientemente intuitivo como para, observando la Figura 58, se pueda comprender el significado de las etiquetas que aparecen: la primera, denominada ANCHOR(), indica que el atributo SENDER (identificado como atributo por el carácter “:” como prefijo) tiene un enlace (lo cuál podemos comprobar en la Figura 5, donde el dato del emisor contiene un enlace a la página de detalles del mensaje); la etiqueta ENDANCHOR() indica el final de ese enlace. Aparece después la etiqueta TAB(), que indica la existencia de algún tipo de tabulador en la página HTML. Después, el atributo SUBJECT, que almacena el asunto del mensaje, también está envuelto por un enlace que permite acceder, igualmente, a la página de detalles de este mensaje. Finalmente, se puede observar cómo existe otra etiqueta de tabulación, el atributo SIZE, y un texto fijo “ kb”. ITPilot permite indicar gráficamente que se desea acceder a una nueva página haciendo clic sobre uno de los enlaces mostrados en la especificación. El modo en que indicamos al componente Record Sequence la manera de acceder desde la página principal a la de detalle, es el siguiente: hacemos doble clic sobre una de las etiquetas ANCHOR (en la Figura 58 lo hemos realizado sobre la segunda), de manera que podemos ver cómo ITPilot asigna a un atributo generado dinámicamente el valor correspondiente a la URL del enlace.

Parte II 63


Figura 58 Editor de Secuencias de Registro

Al hace doble clic sobre una de las etiquetas ANCHOR, se añade una línea denominada ANCHOR en el área de trabajo de abajo (denominada “Current Commands”). El editor de secuencias permite seguir añadiendo comandos de procesamiento; aunque en este caso no es necesario, pues sólo es necesario seguir el enlace; en otras ocasiones puede hacer falta realizar alguna acción adicional (e.g. selección de una casilla de verificación antes de seguir el enlace).

Si seleccionamos el ANCHOR del área de abajo y pulsamos el botón , se abrirá una nueva ventana, como la que se muestra en la Figura 59. En ella, podemos modificar el programa NSEQL que genera ITPilot por defecto en caso de que se desee un comportamiento alternativo. Para ello, se recomienda la lectura de [NSEQL]. En este ejemplo no será necesario, ya que con hacer clic sobre ese enlace, la aplicación web accederá a la página de detalle. En esta página, además, se puede configurar el número de reintentos que esta secuencia puede ejecutarse en caso de error de acceso.

Parte II 64


Figura 59 Editor de Comandos del componente Record Sequence

La pestaña Sequences del editor de la secuencia de registro nos permite realizar configuraciones avanzadas sobre la secuencia de navegación que se ha definido en la pestaña anterior:

1. Tipo de secuencia (“sequence type”): tal y como se explicó en el apartado 3.7.2, se pueden definir diversos protocolos de acceso a los recursos HTML a los que se quiere navegar. Es importante darse cuenta de que los tipos de acceso de una secuencia a otra, o en la utilización de un Record Sequence, pueden ser diferentes entre sí.

2. Reutilización de conexión (“reuse connection”): la marcación de esta casilla de selección indica a ITPilot que utilice el mismo navegador utilizado hasta ahora en el proceso. Esto se realiza fundamentalmente por razones de eficiencia; si no se marca, ITPilot lanzará un nuevo navegador, procediendo a exportar la información de sesión del navegador utilizado hasta ese momento, al recientemente creado (esto es útil y necesario cuando, por ejemplo, se realizan ejecuciones paralelas en una iteración).

3. Utilización de Secuencia de Vuelta Atrás: existen dos casillas y un área de trabajo relacionados con esta funcionalidad. ITPilot permite al usuario decidir si cede la responsabilidad de volver a la página anterior tras cada iteración sobre las páginas de detalle a ITPilot, o si es el usuario el que proveerá una secuencia de navegación específica o, aún más, si se volverá o no a la página principal. Se utilizan los siguientes elementos gráficos:

a. Casilla de selección “Use Custom Back Sequence” (Utilización de Secuencia de Vuelta Atrás a Medida). Se marcará cuando se desee utilizar una secuencia de vuelta atrás para volver a la página anterior. Si no se marca, ITPilot generará una navegación a la página anterior en el mismo navegador a través de un método http POST o GET. Esta acción suele ser más lenta que la navegación a través de una secuencia. Es importante remarcar que la secuencia de vuelta atrás se realizará al comienzo de la siguiente iteración, no al final de la actual.

b. Casilla de selección “Default Sequence” (secuencia por defecto). Sólo activa cuando la anterior casilla ha sido marcada, indica a ITPilot que se utilizará la secuencia por defecto, que consiste en realizar una acción “Back” (como si se pulsara el botón de “Atrás” del navegador).

c. Si la anterior casilla no ha sido marcada, se permite al usuario cargar una secuencia de navegación concreta, mediante los botones “Load from File” o “Import from Browser”, tal y como se ha visto anteriormente en el componente Sequence (ver sección 3.7).

4. Secuencias de Formulario Global: en algunas ocasiones, las acciones que se pueden realizar sobre cada uno de los resultados de una página web para acceder a otras páginas (e.g. las páginas de detalle de este ejemplo) pertenecen conjuntamente a un único formulario. Esto implica que ITPilot, antes de poder pulsar esos enlaces, ha de encontrar el formulario al que pertenecen para identificarlo, y saber, si es necesario, cómo ejecutarlo (e.g. mediante el pulsado de un botón “Submit”, o de un enlace concreto). ITPilot permite en esos casos añadir secuencias de navegación para las acciones previas a la ejecución de la secuencia en

Parte II 65


el área “Global Form pre Sequence” (generalmente, encontrar el formulario) y para las acciones posteriores en el área “Global Form post Sequence” (ejecutar el formulario cuando sea necesario). Las secuencias pueden ser escritas a mano, pero Los botones “Load from File” e “Import from Browser” permiten importar una secuencia de navegación; ITPilot buscará el primer comando del tipo “FindFormByXXX” (ver [NSEQL] para más información) y copiará al área “Global Form pre Sequence” todo lo que esté por encima de este comando, FindFormByXXX incluído, y al “Global Form post Sequence”, lo que esté después. Ver [NSEQL] para más detalle sobre los comandos NSEQL.

3.16.4 Secuencia de Vuelta en los Componentes de Navegación

La posibilidad de definir el comportamiento de la secuencia de vuelta atrás existe en todos los componentes de navegación. En concreto: Sequence –ver apartado 6.20-, Next Interval Iterator – ver apartado 6.14-, Form Iterator – ver apartado 6.10- y Fetch – ver apartado 6.8-). Esta opción es útil para controlar el comportamiento del navegador en casos tales como reintentos, los refrescos de página, etc. La Figura 60 muestra la pestaña “Advanced” en el wizard de configuración de estos componentes. El componente Record Sequence, que es el que se está explicando ahora, tiene esta opción integrada en la pestaña “Sequences”, tal y como se ha descrito en el apartado anterior.

Figura 60 Pestaña Avanzada para definición de Secuencia de Vuelta Atrás

3.16.5 Prueba Individual del Componente Record Sequence

La Figura 61 muestra el resultado de la configuración de secuencias del componente Record Sequence en nuestro ejemplo. Utilizaremos iebrowser como tipo de secuencia, dejaremos que ITPilot genere la secuencia de vuelta atrás, reutilizaremos la conexión del navegador y no requeriremos la utilización de secuencias previas y posteriores, ya que no existe un formulario global en la página de resultados.

Parte II 66


Figura 61 Configuración de Secuencias del componente Record Sequence

Este componente permite ser probado sin necesidad de compilar y probar el envoltorio completo. Esto ocurre también con los componentes FormIterator y Next Interval Iterator. Para ello, los pasos a realizar son los siguientes:

1. Abra un navegador desde la ventana principal de la herramienta de generación de wrappers, a través del menú Browser->New Browser

2. Navegue a la página de resultados.

3. En la ventana de configuración del componente Record Sequence, pulse el botón . ITPilot transferirá la información de sesión del navegador Internet Explorer a un navegador de ITPilot, cargando la misma página. Además, lanzará una ventana de prueba del componente, como la mostrada en la Figura 62;

desde aquí se puede comprobar cómo, pulsando el botón , el navegador de ITPilot accede a la página de detalle de cada resultado tal y como se deseaba. La ventana muestra la traza de la ejecución tal y como ocurría en la ventana de prueba de ejecución del wrapper completo mostrada en la sección 3.14.2.

Parte II 67


Figura 62 Ventana de prueba del componente Record Sequence

3.16.6 Extracción de información de la página de detalle

Una vez ITPilot es capaz de acceder a la página de detalle de cada mensaje, es turno de obtener la información de interés de esa página. Para ello utilizaremos de nuevo un componente Extractor, al igual que cuando fue necesario obtener información de la primera página de resultados (ver apartado 3.8). La utilización del componente en el proceso queda como se muestra en la Figura 63. La entrada del componente es la salida del componente Record Sequence, que hemos nombrado como DETAILPAGE.

Parte II 68


Figura 63 Utilización del componente Extractor para la obtención de información de páginas de detalle

En nuestro ejemplo, el componente Extractor que se ocupa de extraer información de la página de detalle contendrá al menos un elemento (“MESSAGE”) que podrá albergar a su vez tanto etiquetas HTML del tipo “<BR>” como enlaces. Por tanto, el juego de marcas “STANDARD” del escáner StandardHTMLLexer, utilizado por defecto en el Extractor que se ocupa de la página de resultados no nos es útil, ya que encontraría patrones dentro del mensaje, por lo que no podríamos extraer el mensaje completo en un único atributo. Por ello, es necesario que el nivel de detalle tenga un juego de marcas diferente. En la sección 3.17 se muestra cómo desde la herramienta gráfica puede generarse un nuevo juego de marcas asociado a un escáner concreto6. Para entender los conceptos de escáner y juego de marcas con más detalle, se recomienda la lectura de [DEXTL].

3.16.7 Generación de la Especificación de acceso a la Página de Detalle

Una vez generado el nuevo escáner así como el juego de marcas, y con la nueva estructura, pasamos a la pestaña de

Ejemplos (“Examples”), pulsando el botón , donde se asignan los ejemplos; se puede comprobar cómo en este caso sí se permite asignar el texto del mensaje al atributo MESSAGE, al utilizar el nuevo juego de marcas; en caso de que algún mensaje contuviese etiquetas HTML pertenecientes a EOLLINEBREAK, sólo se podría asignar el texto existente hasta esa etiqueta; si fuese necesario, se podría modificar EOLLINEBREAK para que también lo aceptase. Una vez asignados los ejemplos, se pasa a la pestaña de generación. En esta pestaña existe una funcionalidad todavía no comentada, y de bastante utilidad, que es la generación de patrones FROM/UNTIL.

6 En realidad, este juego de marcas ya existe en la distribución de ITPilot; se trata del juego de marcas “STANDARD_TEXTFRAGMENT”, perteneciente al escáner “StandardLexerJS”. Parte II 69


3.16.8 Iteración sobre las estructuras de las páginas de detalle y creación del registro de salida

El componente Extractor, como ya sabemos, devuelve una lista de registros, aunque sólo devuelva un elemento. Por ello, a la salida del componente ha de utilizarse un Iterator que obtenga los registros requeridos. Una vez hayamos realizado esta acción, podremos reutilizar el componente Record Constructor de la sección 3.12.2 para generar un registro de salida que contenga los datos obtenidos de las páginas de resultados y de detalle. La Figura 64 muestra el resultado de añadir estos últimos componentes al proceso de extracción de correos electrónicos.

Figura 64 Adición de Iterador de datos procedentes de las páginas de detalle

Del componente Iterator no se comentará nada más, pues su configuración es idéntica a la realizada ya en la sección 3.12.1. En cuanto al componente Record Constructor, en el apartado 3.12.2 se explicó cómo hacer uso de él como salida de un iterador, y con un único componente Extractor como base para la generación del registro de salida. En este caso, el Record Constructor será utilizado para crear un registro de salida a partir de la información obtenida tanto de la página principal, como de la de detalle de cada uno de los mensajes. En la pestaña “Inputs” del área de configuración del componente Record Constructor, creamos dos valores de entrada (Input Values): el valor de salida del primer iterador (que devolvía cada uno de los registros de tipo WEBMAIL del extractor de información de la página de resultados) y el valor de salida del segundo iterador, al que se encuentra directamente conectado, que devuelve cada uno de los registros de tipo DETAILSTRUCT del extractor de información de la página de detalle de cada mensaje. Ver Figura 65.

Parte II 70


Figura 65 Configuración de valores de entrada del componente Record Constructor

En la pestaña “Wizard” se tiene acceso al editor del componente, donde poder elegir qué campos formarán parte del registro de salida del wrapper. Al igual que en el apartado 3.12.3, pulsaremos el botón de aquellos atributos que lo posean, para habilitarlos, con un resultado similar al mostrado en la Figura 66.

Figura 66 Registro de Salida del componente Record Constructor

Parte II 71


Con esto, ya tenemos preparado el proceso. Se pasa a generar el wrapper y a probarlo. El wrapper generado devuelve los resultados esperados, y de manera asíncrona (no espera a la finalización del proceso para ir devolviendo resultados).

3.17 JUEGOS DE MARCAS Y ESCÁNERS

Desde la herramienta de generación de ITPilot pueden crearse tantos escáneres y juegos de marca como sean necesarios para los diferentes niveles de nuestros envoltorios. En el área de navegación pulsamos el enlace Tools->Scanner & TagSet configuration, que mostrará en el área de trabajo una nueva ventana como la de la Figura 67.

Figura 67 Herramienta de Generación de Juegos de Marca y Escáners

Esta herramienta se divide en tres áreas verticales, donde cada área contiene información sobre los escáners, juegos de marcas y marcas concretas existentes actualmente en la instalación de ITPilot sobre la que se está trabajando. En una distribución estándar recién instalada, como la que se muestra en la figura, nos encontramos con varios escáners, como StandardHTMLLexer, StandardLexer y StandarLexerJS. Pulsando el botón izquierdo del ratón sobre cualquiera de ellos, podremos observar sus características internas: tipo de “lexer” y, lo más importante para nosotros, los juegos de marcas incluídos. El área central muestra el conjunto total de juegos de marcas existentes, y las marcas presentes en cada uno. Por último, el área derecha informa de qué marcas se han creado hasta ahora. Siguiendo el ejemplo utilizado en esta guía, para que la página de detalle de la aplicación de correo web sea accedida adecuadamente, es necesario crear un nuevo juego de marcas perteneciente al escáner StandardHTMLLexer que no contenga marcas que puedan impedir el acceso adecuado al campo “MESSAGE”. Para ello, el juego de marcas sólo contendrá las marcas EOL (sin las etiquetas HTML “<P>” y “<BR>”) y TAB. Por tanto, nuestro primer paso será crear una nueva marca, EOLNOLINEBREAK, que se definirá con las mismas

etiquetas HTML que EOL, pero sin <BR> y <P>. Pulsamos el botón del área derecha de la ventana de

Parte II 72


configuración de escáners (la correspondiente a marcas), y creamos la marca deseada, EOLLINEBREAK, que aparecerá en la lista de marcas existentes. En el campo inferior, nombrado “Tag Value”, podremos definir esta nueva marca. En este caso, y como se comentaba anteriormente, será la marca EOL, pero sin las etiquetas HTML que definen los saltos de línea y nuevo párrafo: “</TD" [^>]* ">" [\n\r\t ]* "</TR" [^>]* ">"|"<LI"~">"|"</TR" [^>]* ">"|"</OPTION" [^>]* ">"|"<DD"~">"|"<DT"~">"|"<DL"~">"|"</UL" [^>]* ">"|"</H1" [^>]* ">"|"</H2" [^>]* ">"|"</H3" [^>]* ">"|"</H4" [^>]* ">"|"</H5" [^>]* ">"|"</H6" [^>]* ">"|"</TH" [^>]* ">" NOTA: Al crear una marca en ITPilot, las etiquetas HTML de apertura han de escribirse con la siguiente sintaxis: “<ETIQUETA”~”>”. Por ejemplo, la etiqueta de párrafo, “<P>”, se escribiría “<P”~”>”. Esto es necesario debido al funcionamiento interno del sistema de mantenimiento automático de ITPilot (ver [USU] para más información acerca de este sistema). El apartado central, “Nested Tag Values”, sirve para definir atributos de la marca que se está creando. Por ejemplo, a la marca ANCHOR se define un atributo URL, al que se le asigna el valor ^CompleteURL(href,@URLBASE), que es una función que recibe como parámetros una URL relativa (e.g. /products?id=3025) y una URL base (e.g. http:///www.bookshop.com) y las combina para devolver una URL absoluta (e.g. http://www.bookshop.com/products?id=3025). En este caso, en el apartado “Nested Tag Values” se escribiría URL=^CompleteURL(href,@URLBASE)

Pulsando el botón , la marca quedará grabada. En caso de actualización de una marca, si se desea

descartar el cambio realizado y volver a la versión anterior, se puede pulsar el botón “Revert to Saved”. Una vez definida esta marca, deseamos crear un nuevo juego de marcas, “myTextTagSet” que contenga TAB y

EOLNOLINEBREAK. Para ello, en el área central “TagSets”, pulsamos la opción de adición, , y creamos el nuevo juego. Para ligar las marcas al juego de marcas, seleccionamos y editamos (pulsando el botón

) el nuevo juego de marcas, y podremos observar cómo las flechas entre las áreas de “juegos de marcas” y “marcas” se habilitan. Podemos en este momento seleccionar aquellas marcas que deseamos incluir en el

juego de marcas, y pulsar la flecha . El juego de marcas “myTextTagSet” mostrará en el campo “Included Tags” las marcas referenciadas. Existe también un área, “HTML tags not removed from texts”, que sirve para declarar qué etiquetas HTML no serán eliminadas del texto procesado; esto es útil si se quiere mantener cierta estructura HTML en los datos extraidos (para, por ejemplo, mostrarlos directamente en algún tipo de aplicación web o portlet). En nuestro ejemplo no haremos uso de esta opción. Para terminar esta fase, grabamos el juego de marcas pulsando el

botón . En caso de actualización de un juego de marcas, si se desea descartar el cambio realizado y volver

a la versión anterior, se puede pulsar el botón “Revert to Saved”. Por último, es necesario crear un nuevo escáner y ligarlo al juego de marcas recién creado. Procedemos de manera

parecida al paso anterior, pulsando el botón del área izquierda de la ventana de generación de escáners, y creando un nuevo escáner, “MyLexer”. Después, marcando el recién creado escáner, pulsamos el botón

de edición , seleccionamos el juego de marcas “myTextTagSet” y pulsamos la flecha entre ambas áreas, para su asignación. La ventana de generación de escáners mostrará un aspecto parecido al de la Figura 68, donde el campo “Included TagSets” del área de escáners muestra el juego de marcas “myTextTagSet”. Añadiremos también el juego de marcas “Standard”, pues una estructura sólo puede utilizar un escáner, y el nivel principal requiere este juego de marcas.

Parte II 73


Figura 68 Escáner y Juego de Marcas Generado

El último paso de este proceso es el almacenamiento y generación del escáner para que pueda ser utilizado por

cualquier aplicación ITPilot. Para ello, sólo hemos de pulsar el botón del área de escáners, comprobando que se ha generado exitosamente. Para que nuestros procesos puedan utilizar este nuevo escáner, hemos de rearrancar la aplicación. No olvidemos guardar el proceso antes de realizar esta acción. Además, si el servidor de ejecución no se encuentra instalado en la misma localización que el entorno de generación de envoltorios, es necesario instalar el escáner en el mismo. En [DEXTL] se describe como hacerlo. Ahora podemos actualizar el escáner y juego de marcas de nuestro componente Extractor:

- En la pestaña Structure del wizard de extracción, seleccionamos el nodo raíz, al que nombraremos “DETAILSTRUCT” y modificamos el escáner para que sea “MyLexer”.

- Crearemos la nueva estructura de datos, con dos atributos: • MESSAGE, de tipo String, que almacenará la información del mensaje recibido. • MESSAGEDATE, de tipo Date. En el menú contextual (pulsando el botón derecho del ratón), se

seleccionará la opción “Options”, y en el campo “Date Pattern” se escribirá: d, dd-MMM-yyyy HH:mm:ss . Esto indica a ITPilot el patrón que el campo MESSAGEDATE debe seguir.

- Pulsamos el botón “Change TagSet”, y seleccionamos el juego de marcas “MYTAGSET”.

3.18 PATRONES DE DELIMITACIÓN FROM/UNTIL

En ocasiones no es fácil determinar en qué parte de la página ha de comenzar el proceso de extracción de información, y en qué parte ha de acabar. La mayor parte de las veces esta situación puede evitarse alargando la especificación del patrón a reconocer con partes que, aunque no se deseen extraer, eviten la ambigüedad. Sin embargo, en otras ocasiones, esto no es tan sencillo. Un ejemplo típico se muestra a continuación. La Figura 69 muestra el formato gráfico utilizado por una tienda de libros en Internet para mostrar la información de sus productos.

Parte II 74


Figura 69 Resultados Tabulados de una Tienda de Libros

Un programa DEXTL generado sin cuidado devolvería la fila cabecera como un resultado más. Si bien en prácticamente todos los casos y también en éste en particular, una cuidadosa definición de marcas de formato u otras alternativas (ver [DEXTL]) permite definir un patrón no ambiguo, es evidente que sería más sencillo y rápido poder definirlo de una manera más intuitiva y sin hacer uso de marcas de formato adicionales definidas específicamente para cada documento y que, casi con toda seguridad, no serían reusables. Para solucionar este tipo de problemas, el sistema ofrece la posibilidad de delimitar la parte de un documento donde se desea buscar concordancias con un determinado patrón. Esto, que en el lenguaje DEXTL se obtiene mediante la utilización de la claúsula FROM de un elemento, especificada mediante las construcciones ‘FROM-END_FROM’ y marca TO, puede generarse gráficamente de la siguiente manera: desde un navegador lanzado desde la herramienta de generación de especificaciones se accede a la página de resultados y se selecciona el texto que conforma la delimitación previa al patrón que se desea extraer (en el ejemplo de la Figura 69, la cabecera de la tabla). Una vez

realizada esta acción, se vuelve a la herramienta de generación, y se pulsa el botón . El sistema ampliará la especificación para incluir la delimitación de búsqueda. También podemos realizar la

delimitación con respecto al final de la búsqueda, mediante el botón . En el ejemplo de WEBMAIL vemos que no es necesaria esta delimitación, pero aún así probaremos a realizar una “FROM”, marcando desde un navegador lanzado desde la herramienta de generación la cabecera de la tabla de la página principal que muestra los correos recibidos (ver Figura 70). Una vez seleccionada esta zona, pulsamos el botón

, momento en el cuál ITPilot aumentará la especificación con la información de delimitación.

Figura 70 Delimitando el Comienzo de la Extracción

Parte II 75


3.19 GENERACIÓN MANUAL DE LAS ESPECIFICACIONES DE EXTRACCIÓN DE DATOS

En algunos casos puede interesar el poder generar la especificación del componente Extractor de forma manual, sin necesidad de introducir ejemplos. Estos casos pueden aparecer debido a que la fuente tiene una estructura muy clara para el usuario, o sencillamente porque el usuario ya ha adquirido cierta destreza en el manejo del lenguaje DEXTL. El wizard del componente Extractor de la herramienta de generación de especificaciones dispone de una utilidad que simplifica esta tarea.

En la pestaña “Utilidades” , que se muestra en la Figura 71, podemos hacer uso de esa funcionalidad. Para ver cómo funciona, mostramos un pequeño ejemplo.

Figura 71 Pestaña de Utilidades

Supongamos que deseamos crear el programa DEXTL de extracción de datos de la página principal de resultados de la aplicación de correo web. Una opción alternativa a lo que hemos visto hasta ahora sería arrancar un navegador (desde la herramienta de generación), acceder a esa página, y, por ejemplo, marcar la primera línea que contiene un mensaje (ver Figura 72).

Figura 72 Selección de Datos a Extraer

Parte II 76


Ahora volvemos a la herramienta de generación de especificaciones, y, tras haber seleccionado adecuadamente el escáner y el juego de marcas deseado (e.g. StandardHTMLLexer y STANDARD, respectivamente), pulsamos el botón

. El resultado es el que se muestra en la Figura 73. El sistema toma el texto marcado por el usuario y lo analiza, extrayendo aquellas marcas reconocibles a partir del escáner y el juego de marcas. Aquello que no ha sido reconocido se mantiene como literal, de manera que el usuario puede, o dejarlo así si realmente es un valor constante, o cambiarlo por el valor de un elemento.

Figura 73 Obtención de Información de Tokens

3.20 EXPORTACIÓN DE UN FLUJO COMO UN COMPONENTE A MEDIDA

Denodo ITPilot permite al usuario la creación de componentes a medida (CUSTOM). Estos componentes pueden ser programados directamente en JavaScript (ver [JSDENODO] para más información). También es posible crear componentes CUSTOM partiendo de procesos previamente creados, de forma que puedan ser reutilizados en otros procesos. En este apartado se procederá a la creación del componente a medida “WebMail” a partir del proceso recientemente generado. El primer paso a realizar es la creación de una copia del proceso “WebMail”, renombrado a “WebMailAsCustom”, donde se realizarán los cambios requeridos para que este proceso funcione como componente a medida. En ese caso concreto, se desea que el componente devuelva la lista de resultados obtenidos tras la extracción de datos. Para ello, se ha de crear una lista de registros que contenga todos los elementos, de manera que se pueda devolver como resultado del componente. La Figura 74 muestra el flujo de proceso deseado.

Parte II 77


Figura 74 Creación de un componente a medida

Se puede observar cómo al comienzo del proceso se crea una lista vacía, que denominaremos “CCReturnList”, y que almacenará los registros que serán devueltos por el componente a medida. Un nuevo componente “Add Record to List” se ha añadido después del Record Constructor que agrega la información procedente de los extractores de información de la página principal y de las páginas de detalle, de manera que el registro respuesta de este componente se almacena en la nueva lista tras cada iteración. Por último hay que tener en cuenta que el componente no devolverá ningún elemento si existe algún error interno, por lo que tendremos que configurar adecuadamente cada uno de los parámetros de error de los componentes. En este ejemplo, se configura el parámetro CONNECTION_ERROR con el valor ON_ERROR_IGNORE, evitando así errores no deseados cuando el número de páginas de más resultados no sea el esperado. ITPilot también ofrece el valor ON_ERROR_RETRY_IGNORE, que reintenta la acción durante un número predeterminado de veces, y si el error persiste, lo ignora. Con el proceso cargado en la herramienta de generación de especificaciones de ITPilot, se selecciona la opción de menú File->Save as custom component… (o con la combinación de teclas Ctrl+Alt-S). Los pasos son los siguientes:

Parte II 78


1. Asignar un nombre al componente a medida (ver Figura 75): WebMailCustomComponent

Figura 75 Asignación de nombre de componente a medida

2. Seleccionar la salida de qué componente del proceso que será utilizado como salida del componente a medida (ver Figura 76): en este caso elegiremos la lista que acabamos de crear, denominada CCReturnList .

Figura 76 Selección del tipo de salida del componente a medida

Una vez realizados estos pasos, se puede observar en el área de navegación de la herramienta cómo aparece un nuevo componente debajo del área “Custom”. Ahora, para probarlo, podemos crear un pequeño proceso de prueba que haga uso de este componente. La Figura 77 muestra este pequeño ejemplo. Podemos observar cómo la salida del componente a medida, al ser una lista, es tratada por un componente Iterator. La entrada de datos se realiza a través de dos componentes Expression que convierten los campos del registro del componente de inicialización en los valores de entrada. El resto del proceso es parecido al mostrado anteriormente en este manual. Este mismo ejercicio se puede realizar directamente mediante la selección de la opción “Use OutputComponent as Output”, que utiliza el registro de salida del componente Output.

Parte II 79


Figura 77 Ejemplo de utilización de un componente a medida

3.21 COMPROBACIÓN DE MANTENIMIENTO DEL PROGRAMA ENVOLTORIO

La herramienta de generación de especificaciones de ITPilot ofrece una opción que informa al usuario de si el wrapper generado es mantenible o no por el servidor de mantenimiento de ITPilot. Este servidor, descrito en [USU], permite regenerar automática un programa envoltorio en caso de que la fuente original cambie.

La opción “Wrapper Maintenance Check” se encuentra en la parte izquierda del área de configuración de componentes, tal y como se muestra en la Figura 78. Pulsando ese botón con un programa envoltorio activo, aparece un diálogo que informa de si ITPilot puede mantener o no ese wrapper (ver Figura 79).

Parte II 80


Figura 78 Área de Configuración de Componentes

Figura 79 Diálogo de comprobación de mantenimiento de wrappers

Parte II 81


4 MANUAL DE GENERACIÓN DE SECUENCIAS

4.1 INTRODUCCIÓN

Denodo ITPilot permite generar fácilmente programas (también llamados “wrappers”) que realicen tareas de automatización y extracción de datos sobre fuentes web semi-estructuradas. Estas tareas implican normalmente la realización automática de secuencias de navegación complejas a través de sitios web, involucrando procesos de autenticación, rellenado de formularios, selección de frames, etc. Denodo ITPilot incluye un lenguaje de comandos llamado NSEQL (Navigation SEQuence Language) para la definición de secuencias de navegación complejas, que se ejecutan utilizando un pool de instancias de navegadores automatizados. Estos navegadores pueden ser de tres tipos:

• Instancias de Microsoft Internet Explorer (MSIE) [MSIE]. • Instancias de Mozilla Firefox [FRFX]. • Instancias de un mini-navegador basado en un cliente http embebido en ITPilot.

En los dos primeros casos, este lenguaje permite manejar el modelo de eventos del navegador y replica exactamente el comportamiento de un usuario humano de MSIE o Firefox que realice una secuencia de navegación cualquiera. De esta manera, para implementar navegaciones complejas, el desarrollador no precisa preocuparse de aspectos de bajo nivel tales como el uso de código JavaScript, los sistemas de mantenimiento de sesión, el uso de HTTPS, etc. En el tercer caso, las secuencias de navegación se ejecutarán normalmente de forma más eficiente pero, a cambio, el sistema no tratará con navegaciones que involucren código JavaScript. Si bien las secuencias de navegación NSEQL son sencillas de escribir [NSEQL], Denodo ITPilot incluye también, para una mayor comodidad y rapidez, el módulo Generador de Secuencias de Navegación, del que se ocupa esta sección del manual. El Generador de Secuencias de Navegación toma la forma de una barra de tareas que se instala en un navegador MSIE. Una vez instalada, el usuario puede generar una secuencia de navegación cualquiera por el sencillo método de realizarla por sí mismo en su navegador. El generador grabará los eventos generados por el usuario en su navegación, y los traducirá automáticamente a un programa NSEQL que replique su comportamiento. NOTA: Es importante destacar que los eventos necesarios para ejecutar una secuencia de navegación en un tipo de mini-navegadores no siempre coinciden con los necesarios en otro tipo. Esto quiere decir que los programas NSEQL producidos por el Generador de Secuencias de Navegación pueden necesitar ser adaptados antes de ser ejecutados con un pool de browsers configurado para utiizar navegadores Firefox o mini-navegadores basados en clientes http. Este generador también puede, opcionalmente, generar secuencias de navegación utilizando peticiones http patrón, cuyas características y diferencias con respecto a NSEQL se explican en el apartado 4.8.3.

4.2 DESCRIPCIÓN DE LA INTERFAZ DEL GENERADOR DE SECUENCIAS DE NAVEGACIÓN

La Figura 80 muestra el aspecto de la barra de tareas del Generador de Secuencias de Navegación cuando se arranca el navegador y la barra está seleccionada.

Manual de Generación de Secuencias 82


Figura 80 Barra de Tareas del Generador de Secuencias de Navegación

A continuación se describe brevemente la función de cada uno de los elementos de su interfaz:

• Open . Permite abrir y ejecutar una secuencia de navegación guardada en un fichero de disco.

• Save . Sólo está activo en modo grabación (al que se accede pulsando el botón Rec). Permite grabar en un fichero en disco la secuencia actual.

• Rec . Inicia el proceso de generación de una secuencia, solicitando al usuario la URL inicial para la misma y haciendo que el Generador pase a modo grabación, en el cuál los eventos generados por el usuario son grabados por el sistema y traducidos a comandos NSEQL. La Figura 81 muestra cómo, al añadir la URL, el usuario puede también decidir si esa URL contiene una página HTML (por defecto), o si, por el contrario, accede a un recurso almacenado con formato Microsoft Word, o Adobe PDF. En esos casos, ITPilot convertirá esos formatos en HTML (utilizando transformadores de formato incluídos en la distribución o dependientes de herramientas de terceros, tal y como se describe en el apartado 2.1.2) para que la herramienta de generación pueda ser utilizada.

Figura 81 Selección Inicial de URL

• Stop . Sólo está activo en modo grabación. Permite finalizar el proceso de generación de una secuencia, devolviendo al navegador al modo normal.

• Play. Sólo está activo en modo grabación. Permite reproducir sobre la marcha en una nueva ventana del navegador la secuencia grabada hasta el momento actual.

• SelectFrame . Sólo está activo en modo grabación. Si bien normalmente el manejo de frames es transparente al usuario, cuando se utiliza el sistema para labores de extracción de datos, a veces es necesario que el usuario especifique directamente un frame en el último paso de una secuencia de navegación. Véase la sección 4.4 para más información.



• Transpose Table . Permite transponer una tabla, transformando sus vectores fila en vectores columna, lo cuál es muy útil cuando se desean obtener resultados desde ITPilot donde cada registro es una columna, en lugar de una fila. Véase la sección 4.5.

• Domain . Puede ser necesario parametrizar las secuencias de navegación en función de ciertos valores recibidos en tiempo de ejecución a través de un wrapper creado mediante ITPilot. Véase la sección 4.7.

• Enabled PopUps . El generador de secuencias soporta la realización de secuencias de navegación que involucren acciones sobre ventanas emergentes (“pop-ups”). Para ello simplemente debe tener activado el botón “allow pop-ups” de la barra. Si no está activado, no se permitirá que aparezca ninguna ventana emergente durante la grabación de la secuencia.

• Select Anchor . El generador de secuencias permite indicar que el enlace que se va a seguir a continuación en el proceso de grabación no es un recurso HTML, sino PDF o Microsoft Word. Pulsando este botón, cuando a continuación se hace clic sobre un enlace, ITPilot convertirá ese recurso en HTML mediante conversores Word-HTML y Word-PDF, para que se pueda procesar posteriormente por parte de la herramienta de generación de especificaciones.

• CloseWindow . Si como parte de la secuencia de navegación a grabar se desea cerrar una ventana pop-up, basta pulsar sobre el botón closeWindow ( X ) de la barra y arrastrarlo sobre la ventana emergente que se desea cerrar. El evento será grabado por el generador e incorporado al programa NSEQL generado.

• Semáforo . Aparece solamente en el modo grabación. Este elemento no es un botón sino un indicador para el usuario. Cada vez que el navegador cambia de página durante la generación de una secuencia, el semáforo pone el disco rojo hasta que el sistema está nuevamente listo para seguir grabando eventos, momento en el que el disco cambia a verde. Por lo tanto, después de acceder a una nueva página durante la generación de una secuencia, el usuario debe esperar a que el semáforo se ponga en verde antes de proseguir.

• Properties . Haciendo click sobre el logo de Denodo situado a la izquierda de la barra es posible configurar diversos aspectos del funcionamiento del generador de secuencias de navegación (ver apartado 4.8).

4.3 PASOS PARA LA GENERACIÓN DE UNA SECUENCIA DE NAVEGACIÓN

En este apartado se describe paso a paso el proceso habitual para la generación de una secuencia de navegación.

1. Pulsar el botón Rec para entrar en modo grabación. 2. Un cuadro de diálogo aparece solicitando la URL de inicio de la secuencia. Puede o bien escribirse

directamente o bien pegarse desde el portapapeles (botón derecho del ratón, opción Pegar). Por ejemplo, puede utilizarse el site de ejemplo de denodo http://mail.demos.denodo.com.

3. El navegador cargará automáticamente la página inicial de la secuencia. Mientras la carga no está

completa, el semáforo aparece con el disco en rojo. 4. Una vez el disco del semáforo cambie a verde, es posible ya empezar a generar la secuencia de

navegación. Para ello debe utilizarse el navegador para generar la secuencia deseada, recordando simplemente los siguientes dos puntos:

• En cada cambio de página durante la generación de la secuencia es necesario esperar a que el

semáforo se ponga en verde antes de proseguir.



• En la generación de la secuencia, todos los eventos deben ser ejecutados utilizando el ratón. Los eventos generados a través de la utilización del teclado no serán registrados por el Generador. Por ejemplo, la ejecución del envío de un formulario debe siempre realizarse haciendo click con el ratón sobre el botón de envío y no pulsando la tecla ENTER.

En nuestro ejemplo de WebMail, podría utilizarse el sistema para generar una secuencia que acceda automáticamente al contenido de la carpeta Inbox de un usuario y ordene los mensajes por fecha. Para ello, se introducirá el identificador de usuario (e.g. demos) y la contraseña (e.g. DeMo.04), cambiando también la elección de idioma si se desea, y se pulsará sobre el botón de envío del formulario. Una vez que el semáforo cambie a verde, se pulsará en el enlace ‘Date’ para ordenar los mensajes por fecha.

5. En cualquier punto durante la generación de la secuencia, es posible utilizar el botón Play para reproducir la

porción de la secuencia generada hasta el momento. El sistema lanza una ventana del navegador dónde puede verse como se ejecuta automáticamente la secuencia generada. Un cuadro de diálogo muestra también la traza de ejecución de los comandos NSEQL. NOTA: Algunos sitios web utilizan técnicas de autenticación y mantenimiento de sesión basadas en cookies, que pueden hacer que la reproducción de una secuencia sobre la marcha no funcione adecuadamente, aún cuando en realidad la secuencia se esté generando correctamente. Véase la sección 4.8.2 para más información.

6. Una vez finalizada la secuencia deseada, y antes de pulsar el botón Stop, el programa de comandos NSEQL

generado puede grabarse en disco pulsando el botón Save y escogiendo la carpeta y el nombre de fichero que se desee. Dicho fichero contendrá, en formato texto, la secuencia de comandos NSEQL correspondiente a la secuencia de navegación generada.

7. Una vez que la secuencia se ha finalizado y se ha grabado en disco, debe pulsarse el botón Stop para

finalizar el modo de grabación y volver al modo normal. 8. Es posible ejecutar la secuencia en cualquier momento pulsando en el botón Open y seleccionando el

fichero en el que fue guardada. Es importante tener en cuenta que si la secuencia de navegación contiene alguna variable de dominio, la ejecución no será satisfactoria, pues no realiza sustitución de variables.

4.3.1 Probando Secuencias de Navegación en Sistemas con Autenticación y Mantenimiento de Sesión Basado en Cookies

Algunos sitios web utilizan técnicas de autenticación y mantenimiento de sesión basadas en cookies, que pueden hacer que la reproducción de una secuencia sobre la marcha con el botón Play no funcione adecuadamente, aún cuando en realidad la secuencia se esté generando correctamente. En particular, algunos sitios web sólo presentan formularios de autenticación a sus usuarios cuando estos acceden por primera vez al sistema después de arrancar su navegador (o bien después de transcurrido un cierto tiempo de expiración de sesión). Así, si mientras se genera una secuencia que requiera autenticación mediante login/password se intenta reproducir dicha secuencia en una nueva ventana del navegador, puede ocurrir que la reproducción falle debido a que la sesión en el sitio web sigue abierta (y, por lo tanto, no será posible localizar el formulario de login/password que sí apareció en el momento de generación). Una situación similar puede ocurrir cuando, en un sitio web, los efectos de cualquier otro evento de navegación varíen en función de si hay o no una sesión establecida. La solución a este problema es muy sencilla: la secuencia se está generando correctamente y la única dificultad surge a la hora de probarla para comprobar su correcto funcionamiento. Para vencer esta dificultad, basta seguir los siguientes pasos:

1. Cuando se desee probar la secuencia generada, guárdese la misma en disco mediante el botón Save. Manual de Generación de Secuencias 85


2. Pulsar el botón Stop para finalizar la secuencia. 3. Cerrar la sesión activa en el sitio web sobre el que se ha generado la secuencia. 4. Utilizar el botón Open para ejecutar la secuencia generada, y comprobar su correcto funcionamiento.

4.4 EL BOTÓN SELECTFRAME

Cuando la secuencia generada va a utilizarse para acceder a una página multi-frame de la que van a extraerse datos haciendo uso de las facilidades de extracción de Denodo ITPilot (véase sección 3.8 y [DEXTL]), es necesario realizar un último paso antes de finalizar la secuencia. Este paso consiste en seleccionar el frame en el que se encuentran los datos a extraer. Para ello el usuario, después de realizar la secuencia de navegación y antes de guardarla en disco y volver al modo normal, debe seguir los siguientes pasos:

1. Resaltar con el ratón un texto cualquiera del frame que se desea seleccionar. 2. Pulsar el botón SelectFrame. 3. A continuación ya se puede guardar y finalizar la secuencia de la manera habitual.

4.5 EL BOTÓN TRANSPOSETABLE

El proceso de extracción de información almacenada en tablas que sigue ITPilot obliga a que las tuplas resultado se organicen a partir de las filas de la tabla, y los campos a partir de las columnas. Así, un programa DEXTL obtendría de una tabla con n filas y m columnas, n registros, cada uno de los cuáles con m campos o atributos. La mayor parte de las veces esto es suficiente, pues es la estructura lógica de una tabla. Sin embargo, en ocasiones es interesante que cada registro de ITPilot tome sus datos de cada una de las columnas (p.e. en tablas cuyas columnas ofrecen información sobre diferentes tramos temporales, y se desea obtener esa información por período de tiempo). Aunque una posible solución es extraer la información fila a fila, para después reestructurarla desde la aplicación cliente, la herramienta de generación de secuencias NSEQL permite una opción denominada “Transpose Table” (“Transponer Tabla”, que realiza la operación de transposición de cualquier tabla que sea seleccionada con el ratón sobre la página. El proceso de transposición da la vuelta a la tabla, transformando los vectores fila en vectores columna. Veamos un ejemplo, mostrado en la Figura 82. Tenemos una tabla con dos filas y tres columnas ({A, B, C}, {D, E, F}), y nos interesa obtener sus resultados como tres registros con dos valores cada uno ({A, D}, {B, E}, {C, F}). Lo que hacemos

es seleccionar la tabla (todos sus elementos), y pulsar el botón de la barra de tareas de Denodo, ; el resultado será como el que se muestra en la Figura 83. Cualquier proceso de extracción de datos posterior tomará la tabla modificada.

Figura 82 Utilización del Botón “Transpose Table”



Figura 83 Resultado de la Ejecución de la Transposición de Tablas

4.6 EL BOTÓN SELECTANCHOR

Denodo ITPilot permite extraer información no sólo de páginas HTML, sino de recursos almacenados en formato Microsoft Word y Adobe PDF. Para ello, como ya se ha comentado, se puede indicar que la URL de inicio de la navegación referencia un recurso Word o PDF. Pero si ese recurso es accedido a través de un enlace, se ha de utilizar este botón antes de pulsar el enlace en sí para indicar a ITPilot que hará falta una transformación. Como se puede observar en la Figura 84, antes de pulsar este botón, se ha de seleccionar qué tipo de transformación será necesaria, si hacia Word o hacia PDF.

Figura 84 Selección de tipo de transformación en el comando Select Anchor

4.7 CONFIGURANDO Y UTILIZANDO DOMINIOS

En ocasiones es conveniente parametrizar las secuencias de navegación NSEQL en función de valores recibidos en tiempo de ejecución de las aplicaciones usuarias de ITPilot. Por ejemplo, si se está construyendo una secuencia para un wrapper generado mediante ITPilot, la secuencia puede incluir variables que indiquen al sistema cómo se relacionan los parámetros de la secuencia con los atributos que se reciben como entrada en las peticiones al wrapper (véase la sección 3.6). Para tratar estas situaciones visualmente, el Generador de Secuencias de Navegación incorpora el concepto de Dominio. En este contexto, un dominio es una lista de parámetros agrupados lógicamente, junto con una lista de ejemplos para dichos parámetros. Los siguientes apartados se ocupan, respectivamente, de la definición de dominios y del uso de los mismos dentro del Generador.

4.7.1 Creación de Dominios

Normalmente los dominios serán creados directamente mediante el uso del entorno de generación de Denodo ITPilot (véase apartado 3.7). Si se está utilizando el Generador de secuencias de navegación sin el resto del entorno de generación de ITPilot, entonces los dominios pueden definirse mediante ficheros XML que deben ser situados en la ruta DENODO_HOME\metadata\seqgenerator\domains. La Figura 85 muestra la definición de un dominio BOOK con parámetros buscables TITLE y AUTHOR y conteniendo dos ejemplos para el dominio, cada uno de ellos proporcionando valor para los parámetros TITLE y AUTHOR.



<?xml version="1.0" encoding="ISO-8859-1"?> <DOMAIN name="BOOK"> <SCHEMA> <FIELD name="TITLE" /> <FIELD name="AUTHOR" /> </SCHEMA> <EXAMPLES> <EXAMPLE alias="Java-Norton"> <PAIR name="TITLE" value="Java"/> <PAIR name="AUTHOR" value="Patrick Naughton" /> </EXAMPLE> <EXAMPLE alias="Tabla Flandes-Reverte"> <PAIR name="TITLE" value="Tabla de Flandes"/> <PAIR name="AUTHOR" value="Arturo Pérez-Reverte" /> </EXAMPLE> </EXAMPLES> </DOMAIN>

Figura 85 Definición del Dominio BOOK

Tal y como puede verse, la definición del dominio empieza especificando su nombre a través de la etiqueta DOMAIN. Posteriormente especifica su lista de parámetros buscables asociados mediante una lista de etiquetas FIELD agrupadas en una etiqueta SCHEMA. Finalmente, las etiquetas EXAMPLE permiten definir ejemplos que proporcionan valores para uno o varios de los parámetros del dominio. Cada ejemplo tiene también asociado un nombre.

4.7.2 Uso de Dominios

Para utilizar los dominios definidos desde la barra, deben seguirse los siguientes pasos:

1. Pulsar el botón DOMAIN. 2. Aparecerá una ventana emergente conteniendo un menú desplegable que permite seleccionar uno de los

dominios disponibles. 3. Una vez seleccionado el dominio deseado, aparecerá en la barra de tareas (al lado del botón DOMAIN o

debajo) un desplegable que permite seleccionar por su nombre uno de los ejemplos asociados al dominio. 4. Una vez escogido el ejemplo, aparecerán en la barra los valores proporcionados por el mismo para los

parámetros que componen el dominio. La Figura 86 muestra la barra de tareas con el dominio LIBRO y el ejemplo “Tabla Flandes – Reverte” seleccionados.

5. Cuando en un paso de la secuencia se desee asociar el valor de un campo de un formulario con uno de los parámetros del dominio, bastará con realizar una operación de “arrastrar y soltar” (drag & drop) que lleve el valor asociado al parámetro hasta el campo deseado del formulario. La Figura 87 muestra un gráfico de este proceso. Como resultado de esta acción, el código NSEQL creado por el Generador asociará a dicho campo una variable con el nombre del parámetro utilizado prefijado por el carácter ‘@’ (e.g. @{TITULO}). De esta manera, la secuencia podrá ser utilizada directamente dentro de la definición de un wrapper que admita a la entrada atributos con los mismos nombres que los parámetros del dominio seleccionado.

6. Los demás pasos involucrados en la generación de la secuencia permanecen inalterados.

Figura 86 Barra de Tareas con un Ejemplo Seleccionado



Figura 87 Asignando Valores de Ejemplos a Campos de Formularios

4.8 PROPIEDADES DE LA BARRA DE NAVEGACIÓN

Pulsando sobre el icono de Denodo a la izquierda de la barra, se abre un diálogo que permite configurar diversas propiedades del proceso de generación. El diálogo consta de dos paneles que permiten configurar, respectivamente, las preferencias en cuanto al criterio seguido para generar comandos NSEQL y las preferencias para proxies autenticados.

4.8.1 Generando Secuencias utilizando un Proxy Autenticado

Si el acceso a Internet se va a realizar a través de un proxy con autenticación puede ser necesario proporcionar un valor para los siguientes parámetros:

• PROXY_LOGIN: usuario en el proxy. • PROXY_PASSWORD: contraseña del usuario en el proxy. • PROXY_DOMAIN (Windows 2000): dominio Windows.

La Figura 88 muestra una vista de esta ventana.



Figura 88 Pantalla de Opciones de Proxy

4.8.2 Criterio de elección de comandos NSEQL

NSEQL [NSEQL] proporciona diversas alternativas para realizar ciertas acciones. Por ejemplo, la selección de un enlace sobre el que se ejecutará un evento click puede realizarse o bien mediante el comando CLICKONANCHORBYTEXT, que identifica un enlace en atención al texto contenido en el mismo, o bien mediante el comando CLICKONANCHORBYHREF, que identifica un enlace en función del valor de su atributo href. Si bien en la mayoría de situaciones es indiferente utilizar uno u otro criterio, puede haber ciertas situaciones en que esto no sea así. Por ejemplo, el criterio basado en texto puede ser inadecuado cuando dicho texto varía dinámicamente cada vez que se accede a la web (e.g. considérese el caso de un enlace que permite acceder a la lista de mensajes nuevos en un sistema de webmail cuyo texto indica el número de mensajes nuevos y, por lo tanto, puede ser diferente cada vez que se accede al servicio). Este panel permite variar el criterio utilizado para las familias de comandos que se refieren a la identificación de enlaces, mapas, formularios y frames. Las opciones que existen para cada familia son:

• Enlaces: texto del enlace, valor del atributo href y posición relativa en la página. • Mapas: valor del atributo href y posición relativa en la página. • Formularios: valor del atributo name, valor del atributo action y posición relativa en la página. • Frames: valor del atributo name, valor del atributo source y posición relativa en la página.

En general, el criterio menos adecuado es el de posición relativa dentro de la página ya que es más vulnerable a posibles cambios en la estructura del sitio web. Sin embargo, en ocasiones puede ser una buena opción cuando las demás alternativas se muestran como inadecuadas.



Si se fija un valor que no existe para un elemento determinado (e.g. un frame sin valor para el atributo name), el sistema intentará escoger por sí mismo otro criterio que sea más adecuado para ese elemento particular. Otro aspecto importante a tener en cuenta es que los criterios fijados para formularios y frames son globales a todala página. Lo que esto significa es que, dentro de una determinada página de la secuencia de navegación, debe utilizarse el mismo criterio de selección para todos los eventos sobre elementos del mismo tipo (frames o formularios) contenidos en ella. Si durante la generación de la secuencia de navegación se especificasen criterios diferentes para elementos del mismo tipo dentro de la misma página, el sistema asumirá siempre el último criterio fijado. Por último, esta pestaña permite seleccionar el tipo de comando NSEQL de espera de descarga de páginas por defecto. El “Normal” indica que se utilizará el comando “WaitPages”, que permite que el navegador espere a que se descargue un número de páginas determinado antes de continuar ejecutando el resto de comandos del programa NSEQL. La opción “Extended” indica la utilización de “extendedWaitPages”, que permite esta misma operación, pero dejando que sea el sistema quien averigüe el número de páginas que hacen falta para continuar la navegación. La Figura 89 muestra una vista de esta ventana de configuración.

Figura 89 Pantalla de Opciones de NSEQL

4.8.3 Elección de Tipo de Secuencia de Navegación

La herramienta de generación de secuencias de navegación permite la grabación de secuencias de navegación en dos lenguajes diferentes. Generalmente, la opción adecuada (y la que está por defecto) es la de generación de programas NSEQL; sin embargo, si la fuente web a la que se quiere acceder cumple una serie de características (que se describen a continuación), es más rápido la utilización de secuencias http patrón. Estas secuencias se basan en peticiones http (el protocolo subyacente en toda comunicación web) sin utilizar ningún navegador como intermediario, por lo que son más eficientes.



Por supuesto, la utilización directa de secuencias http no es posible en cualquier procesamiento web. En general, las fuentes web que utilicen variables de sesión, código JavaScript para procesamiento de formularios o enlaces, pop-ups, etc., no podrán hacer uso de esta opción. Para seleccionarla, desde el menú “Options” de la barra de tareas de Denodo, se selecciona la pestaña “Advanced” y en el apartado “Sequences Type” se elige la opción “http”, tal y como se muestra en la Figura 90.

Figura 90 Pantalla de Opciones de Lenguaje de Secuencias de Navegación

Desde esta pantalla también se puede configurar el tiempo máximo de espera de los navegadores al ejecutar una secuencia. Este parámetro se utiliza cuando se desea ejecutar la navegación desde la barra de tareas.

4.9 SELECCIÓN DE CONVERSORES DE PDF Y HTML

Cuando el usuario pulsa el botón Rec en la herramienta de generación de secuencias, o cuando selecciona el

tipo de “Anchor” con el botón Select Anchor , puede decidir si desea utilizar un conversor de Adobe PDF o de Microsoft Word para poder extraer información estructurada de estos tipos de recursos. El usuario tiene la posibilidad de configurar el extractor concreto que desea utilizar, de la lista provista por ITPilot. Los posibles valores que pueden seleccionarse desde el botón Select Anchor son los siguientes:

1. Word: utilización del conversor de recursos Microsoft Word a HTML. En la actualidad, ITPilot provee un conversor, que utiliza las capacidades de conversión de OpenOffice.

2. PDF: utilización del conversor de recursos Adobe PDF a HTML. En la actualidad, ITPilot provee tres conversores:

a. Acrobat HTML: utiliza el conversor a HTML del software Adobe Acrobat Professional (es necesario que este producto se encuentre instalado).



b. Acrobat Text: utiliza el conversor a texto plano del software Adobe Acrobat Professional, a partir del cuál ITPilot genera un fichero HTML (es necesario que este producto se encuentre instalado).

c. PdfBox HTML: utiliza la librería PDFBox [PDFBOX] para generar el HTML. En el caso de la conversión de PDF a HTML, es necesario que el servidor de conversión de PDF esté arrancado. Este servidor puede encontrarse en la ruta <DENODO_HOME>/bin/:

- PdfConversionsServer.exe: servidor de conversion de PDF.



5 ANEXO A: FUNCIONES ITPILOT

Este anexo describe las funciones provistas por ITPilot para la creación de atributos derivados de otros ya existentes. Las funciones de atributo derivado se utilizan para generar nuevos atributos, aplicando algún procesamiento sobre los valores de los otros atributos de la vista, sobre constantes y/o sobre el resultado de evaluar otras funciones. Una función se define como un identificador y una lista de argumentos, que pueden ser a su vez constantes, campos o nuevas funciones. En algunos casos los parámetros recibidos por una función, así como el valor que será devuelto por ellas, deben normalmente pertenecer todos al mismo tipo de datos. Por ejemplo, la función SUM puede realizar la suma de dos o más valores enteros, de dos o más valores en punto flotante o de dos o más valores de tipo double pero no realizará, la suma de un valor entero y de un valor en punto flotante. Además, algunas funciones, sólo operarán con elementos pertenecientes a un tipo de dato concreto. ITPilot proporciona una serie de funciones predefinidas, que pueden agruparse en diferentes tipos, en base al tipo de datos sobre las que se aplican:

- Funciones aritméticas - Funciones para el manejo de texto - Funciones para el manejo de listas - Funciones para el manejo de fechas - Funciones de manejo de URLs - Funciones de manejo de páginas

En los siguientes apartados se describen las funciones soportadas por el sistema. NOTA: La notación de funciones es prefija, es decir, se indica un identificador seguido de una lista de parámetros entre paréntesis y separados por comas.

5.1 FUNCIONES ARITMÉTICAS

Las funciones aritméticas se aplican sobre atributos y literales de tipo numérico, int, long, float y double, con la restricción de que todos los parámetros deben de poseer el mismo tipo. Permiten realizar cálculos matemáticos sobre atributos y literales. Las funciones aritméticas soportadas son:

• SUM: La función suma recibe un número variable de argumentos (mayor o igual a dos) y devuelve como resultado un nuevo elemento del mismo tipo conteniendo la suma de los anteriores.

• SUBSTRACT: La función resta recibe dos argumentos y devuelve un nuevo elemento del mismo tipo con el resultado de restar del primer argumento el valor del segundo.

• MULT: La función producto recibe un número variable de argumentos (mayor o igual a dos) y devuelve un nuevo elemento del mismo tipo con el resultado del producto entre los diferentes argumentos.

• DIV: La función división recibe dos argumentos de tipo numérico y devuelve un nuevo elemento del mismo tipo con el resultado de dividir el primer argumento por el segundo. Si los argumentos son enteros, el resultado de la división será también entero.

• ABS: La función valor absoluto recibe un único argumento de tipo numérico y devuelve como resultado su valor absoluto.

• MOD: La función módulo recibe dos argumentos de tipo numérico no decimal y devuelve el resultado de la operación módulo entre el primer argumento y el segundo (el resto de la división entera entre el primer argumento y el segundo).

Anexo A: Funciones ITPilot 94


• CEIL: Esta función recibe un argumento numérico y devuelve el menor entero, mayor o igual que el argumento, más próximo al argumento.

• FLOOR: Esta función recibe un argumento numérico y devuelve el mayor entero, menor o igual que el argumento, más próximo al argumento.

• ROUND: Esta función recibe un argumento numérico y devuelve como resultado el número entero más próximo al argumento.

• POWER: Esta función recibe dos argumentos numéricos, el segundo de los cuáles debe ser entero. Devuelve como resultado un valor de tipo double obtenido mediante la exponenciación del primer argumento con el segundo como exponente.

• SQRT: Esta función recibe un argumento numérico y devuelve un valor de tipo double con el resultado de obtener la raíz cuadrada del argumento.

• LOG: Esta función recibe un valor numérico y devuelve un valor de tipo double con el resultado de obtener el logaritmo en base 10 del argumento.

5.2 FUNCIONES DE MANEJO DE TEXTO

Las funciones de manejo de texto tienen como objetivo realizar alguna transformación o cálculo sobre un atributo o literal de tipo texto.

• CONCAT: La función concatenación recibe un número variable de argumentos, y permite obtener un elemento de tipo texto como resultado de concatenar sus parámetros.

• ISNOTNULL: La función recibe como parámetro un argumento de tipo entero, cadena de caracteres, fecha, url, un valor booleano o una lista de registros, devolviendo “true” si el valor indicado no es nulo, y “false” en caso contrario.

• ISNULL: La función recibe como parámetro un argumento de tipo entero, cadena de caracteres, fecha, url, un valor booleano o una lista de registros, devolviendo “true” si el valor indicado es nulo, y “false” en caso contrario.

• LEN: La función len recibe como parámetro un argumento de tipo texto, y devuelve el número de caracteres que lo forman.

• REPLACE: Esta función recibe 3 argumentos de tipo texto y devuelve el resultado de reemplazar en el primero las ocurrencias del segundo, por el tercero.

• LOWER: Esta función recibe un argumento de tipo texto y lo devuelve a la salida con todos los caracteres que lo forman convertidos a minúsculas.

• UPPER: Esta función recibe un argumento de tipo texto y lo devuelve a la salida con todos los caracteres que lo forman convertidos a mayúsculas.

• SUBSTRING: La función substring recibe como parámetros un argumento de tipo texto y dos números enteros. Devuelve a la salida la parte del substring del primer argumento que se corresponde a las posiciones indicadas por el segundo (inicio) y tercer (fin) argumentos.

• REGEXP: Esta función permite realizar transformaciones sobre cadenas de caracteres basadas en expresiones regulares. Recibe tres argumentos: un elemento de tipo texto, una expresión regular “de entrada” y una expresión regular “de salida”. Las expresiones regulares deben expresarse utilizando la sintaxis de expresiones regulares del lenguaje JAVA [REGEX]. La función se comporta de la forma siguiente: la expresión regular de entrada se evalúa contra el texto del primer argumento y la expresión regular de salida puede incluir los “grupos” definidos en la expresión regular de entrada. Las porciones de



texto que hayan encajado con los mismos se sustituirán en la expresión de salida. Por ejemplo, el resultado de evaluar:

REGEXP(‘Shakespeare,William’,‘(\\w+),(\\w+)’,‘$2 $1’) será el valor de tipo texto ‘William Shakespeare’.

• REMOVEACCENTS: Esta función recibe un argumento de tipo texto y devuelve el mismo argumento, una vez le ha eliminado los acentos.

• REMOVEWHITESPACES: Esta función recibe un argumento de tipo texto y devuelve el mismo argumento una vez le ha eliminado los espacios en blanco.

• SIMILARITY: Esta función recibe dos cadenas de caracteres y devuelve un valor entre 0 y 1, que es una medida de la similitud estimada entre las cadenas. El tercer parámetro (opcional) especifica el algoritmo a utilizar para calcular la medida de similitud. ITPilot incluye los siguientes algoritmos (si no se especifica ningún algoritmo, ITPilot escogera cuál aplicar):

a. Basados en la distancia de edición entre las cadenas de los textos: ScaledLevenshtein, JaroWinkler, Jaro, Level2Jaro, MongeElkan, Level2MongeElkan.

b. Basados en la aparición de términos comunes en los textos: TFIDF, Jaccard, UnsmoothedJS.

c. Combinaciones de ambos: JaroWinklerTFIDF.

• TRIM: Esta función recibe un argumento de tipo texto y devuelve el mismo argumento, una vez le ha eliminado espacios y retornos de carro iniciales y finales.

5.3 FUNCIONES DE MANEJO DE LISTAS

• SIZE: Esta función acepta como argumento una lista, y devuelve el número de elementos que la componen.

• ELEMENTAT: esta función acepta como argumentos de entrada una lista y un entero, y devuelve el registro que se encuentra en la posición expresada por el valor entero dentro de la lista. La primera posición de la lista se accede mediante el valor 0.

5.4 FUNCIONES DE MANEJO DE FECHAS

Las funciones de manejo de fechas permiten obtener fechas y elementos concretos de una fecha.

• NOW: Esta función no recibe ningún argumento y crea un objeto de tipo date conteniendo la fecha actual.

• GETDAY: Recibe un argumento de tipo date y devuelve un objeto de tipo long que representa el día de la fecha recibida. Si no recibe argumentos crea un objeto de tipo long que representa el día actual.

• GETHOUR: Recibe un argumento de tipo date y devuelve un objeto de tipo long que representa la hora de la fecha recibida. Si no recibe argumentos crea un objeto de tipo long que representa la hora actual.

• GETMINUTE: Recibe un argumento de tipo date y devuelve un objeto de tipo long que representa el minuto de la fecha recibida. Si no recibe argumentos crea un objeto de tipo long que representa el minuto actual.



• GETSECOND: Recibe un argumento de tipo date y devuelve un objeto de tipo long que representa el segundo de la fecha recibida. Si no recibe argumentos crea un objeto de tipo long que representa el segundo actual.

• GETMONTH: Recibe un argumento de tipo date y devuelve un objeto de tipo long que representa el mes de la fecha recibida. Si no recibe argumentos crea un objeto de tipo long que representa el mes actual.

• GETYEAR: Recibe un argumento de tipo date y devuelve un objeto de tipo long que representa el año de la fecha recibida. Si no recibe argumentos crea un objeto de tipo long que representa el año actual.

• TODATE: Permite convertir cadenas de texto que representan fechas en elementos de tipo date. Recibe tres argumentos de tipo texto. El primero de ellos representa un patrón para expresar fechas (siguiendo la sintaxis estándar en el lenguaje JAVA especificada en [DATEFORMAT]) mientras el segundo será una fecha expresada de acuerdo al mencionado patrón. El tercero, opcional, es un parámetro de tipo texto que indica la configuración de internacionalización que representa el “locale” de la fecha a procesar. Como resultado se devuelve un elemento de tipo date equivalente a la fecha especificada.

5.5 FUNCIONES DE TRATAMIENTO DE URLS

• ENCODE: Esta función recibe como argumento un valor de tipo URL y realiza su codificación (“encoding”). Esto es necesario cuando se desean utilizar caracteres diferentes de aquellos admitidos por las URLs [RFC1738]. Esta función se transformar automáticamente aquellos caracteres inválidos por su codificación correspondiente.

• URLTOSTRING: Esta función recibe como argumento un valor de tipo URL, y obtiene su valor como tipo string.

• TOURL: Esta función recibe como argumento un valor de tipo string que representa una URL, y devuelve el mismo valor pero con tipo de dato URL.

5.6 FUNCIONES DE TRATAMIENTO DE PÁGINAS

• GETLASTURL: Esta función recibe como argumento un objeto de tipo página (Page) y devuelve su URL en una cadena de caracteres.

• GETLASTURLMETHOD: Esta función recibe como argumento un objeto de tipo página (Page) y devuelve su método de acceso (GET o POST) en una cadena de caracteres.

• GETLASTURLPOSTPARAMETERS: Esta función recibe como argumento un objeto de tipo página (Page) y devuelve una cadena de caracteres con los parámetros de tipo POST que han sido utilizados para acceder a esa página.

• GETCOOKIES: Esta función recibe como argumento un objeto de tipo página (Page) y devuelve una cadena de caracteres con las “cookies” actuales.

• GETPAGETYPE: Esta función recibe como argumento un objeto de tipo página (Page) y devuelve una cadena de caracteres con el tipo de acceso (pool ó http).

• TOPAGE(String connection_type, String url, String url_method,String post_parameters, String cookies): Esta function recibe como argumentos el tipo de conexión, la URL, el método de acceso, los parámetros de post y las cookies de una página, y devuelve un objeto de tipo página (Page) que representa el estado de esa página en concreto.



6 ANEXO B: CATÁLOGO DE COMPONENTES

Este anexo lista y define cada uno de los componentes disponibles en Denodo ITPilot para su utilización en el entorno de generación de wrappers.

6.1 ADD RECORD TO LIST

6.1.1 Descripción

Añade un registro a una lista. Este componente debe utilizarse cuando existe una lista previa (p.e. creada mediante el componente CreateList, sección 6.3) a la que se desean añadir nuevos registros.

6.1.2 Parámetros de Entrada

Registro: registro que va a añadirse a la lista. El número y tipo de campos del registro han de ser consistentes con respecto a los existentes en la lista (si no lo fuese, un error aparecerá en pantalla con la descripción “Input List has a different record type than the selected one”.

Lista objetivo: nombre de la lista sobre la cuál se añade el nuevo registro.

6.1.3 Valores de Salida

Este componente no devuelve ningún elemento.

Anexo B: Catálogo de Componentes 98


6.2 CONDITION

6.2.1 Descripción

Permite definir una condición. Dos conexiones de salida determinan el flujo del proceso dependiendo de si la condición se cumple o no.


Cero o más valores, cero o más registros , cero o más listas.


Este componente no devuelve ningún elemento.

6.2.4 Ejemplo

Tomemos como caso el presentado en la figura Figura 91. Tras la extracción de información de un recurso web por parte de un componente Extractor, el proceso itera sobre cada uno de los resultados obtenidos. Supongamos que sólo se desea mostrar aquél conjunto de resultados tales que el valor de uno de sus parámetros coincida con un parámetro de entrada provisto por el usuario (mediante la utilización del componente Init). Para ello, como se puede observar, se utiliza un componente Condition; dependiendo del resultado de la ejecución de la expresión de condición descrita (“true” o “false”), el proceso accederá al componente Record Constructor para generar el registro final de salida, o sencillamente irá hasta el final de la iteración para, si es conveniente, seguir iterando. Utilizando el “wizard” de creación del componente se puede crear una expresión de condición.



Figura 91 Utilización del componente Condition

6.2.5 Utilización del Editor de Condiciones

El editor de condiciones (ver Figura 92) permite crear condiciones de selección. La condición puede escribirse directamente en la caja ‘Selection Condition’ o puede crearse de manera totalmente gráfica. A continuación se describe este último proceso. En la parte izquierda de la pantalla encontramos menús para crear diversos valores que pueden aparecer como operandos en las condiciones:

• Constantes. Este menú permite crear constantes de los diversos tipos de dato soportados por ITPilot. • Funciones. Este menú permite crear una invocación a una de las funciones permitidas por ITPilot. Las

funciones pueden recibir como parámetros constantes, atributos o el resultado de evaluar otras funciones. Devuelven un único resultado. La lista de funciones disponibles y el uso de cada una de ellas puede consultarse en el anexo A, 5.

• Atributos. Se corresponde con la lista de atributos sobre la que se aplica la condición.



Figura 92 Editor de Condiciones

En la parte derecha de la pantalla encontramos menús para seleccionar los diversos operadores que pueden aparecer en las condiciones:

• Operadores de condición. • Operadores lógicos (AND, OR, NOT). Se utilizan para combinar las diferentes condiciones simples en una

expresión booleana. Las cajas centrales de la pantalla permiten la construcción de, de arriba a abajo, tres tipos de elementos: valores que aparecerán en las condiciones, condiciones simples y condiciones booleanas compuestas. La caja de la izquierda de cada grupo es un espacio de trabajo para la creación de nuevos elementos mientras que la caja de la derecha muestra los elementos ya creados. Los siguientes subapartados describirán con más detalle la creación de cada uno de estos tipos de elementos. Por último, la caja “Result condition” contendrá la condición finalmente creada.

6.2.5.1 Creación de valores para las condiciones

Para crear un nuevo valor constante deben realizarse las siguientes acciones:

1. Seleccionar el tipo de dato de la constante en el desplegable ‘Constants’ de la parte izquierda de la pantalla y hacer ‘click’ o drag & drop sobre el espacio de trabajo de creación de valores (caja superior izquierda).


3. Al pulsar el botón ‘>’ la nueva constante aparecerá en la lista de valores creados (caja superior derecha). Para crear un nuevo valor de tipo función, deben realizarse las siguientes acciones:



1. Seleccionar la función deseada en el desplegable ‘Functions’ de la parte izquierda de la pantalla y hacer ‘click’ o drag & drop sobre el espacio de trabajo de creación de valores (caja superior izquierda).

2. Aparecerá en el espacio de trabajo la función seleccionada, junto con un área para rellenar el valor de cada parámetro de la función. Los valores de los parámetros deben estar presentes en la lista de valores creados (caja superior derecha). Para asignar un valor ya creado como parámetro de una función, se hará una operación de drag & drop que lleve el valor creado al área del parámetro. Al pulsar el botón ‘>’ que aparece al lado de la función, ésta aparecerá en la lista de valores creados (caja superior derecha).

6.2.5.2 Creación de condiciones simples

Para crear una nueva condición simple deben realizarse las siguientes acciones:

1. Seleccionar el operador de condición simple deseado en los desplegables de la parte derecha de la pantalla y hacer ‘click’ o drag & drop del mismo sobre el espacio de trabajo de creación de condiciones simples (caja central izquierda).

2. Aparecerá en el espacio de trabajo el operador seleccionado junto con un área para rellenar sus operandos. Los operandos pueden ser o bien atributos de la vista de entrada (presentes en el desplegable “Fields” de la parte izquierda de la pantalla) o valores ya creados (cuya lista se muestra en la caja superior derecha). Para asignar un atributo o un valor ya creado como operando de la condición, se hará una operación de drag & drop que lleve el elemento al área del parámetro. Al pulsar el botón ‘>’ que aparece al lado de la condición, ésta aparecerá en la lista de condiciones ya creadas (caja central derecha).

6.2.5.3 Creación de condiciones booleanas

Para crear una nueva condición booleana deben realizarse las siguientes acciones:

1. Seleccionar el operador booleano deseado (AND, OR o NOT) en los desplegables de la parte derecha de la pantalla y hacer ‘click’ o drag & drop del mismo sobre el espacio de trabajo de creación de condiciones booleanas (caja inferior izquierda).

2. Aparecerá en el espacio de trabajo el operador seleccionado junto con un área para especificar sus operandos. Los operandos pueden ser condiciones simples ya creadas (cuya lista se muestra en la caja central derecha) u otras condiciones booleanas creadas previamente. Para asignar una condición ya creada como operando de la nueva condición booleana, se hará una operación de drag & drop que lleve la condición al área del operando. Al pulsar el botón ‘>’ que aparece al lado de la condición booleana, ésta aparecerá en la lista de condiciones booleanas ya creadas (caja inferior derecha).

Finalmente, se realizará una operación de drag & drop de la condición que se desee añadir a la selección a la caja “Result Condition”. Al pulsar ‘ok’, se volverá a la página de creación del proceso, con la condición ya creada.



6.3 CREATE LIST

6.3.1 Descripción

Crea una lista vacía. Algunos componentes requieren como campo de entrada una lista de registros; en otros casos, la lista resultado de un componente necesita ser enriquecida con información procedente de otras partes del proceso.


Este componente no requiere ningún parámetro de entrada.


Este componente devuelve una lista vacía.



6.4 DIFF

6.4.1 Descripción

El componente Diff permite comparar dos páginas web, devolviendo las diferencias existentes entre ellas, en cuanto al código HTML obtenido.


Este componente cuenta con los siguientes parámetros de entrada. Por una parte, una cadena de caracteres, “Original page source code", que contendrá el código fuente de la página inicial. La página con la que se comparará puede introducirse de dos maneras: o como una cadena de caracteres que contenga el código de la página, o como un objeto de tipo página, como el devuelto por un componente Sequence. Si se utiliza esta última opción, su URL base se utilizará como URL base del código HTML de salida.


El componente devuelve una cadena de caracteres que contiene el código HTML de una página que muestra las diferencias entre las páginas introducidas como parámetros de entrada del componente

6.4.4 Utilización

En algunos casos las decisiones a tomar en el proceso de automatización web han de realizarse a partir, no tanto de los registros obtenidos, sino de cambios en las páginas sobre las que el proceso navega. Para ello, el componente Diff permite encontrar la diferencia entre dos páginas HTML (generalmente la misma página en dos momentos diferentes). Para ello, a partir de la información de entrada, el componente puede configurarse con los siguientes parámetros, mostrados en la Figura 93.



Figura 93 Editor de Condiciones

• Prefix for new content; esta caja de texto indica cuál es el prefijo a utilizar al generar la página resultado para el contenido nuevo (por defecto, etiqueta HTML de fondo en verde).

• Suffix for new content: esta caja de texto indica cuál es el sufijo a utilizar al generar la página resultado para el contenido nuevo (por defecto, etiqueta HTML de fin de fondo en verde).

• Show removed content: esta casilla de selección permite indicar si se requiere la configuración de prefijo y sufijo de contenido eliminado; esto quiere decir que si esta opción no está marcada, las partes eliminadas no serán mostradas. Dependiendo de esta opción, las siguientes dos opciones están habilitadas o no.

• Prefix for removed content: esta caja de texto indica cuál es el prefijo a utilizar al generar la página resultado para el contenido eliminado (por defecto, etiqueta HTML de fondo en rojo).

• Suffix for removed content: esta caja de texto indica cuál es el sufijo a utilizar al generar la página resultado para el contenido nuevo (por defecto, etiqueta HTML de fin de fondo en rojo).

• Case sensitive: indica si el marcado de cambios es sensible a mayúsculas. Por defecto no está marcado.

• Ignore tag attributes: esta casilla de selección permite configurar si se desea que, cuando se están comparando las páginas, se ignoren los atributos de las etiquetas HTML. Esto no afecta al proceso de generación de la página HTML resultado. Por defecto, esta opción no está seleccionada.

• Return null if page has not changed: esta casilla de selección (marcada por defecto) indica que si la página resultado es igual a alguna de las dos páginas de entrada, el componente devuelva “null” en lugar de la página en sí.



6.5 EXECUTE JAVASCRIPT

6.5.1 Descripción

Este componente permite añadir un código JavaScript que será ejecutado en la página actual del navegador.


El componente Execute JavaScript acepta una página de entrada (obligatoria).


El valor de salida del componente será una página resultado de la ejecución del código JavaScript.



6.6 EXPRESSION

6.6.1 Descripción

Permite definir una expresión (a partir de constantes y/o utilización de las funciones provistas por ITPilot) que será evaluada a un valor de salida.


Este componente acepta cero o más valores, cero o más registros o cero o más listas de registros.


Este componente devuelve el valor definido, o un registro que lo contenga.

6.6.4 Ejemplo

La Figura 94 muestra una parte de un proceso que utiliza el componente expresión para inicializar una variable (p.e. CURRENTPAGE) a 1. La Figura 96 muestra cómo inicializarlo es tan sencillo como asignar una constante entera como resultado de la expresión .

Figura 94 Componente Expresión de inicialización de variable

Tras esta inicialización, otro componente Expression puede utilizarse dentro de un bucle (ya sea un componente Loop, un Repeat o algún Iterator) para actuar como contador, en este caso de páginas (ver Figura 95):

Figura 95 Utilización de un componente Expression como contador de páginas

La definición de la expresión se realiza desde el editor de expresiones, cuyo manejo se describe a continuación.

6.6.5 Utilización del Editor de Expresiones

El editor de expresiones se muestra en la Figura 96. La expresión se construye de manera totalmente gráfica o escribiendo en la caja “Expression Value”. A continuación se describe el proceso gráfico del editor. En la parte izquierda de la pantalla encontramos menús para crear diversos valores que pueden aparecer como operandos en las expresiones:



• Constantes. Este menú permite crear constantes de los diversos tipos de dato soportados por ITPilot. • Funciones. Este menú permite crear una invocación a una de las funciones permitidas por ITPilot, y

descritas en el Anexo A, 5. Las funciones pueden recibir como parámetros constantes, atributos o el resultado de evaluar otras funciones. Devuelven un único resultado.

• Atributos. Se corresponde con la lista de atributos del programa envoltorio. Los atributos pueden actuar como parámetros de funciones.

Figura 96 Creación de un valor constante en el Editor de Expresiones

Las cajas centrales de la pantalla permiten la construcción de expresiones. La caja de la izquierda es un espacio de trabajo para la creación de nuevas expresiones mientras que la caja de la derecha muestra las expresiones ya creadas. Por último, la caja “Expression value” contendrá la expresión finalmente creada. Para crear una nueva expresión constante deben realizarse las siguientes acciones:

1. Seleccionar el tipo de dato de la constante en el desplegable ‘Constants’ de la parte izquierda de la pantalla y hacer ‘click’ o drag & drop sobre el espacio de trabajo de creación de expresiones (caja izquierda).


3. Al pulsar el botón ‘>’ la nueva constante aparecerá en la lista de valores creados (caja superior derecha).



Figura 97 Creación de un valor constante en el Editor de Expresiones

Para crear una nueva expresión de tipo función, deben realizarse las siguientes acciones:

1. Seleccionar la función deseada en el desplegable ‘Functions’ de la parte izquierda de la pantalla y hacer ‘click’ o drag & drop sobre el espacio de trabajo de creación de expresiones (caja izquierda).

2. Aparecerá en el espacio de trabajo la función seleccionada, junto con un área para rellenar el valor de los parámetros de la función. Los valores de los parámetros deben ser o bien expresiones presentes en la lista de valores creados (caja derecha) o bien atributos. Para asignar una expresión ya creada como parámetro de una función, se hará una operación de drag & drop que lleve la expresión creada al área del parámetro. Al pulsar el botón ‘>’ que aparece al lado de la función, ésta aparecerá en la lista de expresiones creadas (caja derecha).

La Figura 97 muestra un ejemplo en el que una expresión sirve de contador de páginas.



6.7 EXTRACTOR

6.7.1 Descripción

Se encarga de extraer información estructurada de una página HTML, generando por tanto un programa DEXTL ([DEXTL]).


Este componente admite como entrada un elemento de tipo Página (p.e. como la devuelta por un componente Sequence)., que es la utilizada como base para la extracción de información.


El componente Extractor devuelve una lista de registros con los resultados obtenidos tras el proceso de extracción de información de la página HTML.

6.7.4 Detalles del componente

Ver sección 3.8 para una explicación detallada del componente.



6.8 FETCH

6.8.1 Descripción

Este componente obtiene el contenido de la URL o página utilizadas como argumento de entrada, y lo devuelve, ya sea en formato binario o textual.


• Opcionalmente, un valor de tipo URL

• Opcionalmente, una página

De esa manera, el comportamiento del componente es como sigue:

• Si se asigna un valor de tipo URL, el componente Fetch accederá a esa URL y descargará en el formato configurado en el “wizard” (binario o textual) el contenido del recurso al que se accede. Se permite cargar un fichero de disco utilizando la ruta LOCAL en el “Connection Type” del wizard.

• Si además se utiliza una página de entrada (“Input Page”), el valor URL se utiliza por parte del componente como recurso a obtener localmente a esa página (p.e. URL podría tener asignado el valor “image.jpg”, por lo que intentaría acceder al recurso image.jpg existente en la página de entrada).

• Si sólo se asigna un valor para el campo “Input Page”, el componente Fetch obtendrá el contenido del recurso al que apunte ese elemento.


Valor de tipo cadena o binario.



6.9 FILTER

6.9.1 Descripción

Este componente realiza una operación de filtrado sobre una lista de registros, devolviendo sólo aquellos que cumplan una condición dada.


El componente espera como entrada una lista de registros y, opcionalmente, uno o más registros y uno o más valores (los registros y los valores pueden ser utilizados para construir la condición de filtrado).


El componente Filter devuelve la lista filtrada de registros (lista vacía si no hay ninguno).

6.9.4 Ejemplo

La Figura 98 muestra parte de un proceso ITPilot que filtra los resultados obtenidos por un componente Extractor antes de iterar sobre ellos.

Figura 98 Utilización del componente Filter

El componente Extractor ha extraído estructuradamente la lista de mensajes de correo electrónico, tal y como se explicó en el apartado 3.8. Antes de que la lista de resultados sea iterada por el componente Iterator, se desea filtrar por el campo DATE (de tipo String), para que la iteración se realice tan sólo por aquellos mensajes cuya fecha sea anterior a una determinada (p.e. 1 de Febrero de 2007). Para ello, se realizan los siguientes pasos:

1. Crear un componente Filter y posicionarlo en el proceso tal y como se muestra en la figura anterior.



2. La entrada del componente será la lista de registros devuelta por el componente Extractor. 3. El “wizard” del componente Filter nos permite abrir un editor de condiciones para crear una expresión de

condición que será evaluada para cada elemento de la lista de registros del argumento de entrada; si la condición se cumple, ese elemento será uno de los supervivientes. Este editor se explica en detalle en la sección 6.2.5 de este mismo manual. Las acciones concretas para filtrar por fecha se muestran a continuación:

a. Se crea una condición simple que, básicamente, establece que el valor del atributo “DATE” del registro tiene que ser menor que una fecha específica (p.e. 1 de Febrero de 2007). Así que para empezar se arrastra el operador de condición “<” desde el lado derecho del editor hacia el panel izquierdo del área “Simple Conditions”.

b. Puesto que se desea comparar dos fechas, pero el atributo DATE es de tipo cadena de caracteres, se requiere su conversión a un tipo fecha que permita esa comparación.Para ello, se hará uso de la función TODATE, arrastrándola desde la lista de funciones (área “Functions” a la izquierda del editor). La función TODATE, tal y como se explica en la sección 5 (Apéndice A). El primero determina el formato de fecha, mientras que el segundo es la cadena de caracteres que representa la fecha concreta. En este caso, el formato de fecha es MM/dd/yyyy (dos caracteres para el mes, una barra inclinada, dos caracteres para el día, una barra inclinada, y cuatro caracteres para el año), por lo que se debe crear una constante de tipo cadena, y asignarla al valor “MM/dd/yyyy”. Entonces, se crea otra constante de tipo cadena donde asignar la fecha de comparación, (02/01/2007). La Figura 99 muestra el estado del proceso hasta ahora.

Figura 99 Creación de las constantes de tipo cadena

c. Ahora han de crearse las funciones que convertirán los valores de tipo cadena en fechas. Por tanto, debemos arrastrar la función TODATE al panel izquierdo del área “Values”, para, a continuación, asignarle como parámetros tanto la constante “MM/dd/yyyy” como “02/01/2007”, en ese orden. Estas acciones crean el operando derecho de la condición de filtro. Ver figura Figura 100.



Figura 100 Creación de la fecha de comparación

d. Ahora es necesario crear el operando izquierdo de esa condición. Se arrastra otra instancia de la función TODATE, y se alimenta con la cadena “MM/dd/yyyy” como primer argumento, y con el atributo DATE del registro WMAILDEMO , que se encuentra originalmente en la lista de “Input Values” en la parte izquierda del editor.

e. A punto de terminar, arrastraremos ambas funciones TODATE a la condición creada en el paso (a). Primero la función creada en (d) como operando izquierdo, y después la creada en (c) como operando derecho. Ver figura Figura 101.

.



Figura 101 Creación de la condición de filtrado

f. Para finalizar, tan solo necesitamos arrastrar la condición al area “Result Condition” y pulsar “Ok”. Ver Figura 102.

Figura 102 Generación de la condición resultado



6.10 FORM ITERATOR

6.10.1 Descripción

Este componente permite generar un bucle de ejecución de un formulario concreto donde en cada iteración se utilizan valores diferentes para cada uno de los campos que lo conforman.


Como parámetro de entrada el Form Iterator requiere los siguientes elementos:

• La página de entrada donde se encuentra el formulario sobre el cuál iterar.

• Cero o más listas de registros, cero o más valores, cero o más registros, que se pueden utilizar en la generación de las secuencias de búsqueda y ejecución del formulario concreto.


Como valor de retorno, este componente devuelve, en cada iteración, la página generada tras la ejecución del formulario.

6.10.4 Ejemplo

Se desea obtener información sobre vacaciones en Estados Unidos, a través de una fuente de ofertas inmobiliarias. Esta fuente ofrece un formulario de búsqueda donde se puede introducir un conjunto de términos de búsqueda en una caja de texto, pero además consta de un seleccionable donde elegir qué tipo de complejo se desea para el periodo estival (apartamento, casa de verano, subarrendamiento, venta, …). Con ITPilot podría crearse un proceso que aceptase como argumento de entrada el tipo de complejo sobre el que buscar, pero si se desea buscar sobre varios, sería necesario crear una lista de entrada proporcionada por el usuario. De una manera más sencilla, el componente FormIterator permite configurar los valores de entrada de un formulario, de forma que se indique sobre cuáles se desea iterar de manera dinámica. El componente, en cada iteración, asignará una de las combinaciones posibles de argumentos de entrada del formulario y lo ejecutará. La Figura 103 muestra parte del proceso descrito. Un componente Sequence posiciona un navegador en la página de entrada de información en un formulario. A continuación, se añade un componente FormIterator cuyo resultado en cada iteración es una página utilizada por un Extractor para obtener los datos requeridos. Los pasos a seguir para configurar el componente FormIterator son los siguientes:

1. Como información de entrada, el componente recibe la página resultado del componente Sequence. Además, puede recibir opcionalmente listas, registros o valores que podrán ser utilizados como valores de entrada en el formulario deseado.



Figura 103 Utilización del componente FormIterator

2. El “wizard” del componente se divide en tres pestañas:

a. “Values”: permite asignar los diferentes valores de iteración a cada uno de los campos del formulario. Para ello, primero hay que informar a ITP del formulario sobre el que se desea iterar. Para ello, es necesario realizar los siguientes pasos:

i. Abrir un navegador desde la opción de menú Browser->New Browser, y navegar hasta la página del formulario.

ii. Marcar el formulario deseado de la página. Para ello, sólo hay que seleccionar parte del texto asociado a ese formulario (ver Figura 104).

Figura 104 Marcado de parte del formulario

iii. Pulsar el botón “Import Selected Form”. En el editor del “wizard” se mostrará información de cada uno de los campos del formulario, junto con sus valores; además, a la izquierda se muestran los valores de entrada (ver Figura 105).



Figura 105 Importación de información del formulario

iv. Ahora, para los campos seleccionables (listas de selección, casillas de verificación,…) se pueden escoger los diferentes valores que se quieren usar en las iteraciones. Para los campos de texto, se pueden introducir valores constantes o arrastrar un atributo cuyo valor se quiere utilizar (ver Figura 106). Con estos pasos, ya se informa a ITPilot de qué valores ha de utilizar en las diferentes iteraciones. El número de iteraciones se corresponde con el total de combinaciones de estos datos (p.e. si se introducen dos posibles valores en un desplegable, y dos valores en un campo de texto, el componente iterará 4 veces).

Figura 106 Selección de valores en los campos del formulario



b. En la siguiente pestaña, “Navigation”, es donde se configuran las secuencias de búsqueda del formulario dentro de la página (generalmente ésta se encuentra ya definida cuando se importa el formulario en la pestaña anterior), y de envío del formulario. En este caso esta secuencia puede cargarse de fichero o importarse del navegador, tal y como se explicó en la sección 3.7, o se puede delegar a ITPilot la generación automática de la secuencia mediante el botón “Suggest” (ver Figura 107). Es en esta pestaña, además, donde se puede configurar el número de reintentos que se ejecutarán en caso de error en la secuencia de navegación.

Figura 107 Selección de valores en los campos del formulario

c. Por último, la pestaña “Configuration” se utiliza para diferentes acciones, tales como la limitación en el número total de iteraciones, la posibilidad de ejecutar las iteraciones en paralelo y el número máximo de iteraciones en paralelo que se pueden realizar, reutilizar la conexión actual de manera que se utilice el mismo navegador en cada iteración (lo cuál, como se explica en la sección 3.16.3, puede ser inadecuado en iteraciones ejecutadas en paralelo). También se configura el orden en que se utilizan los atributos, lo cuál afecta al orden de las combinaciones.



Figura 108 Pestaña de configuración del componente Form Iterator

3. Con esto, ya tenemos listo el componente. Se puede probar independientemente mediante el botón “Test”

(para ello es necesario contar con un navegador posicionado en la página del formulario), y utilizar el editor de depuración, tal y como se explica en la sección 3.14.2).



6.11 ITERATOR

6.11.1 Descripción

Este componente itera sobre una lista de registros, de uno en uno.


Se espera como entrada la lista de registros sobre los cuáles se va a iterar.


El componente devolverá, en cada iteración, el registro correspondiente dentro de la lista de entrada. El orden es el de introducción de datos en la lista.


Ver sección 3.12.1 para una explicación detallada del componente.



6.12 JDBCEXTRACTOR

6.12.1 Descripción

Este componente envía una consulta a cualquier fuente accesible a través del protocolo JDBC, devolviendo una lista de registros (de tipo Record) que contiene los resultados obtenidos.


El componente JDBCExtractor acepta como entrada cero o más registros, cero o más valores. Estos elementos se utilizan para asignar variables a los parámetros de configuración del componente.


Una lista de registros, donde la estructura del registro viene definida por la consulta realizada sobre la base de datos.

6.12.4 Ejemplo

En muchos casos las aplicaciones web de las cuáles se quieren extraer datos requieren parámetros de entrada que se encuentran almacenados en otros repositorios. Por ejemplo, los identificadores de trabajadores de una entidad financiera, que van a ser utilizados por esa misma entidad para acceder a su intranet y así realizar control de calidad de servicio de sus aplicaciones internas. Con ITPilot, realizar esta acción se simplifica mediante la utilización del componente JDBCExtractor. La Figura 109 muestra parte del proceso realizado. El componente realiza una consulta a una base de datos relacional, de la que obtiene una lista de empleados. Después, un iterador es utilizado para, empleado a empleado, acceder a la aplicación web interna de la intranet de la compañía y extraer los datos que permitan su validación.



Figura 109 Proceso de acceso a información en una base de datos relacional

La configuración del componente se divide en los siguientes apartados:

• La pestaña Inputs permite añadir valores o registros que sean utilizados como variables en los parámetros de configuración.

• Ya en el “wizard” del componente, nos encontramos con tres pestañas de configuración. La primera permite configurar la conexión al repositorio JDBC:

o Driver Jar File: Ruta y nombre del fichero .jar que contiene la implementación del driver JDBC.

o Driver Class: La clase driver a utilizar para la conexión al origen de datos (puede utilizar variables obtenidas a partir de los valores y registros de entrada del componente).

o Driver Properties: importantes para considerar las características especiales de las diferentes bases de datos utilizadas como origen de información, estos campos son opcionales. Si no se especifican, entonces se utiliza la configuración general de acceso a una base de datos.



o Database URI: El URL de conexión a la base de datos (puede utilizar variables obtenidas a partir de los valores y registros de entrada del componente).

o Login: El nombre del usuario a utilizar para el acceso (puede utilizar variables obtenidas a partir de los valores y registros de entrada del componente).

o Password: La clave de acceso para el usuario utilizado (puede utilizar variables obtenidas a partir de los valores y registros de entrada del componente).

o Locale: información de localización de la fuente a acceder (más información sobre internacionalización y localización en la sección 3.13.2).

• La segunda pestaña del componente permite configurar el pool de conexiones que gestiona el acceso al repositorio:

o Use Pool: en esta casilla de verificación se decide si se desea utilizar pool o no.

o Initial Size: Número de conexiones con las que se desea inicializar el pool. Se establece y crea un número de conexiones en estado “idle” (ocioso), listas para ser usadas.

o Maximum Size: Número máximo de conexiones que puede gestionar el pool al mismo tiempo.

o Ping Query: Consulta SQL utilizada por el pool para verificar el estado de las conexiones que se encuentran cacheadas. Es preciso que la consulta sea sencilla y exista la tabla en cuestión.

• La tercera pestaña permite lanzar la consulta SQL que permite a ITPilot determinar la estructura del registro de salida (la consulta puede utilizar variables obtenidas a partir de los valores y registros de entrada del componente). La figura Figura 110 muestra cómo en el ejemplo se accede a una tabla “billing” para obtener el campo “Customer_Id” como identificador único de cliente. El componente JDBCExtractor, por tanto, devolverá una lista de “Customer_Id”.

Figura 110 Obtención de estructura del registro de salida en el componente JDBCExtractor



6.13 LOOP

6.13.1 Descripción

Este componente permite realizar bucles en el flujo. El bucle se repetirá mientras se cumpla la condición dada (se trata de un tipo de bucle WHILE… DO).


Loop acepta cero o más valores, cero o más registros. Estos elementos se utilizan para asignar variables a la expresión de condición de salida del bucle.


Nada.

6.13.4 Ejemplo

Tras la recepción de información por parte de un componente Extractor, donde uno de los atributos es un valor que indica la fecha de nacimiento de la persona concreta a la que se refiere ese registro, se desea obtener información de cada uno de los años en los que esa persona ha estado viva. Esto se realiza accediendo a otro recurso que acepta como entrada el año concreto del que se desea obtener información y devuelve los acontecimientos más relevantes de ese año.

Utilizando ITPilot, se puede construir un bucle donde cada iteración acceda a cada uno de los años concretos. Los componentes que actúan en esta parte del proceso se muestran en la Figura 111.

Para cada registro obtenido por el componente Extractor, y tras algún tipo de conversión en el componente RecordConstructor, se crea un componente Expression que obtiene la edad de esta persona, aplicando la expresión:

SUBSTRACT(2007,GETYEAR(TODATE('MM/dd/yyyy',Record_Constructor_1_output.DATE)))

, donde restamos a la fecha actual, la fecha de nacimiento que aparece en el registro para averiguar la edad de esta persona (para simplificar el ejemplo, sólo se tiene en cuenta el año de nacimiento). Con esto, ya podemos crear la condición de salida del bucle, que será sencillamente:

AGE = 0

, donde AGE es la expresión resultado de la resta anterior.

Dentro del bucle, lo único que nos queda por hacer esa crear otra expresión que, para cada iteración, vaya restando 1 a la expresión AGE.

SUBTRACT(AGE, 1)



Figura 111 Ejemplo de funcionamiento del componente Loop



6.14 NEXT INTERVAL ITERATOR

6.14.1 Descripción

Este componente permite iterar por diferentes páginas relacionadas entre sí por una misma o diferentes secuencias de navegación.


El Next Interval Iterator acepta como entrada:

• Una página de entrada, que se utiliza como base a partir de la cuál acceder al resto.

• Cero o más registros de entrada, utilizadas como variables de entrada en las navegaciones subsiguientes.


Para cada iteración, el componente devuelve la página resultado.





6.15 OUTPUT

6.15.1 Descripción

Este componente coloca un registro en la salida del wrapper.


Output acepta como entrada un registro, que es el que, asíncronamente, devolverá como resultado del wrapper.


Nada





6.16 RECORD CONSTRUCTOR

6.16.1 Descripción

Este componente permite construir un registro a partir de otros registros generados en el flujo, además de generar nuestros atributos derivados de los ya existentes.


Record Constructor acepta como entrada cero o más registros y cero o más listas de registros, que utiliza como variables que permitan la construcción del registro de salida, ya sea mediante la concatenación de los registros o elementos de las listas, como mediante la construcción de campos derivados.


El componente devuelve un registro.





6.17 RECORD SEQUENCE

6.17.1 Descripción

Este componente crea una secuencia de navegación a partir de un registro extraido con un componente EXTRACTOR. Típicamente, se utiliza cuando, para cada registro extraido de una determinada página, hay que ejecutar una secuencia de navegación contextual al mismo (e.g. acceso a páginas de “detalle” con información adicional de cada registro).


El Record Sequence acepta como entrada:

• Un registro proveniente del extractor, desde el cuál se obtiene la información necesaria para crear la nueva secuencia de navegación.

• Cero o más registros de entrada de otros componentes, utilizados como variables de asignación a la nueva secuencia.

• Página: página a partir de la cuál se navega.


El componente devuelve una página, resultado de la navegación.





6.18 REPEAT

6.18.1 Descripción

Este componente permite realizar bucles en el flujo. Repite el bucle hasta que se cumpla una condición dada (tipo de bucle REPEAT… UNTIL).


Repeat acepta como entrada cero o más valores y cero o más registros. Estos elementos se utilizan para asignar variables a la expresión de condición de salida del bucle.


Nada

6.18.4 Ejemplo

El funcionamiento de este componente es muy similar al de Loop, por lo que se recomienda ver el ejemplo descrito en el apartado 6.13.4.



6.19 SCRIPT

6.19.1 Descripción

El componente permite escribir un programa en Javascript (ver [JSDENODO]).

Esta opción es muy útil cuando se desea introducir en el flujo pequeños scriptlets “javascript” para los cuáles no merece la pena o no es posible realizar un componente a medida.


Cero o más elementos de cualquier tipo


Nada



6.20 SEQUENCE

6.20.1 Descripción

Este componente crea una secuencia de navegación en el lenguaje NSEQL (ver [NSEQL]).


Como argumentos de entrada, Sequence acepta:

• cero o más registros. Estos elementos se utilizan para asignar variables a la secuencia de navegación.

• opcionalmente, una página a partir de la cuál se realiza la navegación.


Se devuelve un elemento que representa la página resultado de la navegación.





6.21 STORE FILE

6.21.1 Descripción

Este componente almacena el contenido introducido como parámetro de entrada en un fichero.


Como argumentos de entrada, Store File acepta:

• Valor (de tipo cadena o binario) que se ha de almacenar.

• Valor de tipo cadena con el nombre del fichero donde almacenar el contenido.


Nada

6.21.4 Ejemplo

Siguiendo el ejemplo mostrado en esta guía, se desea almacenar el conjunto de resultados en un fichero de texto. Para ello, se utilizará el componente Store File. La Figura 113 ,muestra la estructura básica de los pasos a realizar sobre el proceso. Después de que el componente Extractor haya obtenido la lista de resultados de una página concreta, se itera sobre cada uno de ellos. En cada iteración, un componente Record Constructor construye el resultado que se desea enviar asíncronamente como resultado de la ejecución del programa envoltorio. Lo que se hace a continuación es crear una expresión que contenga todos los datos del registro de salida, y se almacene con el nombre RECORDCONTENT. Inmediatamente después, esta expresión se utiliza para concatenar su valor a otra expresión creada inicialmente, denominada RECORDLISTCONCAT, que contendrá los valores de cada uno de los registros obtenidos. Después de la iteración, se puede observar cómo se utiliza el componente StoreFile (al final de la figura, abajo), para tomar el contenido de la expresión RECORDLISTCONCAT, y escribirlo en el fichero cuyo nombre se describe en el valor OutputFileName. Esto se puede observar en la Figura 112.

Figura 112 Parámetros de entrada del componente StoreFile



Figura 113 Ejemplo de funcionamiento del componente Store File

Bibliografía 135


BIBLIOGRAFÍA

[ADOBE] Adobe Acrobat Professional. http://www.adobe.com

[DATEFORMAT] Formato Java de representación de formatos de fecha. http://java.sun.com/j2se/1.5.0/docs/api/java/text/SimpleDateFormat.html

[DEXTL] Manual DEXTL (Data EXtraction Language). Denodo Technologies, 2007.

[FRFX] Mozilla Firefox. http://www.mozilla.com/en-US/firefox/

[ISO3166] Código de país ISO-3166 (http://www.chemie.fu-berlin.de/diverse/doc/ISO_3166.html)

[ISO639] Código de lenguaje ISO-639 (http://www.ics.uci.edu/pub/ietf/http/related/iso639.txt)

[JAVADOC] Documentación Javadoc de la API estándar Java Developer Kit

[JSDENODO] Guía del Desarrollador de Denodo ITPilot. Denodo Technologies, 2007.

[MSIE] Microsoft Internet Explorer. http://www.microsoft.com/windows/ie/

[NSEQL] Manual de NSEQL (Navigation SEQuence Language). Denodo Technologies, 2007.

[OO] OpenOffice Office Suite. http://www.openoffice.org

[PDF] Adobe Portable Document Format. http://www.adobe.com/products/acrobat/adobepdf.html

[PDFBOX] Librería Java – PDF. http://www.pdfbox.org/

[REGEX] Formato Java de representación de patrones de expresiones regulares. http://java.sun.com/j2se/1.5.0/docs/api/java/util/regex/Pattern.html

[RFC1738] Request For Comments 1738: Uniform Resource Locators (URL). http://www.rfc-editor.org/rfc/rfc1738.txt

[USU] Manual de Usuario de Denodo ITPilot. Denodo Technologies, 2007

[VDP] Manual de Administración de Denodo Virtual DataPort. Denodo Technologies, 2007.

[WORD] Microsoft Word. http://office.microsoft.com

Bibliografía 136

DENODO ITPILOT 4.0 MANUAL DEL ENTORNO DE...

Documents

Transcript of DENODO ITPILOT 4.0 MANUAL DEL ENTORNO DE...