UNIVERSIDADE TECNOLÓGICA FEDERAL DO PARANÁ – UTFPR UTFPR CURSO SUPERIOR DE TECNOLOGIA EM ANÁLISE E DESENVOLVIMENTO DE SISTEMAS
TIAGO JOSÉ CASANOVA
RELATÓRIO DE ESTÁGIO
MEDIANEIRA 2012
TIAGO JOSÉ CASANOVA
RELATÓRIO DE ESTÁGIO
Relatório de Estágio apresentado à disciplina de Estágio Supervisionado, do Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas – COADS – da Universidade Tecnológica Federal do Paraná – UTFPR, UTFPR, como requisito parcial para obtenção do título de Tecnólogo. Orientador: Prof. Juliano Rodrigo Lamb
MEDIANEIRA 2012
TIAGO JOSÉ CASANOVA
RELATÓRIO DE ESTÁGIO
Relatório de Estágio apresentado à disciplina de Estágio Supervisionado, do Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas – COADS – da Universidade Tecnológica Federal do Paraná – UTFPR, UTFPR, como requisito parcial para obtenção do título de Tecnólogo. Orientador: Prof. Juliano Rodrigo Lamb
MEDIANEIRA 2012
Ministério da Educação Universidade Tecnológica Tecnológica Federal do Paraná Diretoria de Graduação e Educação Profissional Curso Superior de Tecnologia em Análise e Desenvolvimento Desenvolvimento de Sistemas
TERMO DE ENTREGA Relatório de estágio curricular supervisionado, realizado na Serviceweb.com LTDA no período de 11/11/2011 a 11/05/2012, perfazendo aproximadamente 400 horas. ______________________ _________________________________ _____________ __ Valter Rodrigo Ekert Supervisor do Estágio – Serviceweb.com Serviceweb.com LTDA ______________________ _________________________________ _____________ __ Prof. Juliano Rodrigo Lamb Orientador do Estágio ______________________ _________________________________ _____________ __ Tiago José Casanova Estagiário ______________________ _________________________________ _____________ __ Prof. Juliano Rodrigo Lamb Responsável Responsável pela Atividade de Estágio do Curso
Medianeira – 31 31 de Outubro de 2012
LISTAS DE SIGLAS
API
Interface de Programação de Aplicativos
CSS
Cascade Style Sheet
HTML
Hyper Text Markup Language
IDE
Integrated Development Environment
MVC
Model-View-Control
PHP
Hypertext Preprocessor
SGBD
Sistema Gerenciador de Banco de Dados
SQL
Structured Query Language
XML
eXtensible Markup Language
YAML
Yet Another Markup Language
LISTA DE FIGURAS
Figura 1 - Criando um projeto Ruby on Rails. ......................................................................... 14 Figura 2 – Estrutura de pastas gerada pelo Ruby on Rails. ...................................................... 15 Figura 3 - Estrutura de diretórios do Rails. .............................................................................. 16 Figura 4 - Iniciando aplicação Ruby on Rails. ......................................................................... 16 Figura 5 - Página padrão do Ruby on Rails. ............................................................................. 17 Figura 6 - Visão Geral do NetBeans......................................................................................... 18 Figura 7 - Página padrão do phpMyAdmin. ............................................................................. 19 Figura 8 - Diagrama de Componentes do site. ......................................................................... 21 Figura 9 - Model validação dos dados...................................................................................... 21 Figura 10 - Resultado da Validação. ........................................................................................ 22 Figura 11 - Criando um novo Newsletter no Controller........................................................... 22 Figura 12 - Integração de Ruby com HTML. ........................................................................... 23 Figura 13 - Resultado Final. ..................................................................................................... 24 Figura 14 - Diagrama de Componentes do Sistema Semear. ................................................... 25 Figura 15 – Action responsável por gravar na sessão as opções escolhidas. ........................... 26 Figura 16 – Visão renderizada pela action. .............................................................................. 27 Figura 17 – Partial renderização dos Estudantes. ..................................................................... 27 Figura 18 - Action que exibe os dados selecionados................................................................ 28 Figura 19 – Action que irá buscar os dados. ............................................................................ 28 Figura 20 - Resultado final para impressão. ............................................................................. 29 Figura 21 – Criando um Plugin. ............................................................................................... 30 Figura 22 – Estrutura criada pelo plugin. ................................................................................. 30 Figura 23 - Arquivo responsável por gerar os códigos no projeto Rails. ................................. 31 Figura 24 – Implementação das rotas do plugin. ...................................................................... 32 Figura 25 - Método responsável pelo captcha. ......................................................................... 32 Figura 26 - Método de Internacionalização do plugin.............................................................. 33 Figura 27 - Estrutura final do Plugin. ....................................................................................... 34 Figura 28 - Execução do plugin................................................................................................ 35 Figura 29 - Parte admin do site implementado pelo plugin. ..................................................... 35 Figura 30 - Resultado Final. ..................................................................................................... 36
Figura 31 – Resultado final da votação. ................................................................................... 36
SUMÁRIO
1
INTRODUÇÃO............................................................................................................. 8
1.1
ATIVIDADES PREVISTAS..........................................................................................8
2
IDENTIFICAÇÃO ....................................................................................................... 9
2.1
NOME DO ACADÊMICO............................................................................................. 9
2.2
NOME DO ORIENTADOR........................................................................................... 9
2.3
INSTITUIÇÃO DE ENSINO ......................................................................................... 9
2.3.1 Nome............................................................................................................................... 9 2.3.2 Endereço ......................................................................................................................... 9 2.3.3 Nome do curso ................................................................................................................ 9 2.4
EMPRESA .................................................................................................................... 10
2.4.1 Nome............................................................................................................................. 10 2.4.2 Ramo de atividade ........................................................................................................ 10 2.4.3 Endereço ....................................................................................................................... 10
3
TECNOLOGIAS UTILIZADAS...............................................................................11
3.1
LINGUAGEM HTML..................................................................................................11
3.2
LINGUAGEM CSS ...................................................................................................... 11
3.3
LINGUAGEM RUBY .................................................................................................. 12
3.4
FRAMEWORK ............................................................................................................ 12
3.4.1 RAILS ........................................................................................................................... 13 3.4.2 Exemplo da criação de uma aplicação Rails ................................................................. 14 3.5
BANCO DE DADOS MYSQL .................................................................................... 17
3.6
IDE NETBEANS..........................................................................................................17
3.7
WAMP SERVER.......................................................................................................... 18
4
RESULTADOS E DISCUSSÕES.............................................................................. 20
4.1
DESCRIÇÃO DAS ATIVIDADES ............................................................................. 20
4.2
DESENVOLVIMENTO DE SITES COM RUBY ON RAILS ................................... 20
4.3
MELHORIAS NO SISTEMA “SEMEAR” ................................................................. 25
4.4
DESENVOLVIMENTO PLUGIN “ENQUETE” ........................................................ 29
5
CONSIDERAÇÕES FINAIS.....................................................................................37
5.1
CONCLUSÃO .............................................................................................................. 37
5.2
TRABALHOS FUTUROS/CONTINUAÇÃO DO TRABALHO ............................... 37
6
REFERÊNCIAS BIBLIOGRÁFICAS......................................................................38
8
1 INTRODUÇÃO
Com o aumento da concorrência entre as empresas, seja qual for o ramo, eles precisam expor os seus produtos e sua marca. A Internet tem se destacado como meio privilegiado de pesquisa de informações sobre produtos e serviços. Uma maneira eficaz de se fazer isso é por meio de páginas web, pois na internet a empresa estará disponível 24 horas por dia, 7 dias da semana, podendo ser acessada de qualquer parte do mundo. Além de páginas web, as empresas podem precisar de sistemas para controlar suas operações. Uma vantagem dos sistemas web é que eles podem ser acessados de qualquer computador conectado á rede, gerando uma maior praticidade. Para o desenvolvimento das páginas web podem ser utilizados frameworks, que têm por objetivos auxiliar no desenvolvimento, garantem uma melhor segurança e aumentam a agilidade do desenvolvimento. O Rails é um framework web que tem por objetivo auxiliar no desenvolvimento web. Muito prático, ajudando na construção de sites, com código limpo e de fácil manutenção. Este relatório descreve as tecnologias e atividades realizadas durante o período de 11/11/2011 à 11/05/2012 na empresa ServiceWeb.com LTDA, utilizando o framework Ruby on Rails.
1.1
ATIVIDADES PREVISTAS
As atividades previstas no termo de compromisso o qual estabelece o vínculo de estágio foram:
Estudo e aplicação de HTML, CSS, Javascript ;
Estudo e aplicação do Framework Ruby on Rails.
9
2 IDENTIFICAÇÃO
2.1
NOME DO ACADÊMICO
Tiago José Casanova
2.2
NOME DO ORIENTADOR
Juliano Rodrigo Lamb
2.3
INSTITUIÇÃO DE ENSINO
2.3.1 Nome
Universidade Tecnológica Federal do Paraná – UTFPR – Câmpus Medianeira
2.3.2 Endereço
Avenida Brasil, 4232 CEP 85884-000 - Caixa Postal 271. Telefone Geral +55 (45) 3240-8000 - Fax : +55 (45) 3240-8101. Medianeira - PR – Brasil. 2.3.3 Nome do curso
10
Tecnologia em Análise e Desenvolvimento de Sistemas
2.4
EMPRESA
2.4.1 Nome
Serviceweb.com LTDA
2.4.2 Ramo de atividade
Desenvolvimento de sites e sistemas Web.
2.4.3 Endereço
Avenida Brasil, número 4021 no Bairro Parque Independência no município de Medianeira – PR.
11
3 TECNOLOGIAS UTILIZADAS
Este capítulo tem por objetivo dissertar sobre as tecnologias utilizadas durante o período de estágio, as informações sobre cada uma foram obtidas por meio de pesquisas em sites
na Internet . Durante o período do estágio, utilizou-se das tecnologias da linguagem
Ruby, juntamente com o framework Ruby on Rails
e Ambiente de Desenvolvimento Integrado
(IDE) para o desenvolvimento de páginas HTML com CSS para web.
3.1
LINGUAGEM HTML
A estrutura do HTML é baseada em um conjunto de tags, onde cada tag é usada para posicionar um conteúdo qualquer, como: uma tabela, uma imagem, um formulário, um texto, entre outros. Segundo TEAGUE (2001) , “HTML é uma linguagem de marcação que foi criada para permitir que os autores definam a estrutura de um documento para distribuição na web”.
Segundo a W3C (2008) , “a linguagem de HTML foi originalmente concebida por TIM Berners-Lee e popularizada pelo browser Mosaic”. Um documento escrito em HTML é um texto comum no formato ASCII, que pode ser aberto por qualquer navegador web. Segundo ANGELI (200-), “HTML (HyperText Markup Language) é o termo que designa uma linguagem usada para criar documentos hiper-texto ”.
3.2
LINGUAGEM CSS
Com o CSS é possível separar o código referente apresentação do conteúdo das páginas, do código responsável pela estilização, trazendo uma legibilidade maior para ambos, aumentando inúmeros benefícios como:
Controle do layout de vários documentos a partir de uma simples folha de estilos;
Maior precisão no controle do layout ;
12
Aplicação de diferentes layouts para servir diferentes mídias (telas, impressora, entre outros.);
Portabilidade, pois funciona em qualquer navegador;
Escalabilidade, pois possibilita a página ganhar novas funcionalidades sem prejudicar as já existentes.
Segundo a W3C ( 2008), “CSS é uma linguagem para descrever a apresentação das páginas web, incluindo cores, layout e fontes”.
3.3
LINGUAGEM RUBY
É uma linguagem Open-Source o que possibilita aos desenvolvedores abrirem e melhorarem o código fonte sempre que julgarem necessário, o que possibilita uma melhoria constante na correção de bugs. Segundo MATSUMOTO;FLANAGAN (2008) , “Ruby é uma linguagem de script interpretada para programação orientada a objetos de um modo fácil e rápido. Ela tem vários recursos para processar arquivos de texto e para fazer tarefas de gerenciamento de sistema (assim como o Perl). Ela é simples, direto ao ponto, extensível e portável”. A linguagem Ruby foi desenvolvida em 1995, no Japão por Yukihiro Matsumoto, que se baseou em outras linguagens de programação as quais foram Perl, Smalltalk, Eiffel, Ada, e Lisp.
3.4
FRAMEWORK
Segundo CAVALHEIRO (20--), “ Framework é uma técnica que é aplicada tanto no projeto quanto no desenvolvimento de um software orientado a objetos. Ela implica, basicamente, em explorar o potencial de reutilização de partes de software já desenvolvidas e/ou desenvolver novos componentes de software prevendo sua reutilização no futuro ”. O propósito de um framework é ajudar no processo de desenvolvimento de aplicações, permitindo que aplicações sejam desenvolvidas mais rapidamente e mais facilmente.
13
Segundo FAYAD (1997) , “ framework é um conjunto de classes que colaboram para realizar uma responsabilidade para um domínio de um subsistema da aplicação”.
3.4.1 RAILS
O Rails foi desenvolvido em junho de 2004, seu objetivo era de permitir desenvolvimento ágil de suas aplicações web, produzindo mais com menos linhas de código. Segundo CARNEIRO; AL BARAZI (2011), “O Rails é um framework de ponta para construção de aplicações web. É completo, de código aberto e tem compatibilidade de plataforma cruzada”.
Segundo THOMAS;HANSSON (2007), “O Ruby on Rails é um
framework que torna mais
fácil desenvolver, instalar e manter aplicativos web ”.
A arquitetura do Rails utiliza o padrão MVC dividindo em três categorias distintas: o model (modelo), a view (visão) e o controller (controlador). Por meio do model
representa os
dados, a view representa a interface do usuário e o controller dirige toda a ação. O Rails surgiu da união de alguns frameworks, dentre eles tem-se:
Active Record:
Contém uma camada de mapeamento objeto-relacional
(model ), entre o banco de dados e a aplicação;
Active Suport: Contém coleções de diversas classes, e extensões de bibliotecas, consideradas úteis para uma aplicação em Ruby on Rails;
Active WebServices: Provê uma maneira de publicar APIs que se comuniquem com o Rails;
Action Pack: Compreende Action View (HTML, XML, Javascripts) e a Action Controller (controle de regras de negócio);
Action Mailer: Compreende ao recebimento de e-mails, realiza diversas operações apenas com chamadas de entregas de correspondência;
Segundo o site RUBY ON RAILS (200-) atualmente, o Ruby on Rails está na versão 3.2.0 lançada no dia 20 de janeiro de 2012.
14
3.4.2 Exemplo da criação de uma aplicação Rails
A seguir serão mostrados os passos para criar e executar uma aplicação Ruby on Rails . Foi usando a versão 2.2.2 do Rails. A Figura 1 demonstra como criar a aplicação, onde o comando rails informa que será criado um projeto Ruby on Rails , o AplicacaoRubyonRails é o nome do projeto que será criado e a opção –d mysql serve para definir que será utilizado o banco de dados mysql para a aplicação, por default o Rails usa o banco de dados SQLLite.
Figura 1 - Criando um projeto Ruby on Rails.
Fonte: Autoria própria.
Ao examinar a estrutura criada pelo Rails, pode-se notar alguns diretórios principais como:
App – Nesta pasta contem a maior parte do projeto. Nela ficam todo o código de mapeamento de banco de dados ( model ), as telas ( view) e os controladores (controllers) que são responsáveis pela comunicação entre as telas com o banco, como mencionado anteriormente essa estrutura é conhecida como MVC;
Config – Pasta responsável por armazenar todos os arquivos de configuração;
Db – Ficam armazenados os arquivos relacionados ao banco de dados, como as migrações e esquemas;
Public – Neste diretório ficam os arquivos de acesso público, como imagens, páginas estáticas, folhas de estilo, arquivos de javascript e outros;
Test – Diretório onde ficam os arquivos de teste;
Vendor – Diretório responsável pelas bibliotecas externas, como gems e plug ins.
15
A Figura 2 demonstra a arquitetura gerada pelo Ruby on Rails , após a execução do comando exibido na Figura 1.
Figura 2 – Estrutura de pastas gerada pelo Ruby on Rails.
Fonte: Autoria própria.
Na Figura 3 pode-se observar a estrutura gerada pelo Rails, contendo os principais diretórios para o funcionamento da aplicação.
16
Figura 3 - Estrutura de diretórios do Rails.
Fonte: Autoria própria.
O Rails traz por default o servidor chamado Webrick. Para inicializar a aplicação, deve-se entrar na pasta do projeto criado e digitar o comando ruby script/server . Logo após o processamento do comando, o servidor Rails estará em execução na porta padrão 3000. O resultado deste procedimento pode ser verificado na Figura 4.
Figura 4 - Iniciando aplicação Ruby on Rails.
Fonte: Autoria própria.
Pode-se visualizar a execução no navegador, por meio da seguinte
URL
http://localhost:3000. Na Figura 5 pode-se observar a página padrão do Ruby on Rails renderizada no browser.
17
Figura 5 - Página padrão do Ruby on Rails.
Fonte: Autoria própria.
3.5
BANCO DE DADOS MYSQL
O MySQL é um gerenciador de banco de dados relacional que suporta SQL. É open source e é um dos SGBDs para utilização profissional mais utilizado.
Foi desenvolvido e é disponibilizado pela empresa MySQL AB Limited Company, possui algumas características como, a portabilidade (suporta praticamente qualquer plataforma atual), excelente desempenho e estabilidade, facilidade de uso, suporta triggers, possui interface gráfica (MySQL Toolkit) de fácil utilização, entre outras.
3.6
IDE NETBEANS A IDE NetBeans é um ambiente de desenvolvimento multiplataforma, uma ferramenta
que auxilia programadores a escrever, compilar e debugar aplicações. Foi iniciado em 1996 por dois estudantes tchecos na Universidade de Charles. Totalmente escrita em JAVA, possui suporte a linguagens de programação como C, C++, Ruby, PHP, XML e linguagens HTML. Alguns de seus principais recursos são:
Editor de código fonte integrado;
18
Visualizador de classes integrado ao de interfaces visual;
Plugins para UML;
Auto completar avançado;
Integração de módulos;
Suporte a Database (banco de dados).
Na Figura 6 pode-se visualizar a execução da IDE Netbeans, onde é renderizado um arquivo Ruby.
Figura 6 - Visão Geral do NetBeans.
Fonte: Autoria própria.
3.7
WAMP SERVER
O WampServer foi desenvolvido em PHP, possui também o programa PHPMyAdmin que é uma interface que facilita criar, remover e alterar tabelas, inserir, remover e editar campos, e executar código SQL e manipular campos chaves, aumentando a agilidade no desenvolvimento da aplicação.
19
Segundo LEMES (2010) , “WampServer é um ambiente para o Sistema Operacional Windows, voltado para programadores e/ou pessoas que precisam testar aplicações web, suportando Apache, PHP e banco de dados MySQL ”. Na Figura 7 pode-se visualizar a página padrão do PHPMyAdmin, que pode ser visualizado pela URL http://localhost/phpmyadmin/ .
Figura 7 - Página padrão do phpMyAdmin.
Fonte: Autoria própria.
20
4 RESULTADOS E DISCUSSÕES
Este capítulo visa mostrar de maneira clara as principais atividades realizadas no estágio.
4.1
DESCRIÇÃO DAS ATIVIDADES
As atividades foram organizadas de seguinte modo: a. Desenvolvimento de sites utilizando linguagem Ruby e framework rails; b. Melhorias no sistema “SEMEAR”; c. Desenvolvimento de plugin “ENQUETE”.
4.2
DESENVOLVIMENTO DE SITES COM RUBY ON RAILS
Com a utilização do Rails junto ao framework interno da empresa, conhecido como MOSTRATIVO, a criação de sites e sistemas ficou mais simples e ágil de ser feita. Dentre as atividades realizadas no estágio, o site http://naeleicao.com.br foi escolhido para exibição de seu conteúdo cadastrado no sistema. Para melhor entendimento da estrutura do site, pode-se visualizar na Figura 8, o diagrama de componentes com todas as principais páginas do site, onde tem-se a possibilidade de a partir de uma página navegar pelas outras. Quando uma página é solicitada pelo usuário, primeiro é feita uma requisição ao banco de dados para recuperar os dados pertinentes à página solicitada.
21
Figura 8 - Diagrama de Componentes do site.
Fonte: Autoria própria.
O Rails segue o padrão MVC. Primeiramente, é feita a validação do Model , segundo passo é gerar as consultas e resposta no Controller , e por último trabalha-se, com os objetos na View. Na Figura 9 pode-se ver a primeira etapa desse processo, validação do model Newsletter. Na linha 3 é feita a validação para a presença de um atributo name e email.
Na linha 4 é definido que o atributo email será único no banco de dados. Na linha 5 é criada uma busca personalizada com o nome actived?.
Figura 9 - Model validação dos dados.
Fonte: Autoria própria.
No Rails, o Model representa o mapeamento do banco de dados, as validações do banco e representa as classes de negócio. Na Figura 10 pode ser vista a validação feita na linha 4, ao tentar gravar um novo Newsletter que já possui cadastro no site uma mensagem de alerta é exibida, de modo que possa ser facilmente visualizada.
22
Figura 10 - Resultado da Validação.
Fonte: Autoria Própria .
Seguindo as convenções do Rails adotadas pelos desenvolvedores, a action create é responsável por criar um conteúdo novo para um Model . No exemplo a seguir, é feita a criação de um novo Newsletter. Na Figura 11, linha 20 é criado um objeto do @newsletter que irá receber os dados via post através de um formulário. Na linha 23 é feita a tentativa de salvar o novo Newsletter. Se obtiver sucesso, as linhas 24 a 26 serão executadas, caso contrário serão as
linhas 28 a 30.
Figura 11 - Criando um novo Newsletter no Controller.
Fonte: Autoria Própria .
Na Figura 11, na linha 24 é gravada a mensagem que será exibida na tela, conforme visualizado anteriormente na Figura 10. Na linha 25 é feita uma requisição HTML, onde o Rails
converterá o conteúdo para HTML, e será redirecionado para a página index. Na linha
23
26 é feita uma requisição XML, onde o Rails converterá o conteúdo a ser renderizado para XML. O objeto criado na action create ficam disponíveis para sua visão no application.html.erb da parte pública do controller . No application é colocado
todo o código que se repete mais de uma vez no site. O trecho de código da Figura 12 a seguir usa o objeto acima citado, para criação de um formulário.
Figura 12 - Integração de Ruby com HTML.
Fonte: Autoria Própria.
Como pode-se observar na Figura 12, a integração Ruby on Rails e HTML é feita facilitando a integração com HTML. O resultado final desse processo pode ser visto na Figura 13, onde chamado o link http://naeleicao.com.br, ele exibe a página inicial trazendo o formulário de Nesletter e outros dados.
24
Figura 13 - Resultado Final.
Fonte: Autoria Própria .
No período de estágio outros sites também foram desenvolvidos ou ainda estão em processo de desenvolvimento, alguns exemplos são:
Set Telecom – www.settelecom.com.br
Luce Flores – www.luceflores.com.br
Núcleo Informática – www.nucleoinformatica.com.br
Guia Serranópolis – www.guiaserranopolis.com.br
Imobiliária Schefer – www.schefer.imb.br
25
4.3
MELHORIAS NO SISTEMA “SEMEAR”
A empresa possui um sistema para fins educacionais e de assistência Social desenvolvido especificamente para a Sociedade Filantrópica Semear de Medianeira, chamado “Sistema SEMEAR”,
que tem por objetivo controlar alunos, cursos, turmas, empresas, entre
outros. Para melhor entendimento de como funciona o “Si stema SEMEAR” pode -se visualizar
na Figura 14 o diagrama de componentes do sistema. Para acessar a página home.html o usuário é obrigado a se autenticar na página autenticacao.html, a partir da página home o usuário pode acessar qualquer página e vice-versa, quando o usuário requisitar uma
página, primeiramente é feita a requisição ao banco de dados.
Figura 14 - Diagrama de Componentes do Sistema Semear.
Fonte: Autoria Própria .
Surgiu a necessidade de criar uma maneira de gerar automaticamente a declaração de inscrição dos alunos, de uma forma que desse mais agilidade na inscrição. Após estudo de como deixar essa funcionalidade mais simples optou-se por implementar uma solução que permitisse ao usuário selecionar o aluno, a empresa e o coordenador e gerar a inscrição.
26
Como o Rails trabalha utilizando o padrão MVC nenhuma página é acessada de forma direta e sim pelo seu controlador correspondente, era necessário a criação de uma action que trouxesse todos os estudantes, as empresas e os coordenadores e que salva-se na sessão do navegador a opção escolhida, para isso foi implemento a chamada enrollment dentro do controller contract .
Na Figura 15, entre as linhas 112 a 120 é feita a verificação do parâmetro que é passado pela URL, conforme o parâmetro é feita uma consulta diferente. Nas linhas 122 a 133 também é feita a verificação do parâmetro, se o parâmetro for encontrado será gravado o nome e o id na sessão do navegador.
Figura 15 – Action responsável por gravar na sessão as opções escolhidas.
Fonte: Autoria Própria .
No Rails por padrão cada action do controller possui uma view correspondente, onde mostra os dados que foram buscados anteriormente na chamada da action.
27
Figura 16 – Visão renderizada pela action.
Fonte: Autoria Própria .
O Rails possui o conceito de partial , que seria incluir uma página dentro de outra, reaproveitando seu código e facilitando em futuras manutenções. Na Figura 16 pode-se visualizar nas linhas 32, 34 e 36 as chamadas das partials, conforme o argumento que foi passado para a consulta no controller será renderizado uma partial diferente. Na Figura 17 é possível ver a partial que irá exibir os estudantes. O ponto importante é o método onDbClick(rota), onde será chamada a própria action enrollment passando os argumentos id e o nome do estudante pela URL.
Figura 17 – Partial renderização dos Estudantes.
Fonte: Autoria Própria .
28
Na Figura 18 pode-se visualizar os dados selecionados pela action enrollment .
Figura 18 - Action que exibe os dados selecionados.
Fonte: Autoria Própria .
Na Figura 16 na linha 22 pode-se observar um formulário que corresponde a action show_enrollment, onde sua função é trazer um estudante, uma empresa e um
coordenador para gerar a declaração da matricula. Na Figura 19 pode-se visualizar a action show_enrollment.
Figura 19 – Action que irá buscar os dados.
Fonte: Autoria Própria .
Na Figura 20 pode-se observar o resultado final, onde a declaração da matricula esta construída com os todas as suas devidas informações.
29
Figura 20 - Resultado final para impressão.
Fonte: Autoria Própria .
4.4
DESENVOLVIMENTO PLUGIN “ENQUETE”
A idéia de plugin no Rails é trazer mais agilidade ao desenvolvimento de aplicações web. Em Rails permite o uso de funcionalidades core: plug-ins, de forma a tornar mais fácil determinadas funcionalidades. Com o aumento da concorrência as empresas estão aumentando os seus interesses nas opiniões dos clientes, cada vez mais estão procurando saber o que estão pensando para melhor atendê-lo. Através de uma enquete é possível realizar pesquisas de opiniões dos clientes, pode também verificar as tendências dos consumidores em relação a um produto. A cada site que era desenvolvido perdia-se muito tempo implementando a parte da enquete, o código gerado era o mesmo pra todos os sites, então surgiu à necessidade de desenvolver um plugin que fizesse a reutilização do código aumentando agilidade do desenvolvimento.
30
No Rails um plugin deve-se ser criado dentro de um projeto Rails, na Figura 19 demonstra como criar um plugin, onde o comando ruby informa que será criado um projeto Ruby,
o comando script/generate plugin informa que será gerado os códigos do
tipo plugin e o comando enquete é o nome dado ao plugin.
Figura 21 – Criando um Plugin.
Fonte: Autoria Própria.
Na Figura 22 pode-se observar a estrutura de pastas gerada a partir do comando executado na Figura 21. Algumas pastas deve-se ter uma maior atenção, como a pasta generators a onde temos o diretório templates onde contém os arquivos
implementado
pelo
usuário,
que
podem
ser
utilizados
pelo
arquivo
enquete_generator.rb, este arquivo tem por objetivo gerar os códigos e mover a
estrutura que esta dentro do plugin na pasta templates para dentro do projeto Ruby on Rails,
a pasta lib contém todo o código Ruby, como modelos, bibliotecas que ficaram
automaticamente disponíveis para a aplicação Ruby on Rails.
Figura 22 – Estrutura criada pelo plugin.
Fonte: Autoria Própria .
31
Também a dois arquivo considerados importantes o init.rb que é carregado toda vez que a aplicação inicia, e o arquivo install.rb que é carregado somente uma vez, no momento da instalação do plugin. Tem-se na Figura 23 o método manifest que tem por objetivo mover os arquivos que estão dentro da pasta templates para os seus devidos lugares. Nas linhas 6 e 7 por exemplo será criado dois arquivos do tipo Javascript que serão colocados na pasta public/javascripts do projeto. Nas linhas 13 até a 20 serão criados os arquivos de
migrações que são responsáveis por manter atualizada a estrutura do banco de dados e também é responsável por aplicar ou reverter às modificações na estrutura do banco de dados.
Figura 23 - Arquivo responsável por gerar os códigos no projeto Rails.
Fonte: Autoria Própria .
As URLs são importantes em aplicações web, contem toda a informação necessária para rotear uma requisição. No Rails as regras de mapeamento de URLs para os controllers é uma questão de configuração. Na Figura 24 pode-se observar a implementação do método add_rotas que tem por objetivo adicionar no arquivo de rotas, conhecido como routes.rb e localizado no diretório config do projeto Rails.
32
Figura 24 – Implementação das rotas do plugin.
Fonte: Autoria Própria .
Para evitar spam ou mensagens disparadas por outros computadores ou robôs, foi implementado um captcha, que será solicitado após o usuário escolher uma opção. Na Figura 23 tem-se um método na linha 22 chamado add_application, sua função é copiar o código das linhas 81 a 91 para dentro do arquivo application.rb localizado dentro de app/controllers, esse código tem como funcionalidade gerar randomicamente um numero que será usado no captcha da enquete.
Figura 25 - Método responsável pelo captcha.
Fonte: Autoria Própria .
33
O Rails possui suporte a internacionalização, onde o Rails chama o seu principal método translate, que traduz o conteúdo procurando um texto de tradução em um arquivo de localidade ( locate), normalmente localizado em config/locales. As localidades são como os idiomas, por exemplo, o em-us representa o Inglês norte-americano, para o português do Brasil representa-se pt-br, a extensão do arquivo de tradução é YAML. Na Figura 23, linha 23 é chamado o método add_ptbr que é responsável por adicionar no arquivo de internacionalização pt-br.yml do projeto Rails, na Figura 26 pode-se observar á implementação desse método.
Figura 26 - Método de Internacionalização do plugin.
Fonte: Autoria Própria .
Na Figura 27 pode-se visualizar a estrutura final do plugin, contendo um conjunto de arquivos e pastas como os controladores, modelos, visão, arquivos de CSS, arquivos de javaScript entre outros.
34
Figura 27 - Estrutura final do Plugin.
Fonte: Autoria Própria .
Na aplicação Rails, por padrão os plugins ficam localizados na pasta vendor/plugins, um plugin pode ser instalado de duas formas, através de uma URL ou
adicionando na pasta padrão, é executando com comando ruby script/generate e mais o nome do plugin. Na Figura 28 é feita a instalação do plugin enquete, onde pode-se notar que o arquivo enquete_generator.rb é chamado e executado os métodos manifest, add_rotas e o add_ptbr . Criando alguns arquivos de migração, pastas e copiando os
arquivos localizados dentro de templates.
35
Figura 28 - Execução do plugin.
Fonte: Autoria Própria .
Na Figura 29 pode-se observar a tela de cadastro para uma nova enquete, onde temos um menu com algumas opções, e uma tela principal de cadastro de uma pergunta e uma opção de adicionar uma nova resposta para a pergunta criada.
Figura 29 - Parte admin do site implementado pelo plugin.
Fonte: Autoria Própria .
O resultado final pode ser observado na Figura 30, onde temos uma enquete com uma pergunta e algumas opções de respostas e um código de segurança.
36
Figura 30 - Resultado Final.
Fonte: Autoria Própria .
A cada opção escolhida pelo usuário é gravado no banco de dados, após a votação, ou até antes de votar ele pode visualizar as estáticas da votação da enquete, na Figura 31 pode-se observar o total de votos, como também qual foi à opção escolhida pelo usuário.
Figura 31 – Resultado final da votação.
Fonte: Autoria Própria .
Ao final de todo esse processo foi desenvolvido um plugin que trará mais agilidade no desenvolvimento de websites.
37
5 CONSIDERAÇÕES FINAIS
5.1
CONCLUSÃO
O Ruby on Rails trouxe uma grande agilidade no desenvolvimento de aplicações web, possuindo tags de interação com HTML, JavaScript, CSS e usando a arquitetura MVC, que visa o aumento da produtividade. Existem alguns fatores que destacam o uso do Ruby on Rails , como o suporte aos principais bancos de dados do mercado. Possui uma grande performance no ganho da produtividade, vem por padrão com o suporte ao framework JavaScript JQuery. Possui o código completamente aberto. No Ruby on Rails existe uma grande facilidade na manutenção de códigos gerados por outros programadores, pois o framework obriga o desenvolvedor a seguir um padrão de desenvolvimento, o que posteriormente facilitará o entendimento do código gerado por ele, e dessa forma aumentando a rapidez na manutenção.
5.2
TRABALHOS FUTUROS/CONTINUAÇÃO DO TRABALHO
Para dar continuidade no trabalho, que se busca para trabalhos futuros é o aprimoramento da declaração de matrí cula no “Sistema SEMEAR”, construindo um plugin para que possa ser usado em outros projetos. No plugin “ENQUETE”, implementar a opção de escolha do cadastro do usuário que votou na enquete.