FACULDADE CATLICA DO TOCANTINS BACHARELADO EM SISTEMAS DE INFORMAO

FELIPE AUGUSTO FEITOSA

DESENVOLVIMENTO DE SOFTWARE COM O FRAMEWORK GRAILS: Sistema de Gerenciamento do Processo de Criao de Produtos Publicitrios

PALMAS 2012

FELIPE AUGUSTO FEITOSA

DESENVOLVIMENTO DE SOFTWARE COM O FRAMEWORK GRAILS: Sistema de Gerenciamento do Processo de Criao de Produtos Publicitrios
Trabalho apresentado como requisito parcial de avaliao da disciplina de Trabalho de Concluso de Curso do curso de Sistemas de Informao da Faculdade Catlica do Tocantins FACTO. Orientadora: Professora Especialista Thatiane de Oliveira Rosa

PALMAS 2012

ABSTRACT

In recent years, the job market has been demanding greater flexibility and efficiency in the process of developing information systems, in consequence, the frameworks has emerged that aim to offer the developer tools and standards that help to meet the needs and requirements imposed by the market. One cant deny that in the current scenario, the Java platform is very important to offer a wide array of tools, so compared to other technology systems development. Moreover, Java presents a series of problems such as complexity in developing systems for the web. Thus, it becomes difficult to meet the requirements imposed by the labor market, without sacrificing productivity provided by Java. Therefore, in order to solve the problem of complexity in Java development for web frameworks and languages were created alternatives that leverage the full potential of the platform, Java, however with higher productivity. From this it appeared that Grails is a framework that is intended to allow systems to be developed in an agile and simple, based on the Groovy programming language, which runs on the JVM. Thus, this work has as main goal to present a study on the Grails framework, and demonstrate the process of developing a system to streamline and automate the process of managing the creation of products for an advertising agency.

Keywords: Framework, Grails, Agile Development.

RESUMO

Nos ltimos anos, o mercado de trabalho vem exigindo maior agilidade e eficincia no processo de desenvolvimento de sistemas de informao, em decorrncia disto, surgiram os frameworks, que tm como objetivo oferecer ao desenvolvedor ferramentas e padres, que o auxiliem a atender s necessidades e exigncias impostas pelo mercado. No se pode negar, que no cenrio atual, a plataforma Java muito importante, por oferecer uma vasta quantidade de ferramentas, isso se comparada a outras tecnologias de desenvolvimento de sistemas. Por outro lado, Java apresenta uma srie de problemas, como por exemplo, a complexidade no desenvolvimento de sistemas para a web. Desta forma, torna-se difcil atender s necessidades impostas pelo mercado de trabalho, sem abrir mo da produtividade proporcionada por Java. Por tanto, com o objetivo de solucionar o problema de complexidade do desenvolvimento em Java para web, foram criados frameworks e linguagens alternativas, que aproveitam todo o potencial da plataforma, Java, entretanto com maior produtividade. A partir disto, surgiu o Grails que um framework, que tem o intuito permitir que sistemas sejam desenvolvidos de forma gil e simples, baseando-se na linguagem de programao Groovy, a qual roda sobre a JVM. Desta forma, este trabalho possui como objetivo principal apresentar um estudo sobre o framework Grails, assim como demonstrar o processo de desenvolvimento de um sistema para otimizar e automatizar o gerenciamento do processo de criao de produtos de uma agncia de publicidade.

Palavras-chave: Framework, Grails, Desenvolvimento gil.

LISTA DE ILSUTRAES

Figura 1 - Ciclo de vida do modelo espiral (Modificado de SOMMERVILLE, 2010, p. 33) 13 Figura 2 - Estrutura de diretrios do Grails. .............................................................. 22 Figura 3 - Criao do projeto em Grails. ................................................................... 25 Figura 4 - Executando a aplicao. .......................................................................... 25 Figura 5 - Aplicao em execuo. .......................................................................... 26 Figura 6 - Criao da classe de domnio. ................................................................. 27 Figura 7 - Criao do controlador ............................................................................. 27 Figura 8 - Apresentao do controler ....................................................................... 28 Figura 9 - Casse de domnio: CadastraContato ....................................................... 29 Figura 10 - Controlador: CadastraContato .............................................................. 29 Figura 11 - Tela de cadastro ................................................................................... 30 Figura 12 - Configurao do driver de conexo do banco de dados. ...................... 30 Figura 13 - Ambientes do banco de dadados. ......................................................... 31 Figura 14 - GSPs do controle CadastraContato ..................................................... 32 Figura 15 - Cdigo dos campos nome .................................................................... 33 Figura 16 - Instalando plug-in .................................................................................. 33 Figura 17 - Diagrama de caso de uso geral ............................................................ 38 Figura 18 - Mdulo a ser desenvolvido ................................................................... 40 Figura 19 - Diagrama de classe do mdulo desenvolvido ....................................... 41 Figura 20 - Classe de domnio do Produto .............................................................. 42 Figura 21 - Classe de domnio do Atributo .............................................................. 42 Figura 22 - Classe de domnio do Valor do Atributo ................................................ 42 Figura 23 - Classe de domnio Processo ................................................................ 43 Figura 24 - Classe de domnio Movimentao ........................................................ 43 Figura 25 - Classe de servio de transaes mtodo saveProduto() ................... 44 Figura 26 - Controlador produto Action save ........................................................ 44 Figura 27 - Tela de login ......................................................................................... 45 Figura 28 - View login.gsp ....................................................................................... 46 Figura 29 - Controlador Login Action authenticate ............................................... 47 Figura 30 - Tela Gerenciar Produto ......................................................................... 47 Figura 31 - View create da ptina Gerenciar Produto ............................................. 48 Figura 32 - Tela Visualizar Produto ......................................................................... 49 Figura 33 - Tela de ilustrao do caso de uso Gerenciar Produto .......................... 57 Figura 34 - Tela de ilustrao do caso de uso Visualizar Produto .......................... 59 Figura 35 - Tela de ilustrao do caso de uso Listar Processo ............................... 61 Figura 36 - Tela de ilustrao do caso de uso Inserir Processo .............................. 63 Figura 37 - Tela de ilustrao do caso de uso Visualizar Processo ........................ 65 Figura 38 - Tela de ilustrao do caso de uso Excluir Processo ............................. 67 Figura 39 - Tela de ilustrao do caso de uso Inserir Movimentao ..................... 69 Figura 40 - Tela de ilustrao do caso de uso Visualizar Movimentao ................ 71 Figura 41 - Diagrama de Sequncia do requisito Visualizar Produto ...................... 73 Figura 42 - Diagrama de Sequncia do requisito Inserir movimentao ................. 74

LISTA DE ABREVIATURAS E SIGLAS

COC - Convention Over Configuration CRUD - Create - Read - Update - Delete DI - Dependency Injection DRY - Don't Repeat Yourself GGTS - Groovy/Grails Tool Suite GORM - Grails Object Relational Mapping Grant - Groovy Ant GSP - Groovy Server Pages HTML - HyperText Markup Language IDE - Integrated Development Enveronment IoC - Invertion of Control JDBC - Java Database Connectivity JDK - Java Development Kit JSP - Java Server Pages JVM Java Virtual Machine MVC - Model View Controller ORM - Objetc Relational Mapping RoR - Ruby on Rails SQL - Structured Query Language UML - Unified Modeling Language XML - Extensible Markup Language

SUMRIO

1. INTRODUO ..................................................................................................... 9 1.1. Contexto ........................................................................................................ 9 1.2. Objetivos ..................................................................................................... 10 1.2.1. Objetivo Geral ....................................................................................... 10 1.2.2. Objetivos Especficos ............................................................................ 10 1.3. Justificativas ................................................................................................ 11 2. REFERENCIAL TERICO ................................................................................. 12 2.1. Processo de Desenvolvimento gil ............................................................. 12 2.2. Frameworks de Desenvolvimento gil ........................................................ 14 2.3. Framework Grails ........................................................................................ 15 2.3.1. Definio ............................................................................................... 16 2.3.1.1. Origem do Framework .................................................................... 16 2.3.1.2. Groovy ............................................................................................ 17 2.3.2. Principais Tecnologias Relacionadas ................................................... 18 2.3.2.1. Spring ............................................................................................. 18 2.3.2.2. Hibernate ........................................................................................ 18 2.3.2.3. SiteMesh ........................................................................................ 19 2.3.2.4. Outras tecnologias.......................................................................... 19 2.3.3. Funcionamento ..................................................................................... 20 2.3.3.1. Grails .............................................................................................. 20 2.3.3.2. Estrutura de Diretrios .................................................................... 21 2.3.3.3. Persistncia de Dados.................................................................... 23 2.3.3.4. Scaffold .......................................................................................... 23 2.3.3.5. Camada de Visualizao ................................................................ 24 2.4. Estudo de Caso Aplicao Agenda Desenvolvida em Grails ................... 24 2.4.1.1. Preparao do Ambiente ................................................................ 25 2.4.1.2. Classes de Domnio e Controladores ............................................. 26 2.4.1.3. Conexo com o Banco de Dados ................................................... 30 2.4.1.4. Camada de Visualizao da Aplicao .......................................... 32 2.4.1.5. Pluglins ........................................................................................... 33 3. Metodologia ....................................................................................................... 35 4. DESENVOLVIMENTO ....................................................................................... 37 4.1. Memora Inteligncia Grfica ........................................................................ 37 4.2. Viso Geral do Sistema ............................................................................... 37 4.3. Mdulo de Gerenciamento do Processo de Criao de Produtos ............... 39 4.4. Utilizao do Grails para Desenvolvimento do Mdulo de Gerenciamento do Processo de Criao de Produtos ......................................................................... 40 4.4.1. Classes de Domnio e Controladores ................................................... 40 4.4.2. Views .................................................................................................... 45 5. CONSIDERAES FINAIS ............................................................................... 50 6. REFERNCIAS.................................................................................................. 52 7. ANEXO A ........................................................................................................... 55 7.1. Requisitos funcionais ................................................................................... 55 7.1.1. Requisitos Funcionais ........................................................................... 55 7.1.2. Requisitos No-Funcionais ................................................................... 56

7.2. Caso de uso expandido e Wireframe do Mdulo de Gerenciamento do Processo de Criao de Produtos ......................................................................... 56 7.2.1. Gerenciar Produto ................................................................................. 56 7.2.2. Visualizar Produto ................................................................................. 58 7.2.3. Listar Processo ..................................................................................... 60 7.2.4. Inserir Processo .................................................................................... 62 7.2.5. Visualizar Processo .............................................................................. 64 7.2.6. Excluir Processo ................................................................................... 66 7.2.7. Inserir Movimentao ............................................................................ 68 7.2.8. Visualizar Movimentao ...................................................................... 70 7.3. Diagrama de Sequncias e Contratos ......................................................... 72 7.3.1. Visualizar Produto ................................................................................. 72 7.3.2. Inserir Movimentao ............................................................................ 73

1.

INTRODUO

1.1.

Contexto

O mercado de trabalho vem exigindo, cada vez mais, que os sistemas de informao sejam desenvolvidos com maior qualidade, agilidade e eficincia. Neste sentindo, visando atender a esta necessidade latente, foram criados os frameworks, que consistem em tecnologias, que objetivam oferecer ao desenvolvedor ferramentas e padres, que o auxiliem a atender s exigncias impostas pelo mercado. Ainda importante ressaltar, que no contexto de desenvolvimento de sistemas de informao, a plataforma Java possui grande destaque, pelo fato de ser uma tecnologia robusta e que oferece recursos poderosos. Por outro lado, apresenta alguns problemas, se considerado contexto web, sendo complexa para

determinados procedimentos. Os frameworks permitem que os engenheiros de software preocupem-se pouco com a escrita de cdigo e os reaproveite bastante, assim como obtenham rpidos resultados. Desta forma, visando sanar os problemas do desenvolvimento web baseado em Java, surgiram diversos frameworks, dentre eles destaca-se o projeto Grails, que foi iniciado em 2005, baseado em outro framework denominado Ruby on Rails, alm disso, oferece vrias tecnologias necessrias para o

desenvolvimento de sistemas web como o Hibernate, Tomcat, SiteMesh, Spring e outras, o tornando um framework Ful Stack. Portanto, possvel afirmar que o framework Grails tem o objetivo de tornar o desenvolvimento web, baseado em Java, mais amigvel, rpido e eficiente, utilizando para isto a linguagem Groovy, que foi desenvolvida com o intuito de ser uma linguagem open source, que roda sobre a JVM (Java Virtual Machine) e permite desfrutar de todo o poder proporcionado pelas bibliotecas e scripts, desenvolvidos em Java. Rocher (2006) considera Grails a prxima gerao de framework de aplicaes web para Java, que utilizando a linguagem Groovy, prove simplicidade e a conveno. A partir disto, o trabalho em questo prope o estudo do framework Grails como uma alternativa para desenvolvimento de sistemas de forma gil, a fim

10

de compreender a sua forma de trabalho e organizao, assim como sua as vantagens e desvantagens, quando comparado a outros frameworks disponveis no mercado. Para tanto, com a finalidade de constatar a agilidade e dinamicidade promovidas pelo framework em questo, prope-se ainda desenvolver um sistema para a agncia de publicidade Memora Inteligncia Grfica. A agncia de publicidade Memora Inteligncia Grfica, vem crescendo muito desde 2005 e aumentando suas demandas de atividades, o que por sua vez, exige maior controle e criteriosidade na produo de seus produtos. Neste contexto, o sistema a ser desenvolvido, visa automatizar e permitir melhor gerenciamento de diversas tarefas e prticas, que atualmente so realizadas de forma manual, via email e telefone, assim como presencialmente. Dentre as tarefas que sero consideradas durante a anlise para serem automatizadas, com a finalidade de proporcionar maior agilidade e confiabilidade, destacam-se: coleta de informaes relativas ao produto a ser desenvolvido; e acompanhamento das alteraes do mesmo.

1.2.

Objetivos

1.2.1. Objetivo Geral

Este trabalho possui como objetivo principal apresentar um estudo sobre o framework Grails, assim como apresentar o processo de desenvolvimento de um sistema para otimizar e automatizar o gerenciamento do processo de criao de produtos de uma empresa de publicidade.

1.2.2. Objetivos Especficos

11

Realizar um estudo terico do framework Grails, e a partir disto um

comparativo com os principais frameworks de desenvolvimento gil, disponveis no mercado; Apresentar um estudo prtico do framework Grails, demonstrando seu

funcionamento bsico, por meio de um estudo de caso; Desenvolver o mdulo de um sistema web, baseado em Grails, que atenda s

reais necessidades de gerenciamento do processo de criao de produtos, da empresa de publicidade Memora Inteligncia Grfica; Testar a eficincia do framework Grails, aplicado ao contexto da empresa de

publicidade;

1.3.

Justificativas

Com o avano da internet o mercado tecnolgico trouxe uma migrao dos sistemas desktop para os sistemas web, sendo necessrios recursos e ferramentas que permitam ao mercado de software realizar o processo de desenvolvimento de forma mais gil. Segundo Adriano Antunes (2011, p. 26), o framework Grails foi criado no intuito de fornecer um maior nvel de abstrao com o enfoque em simplificar e facilitar as configuraes e aproveitar mais a sintaxe bem expressiva e limpa da linguagem dinmica Groovy. Desta forma, o Grails apresenta-se como uma soluo gil para ser utilizada com a plataforma Java na web, com o objetivo de deixar os programadores menos preocupados com detalhes desnecessrios (como configurao de XML (Extensible Markup Language), funcionalidades bsicas de controle e a criao do layout bsico de apresentao), que consomem o tempo do que realmente importante, tornando novamente o desenvolvimento da robusta e poderosa plataforma Java mais divertida. Desta maneira, pode-se criar ou melhorar (assim como reaproveitar cdigos Java j existentes) de uma forma mais prtica, sistemas j atuantes em empresas assim como desenvolver, de acordo com a necessidade, novos sistemas de forma mais gil atendendo demandas em curto prazo.

12

2.

REFERENCIAL TERICO

2.1.

Processo de Desenvolvimento gil

Por volta de 2001 profissionais da rea de tecnologia da informao perceberam que o processo de desenvolvimento de sistemas de informao estava se tornando muito burocrtico, a partir disto, alguns especialistas sem reuniram para propor alguns princpios e valores para agilizar tal processo de desenvolvimento, tendo como base suas prprias experincias com programao. Em conjunto, tais especialistas, baseando-se nas teorias e prticas dominadas por cada um, concordaram que, normalmente, os projetos de sucesso tinham um conjunto de princpios em comum, desta forma, com base nestes princpios foi criado o Manifesto de Desenvolvimento gil de Software, mais conhecido como Manifesto gil. Sendo assim, o termo desenvolvimento gil refere-se a metodologias de desenvolvimento, que adotam os valores do manifesto gil, que de acordo com a Agile Manifesto (2001), so: Indivduos e interao so mais importantes que processos e ferramentas; Software em funcionamento mais importante que documentao

abrangente; Colaborao do cliente mais importante que negociao de contratos; Responder a mudanas mais importante que seguir um plano. Devido s caractersticas do processo de desenvolvimento gil, o modelo de

desenvolvimento adotado o espiral, onde as etapas do modelo em cascata so executadas vrias vezes, ao longo de todo o processo de desenvolvimento do sistema. Desta forma, ao final de cada ciclo, obtm-se um software funcional, testado e aprovado. O Modelo espiral evolucionrio, pois combina a natureza iterativa da prototipagem, com o intuito de diminuir riscos. Desta forma, o processo de desenvolvimento representado por uma espiral dividida em quatro quadrantes, onde em cada uma abordado um aspecto do processo de desenvolvimento:

13

1.

Determinao dos objetos, alternativas e restries: onde so identificados os

objetivos especficos para a etapa, assim como as alternativas para realizar os objetivos e restries; 2. Anlise das alternativas e identificao e/ou resoluo de riscos: onde so

identificados os riscos principais, assim como analisadas e definidas maneiras para reduzir tais riscos; 3. Desenvolvimento e validao da verso corrente do produto: nesta etapa

escolhido um modelo apropriado para o desenvolvimento, podendo ser qualquer um dos modelos de ciclo de vida; 4. Planejamento: O projeto revisado, podendo dar incio ao prximo passo do

ciclo espiral planejado.

Figura 1 -

Ciclo de vida do modelo espiral (Modificado de SOMMERVILLE, 2010, p. 33)

Assim como pode ser verificado na figura 1, com o modelo espiral, o software desenvolvido em vrias verses evolucionrias, podendo elas serem, de incio, modelos em papel ou prototipagem, e durante as ltimas iteraes, serem produzidas verses cada vez mais completas do sistema, fazendo com que o desenvolvedor e o cliente o entendam melhor, alm de permitir que os riscos sejam melhor tratados em cada nvel evolucionrio. A seo seguinte abordar alguns dos diversos frameworks de

desenvolvimento gil existentes no mercado atual, que apresentam solues similares ao framework Grails, que objeto de estudo deste trabalho.

14

2.2.

Frameworks de Desenvolvimento gil

Atualmente, existem diversos frameworks que prometem agilizar o processo de desenvolvimento de sistemas utilizando algumas tecnologias, tais como: o padro MVC (Model View Controller Modelagem, Visualizao e Controle); o modelo COC (Convention Over Configuration conveno sobre configurao); o framework hibernate, entre outras ferramentas. Desta forma, baseando-se em pesquisas bibliogrficas, os principais frameworks de desenvolvimento gil disponvel no mercado hoje so:

Django: escrito na linguagem Phyton foi desenvolvido para criaes rpidas

de aplicaes web, utilizando os padres MVC, ORM (Objetc Relational Mapping Mapeamento Objeto-Relacional) e DRY (Dont Repeat Yourself No se repita). O mesmo possui o objetivo de reduzir o tempo, e automatizar as tarefas, que os programadores teriam que executar para tornar a aplicao funcional (DJANGO BRASIL, 2012);

Rails ou RoR (Ruby

on Rails): foi criado com o intuito de aumentar a

velocidade e facilidade no desenvolvimento de sistemas web. Rails foi desenvolvido sobre Ruby , que uma linguagem robusta, orientada a objetos e bem gil, que tambm utiliza os padres MVC, ORM e DRY, entre outros (RUBY ON RAILS, 2012);

VRaptor: um framework desenvolvido no Brasil, que tem como intuito prover

um desenvolvimento de sistemas web de forma gil, utilizando a linguagem Java. uma tecnologia nova, e que tende a crescer cada vez mais (VRAPTOR, 2012);

seu

CakePHP: assim como o nome sugere, um framework escrito em PHP, e principal objetivo fornecer aos programadores uma estrutura de

desenvolvimento de sistemas robustos e de forma rpida. Ele utiliza padres de projetos conhecidos, tais como ActiveRecord, Assossiation Data Mapping, Front Controller e MVC (CAKE PHP, 2012);

Codieigniter: tambm utiliza a linguagem PHP para o desenvolvimento de

suas aplicaes web, e por meio de sua vasta quantidade de bibliotecas, tem como

15

objetivo promover um desenvolvimento de sistemas bem simples e gil, permitindo ao programador concentrar todo seu tempo em atividades mais teis e lgicas (CODIEIGNITER BRASIL, 2012);

JRuby : Foi criado para que os desenvolvedores possam implementar com a

linguagem Ruby para a plataforma Java, sendo ento possvel rodar na JVM (Java Virtual Machine) (JRUBY, 2012);

Grails: Foi desenvolvido pensando nos programadores e no mercado Java,

inspirado principalmente no Rails. Grails, antes chamado de Groovy on Rails, desenvolvido em Groovy, uma linguagem totalmente dinmica inspirada no Java, que os programadores carinhosamente afirmam ser um Java melhorado, tal afirmao realizada por ele rodar perfeitamente sobre a JVM, ganhando todo o poder que o Java fornece, como bibliotecas (GRAILS, 2012). Como visto, possvel verificar que existem atualmente vrios frameworks disponveis, de forma livre, para o desenvolvimento de sistemas web, os quais prometem um desenvolvimento gil. Mas apesar de todos servirem para o mesmo propsito, cada um reside sua preferncia e particularidade como a linguagem de programao. Dentre os frameworks de desenvolvimento gil expostos, este trabalho apresentar um estudo detalhado do Grails, desta forma, a prxima seo aborda sua definio, origem, principais tecnologias, dentre outras caractersticas.

2.3.

Framework Grails

Grails um framework para desenvolvimento de aplicaes web, que utiliza a linguagem dinmica groovy, originada da linguagem Java. Tal framework, por ter a pretenso de ser de alta produtividade, baseia-se no paradigma de conveno. Desta forma, para que seja possvel compreender melhor o objeto de estudo deste trabalho, esta seo abordar, de forma sucinta e didtica, o framework Grails, a linguagem dinmica Groovy, assim como algumas de suas principais tecnologias como Spring, Hibernate e SiteMesh. Alm disso, so apresentadas algumas de suas principais caractersticas de funcionamento, como a organizao da estrutura de diretrios, a persistncia de dados, scaffold e a camada de visualizao.

16

2.3.1. Definio

Grails tem como principal objetivo ser um framework open source de alta produtividade, e para isso ele utiliza tecnologias, tais como, os frameworks Hibernate e Spring, por meio de uma interface simples e consistente. O framework Grails utiliza o padro de desenvolvimento MVC (Model View Control) de forma natural, livrando o desenvolvedor dos detalhes complexos da persistncia de dados, assim como tambm fornecendo um template web para facilitar a implementao da interface com o usurio (ANTUNES, 2011, p. 26). Para que seja possvel melhor compreender como tal framework foi idealizado, a seo seguinte discorre o processo que originou o Grails.

2.3.1.1.

Origem do Framework

"Framework um conjunto de classes que colaboram para realizar uma responsabilidade para um domnio de um subsistema da aplicao." (FAYAD; SCHMIDT, 2007). Entende-se por framework um conjunto de classes e bibliotecas, que auxiliam no desenvolvimento de software, que tem por objetivo poupar trabalho na execuo de procedimentos repetitivos, mas que so importantes (DEPA, 2010), como por exemplo, as configuraes do projeto de software. Muitos destes procedimentos repetitivos j so executados, de forma automtica, pela maioria dos frameworks existentes atualmente. Com a popularizao do Ruby on Rails em 2006, a programao para web tonou-se mais gil, por adotar princpios geis como o DRY e CoC (Convention Over Configuration - Conveno sobre Configurao), que tratam respectivamente sobre o reaproveitamento de cdigo e o foco na conveno com o mnimo de configurao, utilizando a estrutura MVC como padro, passando assim a se tornar uma ameaa ao Java, por fornecer principalmente algumas caractersticas como plug-ins, Scaffold e expansividade. Neste contexto, plug-ins pode ser entendido

17

como componentes pr-integrados, que eliminam a necessidade de associar cada componente de um projeto a uma aplicao. J Scaffold visa eliminar a repetio de tarefas, criando uma base para construo da aplicao. Por fim, a expansibilidade permite a criao de plug-ins, de maneira intuitiva, para recursos que a linguagem no suporta (ANTUNES, p. 24-25, 2011). Desta maneira, buscou-se algumas solues para manter a linguagem Java dentro do que o mercado precisava, e ao mesmo tempo, possibilitar a fcil utilizao de sua vasta quantidade de bibliotecas. A partir disto, surgiram os projetos JRuby e Jython, ambos usando as linguagens Ruby e Phyton, dentro da plataforma Java. Entretanto tais projetos no foram bem aceitos, por apresentarem muitas diferenas no cdigo, para quem estava acostumando com o Java. Sendo assim, a soluo idealizada foi a criao de um framework baseado em Ruby on Rails (RoR) utilizando a linguagem Groovy, que originada do Java, assim juntando Groovy com o Rails, surgi o Grails que veio para enfim manter a plataforma Java em nvel de competio com os novos modelos de desenvolvimento de softwares para web.

2.3.1.2.

Groovy

Em 2004, James Strachan, um programador experiente em Java, estava estudando a linguagem Phyton, e ao descobrir essa linguagem percebeu que seria interessante integrar linguagem Java algumas das caractersticas de Phyton, como por exemplo, o suporte sinttico para operaes habituais como tipos comuns e sua natureza dinmica. Portanto, Groovy foi criado com a inteno de se comunicar bem com Java, e adquirir caractersticas dinmicas e sintticas presentes nas linguagens como Phyton, Ruby e Smalltalk. Assim como Java, Groovy compilado em bytecode e executado sobre a JVM (Java Virtual Machine), sendo possvel importar objetos Java em Groovy e vice-versa. Alm disso, Groovy adota uma sintaxe que possibilita aumentar, de maneira significativa, a produtividade em tempo de execuo, permitindo assim que objetos sejam manuseados de forma que em Java seriam extremamente complicados (ANTUNES, 2011, p. 29-30; ROCHER, 2006, p. 17).

18

Aps compreender o conceito e origem do framework Grails, assim como da linguagem Groovy, a prxima seo apresenta as principais tecnologias

relacionadas a tal framework.

2.3.2. Principais Tecnologias Relacionadas

2.3.2.1.

Spring

O Spring um framework criado por Rod Jonhnson e descrito no seu livro, Expert One-on-One: J2EE Design e Development. Ele um poderoso container de injeo de dependncias, que tem como objetivo livrar o desenvolvedor de grandes trabalhos revivendo a questo da agilidade no desenvolvimento (SANTOS, 2012). Usado hoje por muitos em desenvolvimento de sistemas para a plataforma Java, o Spring uma ferramenta integrante do Grails, sendo assim, boa parte das funcionalidades que o Grails executa est ligado ao Spring e todo o poder de injeo de dependncias que ele oferece. importante ressalta, que o Spring baseado no princpio de Invertion of Control - IoC (Inverso de Controle), que tem a funo de retirar do programador o trabalho de acoplamento, e no princpio de Dependency Injection DI (Injeo de Dependncia), que encarregado de montar dependncias como bibliotecas que sero utilizadas em uma determinada classe, para que o desenvolvedor no perca tempo fazendo isso (ANTUNES, 2011, p. 37; (WALLS; BREIDENBACH 2005, p. 8; WEISSMANN, 2010).

2.3.2.2.

Hibernate

Com o objetivo de simplificar os processos de persistncia de dados, para a programao orientada a objetos, no modelo relacional de banco de dados, o Hibernate atua no Grails por meio do GORM (Grails Object Relational Mapping). Deste modo, auxilia o desenvolvedor a ter pouco trabalho com a escrita de cdigos

19

de acesso a banco de dados e de comandos SQL (Structured Query Language Linguagem de Consulta Estruturada), utilizando o padro de conveno para sua comunicao com as classes e as tabelas do banco (ANTUNES, 2011, p. 38).

2.3.2.3.

SiteMesh

SiteMesh consiste em um gerenciador e manipulador de layout, que foi criado pela OpenSymphony para auxiliar no desenvolvimento de layouts, que seguem o padro decorator, para sistemas grandes. Tal gerenciador auxilia na criao de templates com comandos e objetos padres livrando o desenvolvedor de criar manualmente tais estruturas bsicas. Vale ressaltar que, por padro, o SiteMesh vem configurado como o provedor de layout do Grails (DAVIS; RUDOLPH, 2010, p. 79; WEISSMANN, 2010).

2.3.2.4.

Outras tecnologias

O Grails por ser um framework Full Stack, oferece ao desenvolvedor as ferramentas necessrias para que a aplicao seja executada, sem a necessidade de realizar muitas configuraes. Desta forma, preciso apenas instalar o framework e criar o projeto, a partir disto, a aplicao j estar pronta para funcionar. importante ressaltar, que alm das tecnologias apresentadas, nas sees anteriores, o framework Grails baseia-se em outras, as quais tambm so muito importantes para o seu funcionamento (SANTOS, 2012). Dentre tais tecnologias, destacam-se:

Tomcat: Servidor web, que foi integrado ao framework Grails na verso 1.2,
tal fato possibilitou que no houvesse mais a necessidade de os desenvolvedores terem que instal-lo e configur-lo. No que se refere relao entre o Tomcat e o Grails, vale ainda ressaltar, que possvel realizar o deploy da aplicao, para isto, necessrio apenas configurar o arquivo config.groovy e, logo em seguida, executar o comando grails tomcat deploy.

20

H2 Database: Por padro, o Grails j trs consigo o banco de dados H2

configurado, para que seja possvel testar as aplicaes. Portanto, o mesmo vem junto ao pacote de instalao do framework e pr-configurado no arquivo DataSource.groovy. O H2 um banco de dados leve, o qual escrito em Java, sendo muito til para realizar testes de aplicaes de pequeno porte, desenvolvidas pelo Grails. Tal banco de dados armazena, em tempo de execuo, as informaes da aplicao em memria, entretanto possibilita que tais informaes tambm sejam armazenadas permanentemente no banco de dados, para isto, necessrio apenas indicar no arquivo DataSoruce.groovy como a aplicao deve se comportar.

JUnit: Para a realizao de testes de funcionamento da aplicao, o Grails

trouxe junto a si o JUnit criado para realizar testes automatizados na linguagem Java e gerar relatrios de resultados. Com ele pode-se realizar testes em mtodos de uma classe, verificando se o mesmo funciona da maneira esperada, exibindo possveis erros ou falhas. Aps conhecer as principais tecnologias que integram o framework Grails, a prxima seo discorre sobre o funcionamento do mesmo.

2.3.3. Funcionamento

2.3.3.1.

Grails

Para iniciar o estudo do framework Grails bastante interessante compreender os conceitos bsicos sobre as tecnologias apresentadas

anteriormente, como o Hibernate e Spring, assim como as linguagens Groovy e Java. Uma das principais caractersticas do Grails a agilidade, sendo esta percebida at mesmo no procedimento de instalao, visto que em poucos passos todo o ambiente est pronto para iniciar o desenvolvimento de uma aplicao. Basicamente, para que o framework Grails esteja pronto deve-se instalar o JDK (Java Development Kit) e configurar as variveis de ambiente para o Grails, assim como para o Java, informando o diretrio da pasta bin e do Grails_HOME. Pelo fato

21

de a linguagem Groovy compor as ferramentas integradas do framework no necessrio declarar as variveis de ambientes para ele. Alm disso, vale ressaltar ainda, que conforme explicitado anteriormente, pelo fato de o Grails ser um framework Full Stack, as ferramentas como Hibernate, Spring, H2 e SiteMesh j vm embutidas em seu pacote de instalao, no sendo necessrio que o desenvolvedor as configure. Com o Grails devidamente instalado e as variveis de ambiente configuradas, o desenvolvedor j est pronto para iniciar seu projeto. Como tal framework bastante completo e simples de se utilizar, todas as operaes necessrias podem ser realizadas utilizando o prompt de comando, mas as IDEs (Integrated Development Environment - Ambiente Integrado para Desenvolvimento) como Net Beans, Eclipse e a Spring Source Tool Suite (IDE feito pela empresa Spring baseada no eclipse), podem ser utilizadas para auxiliar no desenvolvimento do projeto, para isto, necessrio apenas configur-las para receber o Grails.

2.3.3.2.

Estrutura de Diretrios

Para criar um projeto em Grails de extrema importncia conhecer bem a sua estrutura de diretrios. Tal estrutura pode ser criada aps executar o comando grails create-app [nome da aplicao], dentro do diretrio com o nome escolhido para a aplicao, a partir disto, gerada a estrutura apresentada na figura 2.

22

Figura 2 -

Estrutura de diretrios do Grails.

Conforme ilustrado na figura 2, o primeiro diretrio da estrutura nomeado como grails-app, o mesmo contm os principais contedos do projeto, uma vez que 99% das classes criadas durante o desenvolvimento do sistema devero estar em um dos seus subdiretrios, os quais so discriminados a seguir. O subdiretrio grails-app/conf contm os arquivos de configurao do banco de dados e de inicializao do sistema (BootStrap), Hibertate, entre outras. J no subdiretrio grails-app/controllers so encontrados todos os controles da aplicao, onde os fluxos de informaes so gerenciados. No subdiretrio grails-app/domain esto as classes de domnio, so elas que representaro as tabelas do banco. J no subdiretrio grails-app/i18n so encontrados os Propers, que armazenam as mensagens do sistema e as linguagens textuais existentes. No subdiretrio grails-app/services so armazenados os servios (regras de negcios) desacoplados do contexto da aplicao, um exemplo seria uma classe que faz uma conexo secundria entre a aplicao e o banco de dados. O subdiretrio grails-app/taglib armazena todas as tags customizadas criadas usando o Grails. O subdiretrio grails-app/utils armazena os codecs, classes utilitrias e classes utilizadas por plug-ins. Por fim, no subdiretrio grails-app/views ficam todas as GSPs (Groovy Server Pages) que faro parte da aplicao.

23

O segundo diretrio apresentado o lib, que armazena todos os arquivos com extenso .jar, os quais fazem referncia a bibliotecas de terceiros, que sero utilizadas no sistema como o JDBC (Java Database Connectivity). O diretrio seguinte o scripts, no qual devem ser armazenados todos os scripts que sero utilizados para facilitar o desenvolvimento da aplicao. Todos os scripts para o Grails so desenvolvidos em Grant (Groovy Ant), que uma abstrao do Ant feita em Groovy. J no diretrio src devem ser armazenados os cdigos fonte que no se encaixam na estrutura de diretrios do Grails. Dentro deste diretrio h dois outros chamados de Java e Groovy, onde sero colocados os cdigos implementados em Java e os cdigos implementados em Groovy. O diretrio test responsvel por armazenar todos os testes unitrios, funcionais e de integrao do projeto. Por fim, o diretrio web-app contm todo o contedo esttico da aplicao como imagens e arquivos .html.

2.3.3.3.

Persistncia de Dados

O Grails oferece um conforto muito grande quando se trata de persistncia de dados, uma vez que trs consigo o banco de dados j configurado para testar as aplicaes em desenvolvimento. O mais interessante nisso que o desenvolvedor ter o mnimo de trabalho para configurar o processo de comunicao da aplicao com o banco de dados, uma vez que a mesma j criada de forma automtica, seguindo regras de conveno, tabelas e cdigos SQL padres. Vale ainda ressaltar, que o framework permite o acesso a base de dados legadas e gerao de comandos SQL para bancos de dados externos como o MySQL.

2.3.3.4.

Scaffold

24

Scaffold um recurso poderoso implementado pelas ferramentas de desenvolvimento gil, que surgiu para facilitar a criao de componentes da camada de visualizao e de controle da aplicao. Desta forma, o Scaffold cria toda a estrutura necessria retirando do desenvolvedor o trabalho de criar os componentes de controle da aplicao. Existem dois tipos de scaffold, o dinmico e o esttico. O scaffold dinmico responsvel por gerar toda a estrutura em memria, e o scaffold esttico, atravs do comando grails generate-all, cria as camadas de controllers e visualizao correspondentes s classes de domnios definidas. importante ressaltar, que o scaffold, criar o CRUD (Create Read Update Delete) da aplicao, dentro dos controladores (CALAHORRO, 2009 p. 29-31; SANTOS, 2010).

2.3.3.5.

Camada de Visualizao

Dentro do padro MVC, a camada de visualizao responsvel por toda a parte de apresentao da aplicao. Tal camada utiliza a tecnologia GSP (Groovy Server Pages), inspirada no JSP (Java Server Pages), que identificada nos arquivos html (HyperText Markup Language) pelas tags especficas indicadas por <g:>, que so responsveis por mostrarem os recursos exclusivos do Grails. Os arquivos gsp so armazenados dentro do diretrio grails-app/views, aps utilizar a funo scaffold com o comando grails generate-all. Aps apresentar o funcionamento do framework Grails, torna-se possvel ento apresentar um estudo de caso baseando-se na utilizao do mesmo, portanto, a prxima seo apresenta uma demonstrao simples da construo uma aplicao com o framework Grails.

2.4.

Estudo de Caso Aplicao Agenda Desenvolvida em Grails

Com base no que foi visto no decorrer do trabalho, esta seo apresenta o framework Grails de forma uma pouco mais prtica, sendo detalhados alguns dos

25

seus comportamentos, assim como a preparao do ambiente do projeto, as classes de controle e de domnio, configurao do banco de dados, a camada de visualizao e algumas outras funcionalidades.

2.4.1.1.

Preparao do Ambiente

Depois de configuradas as variveis de ambiente do Grails, o prximo passo acessar o prompt de comando, e navegar at o diretrio onde so armazenados os projetos baseados em Grails e digitar o seguinte comando: grails createapp [nome do projeto] para criar o projeto, conforme ilustrado na figura 3.

Figura 3 -

Criao do projeto em Grails.

Com a execuo deste comando, ser criada uma pasta no diretrio corrente com o nome escolhido. Feito isso, toda a estrutura do sistema j estar pronta. Neste momento, j possvel executar a aplicao com o comando grails runapp, que ela j estar pronta para funcionar normalmente, como ilustrado na figura 4. Isso concedido pelo fato de, como afirmado anteriormente, o Grails ser Full Stack e j trazer consigo todas as dependncias configuradas e funcionando, como por exemplo, o Tomcat, banco de dados H2, entre outras ferramentas necessrias.

Figura 4 -

Executando a aplicao.

26

Figura 5 -

Aplicao em execuo.

A figura 5 mostra a aplicao em funcionamento. Esta tela uma apresentao padro, oferecida pelo Grails que na rea Avaliable Controllers, lista os controladores gerados, entretanto como, at momento nenhum foi criado, a lista apresentada vazia. Alm disso, tal tela apresenta na rea Application Status, informaes tais como a verso do framework, quantidade de controllers que existem na aplicao, quantidade de domains, entre outras informaes. Alm disso, na rea Installed Plug-ins so identificados os pluguins que j esto configurados e prontos para uso.

2.4.1.2.

Classes de Domnio e Controladores

27

As classes de domnio representam as tabelas do banco de dados, sendo que as mesmas devem conter os atributos (colunas do banco) de uma determinada pgina. Para criar uma domain class necessrio executar o comando grails create-domain-class [nome da domain], como pode ser observado na figura 6.

Figura 6 -

Criao da classe de domnio.

Assim como pode ser verificado na figura 6, aps executar o comando, a domain criada no diretrio domain/agenda. Com a domain existente, necessrio agora criar o controlador relacionado a ela, tal procedimento pode ser realizado por meio do comando grails domain], conforme mostrado na figura 7. create-controller [nome da

Figura 7 -

Criao do controlador

Aps executado o comando o controlador da domain criado no diretrio controller/agenda. Conforme visto na figura 8, possvel perceber que aps a criao do controlador o mesmo apresentado na rea Available Controller.

28

Figura 8 -

Apresentao do controler

importante ressaltar que necessrio preencher os atributos da domain criada, neste caso, uma agenda, como nome, telefone, endereo e e-mail. Para tal fim, necessrio abrir o arquivo CadastraContato.groovy, que encontra-se dentro do diretrio domain/agenda, conforme mostra a figura 9:

29

Figura 9 -

Casse de domnio: CadastraContato

No controller ser adotado o scaffold dinmico, para que o CRUD seja gerado em memria, para tanto, deve-se implementar o controller conforme a ilustra a figura 10.

Figura 10 - Controlador: CadastraContato

Como visto na linha 3 do cdigo acima (figura 10), o scaffold dinmico ativado, ao atribuir o valor true. Vale ressaltar que possvel gerar o CRUD de forma esttica, ao executar o comando grails generate-all. Aps realizar todos os passos descritos anteriormente, possvel executar a aplicao para testar o controlador funcionando, com os atributos definidos na domain previamente criada. Aps executar o comando grails run-app, deve-se clicar no controller CadastraContato, e logo em seguida criar um contato, clicando no boto Novo CadastraContato, por conseguinte apresentada a tela de preenchimento dos dados um novo contato (Figura 11):

30

Figura 11 - Tela de cadastro

2.4.1.3.

Conexo com o Banco de Dados

O framework Grails traz consigo um arquivo de configurao para a conexo com o banco de dados. Conforme explicitado anteriormente, por padro, ele j vem configurado com o banco de dados H2, mas nada impede que possa ser utilizado outro banco de dados para a aplicao como o MySQL e Oracle. No arquivo DataSource.groovy, encontrado no diretrio grails-app/conf, so definidas todas as configuraes necessrias para que a conexo da aplicao com o banco de dados funcione corretamente.

Figura 12 - Configurao do driver de conexo do banco de dados.

31

Conforme pode ser observado na figura 12, bem simples a chamada do driver de conexo com o banco de dados. Na linha 3, varivel driverClassName atribudo o endereo do driver do banco escolhido, neste exemplo utilizado o drive do banco padro do framework (H2 Database). J os atributos username e password devem ser preenchidos de acordo como o que foi configurado no banco de dados escolhido, para que o sistema consiga estabelecer a conexo, como acessar o banco de forma correta.

Figura 13 - Ambientes do banco de dadados.

importante resslatar que o Grails j traz configurado 3 (trs) ambientes de execuso da aplicao, o ambiente de desenvolvimento, o de teste e o de produo. O Grails tambm permite que possa ser utilizado um banco de dados para cada ambiente, assim como aplicar configuraes de comportamentos diferentes, conforme pode ser observado nas linhas 17, 23 e 29 contidas na figura 13.

32

No momento da execuo da aplicao, necessrio informar qual ambiente ser utilizado, por padro o framework grails inicia a aplicao no modo de desenvolvimento, entretanto, caso seja necessrio, possvel configurar para que seja iniciada no ambiente de produo, com o comando grails prod run-app, ou ainda ao executar o comando grails test run-app, a aplicao ser iniciada no modo de teste. J o comando grails dev run-app fora a aplicao ser iniciada para o ambiente de desenvolvimento.

2.4.1.4.

Camada de Visualizao da Aplicao

Para a camada de visualizao da aplicao, existem duas maneiras de gerala, de forma esttica ou em memria, no decorrer do desenvolvimento do sistema, pode-se usar o modo dinmico para gerar as gsps (Groovy Server Page), mas quando partir para a modificao da estrutura das views, necessrio ger-las com o comando [grails generate-all], assim sero criadas, no diretrio grailsapp/view (como ilustra a figura 14). As views criadas nesse diretrio estaro diretamente ligadas a determinada closures das classes de controle, so elas as create.gsp, edit.gsp, list.gsp e show.gsp.

Figura 14 - GSPs do controle CadastraContato

Como mostra na figura 14, uma gsp chamada _form responsvel por criar os campos das telas de cadastro. Os arquivos da camada de visualizao foram separados desta forma a partir da verso 2.0 do grails, para facilitar a edio dos campos e desvincula-los da create.gsp. Pode-se observar um trecho do cdigo na figura 15 onde criado uma label e um textField para a insero de um valor do tipo texto.

33

Figura 15 - Cdigo dos campos nome

Por meio do SiteMesh o Grails criar o layout das pginas, mas nada impede que as gsps sejam acessadas e modifique-se o cdigo para a maneira desejada. Para isto, basta abrir a gsp desejada e editar conforme a necessidade.

2.4.1.5.

Pluglins

Existe uma vasta quantidade de plug-ins prontos para Grails, o fato de ele utilizar a linguagem dinmica Groovy, derivada do Java, faz com que ele absorva sua vasta riqueza, no que diz respeito aos scripts e plug-ins. Portanto Grails permite trabalhar com plug-ins de forma bastante simples, fazendo com que em pouco tempo seja possvel colocar um plug-in em funcionamento. Sendo assim, para instalar um plug-in, utiliza-se o comando grails install-plug-in [nome do plug-in], conforme pode ser verificado na figura 16.

Figura 16 - Instalando plug-in

Uma observao muito importante que, cada plug-in necessita de ser configurado para que seu funcionamento ocorra da maneira desejada, para tal fim, deve-se seguir a orientao da documentao do mesmo, uma vez que a configurao realizada de forma especfica.

34

Vale ressaltar ainda, que existe outra forma de instalar um plug-in, a qual baseia-se no arquivo BildConfig.groovy, localizado no dentro do diretrio grailsapp/conf.

35

3.

METODOLOGIA

Para que fosse possvel compreender o objeto de estudo deste trabalho, adotou-se inicialmente a metodologia de pesquisa bibliogrfica a qual caracterizouse principalmente pelo estudo de livros, trabalho de concluso de curso, artigos cientficos, peridicos, guias de usurio e sites com contedos relacionados a mtodos geis, aos diversos frameworks de desenvolvimento gil e Grails. Alm disso, durante o perodo de estudo e compreenso do framework Grails participouse de cursos introdutrios a Grails, que foram extremamente teis para aquisio do conhecimento necessrio para execuo deste trabalho. Todos os documentos e contedos pesquisados foram de suma importncia para o desenvolvimento bibliogrfico deste projeto, pois forneceram embasamento terico e prtico para entendimento dos conceitos e procedimento relacionados tecnologia Grails. Alm disso, para que fosse possvel melhor compreender o sistema que seria desenvolvido, bem como o seu contexto de utilizao, adotou-se os procedimentos de pesquisa de campo e descritiva. Desta forma, durante todo o perodo de desenvolvimento do trabalho em questo, realizou o acompanhamento do dia a dia do funcionamento da empresa, bem como foram realizadas entrevistas, com os proprietrios e funcionrios da mesma, com o objetivo de compreender de forma consistente a real necessidade da empresa. Aps realizar os estudos bibliogrficos foi possvel compreender os principais conceitos relacionados ao trabalho em questo, tais como mtodos de

desenvolvimento gil, assim como conhecer e compreender os principais frameworks de desenvolvimento gil. Alm disso, foi possvel entender como o framework Grails surgiu, a sua ideologia, principais ferramentas e forma de funcionamento. J com as pesquisas de campo e descritiva foi possvel conhecer a dinmica de trabalho da empresa Memora Inteligncia Grfica, e a partir disto, criar o projeto de software e modelar uma soluo tecnolgica, que atendesse s suas reais necessidades. Com isto, utilizando o Grails, deu-se incio ao processo de implementao do mdulo de gerenciamento de criao de produtos, o qual foi constantemente testado e validado pelo cliente. Vale ainda ressaltar, que durante o processo de desenvolvimento do trabalho em questo foram utilizadas algumas ferramentas, que auxiliaram no processo de

36

desenvolvimento da soluo. Desta forma, durante a fase de anlise adotou-se a ferramenta Astah Community, utilizada para criar os diagramas UML (Unified Modeling Language), alm disso, foi adotada a IDE GGTS (Groovy/Grails Tool Suite) para implementao dos cdigos em Groovy.

37

4.

DESENVOLVIMENTO

4.1.

Memora Inteligncia Grfica

Em 2005 a empresaria Nilcione Messias dos Santos fundou a agncia de eventos, cujo nome foi definido como Memora Cerimonial e Publicidade. Assim que surgiu, a empresa prestava servios voltados a cerimonial e secretaria, mas com o passar dos anos foi empregado a publicidade, focando em convites de formaturas, mas tambm abrangendo publicidade grfica em geral, passando ento a se tornar o foco principal da empresa, isso levou a mudana do nome para Memora Inteligncia Grfica, passando assim a assumir a publicidade como principal fonte rentvel da mesma. A Memora reconhecida hoje como agncia de publicidade, e tem uma demanda de trabalho muito grande, atendendo todo o estado e explorando estados prximos, conquistando clientes de diversas cidades circunvizinhas ao estado do Tocantins, essa demanda de projetos distncia passou a se tornar algo comum empresa, pois grande parte do processo de desenvolvimento do produto pode ser feita por meio de internet e telefone, no sendo totalmente dispensadas as presenas fsica do cliente e da empresa, mas reduzindo-as para situaes extremas. Neste ponto surgiu a necessidade de um sistema que auxilie e facilite na produo e acompanhamento do desenvolvimento dos produtos, em relao a clientes e funcionrios. Sistema este, capaz de em tempo real, poder acompanhar passo-a-passo o processo de desenvolvimento, bem como a troca de informaes necessrias para o andamento da produo, visando conforto e qualidade no processo.

4.2.

Viso Geral do Sistema

O sistema desenvolvido neste trabalho, possibilita realizar o controle de todo o fluxo de criao dos produtos elaborados pela agncia de publicidade Memora,

38

fazendo com que todos os dados e processos sejam unificados, simplificando, desta forma, o acompanhamento e gerenciamento do desenvolvimento dos produtos, tanto por parte da empresa, quanto do cliente. Conforme explicitado anteriormente, o sistema em questo desenvolvido baseando-se em uma necessidade real da empresa, possuindo o objetivo de automatizar aes, que hoje so realizadas/registradas de formas diversas, como email, telefone, e outros meios de comunicao. Portanto, com a implantao do sistema, todas as informaes, de cada produto, so reunidas em um nico local. Sendo assim, o sistema possibilita cadastrar informaes bsicas tanto do cliente, quanto do produto, assim como registra todas as etapas de criao do produto, por meio dos processos executados, e suas respectivas movimentaes. Os requisitos funcionais que compem o sistema podem ser observados na figura 17, a qual ilustra o diagrama de casos de uso.

Figura 17 - Diagrama de caso de uso geral

39

Conforme pode ser observado na figura 17, interagem com o sistema diversos atores, como Usurio, Cliente, Funcionrio, Vendedor e Administrador. Dentre os requisitos ilustrados, tem-se o gerenciamento de instituies, onde ser possvel realizar cadastros de diversos tipos de instituies, ou seja, tanto instituies de ensino e/ou empresas. Alm disso, o sistema permite o cadastro de comisses, requisito que visa promover a oportunidade de reunir um grupo de clientes para gerenciar/acompanhar a criao de um determinado produto. importante ressaltar, que tal gerenciamento/acompanhamento ser realizado de forma dinmica, sendo o processo de criao do produto dividido em etapas: em um primeiro momento realizado o cadastro do tipo de produto, logo em seguida, o cadastro dos atributos referentes a determinado tipo de produto, por conseguinte, disponibilizada a funcionalidade de gerenciamento de produtos, de acordo com o tipo selecionado. Para cada produto cadastrado ser disponibilizado o cadastro de processos, e para cada processo ser disponibilizado o cadastro de movimentaes, desta forma, ser possvel armazenar todo o fluxo de

desenvolvimento do produto no sistema. No decorrer deste trabalho, o mdulo desenvolvido foi o responsvel por automatizar o processo de gerenciamento do processo de criao de produtos, portanto, na prxima seo o mdulo em questo descrito.

4.3.

Mdulo de Gerenciamento do Processo de Criao de Produtos

Para implementao neste trabalho, foi selecionado o mdulo mais crtico do sistema, ou seja, o de gerenciamento do processo de criao dos produtos, e assim comprovar que o framework Grails cumpre sua promessa de desenvolvimento gil. A figura 18 ilustra o diagrama de casos de uso, com os atores e requisitos funcionais do mdulo que ser trabalhado.

40

Figura 18 - Mdulo a ser desenvolvido

Conforme ilustrado na figura 18, os requisitos que compem o mdulo em questo esto relacionados ao gerenciamento de produto, bem como de seus processos e suas respectivas movimentaes. Este mdulo considerado o mais crtico do sistema, pelo fato concentrar as informaes mais importantes, desde o incio do desenvolvimento do produto, at a concluso do mesmo, alm de permitir maior interao do cliente sobre o gerenciamento das movimentaes dos processos, assim como maior controle por parte da empresa. Para que seja possvel melhor compreender cada um dos casos de uso que compem este mdulo do sistema, a seo de Anexos apresenta os artefatos modelados, como: os casos de uso expandidos; wireframes; assim como os diagramas de sequncia dos casos de uso, com fluxo considerado mais complexo.

4.4.

Utilizao do Grails para Desenvolvimento do Mdulo de Gerenciamento

do Processo de Criao de Produtos

4.4.1. Classes de Domnio e Controladores

41

Em um primeiro momento, o projeto foi criado, seguindo os passos descritos na sesso 2.2.1.1. Logo em seguida, as classes de domnio e controle tambm foram geradas, seguindo os mesmos passos descritos na sesso 2.2.1.2. importante ressaltar, que at o momento, as classes criadas foram apenas as necessrias para a implementao do mdulo de gerenciamento do processo de criao de produtos. O diagrama de classes do mdulo em questo pode ser observado na figura 19.

Figura 19 - Diagrama de classe do mdulo desenvolvido

importante reforar, que conforme explicado anteriormente, no modelo de desenvolvimento proposto pelo Grails, as classes de domnio representam as tabelas do banco de dados, sendo que as mesmas devem conter os atributos (colunas do banco) de uma determinada pgina. Sendo assim, na classe Produto, esto condidas as informaes relacionadas ao tipo do produto, cliente vinculado, data do contrato e data de concluso. Tal classe possui relacionamento com a

42

classe de domnio denominada TipoDeProduto, que contm os atributos referentes ao um tipo de produto especfico. Pode-se observar na figura 20, que todos os atributos da classe de domnio Produto, foram marcados como obrigatrio, pois tratam-se de informaes extremamente necessrias para efetivao do cadastro.

Figura 20 - Classe de domnio do Produto

As informaes especficas de cada tipo de produto so cadastradas pelo prprio administrador do sistema, tais informaes esto concentradas na classe de domnio Atributo (Figura 21), sendo que valores atribudos a cada atributo so mencionados na classe de domnio ValorDoAtributo (Figura 22).

Figura 21 - Classe de domnio do Atributo

Figura 22 - Classe de domnio do Valor do Atributo

Com o produto previamente cadastrado, torna-se possvel organizar seus processos, com essa finalidade, foi criada uma classe de domnio chamada Processo, que responsvel por separar as etapas de criao do produto. Desta

43

forma, para cada processo cadastrado, de um determinado produto, so criadas diversas movimentaes, sendo tais movimentaes responsveis por armazenar os dados do fluxo de determinado processo de criao. Na etapa em questo, tanto o cliente quanto os funcionrios da empresa tm permisso de insero de dados. Para tanto, foi criada uma classe de domnio chamada Movimentao (Figura 24), que est relacionada classe Processo (Figura 23), descrita anteriormente, a fim de estabelecer um vnculo dos anexos, que podem ou no vir a existir, e uma descrio a ser passada para a parte envolvente, contendo informaes sobre o andamento da movimentao. A classe

Movimentao (Figura 24) contm ainda o titulo, e a data de criao. Os processos e as movimentaes do produto so as partes mais crticas do sistema, pois so nelas onde sero concentradas todas as informaes pertinentes ao

desenvolvimento geral do produto.

Figura 23 - Classe de domnio Processo

Figura 24 - Classe de domnio Movimentao

Com a finalidade de atender a dinamicidade de tipos de produtos oferecidos pela empresa, o diagrama de classes foi elaborado de forma que o sistema mantivesse tal flexibilidade, no que se referente aos atributos e tipos de produtos.

44

Desta forma, para garantir a consistncia e integridade dos valores dos atributos, salvos no banco de dados, foi utilizada a tcnica de Rollback, implementada na classe de servio, que conforme explicado anteriormente, compe a estrutura do Grails, sendo salva no subdiretrio grails-app/services. A configurao de tal procedimento pode ser observada na figura 25.

Figura 25 - Classe de servio de transaes mtodo saveProduto()

Ainda relacionado ao processo de armazenamento das informaes de um produto, a figura 26 ilustra a chamada ao mtodo de transao na action save do controlador Produto.

Figura 26 - Controlador produto Action save

45

Conforme pode ser observado na figura 26, a linha 56 responsvel por realizar uma chamada ao mtodo de transao saveProduto da classe transacoesServices, sendo responsvel por realizar todos os tratamentos necessrios durante o processo de armazenamento de um determinado produto.

4.4.2. Views

O framework Grails traz consigo um BootStrap com o CRUD bsico muito bem estruturado, conforme mencionado nas sesses 2.3.3.5 e 2.4.1.4 aps a execuo do comando grails generate-all, so geradas as telas de

visualizao padres, mas como mostra na figura 27, possvel modifica-las de acordo com as necessidade. Desta forma, para a implementao do layout do sistema em questo foi utilizado o BootStrap do Twitter.

Figura 27 - Tela de login

Para que fosse possvel gerar a visualizao apresentada na figura 27, foi implementado o cdigo ilustrado na figura 28. Na linha 42 criado um formulrio

46

com a tag <g:form action="authenticate" method="post">, portanto, quando o usurio pressionar o boto Entrar, a tag em questo enviar o formulrio para a action authenticate, contida no controlador padro. Deste modo, por conveno, pode-se afirmar que, neste caso, o controlador o LoginController como ilustrado na figura 28.

Figura 28 - View login.gsp

Assim que o controlador LoginController acionado, a operao executada bem simples, isto porque o framewok Grails realizada grande parte do trabalho para o desenvolvedor. A linha 15, da figura 29, apresentada a instruo findByLoginAndPassword(params.login,params,password), que

responsvel por realizar uma consulta ao banco resgatando os dados equivalentes a expresso enviada. Nas linhas que se seguem, adicionado o objeto usurio na sesso, bem como o perfil de acesso dele. Entretanto, caso a consulta retorne nenhum valor, exibida uma mensagem de informativa, e o usurio redirecionado para a tela de login.

47

Figura 29 - Controlador Login Action authenticate

A figura 30, ilustra uma das principais telas do sistema, ou seja, a de gerenciamento de produtos. Conforme pode ser observado, a figura apresenta o formulrio com os dados de cadastro de um produto, assim como uma tabela com a listagem dos produtos j cadastrados, em ordem decrescente. Sendo assim possvel, nesta mesma tela, acessar as funes de visualizao do produto, edio e excluso.

Figura 30 - Tela Gerenciar Produto

48

importante ressaltar que nesta tela, quando o valor do campo Tipo De Produto alterado na combobox, a pgina renderizada novamente, sendo ento apresentados os dados do produto relacionado ao tipo selecionado. Isso possvel por uma ao realizada na tag referente a combobox, <g:select

onchange="submit()">, que pode ser observada na linha 27, da figura 31, onde ativada a ao submit(), responsvel por ativar a action create do controlador Produto, onde a mesma retorna para a mesma pgina o id do tipo de produto selecionado, para que os dados referentes a ele sejam carregados na tela.

Figura 31 - View create da ptina Gerenciar Produto

Ao solicitar a opo de visualizao dos dados do produto, o usurio ser redirecionado para a tela Visualizao do Produto, apresentada na figura 32. Esta tela contm as informaes de cadastro do produto, bem como seus processos e suas respectivas movimentaes.

49

Figura 32 - Tela Visualizar Produto

A tela ilustrada na figura 32 a responsvel por apresentar a todos os envolvidos na criao de um produto o passo a passo da evoluo do mesmo, permitindo assim que todas as informaes de um produto sejam

registradas/encontradas/acompanhadas em um nico lugar. Portanto, nesta tela, tanto os funcionrios quanto os clientes, podero acompanhar o andamento do desenvolvimento do produto, assim como adicionar novas movimentaes aos processos, mas somente o funcionrio e o administrador podero acrescentar processos, os clientes apenas podero visualiza-los e cadastrar movimentaes.

50

5.

CONSIDERAES FINAIS

realidade

atual

no

mercado

de

trabalho

necessidade

de

desenvolvimento de sistemas de qualidade de forma gil e prtica, que facilitam o trabalho dos desenvolvedores aproveitando seu tempo em focar-se na criatividade no processo de desenvolvimento, ao invs de configuraes e visualizao. Neste contexto, conforme citado no decorrer do trabalho, hoje em dia, existe uma vasta quantidade de frameworks que atendem s necessidades de desenvolvimento gil, e em diversas linguagens. Dentre tais framework o Grails destaca-se, por alm de oferecer um conjunto de ferramentas, que auxiliam na produo de sistemas para web, o mesmo foi desenvolvido para funcionar sobre a JVM. Outra caracterstica importante o fato de o mesmo usar a linguagem de programao Groovy, que permite ao desenvolvedor ter acesso a todo o poder da linguagem Java, uma vez que possui total compatibilidade com as bibliotecas e scripts j existentes em Java. Com isto, pode-se afirmar, que com Grails, programar passou a ser mais divertido. Com a implementao do mdulo de gerenciamento do processo de criao de produtos, foi possvel verificar a eficincia do framework Grails, o qual mostrou ser bastante gil, simples e prtico, visto que nenhuma configurao de banco de dados e XML foram necessrias no decorrer do desenvolvimento. No que diz respeito ao processo de implementao do layout personalizado, utilizou-se o plug-in do Twitter, onde o mesmo se comportou de maneira bem homogenia com o framework Grails, proporcionando uma vantagem significativa na construo e adaptao do layout do sistema. Alm disso, foi possvel verificar algumas vantagens que so proporcionadas pela linguagem dinmica Groovy, dentre elas pode-se citar: a facilidade e simplicidade de implementao da lgica do sistema, onde operaes que em Java poderiam ser mais complexas, em Groovy as mesmas foram reduzidas em uma linha cdigo, alm disso, a sua sintaxe mostra ser bem simples e eficiente. De forma geral, ao somar a dinamicidade da linguagem Groovy, com a consistncia e a agilidade que o framework Grails oferece, foi possvel constatar que o processo de desenvolvimento de sistema tornou-se mais prazeroso, rpido e simples.

51

Como proposta de trabalhos futuros, propem-se realizar a efetiva implantao do mdulo implementado durante este trabalho, bem como o treinamento dos usurios, a fim de inserir aos poucos o sistema na rotina de trabalho da empresa. Alm disso, pretende-se finalizar a implementao dos demais mdulos do sistema que j foram analisados.

52

6.

REFERNCIAS

(AGILE MANIFESTO, 2001) AGILE MANIFESTO. Manifesto for Agile Software Development. 2001. Disponvel em <http://www.agilemanifesto.org>. Acesso em 16 de setembro de 2012. (ANTUNES, 2011) ANTUNES, Adriano Bastos. Introduo ao Framework Grails. Cabo Frio. Universidade Veiga de Almeida UVA, 2011. (CAKE PHP, 2012) CAKEPHP. Documentation. <http://cakephp.org/>. Acesso em: 17 de ago. de 2012. 2012. Disponvel em:

(CALAHORRO), CALAHORRO, Nacho Brito. Manual de Desarrollo Web Con Grails: JavaEE, como Siempre Debi Haber Sido. Criative Commons, Espan. 2009, 167 p. (CARVALHO, 2006) CARVALHO, Marlon. Spring Framework: Introduo. iMasters. Ago. de 2006. Disponvel em: <http://www.imasters.com.br/artigo/4497/java/spring_framework_introducao/>. Acessado em: 30 de abr. de2012. (CARVALHO, 2008) CARVALHO, Marlon. Spring Framework: Introduo. Ago. de 2008. Disponvel em: <http://imasters.com.br/artigo/4497/spring_framework_introducao>. Acessado em 02/05/2012. (CODIEIGNITER BRASIL, 2012) CODEIGNITER. CodeIgniter Brasil. 2012. Disponvel em: <http://codeigniterbrasil.com/>. Acesso em: 17 de ago. de 2012. (DAVIS; RUDOLPH, 2010) DAVIS, Scott; Jason, RUDOLPH. Getting Started With Grails Second Edition: A modern web framework fot the Java Plataform. 2 ed. InfoQ. 2010. 148 p. (DEPA, 2010) DEPA, Departamento de Sistemas e Computao da UFCG. O que so frameworks?. Disponvel em: <http://www.dsc.ufcg.edu.br/~jacques/cursos/map/html/frame/oque.htm>. Acessado em 17 de ago. de 2012. (DJANGO BRASIL, 2012) DJANGO. Documentao do Django. 2012. Disponvel em: <http://www.djangobrasil.org/>. Acesso em: 17 de ago. de 2012. (FAYAD; SCHMIDT, 2007) FAYAD, M. E; SCHMIDT, D. C.. Object-oriented application frameworks. Comm. ACM 40(10), 1997. 32-8. (GRAILS, 2012) GRAILS. The Grails Framework: Reference Documentation. Disponvel em: <http://grails.org/doc/latest/>. Acesso em: 06 de fev. de 2012.

53

(GRAILSBRASIL, 2012) GRAILSBRASIL. 2012. <http://grailsbrasil.com.br>. Acesso em: 05 de mar. de 2012.

Disponvel

em:

(GROOVY, 2012) GROOVY. Portuguese Documentation. 2012. Disponvel em: <http://groovy.codehaus.org/Portuguese+Home>. Acesso em: 18 de ago. de 2012. (H2, 2012) H2. Database Engine. H2 Database EngineDisponvel: <http://www.h2database.com/html/performance.html>.Acessado em 04 de mai. De 2012. (JRUBY, 2012) JRUBY. Documentation. 2012: Disponvel em: <http://jruby.org/>. Acesso em: 17 de ago. de 2012. (JAVAFREE.ORG, 2009) JAVAFREE.ORG. Integrao: Spring e Hibernate. Ago. de 2009. Disponvel em: <http://javafree.uol.com.br/artigo/871470/Integracao-Springe-Hibernate.html>. Acessado em: 01 de mai. De 2012. (___, 2009) JAVAFREE.ORG. Inversion Of Control: Containers de Inverso de Controle e o padro Dependency Injection. Ago. de 2009. Disponvel em: <http://javafree.uol.com.br/artigo/871453/Inversion-Of-Control-Containers-deInversao-de-Controle-e-o-padrao-Dependency-Injection.html>. Acessado em: 01 de mai. de 2012. (JUN, 2009) JUN, Ricardo. Spring Framework: O que afinal de contas e para onde ele vai?. Blobal Code: Informao + colaborao + discusso. Set. de 2009. Disponvel em: <http://blog.globalcode.com.br/2009/09/spring-framework-o-que-eafinal-de.html>. Acessado em: 30 de abr. de 2012. (JUNIT, 2012) JUNIT. Resources for Test Driven Development. Disponvel em: <http://www.junit.org/>. Acessado em: 04 de mai. de 2012. (MACORATTI, 2010) MACORATTI, Jos Carlos. Padres de Projeto: O modelo MVC Model View Controller. Disponvel em < http://www.macoratti.net/vbn_mvc>. Acessado em: 02 de mai. de 2012. (MOREIRA, 2009) MOREIRA, Daniela. Desenvolvimento gil funciona?, Info Online. So Paulo, jun. de 2009. Disponvel em: <http://info.abril.com.br/noticias/ti/desenvolvimento-agil-funciona-30062009-3.shl>. Acessado em: 24 de abr. de 2012. (ROCHER, 2006) ROCHER, Graeme Keith. The Definitive Guide to Grails. Apress. Springer-Verlag New York. 2006. 360 p. (RUBY, 2012) RUBY. Documentao. 2012. Disponvel em: <http://www.rubylang.org/pt/>. Acesso em: 17 de ago. de 2012. (RUBY ON RAILS, 2012) RUBY ON RAILS Desenvolvimento Web Sem Dor. 2012. Disponvel em: <http://rubyonrails.com.br/>. Acesso em: 17 de ag. de 2012.

54

(SANTOS, 2012) SANTOS, Clerbete. Desenvolvimento de sistemas em Grails. Disponvel em: <http://cleorbete.com/cursos/desenvgrails/>. Acessado em: 25 de set. de 2012. (SOMMERVILLE, 2011) SOMMERVILLE, Ian, Engenharia de Software. 9 Edio, Person Education do Brasil, 2011. (VRAPTOR, 2012) VRAPTOR, Documentation. 2012. Disponvel <http://vraptor.caelum.com.br/en>. Acesso em: 17 de ago. de 2012. em:

(WALLS; BREIDENBACH, 2005) WALLS, Craig; BREIDENBACH Ryan. Spring In Action. Editora Manning. Greenwich, 2005, 209 p. (WEISSMANN, 2010) WEISSMANN. Henrique Lobo. Grails: um Guia rpido e indireto. Disponvel em: <http://www.itexto.net/devkico/?page_id=220>. Acessado em: 5 de mar. de 2012.

55

7.

ANEXO A

7.1.

Requisitos funcionais

7.1.1. Requisitos Funcionais

RF1 - Cadastrar Usurio: O cadastro de usurios do sistema deve ser unificado e as permisses dentro do sistema separadas por perfil de acesso. RF2 - Cadastro de instituies: Deve-se manter um cadastro com os dados bsicos das instituies no sistema, o mesmo poder ser usado para futuros contatos. RF3 - Cadastrar produtos: O sistema deve ser desenvolvido de forma que possa ser facilmente adaptvel a mudanas nos produtos cadastrados, bem como o cadastro de novos tipos de produtos. RF4 - Cadastro de comisso: O sistema deve conter o cadastro de comisso, onde sero vinculados vrios clientes e instituies, assim como, vinculados vrios clientes (pessoas) a um produto especfico. RF5 - Cadastrar cursos: de bastante proveito ter uma base de cadastro de cursos, para poder vincula-los a instituies de ensino. RF6 - Cadastrar processos: Para melhor organizao no processo de

desenvolvimento dos produtos, deve ser permitido o cadastro de processos para cada produto, devidamente cadastrado no sistema. RF7 - Cadastrar movimentao: para cada processo cadastrado, deve-se

possibilitar o cadastro de movimentaes do processo especfico. Esta ao tambm ser gerenciada pelo cliente. RF8 - Gerar relatrio: O sistema deve permitir que os funcionrios possam gerar relatrios do sistemas em geral. RF9 - Listar produtos cadastrados: O sistema deve exibir uma lista dos produtos cadastrados. RF10 Listar Usurios Cadastrados: O sistema deve exibir uma lista com os

usurios cadastrados. RF11 Alterar perfil dos Usurios Cadastrados: O sistema deve permitir a

alterao dos perfis dos usurios cadastrados.

56

7.1.2. Requisitos No-Funcionais

RNF 1 Usabilidade O sistema dever realizar as tarefas de maneira eficaz, eficiente e agradvel. RNF 2 Consistncia O sistema dever executar as funcionalidades de forma coerente ao contexto. RNF 3 Confiabilidade O sistema dever sempre realizar as funcionalidades requeridas e apresentar um bom desempenho. RNF 4 Acessibilidade O sistema dever ser acessvel a deficientes visuais.

7.2.

Caso de uso expandido e Wireframe do Mdulo de Gerenciamento do

Processo de Criao de Produtos

7.2.1. Gerenciar Produto

57

Fluxo 1

Fluxo 2 Fluxo 3 Fluxo 4

Figura 33 -

Tela de ilustrao do caso de uso Gerenciar Produto

Caso de Uso: Gerenciar Produto Ator: Administrador Finalidade: Permite ao ator Inserir novos produtos, Editar, Excluir e Listar todos os produtos cadastrados. O ator poder Listar Todos os produtos cadastrado ou efetuar uma busca de produtos com um filtro de Viso Geral: pesquisa. Tambm poder editar ou excluir (apenas produtos que no houver processos), bem como visualizar seus dados cadastrais, processos e movimentaes. PrCondies: PsCondies: criada uma instncia do produto no sistema e a relao do mesmo com Cliente. Resposta do Sistema

Ao do Ator

58

Sequencia Tpica de Evento 1. O ator seleciona Gerenciar Produto. 2. O sistema realiza uma consulta de

produtos cadastrados. 3. O sistema apresenta o tela de

gerencia. Fluxo 1 4. O ator seleciona a opo cadastrar 5. O sistema apresenta o formulrio

novo produto. 6. O ator preenche os dados do

de Cadastro 7. O sistema exibe o resultado de

formulrio e confirma a ao.

sucesso. Fluxo 2

8.

O ator, na listagem de produtos,

9.

O sistema apresenta o formulrio

seleciona a opo editar. 10. O ator altera os dados desejados e escolhe a ao Editar.

preenchido com os dados do produto. 11. O sistema exibe o resultado de sucesso. Fluxo 3

12. O ator, na listagem de produtos, seleciona a opo excluir. 14. O ator confirma a opo.

13. O sistema apresenta a mensagem de confirmao. 15. O sistema apresenta o resultado da operao. Fluxo 4

16. O ator, na listagem de produtos, seleciona a opo visualizar.

17. O sistema apresenta a pgina Visualizar Produto.

Sequncias Alternativa. Linha 7 O usurio no informa os dados corretamente. O sistema exibe uma mensagem de erro correspondente O usurio no informa os dados corretamente. O sistema exibe uma mensagem de erro correspondente O ator, na mensagem de confirmao, no confirma a ao. O sistema no realiza nenhuma ao.

Linha 11

Linha 14

7.2.2. Visualizar Produto

59

Figura 34 -

Tela de ilustrao do caso de uso Visualizar Produto

Caso de Uso: Visualizar Produto Ator: Administrador Finalidade: Visualizar dados do produto, listar e inserir processos e movimentaes.

60

Viso Geral:

Tem como finalidades visualizar os dados do produto, listar e inserir processos e suas movimentaes. Ter acessado a opo visualizar do caso de uso Gerenciar Produto.

PrCondies: PsCondies:

Sequncia Tpica de Eventos Ao do Ator 1. Resposta do Sistema O sistema apresenta os dados de

cadastro do produto bem como os Casos de Uso Inserir processo e Listar Processos. Sequncias Alternativa.

7.2.3. Listar Processo

61

Figura 35 -

Tela de ilustrao do caso de uso Listar Processo

Caso de Uso: Listar Processo Ator: Administrador Finalidade: Listar processos cadastrados. Viso Geral: Permite ao ator listar todos os processos cadastrados de um determinado produto.

62

PrCondies: PsCondies:

O ator ter acessado a o caso de uso Visualizar Produto.

Sequncia Tpica de Eventos Ao do Ator 1. O ator seleciona Processo no caso 2. Resposta do Sistema O sistema exibe a lista de todos os

de uso Visualizar Produto.

processos cadastrados. Sequncias Alternativas

Linha 2

Se no houver registros, o sistema informa uma mensagem correspondente.

7.2.4. Inserir Processo

63

Figura 36 -

Tela de ilustrao do caso de uso Inserir Processo

Caso de Uso: Inserir Processo Ator: Administrador Finalidade: Inserir novo processo. Viso Geral: Permite ao ator inserir um novo processo a um determinado produto.

64

PrCondies:

O ator ter acessado a o caso de uso Visualizar Produto. criada uma instncia do processo e vinculada ao produto.

PsCondies:

Sequncia Tpica de Eventos Ao do Ator 1. O ator seleciona a opo Inserir 2. Resposta do Sistema O sistema apresenta o formulrio

Processo. 3. O ator preenche os dados do

de Cadastro 4. O sistema exibe o resultado de

formulrio e confirma a ao.

sucesso.

Sequncias Alternativas Linha 3 O ator seleciona a opo limpar. O sistema limpa os campos do formulrio.

7.2.5. Visualizar Processo

65

Figura 37 -

Tela de ilustrao do caso de uso Visualizar Processo

Caso de Uso: Visualizar Processo Ator: Administrador Finalidade: Visualizar movimentaes vinculadas ao processo. Viso Geral: Permite ao ator, visualizar todas as movimentaes vinculadas a um determinado processo.

66

PrCondies: O ator ter acessado o caso de uso Listar Processos. So apresentadas todas as movimentaes vinculadas PsCondies: a tal processo, bem como o caso de uso Inserir Movimentao. Sequncia Tpica de Eventos Ao do Ator 1. O ator seleciona um dos 2. Resposta do Sistema O sistema apresenta a lista de

processos listados.

todas as movimentaes vinculadas a tal processo.

Sequncias Alternativas

7.2.6. Excluir Processo

67

Figura 38 -

Tela de ilustrao do caso de uso Excluir Processo

Caso de Uso: Excluir Processo Ator: Administrador Finalidade: Excluir um processos cadastrado.

68

Viso Geral:

Permite ao ator, excluir um determinado processo caso o mesmo no haja movimentaes. O ator ter acessado o caso de uso Visualizar Processo.

PrCondies:

PsCondies: apagada a instancia do processo. Sequncia Tpica de Eventos Ao do Ator 1. O ator solicita a excluso do 2. Resposta do Sistema O sistema apresenta a mensagem

processo. 3. O ator confirma a opo.

de confirmao. 4. O sistema apresenta o resultado de

sucesso.

Sequncias Alternativas O ator, na mensagem de confirmao, no confirma a ao. O sistema no realiza nenhuma ao.

Linha 3

7.2.7. Inserir Movimentao

69

Figura 39 -

Tela de ilustrao do caso de uso Inserir Movimentao

Caso de Uso: Inserir Movimentao Ator: Administrador Finalidade: Inserir uma movimentao e vincula-la a um determinado processo.. Permite ao ator, o cadastro de uma nova movimentao para um determinado processo.

Viso Geral:

70

PrCondies:

O ator ter acessado a o caso de uso Visualizar Processo. criada uma instncia da movimentao e vinculada a um determinado processo.

PsCondies:

Sequncia Tpica de Eventos Ao do Ator 1. O ator seleciona a opo visualizar 2. Resposta do Sistema O sistema apresenta a opo

processo. 3. O ator seleciona a opo Inserir

Inserir Movimentao. 4. O sistema apresenta o formulrio

movimentao. 5. O ator preenche os dados do

de cadastro. 6. O sistema exibe o resultado de

formulrio e confirma a ao.

sucesso.

Sequncias Alternativas Linha 5 O ator seleciona a opo limpar. O sistema limpa os campos do formulrio. Se houver erros na insero dos dados obrigatrios, o sistema informa uma mensagem correspondente.

Linha 6

7.2.8. Visualizar Movimentao

71

Figura 40 -

Tela de ilustrao do caso de uso Visualizar Movimentao

Caso de Uso: Visualizar Movimentao Ator: Administrador Finalidade: Visualizar dados de cadastro. Viso Geral: Permite ao ator, visualizar os dados de cadastro da movimentao

72

PrCondies: PsCondies:

O ator ter acessado o caso de uso Visualizar Processo.

Sequncia Tpica de Eventos Ao do Ator 1. O ator seleciona a movimentao 2. Resposta do Sistema O sistema apresenta os dados de

desejada.

cadastro de uma determinada movimentao.

Sequncias Alternativas Linha 2 Se no houver registros o sistema informa uma mensagem correspondente.

7.3.

Diagrama de Sequncias e Contratos

7.3.1. Visualizar Produto

73

Figura 41 - Diagrama de Sequncia do requisito Visualizar Produto

7.3.2. Inserir Movimentao

74

Figura 42 - Diagrama de Sequncia do requisito Inserir movimentao