Download tutorial de aries

TUTORIAL DE ARIES
Contenido
Introducción..........................................................................................................................................................................................1
Qué es Aries......................................................................................................................................................................................1
A quién va dirigido este tutorial........................................................................................................................................................1
Primeros pasos .....................................................................................................................................................................................2
Preparar nuestro entorno de desarrollo...........................................................................................................................................2
Comenzar una nueva aplicación.......................................................................................................................................................2
Ejecutar la aplicación........................................................................................................................................................................4
Establecer el paquete principal de nuestra aplicación.....................................................................................................................5
El modelo de datos................................................................................................................................................................................6
Introducción......................................................................................................................................................................................6
Nuestro modelo de datos.................................................................................................................................................................6
Escribir las clases Java del modelo....................................................................................................................................................7
Gestión de productos............................................................................................................................................................................9
Gestión de pedidos..............................................................................................................................................................................13
Las líneas del pedido.......................................................................................................................................................................14
Introducción
Qué es Aries
Muy esquemáticamente: Aries es una plataforma de desarrollo orientada a la creación de aplicaciones JEE Web de Gestión, ricas
en interacción, y de alta productividad que utiliza los estándares más aceptados por el mercado y permite la programación 100%
Java.
Puede conocer todos los detalles de sus características, documentación adicional, descargas, etc. desde http://aries.seresco.es.
A quién va dirigido este tutorial
Este tutorial va dirigido a programadores que quieran dar los primeros pasos en Aries. Conviene que el programador que lea este
tutorial esté familiarizado con los conceptos de JEE.
Tutorial Aries - Seresco
Página 1
Primeros pasos
Preparar nuestro entorno de desarrollo
Aries es independiente de la herramienta de desarrollo, aunque se recomienda el uso de Eclipse. En principio, podríamos ir
obteniendo los diferentes componentes de desarrollo, cada uno de su lugar correspondiente. Por ejemplo, bajarnos el SDK de
Java, el Eclipse, el Tomcat, etc.
Sin embargo creemos que resulta más cómodo utilizar la distribución del puesto de desarrollo que ofrece Aries para puestos de
desarrollo Windows, en su forma de un programa instalable. En el sitio Web de Aries podemos obtener este instalador. La
instalación es muy sencilla y no supone intrusión en la máquina. Solamente crea el directorio c:\aries y un acceso directo a
Eclipse en el escritorio. El puesto de trabajo incluye Eclipse, SDK de Java, Tomcat, plugins, etc. Todo el software contenido en
este paquete es de libre distribución.
Comenzar una nueva aplicación.
Vamos a crear una nueva aplicación sobre la que trabajaremos durante este tutorial. Para ello seguimos los siguientes pasos
desde Eclipse:
Ejecutar: File – New – Dynamic Web Project.
Pulsamos Next y aparece la siguiente pantalla, en la cual nos
aseguraremos de dar el nombre de la aplicación, en nuestro
caso se llamará “pedidos”.
Si es la primera vez que creamos un proyecto puede que en
Target Runtime aparezca "None". En este caso tenemos que
pusar el botón "New..." para crear uno. Una vez pulsado
"New..." elegimos Apache/Apache Tomcat 6.0 y ponemos
como directorio c:\aries\tomcat, pulsamos Finish y ya
tenemos creado el Target Runtime.
Nos aseguramos también de que aparece seleccionado como
target Runtime el Apache Tomcat 6.0.
Pulsamos Finish para terminar de crear el proyecto.
Tutorial Aries - Seresco
Página 2
A continuación vamos a importar la aplicación Plantilla de
Aries con lo que conseguiremos obtener todas las librerías
necesarias y disponer de unos ficheros fuente con los que
empezar. Podemos descargarla del sitio público de Aries.
(http://aries.seresco.es/download/plantilla.zip) y dejarla en
nuestro disco duro.
Luego, vamos al menú de Eclipse y hacemos “Import ...”. En la
pantalla que nos aparece elegimos la opción “General /
Archive File”.
A continuación elegimos el archivo plantilla.zip que nos hemos
descargado.
Pulsamos “Finish”. Cuando salgan mensajes de confirmación
de sobrescritura los aceptamos todos. Con estos pasos ya
tenemos una aplicación en blanco lista para trabajar con ella.
Tutorial Aries - Seresco
Página 3
En general, trabajaremos con
la perspectiva “JEE” de Eclipse
que nos ofrece un conjunto de
ventanas apropiado para este
tipo de desarrollo. El aspecto
resultante del Eclipse una vez
realizados los pasos anteriores
sería más o menos como sigue:
Ejecutar la aplicación
En la pestaña "Servers", que normalmente aparece abajo en
nuestro espacio de trabajo debemos añadir el servidor Tomcat
6.0. Esto nos permitirá en lo sucesivo poder arrancarlo,
pararlo, añadirle aplicaciones etc. Para ello pinchamos sobre
la pestaña servers y pulsamos botón derecho y elegimos new /
server y escogemos el Tomcat v6.0 server de la lista. Pulsamos
Finish y ya tenemos el servidor preparado.
Tutorial Aries - Seresco
Página 4
Para ejecutar la aplicación por primera vez
necesitamos añadirla al servidor Tomcat que tenemos
preparado. Para ello vamos a la ventana “Servers” y
pulsando con botón derecho sobre el servidor
Tomcat , elegimos “Add and Remove Projects ...” . Nos
aparecerá la siguiente ventana:
En ella movemos nuestra aplicación de pedidos sobre
los Configured projects. Una vez hecho esto, pulsamos
Finish.
A continuación arrancamos el servidor pulsando botón
derecho sobre él y eligiendo la opción “Start”. Al
hacerlo se activa la ventana “Console” donde nos
aparecen diversas informaciones de depuración. La
importante es la última donde debe decir “Server
Startup in xxx ms”. Si el servidor no arranca diciendo
que tenemos el puerto 8080 ocupado, debemos dar
doble click sobre el servidor y utilizar otro puerto libre
cualquiera. en ese caso al probar debemos especificar
ese otro puerto en la URL que pongamos en el
navegador
Ya tenemos arrancado el servidor. Ahora abriremos un
navegador, y en él escribimos la dirección:
http://localhost:8080/pedidos. Nos aparecerá la
aplicación. Algo así como lo siguiente:
Como vemos, la aplicación Plantilla nos proporciona un menú de ejemplo básico y una pantalla de bienvenida.
Establecer el paquete principal de nuestra aplicación
La aplicación plantilla que hemos importado en nuestra aplicación Pedidos se distribuye bajo el paquete “es.seresco.plantilla”. A
continuación convendría modificar este paquete por el que consideremos oportuno para nuestra aplicación. Supongamos que
queremos usar el paquete “es.seresco.pedidos”.
Nos aseguraremos primero de elegir la representación de
paquetes jerárquica: En la ventana de Project Explorer,
pinchamos sobre el triángulo de la cabecera, elegimos
Package Presentation y Hierarchical
Tutorial Aries - Seresco
Página 5
Usamos la opción “Refactor - rename” de botón derecho
situados sobre el paquete “es.seresco.plantilla” cubrimos la
siguiente pantalla: (Es importante marcar todos los check y
poner “*” en el patrón para que lo cambie en todas partes.
El modelo de datos
Introducción
A menudo en el desarrollo de aplicaciones surge la duda de si empezar a desarrollar el modelo de datos desde Java o desde
herramientas externas para luego importar en Java. No es competencia de la plataforma determinar un orden determinado.
Sin embargo en el tutorial nos interesa desarrollar la aplicación sin la parafernalia de herramientas externas de forma que se
pueda hacer todo directamente desde nuestro IDE sin mayores problemas. Para este enfoque Hibernate nos ayudará bastante
puesto que es capaz de crear y actualizar la estructura de la base de datos mientras desarrollamos todo ello a partir de las clases
Java del modelo.
Otra opción, que no vamos a seguir en el tutorial sería utilizar Hibernate-Tools para hacer Ingeniería Inversa, lo cual nos
permitiría obtener las clases Java a partir de una estructura de base de datos existente. (Esto se puede consultar en la Wiki de
Aries).
En este tutorial utilizamos la base de datos HSQLDB (hsqldb.org) que tiene un motor muy liviano y la incluimos en el puesto de
desarrollo. Esta base de datos es muy útil para tutoriales y pruebas por su sencillez de configuración. De hecho, tal como viene la
aplicación plantilla preparada, no necesitamos configuración adicional ni arrancar ninguna otra tarea ya que el motor está
embebido en el servidor. Los datos, físicamente, se guardan en el directorio c:\aries\datos.
Nuestro modelo de datos
El modelo de datos de la aplicación es gráficamente el siguiente:
Tutorial Aries - Seresco
Página 6
class tutorial
Pedido
-
codPedi do: Integer
fecha: Date
1
1..*
LineaPedido
-
canti dad: Integer
codArti cul o: Integer
codPedi do: Integer
l inP edido: Integer
Producto
1..*
1 -
codProducto: Integer
descri pci on: S tring
preci o: B igDeci m al
Es decir, tenemos un conjunto de productos y sobre ellos permitiremos crear pedidos. Cada pedido tiene una o más líneas de
pedido y cada línea de pedido hace referencia a un producto y establece una cantidad a vender.
Escribir las clases Java del modelo.
Las clases del modelo se escriben en el paquete datos por debajo del paquete de aplicación. Se utilizan anotaciones JPA para
definir con precisión las propiedades de la tabla, claves, relaciones y datos.
Crearemos primero la Entidad “Producto”. Para ello vamos al paquete “es.seresco.pedidos.datos” y sobre él elegimos la opción
de botón derecho “new – Class”, le damos el nombre “Producto” y escribimos el siguiente código:
package es.seresco.pedidos.datos;
import java.math.BigDecimal;
import javax.persistence.*;
@Entity
public class Producto {
private Integer codProducto;
private String
descripcion;
private BigDecimal precio;
@Id
@Column(length=8)
public Integer getCodProducto() {
return codProducto;
}
@Column(length=50)
public String getDescripcion() {
return descripcion;
}
@Column(length=10, scale=2)
public BigDecimal getPrecio() {
return precio;
}
public void setCodProducto(Integer codProducto) {
this.codProducto = codProducto;
}
public void setDescripcion(String descripcion) {
this.descripcion = descripcion;
Tutorial Aries - Seresco
Página 7
}
public void setPrecio(BigDecimal precio) {
this.precio = precio;
}
}
Prestemos atención a lo siguiente:
•
Nótese que la clase es un simple Bean de Java con sus datos privados y sus métodos get y set.
•
La clase tiene la anotación @Entity.
•
La clave principal va marcada con la anotación @Id.
•
Los métodos get tienen la anotación @Column para ayudar a completar la información que Aries más tarde utilizará,
por ejemplo, para establecer máscaras de edición.
Crearemos la entidad Pedido siguiendo la misma idea:
package es.seresco.pedidos.datos;
import java.util.Date;
import javax.persistence.*;
@Entity
public class Pedido {
private Integer codPedido;
private Date fecha;
@Id
@Column(length=8)
@GeneratedValue(strategy=GenerationType.TABLE)
public Integer getCodPedido() {
return codPedido;
}
public Date getFecha() {
return fecha;
}
public void setCodPedido(Integer codPedido) {
this.codPedido = codPedido;
}
public void setFecha(Date fecha) {
this.fecha = fecha;
}
}
Nos queda por declarar la entidad LineaPedido que es la más compleja por una parte por tener una relación al menos con la
entidad Producto. Declararemos así la clase:
package es.seresco.pedidos.datos;
import javax.persistence.*;
@Entity
public class LineaPedido {
private Integer lineaPedido;
private Integer codPedido;
private Producto producto;
private Integer cantidad;
@Id
@Column(length=8)
@GeneratedValue(strategy=GenerationType.TABLE)
public Integer getLineaPedido() {
Tutorial Aries - Seresco
Página 8
return lineaPedido;
}
public Integer getCodPedido() {
return codPedido;
}
@ManyToOne(fetch=javax.persistence.FetchType.LAZY, targetEntity=Producto.class)
@JoinColumn(name="CODPRODUCTO")
public Producto getProducto() {
return producto;
}
@Column(length=8)
public Integer getCantidad() {
return cantidad;
}
public void setLineaPedido(Integer lineaPedido) {
this.lineaPedido = lineaPedido;
}
public void setCodPedido(Integer codPedido) {
this.codPedido = codPedido;
}
public void setProducto(Producto producto) {
this.producto = producto;
}
public void setCantidad(Integer cantidad) {
this.cantidad = cantidad;
}
}
Y prestaremos atención a lo siguiente:
•
Podríamos haber hecho un diseño de la clase con clave compuesta por codPedido y linPedido, pero por simplicidad lo
hacemos de clave simple, que además es la opción recomendada por Hibernate.
•
Para declarar la relación con la entidad Producto hemos utilizado las anotaciones ManyToOne y JoinColumn.
Gestión de productos
Vamos a crear una función para buscar, crear, consultar, modificar y borrar productos.
Situados en el proyecto “pedidos” pulsamos botón derecho “New” y elegimos “Pantalla”.
Tutorial Aries - Seresco
Página 9
En la pantalla del asistente que aparece a continuación
elegimos el tipo “Gestión”, elegimos la entidad principal que
vamos a manejar que es “Producto”, le damos un nombre, y
un título.
Marcamos también la opción de “Generar búsqueda” para
que nos genere una pantalla de búsqueda y la damos un
nombre y un título a la búsqueda .
Pulsamos Finish, y como resultado obtendremos los fuentes
Java y XML de las pantallas de Gestión y de Búsqueda.
Cada pantalla en Aries se compone de dos ficheros:
1.
Diseño: Es la “Vista” de la pantalla. Se trata de un fichero XML que define los componentes que colocamos en la
pantalla.
2.
Controlador: Es la clase Java que controla los eventos y el funcionamiento de la pantalla.
El asistente nos ha generado dos pantallas. La búsqueda y la gestión.
Comenzamos editando el fichero ProductoBusqueda.xml. Las búsquedas tienen dos partes bien diferenciadas. Los criterios y los
resultados. Introduciremos campos para poder establecer criterios de búsqueda y también introduciremos campos para mostrar
los resultados El asistente nos ha dejado dos marcas para que sepamos dónde introducir ambas partes.
Comenzamos por los criterios: Introducimos lo que aparece en negrita a continuación:
<Bloque titulo="Criterios">
<Grid >
<TextField id="producto.codProducto" etiqueta="Código"/>
<TextField id="producto.descripcion" etiqueta="Descripción"/>
</Grid>
</Bloque>
Luego, en la zona de resultados escribiremos:
<Tabla id="Resultados" height="400">
<TextField id="codProducto" etiqueta="Código"/>
<TextField id="descripcion" etiqueta="Descripción"/>
<TextField id="precio"
etiqueta="Precio"/>
</Tabla>
Ahora vamos a editar el fichero ProductoGestion.xml que es la definición de la pantalla de gestión donde vamos a poder crear,
consultar, modificar y borrar productos. En ella declaramos los campos que queremos gestionar:
<Grid size="1">
<Grid >
<TextField id="producto.codProducto" etiqueta="Código"/>
<TextField id="producto.descripcion" etiqueta="Descripción"/>
<TextField id="producto.precio"
etiqueta="Precio"/>
</Grid>
<Include ref="plantillas/BotoneraGestion.xml"/>
</Grid>
Tutorial Aries - Seresco
Página 10
Ahora solamente nos queda por añadir una referencia a la función de búsqueda de productos en el menú general. Vamos
entonces a editar el fichero src/recursos/menus/MenuEscritorio.xml e introducimos lo que aparece en negrita a continuación:
<Opcion texto="$menu.basicos" >
<Opcion texto="Productos" id="ProductoBusqueda"/>
</Opcion>
Ahora ya estamos listos para probar esta funcionalidad. Vamos a la ventana de “Servers” y pulsamos de nuevo el botón de
arrancar el servidor para asegurar que nos coge los últimos cambios.
Con el navegador vamos a la aplicación y abrimos la opción
“Productos” y vemos cómo nos ha quedado la pantalla de
búsqueda.
Desde ella podremos ir a crear nuevos productos pulsando
el botón “Nuevo...”. Introducimos los datos del nuevo
producto y pulsamos Grabar.
Tutorial Aries - Seresco
Página 11
Luego, podemos volver a la búsqueda, aceptar los criterios
y ver los registros que hayamos creado.
Tutorial Aries - Seresco
Página 12
Gestión de pedidos
Crearemos a continuación la gestión de pedidos. Seguimos los mismos pasos que habíamos seguido para crear la de productos:
Mediante la opción de botón derecho “New – PAntalla”
accedemos al asistente y cubrimos los datos tal como se ve en
esta imagen.
Nos aseguramos de marcar “Generar Búsqueda” y de cubrir
los nombres y títulos.
La entidad principal es “Pedido”.
Pulsamos Finish
Obtenemos los ficheros de diseño y control de las pantallas de búsqueda y gestión de pedidos. Del mismo modo que hicimos con
los productos, introduciremos los campos en las zonas de criterios, resultados de la búsqueda y en la gestión.
Criterios de la búsqueda:
<Bloque titulo="Criterios">
<Grid >
<TextField id="pedido.codPedido" etiqueta="Código"/>
<Row etiqueta="Entre fechas">
<CampoFecha id="pedido.fecha.min" />
<CampoFecha id="pedido.fecha.max" etiqueta="y"/>
</Row>
</Grid>
</Bloque>
En este caso hemos decidido poner como criterio el rango de fechas. Nótese que el sufijo “.min”, “.max” permite a Aries conocer
nuestras intenciones sobre el criterio que queremos que aplique.
Resultados:
<Tabla id="Resultados" height="400">
<TextField id="codPedido" etiqueta="Código"/>
<CampoFecha id="fecha"
etiqueta="Fecha"/>
</Tabla>
En la gestión de pedidos:
<Grid size="1">
<Grid >
<TextField id="pedido.codPedido"
etiqueta="Código"/>
<CampoFecha id="pedido.fecha"
etiqueta="Fecha"/>
</Grid>
<Include ref="plantillas/BotoneraGestion.xml"/>
</Grid>
Añadirlo al menú general:
Tutorial Aries - Seresco
Página 13
<Opcion texto="$menu.basicos" >
<Opcion texto="Productos" id="ProductoBusqueda"/>
<Opcion texto="Pedidos"
id="PedidoBusqueda"/>
</Opcion>
Las líneas del pedido
Ahora queremos añadir líneas al pedido para darle la funcionalidad requerida. Lo haremos editando el fichero
PedidoGestion.xml y añadiendo lo siguiente:
<Grid size="1">
<Bloque titulo="Datos generales">
<Grid >
<TextField id="pedido.codPedido" etiqueta="Código" enabled="false"/>
<CampoFecha id="pedido.fecha"
etiqueta="Fecha"/>
</Grid>
</Bloque>
<Bloque titulo="Detalle">
<GrupoTablaGestion entidad="LineaPedido"
camposCabecera="pedido.codPedido"
camposDetalle="codPedido">
<Tabla id="lineaPedido">
<Label
id="estado"/>
<TextField
id="lineaPedido.lineaPedido" visible="false"/>
<CampoConBusqueda
id="lineaPedido.producto.codProducto"
etiqueta="Producto" idBoton="buscarProducto"/>
<TextField
id="lineaPedido.producto.descripcion" etiqueta="Descripción" enabled="false"/>
<TextField
id="lineaPedido.producto.precio" etiqueta="Precio"
enabled="false"/>
<TextField
id="lineaPedido.cantidad"
etiqueta="Cantidad"/>
<TextField
id="importe" edicion="n:##,###,##0.00" enabled="false" etiqueta="Importe"/>
</Tabla>
</GrupoTablaGestion>
</Bloque>
<Include ref="plantillas/BotoneraGestion.xml"/>
</Grid>
Con este diseño de pantalla ya podemos
insertar líneas al pedido aunque de momento
aún no se muestra la descripción, ni el precio
del artículo, ni el importe. Para ello
tendremos ya que escribir código en Java.
Mostrar la descripción y el precio del producto al introducirlo.
Queremos que cada vez que se modifica el código de producto se muestre su descripción y precio asociados.
Tutorial Aries - Seresco
Página 14
1.
Declaramos la relación entre LineaPedido y Producto escribiendo lo siguiente en el método inicializar de
PedidoGestion.
getManejadorRelaciones().getRelacion(Introspector.getNombreEntidad(LineaPedido.class))
.addRelacion(
new Relacion("lineaPedido.producto", Producto.class,
new MapeadorBasico(this,"lineaPedido.producto.codProducto","codProducto")
)
);
Mediante este código le hemos dicho a Aries que debe considerar que el campo lineaPedido.producto.codProducto es clave
origen de una relación con la entidad Producto, de tal forma que cada vez que el usuario introduzca un código de producto y
pulse INTRO se cargarán los datos de la relación, en este caso la descripción y el precio.
Acceder a la búsqueda de productos
Podemos comprobar que en el diseño de la pantalla para el campo codProducto hemos decidido utilizar un componente
llamado CampoConBusqueda.
<CampoConBusqueda
id="lineaPedido.producto.codProducto"
etiqueta="Producto" idBoton="buscarProducto"/>
Este componente hace que se muestre un botón al lado del campo que permitirá al usuario elegir el código de producto
mediante una pantalla de búsqueda que será precisamente la misma pantalla de búsqueda de productos que hemos
desarrollado unos pasos atrás.
Para que esto funcione tenemos que implementar en la parte Java el evento de pulsación del botón buscarProducto. Así:
public void doBuscarProducto() {
LlamadasUtil.llamarBusqueda(this, ProductoBusqueda.class,
"codProducto" , "lineaPedido.producto.codProducto");
}
Mostrar el importe de cada fila
Queremos mostrar el importe de cada fila según se introduce la cantidad, y también al mostrar pedidos ya creados. El importe
de cada fila es el resultado de multiplicar el precio por la cantidad. En el diseño de la pantalla ya hemos preparado una columna
dentro de la tabla para mostrar el importe. Era este:
<TextField
id="importe" edicion="n:##,###,##0.00" enabled="false" etiqueta="Importe"/>
Podemos prestar atención a dos hechos:
•
Hemos tenido que especificar una máscara de edición dado que este campo no pertenece al modelo y Aries no puede
deducir la máscara de las anotaciones JPA. Nótese que para el resto de campos que hemos declarado no ha sido
necesario introducir esta máscara.
•
Lo declaramos con el atributo enabled=”false” para indicar que es un campo sólo de consulta.
Para mostrar el importe vamos a añadir un escuchador al modelo de la tabla. El “Modelo de la tabla” es realmente el contenido
de la misma y añadir un escuchador consiste en escribir código Java que será invocado cada que el contenido de la tabla cambie.
Así:
1.
Para facilitar el acceso a los componentes, utilizando el asistente de Aries vamos a generar una clase llamada
Constantes que contendrá los nombres de los controles que tenemos en la pantalla. Así podremos referirnos a ellos con
seguridad de no equivocarnos. Para ello pulsamos botón derecho sobre la clase Java PedidoGestion y elegimos la opción
“Aries – Generar literales de componentes”. Como resultado obtenemos la clase Constantes con todos los nombres de
componentes.
Tutorial Aries - Seresco
Página 15
2.
Declaramos una instancia de la tabla a nivel de la clase:
// En la clase.
private Tabla tabla;
3.
Y la inicializamos dentro del método inicializar
// Dentro de inicializar
...
tabla=getComponent(Constantes.LINEAPEDIDO);
4.
Ahora tenemos que añadir código al programa Java para que se realice el cálculo en los momentos precisos. Con este
código añadimos un escuchador a los cambios del modelo de la tabla para calcular el importe siempre que cambie
cualquier columna que no sea el importe mismo. De esta forma se calculará el importe tanto en la carga de la tabla
como cuando el usuario modifique el precio o la cantidad.
RelacionMultiple rel=(RelacionMultiple)getManejadorRelaciones().getRelacion(Constantes.LINEAPEDIDO);
rel.getGestorTabla().addTableModelListener(new TableModelListener() {
public void tableChanged(TableModelEvent evento) {
if(evento.getFirstRow()>=0 && evento.getFirstRow()<tabla.getModel().getRowCount() &&
evento.getColumn()!=tabla.getIndiceColumna(Constantes.IMPORTE)) {
calcularImporte(evento.getFirstRow());
}
}
});
5.
Por último escribimos el método calcularImporte:
public void calcularImporte(Integer row) {
GestionTableModel modelo = (GestionTableModelEnLinea) tabla.getModel();
BigDecimal cantidad = modelo.getNumeroAt(Constantes.LINEAPEDIDO_CANTIDAD, row);
BigDecimal precioVta = modelo.getNumeroAt( Constantes.PRODUCTO_PRECIO, row);
BigDecimal importe=precioVta.multiply(cantidad);
modelo.setValueAt(importe, Constantes.IMPORTE, row);
}
Y con esto ya hemos conseguido que se
actualice el importe para cada fila.
Tutorial Aries - Seresco
Página 16