Treball fi de carrera         ENGINYERIA TÈCNICA EN       INFORMÀTICA DE SISTEMES         Facultat de Matemàtiques        ...
Índice detallado1. Introducción...........................................4     1.1 Ámbito del proyecto......................
5.2.3.4 Imágenes..........................55     5.3 Pruebas.........................................566. Conclusiones y l...
Programación de una tienda virtual en Grails      1. Introducción1. Introducción1.1 Ámbito del proyectoEn   la  actualidad...
Programación de una tienda virtual en Grails           1. Introducción1.2 Objetivos generalesEl objetivo principal de nues...
Programación de una tienda virtual en Grails      1. Introducción1.4 Organización de la memoriaLa memoria esta organizada ...
Programación de una tienda virtual en Grails      2. Antecedentes2. Antecedentes2.1 Exposición de problemáticasEn los últi...
Programación de una tienda virtual en Grails        2. AntecedentesPara Groovy, Java no es un lenguaje incompatible con su...
Programación de una tienda virtual en Grails        2. Antecedentescomo en el ejemplo, podemos exportar librerías Java par...
Programación de una tienda virtual en Grails            2. AntecedentesDichos objetivos se han conseguido en mayor o menor...
Programación de una tienda virtual en Grails       2. Antecedentes            seguida por la implementación del soporte má...
Programación de una tienda virtual en Grails                    2. Antecedentes              public class HolaMundo{      ...
Programación de una tienda virtual en Grails                2. Antecedentes             <-- Rangos -->             def rg ...
Programación de una tienda virtual en Grails                  2. Antecedentes      Basta con declarar la expresión de búsq...
Programación de una tienda virtual en Grails                  2. Antecedentes      obtener y modificar el valor de un camp...
Programación de una tienda virtual en Grails                2. Antecedentes          import java.util.Date          if (se...
Programación de una tienda virtual en Grails                 2. Antecedentes      Esta estructura de ficheros nos sitúa au...
Programación de una tienda virtual en Grails                 2. Antecedentes      proyecto. Seguidamente se ha de modifica...
Programación de una tienda virtual en Grails         2. Antecedentes      En el anterior ejemplo descubrimos las ventajas ...
Programación de una tienda virtual en Grails                             2. Antecedentes     class CartController {       ...
Programación de una tienda virtual en Grails      2. Antecedentes      En este ejemplo, podemos ver los controladores bási...
Programación de una tienda virtual en Grails        2. Antecedentes         •   Groovy: Lenguaje de programación base de G...
Programación de una tienda virtual en Grails          3. Análisis3. Análisis3.1 Descripción del problemaTenemos la necesid...
Programación de una tienda virtual en Grails           3. Análisis3.3.1 BannerEl portal, como todo portal que se precie, t...
Programación de una tienda virtual en Grails                                                       3. Análisis            ...
Programación de una tienda virtual en Grails                     3. Análisis   •   RENDIMIENTO       El rendimiento de una...
Programación de una tienda virtual en Grails           4. Diseño4. Diseño4.1 Casos de uso4.1.1 Objetivos afinesAcceso a la...
Programación de una tienda virtual en Grails           4. Diseño     1. El usuario quiere visualizar la ficha de un carrit...
Programación de una tienda virtual en Grails             4. Diseño     5. El usuario modifica los atributos que desee y sa...
Programación de una tienda virtual en Grails           4. Diseño     5. El usuario modifica los atributos que desee y salv...
Programación de una tienda virtual en Grails           4. Diseño     2. El usuario clica en el botón de Profile/Users     ...
Programación de una tienda virtual en Grails           4. Diseño     Administrador: se quiere dar de alta una nueva mascot...
Programación de una tienda virtual en Grails           4. DiseñoEliminación de mascotasActor principal: AdministradorPerso...
Programación de una tienda virtual en Grails                    4. DiseñoEscenario principal de éxito:     1. El usuario q...
Programación de una tienda virtual en Grails           4. Diseño     Usuario Registrado: se quiere modificar el método de ...
Programación de una tienda virtual en Grails                4. Diseñorealizaremos el diseño del diagrama de clases de nues...
Programación de una tienda virtual en Grails                4. DiseñoLos controladores que generan las vistas para el usua...
Programación de una tienda virtual en Grails                                                            4. Diseño los real...
Programación de una tienda virtual en Grails                                                4. Diseño                     ...
Programación de una tienda virtual en Grails    5. Implementación5. Implementación y pruebas5.1 Entorno de desarrolloAsí c...
Programación de una tienda virtual en Grails                     5. Implementación5.2 Seguimiento y problemáticasEn este a...
Programación de una tienda virtual en Grails                        5. ImplementaciónComo podemos observar configuramos el...
Programación de una tienda virtual en Grails                     5. Implementación    $> grails create-domain-class cart  ...
Programación de una tienda virtual en Grails                       5. Implementación5.2.2 Controladores y vistasUna vez co...
Programación de una tienda virtual en Grails                      5. Implementación    Como podemos observar, la restricci...
Programación de una tienda virtual en Grails                        5. Implementación                               }else{...
Programación de una tienda virtual en Grails                      5. Implementacióneliminar mascotas a dicho carrito, Elim...
Programacion de una tienda virtual en Grails
Programacion de una tienda virtual en Grails
Programacion de una tienda virtual en Grails
Programacion de una tienda virtual en Grails
Programacion de una tienda virtual en Grails
Programacion de una tienda virtual en Grails
Programacion de una tienda virtual en Grails
Programacion de una tienda virtual en Grails
Programacion de una tienda virtual en Grails
Programacion de una tienda virtual en Grails
Programacion de una tienda virtual en Grails
Programacion de una tienda virtual en Grails
Programacion de una tienda virtual en Grails
Programacion de una tienda virtual en Grails
Programacion de una tienda virtual en Grails
Programacion de una tienda virtual en Grails
Programacion de una tienda virtual en Grails
Programacion de una tienda virtual en Grails
Programacion de una tienda virtual en Grails
Programacion de una tienda virtual en Grails
Programacion de una tienda virtual en Grails
Programacion de una tienda virtual en Grails
Programacion de una tienda virtual en Grails
Upcoming SlideShare
Loading in...5
×

Programacion de una tienda virtual en Grails

9,856

Published on

Proyecto de Final de Carrera en el que se diseña e implementa una Tienda Virtual mediante el framework Groovy on Grails

Published in: Technology
0 Comments
2 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
9,856
On Slideshare
0
From Embeds
0
Number of Embeds
5
Actions
Shares
0
Downloads
491
Comments
0
Likes
2
Embeds 0
No embeds

No notes for slide

Transcript of "Programacion de una tienda virtual en Grails"

  1. 1. Treball fi de carrera ENGINYERIA TÈCNICA EN INFORMÀTICA DE SISTEMES Facultat de Matemàtiques Universitat de BarcelonaPROGRAMACIÓN DE UNA TIENDA VIRTUAL EN GRAILS Gabriel Bermúdez Merino Director: Jesús Cerquides Bueno Realitzat a: Departament de Matemàtica Aplicada i Anàlisi. UB Barcelona, 3 de julio de 2008
  2. 2. Índice detallado1. Introducción...........................................4 1.1 Ámbito del proyecto..............................4 1.2 Objetivos generales..............................5 1.3 Objetivos específicos............................5 1.4 Organización de la memoria.......................62. Antecedentes...........................................7 2.1 Exposición de problemáticas......................7 2.1.1 Groovy como lenguaje de programación......7 2.1.2 Grails como framework Web.................9 2.2 Tecnologías asociadas...........................11 2.2.1 Groovy...................................11 2.2.2 Grails...................................16 2.3 Conclusión......................................213. Análisis..............................................23 3.1 Descripción del problema........................23 3.2 Descripción del producto........................23 3.3 Requisitos funcionales..........................23 3.3.1 Banner...................................24 3.3.2 Navigation Blocks........................24 3.3.3 Render...................................25 3.4 Requisitos no funcionales.......................25 3.5 Identificación de actores y objetivos...........264. Diseño................................................27 4.1 Casos de uso....................................27 4.1.1 Objetivos afines.........................27 4.1.2 Objetivos administrador..................31 4.1.3 Objetivos Usuario Registrado.............33 4.1.4 Objetivos Usuario No Registrado..........35 4.2 Diagramas.......................................35 4.2.1 Diagrama de dominio......................36 4.2.2 Modelo Vista-Controlador.................36 4.2.2.1 Vista-Controlador User............36 4.2.2.2 Vista-Controlador Pet.............37 4.2.2.3 Vista-Controlador Cart............37 4.2.3 Site Maps................................385. Implementación y pruebas..............................40 5.1 Entorno de desarrollo...........................40 5.1.1 GNU/Linux................................40 5.1.2 Gedit....................................40 5.1.3 Mozilla Firefox 2.14.....................40 5.1.4 Groovy...................................40 5.1.5 Grails...................................40 5.2 Seguimiento y problemáticas.....................41 5.2.1 Estructura y persistencia................41 5.2.2 Controladores y vistas...................44 5.2.2.1 Controladores.....................44 5.2.2.2 Vistas............................50 5.2.3 Extras...................................53 5.2.3.1 Tools Navigation Block............53 5.2.3.2 Contact Navigation Block..........54 5.2.3.3 Gsp’s estructura por defecto......55
  3. 3. 5.2.3.4 Imágenes..........................55 5.3 Pruebas.........................................566. Conclusiones y líneas de futuro.......................607. Bibliografía..........................................62 7.1 Libros..........................................62 7.2 Recursos electrónicos...........................628. Anexos................................................63 8.1 Manual instalación de librerías.................63 8.1.1 Groovy...................................63 8.1.2 Grails...................................63 8.2 Riesgos.........................................64 8.3 Análisis del tiempo de realización del proyecto.64 8.4 Implantación....................................66
  4. 4. Programación de una tienda virtual en Grails 1. Introducción1. Introducción1.1 Ámbito del proyectoEn la actualidad, Internet está viviendo una profundatransformación: ha pasado de ser un escaparate de informaciónestática a un conjunto de aplicaciones y portales que utilizanel conocimiento colectivo para facilitar servicios interactivosdonde los usuarios tienen el control de sus datos y de lainformación.Los entornos colaborativos son el conjunto de herramientas ytecnologías sobre los que se sustenta la Web 2.0: en una solapalabra "COLABORAR".Hay varios factores que son responsables de que seamos testigosde una convergencia entre tecnología y sociedad, donde latecnología facilita cambios sociales, y estos a su vez marcanlas tendencias de la tecnología. Uno de los factores másimportantes ha sido la facilidad de acceso y aparición detarifas planas de conexión, además de que la realidad de losconsumidores ha mutado y no se basa en una lealtad ciega haciacierta marca.El ámbito de los entornos colaborativos es tan amplio como lapropia WWW. Su aplicación se extiende a cualquier modelo denegocio, por lo que no es difícil imaginar el importante impactoeconómico y social que suponen en el entorno empresarial actual.La aparición de Blogs, Wikis, Redes sociales, ComercioElectrónico, etc ... ha impulsado la proliferación de estándarescon el fin de ayudar a la creación de aplicaciones web, losdenominados frameworks, con un único objetivo: simplificar lacomplejidad de la creación de aplicaciones web. Existen variosframeworks web, Struts / Tapestry / ASP.NET / Ruby on Rails /Groovy on Grails, pero casi todos basados en el mismo tipo deestructura: J2EE.Con el paso del tiempo cada vez es más sencillo utilizar estosframeworks, por lo que la creación de una aplicación web,actualmente, está al alcance de cualquier persona con nocionesbásicas de programación y, sobretodo, curiosidad.En algunas de las asignaturas de la carrera hemos estudiadodiversas metodologías de desarrollo de aplicaciones, incluyendosu análisis y diseño, y su aplicación en el panoramacolaborativo de Internet actual. En este proyecto se volverán autilizar estas metodologías para crear una aplicación web dee-commerce con el objetivo de demostrar la potencia delframework web estudiado.Gabriel Bermúdez Merino 4
  5. 5. Programación de una tienda virtual en Grails 1. Introducción1.2 Objetivos generalesEl objetivo principal de nuestro proyecto es el estudio delnuevo framework web Grails basado en Groovy, para elloutilizamos dicho framework para crear una aplicación de e-commerce, en concreto una tienda virtual de mascotas basada enun ejemplo de Sun Microsystems. Gracias a esta aplicación dee-commerce se comparara la simplicidad de creación y laeficiencia entre dicha aplicación y el ejemplo de Sun, con elúnico objetivo de dar a conocer la potencia de este nuevoframework, que sin duda alguna en el futuro dará mucho quehablar en el panorama del diseño web.1.3 Objetivos específicosLos objetivos específicos que se quieren conseguir en elproyecto son descritos a continuación: • Estudio de Groovy, el lenguaje de programación base de Grails. Para este estudio seguiremos las siguientes fases: o Estudio base de las diferencias más relevantes entre Groovy y Java. o Introducción a los comandos básicos de Groovy. o Realización de ejemplos para profundizar en su estructura. • Estudio de Grails, tanto su estructura como sus posibles aplicaciones. Para este estudio seguiremos las siguientes fases: o Introducción a la estructura de Grails y sus comandos más relevantes. o Realización de ejemplos simples para profundizar en su estructura. o Realizar un ejemplo que estudia en profundidad la gran mayoría de su estructura y comandos. o Comparación entre este framework y la estructura del de Sun Microsystems.Gabriel Bermúdez Merino 5
  6. 6. Programación de una tienda virtual en Grails 1. Introducción1.4 Organización de la memoriaLa memoria esta organizada en diversos capítulos, cada uno consus funcionalidades, las cuáles están explicadas a continuación: • Introducción: Apartado en el que se hace una aproximación a los términos que acatará el proyecto. • Antecedentes: Se expondrá el problema que se quiere abordar con el proyecto y se estudiarán las tecnologías para llevarlo a cabo. • Análisis: En este apartado analizaremos el problema, la aplicación que queremos desarrollar, sus requisitos y demás objetivos que se quieren abordar. • Diseño: En este apartado se diseñara el sistema según las especificaciones analizadas en el apartado anterior. • Implementación y pruebas: Este apartado será escrito durante la implementación del código y en él explicaremos el entorno con el que desarrollaremos la aplicación, las simulaciones y problemáticas. • Conclusiones y Líneas de Futuro: El apartado de conclusiones será escrito antes de finalizar el proyecto y en el haremos la valoración final de la aplicación y del proyecto, así también evaluaremos las líneas de futuro de éste. • Bibliografía: En la bibliografía especificaremos los recursos de dónde se ha extraído la información necesaria para el desarrollo del proyecto. • Anexos: Los anexos contienen toda la documentación técnica e instalación de librerías necesarias, así como un análisis del tiempo de realización el proyecto.Gabriel Bermúdez Merino 6
  7. 7. Programación de una tienda virtual en Grails 2. Antecedentes2. Antecedentes2.1 Exposición de problemáticasEn los últimos años Internet ha ido evolucionando poco a pocohacia un entorno colaborativo entre usuarios, hasta llegar a laactualidad y a la Web 2.0, donde el entorno colaborativo haculminado con la aparición de Blogs, Wikis, el e-commerce, …Esto último implica el estudio e investigación de nuevastecnologías que hagan más sencillo el desarrollo de nuevasaplicaciones web tanto para el desarrollador como para elusuario llano.El desarrollo de frameworks web ha ido evolucionandoconstantemente, desde los struts, framework que implementa elpatrón de arquitectura Modelo Vista-Controlador en Java, hasta,por ejemplo, “Groovy on Grails”, buscando siempre unasimplificación de código pero sin comprender una reducción de lacalidad del producto final.El problema abordado por este proyecto es la creación de unaaplicación web de e-commerce, concretamente una tienda virtualde mascotas, utilizando la nueva tecnología basada en Groovy,Grails. Para la implementación de esta aplicación han sidonecesarios varios estudios previos de cada una de lastecnologías que comprenden el mundo de “Groovy on Grails”, loscuales podriamos dividir en: • Estudio del lenguaje de programación Groovy • Estudio del framework basado en Groovy, Grails • Análisis, diseño e implementación de la aplicación web propiamente dicha2.1.1 Groovy como lenguaje de programaciónEl 2 de Enero de 2007 aparecía laversión 1.0 de Groovy, un nuevo lenguajede programación orientado a objetosdesarrollado por Guillaume Laforge, Jefede Proyecto y JSR-241 Spec Lead.La implementación de Groovy se realiza sobre la plataforma Java,además, tiene características similares a Python, Ruby, Perl ySmalltalk. Gracias a la especificación JSR-241, se busca suestandarización para una futura inclusión como componenteoficial de la plataforma Java.Groovy utiliza una sintaxis muy parecida a Java, compartiendo elmismo modelo de objetos, de hilos y de seguridad. Medianteimportaciones, Groovy puede acceder a todas las API de Javaampliando la compilación, ya que el bytecode generado estotalmente compatible con el que Java genera para la JavaVirtual Machine.Gabriel Bermúdez Merino 7
  8. 8. Programación de una tienda virtual en Grails 2. AntecedentesPara Groovy, Java no es un lenguaje incompatible con su código,todo lo contrario, todo el código escrito en Java es válido enGroovy. Este aspecto hace su aprendizaje mucho más sencillo aprogramadores Java que otros lenguajes que se ejecutan sobre laJava Virtual Machine, como Jython o Jruby.Java es totalmente compatible con Groovy, pero esto no hace queGroovy pierda todas las ventajas de un lenguaje de scripting, yaque también se puede ejecutar de forma dinámica. Por ejemplo, enJava la salida estándar de “Hello World” hace necesaria laescritura de una clase, un método main con una serie deargumentos, etc… Pero en Groovy, no es necesario escribir todoel código, te puedes ahorrar la declaración de la clase y elmétodo main, y sólo escribir una línea de código que muestre porpantalla “Hello World”.El contenido del archivo HelloWorld.groovy sería: println “Hello World”Como podemos observar, el dinamismo de un lenguaje de scriptingse encuentra presente en Groovy, pero, ¿y la compatibilidad conJava?Groovy da soporte a listas, mapas, etc… y aún podemos demostrarla simplicidad de Groovy y su capacidad para ejecutar código enJava: //Printamos una fecha utilizando codigo Java def mydate = new java.util.Date() println mydate //Iteración sobre un hash map def numbersMAP = [1:ONE, 2:TWO] for (entry in numbersMAP) { println "${entry.key} = ${entry.value}" } //Introducimos un rango def range = a..d //Listas def numberlist = [1, 2, 3, 4, 5, 6, 7, 8] println numberlist; println "Maximum value: ${numberlist.max()}"Como podemos observar en el código, utilizamos directamentejava.util.Date y no importamos un soporte para colecciones paratrabajar con listas, mapas y rangos. Aunque no es necesario,Gabriel Bermúdez Merino 8
  9. 9. Programación de una tienda virtual en Grails 2. Antecedentescomo en el ejemplo, podemos exportar librerías Java para que elproceso de desarrollo sea más cómodo.En el apartado de tecnologías asociadas, profundizaremos más enel mundo de Groovy mediante explicaciones y ejemplos.2.1.2 Grails como framework WebGrails es un framework paraaplicaciones Web de libredistribución, que tiene comobase el lenguaje deprogramación Groovy. Grailses un framework de alta productividad que viene distribuido bajoel paradigma del “código por convención” (MVC), el cuálproporciona un entorno de desarrollo independiente y unosdetalles de configuración escondidos para el desarrollador.Grails se llamó previamente “Groovy on Rails” (nombre que se lepuso en como homenaje a David Heinemeier Hansson, fundador deRuby on Rails, otro framework web). El trabajo de desarrollocomenzó en Julio de 2005 que dio como fruto la versión 0.1 el 29de Marzo de 2006 i la versión 1.0 el 18 de Febrero de 2008.En el momento de su implementación, se estudiaron variosconceptos a favor de Grails entre los que destacaban: • Proporcionar una alta productividad basándose en la plataforma de Java. • Utilizar de manera más simple tecnologías de Java como Hibernate y Spring, mediante una interface consistente. • Un framework sencillo y fácil de aprender. • Documentación con participación de los usuarios. • Proporcionar simplicidad en áreas donde antes solo podían adentrarse usuarios expertos: o Framework persistente potente y consistente. o Uso sencillo pero potente de las templates de vista utilizando GSP (Páginas de Servidor Groovy). o Librerías de tags dinámicas para una creación de componentes web sencilla. o Buen soporte a Ajax pero simple de ampliar y personalizar. • Proporcionar ejemplos de aplicaciones con los que demostrar la potencia de este nuevo framework. • Proporcionar un modo de desarrollo completo, incluyendo un servidor web y un sistema de carga de ficheros automática.Gabriel Bermúdez Merino 9
  10. 10. Programación de una tienda virtual en Grails 2. AntecedentesDichos objetivos se han conseguido en mayor o menor grado, entrelos logros más relevante, cabe destacar: • Framework sencillo y simple Gracias a la implementación de Grails basandose en el paradigma del “código por convención” (MVC), se han conseguido realizar nuevas implementaciones, ya sea en la mejora del código o en su funcionalidad. Las más relevantes son: o Controllers Los controllers son los sustitutos naturales de los Servlets tal y como los conocemos, ya que siguiendo la convención de Grails crearemos una Closure de Groovy cada vez que queramos realizar una acción sobre una clase de la aplicación web. La creación de un controlador vendría dado por: $> groovy create-controller ---------------------------------------------------- def list = { if(!params.max) params.max = 10 [ petList: Pet.list( params ) ] } o Soporte a Ajax y uso de librerías dinámicas para poder implementar plugins con el fin de facilitar la implementación de la nueva aplicación web. • Persistencia y alta productividad o La alta productividad viene dada por el uso del lenguaje de scripting Groovy como base de programación, ya que sobre este lenguaje se podría aplicar un famoso dicho, “Nunca tan poco a dado tanto”, ya que con poca cantidad de código se puede realizar una pequeña aplicación en Grails. o La persistencia en Grails viene dada por la simplicidad de creación de sus clases de dominio: $> groovy create-domain-class ---------------------------------------------------- class Cart { String status String payment String numberTarget Float total Map contentBuy=[1 : 1] }Gabriel Bermúdez Merino 10
  11. 11. Programación de una tienda virtual en Grails 2. Antecedentes seguida por la implementación del soporte más importante para las operaciones CRUD (Create, Read, Update, Delete), el Scaffolding. Scaffolding es un método para construir aplicaciones basadas en bases de datos, esta técnica está soportada por algunos frameworks del tipo MVC en el cuál el programador escribe una especificación que describe cómo debe ser usada la base de datos. Luego el compilador utiliza esa especificación para generar el código que la aplicación usará para crear, leer, actualizar y eliminar registros de la base de datos. En Grails la activación del Scaffolding es tan sencilla como la mayoría de implementaciones en Grails. class cartController { scaffold = true }Como podemos observar, Grails es un framework potente pero a lapar sencillo, ahora sólo hemos nombrado los aspectos másrelevantes por lo que a continuación, en el apartado detecnologías asociadas, profundizaremos más en el mundo de Grailsmediante explicaciones y ejemplos, posteriormente realizaremosuna implementación completa de una aplicación web de e-comerce.2.2 Tecnologías asociadas2.2.1 GroovyEn este apartado, se va a profundizar en los aspectos másrelevantes de Groovy mediante descripciones y ejemplos. No sepuede considerar este apartado como un manual de usuario deGroovy, más bien como un pequeño tutorial de introducción aéste potente lenguaje de scripting.En algunos de estos ejemplos se hará una comparativa directa conJava con el objetivo de demostrar la disminución de código entreuno y otro. 1. Primeros pasos: “Hola Mundo” Queremos que Groovy imprima por pantalla una cadena de caracteres con la información “Hola Mundo”. Gracias a la compatibilidad de Groovy con el lenguaje Java se podría implementar este problema de la misma manera que lo haríamos en Java, pero al ser un lenguaje de Scripting no sería necesaria la creación de una clase, con solo introducir la instrucción de imprimir por pantalla sería suficiente.Gabriel Bermúdez Merino 11
  12. 12. Programación de una tienda virtual en Grails 2. Antecedentes public class HolaMundo{ public static void main(String[] args){ System.out.println(“Hola Mundo”); } } --------------------------------------------------------- println “Hola Mundo” La diferencia de cantidad de código es abrumadora, pero existen otras implementaciones con el mismo objetivo. class HolaMundo{ def hiWorld(name){ “Hola ${name}” } } def hW = new HolaMundo() println hW.hiWorld(“Mundo”) Con esta implementación podemos observar algunas de las características de Groovy: • El valor de retorno no es específico, por lo que usamos la palabra reservada def (muy parecida a la palabra var de JavaScript) • No es necesario utilizar la palabra reservada return, la última sentencia ejecutada determina el valor de retorno. • La cadena de caracteres no es un java.lang.string, se trata de un GString. Los GStrings permiten la evaluación de expresiones, al igual que con Perl. 2. Tipos de datos Groovy soporta todos los tipos de datos de Java, sin primitivos, y además define listas y mapas como tipos básicos, así como los arrays y hashs de Perl y PHP. En realidad las listas son en el fondo java.util.ArrayList y los mapas java.util.HashMap, por lo que se podrán utilizar todos los métodos ya conocidos en Java relacionados con listas y mapas. Además, Groovy permite que los índices y llaves sean manipulados a través del operador ‘[]’, y en el caso de los mapas también mediante ‘.’. <-- Números --> def x = 12 def y = 10.0e4 <-- Caracteres y Strings --> def c = “a” def s = “hi World!” <-- Listas y Mapas --> def list = [1,2,3,4] def map= [“Jon”:”Matthers”, “1”:”Mark”]Gabriel Bermúdez Merino 12
  13. 13. Programación de una tienda virtual en Grails 2. Antecedentes <-- Rangos --> def rg = (0..9) <-- Impresión de rangos --> rg.each{num -> print num} Como podemos observar, la definición de variables en Groovy no implica una definición primitiva, el contenido de la variable especifica el tipo de dicha variable. En la última descripción, podemos observar el método de recorrido de los rangos, el cuál puede ser aplicado en más tipos de variables, además nos introduce en un nuevo concepto de Groovy, que ha sido adoptado por la nueva implementación de Java 7, las closures. 3. Closures Una closure se podría describir como un bloque de código reutilizable, que retiene la información entorno donde fueron definidos. Esta forma de trabajo es muy parecida a JavaScript, ya que es muy parecido a la definición de una función anónima en un script. Las closures pueden recibir parámetros, puesto que los tipos de Groovy son opcionales, sólo es necesario escribir el nombre del parámetro. El uso de closures es tan común, que si no se ha definido un parámetro específico de todos modos estará disponible una variable it que representa el valor del parámetro. def printOut = {item -> print item} (0..9).each(printout) --------------------------------------------------------- def printOut = {print it} (0..9).each(printout) La implementación de las closures implica un gran avance en el mundo de la programación, ya que no es necesario crear un nuevo método fuera del actual pudiendo utilizar las variables locales del actual. 4. Expresiones regulares Como muchos lenguajes de scripting, Groovy también ofrece la posibilidad de utilizar expresiones regulares, es decir, declarar y utilizar dichas expresiones sin necesidad de construcciones complexas o añadir sintaxis adicionales a las construcciones básicas del lenguaje.Gabriel Bermúdez Merino 13
  14. 14. Programación de una tienda virtual en Grails 2. Antecedentes Basta con declarar la expresión de búsqueda entre barras diagonales y usar uno de los tres operadores disponibles: • =~ búsqueda de ocurrencias • ==~ coincidencias • ~ patrón def text = “At school, Harry had no one. Everybody know that Dudley’s gang hated that odd Harry Potter” + “ in his baggy old clothes and broken glasses, and nobody liked to disagree with Dudley’s gang.” matcher = (text =~ /Harry Potter/) --------------------------------------------------------- matcher = (text ==~ /Harry/) --------------------------------------------------------- matcher = (text ~ /H.*y/) 5. POJOs to POGOs En los últimos años Sun a dominado el sector de JavaBeans gracias al resurgimiento de los POJOs (Plain Old Java Objects), es decir, un subconjunto de la convención JavaBeans. Los POJOs son un subconjunto puesto que los JavaBeans deben notificar cualquier cambio que se realice en alguna de sus propiedades, mientras que los POJOs no lo hacen. Spring y Hibernate no dudaron sobre las ventajas de uso, y no tardaron en incorporarlo en su implementación. El único pero que tenían los POJOs era su complicada implementación, este apartado fue resuelto gracias a que algunos Ambientes de Desarrollo Integrados (IDE) comenzaron a proporcionar herramientas para generar este tipo de código. Pero los POGOs van más allá, simplemente con declarar las propiedades según la convención, los métodos de acceso se generarán. Dichas propiedades se declaran con tipo y nombre, sin modificador de acceso, ya que de tenerlo dejan de ser una propiedad para pasar a ser un campo. La creación de POGOs implica una definición de un POGO propiamente dicho, la definición de cómo mínimo 1 propiedad y campos. En el momento de la creación descubrimos otra de las ventajas de Groovy, en el momento de la llamada al constructor mediante un mapa extendido debido a que Groovy anexa un constructor por omisión a los POGOs. En el momento del acceso a campos se puede realizar mediante el operador ‘.’ o ‘[]’ lo cuál hace que parezca que se ha roto la encapsulación del POGO, pero en realidad es todo lo contrario, ya que existe la posibilidad deGabriel Bermúdez Merino 14
  15. 15. Programación de una tienda virtual en Grails 2. Antecedentes obtener y modificar el valor de un campo mediante el operador ‘.@’ que tampoco rompe la encapsulación. class Person{ String name #Property String firstName #Property private int id #Field String toString() {“${name} ${firstName}”} } Person person = new Person(name:’Matthew’, firstName:’McMag’) assert “Matthew McMag” == person.toString() person.firstName = “McGam” assert “Matthew McGam” == person.toString() person[‘firstName’] = “McMag” assert “Matthew McMag” == person.toString() assert person.name == “Matthew” assert person.@name == “Matthew” assert person.completName == “Matthew McMag” try{ assert person.completName == “Matthew McMag” }match(MissingFieldException e){ println “Error, completName isn’t a field } Gracias a los POGOs podemos descubrir otra de las peculiaridades de Groovy, es el segundo lenguaje, después de Java, que soporta anotaciones, aunque el soporte para tipos genéricos aún está en desarrollo. class Person{ @BoundProperty String name @BoundProperty String firstName } 6. Desarrollo web con Groovy Como pequeña introducción en el desarrollo web con Groovy antes de las definiciones y ejemplos de Grails, introduciremos el sustituto de los Servlets de Java por los Groovlets. La simplicidad de código y la posible inclusión de tags de html en el mismo código en Groovy representa grandes ventajas que los Servlets no disponen. A continuación introducimos un ejemplo de un Groovlet ya que es la forma más sencilla de entender este tipo de implementación.Gabriel Bermúdez Merino 15
  16. 16. Programación de una tienda virtual en Grails 2. Antecedentes import java.util.Date if (session == null) { session = request.getSession(true); } if (session.counter == null) { session.counter = 1 } println """ <html> <head> <title>Groovy Servlet</title> </head> <body> Hello, ${request.remoteHost}: ${session.counter}! ${new Date()} </body> </html> """ session.counter = session.counter + 12.2.2 GrailsEn este apartado, se va a profundizar en los aspectos másrelevantes de Grails mediante descripciones y ejemplos. No sepuede considerar este apartado como un manual de usuario deGrails, más bien como un pequeño tutorial de introducción aéste potente framework web.En los siguientes apartados vamos a tratar varios aspectos deGrails, desde su estructura hasta llegar a su funcionalidadpasando por la implementación de controladores, gsp’s, etc … 1. Estructura de la aplicación El primer paso en la implementación de un nuevo proyecto en Grails, es la creación de la estructura de directorios del proyecto. Para realizar este paso, Grails nos proporciona un comando que nos crea automáticamente la estructura de directorios: $> grails create-app seguidamente a esta instrucción introducimos el nombre de la aplicación y a continuación Grails nos crea la estructura necesaria para administrar nuestro proyecto. Una de las ideas principales de Grails es la aplicación de convenciones de desarrollo de aplicaciones Web, siguiendo esta convención se crean los archivos y directorios que se usarán en la mayoría de aplicaciones Web. Aunque esta estructura de directorios no es estática, ya que la podemos configurar según nuestras necesidades.Gabriel Bermúdez Merino 16
  17. 17. Programación de una tienda virtual en Grails 2. Antecedentes Esta estructura de ficheros nos sitúa automáticamente los Paths donde van a ir almacenados las vistas, controladores, librerías,… donde Grails va a ir colocando los nuevos elementos que se vayan creando automáticamente durante la implementación del proyecto. Si se tiene experiencia utilizando Apache Ant, se puede crear manualmente este sistema de directorios modificando el archivo de /src/grails/build.xml que encontramos en el directorio GRAILS_HOME. 2. Base de datos La base de datos que viene configurada por defecto cuando creamos un nuevo proyecto en Grails es volátil y utiliza el lenguaje de base de datos HSQL. Si queremos que nuestra base de datos deje de ser volátil y queremos que tenga una permanencia (en el localhost), se modificará la siguiente línea en el fichero: …/grails-app/conf/ApplicationDataSource.groovy dataSource { pooled = false driverClassName = "com.mysql.jdbc.Driver" username = "root" password = "" } … environments { development { dataSource { dbCreate = "update" // one of create, create-drop,update url = "jdbc:mysql://localhost/petStore_dev" } } test { dataSource { dbCreate = "update" url = "jdbc:mysql://localhost/petStore_test" } } production { dataSource { dbCreate = "update" url = "jdbc:mysql://localhost/petStore_prod;shutdown=true" } } } Como podemos observar en el código, modificando el valor de dbCreate por update, establecemos una base de datos permanente. Observamos también que por cada tipo de implementación, ya sea de desarrollo, testeo o producción podemos tener una base de datos diferente, lo que facilita la futura implantación del proyecto. Si por comodidad se quiere utilizar otro tipo de lenguaje de base de datos, tan sólo se ha de descargar el driver correspondiente y almacenarlo en el directorio lib delGabriel Bermúdez Merino 17
  18. 18. Programación de una tienda virtual en Grails 2. Antecedentes proyecto. Seguidamente se ha de modificar el nombre del driver en el anterior código, así como la situación de las bases de datos que se utilizaran. 3. Clases de dominio El Mapeo de Objetos Relacionales de Grails (GORM) utiliza internamente Hibernate 3, pero para poder implementar la aplicación Web no es necesario tener ningún conocimiento sobre Hibernate. Para realizar este mapeo Grails utiliza las llamadas clases de dominio, que determina los objetos mapeados en la base de datos. Se pueden linkar clases de dominio utilizando relaciones proporcionando metodos dinámicos para realizar operaciones CRUD (Create, Read, Update, Delete), sobretodo mediante Scaffolding. Grails dispone de una instrucción para la creación automática de clases, que nos almacenará las nuevas clases en el directorio …/grails-app/domain/ , $> grails create-domain-class a dicha instrucción solamente le hemos de proporcionar el nombre de la clase y ya tendremos una nueva clase disponible para configurar. Estas clases de dominio pueden disponer, además de sus propiedades y campos, de métodos propios y declaraciones de constraints para las propiedades y campos. Es posible establecer una relación de 1-1, 1-n o n-n entre clases directamente en la implementación de dichas clases, este y anteriores elementos los veremos en el siguiente ejemplo. class Pet { String name String type String description Float price byte[] image static hasMany = [carts:Cart] static belongsTo = Cart static constraints = { name(maxLength:50, blank:false) type(inList:[Bird,Cat, Dog, Fish, Ferret, Rodent], blank:false) description() price(min:0f) image(nullable:true, maxSize:65536) /* 64K */ } static mapping = { description type: text } }Gabriel Bermúdez Merino 18
  19. 19. Programación de una tienda virtual en Grails 2. Antecedentes En el anterior ejemplo descubrimos las ventajas de las clases de dominio de Grails, las restricciones directas en código y la relación entre diferentes clases directamente en código. • Restricciones directas en código Como podemos observar, utilizando una closure con el nombre “constraints”, podemos configurar las restricciones que queremos que tengan las propiedades y los campos de la clase, lo que nos facilitará la implementación posteriormente cuando se creen las vistas y los controladores. • Relación entre clases directamente en código Para realizar una relación entre clases, tan sólo se ha de establecer una variable relacional: o Sección 1 de la relación: Utilizaremos la variable belongsTo con valor igual a la clase con la que estamos relacionando. o Sección n de la relación: Utilizaremos la variable anterior belongsTo, además de la variable hasMany con valor igual a la clase con la que estamos relacionando mediante un mapa extendido, especificando el nombre de la variable que almacenará la colección de valores. 4. Controladores y vistas Una vez que las clases de dominio ya se han creado, es el momento de utilizar un nuevo comando de Grails que nos auto genera los CRUD básicos para nuestra aplicación Web: $> grails generate-all Gracias a este comando se crean los llamados controladores y las vistas básicas que necesitaremos para gestionar nuestra clase de dominio. Los controladores se almacenarán en el directorio grails- appcontrollers. Dichos controladores son los responsables de el manejo de las peticiones de nuestra aplicación Web. Los controladores son los sustitutos naturales de los Servlets de Java, con la ventaja de que su implementación es tan sencilla como crear una closure por cada tipo de petición que queramos que atienda. A continuación vamos a ver un ejemplo de controladores e introduciremos el concepto de Scaffolding en Grails.Gabriel Bermúdez Merino 19
  20. 20. Programación de una tienda virtual en Grails 2. Antecedentes class CartController { def index = { redirect(action:list,params:params) } def scaffold = Cart def list = { if(!params.max) params.max = 10 [ cartList: Cart.list( params ) ] } def show = { def cart = Cart.get( params.id ) if(!cart) { flash.message = "Cart not found with id ${params.id}" redirect(action:list) } else { return [ cart : cart ] } } def delete = { def cart = Cart.get( params.id ) if(cart) { cart.delete() flash.message = "Cart ${params.id} deleted" redirect(action:list) } else { flash.message = "Cart not found with id ${params.id}" redirect(action:list) } } def edit = { def cart = Cart.get( params.id ) if(!cart) { flash.message = "Cart not found with id ${params.id}" redirect(action:list) } else { return [ cart : cart ] } } def update = { def cart = Cart.get( params.id ) if(cart) { cart.properties = params if(!cart.hasErrors() && cart.save()) { flash.message = "Cart ${params.id} updated" redirect(action:show,id:cart.id) } else { render(view:edit,model:[cart:cart]) } } else { flash.message = "Cart not found with id ${params.id}" redirect(action:edit,id:params.id) } } def create = { def cart = new Cart() cart.properties = params return [cart:cart] } def save = { def cart = new Cart(params) if(!cart.hasErrors() && cart.save()) { flash.message = "Cart ${cart.id} created" redirect(action:cartBuy,id:params.id) } else { render(view:create,model:[cart:cart]) } } }Gabriel Bermúdez Merino 20
  21. 21. Programación de una tienda virtual en Grails 2. Antecedentes En este ejemplo, podemos ver los controladores básicos que se crean con el comando anterior, añadiendo además la opción de Scaffolding con la variable “scaffold”. Los controladores básicos son los de Creación, Actualización, Edición y Modificación, pero posteriormente se pueden ir añadiendo funcionalidades como el logging de usuarios, etc... Una vez el controlador ha procesado la petición, la delega a la vista apropiada. Para realizarlo Grails utiliza un mecanismo de convención, en el cuál el controlador delega la petición a la vista que tiene su mismo nombre, la cuál se encuentra almacenada en grails-app/views/name/ donde name es el nombre de la clase dominio. En dicha carpeta podemos encontrar la vista en formato JSP o GSP, ya que Grails admite ambos formatos. 5. Funcionalidad Grails incorpora un servidor de management con el que se puede ejecutar nuestra aplicación de Grails antes de importarla. Utilizando el comando especifico: $> grails run-app de compilación y ejecución con nuestra aplicación, el servidor inicia nuestra aplicación en la dirección http://localhost:8080/nameApp, donde “nameApp” es el nombre de nuestra aplicación Web. Posteriormente podemos exportar nuestra aplicación en un fichero war para importarlo en un Tomcat utilizando el comando: $> grails warDespués de esta breve introducción a Grails, realizaremos unaaplicación Web de ejemplo basada en una tienda virtual demascotas, donde profundizaremos más en los aspectos de Grailsademás de una comparación directa con la implementación de unaaplicación semblante en Java.2.3 ConclusiónDurante el desarrollo de este apartado hemos visto los problemasque tendremos que afrontar durante el desarrollo de proyecto,además de un pequeño estudio de las tecnologías que utilizaremospara el desarrollo de dicho proyecto. Los papeles de lasdiferentes tecnologías en nuestro proyecto son:Gabriel Bermúdez Merino 21
  22. 22. Programación de una tienda virtual en Grails 2. Antecedentes • Groovy: Lenguaje de programación base de Grails, con el que sin una pequeña práctica anterior al desarrollo del proyecto, no se habría podido realizar con soltura. • Grails: Framework Web que nos asiste en la creación de nuestra aplicación Web y además nos hace dicha tarea más amena y sencilla.Gabriel Bermúdez Merino 22
  23. 23. Programación de una tienda virtual en Grails 3. Análisis3. Análisis3.1 Descripción del problemaTenemos la necesidad de crear un portal de una tienda virtual demascotas, donde los visitantes de dicha página pueden ver losanimales que hay en stock, así como sus descripciones yposteriormente comprarlos si satisfacen sus necesidades previoregistro en la base de datos de la página.Además de la visión externa del portal y las actividades quepodemos realizar en ella, necesitamos poder gestionar tanto lospedidos como el stock de animales y el registro de usuarios,mediante unas actividades especiales para el administrador de lapágina.3.2 Descripción del productoEl portal que desarrollaremos utilizará como apoyo el frameworkWeb Grails. En dicho portal, el cliente navegará por la lista demascotas a la venta y se autenticará en la página, previoregistro, para poder gestionar la compra de las mascotas quedesee, además de poder editar sus datos de registro y realizarun seguimiento del estado de las compras que ha realizadopreviamente.El administrador del portal administrará la lista de usuarios,mascotas y carritos de la compra. La creación de nuevas entradasen las listas de usuarios, además de su edición, actualización yeliminación; y la gestión de los carritos de la compra de losclientes,, actualizando el estado de éstos según vayaevolucionando el pedido.3.3 Requisitos funcionalesEn este apartado definiremos los requisitos funcionales y laestructura fija de nuestro portal. En la siguiente figurapodemos ver los elementos básicos que tendrá nuestro portal.Gabriel Bermúdez Merino 23
  24. 24. Programación de una tienda virtual en Grails 3. Análisis3.3.1 BannerEl portal, como todo portal que se precie, tendrá un bannerestático en el que se mostrará su temática mediante una imagenfija con la que se pueda relacionar fácilmente con la rama decomercio a la que está dirigido el portal. Será una imagen fija,sin opciones ni funciones añadidas.3.3.2 Navigation BlocksTendremos dos bloques de navegación, el propio de navegación yel de contacto. • TOOLS NAVIGATION BLOCK En este bloque de navegación, se proporcionarán diferentes “atajos” a diferentes servicios del portal. Según el usuario que se encuentre activo en la sesión, las opciones del bloque de navegación variarán, ya que las opciones del administrador tienen que ser diferentes a la del usuario externo ya registrado o sin registrar. Las opciones que tendrá cada usuario serán: o ADMINISTRADOR Pets administration: Acceso a la lista de mascotas dadas de alta en la página, donde además se podrán dar de alta nuevas mascotas, editar o eliminar mascotas ya registradas. Carts administration: Acceso a la lista de carritos de la compra tanto activos como pendientes o finalizados. En dicha lista se podrán modificar los carritos o eliminarlos. Users administration: Acceso a la lista de usuarios dados de alta en la página, donde además se podrán dar de alta nuevos usuarios, editar o eliminar usuarios ya registrados. Search: Acceso a la búsqueda de mascotas. Log out: Salir de la sesión. o USUARIO NO REGISTRADO Pets: Acceso a la lista de mascotas en venta, donde se podrán comprar dichas mascotas previo registro/autenticación en el portal. Search: Acceso a la búsqueda de mascotas. Register: Acceso a la página de registro de usuarios. Log in: Acceso a la página de autenticación de usuarios ya registrados.Gabriel Bermúdez Merino 24
  25. 25. Programación de una tienda virtual en Grails 3. Análisis o USUARIO REGISTRADO Pets: Acceso a la lista de mascotas en venta, donde se podrán comprar dichas mascotas siguiendo unos pasos bien definidos. Profile: Acceso al perfil del usuario actual donde el usuario podrá modificar su información o eliminarse de la base de datos de la página. Cart: Acceso al carrito de compra activo, donde el usuario podrá eliminar las mascotas añadidas si no satisfacen sus necesidades, así como comprar dicho carrito. Search: Acceso a la búsqueda de mascotas. Log out: Salir de la sesión. • CONTACT NAVIGATION BLOCK En este bloque de navegación, se proporcionarán diferentes “atajos” a diferentes servicios del portal que se mantendrán estáticos para todos los usuarios. Los servicios a los que se proporcionan acceso son: o Contact: Proporciona una dirección de contacto física con la tienda, así como un plug-in de Google Maps con la situación de la tienda. o Information: Proporciona información sobre el portal.3.3.3 RenderSección dinámica de nuestro portal donde se visualizarán lasdiferentes páginas de servicios de nuestra aplicación Web. Segúnel usuario que haya activo se podrá visualizar un tipo deservicios u otros, ya que un usuario externo no podrá visualizarel mismo contenido que el administrador, por lo que serestringirán los accesos a dichos servicios mediante unainstrucción propia de Grails insertada en cada uno de los archivosde controladores de las diferentes clases de dominio. //Closure para controlar los accesos de los usuarios def beforeInterceptor = [action:this.&auth, except:[login, logout, show, create, update, delete, save]]3.4 Requisitos no funcionales • FACILIDAD DE USO Los accesos a los diferentes servicios del portal son sencillos e intuitivos.Gabriel Bermúdez Merino 25
  26. 26. Programación de una tienda virtual en Grails 3. Análisis • RENDIMIENTO El rendimiento de una aplicación Web depende en gran medida de la capacidad de la red del usuario, pero intentaremos disminuir la carga reduciendo el peso de los atributos a cargar de la aplicación Web. • INTERFICIE La interficie debe ser lo más amigable e intuitiva posible.3.5 Identificación de actores y objetivosEn la aplicación habrá tres actores diferentes, por lo que cadauno tendrá unos objetivos diferentes, pero también comparten unaserie de objetivos afines, dichos objetivos serán compartidos nopor todos los tipos de actores, sino por los más relevantes: elAdministrador y el Usuario Registrado. • OBJETIVOS ADMINISTRADOR o Alta de mascotas. o Alta de carritos. o Edición de mascotas. o Eliminación de mascotas. o Acceso a la lista de usuarios. o Acceso a la lista de carritos de la compra. • OBJETIVOS USUARIO REGISTRADO o Compra de mascotas. o Compra y finalización de carritos. o Eliminar mascotas del carrito. o Modificar el método de pago • OBJETIVOS USUARIO NO REGISTRADO o Log in • OBJETIVOS AFINES o Acceso a la lista de mascotas a la venta. o Acceso a la ficha de la mascota. o Acceso a la ficha del carrito de la compra. o Acceso a la ficha del usuario. o Alta de usuarios. o Edición de carritos. o Edición de usuarios. o Eliminación de carritos. o Eliminación de usuarios. o Búsqueda o Log outGabriel Bermúdez Merino 26
  27. 27. Programación de una tienda virtual en Grails 4. Diseño4. Diseño4.1 Casos de uso4.1.1 Objetivos afinesAcceso a la lista de mascotas a la ventaActor principal: Cualquier UsuarioPersonal involucrado e intereses: Usuario: se quiere visualizar el contenido de la lista de mascotas a la venta.Escenario principal de éxito: 1. El usuario quiere visualizar la lista de mascotas a la venta desde cualquier página. 2. El usuario clica en el botón de Pets/Pets Administration 3. Se carga la vista con la lista de mascotas a la venta.Extensiones: 3a. Si el usuario está autenticado, se carga la vista con la lista de mascotas a la venta junto con una visualización del carrito de la compra.Acceso a la ficha de la macotaActor principal: Usuario Registrado y AdministradorPersonal involucrado e intereses: Usuario Registrado y Administrador: se quiere visualizar la ficha de una mascota en concreto.Escenario principal de éxito: 1. El usuario quiere visualizar la ficha de una mascota en concreto desde la página de mascotas a la venta. 2. El usuario clica sobre el identificador de la mascota. 3. Se carga la vista con la ficha de la mascota correspondiente.Extensiones: 1a. El usuario quiere visualizar la ficha de una mascota en concreto desde el carrito de la compra. 2a. El usuario clica sobre el nombre de la mascota.Acceso a la ficha del carrito de la compraActor principal: Usuario Registrado y AdministradorPersonal involucrado e intereses: Usuario Registrado y Administrador: se quiere visualizar la ficha de un carrito de la compra en concreto.Escenario principal de éxito:Gabriel Bermúdez Merino 27
  28. 28. Programación de una tienda virtual en Grails 4. Diseño 1. El usuario quiere visualizar la ficha de un carrito de la compra desde cualquier página. 2. El usuario clica en el botón de Cart/Carts Administration 3. (Usuario) Se carga la vista con el carrito de la compra activo para ese usuario.Extensiones: 3a. (Administrador) Se carga la vista de la lista de carritos de la compra. 1. (Administrador) El usuario clica sobre el identificador del carrito. 2. (Administrador) Se carga la vista con el carrito de la compra activo para ese usuario.Acceso a la ficha del usuarioActor principal: Usuario Registrado y AdministradorPersonal involucrado e intereses: Usuario Registrado y Administrador: se quiere visualizar la ficha de un usuario en concreto.Escenario principal de éxito: 1. El usuario quiere visualizar la ficha del usuario desde cualquier página. 2. El usuario clica en el botón de Profile/Users Administration 3. (Usuario) Se carga la vista con la ficha del usuario actual.Extensiones: 3a. (Administrador) Se carga la vista de la lista de usuarios. 1. (Administrador) El usuario clica sobre el identificador del usuario. 2. (Administrador) Se carga la vista con la ficha del usuario.Edición de carritosActor principal: Usuario Registrado y AdministradorPersonal involucrado e intereses: Usuario Registrado y Administrador: se quiere editar la información de un carrito de la compra.Escenario principal de éxito: 1. El usuario modificará algún campo perteneciente al carrito de la compra. 2. El usuario clica en el botón de Cart/Carts Administration 3. (Usuario) Se carga la vista con la ficha carrito actual. 4. El usuario clica sobre el botón Edit.Gabriel Bermúdez Merino 28
  29. 29. Programación de una tienda virtual en Grails 4. Diseño 5. El usuario modifica los atributos que desee y salva los datos mediante el botón Save.Extensiones: 3a. (Administrador) Se carga la vista de la lista de carritos. 1. (Administrador) El usuario clica sobre el identificador del carrito. 2. (Administrador) Se carga la vista con la ficha del carrito. 3. (Administrador) Se continúa con el punto 4.Alta de usuariosActor principal: Usuario No Registrado y AdministradorPersonal involucrado e intereses: Usuario No Registrado y Administrador: se quiere dar de alta un nuevo usuario.Escenario principal de éxito: 1. El usuario dará de alta un nuevo usuario. 2. El usuario clica en el botón de Register/Users Administration 3. (Usuario) Se carga la vista con la ficha de registro. 4. El usuario rellena los campos necesarios y salva los datos mediante el botón Save.Extensiones: 3a. (Administrador) Se carga la vista de la lista de usuarios. 1. (Administrador) El usuario clica sobre el botón Create. 2. (Administrador) Se carga la vista con la ficha de registro. 3. (Administrador) Se continúa con el punto 4.Edición de usuariosActor principal: Usuario Registrado y AdministradorPersonal involucrado e intereses: Usuario Registrado y Administrador: se quiere editar la información de un usuario.Escenario principal de éxito: 1. El usuario modificará algún campo perteneciente al usuario. 2. El usuario clica en el botón de Profile/Users Administration 3. (Usuario) Se carga la vista con la ficha del usuario actual. 4. El usuario clica sobre el botón Edit.Gabriel Bermúdez Merino 29
  30. 30. Programación de una tienda virtual en Grails 4. Diseño 5. El usuario modifica los atributos que desee y salva los datos mediante el botón Save.Extensiones: 3a. (Administrador) Se carga la vista de la lista de usuarios. 1. (Administrador) El usuario clica sobre el identificador del usuario. 2. (Administrador) Se carga la vista con la ficha del usuario. 3. (Administrador) Se continúa con el punto 4.Eliminación de carritosActor principal: Usuario Registrado y AdministradorPersonal involucrado e intereses: Usuario Registrado y Administrador: se quiere eliminar un carrito de la compra.Escenario principal de éxito: 1. El usuario eliminará algún carrito de la compra. 2. El usuario clica en el botón de Cart/Carts Administration 3. (Usuario) Se carga la vista con la ficha carrito actual. 4. El usuario clica sobre el botón Delete y confirma la eliminación.Extensiones: 2a. (Usuario) El usuario clica en el botón Profile. 1. (Usuario) Clica en el identificador de carrito que quiere eliminar. 2. (Usuario) Se carga la vista con la ficha del carrito a eliminar. 3. (Usuario) Se continúa con el punto 4. 3a. (Administrador) Se carga la vista de la lista de carritos. 1. (Administrador) El usuario clica sobre el identificador del carrito. 2. (Administrador) Se carga la vista con la ficha del carrito a eliminar. 3. (Administrador) Se continúa con el punto 4.Eliminación de usuariosActor principal: Usuario Registrado y AdministradorPersonal involucrado e intereses: Usuario Registrado y Administrador: se quiere eliminar un usuario.Escenario principal de éxito: 1. El usuario eliminará algún usuario.Gabriel Bermúdez Merino 30
  31. 31. Programación de una tienda virtual en Grails 4. Diseño 2. El usuario clica en el botón de Profile/Users Administration 3. (Usuario) Se carga la vista con la ficha del usuario actual. 4. El usuario clica sobre el botón Delete y confirma la eliminación.Extensiones: 3a. (Administrador) Se carga la vista de la lista de usuarios. 1. (Administrador) El usuario clica sobre el identificador del usuario. 2. (Administrador) Se carga la vista con la ficha del usuario a eliminar. 3. (Administrador) Se continúa con el punto 4.BúsquedaActor principal: Cualquier UsuarioPersonal involucrado e intereses: Usuario: se quiere realizar una búsqueda de alguna mascota.Escenario principal de éxito: 1. El usuario eliminará realizará una búsqueda de alguna mascota. 2. El usuario clica en el botón de Search 3. Se carga la vista con la ficha de búsqueda. 4. El usuario rellena los campos necesarios para realizar la búsqueda. 5. Se carga la vista con los resultados de la búsqueda.Log outActor principal: Usuario Registrado y AdministradorPersonal involucrado e intereses: Usuario Registrado y Administrador: se quiere cerrar la sesión actual.Escenario principal de éxito: 1. El usuario cerrará la sesión actual. 2. El usuario clica en el botón de Log out 3. Se cierra la sesión y se carga la vista de la página de inicio.4.1.2 Objetivos AdministradorAlta de mascotasActor principal: AdministradorPersonal involucrado e intereses:Gabriel Bermúdez Merino 31
  32. 32. Programación de una tienda virtual en Grails 4. Diseño Administrador: se quiere dar de alta una nueva mascota en el sistema.Escenario principal de éxito: 1. El usuario quiere dar de alta una nueva mascota en el sistema. 2. El usuario clica en el botón de Pets Administration 3. Se carga la vista de la lista de mascotas. 4. El usuario clica el botón Create. 5. Se carga la vista con la plantilla de mascotas. 6. El usuario rellena los campos necesarios y guarda los cambios con el botón Save.Alta de carritos de la compraActor principal: AdministradorPersonal involucrado e intereses: Administrador: se quiere dar de alta un nuevo carrito en el sistema.Escenario principal de éxito: 1. El usuario quiere dar de alta un nuevo carrito en el sistema. 2. El usuario clica en el botón de Carts Administration 3. Se carga la vista de la lista de carritos. 4. El usuario clica el botón Create. 5. Se carga la vista con la plantilla de carritos. 6. El usuario rellena los campos necesarios y guarda los cambios con el botón Save.Edición de mascotasActor principal: AdministradorPersonal involucrado e intereses: Administrador: se quiere editar la ficha de una mascota en concreto.Escenario principal de éxito: 1. El usuario quiere editar la ficha de una mascota en concreto. 2. El usuario clica en el botón de Pets Administration 3. Se carga la vista de la lista de mascotas. 4. El usuario clica sobre el identificador de la mascota. 5. (Administrador) Se carga la vista con la ficha de la mascota. 6. El usuario clica sobre el botón Edit. 7. El usuario modifica los atributos que desee y salva los datos mediante el botón Save.Gabriel Bermúdez Merino 32
  33. 33. Programación de una tienda virtual en Grails 4. DiseñoEliminación de mascotasActor principal: AdministradorPersonal involucrado e intereses: Administrador: se quiere eliminar una mascota.Escenario principal de éxito: 1. El usuario eliminará alguna mascota. 2. El usuario clica en el botón de Pets Administration 3. Se carga la vista de la lista de mascotas. 4. El usuario clica sobre el identificador de la mascota. 5. Se carga la vista con la ficha de la mascota a eliminar. 6. El usuario clica sobre el botón Delete y confirma la eliminación.Acceso a la lista de usuariosActor principal: AdministradorPersonal involucrado e intereses: Administrador: se quiere acceder a la lista de usuarios.Escenario principal de éxito: 1. El usuario accederá a la lista de usuarios. 2. El usuario clica en el botón de Users Administration 3. Se carga la vista de la lista de usuarios.Acceso a la lista de carritos de la compraActor principal: AdministradorPersonal involucrado e intereses: Administrador: se quiere acceder a la lista de carritos de la compra.Escenario principal de éxito: 1. El usuario accederá a la lista de carritos de la compra. 2. El usuario clica en el botón de Carts Administration 3. Se carga la vista de la lista de carritos de la compra.4.1.3 Objetivos Usuario RegistradoCompra de mascotasActor principal: Usuario RegistradoPersonal involucrado e intereses: Usuario Registrado: se quiere realizar la compra de una mascota.Gabriel Bermúdez Merino 33
  34. 34. Programación de una tienda virtual en Grails 4. DiseñoEscenario principal de éxito: 1. El usuario quiere realizar la compra de una mascota. 2. El usuario clica en el botón de Pets. 3. Se carga la vista de la lista de mascotas a la venta. 4. El usuario clica el botón Buy it!. 5. Se carga la vista con el carrito actual y la mascota añadida.Compra y finalización de carritosActor principal: Usuario RegistradoPersonal involucrado e intereses: Usuario Registrado: se quiere realizar la compra y finalización de un carrito.Escenario principal de éxito: 1. El usuario quiere realizar la compra y finalización de un carrito. 2. El usuario clica en el botón de Cart. 3. Se carga la vista con el carrito actual. 4. El usuario clica el botón Buy Cart. 5. Se carga la vista con la factura de la compra.Extensiones: 6a. El usuario clica el botón Edit para modificar el método de pago. 1. El usuario modifica el método de pago. 2. El usuario salva los datos con el botón Save. 3. Se continúa con el punto 5.Eliminar mascotas del carritoActor principal: Usuario RegistradoPersonal involucrado e intereses: Usuario Registrado: se quiere eliminar una mascota añadida del carrito de la compra.Escenario principal de éxito: 1. El usuario quiere eliminar una mascota añadida del carrito de la compra. 2. El usuario clica en el botón de Cart. 3. Se carga la vista con el carrito actual. 4. El usuario clica el botón de eliminación que hay al lado de cada mascota añadida. 5. Se vuelve al paso 3.Modificar el método de pagoActor principal: Usuario RegistradoPersonal involucrado e intereses:Gabriel Bermúdez Merino 34
  35. 35. Programación de una tienda virtual en Grails 4. Diseño Usuario Registrado: se quiere modificar el método de pago.Escenario principal de éxito: 1. El usuario quiere modificar el método de pago. 2. El usuario clica en el botón de Cart. 3. Se carga la vista con el carrito actual. 4. El usuario clica el botón Edit para modificar el método de pago. 5. El usuario modifica el método de pago. 6. El usuario salva los datos con el botón Save.4.1.4 Objetivos Usuario No RegistradoLog inActor principal: Usuario No RegistradoPersonal involucrado e intereses: Usuario No Registrado: se quiere iniciar una nueva sesión.Escenario principal de éxito: 1. El usuario quiere iniciar una nueva sesión. 2. El usuario clica en el botón de Log in. 3. Se carga la vista de autenticación. 4. El usuario rellena los campos e inicia la sesión.4.2 DiagramasSiguiendo el modelo Vista-Controlador en que está basado Grailsel cuál simplifica el desarrollo de aplicaciones Web mediante lareducción de archivos de configuración y generandoautomáticamente la mayoría de elementos necesarios por unaaplicación Web sobre una base de datosGabriel Bermúdez Merino 35
  36. 36. Programación de una tienda virtual en Grails 4. Diseñorealizaremos el diseño del diagrama de clases de nuestraaplicación. El hecho de que se trate de una aplicación Web, parauna comprensión más sencilla, proporcionaremos un diagrama dedominio de las clases, el modelo Vista-Controlador mencionadoanteriormente y un mapa de portal el cuál nos informará sobre lanavegación dentro del portal.4.2.1 Diagrama de dominioEl diagrama de dominio de nuestra aplicación Web, nos ayudará ala comprensión de la configuración de la base de datos denuestra aplicación y nos dará una idea de la estructuración denuestro portal. PET N USER 1 N CART NComo podemos observar, tendremos 3 clases principalesrelacionadas entre sí, las cuáles serán la base de la estructurade la base de datos y de la aplicación Web.4.2.2 Modelo Vista-ControladorEn nuestra aplicación, el Controlador recoge las peticionesrealizadas por el servidor, posteriormente genera los datosnecesarios y la vista que se mostrará en el Render del navegadordel usuario. Realizaremos tres modelos de Vista-Controlador, unopor cada Clase de dominio.4.2.2.1 Vista-Controlador UserEl usuario realiza una acción en el VIEWportal, el cuál envía una petición alcontrolador, el cuál genera la vista dela respuesta a la petición del usuario. PETLos controladores que generan lasvistas para el usuario son los básicosdel CRUD a los cuáles añadimos losrealizados para la gestión de otraspeticiones. CONTROLLERGabriel Bermúdez Merino 36
  37. 37. Programación de una tienda virtual en Grails 4. DiseñoLos controladores que generan las vistas para el usuario son losbásicos del CRUD a los cuáles añadimos los realizados para lagestión de otras peticiones. • Login: Controlador que comprueba que el usuario introducido y la contraseña corresponden a los almacenados en la base de datos, y si coincide, se almacena en la variable de sesión para la gestión de usuarios en los demás servicios de los portales. • Logout: Controlador que cierra la sesión del usuario activo y redirige el portal a la página de inicio por defecto.4.2.2.2 Vista-Controlador PetEl usuario realiza una petición en un VIEWelemento perteneciente a la clase dedominio de las mascotas que esgestionada por los controladores dedicha clase de dominio generando los USERelementos de la vista que serenderizará.Los controladores que generan las CONTROLLERvistas para la petición del usuario enel elemento de mascotas, son losbásicos del CRUD a los cuáles añadimos los realizados para lagestión de otras peticiones. • Upload_image: Controlador que gestiona el almacenamiento de la imagen correspondiente a la mascota que se crea o edita. • Image_link: Controlador que crea el link con la imagen correspondiente a la mascota actual. • Search: Controlador que gestiona la búsqueda de mascotas siguiendo un tipo de búsqueda establecido por el usuario.4.2.2.3 Vista-Controlador CartEl usuario realiza una petición en unelemento perteneciente a la clase de VIEWdominio del carrito que es gestionadapor los controladores de dicha clase dedominio generando los elementos de lavista que se renderizará. CARTLos controladores que generan lasvistas para la petición del usuario enel elemento del carrito, son los CONTROLLERbásicos del CRUD a los cuáles añadimosGabriel Bermúdez Merino 37
  38. 38. Programación de una tienda virtual en Grails 4. Diseño los realizados para la gestión de otras peticiones. • CartBuy: Controlador que gestiona la compra de las mascotas añadiéndolas al carrito activo. • EndCart: Controlador que gestiona la compra del carrito estableciendo el método de pago que utilizará el usuario. • DelOfCart: Controlador que muestra el estado final del carrito una vez confirmada la compra del mismo. 4.2.3 Site Maps Los Site Maps de nuestra aplicación Web, nos proporcionan información sobre la navegación entre las diferentes páginas Home Page Admin login Pets list Search Carts List Users LogoutDelete Update Show Pet Search Result Status Update Delete Show User Update Delete Gabriel Bermúdez Merino 38
  39. 39. Programación de una tienda virtual en Grails 4. Diseño Home Page User login Profile Pets list sale Search Cart Logout Update Delete Buy Pet Show Pet Search Result Buy cart Update Delete Pay Mode ConfirmTodos los objetos mostrados en los Site Maps están representadospor controladores de las diferentes clases los cuáles seexplicarán en el apartado de Implementación.Gabriel Bermúdez Merino 39
  40. 40. Programación de una tienda virtual en Grails 5. Implementación5. Implementación y pruebas5.1 Entorno de desarrolloAsí como en el apartado de análisis hemos realizado unavaloración inicial antes de implementar el código, en esteapartado realizaremos un balance de algunas herramientasutilizadas para la implementación del proyecto.5.1.1 GNU/LinuxEl sistema operativo escogido para programar la aplicación esGNU/Linux. Se ha escogido este sistema porque ofrece un entornode programación más amigable para el desarrollador además de serde libre distribución. Grails, como Java, ofrece unacompatibilidad con cualquier sistema operativo, lo que hace queel sistema operativo en que se haya desarrollado no searelevante.5.1.2 GEditEl editor de texto por defecto del entorno Gnome de GNU/Linux,que ofrece la posibilidad de inclusión de diferentes plugins quehacen más sencillo el desarrollo de aplicaciones en cualquierlenguaje de programación.5.1.3 Mozilla Firefox 2.14Firefox ha sido el navegador elegido para realizar las pruebasde nuestra aplicación Web, aunque como con el sistema operativo,la implementación final no establece un navegador por defecto,por lo que el navegador Web tampoco es relevante.5.1.4 GroovyComo ya he comentado varias veces durante la memoria, miconocimiento sobre este lenguaje de programación era nulo antesdel inicio de este proyecto, por este motivo y al ser una de laspartes fundamentales del proyecto, este lenguaje de Scriptingdispone de su propio apartado en esta memoria. La compatibilidaden los sistemas operativos es muy alta, ya que tanto Mac,Unix/Linux como Windows son compatibles con este lenguajeimportando sus librerías.5.1.5 GrailsAl igual que Groovy, el framework Web Grails tambien dispone deun apartado propio en la memoria debido a su relevancia en esteproyecto. La compatibilidad en los sistemas operativos es muyalta, ya que tanto Mac, Unix/Linux como Windows son compatiblescon este lenguaje importando sus librerías.Gabriel Bermúdez Merino 40
  41. 41. Programación de una tienda virtual en Grails 5. Implementación5.2 Seguimiento y problemáticasEn este apartado realizaremos un seguimiento a la implementaciónde nuestra aplicación Web, durante el cuál también iremosdescubriendo las diferentes problemáticas con las que nos hemosencontrado durante dicha implementación.5.2.1 Estructura y persistenciaEl primer paso de una implementación en Grails es establecer laestructura de nuestro proyecto, para ello, Grails, aporta uncomando especial que nos asiste en la construcción de laestructura de nuestro proyecto.Creamos una carpeta en cualquier directorio de nuestro sistemaoperativo, e introducimos el siguiente comando de Grails: $> grails create-app projectNamecon este comando creamos la estructura de nuestro proyecto quequedará dividido en diferentes carpetas distribuidas según lafuncionalidad que tienen dentro del proyecto.Una vez ya hemos establecido la estructura del proyectoconfiguramos la persistencia de datos mediante la creación deuna base de datos (en nuestro caso MySQL) y posteriorconfiguración en nuestro proyecto de dicha BBDD. Para ellodescargamos el driver de la BBDD que queremos utilizar para lapersistencia de datos y lo almacenamos en la carpeta …/lib.Posteriormente configuramos el fichero …/grails-app/conf/ApplicationDataSource.groovy en el cuál estructuramosel fichero según las diferentes BBDD que se utilizaran para losdiferentes estados de creación de la aplicación Web. dataSource { pooled = false driverClassName = "com.mysql.jdbc.Driver" username = "root" password = "" } … environments { development { dataSource { dbCreate = "update" // one of create, create- drop,update url = "jdbc:mysql://localhost/petStore_dev" } } test { dataSource { dbCreate = "update" url = "jdbc:mysql://localhost/petStore_test" } } production { dataSource { dbCreate = "update" url = "jdbc:mysql://localhost/petStore_prod;shutdown=true" } } }Gabriel Bermúdez Merino 41
  42. 42. Programación de una tienda virtual en Grails 5. ImplementaciónComo podemos observar configuramos el fichero con el driver quehemos descargado, con su usuario y password, además del path decada BBDD que vamos a utilizar durante el desarrollo delproyecto.A continuación creamos las clases de dominio más relevantes denuestro proyecto utilizando un comando de Grails, las cualesposteriormente también se utilizará su estructura en la BBDD.Para la creación de estas clases seguiremos el diagrama dedominio del apartado de diseño. PET N USER 1 N CART NCreamos la clase de dominio mediante el comando de Grails yposteriormente rellenamos las clases con los atributos, lasconstraints y las relaciones entre las clases. $> grails create-domain-class pet import grails.util.GrailsUtil import org.springframework.web.multipart.MultipartFile import org.codehaus.groovy.grails.commons.ConfigurationHolder class Pet { String name String type String description Float price byte[] image static hasMany = [carts:Cart] static belongsTo = Cart static constraints = { name(maxLength:50, blank:false) type(inList:[Bird,Cat, Dog, Fish, Ferret, Rodent], blank:false) description() price(min:0f) image(nullable:true, maxSize:65536) /* 64K */ } static mapping = { description type: text } }Gabriel Bermúdez Merino 42
  43. 43. Programación de una tienda virtual en Grails 5. Implementación $> grails create-domain-class cart class Cart { String status String payment String numberTarget Float total Map contentBuy=[1 : 1] static hasMany = [pets:Pet] static belongsTo = [user:User] static constraints = { payment(inList:[Card,Against reimbursement]) status(inList:[In process, Pending, Completed]) total(min:0f) } } $> grails create-domain-class user class User { String name String firstName String lastName String NIF String postalAddress String emailAddress String userId String password static hasMany = [carts:Cart] static constraints = { userId(length:5..8, unique:true) password(length:6..8) name(blank:false) firstName(blank:false) lastName(blank:false) NIF(length:9,unique:true) postalAddress(maxLength:255,blank:true) emailAddress(maxLength:50,blank:false,email:true) } }Para finalizar este punto, establecemos la estructura de la BBDDmediante otro comando de Grails, el cuál inicia la aplicaciónWeb a la vez que crea la estructura de la aplicación en la BBDD. $> grails run-appGabriel Bermúdez Merino 43
  44. 44. Programación de una tienda virtual en Grails 5. Implementación5.2.2 Controladores y vistasUna vez configurada la estructura de la aplicación, sus clasesde dominio y la Base de Datos, necesitamos configurar loscontroladores de las clases y sus respectivas vistas mediantecomandos de Grails y la posterior personalización editando losficheros que se crearán. $> grails generate-all classNameMediante este comando de Grails se generan los controladores ylas vistas básicos para realizar tareas CRUD. Posteriormente loseditaremos para añadir funcionalidades a los controladores ycrearemos sus respectivas vistas.A continuación veremos las funcionalidades añadidas a loscontroladores y las ventajas que ha supuesto su implementaciónen Groovy y el uso de gsp’s para las vistas.5.2.2.1 ControladoresBase ControllerBase Controller es un pequeño controlador del cuál extiendentodos los Controladores que proporciona un chequeo continuo delos accesos a los controladote, comprobando que el usuario estaautentificado y compara los permisos con de acceso con losestablecidos en cada controlador. abstract class BaseController{ def auth(){ if(!session.userId){ redirect(controller:user, action:login) return false } } }PetsComo veremos a continuación, en el controlador de mascotas (Pet)añadiremos las funciones de Cargar imágenes y Búsqueda, ademásde los permisos de acceso a los controladores y la variable deScaffolding. Cargar imágenes nos proporciona la posibilidad desubir imágenes para añadirlas al perfil de las mascotas yBúsqueda nos proporciona el servicio de realizar búsquedas entrela lista de mascotas a la venta.Permisos de acceso y Scaffolding … def scaffold = Pet //Closure para controlar los accesos de los usuarios def beforeInterceptor = [action:this.&auth, except:[show, list]] …Gabriel Bermúdez Merino 44
  45. 45. Programación de una tienda virtual en Grails 5. Implementación Como podemos observar, la restricción es para cualquier acción excepto para show y list.Cargar imágenes … def upload_image = { def pet = Pet.current(session) // Obtenemos el fichero de la imagen del request multi-parte def f = request.getFile(image) // Listado de las extensiones permitidas def okcontents = [image/png, image/jpeg, image/gif] if(! okcontents.contains(f.getContentType())){ flash.message = "La imagen debe tener la extensión: ${okcontents}" render(view:create, model:[pet:pet]) return; } // Guardamos la imagen y su extension pet.image = f.getBytes() log.info("Imagen subida") // Validamos el trabajo, comprobamos que la imagen no sea muy grande if(!pet.save()){ render(view:create, model:[pet:pet]) return; } flash.message = "Imagen subida correctamente." // redirect(action:show) } def image_link = { def imagePet = Pet.get(params.id) if(!imagePet || !imagePet.image){ response.sendError(404) return; } OutputStream out = response.getOutputStream(); out.write(imagePet.image); out.close(); } … Como podemos observar, la problemática más grande que ha tenido este servicio del controlador ha sido la configuración de los contenidos aceptados y el almacenaje de la imagen subida mediante la distribución de las referencias entre la base de datos y el objeto subido.Búsqueda … def search = { if(request.method == POST){ def auxName = params.name def auxType = params.type params.name = null params.type = null PetQuery query = new PetQuery() bindData(query, params) /*if(auxName != null){ if(auxType != null){ render(view:list, model:[petList:Pet.findAllByNameLikeAndTypeLike(% + auxName + %, % + auxType + %)])Gabriel Bermúdez Merino 45
  46. 46. Programación de una tienda virtual en Grails 5. Implementación }else{ render(view:list, model:[petList: Pet.findAllByNameLike(% + auxName + %)]) } }else{ render(view:list, model:[petList: Pet.findAllByTypeLike(% + params.type + %)]) }*/ def criteria = Pet.createCriteria() def results = criteria { and { like(name, % + auxName + %) like(type, % + auxType + %) if(query.price) { switch (query.priceOperator) { case PetQuery.PriceOperator.AT_LEAST: ge(price, query.price) break case PetQuery.PriceOperator.EXACTLY: eq(price, query.price) break case PetQuery.PriceOperator.AT_MOST: le(price, query.price) break default: log.error "Found unexpected value for price" + "operator - ${query.priceOperator}" } } } } render(view:list, model:[raceList:results]) } } … Para la implementación de este controlador, se han realizado dos pasos previos: • Creación de una clase Java llamada PetQuery, que únicamente está formada por la definición de los atributos que se van a utilizar en las consultas y sus respectivos métodos getter y setter. • Uso de una clase propia de Grails, criteria, que nos proporciona un sistema de búsqueda más sencillo y eficaz. Una vez realizados estos dos pasos previos, se han configurado las llamadas a dicha clase Java y a criteria, y los parámetros de búsqueda que se quieran utilizar mediante diferentes condicionales, y finalmente retornando el resultado de dicha búsqueda.CartComo veremos a continuación, en el controlador de carritos(Cart) añadiremos las funciones de Compras del carrito,Eliminación del carrito y Finalización del carrito, además delos permisos de acceso a los controladores y la variable deScaffolding. Compras del carrito nos proporciona una vista delcontenido del carrito así como la posibilidad de añadir oGabriel Bermúdez Merino 46
  47. 47. Programación de una tienda virtual en Grails 5. Implementacióneliminar mascotas a dicho carrito, Eliminación del carrito nosproporciona la posibilidad de eliminar mascotas añadidas alcarrito y Finalización de carrito, como su propio nombre indica,nos da la posibilidad de finalizar la compra proporcionándonosuna “factura electrónica” del pedido.Permisos de acceso y Scaffolding … def scaffold = Cart //Closure para controlar los accesos de los usuarios def beforeInterceptor = [action:this.&auth] … Como podemos observar, la restricción es para cualquier acción.Compras del carrito … def cartBuy = { def user = User.findByUserId(session.userId); params.petId = params.id def cart = null; def value = null if(user.name == default){ redirect(controller:user, action:login) } def findCart = { if(it.status ==~ In process){ cart = it } } user.carts.each(findCart); if(cart == null){ //redirect(action:create) params.status=In process params.payment=Against reimbursement params.numberTarget= params.total=0.0 params.user=user save() if(params.petId == null) redirect(controller:pet, action:listPetsSale) } if(params.id != null){ def pet = Pet.findById(params.petId) if(pet != null){ if(cart.contentBuy.containsKey(pet.id)){ value = cart.contentBuy.get(pet.id) cart.contentBuy.put(pet.id, value+1) }else{ cart.pets.add(pet) cart.contentBuy.put(pet.id, 1) } cart.total += pet.price } } params.petId = null return [ cart : cart ] } …Gabriel Bermúdez Merino 47

×