Introducción a gvHIDRAÍndice de contenido1. Introducción.......................................................................3

a. Introducción a PHP.............................................................................................................3b. Entendiendo el entorno, arquitectura MVC..........................................................................3c. Comunidad www.gvhidra.org ..............................................................................................6

2. Infraestructura..........................................................................................................................7a. Infraestructura de servidor LAPP/LAMP/WAMP, etc...........................................................7b. Configuración del entorno de desarrollo............................................................................12

i. IDE: Eclipse + herramientas...........................................................................................12ii. Instalación de una demo gvHIDRA...............................................................................14iii. Otras herramientas.......................................................................................................15

3. ¿Qué es gvHIDRA?...............................................................................................................16a. Guía de estilo....................................................................................................................16b. Arquitectura de una aplicación..........................................................................................16c. Patrones de interfaz..........................................................................................................17d. Mi primera aplicación, uso de Genaro...............................................................................18

4. Desarrollando software con gvHidra (Caso práctico).............................................................22a. Presentación del caso.......................................................................................................22

i. Requisitos......................................................................................................................22ii. Modelo entidad relación de apoyo.................................................................................23

b. Preparación entorno, personalización y carga de datos....................................................24c. Creación de mantenimientos ............................................................................................31

i. Mantenimientos a realizar según los requisitos del enunciado:......................................33d. Incorporación de lógica de presentación...........................................................................56

i. Componentes simples....................................................................................................56ii. Componentes avanzados..............................................................................................58iii. Acciones de interfaz.....................................................................................................62

e. Incorporar la lógica de negocio.........................................................................................63i. Acciones genéricas........................................................................................................63ii. Acciones particulares....................................................................................................68

f. Incorporar control de acceso..............................................................................................74

1

g. Programación de informes................................................................................................77i. Preparación del entorno.................................................................................................77ii. Configuración servidor..................................................................................................77ii. Configuración aplicación gvHidra..................................................................................82iii. Configuración del navegador........................................................................................83iv. Integración de un informe.............................................................................................83

5. Integración.............................................................................................................................86a. Autenticación.....................................................................................................................86

i. Sin autenticación............................................................................................................87ii. Mediante usuario / contraseña......................................................................................87iii. Mediante más de una fuente........................................................................................88iv. Autenticación externa...................................................................................................89v. Otros.............................................................................................................................89

b. Autorización: módulos y roles............................................................................................90c. Información de estado.......................................................................................................90

5. Conclusiones.........................................................................................................................92Anexo 1: Wizard iReport............................................................................................................93

Ignacio Santos Gaudioso <santos_ign@gva.es>

Esta obra está bajo una licencia de Creative Commons Reconocimiento-CompartirIgual 3.0 España.

2

1. Introducción

a. Introducción a PHPPHP es un lenguaje interpretado que permite la generación dinámica de contenidos en un servidor web. Sus siglas significan Php Hypertext Preprocessor (acrónimo recursivo). Su licencia está considerada como una licencia de software libre: http :// es . wikipedia . org / wiki / Licencia _ PHP .

Es muy similar a C y Perl en cuanto a programación estructurada pero también es un lenguaje muy potente en cuanto a programación Orientada a Objetos. Nosotros utilizaremos el lenguaje en ambas formas (estructurada y orientada a objetos), pero siempre contenidos en el marco de trabajo del framework gvHidra el cual nos aislará del código a bajo nivel y nos facilitará enormemente el trabajo.

El código PHP normalmente se guarda en ficheros con extensión .php. Dentro del fichero el código se delimita normalmente por las etiquetas <?php y ?>.

El funcionamiento básico se puede describir en el siguiente orden:1. El navegador web cliente solicita el documento mediante su URL, ejemplo:

http//localhost/informacion.php2. El servidor web recibe la solicitud, llama al intérprete de PHP, ejecuta el código y

retorna el resultado. Ejemplo de código 3. El servidor web devuelve el resultado generado al navegador web.

En todo caso, para el desarrollo de nuestra lógica de negocio nos vendrá muy bien consultar el manual http :// www . php . net / manual / es /

b. Entendiendo el entorno, arquitectura MVCEs necesario explicar el entorno o la arquitectura en la que nos movemos, hecho que nos permitirá entender mejor nuestros desarrollos, la potencia de la herramienta, así como detectar antes errores de código o configuración.

Los desarrollos pequeños o “de antes” en PHP son lo que ahora se denomina peyorativamente como “Spaguetti code”. Nos referimos, al hecho de mezclar en una única porción de código varios lenguajes como PHP y HTML, así como mezclar la lógica de negocio y la lógica de presentación (que queremos hacer y que es como lo queremos mostrar).

3

Ejemplo:

<?php$a=1;$b=2;echo '<html>';echo '<head>';echo '</head>';echo '<body>';echo '<form action="ejemplo.php">';if($a+$b==1){

echo '<p>Nombre<input type="text" name="nombre" value="" /></p>';}else{

echo '<p>Telefono<input type="text" name="telefono" value="" /></p>';}echo '</form>';echo '</body>';echo '</html>';

?>

Nuestros desarrollos se van a enmarcar en un framework de desarrollo que implementa la arquitectura MVC (Modelo Vista Controlador), que en grandes rasgos consiste en separar la lógica de negocio por un lado (Modelo), la presentación en pantalla por otro (Vista) y su ejecución ordenada o único punto de entrada por otro (Controlador).

4

Esta ilustración refleja fielmente el flujo en la arquitectura MVC:

Para el caso concreto de gvHidra, se utilizan los siguientes “componentes” para la implementación del MVC.

Modelo: Implementado con el propio PHP y librerías PEAR, tales como MDB2 para la persistencia de los datos (Oracle, PostgreSQL, SqlServer, MySQL, Sqlite2,...), MAIL para el envío de e-mails o SOAP para los webservices.

Vista: Para la implementación de la vista se ha incluido el famoso motor de plantillas Smarty, el cual se ha sobrecargado con “menús” dinámicos, máscaras, diálogos modales, etc.

Controlador: Como controlador se incluye el proyecto Phrame, sobrecargado para poder ejecutar código en el lado del servidor sin recargar la pantalla.

5

c. Comunidad www . gvhidra . org

Todo proyecto de software libre que se precie, tiene una comunidad de usuarios y colaboradores. Para el caso de gvHidra, podemos encontrarla en el enlace www . gvhidra . org . Es por lo tanto importante que revisemos y conozcamos todo los contenidos que puede ofrecernos.

Para un desarrollador, los contenidos más relevantes serán el manual de usuario así como el espacio de comunicación con otros desarrolladores. Por ello, en este curso realizaremos la descarga de la última versión del manual y a su vez nos registraremos en la lista de correo.

Otros elementos no menos importantes son la forja del proyecto, donde podremos seguir su roadmap, conocer features y bugs, así como consultar el código fuente.

6

2. Infraestructura

a. Infraestructura de servidor LAPP/LAMP/WAMP, etc.En este punto vamos a conocer, instalar y configurar la infraestructura del lado servidor necesaria para la correcta ejecución del framework gvHidra.

El framework necesita unos componentes mínimos para funcionar, estos son; un servidor web, un módulo que interprete PHP 5 y según casos una bases de datos relacional.En las instalaciones típicas de otros frameworks y/o aplicaciones web, suelen utilizarse paquetes preparados para satisfacer esos tres componentes, por ello podremos encontrar fácilmente por la red paquetes como:

● LAPP: Linux, Apache, PostgreSQL y PHP.● LAMP: Linux, Apache, MySQL y PHP.● WAMP: Windows, Apache, MySQL y PHP.● WAPP: Windows, Apache, PostgreSQL y PHP.● MAMP: Mac OS X, Apache, MySQL y PHP.

Nosotros instalaremos de manera manual o mediante paquete el entorno que nos interese para este curso y nos puede servir de ayuda la “Guía de instalación rápida del entorno gvHidra” disponible en la web del proyecto www . gvHidra . org .

Para una instalación LAPP los pasos a seguir serían estos:

Instalamos PostgreSQL y PgAdmin IIIisantos:~# apt-get update; apt-get install pgadmin3 postgresql

isantos:~# sudo - postgresql

postgres@isantos:~$ vi /etc/postgresql/9.0/main/pg_hba.confhost all all 127.0.0.1/32 md5host all all 192.168.1.0/24 md5

postgres@isantos:~$ vi /etc/postgresql/9.0/main/postgresql.conflisten_addresses = '*’

postgres@isantos:~$ pg_lsclusters Version Cluster Port Status Owner Data directory Log file9.0 main 5432 online postgres /var/lib/postgresql/9.0/main /var/log/postgresql/postgresql-9.0-main.logpostgres@isantos:~$ pg_ctlcluster 9.0 main restart

Instalamos PHP 5.2.x, módulos PEAR y Apache 2isantos:~# echo "#Paquetes para forzar PHP5.2.X" >> /etc/apt/sources.list

7

isantos:~# echo "deb http://snapshot.debian.org/archive/debian/20100111T220436Z/ lenny main contrib non-free" >> /etc/apt/sources.listisantos:~# echo "deb http://snapshot.debian.org/archive/debian/20090609T043519Z/ lenny main contrib non-free" >> /etc/apt/sources.list

isantos:~# apt-get update; apt-get install php5=5.2.6.dfsg.1-1+lenny3 libapache2-mod-php5=5.2.6.dfsg.1-1+lenny3 php5-common=5.2.6.dfsg.1-1+lenny3 php5-cli=5.2.6.dfsg.1-1+lenny3 php-pear=5.2.6.dfsg.1-1+lenny3 php5-mysql=5.2.6.dfsg.1-1+lenny3 php5-pgsql=5.2.6.dfsg.1-1+lenny3 php5-sqlite=5.2.6.dfsg.1-1+lenny3 php5-gd=5.2.6.dfsg.1-1+lenny3 php-auth php-mdb2-driver-mysql php-mdb2-driver-pgsql php-mdb2-driver-sqlite

Bloqueamos el paquete para que no se actualiceisantos:~# echo "libapache2-mod-php5 hold" | dpkg --set-selectionsisantos:~# apache2ctl restartóisantos:~# service apache2 restart

Puede darse el caso que en Ubuntu haya que añadir la firma del repositorio.ubuntu# gpg --keyserver keyserver.ubuntu.com --recv AAAAAAAAAFFFFFFFubuntu# gpg --armor --export AAAAAAAAAAFFFFFFF | apt-key add

Añadimos paquetes PEAR que no encontramos en empaquetados .debisantos:~# pear upgrade PEARisantos:~# pear channel-update -f "pear.php.net"(opcional proxy)isantos:~# pear config-set http_proxy="http://ip:port"isantos:~# pear install --alldeps PEARisantos:~# pear install --alldeps MDB2isantos:~# pear install --alldeps MDB2_Driver_pgsqlisantos:~# pear install --alldeps MDB2_Driver_mysqlisantos:~# pear install --alldeps MDB2_Driver_mysqliisantos:~# pear install --alldeps MDB2_Driver_sqliteisantos:~# pear install --alldeps MDB2_Driver_oci8isantos:~# pear install --alldeps Authisantos:~# pear install --alldeps Mailisantos:~# pear install --alldeps SOAPisantos:~# pear config-set preferred_state alphaisantos:~# pear install --alldeps Image_Graphisantos:~# pear install --alldeps SOAPisantos:~# pear list

Configuramos la instalación de PHP (php.ini):include_path =".:/usr/local/php/php_XX/lib/php/PEAR: /usr/local/php/php_XX/lib/php"error_reporting = E_COMPILE_ERROR|E_RECOVERABLE_ERROR|E_ERROR|E_CORE_ERRORmagic_quotes = Off display_errors = On

Instalamos soporte Java en Apache necesario para el proyecto Jasper# apt-get install sun-java6-bin# update-java-alternatives -l

8

# echo "SetEnv JAVA_HOME /usr/lib/jvm/java-6-sun" > /etc/apache2/conf.d/jasper.conf# service apache2 restart

Habilitamos debug alto en Apache $ sudo vi /etc/apache2/apache2.conf207: LogLevel debug

Puede ser necesario parchear la instalación de SOAPsudo vi /usr/share/php/SOAP/Disco.php369: $type = preg_replace('#'.$m[0][0].'#', '', $type);

Comprobamos que la instalación está funcionando# netstat -ntlp | grep -E "(5432|80)"

Para una instalación WAMPP(+ Oracle) los pasos a seguir serían estos:

Base de Datos OraclePara desarrollar con oracle, podemos usar la versión “Oracle Database 11g Express Edition” que aunque tiene algunas limitaciones, es fácil de instalar y más que suficiente para un entorno de desarrollo.

Los pasos de instalación son:

1. Descargar la última versión desde http :// www . oracle . com / technetwork / products / express - edition / downloads / index . html (requiere registro).

2. Hay que descomprimir el fichero y ejecutar el fichero “DISK1\setup.exe”. Dejaremos la ruta de instalación por defecto (c:\oraclexe). Como contraseña de sys y system pondremos “curso”.

9

La instalación del software y de una instancia se hace con los siguientes parámetros:

3. Una vez finalizada la instalación, arrancamos la base de datos con el comando Inicio -> Oracle Database 11g Express Edition -> Start database. Podemos iniciar una conexión con comando “Run SQL Command Line”, tecleando

SQL> connect system/curso;

Base de Datos PostgreSQL

1. Descargar la versión 9.1.4 de http :// postgresql . org . Ejecutamos el fichero y dejamos la ruta por defecto, directorio de datos por defecto, como contraseña del administrador usaremos también “curso”, puerto por defecto, configuración regional por defecto, y no marcar la opción de instalar “Stack Builder”.

2. Añadir al PATH la ruta ;C:\Archivos de Programa\PostgreSQL\9.1\bin

3. Una vez finalizada la instalación, podemos conectarnos usando el pgAdmin III que viene con la instalación.

10

PHP

La actual versión estable de gvHidra es la 3.1.8, que todavía no soporta PHP 5.3, por lo que vamos a utilizar wampserver (http :// www . wampserver . com / en / ), ya que nos permite usar fácilmente varias versiones de PHP. Los pasos para la instalación son:

1. Descargar la versión WAMPSERVER (32 BITS & PHP 5.3) 2.2E, y ejecutar. Lo instalaremos en la ruta c:\wamp, y cuando nos pregunte la ubicación del navegador le indicaremos la ruta del Firefox (c:\archivos de programa\Mozilla Firefox)

2. Ejecutarlo y si aparece el icono en verde significa que ya está en marcha el servidor web apache y la base de datos mysql. En otro caso ir a la guía de instalación.

3. Como la versión instalada es la 5.3 de PHP, tenemos que descargar ahora desde “addons” -> “download PHP addons” la versión “PHP 5.2.9”. Ejecutamos el fichero y al finalizar, ya podremos elegir la nueva versión de PHP

4. Podemos acceder al servidor en http :// localhost (sirve contenidos en C:\wamp\www).

5. Para el acceso a bases de datos oracle y postgresql, necesitamos habilitar la extensión PHP oci8 y la pgsql respectivamente. Tenemos que hacerlo en el menu PHP -> PHP Extensions -> php_oci8 y php_pgsql. Para que funcione también en línea de comando (CLI), tenemos que descomentar las líneas correspondientes en C:\wamp\bin\php\php5.2.9-2\php.ini.

11

6. Ahora ya podemos instalar todas las librerias PEAR necesarias, con los siguientes comandos:

cd c:\wamp\bin\php\php5.2.9-2go-pear (opciones por defecto)-- ejecutar el fichero C:\wamp\bin\php\php5.2.9-2\PEAR_ENV.reg

(Localizar y descomentar en php.ini (php -i | more)extension=php_pgsql.dll y extension=php_oci8.dll(opcional proxy)pear config-set http_proxy="http://ip:port"pear upgrade PEARpear channel-update -f "pear.php.net"pear install -–alldeps Authpear install -–alldeps MDB2pear install -–alldeps MDB2_Driver_oci8pear install -–alldeps MDB2_Driver_pgsqlpear install -–alldeps Mailpear config-set preferred_state alphapear install --alldeps Image_Graphpear install --alldeps SOAP

7. Desde el menú wamp, en opción PHP -> php.ini fijar estas variables:error_reporting = E_ALL & ~E_NOTICEinclude_path = ".;C:\wamp\bin\php\php5.2.9-2\PEAR"

Por último, hacer hincapié en que siempre será más adecuado realizar una instalación controlada de cada elemento necesario en un servidor, pero consideramos que este asunto no es competencia de este curso, y por extensión del desarrollador de aplicaciones.

b. Configuración del entorno de desarrollo.

i. IDE: Eclipse + herramientasTener un Entorno de Desarrollo Integrado (IDE) cómodo, potente y efectivo es muy importante. Por ello, instalaremos las herramientas, que desde nuestra experiencia, consideramos más adecuadas para el desarrollo de aplicaciones con gvHidra.

Eclipse PDTEn primer lugar descargaremos e instalaremos el popular IDE Eclipse, con soporte para desarrollo en PHP (PHP Development Tools). http :// www . eclipse . org / pdt / downloads / Esta herramienta nos permitirá resaltar la sintaxis del código, autocompletar invocaciones a métodos y/o propiedades de clases, así como sincronizar nuestros desarrollos para trabajo en grupo con herramientas de control de versiones (cvs, svn,...).

Los proyectos en gvHIDRA usan codificación de caracteres ISO-8859-1 (o latin1) por lo que para evitar problemas, conviene fijar la codificación de forma general para todos los proyectos.

12

Se hace desde el menú Windows -> Preferences, opción General -> Workspace -> Text file encoding. En otro caso habrá que hacerlo individualmente para cada proyecto.

Firefox + PluginsAhora, para probar nuestros desarrollos instalamos el navegador web Mozilla Firefox http :// www . mozilla . org / . Elegimos esta aplicación porque cuenta con numerosos plugins/complementos que nos permitirán encontrar errores de programación. Por lo tanto, una vez instalado el navegador, añadiremos un complemento llamado Web Developer que podremos descargar desde https :// addons . mozilla . org .

SQL DeveloperHerramienta gráfica y gratuita desarrollada por Oracle para las bases de datos a partir de la versión 9.2.0.1. Permite, entre otras cosas, explorar los objetos de la base de datos, ejecutar sentencias y scripts SQL, editar y depurar código PL/SQL. Requiere la JDK 1.5 o superior. Podemos descargarla de http :// www . oracle . com / technetwork / developer - tools / sql - developer / downloads / index . html (requiere registro).

13

pgAdminIIIHerramienta gráfica incluida en los adminpacks de instalaciones de postgreSQL, para administrar bases de datos postgreSQL. Permite, entre otras cosas, explorar los objetos de la base de datos, ejecutar sentencias y scripts SQL, editar y depurar código PL/SQL. Podemos descargarla desde: http :// www . pgadmin . org /

iReportEn el caso de tener que desarrollar informes/entregables, utilizaremos una herramienta para diseñarlos. Esta herramienta es iReport y la podemos descargar desde http :// sourceforge . net / projects / ireport /

ii. Instalación de una demo gvHIDRA.La mejor manera de conocer las posibilidades de la herramienta es verla funcionar “in situ”. Por ello vamos a realizar la instalación de una aplicación demo de gvHidra que contiene muchos (no todos) de los patrones y complementos que implementa gvHidra. Descargamos el fichero demo-gvhidra.zip de la forja de desarrollo.

GNU Linux

1. Descomprimimos la aplicación “demo-gvhidra.zip” en nuestro raíz de documentos de Apache. $ sudo chown usuario:grupo_usuario /var/www$ unzip demo.zip /var/www/

2. Creamos el directorio temporal de plantillas “templates_c” en el raíz de dicha aplicación.$ mkdir /var/www/demo/templates_c $ chmod o+w /var/www/demo/templates_c

3. Instalamos la base de datos asociada a la aplicación:$ sudo su - postgres$ psql -f /var/www/demo/doc/demo.sql -L /tmp/salidaDemo.log

ó# psql -h localhost -p 5432 -U postgres -f /var/www/demo/doc/demo.sql

-L /tmp/salidaDemo.log

14

Windows

1. Descomprimimos la aplicación “demo.zip” en nuestro raíz de documentos de Apache (c:\wamp\www).

2. Si no existe, creamos el directorio temporal de plantillas “templates_c” en el raíz de dicha aplicación, y nos aseguramos que no sea sólo lectura.

3. Instalamos la base de datos asociada a la aplicación:psql -h localhost -p 5432 -U postgres -f c:\wamp\www\demo\demo.sql -L c:\wamp\www\demo\salida.log

Acceder con el navegador a http :// localhost / demo y accedemos con invitado/invitado.

Con la demo instalada, continuamos con el curso. Haremos referencia a ella para poder ver en funcionamiento cualquier patrón, componente o funcionalidad en el transcurso del curso.

iii. Otras herramientasHasta ahora hemos visto las herramientas que vamos a utilizar durante el curso. Sin embargo hay que tener en cuenta que hay otras que también conviene incluir en nuestro entorno de desarrollo, pero que aquí no podemos ver por falta de espacio. Destacamos las siguientes:

● Control de versiones: svn, cvs, git, mercurial, … Nos permiten llevar un control de cambios del código fuente y facilitan el trabajo en grupo y la gestión de errores y funcionalidades en un proyecto.

● Tests unitarios: PHPUnit es una herramienta basada en JUnit que nos permite controlar que las clases y métodos hacen lo que se ha definido en los tests. La ejecución de estos tests se suele automatizar para que se invoquen desde el control de versiones.

● Tests funcionales: Selenium. Nos permite testear nuestra aplicación a nivel de la interfaz web, como si fuera un usuario, que realiza una serie de pasos y espera obtener un resultado. También permite hacer los tests en distintos navegadores.

● Forja para el proyecto: redmine, gforge, trac, … o bien en la nube (google code, sourceforge, github, …) Hay muchos, y su objetivo es servir de ayuda en el desarrollo de un proyecto. Suelen incluir integración con el control de versiones, registro de errores y mejoras, planificación de versiones, tareas, repositorio de ficheros para descargar, …

15

● Estándares de código: PHP_CodeSniffer. Verifica que el código fuente sigue los estándares de nomenclatura definidos, admitiendo los más populares como Pear, zend, …

16

3. ¿Qué es gvHIDRA?

a. Guía de estilogvHidra son las iniciales de Generalitat Valenciana: Herramienta Integral de Desarrollo Rápido de Aplicaciones.

Si hay que dar una explicación rápida, podemos decir que se trata de un entorno de trabajo (framework) para el desarrollo de aplicaciones de gestión en entornos web con PHP siguiendo una guía de estilo .

Una guía de estilo es un documento que recoge normativas y patrones básicos relacionados con el aspecto y usabilidad en el proceso de desarrollo de aplicaciones nuevas dentro de un entorno concreto. Recoge el contenido o información de la pantalla; Textos, campos de formularios, botones, menús y su comportamiento. Cómo se comporta cuando un usuario envía un formulario (validaciones), hace clic en un botón. Así como la apariencia final de un sistema; colores, tipografía, disposición de los elementos en pantalla.

Una buena guía de estilo, debe integrarse de manera eficiente en el proceso de trabajo de un programador ofreciendo criterios y ayudando en la toma de decisiones en aspectos de diseño de interfaz. Nunca debe ser una carga. Siendo esto último el motivo de la creación de framework que automatice todas esas tareas.

b. Arquitectura de una aplicación

Antes hemos hablado del entorno MVC. Ahora vamos a entender como es la arquitectura de una aplicación desarrollada en gvHidra.

Podemos resumir que el desarrollador de aplicaciones modificará/creará los siguientes ficheros en relación al MVC. Aunque también es posible hacerlo de manera automática, como veremos más adelante (genaro).

Modelo: Clases PHP que heredan de las clases gvHidraForm y gvHidraFormDB, según queramos persistencia de datos o no. Normalmente almacenados en el directorio actions/

Vista: Ficheros PHP que instancian objetos del motor de plantillas Smarty, normalmente almacenados en el directorio views/ . Y plantillas (templates) en lenguaje Smarty, normalmente almacenadas en el directorio plantillas/

17

Controlador: Ficheros include.php, mappings.php y menuModulos.xml . Almacenados en el directorio include/

En resumen, estos serán los directorios de trabajo normales de una aplicación hecha con gvHidra:

`-- aplicacion |-- actions |-- include |-- plantillas `-- views

c. Patrones de interfazUn patrón de interfaz es una agrupación de formulario/s, botones y comportamientos. El framework implementa muchos de los patrones de interfaz más útiles para el desarrollo de aplicaciones de gestión.

Nombre Codificación/Siglas

Patrón Tabular P1M2(FIL-LIS) Patrón Búsqueda P1M1(FIL)Patrón Tabular sin búsqueda P1M1(LIS)Patrón Alta Masiva P1M1(EDI)Patrón Registro P 1 M 2( FIL - EDI ) Patrón Registro sin búsqueda P1M1(EDI)Patrón Tabular - Registro P 1 M 3( FIL - LIS - EDI ) Patrón MD Maestro Tabular - Detalle Registro P2M2(FIL-LIS)M1(EDI)Patrón MD Maestro Tabular - Detalle Tabular P2M2(FIL-LIS)M1(LIS)Patrón MD Maestro Registro - Detalle Registro P2M2(FIL-EDI)M1(EDI)Patrón MD Maestro Registro - Detalle Tabular P 2 M 2( FIL - EDI ) M 1( LIS ) Patrón MD Maestro Registro - Detalle Tabular-Registro P2M2(FIL-EDI)M1(LIS-EDI)Patrón Árbol P1M2(FIL-EDI)

La codificación de los patrones indica:1. Px: número de paneles del patrón, siendo un panel un área que normalmente estará

asociada a una tabla2. Mx: número de modos del panel. Para los patrones con dos paneles, se indican los

modos para cada panel. Los modos usados son el de búsqueda o filtro (FIL), listado tabular (LIS) y listado monoregistro (EDI). A continuación del número de modos, se enumeran entre paréntesis los modos.

Podremos encontrar el esqueleto de estos patrones dentro del directorio de documentación del framework, en esta dirección igep/doc/plantillasTipo

18

El éxito de nuestros desarrollos se basarán en gran parte en la elección adecuada del patrón a la hora de implementar las operaciones que queremos que haga nuestra aplicación.

d. Mi primera aplicación, uso de Genaro.

Una vez presentados todos los actores, vamos a realizar nuestra primera aplicación mediante el asistente de “Generación de código gvHidra” Genaro. Esta herramienta nos va a permitir construir un esqueleto básico y funcional de nuestra aplicación a partir de nuestro diseño de tablas relacional. La herramienta se puede descargar junto al proyecto gvHIDRA en www . gvhidra . org .

Para realizar nuestra primera aplicación, primero tendremos que crear el esqueleto mínimo de una aplicación en gvHIDRA. Esto lo podremos hacer extrayendo de cualquier empaquetado de versión de gvHIDRA, el directorio plantilla-gvHidra.En segundo lugar, tendremos que incluir en nuestra nueva estructura de aplicación creada a partir de la plantilla, el “core” del framework, esto es el directorio igep, que también está dentro de cualquier empaquetado de versión. Por último, si queremos servirnos de la generación automática de código, descargaremos e incluiremos el proyecto genaro, en el directorio include de nuestro proyecto.

Para nuestra instalación concreta seguiremos los siguientes pasos.

GNU\Linux

1. Descargamos la última versión de gvHidra desde la web www . gvhidra . org $ wget https://gvhidra.gva.es/redmine/attachments/download/103/gvHIDRA-3_1_9.zip --no-check-certificate

2. Descomprimimos el zip a nuestro raíz de documentos de Apache (/var/www/).$ unzip gvHIDRA-3_1_9.zip -d /var/www/

3. Copiamos el directorio plantilla-gvHidra a nuestra raíz de documentos de Apache$ cp -R gvHIDRA-3_1_9/plantilla-gvHidra/ proyecto1

4. Otorgamos permisos de escritura al usuario que ejecuta Apache sobre el directorio templates_c. En su defecto asignaremos permisos de ejecución al grupo “Otros”.$ chmod o+w proyecto1/templates_c

5. Añadimos dentro de nuestra plantilla el “core” del framework.$ cp -R gvHIDRA-3_1_9/igep proyecto1/

6. Descargamos Genaro desde la web www . gvhidra . org $ wget https://gvhidra.gva.es/redmine/attachments/download/119/genaro-2_0_0.zip --no-check-certificate

7. Descomprimimos el zip a nuestro raíz de documentos Apache$ unzip genaro-2_0_0.zip

8. Copiamos el directorio genaro al directorio include de nuestra plantilla$ cp -R genaro-2_0_0/genaro proyecto1/include/

19

9. Damos permisos de escritura al usuario que ejecuta el servidor web en los directorios proyecto1/include/genaro/compile , proyecto1/actions proyecto1/views proyecto1/plantillas proyecto1/include/include.php proyecto1/include/mappings.php proyecto1/include/menudModulos.xml$ chmod o+w proyecto1/include/genaro/compile proyecto1/actions/ proyecto1/views proyecto1/plantillas proyecto1/include/include.php proyecto1/include/mappings.php proyecto1/include/menuModulos.xml

10. Configuramos los parámetros de conexión a nuestra base de datos en el fichero proyecto1/gvHidraConfig.inc.xml del raíz de la aplicación.

<dbDSN id='g_dsn' sgbd='postgres'> <dbHost>localhost</dbHost> <dbDatabase>demo</dbDatabase> <dbUser>demo_ae</dbUser> <dbPassword>demo_ae</dbPassword> </dbDSN>

Windows

1. Descargamos la última versión de gvHidra desde la web www . gvhidra . org 2. Descomprimimos el zip a nuestro raíz de documentos de Apache (c:\wamp\www\), esto

nos generará un directorio llamado gvHIDRA-3-1-9.3. Copiamos el directorio plantilla-gvHidra incluido en gvHIDRA-3-1-9/ a nuestro raíz de

documentos de Apache (c:\wamp\www\) y lo llamamos “proyecto1”c:\wamp\www\proyecto1

4. Nos aseguramos que existan las permisos necesarios para que el servidor Apache pueda escribir caché en el directorio c:\wamp\www\proyecto1\templactes_c

5. Copiamos dentro de nuestro proyecto1 el directorio c:\wamp\gvHIDRA-3-1-9\igepc:\wamp\www\proyecto1\igep

6. Descargamos la herramienta Genaro desde la web www . gvhidra . org 7. Descomprimimos el zip a nuestro raíz de documentos Apache (c:\wamp\www\)

c:\wamp\www\genaro

8. Copiamos el directorio genaro (c:\wamp\www\genaro-2_0_0\genaro) al directorio include de nuestro proyecto1

c:\wamp\www\proyecto1\include\genaro

9. Nos aseguramos que tiene permisos de escritura el usuario que ejecuta el servidor web en los directorios proyecto1/include/genaro/compile , proyecto1/actions proyecto1/views proyecto1/plantillas proyecto1/include/include.php proyecto1/include/mappings.php proyecto1/include/menudModulos.xml

10. Con todos los ficheros creados, crearemos un proyecto eclipse a partir del directorio c:\wamp\www\proyecto1

20

11. Configuramos los parámetros de conexión a nuestra base de datos editando con eclipse el fichero gvHidraConfig.inc.xml ubicado en el raíz de la aplicación.

<dbDSN id='g_dsn' sgbd='postgres'> <dbHost>localhost</dbHost> <dbDatabase>demo</dbDatabase> <dbUser>demo_ae</dbUser> <dbPassword>demo_ae</dbPassword> </dbDSN>

Una vez instalada correctamente la plantilla y el proyecto genaro, probamos la generación de nuestra primera pantalla accediendo1 a la url http://localhost/proyecto1/ y haciendo click en “Genaro”.

Ejemplo a seguir en genaro:

Elegimos el dsn de conexión: g_dsnPinchamos en la solapa: Patrón SimpleNombre módulo: GenaroInformesClase Manejadora: GenaroInformesSeleccionar Tabla: informesSeleccionar Patrón: FIL-LIS-EDI

Generar!

Tras la ejecución, podremos ver que Genaro ha creado ficheros necesarios en la arquitectura MVC que hemos visto con anterioridad.

`-- proyecto1 |-- actions/GenaroInformes/GenaroInformes.php |-- include/include.php: $al->registerClass('GenaroInformes.... |-- include/menuModulos.xml: <modulo titulo="genaroInformes"... |-- include/mappings.php: $this->_AddMapping('GenaroInformes... |-- plantillas/GenaroInformes/p_GenaroInformes.tpl `-- views/GenaroInformes/p_GenaroInformes.php

1 Usuario/Contraseña: Invitado/1

21

22

4. Desarrollando software con gvHidra (Caso práctico)

a. Presentación del caso

“Control de actividad en la unidad de Diálisis”

El control de las sesiones a los pacientes del servicio de Diálisis se viene realizando sobre aplicaciones dispersas propietarias y bases de datos Ms Access sin normalizar con redundancia de mantenimientos básicos.Por suerte, un equipo de desarrolladores ha decidido acabar con este problema realizando una aplicación gvHIDRA, cumpliendo los requisitos extraídos, que además será utilizable por todo el personal autorizado sin mayor inconveniente por tratarse de una aplicación multiplataforma y de interfaz universal (web).

Se establece como objetivo general el desarrollo de un sistema integral para el seguimiento de la actividad clínico-administrativa del paciente y el consumo de recursos materiales.

i. Requisitos● Será necesario tener un inventario de personal facultativo organizado según categoría

profesional. Este personal, podrá ser en principio agrupado por; auxiliares, enfermeros y médicos.

● También se registrará al paciente con sus datos personales sobre el cual se realizarán las sesiones que también serán registradas junto con su información relevante y materiales utilizados en la sesión.

● Del mismo modo, será necesario mantener un inventario de recursos materiales de los cuales se deberá conocer al menos su descripción detallada y precio unitario. Estos materiales también deben ser categorizados según su naturaleza; Papelería, Fungible, Laboratorio, Sueros, etc.

● Por último se obtendrán informes del coste del material empleado en las distintas sesiones que pueda percibir un paciente.

23

ii. Modelo entidad relación de apoyo

24

b. Preparación entorno, personalización y carga de datos

A la hora de iniciar una nueva aplicación vamos a seguir los siguientes pasos:

GNU/Linux1. Creamos un directorio para la nueva aplicación “dialisis”

$ mkdir /var/www/dialisis

2. Descomprimir/copiar la “plantilla de aplicación” en su interior.$ cp -R /var/www/gvHIDRA-3_1_9/plantilla-gvHidra/* /var/www/dialisis/

3. Descomprimir/copiar “IGEP” en su interior$ cp -R /var/www/gvHidra-3_1_9/igep /var/www/dialisis/

4. Descomprimir/copiar “genaro” en su interior y configurar los permisos.$ cp -R /var/www/genaro-2_0_0/genaro /var/www/dialisis/include/$ chmod o+w /var/www/dialisis/templates_c \ /var/www/dialisis/include/genaro/compile \ /var/www/dialisis/actions \ /var/www/dialisis/views \ /var/www/dialisis/plantillas \ /var/www/dialisis/include/include.php \ /var/www/dialisis/include/mappings.php \ /var/www/dialisis/include/menuModulos.xml

5. Crear proyecto PHP en EclipseCreamos el proyecto con soporte PHP a partir de la ruta /var/www/dialisis

Windows1. Crear un directorio para la nueva aplicación “dialisis”

md c:\wamp\www\dialisis

2. Descomprimir/copiar la “plantilla de aplicación” en su interior.xcopy c:\wamp\www\gvHIDRA-3_1_9\plantilla-gvHidra\* c:\wamp\www\dialisis\ /E

3. Descomprimir/copiar “IGEP” en su interiorxcopy c:\wamp\www\gvHidra-3_1_9\igep c:\wamp\www\dialisis\ /E

4. Descomprimir/copiar “genaro” en su interior y configurar los permisos.xcopy c:\wamp\www\genaro-2_0_0\genaro c:\wamp\www\dialisis\include\ /E

5. Comprobamos que los siguientes directorios no son de solo lectura y el usuario que ejecuta el servidor web tiene permisos de escritura en ellos:

c:\wamp\www\dialisis\templates_cc:\wamp\www\dialisis\include\genaro\compilec:\wamp\www\dialisis\actions c:\wamp\www\dialisis\views c:\wamp\www\dialisis\plantillas c:\wamp\www\dialisis\include\include.php c:\wamp\www\dialisis\include\mappings.php c:\wamp\www\dialisis\include\menuModulos.xml

25

6. Crear un proyecto eclipse con soporte PHP a partir de la ruta ( /var/www/dialisis ó c:\wamp\www\dialisis )

26

6. Cargar base de datospsql -f dialisis.sql -U postgres

27

Contenido del fichero dialisis.sql:

/* ********************************************************************* *//* Caso practico gvHidra - Control de actividad en la unidad de Dialisis *//* ********************************************************************* */SET client_encoding = 'UTF8'; SET escape_string_warning = 'off';/* **************** *//* **** USUARIOS ** *//* **************** */CREATE ROLE dialisis; ALTER ROLE dialisis WITH NOSUPERUSER INHERIT NOCREATEROLE NOCREATEDB LOGIN PASSWORD 'dialisis';ALTER ROLE dialisis SET SEARCH_PATH='dialisis';

CREATE ROLE dialisis_ae; ALTER ROLE dialisis_ae WITH NOSUPERUSER INHERIT NOCREATEROLE NOCREATEDB LOGIN PASSWORD 'dialisis_ae';ALTER ROLE dialisis_ae SET SEARCH_PATH='dialisis';

CREATE ROLE dialisis_ac; ALTER ROLE dialisis_ac WITH NOSUPERUSER INHERIT NOCREATEROLE NOCREATEDB LOGIN PASSWORD 'dialisis_ac';ALTER ROLE dialisis_ac SET SEARCH_PATH='dialisis';/* **************** *//* **** DATABASE ** *//* **************** */

CREATE DATABASE dialisis WITH TEMPLATE = template0 OWNER = postgres ENCODING = 'UTF8';

\connect dialisis

SET statement_timeout = 0;SET client_encoding = 'UTF8';SET standard_conforming_strings = off;SET check_function_bodies = false;SET client_min_messages = warning;SET escape_string_warning = off;

/* **************** *//* **** ESQUEMA ** *//* **************** */

CREATE SCHEMA dialisis; ALTER SCHEMA dialisis OWNER TO dialisis;COMMENT ON SCHEMA dialisis IS 'Caso practico gvHidra - Control de actividad en la unidad de Dialisis';ALTER ROLE dialisis SET search_path TO dialisis;ALTER ROLE dialisis_ae SET search_path TO dialisis;ALTER ROLE dialisis_ac SET search_path TO dialisis;

/* **************** *//* ** SECUENCIAS ** *//* **************** */

CREATE SEQUENCE dialisis.scmn_pacientes START WITH 0 INCREMENT BY 1 NO MAXVALUE MINVALUE 0

28

CACHE 1 CYCLE;ALTER TABLE dialisis.scmn_pacientes OWNER TO dialisis;

CREATE SEQUENCE dialisis.scmn_personal START WITH 0 INCREMENT BY 1 NO MAXVALUE MINVALUE 0 CACHE 1 CYCLE;ALTER TABLE dialisis.scmn_personal OWNER TO dialisis;

/* **************** *//* ** TABLAS ** *//* **************** */

/* PACIENTES */CREATE TABLE dialisis.pacientes( idpaciente integer NOT NULL, sip integer NOT NULL, nif character varying(12), nombre character varying(50), apellido1 character varying(30), apellido2 character varying(30), sexo character varying(1), domicilio character varying(150), poblacion character varying(75), cpostal character varying(8), provincia character varying(30), telefono character varying(50), fecha_nacim date, estado smallint, CONSTRAINT pacientes_pkey PRIMARY KEY (idpaciente ))WITHOUT OIDS;ALTER TABLE dialisis.pacientes OWNER TO dialisis;

/* PERSONAL */CREATE TABLE dialisis.categoria_personal ( idcategoria integer NOT NULL, descripcategoria character varying(25) default NULL, PRIMARY KEY (idcategoria))WITHOUT OIDS;ALTER TABLE dialisis.categoria_personal OWNER TO dialisis;

CREATE TABLE dialisis.personal( idpersona integer NOT NULL, ncolegiado character varying(15), nif character varying(30), apellido1 character varying(20), apellido2 character varying(20), nombre character varying(30), refcategoria integer, FOREIGN KEY (refcategoria) REFERENCES dialisis.categoria_personal (idcategoria) ON UPDATE CASCADE, PRIMARY KEY (idpersona)

29

)WITHOUT OIDS;ALTER TABLE dialisis.personal OWNER TO dialisis;

/* MATERIAL */CREATE TABLE dialisis.grupo_material ( idgrupomed integer NOT NULL, descripgpmed character varying(50) default NULL, PRIMARY KEY (idgrupomed) )WITHOUT OIDS;ALTER TABLE dialisis.grupo_material OWNER TO dialisis;

CREATE TABLE dialisis.tipo_material ( idtipomed integer NOT NULL, descriptpmed character varying(50) default NULL, refgpmed integer NOT NULL, PRIMARY KEY (idtipomed), FOREIGN KEY (refgpmed) REFERENCES dialisis.grupo_material (idgrupomed) ON UPDATE CASCADE)WITHOUT OIDS;ALTER TABLE dialisis.tipo_material OWNER TO dialisis;

CREATE TABLE dialisis.material ( idmatmedic integer NOT NULL, codmaterial character varying(15) NOT NULL, descripmatmedic character varying(75), reftipomedic integer, preciounit numeric(9,5) DEFAULT 0, PRIMARY KEY (idmatmedic), FOREIGN KEY (reftipomedic) REFERENCES dialisis.tipo_material (idtipomed))WITHOUT OIDS;ALTER TABLE dialisis.material OWNER TO dialisis;CREATE INDEX idx_codmaterial ON dialisis.material USING btree (codmaterial);

/* SESIONES */

CREATE TABLE dialisis.sesiones ( idsesion integer NOT NULL, fecha date NOT NULL, refpaciente integer NOT NULL, talla numeric(5,2), peso numeric(5,2), observaciones character varying(250), reffacultativo integer NOT NULL, dp smallint, hd smallint, cexnef smallint, plasmaf smallint, prehierro smallint, refpretipofe integer DEFAULT 1 NOT NULL, prehtc numeric(6,2),

30

prevcm numeric(6,2), presid numeric(6,2), preist numeric(6,2), preferrit numeric(6,2), precoment character varying(250), posthierro smallint, refposttipofe integer DEFAULT 1 NOT NULL, posthtc numeric(6,2), postvcm numeric(6,2), postsid numeric(6,2), postist numeric(6,2), postferrit numeric(6,2), nanalitica integer, postcoment character varying(250), FOREIGN KEY (refpaciente) REFERENCES dialisis.pacientes(idpaciente) ON UPDATE CASCADE, FOREIGN KEY (reffacultativo) REFERENCES dialisis.personal(idpersona) ON UPDATE CASCADE, PRIMARY KEY (idsesion) ) WITHOUT OIDS;ALTER TABLE dialisis.sesiones OWNER TO dialisis;

/* PERMISOS */

GRANT USAGE ON SCHEMA dialisis TO dialisis;GRANT USAGE ON SCHEMA dialisis TO dialisis_ae;GRANT USAGE ON SCHEMA dialisis TO dialisis_ac;

GRANT ALL ON TABLE dialisis.scmn_pacientes TO dialisis;GRANT USAGE,SELECT,UPDATE ON TABLE dialisis.scmn_pacientes TO dialisis_ae;GRANT USAGE,SELECT ON TABLE dialisis.scmn_pacientes TO dialisis_ac;

GRANT ALL ON TABLE dialisis.scmn_personal TO dialisis;GRANT USAGE,SELECT,UPDATE ON TABLE dialisis.scmn_personal TO dialisis_ae;GRANT USAGE,SELECT ON TABLE dialisis.scmn_personal TO dialisis_ac;

GRANT ALL ON TABLE dialisis.pacientes TO dialisis;GRANT SELECT,INSERT,DELETE,UPDATE ON TABLE dialisis.pacientes TO dialisis_ae;GRANT SELECT ON TABLE dialisis.pacientes TO dialisis_ac;

GRANT ALL ON TABLE dialisis.categoria_personal TO dialisis;GRANT SELECT,INSERT,DELETE,UPDATE ON TABLE dialisis.categoria_personal TO dialisis_ae;GRANT SELECT ON TABLE dialisis.categoria_personal TO dialisis_ac;

GRANT ALL ON TABLE dialisis.personal TO dialisis;GRANT SELECT,INSERT,DELETE,UPDATE ON TABLE dialisis.personal TO dialisis_ae;GRANT SELECT ON TABLE dialisis.personal TO dialisis_ac;

GRANT ALL ON TABLE dialisis.grupo_material TO dialisis;GRANT SELECT,INSERT,DELETE,UPDATE ON TABLE dialisis.grupo_material TO dialisis_ae;GRANT SELECT ON TABLE dialisis.grupo_material TO dialisis_ac;

GRANT ALL ON TABLE dialisis.tipo_material TO dialisis;GRANT SELECT,INSERT,DELETE,UPDATE ON TABLE dialisis.tipo_material TO dialisis_ae;GRANT SELECT ON TABLE dialisis.tipo_material TO dialisis_ac;

GRANT ALL ON TABLE dialisis.material TO dialisis;GRANT SELECT,INSERT,DELETE,UPDATE ON TABLE dialisis.material TO dialisis_ae;GRANT SELECT ON TABLE dialisis.material TO dialisis_ac;

31

GRANT ALL ON TABLE dialisis.sesiones TO dialisis;GRANT SELECT,INSERT,DELETE,UPDATE ON TABLE dialisis.sesiones TO dialisis_ae;GRANT SELECT ON TABLE dialisis.sesiones TO dialisis_ac;

7. Fijar el nombre de la aplicación (dialisis/gvHidraConfig.inc.xml)<applicationName>dialisis</applicationName>

8. Definir las conexiones en la aplicación (dialisis/gvHidraConfig.inc.xml)<DSNZone>

<dbDSN id='g_dsn' sgbd='postgres'> <dbHost>localhost</dbHost> <dbDatabase>dialisis</dbDatabase> <dbUser>dialisis_ae</dbUser> <dbPassword>dialisis_ae</dbPassword> </dbDSN>

<dbDSN id='g_dsn_log' sgbd='postgres'> <dbHost>localhost</dbHost> <dbDatabase>demo</dbDatabase> <dbUser>demo_log</dbUser> <dbPassword>demo_log</dbPassword> </dbDSN> </DSNZone>

Atención: Esta configuración conecta el LOG a la base de datos demo, por lo que debe de existir.

9. Habilitar Debug<logSettings status='LOG_ALL' dsnRef='g_dsn_log'/>

Atención: Debido a un bug en la distribución de la plantilla, para que la anterior configuración de debug surta efecto, hay que comentar la linea 15 del fichero actions/principal/AppMainWindow.php

15: //$conf->setLogStatus(LOG_NONE);

c. Creación de mantenimientos

Para comenzar, vamos a crear los mantenimientos necesarios según los requisitos del enunciado. Estos mantenimientos los podremos realizar de manera automática con la ayuda de la herramienta “genaro”. De igual modo, podríamos comenzar utilizando las plantillas de los patrones que están almacenadas en igep/doc/plantillasTipo/ y rellenándolas a mano.

32

En este ejercicio lo haremos todos con la herramienta “genaro” y el último, relativo al informe lo haremos desde las plantillas para que sirva de ejemplo.

Accedemos a la plantilla de aplicación creada y nos validamos1 con usuario/contraseña invitado/1.

http://localhost/dialisis

1 Si deseamos cambiar este validación, cambiaremos el fichero igep/include/valida/AuthBasic.php

33

i. Mantenimientos a realizar según los requisitos del enunciado:• Mantenimiento tipo material Patrón Tabular / P1M2(FIL-LIS)

• Mantenimiento material Patrón Tabular / P1M2(FIL-LIS)

• Mantenimiento categorías personal Patrón Tabular / P1M2(FIL-LIS)

• Mantenimiento personal Patrón Registro / P1M2(FIL-EDI)

• Mantenimiento pacientes Patrón Tabular-Registro / P1M3(FIL-LIS-EDI)

• Mantenimiento sesiones Patrón MD Maestro Registro - Detalle Tabular / P2M2(FIL-EDI)M1(LIS)

• Informe gasto paciente Patrón Tabular / P1M2(FIL-LIS)

Mantenimiento tipo material Patrón Tabular / P1M2(FIL-LIS)

34

35

Mantenimiento material Patrón Tabular / P1M2(FIL-LIS)

36

37

Mantenimiento categorías personal Patrón Tabular / P1M2(FIL-LIS)

38

39

Mantenimiento personal Patrón Registro / P1M2(FIL-EDI)

40

41

Mantenimiento pacientes Patrón Tabular-Registro / P1M3(FIL-LIS-EDI)

42

43

44

Mantenimiento sesiones Patrón MD Maestro Registro - Detalle Tabular / P2M2(FIL-EDI)M1(LIS)

Atención: Si en el momento de rellenar el “Detalle 1” no se autodetecta la relación con la tabla correspondiente, pincharemos el “checkbox” junto al desplegable y rellenaremos manualmente nombre de tabla y clave ajena.

45

46

Informe gasto paciente Patrón Tabular / P1M2(FIL-LIS)

Este patrón lo haremos “a mano” desde las plantillas. En primer lugar creamos la “clase manejadora”, la cual se encargará del “negocio”.

Copiamos el fichero classForm_DB.php al directorio actions/Informes/InfGastoPaciente.php.En el rellenaremos los siguientes datos; nombre de la clase manejadora (igual que el nombre del fichero), datos de conexión de la aplicación, tablas sobre las cual se va a operar, sentencia SQL para mostrar los datos.

47

El resultado será algo como este:

<?php

class InfGastoPaciente extends gvHidraForm_DB {

public function __construct(){

$conf = ConfigFramework::getConfig(); //Identifique el nombre del dsn. $g_dsn = $conf->getDSN('g_dsn'); $nombreTablas= array('pacientes'); parent::__construct($g_dsn,$nombreTablas); //La select que mostramos en el panel de listado $this->setSelectForSearchQuery(" SELECT idpaciente as lis_idpaciente ,sip as lis_sip ,nif as lis_nif ,apellido1 || ' '|| apellido2||', '||nombre as lis_nombre FROM pacientes" ); $this->setOrderByForSearchQuery("lis_nif");

$this->addMatching('fil_nif', 'nif', 'pacientes');$this->addMatching('fil_sip', 'sip', 'pacientes');

}

}?>

48

En segundo lugar, creamos el ”template” o plantilla, donde definiremos el aspecto de la pantalla.

Copiamos el fichero plantilla-P1M2(FIL-LIS).tpl al directorio plantillas/Informes/p_InfGastoPaciente.tplEn el rellenaremos la información relativa a; clase manejadora, título y componentes que queremos mostrar. Para conocer dichos componentes y cómo rellenarlos haremos uso del manual de gvHIDRA descargado de la web .

49

El resultado será algo como este:

{CWVentana tipoAviso=$smty_tipoAviso codAviso=$smty_codError descBreve=$smty_descBreve textoAviso=$smty_textoAviso onLoad=$smty_jsOnLoad}{CWBarra usuario=$smty_usuario codigo=$smty_codigo customTitle=$smty_customTitle} {CWMenuLayer name="$smty_nombre" cadenaMenu="$smty_cadenaMenu"} {/CWBarra}{CWMarcoPanel conPestanyas="true"}

<!--*********** PANEL fil ******************--> {CWPanel id="fil" action="buscar" method="post" estado="$estado_fil" claseManejadora="InfGastoPaciente"} {CWBarraSupPanel titulo="Informe de gasto por paciente"} {*CWBotonTooltip imagen="01" titulo="Insertar registros" funcion="insertar" actuaSobre="ficha" action="InfGastoPaciente__nuevo"*} {CWBotonTooltip imagen="04" titulo="Restaurar valores" funcion="restaurar" actuaSobre="ficha"} {/CWBarraSupPanel} {CWContenedor} {CWFicha} <br /> {CWCampoTexto nombre="fil_nif" textoAsociado="NIF" size="8" value=$defaultData_InfGastoPaciente.fil_nif dataType=$dataType_InfGastoPaciente.fil_nif} &nbsp; {CWCampoTexto nombre="fil_sip" textoAsociado="SIP" size="8" value=$defaultData_InfGastoPaciente.fil_sip dataType=$dataType_InfGastoPaciente.fil_sip} &nbsp;&nbsp; {CWCampoTexto nombre="fil_nombre" size="50" value=$defaultData_InfGastoPaciente.fil_nombre dataType=$dataType_InfGastoPaciente.fil_nombre} <br /> <br /> {/CWFicha} {/CWContenedor} {CWBarraInfPanel} {CWBoton imagen="50" texto="Buscar" class="boton" accion="buscar" } {/CWBarraInfPanel} {/CWPanel} <!-- ****************** PANEL lis ***********************--> {CWPanel id="lis" tipoComprobacion="envio" action="operarBD" method="post" estado="$estado_lis" claseManejadora="InfGastoPaciente"} {CWBarraSupPanel titulo="Listado pacientes para informe"} {*CWBotonTooltip imagen="01" titulo="Insertar registros" funcion="insertar" actuaSobre="tabla" action="InfGastoPaciente__nuevo"*} {CWBotonTooltip imagen="02" titulo="Modificar registros" funcion="modificar" actuaSobre="tabla"} {*CWBotonTooltip imagen="03" titulo="Eliminar registros" funcion="eliminar" actuaSobre="tabla"*} {/CWBarraSupPanel} {CWContenedor} {CWTabla conCheck="true" conCheckTodos="false" id="Tabla1" numPagInsertar="1" numFilasPantalla="6" datos=$smty_datosTabla} {CWFila tipoListado="false"} {CWCampoTexto nombre="lis_idpaciente" textoAsociado="Id" size="8" value=$defaultData_InfGastoPaciente.lis_idpaciente dataType=$dataType_InfGastoPaciente.lis_idpaciente} {CWCampoTexto nombre="lis_nif" textoAsociado="NIF" size="8" value=$defaultData_InfGastoPaciente.lis_nif dataType=$dataType_InfGastoPaciente.lis_nif} {CWCampoTexto nombre="lis_sip" textoAsociado="SIP" size="8" value=$defaultData_InfGastoPaciente.lis_sip dataType=$dataType_InfGastoPaciente.lis_sip}

50

{CWCampoTexto nombre="lis_nombre" size="50" textoAsociado="Nombre" value=$defaultData_InfGastoPaciente.lis_nombre dataType=$dataType_InfGastoPaciente.lis_nombre} {/CWFila} {CWPaginador enlacesVisibles="3"} {/CWTabla} {/CWContenedor} {CWBarraInfPanel} {*CWBoton imagen="41" texto="Guardar" class="boton" accion="guardar"*} {CWBoton imagen="42" texto="Cancelar" class="boton" accion="cancelar"} {/CWBarraInfPanel} {/CWPanel} <!-- ****************** PESTANYAS ************************--> {CWContenedorPestanyas} {CWPestanya tipo="fil" estado=$estado_fil} {CWPestanya tipo="lis" estado=$estado_lis} {/CWContenedorPestanyas}{/CWMarcoPanel}{/CWVentana}

51

Ahora vamos a crear el fichero que conecta la plantilla con la clase manejadora, es decir, la presentación con el negocio.

Copiamos el fichero views/views-P1M2(FIL-LIS).php al directorio views/Informes/p_InfGastoPaciente.phpEn el rellenaremos la clase manejadora y la ruta a la plantilla.

52

El resultado será algo como este:<?php//Creamos una pantalla$comportamientoVentana= new IgepPantalla();

$panel1 = new IgepPanel('InfGastoPaciente',"smty_datosTabla");$panel1->activarModo("fil","estado_fil");$panel1->activarModo("lis","estado_lis");$comportamientoVentana->agregarPanel($panel1);

$s->display('Informes/p_InfGastoPaciente.tpl');?>

Ahora vamos a informar al controlador donde se encuentran nuestra nueva pantalla y que caminos debe tomar para ejecutarla.

53

Copiamos el CONTENIDO del fichero include/mappings-P1M2(FIL-LIS).php al interior de nuestro fichero include/mappings.php.En el rellenamos el nombre de la clase manejadora y la ruta al fichero de views que hemos creado en el paso anterior. El resultado será algo como este:

/*Informes*/$this->_AddMapping('InfGastoPaciente__iniciarVentana', 'InfGastoPaciente');$this->_AddForward('InfGastoPaciente__iniciarVentana', 'gvHidraSuccess', 'index.php?view=views/informes/p_InfGastoPaciente.php&panel=buscar');$this->_AddForward('InfGastoPaciente__iniciarVentana', 'gvHidraError', 'index.php?view=igep/views/aplicacion.php');$this->_AddMapping('InfGastoPaciente__buscar', 'InfGastoPaciente');

54

$this->_AddForward('InfGastoPaciente__buscar', 'gvHidraSuccess', 'index.php?view=views/informes/p_InfGastoPaciente.php&panel=listar');$this->_AddForward('InfGastoPaciente__buscar', 'gvHidraNoData', 'index.php?view=views/informes/p_InfGastoPaciente.php&panel=listar');$this->_AddForward('InfGastoPaciente__buscar', 'gvHidraError', 'index.php?view=views/informes/p_InfGastoPaciente.php&panel=listar');/*Informes*/

Atención: Si se añaden los mappings anteriores al final del fichero, hay que tener en cuenta de insertarlos antes de las llaves de cierre y tag de php: }}?>

Además, registramos la clase para que sea cargada solo cuando sea necesaria. Esto lo conseguimos añadiendo la siguiente línea en nuestro fichero include/include.php

$al->registerClass('InfGastoPaciente','actions/Informes/InfGastoPaciente.php');

Como último paso, solo nos queda crear la entrada de menú correspondiente para poder acceder a la pantalla. Para conseguirlo, tan solo tendremos que editar el fichero include/menuModulos.xml1 y añadir algo como esto:

<modulo titulo="Informes" imagen="menu/43.gif" descripcion="Informes para imprimir"> <opcion titulo="Informe gasto paciente" descripcion="Informe de gasto por paciente" url="phrame.php?action=InfGastoPaciente__iniciarVentana" /> </modulo>

En definitiva, tenemos que editar esta serie de ficheros:

En cada uno de ellos, hemos realizado el reemplazo de las palabras clave con los datos que identifican nuestra pantalla. Es decir, principalmente hemos identificado la “clase manejadora” del panel, el dsn de conexión, las tablas involucradas, los títulos de las ventanas, el nombre de fichero de plantilla, la relación con el controlador (mappings). Además, hemos realizado la consulta SQL que nos ha interesado, los campos de la tabla sobre los cuales realizaremos operaciones y en relación a estos los campos su visibilidad/editabilidad en la pantalla.

1Como siempre, encontraremos la información necesaria para diseñar el menú en el manual de gvHidra

55

El resultado esperado en ejecución es este:

56

d. Incorporación de lógica de presentación

Como hemos podido observar, la generación de los mantenimientos con la herramienta “Genaro” no nos proporciona el resultado final requerido. Tendremos que resolver por tanto, detalles de aspecto de los campos, ubicación y tamaño, la generación de claves primarias automáticamente, o facilitar el uso de claves foráneas.

Estas tareas las vamos a ir desarrollando en los siguientes apartados. Partiremos de las modificaciones más sencillas a las más complejas. No obstante, estas modificaciones serán relativas a la presentación, dejando para el punto siguiente las modificaciones de la lógica de negocio.

i. Componentes simples

Antes de empezar a modificar componentes, tal vez sea buena idea organizarlos en la pantalla adecuadamente. Como la generación de los componentes en html se realiza por la transformación de la plantilla, tendremos que intercalar código HTML con código del motor de plantillas Smarty. Lo más habitual será añadir saltos de página <br />, espacios en blanco &nbsp; o tablas <TABLE>.1

Si observamos las plantillas generadas por la herramienta “genaro”, veremos que ya se ha seguido esta estrategia. En cambio, en la pantalla que hemos generado nosotros a mano, tal vez haya que retocarla algo, editamos por tanto dialisis/plantillas/Informes/p_InfGastoPaciente.tpl, guardamos los cambios y recargamos la pantalla.

Hablando de componentes propiamente dichos, estos son algunos de los que podemos considerarlos simples:

CWCampoTextoCWTextAreaCWBotonCWBotonToolTipCWImagenCWBarra[Sup/Inf]Panel

Estos componentes tienen características parametrizables como: tabIndex, size, longitud[Max/Min], label, máscara, oculto, visible, editable, imagen, título

1Si nos decantamos por la distribución mediante tablas, utilizar el estilo asociado llamado “formularios”.

57

Obtendremos toda la información necesaria para su correcta parametrización en el manual de gvHIDRA en el apartado de “Plugins”.

Siguiendo con el ejemplo haremos las siguientes modificaciones:

Mejorar la presentación de la pantalla “MantPacientes”, parametrizando los siguientes puntos:

Cambiar títulos en menú de acceso a la pantalla y en las pantallas de la aplicaciónFichero: include/menuModulos.xmlCódigo: <opcion titulo="Alta/Baja Pacientes" descripcion="Mantenimiento de datos de

Pacientes" url="phrame.php?action=MantPacientes__iniciarVentana"/>

Fichero: plantillas/Mantenimiento Pacientes/p_MantPacientes.tplCódigo: {CWBarraSupPanel titulo="Búsqueda de Pacientes"} , {CWBarraSupPanel

titulo="Listado de Pacientes"}, {CWBarraSupPanel titulo="Mantenimiento de Pacientes"}

Limitar tamaño de los campos en listado y alta/modificación:Fichero: plantillas/MantenimientoPacientes/p_MantPacientes.tplCódigo: lis_domicilio-> size=15, lis_poblacion-> size=8, lis_provincia> size=8

Fichero: actions/MantenimientoPacientes/MantPacientes.phpCódigo:$string9= new gvHidraString(false,9);

$this->addFieldType("edi_nif", $string9);

Añadir máscara de formato a los campos NIF y teléfonoFichero: actions/MantenimientoPacientes/MantPacientes.phpCódigo:

$string9= new gvHidraString(false,9);$string9->setInputMask('########x');$this->addFieldType("edi_nif", $string9);

$telefono= new gvHidraString(false,15);$telefono->setInputMask('(+##)-#########');

$this->addFieldType("edi_telefono", $telefono);

Convertir en obligatorio el campo NIF y teléfonoFichero: actions/MantenimientoPacientes/MantPacientes.phpCódigo:

$string9= new gvHidraString(false,9);$string9->setInputMask('########x');$string9->setRequired(true);$this->addFieldType("edi_nif", $string9);

$telefono= new gvHidraString(true,15);$telefono->setInputMask('(+##)-#########');

$this->addFieldType("edi_telefono", $telefono);

58

Vamos ahora a mejorar la pantalla “RegistroSesion”:Cambiamos títulos en menú y pantallas. Delimitamos mejor los campos del maestro y detalle para su correcta visualización.

Convertimos el campo Observaciones de “campo de texto” a “área de texto”Fichero: plantillas/Sesiones/p_RegistroSesion.tplCódigo: {CWAreaTexto textoAsociado="Observaciones" nombre="fil_observaciones"

longitudMaxima="200" cols="80" rows="8" editable="true" value=$defaultData_RegistroSesion.fil_observaciones dataType=$dataType_RegistroSesion.fil_observaciones}

También podemos ocultar los campos que no nos interesen en la pantalla de filtro, ya sea utilizando el tag de comentario {* *} o eliminando completamente el componente.

Fichero: plantillas/Sesiones/p_RegistroSesion.tplCódigo:{*CWCampoTexto textoAsociado="Dp" nombre="fil_dp" size="2" editable="true"

value=$defaultData_RegistroSesion.fil_dp dataType=$dataType_RegistroSesion.fil_dp*}

ii. Componentes avanzados

En cuanto a componentes avanzados vamos a tratar componentes que requieren de mayor configuración. De igual modo, dichos componentes dotarán de mayor potencia nuestras pantallas.

Vamos ahora a agrupar los datos por solapas. Esto lo realizaremos en el “RegistroSesion”, agrupando los datos del paciente en una solapa y los de la sesión en otra.

Fichero: plantillas/Sesiones/p_RegistroSesion.tplCódigo:

{CWSolapa titulo="Ficha" posicionSolapa=0} <table class="formularios" cellspacing="4" cellpadding="4" border="0"> <tr> <td>{CWCampoTexto textoAsociado="Idsesion" nombre="idsesion" size="4"

editable="true" value=$defaultData_RegistroSesion.idsesion dataType=$dataType_RegistroSesion.idsesion}</td>

</tr>... <tr> <td>{CWCampoTexto textoAsociado="Reffacultativo" nombre="edi_reffacultativo"

size="4" editable="true" value=$defaultData_RegistroSesion.edi_reffacultativo dataType=$dataType_RegistroSesion.edi_reffacultativo}</td>

</tr> </table> {/CWSolapa}

{CWSolapa titulo="Parámetros" posicionSolapa=1}<table class="formularios" cellspacing="4" cellpadding="4" border="0"><tr>

59

<td>{CWCampoTexto textoAsociado="Dp" nombre="edi_dp" size="2" editable="true" value=$defaultData_RegistroSesion.edi_dp dataType=$dataType_RegistroSesion.edi_dp}</td>

</tr>...<tr><td>{CWCampoTexto textoAsociado="Postcoment" nombre="edi_postcoment" size="50"

editable="true" value=$defaultData_RegistroSesion.edi_postcoment dataType=$dataType_RegistroSesion.edi_postcoment}</td>

</tr></table>{/CWSolapa}

Un componente muy útil e interesante es el componente “fecha”, el cual nos permitirá delimitar la introducción de los datos a la vez que nos asiste con un calendario para no tener que teclearla.

Fichero:actions/Sesiones/RegistroSesion.phpCódigo:

$fecha= new gvHidraDate(false);$fecha->setCalendar(true);

$fecha->setDayOfWeek(true);$this->addFieldType('edi_fecha', $fecha);

También parece interesante que a la hora de registrar una nueva sesión, se rellene automáticamente el campo fecha con la fecha actual. Esto lo conseguiremos creando un objeto de tipo gvHidraTimestamp y añadiéndolo como dato por defecto (Más información en la sección “Fechas” y “Uso de datos por defecto” del manual gvHIDRA).

Fichero:actions/Sesiones/RegistroSesion.phpCódigo:

$today= new gvHidraTimestamp('today');$this->addDefaultData('edi_fecha', $today);

Otro componente avanzado, pero básico al mantener tablas con relaciones de claves ajenas es la lista desplegable (Ver apartado Listas en manual gvHidra). Por ello, transformaremos el campo Reffacultativo el cual es un campo de texto libre (CWCampoTexto) a lista desplegable dinámica (CWLista) que mostrará como valores posibles los que hayamos introducido en el mantenimiento de personal

Fichero: actions/principal/appMainwindow.phpCódigo: $conf->setList_DBSource('LISTA_PERSONAL',"select idpersona as \"valor\",

apellido1 ||' '||apellido2 || ', '||nombre as \"descripcion\" from personal");

Fichero:actions/Sesiones/RegistroSesion.phpCódigo:

$listaFacultativo= new gvHidraList('edi_reffacultativo', 'LISTA_PERSONAL');$this->addList($listaFacultativo);

60

Fichero: plantillas/Sesiones/p_RegistroSesion.tplCódigo: {CWLista textoAsociado="Reffacultativo" nombre="edi_reffacultativo" size="0"

editable="true" datos=$defaultData_RegistroSesion.edi_reffacultativo dataType=$dataType_RegistroSesion.edi_reffacultativo}

Las listas, también pueden ser dependientes unas de otras, de este modo podemos restringir y filtrar la cantidad de valores elegibles (ej: Provincias->Municipios). Como ejemplo,en el mantenimiento MaterialSesion (Detalle del registro de sesiones) vamos a crear dos listas nuevas, dependientes entre sí. Utilizaremos el campo Idmatmedic para mostrar en el la descripción del material, añadiendo además una lista que nos permita elegir el material en función de su tipo.

Fichero: actions/principal/appMainwindow.phpCódigo: $conf->setList_DBSource('LISTA_MATERIAL',"select idmatmedic as \"valor\",

descripmatmedic as \"descripcion\" from material order by 2");

Fichero:actions/Sesiones/MaterialSesion.phpCódigo:

$listaMaterial= new gvHidraList('lis_idmatmedic', 'LISTA_MATERIAL');$listaMaterial->addOption('','----');$this->addList($listaMaterial);

Fichero: plantillas/Sesiones/p_RegistroSesion.tplCódigo: {CWLista textoAsociado="Idmatmedic" nombre="lis_idmatmedic" size="0"

editable="true" datos=$defaultData_MaterialSesion.lis_idmatmedic dataType=$dataType_MaterialSesion.lis_idmatmedic}

Fichero: actions/principal/appMainwindow.phpCódigo: $conf->setList_DBSource('LISTA_TIPO_MATERIAL',"select idtipomed as \"valor\",

descriptpmed as \"descripcion\" from tipo_material order by 2");

61

Fichero:actions/Sesiones/MaterialSesion.phpCódigo:

$listaTipoMaterial= new gvHidraList('lis_idtipomed', 'LISTA_TIPO_MATERIAL');$listaTipoMaterial>addOption('','----');$this->addList($listaTipoMaterial);

Fichero: plantillas/Sesiones/p_RegistroSesion.tplCódigo: {CWLista textoAsociado="Tipo" nombre="lis_idtipomed" size="0" editable="true"

datos=$defaultData_MaterialSesion.lis_idtipomed dataType=$dataType_MaterialSesion.lis_idtipomed}

Una vez creadas las listas, vemos que ambas son independientes, hecho que nos permite añadir un material de un tipo como si fuera de otro.Para solucionar este problema, y además permitir una mayor especialización de la información a la hora de escogerla, vamos a convertir las listas de tipo material y material en listas dependientes (Ver listas dependientes en manual gvHIDRA).

Fichero:actions/Sesiones/MaterialSesion.phpCódigo:

$listaMaterial->setDependence(array('lis_idtipomed'), array('reftipomedic'),1);

Fichero:plantillas/Sesiones/p_RegistroSesion.tplCódigo:{CWLista textoAsociado="Tipo" nombre="lis_idtipomed" editable="true"

datos=$defaultData_MaterialSesion.lis_idtipomed dataType=$dataType_MaterialSesion.lis_idtipomed actualizaA="lis_idmatmedic"}

Otro componente avanzado muy útil es la “ventana de selección”. Este componente sirve para añadir el valor de un campo que exista en otra tabla referenciada por su clave ajena. Un ejemplo concreto es la referencia del paciente refpaciente de la sesión. Para rellenar dicha pantalla de alta, si no añadimos una referencia válida de paciente, al hacer el insert, el SGBD nos avisará de la restricción de clave ajena no satisfecha.Vamos por tanto a añadir un componente “ventana de selección” para rellenar el campo refpaciente de la solapa “Ficha” en el registro maestro del “Registro de sesiones”.

Fichero: actions/principal/appMainwindow.php

62

Código: $conf->setSelectionWindow_DBSource('VS_PACIENTES', 'select idpaciente as "Id", apellido1 || \' \' || apellido2 || \' ,\' || nombre as "Nombre" from pacientes',array('id','nombre'));

Fichero:actions/Sesiones/RegistroSesion.phpCódigo:

$pacientes= new gvHidraSelectionWindow('edi_refpaciente', 'VS_PACIENTES'); $pacientes->addMatching('edi_refpaciente', 'Id'); $this->addSelectionWindow($pacientes);

Fichero: plantillas/Sesiones/p_RegistroSesion.tplCódigo: {CWBotonTooltip imagen="13" titulo="Busqueda de Pacientes" funcion="abrirVS"

actuaSobre="edi_refpaciente" claseManejadora="RegistroSesion"}

iii. Acciones de interfazUna acción de interfaz (Ver acciones de interfaz en manual gvHIDRA) consiste en ejecutar código disparado por un evento que se produce en la interfaz. Dicha ejecución de código PHP, puede repercutir en la misma interfaz o en el negocio de la aplicación.Por ejemplo, podríamos obtener directamente de la base de datos el nombre del paciente al abandonar el campo NIF habiéndolo rellenado correctamente.

Para realizar un ejemplo similar, utilizaremos la pantalla “Informe gasto por paciente”. Previamente necesitaremos añadir un campo de texto que contendrá el nombre del paciente que queremos rellenar automáticamente. Una vez añadido, realizaremos la acción de interfaz sobre el campo “fil_nif” de la búsqueda.

Fichero: plantillas/Informes/p_InfGastoPaciente.tplCódigo:{CWCampoTexto nombre="fil_nombre" size="50" editable=”false”}

Fichero:actions/Informes/InfGastoPaciente.phpCódigo:

//Definimos operación fuera del constructorpublic function AccionInterfazNombre ($objDatos){

$nif = $objDatos->getValue('fil_nif'); if($nif!=''){

$res=$this->consultar("select apellido1 || ' ' || apellido2 || ' ,' || nombre as \"nombre\" from pacientes where upper(nif)=upper('$nif')");

$objDatos->setValue('fil_nombre', $res[0]['nombre']);}else{

$objDatos->setValue('fil_nombre','');}return 0;

}

//Relacionamos campo con operación (dentro del constructor)$this->addAccionInterfaz('fil_nif', 'AccionInterfazNombre');

63

Fichero: plantillas/Informes/p_InfGastoPaciente.tplCódigo:{CWCampoTexto nombre="fil_nif" textoAsociado="NIF" size="8"

value=$defaultData_InfGastoPaciente.fil_nif dataType=$dataType_InfGastoPaciente.fil_nif actualizaA="fil_nombre"}

e. Incorporar la lógica de negocioHasta ahora hemos visto como realizar cambios en la interfaz de nuestras pantallas que nos han facilitado la introducción de datos, pero estas porciones de código no dicen realmente nada del funcionamiento interno de nuestra aplicación. Consideramos lógica de negocio a todo lo que nuestra aplicación hace internamente.El framework nos da varios puntos de entrada al hilo de ejecución que transcurre mientras interactuamos con las pantallas. Cabe al menos diferenciar entre dos puntos de entrada, los que llamamos “acciones genéricas” y “acciones particulares”.Las acciones genéricas son propiamente las acciones CRUD. Estas acciones resuelven procesos comunes de un mantenimiento Create Read Update Delete , es decir Altas, Listados, Modificaciones y Borrados.Las acciones particulares son las acciones que resolverán necesidades concretas no resueltas por el framework. Como ejemplo, consultar un webservice, parsear un XML, etc.

i. Acciones genéricasLas acciones genéricas cuentan con métodos virtuales sobrecargables, antes y después de cada operación. Por ejemplo, podremos sobrecargar un método antes de una inserción que nos permita ejecutar código, por ejemplo validaciones de campos y podremos también sobrecargar otro método después de la inserción que nos permita realizar operaciones en otras tablas.El framework cuenta con los siguientes operaciones y métodos virtuales:

preIniciarVentana: Permite ejecutar código antes de entrar una ventana. Típicamente usado para validaciones de usuarios y perfiles.preBuscar: Permite ejecutar código antes de ejecutar la consulta a la base de datos. Típicamente usado para añadir condiciones al filtro dependiente de información no visible.postBuscar: Permite ejecutar código después de haber obtenido los datos de la base de datos. Típicamente usado para añadir datos extra o complementarlos.preEditar: Permite ejecutar código cuando pasamos de un patrón tabular a otro en modo ficha editando el registro. Típicamente usado para mostrar u ocultar campos según perfil.postEditar: Permite ejecutar código cuando guardamos los cambios en el modo ficha y volvemos al tabular. Típicamente usado para redirigir a otras pantallas.preRecargar: Permite ejecutar código en un detalle cuando cambia su maestro, antes de la consulta.postRecargar:Permite ejecutar código en un detalle cuando cambia su maestro, después de la consulta.

64

preModificar: Permite ejecutar código en un panel que esté editándose antes de realizar los cambios.postModificar:Permite ejecutar código en un panel que estaba editándose después de realizar los cambios.

Y como su propio nombre indica:preBorrar y postBorrarpreInsertar y postInsertarpreNuevo y postNuevo

Estos métodos tienen las siguientes características:- Reciben por parámetro un objeto que contiene información de la pantalla o de la base de datos, según sea el método.- Pueden retornar tres valores que implican distintos comportamientos:

0: Todo fue bien, la ejecución continúa. Se corresponde con la acción gvHidraSuccess.-1: Algo fue mal, la ejecución se detiene. Se corresponde con la acción gvHidraError.actionForward: Objeto PHP que corresponde con otro camino a seguir distinto de

correcto o error. (Véase fichero de mappings)

Ejemplo:

public function preBuscar($objDatos){ if ($objDatos->getValue("colegiado")==true) $this->setParametrosBusqueda("ncolegiado is not null"); return 0;}

Para este curso vamos a realizar los siguientes ejemplos:1. Parametrización de la búsqueda; entrar directamente sin pulsar el botón buscar en el

mantenimiento de “tipo de materiales”. Además, luego fijaremos que solo salgan tipos de material según su nivel de identificador. (preBuscar)

2. Añadiremos el cálculo automático de la clave primaria en el mantenimiento de materiales. (preNuevo o preInsertar)

3. Añadiremos auditoría sobre las modificaciones que realiza un usuario en los datos de una sesión, registrando usuario y operación.(preModificar, preBorrar,...)

4. Añadiremos color a las filas del detalle de Materiales de una sesión, según las unidades superen la cantidad de “5”. (postRecargar)

65

1. Parametrizar búsqueda automática y añadir filtro extra por condiciones externas

Fichero: include/menuModulos.xmlCódigo:<opcion titulo="MantTipoMat" descripcion="Mantenimiento de MantTipoMat" url="phrame.php?

action=MantTipoMat__buscar"/>

Fichero: actions/MantenimientoMateriales/MantTipoMat.phpCódigo: /** * metodo preBuscar * * @access public * @param object $objDatos * * Incorpore aqui la logica para parametrizar la busqueda. Por ejemplo: * - Incluir condiciones de filtrado. * - Cancelar la accion de buscar. */ public function preBuscar($objDatos) { //Sacar solo materiales de identificador mayor que 30 $nivel = 30; //Mostramos mensaje en debugger sobre lo que estamos haciendo IgepDebug::setDebug(DEBUG_USER,"Añadiendo a la WHERE nivel= ".$nivel." </pre>"); //Añadimos condicion a la where $this->setParametrosBusqueda("idtipomed >= $nivel"); return 0; }

2. Añadir cálculo automático de clave primaria en el mantenimiento de materiales.Nota: Elegimos programarlo en preInsertar porque de este modo minimizamos el riesgo de concurrencia al obtener la clave primaria.

Fichero: actions/MantenimientoMateriales/MantMat.phpCódigo:/** * metodo preInsertar * * @access public * @param object $objDatos * * Incorpore aqui la logica para parametrizar los datos a insertar. Por ejemplo: * - Calcular el valor de una secuencia. * - Cancelar la acción de insercion. */ public function preInsertar($objDatos) { IgepDebug::setDebug(DEBUG_USER,"INI preInsertar <pre>".print_r($objDatos->getAllTuplas(),true)." </pre>"); $id=$this->calcularSecuencia('material', 'idmatmedic', array()); $datos= $objDatos->getAllTuplas();

66

foreach ($datos as &$dato){ $dato['lis_idmatmedic']=$id; $id++; } $objDatos->setAllTuplas($datos); IgepDebug::setDebug(DEBUG_USER,"FIN preInsertar <pre>".print_r($objDatos->getAllTuplas(),true)." </pre>"); return 0; }

Fichero: plantillas/MantenimientoMaterialess/p_MantMat.tplCódigo:{CWCampoTexto textoAsociado="Idmatmedic" nombre="lis_idmatmedic" size="10" oculto="true"

editable="true" value=$defaultData_MantMat.lis_idmatmedic dataType=$dataType_MantMat.lis_idmatmedic}

3. Añadir auditoría sobre las modificaciones

/** * metodo postModificar * * @access public * @param object $objDatos * * Incorpore aqui la logica para completar la operacion de actulizacion. Por ejemplo: * - Actualizar en una segunda tabla */ public function postModificar($objDatos) { //Recuperamos información del usuario conectado

$usuario= IgepSession::dameUsuario(); $operacion='Modificar'; IgepDebug::setDebug(DEBUG_USER, "Se ha realizado la operación: $operacion por: <pre>".print_r($usuario,true)."</pre>"); return 0; }

67

4. Añadir color a las filas

Fichero:action/Sesiones/MaterialSesion.phpCódigo:

/** * metodo postRecargar * * @access public * @param object $objDatos * * Incorpore aqui la logica para parametrizar los datos obtenidos. Por ejemplo: * - Completar la informacion obtenida. * - Cambiar el color de las filas dependiendo de su valor */ public function postRecargar($objDatos) { //Obtenemos la matriz de datos $m_datos = $objDatos->getAllTuplas(); IgepDebug::setDebug(DEBUG_USER, print_r($m_datos,true)); foreach($m_datos as $indice =>$tupla) { if ($tupla['lis_cantidad']>0) $objDatos->setRowColor($m_datos[$indice],'aviso'); if ($tupla['lis_cantidad']>5)

$objDatos->setRowColor($m_datos[$indice],'sugerencia'); if ($tupla['lis_cantidad']>10)

$objDatos->setRowColor($m_datos[$indice],'error'); } //Guardamos la matriz de datos modificada $objDatos->setAllTuplas($m_datos); return 0; }

68

ii. Acciones particularesUna acción particular es un método programado en la clase que maneja el panel, la cual es invocada desde un botón añadido expresamente para dicha operación. La acción particular debe retornar obligatoriamente un objeto del tipo ActionForward para que el framework sepa donde acabar el hilo de ejecución.

Las acciones particulares tienen un punto de entrada común, el método virtual sobrecargable accionesParticulares.

/** * metodo accionesParticulares * * @access public * @param string $str_accion * @param object $objDatos * * Incorpore aqui la logica de sus acciones particulares. * -En el parametro $str_accion aparece el id de la accion. * -En el parametro $objDatos esta la informacion de la peticion. Recuerde que debe fijar la operacion * con el metodo setOperacion. */ public function accionesParticulares($str_accion, $objDatos) { throw new Exception('Se ha intentado ejecutar la acción '.$str_accion.' y no está programada.'); }

Este método recibe dos parámetros, en primer lugar la acción asociada al botón que le invoca ($str_accion) y en segundo lo datos que vienen desde la pantalla ($objDatos).

Normalmente el anterior método se programa para que sirva de lanzador de los métodos privados programados en la clase, como hemos dicho en las primeras líneas.

/** * metodo accionesParticulares * * @access public * @param string $str_accion * @param object $objDatos * * Incorpore aqui la logica de sus acciones particulares. * -En el parametro $str_accion aparece el id de la accion. * -En el parametro $objDatos esta la informacion de la peticion. Recuerde que debe fijar la operacion * con el metodo setOperacion. */ public function accionesParticulares($str_accion, $objDatos) { switch ($str_accion) { case 'accion1': //Acción del botón 1

69

$actionForward=$this->accion1($objDatos); break; case 'accion2': //Acción del botón 2 $actionForward=$this->accion2($objDatos); break; default: throw new Exception('Se ha intentado ejecutar la acción '.$str_accion.' y no está programada en la clase: '.__CLASS__); } return $actionForward; }

Donde los métodos que ejecutan el negocio serían así:

private function accion1($objDatos) {

/** Operaciones **/ if($correcto == true) $actionForward=$objDatos->getForward('Success'); else $actionForward=$objDatos->getForward('Error'); return $actionForward; }

private function accion2($objDatos) {

/** Operaciones **/ if($correcto == true) $actionForward=$objDatos->getForward('Success'); else $actionForward=$objDatos->getForward('Error'); return $actionForward; }

Por último, faltaría un botón que invoque el método y unos “mappings” que informen al controlador que hacer en cada retorno. El botón se puede ubicar arriba o abajo de la ventana, según el comportamiento que deseemos.

Botones:

- Botón grande en la barra inferior (CWBarraInfPanel){CWBoton imagen="31" texto="Accion1" class="boton" accion="particular" action="accion1" }

{CWBoton imagen="31" texto="Accion2" class="boton" accion="particular" action="accion2" }

- Botón pequeño en la barra superior (CWBarraSupPanel){CWBotonTooltip imagen="31" titulo="Accion1" funcion="particular" action="accion1" actuaSobre="tabla"}{CWBotonTooltip imagen="31" titulo="Accion2" funcion="particular" action="accion2" actuaSobre="tabla"}

70

Mappings$this->_AddMapping('ClaseManejadora__accion1', 'ClaseManejadora');$this->_AddForward('ClaseManejadora__accion1', 'Success', 'index.php?view=views/modulo/p_clasemanejadora.php&panel=buscar');$this->_AddForward('ClaseManejadora__accion1', 'Error', 'index.php?view=views/modulo/p_clasemanejadora.php&panel=buscar');

$this->_AddMapping('ClaseManejadora__accion2', 'ClaseManejadora');$this->_AddForward('ClaseManejadora__accion2', 'Success', 'index.php?view=views/modulo/p_clasemanejadora.php&panel=buscar');$this->_AddForward('ClaseManejadora__accion2', 'Error', 'index.php?view=views/modulo/p_clasemanejadora.php&panel=buscar');

Por lo que en definitiva, para programar una acción particular necesitamos:– Añadir un botón del tipo que deseemos en la plantilla: fichero .tpl– Añadir una función privada dentro de la clase manejadora (clase que hereda de

gvHidraForm)del panel donde deseemos realizar la acción.– Sobrecargar el método virtual “accionesParticulares” de manera que según el parámetro

“action” del botón, se ejecute la función deseada y además se retorne un “acctionForward válido”

– Definir en el controlador (fichero include/mappings.php) la operación y los “actionForward” que estemos retornando en la programación.

Para entender mejor el funcionamiento, vamos a crear la siguiente lógica de negocio mediante acciones particulares:

1. Borrado de un tipo material aunque tengan restricción de clave ajena con tabla material.2. Duplicar una paciente asignando un nuevo identificador.

1. Borrado de un tipo de material con restricción de integridad

Fichero: MantenimientoMateriales/MantTipoMat.phpCódigo:/** * metodo accionesParticulares * * @access public * @param string $str_accion * @param object $objDatos * * Incorpore aqui la logica de sus acciones particulares. * -En el parametro $str_accion aparece el id de la accion. * -En el parametro $objDatos esta la informacion de la peticion. Recuerde que debe fijar la operacion * con el metodo setOperacion. */ public function accionesParticulares($str_accion, $objDatos) {

switch ($str_accion)

71

{ case 'aniquilar': //Acción del botón aniquilar $actionForward=$this->aniquilarTipoMat($objDatos); break;

default: throw new Exception('Se ha intentado ejecutar la acción '.$str_accion.' y no está programada en la clase: '.__CLASS__); } return $actionForward; }

//Método privada que hace la operación concretaprivate function aniquilarTipoMat($objDatos){

//Recogemos valor idtipomed del panel lis $idtipomed=$objDatos->getValue('lis_idtipomed','seleccionar');

//Recupero la conexión del panel e inicio transacción $conexion=$this->getConnection(); $conexion->empezarTransaccion(); //Realizo los deletes previos.

$res=$conexion->operar("DELETE FROM material_sesion WHERE EXISTS (select reftipomedic from material where material.idmatmedic=material_sesion.idmatmedic and

material.reftipomedic=$idtipomed)");if($res>=0)$res=$conexion->operar("DELETE FROM material WHERE reftipomedic=$idtipomed");//Borramos al tipo_material ahora sin restricciones de clave ajena

if($res>=0)$res=$conexion->operar("DELETE FROM tipo_material WHERE idtipomed=$idtipomed");//Si todo ha ido bien acabo transacción y devuelvo el forward (del mappings.php) correcto

if($res>=0){ $conexion->acabarTransaccion(false); $actionForward=$objDatos->getForward('Success'); } else{

//Ante posible fallo, hago un ROLLBACK y devuelvo el forward que he preparado para error $conexion->acabarTransaccion(true); $actionForward=$objDatos->getForward('Error'); } $this->refreshDetail(); return $actionForward;

}

Fichero: plantillas/MantenimientoMateriales/p_MantTipoMat.tplCódigo:<!--Añado un botón pequeño en la barra superior-->{CWBotonTooltip imagen="31" titulo="Aniquilar tipo" funcion="particular" action="aniquilar" actuaSobre="tabla"}

Fichero: include/mappings.phpCódigo://Añado los caminos que quiero tomar según acabe bien o mal $this->_AddMapping('MantTipoMat__aniquilar', 'MantTipoMat');

72

$this->_AddForward('MantTipoMat__aniquilar', 'Success', 'index.php?view=views/Mantenimiento Materiales/p_MantTipoMat.php&panel=buscar');

$this->_AddForward('MantTipoMat__aniquilar', 'Error', 'index.php?view=views/Mantenimiento Materiales/p_MantTipoMat.php&panel=listar');

2. Duplicar pacienteAñadimos la operación al case de acciones particulares, programamos la nueva operación, añadimos el nuevo botón y añadimos las lineas de mappings de la nueva operación.

Fichero: MantenimientoPacientes/MantPacientes.phpCódigo:/** * metodo accionesParticulares * * @access public * @param string $str_accion * @param object $objDatos * * Incorpore aqui la logica de sus acciones particulares. * -En el parametro $str_accion aparece el id de la accion. * -En el parametro $objDatos esta la informacion de la peticion. Recuerde que debe fijar la operacion * con el metodo setOperacion. */ public function accionesParticulares($str_accion, $objDatos) {

switch ($str_accion) { case 'aniquilar': //Acción del botón aniquilar $actionForward=$this->aniquilarTipoMat($objDatos); case 'duplicar': //Acción del botón aniquilar $actionForward=$this->duplicarPaciente($objDatos); break; break;

default: throw new Exception('Se ha intentado ejecutar la acción '.$str_accion.' y no está programada en la clase: '.__CLASS__); } return $actionForward; }

Fichero:MantenimientoPacientes/MantPacientes.phpCódigo: private function duplicarPaciente($objDatos){ $datos=$objDatos->getAllTuplas('seleccionar'); $paciente=$datos[0]; $idpaciente=$this->calcularSecuencia('pacientes', 'idpaciente', array()); $conexion=$this->getConnection(); $conexion->empezarTransaccion(); $res=$conexion->operar("INSERT INTO pacientes (idpaciente, sip, nif, nombre, apellido1, apellido2, sexo, domicilio, poblacion, cpostal) VALUES ($idpaciente,

73

{$paciente['lis_sip']},'{$paciente['lis_nif']}','{$paciente['lis_nombre']}','{$paciente['lis_apellido1']}','{$paciente['lis_apellido2']}','{$paciente['lis_sexo']}','{$paciente['lis_domicilio']}','{$paciente['lis_poblacion']}','{$paciente['lis_cpostal']}' )"); if($res>=0){ $conexion->acabarTransaccion(false); $actionForward=$objDatos->getForward('Success'); } else{ $conexion->acabarTransaccion(true); $actionForward=$objDatos->getForward('Error'); } $this->refreshDetail(); return $actionForward; }

Fichero: plantillas/MantenimientoPacientes/p_MantPacientes.tplCódigo:

{CWBotonTooltip imagen="51" titulo="Duplicar paciente" funcion="particular" action="duplicar" actuaSobre="tabla"}

Fichero: include/mappings.phpCódigo:$this->_AddMapping('MantPacientes__duplicar', 'MantPacientes');$this->_AddForward('MantPacientes__duplicar', 'Success', 'index.php?view=views/Mantenimiento Pacientes/p_MantPacientes.php&panel=buscar');$this->_AddForward('MantPacientes__duplicar', 'Error', 'index.php?view=views/Mantenimiento Pacientes/p_MantPacientes.php&panel=buscar');

74

f. Incorporar control de accesoPara poder incorporar autenticación y autorización en nuestra aplicación gvHIDRA, necesitamos implementar un método de validación y estructurar los datos de la sesión del usuario conectado. Para conocer como, debemos referirnos al punto 5 de este manual.

Para seguir con el ejemplo, copiaremos estos tres ficheros ya preparados: login_DB.php, AuthDB.php y validacionDB.php a nuestra aplicación.

Fichero: Dialisis/login_DB.phpCódigo:<?php/** * Hace uso de la validacion basica * * @package gvHIDRA */

include_once('igep/include_class.php');include_once 'igep/include/valida/AuthDB.php';

$msg = AuthDB::autenticate(ConfigFramework::getApplicationName());if ($msg) {

echo $msg;}

?>

Fichero: dialisis/igep/include/valida/AuthDB.phpCódigo:

<?php/** * Validacion de usuarios: configuracion personalizable por el usuario * Hace uso del PEAR::Auth * * @package gvHIDRA */

include_once 'gvhBaseAuth.php';

//Heredamos de gvhBaseAuthclass AuthDB extends gvhBaseAuth{

//Definimos una variable estática con los datos de conexiónstatic $options = array(

'dsn'=>'pgsql://dialisis_ae:dialisis_ae@localhost/dialisis','table'=>'usuarios','usernamecol'=>'usuario','passwordcol'=>'pwd',//'cryptType'=>'md5', // por defecto

);

/** * Inicializa variables en la sesión que recibe.

75

* Se ejecuta la primera vez que accede a la aplicación */

function postLogin($sess, $auth=null){

$sess['usuario']['nombre']='Usuario validado en BD';//Aquí se podría añadir una consulta y obtener roles de otra tablaif ($sess['usuario']['usuario']=='db1')

$sess['rolusuar'] = 'ADMINISTRADOR';else

$sess['rolusuar'] = '';//Aquí se podría añadir una consulta y obtener módulos de otra tabla$sess['modulos'] = array('MODULO1'=>array('valor'=>'MOD1','descrip'=>'Descripción

MOD1'));//Título dinámico de la aplicación$sess['daplicacion'] = 'Aplicación de dialisis con gvHIDRA';

return $sess; }

/** * Metodo para llamar desde aplicaciones, en la autenticacion inicial * * Devuelve cadena vacia si todo va bien, o texto si error */static function autenticate($p_apli){

$auth_container = new self($p_apli);

IgepSession::session_start($p_apli, false);$aut = new Auth('MDB2',self::$options);

$aut->setSessionName($p_apli);if (isset($_GET['logout']))

$aut->logout();$aut->start();//Aquí comprueba contra la base de datos usuario/passwordif ($aut->checkAuth()) {

//Si todo ha ido bien, cargamos el perfil$auth_container->open('igep/include/valida/validacionDB.php');

}

return '';}

}

?>

Fichero: dialisis/igep/include/valida/validacionDB.phpCódigo:<?php/** * Validacion de usuarios: comprueba en cada acceso si el usuario puede entrar * En caso de no validado, muestra enlace a un php de igep para validarse. * * Es una clase estática. * * @package gvHIDRA */

76

require_once 'AuthDB.php';

class validacion {

/** * Validación normal, con todas las comprobaciones * Se invoca al inicio de la aplicacion y carga la informacion del usuario en la sesion * * @access public */

static function valida($apli, $sesion=TRUE) {

$auth_container = new AuthDB();$aut = new Auth('MDB2',AuthDB::$options,'',false);$aut->setSessionName($apli);$aut->start();if (!$aut->checkAuth())

exit('No estás validado; Vuelve a la pantalla de conexión.');

if (!isset($_SESSION[$apli]['usuario'])){if (!isset($_SESSION[$apli]))

$_SESSION[$apli] = array();//Añadimos el perfil del usuario$_SESSION[$apli]['usuario']['usuario'] = $aut->getUsername();$_SESSION[$apli] = $auth_container->postLogin($_SESSION[$apli],$aut);$_SESSION['validacion'] = array(

'bd'=>'LOCALHOST','server'=>'host-login',);

$auth_container->checkData($_SESSION, $apli);}

}

}

?>

Una vez implementado un método de autenticación y añadida una autorización, para realizar el control de acceso a partes de nuestra aplicación haremos lo siguiente.

Control de acceso en opciones de menú

Añadimos en el menú de la aplicación, las etiquetas control de acceso respecto al valor del rol esperado.

Fichero:include/MenuModulos.xmlCódigo:

<controlAcceso><rolPermitido valor="ADMINISTRADOR"/>

</controlAcceso>

Mediante esta configuración, controlamos que roles pueden acceder a que opciones de menú.

77

Por ejemplo:<modulo titulo="MantenimientoMateriales" imagen="menu/43.gif" descripcion="MantenimientoMateriales"> <controlAcceso> <rolPermitido valor="ADMINISTRADOR"/> </controlAcceso> <opcion titulo="MantTipoMaterial" descripcion="Mantenimiento de MantTipoMaterial" url="phrame.php?action=MantTipoMaterial__iniciarVentana"/> <opcion titulo="MantMaterial" descripcion="Mantenimiento de MantMaterial" url="phrame.php?action=MantMaterial__iniciarVentana"/> </modulo>

Otra forma de controlar la autorización de un usuario se puede realizar en el acceso a un panel. Este otro método nos sirve para cuando necesitamos que un panel se comporte de un modo u otro según que rol se conecte.

Fichero:actions/MantenimientoPersonal/MantPersonal.phpCódigo:

/*** metodo postBuscar* * @access public* @param object $objDatos* * Incorpore aqui la logica para parametrizar los datos obtenidos. Por ejemplo:* - Completar la informacion obtenida.* - Cambiar el color de las filas dependiendo de su valor*/public function postBuscar($objDatos) {

$rolUsuarioConectado= IgepSession::dameRol();

if ($rolUsuarioConectado!='ADMINISTRADOR')$this->showMensaje('APL-1');

return 0;}

Mediante esta configuración mostramos un mensaje tras una búsqueda cuando no se es administrador.

g. Programación de informes

Para la realización de informes utilizaremos la herramienta iReport. Es una herramienta que diseña informes para ser ejecutados por el motor de informes JasperReports. Por ello, para poder ejecutar los informes desde el framework gvHIDRA, necesitamos incluir un módulo/proyecto llamado “Jasper” que descargaremos de la web del proyecto www.gvhidra.es

i. Preparación del entornoEn este punto entendemos que ya se tiene configurado un entorno de desarrollo de informes con iReport, por lo que nos quedará configurar el servidor web para que pueda ejecutar procesos Java, nuestra aplicación gvHIDRA y por último el navegador web si realizamos los informes en PDF y este no dispone de visor.

78

ii. Configuración servidorLa configuración del servidor para que ejecute procesos java, como lo es el proceso que realiza en informe en JasperReport, es bastante sencilla y se resume en dos pasos.

1. Tener una máquina virtual java instalada2. Que sea accesible por el usuario que ejecuta el servidor web.

Windows

Para el primer paso tenemos que mirar en el panel de control de windows si ya tenemos una máquina virtual de java instalada.

79

Si ya la tenemos, hacemos doble click y elegimos la solapa “java” y hacemos click en “ver” con la intención de ver donde está instalada.

La ruta donde esté instalada la máquina virtual nos servirá para informar nuestra variable JAVA_HOME. Para este ejemplo la variable JAVA_HOME apuntaría a C:\Archivos de programa\Java\jre7

Para definir una variable de entorno y que sea visible por el servidor web, seguimos los siguientes pasos:

80

1. Hacemos “click” sobre el icono de WampServer en nuestro SystemTray.2. Seleccionamos Apache/httpd.conf y editamos el fichero.

3. Añadimos al final del fichero la siguiente linea:SetEnv JAVA_HOME "C:\Archivos de programa\Java\jre7"

4. Guardamos los cambios y reiniciamos el servicio.

81

5. Finalmente solo nos queda comprobar que la configuración del servidor es correcta. Esto lo haremos ejecutando el método phpInfo(); el cual ya viene preparado en la instalación de WampServer y viendo si aparece la variable en la sección “Apache Environment”.

82

GNU/Linux# apt-get install sun-java6-bin# update-java-alternatives -l# echo "SetEnv JAVA_HOME /usr/lib/jvm/java-6-sun" > /etc/apache2/conf.d/jasper.conf# service apache2 restart

ii. Configuración aplicación gvHidraComo hemos dicho antes, para poder ejecutar los informes generados con iReport dentro del framework gvHidra, tenemos que incluir el proyecto “Jasper” dentro de nuestra aplicación.

Estos pasos también son muy sencillos:1. Descargar el proyecto de la web www . gvhidra . org 2. Descomprimir dentro del directorio include de nuestra aplicación (C:\wamp\www\dialisis\include)3. Registrar en el fichero include/include.php las clases php necesarias para su invocación.

$al->registerClass('InformeJasper','include/jasper/modulosPHP/informeJasper.php');

83

iii. Configuración del navegadorPor último, si vamos a generar ficheros en formato PDF, tendremos que asegurarnos que el navegador web que vamos a utilizar tiene el plugin/visor correspondiente instalado.

Esto lo podremos saber escribiendo en el campo dirección del navegador la siguiente URI:about:plugins

Llegados este punto, comprobaremos que todo funciona correctamente accediendo a la siguiente URL.

http :// localhost / dialisis / include / jasper / testJasper . php

iv. Integración de un informeExisten multitud de formas de lanzar un informe desde una pantalla programada en gvHIDRA. Aquí explicaremos la que consideramos como mejor práctica.

Anteriormente, hemos programado un patrón FIL-LIS a mano para usarlo ahora como lanzador de informes. Dado que dicho patrón muestra un resultado por filas, añadiremos un “boton tooltip” en la parte superior, que lanzará el informe para la tupla seleccionada. El código para lanzar el informe lo escribiremos en una acción particular y utilizaremos un fichero en views/ para cargar el informe en una ventana.

84

Esta programación, lanza un informe ya compilado previamente que se guarda por convenio en un directorio de la aplicación llamado “dialisis/plantillasJasper/”. El fichero compilado es “informePaciente.jasper” y el fichero sin compilar que se utiliza desde iReport es “informePaciente.jrxml”.

Resumiendo los pasos son:1. Añadir botón en la plantilla2. Programar la acción particular que construirá el informe.3. Configurar el controlador y añadir fichero de apoyo

1. Añadir botón a la plantillaFichero:plantillas/Informes/p_InfGastoPaciente.tplCódigo:

{CWBotonTooltip imagen="pdf" titulo="Informe Gasto Paciente" funcion="particular" action="lanzarInforme" actuaSobre="tabla"}

2. Programar acción particular

Fichero:dialisis/actions/Informes/InfGastoPaciente.phpCódigo:

/** * metodo accionesParticulares * * @access public * @param string $str_accion * @param object $objDatos * * Incorpore aqui la logica de sus acciones particulares. * -En el parametro $str_accion aparece el id de la accion. * -En el parametro $objDatos esta la informacion de la peticion. Recuerde que debe fijar la operacion * con el metodo setOperacion. */ public function accionesParticulares($str_accion, $objDatos) { switch ($str_accion) { case 'lanzarInforme': //Acción del botón aniquilar $actionForward=$this->informePaciente($objDatos); break; default: throw new Exception('Se ha intentado ejecutar la acción '.$str_accion.' y no está programada en la clase: '.__CLASS__); } return $actionForward; } private function informePaciente($objDatos){ $nif=$objDatos->getValue('lis_nif','seleccionar');

85

if($nif=='') return $objDatos->getForward('Error'); //Creamos el objeto que manejará el informe $informeJasper = new InformeJasper('InformePaciente'); $informeJasper->setDataSourceType('sgbd'); $g_dsn = ConfigFramework::getConfig()->getDSN('g_dsn'); $informeJasper->importPearDSN($g_dsn); //Fijamos la disposición del informe incrustado en la ventana $informeJasper->setDisposition('inline'); //Fijamos el fichero jasper que nos hace de plantilla $informeJasper->setJasperFile('./plantillasJasper/informePaciente.jasper'); //Añado parámetro para el filtro del informe ya que el informe espera el parámetro $informeJasper->addParam("nif", $nif, 'String'); //Asignamos el informe como variable de clase para poder //acceder a él desde el fichero views donde realizaremos "la ejecución" IgepSession::guardaVariable('InfGastoPaciente','informe',$informeJasper); //Hacemos un fork de la ejecución en una nueva ventana, recuperando el forward del mapping $actionForwardHijo=$objDatos->getForward('Print'); $this->openWindow($actionForwardHijo); //Continua ejecución padre $actionForwardPadre = $objDatos->getForward('Success'); return $actionForwardPadre; }

3. Añadir mappings y fichero lanzadorFichero: include/mappings.phpCódigo:

$this->_AddMapping('InfGastoPaciente__lanzarInforme', 'InfGastoPaciente'); $this->_AddForward('InfGastoPaciente__lanzarInforme', 'Success', 'index.php?view=views/Informes/p_InfGastoPaciente.php&panel=listar'); $this->_AddForward('InfGastoPaciente__lanzarInforme', 'Error', 'index.php?view=views/Informes/p_InfGastoPaciente.php&panel=listar'); $this->_AddForward('InfGastoPaciente__lanzarInforme', 'Print', 'index.php?view=views/Informes/p_InfGastoPacienteInforme.php');

Fichero:dialisis/views/Informes/p_InfGastoPacienteInforme.php (Creamos el fichero)Código:<?php

if (IgepSession::existeVariable('InfGastoPaciente',"informe")){ $informeJasper = IgepSession::dameVariable('InfGastoPaciente',"informe"); IgepSession::borraVariable('InfGastoPaciente',"informe"); //INI Debug // $informeJasper->setDebugMode(true); //FIN Debug $informeJasper->createResultFile('pdf'); }else $s->display('../igep/plantillas/l_errorList.tpl');?>

86

Nota: Si no tenemos un informe para lanzar, utilizaremos el wizard de iReport para generar uno rápidamente (ver anexos).

5. Integración

a. AutenticaciónCuando creamos una aplicación gvHIDRA, a partir de la plantilla, ésta viene con un control de acceso muy básico que permite conectarse con el usuario invitado. En este apartado vamos a ver como personalizar el control de acceso para adaptarlo a nuestra organización.

El control de acceso gestiona qué usuarios pueden acceder a qué recursos. Básicamente trata los dos siguientes aspectos:

● Autenticación: Procedimiento de comprobación de la identidad de un usuario● Autorización: Definición granular de permisos de acceso concedidos a un determinado

usuario, dispositivo o sistema

La autenticación se basa en algo que el usuario sabe (p.e. contraseña), tiene (tarjeta de identidad, tarjeta inteligente, …) o características físicas (huella, retina, voz, … ). El más frecuente por su sencillez y bajo coste es mediante contraseña, aunque desde hace unos años empiezan a proliferar los basados en tarjetas inteligentes (certificados ACCV, DNIe, FNMT, …).

En gvHIDRA, durante el proceso de conectarnos a la aplicación, podemos distinguir dos fases:1. Comprobar credenciales2. Carga de la información del usuario/aplicación

Las dos fases ocurren secuencialmente, y se comunican mediante una clase que definimos (hereda de gvhBaseAuth) y que implementa la lógica usando PEAR::Auth. Es usada desde:

1. login*.php → punto de entrada (autenticación)2. validacion::valida → inicializa parámetros (autorización)

Excepto el fichero de login que ha de situarse en la raíz de la aplicación, los otros dos pueden estar en cualquier sitio de la aplicación.

Con la creación de los tres ficheros mencionados ya tendríamos un nuevo mecanismo de autenticación.

Cuando accedemos a una aplicación gvHIDRA, se busca al primero de los ficheros con nombre login*.php. Si hubiera más de uno, podemos indicar en la URL al fichero del método de autenticación que queremos usar.

87

A continuación veremos los tipos más comunes, para ilustrar lo que se puede hacer y así poder adaptarlo a nuestra organización.

i. Sin autenticaciónCon esta solución podemos acceder a la aplicación sin introducir usuario. Éste se pone de forma fija por código. Para ello hay que indicar el usuario en el método autenticate (antes del start)

$aut->setAuth('invitado');

ii. Mediante usuario / contraseñaAuth incluye muchos gestores de donde obtener los usuarios (BD, Array, LDAP, Radius, SOAP, IMAP, …) y permite definir nuevos.

Para crear nuevos gestores se recomienda seguir los pasos en AuthGva en la doc ( http://www.gvpontis.gva.es/fileadmin/conselleria/images/Documentacion/migracionSwAbierto/HIDRA/Documentacion/doc-gvHIDRA-3_0_4/auth_gva.html ).

Podemos personalizar el formulario de login, para adaptarlo a nuestra guía de estilo.

La solución más simple sería tener los usuarios directamente en una matriz:

static $options = array( 'cryptType'=>'md5', 'users'=>array( 'usu1'=>'529113007b15005637b3dad6d9ba2f10', //md5(usu1) 'usu2'=>'9c60c45d8440e2ece3442fed8fe4c5c2', //md5(usu2)));$aut = new Auth('Array',self::$options);$aut->start();

Una vez validado el usuario, hay que inicializar su información en esa aplicación (para aplicar la autorización). Se hace en método validacion::valida. La información ha de seguir cierta estructura en la sesión, y se debe validar con:

$auth_container->checkData($_SESSION, $apli);

Para obtener la información del usuario en la aplicación lo más frecuente es conectarnos a un sistema externo (BD, ldap, …) y recuperarla. También podemos tenerla de forma estática en la aplicación (xml, php, ini...) aunque no es recomendable a menos que haya pocos usuarios (una decena máximo).

88

iii. Mediante más de una fuenteTambién podemos usar más de una fuente de datos para los usuarios. Veamos un ejemplo de contenedor que incluye:

1. Base de datos (MDB2 oci8)2. Array

Este podría ser el caso en que tenemos la mayoría de usuarios en una base de datos ya existente en la organización, y para unos pocos usuarios especiales que no queremos incluir en esa base de datos, usamos el otro contenedor con los usuario de forma estática.

En estos casos el orden de los contenedores es importante, ya que Auth va probando con cada uno hasta que consigue validar al usuario.

La definición seria:

static $options = array( array(

'type'=>'MDB2','options'=>array(

'dsn'=>'oci8://system:curso@localhost:1521/?service=xe', 'table'=>'usuarios', 'usernamecol'=>'usuario', 'passwordcol'=>'pwd', //'cryptType'=>'md5', // por defecto )), array(

'type'=>'Array','options'=>array(

'cryptType'=>'md5', 'users'=>array( 'usu1'=>'529113007b15005637b3dad6d9ba2f10', //md5(usu1) 'usu2'=>'9c60c45d8440e2ece3442fed8fe4c5c2', //md5(usu2)))));$aut = new Auth('Multiple',self::$options);

Por la definición que hemos hecho, debe existir la tabla usuarios, con columnas usuario y pwd al menos.

89

iv. Autenticación externaEn este caso la autenticación se realiza en un sistema externo, y éste comunica a la aplicación gvHIDRA que las credenciales del usuario son válidas.

Lo normal es pasar el usuario como parámetro, aunque también podemos pasar otra información que nos interese.

Esta solución seria la idónea para plataformas single sign on (SSO), donde el usuario se identifica en el servicio SSO, y ya puede acceder a todas las aplicaciones.

Para implementar la solución más simple, que el servicio SSO nos pasa como parámetro el usuario autenticado, sólo tenemos que incluir las siguientes líneas en el método autenticate (antes del start):

if (isset($_POST['user']))$aut->setAuth($_POST['user']);

Sin embargo esta solución sólo es válida a efectos didácticos, pues es una solución poco segura ya que es fácil para un usuario hacerse pasar por otro. Para evitar el problema hay que utilizar infraestructura de clave pública (PKI) para:

● La información enviada a la aplicación vaya encriptada con la clave pública de la aplicación, para que sólo ésta pueda acceder a la información

● La información enviada vaya firmada por el servicio SSO (con su clave privada) para que la aplicación pueda verificar la autenticidad del origen del mensaje

Se puede encontrar más información y una implementación en el seminario de control de acceso en http :// gvhidra . org .

v. OtrosOtras soluciones que también se han integrado con gvHidra es el uso de las cuentas de correo de la GVA para autenticarse (usa Auth::IMAP).

También es posible autenticarnos con certificados digitales ACCV (próximamente con DNIe), y en otra aplicación se ha integrado un CAPTCHA ( Completely Automated Public Turing test to tell Computers and Humans Apart /Prueba de Turing pública y automática para diferenciar máquinas y humanos ).

90

b. Autorización: módulos y rolesLos módulos y roles se usan para controlar los permisos sobre recursos o funcionalidades

● Módulos: representan a los recursos, y pueden asignarse muchos por usuario. Cada módulo tiene un código, una descripción y opcionalmente puede tener un valor

● Roles: representan los perfiles de usuarios y pueden incluir muchos módulos. Cada usuario sólo tiene un role en una aplicación

Se inicializan la primera vez que se accede a la aplicación, en método postLogin, y han de seguir la siguiente estructura:

$_SESSION[<apl>]['modulos']$_SESSION[<apl>]['modulos'][<modulo x>]['valor']$_SESSION[<apl>]['modulos'][<modulo x>]['descrip']...$_SESSION[<apl>]['rolusuar']

Podemos usar los siguientes métodos para obtener información de módulos:IgepSession::hayModulo( string ) return booleanIgepSession::dameModulo( string ) return arrayIgepSession::dameModulos() return array de arrays

Si queremos controlar el acceso a los menús por módulos podemos usar los siguientes elementos:

<controlAcceso> <moduloPermitido id="Tramitar"/></controlAcceso><controlAcceso>

<moduloPermitido id="Provincia"> <valorModulo valor="Valencia" /> <valorModulo valor="Alicante" />

</moduloPermitido></controlAcceso>

En el caso de los roles, podemos usar el siguiente método para obtener el role del usuario:

IgepSession::dameRol() return string

Para controlar el acceso a los menús usando roles, podemos usar:

<controlAcceso><rolPermitido valor="consultor"/>

91

<rolPermitido valor="gestor"/></controlAcceso>

c. Información de estadoEl protocolo HTTP es por naturaleza un protocolo sin estado, y no existe el concepto de sesión. Para solventar esta carencia y proporcionar una navegación como si tuviéramos sesiones, se utilizan las cookies. Estas consisten básicamente en una información (nombre, valor) que se almacena en el navegador, y que cada vez que se hace una petición al servidor se envían a éste. A partir de estas, el servidor obtiene la información que necesita del cliente.

En PHP se utiliza una cookie especial (por defecto con nombre PHPSESSID) cuyo valor utiliza para cargar la información de estado del usuario. En gvHidra esta cookie se nombra como gvHIDRA_c893ba… El valor de ésta lo usa el servidor para localizar el fichero con el estado de usuario (ver c:\wamp\tmp\sess_*), y la carga en la variable global $_SESSION. En gvHidra se encapsula el acceso a esta variable con la clase IgepSession (en carpeta igep/include)

Si tenemos necesidad de almacenar alguna información en un formulario para recuperarla en otro, también podemos hacer uso de la sesión para almacenar cualquier información usando los métodos:

IgepSession::guardaVariableGlobal($nombreVar, $valor)IgepSession::dameVariableGlobal($nomVariable)

92

5. Conclusiones

Consideramos que el framework de desarrollo gvHIDRA es una herramienta ágil y creciente que permite desarrollar software de calidad con una curva de aprendizaje baja.En este curso se ha pretendido enseñar de manera teórica y práctica los conceptos básicos a conocer por analistas y desarrolladores para abordar con éxito el desarrollo de nuevas aplicaciones. Para mayor profundización existen manuales, guías y otros tutoriales sobre la herramienta en la web del proyecto http :// www . gvhidra . es

En esta parte, nos gustaría conocer las opiniones de los participantes, sugerencias y quejas que puedan servirnos para mejorar.

93

Anexo 1: Wizard iReportPara utilizar la herramienta iReport con una conexión a la instalación local de Oracle en Windows, debemos cargar previamente la librería JDBC proporcionada por la instalación de Oracle para permitir la conexión.

Ir a Opciones

94

Añadir librería JDBC de Oracle al classpath de la herramienta

95

96

97

Crear una nueva conexión.

98

Elegir conexión de tipo JDBC

99

Seleccionar conexión Oracle y rellenar los datos de la conexión local de Oracle XE.

100

Guardar la conexión.

101

Para realizar un informe de manera rápida, utilizaremos el asistente de iReport.

Hacer click en el “report wizard”.

102

Seleccionar una plantilla y hacer click en “Launch Report Wizard”

103

Rellenar nombre del informe y guardar fichero en c:\wamp\www\aplicacion\plantillasJasper\

104

Seleccionar conexión y hacer click en “Design query”

105

Seleccionar las tablas del esquema/usuario SEDES y arrastrarlas al panel vacío

106

Botón derecho sobre WHERE , seleccionar “add condition” y añadir una condición

107

Al cambiar a la solapa “syntax” podremos ver la consulta SQL generada.

108

Aceptar y continuar

109

Seleccionar los campos que queremos ver en el informe

110

111

Seleccionar los grupos que queramos que distinga el informe

112

Terminar y guardar

113

Editar título y colocar campos y columnas

Ahora vamos a editar la consulta del informe para que el valor del campo responsable.nif sea igual al valor que contenga un parámetro. De este modo, el informe variará según el valor de dicho parámetro.

114

Botón derecho sobre la raíz del árbol de la izquierda y seleccionar “Edit Query”

115

Hacer click en “New parameter”

116

Dar nombre a dicho parámetro

117

118

Arrastrar el parámetro y soltarlo sobre las comillas simples de la condición de la where para remplazarlas.

119

Si hacemos click en preview podremos ver el informe diseñado

120

Dar valor al parámetro para que se ejecute la condición de filtro

121

Resultado del informe

122

Ahora solo nos falta compilar y guardar el informe. Al compilar se generará un fichero .jasper que utilizaremos en gvHidra.

123

Muestra del informe invocado desde gvHidra, añadiendo como parámetro el valor del campo “lis_NIF” de la fila seleccionada en el tabular.

124