autarquia educacional do vale do sÃo francisco …€¦ · agradeço ao meu orientador prof....
TRANSCRIPT
AUTARQUIA EDUCACIONAL DO VALE DO SÃO FRANCISCO
FACULDADE DE CIÊNCIAS APLICADAS E SOCIAIS DE PETROLINA CIÊNCIA DA COMPUTAÇÃO
TÁSSIO GUERREIRO ANTUNES VIRGÍNIO
ESTUDO COMPARATIVO ENTRE FRAMEWORKS STRUTS E RUBY ON RAILS
NO DESENVOLVIMENTO DE APLICAÇÕES WEB
PETROLINA-PE 2007
1
TÁSSIO GUERREIRO ANTUNES VIRGÍNIO
ESTUDO COMPARATIVO ENTRE FRAMEWORKS STRUTS E RUBY ON RAILS
NO DESENVOLVIMENTO DE APLICAÇÕES WEB
Monografia apresentada ao colegiado de Ciência da Computação como um dos pré-requisitos para aprovação na disciplina monografia.
Professor Orientador
Jocélio Passos
2
TÁSSIO GUERREIRO ANTUNES VIRGÍNIO
ESTUDO COMPARATIVO ENTRE FRAMEWORKS STRUTS E RUBY ON RAILS
NO DESENVOLVIMENTO DE APLICAÇÕES WEB
Trabalho de conclusão de curso apresentado ao colegiado de ciência da computação da Faculdade de Ciências Sociais e Aplicadas de Petrolina – FACAPE como requisito á obtenção do grau de bacharel em ciência da computação. Aprovado em: ____/______/______
BANCA EXAMINADORA
Prof.Msc. Jocélio de Oliveira Dantas Passos Faculdade de Ciências Sociais e Aplicadas de Petrolina
Prof.Msc. Ana Emilia de Melo Queiroz Universidade Federal do Vale do São Francisco
Prof. Orlando Silva de Oliveira Faculdade de Ciências Sociais e Aplicadas de Petrolina
3
AGRADECIMENTOS
Agradeço a Deus por ter me dado a oportunidade de aprender e crescer nessa
existência, por esta me guiando, colocando pedras e flores no meu caminho. Para
com isso possa aprender, e ser feliz.
Agradeço aos meus pais por terem me criado e me ensinado da melhor forma que
existe, pelo exemplo de pessoas que são, e que eu um dia sonho em ser, obrigado
por tudo.
Aos meus familiares obrigado por acreditarem no meu sucesso, mesmo distantes sei
que sempre torceram por mim.
Agradeço ao meu orientador Prof. Jocélio Passos que foi um Mestre nessa
caminhada que estou concluindo. Sempre presente em todas as etapas que passei
no curso, repassando conhecimento direta e indiretamente, com os seus
ensinamentos e seu exemplo. Obrigado.
Agradeço a grande equipe de profissionais com quem trabalho, Altair Aquino colega
e amigo, foi sorte ter te conhecido, Nicolas, um grande chefe e amigo, André Luiz,
alguém que aprendi a admirar, Amilton, obrigado pela descontração nas horas
difíceis, ajudou muito, ao pessoal dos outros setores do NTI, Marcos Matos, por sua
alegria constante, Fabio por seu profissionalismo e por ter acreditado em mim no
momento que mais precisava e obrigado a todos os colegas estagiários que
passaram pelo NTI e fizeram parte dessa equipe.
Agradeço ao prof. Jorge Cavalcante e ao prof. Alex Sandro Gomes, por incentivaram
o desenvolvimento do Curso de Computação, trazendo projetos, palestras, cursos e
eventos, acreditando nos alunos dessa faculdade a qual com orgulho fiz parte.
E para uma pessoa muito especial na minha vida, obrigado por esta ao meu lado
nessa época de descobertas, me fazendo feliz.
4
“Porque foi tão fácil conseguir E agora eu me pergunto: e daí ?
Eu tenho uma porção de coisas grandes pra conquistar, E eu não posso ficar aí parado”
Raul Seixas
5
RESUMO
O desenvolvimento de aplicativos para o ambiente da internet esta cada vez mais
abrangente. Todos os dias aparecem aplicações inovadoras, com suas próprias
soluções e ideologias. As empresas atualmente têm mais um requisito importante
pra ser analisado na hora de desenvolver um projeto Web: Qual o framework que
será utilizado, pois os frameworks se tornaram peça padrão no desenvolvimento de
aplicativos web, principalmente pela variedade de tecnologias utilizadas no seu
desenvolvimento.Com os prazos e custos das empresas de desenvolvimento cada
vez mais apertados, apostar em um framework no desenvolvimento de uma
requisição do cliente pode ser um passo em falso, fracassando todo o projeto, ou
mesmo levando para o sucesso. Ficando mais fácil para as empresas apostarem
nas soluções já consolidadas no mercado, e cada vez mais difícil para as novas
soluções conquistarem mercado. Essas são as posições opostas que se encontram
o Struts e o Ruby on Rails. No desenvolver dessa dissertação serão mostradas as
características dos dois frameworks estudados, suas soluções, ideologias e
arquiteturas. Serão apresentados dois aplicativos desenvolvidos, cada qual com um
framework citado. Escolhidos por suas características de mercado, o Struts é
considerado o framework padrão para o desenvolvimento de aplicativos Java para
web, enquanto o Ruby on Rails é uma proposta que esta crescendo e ganhando
espaço entre os desenvolvedores da área, por sua facilidade de programação
através da linguagem Ruby e da sua filosofia forte de desenvolvimento.
Palavras chaves: Struts, Ruby on Rails, Framework.
6
ABSTRACT
The development of applicatory for the environment of the Internet this each more
including time. Every day they appear innovative applications, with its proper
solutions and ideologies. The companies currently have plus a requirement important
pra to be analyzed in the hour to develop a Web project: Which framework that it will
be used, therefore frameworks had become part standard in the development of
applicatory web, mainly for the variety of technologies used in its development. With
the stated periods and costs of the companies of pressed development each time
more, to bet in one framework in the development of a solicitation of the customer
can be a step in false, failing all the project, or same leading for the success. Being
more easy companies to bet them in the consolidated solutions already in the
market, and each more difficult time them new solutions to conquer market. These
are the opposing positions that if find the Struts and the Ruby on Rails. In developing
of this dissertação the the two will be shown studied characteristics of frameworks, its
solutions, ideologies and architectures. Applicatory ones will be presented two
developed, each one with one framework cited. Chosen for its characteristics of
market, the Struts is considered the leader of market in the development of
applicatory Java for web, while the Ruby on Rails is a proposal that this growing and
gaining space enters the desenvolvedores of the area, for its easiness of
programming through the Ruby language and of its strong philosophy of
development.
Words keys: Struts, Ruby on Rails, Framework.
7
SUMÁRIO
Resumo Abstract Capitulo I - Introdução ......................................................................................... 09 1.1 Motivação....................................................................................................... 10 1.2 Objetivos ........................................................................................................ 11 1.2.1 Objetivo Geral ............................................................................................. 11 1.2.2 Objetivos Específicos .................................................................................. 11 1.3 Estrutura Do Trabalho .................................................................................... 11 Capítulo II – Metodologia...................................................................................... 12 2.1 Caso De Uso E Protótipos .............................................................................. 12 2.2 Diagramas UML .............................................................................................. 13 2.2.1 Diagrama De Caso De Uso ......................................................................... 13 2.3. Prototipagem De Baixa Fidelidade ................................................................ 13 2.4 Modelagem Do Banco De Dados ................................................................... 14 2.5 Técnicas E Ferramentas Utilizada.................................................................. 14 2.6 Levantamento Dos Critérios De Avaliação..................................................... 15 2.6.1 Tempo De Desenvolvimento Pela Estimativa De Esforço........................... 15 2.6.1.1 Esforço De Estruturação .......................................................................... 15 2.6.1.2 Esforço De Programação ......................................................................... 15 2.6.2 Numero De Linhas De Código..................................................................... 16 2.6.3 Tamanho Do Vocabulário............................................................................ 16 2.6.4 Recursos Para Desenvolvimento Rápido De Aplicativos (RAD) ................. 16 Capítulo III - Fundamentos Teóricos De Desenvolvimento De Sistemas Web..... 17 3.1 Programação Orientada A Objetos ............................................................... 17 3.2 Java................................................................................................................ 17 3.3 Ruby............................................................................................................... 19 3.4 Framework ..................................................................................................... 22 3.5 Padrão De Modelagem Model-View-Controlller ............................................. 27 3.6 Eclipse IDE..................................................................................................... 29 3.7 Aptana IDE..................................................................................................... 33 3.8 Firebird Data Base ......................................................................................... 35 3.9 Tecnologia Servlet.......................................................................................... 37 3.10 Tecnologia Javaserver Pages ...................................................................... 38 3.11 Javabeans.................................................................................................... 38 Capítulo IV - Ruby On Rails ................................................................................. 39 4.1 Sobre O Framework ....................................................................................... 39 4.1.1 Filosofias ..................................................................................................... 39 4.2 Descrição Das Camadas................................................................................ 42 4.3 Configuração .................................................................................................. 43 4.4 Estrutura De Pastas ....................................................................................... 43 4.5 Recursos Adicionais....................................................................................... 44 Capítulo V – Apache Struts .................................................................................. 45 5.1 Sobre O Framework ....................................................................................... 45 5.2 Camada Modelagem ...................................................................................... 46 5.3 Camada De Controle...................................................................................... 46 5.4 Camada Visual ............................................................................................... 47 5.5 Configuração .................................................................................................. 48 5.6 Estrutura De Pastas ....................................................................................... 49
8
5.7 Recursos Adicionais....................................................................................... 49 Capítulo VI – Projeto Lógico................................................................................. 50 6.1 UML do Sistema: Diagrama Dos Casos De Uso E Suas Descrições............. 50 6.1.1 Diagramas Dos Casos De Uso.................................................................... 50 6.1.2 Descrição Dos Casos De Uso ..................................................................... 51 6.2 Prototipagem De Telas................................................................................... 57 6.3 Desenvolvimento Do Banco De Dados .......................................................... 60 6.3.1 Diagrama Do Banco De Dados ................................................................... 61 6.3.2 Descrição Das Tabelas E Dos Seus Campos ............................................. 61 Capitulo VII - Desenvolvimento Das Aplicações................................................... 63 7.1 Desenvolvendo Com Ruby On Rails .............................................................. 63 7.1.1 Etapas Do Desenvolvimento ....................................................................... 63 7.1.1.1 Criação Do CRUD Da Aplicação Com Suas Entidades............................ 63 7.1.1.2 Configuração Das Entidades Da Aplicação.............................................. 63 7.1.1.3 Criação Dos Métodos E Páginas De Login, Logoff .................................. 63 7.1.1.4 Criação Do Menu Principal....................................................................... 64 7.1.1.5 Inserção Do Filtro De Controle De Usuários Em Toda A Aplicação ......... 65 7.1.2 Resultados .................................................................................................. 65 7.2 Desenvolvendo Com Struts............................................................................ 67 7.2.1 Etapas Do Desenvolvimento ....................................................................... 67 7.2.1.1 Criação Dos Javabeans Do Sistema........................................................ 67 7.2.1.2 Criação Da Camada De Modelagem Do Sistema .................................... 67 7.2.1.3 Criação Das Páginas, Forms E Actions Da Aplicação.............................. 68 7.2.1.4 Criação Do Pacote Útil ............................................................................. 69 7.2.2 Resultados .................................................................................................. 70 7.3 Conclusões Do Comparativo.......................................................................... 71 Conclusão ............................................................................................................ 72 Trabalhos Futuros ................................................................................................ 72 Referências Anexos
9
CAPÍTULO I - INTRODUÇÃO
Atualmente a construção de ferramentas para agilizar o desenvolvimento de
aplicativos web é de grande importância nas empresas especializadas do setor.
Essas ferramentas denominadas frameworks que serão explicadas mais
detalhadamente nesta monografia agilizam o desenvolvimento e competitividade,
sendo atualmente de extrema importância para os desenvolvedores. Diminuindo
principalmente a repetição de código, melhorando a padronização das aplicações.
Com a variedade de tipos de aplicações, varias linguagens de programação e vários
recursos que podem ser disponíveis no meio multimídia da internet, se originaram
diversos tipos de frameworks, com suas filosofias e habilidades características.
Cada um com suas soluções para problemas específicos ou para todos os
problemas.
Essa oferta de soluções torna a escolha desse tipo de facilidade uma boa iniciativa
para agilizar o desenvolvimento e diminuindo o espaço de tempo de entrega das
aplicações, onde, atualmente, com a concorrência entre as empresas, qualquer
incentivo na velocidade de desenvolvimento faz diferença, e principalmente o
diferencial de tempo de entrega de um produto. Todavia existe um excesso de
soluções desse ramo no mercado, tanto Opensource (OPENSOURCE, 2007),
quanto de empresas privadas, para varias linguagens e com varias idéias de
soluções, cada qual tendo suas particularidades. Vários já foram descontinuados, e
outros continuam atuantes, tendo sempre que se atualizar, para não perder espaço
perante tantas escolhas.
Atualmente o desenvolvimento de aplicações web, tem como suas principais
ferramentas de desenvolvimento seus frameworks. Com isso uma empresa que
trabalha com desenvolvimento de soluções para web tem que fazer uma escolha
que pode afetar todo o projeto, pois é na escolha do framework que pode determinar
o sucesso ou fracasso de uma solução. Mesmo no meio profissional a escolha de
uma dessas soluções, para especialização, foco de carreira vai fazer diferença no
futuro profissional e retorno financeiro.
Nesse contexto, este trabalho analisa dois frameworks em destaque, foram
escolhidos o Struts por ser o framework mais citado na internet (INDEED, 2007), e o
Ruby on Rails por ser o framework que mais cresceu no ano de 2006 junto com a
linguagem Ruby. (INDEED, 2007) (TIOBE,2007). São duas soluções para um
10
mesmo problema, com suas filosofias e resoluções, fazendo uma discussão das
vantagens e desvantagens de cada um nesse escopo apresentado.
Neste trabalho, serão desenvolvidas duas aplicações, cada qual com um dos
frameworks discutidos, Ruby on Rails (RAILS, 2007) e Struts (STRUTS, 2007),
essas aplicações terão as mesmas bases para o desenvolvimento, onde os casos
de uso, banco de dados e prototipação de telas serão os mesmo. Sendo comparado
somente suas soluções internas de desenvolvimento.
1.1 Motivação
O numero de aplicações voltadas para web encontram-se em constante
multiplicação e soluções para o desenvolvimento das mesmas segue o mesmo
ritmo. Há empresas que resolvem desenvolver suas próprias soluções e outras que
preferem escolher uma do vasto cardápio disponível. Cada dia que se passa
aplicações web estão sendo desenvolvidas com funcionalidades de aplicativos para
Desktop. Como alguns exemplos temos processadores de texto, planilhas
eletrônicas, clientes de e-mail, agendas, bloco de notas, jogos entre outros (WEB2,
2007)(GOOGLE,2007).
O Ruby on Rails chama à atenção por sua explosão, e comentários no grupo de
usuários Java, JavaFree (JAVAFREE,2007). Levando aos desenvolvedores Java do
site JavaFree produzirem um portal para a linguagem Ruby e o framework Ruby on
Rails (RUBYONBR, 2007).
Atualmente três grandes empresas de soluções de desenvolvimento, SUN
Microsystem (SUN, 2007), Microsoft (MICROSOFT, 2007) e a Borland (BORLAND,
2007) estão investindo na linguagem Ruby. A SUN contratou os desenvolvedores do
Jruby, um projeto que implementa a linguagem Ruby para rodar na arquitetura da
Maquina Virtual Java, no momento esses desenvolvedores continuam trabalhando
no Jruby (JRUBY, 2007) para melhorar a implementação. E a partir do JRUBY já se
tem hoje o JRuby on Rails, ou seja, o Ruby on Rails rodando com o recursos do
Java que não fazem parte do escopo dessa monografia (JRUBYONRAILS, 2007).
As IDE´s (Integrated Development Environment) de desenvolvimento mais
conhecidas atualmente estão com versões que suportam programação na
linguagem Ruby, entre elas estão o ECLIPSE (ECLIPSE,2007), NETBEANS
11
(NETBEANS,2007) e a próxima versão da Microsoft Visual Studio
(MVSTUDIO,2007).
1.2 Objetivos 1.2.1 Objetivo Geral
Fazer um comparativo das soluções utilizadas pelos dois frameworks que serão
apresentados, a partir do desenvolvimento de duas aplicações cada qual com um
framework. E com isso avaliar qual das duas apresenta os melhores recursos no
desenvolvimento de aplicações web.
1.2.2 Objetivos Específicos
• Estudar os conceitos das tecnologias no desenvolvimento web;
• Apresentar os dois frameworks;
• Avaliar os resultados do estudo comparativo;
1.3 Estrutura do Trabalho
Esta monografia está dividida em sete capítulos:
O segundo capítulo trata da metodologia utilizada no projeto; O terceiro capítulo trata
das tecnologias e referenciais teóricos que serviram de base para os dois
frameworks; No quarto capítulo será apresentado o framework Ruby on Rails,
especificando suas origens, funcionamento, estrutura e características especiais; No
quinto capítulo será apresentado o framework Apche Struts, especificando suas
origens, funcionamento, estrutura e características especiais; O sexto capítulo será
mostrado o projeto lógico que servirá de base para o desenvolvimento das duas
aplicações; O sétimo capítulo será explicado cada etapa de desenvolvimento das
duas aplicações, e os resultados obtidos; O último capítulo terá as conclusões finais
sobre os dois frameworks a partir dos dados obtidos com o desenvolvimento.
12
CAPÍLULO II – METODOLOGIA
Este capítulo apresenta os métodos utilizados para alcançar os objetivos gerais e
específicos citados no capítulo 1 dessa proposta.
Serão utilizados diagramas no padrão UML (UML, 2007) para representar os
diagramas de casos de uso dos dois tipos de usuários que o sistema comporta.
Depois serão desenvolvidos os casos de uso do sistema para ter como base no
desenvolvimento. Logo após será desenvolvido os protótipos de telas. Com base
nos protótipos, vem a fase de escolha das ferramentas a serem utilizadas na
implementação da aplicação com os dois frameworks, Ruby on Rails e Struts.
2.1 Casos de Uso e Protótipos
Conforme apresentada na Figura 1, serão trabalhadas na metodologia da aplicação
estas etapas:
Figura 1 – Etapas da metodologia
13
2.2 Diagramas UML
UML (Unified Modeling Language) é uma linguagem para visualização,
especificação, construção e documentação de artefatos de um software em
desenvolvimento (UML, 2007).
2.2.1 Diagrama de Caso de Uso
Segundo (GOMES, 2003) diagramas de caso de uso fornecem um modo de
descrever a visão externa do sistema e suas interações com o mundo exterior,
representando uma visão de alto nível de funcionalidade intencional mediante o
recebimento de um tipo de requisição do usuário (UML, 2007).
2.3. Prototipagem de baixa fidelidade
Protótipo é uma valiosa ferramenta no projeto de aplicações. Eles podem ajudar na
avaliação de alternativas de design a qualquer estágio do processo de
desenvolvimento (AZEVEDO, 2005). Durante a fase conceitual os elementos
básicos do design podem ser explorados e testados junto com os usuários. Ao
serem projetadas as telas, menus e levantadas as formas de interação em maior
detalhe, estas questões podem ser discutidas, avaliadas e testadas. Mais adiante
modelos mais elaborados podem ser utilizados para dar uma visão antecipada da
aplicação final.
A prototipação de papel pode ser considerada como um método de projeto, criação,
teste e comunicação de interfaces gráficas com usuários. Segundo a definição de
(AZEVEDO, 2005) prototipação em papel é uma variação de testes de usabilidade
que usuários representativos executam tarefas reais através da interação com uma
versão de papel da interface manipulada por uma pessoa “atuando como um
computador”, que não explica como a interface foi projetada para funcionar. A
autora ainda salienta que essa técnica é independente de plataforma, podendo ser
utilizada para aplicações para internet, softwares, celulares, tudo que possui uma
interface homem-computador pode ser objeto de prototipação em papel.
Essa etapa da metodologia visa criar as telas do Sistema de Atividade proposto para
as duas aplicações.
14
Ao concluir a prototipação de papel inicia-se a implementação do Projeto lógico do
Banco de Dados, logo após o desenvolvimento físico do Banco de Dados e o inicio
do desenvolvimento das aplicações utilizando os dois frameworks.
2.4 Modelagem do Banco de Dados
A modelagem do banco de dados será desenvolvida de acordo com o modelo
relacional proposto pelo framework Ruby on Rails e seu ActiveRecord. (AKITA,
2007). Não influenciando o desenvolvimento no framework Struts. Serão criadas as
tabelas na ferramenta específica e a partir daí cria-se o banco de dados registrando-
o para sua utilização no servidor de Banco de Dados.
2.5 Técnicas e Ferramentas utilizadas
A ferramenta utilizada será o Eclipse 3.2.2 (ECLIPSE, 2007) para o desenvolvimento
do projeto em Struts, um ambiente de desenvolvimento de aplicações Java mostrado
descrito com maiores detalhes no capitulo 3 seção 3.6. Para o desenvolvimento em
Ruby on Rails será usado o Aptana 0.2.8 (APTANA, 2007), um versão modificada do
Eclipse para o desenvolvimento de projetos Ruby on Rails, descrito com maiores
detalhes no capitulo 3 seção 3.7.
O servidor de aplicação utilizado para o projeto feito com o framework Struts será o
Apache Tomcat (TOMCAT, 2007). É distribuído como software livre e desenvolvido
como código aberto dentro do conceituado projeto Apache Jakarta (JAKARTA, 2007)
e oficialmente endossado pela SUN (SUN, 2007) para as tecnologias JavaServer
Pages (JSP, 2007) citado no capítulo 3 seção 3.11. O Tomcat tem a capacidade de
atuar também como servidor web/HTTP (TOMCAT, 2007).
O banco de dados escolhido foi o Firebird 2.0 (FIREBIRD, 2007) e será desenvolvido
na ferramenta SQL Manager 2005 for Firebird/Interbase (SQLM, 2006) citado no
capítulo 3 seção 3.8.
15
2.6 Levantamento dos Critérios de Avaliação
Nessa seção serão apresentados os critérios de avaliação usados nas duas
aplicações, através de métricas. Segundo Pressman (PRESSMAN, 2007), as
métricas têm três objetivos principais na engenharia de software para web:
• Fornecer uma indicação da qualidade da aplicação web de um ponto de vista
técnico;
• Fornecer uma base para estimativa de esforço;
• E fornecer uma indicação da aplicação web do ponto de vista do negócio;
Focaliza-se, nesta monografia, a estimativa de esforço, onde o principal objetivo dos
dois frameworks é melhorar essa estimativa. Alem dessa medida iremos utilizar
métricas padrões de projetos não focados em aplicativos web, que podem ser
usados sem problema nesses dois projetos, servindo para quantifica-los. São eles:
(1) Numero de Linhas de Código, (2) Tamanho do Vocabulário, (3) Recursos para
RAD.
2.6.1 Tempo de Desenvolvimento pela Estimativa de Esforço
Nas Métricas para Esforço da Engenharia da Web (PRESSMAN, 2007), iremos
quantificar os seguintes esforços nos dois projetos:
2.6.1.1 Esforço de Estruturação
Métrica utilizada para quantificar o tempo gasto na estruturação da aplicação, nas
pastas e arquivos do sistema.
2.6.1.2 Esforço de Programação
Métrica utilizada para quantificar o tempo gasto na codificação dos sistemas
propostos.
16
2.6.2 Numero de Linhas de Código
Essa métrica conta o número de linhas de código. É uma medida de tamanho
tradicional. Comentários relativos à documentação ou implementação não são
interpretados como código. Linhas em branco também não são contadas.
Estilos diferentes de programação podem influenciar os resultados obtidos pela
aplicação dessa métrica. Quanto maior for o número de linhas de código, maior será
a dificuldade para: (1) entender o sistema. (2) encontrar as linhas que precisam ser
alteradas durante atividades de evolução, (3) entender a implementação das
funcionalidades que se deseja reutilizar.
2.6.3 Tamanho do Vocabulário
Essa métrica conta o número de componentes do sistema, isto é, o número de
classes e interfaces que constituem o sistema. Cada nome de componente é
contado como parte do vocabulário do sistema. As instâncias não são contadas.
Quanto maior for o tamanho do vocabulário, mais difícil será para entender o
sistema. Quanto mais difícil for para entender o sistema, mais difícil será para
encontrar os componentes que precisam ser modificados durante atividades de
evolução, e mais difícil será para encontrar os componentes que implementam as
funcionalidades que se deseja reutilizar.
2.6.4 Recursos para Desenvolvimento Rápido de Aplicativos (RAD – Rapid
Application Development)
Essa métrica quantificará a quantidade de recursos RAD em cada framework. Onde
quanto maior o numero de recursos menos é o tempo de desenvolvimento. E quanto
maior o numero de recursos menor o tempo de manutenção.
17
CAPÍLULO III - FUNDAMENTOS TEÓRICOS DE DESENVOLVIMENTO DE
SISTEMAS WEB
Aqui será tratado tecnologias e conceitos fundamentais do projeto proposto,
para uma analise mais aprofundada nas estruturas que se firmaram os frameworks
Ruby on Rails e Struts.
3.1 Programação Orientada a Objetos
Programação Orientação a Objeto tem como base a idéias de classes, onde
uma classe é um tipo de dado definido pelo usuário, ou seja, pelo programador ou
analista (SEB 2000). Um objeto é uma instância, ou ocorrência, da classe (DEI
2001). Esse conceito de classes foi introduzido com a linguagem SIMULA (SIM
2007) em 1967 e Smalltalk (SMT 2007) em 1980 (GHE 1998). As Classes podem ter
propriedades, que podem ser alteradas através de métodos de acesso, e esses
métodos pode receber parâmetros ou não. Três linguagens de programação
bastante difundidas que atualmente carregam a bandeira da orientação a objeto são
C++ (GCC 2007), criada em 1980, Java (JAVA, 2007) criada em 1990 (SEB 2000) e
Ruby (RUBY, 2007), criada em 1993. Nesse trabalho as duas linguagens de
programação abordadas nas seções 3.2 e 3.3 são orientadas a objetos.
3.2 Java
Java é uma linguagem de programação orientada a objeto desenvolvida na década
de 90 pelo programador James Gosling, na empresa Sun Microsystems (SUN,
2007). Diferentemente das linguagens convencionais, que são compiladas para
código nativo, ou seja, o código é compilado para rodar somente para aquele
sistema operacional, a linguagem Java é pré-compilada, e o resultado é um
"bytecode" que será interpretado pela Máquina Virtual Java
(ARNOLD,GOSLING,HOLMES, 2006). A Maquina Virtual Java esta disponível para
os principais sistemas operacionais do mercado, sendo assim Java não é uma
linguagem compilada nem interpretada e sim pré-compilada. Java é uma linguagem
híbrida, um dos motivos é seus tipos primitivos de variáveis. Outra característica é
sua tipagem estática e forte, ou seja, quando se é criado um objeto no código fonte
ele não poderá mudar mais seu tipo. O Java que tem sua sintaxe e tipos primitivos
herdados da linguagem C++ (GCC, 2007).
18
O Java teve sua explosão a partir dos seus aplicativos para internet, que rodavam
dentro dos navegadores. Os Applets se tornaram sinônimo de dinamismo das
paginas web de todo o planeta (ARNOLD,GOSLING,HOLMES, 2006). Com essa
versatilidade desses pequenos aplicativos acabou aumentando a curiosidade de
vários desenvolvedores, crescendo para se tornar à linguagem mais utilizada no
desenvolvimento mundial (TIOBE, 2007). Hoje o Java possui uma vasta biblioteca
de recursos, sendo utilizada para desenvolvimento de Aplicativos para internet,
desktop, celulares, cartões, eletrodomésticos entre outros
(ARNOLD,GOSLING,HOLMES, 2006).
O Java não tem um gerenciador para atualizar e instalar novas bibliotecas e
recursos da linguagem, sendo necessário acessar o site do desenvolvedor da
biblioteca, efetuar o download, colocar na pasta da aplicação e referenciá-la na
aplicação para poder usar.
Java é a linguagem mais usada em todo mundo (TIOBE, 2007). Com vários sites
especializados, listas de discussões e grupos de desenvolvedores em vários paises.
Tendo ainda muito material disponível na internet, uma boa e vasta documentação.
A linguagem Java foi projetada tendo em vista os seguintes objetivos:
• Ser Orientada a Objetos;
• Ser Portável “Independência de plataforma”;
• Possuir Recursos de Rede;
• Ser Segura;
Além disso, podem-se destacar outras vantagens apresentadas pela linguagem:
• Palavras chaves similares a Linguagem C/C++ (GCC, 2007).
• Facilidades de Internacionalização;
• É distribuída com um vasto conjunto de bibliotecas;
• Possui facilidades para criação de sistemas distribuídos e multitarefa;
• Possui um sistema de gerenciamento de memória automático, através do
processo de coleta de lixo (garbage collector);
• Carga Dinâmica de Código - Programas em Java são formados por uma
coleção de classes armazenadas independentemente e que podem ser
19
carregadas para a Memória no momento de utilização.
(ARNOLD,GOSLING,HOLMES, 2006)
Java é a linguagem utilizada na construção do framework Struts. Iremos estudar
esse framework no capitulo IV.
3.3 Ruby
Ruby é uma linguagem de programação criada em 1993 por um programador
japonês chamado Yukihiro Matsumoto (MATZ, 2007), não sendo uma linguagem
compilada e sim interpretada. Ela é executada diretamente encima do código fonte.
Tem tipagem dinâmica e forte, ou seja, os objetos sabem o tipo em execução,
diferentemente da linguagem Java que é estática e forte. Ruby é 100% orientada a
objeto, de forma simples por sua interface humana de programação, como será
explicado adiante. Projetada tanto para a programação de grandes projetos como
para pequenos aplicativos. Como exemplo temos os aplicativos de Shell Linux
(SHELL, 2007), o seu suporte a orientação a objetos foi projetado para ser simples e
pratico.
A partir de um site especializado em fazer buscar por referencia percebe-se que o
Ruby esta crescendo o numero de referencias na internet, esta ficando mais
conhecido (INDEED, 2007). Possui vários repositórios de código como o Ruby
Application Archive (RAA, 2007) e Rubyforge (RUBYFORGE, 2007). Entre as
características que podemos apontar nessa linguagem se destaca uma ferramenta
que gerencia as atualizações e instalações de plugins chamada RubyGems (GEMS,
2007).
Ruby se tornou reconhecida no ocidente a partir do momento que Dave Thomas,
conhecido como um dos Pragmatic Programmers (Programadores Pragmáticos),
adotou o Ruby como uma de suas linguagens de trabalho. Thomas acabou por
escrever a bíblia da linguagem, o Programming Ruby, The Pragmatic Programmer's
Guide. Com isso Ruby ganhou mais alguns adeptos de sua filosofia. (THOMAS,
2007)
20
A praticidade é um dos conceitos básicos desta linguagem. Deve-se fazer códigos
que resolvam os problemas do desenvolvedor, e não os problemas da linguagem
e/ou interpretador/compilador (RUBY, 2007).
Para manter a praticidade, a linguagem possui algumas características
interessantes:
� A sintaxe é enxuta, quase não havendo necessidade de colchetes e outros
caracteres que dificultam a leitura.
� Com o conceito de praticidade, para ter acesso as propriedades de uma
classe e seus métodos de acesso, no Ruby só é necessário declarar as
propriedades e dizer qual o tipo de acesso que se quer dar através dos atalhos:
(1) "attr_acessor" que dar acesso de leitura e escrita à propriedade, (2)
"attr_reader" que dá acesso somente de leitura e (3) "attr_writer" que dá acesso
somente de escrita. Sendo possível sobre-escrever os métodos de acesso se
necessário, ficando exemplificado nos Quadros 1 e 2
� Outra característica é a forma que é montado o construtor, as classes em
Ruby tem um único construtor. Podendo as entradas de parâmetros valores
padrões.
� Tudo são objetos, até mesmo os tipos mais básicos de variáveis.
Java class Pessoa { private String nome; public Pessoa(String nome){ this.nome = nome; } public Pessoa(){ this.nome = “ninguem”; } public void setNome(String nome){ this.nome = nome; } public String getNome(){ return this.nome; } }
Ruby class Pessoa attr accessor :nome def initialize(nome = “ninguem”) @nome = nome end end
Quadro 1 Quadro 2
21
� Ruby tem um gerenciador de bibliotecas e plugins da linguagem. Como
exemplo para instalar uma biblioteca nova, basta digitar "gem install biblioteca"
na linha de comando do seu sistema operacional.
� Tem o recurso de blocos de código, o qual ajuda o programador a passar
um trecho de instruções para um método. A idéia é o programador poder
passar alem de dados para os métodos, passar também código que será
executado dentro da classe. No Quadro 3 esta sendo declarada um método
que recebe um bloco de código e o executa. Essa é uma característica que não
existe na linguagem Java.
� No Ruby existe a idéia de Módulos, uma forma mais simples de Herança
Múltipla, ou seja, quando uma classe herdar características de outras.
� No código dos Quadros 4 e 5 esta sendo instanciado uma classe Telefone,
e um modulo CoisaQueFazBip, com seus respectivos métodos, logo após é
instanciada uma classe Celular que herda da classe Telefone e é inserido o
modulo CoisaQueFazBip, e logo após é instanciado a classe Palmtop que não
herda de nenhuma classe, e é adicionado o modulo CoisaQueFazBep.
def teste(um_bloco)
um_bloco.call
end
bloco = proc { puts “oi!” }
teste(bloco) # >> oi!
class Telefone def disca
“discando...” end def atende
“atendendo...” end
end module CoisaQueFazBip
def bip “Bip!”
end end
class Celular < Telefone include CoisaQueFazBip end class Palmtop include CoisaQueFazBip End c = Celular.new p = Palmtop.new Puts “celular: #{c.bip}” Puts “palmtop: #{p.bip}” Resultado: Celular: Bip! Palmtop: Bip!
Quadro 3
Quadro 4 Quadro 5
22
Lembrando que no Java não existe herança múltiplas, usando Interfaces para
chegar a resultados próximos da herança múltiplas.
(ARNOLD,GOSLING,HOLMES, 2006).
� Tipagem dinâmica, mas forte. Isso significa que todas as variáveis devem
ter um tipo, mas o tipo só é conhecido em execução. Onde as variáveis fazem
referencia ao objeto. Lembrando que não é o Objeto que muda de tipo e sim a
referência que aponta para outro objeto. Em outras linguagens como o Java as
variáveis e os objeto devem ser referenciados antes da execução, tendo
referencia estática. Não podendo ser mudada dinamicamente no momento da
execução. Um exemplo de tipagem dinâmica e forte do ruby no Quadro 6.
Com o Ruby é uma linguagem interpretada a sua performance de execução é menor
que o Java por ser pré-compilada, e a linguagem Java tem menor performance que
a linguagem C (GCC, 2007).
O Ruby tem Independência de plataforma como o Java, más não tem Maquina
Virtual como o mesmo e sim um interpretador de código fonte, ou seja, a medida que
o código vai sendo lido pelo interpretador, ele o transforma em código de maquina e
executa a aplicação, por esse motivo o Ruby acaba sendo mais lendo que o Java.
(EUSTÀQUIO,2006).
3.4 Framework
A definição de framework varia. Uma definição usada freqüentemente é “um
framework é um design reusável de todo ou parte de um sistema que é representado
por um conjunto de classes abstratas e a forma que suas instâncias interagem”
(Fayad;Schmidt;Johnson, 1999). Outra definição comum é “um framework é o
esqueleto de uma aplicação que pode ser customizado pelo desenvolvedor da
x = 10
x = 'Texto String'
y = 20
z = x + y => ocorrerá um erro de tipo
TypeError: String can't be coerced into Fixnum
Quadro 6
23
aplicação” (Fayad;Schmidt;Johnson, 1999). Estas não são definições conflitantes: a
primeira descreve a estrutura de um framework enquanto a segunda descreve seu
propósito. (Fayad;Schmidt;Johnson, 1999) Usualmente, vários aspectos de um
framework de aplicação não podem ser completamente antecipados. Estas partes -
genéricas para que possam ser facilmente estendidas e customizadas, ou seja,
adaptáveis a necessidades específicas – são denominadas hot-spots flexíveis
(FAYAD;SCHMIDT;JOHNSON, 1999) como mostra a Figura 2.
Estes hot-spots são descobertos na análise do domínio ou providos por um
especialista no domínio (Fayad;Schmidt;Johnson, 1999). A dificuldade de um bom
design orientado a objetos é identificar estes aspectos do domínio de aplicação que
têm que ser mantidos flexíveis, tanto que um framework é considerado “bem
projetado” se ele provê hot-spots adequados para adaptações. (PREE, 1995)
Conforme citado anteriormente, esta flexibilização permite que o framework possa
ser usado como base para o desenvolvimento de diferentes aplicações no domínio
de aplicação por ele capturado como mostra a Figura 3.
Figura 2: Hot-spots flexíveis do framework (regiões sombreadas)
24
O desenvolvimento de frameworks orientados a objetos tem potenciais pontos fortes
e fracos, (MATTSSON, 1996) conforme pode ser visto na Tabela 1.
Pontos Fortes Pontos Fracos- uma diminuição real em linhas de código que tem que ser desenvolvidas se a funcionalidade requerida pela aplicação e a funcionalidade capturada pelo framework tem um alto grau de similaridade;- o código do framework já está escrito e depurado;- o framework oferece reuso de design e não somente de código. Este reuso de design feito por outros pode transferir conhecimento e experiências de design ao usuário do framework;- aspectos de eficiência do software podem ser previstos pelos desenvolvedores do framework o que normalmente não pode ser feito em um planejamento de projeto de aplicação normal.
- é difícil desenvolver um bom framework. Experiência no domínio da aplicação é necessária quando o mesmo for construído;- a documentação do framework é crucial a seu usuário. Se os frameworks não provêm documentação, eles provavelmente não serão usados;- a compatibilidade pode ser difícil de manter. Isto deve-se ao fato do framework se desenvolver e tornar-se mais maduro com o tempo e a aplicação construída sobre ele dever evoluir junto;- o processo de depuração pode ser complicado por que é difícil distinguir problemas no framework de problemas no código da aplicação. Se os problemas estão no framework, pode ser impossível para seu usuário encontrá-los;- a generalidade e flexibilidade do framework podem ir em contra sua eficiência em uma aplicação particular.
Tabela 1: Potenciais pontos fortes e fracos de um framework
Como as pessoas, as aplicações de software são mais semelhantes que diferentes.
Elas são executadas nos mesmos computadores, esperam uma entrada dos
mesmos dispositivos, produzem as mesmas exibições e gravam os dados nos
mesmos discos rígidos. Os desenvolvedores que trabalham em aplicações
convencionais estão acostumados a kits de ferramentas e a ambientes de
desenvolvimento que aproveitam a igualdade entre as aplicações. Os frameworks de
aplicação se desenvolvem nessa base comum, para fornecer aos desenvolvedores
uma ferramenta reutilizável que pode servir como estrutura principal para seus
Figura 3: Desenvolvimento de Aplicações baseadas em frameworks (Mattsson, M, 1996)
25
próprios projetos Ou seja, o framework captura as funcionalidades comuns a várias
aplicações, as aplicações devem ter algo razoavelmente grande em comum, como
ilustrado na Figura 4.
Figura 4 Possibilidade de Criação de um framework
Um framework é diferente de uma biblioteca de componentes, pois as partes que se
compõem têm quê se comunicar de forma padronizada sendo cada parte
dependente da outra, nas bibliotecas de componentes cada classe é independente
das demais, demonstrado na Figura 5.
Figura 5 Diferenças entre framework e Biblioteca
No desenvolvimento com o uso de frameworks os benefícios são claros em termos
de redução de custos e de tempo de desenvolvimento, motivando a maximização de
re-uso de código, os desenvolvedores se concentram em adicionar valor em vez de
gastar tempo com codificação de marcação. Há um menor numero de manutenções,
26
pois existe um menor numero de codificação no desenvolvimento, dando mais
estabilidades nas aplicações desenvolvidas com o framework.
O framework oferece uma forma de empacotar conhecimento, ou seja, um
framework pode ser desenvolvido com uma gama de tecnologias e por especialistas,
e assim que fica pronto, os desenvolvedores que irão utiliza-lo não precisam saber
das tecnologias que ele foi feito, e sim só saber usar o framework. Como exemplo
temos o Struts que usa da tecnologia JavaServer Page, abstraindo a mesma,
deixando seu uso oculto no framework. Assim não é necessário a contratação ou o
investimento elevado para desenvolver com frameworks. Ou seja, não precisa do
desenvolvedor do framework para desenvolver com ele. Apenas saber como usar o
mesmo.
Referente aos tipos, os frameworks podem ser classificados dependendo de onde
são usados e como são usados (FAYAD;SCHMIDT;JOHNSON, 1999):
Como é Usado:
• Caixa-Branca
o Estende ou modifica funcionalidades internas do framework.
• Caixa-Preta
o Usa dos recursos disponíveis no framework sem ter acesso ao seu
núcleo de funcionamento.
• Híbridos
o São uma mistura dos dois acima. Onde o framework tem partes
modificáveis e outras não.
Onde é Usado (FAYAD;SCHMIDT;JOHNSON, 1999):
• Framework de suporte
o Provê serviços de nível de sistema operacional (e não de aplicação)
� Acesso a arquivos;
� Computação distribuída;
� Device drivers;
• Framework de aplicação
27
o Encapsula conhecimento ("expertise") aplicável a uma vasta gama de
aplicações;
o Resolve apenas uma fatia do problema da aplicação;
o Exemplo: Framework para construção de interface GUI;
• Framework de domínio
o Encapsula conhecimento ("expertise") aplicável a aplicações
pertencendo a um domínio particular de problema;
o Resolve boa parte do desenvolvimento da aplicação;
o Exemplo: Framework para construir aplicações de controle de
manufatura;
Normalmente uma aplicação pode usar vários frameworks para ser construída,
podendo ser de vários tipos, com varias funcionalidades e recursos.
3.5 Padrão de Modelagem Model-View-Controlller
Padrão de Modelagem MVC - Model, View, Controller “Modelo, Visual, Controle”
(HUSTED,2004) fornece uma maneira de dividir a funcionalidade envolvida na
manutenção e apresentação dos dados de uma aplicação. A arquitetura MVC não é
nova e foi originalmente desenvolvida para mapear as tarefas tradicionais de
entrada, processamento e saída para um modelo de interação com o usuário
(HUSTED,2004). A origem do padrão MVC é do framework interno da linguagem de
programação Smalltalk. O framework suportava três classes representando, o
estado da aplicação identificado como Model, a apresentação da tela identificada
como View, o fluxo de controle identificado como Controller. E todas as camadas se
comunicam entre si, como demonstra a Figura 6.
Controller
Model
View
28
Figura 6: Diagrama da comunicação das camadas do modelo MVC.
A solução Smalltalk MVC é usar um padrão de notificação Observer. Nesse padrão,
cada View registra-se como um observador dos dados de Model. Model pode então
notificar as Views sobre as alterações enviando uma mensagem para todos os seus
observadores registrados.
Houve a generalização do padrão Smalltalk MVC para o modelo Model-View-
Controller, que pode ser aplicado na construção de aplicações em qualquer
plataforma.
A partir da idéia do MVC do Smalltalk se teve origem o padrão usado em
frameworks como Struts, o Modelo 2 (HUSTED,2004). O Modelo 2 teve origem a
partir do desenvolvimento de aplicativos JSP (HUSTED,2004), os programadores
sentiram a necessidade após o crescimento do projeto de padronizar o fluxo de
informação dentro do JSP.
O modelo de três camadas físicas divide um aplicativo de modo que a lógica da
aplicação resida no meio das três camadas físicas. Isto é chamado de camada física
intermediária ou camada física de negócios. A maior parte do código escrito reside
na camada de apresentação e de negócio (HUSTED,2004). Tem como contexto
aplicações interativas que requerem interfaces flexíveis.
As funcionalidades de cada camada são as seguinte:
• Camada de Modelagem (Model): estrutura lógica de dados;
• Camada de Visualização (View): camada responsável pela comunicação da
aplicação com o usuário;
• Camada de Controle (Controller): realiza a comunicação entre a camada de
modelagem e visualização.
As características principais do padrão MVC são: (HUSTED,2004)
• a separação das camadas,
• padronização do projeto,
• reusabilidade das camadas em outras aplicações,
29
• melhor separação de uma equipe de desenvolvimento, podendo separar
equipes por camadas,
• melhor divisão de funcionalidades,
• separa o código da camada visual.
Atualmente é o padrão mais usado no desenvolvimento de aplicativos web
(HUSTED, 2004), sendo o padrão dos frameworks aqui abordados, Apache Struts e
Ruby on Rails.
3.6 Eclipse IDE
A IDE de desenvolvimento escolhida para a pesquisa é o eclipse (ECLIPSE, 2007)
utilizada para programar nas duas linguagens e para os dois frameworks. Sendo
necessário somente instalar os plugins específicos para o desenvolvimento das
aplicações em seus devidos frameworks.
A plataforma Eclipse é uma proposta de consórcio de empresas que apóiam o uso
de uma arquitetura aberta para a criação de ambientes integrados de
desenvolvimento (Integrated Development Environment - IDE), onde a indústria de
software possa desenvolver diversos programas, aplicativos e ferramentas, de forma
otimizada e padronizada, baseando-se nas iniciativas de software livre.
O Eclipse oferece uma estrutura flexível, pois utiliza linguagem Java e vem com
exemplos de construção. Isso torna mais fácil a criação, integração e utilização das
ferramentas, economizando tempo e dinheiro. A plataforma Eclipse como é
desenvolvida em Java acaba sendo uma IDE multiplataforma por rodar encima da
Maquina Virtual Java.
Para pesquisadores e educadores (ECLIPSE, 2007), o Eclipse ainda oferece um
valor significativo: uma infra-estrutura para condução de pesquisas e
desenvolvimento curricular em muitas áreas da engenharia de computação, com
relevância particular em linguagem de programação, ferramentas de
desenvolvimento e colaboração.
O Eclipse é uma ferramenta para o desenvolvimento de aplicações de portes
variados, funções e em varias linguagens de programação, entre elas C (GCC,
2007), C++ (GCC, 2007), PHP (PHP, 2007), Java (JAVA, 2007), Ruby (RUBY,
30
2007), Fortran (FORTRAN, 2007) entre outras e linguagens de marcação como
JavaScript (JAVASCRIPT, 2007), HTML (HTML, 2007), CSS (CSS, 2007), XML
(XML, 2007) e outras. (BURNETTE,ED,2006).
A versão utilizada do Eclipse para o desenvolvimento do Projeto com o framework
Struts foi a 3.2.1 com os seguintes plugins que ajudam na edição dos códigos:
• Amateras HTML Editor: Plugin para edição de códigos html (HTML, 2007), jsp
(JSP, 2007), css (CSS, 2007) e javascript (JAVASCRIPT, 2007).
(AMATERAS,2007)
• Amateras Struts Editor: Plugin para edição, criação de arquivos,
configurações e estrutura de pastas do framework Struts. (AMATERAS,2007)
• Sysdeo Tomcat: Plugin para controlar o servidor de aplicação utilizado a partir
do Eclipse, com ele é possível adicionar projetos a serem iniciados, iniciar,
parar e re-iniciar o Tomcat ao qualquer momento, alem de ter o controle dos
processos da aplicação, podendo achar erros mais
facilmente.(SYSDEO,2007) (TOMCAT,2007)
• Subclipse: Plugin para controle do servidor de controle de versão Subversion
diretamente na IDE. (SUBCLIPSE,2007) (SUBVERSION,2007)
Na Figura 7 tem a descrição das ferramentas internas do Eclipse, como: (1) a
aba de arquivos, onde pode ser aberto vários arquivos simultaneamente e se ter
uma edição dinâmica de qualquer projeto; (2) o explorador de Projetos, onde
podemos adicionar vários projetos e abrir e fechar os arquivos dos mesmo,
visualizador de propriedades, onde podemos visualizar as propriedade do
arquivo que esta sendo editado; (3) O editor de código com funções de auto-
complete, numeração de linhas entre outros recursos, e o (4) console do servidor
Tomcat onde se pode visualizar todas as mensagens e retorno do servidor, sem
precisar rodar externamente o Tomcat.
31
Console doTomcat
Editor de Código
Explorador deProjetos
Visualizadorde Propriedades
de Classes
Aba de Arquivos
Figura 7 Visão detalhada das ferramentas internas do Eclipse.
A Figura 8 mostra a janela de criação de projetos do Eclipse, com a funcionalidade
de adicionar ao projeto o Suporte ao Struts pelo plugin Amateras, entre outras
funcionalidades como criação de arquivos JSP, HMLT, XML, ACTION e
ACTIONFORM.
Figura 8 janela de criação de projetos.
32
Na Figura 9 é apresentado o recurso de configuração visual do arquivo struts-
config.xml, o qual fica todas as configurações do Struts.
Na Figura 10 é apresentada a visão do controle de repositório de código Subversion,
acrescentado a interface do Eclipse através do plugin Subclipse.
Figura 10 Janela com o controle de repositório do Subversion.
Figura 9 Editor Visual do Arquivo de configuração do Struts.
33
3.7 Aptana IDE
O Aptana é uma versão modificada da IDE Eclipse para o desenvolvimento de
aplicações em linguagem Ruby, HTML, CSS entre outros (APTANA,2007). No ano
de 2006 o plugin RDT que faz parte do Aptana ganhou o premio Eclipse Community
Award, o qual é dado aos melhores plugins para o Eclipse (ECLIPSE,2007). Nesse
ano de 2007 o projeto RadRails, o qual é outra IDE para o desenvolvimento de
aplicativos Rails se uniu com o projeto Aptana tornando-se uma única IDE (IDE,
2007). A cada dia que passa o plugin RDT para o Eclipse vem se tornando um
verdadeiro Ambiente de Desenvolvimento Integrado, porque une a técnica de RAD
(Rapid Application Development) (Desenvolvimento Rápido de Aplicações) e
consiste em permitir que os desenvolvedores obtenham um aproveitamento maior,
desenvolvendo código com maior rapidez e produtividade, o Aptana é composto
pelos seguintes plugins:
• Subclipse: Cliente para ao Eclipse para repositórios Subversion.
• RDT: Editor de Código Ruby on Rails.
• Aptana HTML Editor: Editor de código HTML .
• Aptana CSS Editor: Editor de Código CSS.
• Aptana JavaScript Editor: Editor de código JavaScript.
No Ruby on Rails existe alguns scripts para executar determinadas ações
repetitivas, como, por exemplo, criar classes que serão ligas com as tabelas do
banco de dados, e esses scripts são executados em linha de comando. Com o
Aptana não precisamos ir a linha de comando para usar os scripts, nem iniciar o
servidor da aplicação, o Aptana dá suporte a essas funções, na própria interface da
IDE.
Na Figura 11 tem a descrição das ferramentas internas do Aptana, como: (1) a aba
de arquivos, onde pode ser aberto vários arquivos simultaneamente e se ter uma
edição dinâmica de qualquer projeto; (2) o explorador de Projetos, onde podemos
adicionar vários projetos e abrir e fechar os arquivos dos mesmo, visualizador de
propriedades, onde podemos visualizar as propriedade do arquivo que esta sendo
editado; (3) O editor de código com funções de auto-complete, numeração de linhas
entre outros recursos, e o (4) console do servidor, onde se pode visualizar todas as
mensagens e retorno do servidor; (5) Visualizador de propriedades da classe.
34
Console doServidor
Editor de Código
Explorador deProjetos
Visualizadorde Propriedades
de Classes
Aba de Arquivos
Figura 11 Visão detalhada das ferramentas internas do Aptana
Na Figura 12 é apresentado a paleta de controle dos servidores do Ruby on Rails,
no Ruby on Rails cada aplicação tem seu próprio servidor de aplicação, sendo
possível iniciar individualmente cada um através da paleta de servidores.
Gerenciador deServidores
Figura 12 Visão da paleta de gerenciamento de servidores.
Na Figura 13 é apresentado um o gerenciador dos Scripts de Execução do Ruby on
Rails, podem ser gerados a partir dessa Aba, Classes de Controle, são classes que
ficam responsável pela camada de controle da aplicação, Classes de Modelagem ,
são classes que estão ligadas ao banco de dados, Scaffold é a coleção das classes
de modelagem, controle mais a pagina rhtml que faz o controle do CRUD., Classes
de plugins, são funcionalidades que podem ser adicionadas a aplicação, entre outros
recursos.
35
Gerenciador deGeradores de
Código
Figura 13 Visão da paleta de geração de código para o Rails, com as opções de gerar
controller, model, scaffold (SCAFFOLD, 2007), integration, entre outros.
Na Figura 14 é apresentada a paleta de busca de documentação do Ruby on Rails,
nessa paleta se pode fazer buscar de toda a documentação do Ruby on Rails e seus
exemplos incluídos nela.
Visualizador daDocumentação do
Ruby / Rails
Figura 14 Visão da paleta de consulta da Documentação do Rails e Ruby.
3.8 Firebird Data Base
Firebird é um Sistema Gerenciado de Banco de Dados SQL. Poderoso e leve com
apenas sete mega-bytes o seu arquivo de instalação. Ao mesmo tempo, com
mínima necessidade de configuração e administração. Atende igualmente bem a
aplicações de um único usuário e a aplicações corporativas (CANTU, 2005). Um
simples servidor Firebird pode manipular múltiplas bases de dados independentes,
cada uma com múltiplas conexões clientes. É uma aplicação Open Source, com
essa qualidade é livre de quais quer exigência de licença, mesmo para uso
comercial. (FIREBIRD, 2007)
Principais características do Firebird (CANTU, 2005):
36
� O Firebird foi desenvolvido de acordo com o conceito de "Atomicidade,
Consistência, Isolamento e Durabilidade", que é um conceito que consiste
que os bancos de dados devem ser independentes de arquitetura de
computador, de sistema operacional e teoricamente de tamanho.
� Arquitetura de Múltiplas Gerações, que permite ao banco manipular várias
versões do mesmo registro físico em qualquer momento, assim qualquer
transação pode ter sua própria versão sem se importar com outras transações
concorrentes, ou seja, a leitura de registro no banco não bloqueia escrita de
registros e a escrita não bloqueia leitura.
� Suporta Stored Procedures com a linguagem interna Procedural SQL.
� Suporta Gatilhos (Triggers), que podem disparar eventos em determinados
momentos no Banco de Dados.
� Tem suporte a Geradores, são blocos de código quê executam uma
determinada tarefa, permitindo facilmente a implementação de colunas do tipo
auto-incrementos.
� O limite teórico é atualmente 64TB para um único arquivo da base de dados.
� Bases de dados "somente leitura": Para distribuição de Bases de dados em
CD-ROM.
� Controle total de transações: Uma simples aplicação cliente pode ter múltiplas
transações concorrentes.
� Backups Online: Não há necessidade de parar a base de dados para efetuar
o backup. Um processo de backup captura a imagem da base de dados no
momento em que ele inicia, assim os usuários podem continuar trabalhando
enquanto o backup é executado, permitindo a operação 24x7.
� Integridade Referencial em Cascata (Declarative Cascading Referential
Integrity): Assegura consistência e validade de um relacionamento 1-N (Pai e
Filho) entre tabelas.
� Character Sets: O Firebird implementa muitos Charsets Internacionais.
(CSET, 2007)
� Em conformidade com o Padrão SQL (SQL, 2007).
� O Firebird também implementa Domínios (Domains) e campos com Check
Constraints, Views, Exceptions, Roles e uma refinada gerência de permissões
(Grant).
37
Existe vários pacotes de componentes nativos para conexão com o Firebird, e para
as principais linguagens de programação como C/C++, Delphi (DELPHI, 2007),
ODBC (ODBC, 2007), JDBC (JDBC, 2007), Driver PHP (PHP, 2007), .Net (DOTNET,
2007) e se preciso ainda é possível usar chamadas diretas a API do Firebird através
da biblioteca fbclient.dll/.so (CANTU, 2007).
Versões do Firebird (FIREBIRD, 2007):
• Classic Server: Uma instância por conexão cliente;
• SuperServer: Todas as conexões são manipuladas por um único módulo;
• Embedded Version: O sistema inteiro é uma única DLL/SO.
3.10 Tecnologia Servlet
A tecnologia Servlet (SERVLET, 2007) permite a criação de aplicações para a web a
partir de uma classe que implementa a interface da classe servlet específica para
http. O Servlet é a base estrutural onde foi desenvolvido o Struts. O Struts se utiliza
em seus Actions de recursos do mesmo, como o controle de requisições e seções
com as classes HTTPSession e HTTPRequest. Ou seja, todos os recursos
disponíveis pelos servlet estão disponíveis no Struts para ser usados. Uma classe
servlet estende as capacidades dos servidores que hospedam aplicativos acessados
por meio de um modelo de programação requerição-resposta. Embora servlets
possam responder a qualquer tipo de requisição, eles são comumente usados para
estender os aplicativos hospedados por servidores Web.
Os pacotes javax.servlet e javax.servlet.HTTP fornecem interface e classes para
escrever servlets. Todos os servlets devem implementar a interface Servlet, que
define os métodos de ciclo de vida. Ao implementar um serviço genérico, você pode
usar ou estender a classe GenericServlet fornecida com a API Java Servlet. A classe
HttpServlet fornece métodos, tais como doGet e doPost, para tratamento de serviços
específicos para http. (TUTORIALJ2EE, 2005).
3.11 Tecnologia JavaServer Pages
A tecnologia JavaServer Pages permite que crie facilmente conteúdo Web que
possui componentes tanto estáticos como dinâmicos. A tecnologia JSP torna
disponível todas as capacidades dinâmicas da tecnologia Java Servlet, mas fornece
38
uma abordagem mais natural para criar conteúdo estático. Os principais recursos da
tecnologia JSP são os seguintes (TUTORIALJ2EE,2005):
(1) Uma linguagem para desenvolver páginas JSP, que são documentos baseados
em texto que descrevem como processar uma requisição e construir uma resposta;
(2) Uma linguagem de expressão para acessar objetos do lado do servidor;
(3) Mecanismos para definir extensões para a linguagem JSP.
Essa tecnologia será usada no desenvolvimento da aplicação com o framework
Struts, utilizando dos seus recurso de utilização de bibliotecas de tag´s
customizadas, que nesse caso serão as bibliotecas de tag´s do Struts.
3.12 JavaBeans
JavaBean é uma classe de conexão, ela leva informações de uma camada pra
outra. Um JavaBean é um componente de software reutilizável escrito em Java.
Para ser qualificado como JavaBean, a classe tem que ser concreta e pública e ter
um construtor sem argumentos. Os JavaBeans expõem os campos internos como
propriedades fornecendo métodos públicos e que seguem um padrão de projeto
consistente. Sabendo que os nomes patenteados seguem esse padrão, as outras
classes Java são capazes de usar introspecção para descobrir a manipular as
propriedades JavaBean. Os padrões de construção do JavaBean fornecem acesso
para o estado interno do componente através de dois tipos de métodos: os
assessores são usados para ler o estado de um JavaBean; os transformadores são
usados para alterar o estado de um JavaBean, o Quadro 7 tem uma um exemplo.
(JAVABEANS, 2007). Os Javabeans serão usados no projeto desenvolvido com o
framework Struts, na camada de modelagem da aplicação.
39
CAPÍTULO IV - RUBY ON RAILS
4.1 SOBRE O FRAMEWORK
Ruby On Rails é um framework de código aberto para desenvolvimento de
aplicações Web, escrito em Ruby, sua primeira versão incompleta foi publicada em
julho de 2004 (AKITA, 2006). Esse framework foi extraído do produto comercial
Basecamp (BASECAMP,2007), da empresa 37signals (37SIGNAL,2007), e
finalizado depois de dois meses de desenvolvimento com quatro mil linhas de
código, por um único desenvolvedor, David Heinemeier-Hansson (AKITA, 2006).
4.1.1 Filosofias
• Interface Mínima
O primeiro ponto foi bem descrito por Martin Fowler (MATIRNFOWLER,2007),
grande expoente do movimento Ágil e de Padrão de Projetos. Ruby tende a
seguir o principio de Interface Humana, em contraste com a Interface Mínima
que a linguagem Java tende a seguir. Exemplos desses conceitos estão nos
Quadros 7 e 8:
Ou seja, ambos tem o mesmo efeito do ponto de vista da máquina, porém a
primeira versão é mais amigável do que a segunda. Daí o termo “Interface
Humana”. Na versão com Java do exemplo acima somos obrigados a saber
que uma classe List usa um indexador interno que começa no zero e vai até
seu tamanho menos um. Ou seja, precisamos saber do que é feito
internamente para usarmos. É o oposto do principio de encapsulamento da
Orientação a Objetos, onde a implementação deveria ser escondida em uma
caixa-preta.
Interface Humana (Ruby):
lista = list.last
lista = list.first
Interface Mínima (Java):
lista = list.get(list.size() -1);
lista = list.get(0);
Quadro 7 Quadro 8
40
• Não se Repita
O Segundo ponto da filosofia é o DRY “Don't Repeat Yourself”, ou seja, “Não
se Repita”. Esse principio assume a filosofia de não se repetir, não copiar e
colar trechos de código por toda a aplicação, deixar o código com o menor
numero de caracteres de marcação e o mais legível possível. A idéia base é,
se estamos sempre repetindo o mesmo código então esse código não era pra
ser escrito novamente. Um exemplo são os métodos de acesso a uma
entidade JavaBean, os get e sets da aplicação no Ruby não são necessárias
escrever, economizando tempo e código nas entidades feitas com Ruby.
• Convenção sobre Configuração
O terceiro e ultimo ponto é o conceito “Convention over Configuration”, ou
Convenção sobre Configuração, ou seja, se não quisermos configurar nada,
basta seguir as conversões e o framework saberá o que fazer, como no
exemplo do Quadro 9, onde não precisamos fazer nenhuma configuração
para a Ruby on Rails mapear a classes e seus métodos.
.
O mapeamento é como o servidor vai chamar os métodos das classes, o
framework assume esse mapeamento automaticamente levando em conta
apenas a nomenclatura utilizada entre os diversos recursos, ou seja, quando
é acessada a seguinte URL: “http://127.0.0.1:3000/account/show/1”, o Ruby
Exemplo através do controle da URL do Rails:
/account/show/1
onde:
account => classe AccountController que extende de ApplicationController.
show => método show() da classe AccountController
1 => parâmetro chamado id com valor “1”
class Account def show x = params[:id] end
end
Quadro 9
41
on Rails vai chamar o método show da classe Account enviando como
parâmetro o numero 1 (id=1). Em outros frameworks como o struts é preciso
manipular um arquivo de configuração xml, no caso é o struts-config.xml para
fazer essa mesma função de mapeamento das urls do sistema para chamar
as classes correspondentes, só que de uma maneira estática, tem que ser
definida antes de ser usadas, no Ruby on Rails esse controle é dinâmico,
assim que se cria um método já se pode chamá-lo na url sem precisar fazer
nenhuma configuração.
Outro exemplo de “Convention over Configuration” no Rails seria na camada
de Modelagem, onde o único código a ser feito para ligar uma classe entidade
com a tabela no banco correspondente se encontra no Quadro 10:
No Quadro 10 a classe Produto esta representando a tabela produto no
banco de dados, onde o Ruby on Rails no momento da execução é as
propriedades da tabela e cria uma propriedade equivalente na classe
entidade que representa a tabela do banco. Na maioria dos frameworks
escritos em Java essa praticidade não existe sendo o programado ficando
responsável a desenvolver toda a camada de acesso ao banco de dados,
com geração de JavaBeans para cada tabela, preenche-las com
propriedades iguais as propriedades das tabelas e gerando os métodos “get”
e “set” para cada propriedade.
Rails foi projetado para ser uma solução de desenvolvimento completa, ou
seja, sem precisar recorrer a outros frameworks para adicionar características
que não tem. As suas camadas se comuniquem de forma transparente, ou
seja, uma variável criada em um método de ma classe esta disponível
também da pagina rhtml sem precisar importar nenhum pacote na página, e
as classes que representam as tabelas no banco de dados depois de feitas
podem ser acessadas de qualquer lugar na aplicação sem precisar de
importação, se comunicando da forma mais transparente possível, em uma
estrutura de pastas obrigatórias. Rails é uniforme, ou seja, escrito totalmente
class Produto < ActionRecord::Base
end
Quadro 10
42
apenas na linguagem Ruby e segue o modelo MVC (Modelagem,Visual e
Controle).
A Figura 20 descreve como funciona dos componentes do Ruby on Rails nas
camadas referentes ao MVC. Onde a ActionView fica responsável pelos
arquivos RHTML, o ActionController fica responsável pelas classes de
controle da aplicação e o ActiveRecord fica responsável pelas classes que
fazem a representação das tabelas do banco de dados.
Com essas características o Rails tende a ser extremamente produtivo e sugere
uma baixar a curva de aprendizagem.
4.2 DESCRIÇÃO DAS CAMADAS
• CAMADA DE MODELAGEM
Na camada de modelagem do Rails quem é o responsável pelo mapeamento das
tabelas com as entidades do Ruby é o ActiveRecord.
• CAMADA DE CONTROLE
Na camada de controle do Rails que é responsável pelo controle dos Actions é o
ActionPack.
Figura 20: MVC aplicado no Ruby on Rails
43
• CAMADA VISUAL
Na camada visual do Rails quem é o responsável pelo controle das paginas
RHTML é o ActionPack, o mesmo que a camada de controle. Lembrando que o
Ruby on Rails não usa nenhuma biblioteca de tag´s, que são bibliotecas usadas
para agilizar o desenvolvimento visual da aplicação. De acordo com Akita esse
recurso não é necessário, pois os códigos utilizados nas paginas RHTML ou seja
os scriptlets Ruby utilizando os métodos do Rails já fazem a redução e abstração
de código necessários para a separação das camadas Visual e de Controle do
Rails.
4.3 CONFIGURAÇÃO
Como dito na seção 4.1.1 uma das filosofias do Rails é a Convenção sobre
Configuração, sendo que se iniciar um projeto no padrão proposto pelo Rails, o
único arquivo necessário a ser configurado é o arquivo database.yml, para
configurar a conexão com o banco de dados.
4.4 ESTRUTURA DE PASTAS
Na Tabela 2 encontram-se as pastas de uma aplicação Ruby on Rails.
app É nela que vão as classes MVC. Dentro temos dividido os subdiretórios apis, controllers, helpers, models e views.
components Local para colocar controllers, views ou models to tipo componente reutilizáveis.
config Local onde fica os arquivos de configuração do Rails. Como a localização do banco de dados.
dd Local onde ficam os sripts para a geração e atualização do banco de dados.doc Documentação do projeto, que é gerado pelo comando rdoc.lib Local para colocar classes pessoais e de terceiros.log Local onde ficam armazenados os arquivos de log do servidor web.public É o diretório-raiz do site, que será exposto via internet. Aqui coloca-se recursos como
imagens, javascript e stylesheets. Sub-diretorios principais: images, javascript, stylesheets.
script Contem todos os scripts que precisaremos para aumentar a velocidade de desenvolvimento. Aqui temos: about, breakpoint, console, destroy, generate, plugin, runner, server.
test Pasta onde ficam as classes de testes para cada controle criao.tmp Onde ficam os arquivos temporários.vendor Por fim aqui são instalados plugins e engines. Estes componentes usam o recurso de
inserção e extensão de módulos, para enxertar funcionalidades diretamente nas classes principais do Rails sem necessidade de realizar herança ou configurações.
Tabela 2: pastas de uma aplicação Ruby on Rails e suas decrições
44
4.7 RECURSOS ADICIONAIS
O Rails tem o recurso de Scripts de automação. Como exemplo o script generate
que pode ser usado para criar controllers, mailers, models, scaffolds, entre outros.
Um exemplo de como usar esse script é o comando do Quadro 11 onde ele gera
todos os arquivos necessários para ler, criar, editar e apagar o model usuário que é
um objeto transparente para a tabela usuário no banco de dados. Tem ainda um
pacote para o controle de e-mail, com ele o Rails consegue enviar e-mails ou
responder ao recebimento de e-mail. Tem o pacote que fornece ao aplicativo
funcionalidades para que possa responder como se fosse um Web Service
(WEBSERVICE, 2007).
ruby script/generate scaffold usuario
Quadro 11
45
CAPÍTULO V – APACHE STRUTS
5.1 SOBRE O FRAMEWORK O Struts é um framework open-source do projeto Jakarta (JAKARTA, 2007) que
auxilia a construção de aplicações para a Web. Ele é construído em Java, e seu
coração consiste numa camada de controle flexível baseada nas tecnologias Java
Servlets (SERVLETS, 2007), JavaBeans (JAVABENS, 2007) e XML (XML, 2007).
O Struts favorece o desenvolvimento de aplicações seguindo o modelo MVC (Model-
View-Controller). O Struts fornece um componente Controller e se integra a outras
tecnologias para oferecer suporte aos componentes Model (JDBC), e View (JSP). O
fluxo da aplicação é mediado por um controlador central (Controller). O controlador
delega requisições para os tratadores apropriados, que estão localizados no modelo
(Model), que representa a lógica de negócio e o estado da aplicação. A requisição
então é respondida, através do controlador, e apresentada na visão (View), da
maneira adequada. No Struts, essas respostas são orientadas através de
mapeamento da url chamada no navegador com as classes e métodos que serão
chamados, que são carregados através de um arquivo de configuração (struts-
config.xml). Isso faz com que não haja dependência entre a visão e o modelo, que
auxilia na criação e na manutenção da aplicação.
Na Figura 21 se pode notar com funciona cada componente do Struts dentro do
modelo MVC, o ActionServlet faz o controle através das configurações existentes no
arquivo struts-config.xml das classes Actions, ActionForms, e da camada visual, ou
seja, dos arquivos jsp. A camada de modelagem fica a critério da tecnologia
escolhida no projeto.
46
Figura 21: MVC aplicado no Struts
5.2 CAMADA MODELAGEM
Os componentes Model englobam dois conceitos: a lógica de negócio da aplicação e
seu estado. As tecnologias utilizadas nessa camada, são JavaBeans, e
freqüentemente, Enterprise JavaBeans e JDBC.
Através destas tecnologias, deverá ser construída a lógica de negócio da aplicação.
5.3 CAMADA DE CONTROLE
Os componentes Controller são responsáveis pelo fluxo da aplicação. O principal
componente Controller do Struts é a ActionServlet, que é uma extensão de Servlet,
exercendo o papel de controlador principal da aplicação. Sua principal função é fazer
o mapeamento das requisições do servidor.
Para isso, é necessário criar um arquivo de configuração, denominado struts-
config.xml, que é usado para ligar a url que vai ser chamada com o a classe Action,
essa ligação se dá o nome de mapeamento. Depois disso, deverão ser criadas as
classes Action (que são extensões da classe Action do Struts), que conterão as
ações a serem executadas a cada requisição. O objetivo da classe Action é
processar a requisição e retornar um objeto da classe ActionForward que identifica
para qual componente de visão (normalmente uma página JSP) será gerada a
47
resposta. As classes Action são compostas de um único método “execute”, que será
invocado quando a ActionServlet receber a requisição do navegador e através da
configuração existente no struts-config.xml irá chamar o método execute da classe
correspondente.
No arquivo de configuração struts-config.xml se tem a ligação das classes
ActionForm com os seus formulários correspondentes JSP. Form-beans são classes
Java que estendem ActionForm e se integram a um formulário de entrada de dados
de uma aplicação. O conceito dos form-beans é simples: são JavaBeans que
contém uma propriedade para cada campo de seus formulários HTML, com seus
respectivos métodos getters e setters.
5.4 CAMADA VISUAL
Os componentes View representam a visão da aplicação, ou seja, a maneira como o
sistema interage com o usuário. A tecnologia mais comumente utilizada nessa
camada é Java Server Pages.
Nessa camada, o Struts oferece suporte a dois importantes aspectos:
internacionalização, ou seja, uma única aplicação para vários idiomas, e a
construção de interfaces JSP através de custom tag’s.
Para permitir a internacionalização, é necessário que se crie, sob o diretório WEB-
INF/resources da aplicação, um arquivo chamado ApplicationResources.properties,
que conterá mensagens para a linguagem padrão do seu servidor. As mensagens
são colocadas nos arquivos através de texto simples, como no exemplo do Quadro
12:
Para possibilitar que se crie mensagens em outras linguagens, é necessário criar o
arquivo ApplicationResources_xxx.properties, onde xxx será utilizada a
padronização ISO (ISO, 2007) de localização internacional da linguagem a ser
utilizada.
Outro importante recurso é a disponibilidade de custom tag’s do Struts, que
permitirá, além da utilização dos arquivos de internacionalização, uma série de
funcionalidades, que, na grande maioria dos casos, dispensará a utilização de
código Java dentro da página (aliás, esse é um dos objetivos da arquitetura MVC,
app.cliente.nome=Nome do cliente
Quadro 12
48
pois o fluxo de controle e lógica de negócio da aplicação não devem estar na
camada de visão). Além disso, a extensibilidade de Java permite que o próprio
desenvolvedor crie suas próprias custom tag’s, que, aliás, é uma tarefa bastante
simples.
A coleção de tags que fazem parte do Struts estão descritas na lista abaixo
(HUSTED, 2007):
• html: permite a criação e manipulação de dados enviados e recebidos através
dos formulários HTML;
• logic: permite a criação de estruturas de condição e repetição, além da
administração do fluxo da aplicação;
• bean: permite a criação e manipulação de JavaBeans dentro da página;
• nested: permite a definição de modelos de objetos aninhados e a capacidade
de representá-los e administrá-los;
• template: permite a criação de modelos dinâmicos de páginas JSP que
compartilham de um formato comum.
5.5 CONFIGURAÇÃO
Antes de utilizar o Struts, é necessário configurar seu
ambiente para que ele saiba como mapear todas as
requisições através de uma determinada extensão de
arquivo para a ActionServlet do Struts. Isso deverá estar
no arquivo web.xml, que fica abaixo do diretório WEB-INF
de sua aplicação, como na Figura 22. O próximo passo é
configurar o arquivo fundamental do Struts, o struts-
config.xml. O struts-config.xml determina exatamente o
que vai acontecer com a requisição do cliente (Navegador). Nada acontece sem sua
permissão ou seu conhecimento: é onde os mapeamentos são definidos. Toda a
navegação da aplicação está definida nesse arquivo, o que é uma grande vantagem,
pois a mantém modularizada e de fácil manutenção. Todo esse arquivo é lido na
inicialização do servidor e armazenado na memória, por questões de performance
(HUNTED, 2007).
Além disso, é necessário que se tenha todos as bibliotecas que serão usadas para
acessar o banco de dados entre outros recursos adicionais como geração de pdf no
Figura 22
49
diretório WEB-INF/lib, e todos os descritores de custom-tag’s abaixo do diretório
WEB-INF, como mostra a Figura 22.
5.6 ESTRUTURA DE PASTAS
WEB-INF Essa é a pasta principal da aplicação, onde se econtra as pastas classes, lib e src descritas abaixo. É nessa pasta que ficam os arquivos de configuração, struts-config.xml e web.xml, e as bibliotecas de tag´s do Struts.
pages Pasta que fica na raiz do sistema, segue o padrão de desenvolvimento colocar todas as paginas nessa pasta.
classes Onde se encontra todas as classes e seus pacotes, já compilados, e prontos a serem usados.
lib Local onde ficam as bibliotecas de terceiros utilizadas no projeto, como por exemplo biblioteca para acesso ao banco de dados.
src Pasta que fica o código fonte da aplicação (opcional).
Na Tabela 3 estão listados os diretórios padrões de uma aplicação Struts, e suas
respectivas descrições.
5.7 RECURSOS ADICIONAIS
Não existe recursos adicionais no Struts fora da sua camada de controle e visual
(HUSTED, 2007). Pode ser adicionado recursos adicionais ao Struts através de
outros frameworks, incorporando suas funcionalidades ao Struts. Alguns exemplos
são o Hibernate (HIBERNATE, 2007), Velocity (VELOCITY, 2007), Tiles (TILES,
2007) entre outros. Más lembrando que a um custo de aprendizado para se
desenvolver um sistema aumentando o tempo de desenvolvimento com cada
recurso incorporado.
Tabela 3: descrições das pastas de uma aplicação Struts.
50
CAPÍTULO VI – PROJETO LÓGICO
Aqui sera apresentado o projeto lógico das aplicações que serão desenvolvidas com
os frameworks Struts e Ruby on Rails.
6.1 UML do Sistema: Diagrama dos Casos de Uso e Suas Descrições
Aqui serão apresentados os casos de uso do sistema. Os dois sistemas consistem
em dois usuários: Dono do grupo e Participante do Grupo. Esses dois usuários têm
as mesmas opções dentro do sistema, modificando apenas no caso do numero de
outros usuários cada um pode enviar uma mensagem. O Dono do grupo pode enviar
mensagens para todos os participantes do seu grupo, e o Participante só pode
enviar mensagem pra ele mesmo.
6.1.1 Diagramas dos Casos de Uso
Figura 23: Diagrama dos casos de uso do participante do grupo.
51
Figura 24: Diagrama dos casos de uso do dono do grupo.
6.1.2 Descrição dos Casos de Uso
Nome: Fazer Login Atores: Dono do Grupo, Participante do Grupo Prioridade: Essencial Entradas e pré-condições:
Usuários e Grupos previamente cadastrados.
Saídas e pós-condições:
Login efetuado com sucesso.
Fluxos de eventos
Fluxo principal:
1. Na tela inicial da aplicação o sistema exibirá os seguintes campos:
a. Login b. Senha
2. O Usuário preencherá os campos e envia para serem validados pelo sistema.
3. O sistema valida e exibe a tela de menu. [FS001]
Fluxo Secundário 1
1. O sistema exibe a pagina de login novamente e mostra a mensagem de erro na validação.
Fluxo Secundário 2
A janela apresentada vai depender do tipo de atividade que será editada. Tabela 4: caso de uso fazer login
Nome: Listar Atividades Recebidas Atores: Dono do Grupo, Participante do Grupo Prioridade: Essencial Entradas e pré- Login efetuado com sucesso.
52
condições: Saídas e pós-condições:
Lista das Atividades Recebidas.
Fluxos de eventos
Fluxo principal:
1. Na tela de menu, é exibido 4 botões com as seguintes descrições:
a. Atividades Recebidas b. Atividades Enviadas c. Atividades Concluídas d. Enviar Atividade
2. O usuário escolhe a opção Atividades Recebidas.
3. O Sistema exibe a lista das atividades destinadas para o usuário logado.
Tabela 5: caso de uso listar atividades recebidas
Nome: Lista Atividades Recebidas Atores: Dono do Grupo, Participante do Grupo Prioridade: Essencial Entradas e pré-condições:
Login efetuado com sucesso.
Saídas e pós-condições:
Lista das Atividades Enviadas.
Fluxos de eventos
Fluxo principal:
1. Na tela de menu, é exibido 4 botões com as seguintes descrições:
2. Atividades Recebidas 3. Atividades Enviadas 4. Atividades Concluídas 5. Enviar Atividade 6. O usuário escolhe a opção Atividades Enviadas. 7. O Sistema exibe a lista das atividades destinadas
pelo o usuário logado. Tabela 6: caso de uso listar atividades recebidas
Nome: Lista Atividades Concluídas Atores: Dono do Grupo, Participante do Grupo Prioridade: Essencial Entradas e pré-condições:
Login efetuado com sucesso.
Saídas e pós-condições:
Lista das Atividades Concluídas.
Fluxos de eventos
Fluxo principal: 1. Na tela de menu, é exibido 4 botões com as
seguintes descrições: a. Atividades Recebidas
53
b. Atividades Enviadas c. Atividades Concluídas d. Enviar Atividade
2. O usuário escolhe a opção Atividades Concluídas. 3. O Sistema exibe a lista das atividades destinadas
para o usuário logado e que já foram concluídas. Tabela 7: caso de uso listar atividades concluídas
Nome: Enviar Atividade Atores: Dono do Grupo, Participante do Grupo Prioridade: Essencial Entradas e pré-condições:
Login efetuado com sucesso.
Saídas e pós-condições:
Atividade enviada com sucesso.
Fluxos de eventos
Fluxo principal:
1. Na tela de menu, é exibido 4 botões com as seguintes descrições:
a. Atividades Recebidas b. Atividades Enviadas c. Atividades Concluídas d. Enviar Atividade
2. O usuário escolhe a opção Enviar Atividade. 3. O Sistema exibe o formulário para preenchimento,
destinado ao envio da atividade, com os seguintes campos:
a. Usuário de Destino. b. Prazo para a realização da tarefa. c. Descrição da tarefa. d. Observações sobre a tarefa.
4. Após ter preenchido os campos, o usuário escolhe a opção enviar.
5. O sistema envia a Atividade para o usuário de destino.
Tabela 8: caso de uso enviar atividade
Nome: Visualizar Atividade Atores: Dono do Grupo, Participante do Grupo Prioridade: Essencial Entradas e pré-condições:
Login efetuado com sucesso.
Saídas e pós-condições:
Visualizar detalhes da Atividade.
Fluxos de eventos
Fluxo principal: 1. Na lista de Atividades (Recebidas, Enviadas,
Concluídas), o sistema exibe um link com a descrição da atividade.
54
2. O usuário clica no link com a descrição. 3. O Sistema exibe a pagina com os detalhes da
Atividade, com os seguintes campos: a. Usuário Origem b. Usuário Destino c. Data de Envio d. Prazo e. Descrição f. Observações
Tabela 9: caso de uso visualizar atividade
Nome: Editar Dados do Usuário Atores: Dono do Grupo, Participante do Grupo Prioridade: Essencial Entradas e pré-condições:
Login efetuado com sucesso.
Saídas e pós-condições:
Dados do usuário alterados com sucesso.
Fluxos de eventos
Fluxo principal:
1. No Menu principal, o usuário clica na opção “editar”.
2. O sistema exibe o formulário com os dados atuais do usuário preenchidos, com os seguintes campos: a. Nome b. Senha c. Email
3. O usuário altera os campos necessários e clica no botão salvar.
4. O sistema salva as alterações feitas. Tabela 10: caso de uso editar dados do usuário
Nome: Concluir uma Atividade Atores: Dono do Grupo, Participante do Grupo Prioridade: Essencial Entradas e pré-condições:
Login efetuado com sucesso.
Saídas e pós-condições:
Status da Atividade será Concluída.
Fluxos de eventos
Fluxo principal:
1. Na lista de Atividades Recebidas, o sistema exibe um link com a descrição da atividade.
2. O usuário clica no link com a descrição. 3. O Sistema exibe a pagina com os detalhes da
Atividade, com os seguintes campos: a. Usuário Origem b. Usuário Destino
55
c. Data de Envio d. Prazo e. Descrição f. Observações
4. O sistema exibe a opção ‘Concluir’. [Fluxo Secundário 1]
5. O usuário clica na opção ‘Concluir’ 6. O sistema define o status da atividade como
concluído.
Fluxo Secundário 1
A opção ‘Concluir’ só aparece para quem é destinatário da atividade, e ainda não concluiu a Atividade.
Tabela 11: caso de uso concluir uma atividade
Nome: Ficar Ciente da Conclusão de uma Atividade Atores: Dono do Grupo, Participante do Grupo Prioridade: Essencial Entradas e pré-condições:
Login efetuado com sucesso.
Saídas e pós-condições:
Status da Atividade como Ciente.
Fluxos de eventos
Fluxo principal:
1. Na lista de Atividades Enviadas, o sistema exibe um link com a descrição da atividade.
2. O usuário clica no link com a descrição. 3. O Sistema exibe a pagina com os detalhes da
Atividade, com os seguintes campos: a. Usuário Origem b. Usuário Destino c. Data de Envio d. Prazo e. Descrição f. Observações
4. O sistema exibe a opção ‘Ficar Ciente da Conclusão da Atividade’. [Fluxo Secundário 1]
5. O usuário clica na opção ‘Ficar Ciente da Conclusão da Atividade’
6. O sistema define o status da atividade como ciente.
Fluxo Secundário 1
A opção ‘Ciente’ só aparece para o usuário de origem da atividade, e se a Atividade já estiver concluída.
Tabela 12: caso de uso ficar ciente da conclusão de uma Atividade
Nome: Sair do Sistema Atores: Dono do Grupo, Participante do Grupo Prioridade: Essencial
56
Entradas e pré-condições:
Login efetuado com sucesso.
Saídas e pós-condições:
O usuário esta fora do sistema.
Fluxos de eventos
Fluxo principal: 1. No menu principal o usuário escolhe a opção ‘sair’. 2. O sistema retira seus dados da seção e finaliza a
aplicação, exibindo a pagina de login.
Tabela 13: caso de uso sair do sistema
6.2 Prototipagem de Telas
Aqui mostraremos a prototipação das telas dos dois sistemas, tanto em Ruby on
Rails quanto em Struts.
Na Figura 25 se encontra a tela de login do sistema, onde se encontra os campos
login e senha, para ser enviado para a validação. Se for validado o sistema irá para
a tela do menu, se não voltará para a tela de login.
Figura 25: tela de login
Na Figura 26 se encontra a tela com as opções do menu do sistema e a lista de
atividades recebidas, com os campos Descrição da atividade, usuário de origem,
prazo dado para a realização, dia de conclusão da atividade, e data que o usuário de
origem teve conhecimento da conclusão da atividade.
57
Figura 26: tela lista de atividades recebidas
Na Figura 27 se encontra as opções do menu do sistema e a lista de atividades
enviadas, com os campos prazo de conclusão da atividade, data de conclusão, data
que o usuário ficou ciente da conclusão da atividade.
Figura 27: tela lista de atividade enviadas
Na Figura 28 se encontra as opções do menu do sistema e a lista das atividades
concluídas do usuário logado, com os campos: prazo para conclusão da atividade,
data de conclusão da atividade e data de ciente da atividade.
58
Figura 28: tela lista de atividades concluídas
Na Figura 29 se encontra as opções do menu do sistema, e o formulário para o
envio de uma atividade, onde o usuário escolhe o usuário de destino, o prazo de
conclusão, preenche o campo de descrição da atividade e as observações da
mesma.
Figura 29: tela de envio de atividade
59
Na Figura 30 se encontra as opções do menu do sistema e o formulário para
alteração dos dados cadastrais do usuário logado, com os campos login, nome,
senha e email.
Figura 30: tela de mudança de dados do usuário
6.3 Desenvolvimento do Banco de Dados
Aqui será apresentado o diagrama de descrição das tabelas do banco de dados
usado no desenvolvimento das duas aplicações. O banco de dados esta no padrão
para aplicações Ruby on Rails (AKITA, 2007), não tendo nenhuma desvantagem
para desenvolver aplicações para o Struts. Nessa etapa aproveitou-se de mais um
recurso do framework Ruby on Rails, que é seu padrão de desenvolver o banco de
dados. Aqui começa o desenvolvimento das duas aplicações e já se encontra
influencia no desenvolvimento, onde o Ruby on Rails já dá a opção ao
desenvolvedor de iniciar o banco pensando em usa-lo, e diminuindo o trabalho no
futuro como será descrito adiante. Algumas características a serem usadas no
banco de dados, são as seguinte (AKITA, 2007): (1) As tabelas devem estar sempre
no plural, pois a camada de mapeamento objeto relacional do Ruby on Rails, faz seu
mapeamento automaticamente dessa maneira, gerando um objeto para a mesma,
com o nome no singular. (2) Toda tabela deve ter seu identificador único “campo id”,
pois cada campo na tabela equivale a um objeto na aplicação, sendo esse mesmo
60
campo a chave primaria. (3) As chaves estrangeiras devem seguir o padrão:
TABELA_ID, onde o próprio framework faz a ligação, após inserção do uso dessa
possibilidade no objeto relacional. (4) Outro recurso para facilitar o desenvolvimento,
que deve ser inserido no projeto na etapa de desenvolvimento do banco é do campo
CREATED_AT, o qual é identificado pela camada de ActiveRecord do framework, e
quando for inserido uma linha na tabela esse campo é automaticamente preenchido
com a data e hora de criação da linha.
6.3.1 Diagrama do Banco de Dados:
Na Figura 31 esta o diagrama do banco de dados, com suas ligações de chaves
estrangeiras e primarias.
Figura 31 Diagrama Entidade Relacionamento do Banco de Dados
6.3.2 Descrição das tabelas e dos seus campos:
Abaixo estão as descrições de todas as tabelas do Banco de Dados proposto, onde
descrevem quais são seus campos de chaves primárias “Primary Key” (PK), chaves
secundarias “Forest Key” (FK), nome do campo, tido de dado que será armazenado,
se o campo pode ser nulo ou não (Não Nulo) e a Descrição do campo.
Na Tabela 14 estão as descrições da tabela Atividades, onde irão ser armazenadas
as atividades recebidas e enviadas pelos usuários do sistema.
61
PK FK Nome Tipo de Dados Não Nulo Descrição
ID INTEGER Identificador da Atividade
DESCRICAO VARCHAR(150) Descrição da Atividade
OBS VARCHAR(200) Observações da Atividade
USUARIO_ORIGEM_ID INTEGER Identificador do Usuário de Origem
USUARIO_DESTINO_ID INTEGER Identificador do Usuário de Destino
GRUPO_ORIGEM_ID INTEGER Identificador do Grupo de Origem
GRUPO_DESTINO_ID INTEGER Identificador do Grupo de Destino
CREATED_AT TIMESTAMP Data de Criação da Atividade
PRAZO TIMESTAMP Data Prazo da Atividade
CONCLUSAO TIMESTAMP Data de Conclusão da Atividade
CIENTE TIMESTAMP Data de Ciente da Atividade
Tabela 14: descrição da tabela atividades do banco de dados
Na Tabela 15 estão as descrições da tabela Usuários, onde irão ser armazenadas
os dados dos usuários do sistema.
PK FK Nome Tipo de Dados Não Nulo Descrição
ID INTEGER Identificador Único
NOME VARCHAR(100) Nome do Usuário
LOGIN VARCHAR(15) Login do Usuário
SENHA VARCHAR(15) Senha do Usuário
EMAIL VARCHAR(150) Email do Usuário
CREATED_AT TIMESTAMP Data de Criação do Usuário
HABILITADO CHAR(1) Usuário Habilitado
Tabela 15: descrição da tabela usuários do banco de dados
Na Tabela 16 estão as descrições dos campos da tabela Grupos, onde irão ser
armazenadas os dados dos grupos do sistema.
PK FK Nome Tipo de Dados Não Nulo Descrição
ID INTEGER Identificador do Grupo
USUARIO_ID INTEGER Identificador do Usuário Dono do Grupo
DESCRICAO VARCHAR(30) Descrição do Grupo
Tabela 16: descrição da tabela grupos do banco de dados
Na Tabela 17 estão as descrições dos campos da tabela Grupos_Usuarios, onde
irão ser armazenadas as relações dos grupos e usuários do sistema, ou seja, a que
grupo pertence determinado usuário.
62
PK FK Nome Tipo de Dados Não Nulo Descrição
GRUPO_ID INTEGER Identificador do Grupo
USUARIO_ID INTEGER Identificador do usuário
Tabela 17: descrição da tabela grupos_usuarios do banco de dados
63
CAPÍLULO VII - DESENVOLVIMENTO DAS APLICAÇÕES
Aqui se inicia a separação do desenvolvimento em duas aplicações com os
frameworks Ruby on Rails e Struts.
7.1 DESENVOLVENDO COM RUBY ON RAILS
Aqui apresentamos as etapas no desenvolvimento para os dois frameworks.
7.1.1 Etapas do Desenvolvimento
Aqui apresentamos as etapas no desenvolvimento do projeto no framework Ruby on
Rails, com as descrições e características do desenvolvimento com essa ferramenta.
7.1.1.1 Criação do CRUD da Aplicação com suas entidades
Essa é a etapa inicial do desenvolvimento com o Ruby on Rails, é onde utilizamos
um dos recursos que mais se destaca nesse framework, a geração de paginas com
suas entidade e controles necessários para Listar, Excluir, Criar e Editar os registros
de uma tabela no banco de dados. Para tal, utilizaremos o Script Scaffold, que é um
script gerador de código automático do Ruby on Rails, que gera todos os arquivos
necessários com um comando para cada tabela. Nessa etapa serão executados dois
comandos para gerar o CRUD das tabelas do banco Atividades e Usuários. E após
isso ainda será gerada uma entidade para a tabela Grupo, a qual não é necessário o
CRUD no escopo dessa aplicação. Para a tabela Grupos_Usuarios, pois é uma
tabela de ligação e o próprio Rails faz sua configuração. Ocultado a manipulação
dela do desenvolvedor. Ao final dessas etapas nossa aplicação já será capais de
incluir registros no banco de dados. Podemos passar para a próxima etapa.
7.1.1.2 Configuração das entidades da aplicação
No Rails existe um único arquivo de configuração “database.yml” que é responsável
por armazenar o local do banco de dados e os dados necessários para a conexão
como mesmo. No Ruby on Rails não temos um arquivo como o struts-config.xml do
Struts, boa parte das configurações ficam por conta do próprio framework, com
exceção das configurações das classes que representam as tabelas no banco de
dados, sendo necessário adicionar algumas linhas de código nas classes que
representam as tabelas do banco de dados, para configurar os relacionamentos
entre essas classes em um modelo orientado a objetos. Não sendo obrigatórios para
o uso da camada de Modelagem, más é um recurso de agiliza o desenvolvimento da
64
aplicação. Os relacionamentos podem ser configurados facilmente, e com isso
melhoram a modelagem Orientada a Objetos das entidades, pode-se exemplo usar
a entidade Grupo, que tem um relacionamento com a entidade Usuário, podendo o
usuário do grupo ser chamado sem precisar de SQL de for usado o modelo do
Quadro 13:
No Quadro 13 o código demonstra como instanciar uma entidade Grupo e a partir
dela conseguir uma entidade Usuário que é dono do grupo. Ou seja, essas
configurações nas entidades, irão facilitar a vida do desenvolvedor. Só necessitando
escrever consultas SQL quando for extremamente necessárias.
Outro recurso que se apresenta nessa camada são as validações, que são usadas
por todo o framework, principalmente na camada visual. As validações são feitas
para cada propriedade da entidade.
7.1.1.3 Criação dos Métodos e Páginas de Login, Logoff.
Após a camada de modelagem esta pronta pra ser usada, podemos fazer gerar o
controle responsável pela validação do usuário, nesse controle terão três métodos:
• Index: responsável por chamar o formulário para efetuar o login na aplicação.
• Fazer_login: responsável de receber os dados da pagina de login e verificar
no banco de esse usuário é cadastrado.
• Fazer_logoff: responsável de retirar do sistema de maneira segura o usuário,
efetuado seu logoff.
7.1.1.4 Criação do Menu Principal
Nessa etapa será criado o controle e a página que após a autenticação do usuário
será mostrada, nessa pagina terão as opções principais do usuário. Como:
• Editar Dados do Usuário
• Enviar Atividade
• Listar Atividades Enviadas
• Listar Atividades Recebidas
g = Grupo.new(1)
u = g.usuário
Quadro 13
65
• Listar Atividades Concluídas
• Sair do Sistema
E seu controle terá um único método:
• Index: que é responsável de enviar a entidade usuário que esta na seção
disponibilizando na pagina index. Onde será usada pra mostrar os dados do
usuário e do seu grupo no Menu principal.
7.1.1.5 Inserção do Filtro de Controle de Usuários em toda a Aplicação
Para ter o controle dos usuários será utilizado mais um recurso do Ruby on Rails, os
filtros. Será colocado um filtro na classe ApplicationController que todos os outras
classes controles da aplicação fazem herança. Um filtro nada mais é que um
método, e nesse caso é um método que verifica se existe o objeto usuário na seção
se não existir o usuário é levado a pagina de login. Para se usar o filtro basta colocar
uma linha de comando nas classes que devem ser acessadas somente por usuários
logados no sistema, o seguinte código: before_filter :checar_login . Nesse caso o
método checar_login se encontra na classe ApplicationController que todos os
controllers fazem herança. Com isso quando qualquer método for chamado desse
controle, o controle verifica se o usuário esta ou não logado antes de dar acesso aos
seus métodos.
7.1.2 Resultados
A partir do desenvolvimento da aplicação em Ruby on Rails fizemos as analises
descritas na metodologia, e serão apresentadas abaixo com sua respectivas
conclusões.
• Esforço de Estruturação: 0
Não se teve nenhum esforço de estruturação, pois as pastas e pacotes utilizados
no Ruby on Rails já vêm totalmente montados, não sendo necessário criar
nenhuma pasta nem pacote para desenvolver o projeto. E os scripts de geração
de código o fazem automaticamente quando é necessário criar algum arquivo,
como por exemplo um controle, ele gera a classe já na pasta correta e o arquivo
representando o método na pasta referida.
• Esforço de Programação: 240 minutos
66
Foi preciso 240 minutos para desenvolver a aplicação completa em Ruby on
Rails, esse baixo tempo se deve como visto ao gerador de código Scaffold e a
camada de Modelagem dinâmica, sem precisar escrever os get´s e set´s para
cada entidade que representa as tabelas do banco de dados.
• Numero de Linhas de Código: 203
O numero de linha de código foi de 203, sendo que a simplicidade da linguagem
ruby foi a grande influencia e os atalhos do framework Ruby on Rails, como o
controle de usuário por filtros, a camada de modelagem novamente por não ter
precisado escrever os get´s e set´s como descrito anteriormente.
• Tamanho do Vocabulário: 8 classes
Só foram necessárias 8 classes para desenvolver a aplicação, sendo elas:
o application.rb: classe que é herdada por todos os controles;
o atividades_controller.rb: classe que contem todos os métodos
necessários para a manipulação da entidade atividade. Sendo eles:
show, new, create, recebidas, enviadas, concluídas, concluir e ciente;
o login_controller.rb: classe responsável por fazer o login e logoff dos
usuários, com os seguintes métodos: index, fazer_login e fazer_logoff;
o menu_controller.rb: classe responsável em carregar a pagina do menu,
com o método index;
o usuarios_controller.rb: classe que contem todos os métodos
responsáveis pela manipulação do usuário usados na aplicação, sendo
eles: edit e update;
o atividade.rb: classe usada para mapear a tabela Atividades do banco
de dados. Com os seguintes métodos: concluir!, ciente!, concluída?,
ciente?;
o grupo.rb classe usada para mapear a tabela Grupos do banco de
dados.
o usuário.rb classe usada para mapear a tabela Usuários do banco de
dados. Com os seguintes métodos: habilitado?, validar?;
• Recursos para RAD:
Como descrito anteriormente os recursos que mais agilizaram o desenvolvimento
foram a própria linguagem Ruby por sua interface humana, o gerador de código
Scaffold e o controlador da camada de modelagem ActiveRecord. Com esses
recursos se teve redução de tempo e de código no desenvolvimento do sistema.
67
7.2 DESENVOLVENDO COM STRUTS
A etapas de criação da aplicação desenvolvida com o framework Struts.
7.2.1 Etapas do Desenvolvimento
7.2.1.1 Criação dos JavaBeans do Sistema
Inicialmente serão criadas as entidades para representar as tabelas do banco de
dados. Sendo criados as seguintes entidades:
• BeanAtividades: utilizada para representar a tabela Atividade do Banco de
Dados; Com as seguintes propriedades: id, descrição, obs,
usuário_origem_id, usuário_destino_id, grupo_origem_id, grupo_destino_id,
created_at, prazo, conclusão, ciente e seus respectivos métodos de acesso
get e set.
• BeanGrupos: utilizada para representar a tabela Grupos do Banco de Dados,
com as seguintes propriedades: id, usuário_id e descrição, com seus métodos
de acesso get e set;
• BeanUsuarios: utilizada para representar a tabela Usuarios do Banco de
Dados com as seguintes propriedades: id, nome, login, senha, email,
created_at e habilitado, e seu métodos de acesso get e set.
Essas entidades serão usadas na comunicação da camada de controle com a
camada de modelagem.
7.2.1.2 Criação da Camada de Modelagem do Sistema
A camada de modelagem conta com alem das classes JavaBeans de mais duas
classes:
• Banco: que é responsável por ter o local do banco de dados e as classes
responsáveis pela conexão com o mesmo.
o Model: classe responsável pelos métodos que serão usados para
inserir, apagar, listar e editar as tabelas do banco de dados. Será essa
classe usada na camada de controle.
A camada de modelagem utilizou-se do recurso da biblioteca de acesso à banco de
dados padrão da API do Java, a JDBC (JDBC, 2007).
7.2.1.3 Criação das Páginas, Forms e Actions da Aplicação
68
No desenvolvimento com Struts é necessário criar para cada formulário html uma
classe ActionForm, que é um Bean que herda da classe ActionForm, o Struts utiliza
dessa classe pra fazer o mapeamento com o formulário html. Ou seja, para cada
campo no formulário html tem que ter uma propriedade com o mesmo nome no
ActionForm responsável pelo formulário html. Na nossa aplicação serão usado as
seguintes paginas html:
• atualizadosucesso.jsp
Pagina utilizada para exibir a mensagem de dados do usuário atualizados com
sucesso.
• enviadasucesso.jsp
Pagina utilizada para exibir a mensagem de Atividade enviada com sucesso.
• erro.jsp
Página utilizada para exibir um mensagem de erro pra qualquer anomalia no
sistema.
• cadastroatividade.jsp
Pagina que contem o formulário para o cadastro/envio de atividade.
• editarusuario.jsp
Pagina com o formulário para a edição dos dados do usuário.
• listaatividades.jsp
Página que exibe as listas de atividades.
• login.jsp
Pagina com o formulário para o usuário efetuar o login no sistema.
• menu.jsp
Página da estrutura principal da aplicação, onde esta as opções do sistema,
como os botões das listagens das atividade, edição dos dados do usuário, a
opção de envio de atividades, atividade recebidas e sair do sistema.
• visualizaratividade.jsp
Pagina responsável pela visualização individual da atividade e onde aparece as
opções: concluir atividade e ficar ciente da atividade;
A seguir temos as classes ActionForm utilizadas para mapear as paginas de
cadastro de atividade e edição do usuário respectivamente:
• FormAtividades.Java
69
ActionFom que será preenchido pelo ActionServlet do Struts com os dados do
formulário correspondente e enviado para o Action de cadastro de atividade.
• FormUsuarios.Java
ActionFom que será preenchido pelo ActionServlet do Struts com os dados do
formulário de edição de usuário, e enviado para Action corresponde a edição do
usuário.
No pacote Form se encontra as classes ActionForm, que fazem a ligação da camada
visual com a camada de controle.
7.2.1.4 Criação do Pacote Útil
E por fim o pacote Útil que tem uma classe utilitária:
• Útil.Java: Classe utilitária com funções que não fazem parte de nenhuma
camada, podendo ser chamada por qualquer camada da aplicação, essa
classe tem o seguinte método: ConverterEmDate2.
7.2.2 Resultados
• Esforço de Estruturação: 30 minutos
Nessa etapa foi preciso criar alguns pacotes para organizar as classes da
aplicação. E também a configuração de cada classe teve que ser feita para
descrever o pacote que a mesma fazia parte.
• Esforço de Programação: 410 minutos
O esforço de programação foi bem mais elevado que na aplicação desenvolvida
com Ruby on Rails por não contar com os mesmo facilitadores que ele. Aqui teve
que ser desenvolvida toda a camada de modelagem da aplicação, a qual faz
parte as classes: Banco, Model, BeanAtividades, BeanGrupos e BeanUsuario.
Outro fator que influenciou esse índice foi o arquivo struts-config.xml que
precisou ser escrito, para os mapeamentos de url e os actionforms serem
reconhecidos.
• Numero de Linhas de Código: 1257
A contagem de linha de código ficou bem acima da aplicação feita com Ruby on
Rails, o principal motivo foi à codificação da camada de modelagem e pelo
principio da interface mínima da linguagem Java que precisa de mais codificação
que utilizando a linguagem Ruby.
70
• Tamanho do Vocabulário: 15 classes
Aqui se teve um maior numero de classes que a outra aplicação. Sendo elas:
o ActionAtividades.java
o ActionCadastroAtividade.java
o ActionEditarUsuario.java
o ActionLogin.java
o ActionLogoff.java
o ActionNovaAtividade.java
o ActionVisualizarAtividade.java
o BeanAtividades.java
o BeanGrupos.java
o BeanUsuarios.java
o FormAtividades.java
o FormUsuarios.java
o Banco.java
o Model.java
o Util.java
• Recursos para RAD:
Dos recursos para agilizar o desenvolvimento rápido que se percebeu no Struts
estão sua biblioteca de tag´s que são usadas pelo ActionServlet do para
preencher o ActionForms e enviar para os Actions. Ficando o Struts a dever
nesse requisito.
7.3 CONCLUSÕES DO COMPARATIVO
Percebe-se que o framework Ruby on Rails é mais completo como uma ferramenta
de desenvolvimento web, com suas camadas interligadas, de modo que não precise
fazer configurações para a comunicação entre elas e nem geração de classes
adicionais. Percebe-se que o gerador de código scaffold e sua camada de
modelagem gerenciada pelo ActiveRecord são os pontos fortes desse framework,
nas analises aqui apresentadas. O Struts tem sua arquitetura mais aberta, com sua
camada de modelagem sem definição, ou seja, fica a critério do desenvolvedor qual
a solução que ele que usar nessa cama, como explicado anteriormente. O tempo de
desenvolvimento com Ruby on Rails foi bem menor que com o Struts, mesmo em
um projeto de pequeno por como o abordado nesse trabalho. O Ruby on Rails
71
mostrou-se a partir das analises, um framework para um determinado tipo de
problema, pois como as suas camadas MVC estão fortemente interligadas o uso de
outro recurso para substituir uma delas não seria viável. E exatamente nesse ponto
o Struts se destaca por ter suas camadas mais flexíveis para mudanças. Não sendo
obrigatório usar das suas bibliotecas de tag´s na sua camada visual e não ter
definido nenhum padrão na sua camada de modelagem, ou seja, o Struts acaba
sendo mais flexível em soluções fora dos recursos do framework, algo que não é
característica do Ruby on Rails. Uma aplicação já existente com o banco de dados
fora do padrão utilizado pelo Ruby on Rails, como por exemplo, com chaves
compostas como identificadores da tabela, já deixaria de funcionar boa parte das
facilidades que o ActiveRecord proporciona, pois ele precisa de um identificador
único para inserir, fazer alterar e apagar um registro no banco. O Ruby on Rails
perde o dinamismo de desenvolvimento quando a aplicação a ser desenvolvida sai
do seu padrão de desenvolvimento.
72
CONCLUSÃO
Neste trabalho, foi possível a realização de um estudo comparativo entre os
frameworks Struts e Ruby on Rails, duas ferramentas com soluções particulares no
desenvolvimento de aplicativos Web. Essas duas soluções de desenvolvimento
surgiram a partir do conceito de framework empregando o modelo de padrão de
projeto MVC, com sua separação de camadas. Os dois vieram com a mesma
proposta de agilizar o desenvolvimento de aplicações Web.
Foi possível também conhecer ainda mais as tecnologias utilizadas como base pelos
dois frameworks, com o referencial teórico que foi embasado: Java, Ruby,
JavaBeans, JavaServlet, JavaServer Page, Framework, Firebird, Aptana IDE e
Eclipse IDE. Com o conteúdo apresentado no referencial teórico pode-se estudar os
dois frameworks, com suas metodologias de desenvolvimento e funcionalidades
peculiares, que os diferenciam.
Com a realização deste trabalho foi possível acrescentar conhecimentos sobre o
assunto estudado, além de demonstrar o desenvolvimento de duas aplicações.
Fazendo o uso dos dois frameworks na prática permitindo dessa forma, a análise
dos resultados de desenvolvimento.
Conclui-se que o desenvolvimento com o framework Ruby on Rails é mais ágil que
com o Struts. Como vimos através dos resultados apresentados nas duas analises
de cada framework. Tal agilidade foi influenciada pela camada de modelagem do
Ruby on Rails, gerenciada pelo ActiveRecord, e pelos scripts de geração de código
que vêm com o framework, diminuindo a quantidade de código fonte, e o tempo de
desenvolvimento da aplicação, outros recursos que fizeram a diferença foi a
linguagem Ruby com sua interface humana, que reduz a quantidade de codificação
e melhora o entendimento do código, a estrutura de pastas fixas, que já vem pronta
e bem padronizada, a simplicidade de configuração do Ruby on Rails faz vantagem
sobre a forma de configuração do Struts, onde no Rails só é preciso identificar os
dados do banco de dados no arquivo database.yml, enquanto no Struts é necessário
colocar no arquivo de configuração struts-config.xml todos os ActionForms
utilizados, Actions e Caminho das Páginas utilizadas.
Outro resultado que pôde ser analisado é que para o desenvolvimento da aplicação
com o banco de dados fora do padrão de desenvolvimento do Ruby on Rails o Struts
73
ganha uma vantagem, pois a camada de modelagem do mesmo é aberta a qualquer
solução, ficando flexível o seu desenvolvimento com sistemas já existentes, que não
seguem o padrão do Ruby on Rails. Perdendo o Rails boa parte da agilidade de
desenvolvimento se não for seguido o seu padrão. Por outro lado o Ruby on Rails é
uma solução completa de framework no desenvolvimento de aplicativos Web, pois
possui soluções de desenvolvimento em todas as suas camadas, algo que não
acontece com o Struts, pois falta a solução da camada de Modelagem, responsável
pela abstração do banco de dados na aplicação.
TRABALHOS FUTUROS
Sugerem-se para trabalhos futuros pesquisas relacionadas à velocidade de
desenvolvimento com duas equipes de programadores. E a analise da curva de
aprendizado com essas mesmas duas equipes, ensinando Java e depois Struts pra
uma equipe, depois ensinando Ruby e depois Ruby on Rails para a segunda equipe.
Sendo possível fazer a analise da curva de aprendizado entre os dois frameworks e
logo depois sendo possível desenvolver uma mesma aplicação com as duas equipes
de desenvolvimento, cada qual com um framework.
Aperfeiçoar as duas aplicações desenvolvidas nessa monografia, adicionando
funcionalidades que ficaram de fora dos casos de uso, como, por exemplo, adicionar
grupo, adicionar usuários, associar usuário no grupo, pesquisa de atividades e
relatórios de atividades.
Sugere-se a criação de uma página de divulgação da aplicação e a abertura do
código fonte do programa desenvolvido em Ruby on Rails o tornando uma aplicação
OpenSource, e com essa abertura, o projeto pode receber contribuição de
desenvolvimento de programadores de todo mundo, e podendo ser usados em
empresas reais, a quais ajudarão para o seu desenvolvimento, melhorando a
aplicação.
Referências
(37SIGNAL,2007) Empresa 37Signals, criadora do Framework Ruby on Rails.
Disponível em < http://www.37signals.com >. Acesso em: 26 de maio. 2007.
(AKITA, 2006) AKITA, FABIO. Repensando a web com Rails – Rio de Janeiro:
Brasport, 2006.
(AMATERAS, 2007) AMATERAS. Disponível em < http://amateras.sourceforge.jp>.
Acesso em: 26 de maio. 2007.
(APTANA, 2007) APATANA. Disponível em < http://aptana.com>. Acesso em: 10 de
junho. 2007.
(ARNOLD,GOSLING,HOLMES, 2006) Facape BODOFF, STEPHANIE ET AL.
Tutorial do J2EE Enterprise Edition 1.4 – Rio de Janeiro: Editora Ciência Moderna,
2005.
(AZEVEDO, 2005) AZEVEDO, Filipe Levi Barros de. Prototipação rápida no ciclo de
design interativo de aplicações multimídia para formação de professores. Trabalho
de conclusão de Curso de Ciência da Computação – Centro de Informática (UFPE).
Disponível em <www.cin.ufpe.br/flba>. Acesso em dezembro de 2006.
(BODOFF, 2005) BODOFF, STEPHANIE ET AL. Tutorial do J2EE Enterprise Edition
1.4 – Rio de Janeiro: Editora Ciência Moderna, 2005.
(BASECAMP, 2007) BASECAMP. Disponível em < http://www.basecamp.com >.
Acesso em: 26 de maio. 2007.
(BORLAND, 2007) BORLAND. Disponível em < http://www.borland.com/br >. Acesso
em: 26 de maio. 2007.
(BURNETTE,ED,2006) BURNETTE, Ed. Eclipse IDE – Porto Alegre: Editora
Bookman, 2006.
(CANTU, 2005) CANTU, CARLOS H. Firebird Essencial – Rio de Janeiro: Editora
Ciência Moderna, 2005.
(CSS, 2007) CSS. Disponível em < http://www.w3.org/style/css>. Acesso em: 10 de
julho. 2007.
(DAVID,2007) DAVID, H.H. Disponível em < http://www.loudthinking.com >. Acesso
em: 26 de maio. 2007.
(DEITEL, 2003) DEITEL, H. M. e DEITEL, P.J. Java, como programar. 4ª edição –
Porto Alegre: Bookman, 2003.
(DELPHI,2007) DELPHI. Disponível em < http://info.borland.com.br/delphi >. Acesso
em: 10 de julho. 2007.
(DOTNET, 2007) .NET . Disponível em < http://msdn.microsoft.com/netFramework >.
Acesso em: 10 de julho. 2007.
(ECLIPSE, 2007) IDE ECLIPSE. Disponível em < http://www.eclipse.org >. Acesso
em: 10 de julho. 2007.
(EUSTÀQUIO,2006) OLIVEIRA JUNIOR, Eutàquio Rargel de. Ruby Conhecendo a
Linguagem – Rio de Janeiro: Brasport, 2006.
(FAYAD;SCHMIDT;JOHNSON, 1999) Fayad, M.E.; Schmidt, D.C.; Johnson, R.E.
Building Application Frameworks - Addison-Wesley Publishing Company, 1995.
(FIREBIRD, 2007) Banco de Dados Firebird . Disponível em <
http://www.firebirdsql.org >. Acesso em: 26 de maio. 2007.
(FORTRAN, 2007) Linguagem de Programação FORTRAN. Disponível em <
http://www-360.ibm.com/software/awdtools/xlfortran >. Acesso em: 10 de julho. 2007.
(FTP,2007) Protocolo FTP. Disponível em < http://orgãopadronizador.com >. Acesso
em: 26 de maio. 2007.
(GCC, 2007) Compilador OpenSource para linguagem C. Disponível em <
http://www.gcc.gnu.org >. Acesso em: 26 de maio. 2007.
(GEMS, 2007) RUBY GEMS. Disponível em < http://rubygems.org >. Acesso em: 10
de julho. 2007.
(GOMES, 2003) GOMES, Marco Antonio Pereira. Estudo e Prototipação de
ferramenta para gerência de projetos, enfocando a gerência de aquisições.
http://www.ulbra.tche.br/~tcc-canoas/2003-2/marco.pdf . Acesso em junho de 2007.
(GOOGLE, 2007) GOOGLE. Disponível em < http://www.google.com >. Acesso em:
10 de julho. 2007.
(HIBERNATE, 2007) FRAMEWORK HIBERNATE. Disponível em <
http://www.hibernate.org >. Acesso em: 10 de julho. 2007.
(HTTP, 2007) Protocolo HTTP. Disponível em < http://www.w3.org/Protocols >.
Acesso em: 26 de maio. 2007.
(HUSTED,2004) HUSTED, Ted. Struts em Ação – Rio de Janeiro: Editora Ciência
Moderna, 2004.
(IDE, 2007) HUSTED, Ted. Struts em Ação – Rio de Janeiro: Editora Ciência
Moderna, 2004.
(INDEED, 2007) INDEED. Disponível em < http://www.indeed.com >. Acesso em: 17
de junho. 2007.
(ISO, 2007) SQL ISO. Disponível em <
http://www.techstreet.com/features/ISSO_IEC_9075.tmpl >. Acesso em: 26 de maio.
2007.
(JAKARTA, 2007) Projeto JAKARTA. Disponível em < http://jakarta.apache.org >.
Acesso em: 26 de maio. 2007.
(JAVA, 2007) A Sun Microsystems Developers Network Site, Java Technology.
Disponível em <http://java.sun.com/>. Acesso em: 23 maio. 2007.
(JAVABEANS, 2007) A Sun Microsystems Developers Network Site, Java
Technology. Disponível em <http://java.sun.com/procucts/javabeans>. Acesso em:
23 maio. 2007.
(JAVAFREE, 2007). Portal JAVAFREE. Disponível em <http://www.javafree.org/>.
Acesso em: 23 maio. 2007.
(JAVASCRIPT, 2007) JAVASCRIPT. Disponível em <http://www.w3.org/DOM>.
Acesso em: 23 maio. 2007.
(JDBC, 2007) JDBC. Disponível em
<http://java.sun.com/javase/technologies/database>. Acesso em: 23 maio. 2007.
(JRUBY, 2007) JRUBY. Disponível em <http://jruby.codehaus.org>. Acesso em: 10
de julho. 2007.
(JRUBYONRAILS, 2007) JRUBY On RAILS. Disponível em
<http://jruby.codehaus.org>. Acesso em: 10 de julho. 2007.
(JSP, 2007) Java Server Pages. Disponível em < http://www.java.com/jsp >. Acesso
em: Acesso em: 26 de maio. 2007.
(MATIRNFOWLER,2007) MARTIN,fowler. Disponível em < http://Site da
linaguem.com >. Acesso em: 26 de maio. 2007.
(MATTSSON, 1996) Mattsson, M. Object-Oriented Frameworks: a survey of
methodological issues. Lund: Department of Computer Science, Lund University,
1996.
(MATZ, 2007) MATSUMOTO, YOUKIHIRO. Disponível em < http://www.ruby-
lang.org >. Acesso em: 26 de maio. 2007.
(MICROSOFT, 2007) MICROSOFT. Disponível em < http://www.microsoft.com.br >.
Acesso em: 26 de maio. 2007.
(MVSTUDIO,2007) MICROSOFT VIRTUAL STUDIO. Disponível em <
http://msdn.microsoft.com/vstudio >. Acesso em: 26 de maio. 2007.
(NETBEANS,2007) IDE NETBEANS. Disponível em < http://www.netbeans.org >.
Acesso em: 26 de maio. 2007.
(ODBC, 2007) ODBC. Disponível em < http://www.microsoft.com/data >. Acesso em:
26 de maio. 2007.
(OPENSOURCE, 2007) OPENSOURCE. Disponível em <
http://www.opensource.org >. Acesso em: 26 de maio. 2007.
(PERL,007) Linguagem de Programação Perl. Disponível em < http://www.perl.com
>. Acesso em: 26 de maio. 2007.
(PHP,2007) Linguagem de Programação PHP. Disponível em < http://www.php.net
>. Acesso em: 26 de maio. 2007.
(PREE, 1995) Pree, W. Design Patterns for Object-Oriented Software Development.
Reading: object-oriented foundations of Framework design. New York: Wiley
Computer. Publishing, 1999.
(PRESSMAN, 2007) PRESSMAN, Roger S. Engenharia de Spftware Sexta Edição –
São Paulo: Mc Graw Hill, 2006.
(PYTH, 2007) Linguagem de Programação Python. Disponível em < http://Site da
linaguem.com >. Acesso em: 26 de maio. 2007.
(RAA, 2007) Ruby Application Archive. Disponível em <http://raa.ruby-lang.org>.
Acesso em: 26 de maio. 2007.
(RAILS, 2007) Framework Ruby on Rails. Disponível em
<http://www.rubyonrails.com>. Acesso em: 26 de maio. 2007.
(RUBY, 2007) Linguage Ruby. Disponível em <http://www.ruby-lang.org>. Acesso
em:26 de maio. 2007.
(RUBYFORGE, 2007) Ruby Forge. Disponível em <http://rubyforge.org>. Acesso
em:26 de maio. 2007.
(RUBYONBR, 2007) Ruby on BR. Disponível em <http://www.rubyonbr.org>. Acesso
em:26 de maio. 2007.
(SERVLETS, 2007) (BODOFF, 2005) BODOFF, STEPHANIE ET AL. Tutorial do
J2EE Enterprise Edition 1.4 – Rio de Janeiro: Editora Ciência Moderna, 2005.
(SHELL, 2007) NEVES, Julio C. Programação Shell Linux 6ª edição – Rio de
Janeiro: Editora Brasport, 2006.
(SIM, 2007) Linguagem de Programação Simula. Disponível em <
http://www.simula.no >. Acesso em: 26 de maio. 2007.
(SMLL, 2007) Linguagem de Programação Small Talk. Disponível em <
http://www.smalltalk.com >. Acesso em: 26 de maio. 2007.
(SMTP,2007) Protocolo SMTP. Disponível em < http://www.w3.org/protocols >.
Acesso em: 26 de maio. 2007.
(SCAFFOLD, 2007) Scaffold Ruby on Rails. Disponivel em <
http://wiki.rubyonrails.org/rails/pages/Scaffold >. Acesso em 10 de junho. 2007.
(SQL, 2007) SQL. Disponível em < http://www.w3school.com/sql >. Acesso em: 26
de maio. 2007.
(SQLM, 2006) EMS SQL Firebird Manager Protocolo. Disponível em <
http://www.sqlmanager.org >. Acesso em: 26 de maio. 2007.
(STRUTS, 2007) Apache Struts. Disponível em <http://struts.apache.org/>. Acesso
em: 26 de maio . 2007.
(SUBCLIPSE,2007) Plugin SUBCLIPSE. Disponível em < http://subclipse.tigris.org >.
Acesso em: 26 de maio. 2007.
(SUBVERSION,2007) SUBVERSION. Disponível em < http://subversion.tigris.org >.
Acesso em: 26 de maio. 2007.
(SUN, 2007) A Sun Microsystems. Disponível em <http://www.sun.com/>. Acesso
em: 23 mai. 2007.
(SYSDEO ,2007) Plugin SYSDEO for Tomcat. Disponível em <
http://www.eclipsetotale.com/tomcatPlugin.html >. Acesso em: 26 de maio. 2007.
(TILES, 2007) (HUSTED,2004) HUSTED, Ted. Struts em Ação – Rio de Janeiro:
Editora Ciência Moderna, 2004.
(TIOBE,2007) TIOBE. Disponivel em < http://www.tiobe.org >. Acesso em: 26 de
maio. 2007.
(THOMAS,2007) THOMAS, Dave. Programming Ruby. Disponível em <
http://www.rubycentral.com/pickaxe >. Acesso em: 26 de maio. 2007.
(TOMCAT, 2007) Apache TOMCAT. Disponível em < http://tomcat.apache.org>.
Acesso em: 26 de maio. 2007.
(TPCIP, 2007) Protocolo TCP/IP. Disponível em < http://orgãopadronizador.com >.
Acesso em: 26 de maio. 2007.
(UML, 2007) MEDEIROS, ERNANI. UML 2.0 Definitivo – São Paulo: Pearson
Makron Books, 2004.
(UTF8, 2007) Unicode UFT-8. Disponível em < http://www.unicode.org >. Acesso
em: 26 de maio. 2007.
(VELOCITY, 2007) Framework VELOCITY. Disponível em <
http://velocity.apache.org>. Acesso em: 26 de maio. 2007.
(WEB2, 2007) WEB 2.0. Disponível em < http://www.w3.org/TR/WCAG20 >. Acesso
em: 26 de maio. 2007.
(WEBSERVICE, 2007) WEBSERVICE. Disponível em <
http://msdn.microsoft.com/webservices >. Acesso em: 26 de maio. 2007.
(XML, 2007) Extensible Markup Language. Disponível em < http://www.w3.org/XML
>. Acesso em: 26 de maio. 2007.
(TUTORIALJ2EE, 2005) (BODOFF, 2005) BODOFF, STEPHANIE ET AL. Tutorial do
J2EE Enterprise Edition 1.4 – Rio de Janeiro: Editora Ciência Moderna, 2005.
ANEXOS
Anexo I – Código Fonte da Aplicação em Ruby on Rails O conteúdo listado a seguir é o código fonte da aplicação desenvolvida com o Framework Ruby on Rails, todas suas classes, rhtml e arquivo de configuração. class ApplicationController < ActionController::Base session :session_key => '_atividades2_session_id' def checar_login if session["usuario"] == nil redirect_to :controller => "login",:action => 'index' end end end class AtividadesController < ApplicationController before_filter :checar_login verify :method => :post, :only => [ :destroy, :create, :update ], :redirect_to => { :action => :list } def show @atividade = Atividade.find(params[:id]) end def new @usuarios_grupo = Grupo.find(session['usuario'].grupos[0].id).usuarios @atividade = Atividade.new end def create @atividade = Atividade.new(params[:atividade]) @atividade.usuario_origem = session['usuario'] if @atividade.save flash[:notice] = 'Atividade enviada com sucesso.' redirect_to :action => 'enviadas' else render :action => 'new' end end def recebidas @atividade_pages, @atividades = paginate :atividades,:conditions => ["usuario_destino_id = ? and conclusao is not null",session['usuario'].id],:order => 'prazo DESC' ,:per_page => 10 render :action => 'lista_atividades' end def enviadas @atividade_pages, @atividades = paginate :atividades, :conditions => ["usuario_origem_id = ?",session['usuario'].id] ,:per_page => 10,:order => 'prazo DESC' render :action => 'lista_atividades' end def concluidas @atividade_pages, @atividades = paginate :atividades, :conditions => ["usuario_destino_id = ? and conclusao is not null",session['usuario'].id] ,:per_page => 10,:order => 'prazo DESC' render :action => 'lista_atividades' end def concluir Atividade.find(params[:id]).concluir! redirect_to :action => 'show', :id => params[:id] end def ciente a = Atividade.find(params[:id]) puts "Teste Ciente => " + a.ciente?.to_s a.ciente! puts "Teste Ciente => " + a.ciente?.to_s a.save redirect_to :action => 'show', :id => params[:id] end end
class LoginController < ApplicationController def index end def fazer_login login = params[:usuario]["login"] senha = params[:usuario]["senha"] if Usuario.new.validar?(login,senha) session["usuario"] = Usuario.find_by_login_and_senha(login,senha) redirect_to(:controller => "menu", :action => "index") else redirect_to(:controller => "login", :action => "index") end end def fazer_logoff session["usuario"] = nil redirect_to(:controller => "login", :action => "index") end end class MenuController < ApplicationController before_filter :checar_login def index @usuario = session["usuario"] end end class UsuariosController < ApplicationController require 'util_date' before_filter :checar_login # GETs should be safe (see http://www.w3.org/2001/tag/doc/whenToUseGet.html) verify :method => :post, :only => [ :destroy, :create, :update ],:redirect_to => { :action => :list } def edit @usuario = Usuario.find(params[:id]) end def update @usuario = Usuario.find(params[:id]) if @usuario.update_attributes(params[:usuario]) flash[:notice] = 'Alterações realizadas com sucesso.' redirect_to :action => 'edit', :id => @usuario #redirect_to :action => 'show', :id => @usuario else render :action => 'edit' end end end class Atividade < ActiveRecord::Base belongs_to :usuario_origem, :class_name => 'Usuario', :foreign_key => 'usuario_origem_id' belongs_to :usuario_destino, :class_name => 'Usuario', :foreign_key => 'usuario_destino_id' belongs_to :grupo_origem, :class_name => 'Grupo', :foreign_key => 'grupo_origem_id' belongs_to :grupo_destino, :class_name => 'Grupo', :foreign_key => 'grupo_destino_id' validates_presence_of([:descricao,:prazo], :message => "Campo Obrigatorio") def concluir! self.conclusao = Time.now self.save end def ciente! self.ciente = Time.now self.save end
def concluida? if self.conclusao == nil false else true end end def ciente? if self.ciente == nil false else true end end end class Grupo < ActiveRecord::Base belongs_to :usuario has_many :atividades has_and_belongs_to_many :usuarios belongs_to :usuario_dono, :class_name => 'Usuario', :foreign_key => 'usuario_id' end class Usuario < ActiveRecord::Base has_one :grupo has_many :atividades has_and_belongs_to_many :grupos def habilitado? if self.habilitado == 'T' true else false end end def validar?(login,senha) u = Usuario.find_by_login_and_senha(login,senha) if u.nil? false else true end end end #class util_date.rb def datebrasil(x) if x.nil? " " else x.day.to_s + "/" + x.month.to_s + "/" + x.year.to_s end end #arquivo de configuração databse.yml development: adapter: firebird database: C:\ATIVIDADES.FDB username: sysdba password: masterkey host: 127.0.0.1
Paginas RHTML <html> <head> <meta http-equiv="content-type" content="text/html; charset=ISO-8859-1"> <meta http-equiv="refresh" content="600"> <title>Atividades</title>
<style type="text/css"> img{ border: 0;} body { scrollbar-arrow-color:#FFF974; scrollbar-3dlight-color:#FFF974; scrollbar-highlight-color:#FFF974; scrollbar-face-color:#000000; scrollbar-shadow-color:#FFF974; scrollbar-darkshadow-color:#FFF974; scrollbar-track-color:#FFF974; } </style> </head> <body class="login"> <table width="789" align="center" border="0" bgcolor="#FFF974" cellpadding="0" cellspacing="0" vspace="0"> <tr> <td><img src="images/top.jpg"></td> </tr> <tr> <td align="right"> <b> <%[email protected] %> - <%=link_to ("editar", {:controller => "usuarios", :action => "edit", :id => @usuario}, :target => "principal") %> - <%= link_to "sair", :controller => "login", :action => "fazer_logoff" %> <br> Grupo: <%= @usuario.grupos[0].descricao.capitalize %> (<%=Grupo.find(@usuario.grupos[0].id).usuario.nome.camelize%>) </b> <table width="790"> <tr> <td width="190" height="300" valign="top" align="center"> <a href="atividades/recebidas" target="principal"><img src="images/bt_04.jpg" border="0"></a><br> <a href="atividades/enviadas" target="principal"><img src="images/bt_01.jpg" border="0"></a><br> <a href="atividades/concluidas" target="principal"><img src="images/bt_05.jpg" border="0"></a><br> <%=link_image_to("images/bt_03.jpg", {:controller => "atividades", :action => "new"}, :target => "principal") %></a><br> </td> <td width="600" height="420" valign="top"> <iframe name="principal" height="420" width="600" frameborder="0" border="0" marginheight="0" marginwidth="0" src="atividades/recebidas"> </td> </tr> </table> </td> </tr> </table> </body> </html> <%= stylesheet_link_tag 'scaffold' %> <html> <head> <title> Sistema de Atividades </title> </head> <body class="login" > <% form_tag :action => 'fazer_login' do %> <table class="login" align="center" border="0" width="790" bgcolor="#FFF974" cellpadding="0" cellspacing="0" bordercolor="#FFF974"> <tr> <td colspan="2">
<img src="images/top.jpg"> </td> </tr> <tr> <td> <table align="left" class="login" > <tr> <td> <label><b>login<b></label><br> <%= text_field 'usuario','login' , :size => 20 %> <br> <label><b>senha</b></label><br> <%= password_field 'usuario','senha' , :size => 20 %> <br> <%= submit_tag "Entrar" %> </td> </tr> </table> </td> <td> <img src="images/banner.jpg"> </td> </tr> </table> <% end %> <body> </html> ####################edit.rhtml <% form_tag :action => 'update', :id => @usuario do %> <%= render :partial => 'form' %> <% end %> #################### <%= error_messages_for 'usuario' %> <!--[form:usuario]--> <table align="center" bgcolor="#FFFFFF"> <input type="hidden" value="2" name="id"> <tr> <th colspan="2" bgcolor="#000000"> <font color="#FFFFFF" > Dados do Usuário </font> </th> </tr> <tr> <td>Login</td> <td> <%= text_field 'usuario', 'login' , :readonly => "false" %> </td> </tr> <tr> <td>Nome</td> <td> <%= text_field 'usuario', 'nome' %> </td> </tr> <tr> <td>Senha</td> <td> <%= text_field 'usuario', 'senha' %> </td> </tr> <tr> <td>E-mail</td> <td> <%= text_field 'usuario', 'email' %> </td> </tr> <tr> <td > <%= submit_tag 'Salvar' %> </td>
</tr> </table> <!--[eoform:usuario]--> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> <head> <meta http-equiv="content-type" content="text/html;charset=UTF-8" /> <title>Usuarios: <%= controller.action_name %></title> <%= stylesheet_link_tag 'scaffold' %> </head> <body> <p style="color: green"><%= flash[:notice] %></p> <%= yield %> </body> </html> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> <head> <meta http-equiv="content-type" content="text/html;charset=UTF-8" /> <title>Atividades: <%= controller.action_name %></title> <%= stylesheet_link_tag 'scaffold' %> </head> <body> <p style="color: green"><%= flash[:notice] %></p> <%= yield %> </body> </html> <html> <head> <meta http-equiv="content-type" content="text/html; charset=ISO-8859-1"> <title>Visualizar Atividade</title> <style type="text/css"> </style> </head> <body marginheight="0" marginwidth="0" vlink="#000000" alink="#000000" link="#000000"> <table align="center" width="480" bgcolor="#FFFFFF"> <tr> <th colspan="2" bgcolor="#000000"> <font color="#FFFFFF" >Visualizar Atividade</font> </th> </tr> <tr> <td width="30%" bgcolor="#FFF974"> Usuário Origem </td> <td width="*"> <%= @atividade.usuario_origem.nome %> </td> </tr> <tr> <td bgcolor="#FFF974"> Data de Envio </td> <td> <%=datebrasil(@atividade.created_at)%> </td> </tr> <tr> <td bgcolor="#FFF974"> Prazo
</td> <td><%=datebrasil(@atividade.prazo)%> </td> </tr> <tr> <td bgcolor="#FFF974"> Usuário Destino </td> <td> <%= @atividade.usuario_destino.nome %> </td> </tr> <tr> <td valign="top" bgcolor="#FFF974"> Descrição </td> <td valign="top"> <%=h @atividade.descricao %> </td> </tr> <tr> <td valign="top" bgcolor="#FFF974"> Observações Adicionais </td> <td valign="top"> <%=h @atividade.obs %> </td> </tr> <tr> <td colspan="2"> <% if @atividade.usuario_destino == session['usuario'] and not @atividade.concluida? and not @atividade.ciente? %> <%= link_to "Concluir", :controller => "atividades", :action => "concluir", :id => @atividade.id %> <% end %> <% if @atividade.usuario_origem == session['usuario'] and @atividade.concluida? and not @atividade.ciente? %> <%= link_to "Ciente", :controller => "atividades", :action => "ciente", :id => @atividade.id.to_i %> <% end %> </td> </tr> <tr> <td colspan="2" align="center"> <a href="javascript:history.go(-1)" target="principal">Voltar</a> </td> </tr> </table> </body> </html> ################# <% form_tag :action => 'create' do %> <%= render :partial => 'form' %> <% end %> ################## <%require 'util_date'%> <table width="580" border="0" align="center" bgcolor="#FFFFFF"> <tr> <th colspan="5" bgcolor="#000000" > <font color="#FFFFFF"> Lista de Atividades <%= controller.action_name.capitalize %> </font> </th> </tr> <tr bgcolor="#FFF974"> <th> Descrição </th> <%if controller.action_name.capitalize == "Enviadas"%> <th width="20%"> Usuário Destino </th> <%end%>
<%if controller.action_name.capitalize == "Recebidas"%> <th width="20%"> Usuário Origem </th> <%end%> <th width="15%"> Prazo </th> <th width="15%"> Concluído </th> <th width="15%"> Ciente </th> </tr> <% for atividade in @atividades %> <tr> <td align="center"> <%= link_to atividade.descricao , :action => 'show', :id => atividade %></td> <%if controller.action_name.capitalize == "Recebidas"%> <td align="center"><%= atividade.usuario_origem.nome %> <%end%> <%if controller.action_name.capitalize == "Enviadas"%> <td align="center"><%= atividade.usuario_destino.nome %> <%end%> </td> <td align="center"><%=datebrasil(atividade.prazo)%></td> <td align="center"><%=datebrasil(atividade.conclusao)%></td> <td align="center"><%=datebrasil(atividade.ciente)%></td> </tr> <% end %> </table> <%= link_to 'Página Anterior', { :page => @atividade_pages.current.previous } if @atividade_pages.current.previous %> <%= link_to 'Próxima Página', { :page => @atividade_pages.current.next } if @atividade_pages.current.next %> #################### <%= error_messages_for 'atividade' %> <!--[form:atividade]--> <table align="center" width="480" bgcolor="#FFFFFF"> <tr> <th colspan="2" bgcolor="#000000"> <font color="#FFFFFF">Enviar Atividade</font> </th> </tr> <tr> <td><b> Usuário Origem<br> <input type="text" readonly="false" value="<%= session["usuario"].nome %>" /> </b> </td> <td><b> Usuário Destino<br> <%= select('atividade', 'usuario_destino_id', @usuarios_grupo.collect{|u| [u.nome,u.id]}) %> </b> </td> </tr> <tr> <td><b>Data de Envio</b><br> <input type="text" value="<%=datebrasil(Time.now) %>" readonly="false" /> </td> <td> Prazo<br> <%= date_select 'atividade', 'prazo' , :order => [:day, :month , :year], :start_year => 2007, :end_year => 2009,:use_month_numbers => true %> </b> </td> </tr> <tr> <td colspan="2"> <b>
Descrição<br> <%= text_area 'atividade', 'descricao' , {:cols=>"60", :rows=>"5"} %> </b> </td> </tr> <tr> <td colspan="2"> <b> Observações Adicionais<br> <%= text_area 'atividade', 'obs', {:cols=>"60", :rows=>"5"} %> </b> </td> </tr> <tr> <th colspan="2"> <%= submit_tag "Enviar" %> </th> </tr> </table> <!--[eoform:atividade]-->
Anexo II – Código Fonte da Aplicação em Struts O conteúdo listado a seguir é o código fonte da aplicação desenvolvida com o Framework Struts, todas suas classes, jsp e arquivo de configuração.
package atividades.struts.model; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; public class Banco { /** * Conexão com o BD. */ private Connection con = null; private String hostName = null; private String userName = null; private String password = null; private String url = null; private String jdbcDriver = null; private String dataBaseName = null; private String dataBasePrefix = null; /** * Cosntrutor Padrão */ public Banco() { hostName = "127.0.0.1"; userName = "SYSDBA"; password = "masterkey"; jdbcDriver = "org.firebirdsql.jdbc.FBDriver"; dataBaseName = "C:/ATIVIDADES.FDB"; dataBasePrefix = "jdbc:firebirdsql:"; url = dataBasePrefix + hostName + ":"+ dataBaseName; } /** * Retorna uma java.sql.Connection. * @return con */ public Connection getConnection() { try { if (con == null) { Class.forName(jdbcDriver); con = DriverManager.getConnection(url, userName, password); }else if (con.isClosed()) { con = null; return getConnection(); } } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (SQLException e) { e.printStackTrace(); } return con; } /** * Fecha a conexão com BD. */ public void closeConnection() { if (con != null) { try { con.close(); }catch (SQLException e) { e.printStackTrace(); } } }
} package atividades.struts.model; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.util.ArrayList; import atividades.struts.beans.BeanAtividades; import atividades.struts.beans.BeanGrupos; import atividades.struts.beans.BeanUsuarios; import atividades.utils.Util; public class Model { public static Model getInstance(){ return new Model(); } public boolean retornaSeAtividadeConcluida_(int id){ Banco b = new Banco(); String query = "SELECT ATIVIDADES.ID FROM ATIVIDADES WHERE ATIVIDADES.ID = ? AND ATIVIDADES.CONCLUSAO IS NOT NULL "; boolean retorno = false; try{ PreparedStatement st = b.getConnection().prepareStatement(query); st.setInt(1, id); ResultSet rs = st.executeQuery(); retorno = rs.next(); }catch (Exception e) { e.printStackTrace(); } return retorno; } public boolean retornaSeAtividadeCiente_(int id){ Banco b = new Banco(); String query = "SELECT ATIVIDADES.ID FROM ATIVIDADES WHERE ATIVIDADES.ID = ? AND ATIVIDADES.CIENTE IS NOT NULL "; boolean retorno = false; try{ PreparedStatement st = b.getConnection().prepareStatement(query); st.setInt(1, id); ResultSet rs = st.executeQuery(); retorno = rs.next(); }catch (Exception e) { e.printStackTrace(); } return retorno; } public BeanAtividades retornaAtividade(int id){ Banco b = new Banco(); String query = "SELECT * FROM ATIVIDADES WHERE ATIVIDADES.ID = ?"; BeanAtividades atividade = new BeanAtividades(); try{ PreparedStatement st = b.getConnection().prepareStatement(query);
st.setInt(1, id); ResultSet rs = st.executeQuery(); if(rs.next()){ atividade.setId(rs.getString("id")); atividade.setDescricao(rs.getString("descricao")); atividade.setObs(rs.getString("obs")); atividade.setUsuario_origem_id(rs.getString("usuario_origem_id")); atividade.setUsuario_destino_id(rs.getString("usuario_destino_id")); atividade.setGrupo_origem_id(rs.getString("grupo_origem_id")); atividade.setGrupo_destino_id(rs.getString("grupo_destino_id")); atividade.setCreated_at(rs.getString("created_at")); atividade.setPrazo(rs.getString("prazo")); atividade.setConclusao(rs.getString("conclusao")); atividade.setCiente(rs.getString("ciente")); } }catch (Exception e) { e.printStackTrace(); } return atividade; } public ArrayList<BeanAtividades> retornaAtividades(){ Banco b = new Banco(); ArrayList<BeanAtividades> atividades = new ArrayList<BeanAtividades>(); String query = "SELECT * FROM ATIVIDADES"; try{ PreparedStatement st = b.getConnection().prepareStatement(query); ResultSet rs = st.executeQuery(); while(rs.next()){ BeanAtividades atividade = new BeanAtividades(); atividade.setId(rs.getString("id")); atividade.setDescricao(rs.getString("descricao")); atividade.setObs(rs.getString("obs")); atividade.setUsuario_origem_id(rs.getString("usuario_origem_id")); atividade.setUsuario_destino_id(rs.getString("usuario_destino_id")); atividade.setGrupo_origem_id(rs.getString("grupo_origem_id")); atividade.setGrupo_destino_id(rs.getString("grupo_destino_id")); atividade.setCreated_at(rs.getString("created_at")); atividade.setPrazo(rs.getString("prazo")); atividade.setConclusao(rs.getString("conclusao")); atividade.setCiente(rs.getString("ciente")); atividades.add(atividade); } }catch (Exception e) { e.printStackTrace(); } return atividades; } public ArrayList<BeanAtividades> retornaAtividadesEnviadas(BeanUsuarios usuario){ Banco b = new Banco(); ArrayList<BeanAtividades> atividades = new ArrayList<BeanAtividades>(); String query = "SELECT * FROM ATIVIDADES WHERE ATIVIDADES.USUARIO_ORIGEM_ID = ? ORDER BY ATIVIDADES.PRAZO DESC"; try{ PreparedStatement st = b.getConnection().prepareStatement(query); st.setInt(1, Integer.parseInt(usuario.getId())); ResultSet rs = st.executeQuery(); while(rs.next()){ BeanAtividades atividade = new BeanAtividades(); atividade.setId(rs.getString("id"));
atividade.setDescricao(rs.getString("descricao")); atividade.setObs(rs.getString("obs")); atividade.setUsuario_origem_id(rs.getString("usuario_origem_id")); atividade.setUsuario_destino_id(rs.getString("usuario_destino_id")); atividade.setGrupo_origem_id(rs.getString("grupo_origem_id")); atividade.setGrupo_destino_id(rs.getString("grupo_destino_id")); atividade.setCreated_at(rs.getString("created_at")); atividade.setPrazo(rs.getString("prazo")); atividade.setConclusao(rs.getString("conclusao")); atividade.setCiente(rs.getString("ciente")); atividades.add(atividade); } }catch (Exception e) { e.printStackTrace(); } return atividades; } public ArrayList<BeanAtividades> retornaAtividadesEnviadasConcluidas(BeanUsuarios usuario){ Banco b = new Banco(); ArrayList<BeanAtividades> atividades = new ArrayList<BeanAtividades>(); String query = "SELECT * FROM ATIVIDADES WHERE ATIVIDADES.USUARIO_ORIGEM_ID = ? AND ATIVIDADES.CONCLUSAO IS NOT NULL ORDER BY ATIVIDADES.PRAZO DESC"; try{ PreparedStatement st = b.getConnection().prepareStatement(query); st.setInt(1, Integer.parseInt(usuario.getId())); ResultSet rs = st.executeQuery(); while(rs.next()){ BeanAtividades atividade = new BeanAtividades(); atividade.setId(rs.getString("id")); atividade.setDescricao(rs.getString("descricao")); atividade.setObs(rs.getString("obs")); atividade.setUsuario_origem_id(rs.getString("usuario_origem_id")); atividade.setUsuario_destino_id(rs.getString("usuario_destino_id")); atividade.setGrupo_origem_id(rs.getString("grupo_origem_id")); atividade.setGrupo_destino_id(rs.getString("grupo_destino_id")); atividade.setCreated_at(rs.getString("created_at")); atividade.setPrazo(rs.getString("prazo")); atividade.setConclusao(rs.getString("conclusao")); atividade.setCiente(rs.getString("ciente")); atividades.add(atividade); } }catch (Exception e) { e.printStackTrace(); } return atividades; } public ArrayList<BeanAtividades> retornaAtividadesRecebidas(BeanUsuarios usuario){ Banco b = new Banco(); ArrayList<BeanAtividades> atividades = new ArrayList<BeanAtividades>(); String query = "SELECT * FROM ATIVIDADES WHERE ATIVIDADES.USUARIO_DESTINO_ID = ? ORDER BY ATIVIDADES.PRAZO DESC"; try{ PreparedStatement st = b.getConnection().prepareStatement(query); st.setInt(1, Integer.parseInt(usuario.getId())); ResultSet rs = st.executeQuery(); while(rs.next()){ BeanAtividades atividade = new BeanAtividades(); atividade.setId(rs.getString("id")); atividade.setDescricao(rs.getString("descricao")); atividade.setObs(rs.getString("obs"));
atividade.setUsuario_origem_id(rs.getString("usuario_origem_id")); atividade.setUsuario_destino_id(rs.getString("usuario_destino_id")); atividade.setGrupo_origem_id(rs.getString("grupo_origem_id")); atividade.setGrupo_destino_id(rs.getString("grupo_destino_id")); atividade.setCreated_at(rs.getString("created_at")); atividade.setPrazo(rs.getString("prazo")); atividade.setConclusao(rs.getString("conclusao")); atividade.setCiente(rs.getString("ciente")); atividades.add(atividade); } }catch (Exception e) { e.printStackTrace(); } return atividades; } public ArrayList<BeanAtividades> retornaAtividadesRecebidasEnceradas(BeanUsuarios usuario){ Banco b = new Banco(); ArrayList<BeanAtividades> atividades = new ArrayList<BeanAtividades>(); String query = "SELECT * FROM ATIVIDADES WHERE ATIVIDADES.USUARIO_DESTINO_ID = ? AND ATIVIDADES.CONCLUSAO IS NULL AND ATIVIDADES.CIENTE IS NULL ORDER BY ATIVIDADES.ID DESC"; try{ PreparedStatement st = b.getConnection().prepareStatement(query); st.setInt(1, Integer.parseInt(usuario.getId())); ResultSet rs = st.executeQuery(); while(rs.next()){ BeanAtividades atividade = new BeanAtividades(); atividade.setId(rs.getString("id")); atividade.setDescricao(rs.getString("descricao")); atividade.setObs(rs.getString("obs")); atividade.setUsuario_origem_id(rs.getString("usuario_origem_id")); atividade.setUsuario_destino_id(rs.getString("usuario_destino_id")); atividade.setGrupo_origem_id(rs.getString("grupo_origem_id")); atividade.setGrupo_destino_id(rs.getString("grupo_destino_id")); atividade.setCreated_at(rs.getString("created_at")); atividade.setPrazo(rs.getString("prazo")); atividade.setConclusao(rs.getString("conclusao")); atividade.setCiente(rs.getString("ciente")); atividades.add(atividade); } }catch (Exception e) { e.printStackTrace(); } return atividades; } public ArrayList<BeanAtividades> retornaAtividadesEnviadasEnceradas(BeanUsuarios usuario){ Banco b = new Banco(); ArrayList<BeanAtividades> atividades = new ArrayList<BeanAtividades>(); String query = "SELECT * FROM ATIVIDADES WHERE ATIVIDADES.USUARIO_ORIGEM_ID = ? AND ATIVIDADES.CONCLUSAO IS NULL AND ATIVIDADES.CIENTE IS NULL ORDER BY ATIVIDADES.ID DESC"; try{ PreparedStatement st = b.getConnection().prepareStatement(query); st.setInt(1, Integer.parseInt(usuario.getId())); ResultSet rs = st.executeQuery(); while(rs.next()){ BeanAtividades atividade = new BeanAtividades(); atividade.setId(rs.getString("id")); atividade.setDescricao(rs.getString("descricao")); atividade.setObs(rs.getString("obs")); atividade.setUsuario_origem_id(rs.getString("usuario_origem_id")); atividade.setUsuario_destino_id(rs.getString("usuario_destino_id"));
atividade.setGrupo_origem_id(rs.getString("grupo_origem_id")); atividade.setGrupo_destino_id(rs.getString("grupo_destino_id")); atividade.setCreated_at(rs.getString("created_at")); atividade.setPrazo(rs.getString("prazo")); atividade.setConclusao(rs.getString("conclusao")); atividade.setCiente(rs.getString("ciente")); atividades.add(atividade); } }catch (Exception e) { e.printStackTrace(); } return atividades; } public ArrayList<BeanAtividades> retornaAtividadesRecebidasConcluidas(BeanUsuarios usuario){ Banco b = new Banco(); ArrayList<BeanAtividades> atividades = new ArrayList<BeanAtividades>(); String query = "SELECT * FROM ATIVIDADES WHERE ATIVIDADES.USUARIO_DESTINO_ID = ? AND ATIVIDADES.CONCLUSAO IS NOT NULL ORDER BY ATIVIDADES.PRAZO DESC"; try{ PreparedStatement st = b.getConnection().prepareStatement(query); st.setInt(1, Integer.parseInt(usuario.getId())); ResultSet rs = st.executeQuery(); while(rs.next()){ BeanAtividades atividade = new BeanAtividades(); atividade.setId(rs.getString("id")); atividade.setDescricao(rs.getString("descricao")); atividade.setObs(rs.getString("obs")); atividade.setUsuario_origem_id(rs.getString("usuario_origem_id")); atividade.setUsuario_destino_id(rs.getString("usuario_destino_id")); atividade.setGrupo_origem_id(rs.getString("grupo_origem_id")); atividade.setGrupo_destino_id(rs.getString("grupo_destino_id")); atividade.setCreated_at(rs.getString("created_at")); atividade.setPrazo(rs.getString("prazo")); atividade.setConclusao(rs.getString("conclusao")); atividade.setCiente(rs.getString("ciente")); atividades.add(atividade); } }catch (Exception e) { e.printStackTrace(); } return atividades; } public ArrayList<BeanUsuarios> retornaUsuarios(){ Banco b = new Banco(); ArrayList<BeanUsuarios> usuarios = new ArrayList<BeanUsuarios>(); String query = "SELECT * FROM USUARIOS"; try{ PreparedStatement st = b.getConnection().prepareStatement(query); ResultSet rs = st.executeQuery(); while(rs.next()){ BeanUsuarios usuario = new BeanUsuarios(); usuario.setId(rs.getString("id")); usuario.setNome(rs.getString("nome")); usuario.setLogin(rs.getString("login")); usuario.setSenha(rs.getString("senha")); usuario.setEmail(rs.getString("email")); usuario.setCreated_at(rs.getString("created_at")); usuario.setHabilitado(rs.getString("habilitado"));
usuarios.add(usuario); } }catch (Exception e) { e.printStackTrace(); } return usuarios; } public ArrayList<BeanUsuarios> retornaUsuariosDoGrupo(int id_grupo){ Banco b = new Banco(); ArrayList<BeanUsuarios> usuarios = new ArrayList<BeanUsuarios>(); String query = "SELECT USUARIOS.ID,USUARIOS.NOME,USUARIOS.LOGIN,USUARIOS.SENHA,USUARIOS.EMAIL,USUARIOS.CREATED_AT,USUARIOS.HABILITADO "+ " FROM USUARIOS,GRUPOS_USUARIOS WHERE (USUARIOS.ID = GRUPOS_USUARIOS.USUARIO_ID) AND (GRUPOS_USUARIOS.GRUPO_ID = ?)"; try{ PreparedStatement st = b.getConnection().prepareStatement(query); st.setInt(1, id_grupo); ResultSet rs = st.executeQuery(); while(rs.next()){ BeanUsuarios usuario = new BeanUsuarios(); usuario.setId(rs.getString("id")); usuario.setNome(rs.getString("nome")); usuario.setLogin(rs.getString("login")); usuario.setSenha(rs.getString("senha")); usuario.setEmail(rs.getString("email")); usuario.setCreated_at(rs.getString("created_at")); usuario.setHabilitado(rs.getString("habilitado")); usuarios.add(usuario); } }catch (Exception e) { e.printStackTrace(); } return usuarios; } public BeanUsuarios retornaUsuario(int id){ Banco b = new Banco(); String query = "SELECT * FROM USUARIOS WHERE USUARIOS.ID = ?"; BeanUsuarios usuario = new BeanUsuarios(); try{ PreparedStatement st = b.getConnection().prepareStatement(query); st.setInt(1, id); ResultSet rs = st.executeQuery(); if(rs.next()){ usuario.setId(rs.getString("id")); usuario.setNome(rs.getString("nome")); usuario.setLogin(rs.getString("login")); usuario.setSenha(rs.getString("senha")); usuario.setEmail(rs.getString("email")); usuario.setCreated_at(rs.getString("created_at")); usuario.setHabilitado(rs.getString("habilitado")); } }catch (Exception e) { e.printStackTrace(); } return usuario; } public BeanGrupos retornaGrupo(int id){
Banco b = new Banco(); String query = "SELECT * FROM GRUPOS WHERE GRUPOS.ID = ?"; BeanGrupos grupo = new BeanGrupos(); try{ PreparedStatement st = b.getConnection().prepareStatement(query); st.setInt(1, id); ResultSet rs = st.executeQuery(); if(rs.next()){ grupo.setId(rs.getString("id")); grupo.setUsuario_id(rs.getString("usuario_id")); grupo.setDescricao(rs.getString("descricao")); } }catch (Exception e) { e.printStackTrace(); } return grupo; } public BeanGrupos retornaGrupoDoUsuario(int id_usuario){ Banco b = new Banco(); String query = "SELECT FIRST 1 GRUPOS.ID,GRUPOS.USUARIO_ID,GRUPOS.DESCRICAO FROM GRUPOS_USUARIOS,GRUPOS WHERE (GRUPOS.ID = GRUPOS_USUARIOS.GRUPO_ID) AND (GRUPOS_USUARIOS.USUARIO_ID = ?)"; BeanGrupos grupo = new BeanGrupos(); try{ PreparedStatement st = b.getConnection().prepareStatement(query); st.setInt(1, id_usuario); ResultSet rs = st.executeQuery(); if(rs.next()){ grupo.setId(rs.getString("id")); grupo.setUsuario_id(rs.getString("usuario_id")); grupo.setDescricao(rs.getString("descricao")); } }catch (Exception e) { e.printStackTrace(); } return grupo; } public BeanUsuarios retornaUsuario(String login, String senha){ Banco b = new Banco(); String query = "SELECT * FROM USUARIOS WHERE (USUARIOS.LOGIN = ?) AND (USUARIOS.SENHA = ?)"; BeanUsuarios usuario = new BeanUsuarios(); try{ PreparedStatement st = b.getConnection().prepareStatement(query); st.setString(1, login); st.setString(2, senha); ResultSet rs = st.executeQuery(); if(rs.next()){ usuario.setId(rs.getString("id")); usuario.setNome(rs.getString("nome")); usuario.setLogin(rs.getString("login")); usuario.setSenha(rs.getString("senha")); usuario.setEmail(rs.getString("email")); usuario.setCreated_at(rs.getString("created_at")); usuario.setHabilitado(rs.getString("habilitado")); } }catch (Exception e) {
e.printStackTrace(); } return usuario; } public boolean UsuarioValidar(String login, String senha){ Banco b = new Banco(); String query = "SELECT USUARIOS.ID FROM USUARIOS WHERE (USUARIOS.LOGIN = ?) AND (USUARIOS.SENHA = ?)"; boolean retorno = false; try{ PreparedStatement st = b.getConnection().prepareStatement(query); st.setString(1, login); st.setString(2, senha); ResultSet rs = st.executeQuery(); retorno = rs.next(); }catch (Exception e) { e.printStackTrace(); } return retorno; } public ArrayList<BeanGrupos> retornaGrupos(){ Banco b = new Banco(); ArrayList<BeanGrupos> grupos = new ArrayList<BeanGrupos>(); String query = "SELECT * FROM GRUPOS"; try{ PreparedStatement st = b.getConnection().prepareStatement(query); ResultSet rs = st.executeQuery(); while(rs.next()){ BeanGrupos grupo = new BeanGrupos(); grupo.setId(rs.getString("id")); grupo.setUsuario_id(rs.getString("usuario_id")); grupo.setDescricao(rs.getString("descricao")); grupos.add(grupo); } }catch (Exception e) { e.printStackTrace(); } return grupos; } public void salvarUsuario(BeanUsuarios usuario){ try{ String sql = "INSERT INTO USUARIOS(NOME,LOGIN,SENHA,EMAIL,CREATED_AT,HABILITADO)VALUES(?,?,?,?,?,?)"; PreparedStatement pst = new Banco().getConnection().prepareStatement(sql); pst.setString(1, usuario.getNome()); pst.setString(2, usuario.getLogin()); pst.setString(3, usuario.getSenha()); pst.setString(4, usuario.getEmail()); pst.setDate(5, Util.converteEmDate2(usuario.getCreated_at())); pst.setString(6, usuario.getHabilitado()); pst.executeUpdate(); }catch (Exception e) { e.printStackTrace(); } } public void atualizarUsuario(BeanUsuarios usuario){ try{ String sql = "UPDATE USUARIOS SET NOME = ?,SENHA = ?,EMAIL = ? WHERE (USUARIOS.ID = ?)";
PreparedStatement pst = new Banco().getConnection().prepareStatement(sql); pst.setString(1, usuario.getNome()); pst.setString(2, usuario.getSenha()); pst.setString(3, usuario.getEmail()); pst.setInt(4, Integer.parseInt(usuario.getId())); pst.executeUpdate(); }catch (Exception e) { e.printStackTrace(); } } public void salvarGrupo(BeanGrupos grupo){ try{ String sql = "INSERT INTO GRUPOS(USUARIO_ID,DESCRICAO)VALUES(?,?)"; PreparedStatement pst = new Banco().getConnection().prepareStatement(sql); pst.setInt(1, Integer.parseInt(grupo.getUsuario_id())); pst.setString(2, grupo.getDescricao()); pst.executeUpdate(); }catch (Exception e) { e.printStackTrace(); } } public void salvarAtividade(BeanAtividades atividade){ try{ String sql = "INSERT INTO ATIVIDADES(DESCRICAO,OBS,USUARIO_ORIGEM_ID,USUARIO_DESTINO_ID,GRUPO_ORIGEM_ID," + "GRUPO_DESTINO_ID,CREATED_AT,PRAZO)" + "VALUES(?,?,?,?,?,?,?,?)"; PreparedStatement pst = new Banco().getConnection().prepareStatement(sql); pst.setString(1, atividade.getDescricao()); pst.setString(2, atividade.getObs()); pst.setInt(3, Integer.parseInt(atividade.getUsuario_origem_id())); pst.setInt(4, Integer.parseInt(atividade.getUsuario_destino_id())); pst.setInt(5, Integer.parseInt(atividade.getGrupo_origem_id())); BeanUsuarios usuario = this.retornaUsuario(Integer.parseInt(atividade.getUsuario_destino_id())); pst.setInt(6, Integer.parseInt(usuario.retornaGrupoDoUsuario().getId())); java.util.Date date = new java.util.Date(); java.sql.Date date2 = new java.sql.Date(date.getTime()); pst.setDate(7, date2); pst.setDate(8, Util.converteEmDate2(atividade.getPrazo())); pst.executeUpdate(); }catch (Exception e) { e.printStackTrace(); } } public void AtividadeConcluida(int id){ try{ String sql = "UPDATE ATIVIDADES SET CONCLUSAO = ? WHERE (ATIVIDADES.ID = ?)"; PreparedStatement pst = new Banco().getConnection().prepareStatement(sql); java.util.Date date = new java.util.Date(); java.sql.Date date2 = new java.sql.Date(date.getTime()); pst.setDate(1, date2); pst.setInt(2, id); pst.executeUpdate(); }catch (Exception e) { e.printStackTrace(); } } public void AtividadeCiente(int id){ try{ String sql = "UPDATE ATIVIDADES SET CIENTE = ? WHERE (ATIVIDADES.ID = ?)"; PreparedStatement pst = new Banco().getConnection().prepareStatement(sql); java.util.Date date = new java.util.Date(); java.sql.Date date2 = new java.sql.Date(date.getTime()); pst.setDate(1, date2); pst.setInt(2, id); pst.executeUpdate(); }catch (Exception e) { e.printStackTrace(); } } public void adicionaUsuarioNoGrupo(BeanUsuarios usuario,BeanGrupos grupo){ try{ String sql = "INSERT INTO GRUPOS_USUARIOS(GRUPO_ID,USUARIO_ID)VALUES(?,?)";
PreparedStatement pst = new Banco().getConnection().prepareStatement(sql); pst.setInt(1, Integer.parseInt(grupo.getId())); pst.setInt(2, Integer.parseInt(usuario.getId())); pst.executeUpdate(); }catch (Exception e) { e.printStackTrace(); } } } package atividades.struts.beans; import java.io.Serializable; import atividades.struts.model.Model; public class BeanAtividades implements Serializable{ private static final long serialVersionUID = 1L; private String id; private String descricao; private String obs; private String usuario_origem_id; private String usuario_destino_id; private String grupo_origem_id; private String grupo_destino_id; private String created_at; private String prazo; private String conclusao; private String ciente; public String getCiente() { return ciente; } public void setCiente(String ciente) { this.ciente = ciente; } public String getConclusao() { return conclusao; } public void setConclusao(String conclusao) { this.conclusao = conclusao; } public String getCreated_at() { return created_at; } public void setCreated_at(String created_at) { this.created_at = created_at; } public String getDescricao() { return descricao; } public void setDescricao(String descricao) { this.descricao = descricao; } public String getGrupo_destino_id() { return grupo_destino_id; } public void setGrupo_destino_id(String grupo_destino_id) { this.grupo_destino_id = grupo_destino_id; } public String getGrupo_origem_id() { return grupo_origem_id; } public void setGrupo_origem_id(String grupo_origem_id) { this.grupo_origem_id = grupo_origem_id; } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getObs() { return obs; } public void setObs(String obs) {
this.obs = obs; } public String getPrazo() { return prazo; } public void setPrazo(String prazo) { this.prazo = prazo; } public String getUsuario_destino_id() { return usuario_destino_id; } public void setUsuario_destino_id(String usuario_destino_id) { this.usuario_destino_id = usuario_destino_id; } public String getUsuario_origem_id() { return usuario_origem_id; } public void setUsuario_origem_id(String usuario_origem_id) { this.usuario_origem_id = usuario_origem_id; } public BeanUsuarios getUsuarioOrigem(){ return (new Model()).retornaUsuario(Integer.parseInt(this.usuario_origem_id)); } public BeanUsuarios getUsuarioDestino(){ return (new Model()).retornaUsuario(Integer.parseInt(this.usuario_destino_id)); } public BeanGrupos getGrupoOrigem(){ return (new Model()).retornaGrupo(Integer.parseInt(this.grupo_origem_id)); } public BeanGrupos getGrupoDestino(){ return (new Model()).retornaGrupo(Integer.parseInt(this.grupo_destino_id)); } public boolean SeConcluida(){ return (new Model()).retornaSeAtividadeConcluida_(Integer.parseInt(this.id)); } public boolean SeCiente(){ return (new Model()).retornaSeAtividadeCiente_(Integer.parseInt(this.id)); } public String getUsuario_destino_string() { BeanUsuarios usuario = (new Model()).retornaUsuario(Integer.parseInt(this.usuario_destino_id)); return usuario.getNome(); } public String getUsuario_origem_string() { BeanUsuarios usuario = (new Model()).retornaUsuario(Integer.parseInt(this.usuario_origem_id)); return usuario.getNome(); } public String getPrazo_string(){ String retorno = ""; if(this.conclusao != null) if(this.prazo.trim().length() != 0){ retorno = DateF(this.prazo); } return retorno; } public String getConclusao_string(){ String retorno = ""; if(this.conclusao != null) if(this.conclusao.trim().length() != 0){ retorno = DateF(this.conclusao); } return retorno; } public String getCiente_string(){ String retorno = ""; try{ if(this.conclusao != null) if(this.ciente.trim().length() == 21){ retorno = DateF(this.ciente); }else{ retorno = ""; } return retorno; }catch (Exception e) {
e.printStackTrace(); } return retorno; } public String getCreated_at_string(){ String retorno = ""; if(this.created_at.trim().length() != 0){ retorno = DateF(this.created_at); } return retorno; } private String DateF(String date){ String retorno; try{ if(date == null){ retorno = ""; }else{ retorno = date.substring(8,10) + "/" + date.substring(5,7)+ "/" + date.substring(0,4); } }catch (Exception e) { retorno = ""; } return retorno; } } package atividades.struts.beans; import java.io.Serializable; import atividades.struts.model.Model; public class BeanUsuarios implements Serializable{ private static final long serialVersionUID = 1L; private String id; private String nome; private String login; private String senha; private String email; private String created_at; private String habilitado; public String getCreated_at() { return created_at; } public void setCreated_at(String created_at) { this.created_at = created_at; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } public String getHabilitado() { return habilitado; } public void setHabilitado(String habilitado) { this.habilitado = habilitado; } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getLogin() { return login; } public void setLogin(String login) { this.login = login; }
public String getNome() { return nome; } public void setNome(String nome) { this.nome = nome; } public String getSenha() { return senha; } public void setSenha(String senha) { this.senha = senha; } public BeanGrupos retornaGrupoDoUsuario(){ return (new Model()).retornaGrupoDoUsuario(Integer.parseInt(this.id)); } } package atividades.struts.beans; import java.io.Serializable; import java.util.ArrayList; import atividades.struts.model.Model; public class BeanGrupos implements Serializable{ private static final long serialVersionUID = 1L; private String id; private String usuario_id; private String descricao; public String getDescricao() { return descricao; } public void setDescricao(String descricao) { this.descricao = descricao; } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getUsuario_id() { return usuario_id; } public void setUsuario_id(String usuario_id) { this.usuario_id = usuario_id; } public BeanUsuarios getUsuarioDono(){ return (new Model()).retornaUsuario(Integer.parseInt(this.usuario_id)); } public ArrayList<BeanUsuarios> getUsuariosDoGrupo(){ return (new Model()).retornaUsuariosDoGrupo(Integer.parseInt(this.id)); } } package atividades.struts.action; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.struts.action.Action; import org.apache.struts.action.ActionForm; import org.apache.struts.action.ActionForward; import org.apache.struts.action.ActionMapping; import atividades.struts.beans.BeanAtividades; import atividades.struts.beans.BeanUsuarios; import atividades.struts.model.Model;
public class ActionVisualizarAtividade extends Action { public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { String id = (String)request.getParameter("id"); Model model = new Model(); BeanUsuarios usuario = (BeanUsuarios)request.getSession().getAttribute("user"); BeanAtividades atividade = model.retornaAtividade(Integer.parseInt(id)); request.setAttribute("ativ",atividade); if (atividade.getUsuario_origem_id().equals(usuario.getId()) && atividade.SeConcluida() && !atividade.SeCiente()){ request.setAttribute("botaociente", "botaociente"); }else{ request.removeAttribute("botaociente"); } if (atividade.getUsuario_destino_id().equals(usuario.getId()) && !atividade.SeConcluida()){ request.setAttribute("botaoconcluir", "botaoconcluir"); }else{ request.removeAttribute("botaoconcluir"); } return mapping.findForward("visualizaratividadejsp"); } } package atividades.struts.action; import java.util.ArrayList; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.struts.action.Action; import org.apache.struts.action.ActionForm; import org.apache.struts.action.ActionForward; import org.apache.struts.action.ActionMapping; import atividades.struts.beans.BeanUsuarios; import atividades.struts.model.Model; public class ActionNovaAtividade extends Action { public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { BeanUsuarios usuario = (BeanUsuarios)request.getSession().getAttribute("user"); Model model = new Model(); if (usuario == null){ return mapping.findForward("errojsp"); } ArrayList<BeanUsuarios> ug = model.retornaUsuariosDoGrupo(Integer.parseInt(usuario.retornaGrupoDoUsuario().getId())); request.getSession().setAttribute("ug",ug); return mapping.findForward("cadastroatividadejsp"); } } package atividades.struts.action; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.struts.action.Action; import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward; import org.apache.struts.action.ActionMapping; public class ActionLogoff extends Action { public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception{ request.getSession().invalidate(); return mapping.findForward("loginjsp"); } } package atividades.struts.action; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.struts.action.Action; import org.apache.struts.action.ActionForm; import org.apache.struts.action.ActionForward; import org.apache.struts.action.ActionMapping; import atividades.struts.beans.BeanUsuarios; import atividades.struts.form.FormUsuarios; import atividades.struts.model.Model; public final class ActionLogin extends Action{ public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception{ FormUsuarios formusuario = (FormUsuarios)form; Model model = new Model(); try{ if (model.UsuarioValidar(formusuario.getLogin(), formusuario.getSenha())){ BeanUsuarios usuario = model.retornaUsuario(formusuario.getLogin(), formusuario.getSenha()); request.getSession().setAttribute("grupo",model.retornaGrupoDoUsuario(Integer.parseInt(usuario.getId()))); request.getSession().setAttribute("user",usuario); return mapping.findForward("menujsp"); } else{ return mapping.findForward("loginjsp"); } }catch (Exception e) { return mapping.findForward("errojsp"); } } } package atividades.struts.action; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.commons.beanutils.BeanUtils; import org.apache.struts.action.Action; import org.apache.struts.action.ActionForm; import org.apache.struts.action.ActionForward; import org.apache.struts.action.ActionMapping; import atividades.struts.beans.BeanUsuarios; import atividades.struts.form.FormUsuarios; import atividades.struts.model.Model; public class ActionEditarUsuario extends Action { public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { FormUsuarios formUsuarios = (FormUsuarios)form;
Model model = new Model(); if(formUsuarios.getNome().equals("")){ request.getSession().setAttribute("mensagem_login", "login invalido..."); return mapping.findForward("editarusuariojsp"); } if(formUsuarios.getEmail().equals("")){ request.getSession().setAttribute("mensagem_login", "email invalido..."); return mapping.findForward("editarusuariojsp"); } if(formUsuarios.getSenha().equals("")){ request.getSession().setAttribute("mensagem_login", "senha invalida..."); return mapping.findForward("editarusuariojsp"); } BeanUsuarios usuario = new BeanUsuarios(); BeanUtils.copyProperties(usuario, formUsuarios); try { model.atualizarUsuario(usuario); } catch (Exception e) { e.printStackTrace(); return mapping.findForward("errojsp"); } return mapping.findForward("editarusuariojsp"); } } package atividades.struts.action; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.commons.beanutils.BeanUtils; import org.apache.struts.action.Action; import org.apache.struts.action.ActionForm; import org.apache.struts.action.ActionForward; import org.apache.struts.action.ActionMapping; import atividades.struts.beans.BeanAtividades; import atividades.struts.beans.BeanUsuarios; import atividades.struts.form.FormAtividades; import atividades.struts.model.Model; public class ActionCadastroAtividade extends Action { public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception{ FormAtividades formAtividade = (FormAtividades)form; BeanAtividades atividade = new BeanAtividades(); BeanUtils.copyProperties(atividade, formAtividade); Model model = new Model(); BeanUsuarios usuario = (BeanUsuarios)request.getSession().getAttribute("user"); atividade.setUsuario_origem_id(usuario.getId()); atividade.setGrupo_origem_id(usuario.retornaGrupoDoUsuario().getId()); if (atividade.getDescricao().equals("") || atividade.getPrazo().equals("")){ return mapping.findForward("actNovaAtividade"); } if (usuario == null){ return mapping.findForward("errojsp"); } try{ model.salvarAtividade(atividade); formAtividade.reset(); return mapping.findForward("enviadasucessojsp"); }catch (Exception e) { e.printStackTrace();
return mapping.findForward("errojsp"); } } } package atividades.struts.action; import java.util.ArrayList; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.struts.action.ActionForm; import org.apache.struts.action.ActionForward; import org.apache.struts.action.ActionMapping; import org.apache.struts.actions.DispatchAction; import atividades.struts.beans.BeanAtividades; import atividades.struts.beans.BeanUsuarios; import atividades.struts.model.Model; public class ActionAtividades extends DispatchAction { public ActionForward enviadas(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { BeanUsuarios usuario = (BeanUsuarios)request.getSession().getAttribute("user"); if (usuario == null){ return mapping.findForward("errojsp"); } request.setAttribute("label", "Enviadas"); Model model = new Model(); ArrayList<BeanAtividades> lista_atividade_enviadas = model.retornaAtividadesEnviadas(usuario); request.getSession().setAttribute("ativ",lista_atividade_enviadas); return mapping.findForward("listaatividadesjsp"); } public ActionForward recebidas(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { BeanUsuarios usuario = (BeanUsuarios)request.getSession().getAttribute("user"); if (usuario == null){ return mapping.findForward("errojsp"); } request.setAttribute("label", "Recebidas"); Model model = new Model(); ArrayList<BeanAtividades> lista_atividade_enviadas = model.retornaAtividadesRecebidas(usuario); request.getSession().setAttribute("ativ",lista_atividade_enviadas ); return mapping.findForward("listaatividadesjsp"); } public ActionForward concluidas(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { BeanUsuarios usuario = (BeanUsuarios)request.getSession().getAttribute("user"); if (usuario == null){ return mapping.findForward("errojsp"); } request.setAttribute("label", "Concluidas"); Model model = new Model(); ArrayList<BeanAtividades> lista_atividade = model.retornaAtividadesRecebidasConcluidas(usuario); request.getSession().setAttribute("ativ",lista_atividade );
return mapping.findForward("listaatividadesjsp"); } public ActionForward encerradas(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { BeanUsuarios usuario = (BeanUsuarios)request.getSession().getAttribute("user"); if (usuario == null){ return mapping.findForward("errojsp"); } request.setAttribute("label", "Encerradas"); Model model = new Model(); ArrayList<BeanAtividades> lista_atividade = model.retornaAtividadesRecebidasEnceradas(usuario); request.getSession().setAttribute("ativ",lista_atividade); return mapping.findForward("listaatividadesjsp"); } public ActionForward concluir(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { BeanUsuarios usuario = (BeanUsuarios)request.getSession().getAttribute("user"); String id = (String)request.getParameter("id"); Model model = new Model(); if (usuario == null){ return mapping.findForward("errojsp"); }else{ try{ model.AtividadeConcluida(Integer.parseInt(id)); }catch(Exception e){ System.out.print(e.getMessage()); } } ArrayList<BeanAtividades> lista_atividade = model.retornaAtividadesRecebidasConcluidas(usuario); request.getSession().setAttribute("ativ",lista_atividade ); return mapping.findForward("listaatividadesjsp"); } public ActionForward ciente(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { BeanUsuarios usuario = (BeanUsuarios)request.getSession().getAttribute("user"); String id = (String)request.getParameter("id"); Model model = new Model(); if (usuario == null){ return mapping.findForward("errojsp"); }else{ try{ model.AtividadeCiente(Integer.parseInt(id)); }catch(Exception e){ System.out.print(e.getMessage()); } } ArrayList<BeanAtividades> lista_atividade = model.retornaAtividadesEnviadasEnceradas(usuario); request.getSession().setAttribute("ativ",lista_atividade ); return mapping.findForward("listaatividadesjsp"); } } package atividades.struts.form;
import java.io.Serializable; import org.apache.struts.action.ActionForm; public class FormUsuarios extends ActionForm implements Serializable{ private static final long serialVersionUID = 1L; private String id; private String nome; private String login; private String senha; private String email; private String created_at; private String habilitado; public String getCreated_at() { return created_at; } public void setCreated_at(String created_at) { this.created_at = created_at; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } public String getHabilitado() { return habilitado; } public void setHabilitado(String habilitado) { this.habilitado = habilitado; } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getLogin() { return login; } public void setLogin(String login) { this.login = login; } public String getNome() { return nome; } public void setNome(String nome) { this.nome = nome; } public String getSenha() { return senha; } public void setSenha(String senha) { this.senha = senha; } } package atividades.struts.form; import java.io.Serializable; import org.apache.struts.action.ActionForm; public class FormAtividades extends ActionForm implements Serializable{ private static final long serialVersionUID = 1L; private String id; private String descricao; private String obs; private String usuario_origem_id;
private String usuario_destino_id; private String grupo_origem_id; private String grupo_destino_id; private String created_at; private String prazo; private String conclusao; private String ciente; public String getCiente() { return ciente; } public void setCiente(String ciente) { this.ciente = ciente; } public String getConclusao() { return conclusao; } public void setConclusao(String conclusao) { this.conclusao = conclusao; } public String getCreated_at() { return created_at; } public void setCreated_at(String created_at) { this.created_at = created_at; } public String getDescricao() { return descricao; } public void setDescricao(String descricao) { this.descricao = descricao; } public String getGrupo_destino_id() { return grupo_destino_id; } public void setGrupo_destino_id(String grupo_destino_id) { this.grupo_destino_id = grupo_destino_id; } public String getGrupo_origem_id() { return grupo_origem_id; } public void setGrupo_origem_id(String grupo_origem_id) { this.grupo_origem_id = grupo_origem_id; } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getObs() { return obs; } public void setObs(String obs) { this.obs = obs; } public String getPrazo() { return prazo; } public void setPrazo(String prazo) { this.prazo = prazo; } public String getUsuario_destino_id() { return usuario_destino_id; } public void setUsuario_destino_id(String usuario_destino_id) { this.usuario_destino_id = usuario_destino_id; } public String getUsuario_origem_id() { return usuario_origem_id; } public void setUsuario_origem_id(String usuario_origem_id) { this.usuario_origem_id = usuario_origem_id; } public String getPrazo_string() { return DateF(this.prazo); }
//ciente_string public String getCiente_string() { return DateF(this.ciente); } public String getConclusao_string() { return DateF(this.conclusao); } private String DateF(String date){ return date.substring(8,10) + "/" + date.substring(5,7)+ "/" + date.substring(0,4); } public void reset(){ this.id = ""; this.descricao = ""; this.obs = ""; this.usuario_origem_id = ""; this.usuario_destino_id = ""; this.grupo_origem_id = ""; this.grupo_destino_id = ""; this.created_at = ""; this.prazo = ""; this.conclusao = ""; this.ciente = ""; } }
Páginas JSP <%@ taglib uri="/tags/struts-bean" prefix="bean" %> <%@ taglib uri="/tags/struts-logic" prefix="logic" %> <%@ taglib uri="/tags/struts-html" prefix="html" %> <%@ taglib uri="/tags/struts-nested" prefix="nested" %> <%@ page import="java.util.*"%> <%@ page import="java.text.*"%> <%@ page import="java.text.SimpleDateFormat"%> <html:html> <head> <title>Visualizar Atividade</title> <style type="text/css"> <jsp:include page="css.css"/> </style> </head> <body marginheight="0" marginwidth="0" vlink="#000000" alink="#000000" link="#000000"> <table align="center" width="480" bgcolor="#FFFFFF"> <tr> <th colspan="2" bgcolor="#000000"> <font color="#FFFFFF" >Visualizar Atividade</font> </th> </tr> <tr> <td width="30%" bgcolor="#FFF974"> Usuário Origem </td> <td width="*"> <bean:write name="ativ" property="usuario_origem_string"/> </td> </tr> <tr> <td bgcolor="#FFF974"> Data de Envio </td> <td> <bean:write name="ativ" property="created_at_string"/> </td> </tr> <tr> <td bgcolor="#FFF974"> Prazo </td> <td> <bean:write name="ativ" property="prazo_string"/> </td> </tr> <tr> <td bgcolor="#FFF974"> Usuário Destino </td> <td> <bean:write name="ativ" property="usuario_destino_string" /> </td> </tr> <tr> <td valign="top" bgcolor="#FFF974"> Descrição </td> <td valign="top"> <bean:write name="ativ" property="descricao"/> </td> </tr> <tr> <td valign="top" bgcolor="#FFF974"> Observações Adicionais </td> <td valign="top"> <bean:write name="ativ" property="obs"/>
</td> </tr> <logic:present name="botaoconcluir"> <tr> <td colspan="2"> <a href="actAtividadesEnviadas.do?acao=concluir&id=<bean:write name="ativ" property="id"/>" target="principal">Concluir</a> </td> </tr> </logic:present> <logic:present name="botaociente"> <tr> <td colspan="2"> <a href="actAtividadesEnviadas.do?acao=ciente&id=<bean:write name="ativ" property="id"/>" target="principal">Ficar ciênte da conclusão da atividade</a> </td> </tr> </logic:present> <logic:present name="respenvio"> <logic:notPresent name="naoconcluida"> <logic:notPresent name="naociente"> <tr> <td> Status </td> <td> Atividade já concluida e ciente </td> </tr> </logic:notPresent> </logic:notPresent> </logic:present> <tr> <td colspan="2" align="center"> <a href="javascript:history.go(-1)" target="principal">Voltar</a> </td> </tr> </table> </body> </html:html> <%@ taglib uri="/tags/struts-bean" prefix="bean" %> <%@ taglib uri="/tags/struts-logic" prefix="logic" %> <%@ taglib uri="/tags/struts-html" prefix="html" %> <%@ taglib uri="/tags/struts-nested" prefix="nested" %> <link href="stylesheets/scaffold.css" media="screen" rel="Stylesheet" type="text/css" /> <logic:present name="user"> <logic:redirect forward="menujsp"/> </logic:present> <!-- Teste --> <html:html> <head> <title> Sistema de Atividades </title> </head> <body class="login" > <html:form action="actLogin" focus="login"> <table class="login" align="center" border="0" width="790" bgcolor="#FFF974" cellpadding="0" cellspacing="0" bordercolor="#FFF974"> <tr> <td colspan="2"> <img src="paginas/imagens/top.jpg">
</td> </tr> <tr> <td> <table align="left" class="login"> <tr> <td> <label><b>login<b></label><br> <html:text property="login" style="background-color:e3e3e3; border: 1px solid #666666; font-size:8pt; color: #000099" /> <br> <label><b>senha</b></label><br> <html:password property="senha" style="background-color:e3e3e3; border: 1px solid #666666; font-size:8pt; color: #000099" /> <br> <html:submit value="Entrar" style="background-color:e3e3e3; border: 1px solid #666666; font-size:8pt; color: #000099" /> </td> </tr> </table> </td> <td> <img src="paginas/imagens/banner.jpg"> </td> </tr> </table> </html:form> </html:html> <%@ taglib uri="/tags/struts-bean" prefix="bean" %> <%@ taglib uri="/tags/struts-logic" prefix="logic" %> <%@ taglib uri="/tags/struts-html" prefix="html" %> <%@ taglib uri="/tags/struts-nested" prefix="nested" %> <html:html> <head> <link href="/stylesheets/scaffold.css?1182910814" media="screen" rel="Stylesheet" type="text/css" /> <style type="text/css"> body { scrollbar-arrow-color:#FFF974; scrollbar-3dlight-color:#FFF974; scrollbar-highlight-color:#FFF974; scrollbar-face-color:#000000; scrollbar-shadow-color:#FFF974; scrollbar-darkshadow-color:#FFF974; scrollbar-track-color:#FFF974; } </style> </head> <logic:notPresent name="user"> <logic:redirect forward="erro"/> </logic:notPresent> <body marginheight="0" bgcolor="#FFF974" vlink="#000000" alink="#000000" link="#000000" marginwidth="0" onload="carregarPopup();"> <table width="580" border="0" align="center" bgcolor="#FFFFFF"> <tr> <th colspan="5" bgcolor="#000000" > <font color="#FFFFFF"> Lista de Atividades <logic:present name="label"> <bean:write name="label"/> </logic:present> </font> </th> </tr> <tr bgcolor="#FFF974"> <th width="30%"> Descrição </th> <logic:equal value="Enviadas" name="label">
<th width="20%" > Usuário Destino </th> </logic:equal> <logic:equal value="Encerradas" name="label"> <th width="20%"> Usuário Destino </th> </logic:equal> <logic:equal value="Recebidas" name="label"> <th width="20%"> Usuário Origem </th> </logic:equal> <th width="15%"> Prazo </th> <th width="15%"> ConcluÃ-do </th> <logic:notEqual value="Enviadas" name="label"> <th width="15%"> Ciente </th> </logic:notEqual> </tr> <logic:notEmpty name="ativ"> <logic:iterate id="bean" name="ativ"> <tr> <td valign="top" align="center"> <a href="actViewAtividade.do?id=<bean:write name="bean" property="id"/>"><bean:write name="bean" property="descricao"/></a> </td> <logic:equal value="Enviadas" name="label"> <td valign="top" align="center"> <bean:write name="bean" property="usuario_destino_string"/> </td> </logic:equal> <logic:equal value="Encerradas" name="label"> <td valign="top" align="center"> <bean:write name="bean" property="usuario_destino_string"/> </td> </logic:equal> <logic:equal value="Recebidas" name="label"> <td valign="top" align="center"> <bean:write name="bean" property="usuario_origem_string"/> </td> </logic:equal> <td valign="top" align="center"> <bean:write name="bean" property="prazo_string"/> </td> <td valign="top" align="center"> <bean:write name="bean" property="conclusao_string"/> </td> <logic:notEqual value="Enviadas" name="label"> <td valign="top" align="center"> <bean:write name="bean" property="ciente_string"/> </td> </logic:notEqual> </tr> </logic:iterate> </logic:notEmpty> <logic:empty name="ativ"> <tr> <td colspan="5" align="center"> Não há atividades <logic:present name="label"> <bean:write name="label"/> </logic:present> </td> </tr> </logic:empty> </table> </body> </html:html>
<%@ page contentType="text/html; charset=UTF-8" %> <%@ taglib uri="/tags/struts-bean" prefix="bean" %> <%@ taglib uri="/tags/struts-logic" prefix="logic" %> <%@ taglib uri="/tags/struts-html" prefix="html" %> <%@ taglib uri="/tags/struts-nested" prefix="nested" %> <html:html> <head> <meta http-equiv="content-type" content="text/html; charset=UTF-8"> <title>Erro no aplicativo</title> </head> <body> <center> <font size="4" face="verdana"> Sua Seção foi Encerrada<br> Por favor para ter acesso novamente<br> Clique no link sair do sistema e entre novamente. </font> </center> </body> </html:html> <%@ page contentType="text/html; charset=UTF-8" %> <%@ taglib uri="/tags/struts-bean" prefix="bean" %> <%@ taglib uri="/tags/struts-logic" prefix="logic" %> <%@ taglib uri="/tags/struts-html" prefix="html" %> <%@ taglib uri="/tags/struts-nested" prefix="nested" %> <html:html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/> <title>Sistema de Controle de Atividades</title> </head> <body> <center> <font size="3" style="background-color:e3e3e3; border: 1px solid #666666; font-size:23pt; color: #000099" > Atividade Enviada com Sucesso! </font> </center> </body> </html:html> <%@ taglib uri="/tags/struts-bean" prefix="bean" %> <%@ taglib uri="/tags/struts-logic" prefix="logic" %> <%@ taglib uri="/tags/struts-html" prefix="html" %> <%@ taglib uri="/tags/struts-nested" prefix="nested" %> <html:html> <head> <title></title> <style type="text/css"> <jsp:include page="css.css"/> </style> </head> <logic:notPresent name="user"> <logic:redirect forward="errojsp"/> </logic:notPresent> <body> <html:form action="actEditarUsuario"> <table align="center" bgcolor="#FFFFFF"> <input type="hidden" value="<bean:write name="user" property="id"/>" name="id"> <tr> <th colspan="2" bgcolor="#000000"> <font color="#FFFFFF" > Dados do Usuário </font> </th> </tr> <tr> <td> Login </td> <td>
<bean:write name="user" property="login"/> <input type="hidden" name="login" value="<bean:write name="user" property="login"/>" size="40"> </td> </tr> <tr> <td> Nome </td> <td> <input type="text" name="nome" value="<bean:write name="user" property="nome"/>" style="background-color:e3e3e3; border: 1px solid #666666; font-size:8pt; color: #000099" /> </td> </tr> <tr> <td> Senha </td> <td> <input type="password" name="senha" value="<bean:write name="user" property="senha"/>" size="40" style="background-color:e3e3e3; border: 1px solid #666666; font-size:8pt; color: #000099" /> </td> </tr> <tr> <td> E-mail </td> <td> <input type="text" name="email" value="<bean:write name="user" property="email"/>" size="40" style="background-color:e3e3e3; border: 1px solid #666666; font-size:8pt; color: #000099" /> </td> </tr> <tr> <td > <html:submit value="Salvar" style="background-color:e3e3e3; border: 1px solid #666666; font-size:8pt; color: #000099" /> </td> <logic:present name="mensagem_login"> <td bgcolor="red"> <bean:write name="mensagem_login" /> </td> </logic:present> </tr> </table> </html:form> </body> </html:html> <%@ page contentType="text/html; charset=UTF-8" %> <%@ taglib uri="/tags/struts-bean" prefix="bean" %> <%@ taglib uri="/tags/struts-logic" prefix="logic" %> <%@ taglib uri="/tags/struts-html" prefix="html" %> <%@ taglib uri="/tags/struts-nested" prefix="nested" %> <logic:notPresent name="user"> <logic:redirect forward="errojsp"/> </logic:notPresent> <html:html> <head> <meta http-equiv="content-type" content="text/html; charset=UTF-8"> <title>Sistema de Controle de Atividades</title> <style type="text/css"> <jsp:include page="css.css"/> </style> </head> <body> <html:form action="actCadastroUsuario" focus="uscnome"> <table align="center" bgcolor="#FFFFFF"> <tr> <th colspan="2" bgcolor="#000000"> <font color="#FFFFFF">Cadastro de Novo Usu�rio</font> </th>
</tr> <tr> <td> Nome </td> <td> <html:text property="uscnome" size="40" style="background-color:e3e3e3; border: 1px solid #666666; font-size:8pt; color: #000099" /> </td> </tr> <tr> <td> Login </td> <td> <html:text property="usclogn" size="40" style="background-color:e3e3e3; border: 1px solid #666666; font-size:8pt; color: #000099" /> </td> </tr> <tr> <td> Senha </td> <td> <html:password property="uscsenh" size="40" style="background-color:e3e3e3; border: 1px solid #666666; font-size:8pt; color: #000099" /> </td> </tr> <tr> <td> E-mail </td> <td> <html:text property="uscmail" size="50" style="background-color:e3e3e3; border: 1px solid #666666; font-size:8pt; color: #000099" /> </td> </tr> <tr> <td> Habilitado </td> <td> <html:select property="uslhabl" style="background-color:e3e3e3; border: 1px solid #666666; font-size:8pt; color: #000099" > <html:option value="S">Sim</html:option> <html:option value="N">Nao</html:option> </html:select> </td> </tr> <tr> <td colspan="2"> <html:submit value="Salvar" style="background-color:e3e3e3; border: 1px solid #666666; font-size:8pt; color: #000099" /> </td> </tr> </table> </html:form> <br> <table width="500" align="center" bgcolor="#FFFFFF"> <tr> <th colspan="3" align="center" bgcolor="#000000"> <font color="#FFFFFF">Lista de Usu�rios do Grupo</font> </th> </tr> <tr> <th width="20%">Nome</th> <th width="20%">Login</th> <th width="20%">E-mail</th> </tr> <logic:iterate id="list" name="listuser"> <tr> <td><bean:write name="list" property="uscnome"/></td> <td><bean:write name="list" property="usclogn"/></td> <td><bean:write name="list" property="uscmail"/></td> </tr> </logic:iterate> </table>
</body> </html:html> <%@ taglib uri="/tags/struts-bean" prefix="bean" %> <%@ taglib uri="/tags/struts-logic" prefix="logic" %> <%@ taglib uri="/tags/struts-html" prefix="html" %> <%@ taglib uri="/tags/struts-nested" prefix="nested" %> <logic:notPresent name="user"> <logic:redirect forward="errojsp"/> </logic:notPresent> <html:html> <head> <title>Cadastrar Grupo</title> <style type="text/css"> <jsp:include page="css.css"/> </style> </head> <body> <table align="center"> <tr> <th>Cadastrar Grupo</th> </tr> <tr> <td> <br> <html:form action="actCadastroGrupo"> Responsavel pelo Grupo: <bean:write name="user" property="uscnome"/><br><br> Nome do Grupo: <html:text property="gpcdesc"/><br><br> <input type="hidden" name="gpnresp" value="<bean:write name="user" property="usncodg"/>"/> <center><html:submit/></center> </html:form> </td> </tr> </table> </body> </html:html> <%@ taglib uri="/tags/struts-bean" prefix="bean" %> <%@ taglib uri="/tags/struts-logic" prefix="logic" %> <%@ taglib uri="/tags/struts-html" prefix="html" %> <%@ taglib uri="/tags/struts-nested" prefix="nested" %> <%@ page import="java.util.*"%> <%@ page import="java.text.*"%> <%@ page import="java.text.SimpleDateFormat"%> <logic:notPresent name="user"> <logic:redirect forward="errojsp"/> </logic:notPresent> <html:html> <head> <title>Enviar Atividade</title> <style type="text/css"> <jsp:include page="css.css"/> </style> <link rel="stylesheet" type="text/css" media="all" href="calendar/calendar-atividades.css" title="winter" /> <script type="text/javascript" src="/atividades/calendar/calendar.js"></script> <script type="text/javascript" src="/atividades/calendar/lang/calendar-br.js"></script> <script type="text/javascript" src="/atividades/calendar/calendar-setup.js"></script> </head> <body> <html:form action="actCadastroAtividade"> <% Date data = new Date(); SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy"); String novoFormato = formatador.format(data); %> <table align="center" width="480" bgcolor="#FFFFFF"> <tr> <th colspan="2" bgcolor="#000000"> <font color="#FFFFFF">Enviar Atividade</font> </th>
</tr> <tr> <td><b> De<br> <bean:write name="user" property="nome"/> <input type="hidden" name="usuario_origem_id" readonly="false" value="<bean:write name="user" property="id"/>"/> </b> </td> <td><b> Para<br> <html:select property="usuario_destino_id" style="background-color:e3e3e3; border: 1px solid #666666; font-size:8pt; color: #000099" > <html:optionsCollection name="ug" label="nome" value="id"/> </html:select> </b> </td> </tr> <tr> <td><b> Data de Envio<br> <input type="text" name="cadastro" readonly="false" value="<%= novoFormato%>" style="background-color:e3e3e3; border: 1px solid #666666; font-size:8pt; color: #000099" /> </b> </td> <td><b> Prazo<br> <html:text styleId="data1" property="prazo" readonly="true" style="background-color:e3e3e3; border: 1px solid #666666; font-size:8pt; color: #000099" /> <html:image styleId="btdata" property="" src="../atividades/calendar/img.gif"/> </b> </td> </tr> <tr> <td colspan="2"> <b> Descrição<br> <html:textarea property="descricao" rows="5" cols="60" style="background-color:e3e3e3; border: 1px solid #666666; font-size:8pt; color: #000099" /> </b> </td> </tr> <tr> <td colspan="2"> <b> Observações Adicionais<br> <html:textarea property="obs" rows="5" cols="60" style="background-color:e3e3e3; border: 1px solid #666666; font-size:8pt; color: #000099" /> </b> </td> </tr> <tr> <td align="center" colspan="2"> <html:submit value="Enviar" style="background-color:e3e3e3; border: 1px solid #666666; font-size:8pt; color: #000099" /> </td></b> </tr> </table> </html:form> </body> </html:html> <script type="text/javascript"> Calendar.setup({ inputField : "data1", // id of the input field ifFormat : "dd/mm/y", // format of the input field button : "btdata", // trigger for the calendar (button ID) singleClick : false // double-click mode }); </script> <html:html> <head> <title>Sistema de Controle de Atividades</title>
</head> <body> <font size="5"> Dados Atualizados com Sucesso! </font> </body> </html:html> <%@ taglib uri="/tags/struts-bean" prefix="bean" %> <%@ taglib uri="/tags/struts-logic" prefix="logic" %> <%@ taglib uri="/tags/struts-html" prefix="html" %> <%@ taglib uri="/tags/struts-nested" prefix="nested" %> <%@ page import="atividades.struts.beans.*" %> <%@ page import="java.util.*" %> <%@ page import="java.text.*" %> <logic:notPresent name="user" scope="session"> <logic:redirect forward="actLogoff"/> </logic:notPresent> <html:html> <head> <title>Atividades</title> </head> <body onload="carregarPopup();"> <table width="789" align="center" border="0" bgcolor="#FFF974" cellpadding="0" cellspacing="0" vspace="0"> <tr> <td><img src="paginas/imagens/top.jpg"></td> </tr> <tr> <td align="right"> <b> <% BeanGrupos grupo2 = (BeanGrupos)session.getAttribute("grupo"); BeanUsuarios usuario2 = grupo2.getUsuarioDono(); %> <bean:write name="user" property="nome"/> - <html:link forward="editarusuariojsp" target="principal">editar</html:link> - <html:link forward="actLogoff">sair</html:link><br> Grupo: <bean:write name="grupo" property="descricao"/> (<%= usuario2.getNome() %>) </b> <table width="790"> <tr> <td width="190" height="300" valign="top" align="center"> <a href="actAtividadesEnviadas.do?acao=recebidas" target="principal"><img src="paginas/imagens/bt_04.jpg" border="0"></a><br> <a href="actAtividadesEnviadas.do?acao=enviadas" target="principal"><img src="paginas/imagens/bt_01.jpg" border="0"></a><br> <a href="actAtividadesEnviadas.do?acao=concluidas" target="principal"><img src="paginas/imagens/bt_05.jpg" border="0"></a><br> <logic:present name="resp" scope="session"> <a href="actAtividadesEnviadas.do?acao=encerradas" target="principal"><img src="paginas/imagens/bt_08.jpg" border="0"></a><br> </logic:present> <html:link forward="actNovaAtividade" target="principal"><img src="paginas/imagens/bt_03.jpg" border="0"></html:link><br> <logic:present name="resp" scope="session"> <html:link forward="actCadastroNovoUsuario" target="principal"><img src="paginas/imagens/bt_07.jpg" border="0"></html:link><br> </logic:present> </td> <td width="600" height="420" valign="top"> <iframe name="principal" height="420" width="600" frameborder="0" border="0" marginheight="0" marginwidth="0" src="actAtividadesEnviadas.do?acao=recebidas">
</td> </tr> </table> </td> </tr> </table> </body> </html:html>
Anexo III – SQL de criação do Banco de Dados O conteúdo listado a seguir é o SQL de criação do banco de dados. Para os dois aplicativos. CREATE DATABASE 'C:\ATIVIDADES.FDB' USER 'SYSDBA' PAGE_SIZE 1024 DEFAULT CHARACTER SET ISO8859_1; CREATE GENERATOR ATIVIDADES_ID_GEN; CREATE GENERATOR ATIVIDADES_SEQ; SET GENERATOR ATIVIDADES_SEQ TO 13; CREATE GENERATOR GRUPOS_ID_GEN; CREATE GENERATOR GRUPOS_SEQ; SET GENERATOR GRUPOS_SEQ TO 1; CREATE GENERATOR USUARIOS_ID_GEN; CREATE GENERATOR USUARIOS_ID_GEN1; SET GENERATOR USUARIOS_ID_GEN1 TO 1; CREATE GENERATOR USUARIOS_SEQ; SET GENERATOR USUARIOS_SEQ TO 3; CREATE TABLE USUARIOS ( ID INTEGER NOT NULL, NOME VARCHAR(100) CHARACTER SET ISO8859_1 COLLATE ISO8859_1, LOGIN VARCHAR(15) CHARACTER SET ISO8859_1 COLLATE ISO8859_1, SENHA VARCHAR(15) CHARACTER SET ISO8859_1 COLLATE ISO8859_1, EMAIL VARCHAR(150) CHARACTER SET ISO8859_1 COLLATE ISO8859_1, CREATED_AT TIMESTAMP, HABILITADO CHAR(1) CHARACTER SET ISO8859_1 COLLATE ISO8859_1); update rdb$relation_fields set rdb$description = 'Identificador Único' where rdb$relation_name = 'USUARIOS' and rdb$field_name = 'ID'; update rdb$relation_fields set rdb$description = 'Nome do Usuário' where rdb$relation_name = 'USUARIOS' and rdb$field_name = 'NOME'; update rdb$relation_fields set rdb$description = 'Login do Usuário' where rdb$relation_name = 'USUARIOS' and rdb$field_name = 'LOGIN'; update rdb$relation_fields set rdb$description = 'Senha do Usuário' where rdb$relation_name = 'USUARIOS' and rdb$field_name = 'SENHA'; update rdb$relation_fields set rdb$description = 'Email do Usuário' where rdb$relation_name = 'USUARIOS' and rdb$field_name = 'EMAIL'; update rdb$relation_fields set rdb$description = 'Data de Criação do Usuário'
where rdb$relation_name = 'USUARIOS' and rdb$field_name = 'CREATED_AT'; update rdb$relation_fields set rdb$description = 'Usuário Habilitado' where rdb$relation_name = 'USUARIOS' and rdb$field_name = 'HABILITADO'; update rdb$relations r set r.rdb$description = 'Tabela dos Usuários do Sistema' where (r.rdb$relation_name = 'USUARIOS') and (r.rdb$view_source is null); ALTER TABLE USUARIOS ADD CONSTRAINT INTEG_9 PRIMARY KEY (ID); CREATE TABLE GRUPOS ( ID INTEGER NOT NULL, USUARIO_ID INTEGER, DESCRICAO VARCHAR(30) CHARACTER SET ISO8859_1 COLLATE ISO8859_1); update rdb$relation_fields set rdb$description = 'Identificador do Grupo' where rdb$relation_name = 'GRUPOS' and rdb$field_name = 'ID'; update rdb$relation_fields set rdb$description = 'Identificador do Usuário Dono do Grupo' where rdb$relation_name = 'GRUPOS' and rdb$field_name = 'USUARIO_ID'; update rdb$relation_fields set rdb$description = 'Descrição do Grupo' where rdb$relation_name = 'GRUPOS' and rdb$field_name = 'DESCRICAO'; update rdb$relations r set r.rdb$description = 'Tabela dos Grupos do Sistema' where (r.rdb$relation_name = 'GRUPOS') and (r.rdb$view_source is null); ALTER TABLE GRUPOS ADD CONSTRAINT INTEG_6 PRIMARY KEY (ID); ALTER TABLE GRUPOS ADD CONSTRAINT FK_GRUPOS1 FOREIGN KEY (USUARIO_ID) REFERENCES USUARIOS(ID); CREATE TABLE ATIVIDADES ( ID INTEGER NOT NULL, DESCRICAO VARCHAR(150) CHARACTER SET ISO8859_1 COLLATE ISO8859_1, OBS VARCHAR(200) CHARACTER SET ISO8859_1 COLLATE ISO8859_1, USUARIO_ORIGEM_ID INTEGER, USUARIO_DESTINO_ID INTEGER, GRUPO_ORIGEM_ID INTEGER, GRUPO_DESTINO_ID INTEGER, CREATED_AT TIMESTAMP, PRAZO TIMESTAMP, CONCLUSAO TIMESTAMP, CIENTE TIMESTAMP); update rdb$relation_fields set rdb$description = 'Identificador da Atividade' where rdb$relation_name = 'ATIVIDADES' and rdb$field_name = 'ID'; update rdb$relation_fields set rdb$description = 'Descrição da Atividade' where rdb$relation_name = 'ATIVIDADES' and rdb$field_name = 'DESCRICAO'; update rdb$relation_fields set rdb$description = 'Observações da Atividade' where rdb$relation_name = 'ATIVIDADES' and rdb$field_name = 'OBS'; update rdb$relation_fields set rdb$description = 'Identidficador do Usuário de Origem' where rdb$relation_name = 'ATIVIDADES' and rdb$field_name = 'USUARIO_ORIGEM_ID'; update rdb$relation_fields set rdb$description = 'Identificador do Usuário de Destino' where rdb$relation_name = 'ATIVIDADES'
and rdb$field_name = 'USUARIO_DESTINO_ID'; update rdb$relation_fields set rdb$description = 'Identificador do Grupo de Origem' where rdb$relation_name = 'ATIVIDADES' and rdb$field_name = 'GRUPO_ORIGEM_ID'; update rdb$relation_fields set rdb$description = 'Identificador do Grupo de Destino' where rdb$relation_name = 'ATIVIDADES' and rdb$field_name = 'GRUPO_DESTINO_ID'; update rdb$relation_fields set rdb$description = 'Data de Criação da Atividade' where rdb$relation_name = 'ATIVIDADES' and rdb$field_name = 'CREATED_AT'; update rdb$relation_fields set rdb$description = 'Data Prazo da Atividade' where rdb$relation_name = 'ATIVIDADES' and rdb$field_name = 'PRAZO'; update rdb$relation_fields set rdb$description = 'Data de Conclusão da Atividade' where rdb$relation_name = 'ATIVIDADES' and rdb$field_name = 'CONCLUSAO'; update rdb$relation_fields set rdb$description = 'Data de Ciente da Atividade' where rdb$relation_name = 'ATIVIDADES' and rdb$field_name = 'CIENTE'; update rdb$relations r set r.rdb$description = 'Tabela das Atividades do Sistema' where (r.rdb$relation_name = 'ATIVIDADES') and (r.rdb$view_source is null); ALTER TABLE ATIVIDADES ADD CONSTRAINT INTEG_7 PRIMARY KEY (ID); ALTER TABLE ATIVIDADES ADD CONSTRAINT FK_ATIVIDADES1 FOREIGN KEY (USUARIO_ORIGEM_ID) REFERENCES USUARIOS(ID); ALTER TABLE ATIVIDADES ADD CONSTRAINT FK_ATIVIDADES2 FOREIGN KEY (USUARIO_DESTINO_ID) REFERENCES USUARIOS(ID); ALTER TABLE ATIVIDADES ADD CONSTRAINT FK_ATIVIDADES3 FOREIGN KEY (GRUPO_ORIGEM_ID) REFERENCES GRUPOS(ID); ALTER TABLE ATIVIDADES ADD CONSTRAINT FK_ATIVIDADES4 FOREIGN KEY (GRUPO_DESTINO_ID) REFERENCES GRUPOS(ID); CREATE TABLE GRUPOS_USUARIOS ( GRUPO_ID INTEGER, USUARIO_ID INTEGER); update rdb$relation_fields set rdb$description = 'Identificador do Grupo' where rdb$relation_name = 'GRUPOS_USUARIOS' and rdb$field_name = 'GRUPO_ID'; update rdb$relation_fields set rdb$description = 'Identificador do usuário' where rdb$relation_name = 'GRUPOS_USUARIOS' and rdb$field_name = 'USUARIO_ID'; update rdb$relations r set r.rdb$description = 'Tabela de ligação para as tabelas Grupo e Usuario' where (r.rdb$relation_name = 'GRUPOS_USUARIOS') and (r.rdb$view_source is null); ALTER TABLE GRUPOS_USUARIOS ADD CONSTRAINT FK_GRUPOS_USUARIOS1 FOREIGN KEY (GRUPO_ID) REFERENCES GRUPOS(ID); ALTER TABLE GRUPOS_USUARIOS ADD CONSTRAINT FK_GRUPOS_USUARIOS2 FOREIGN KEY (USUARIO_ID) REFERENCES USUARIOS(ID); SET TERM ^ ;
CREATE TRIGGER BI_ATIVIDADES_ID FOR ATIVIDADES ACTIVE BEFORE INSERT POSITION 0 AS BEGIN IF (NEW.ID IS NULL) THEN NEW.ID = GEN_ID(ATIVIDADES_SEQ, 1); END^ SET TERM ; ^ SET TERM ^ ; CREATE TRIGGER BI_GRUPOS_ID FOR GRUPOS ACTIVE BEFORE INSERT POSITION 0 AS BEGIN IF (NEW.ID IS NULL) THEN NEW.ID = GEN_ID(GRUPOS_SEQ, 1); END^ SET TERM ; ^ SET TERM ^ ; CREATE TRIGGER BI_USUARIOS_ID FOR USUARIOS ACTIVE BEFORE INSERT POSITION 0 AS BEGIN IF (NEW.ID IS NULL) THEN NEW.ID = GEN_ID(USUARIOS_SEQ, 1); END^ SET TERM ; ^ GRANT SELECT, INSERT, DELETE, REFERENCES, UPDATE ON USUARIOS TO SYSDBA WITH GRANT OPTION; GRANT SELECT, INSERT, DELETE, REFERENCES, UPDATE ON GRUPOS TO SYSDBA WITH GRANT OPTION; GRANT SELECT, INSERT, DELETE, REFERENCES, UPDATE ON ATIVIDADES TO SYSDBA WITH GRANT OPTION; GRANT SELECT, INSERT, DELETE, REFERENCES, UPDATE ON GRUPOS_USUARIOS TO SYSDBA WITH GRANT OPTION;