Monografia da Bruna

CENTRO UNIVERSITÁRIO ESTADUAL DA ZONA OESTEColegiado de Computação e Matemática Aplicada

Curso de Ciência da Computação

Sistema de Enquetes Aplicado em Django

Bruna Esteves da Silva

1

Rio de Janeiro, Brasil2013

Bruna Esteves da Silva

Sistema de Enquetes Aplicado em Django

Monografia apresentada ao Colegiado de Computação e Matemática Aplicada do Centro Universitário Estadual da Zona Oeste, sob orientação do Professor José Luiz Rosa como requisito parcial para obtenção do grau de bacharel em Ciência da Computação.

Rio de Janeiro, junho de 2013

2

Não que sejamos capazes, por nós, de pensar alguma coisa, como de nós mesmos, mas a nossa capacidade vem de Deus.

Bíblia Sagrada (2 Coríntios 3:5)

3

S586 Silva, Bruna Esteves da. Sistema de Enquetes Aplicado em Django. / Bruna

Esteves da Silva. — 2013. 88 f.; 30 cm. Trabalho de Conclusão de Curso (Graduação em

Ciência da Computação)— Centro Universitário Estadual da Zona Oeste, Rio de Janeiro, 2013.

Bibliografia: f. 88-89. 1. Django. 2. Python. 3. Polls. 4. Enquetes.

5. Avaliação de mercado. 6. Avaliações I. Título. CDD 005.133

4

Agradecimentos

A Deus, em primeiro lugar, quero não somente ser grata, mas também

engrandecer Seu nome, pois nada presente neste trabalho é por mérito meu, e sim

por Sua graça que me alcançou. Sua mão que me sustentou até aqui e me

capacitou em mais uma vitória.

Aos meus pais, Jaqueline Esteves e Claudio Antônio por me ensinarem o que

tem real importância na vida, que são exemplo de caráter e bondade, que me

apoiam e sempre serão as pessoas responsáveis por todas as minhas conquistas.

Aos meus professores, que nesta jornada foram chave de conhecimento e

atenção, em especial ao professor José Luiz dos Anjos Rosa, que me orientou neste

processo.

Às minhas irmãs, Patricia Esteves e Priscila da Silva, que acreditam em mim,

mesmo se eu não o fizer, que são exemplo em diversas atitudes e sempre

respeitaram todas as minhas escolhas.

Ao meu cunhado Marcelo, por sua atenção e pré-disposição, pelas horas de

ensino e por sempre ter me amparado quando precisei.

Ao meu namorado Felipe, por seu companheirismo e acima de tudo sua

compreensão pelos dias e meses dedicados à esta monografia e à faculdade, por

ficar feliz pelas minhas realizações e tê-las como suas. Agradeço por suas

constantes demonstrações não só de amor, mas de amizade.

Aos meus amigos da faculdade, Thiogo Paulo, Luana Campos, Suene Mattos

e Thiago Barradas, que me ajudaram tanto durante esses anos, compartilhando

crescimento pessoal, além dos limites da sala de aula.

Aos meus amigos do trabalho, Leonardo Torres, Paulo Cereigido, Gilberto

Rodrigues, Luis Felipe e Marina Melo, por terem me auxiliado tantas vezes na

caminhada do conhecimento, utilizado neste projeto e na vida.

A todos os meus amigos, que acrescentaram algo de valor e me influenciaram

de alguma forma positiva, pois cada um contribuiu para me tornar quem sou hoje.

5

Lista de Tabelas

Tabela 1 – Relação Web X Desktop

Tabela 2 – Relação cargo / salário

Tabela 3 – Relação função / custo

Tabela 4 – Lista de Funcionalidades

Tabela 5 – Descrição do Caso de Uso Realizar Cadastro

Tabela 6 – Validação do Caso de Uso Realizar Cadastro

Tabela 7 – Descrição do Caso de Uso Login

Tabela 8 – Validação do Caso de Uso Login

Tabela 9 – Descrição do Caso de Uso Criar Avaliação

Tabela 10 – Validação do Caso de Uso Criar Avaliação

Tabela 11 – Descrição do Caso de Uso Visualizar Avaliações

Tabela 12 – Descrição do Caso de Uso Manter Avaliações Próprias (Alterar)

Tabela 13 – Descrição do Caso de Uso Manter Avaliações Próprias (Excluir)

Tabela 14 – Descrição do Caso de Uso Votar em Avaliação

Tabela 15 – Validação do Caso de Uso Votar em Avaliação

Tabela 16 – Descrição do Caso de Uso Visualizar mais/menos recentes

Tabela 17 – Descrição do Caso de Uso Visualizar mais/menos votadas

Tabela 18 – Descrição do Caso de Uso Visualizar Avaliações por Categoria

Tabela 19 – Descrição do Caso de Uso Enviar E–mail de Sugestões

Tabela 20 – Validação do Caso de Uso Enviar E–mail de Sugestões

Tabela 21 – Descrição do Caso de Uso Comentar em Avaliações

Tabela 22 – Validação do Caso de Uso Comentar em Avaliações

Tabela 23 – Descrição do Caso de Uso Compartilhar Avaliações

Tabela 24 – Descrição do Caso de Uso Alterar Avaliações

Tabela 25 – Descrição do Caso de Uso Excluir Avaliações

Tabela 26 – Descrição do Caso de Uso Visualizar Relatórios

Tabela 27 – Modelo Físico da tabela Avaliação

Tabela 28 – Modelo Físico da tabela Tipo

Tabela 29 – Modelo Físico da tabela Categoria

Tabela 30 – Modelo Físico da tabela Escolha

Tabela 31 – Modelo Físico da tabela EscolhaDescritiva

6

Lista de Figuras

Figura 1 – Vantagens do uso da internet na busca de informações

Figura 2 – A relação entre Model, View e Controller

Figura 3 – Relação Views, Models e Templates no Django

Figura 4 – Visão geral da UML

Figura 5 – Diagrama de Casos de Uso

Figura 6 – Diagrama de Classes

Figura 7 – Diagrama de Sequência com Caso de Uso de Cadastro

Figura 8 – Diagrama de Sequência com Caso de Uso de Login

Figura 9 – Diagrama de Sequência com Caso de Uso Criar Avaliação

Figura 10 – Diagrama de Sequência com Caso de Uso Alterar Avaliação

Figura 11 – Diagrama de Sequência com Caso de Uso Enviar E–mail de Sugestões

Figura 12 – Diagrama de Sequência com Caso de Uso Excluir Avaliação

Figura 13 – Diagrama de Sequência com Caso de Uso Votar em Avaliação

Figura 14 – Diagrama de Sequência com Caso de Uso Comentar em Avaliação

Figura 15 – Diagrama de Entidade Relacionamento do Sistema

Figura 16 – Servidor Local Django

Figura 17 – Tela de Cadastro

Figura 18 – Tela de Login

Figura 19 – Tela de Logout

Figura 20 – Tela de Contato

Figura 21 – Tela de Filtro Mais Recentes

Figura 22 – Tela de Filtro Mais Votadas

Figura 23 – Tela de Categorias

Figura 24 – Tela de Criação de Avaliação

Figura 25 – Tela de Votação de Avaliação

Figura 26 – Tela de Resultado de Avaliação

Figura 27 – Tela de Alteração de Avaliação

Figura 28 – Tela de Remoção de Avaliação

Figura 29 – Sistema Fuzzy

Figura 30 – Exemplo de Código em Python utilizado no sistema

7

Sumário

1 Introdução................................................................................................................10

1.1 História.................................................................................................................10

1.2 Objetivo do Projeto...............................................................................................11

1.3 Motivação do Projeto............................................................................................12

1.4 Estrutura do Projeto..............................................................................................13

2 Capítulo 1 – Modelagem e Descrição do Sistema..................................................14

2.1 Funcionalidades...................................................................................................14

2.2 Descrição do Sistema...........................................................................................15

2.2.1 Aplicação...........................................................................................................18

2.3 Comparação com o MVC – Model View Controller..............................................19

2.4 Cronograma de Desenvolvimento........................................................................21

2.4.1 Tempo Estimado................................................................................................21

2.4.2 Custo do Processo............................................................................................22

2.4.3 Lista de Funcionalidades...................................................................................25

2.4.4 A UML - Unified Modeling Language................................................................26

2.4.4.1 Diagrama de Casos de Uso...........................................................................28

2.4.4.2 Descrição de Casos de Uso...........................................................................29

2.4.4.2.1 Diagrama de Classes..................................................................................30

2.4.4.2.2 Descrição de Casos de Uso (Tabular).........................................................31

2.4.4.2.3 Diagramas de Sequência............................................................................46

3 Capítulo 2 – Implementação....................................................................................52

3.1 Instalação e Ambientes........................................................................................52

3.1.1 Considerações e Instalação do Python.............................................................52

3.1.2 Considerações e instalação do Django.............................................................55

3.2 Criação do Projeto Django...................................................................................57

3.3 Autenticação e Cadastro de Usuários..................................................................59

3.4 Avaliações............................................................................................................61

3.4.1 Chaves Estrangeiras.........................................................................................62

3.4.1.1 Tipo.................................................................................................................62

8

3.4.1.2 Categoria........................................................................................................63

3.4.1.3 Usuário...........................................................................................................63

3.5 Escolhas...............................................................................................................63

3.5.1 Escolha..............................................................................................................64

3.5.2 EscolhaDescritiva..............................................................................................64

3.6 Páginas.................................................................................................................65

3.6.1 Cadastro............................................................................................................66

3.6.2 Login..................................................................................................................67

3.6.3 Logout................................................................................................................68

3.6.4 Contato..............................................................................................................69

3.6.5 Filtros.................................................................................................................70

3.6.5.1 Mais Recentes................................................................................................70

3.6.5.2 Mais Votadas..................................................................................................71

3.6.6 Categorias.........................................................................................................72

3.6.7 Criar Avaliações.................................................................................................73

3.6.8 Votar em Avaliações..........................................................................................74

3.6.9 Resultados.........................................................................................................75

3.6.10 Manter Avaliações...........................................................................................75

3.6.10.1 Alterar Avaliação...........................................................................................76

3.6.10.2 Deletar Avaliação..........................................................................................77

3.7 Relatórios.............................................................................................................78

3.7.1 Instalação..........................................................................................................80

3.7.1.1 Geraldo Reports.............................................................................................80

3.7.1.2 CairoPlot.........................................................................................................80

3.7.1.3 GnuPlot...........................................................................................................81

3.7.1.3 PyFuzzy..........................................................................................................82

9

Resumo

Esta monografia apresenta um sistema de enquetes e votações para cálculo e

visualização de pesquisas, categoricamente. Com este mecanismo, pode-se

facilmente difundir e analisar resultados adquiridos pela ideia comum a muitos

respondentes. Seu objetivo é mostrar uma forma eficiente de coletar informações e

facilitar o usuário na criação de enquetes, de acordo com suas necessidades. É de

fácil administração e integração de aplicações, podendo ser aplicado em sites com

Django de diversas áreas, devido ao acesso à ferramenta. A implementação do

mesmo, visa construir um modelo informal, onde pesquisadores de determinada

categoria podem ver tendências e opiniões diversificadas, tendo um resultado de

maior aceitação como saída do sistema. O uso de enquetes pode trazer benefícios

sociais, quando aplicados à um meio comum a muitos.

Palavras-Chave: Sistema, Enquetes,Votações, Pesquisa, Benefícios.

10

Abstract

This monograph presents a system of surveys and polls for calculation and

visualization research, categorically. With this mechanism, one can easily spread and

analyze results obtained by the idea common to many respondents. Your goal is to

show an efficient way to collect information and facilitate the user in creating polls,

according to their needs. It is easy to administer and integrate applications, can be

applied to sites with Django in various areas due to access to the tool. The

implementation of the same, aims to build an informal model, where researchers can

see specific category trends and diverse opinions, with a greater acceptance as a

result of the system output. The use of surveys can bring benefits when applied to a

common means to many.

Keywords: System, Polls, Polls, Survey, Benefits.

11

1 Introdução

1.1 História

A história das votações cresceu nacionalmente em paralelo à colonização do

Brasil. Pode-se datar as primeiras ocorrências baseado no tempo da chegada dos

portugueses e sua tradição política centralizadora.

Devido à expansão, havia a necessidade de administradores para domínio de

faixas de terra então fundadas e manutenção da unidade organizacional, bem como

conselhos e eleições para escolha dos mesmos.

Hoje, a ideia do voto é de suma importância como movimento civil no

exercício de direitos, incluindo inúmeros setores da sociedade. Este conceito foi

amplamente difundido, tornando-o aplicável ao meio comum não somente para

escolha de ocupação de um cargo mas também para votações baseadas em

entretenimento, tornando esta prática informal e acessível.

Como resposta à abrangência de conteúdos e temas, tem-se a análise de

tendências de moda, culinária, música e outros, beneficiando dentre outros setores,

o mercado. A divulgação está entre os fatores mais importantes desta área, senão o

essencial, e não há como não citar o principal meio de veiculação de informações, a

“rede”.

Na internet, pode-se visualizar a diversidade de dados e transferência dos

mesmos, referentes a múltiplos usuários, de diferentes níveis, orientações e

opiniões, tornando-se o maior fórum global de comunicação, sobre os mais variados

assuntos. Ela disponibiliza uma grande remessa de produtos e serviços, incluindo

documentos, interligados através de conexões, para cada dia mais proporcionar

conforto na realização de atividades necessárias ao que usufrui deste mecanismo.

A adaptação das avaliações à realidade atual ajuda os usuários à

atualizarem-se e tem o papel de influênciar, para muitas vezes se tornar fator

responsável pela tomada de decisões.

12

1.2 Objetivo do Projeto

O objetivo deste modelo de pesquisa é, basicamente, mostrar na aplicação

web o uso com base em dados coletados, podendo-se obter avaliações que podem

ser de realidade física, econômica ou social, visualizando relatórios textuais e

estatísticos (como no IBGE - Instituto Brasileiro de Geografia e Estatística), como

também gráficos (barra, pizza e linha), representando divisões, distribuições e

tendências de um público que age como matéria-prima para obtenção de resultados.

Para análise de mercado, por exemplo, é fundamental a noção de critérios

estatísticos, para base da futura concretização do negócio, considerando os

consumidores e suas características, bem como aspectos da atualidade no

empreendedorismo.

A fase de controle de qualidade das respostas, em contramão, não fica a

cargo do sistema, e sim trata da necessidade de inclusão do fator pessoal para a

obtenção da mesma.

A presença de relatórios torna o acompanhamento ativo quando comparado

ao mundo externo, gastando-se menos tempo e organizando a análise de resultados

modo a possibilitar um melhor “feedback” para progressão da pesquisa.

Uma boa questão a ser observada é a quebra de paradigma relacionado à

amostra de dados e confiabilidade dos mesmos dentro deste universo on-line. O que

se precisa embutir no senso comum é o fato de que esta inclusão digital não muda

de alguma forma negativa nenhum dos componentes do processo, pelo contrário,

pois existe maior aceitação quando o usuário não é intimidado pela presença

humana.

Este sistema de avaliações estará apto a informar ao usuário a resposta às

dúvidas com relação ao tema de seu interesse, gerindo formulários sobre questões

livres, onde a opinião do utilizador será aberta para críticas e comentários, e

questões fechadas, onde as respostas possíveis serão pré-definidas, além de

visualizar votações e avaliações mais comuns de diferentes categorias.

O sharing de assuntos relevantes ao usuário se dará por meio das mais

13

populares redes sociais, pela facilidade de divulgação e disseminação ao público-

alvo, usando-as também para login com praticidade e rapidez.

A implementação dessas avaliações será dado a partir do framework de alto

nível escrito na linguagem Python, fornecendo ao desenvolvedor e usuário um

ambiente limpo e de simples estrutura, possibilitando a eficiência deste sistema web.

A modelagem se dará com base nos conceitos da Análise Orientada a

Objetos, explicitando os diagramas necessários para o conjunto de informações e

processos referentes ao projeto.

1.3 Motivação do Projeto

A inclusão da tecnologia em meios de pesquisa não é nova no que diz

respeito à verdades científicas, onde o principal objetivo é que, com base em

resultados concretos, forneça o desenvolvimento essencial para a ocorrência de

melhoras significativas em processos já existentes ou em surgimento.

Com o fator de crescimento desta área, a cada ano são inseridos inúmeras

novas ferramentas e metodologias para agilidade deste processo e pode-se

entender a possibilidade de ágil entendimento dos pesquisadores quanto ao

mercado em que estão inseridos.

Conforme pensamento do porta-voz da Market Research Society Richard

Windle, explícito pela eCGlobalSolutions (Dezembro, 2011), “A pesquisa on-line

oferece muitas oportunidades, a maioria ainda inexplorada. Este é, portanto, um

ótimo momento para as empresas considerarem a possibilidade de pesquisas on-

line como uma área de crescimento para o futuro. No entanto, é importante que o

seu potencial significativo seja explorado corretamente.”

14

Graficamente, tem-se a representação do exposto:

Figura 1- Vantagens do uso da internet na busca de informações

(http://www3.unisul.br/paginas/ensino/pos/linguagem/0903/08.htm - Acessado em

23/08/2012, Marcio Antônio de Moraes)

1.4 Estrutura do Projeto

No capítulo 1 será descrito o ambiente, especificando o seu modelo de

desenvolvimento de software em comparação com o Model-View-Controller (MVC),

a descrição do sistema, explicitando detalhadamente cada processo com suas

entidades e relacionamentos, tendo como meta a identificação de restrições de

acesso, requisitos do sistema, funcionais e não-funcionais, bem como os requisitos

de desenvolvimento e manutenção.

O sistema terá como base uma aplicação web direcionada à banco de dados,

apresentando os benefícios e características do Django nesta implementação.

O objetivo do primeiro capítulo será a fase de análise de todo o processo,

testificando a importância da mesma para a operabilidade do sistema.

Serão vistos os diagramas: de classe, exemplificando a estrutura e

relacionamento entre as tabelas, de sequencia, mostrando mensagens entre os

objetos e de casos de uso, seguido da descrição de cada funcionalidade. Não será

15

http://www3.unisul.br/paginas/ensino/pos/linguagem/0903/08.htm

exemplificado o diagrama de estados, por se tratar de uma aplicação online não

robusta o suficiente.

1.5 Metodologia do Projeto

Ferramenta de Pesquisa

A maioria das informações sobre programação são encontradas na internet,

em documentações de módulos, linguagens, etc... As pesquisas para

desenvolvimento deste projeto foram feitas neste meio, onde existem muitos fóruns

com solução de problemas que os desenvolvedores sempre esbarram em seu dia a

dia.

A modelagem

Python é uma linguagem naturalmente orientada a objetos desde o início. Isto

quer dizer que os conceitos de objetos estão escondidos atrás de conceitos

avançados como sobrecarga de operadores, herança múltipla e introspecção. Foi

utilizado UML para a precisão de visualização da comunicação entre objetos.

2 Capítulo 1 – Modelagem e Descrição do Sistema

2.1 Funcionalidades

Tendo em vista que Django é um framework escrito em Python, se faz

necessário ter o mesmo instalado no sistema. Para perfeitas condições deste

framework, a versão favorável é de Python 2.6 a 2.7.

Neste desenvolvimento, pode-se analisar vantagens e desvantagens do

sistema operacional. Para Mac OS X e Linux, na maioria dos casos, o Python já é

um componente presente, agilizando o processo, bem como na instalação de

dependências requeridas. No Windows, é preciso ajustar a variável de ambiente

para incluir processos para execução do Python e seus scripts, dentre outras

configurações necessárias.

16

Além do Django e Python precisa-se integrar a aplicação do banco de dados.

Existem diversas opções oficiais, são elas: PostgreSQL, MySQL, Oracle e SQLite.

Existem também backends para suporte de outros bancos de dados. São eles:

Sybase SQL Anywhere, IBM DB2, Microsoft SQL Server 2005, Firebird e ODBC.

Como descrito anteriormente, pela vantagem de acesso à comandos de

instalação e facilidade, será usado o sistema operacional Linux com distribuição

Ubuntu 11.10.

Para este projeto, tendo sua característica aberta à múltiplos indivíduos em

ambiente web, será um importante requisito do sistema que o usuário não tenha

acesso à todas as funcionalidades, sendo necessário que o mesmo se cadastre para

completa experiência da aplicação.

2.2 Descrição do Sistema

No desenvolvimento do sistema, faz-se necessário identificar, desde o início,

o que o usuário espera e quais restrições serão utilizadas.

Sendo assim, a função primordial do começo deste trabalho é o levantamento

de requisitos e sua documentação, de forma a listar também atividades envolvidas

no processo e continuar com a atividade de modelagem.

Na verdade, torna-se realmente uma árdua tarefa para se chegar à

engenharia, que de acordo com a concepção de Kappel et al.(2006, p. 3), significa:

“engenharia em geral significa a aplicação prática da ciência para o comércio ou

indústria com o objetivo de projetar aplicações ou solicitações feitas, da melhor

maneira, isto é, mais rápida, mais barata, mais segura, etc.”.

Desta forma, lista-se todos os tipos de requisitos do sistema. São eles:

Requisitos Funcionais, Requisitos Não-Funcionais e Restrições.

O primeiro deles, especifica a capacidade que o sistema tem em relação às

funções e serviços que serão oferecidos.

No segundo caso, são descritas as formas desejadas do sistema, como nível

de segurança e qualidade.

As restrições são as causas que podem impedir o projeto de caminhar como

esperado, dificultando ou afetando-o. Tem-se exemplos de orçamento e limitações

17

monetárias, capacidade de equipe, bem como sua competência e experiência para o

desenvolvimento.

O primeiro passo é ter o conhecimento dos interessados no sistema. Deve-se

responder às perguntas : “Quem são os interessados em análise de mercado?”,

“Quem serão os usuários finais?”, “Qual o padrão de comportamento deste nível de

usuário?”,”O que eles procuram?”. Estas são algumas das questões necessárias ao

entendimento do processo de atender às expectativas finais.

Esta tarefa acaba por complicar-se, pois muitas vezes o usuário não sabe o

que realmente quer. Sendo assim, a tarefa de interpretar a real necessidade torna-se

parte da função do desenvolvedor.

O sistema a ser apresentado possui requisitos funcionais no que diz respeito

ao número de profissionais a serem disponibilizados integralmente e aos opcionais.

Pode-se listar somente um desenvolvedor para parte de server e um para a

parte de client do sistema, tendo em vista que, geralmente profissionais dessas

áreas possuem perfis diferentes.

Os opcionais ao sistema são os arquitetos da informação e webdesigners,

presentes geralmente em empresas, com o papel de organização e rotulação de

esquemas de navegação.

Quando uma aplicação a ser desenvolvida é to tipo web, como neste caso,

faz-se necessário analisar diferenças peculiares à características de desktop.

Segue abaixo algumas importantes causas de tomada de tempo e demanda

diferenciada para aplicações web.

Aplicações Web Aplicações Desktop

Imediatismo Geralmente mais curto, podendo variar de dias a

poucas semanas

Geralmente pode durar meses

Segurança São mais suscetíveis à ataques e falhas de segurança pelo alto

número de acessos de diferentes tipos de

pessoas

Mais despreocupado com falhas na segurança, visto

que é limitado a um número específico de usuários dentro de um

grupo

18

Estética Fortemente moldado à parte visual e

comportamento quanto à adequação do público-

alvo

Predomina o lado funcional da aplicação

Tabela 1 – Relação Web X Desktop

O desenvolvedor responsável pela parte de backend realiza toda a parte de

criação de models, views e templates, como o setting do projeto com o ambiente a

ser homologado e o real (produção).

Para este papel é preciso estar apto e ter o conhecimento da linguagem

Python, incorporando todo o processo conhecido em outras como condicionais de

fluxo, listas e dicionários (bastante utilizado), etc… bem como sua instalação no

sistema operacional, controle de versão com os ambientes virtuais, classes, dentre

outros.

Antes da etapa de implementação, é preciso saber toda a estrutura de URLs,

um caso bastante particular no Django, pois é preciso ter conhecimento de

expressões regulares e saber como “setar” cada caso num arquivo separado de

configuração.

Serão utilizados filtros, manipulados objetos de request e response para

aquisição do tratamento de informações provenientes da base de dados.

Para este projeto, não será necessário haver algum validador com a função

de testes, como por exemplo o de unidade. Todo o processo de verificação de

funcionamento estará a cargo do desenvolvedor server.

Para a função de frontend pelo profissional client, será configurada toda a

parte visual, com Javascript e Jquery para objetos que possuem comportamento

diferenciado como destaques, e CSS para comportamento de botões com funções

como por exemplo de envio de informações de contato ou voto.

O sistema operacional a ser utilizado é o Linux, por ser gratuito, mais rápido e

por ser seguro, pois a maioria dos vírus são criados para o Windows e suas

aplicações.

19

O objetivo do uso do Django nesta aplicação web é a agilidade e clareza ao

cliente e usuário da resposta desejada.

2.2.1 Aplicação

Um usuário entrará no site e poderá, sem qualquer requisito visualizar

avaliações de mercado, realizar filtros de conteúdo, navegando pelo site. Poderá

também usufruir de resultados das avaliações.

As avaliações estarão totalmente sobre o julgo do administrador, que poderá

incluir, excluir e alterá-las.

Para cadastrar-se, com intuito de usufruir de funcionalidades restritas como

incluir e manter avaliações, o usuário deverá clicar em cadastre-se e incluir suas

informações num formulário padrão de dados, submetendo-os à inclusão no banco.

Tendo realizado o cadastro, o usuário será redirecionado à home page e poderá

clicar e acessar suas informações no link “Minha Conta", onde ficarão disponíveis

listas de avaliações, inclusão e funções de alteração e exclusão, o resultado e

quantidade de votos obtidos, e o link de cada avaliação.

Ao clicar numa avaliação, poderão ser visto comentários e discussões sobre o

tema na página da mesma.

Existirão conteúdos filtrados por itens mais recentes, temas e quantidade de

votos.

Se houver qualquer tipo de abuso, ou denúncia via e-mail de sugestões, o

problema será tratado pelo administrador.

Existirá uma página destinada ao envio de dúvidas e quaisquer comentários

ou sugestões, sendo necessária a inclusão dos dados nome e e-mail do remetente.

Na criação da avaliação, será possível a escolha do usuário quanto ao tipo de

questão, ou seja, haverá a disponibilidade de perguntas com respostas pré-

estabelecidas (múltipla escolha) e respostas livres, com um limite de caracteres.

A avaliação poderá ser compartilhada por redes sociais, dadas por widgets da

rede, com livre divulgação do conteúdo.

20

O administrador poderá dar acesso à usuários específicos, se assim o quiser,

pela possibilidade de manter grupos com permissões restritas no Django.

O voto em toda e qualquer avaliação será livre de todo e qualquer requisito.

A parte mais importante deste processo, é a geração de relatórios, sendo eles

mistos, com partes gráficas e textuais.

Na parte gráfica, será implementado o conceito de lógica fuzzy e análise de

dados, submetendo processos em Python acoplados ao desenvolvimento web.

Na parte textual, o relatório terá o resultado impresso num arquivo formal,

exibindo dados, acoplando o conceito de estatística ao mesmo.

2.3 Comparação com o MVC – Model View Controller

Para se comparar algo, é preciso saber detalhadamente o significado e

características dos tipos em questão.

O MVC é um padrão hoje amplamente discutido e utilizado tanto em

softwares como em frameworks, que possui arquitetura de modo a disponibilizar a

divisão do sistema em camadas e tem o objetivo do mapeamento de tarefas

tradicionais de entrada, processamento e saída.

O principal foco desta arquitetura é a independência entre os componentes de

cada uma camada de modo a separar a lógica de negócio do sistema.

A camada Model (Modelo) é a camada responsável pela manipulação de toda

informação, ou seja, cuida das regras de negócio que governam o acesso e a

modificação de dados.

A camada View (Visualização) trata da renderização do conteúdo e

encaminha as ações do usuário ao controller. É a interface com o utilizador do

sistema.

A camada Controller (Controlador) define como a aplicação irá se comportar,

tem a função de intermediar o processo entra o Model e a View identificando qual a

função a ser executada, a chamada da view e o modelo a ser processado.

21

Figura 2 - A relação entre Model, View e Controller

(http://www.ryanpadilha.com.br/en/2011/08/design-pattern-mvc-%E2%80%93-

arquitetura-de-software-coesa-e-flexivel-revista-active-delphi-2/ - Acessado em 23-

08-2012, Ryan Padilha)

No Django, existe uma interpretação diferente do MVC tradicional no que diz

respeito da separação de funções entre view e controller.

Na View, o objetivo é a descrição de quais dados são vistos, e não como são

vistos, ou seja, é uma função Python de callback chamada por uma URL.

O Controller, no Django, é o próprio framework, que é a máquina que trata a

view adequada de acordo com a configuração de URLs.

Na estrutura padrão do Django têm-se os templates, e é aí onde entram as

views do processo. Neste espaço são tratadas como as informações serão vistas

pelo usuário. São os arquivos html do sistema.

No caso de siglas, pode-se entender o Django como MTV – Model – Template

- View, respectivamente às funções do padrão original.

22

http://www.ryanpadilha.com.br/en/2011/08/design-pattern-mvc-%E2%80%93-arquitetura-de-software-coesa-e-flexivel-revista-active-delphi-2/

http://www.ryanpadilha.com.br/en/2011/08/design-pattern-mvc-%E2%80%93-arquitetura-de-software-coesa-e-flexivel-revista-active-delphi-2/

Figura 3 – Relação Views, Models e Templates no Django

(http://www.profissionaisti.com.br/2009/04/entendendo-o-django/ - Acessado em

23/08/2012, Klaus Peter Laube)

2.4 Cronograma de Desenvolvimento

2.4.1 Tempo Estimado

A principal característica do Django é a rapidez do desenvolvimento em

projetos aplicados.

O funcionamento do processo atende à esta afirmação, porém a parte visual e

adaptação das informações ao layout demandam maior tempo de execução.

Em média, o funcionamento de todos os componentes do lado backend ficam

prontos em um mês, de trabalho contínuo de 6 horas por dia, acoplados à

especificação de tratamento de erros.

23

http://www.profissionaisti.com.br/2009/04/entendendo-o-django/

Já o lado de arquitetura da informação e design estendem esse processo por

em média 2 meses de validação de estrutura da aplicação, navegabilidade e clareza

ao usuário.

2.4.2 Custo do Processo

Para a estipulação do custo do processo, existem várias fórmulas de cálculo.

O mesmo pode ser feito a partir de informações, como o custo de aplicação, os

sistemas usados e seu salário.

O custo – hora de profissionais muitas vezes está mais ligado à sua

experiência do que ao trabalho exercido sobre o sistema como também a empresa

em que trabalha.

O fato é que o tamanho do problema e o tempo gasto na resolução é muito

menor quando tratado por desenvolvedores mais aptos e experientes em processos

de testes, porém nem todos os processos são iguais. O processo em questão possui

documentação que abrange inúmeros tutoriais, fóruns e ferramentas de teste de

unidade por exemplo, o que torna ainda mais acessível à profissionais que

começaram sua carreira há pouco tempo.

O custo, neste projeto, também está ligado à resposta à questões cotidianas e

principalmente ao benefício trazido ao cliente após o resultado. Neste caso, a

importância do projeto também é levada em conta.

O custo – hora de profissionais deste nível de abstração de linguagens

adequado ao processo, varia muito. Na tabela a seguir, pode-se ter uma visão deste

processo:

CARGO SALÁRIO/HORA SALÁRIO/MÊS

PROGRAMADOR - -

PROGRAMADOR ABAP R$44,67 R$5.105,11

ASSISTENTE

INFORMÁTICAR$12,22 R$1396,18

WEB DESIGNER R$19,20 R$2.193,10

24

WEBMASTER R$31,09 R$3.551,66

COORDENADOR DE

DESENVOLVIMENTOR$50,61 R$5.783,79

Tabela 2- Relação cargo / salário ( http://www.rhinfo.com.br/sal-ti.htm#p , Acessado

em 23/08/2012)

Baseado no tempo de desenvolvimento descrito acima, pode-se obter parte

do custo pela quantidade de horas multiplicada pelo valor, durante 5 dias por

semana e dentro de 2 meses de entregar o projeto, e arredondando para R$50,00 a

hora de serviço do programador com experiência (em comparação ao programador

ABAP). O gasto de desenvolvimento seria de então R$6.000 por desenvolvedor.

Para o web designer, com seu custo-hora de aproximadamente R$20,00, o valor

gasto com esse profissional no mês seria de R$2400,00. Assim seguem descritos

na tabela os gastos com 1 programador e 1 web designer:

FUNÇÃO TEMPO/SERVIÇO PREÇO/HORA TOTAL

PROGRAMADOR/

DESENVOLVEDOR

2 MESES R$50,00 R$6000,00

WEB DESIGNER 2 MESES R$20,00 R$2400,00

- - - R$8400,00

Tabela 3 - Relação Função / Custo

Existem outros fatores que variam este valor. O gasto de fatores ambientais

como luz e alimentação também podem estar incluídos.

Por exemplo, em média os monitores e desktops, que em geral podem

facilitar o desempenho do link com a internet, são utilizados e por somente

conectados (mesmo que estejam desligados) consomem 100mA. Durante 4 horas,

obtem-se 0.407 kWh, ou seja 0,6105 kWh em 6 horas e 18,315 kWh em 1 mês.

25

Tendo como parâmetro que cada kWh cobrado, na cidade do Rio de Janeiro

custa aproximadamente R$ 0,42 , durante dois meses, totalizando R$ 36,06.

Neste projeto não será necessária a compra de ferramentas de

desenvolvimento, pois IDEs com suporte ao Django como o Eclipse, servidores web

como o Apache, o Linux que é Software Livre e todos os outros elementos

necessários ao projeto são gratuitos.

A parte de manutenção do sistema será cobrada a cada nova modificação,

não incluindo inclusão de conteúdo, visto que o mesmo será feito pela parte do autor

das avaliações, e irá variar de acordo com a nova funcionalidade e seu impacto nos

processos adjacentes.

26

2.4.3 Lista de Funcionalidades

NR Funcionalidade Requisito Descrição

1 Usuário se Cadastra

- Envio de informações pessoais a serem salvas no

banco

2 Usuário Vota na Avaliação

- Inclusão para contabilidade de votos

3 Usuário Lista mais

votadas

- Ranking de Avaliações

4 Usuário busca por Categoria

- Busca por filtro do Django por categorias

5 Usuário envia e-mail de Sugestões

- Envio de e-mail para o e-mail cadastrado na aplicativo Django

6 Usuário comenta em Avaliação

- Utilização do aplicativo de comentários Django

7 Usuário Compartilha

Avaliação em Redes Sociais

- Integração de redes Sociais com o Django

8 Usuário cria sua Avaliação

Logado Envio de requisitos básicos para Avaliações

9 Usuário visualiza suas Avaliações

Logado Lista de Avaliações incluídas pelo usuário

10 Usuário mantém Avaliações

Logado Usuário logado pode alterar ou excluir sua

Avaliação

11 Administrador mantém avaliações

Logado As avaliações fazem parte do sistema para

entretenimento

27

12 Administrador visualiza relatórios gráficos, textuais e

mistos das Avaliações gerados

pelo sistema

Logado Apenas o administrador poderá visualizar relatórios,

até que o mesmo dê permissão ao usuário para

visualizá-los

13 Administrador mantém usuários e

grupos

Logado Administrador poderá excluir a qualquer momento

os dados de um usuário, bem como alterar

permissões

Tabela 4 - Lista de Funcionalidades

2.4.4 A UML - Unified Modeling Language

A Linguagem de Modelagem Unificada foi padronizada pelo OMG (Object Management Group) e especificou como : "The Unified Modeling Language (UML) is a graphical language for visualizing, specifying, constructing, and documenting the artifacts of a software-intensive system. The UML offers a standard way to write a system's blueprints, including conceptual things such as business processes and system functions as well as concrete things such as programming language statements, database schemas, and reusable software components” .

Seu significado traduzido é: "A Unified Modeling Language (UML) é uma linguagem gráfica para visualizar, especificar, construir e documentar os artefatos de um sistema de software intensivo. A UML oferece uma maneira padrão para escrever projetos de um sistema, incluindo partes conceituais tais como processos de negócios e funções do sistema, bem como partes concretas, tais como declarações da linguagem de programação, esquemas de banco de dados e software reutilizáveis componentes. "

A UML será usada neste projeto para especificação da aplicação a ser desenvolvida com a diagramação feita no software Umbrello.

Esta linguagem fornece precisão de visualização de comunicação entre objetos.

28

A análise feita com UML é utilizada para visualizar sistemas orientados a objetos, e com isto poder representar diferentes partes do sistema, mudando o foco e objetivo quando visualizados por seus elementos na criação de diagramas.

Figura 4 – Visão geral da UML (http://evertongomede.blogspot.com.br/2010_09_01_archive.html - Acessado em

27/08/2012, Everton Gomede)

29

http://evertongomede.blogspot.com.br/2010_09_01_archive.html

2.4.4.1 Diagrama de Casos de Uso

Figura 5 – Diagrama de Casos de Uso

Neste diagrama estão descritos os principais elementos do sistema, com base no processo de ações requeridas pelo usuário e funções do administrador.

Tem a função de mostrar os possíveis uso da aplicação, ignorando a organização interna do sistema.

Exemplifica o que o sistema realiza e não a maneira que o executa.

Um caso de uso são ações sequencialmente relacionadas que um sistema realiza para produzir um resultado visível com valor para o ator que o executou.

A relação <<includes>> descrita acima tem relação com a restrição de acesso (login) às funcionalidades de criação e manutenção de avaliações pelo usuário.

30

2.4.4.2 Descrição de Casos de Uso

• Realizar Cadastro: Um usuário clica no link “Cadastre-se” ou tenta acessar

alguma funcionalidade restrita e é notificado que é preciso estar logado. Sendo assim, o mesmo preenche o formulário de cadastro na página a qual foi redirecionada e conclui com o redirecionamento à Home.

• Login: Um usuário clica no link “Login” ou tenta acessar alguma

funcionalidade restrita e é notificado que é preciso estar logado. Sendo assim, o mesmo preenche o formulário de login na página a qual foi redirecionada e conclui com o redirecionamento à Home.

• Criar Avaliação: Um usuário (logado) clica em “Criar Avaliação”, sendo

redirecionado a um formulário com os tipos possíveis de avaliações (aberta e múltipla escolha), cadastrando respostas pré-definidas no último caso, dentre outros atributos relativos à avaliação. Por fim, é redirecionado para a página correspondente à avaliação criada.

• Visualizar Avaliações: Um usuário (logado) clica em “Minhas Avaliações”,

obtendo uma lista de suas avaliações criadas, com especificações como data de criação e atributos correspondentes.

• Manter Avaliações Próprias: Um usuário (logado) pode excluir ou alterar sua

avaliação, sendo notificado ao final de cada ação.

• Votar em Avaliação: Um usuário pode clicar em uma resposta pré-definida ou

digitar num campo de texto e enviar seu voto para contabilização.

• Visualizar mais/menos votadas: Um usuário tem a opção de visualizar as

avaliações com maior popularidade e menos popularidade.

• Visualizar mais/menos recentes: Um usuário tem a opção de visualizar as

avaliações com data de criação mais recentes e menos recentes.

• Buscar por Categoria: Um usuário tem a opção de clicar na categoria de sua

escolha e listar avaliações por tipo.

• Enviar e-mail de Sugestões: Um usuário poderá preencher um formulário com

sugestões e/ou reclamações a ser enviado para o e-mail configurado na aplicação de envio de e-mails acoplada à aplicação de avaliações web.

31

• Comentar em Avaliação: Um usuário poderá comentar na avaliação de sua

escolha utilizando seu login do Intense Debate, Wordpress ou colocar seu nome na ferramenta de comentários.

• Compartilhar Avaliação: Um usuário poderá compartilhar a avaliação de forma

a divulgá-la para outros, pela interação com o Facebook.

• Manter Avaliações Públicas: O administrador está apto a realizar qualquer

alteração em avaliações diárias e criadas para divulgação do site com assuntos populares e públicos.

• Visualizar Relatórios: O administrador estará encarregado de visualizar

relatórios de todas as formas, podendo divulgá-lo à usuários.

Com a descrição acima, pode-se notar a presença das classes: Usuário, Avaliação, Escolha Descritiva, Escolha e Administrador.

2.4.4.2.1 Diagrama de Classes

Figura 6 – Diagrama de Classes

Estão listados acima os atributos e métodos passíveis de execução pelas classes.

32

Para construção deste diagrama, é preciso acoplar as informações provenientes do diagrama de casos de uso com a análise dos atributos e métodos dos atores.

As propriedades são as informações específicas de cada classe.

Os métodos acima são as ações que podem ser executadas pelos objetos de cada classe.

A preocupação neste caso está na especificação de todas as propriedades de cada classe que têm interação com o sistema, bem como os métodos que cada uma pode executar e a cardinalidade entre os objetos.

2.4.4.2.2 Descrição dos Casos de Uso - Tabular

2.4.4.2.2.1 Realizar Cadastro

Realizar Cadastro

Ações do Usuário Ações do Sistema

1. O usuário clica no link “Cadastre-se” presente no menu presente no topo da página.

2. Sistema redireciona o usuário à página de cadastro, onde existe a interface de autenticação com os campos necessários ao reconhecimento do mesmo.

3. O usuário preenche os campos relativos aos seus dados e clica no botão “Enviar”

4. Sistema verifica se os campos obrigatórios foram preenchidos.

5. Sistema verifica se o e-mail informado é igual a um e-mail já cadastrado.

33

6. Sistema verifica se o campo de confirmação de senha tem o valor igual ao valor do campo senha.

7. Sistema redireciona o usuário para a página inicial, mostrando o login numa saudação no menu.

Tabela 5 – Descrição do Caso de Uso Realizar Cadastro

2.4.4.2.2.1.1 Validação de Exceções de Realizar Cadastro

Validações do Caso de Uso “Realizar Cadastro”

1. Os campos obrigatórios precisam estar preenchidos.

2. O e-mail preenchido precisa ser diferente de todos os e-mails já cadastrados na base de dados.

3. O username preenchido precisa ser diferente de todos os e-mails já cadastrados na base de dados.

4. O valor do campo de confirmação de senha deve ser o mesmo do campo da senha.

Fluxo de Exceção I - Campos obrigatórios vazios.

1. Sistema comunica ao usuário com mensagens explicativas e indicativas que o campo vazio deve ser preenchido.

Fluxo de Exceção II – E-mail já cadastrado na base de dados.

1. Sistema comunica ao usuário com a mensagem explicativa: “Já existe um usuário com este e-mail”

Fluxo de Exceção III - Username já cadastrado na base de dados.

34

1. Sistema comunica ao usuário com a mensagem explicativa: “Já existe um usuário com este username”

Fluxo de Exceção IV – Confirmação de senha com valor diferente do campo senha.

1. Sistema comunica ao usuário com a mensagem explicativa: “Confirmação da senha não confere!”

Tabela 6 – Validação do Caso de Uso Realizar Cadastro

2.4.4.2.2.2 Login

Login


1. O usuário clica no link “Entrar” presente no menu presente no topo da página à direita.

2. Sistema redireciona o usuário à página de login, onde existe a interface de autenticação com os campos necessários ao reconhecimento do mesmo.

3. O usuário preenche os campos relativos aos seus dados e clica no botão “Enviar”


5. Sistema verifica se os dados preenchidos são capazes de autenticar o usuário.

35

6. Sistema redireciona o usuário para a página inicial, mostrando o login numa saudação no menu.

Tabela 7 – Descrição do Caso de Uso Login

2.4.4.2.2.2.1 Validação de Exceções de Login

Validações do Caso de Uso “Login” 1. Os campos obrigatórios precisam estar preenchidos.

2. Os dados de usuário e senha precisam ser iguais aos presentes na base de dados associados (os dados) ao usuário.


1. Sistema comunica ao usuário que os dados estão incorretos.

Fluxo de Exceção II – Dados de usuário incorretos para autenticação.

1. Sistema comunica ao usuário com a mensagem explicativa: “Dados Incorretos. Por favor, tente novamente.”

Tabela 8 – Validação do Caso de Uso Login

36

2.4.4.2.2.3 Criar Avaliação

Criar Avaliação

Pré-Condição Executar o Caso de Uso “Login”


1. O usuário (logado) clica no link “Criar Avaliação” agora presente no menu presente no topo da página.

Nota: O menu foi modificado no momento do login

2. Sistema redireciona o usuário à página de criação, onde existe a interface com as avaliações, com os campos necessários para preenchimento de seus dados.

3. O usuário preenche os campos relativos à sua avaliação e clica no botão “Criar”


Tabela 9 – Descrição do Caso de Uso Criar Avaliação

2.4.4.2.2.3.1 Validação de Exceções de Criar Avaliação

Validações do Caso de Uso “Criar Avaliação”



1. Sistema comunica ao usuário que o preenchimento dos campos é

37

obrigatório.

Tabela 10 – Validação do Caso de Uso Criar Avaliação

2.4.4.2.2.4 Visualizar Avaliações

Visualizar Avaliações

Pré-Condição Executar o Caso de Uso “Login”


1. O usuário clica no link “Minha Conta/Minhas Avaliações” no menu presente no topo da página à direita.

2. Sistema redireciona o usuário à página de avaliações associadas ao seu username, onde existe a interface de suas avaliações com os dados de sua criação e suas possíveis ações relacionadas.

Tabela 11 – Descrição do Caso de Uso Visualizar Avaliações

2.4.4.2.2.5 Manter Avaliações Próprias (Alterar)

Manter Avaliações Próprias (Alterar)

Pré-Condição Executar o Caso de Uso “Login” e “Visualizar Avaliações”


1. O usuário clica no botão “Alterar” presente abaixo da descrição de cada

38

uma de suas avaliações.

2. Sistema redireciona o usuário à página de alteração da avaliação associada à sua requisição com os dados do banco equivalentes a cada campo.

3. Usuário altera o campo de sua preferência e clica em “Alterar”

4. Sistema redireciona o usuário à página da avaliação já com os dados alterados para sua visualização.

Tabela 12 – Descrição do Caso de Uso Manter Avaliações Próprias (Alterar)

2.4.4.2.2.6 Manter Avaliações Próprias (Excluir)

Manter Avaliações Próprias (Excluir)

Pré-Condição Executar o Caso de Uso “Login” e “Visualizar Avaliações”


1. O usuário clica no botão “Excluir” presente abaixo da descrição de cada uma de suas avaliações.

2. Sistema redireciona o usuário à mesma página, porém com a avaliação excluída.

Tabela 13 – Descrição do Caso de Uso Manter Avaliações Próprias (Excluir)

39

2.4.4.2.2.7 Votar em Avaliação

Votar em Avaliação


1. O usuário clica no botão “Votar” presente abaixo da descrição de sua avaliação ou que está visualizando.

2. Sistema redireciona o usuário à página de votação da avaliação, com os dados de criação da mesma e também os campos relativos à seu tipo.

3. Usuário preenche o campo com sua idade e sexo, juntamente com sua resposta à avaliação e clica em “Votar”

4. Sistema verifica se os campos obrigatórios estão preenchidos.

5. Sistema redireciona o usuário à página com o resultado parcial (atualizado).

Tabela 14 – Descrição do Caso de Uso Votar em Avaliação

40

2.4.4.2.2.7.1 Validação de Exceções de Votar em Avaliação

Validações do Caso de Uso “Votar em Avaliação”



1. Sistema comunica ao usuário que o preenchimento dos campos é obrigatório.

Tabela 15 – Validação do Caso de Uso Votar em Avaliação

2.4.4.2.2.8 Visualizar Mais/Menos Recentes

Visualizar Mais/Menos Recentes


1. O usuário clica no link “Filtros/Mais Recentes” no menu presente no topo da página.

2. Sistema redireciona o usuário à página de avaliações múltipla escolha ordenadas pela data de criação.

Tabela 16 – Descrição do Caso de Uso Visualizar mais/menos recentes

41

2.4.4.2.2.9 Visualizar Mais/Menos Votadas

Visualizar Mais/Menos Votadas


1. O usuário clica no link “Filtros/Mais Votadas” no menu presente no topo da página.

2. Sistema redireciona o usuário à página de avaliações múltipla escolha ordenadas pela quantidade de votos.

Tabela 17 – Descrição do Caso de Uso Visualizar mais/menos votadas

2.4.4.2.2.10 Visualizar Avaliações por Categoria

Visualizar Avaliações por Categoria


1. O usuário clica no link “Categorias” no menu presente no topo da página.

2. Sistema redireciona o usuário à página de categorias, que mostra a lista de todas cadastradas no sistema.

Tabela 18 – Descrição do Caso de Uso Visualizar Avaliações por Categoria

42

2.4.4.2.2.11 Enviar E-mail de Sugestões

Enviar E-mail de Sugestões


1. O usuário clica no link “Contato” no menu presente no topo da página.

2. Sistema redireciona o usuário à página de envio de e-mail (presente nas configurações), que mostra o formulário com os dados para contato.

3. Usuário preenche os dados do formulário (nome, e-mail e mensagem) e clica em “Enviar Mensagem”.

4. Sistema verifica se os campos obrigatórios estão preenchidos.

5. Sistema redireciona o usuário à mesma página com uma mensagem de envio concluído.

Tabela 19 – Descrição do Caso de Uso Enviar E-mail de Sugestões

43

2.4.4.2.2.11.1 Validação de Exceções de Enviar E-mail de Sugestões

Validações do Caso de Uso “Enviar E-mail de Sugestões”



1. Sistema comunica ao usuário que o preenchimento dos campos é obrigatório.

Tabela 20 – Validação do Caso de Uso Enviar E-mail de Sugestões

2.4.4.2.2.12 Comentar em Avaliação

Comentar em Avaliação


1. O usuário clica em qualquer link de avaliação presente no site.

2. Sistema redireciona o usuário à página da avaliação conforme a requisição.

3. Usuário preenche os dados do formulário (nome, e-mail e website(opcional)) e clica em “Enviar”.

4. Intense Debate verifica se os campos obrigatórios estão preenchidos.

Tabela 21 – Descrição do Caso de Uso Comentar em Avaliações

44

2.4.4.2.2.12.1 Validação de Exceções de Comentar em Avaliação

Validações do Caso de Uso “Comentar em Avaliação”



1. Intense Debate comunica ao usuário que o preenchimento dos campos é obrigatório.

Tabela 22 – Validação do Caso de Uso Comentar em Avaliações

2.4.4.2.2.13 Compartilhar Avaliação

Compartilhar Avaliação


1. O usuário clica no botão “Compartilhar”, presente em todas as páginas de avaliação do site.

2. Uma nova janela do Facebook é criada com os dados do link e a área de mensagem.

3. Usuário preenche a mensagem (opcional) e clica em “Compartilhar”.

Tabela 23 – Descrição do Caso de Uso Compartilhar Avaliações

45

2.4.4.2.2.14 Manter Avaliações

2.4.4.2.2.14.1 Alterar

Manter Avaliações (Alterar)

Pré-Condição Login pela url de administração


1. Administrador clica no link “Avaliações”, presente na home de administração.

2. Sistema redireciona o usuário à lista de avaliações cadastradas.

3. Administrador clica na avaliação que quer alterar.

4. Sistema redireciona o usuário à página da avaliação.

5. Administrador altera o formulário e clica em salvar.

Tabela 24 – Descrição do Caso de Uso Alterar Avaliações

2.4.4.2.2.14.2 Excluir

Manter Avaliações (Excluir)

Pré-Condição Login pela url de administração


1. Administrador clica no link “Avaliações”, presente na home de

46

administração.

2. Sistema redireciona o usuário à lista de avaliações cadastradas.

3. Administrador checa as avaliações que quer excluir e seleciona a ação “Remover avaliações selecionadas”

4. Sistema confirma a ação.

5. Administrador visualiza a lista de avaliações atualizada.

Tabela 25 – Descrição do Caso de Uso Excluir Avaliações

2.4.4.2.2.15 Visualizar Relatórios

Visualizar Relatórios


1. O usuário digita o link do relatório de acordo com o tipo desejado.

2. Sistema redireciona o usuário à página do relatório em pdf.

Tabela 26 – Descrição do Caso de Uso Visualizar Relatórios

47

2.4.4.3 Diagramas de Sequência

Figura 7– Diagrama de Sequência com Caso de Uso de Cadastro

Figura 8– Diagrama de Sequência com Caso de Uso de Login

Figura 9– Diagrama de Sequência com Caso de Uso Criar Avaliação

48

Figura 10- Diagrama de Sequência com Caso de Uso Alterar Avaliação

Figura 11 – Diagrama de Sequência com Caso de Uso Enviar E-mail de Sugestões

Figura 12 – Diagrama de Sequência com Caso de Uso Excluir Avaliação

49

Figura 13 – Diagrama de Sequência com Caso de Uso Votar em Avaliação

Figura 14 – Diagrama de Sequência com Caso de Uso Comentar em Avaliação

50

2.4.4.4 DER – Diagrama Entidade Relacionamento

Figura 15 – Diagrama de Entidade Relacionamento do Sistema

2.4.4.5 Modelo Fĩsico

Avaliação

Nome do Campo Tipo do Campo Tamanho do Campo

id Numérico --

Pergunta CharField 200

dataPub DateField 30

imagem ImageField --

subtitulo CharField 500

51

descricao CharField 2000

tipo ForeignKey(Categoria) --

categoria ForeignKey(Categoria) --

usuario ForeignKey(User) --

Tabela 27 – Modelo Físico da tabela Avaliação

Tipo


id Numérico --

tipo CharField 500

Tabela 28 – Modelo Físico da tabela Tipo

Categoria


id Numérico --

categoria CharField 200

Tabela 29 – Modelo Físico da tabela Categoria

52

Escolha


id Numérico --

sexoPessoa CharField 100

idade IntegerField --

avaliacao ForeignKey(Avaliacao) --

escolhaTexto CharField 200

votos IntegerField --

Tabela 30 – Modelo Físico da tabela Escolha

EscolhaDescritiva


id Numérico --

sexoPessoa CharField 100

idade IntegerField --

avaliacao ForeignKey(Avaliacao) --

texto CharField 200

Tabela 31 – Modelo Físico da tabela EscolhaDescritiva

53

3 Capítulo 2 – Implementação

3.1 Instalação e Ambientes

Para muitos dos comandos a seguir, será necessário que o desenvolvedor tenha noções do comportamento da plataformas Unix, bem como seus comandos de execução, permissão de pastas, criação e compilação de arquivos.

É muito comum que se use o apt-get para a instalação de pacotes e suas dependências automaticamente, bem como o aptude, tendo o último a diferenciação pela maior complexidade, ou seja, maior gama de funcionalidades.

Os pacotes Python têm a facilidade de disponibilização via comando pip, disponíveis no repositório oficial (http://pypi.python.org/pypi). Sobre estes repositórios, é usual que hajam espelhos. Os mesmos são criados para que não haja demora obtida pelo grande número de acessos ao repositório oficial, podendo-se até mesmo uma empresa criar para uso interno de suas máquinas, passando como parâmetro a url em questão com a opção -i.

3.1.1 Considerações e Instalação do Python

De acordo com o site oficial (www.python.org/), Python é uma linguagem de programação com 23 anos de criação, datada de dezembro de 1989 e inventada por Guido van Rossum. É gerida pela Python Software Foundation, uma organização sem fins lucrativos, voltada para a exposição da linguagem.

Esta linguagem tem capacidade e poder aliados ao aprendizado claro. Suas características principais são a programação orientada a objetos e estruturas de dados de alto nível, permitindo a expressão de operações complexas em um só comando , maior verificação de erros e possuindo tipos nativos de alto nível, como dicionários por exemplo. Nela, não existe a preocupação com a declaração de variáveis ou parâmetros formais. Sua natureza é do tipo interpretada, e é usualmente aplicada no desenvolvimento de scripts ( que em comparação com scripts para o shell Unix, temos a desvantagem da não adequação à aplicações GUI(Graphical User Interface) ) e aplicações ágeis.

54

Um dos seus pontos fortes é ser quase um pseudo-código, tornando a solução do problema mais importante e rápida pela simplicidade de sua sintaxe. A delimitação de blocos é feita somente pela identação, facilitando a legibilidade e entendimento.

É um exemplo de FLOSS (Free/Libre and Open Source Software), ou seja, seu código é aberto para leitura e manipulação, bem como sua distribuição e utilização de trechos. Um exemplo disto seria a criação de um programa em módulos e a reutilização do mesmo em outros programas em Python. Este conceito é amplamente difundido quanto ao compartilhamento de experiência e informação.

É um software livre sob a licença da Python Software Foundation, totalmente compatível com a GNU General Public License (GPL), a mais comum neste segmento. Isto significa que diferentes trabalhos, mesmo que alterados ou adicionados, estão debaixo da preservação dos direitos de liberdade.

Falando de sua biblioteca padrão, a Python Standard library, ela não deixa a desejar quanto a funções e apoio de métodos como criptografia, manipulação de arquivos, documentação, testes unitários, CGI e outros dependentes do sistema. Ela contém métodos built-in escritos em C, dando acesso às funcionalidades do sistema, como entrada e saída. Um fato importante quanto a isto, é que a linguagem está inserida na filosofia de “Pilhas Incluídas”, ou seja, podem ser adicionadas outras bibliotecas com a Python Imaging Library e a WxPython Twisted.

Sobre seu interpretador, é extensível por incorporar funções e tipos de dados em C ou C++, incluindo as que são baseadas em C, sendo assim acessíveis. É usualmente instalado em /usr/local/bin/python, sendo este processo o responsável pela execução no terminal.

Python se destaca também pela não compilação de seu código. É uma linguagem do tipo interpretada, tendo sido modificada para tornar-se portável, como o Java. Neste processo, o programa é executado diretamente por seu código fonte no formato intermediário, o conhecido byte-code, traduzindo-o para a linguagem de máquina. Isto resulta na economia de tempo considerável durante o desenvolvimento.

Conforme já dito anteriormente, a maioria das distribuições do Linux já vem com uma versão do Python instalada, mas se por motivos de desenvolvimento e sintaxe de código houver a necessidade de diferentes versões diferentes da padrão, não é recomendável que se desinstale ou a modifique, e sim que crie um ambiente virtual com todas as suas dependências.

Para a instalação do Python no Windows, somente é necessário fazer o download da versão pelo site oficial (http://python.org) e executar o arquivo do tipo Windows Installer Package. O pacote já vem com a biblioteca padrão e alguns

55

componentes adicionais. Após este processo, será necessário estabelecer uma variável de ambiente que aponte para o diretório onde os módulos do Python são instalados. Para o teste de funcionamento, pode-se abrir o prompt de comando e digitando a palavra Python, serão disponibilizadas informações como a versão do instalada no sistema no Python Shell, bem como seu interpretador, antecedido pelos sinais “>>>”.

Para a instalação no Linux, mais precisamente no Ubuntu, o processo não é tão trivial assim. Serão necessários recursos previamente instalados para que se possa realizar a operação via terminal, como por exemplo o ato de descompactar arquivos. Para melhor entendimento, ao ocorrer algum erro, o terminal é responsável por determinar o pacote ou módulo requerido, tornando a aquisição do mesmo mais clara.

Pode-se realizar o download via wget -c, passando como parâmetro a url de download do arquivo compactado no site oficial, por exemplo, wget -c http://www.python.org/ftp/python/2.7.2/Python-2.7.2.tar.bz2, podendo ser a mesma versão que no windows foi acessada via browser.

Para descompactar a pasta, usa-se o comando tar, estando localizado na pasta de download do arquivo, e se ocorrer erro, será necessário o comando de instalação apt-get install bzip2, para compreensão da extensão .bz2.

Ao acessar a pasta que foi extraída, é necessária a compilação do código fonte, com o comando ./configure. Este comando irá precisar das dependências, que poderão ser adquiridas com o apt-get install build-essencial, executadas como root da máquina.

Prosseguindo com os comandos make e ./python, haverá a execução local, testando sua compilação. Isto não será suficiente para a instalação na pasta necessária do sistema (/usr/local/lib), função do sudo make install.

Para configuração da versão padrão, é utilizada a sequência de comandos: sudo update-alternatives --install /usr/bin/python python /usr/local/lib/python2.7 e sudo update-alternatives --config python.

Tendo seguido estes passos, estará devidamente configurada a versão do Python na máquina de distribuição Ubuntu.

56

3.1.2 Considerações e instalação do Django

Django é um framework para aplicações web implementado em Python. Como as características funcionais da linguagem, esta “caixa de ferramentas” traz consigo as facilidades e principalmente agilidade de desenvolvimento para o minimizar o trabalho e esforço (Fonte: docs.djangobrasil.org/intro/install.html, acessado em 30/06/2014).

Foi criada inicialmente para gerenciamento de um site jornalístico em Lawrence, Kansas. Nasceu no outono de 2003, pelos programadores Web do jornal Lawrence Journal-World, Adrian Holovaty e Simon Willison, quando começaram a utilizar Python na construção de suas aplicações.O conceito de agilidade nasceu deste meio baseado pelos prazos apertados no mundo do jornalismo. Posteriormente foi publicado em julho de 2005, com a licença de código aberto BSD, e recebeu o nome Django em homenagem ao guitarrista de jazz Django Reinhardt.

Uma de suas características marcantes é o total direcionamento a banco de dados, tornando a manipulação de objetos e atributos pertencentes a mesma de fácil acesso. Seu mapeamento é ORM (Objeto-Relacional), o que significa, internamente, que a mecânica necessária é dada totalmente em Python.

Com esta facilidade da estrutura, torna-se desnecessário ser bom entendedor de manipulação de banco de dados, sendo ele o escolhido pelo desenvolvedor dentre os que o Django dá suporte, pois as tabelas e tipos de atributos são “setados” diretamente no código e criados automaticamente. Essa configuração dá o comportamento essencial do dado a ser gravado, sendo cada modelo uma classe Python a tornar-se uma tabela e cada atributo uma coluna.

Se a aplicação web precisa de interface para o administrador, também já existe toda uma estrutura montada e baseada também nas classes provenientes do banco de dados. Esta ferramenta de administração do Django é de grande valia para manipulação de dados e como publicador direto de conteúdo.

Uma situação muito comum em aplicações web é o uso de formulários para diferentes funcionalidades, como é o caso deste projeto em questão. Para a utilização do mesmo, já existe a automatização através dos modelos de dados.

Quanto às urls da aplicação, é possível trocá-las a qualquer momento, o que facilita a manutenção como solução de alguma mudança de estrutura por exemplo.

57

Para a parte de templates, indo de encontro ao padrão MTV, existe uma poderosa estrutura por trás de filtros, manipulação de dados e controle de fluxo, podendo-se utilizar programação não só do lado controller, mas na própria view.

Se houver a necessidade de internacionalização, existe total suporte para configurações multi-idioma, a serem adicionadas ao projeto, expandindo os horizontes do projeto quanto à área de cobertura, pois se existem funcionalidades específicas do sistema traduzidas para diferentes idiomas, um maior número de pessoas terão acesso ao conteúdo.

Fornece abstrações também de alto nível, com atalhos para frequentes utilizações na programação e convenções na forma de solucionar problemas, ao mesmo tempo que o Django em si não se coloca em seu caminho, dificultando a tarefa e deixando-a repetitiva.

Uma grande vantagem deste tipo de desenvolvimento é que ao se pretender modificar uma peça componente do sistema, não serão afetadas outras partes, por serem de baixo acoplamento, com funções bem distintas e divididas.

Tendo em vista que o ambiente já foi configurado com o Python, ou seja, já está instalado, o Django irá ser executado sem problemas. Ele requer a versão do Python 2.3 ou superior.

Este framework está disponível para download em duas versões, sendo elas: a oficial e pela instalação do Subversion que se diferencia pelo fato de poder, a qualquer momento, atualizar a versão local do código, sendo mantido pela equipe do Django para gerenciamento das alterações correntes no código-fonte.

Neste projeto, a rotina a ser seguida será pela instalação da versão oficial, disponível em http://www.djangoproject.com/download/.

Ao acessar este site, existe uma série de documentos de suporte, o que facilita a instalação e explica o funcionamento de cada versão.

Após o download, é necessária a extração do pacote e execução do comando python setup.py install, como root da máquina.

Se tudo correr bem na instalação, será possível verificar o funcionamento e versão do Django diretamente no interpretador Python no terminal, verificados pelo comando django.VERSION sendo antes importado o módulo.

Como dito anteriormente, Django é construído mais precisamente para uma aplicação baseada no modelo objeto-relacional, e para tal funcionalidade, é preciso que não só haja o Python instalado na máquina, como também outras dependências como um servidor de banco de dados.

58

Para a configuração deste servidor, é preciso que se tenha atenção no suporte dado por este framework. São eles: PostGreSQL, SQLite3 e MySQL. Esses são provavelmente alguns dos mais conhecidos neste meio de desenvolvimento, mas se o desenvolvedor, ao analisar por este ponto questionar as vantagens de uso, é bom saber que já existem trabalhos e teste de suporte às tecnologias Microsoft SQL, Server e Oracle.

Neste projeto será utilizado o MySQL, por isto o foco de instalação será somente este, dentre os outros listados acima.

Para a utilização do MySQL, o Django requer a versão 4.0 ou superior, sendo também necessário o pacote MySQLdb, disponível em http://www.djangoproject.com/r/python-mysql/ ou via apt-get pelo terminal, sendo os comandos sudo apt-get install mysql-server e sudo apt-get install python-mysqldb.

Ao seguir os passos descritos, estará configurado o ambiente para total funcionamento da criação do projeto, utilizando artifícios do Django para a automática criação dos arquivos requeridos.

3.2 Criação do Projeto Django

O Django possui comandos reservados para múltiplas funcionalidades como por exemplo o start de um projeto. Alguns dos comandos principais são executados pelo admin.py e manage.py. O admin.py é uma ferramenta para execução de tarefas administrativas, enquanto que o manage.py é automaticamente criado no projeto Django e possui duas funcionalidades essenciais: colocar o pacote do projeto no sys.path e definir a variável de ambiente DJANGO_SETTINGS_MODULE,que aponta para o tão necessário arquivo settings.py.

Utiliza-se o admin.py para o comando de criação django-admin.py startproject mywebsite passando o nome do projeto por último, neste caso mywebsite.

Após a execução, terão sido criados os arquivos de um projeto django, conforme abaixo:

mywebsite/__init__.pymanage.pysettings.pyurls.py

59

Cada um possui uma função especifica. Segue abaixo:

• O __init__.py tem a função de notificar ao Python que o diretório na verdade é um pacote.

• O manage.py será utilizado com vários comandos para interação e manipulação, como o processo syncdb.

• No settings.py estão praticamente todas as configurações necessárias à personalização do projeto, toda a lista de apps instaladas, a quem notificar os erros obtidos, os dados do administrador, o banco de dados com seu tipo, nome e senha, os middlewares, se existe ou não admin padrão do Django para o projeto, variáveis de url, time zone e onde serão localizados os templates,etc... Existe uma gama de funcionalidades para este arquivo. Ele é a centralização do projeto.

• O urls.py é responsável pelo total mapeamento de urls e configuração da funcionalidade respectiva a cada página. Este arquivo requer conhecimento de expressões regulares.

De todas as características citadas, a grande chave deste framework é o desenvolvimento local, possibilitando o total controle e alinhamento do processo. Ele possui um servidor leve para que isto possa acontecer, já incluído no sistema. É de rápida atualização, conforme modificações constantes nesta fase, não considerando com o cache que pode tornar esta etapa demorada. A grande vantagem desta utilização é o ganho de tempo , porém não se pode comparar totalmente ao comportamento do servidor Web de Produção, pois localmente, só é possível lidar com uma requisição por vez, de maneira confiável.

Para utilizar este artifício basta executar o comando python manage.py runserver, onde serão validados os modelos e visto no localhost, na porta usual 8000. Se o código estiver com algum erro, será mostrado no browser todas as informações necessárias ao acerto, como linha, arquivo e tipo no erro, mostrando o conteúdo onde o erro foi apontado.

60

Figura 16 - Servidor Local Django

Para a aplicação web ser exatamente o que foi projetada e pensada para ser, dinâmica, é preciso que se crie um arquivo com as funções do site, o views.py. Todos os dados a serem visualizados, passarão por ele. Geralmente, esta etapa lista as requisições e retorna as respostas a serem exibidas pelo servidor, sejam elas arquivos ou simplesmente o conteúdo a ser “enxergado” na requisição, todas são um objeto HttpResponse. Neste arquivo estará toda a importação de classes necessárias às funções listadas.

É necessário que se entenda o conceito de URLConf nesta fase, pois após ter montado o arquivo views.py, é necessário fazer o link entre a função e a url em que ela responderá. Esta é a função do URLConf, que é uma tabela com o objetivo de ligar uma função a uma url de resposta.

Tendo manipulado os dados a serem retornados na função, apontado para um template como objeto de resposta da função e chamando a função no arquivo de URLs, tudo estará configurado para que se possa montar a aplicação de acordo com os requisitos.

Os atributos das classes poderão ser chamados de forma dinâmica em forma de variáveis diretamente dos templates com blocos envoltos por estruturas como {% for %} , {% forloop.counter %}, etc...

61

3.3 Autenticação e Cadastro de Usuários

Para a instalação do suporte de autenticação serão necessárias as aplicações instaladas django.contrib.auth e django.contrib.contenttypes, sendo o modelo de permissão incluído no auth dependente do contenttypes. Na execução do comando startproject estes itens já são incluídos no settings.py.

Para a criação das tabelas e colunas necessárias a esse processo, faz-se necessária a execução do comando python manage.py syncdb, que sincroniza e cria todas as dependências de usuários, grupos e permissão automaticamente. É possível criar um superuser para total controle de gerenciamento. É importante notar que ele só deve ser instruído após a criação da base de dados atribuída na engine, neste caso o mysql.

Para a autenticação dos usuários no ato do login, precisa-se entender os conceitos da proteção de dados por Cross Site Request Forgery e Template Context Processors, bem como as funções de um middleware.

Um middleware é um framework responsável por funções especificas dentro do contexto de requisições e respostas. Existe a possibilidade de adicionar “ganchos” ao projeto, de acordo com as necessidades do mesmo. Por exemplo, se existe a restrição de ips para algumas páginas, é possível adicionar o middleware ip-restriction na lista de classes middleware. É aí que entra o django.middleware.csrf.CsrfViewMiddleware.

O CSRF provê a segurança para ataques CSRF, que ocorre quando um site contém um formulário responsável pelo envio de informações é vítima de um ataque para aquisição de informações pessoais. Sua função é assegurar a confiabilidade das requisições do website.

O Template Context é utilizado quando é necessário utilizar o contexto de um template, ou seja, os dados de cada página em forma de um dicionário com suas variáveis e valores. Sua classe primitiva é django.template.Context e com esta classe é possível criar diferentes subclasses de acordo com a funcionalidade requerida.

No caso de subclasses, já existe uma subclasse muito útil oferecida pelo Django, o django.template.RequestContext. Esta subclasse, neste projeto foi utilizada para retorno da variável usuário logado. Seu funcionamento é dado pela verificação da configuração TEMPLATE_CONTEXT_PROCESSORS, que retorna

62

uma tupla de objetos, sendo cada um um dicionário responsável pela atribuição de chaves e valores em loop.

Este uso permite não haver repetitividade de chamada de variáveis a cada template, tornando o código mais dinâmico e limpo.

A autenticação em si, é dada apenas pelas variáveis username e password, pelo método authenticate, que retorna um objeto usuário, retornando None caso contrário.

No cadastro foi utilizado o conceito e a aplicação de formulários para a configuração de campos, explicitando seu comportamento usual por tipo de preenchimento. Assim, a renderização do html torna-se dinâmica o suficiente para facilitar a manutenção como inclusão e exclusão de campos.

A utilização de forms do Django possui benefícios quanto à validação de campos e seu preenchimento, mensagens de erro e mensagens do mesmo. Sua aplicação é dada pela inclusão de classes Python que extendem a classe de forms tradicional do Django.

3.4 Avaliações

Como de costume no Django, esta parte do projeto será uma app que pode ser acoplada ao sistema. Para isto, utiliza-se o comando start app passando como parâmetro seu futuro nome, para a estrutura necessária ao desenvolvimento e configuração, com seus models, arquivo de testes unitários e views.

Nos seus modelos serão criadas as classes python que extendem os Models, uma estrutura importada por django.db e notada por “models.Model”. Serão configurados os campos das avaliações para o banco de dados, como por exemplo as perguntas, votos e respostas.

Para esta app ter a possibilidade de gerenciamento por parte do admin, é necessário que se configure o arquivo admin.py para trazer os campos provenientes do banco de dados e uma visão “inline” da configuração dos atributos e chaves estrangeiras sem sair da mesma tela, obtendo assim a visão completa de um objeto com todas as suas possíveis respostas pré-definidas.

Ainda no admin, existe uma gama de configurações , como comportamento à esquerda, visão por filtro e ordem por data de publicação, o que facilita e organiza o conteúdo quando o mesmo torna-se extenso com o passar do tempo.

A configuração de avaliações neste projeto dá-se pelos atributos abaixo:

63

• Pergunta – Será o título de cada avaliação, tendo o maior destaque visual.

• Data de publicação – Automático do sistema. É montado ao criar uma avaliação.

• Imagem - É necessário ser uma imagem que dê sentido à avaliação, e faz parte da identidade visual do site.

• Subtítulo – Descrição sucinta de cada avaliação.

• Descrição – Moderadamente grande, é possível descrever o objetivo neste campo, dando assim uma ideia do que deve ser o ponto e foco do avaliador.

• Tipo – Chave estrangeira para a classe Tipo

• Categoria – Chave estrangeira para a classe Categoria

• Usuário – Chave Estrangeira para a classe User (nativa do Django - django.contrib.auth.models)

São estes os atributos a serem mostrados na web, no formulário de criação e descrição de acordo com cada instância e são os mesmos que possibilitam as regras de negócio acopladas a este projeto.

Esta classe será também a chave estrangeira das escolhas, que, ao se completar o entendimento, pode-se dizer que uma escolha está associada a uma avaliação, podendo assim acoplar os tipos de escolhas diferenciadas.

3.4.1 Chaves Estrangeiras

3.4.1.1 Tipo

Este atributo, conforme descrito acima, faz referência a uma classe configurada para o funcionamento específico deste projeto, a classe Tipo.

Ela possui o atributo tipo, que é a descrição de cada tipo de avaliação. Neste caso, é responsável por dizer o comportamento dos formulários de criação das avaliações.

Existem dois tipos pré-definidos de avaliação: Múltipla Escolha ou Descritiva, que encaixam diferentes tipos de campos nos formulários do site.

64

3.4.1.2 Categoria

Este atributo também referencia uma classe configurada para este projeto, a classe Categoria. O objetivo dele é filtrar o conteúdo por categorias, como política, religião, etc...

Tendo uma chave estrangeira categoria em cada avaliação, é possível obter um grau de unificação de tipo de respostas, e trabalhar com o resultado. Por exemplo, se este fosse um campo editável, cada avaliador poderia especificar uma resposta diferente para uma mesma categoria.

3.4.1.3 Usuário

Este atributo como chave estrangeira, referencia uma classe já existente do Django, a classe User.

A utilização da mesma é de imenso conhecimento de desenvolvedores da linguagem, pois a facilidade de implementação é dada por um pacote de gerenciamento pronto para ser instanciado em cada projeto. Como exemplo disso, temos os atributos first_name, username, email, dentre outros e os métodos de autenticação is_staff, is_active, etc...

Os objetos desta classe também podem ser configurados para permissionamento de páginas e arquivos, como para agrupamento pelos grupos do Django.

Se além dos atributos já provenientes da classe nativa for necessário o acoplamento de outros, é possível fazer o desenvolvimento da especialização da classe, instanciando a nativa. Não foi o caso neste projeto.

3.5 Escolhas

Os tipos de escolhas foram os responsáveis pela criação de novas classes, com seus atributos diferenciados. Não foi necessário neste caso a herança de uma

65

superclasse escolha, pela não complexidade de seus métodos e pouca semelhança entre seus atributos.

Foram divididas em duas classes: Escolha e Escolha Descritiva.

3.5.1 Escolha

Embora o nome desta classe seja escolha, ela é específica para o tipo Múltipla Escolha, e seus atributos são:

• SexoPessoa

• Idade

• Avaliação

• EscolhaTexto

• Votos

Mais a frente, será descrito o porquê dos atributos que dizem respeito ao sexo e idade estão nesta classe, e não numa classe usuário.

O atributo avaliação é uma chave estrangeira para a classe Avaliação, com os seus métodos específicos.

EscolhaTexto é a descrição de cada resposta pré-definida pelo criador, sendo o atributo votos a quantidade associada a cada uma escolha.

O que é importante salientar neste escopo, é que ao criar as escolhas, é possível checar se a mesma foi escolhida pelo método set de cada atributo, neste caso escolha_set. O mesmo foi utilizado para a página de resultados.

3.5.2 EscolhaDescritiva

Esta escolha tem este nome por ser de livre descrição do avaliador. No caso de perguntas livres, onde o foco é a opinião do usuário, é gerado um campo maior (textarea), ou seja, com maior quantidade de caracteres para futura visualização.

Os atributos desta classe são:

• SexoPessoa

66

• Idade

• Avaliação

• Texto

As características de descrição citadas acima são possíveis pelo atributo Texto.

3.6 Páginas

As páginas do site são totalmente configuráveis quanto à informação disponibilizada. Cada uma é renderizada podendo-se passar atributos para estruturas condicionais e laços para listas. Este comportamento é dado pela função render_to_response, onde é passado um dicionário com as informações necessárias, como é o caso da página de descrição das avaliações e a de categorias.

Páginas, para o desenvolvedor, é sinônimo dos templates, já antes citados na estrutura de criação do projeto Django.

Para o controle de login sobre cada página, existe um decorador do Django chamado login_required. Para o usuário, o comportamento previsto é visualizado na ação de tentativa de acesso de uma página especificada pelo desenvolvedor no arquivo de views com o login requerido. O mesmo se dá pelo redirecionamento para a tela de login, atribuída nas configurações do projeto.

67

3.6.1 Cadastro

Neste projeto, uma regra de negócio é o login de usuário para a criação de avaliações, que é o foco do sistema. Sendo assim, esta página é de extrema importância de funcionamento.

Esta página utiliza um formulário com o usuário nativo com o apoio do funcionamento do form nativo do Django. Além da facilidade de desenvolvimento, outro benefício desta utilização é o controle de erros do formulário, como visualização de mensagem de email ou username já cadastrado ou confirmação de senha errada.

Basicamente é mostrado ao usuário uma simples mensagem de que é necessário de cadastrar para obter privilégio sobre algumas funcionalidades e um simples formulário com os campos nativos do modelo de Usuário.

Após a função de autenticação, o usuário é redirecionado à raiz do site, com uma mensagem com seu nome. É possível verificar que agora, o menu foi modificado com os links para as funcionalidades para manter avaliações e logout.

Figura 17 – Tela de Cadastro

68

3.6.2 Login

Simplesmente um formulário de username e senha, com o mesmo comportamento de redirecionamento final do usuário que o cadastro possui.

Figura 18 – Tela de Login

69

3.6.3 Logout

Função nativa do Django para encerrar sessão do usuário, com modificação no menu do site.

Figura 19 – Tela de Logout

70

3.6.4 Contato

O contato tem a funcionalidade de enviar uma mensagem ao e-mail de destino com a mensagem do usuário e e-mail do remetente.

Este template é dado pela configuração de um formulário no arquivo python de manipulação de mensagem, título a ser mostrado no recebimento e destino. Para isto, é preciso que o desenvolvedor configure no arquivo settings a porta e host, utilizando o servidor de e-mail necessário para a entrega da mensagem.

Após o envio, é mostrada uma mensagem de agradecimento pelo contato.

Figura 20 – Tela de Contato

71

3.6.5 Filtros

3.6.5.1 Mais Recentes

Os filtros são uma funcionalidade do Django que proporcionam ao desenvolvedor especificar a query a ser feita, ou seja, pode-se passar ao sistema a porção de objetos a serem retornados de acordo com a especificação de atributos ou até mesmo funções lambda.

Nesta página, o filtro é dado pela data de publicação, aliado ao order_by, que proporciona a ordenação ascendente ou neste caso, ascendente.

Figura 21 – Tela de Filtro Mais Recentes

72

3.6.5.2 Mais Votadas

Para esta view, é necessário que se faça uma query de todas as avaliações que possuem votos atrelados e ordene pela quantidade dos mesmos.

É mostrado ao usuário uma lista de avaliações de acordo com as mais populares.

Figura 22 – Tela de Filtro Mais Votadas

73

3.6.6 Categorias

É uma lista de todas as categorias do sistema, como link para acesso relacionado à busca de um determinado assunto.

3.6.6.1 Categoria

É feita uma query com a passagem do parâmetro por link, ou seja, via método get é possível filtrar e montar a lista de avaliações associada à determinada categoria.

Figura 23 – Tela de Categorias

74

3.6.7 Criar Avaliações

Esta funcionalidade é um exemplo de uso de login requerido, expressa por um formulário de cadastro de uma nova avaliação, com os atributos já citados acima pela descrição da classe Avaliação.

Ao criar a avaliação, o usuário é redirecionado para a página da mesma, com a descrição das informações condizentes ao cadastro. Esta página também engloba os comentários de usuários dado pela ferramenta Intense Debate, onde é possível comentar como visitante, usuário do Wordpress ou usuário do Intense Debate e também compartilhar a avaliação no Facebook ou curti-la.

O link de votação da avaliação redireciona para a página de votação, com a passagem de parâmetro do id da votação.

Figura 24 – Tela de de Avaliação

75

3.6.8 Votar em Avaliações

Este é o ponto de explicar o porquê de sexo e idade estarem em escolha, e não em usuário.

Para a utilização de sexo e idade na classe nativa de User, seria necessário criar uma nova classe, com a instância da mesma, além disso, o usuário, desnecessariamente iria preencher estas informações, pois nem todos os usuários que se cadastram votam ou criam avaliações. Esta informação, somente é útil para os avaliadores, ou seja, somente aqueles que respondem às avaliações e assim, é possível gerar relatório dos usuários que realmente consomem o conteúdo.

Nesta página são identificadas as respostas múltipla escolha ou descritivas, sendo adaptados os campos de acordo com este dado.

Ao votar, o usuário é redirecionado à página de resultados, com seu voto já contabilizado.

Figura 25 – Tela de Votação de Avaliação

76

3.6.9 Resultados

É onde é visualizado o resultado de uma avaliação, com a contabilização de votos ou somente as respostas descritivas.

Figura 26 – Tela de Resultado de Avaliação

3.6.10 Manter Avaliações

Manter é um verbo disseminado no meio da Modelagem de Dados e que diz respeito à inclusão, alteração e exclusão de objetos.

77

3.6.10.1 Alterar Avaliação

Em caso de algum erro nas avaliações, no momento da criação ou posterior à mesma, é possível alterar os valores de atributos da mesma.

Para isto, é aberto um formulário semelhante ao da criação, porém com as informações preenchidas e prontas para serem submetidas.

Se as informações forem distintas, são sobrescritas e o usuário é redirecionado à página de avaliações, já com as alterações feitas.

Figura 27 – Tela de Alteração de Avaliação

78

3.6.10.2 Deletar Avaliação

O usuário ao clicar em deletar, é redirecionado para a página atual, já com a atualização da lista com a exclusão.

Figura 28 – Tela de Remoção de Avaliação

79

3.7 Relatórios

Para este módulo, foi preciso instalar algumas ferramentas no sistema. Para começar, é necessário entender a complexidade da utilização do mecanismo de relatório chamado Geraldo.

Esta ferramenta é independente de plataforma, podendo ser instalada e acoplada a sistemas web como também a sistemas desktop. Trabalha em acordo com a liguagem Python e Django criando relatórios de acordo com a configuração desejada.

O que há de melhor nesta ferramenta é a manipulação de objetos passados em dicionários e a forma atrativa como é visualizada pelo usuário. É possível ver os relatórios simplesmente acessando uma url configurada no arquivo de urls do projeto.

Seu formato de entrada recebe a configuração por cm de página, com a utilização de formato (A4, A5), bordas, rodapés e muitas outras facilidades. Seu formato de saída é um documento pdf, mostrando todos os elementos de entrada, sejam eles textuais ou gráficos.

De acordo com o site oficial (http://www.geraldoreports.org/docs/index.html), seu fluxo de trabalho deverá ser o seguinte:

1. Você declara uma classe Relatório com sua estrutura de relatório e definições;

2. Instancie sua classe Report, proporcionando um queryset com uma lista de objetos;

3. Chame o método de relatório 'generate_by', proporcionando à classe gerador e saída nome do arquivo (pode ser um nome de arquivo ou arquivo de saída). Ele irá gerar um arquivo no disco rígido ou na memória;

4. Faça o que você quiser com a saída: você pode devolvê-lo em um HttpResponse, mantê-lo em um arquivo, etc

80

http://www.geraldoreports.org/docs/index.html

Para a parte gráfica, foi utilizado o CairoPlot, que é uma API também escrita em Python para desenhar 6 tipos de gráficos. Somente será utilizado neste projeto o gráfico em barra, donut plot (que é uma versão do gráfico mais conhecido como pizza). O gráfico em barra é utilizado para a visualização dos votos, com a legenda de cada um na barra. O donut plot é utilizado para a contabilização de usuários por sexo, no sumário dos relatórios.

Para o relatório gráfico, foi feito um gráfico fuzzy de idade. Para este método foi utilizada a ferramenta GnuPlot, com suas dependências. Na abstração deste gráfico, precisa-se entender sobre lógica Fuzzy e seu conceito aplicado a este projeto.

Lógica fuzzy na verdade é uma evolução da Lógica Booleana, que atribuía a objetos em questão os valores de falso ou verdadeiro, como por exemplo o sexo de uma pessoa, que só pode ser masculino ou feminino.

Dentro deste conceito, pode-se fazer analogia com a linguagem do dia a dia e com valores intermediários, por exemplo a palavra talvez, que utiliza-se tanto no dia a dia.

Para entender mais a fundo, pode-se visualizar o sistema abaixo:

Figura 29 – Sistema Fuzzy

81

No sistema de avaliações, tendo em vista o dicionário de dados com a idade de cada avaliador como entrada precisa, é possível a obtenção de um gráfico com as regras de classificação de etapa de vida, como Jovem, Adulto e Idoso e com este gráfico ser inferido o valor médio das idades para saber o público-alvo do website.

3.7.1 Instalação

3.7.1.1 Geraldo Reports

Essa engine não pode ser utilizada sem a ferramenta ReportLab. Sendo assim, pode-se listar mais uma dependência a ser adicionada nos requirements do projeto.

Para a instalação deste componente no Linux deve-se seguir o passo a passo abaixo:

tar xvfz Geraldo-latest.tar.gz

cd Geraldo

sudo python setup.py install

Este processo é responsável por copiar os pacotes para dentro do diretório de instalação do Python dentro do sistema, ou seja, do PythonPath.

As seguintes dependências devem ser adquiridas:

• PIL

• ReportLab

3.7.1.2 CairoPlot

CairoPlot é uma Api com total compatibilidade com este sistema, por ser escrita em Python e suportar 8 tipos de gráficos,verticais e horizontais com a utilização do conjunto de ligações para a biblioteca python Cairo (PyCairo).

82

PyCairo fornece uma interface totalmente orientada a objetos e foi projetada para ser totalmente compatível e combinar com a Cairo API.

Para os gráficos na parte dos relatórios, foi utilizada esta ferramenta de fácil implementação, porém de acordo com a natureza dos dados, não foram usados todos os tipos de plots. A escolha desta API também se deu pelo motivo da criação dela, a maneira como ela é representada, podendo até mesmo ser visualizada em apresentações de maneira mais bonita.

Tendo em vista que deve-se sanar todas as dependências para instalação, segue abaixo o tutorial via terminal do Linux.

python2.5

sudo apt-get install python2.5

cairo

sudo apt-get install libcairo

pycairo

sudo apt-get install pycairo

Depois disso, o pacote CairoPlot deve ser baixado e instalado conforme os passos abaixo:

via launchpad (http://launchpad.net)

sudo apt-get install bzr

bzr co lp:cairoplot

python setup.py

3.7.1.3 GnuPlot

Gnuplot é uma ferramenta de linha de comando portátil orientado à utilidades gráficas, compatível com Linux, OS/2, MS Windows, OSX, VMS e outras plataformas.

Uma das grandes vantagens do uso do Gnuplot é o código-fonte aberto a modificações, como foi o caso neste sistema, onde foi necessário mudar alguns atributos na geração do gráfico 2D fuzzy.

83

A utilização dos gráficos fuzzy neste projeto foi feita com base no gnuplot, com o apoio das funções do pyfuzzy para interpretar o arquivo de regras.

A instalação deste módulo pode ser feita também via terminal, baseado no conceito da habilitação de repositórios, neste caso o Universe. Basta digitar o seguinte comando:

sudo aptitude install gnuplot

3.7.1.4 PyFuzzy

Pyfuzzy é um framework para a parte de lógica fuzzy acoplada a este projeto. Ele opera os fuzzy sets e os interpreta como um sistema fuzzy, com os componentes de leitura de regras, variáveis de input, inferência e output.

Foi baseado neste funcionamento que foi criado o arquivo de regras de idade, com os ranges para montagem do gráfico com os fuzzy sets de idade, com output de faixas etárias. A forma mais simples de implementação é o carregamento de um arquivo para inferência das regras. Este arquivo possui uma linguagem própria.

84

Conclusão

Esta documentação visou apresentar os benefĩcios das ferramentas utilizadas, juntamente com uma proposta de avaliações útil para a análise de determinados aspectos cotidianos e ainda inexplorados.

Foram apresentados os principais pontos necessários para a criação de uma aplicação simples e rápida, que, quando aliada a uma ideia, pode certamente tornar-se realidade.

Baseado no processo criado, é possível certamente a implementação para uso de conhecimento específico de determinadas empresas, quanto para a mais simples avaliação, denominada enquete.

Com a modelagem escrita e gráfica, pôde-se explicitar a vantagem da manutenibilidade, para futuras ações, como para maior entendimento da aplicação.

Para maior controle, foi acoplado o sistema de relatórios, totalmente passível de customização, de acordo com as necessidades da utilização.

Os resultados dos testes no sistema foram satisfatórios quanto ao seu objetivo principal explícito anteriormente, aprovados pela exemplificação do seu comportamento à diversos usuários, onde foi atestado o entendimento no momento do uso.

Durante a execução, o sistema se manteve estável, enquanto o requisito de uma conexão aceitável e aberta foi atendido, pois sem tal recurso algumas funcionalidades se tornam inviáveis. Com isso, o projeto alcançou seu motivo de criação, alcançando aceitação pública.

O maior objetivo desta documentação é mostrar, que com empenho, pensamentos tornam-se realidade, e a mesma poderá atender e alcançar muitos usuários, quando inserida na grande rede que nos envolve durante nossas experiências atuais, a internet.

85

Sugestão de Trabalhos Futuros

Como melhoria deste projeto, pode-se implementar um novo controle de usuários quanto às suas informações cadastrais, funcionalidade de busca de avaliações, recuperação de senha, interface melhorada na inclusão de diversas categorias e campo de idade com cálculo baseado na data de nascimento do usuário.

Como sugestão maior, poderia ser divulgado à empresas tendo cada uma sua própria página, com seus resultados de aceitação pública em diversas questões. Isto acarretaria a inclusão de uma área de avaliações anteriores relacionadas à instituição, com gráficos não mais somente em pdf, mas acessados via url, e também visíveis a todos os usuários.

Com estas ações, a divulgação e o marketing também estariam inclusos como foco principal e objetivo.

86

Anexo

Exemplo do método votar escrito em Python utilizado no sistema:

Figura 30 – Exemplo de Código em Python utilizado no sistema

87

Referências Bibliográficas

http://www.adital.com.br/site/noticia2.asp?lang=PT&cod=13981 – (Acessado em 27/08/2012, Castello Branco)

http://www.slideshare.net/eCGlobalSolutions/online-x-offline-por – (Acessado em 27/08/2012, eCGlobal Solutions)

http://educacao.uol.com.br/cidadania/eleicoes-no-brasil-a-historia-do-voto-no-brasil.jhtm – (Acessado em 27/08/2012, Antonio Carlos Olivieri)

http://www.sourcebrasil.org/tutoriais/python/instalacao/instalacao-do-python-272-em-plataforma-linux-debianubuntu.html - (Acessado em 13/09/2012 - alessonzaire)

http://ubuntuforum-br.org/index.php?topic=21380.0 - (Acessado em 13/09/2012 – clcampos)

http://pypi.python.org/pypi - (Acessado em 13/09/2012 – Python Software Foundation)

http://turing.com.br/pydoc/2.7/tutorial/index.html - (Acessado em 13/09/2012 – Python Software Foundation)

http://memyworldandmylife.wordpress.com/2011/11/12/python-a-completely-floss-programming-language/ - ( Acessado em 13/09/2012 – Cesar valiente)

http://en.wikipedia.org/wiki/GNU_General_Public_License - (Acessado em 13/09/2012 – Enciclopedia livre)

http://docs.djangobrasil.org/intro/overview.html#intro-overview – (Acessado em 16/09/2012 – Grupo Django Brasil)

http://www.djangobook.com/en/ - (Acessado em 16/09/2012 - Adrian Holovaty and Jacob Kaplan-Moss)

http://www.saltycrane.com/blog/2008/07/how-set-django-mysql-ubuntu-hardy/ - ( Acessado em 16/09/2012 – Eliot)

http://docs.djangobrasil.org/ref/django-admin.html – (Acessado em 16/09/2012)

https://docs.djangoproject.com/en/dev/topics/http/middleware/?from=olddocs - ( Acessado em 19/09/2012 – Django Software Foundation)

88

https://docs.djangoproject.com/en/dev/topics/http/middleware/?from=olddocs

http://docs.djangobrasil.org/ref/django-admin.html

http://www.saltycrane.com/blog/2008/07/how-set-django-mysql-ubuntu-hardy/

http://www.djangobook.com/en/

http://docs.djangobrasil.org/intro/overview.html#intro-overview

http://en.wikipedia.org/wiki/GNU_General_Public_License

http://memyworldandmylife.wordpress.com/2011/11/12/python-a-completely-floss-programming-language/

http://memyworldandmylife.wordpress.com/2011/11/12/python-a-completely-floss-programming-language/

http://turing.com.br/pydoc/2.7/tutorial/index.html

http://pypi.python.org/pypi

http://ubuntuforum-br.org/index.php?topic=21380.0

http://www.sourcebrasil.org/perfil/alessonzaire

http://www.sourcebrasil.org/tutoriais/python/instalacao/instalacao-do-python-272-em-plataforma-linux-debianubuntu.html

http://www.sourcebrasil.org/tutoriais/python/instalacao/instalacao-do-python-272-em-plataforma-linux-debianubuntu.html

http://educacao.uol.com.br/cidadania/eleicoes-no-brasil-a-historia-do-voto-no-brasil.jhtm

http://educacao.uol.com.br/cidadania/eleicoes-no-brasil-a-historia-do-voto-no-brasil.jhtm

http://www.slideshare.net/eCGlobalSolutions

http://www.slideshare.net/eCGlobalSolutions

http://www.slideshare.net/eCGlobalSolutions/online-x-offline-por

http://www.adital.com.br/site/noticia2.asp?lang=PT&cod=13981

http://www.aprendendodjango.com/funcoes-de-usuarios/ - (Acessado em 23/09/2012 – Marinho Brandão)

https://www.habitusconsultoria.com.br/servicos.html - (Acessado em 21/06/2013- Habitus soluções empresariais)

Modelagem:

Guedes, 2009

(Elsevier) – Princípios de Análise e Projeto de Sistemas com UML, Eduardo Bezerra

Two Scoops of Django: Best Practices for Django 1.5 (Daniel Greenfeld and Audrey Roy, 2013)

89

https://www.habitusconsultoria.com.br/servicos.html

http://www.aprendendodjango.com/funcoes-de-usuarios/

Monografia da Bruna

Internet

Transcript of Monografia da Bruna