CESED - CENTRO DE ENSINO SUPERIOR E DESENVOLVIMENTO FACISA - FACULDADE DE CINCIAS SOCIAIS APLICADAS CURSO DE BACHARELADO EM SISTEMAS DE INFORMAO

RENAN RIBEIRO BARBOZA ALBUQUERQUE

DESENVOLVENDO APLICAES GEIS E DINMICAS COM GROOVY E GRAILS

CAMPINA GRANDE - PB 2011

RENAN RIBEIRO BARBOZA ALBUQUERQUE

DESENVOLVENDO APLICAES GEIS E DINMICAS COM GROOVY E GRAILS

Trabalho de concluso de curso apresentado como pr-requisito para a obteno do ttulo Bacharel em Sistemas de Informao pela Faculdade de Cincias Sociais Aplicadas. rea de Concentrao: Desenvolvimento de sistemas web. Orientador: Bruno de Brito Leite.

Campina Grande - PB 2011

Trabalho de concluso de curso, Desenvolvendo aplicaes geis e dinmicas com Groovy e Grails, apresentado por Renan Ribeiro Barboza Albuquerque como parte dos requisitos para obteno do ttulo de Bacharel em Sistemas de Informao outorgado pela Faculdade de Cincias Sociais Aplicadas de Campina Grande PB. APROVADO EM: _____/ _____/ _____ BANCA EXAMINADORA: _________________________________ Prof. da FACISA Bruno de Brito Leite Orientador

1 Membro da Banca

2 Membro da Banca

AGRADECIMENTOS

Agradeo a Deus por ter me dado o dom da vida e foras para superar as dificuldades impostas durante todo o curso. Aos meus pais, pela grande contribuio na minha formao intelectual, moral e tica e que sempre me incentivaram para lutar pelos meus ideais. A minha querida av e irm pelo amor, carinho, dedicao e apoio que sempre me deram. Aos professores e coordenadores do curso de Sistemas de Informao pelo incentivo constante no decorrer de todo esse tempo de estudo, em especial, ao professor Bruno de Brito Leite, orientador da presente dissertao, pelo crdito, compreenso, pacincia e apoio que me deu durante sua realizao e ao professor Bruno Gama Cato que muito contribuiu para o meu crescimento intelectual, abrindo meu campo de viso para novos horizontes. A todos os meus parentes e amigos.

A experincia dos erros to importante quanto experincia dos acertos, porque vistos de um jeito certo, os erros nos preparam para as nossas vitrias e conquistas futuras, porque no h aprendizado na vida que no passe pela experincia dos erros. Pe. Fbio de Melo

RESUMO

A plataforma Java EE vem sendo criticada por muitos desenvolvedores, pela sua complexidade em relao ao seu desenvolvimento na web. Visando suprir estas complexidades, surgem diversas linguagens de programao com prticas em metodologias geis e dinmicas. Estas prticas alm de beneficiar na qualidade do desenvolvimento e manuteno de sistemas web, poupa o desenvolvedor, entre outras coisas, do trabalho repetitivo e tempo de desenvolvimento. Nesse contexto, o presente trabalho tem como objetivo apresentar para o leitor duas tecnologias: a linguagem de programao Groovy e um framework de alta produtividade fullstack Grails, que seguem esta tendncia de desenvolvimento de sistemas voltado para a web e tambm, por em prtica todo o contedo visto, atravs de um estudo de caso, mostrando as vantagens de se trabalhar com elas. O trabalho foi realizado atravs de pesquisa bibliogrfica, no qual foi baseado em consultas literrias e artigos cientficos, seguido de um estudo de caso, no qual foi possvel desenvolver uma aplicao, vivenciando as prticas que estas tecnologias proporcionam, onde percebe-se claramente, que os recursos e ferramentas que compe o Grails integrados a linguagem dinmica Groovy, tornam o cotidiano dos desenvolvedores mais prtico e produtivo no que diz respeito ao desenvolvimento de projetos corporativos. PALAVRAS-CHAVE: Groovy, framework Grails, sistemas web.

ABSTRACT

The Java EE platform has been criticized by many developers because of its complexity in relation to its development on the web. Aiming to overcome these complexities, there are several programming languages with practices in agile and dynamic. These practices also benefit the quality of development and maintenance of web systems, saves the developer, among other things, repetitive work and development time. In this context, this paper aims to introduce the reader to two technologies: the Groovy programming language and a framework of high productivity fullstack Grails, following this development trend of web-facing systems and also because in practice all the content seen through a case study showing the benefits of working with them. The study was conducted through literature search, which was based on consultations literary and scientific articles, followed by a case study in which it was possible to develop an application, experiencing the practices that these technologies offer, where it is clear that the resources and tools that comprise the integrated Grails Groovy dynamic language, make the daily life of the developers more practical and productive with regard to the development of corporate projects. KEYWORDS: Groovy, Grails framework, web systems.

LISTA DE ABREVIATURAS E SIGLAS

API COC CSS DRY EJB EL GANT GDK GDT GLS GORM GSP IDE JAR JAVA SE Java EE JCP JDK JDBC JEE JPA JRE JSP JSR JVM HTML MVC MOP MOR ORM

Application Programming Interface Convention Over Configuration Cascading Style Sheets Don't Repeat Yourself Enterprise JavaBeans Expression Language Groovy Ant Groovy Development Kit Groovy Developer Tools Groovy Language Specification Groovy Object Relational Mapping Groovy Server Pages Integrated Development Environment Java Archive Java Standard Edition Java Enterprise Edition Java Community Process Java Development Kit Java Database Connectivity Java Enterprise Edition Java Persistence API Java Runtime Environment Java Server Page Java Specification Request Java Virtual Machine HyperText Markup Language Model-View-Controller Meta-Object Protocol Mapeamento Objeto-Relacional Object-Relational Mapping

PDF POGO POJO SDK STS TCK TI URL XML

Portable Document Format Plain Old Groovy Object Plain Old Java Object Software Development Kit SpringSource Tool Suite Test Compatible Kit Tecnologia da Informao Uniform Resource Locator Extensible Markup Language

LISTA DE TABELAS

Tabela 1 - Operadores do Groovy ......................................................................................................31 Tabela 2 - Operadores relacionais do Groovy ....................................................................................31 Tabela 3- Tipos de dados no Groovy ..................................................................................................33 Tabela 4 - Actions default do Grails ...................................................................................................43 Tabela 5- Arquivos de configurao do banco de dados ....................................................................66

LISTA DE FIGURAS

Figura 1 - Tela do Prompt de Comando, executando o console Groovy ..............................................22 Figura 2 - GroovyConsole, executando o exemplo Alo,Groovy! ..........................................................23 Figura 3 - Tela do Prompt de Comando, verificando a configurao do Groovy ..................................35 Figura 4 - Estrutura de diretrios do Grails ........................................................................................39 Figura 5 - Arquitetura Grails ..............................................................................................................47 Figura 6 - Configurando a varivel de ambiento do Grails ..................................................................49 Figura 7 - Tela do Prompt de Comando, verificando a configurao do Grails ....................................50 Figura 8 - Tela principal do sistema ...................................................................................................52 Figura 9 - Caso de uso do sistema......................................................................................................53 Figura 10 - Diagrama de Classe ..........................................................................................................55 Figura 11 - Estrutura de diretrios da Aplicao ................................................................................57 Figura 12 - Classes Groovy dentro do diretrio domain na Aplicao .................................................58 Figura 13 - Controladores da Aplicao .............................................................................................59 Figura 14 - Aplicao sendo executada no terminal. ..........................................................................60 Figura 15 - Pgina inicial da aplicao. ...............................................................................................61 Figura 16 - Listagem de clientes cadastrados .....................................................................................61 Figura 17 - Tela de cadastro de um cliente ........................................................................................62 Figura 18 - Mapeamento de URL no Grails ........................................................................................62 Figura 19 - Arquivos de configurao do banco de dados ..................................................................65 Figura 20 - Views da Aplicao ..........................................................................................................68 Figura 21 - Abrindo o prompt de commando do Grails ......................................................................69 Figura 22 - Comando grails generate-all makeup.erp.Cliente.............................................................69 Figura 23 - Layout do Index.gsp .........................................................................................................71 Figura 24 - Pgina principal com o usurio logado .............................................................................76 Figura 25 - Tela de login ....................................................................................................................77 Figura 26 - Campo de busca ..............................................................................................................79

Figura 27 - Criando o relatrio de clientes no iReport ........................................................................80 Figura 28 - Diretrio reports ..............................................................................................................81 Figura 29 - Boto do relatrio ...........................................................................................................81 Figura 30 - Botes internacionalizados para pt_BR ............................................................................83 Figura 31 - Arquivo war. gerado dentro do diretrio target ...............................................................84 Figura 32 - Configuraes bsicas do Tomcat ....................................................................................92 Figura 33 - Configurando a varivel de ambiento do Tomcat .............................................................93 Figura 34 - Tela de abertura do SpringSource Tool Suite ....................................................................94 Figura 35 - Dashboard do SpringSource Tool Suite .............................................................................95 Figura 36 - Configurando o Grails na Dashboard................................................................................95

Sumrio

1 2 2.1 2.1.1 2.1.2 2.1.3 2.1.4

INTRODUO ............................................................................................. 16 FUNDAMENTAO TERICA ................................................................... 18 LINGUAGEM GROOVY ............................................................................... 18 Histrico ...................................................................................................... 18 Introduo linguagem Groovy................................................................ 20 Groovy: Uma linguagem de Scripting e Dinmica................................... 24 Elementos bsico do Groovy ................................................................... 25

2.1.4.1 Trabalhando com Strings .......................................................................... 25 2.1.4.2 Mtodos e Closures ................................................................................... 26 2.1.4.3 Intervalos, Lista e Mapas (Hashes) .......................................................... 27 2.1.4.4 Expresses Regulares ............................................................................... 29 2.1.4.5 Operadores ................................................................................................. 30 2.1.4.6 Tipos de dados ........................................................................................... 32 2.1.4.7 Groovy Beans ............................................................................................. 33 2.1.3 2.2 2.2.1 2.2.2 2.2.3 2.2.4 Instalando o Groovy ................................................................................... 34 FRAMEWORK GRAILS ................................................................................ 35 Histrico ...................................................................................................... 36 Introduo ao Grails................................................................................... 37 Grails e sua estrutura................................................................................. 38 Recursos do Grails..................................................................................... 41

2.2.4.1 Conveno sobre configurao ................................................................ 41 2.2.4.2 Testes Unitrios.......................................................................................... 42 2.2.4.3 Scaffolding .................................................................................................. 42 2.2.4.4 Mapeamento Objeto Relacional ................................................................ 43 2.2.4.5 Plugins ........................................................................................................ 44

2.2.5

Frameworks Integrados ............................................................................. 44

2.2.5.1 Spring Framework ...................................................................................... 44 2.2.5.2 Hibernate ..................................................................................................... 45 2.2.5.3 SiteMesh ...................................................................................................... 45 2.2.5.4 Ajax Framework .......................................................................................... 45 2.2.5.5 Jetty ............................................................................................................. 46 2.2.5.6 HSQLDB ...................................................................................................... 46 2.2.5.7 JUnit ............................................................................................................ 47 2.2.6 2.2.7 2.2.3 3 3.1 3.2 3.3 3.3.1 3.3.2 3.3.3 3.3.4 3.3.5 3.3.6 3.3.7 3.3.8 3.3.9 Arquitetura Grails ....................................................................................... 47 Mapeamento Objeto Relacional ................................................................ 48 Instalando o Grails ..................................................................................... 49 ESTUDO DE CASO ..................................................................................... 51 DESCRIO DO SISTEMA ......................................................................... 51 ANLISE DE REQUISITOS ......................................................................... 52 CRIANDO A APLICAO ............................................................................ 55 Criando o Projeto ....................................................................................... 56 Criando classes de domnio ...................................................................... 57 Criando os controllers(Controladores) .................................................... 59 Executando o Projeto................................................................................. 60 Validao..................................................................................................... 63 Criando o banco de dados......................................................................... 64 Configurando o Banco de dados .............................................................. 65 Personalizando a aplicao....................................................................... 68 Adicionando segurana na aplicao ...................................................... 73

3.3.10 Adicionando uma busca ............................................................................ 77 3.3.11 Internacionalizao .................................................................................... 82 3.3.12 Deploy ......................................................................................................... 84

4 5 5.1 5.2

METODOLOGIA .......................................................................................... 85 CONSIDERAES FINAIS ......................................................................... 86 TRABALHOS RELACIONADOS .................................................................. 87 TRABALHOS FUTUROS ............................................................................. 88

REFERNCIAS ......................................................................................................... 89 APENDICE ................................................................................................................ 91 A.1 JAVA DEVELOPMENT KIT (JDK) ...................................................................... 91 A.2 SERVIDOR APACHE TOMCAT.......................................................................... 91 A.3 SPRING SOURCE TOOL SUITE 2.5.2.SR1 ....................................................... 93 A.4 MYSQL SERVER 5.5 .......................................................................................... 96 ANEXOS ................................................................................................................... 98

16

1 INTRODUO

Com a crescente disponibilidade de recursos que a Internet oferece aos seus usurios, as aplicaes na web tornam-se mais atrativas. O desenvolvimento de aplicaes web utilizando a plataforma Java EE tem crescido nos ltimos anos e proporcionado novos frameworks e bibliotecas. A plataforma Java possui uma arquitetura para aplicaes web bastante rica, porm muito complexa, por tentar atender a diferentes situaes e propsitos. Essa complexidade, somadas a diversas opes de frameworks, trazem alguns problemas plataforma Java, tornando-a pouco produtiva comparada a outras tecnologias web. Pode-se perceber na prtica alguns problemas, como perda no tempo para configurar uma aplicao, incompatibilidade de alguns frameworks entre si devido as suas verses, exaustivas repeties em criaes de CRUDs, configurao de logs, internacionalizao, acesso aos dados, relatrios, etc. Logo, os desenvolvedores Java nunca conseguiram um nvel de produtividade exigido pelos princpios e prticas geis. Esta falta de agilidade fez com que linguagens dinmicas como Ruby e Python crescessem e tivessem cada vez mais adeptos, dentre os quais se destacavam os que seguem as metodologias geis (JUDD; NUSAIRAT; SHINGLER, 2008). Com o intuito de suprir estas deficincias surgiu o Groovy, uma linguagem de programao estvel, rica de recursos que manteve a compatibilidade com a API existente no Java, que busca o que faltava para a plataforma: flexibilidade e produtividade. Neste trabalho sero apresentados uma linguagem de desenvolvimento e um framework para implementaes de um sistema em metodologias geis. A linguagem Groovy, que uma linguagem de script e dinmica, construda sobre o fundamento slido da plataforma Java, vem ganhando notoriedade para o desenvolvimento web, devido ao seu alto grau de produtividade. O Grails um framework que surgiu com o intuito de criar software de forma gil e dinmica, dando ao desenvolvedor mais simplicidade, flexibilidade, poder e robustez tecnolgica, aumentando a produtividade de codificao. Para ilustrar os conceitos apresentados, ao final deste trabalho ser desenvolvida uma simples aplicao web, baseado nos estudos feitos com a

17

linguagem e o framework, para que atravs de um estudo de caso, o leitor possa compreender o funcionamento, analisar e testar as funcionalidades de uma aplicao web em camadas. Relacionando as tecnologias utilizadas pelo framework Grails, avaliando-o com relao facilidade de utilizao e produtividade, que propem uma metodologia de desenvolvimento rpido.

18

2 FUNDAMENTAO TERICA

Nesta seo ser apresentada a linguagem Groovy, uma nova linguagem de scripting e dinmica cujo uso vem crescendo no mbito de desenvolvimento de sistemas web. Aprofundaremos sobre o Groovy, desde a sua criao, a sua semntica, sua relao com o Java, e por fim sero apresentados os passos necessrios para configurar o ambiente de desenvolvimento que permita usufruir de todos os seus recursos.

2.1 LINGUAGEM GROOVY

O Groovy uma linguagem de programao dinmica de altssima produtividade executada na JVM que oferece algumas melhorias em relao linguagem Java. Ser apresentado os principais conceitos por traz do funcionamento da linguagem para auxiliar na compreenso do framework Grails, que baseado nesta linguagem.

2.1.1 Histrico

Como apresenta KNIG(2007), o Groovy surgiu em meados de 2003, sendo criado pelo programador James Strachan, um membro do Apache Software Foundation1, co-fundador de vrios outros projetos com cdigo livre. O desenvolvimento da linguagem Groovy comeou em consequncia de um voo atrasado, onde James Strachan e sua esposa estavam espera. Enquanto sua esposa foi s compras, James Strachan visitou um cybercaf e, espontaneamente,

1

http://www.apache.org

19

decidiu navegar pelo site2 da linguagem Python e estud-la. No decurso

desta

atividade, ele reconheceu que a linguagem de programao na qual era experiente (Java) no tinha muitos dos recursos interessantes e teis presentes no Python, exemplo do suporte ao idioma nativo para tipos de dados comuns em uma sintaxe expressiva e, o mais importante, comportamento dinmico. Partindo deste ponto, surgiu a idia de trazer estes recursos para o Java. No dia 29 de Agosto de 2003, James Strachan publicou em seu blog3 um artigo com as primeiras descries do Groovy. Sua idia inicial era criar uma linguagem dinmica, que fosse compilada diretamente em classes Java e que tivesse a produtividade encontrada no Ruby e Python, mas que permitisse reusar, estender, implementar e testar cdigo Java j existente. James Strachan no queria apenas limitar o Groovy uma nova linguagem dinmica, mas sim criar algo que pudesse ser integrado ao que ele j tinha pronto em Java. Com a idia formada, James uniu-se a Bob McWhirter e juntos fundaram o projeto Groovy no segundo semestre de 2003. Junto a eles, algumas pessoas que partilhavam da mesma idia deram incio ao desenvolvimento da linguagem. Inicialmente, este projeto ficou hospedado pelo CodeHaus4, um repositrio de projetos de cdigo aberto com nfase em projetos na linguagem Java. De acordo com KNIG(2007), em 2004, o nome do projeto foi renomeado para Groovy-One, a equipe estava crescendo e a entrada de novos desenvolvedores (entre eles Guillaume Laforge, que posteriormente se tornou um dos lderes) fez o projeto dar continuidade. Foi ento lanado o Groovy Language Specification (GLS), o kit para testes de compatibilidade (TCK) e a sua primeira verso. Ainda em 2004, o Groovy deu incio a sua Java Specification Request (JSR), com o objetivo de padronizar a nova linguagem Groovy para a plataforma Java SE. Sendo aprovado no final de maro daquele ano, se tornou a segunda linguagem-padro para a Java Virtual Machine (JVM), depois da prpria linguagem Java. No comeo de 2005, Guillaume LaForge, um dos principais auxiliares de Strachan, assumiu o comando do projeto devido uma forte crise no segundo semestre de 2004, com alguns dos membros abandonando o projeto, insatisfeitos com o progresso da especificao formal da linguagem e da implementao, pela2 3 4

http://www.python.org

http://macstrac.blogspot.comhttp://groovy.codehaus.org

20

falta de dedicao por parte de James Strachan. Aps Guillaume assumir o cargo, o projeto voltou ao normal. At 2006 diversas verses betas foram lanadas. Finalmente, no dia 02 de Janeiro de 2007 foi lanada a verso 1.0, aps o incio do processo de padronizao Java Community Process (JCP). Apesar de sua ascenso, o Groovy cresceu sem muita popularidade e com o passar do tempo foram lanadas vrias verses sob o nmero 1.1.x. No dia 07 de dezembro de 2007 foi lanada sua verso final da famlia 1.1. Logo, nomeada para Groovy 1.5 devido s diversas modificaes realizadas na linguagem. Por ser um projeto de cdigo-aberto, qualquer desenvolvedor pode participar do projeto Groovy que financiado pela G2One Inc. Empresa fundada em 2007 pelos lderes do Groovy e Grails, (Guillaume Laforge, Graeme Rocher e Alex Trackman), que foi adquirida pela SpringSource5 em novembro de 2008, oferecendo para as empresas, suporte para os desenvolvedores e operaes de TI que utilizam aplicaes Groovy e Grails. A ltima verso estvel lanada a 1.7, mas est possvel para baixar as verses 1.8 e 1.9, que se encontram em estgio beta, no prprio site6 oficial da linguagem. Hoje a linguagem Groovy uma especificao do JCP (JSR 241)7, sendo considerada a segunda linguagem oficial da plataforma Java. Na prxima seo, veremos uma definio e uma abordagem inicial linguagem Groovy.

2.1.2 Introduo linguagem Groovy

A descrio presente no site oficial8 da linguagem diz que:Groovy uma linguagem gil e dinmica para a plataforma Java com muitas caractersticas que so inspirados por linguagens como Python, Ruby e

http://www.springsource.com http://groovy.codehaus.org/Download 7 http://www.jcp.org/en/jsr/detail?id=241 8 http://groovy.codehaus.org5 6

21

Smalltalk, trazendo uma sintaxe Java-like para os desenvolvedores Java. Segundo o site oficial da linguagem Groovy.(LAFORGE,2011).

O Groovy relativamente uma linguagem dinmica que pode ser interpretada ou compilada pela JVM, projetado especificamente para a plataforma Java9. Sua criao foi influenciada por linguagens como o Ruby10, Python, Perl11, e Smalltalk12. Considerada segunda linguagem-padro para a JVM, a linguagem Groovy fornece para programadores Java, facilidade em sua utilizao, pois o Groovy baseado na API Java. O que torna fcil a integrao entre as duas linguagens. De acordo com JUDD(2008) uma das vantagens da linguagem Groovy em relao as demais linguagens citadas acima, que o Groovy no se limita apenas ao acesso API Java existente. O Groovy possui sua prpria API, Groovy Development Kit (GDK), que se complementa a API Java, adicionando novos mtodos para as classes Java existentes. JUDD(2008) ainda afirma que, a sintaxe do Groovy muito mais flexvel e poderosa se comparando ao Java. Dezenas de linhas de cdigo na linguagem Java, podem ser reduzidas para algumas linhas de cdigo em Groovy. A linguagem Groovy tambm tem provado ser uma plataforma eficiente para conceitos como meta-programao e linguagens especficas de domnio. O Groovy uma linguagem orientada a objetos baseada em classes, se igualando neste aspecto linguagem Java. Desta forma, as classes suportam (heranas simples) e interfaces (com herana mltipla), sobrescrita de mtodos, etc. A maior diferena que o Groovy no possui tipos primitivos, onde todos os tipos so objetos. Para comearmos a entender melhor esta linguagem vamos criar um exemplo clssico Alo Java na linguagem Java, em seguida, para linguagem Groovy: Listagem 1. A classe AloJava.java _________________________________________________________public class AloJava { public static void main ( String[] args ) { System.out.println(Alo, Java!); }

http://www.java.org http://www.ruby-lang.org/en 11 http://www.perl.org/ 12 http://www.smalltalk.org/main/9 10

22

}

Agora veremos a mesma classe AloGroovy na linguagem Groovy. Listagem 2. A classe AloMundo.groovy_______________________________________________________class AloGroovy { static main( args ){ println "Alo, Groovy!" } }

Para executar o cdigo Groovy, siga os passos da instalao da linguagem Groovy na seo 2.1.5. Feito a instalao, existem vrias opes de execuo para as classes Groovy implementadas. A mais simples, abra o prompt de comando, localize o diretrio bin dentro da pasta de instalao do Groovy, digite o comando groovyConsole e pressione enter, de acordo com Figura 1.

Figura 1 - Tela do Prompt de Comando, executando o console Groovy

O utilitrio GroovyConsole, somente um .bat ou script de shell que invoca a JVM aps confirmar o classpath com os arquivos de biblioteca (jars) de runtime do Groovy. Os usurios do Eclipse13 podem instalar o Groovy Developer Tools (GDT), um plugin que facilita a edio e execuo de scripts Groovy. Aps seguir estes passos

13

http://www.eclipse.org

23

o console ir abrir e nela o usurio poder criar, alterar e executar as suas classes Groovy, como apresentado na Figura 2.

Figura 2 - GroovyConsole, executando o exemplo Alo,Groovy!

Por estas linhas de cdigo, j podemos observar algumas caractersticas de linguagens dinmicas. O Groovy possibilita ao desenvolvedor, no precisar declarar classes e mtodos, permitindo executar o cdigo em um escopo global. A terminao por ; opcional, exceto para separar statements na mesma linha, que segue as mesmas regras de outras linguagens dinmicas como JavaScript. Outra caracterstica comum nas classes Groovy sua visibilidade por padro de mtodos e campos pblicos e o acesso facilitado a APIs importantes, conforme explicou DEARLE(2010). Neste caso, importaes implcitas como o pacote java.util .* e a invocao do mtodo println() sem a necessidade do prefixo System.out. JUDD(2008) afirma que com as melhorias feitas na linguagem, usando o seu conceito de script: a implementao de mtodos bsicos como o get/set no

necessria, contudo possvel redefinir caso a implementao padro no satisfaa as necessidades; podemos rescrev-las se quisermos implementaesno-default. O comando return muito usado na linguagem Java suportado pela linguagem Groovy, mas no necessrio pois mtodos com retorno diferente de void retornam o resultado da ltima expresso avaliada.

24

Os recursos dinmicos contidos no Groovy nos permite definir variveis e mtodos sem declarar tipos (de variveis, atributos, parmetros ou retornos). E dentro de strings, a sintaxe ${...} d acesso ao valor formatado de variveis ou expresses arbitrrias, de forma semelhante s expresses da Expression Language (EL) do JSP 2.0.

2.1.3 Groovy: Uma linguagem de Scripting e Dinmica

Groovy uma linguagem que pertence a ambas categorias: tanto uma linguagem de scripting, como uma linguagem dinmica. De acordo com DOEDERLEIN(2007), estas categorias esto assim definidas: a) Linguagem de script: Tambm conhecido como linguagem de scripting, ou linguagem de extenso, so linhas de comandos escritas em arquivos, referidos como scripts, que so interpretadas e executados no interior de programas e/ou de outras linguagens de programao, no se restringindo a esses ambientes. As linguagens de script tem como finalidade estender a funcionalidade de um programa e/ou control-lo, acessando sua API e so frequentemente usadas como ferramentas de configurao e instalao em sistemas operacionais. A interpretao direta dos cdigo-fontes desses scripts permite alterar o cdigo sem reiniciar a aplicao executada. Exemplos de linguagens de script (JavaScript, Php, Ruby e Python). b) Linguagem dinmica: So linguagens de alto nvel, em sua maioria com tipagem dinmica e com um Protocolo de Meta-Objeto (Meta-Object Protocol), ou MOP. Estas caractersticas proporcionam muitas facilidades e um enorme poder no desenvolvimento da aplicao. Linguagens dinmicas no so compiladas, portanto a tipagem dinmica faz todo sentido. Porm, existe algumas linguagens dinmicas que utilizam de tipagem esttica, como o caso do Groovy, para utilizar de tcnicas como overloading de mtodos e de construtor. O Meta-Object Protocol sem dvida a grande vantagem das linguagens dinmicas. Alm de economizar a digitao com declaraes de tipos, as linguagens dinmicas permitem usar tcnicas de programao muito expressivas e reusveis.

25

2.1.4 Elementos bsico do Groovy

Nesta seo sero apresentados os principais conceitos do funcionamento da linguagem Groovy que sero pontos fundamentais para a compreenso do framework Grails.

2.1.4.1 Trabalhando com Strings

Como a maioria das linguagens modernas, o Groovy tem o conceito de uma string. Um problema muito comum em Java ocorre na concatenao de strings. Frequentemente possvel encontrar trechos de cdigo como:String mensagem = Bem vindo + pessoa.getNome();

Em Groovy, o mesmo comando poderia ser digitado como:String mensagem = Bem vindo $(pessoa.nome)

A sintaxe bastante simples, dentro de uma string, a expresso que estiver entre ${ e } ser interpretada e, em seguida, o valor de retorno ser includo na string a ser formada. No necessrio o uso do operador de concatenao e nem a chamada ao mtodo acessador get (BARCLAY; SAVAGE,2007). Na linguagem Groovy uma string pode ser definida de trs formas: Single quote (aspas simples), Double quote (aspas duplas) ou Triple quote (aspas triplas). (JUDD,2008): Listagem 3. Single quote (Aspas simples)_______________________________________def OiRenan = 'Oi, Renan'

Listagem 4. Double quote (Aspas duplas)_______________________________________def OiRenan = Oi, Renan

26

Listagem 5. Triple quote (Aspas triplas)def OiRenan = Oi, Renan sou uma string com muitas linhas de cdigo groovy

____________________________________

Existe uma diferena entre o funcionamento destes trs tipos de declarao: strings com aspas duplas e triplas permitem strings com mltiplas linhas, enquanto strings com aspas simples no.

2.1.4.2 Mtodos e Closures

Mtodo um nome dado a um conjunto de comandos que pode ser executado ou chamado uma ou mais vezes em um programa. Closures um objeto que contm um conjunto de comandos limitados por chaves ({ }). Sendo um objeto, pode ser atribudo a uma propriedade ou uma varivel, ou passado como parmetro para mtodos associado ao contexto esttico da sua definio. Pode tambm ser retornada, atribuda a variveis e manipulada de diversas formas. Sendo assim, o conjunto de comandos s ser executado quando a closures for invocada. Uma das vantagens das closures sobre os mtodos que elas capturam as variveis contidas no escopo final do conjunto de comandos e poder sempre acess-lo enquanto a closure existir. A diferena entre os mtodos que as closures so objetos e os mtodos no. Um mtodo s pode acessar os seus parmetros e os atributos da classe qual pertence, j uma closure pode acessar tambm as variveis locais do escopo onde foi declarada. Para entender isso, vamos invocar uma closure: /* Def a definio de varivel usado para indicar um tipo. Isso necessrio para que as variveis sejam detectveis ao analisador do Groovy.Podemos pensar em "def" como um pseudnimo de "Objeto". */def name = Joo def printClosure = { println Oi, ${name} } printClosure() name = Pedro

27

printClosure() Sada Oi, Joo Oi, Pedro

Este exemplo demonstra que, assim como os mtodos, os closures podem acessar variveis definidas no mesmo mbito que o closure. E assim como com os mtodos, os parmetros podem ser passados para o closure tambm.

2.1.4.3 Intervalos, Lista e Mapas (Hashes)

A linguagem Groovy, assim como a linguagem Perl, traz consigo operadores para trabalhar com hashes e colees. Podemos encontrar muitas das Collections do Java na prpria sintaxe da linguagem Groovy. No h necessidade de referenciar o pacote java.util. Groovy j referencia este pacote automaticamente para o usurio. Entre os operadores disponveis na linguagem Groovy, podemos citar: a) Intervalos: Apresentado como escalas pelo livro (Groovy in Action), este operador consistem em um recurso extremamente til na linguagem. Veja um exemplo de um loop escrito em Java:for (int i = 0; i < 10; i++) { cdigo.... }

A definio do loop, na realidade um intervalo, porm aplicado de uma forma mais complexa, pois envolve uma declarao de varireis, uma condio lgica e um incremento. Veja agora como o mesmo cdigo em Java, ficaria na linguagem Groovy:for (a in 0..9) { cdigo.... }

Analisando o cdigo acima este 0..9 consiste em uma escala, que implementa a interface Collection do Java. Sendo assim, mais do que sintaxe: um objeto por

28

si s. Declarar uma escala bastante simples. Basta usar a sintaxe [limite inferior]..[limite superior]. O .. consiste em um operador de precedncia baixa, sendo assim uma boa prtica de programao sempre definir seus intervalos dentro de parnteses, tal como (0..9). Existe tambm outro operador que ser utilizado ao definir escalas. O operador .. retorna o mesmo inteiro gerado pelo compareTo(), j os operadores > , >=, < e { ... } def adminUser = Usuario.findByUsername('admin') ?: new Usuario( username: 'admin', password: springSecurityService.encodePassword('admin'), papel: adminRole, enabled: true).save(failOnError: true)

76

if (!adminUser.authorities.contains(adminRole)) { UsuarioPapel.create adminUser, adminRole } } def destroy = { } }

A aplicao de segurana est quase pronta, falta inserir na tela do sistema um link para que quando o usurio estiver logado, possuir a opo de deslogar. Ento, precisamos inserir um painel lateral no views/layouts/main.gsp Listagem 26. Adicionando painel lateral no main.gsp (Sair)

O trecho de cdigo acima exibe um painel lateral que exibe o nome do usurio logado e um link para sair, conforme podemos observar na Figura 24.

Figura 24 - Pgina principal com o usurio logado

Caso o usurio efetue o logout do sistema, ser redirecionado para a pgina de login, como ilustra Figura 25, como definido pelas configuraes do controle de acesso no arquivo Config.groovy.

77

Figura 25 - Tela de login

3.3.10

Adicionando uma busca

Para adicionar um mtodo de busca na aplicao, foi utilizado o plugin Searchable. Este plugin fornece recursos de pesquisa para o aplicativo. Nesta seo ser visto como aplic-lo para o sistema de acordo com DAVIS(2009). Para instalar o plugin Searchable, abra o prompt de comando do Grails e execute a linha de comando:grails install-plugin searchable

Aps a instalao do plugin no projeto, incluiremos em todas as classes de domnio, em que se deseja um campo de pesquisa, a linha de cdigo abaixo.class Cliente { [...] static constraints = { [...] } /* Este parmetro torna true o acesso do mtodo searchable aos atributos da classe de domnio persistidos no banco de dados. static searchable = true [...] }

78

E adicionar ao controlador pertencente a classe de domnio o mtodo que far uma busca no banco dados retornando uma lista. Assim, quando o usurio do sistema digitar o que deseja encontrar e executar o boto de busca, a requisio ser feita pelo navegador ao servidor, que processar o pedido do usurio e em seguida retornar um mapa de metadados sobre a pesquisa, juntamente com uma lista de classes de domnio que correspondem aos critrios da busca.def search = { def query = params.q if(query){ def srchResults = Cliente.search('*'+query+'*') render(view: "list", model: [clientesInstanceList:srchResults.results, clientesInstanceTotal:srchResults.total]) }else{ redirect(action: "list") } }

Por fim, s precisaremos inserir o campo com o parmetro de busca na pgina list do Cliente colocando o cdigo a abaixo dentro do arquivo list.gsp localizado no diretrio views/clientes/list.gsp.# Adicionando um boto, com uma action search, que far um get retornando os atributos da classe de domnio cadastrados.

O resultado ser o campo de busca na view de Cliente.list como apresenta Figura 26.

79

Figura 26 - Campo de busca

3.3.10 Gerando relatrios

Para integrar relatrios JasperReport dentro da aplicao, ser necessrio instalar o plugin Jasper. Este plugin suporta os seguintes tipos de formatos: PDF, HTML, XML, CSV, XLS, RTF, TEXT, ODT, ODS, DOCX, XLSX, PPTX. Para instalar este plugin, abra o prompt de comando do Grails e execute a linha de comando:grails install-plugin jasper

Aps a instalao do plugin, ser inserido na view do Cliente, onde se encontra a lista dos clientes cadastrados, dentro do arquivo List.gsp, um boto com a funo gerar um relatrio:[...]

80

Dentro do parmetro ser configurado o nome do relatrio e os tipos de formato. Para personalizar os modelos de relatrios ser necessrio a instalao do programa iReport30. Esta ferramenta cria diversos tipos de relatrio usando uma interface muito simples, ilustrada na Figura 27. Crie um relatrio e arraste para dentro dele elementos do report localizado na paleta definindo com atributos da classe de domnio e salve para dentro da pasta \web-app\reports, com o nome clientes-reports, de acordo com a Figura 28.

Figura 27 - Criando o relatrio de clientes no iReport

30

http://jasperforge.org/uploads/publish/ireportwebsite/IR%20Website/ir_download.html

81

Figura 28 - Diretrio reports

Com resultado, teremos na view/list.gsp do Cliente o boto para a gerao de relatrios, como apresenta a Figura 29. Figura 29 - Boto do relatrio

82

3.3.11 Internacionalizao

De

acordo

com

ROCHER(2009)

o

Grails

traz

suporte

para

a

internacionalizao31 de aplicaes web, sendo bastante simples de manusear. O Grails determina automaticamente a localidade do usurio com base no cabealho Accept-Language que o seu navegador envia. Quando criamos uma aplicao em Grails, o projeto inclui uma srie de arquivos de propriedades localizados dentro do diretrio grails-app/i18n/. O arquivo messages.properties contm validao padro de mensagens em ingls. Essas mensagens sero usadas quando ocorrer algum erro de validao em uma classe de domnio ou algum comando de objeto. Dentro do diretrio grails-app/i18n/, so gerados arquivos com propriedades em vrios idiomas. Por exemplo, messages_pt.properties, contm mensagens de validao em portugus. Essas propriedades, so definidas por campos de espao reservado: {0} para um nome de propriedade {1} para um nome de classe {2} para um valor O Grails oferece uma tag chamada message dentro da GSP, que recupera os valores de propriedades a partir dos arquivos de mensagens no grails-app/i18n/. Buscaremos no arquivo views/cliente/list.gsp, as tags com o parmetro dos botes Home e New.

31

http://grails.org/doc/1.1/guide/single.html#10.%20Internationalization

83

Aps identificar as tags g:message , abra o arquivo de configurao messages.properties e pesquise no cdigo pelo texto default.home.label. edefault.new.label .Como j haviamos citado anteriormente, o Grails contm todas

as mensagens da aplicao, por padro, em ingls. Neste caso, identificamos o texto da mensagem default.home.label. = Home e default.new.label = New. Vamos abrir o arquivo de configurao messages_pt_BR.properties e adicionar as mensagens que queremos que sejam traduzidas.# Trecho do cdigo: Vamos adicionar aqui nossas mensagens de erro default.home.label=Incio default.new.label=Novo {0} default.add.label=Adicionar {0} default.list.label=Listar {0}#Ateno ao parmetro {0}, ele ser substitudo pelo nome de uma propriedade.

Podemos atualizar a pgina Cliente.list e automaticamente ela far a traduo dos campos alterados, como podemos observar na figura 30.

Figura 30 - Botes internacionalizados para pt_BR

84

3.3.12 Deploy

Uma vez estando a aplicao finalizada, possvel efetuar o deploy do projeto. O processo bastante simples, tudo o que precisa ser feito executar o comando grails war no prompt de comando do Grails. Este comando far o build do projeto, empacotar no formato war padro do JEE e ser salvo dentro do diretrio target do projeto, conforme Figura 31.

Figura 31 - Arquivo war. gerado dentro do diretrio target

Aps a gerao do arquivo war da aplicao, podemos implantar em qualquer servidor. Os passos necessrios para implantar o war variam de acordo com os tipos servidores. Usaremos o servidor web Tomcat para testar a nossa aplicao. Com o war gerado, devemos apenas copiar o arquivo gerado para dentro do diretrio webapps, onde est instalado o Tomcat e rodarmos e executarmos o servidor. Um tutorial de instalao e configurao do Apache Tomcat est disponvel no Apndice.

85

4 METODOLOGIA

Este trabalho foi desenvolvido baseado em uma metodologia especfica voltada para a rea de Sistemas de Informao, com o intuito de realizar um estudo sobre novas tecnologias que adotam metodologias geis para o desenvolvimento de sistemas web. Na primeira etapa, foi feito uma pesquisa exploratria atravs de um levantamento bibliogrfico sobre a linguagem Groovy, um estudo de suas caractersticas, desde sua estrutura (mtodos, closures, expresses regulares, operadores), a sua configurao para o desenvolvimento. Aps esta etapa, foi feito um estudo sobre o framework Grails, desde sua arquitetura, caractersticas, estrutura, configuraes e seus recursos que integrados formam uma verstil ferramenta para o desenvolvimento de aplicaes web. A populao alvo deste trabalho so os prprios desenvolvedores web que podero ter uma nova viso e conhecimento sobre estas tecnologias que tornam o desenvolvimento de aplicaes web cada vez mais geis e dinmicas, aumentando o nvel de produtividade e reduzindo o nvel de complexidade na criao de sistemas. Concludo a fundamentao terica, foi realizado um estudo de caso, definindo as funcionalidades necessrias para o sistema, criando diagrama de classes e o caso de uso, que facilitaram o entendimento do problema. Com a utilizao do framework Grails foi possvel criar toda a parte relacional do banco de dados automaticamente, de acordo com as classes de domnio, levantadas no estudo de caso e instalados plugins com funcionalidades especificas de pesquisa e segurana para incrementar o sistema. Finalmente, sero apresentados nas consideraes finais os resultados da implantao do sistema na empresa.

86

5 CONSIDERAES FINAIS

possvel notar os grandes avanos feitos no campo de desenvolvimento em aplicaes web, a linguagem Groovy e o framework Grails trazem para os desenvolvedores um novo paradigma de programao, combinao perfeita que integra diversas tcnicas e tecnologias existentes do framework Grails, com as caractersticas dinmicas da linguagem dinmica Groovy, resultando em uma estrutura favorvel ao desenvolvimento com relao a facilidade de utilizao e produtividade. Durante parte do trabalho foi focado nos conceitos fundamentais da linguagem Groovy, apresentando toda a sintaxe bsica para que o leitor pudesse absorver o contedo desta linguagem dinmica e o potencial do framework Grails, relacionando as tecnologias utilizadas pelo framework, assim como a compreenso de sua estrutura e funcionamento em aplicaes web e no desenvolvimento em camadas. Ento os objetivos propostos neste trabalho, alm de apresentar o contedo de uma forma simples sobre os conceitos fundamentais das tecnologias em questo, foi possvel tambm vivenciar o lado prtico, desenvolvendo um sistema web, sendo implementado algumas funcionalidades do sistema, proposto para a empresa Andreza Andrade, que passou a utilizar o sistema desenvolvido por este trabalho. Como resultado foi constatada vantagens desde a implantao do sistema em sua empresa, tais como: agilidade no cadastro de produtos e clientes, facilidade em suas vendas e controle de estoque (atravs de relatrios gerados pelo sistema), de acordo com os questionrios elaborados e respondidos por ela, anexados neste trabalho. Podemos destacar os Prs e Contras, da utilizao do sistema na empresa: Prs: Idioma est portugus. Interface amigvel. Fcil usabilidade. Controle de usurios. CRUD (clientes, produto e vendas) Relatrios em PDF. Rpido acesso as funcionalidades. Contras: Apesar de ser um sistema web, roda apenas em um servidor local. Instalar o Tomcat na mquina. Instalar o MYSQL na mquina.

87

Nos anexos segues dois questionrios elaborados, relatando a experincia do usurio antes e depois da implantao do sistema na empresa. Foi possvel constatar que aps 4 8 horas de inatividade, o framework Grails perde a conexo com o banco de dados, havendo a necessidade de reiniciar o programa. Para evitar esta situao, adicionamos ao DataSource.groovy seguinte propriedade:properties { validationQuery="select 1" testWhileIdle=true timeBetweenEvictionRunsMillis=60000 }

No foi possvel se fazer presente de toda a instruo de como foi criado o sistema neste trabalho, a idia inicial, era mostrar para desenvolvedores web, conceitos da linguagem e do framework, para que o leitor tivesse uma noo bsica de como construir uma aplicao utilizando Grails (classes de domnio, controladores, entre os outros recursos) citados no decorrer do desenvolvimento da aplicao.

5.1 TRABALHOS RELACIONADOS

Alguns trabalhos relacionados foram encontrados dentre eles pode-se citar o artigo: a) GRAILS: DO GROOVY WEB ALTA PRODUTIVIDADE NO

DESENVOLVIMENTO DE APLICAES WEB. Este artigo apresenta uma viso panormica do funcionamento do Grails, um framework fullstack para o desenvolvimento de aplicaes web que baseado na linguagem Groovy.

88

b)

CRIANDO UM BLOG EM CINCO MINUTOS COM GRAILS.

Este artigo32

apresenta as vantagens de se trabalhar com Groovy e Grails, desenvolvendo passoa-passo um blog. O Grails prima por ser um framework de alta produtividade ao adotar o princpio de padres sobre configuraes aliado aos ganhos obtidos com uma linguagem dinmica. Neste artigo relacionado podemos ver o funcionamento bsico: como criar classes de domnio, controladores e a execuo do scaffolding, que agiliza muito a vida do desenvolvedor ao fornecer um ponto de partida na criao de suas aplicaes. Dada a escassez de artigos em desenvolvimento de sistemas web utilizando Groovy e Grails, assim como as restries do contedo em apenas apresentar a teoria ou de desenvolver simples blogs e micro-blogs, percebe-se limitaes ao passar para o leitor, algumas funcionalidades necessrias principalmente para o desenvolvimento na rea comercial. O presente trabalho vai mais alm desses artigos trazendo formas de implementao de buscas no banco de dados e a integrao de relatrios usando plugins criados para o framework.

5.2 TRABALHOS FUTUROS

Como trabalho futuro, sugere-se o aprofundamento em outras tecnologias de desenvolvimento de aplicaes geis e dinmicas para web, fazendo comparativos da linguagem Groovy com outras linguagens dinmicas, exemplo do Ruby e Scala, abrindo novos horizontes no que diz respeito ao desenvolvimento de sistemas para a web.

32

http://www.michelsilva.net/index.php?option=com_content&task=view&id=49&Itemid=12

89

REFERNCIAS

ROCHER, Graeme; BROWN, Jeff. The Definitive Guide to Grails. 2nd ed. [S.I]: Apress, 2009. JUDD, C. M.; NUSAIRAT, J. F.; SHINGLER, J. Beginning Groovy and Grails: From Novice to Professional. 1. ed. [S.l.]: Apress, 2008. KONIG, D.; GLOVER, A.; KING, P.; LAFORGE, G.; SKEET, J. Groovy in Action. 1. ed. [S.l.]: Manning Publications, 2007. BARCLAY, Kenneth; SAVAGE John. Grovvy Programming an introduction for Java Developers. San Francisco: Elsevier, 2007. DEARLE, Fergal. Groovy for Domain Specific Languages. [S.I.]: Packt Publications, 2010. SMITH, Glen; LEDBROOK, Peter. Grails in Action .1st ed. [S.I.]: Manning Publications, 2009. JAWAD, Bashar Abdul. Groovy and Grails Recipes. 1st ed. [SI.]: Apress, 2009. RUDOLPH, Jason. Getting Started with Grails. 1st ed. [S.I.]: InfoQ Publisher, 2006. DOEDERLEIN, OSVALDO. Aprendendo Groovy - Scripting e Dinamismo na Plataforma Java. Revista Java Magazine,Ed.32, [S.I], p. 30-44, [2007]. WEISSMANN, HENRIQUE. Grails: do Groovy Web - Alta produtividade no desenvolvimento - Parte 1. Revista Java Magazine,Ed.75, [S.I], p. 28-34, 2010. WEISSMANN, HENRIQUE. Grails: do Groovy Web - Alta produtividade no desenvolvimento - Parte 2. Revista Java Magazine,Ed.76, [S.I], p. 48-56, 2010. WEISSMANN, HENRIQUE. Grails: do Groovy Web - Alta produtividade no desenvolvimento - Parte 3. Revista Java Magazine,Ed.77, [S.I], p. 46-53, 2010. WEISSMANN, HENRIQUE. Grails: do Groovy Web - Alta produtividade no desenvolvimento - Parte 4. Revista Java Magazine,Ed.78, [S.I], p. 38-50, 2010. WEISSMANN, HENRIQUE. Grails: do Groovy Web - Alta produtividade no desenvolvimento - Parte 5. Revista Java Magazine,Ed.79, [S.I], p. 30-41, 2010. COMMUNITY, C. G. Groovy Home. Disponvel em: http://groovy.codehaus.org/. Acessado em 20 de Maio 2011.

90

LEDBROOK, Peter. Simplified Spring Security with Grails. Disponvel em: http://blog.springsource.com/2010/08/11/simplified-spring-security-with-grails. Acessado em 20 de Maio de 2011. DAVIS, Scott. Dominando Grails: Entendendo Plug-ins. Disponvel em: http://www.ibm.com/developerworks/br/java/library/j-grails07219/ . Acessado em 20 de Maio de 2011. CASTELLANI, Marcelo. Um pouco de Groovy. Disponvel em: http://www.devmedia.com.br/websys.2/webreader.asp?cat=6&revista=javamagazine _69#a-1572 . Acessado em 20 de Maio de 2011. LAFORGE, Guillaume. Groovy - An agile dynamic language for the Java Platform. Disponvel em: http://groovy.codehaus.org/ . Acessado em 20 de Maio de 2011

91

APENDICE

O material apresentado nesta monografia foi fornecido sob licenas de cdigo aberto, no infringindo nenhuma lei. O cdigo fonte e binrios esto disponveis gratuitamente. O material inteiramente acadmico e esto livres para os usurios. O exemplo utilizado neste trabalho foi desenvolvido na plataforma Microsoft Windows. As sees a seguir esto atualizadas at presente data e podem estar sujeitos a alteraes. Por tanto, os leitores devem consultar o site do livro e do site das ferramentas para obter mais detalhes e atualizaes

A.1 JAVA DEVELOPMENT KIT (JDK)

O Java Development Kit (JDK) est disponvel no site da Oracle33. O arquivo encontra-se disponveis para uma variedade de plataformas. No Windows, clique duas vezes no arquivo executvel (por exemplo, jdk-6u24-windowsi586.exe) para iniciar o processo de instalao. Por padro o JDK se localizar na pasta C:\Program Files\Java.

A.2 SERVIDOR APACHE TOMCAT

O servidor Tomcat est disponvel no site34, na seo de downloads. No item Binary Distributions, clique em Windows service Installer e faa o download. Atualmente o Tomcat encontra-se na verso 6.0.32, antes de baixar verifique o seu sistema operacional. No windows, clique duas vezes no arquivo executvel (por exemplo, apache-tomcat-6.0.32.exe) para iniciar o processo de instalao. Nas

33

http://www.oracle.com/technetwork/java/javase/downloads/index.html http://tomcat.apache.org/

34

92

etapas de instalao defina o diretrio onde o Tomcat ser instalado, em nossa instalao vamos adicionar o caminho: C:\Arquivos de Programas\Tomcat 6.0. Figura 32 - Configuraes bsicas do Tomcat

Como ilustra a figura 32, as configuraes bsicas do Tomcat so: Porta de instalao: Porta de acesso exclusiva ao Tomcat, por padro a porta de instalao do Tomcat a 8080. a) Username: Define um nome de usurio para acesso a administrao do Tomcat, por padro admin. b) Password: Define uma senha para o administrador do Tomcat, por padro admin. Feito isso avance a etapa. Para finalizar, indique onde esta instalada a Java Runtime Environment (JRE) e clique em Install. Para configurar o Tomcat, teremos que definir uma varivel de ambiente. Para acessar as variveis de ambiente do sistema, clique com o boto direito do mouse no cone Meu Computador, clique na aba Avanado, e clique no boto Variveis de Ambiente. Agora defina o nome para a varivel de ambiente para CATALINA_HOME

93

e o valor da varivel para o caminho onde foi instalado o Tomcat como apresentado na Figura 33. Figura 33 - Configurando a varivel de ambiento do Tomcat

Para testar a instalao do Tomcat basta digitar no browser o endereo http://localhost:8080.

A.3 SPRING SOURCE TOOL SUITE 2.5.2.SR1

A ferramenta que usaremos para desenvolver o aplicativo web est disponvel no site35 oficial, na seo de downloads. Trata-se de uma verso do Eclipse j pronta para rodar o Grails, faa o download do Installer. Feito o download, siga este tutorial para o apoio do Grails Eclipse na ferramenta Spring Source Tool Suite (STS).35

http://www.springsource.com/products/springsource-tool-suite-download

94

Neste tutorial, iremos fazer a instalao do suporte ao idioma Groovy e instalar as ferramentas Grails no SringSource Tool Suite. Aps a instalao, execute o programa, uma tela de Bem-vindos ir aparecer na tela conforme Figura 34.

Figura 34 - Tela de abertura do SpringSource Tool Suite

Na aba de menus clique em Help e depois na guia Dashboard. Feito isso uma nova janela ir abrir.

95

Figura 35 - Dashboard do SpringSource Tool Suite

Na parte inferior, em um painel separador, clique em Extensions de acordo com Figura 35. Figura 36 - Configurando o Grails na Dashboard

96

Como ilustra Figura 36, na seo Languages and Frameworks, encontramos a ltima verso do framework Grails. Caso possua o Grails instalado em sua mquina, ento no h a necessidade de marcar. Na seo Language and Framework Tooling, marque as duas opes, para instalar o suporte ao Grails e o Groovy Eclipse plugin e clique em Install. Aps a instalao, reinicie o SpringSource Tool Suite e este estar habilitado para o desenvolvimento com o Groovy e Grails.

A.4 MYSQL SERVER 5.5

Faa

o

download

do

MySQL

Community

Server

pelo

site

dev.mysql.com/downloads/. Aps acessar o link acima, clique na opo MySQL Community Server. Nesta pgina, teremos a opes de escolha de acordo com o sistema operacional utilizado. Para fazer o donwload preciso ser cadastrado. Faa o rpido cadastro e clique em donwload. Aps baixar o arquivo execute-o e siga os passos conforme abaixo: 1. Siga a instalao, dando next , aceite os termos de acordo. 2. Escolha a opo Custom para poder interagir com as configuraes e clique em next. 3. Siga dando next e clique em Install. 4. Aguarde enquanto a instalao automtica configura e efetua alguns procedimentos. 5. Finalizada a instalao do MySQL Server 5.5, vamos configurar o servidor. Uma janela do MySQL Serve Instance Configuration Wizard ir abrir, marque a primeira opo - Detailed configuration e depois next. 6. Em seguida marque a primeira opo novamente - Developer Machine e depois em next. 7. Marque a primeira opo - Multifuncional Database e depois em next. 8. Mantenha as configuraes padro e depois next. 9. Marque a primeira opo - Decision Suppots (DSS)/OLAP e depois em next.

97

10. Mantenha as opes Enable TCP/IP Networking e Enable Strict Mode marcadas e clique em next. 11. Em relao ao Charset padro, escolha a opo - Best Support for Multilinguism. 12. Na prxima janela marque a opo - Install as windows service, e siga avanando. 13. Agora deixe marcada a opo Modify Security Settings e defina a senha root e clique em next. 14. Aparecer uma janela informando os passos que o assistente de configurao seguir automaticamente a partir desse ponto. Clique em Execute. 15. Pronto, o servidor de banco de dados MySQL esta devidamente instalado e configurado.

98

ANEXOS

99

ANEXOS A QUESTIONRIO 1. Roteiro de perguntas respondidas por Andreza Andrade (Empresria) sobre o comportamento da empresa antes da instalao do sistema

De que forma organizada os dados dos clientes na empresa? Resposta: Eram organizadas atravs de fichas, onde todos os dados dos clientes eram guardados em fichrios, por ordem alfabtica. De que forma organizada os dados dos produtos na empresa? Resposta: Os dados dos produtos eram anotados em cadernos de estoque, organizados por fornecedores,referncias,preo de custo,entre outros. De que forma organizada os dados das vendas na empresa? Resposta: As vendas eram feitas atravs do livro caixa, onde eram discriminados todos os produtos vendidos diariamente, e tiradas s respectivas notas fiscais, tudo manualmente. Como eram feitos os relatrios na empresa? Resposta: Os relatrios eram feitos semanalmente, para o controle fsico/ financeira da empresa. Como voc classifica a eficincia na prtica do cadastro manual do cliente na empresa? 1 2 3 4 5 Pouco Eficiente Muito Eficiente

Como voc classifica a eficincia na prtica de consultar informaes sobre os clientes na empresa? 1 2 3 4 5 Pouco Eficiente Muito Eficiente

Como voc classifica a eficincia na prtica do cadastro manual dos produtos na empresa? 1 2 3 4 5 Pouco Eficiente Muito Eficiente

100

Como voc classifica a eficincia na prtica de consultar informaes sobre o produto na empresa? 1 2 3 4 5 Pouco Eficiente Muito Eficiente

Como voc classifica a eficincia nas prticas manuais de vendas na empresa? 1 2 3 4 5 Pouco Eficiente Muito Eficiente

ANEXO B QUESTIONRIO 2.

101

Roteiro de perguntas respondidas por Andreza Andrade (Empresria) aps implantao do sistema em sua empresa.

Como voc classifica a eficincia na prtica do cadastro de Clientes aps a implantao do sistema? 1 2 3 4 5 Pouco Eficiente Muito Eficiente

Como voc classifica a eficincia na prtica de consulta de Clientes aps a implantao do sistema? 1 2 3 4 5 Pouco Eficiente Muito Eficiente

Como voc classifica a eficincia dos relatrios de Clientes aps a implantao do sistema? 1 2 3 4 5 Pouco Eficiente Muito Eficiente

Como voc classifica a eficincia na prtica do cadastro de produtos aps a implantao do sistema? 1 2 3 4 5 Pouco Eficiente Muito Eficiente

Como voc classifica a eficincia na prtica de consulta de produtos aps a implantao do sistema? 1 2 3 4 5 Pouco Eficiente Muito Eficiente

Como voc classifica a eficincia dos relatrios de Produtos do cadastro aps a implantao do sistema? 1 2 3 4 5 Pouco Eficiente Muito Eficiente

Como voc classifica a eficincia em criar Vendas aps a implantao do sistema?

102

1 Pouco Eficiente

2

3

4

5 Muito Eficiente

Como voc classifica a eficincia em consultar Vendas aps a implantao do sistema? 1 2 3 4 5 Pouco Eficiente Muito Eficiente

Como voc classifica a eficincia dos relatrios de Vendas aps a implantao do sistema? 1 2 3 4 5 Pouco Eficiente Muito Eficiente

ANEXO C CDIGOS FONTES

103

Segue abaixo as classes de domnio que foram desenvolvidas no sistema makeup-erp.

Listagem 27. Classe de domnio Cliente.groovy ____________________________________________package makeup.erp import java.util.Date; class Cliente { String nome String campoEmail Date dataNascimento String endereco String cidade = "Campina Grande" String estado = "PB" String telefone String celular Date dateCreated static constraints = { nome(blank:false) campoEmail(email:true, nullable:true) dataNascimento(nullable:true) endereco(maxSize:100,nullable:true) cidade(nullable:true) estado(inList:["AC","AL","AP","AM","BA","CE","DF","ES","GO","MA", "MT","MS","MG","PA","PB","PR","PE","PI","RJ","RN","RS","RO", "RR","SC","SP","SE","TO"], nullable:true) telefone(/*matches:"\\(?\\d{2}\\)?\\d{4}-\\d{4}", */nullable:true) celular(nullable:true) } static searchable = true String toString(){ nome } }

104

Listagem 28. Classe de domnio Devolucao.groovy _______________________________________package makeup.erp import java.util.Date; class Devolucao { Cliente cliente double valorRetornado Date dateCreated static hasMany = [itens:ItemDevolucao] List itens static constraints = { cliente(nullable: true) valorRetornado(scale:2, min:0d) } static searchable = { itens component:true cliente component:true } }

Listagem 29. Classe de domnio ItemDevolucao.groovy __________________________________package makeup.erp class ItemDevolucao { static belongsTo = [devolucao:Devolucao] Produto produto double quantidade = 1 double valorUnitario double valorTotal int sequencia static constraints = { valorUnitario(scale:2, min:0d) valorTotal(scale:2, min:0d) quantidade(min:0d) } static searchable = true String toString(){ quantidade + ": " + produto.toString(); } }

Listagem 30. Classe de domnio ItemVenda.groovy __________________________________package makeup.erp

105

class ItemVenda { static belongsTo = [venda:Venda] Produto produto double quantidade = 1 double valorUnitario double valorTotal int sequencia static constraints = { valorUnitario(scale:2, min:0d) valorTotal(scale:2, min:0d) quantidade(min:0d) } static searchable = true String toString(){ quantidade + ": " + produto.toString(); } }

Listagem 31. Classe de domnio Papel.groovy __________________________________package makeup.erp class Papel { String authority static mapping = { cache true } static constraints = { authority blank: false, unique: true } String toString(){ authority } }

Listagem 32. Classe de domnio Produto.groovy __________________________________package makeup.erp import java.util.Date; class Produto {

106

String String double double double String

descricao barCode quantidade precoCusto precoVenda observacoes

Date dateCreated static constraints = { descricao() precoCusto(scale:2, min:0d) precoVenda(scale:2, min:0d) quantidade(min: 0d) barCode(nullable:true) observacoes(nullable:true, maxSize:300) } static searchable = true String toString(){ descricao } }

Listagem 33. Classe de domnio Usuario.groovy __________________________________package makeup.erp class Usuario { String username String password boolean enabled = true boolean accountExpired = false boolean accountLocked = false boolean passwordExpired = false Papel papel static constraints = { username blank: false, unique: true password blank: false, password: true enabled display: false accountExpired display: false accountLocked display: false passwordExpired display: false } static mapping = { password column: '`password`' }

107

static searchable = true Set getAuthorities() { UsuarioPapel.findAllByUsuario(this).collect { it.papel } as Set } }

Listagem 34. Classe de domnio UsuarioPapel.groovy __________________________________package makeup.erp import org.apache.commons.lang.builder.HashCodeBuilder class UsuarioPapel implements Serializable { Usuario usuario Papel papel boolean equals(other) { if (!(other instanceof UsuarioPapel)) { return false } other.usuario?.id == usuario?.id && other.papel?.id == papel?.id } int hashCode() { def builder = new HashCodeBuilder() if (usuario) builder.append(usuario.id) if (papel) builder.append(papel.id) builder.toHashCode() } static UsuarioPapel get(long usuarioId, long papelId) { find 'from UsuarioPapel where usuario.id=:usuarioId and papel.id=:papelId', [usuarioId: usuarioId, papelId: papelId] } static UsuarioPapel create(Usuario usuario, Papel papel, boolean flush = false) { new UsuarioPapel(usuario: usuario, papel: papel).save(flush: flush, insert: true) } static boolean remove(Usuario usuario, Papel papel, boolean flush = false) { UsuarioPapel instance = UsuarioPapel.findByUsuarioAndPapel(usuario, papel) instance ? instance.delete(flush: flush) : false }

108

static void removeAll(Usuario usuario) { executeUpdate 'DELETE FROM UsuarioPapel WHERE usuario=:usuario', [usuario: usuario] } static void removeAll(Papel papel) { executeUpdate 'DELETE FROM UsuarioPapel WHERE papel=:papel', [papel: papel] } static mapping = { id composite: ['papel', 'usuario'] version false } }

Listagem 35. Classe de domnio Venda.groovy __________________________________package makeup.erp import org.apache.commons.collections.FactoryUtils import org.apache.commons.collections.list.LazyList class Venda { double double double double double valorTotal desconto valorAPagar valorRecebido troco

String formaPagamento Cliente cliente Date dateCreated static hasMany = [itens:ItemVenda] List itens

static constraints = { cliente(nullable: true) itens() valorTotal(scale:2, min:0d) formaPagamento(inList:["Carto","Cheque","Dinheiro"], nullable:false) } static searchable = { itens component:true cliente component:true } }

109

Os controladores do sistema makeup-erp. Listagem 36. Controlador ClienteController.groovy __________________________________package makeup.erp class ClienteController { def scaffold = Cliente def search = { def query = params.q if(query){ def srchResults = Cliente.search('*'+query+'*') render(view: "list", model: [clienteInstanceList:srchResults.results, clienteInstanceTotal:srchResults.total]) }else{ redirect(action: "list") } } }

Listagem 37. Controlador ItemDevolucaoController.groovy__________________________________

package makeup.erp class ItemDevolucaoController { def scaffold = ItemDevolucao }

Listagem 38. Controlador ItemVendaController.groovy __________________________________package makeup.erp class ItemVendaController { def scaffold = ItemVenda }

Listagem 39. Controlador DevolucaoController.groovy __________________________________package makeup.erp class DevolucaoController { static allowedMethods = [save: "POST", update: "POST", delete: "POST"]

110

def index = { redirect(action: "list", params: params) } def list = { params.max = Math.min(params.max ? params.int('max') : 10, 100) [devolucaoInstanceList: Devolucao.list(params), devolucaoInstanceTotal: Devolucao.count()] } def search = { def query = params.q if(query){ def srchResults = Devolucao.search('*'+query+'*') render(view: "list", model: [vendaInstanceList:srchResults.results, vendaInstanceTotal:srchResults.total]) }else{ redirect(action: "list") } } def create = { def devolucaoInstance = new Devolucao() devolucaoInstance.properties = params return [devolucaoInstance: devolucaoInstance] } def save = { def devolucaoInstance = new Devolucao(params) adicionarItens(devolucaoInstance, params) if (devolucaoInstance.save(flush: true)) { flash.message = "${message(code: 'default.created.message', args: [message(code: 'devolucao.label', default: 'Devolucao'), devolucaoInstance.id])}" redirect(action: "show", id: devolucaoInstance.id) } else { render(view: "create", model: [devolucaoInstance: devolucaoInstance]) } } def adicionarItens(devolucao, params) { def itemCount = params["produtoCount"].toInteger() def success = true for (int i = 0; i < itemCount; i++) { def itemArr = params["itensVenda[" + i + "]"] if ( itemArr != null) { Produto produto = Produto.get(itemArr.produto.toInteger())

111

ItemDevolucao itemDevolucao = new ItemDevolucao(itemArr) itemDevolucao.devolucao = devolucao itemDevolucao.produto = produto itemDevolucao.sequencia = i def quantidadeAnterior = produto.quantidade def novaQuantidade = quantidadeAnterior + itemDevolucao.quantidade produto.quantidade = novaQuantidade produto.save(); devolucao.addToItens(itemDevolucao) } } } def show = { def devolucaoInstance = Devolucao.get(params.id) if (!devolucaoInstance) { flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'devolucao.label', default: 'Devolucao'), params.id])}" redirect(action: "list") } else { [devolucaoInstance: devolucaoInstance] } } def edit = { def devolucaoInstance = Devolucao.get(params.id) if (!devolucaoInstance) { flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'devolucao.label', default: 'Devolucao'), params.id])}" redirect(action: "list") } else { return [devolucaoInstance: devolucaoInstance] } } def update = { def devolucaoInstance = Devolucao.get(params.id) if (devolucaoInstance) { if (params.version) { def version = params.version.toLong() if (devolucaoInstance.version > version) { devolucaoInstance.errors.rejectValue("version", "default.optimistic.locking.failure", [message(code: 'devolucao.label',

112

default: 'Devolucao')] as Object[], "Another user has updated this Devolucao while you were editing") render(view: "edit", model: [devolucaoInstance: devolucaoInstance]) return } } devolucaoInstance.properties = params if (!devolucaoInstance.hasErrors() && devolucaoInstance.save(flush: true)) { flash.message = "${message(code: 'default.updated.message', args: [message(code: 'devolucao.label', default: 'Devolucao'), devolucaoInstance.id])}" redirect(action: "show", id: devolucaoInstance.id) } else { render(view: "edit", model: [devolucaoInstance: devolucaoInstance]) } } else { flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'devolucao.label', default: 'Devolucao'), params.id])}" redirect(action: "list") } } def delete = { def devolucaoInstance = Devolucao.get(params.id) if (devolucaoInstance) { try { def transactionError = false Devolucao.withTransaction() { status -> Iterator iterator = devolucaoInstance.itens.iterator() while (iterator.hasNext()) { ItemDevolucao itemDevolucao = iterator.next(); def quantidadeAnterior = itemDevolucao.produto.quantidade def quantidadeNova = quantidadeAnterior - itemDevolucao.quantidade if (quantidadeNova < 0) { status.setRollbackOnly() flash.message = "Quantidade insfuciente para o produto " + itemDevolucao.produto.descricao +"."

113

redirect(action: "show", id: params.id) transactionError = true return } itemDevolucao.produto.quantidade = quantidadeNova itemDevolucao.produto.save() iterator.remove() itemDevolucao.delete(flush:true) } } if (transactionError) { return } devolucaoInstance.delete(flush: true) flash.message = "${message(code: 'default.deleted.message', args: [message(code: 'devolucao.label', default: 'Devolucao'), params.id])}" redirect(action: "list") } catch (org.springframework.dao.DataIntegrityViolationException e) { flash.message = "${message(code: 'default.not.deleted.message', args: [message(code: 'devolucao.label', default: 'Devolucao'), params.id])}" redirect(action: "show", id: params.id) } } else { flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'devolucao.label', default: 'Devolucao'), params.id])}" redirect(action: "list") } } }

Listagem 40. Controlador ProdutoController.groovy __________________________________package makeup.erp import grails.converters.JSON; class ProdutoController {

114

def scaffold = Produto def produtoByBarCode = { def produto = Produto.findByBarCode(params.barCode) def produtoId = produto == null ? null : produto.id render(contentType:"application/json", text:"${produtoId}") } def produtoById = { def produto = Produto.findById(params.idProduto) render produto as JSON } def search = { def query = params.q if(query){ def srchResults = Produto.search('*'+query+'*') render(view: "list", model: [produtoInstanceList:srchResults.results, produtoInstanceTotal:srchResults.total]) }else{ redirect(action: "list") } } }

Listagem 41. Controlador UsuarioController.groovy __________________________________package makeup.erp class UsuarioController { def scaffold = Usuario def springSecurityService static allowedMethods = [save: "POST", update: "POST", delete: "POST"] def index = { redirect(action: "list", params: params) } def list = { params.max = Math.min(params.max ? params.int('max') : 10, 100) [usuarioInstanceList: Usuario.list(params), usuarioInstanceTotal: Usuario.count()] } def search = { def query = params.q if(query){ def srchResults = Usuario.search('*'+query+'*')

115

render(view: "list", model: [usuarioInstanceList:srchResults.results, usuarioInstanceTotal:srchResults.total]) }else{ redirect(action: "list") } } def create = { def usuarioInstance = new Usuario() usuarioInstance.properties = params return [usuarioInstance: usuarioInstance] } def save = { def usuarioInstance = new Usuario(params) usuarioInstance.password = springSecurityService.encodePassword(usuarioInstance.password) if (usuarioInstance.save(flush: true)) { if (!usuarioInstance.authorities.contains(usuarioInstance.papel)) { UsuarioPapel.create usuarioInstance, usuarioInstance.papel } flash.message = "${message(code: 'default.created.message', args: [message(code: 'usuario.label', default: 'Usuario'), usuarioInstance.id])}" redirect(action: "show", id: usuarioInstance.id) } else { render(view: "create", model: [usuarioInstance: usuarioInstance]) } } def show = { def usuarioInstance = Usuario.get(params.id) if (!usuarioInstance) { flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'usuario.label', default: 'Usuario'), params.id])}" redirect(action: "list") } else { [usuarioInstance: usuarioInstance] } } def edit = { def usuarioInstance = Usuario.get(params.id) if (!usuarioInstance) {

116

flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'usuario.label', default: 'Usuario'), params.id])}" redirect(action: "list") } else { return [usuarioInstance: usuarioInstance] } } def update = { def usuarioInstance = Usuario.get(params.id) if (usuarioInstance) { if (params.version) { def version = params.version.toLong() if (usuarioInstance.version > version) { usuarioInstance.errors.rejectValue("version", "default.optimistic.locking.failure", [message(code: 'usuario.label', default: 'Usuario')] as Object[], "Another user has updated this Usuario while you were editing") render(view: "edit", model: [usuarioInstance: usuarioInstance]) return } } Papel papelAntigo = usuarioInstance.papel def senhaAntiga = usuarioInstance.password usuarioInstance.properties = params if (!senhaAntiga.equals(usuarioInstance.password)) { usuarioInstance.password = springSecurityService.encodePassword(usuarioInstance.password) } if (!usuarioInstance.hasErrors() && usuarioInstance.save(flush: true)) { if (!usuarioInstance.authorities.contains(usuarioInstance.papel)) { UsuarioPapel.create usuarioInstance, usuarioInstance.papel } if (!usuarioInstance.authorities.contains(papelAntigo)) { UsuarioPapel.remove usuarioInstance, papelAntigo } flash.message = "${message(code: 'default.updated.message', args: [message(code: 'usuario.label', default: 'Usuario'), usuarioInstance.id])}"

117

redirect(action: "show", id: usuarioInstance.id) } else { render(view: "edit", model: [usuarioInstance: usuarioInstance]) } } else { flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'usuario.label', default: 'Usuario'), params.id])}" redirect(action: "list") } } def delete = { def usuarioInstance = Usuario.get(params.id) if (usuarioInstance) { try { usuarioInstance.delete(flush: true) flash.message = "${message(code: 'default.deleted.message', args: [message(code: 'usuario.label', default: 'Usuario'), params.id])}" redirect(action: "list") } catch (org.springframework.dao.DataIntegrityViolationException e) { flash.message = "${message(code: 'default.not.deleted.message', args: [message(code: 'usuario.label', default: 'Usuario'), params.id])}" redirect(action: "show", id: params.id) } } else { flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'usuario.label', default: 'Usuario'), params.id])}" redirect(action: "list") } } }

Listagem 42. Controlador VendaController.groovy __________________________________package makeup.erp class VendaController { static allowedMethods = [save: "POST", update: "POST", delete: "POST"] def index = { redirect(action: "list", params: params)

118

} def list = { params.max = Math.min(params.max ? params.int('max') : 10, 100) [vendaInstanceList: Venda.list(params), vendaInstanceTotal: Venda.count()] } def search = { def query = params.q if(query){ def srchResults = Venda.search('*'+query+'*') render(view: "list", model: [vendaInstanceList:srchResults.results, vendaInstanceTotal:srchResults.total]) }else{ redirect(action: "list") } } def create = { def vendaInstance = new Venda() vendaInstance.properties = params return [vendaInstance: vendaInstance] } def save = { def vendaInstance = new Venda(params) def adicionouSucesso = true Venda.withTransaction() { status -> adicionouSucesso = adicionarItens(vendaInstance, params) if (!adicionouSucesso) { status.setRollbackOnly(); } } if (adicionouSucesso && vendaInstance.save(flush: true)) { flash.message = "${message(code: 'default.created.message', args: [message(code: 'venda.label', default: 'Venda'), vendaInstance.id])}" redirect(action: "show", id: vendaInstance.id) } else { render(view: "create", model: [vendaInstance: vendaInstance]) } } def adicionarItens(venda, params) { def itemCount = params["produtoCount"].toInteger() def success = true for (int i = 0; i < itemCount; i++) { def itemArr = params["itensVenda[" + i + "]"]

119

if ( itemArr != null) { Produto produto = Produto.get(itemArr.produto.toInteger()) ItemVenda itemVenda = new ItemVenda(itemArr) itemVenda.venda = venda itemVenda.produto = produto itemVenda.sequencia = i def quantidadeAnterior = produto.quantidade def novaQuantidade = quantidadeAnterior itemVenda.quantidade if (novaQuantidade < 0) { venda.errors.rejectValue("itens", "Produto " + produto.descricao + " com quantidade insuficiente. Existem " + quantidadeAnterior + " unidades desse produto em estoque.") success = false } else { produto.quantidade = novaQuantidade produto.save(); } venda.addToItens(itemVenda) } } return success } def show = { def vendaInstance = Venda.get(params.id) if (!vendaInstance) { flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'venda.label', default: 'Venda'), params.id])}" redirect(action: "list") } else { [vendaInstance: vendaInstance] } } def edit = { def vendaInstance = Venda.get(params.id) if (!vendaInstance) { flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'venda.label', default: 'Venda'), params.id])}" redirect(action: "list") } else { return [vendaInstance: vendaInstance] } }

120

def update = { def vendaInstance = Venda.get(params.id) if (vendaInstance) { if (params.version) { def version = params.version.toLong() if (vendaInstance.version > version) { vendaInstance.errors.rejectValue("version", "default.optimistic.locking.failure", [message(code: 'venda.label', default: 'Venda')] as Object[], "Another user has updated this Venda while you were editing") render(view: "edit", model: [vendaInstance: vendaInstance]) return } } vendaInstance.properties = params if (!vendaInstance.hasErrors() && vendaInstance.save(flush: true)) { flash.message = "${message(code: 'default.updated.message', args: [message(code: 'venda.label', default: 'Venda'), vendaInstance.id])}" redirect(action: "show", id: vendaInstance.id) } else { render(view: "edit", model: [vendaInstance: vendaInstance]) } } else { flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'venda.label', default: 'Venda'), params.id])}" redirect(action: "list") } } def delete = { def vendaInstance = Venda.get(params.id) if (vendaInstance) { try { Iterator iterator = vendaInstance.itens.iterator() while (iterator.hasNext()) { ItemVenda itemVenda = iterator.next() itemVenda.produto.quantidade += itemVenda.quantidade itemVenda.produto.save() iterator.remove() itemVenda.delete() }

121

vendaInstance.delete(flush: true) flash.message = "${message(code: 'default.deleted.message', args: [message(code: 'venda.label', default: 'Venda'), params.id])}" redirect(action: "list") } catch (org.springframework.dao.DataIntegrityViolationException e) { flash.message = "${message(code: 'default.not.deleted.message', args: [message(code: 'venda.label', default: 'Venda'), params.id])}" redirect(action: "show", id: params.id) } } else { flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'venda.label', default: 'Venda'), params.id])}" redirect(action: "list") } } }

Listagem 43. Controlador LoginController.groovy __________________________________import grails.converters.JSON import javax.servlet.http.HttpServletResponse import org.codehaus.groovy.grails.plugins.springsecurity.SpringSecurityUtils import org.springframework.security.authentication.AccountExpiredException import org.springframework.security.authentication.CredentialsExpiredException import org.springframework.security.authentication.DisabledException import org.springframework.security.authentication.LockedException import org.springframework.security.core.context.SecurityContextHolder as SCH import org.springframework.security.web.WebAttributes import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter class LoginController { /** * Dependency injection for the authenticationTrustResolver. */ def authenticationTrustResolver /** * Dependency injection for the springSecurityService. */ def springSecurityService /**

122

* Default action; redirects to 'defaultTargetUrl' if logged in, /login/auth otherwise. */ def index = { if (springSecurityService.isLoggedIn()) { redirect uri: SpringSecurityUtils.securityConfig.successHandler.defaultTargetUrl } else { redirect action: auth, params: params } } /** * Show the login page. */ def auth = { def config = SpringSecurityUtils.securityConfig if (springSecurityService.isLoggedIn()) { redirect uri: config.successHandler.defaultTargetUrl return } String view = 'auth' String postUrl = "${request.contextPath}${config.apf.filterProcessesUrl}" render view: view, model: [postUrl: postUrl, rememberMeParameter: config.rememberMe.parameter] } /** * Login page for users with a remember-me cookie but accessing a IS_AUTHENTICATED_FULLY page. */ def full = { def config = SpringSecurityUtils.securityConfig render view: 'auth', params: params, model: [hasCookie: authenticationTrustResolver.isRememberMe(SCH.context?.authentication), postUrl: "${request.contextPath}${config.apf.filterProcessesUrl}"] } /** * Callback after a failed login. Redirects to the auth page with a warning message. */ def authfail = {

123

def username = session[UsernamePasswordAuthenticationFilter.SPRING_SECURITY_LAST_USERNAME_ KEY] String msg = '' def exception = session[WebAttributes.AUTHENTICATION_EXCEPTION] if (exception) { if (exception instanceof AccountExpiredException) { msg = SpringSecurityUtils.securityConfig.errors.login.expired } else if (exception instanceof CredentialsExpiredException) { msg = SpringSecurityUtils.securityConfig.errors.login.passwordExpired } else if (exception instanceof DisabledException) { msg = SpringSecurityUtils.securityConfig.errors.login.disabled } else if (exception instanceof LockedException) { msg = SpringSecurityUtils.securityConfig.errors.login.locked } else { msg = SpringSecurityUtils.securityConfig.errors.login.fail } } if (springSecurityService.isAjax(request)) { render([error: msg] as JSON) } else { flash.message = msg redirect action: auth, params: params } } /** * The Ajax success redirect url. */ def ajaxSuccess = { render([success: true, username: springSecurityService.authentication.name] as JSON) } /** * The Ajax denied redirect url. */ def ajaxDenied = { render([error: 'access denied'] as JSON) } }

124

Listagem 44. Controlador LogoutController.groovy __________________________________import org.codehaus.groovy.grails.plugins.springsecurity.SpringSecurityUtils class LogoutController { /** * Index action. Redirects to the Spring security logout uri. */ def index = { // TODO put any pre-logout code here redirect uri: SpringSecurityUtils.securityConfig.logout.filterProcessesUrl // '/j_spring_security_logout' } }

Os arquivos de configurao do sistema makeup-erp. Listagem 45. Arquivo de configurao BootStrap.groovy ____________________________import import import import advogasystem.Cliente; seguranca.Papel; seguranca.Usuario; seguranca.UsuarioPapel;

import grails.util.GrailsUtil;

class BootStrap { def springSecurityService def init = { servletContext ->

def userRole = Papel.findByAuthority('ROLE_USUARIO') ?: new Papel(authority: 'ROLE_USUARIO').save(failOnError: true) def adminRole = Papel.findByAuthority('ROLE_ADMIN') ?: new Papel(authority: 'ROLE_ADMIN').save(failOnError: true) def adminUser = Usuario.findByUsername('admin') ?: new Usuario( username: 'admin', password: springSecurityService.encodePassword('admin'), papel: adminRole, enabled: true).save(failOnError: true) if (!adminUser.authorities.contains(adminRole)) { UsuarioPapel.create adminUser, adminRole }

125

} def destroy = { } }

Listagem 46. Arquivo de configurao BuildConfig.groovy ____________________________grails.project.class.dir = "target/classes" grails.project.test.class.dir = "target/test-classes" grails.project.test.reports.dir = "target/test-reports" //grails.project.war.file = "target/${appName}-${appVersion}.war" grails.project.dependency.resolution = { // inherit Grails' default dependencies inherits("global") { // uncomment to disable ehcache // excludes 'ehcache' } log "warn" // log level of Ivy resolver, either 'error', 'warn', 'info', 'debug' or 'verbose' repositories { grailsPlugins() grailsHome() grailsCentral() // uncomment the below to enable remote dependency resolution // from public Maven repositories //mavenLocal() //mavenCentral() //mavenRepo "http://snapshots.r