Monografia da Bruna

CENTRO UNIVERSITÁRIO ESTADUAL DA ZONA OESTE
Colegiado 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, Brasil
2013
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

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

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

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ÁTICA
R$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
DESENVOLVIMENTO
R$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

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

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.
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.
página de login, onde existe a interface
de autenticação com os campos
necessários ao reconhecimento do
mesmo.
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.
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
página de criação, onde existe a
interface com as avaliações, com os
campos necessários para
preenchimento de seus dados.
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”
estar preenchidos.
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.
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.
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”
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.
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.
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”
obrigatórios estão preenchidos.
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”
estar preenchidos.
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.
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.
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.
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.
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”.
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”
estar preenchidos.
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.
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
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”
estar preenchidos.
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.
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.
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__.py
manage.py
settings.py
urls.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

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

Monografia da Bruna

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a Monografia da Bruna

Semelhante a Monografia da Bruna (20)

Monografia da Bruna