Tarefa 4.2

0
UNIVERSIDADE JOS DO ROSRIO VELLANO

UNIFENAS
GUILHERME FERNANDES GOMES
JLIO DE PAULO JUNIOR
RAFAEL DANZIGER SILVA PEREIRA
WANDEIR MARQUES DOS REIS
IDENTIFICANDO E CORRIGINDO FALHAS

DURANTE O DESENVOLVIMENTO DE
SOFTWARE
Alfenas-MG
2011

IDENTIFICANDO E CORRIGINDO FALHAS

DURANTE O DESENVOLVIMENTO DE
SOFTWARE
Monografia apresentada Universidade Jos do

Rosrio Vellano como parte das exigncias do
Curso de Bacharel em Cincia da Computao
para concluso do curso de graduao.
Orientador: Prof. Celso de vila Ramos
Alfenas-MG
2011

IDENTIFICANDO E CORRIGINDO FALHAS DURANTE O

DESENVOLVIMENTO DE SOFTWARE
A banca examinadora abaixo-assinada aprova

a monografia apresentada como parte dos
requisitos para obteno do ttulo de bacharel
em cincia da computao pela Universidade
Jos do Rosrio Vellano.
Aprovada em:_____/_____/_______
Orientador:
Prof. Celso de vila Ramos
Universidade Jos do Rosrio Vellano
_____________________
Assinatura
Prof. Jos Claudio de Sousa Reis

_____________________
Assinatura
Prof. Marcos Alberto de Carvalho

_____________________
Assinatura
Alfenas-MG
2011
SUMRIO
1 INTRODUO.........................................................................................................10
1.1 Justificativa: origem e importncia do trabalho...........................................10
1.2 Caracterizao do problema em estudo.......................................................10
1.3 Objetivo.............................................................................................................11
1.4 Organizao do trabalho.................................................................................11
2 REFERENCIAL TERICO......................................................................................12
2.1 Engenharia de software..................................................................................12
2.1.1 Processo.........................................................................................................12
2.1.2 Mtodos..........................................................................................................13
2.1.3 Ferramentas....................................................................................................13
2.2 Desenvolvimento gil......................................................................................13
2.2.1 Extreme Programming (XP)............................................................................14
2.2.1.1 Planejamento...............................................................................................15
2.2.1.2 Projeto..........................................................................................................16
2.2.1.3 Codificao..................................................................................................16
2.2.1.4 Teste.............................................................................................................17
2.3 TDD (Test Driven Development).....................................................................17
2.4 Carona com tecnologia...................................................................................19
3 MATERIAL E MTODOS.........................................................................................20
4 DESENVOLVIMENTO............................................................................................22
4.1 Camada de Testes e Mtodos.........................................................................22
5 RESULTADOS E DISCUSSO...............................................................................33
6 CONCLUSO..........................................................................................................34
7 CONSIDERAES FINAIS.....................................................................................35
8 REFERNCIAS........................................................................................................36
APNDICE A CDIGOS E TELAS DA INTERFASE.............................................37
APNDICE B CDIGOS DAS CLASSES..............................................................85
APNDICE C - DICIONRIO DE DADOS...............................................................112
APNDICE D - DESCRIO DOS CASOS DE USO..............................................114
APNDICE E - DIAGRAMA DE CASO DE USO.....................................................122
APNDICE F - MODELO ER...................................................................................124
APNDICE G - DIAGRAMA DE CLASSE E TABELAS..........................................125
LISTA DE FIGURAS
Figura 1 - Engenharia de Software em camadas (PRESSMAN, 2010, p.17)............12

Figura 2 - O processo extreme progamming.(PRESSMAN, 2010, p64)....................15
Figura 3 - O processo TDD.........................................................................................18
Figura 4 - Exemplo de um teste falhando na rotina de testes criada.........................23
Figura 5 - Exemplo de uma correo de erro.............................................................24
Figura 6 - Tela de Login...............................................................................................37
Figura 7 - Tela de Contatos.........................................................................................39
Figura 8 - Tela de Ajuda..............................................................................................40
Figura 9 - Tela de Abertura aps o login.....................................................................41
Figura 10 - Tela de cadastrar Perfil.............................................................................42
Figura 11 - Tela inicial de cadastrar Rota....................................................................46
Figura 12 - Tela de cadastro de Rota para oferecedor...............................................47
Figura 13 - Tela de cadastro de Rota para caroneiro.................................................48
Figura 14 - Tela de consulta do Perfil do usuario logado............................................53
Figura 15 - Tela de consulta s reservas do usurio logado......................................58
Figura 16 - Tela em que aparecem os dados da reserva selecionada.......................59
Figura 17 - Tela de consultar as rotas do usurio logado...........................................62
Figura 18 - Tela de dados da rota selecionada...........................................................63
Figura 19 - Tela inicial de consultar perfil....................................................................70
Figura 20 - Tela de consulta de todos os usurios.....................................................71
Figura 21 - Tela de consulta por nomes......................................................................71
Figura 22 - Tela de consulta por cidades....................................................................72
Figura 23 - Tela de apresentao dos dados do perfil selecionado...........................73
Figura 24 - Tela de consulta de rotas..........................................................................77
Figura 25 - Tela de consulta de todas as rotas...........................................................78
Figura 26 - Tela de consultar rotas por cidades..........................................................78
Figura 27 - Tela de apresentao dos dados da rota selecionada.............................79
Figura 28 - Diagrama da Pessoa..............................................................................122
Figura 29 - Diagrama da Reserva.............................................................................122
Figura 30 - Diagrama da Rota...................................................................................123
Figura 31 - Diagrama do Veiculo...............................................................................123
Figura 32 - Modelo ER do banco de dados..............................................................124

Figura 33 - Diagrama de Classe...............................................................................125
Figura 34 - Diagrama de Tabelas..............................................................................125
LISTA DE TABELAS
Tabela 1 - Dicionrio de dados da Tabela Cidade.....................................................112

Tabela 2 - Dicionrio de dados da Tabela Pessoa....................................................112
Tabela 3 - Dicionrio de dados da Tabela Reserva...................................................113
Tabela 4 - Dicionrio de dados da Tabela Rota........................................................113
Tabela 5 - Dicionrio de dados da Tabela Veculo....................................................113
RESUMO
Com grande demanda, o mercado de software levanta algumas questes, a

principal se o produto vendido de confiana. Sendo assim, testes so
fundamentais para construir softwares de qualidade. Umas das tcnicas utilizadas
o Desenvolvimento Dirigido por Testes (TDD). necessrio ter em mente que testes
em TDD devem ser testes de unidades automatizadas em que requisitos so
definidos antes mesmo que o cdigo seja criado. Para isso, o desenvolvedor deve
ter conhecimento sobre o problema para saber test-lo de forma correta. TDD
baseado em um ciclo curto de repeties onde se escreve um cdigo que servir
para melhorar o funcionamento do que ser testado ou at mesmo adicionar uma
nova funo. Feito isso, o cdigo do programa em questo ser gerado para testar
estas rotinas. Quando os testes so validados, ento o cdigo refatorado para
evitar a duplicao de cdigo desnecessrio. Estes testes sero demonstrados em
um sistema criado com os conceitos de desenvolvimento gil, sendo este, um
"software de carona". Como pessoas tem acesso a universidades, escolas,
empresas, outras localidades e enfrentam problemas com trnsito para chegar s
mesmas, devido ao excesso de veculos ou a falta do mesmo. Uma forma de
resolver este problema, seria a comunicao entre as pessoas, sejam elas de
diferentes localidades ou no e tendo por funo oferecer ou pedindo carona,
seguindo este conceito seria uma forma prtica, rpida e bem vivel para a
mobilidade da comunidade com intuito de diminuir o trfego e o fluxo de veculos nos
permetros urbanos e industriais. Dito isto, este projeto tem por objetivo mostrar a
importncia de testes para garantir qualidade, baixos custos e ganho em tempo e
em desempenho atravs do uso de TDD. Tais testes sero demonstrados e
praticados atravs de um software de Carona (Sistema responsvel por cadastrar
pessoas que podem oferecer e necessitar de carona alm de suas rotas e outras
condies).
Palavras-chave: TDD. Software de carona. Refatorao, Qualidade de Software.
ABSTRACT
With high demand, the software market raises some questions, the main one
is if the product sold is reliable. Therefore, tests are essential to build quality
software. One of the most requested is the Test Driven Development (TDD). It should
be borne in mind that TDD tests should be automated unit testing where
requirements are defined before the code created. For this, the developer must have
knowledge about the problem and know test it properly. TDD is based on a short
cycle of repetitions where you write code that will serve to improve the functioning of
which will be tested or even add a new function. Then, the program code in question
will be raised to 'test' these routines. When the tests are validated, then the code is
refactored to avoid unnecessary code duplication. These tests will be demonstrated
in a system built with the concepts of agile development, this being a "software of
ride." How people have access to universities, schools, businesses, and other places
have problems with transit to get to work due to excessive vehicle or lack of it. One
way to solve this problem, would be the communication among people, whether or
not of the different locations and having the task of offering or hitchhiking, following
this concept would be a convenient, fast and quite feasible for a mobile community
with a view to reduce traffic and vehicle flow in industrial and urban perimeters. That
said, this project aims to show the importance of testing to ensure quality, low cost
and gain in time and performance through the use of TDD. Such tests will be
demonstrated and practiced through a software 'Ride' system (responsible for
registering people who can provide and need to ride beyond their routes and other
conditions).
Keywords: TDD. Ride. Refactoring.
10
1 INTRODUO
1.1 Justificativa: origem e importncia do trabalho
Com grande demanda, o mercado de software levanta questes, sendo a

principal delas,
se o produto vendido confivel. Sendo assim, testes so
fundamentais para construir softwares de qualidade. Atualmente, umas das tcnicas

requisitadas o desenvolvimento dirigido por testes (Test Driven Development).
importante ter em mente que os testes em TDD devem ser testes de
unidades automatizadas, em que requisitos so definidos antes mesmo que o cdigo
seja criado. Para isso, o desenvolvedor deve ter conhecimento sobre o problema
proposto, para saber test-lo de forma correta.
Cumprindo todas as etapas, o software ter passado por testes consistentes
de qualidade, alm de se constiturem em cdigos simples por terem sido
refatorados.
1.2 Caracterizao do problema em estudo
TDD baseado em um ciclo curto de repeties, no qual se escreve um

cdigo que servir para melhorar o funcionamento do que ser testado ou at
mesmo lhe adicionar uma nova funo. Feito isso, o cdigo do programa em
questo ser gerado para testar as rotinas de teste. Quando os testes so
validados, o cdigo refatorado para evitar a duplicao de cdigo.
Mas por que testar um software? O teste exercita a lgica interna dos
componentes do software e as reaes do produto com relao entrada e sada de
dados, buscando encontrar erros para que, posteriormente, sejam analisados e
corrigidos. Apesar de ocupar em torno de 30% a 40% do tempo planejado para o
desenvolvimento de um produto de software, uma pesquisa mostrou que um erro
descoberto tardiamente em sistema provoca acrscimo de 60% no custo do projeto
11
(ANGELON, 2006, p.13). Assim, alm de minimizar custos, os testes aumentam a

qualidade e a confiabilidade do software.
1.3 Objetivo
Este projeto tem por objetivo mostrar a importncia de testes para garantir
qualidade, baixos custos e ganho em tempo e em desempenho por meio do uso de
TDD.
Tais testes sero demonstrados e praticados atravs de um software de
carona. O sistema ser responsvel por cadastrar pessoas que podem oferecer e
necessitar de carona, alm de suas rotas e outras condies.
1.4 Organizao do trabalho

No prximo captulo ser apresentado todo o fundamento terico utilizado
neste trabalho para aplicao prtica dos testes de software. O Captulo 3 ir
descrever os materiais e mtodos escolhidos para o desenvolvimento.
Uma
anlise prtica dos testes aplicados ser apresentada no Captulo 4. No Captulo 5

esto os resultados e discusso. No captulo 6, a concluso. No Captulo 7, as
consideraes finais.
12
2 REFERENCIAL TERICO
2.1 Engenharia de software

Engenharia de Software a juno de conceitos de engenharia com o
objetivo de obter softwares com qualidade, baixo custo e que sejam confiveis.
A Engenharia de Software uma tecnologia em camadas. Segundo
Pressman (2010, p.17), [...] qualquer abordagem da Engenharia (incluindo
Engenharia de Software) deve se apoiar em um compromisso organizacional com a
qualidade. A base em que se apoia o foco na qualidade.
Figura 1 - Engenharia de Software em camadas (PRESSMAN, 2010, p.17)
2.1.1 Processo
O Processo tem por funo manter unidas as camadas de tecnologia, permitir

o desenvolvimento oportuno e racional do software, formar a base para o controle
gerencial dos projetos de software e estabelecer quais mtodos tcnicos sero
aplicados. Nos produtos de trabalho (modelos, dados, documentos, formulrios,
relatrios, etc), a qualidade assegurada, os limites so estabelecidos e as
modificaes so adequadamente geradas.
13
2.1.2 Mtodos
Os mtodos de Engenharia de Software fornecem a tcnica de como fazer

para construir softwares. Eles abrangem um amplo conjunto de tarefas que incluem
comunicao, anlise de requisitos, modelagem de projeto, construo de
programas, testes e manuteno. Os mtodos de Engenharia de Software repousam
em um conjunto de princpios bsicos que regem cada rea da tecnologia e incluem
atividades de modelagem de outras tcnicas descritivas.
A UML um mtodo que se aplica na etapa do modelo de anlise.
2.1.3 Ferramentas
As ferramentas de Engenharia de Software fornecem apoio automatizado ou

semi-automatizado para um processo e para os mtodos. Quando ferramentas so
integradas de modo que a informao criada por uma ferramenta possa ser usada
por outra, um sistema de apoio ao desenvolvimento de software, chamado
Engenharia de Software apoiada por Computador, estabelecido.
Temos por exemplos de ferramenta de desenvolvimento de software: Visual
Studio e PHP (Personal Hypertex Preprocessor).
2.2 Desenvolvimento gil
As definies modernas de desenvolvimento gil evoluram a partir da dcada

de 1990. Os mtodos geis foram desenvolvidos para acabar com fraquezas
desenvolvidas
nos
softwares
convencionalmente
usados.
Podem
fornecer
importantes benefcios, mas no so aplicveis a quaisquer projetos, produtos,

pessoas ou situaes. Todavia, no perdem a prtica de Engenharia de Software.
Segundo Pressman (2010, p.21), Modelos de processo que enfatizam a
agilidade do projeto e seguem uma srie de princpios que levam a uma abordagem
mais informal (mas, segundo seus proponentes, no menos efetivo) do processo de
14
software foram propostos nos ltimos anos. Esses modelos de processo gil
enfatizam a manobrabilidade e a adaptabilidade. Eles so adequados a muitos tipos
de projetos e so particularmente teis quando aplicaes web passam por
engenharia.
Nos dias atuais frequente, difcil ou impossvel prever como um sistema
baseado em computador evoluir com o passar do tempo. Com um mercado de
software nessa estabilidade, os engenheiros de software devem ser suficientemente
geis para responder a um ambiente de negcios mutantes.
De acordo com Pressman (2010, p.59), Jacobson [Jac02]Agilidade tornou-se
atualmente uma palavra mgica quando se descreve um processo moderno de
software. Tudo gil. [...]. Ela idealiza a rpida entrega do software operacional, d
menos importncia para produtos de trabalho intermedirios, adota os clientes como
parte da equipe de desenvolvimento e trabalha para eliminar a atitude ns e eles,
que tende a permanecer em muitos projetos de software.
2.2.1 Extreme Programming (XP)
O modelo de processo XP como seu padro de desenvolvimento pr-definido

inclui um conjunto de regras e prticas que ocorrem no contexto de quatro
atividades: planejamento, projeto, codificao e teste. A figura 2 ilustra o processo
XP e mostra algumas das ideias-chaves e tarefas que esto associadas a cada
atividade.
15
Figura 2 - O processo extreme progamming.(PRESSMAN, 2010, p64)
2.2.1.1 Planejamento
Planejamento a criao de um conjunto de histrias que descreve as
caractersticas e as funcionalidades requeridas para o software a ser construdo. O
cliente estabelece um conjunto de problemas a ser resolvido e os membros da
equipe XP estabelecem um prazo medido em semanas para resolver este conjunto
de problemas. Se o conjunto de problemas demorar mais que trs semanas, os
membros da equipe solicitam ao cliente que divida o conjunto de problemas em
partes. importante notar que novos conjuntos de problemas podem ser escritos.
Os clientes e a equipe XP trabalham juntos para decidir como agrupar os
conjuntos de problemas na verso seguinte a ser desenvolvida pela equipe XP. Uma
vez feito um compromisso bsico para nova verso a ser desenvolvida, define-se
por qual dos trs modos ser desenvolvido o conjunto de problemas.
16
Tudo implementado imediatamente;

Os problemas com maior prioridade so desenvolvidos primeiro;
Os problemas com maior risco so implementados primeiro.
2.2.1.2 Projeto
O Projeto XP um projeto simples e sempre o preferido em uma

representao mais complexa. Este projeto fornece diretrizes de implementao
para um conjunto de problemas como est escrita pelo cliente; nada mais e nada
menos.
Se um problema de alta complexidade encontrado como parte de um
determinado conjunto de problemas, o XP recomenda a criao imediata dos
prottipos desta parte do projeto, denominado soluo de ponta. O prottipo do
projeto implementado e avaliado e o XP sugere a refabricao.
Segundo Pressman(2010, p.65), Fowler[fow00] Refabricao o processo
de modificar um sistema de software de tal modo que ele no altere o
comportamento externo do cdigo, mas aperfeioe a estrutura interna. um modo
disciplinado de limpar o cdigo (e modificar/simplificar o projeto interno) que
minimiza as chances de introduo de defeitos. Em essncia, quando voc refabrica
est aperfeioando o projeto de cdigo depois que ele foi escrito.
O XP, em uma viso geral, ocorre tanto antes de codificar quanto depois que
a codificao comea.
2.2.1.3 Codificao
O conceito-chave da codificao a programao em pares. O XP

recomenda que duas pessoas da equipe trabalhem juntas em um computador para
criar o cdigo correspondente a um conjunto de problemas, pois isto fornece recurso
de correo de problemas em tempo real e garantia de qualidade tambm em tempo
17
real. medida em que os pares de programadores completam seu trabalho, estes

cdigos so unificados por uma equipe de unificao diariamente.
O XP recomenda que, ao terminar as etapas preliminares e antes que os
conjuntos de problemas sejam codificados, seja feito um conjunto de testes unitrios
que exercitaro cada um dos conjuntos de problemas, que devem ser includos na
verso atual.
2.2.1.4 Teste
J foi mencionado que criar um teste unitrio primordial antes da

codificao no XP. Na proporo em que os testes unitrios individuais so
organizados em uma sequncia universal de testes, o teste de integrao e a
validao do sistema podem ocorrer diariamente, fornecendo equipe XP uma
indicao contnua do progresso dos testes.
Os testes de aceitao XP, tambm chamados testes do cliente, so
especificados pelo cliente e focalizam as caractersticas e funcionalidades globais do
sistema em geral. So, assim, um teste especfico do cliente.
2.3 TDD (Test Driven Development)
O Desenvolvimento Dirigido por Testes (TDD) tem por idealizador Kent Beck.
Uma das diferenas entre TDD em relao a outros mtodos que com TDD o
desenvolvedor vai evoluindo seu cdigo aos poucos, conforme explora o problema,
com o uso de testes automatizados escritos antes da soluo sequer existir.
De acordo com Beck (2003), [...] uma abordagem evolutiva para o
desenvolvimento que combina teste anterior de desenvolvimento, onde voc escreve
um teste antes de escrever cdigo de produo apenas o suficiente para cumprir
esse teste e a refatorao.
18
Pode-se perder um pouco de um dos maiores benefcios de TDD, o feedback

rpido sobre o que est sendo gerado. Nesse ponto, o design incremental
apresentado. A ideia que a soluo seja criada em pequenos passos, que sero
detalhados a seguir:
Escreva um pequeno teste que falhe e que talvez sequer compile
inicialmente. Como o cdigo nem foi gerado, o teste no poder prever seus erros.
Faa o teste passar da maneira rpida, cometendo qualquer pecado durante
este processo. O teste foi realizado, realmente funciona e passa pelas condies
impostas. Mas preciso lembrar que ele no est pronto para testar e encontrar o
erro em um programa. Foi apenas projetado para passar por uma determinada
condio que satisfaa o problema inicial. Se necessrio, escreva apenas a parte do
cdigo necessrio para que o teste passe.
Refatore: elimine toda duplicao criada para fazer os testes passarem. O
cdigo gerado inicialmente pode ser melhorado por meio da refatorao. Com a
refatorao, o cdigo ser escrito de forma mais simples, com menos linhas de
comandos e codificaes que outrora estavam duplicados em todo programa. A
Figura 3 ilustra os passos de TDD:
Figura 3 - O processo TDD
19
importante lembrar tambm que, como o teste inicial foi feito sem o cdigo,
dever ser modificado para melhor atender ao funcionamento de um programa em
geral. Por isso, deve-se ter em mente que, para projetar um teste de alto nvel, o
programador precisa ter conhecimento sobre o assunto e principalmente saber como
test-lo e test-lo de forma efetiva, que d resultados. Segundo Reis (2011, p.85),
"Voc s deve escrever um programa se voc souber como test-lo."
Outro ponto importante em TDD no ficar preso ao mesmo teste por muito
tempo. Deve-se tentar resolv-lo de forma rpida. Caso no consiga test-lo
rapidamente no se deve ficar preso a este teste, mas sim iniciar outro meio de
como fazer o mesmo teste, para que o mesmo seja feito, testado e, se houver
resultados positivos, refator-lo futuramente. Caso no haja melhoria, deve-se
simplesmente voltar verso anterior do projeto, que j passou por todas as etapas,
foi refatorado e ento voltou a ser testado, e continue a partir dele. Dessa forma, no
h perda de tempo com depurao.
Vale acrescentar que tempo no perdido com testes. Na verdade, quando o
assunto a ser testado conhecido pelo programador e os testes so bem
desenvolvidos, muito tempo poupado na parte de programao.
2.4 Carona com tecnologia

Atualmente, pessoas que tm acesso a universidades, escolas, empresas,
localidades e outras instituies enfrentam um srio problema com o trnsito para
chegar a essas instituies, devido ao excesso de veculos ou falta do mesmo.
Outro conceito racional seria tambm pensar no meio ambiente, diminuindo o
lanamento do monxido de carbono na natureza. Assim sendo, seria vivel
aumentar a mobilidade das comunidades, agilizando e melhorando a qualidade de
vida das pessoas. Uma forma de resolver esse problema poderia ser a comunicao
entre as pessoas, sejam elas de diferentes localidades ou no.
Tendo por funo oferecer ou pedir carona, seguindo este conceito, seria uma
forma prtica, rpida e bem vivel para a mobilidade da comunidade com intuito de
diminuir o trfego e o fluxo de veculos nos permetros urbanos e industriais.
20
3 MATERIAL E MTODOS
Os seguintes mtodos foram utilizados para o desenvolvimento do sistema

proposto neste projeto:
Arquitetura em Camadas: sua utilizao permite abstrair toda a lgica de

acesso aos dados em um conjunto de classes e fornece uma interface
consistente, alm de facilitar a manuteno, a portabilidade e a escalabilidade
da aplicao;
Arquitetura Orientada a Objetos: baseada na composio e interao entre
diversas unidades de software chamadas de objetos;

Modelo Relacional de Banco de Dados: um conceito abstrato que define
maneiras de
armazenar, manipular
recuperar
dados
estruturados
unicamente na forma de tabelas;

Histrias de usurio: descreve uma funcionalidade de valor para o usurio ou
patrocinador de um software.
Este trabalho foi desenvolvido em seis etapas:
Na primeira etapa foi desenvolvido um estudo sobre Engenharia de Software.

Na segunda etapa foi realizado um estudo sobre TDD;
Na terceira etapa foi realizada uma pesquisa sobre as ferramentas
necessrias que permitissem a implementao do sistema proposto;

Na quarta etapa foi realizada uma pesquisa sobre o sistema proposto;
Na quinta etapa foi implementado o mtodo de testes TDD;
Na sexta etapa foi desenvolvido o sistema proposto, utilizando TDD e o
processo XP.
As seguintes tecnologias foram utilizadas para o desenvolvimento do sistema

proposto neste projeto.
ASP.NET: Plataforma da Microsoft para o desenvolvimento de aplicaes

Web, que o sucessor da tecnologia ASP. um componente do IIS que
permite, atravs de uma linguagem de programao integrada na .NET
Framework, criar paginas dinmicas. As aplicaes para essa plataforma
podem ser escritas em varias linguagens, como C# e Visual Basic .Net;
21
C#: linguagem de programao orientada a objetos desenvolvida pela

Microsoft como parte da plataforma .Net. A sua sintaxe orientada a objetos foi
baseada no C++, mas inclui muitas influncias de outras linguagens de
programao, como Delphi e Java.

SQL Server 2008 Express: um produto de gerenciamento de dados poderoso
e confivel, que fornece recursos robustos, proteo de dados e desempenho
para clientes de aplicativos incorporados, aplicativos Web simples e
armazenamentos de dados locais.

Visual Studio Team System 2010.
4 DESENVOLVIMENTO
22
Foi desenvolvido um sistema de carona voltado para os alunos da Unifenas,

utilizando-se os conceitos de Test Driven Development (TDD).
4.1 Camada de Testes e Mtodos
Todos os testes foram gerados pelo uso de TDD e aplicados neste projeto,
sendo executados na ferramenta de desenvolvimento Visual Studio Team System
2010 e utilizando a biblioteca Microsoft.VisualStudio.TestTools.UnitTesting.
TDD implica em testes que sero executados antes que o cdigo seja gerado
e que novos testes sejam aplicados medida que o cdigo evolua. Por esse motivo,
testes foram aplicados antes mesmo que a interface fosse criada. Este um ponto
importante, porque testes existem para encontrar erros antes da implementao de
interfaces.
Com o TDD, foram criados testes que seriam necessrios para o bom
desenvolvimento do sistema em questo, sendo este sistema codificado em
concordncia aos testes j criados inicialmente. Conforme avanava na codificao,
apareciam novos testes para serem criados. Como as etapas do TDD exigem que
para cada teste criado um mtodo seja implementado, para verificar o determinado
teste, deve-se faz-lo passar de forma rpida, se necessrio, e ento o mtodo
refatorado. Depois dessa etapa, o cdigo principal documentado, informando onde
ser necessrio utilizar aquele mtodo.
Depois de todos os mtodos criados disparada a rotina de testes para
verificar se um mtodo no atrapalha o outro, sendo feito ento o teste de
componente. Havendo algum erro, o mtodo em questo refatorado. A Figura 4
demonstra uma falha de teste na rotina, que valida a data.
23
Figura 4 - Exemplo de um teste falhando na rotina de testes criada
O teste Teste_Data falhou, porque a data de sada para viagem inserida

menor que a data atual do sistema, como descrita abaixo pelo cdigo do teste e do
mtodo.
Rotina de teste para a data:
[TestMethod]
public void Teste_Data()
{
string _data = "01/12/2011";
Assert.IsNotNull(objRota);
Assert.IsTrue(objRota.Valida_Data(_data));
}
Este teste chama o mtodo Valida_Data, passando para ele uma data
qualquer como parmetro.
Mtodo Valida_Data:
public bool Valida_Data(string _data)

{
int _dia = int.Parse(_data.Substring(0, 2));
int _mes = int.Parse(_data.Substring(3, 2));
24
int _ano = int.Parse(_data.Substring(6, 4));

bool teste = true;
if ((((_ano - 1900) % 4) != 0) && (_mes == 2) || (_dia > 29))
{ teste = false; }
if (((_mes == 01) || (_mes == 03) || (_mes == 05) || (_mes == 07) ||
(_mes == 08) || (_mes == 10) || (_mes == 12)) && (_dia > 31))
{ teste = false; }
if (((_mes == 04) || (_mes == 06) || (_mes == 09) || (_mes == 11))
&& (_dia > 30))
{ teste = false; }
if ((_mes > 12) || (_dia > 31) || (_dia < 1) || (_mes < 1) ||
(_ano < 1900))
{ teste = false; }
return teste;
}
O mtodo recebe como parmetro uma data e verifica se maior que a data
do sistema; tambm verifica a quantidade de dias por ms, a quantidade de meses
por ano e se o ano bissexto ou no.
Se for inserida uma data maior ou igual data do sistema, a rotina de teste
no apresentar mais o erro gerado. Observe o exemplo na Figura 5, inserindo a
data 29/10/2011, sendo que a data atual do sistema de 28/10/2011.
Figura 5 - Exemplo de uma correo de erro
25
Abaixo ser demonstrada toda a classe de teste e seus mtodos, tendo como
principal finalidade a verificao de dados digitados pelo usurio e dados a serem
inseridos no banco de dados:
Library Carona_Teste com a Classe Pessoa_Teste, onde esto todos os
testes que verificam o cadastro e a alterao de pessoas no sistema:
using
using
using
using
using
using
System;
System.Text;
System.Collections.Generic;
System.Linq;
Microsoft.VisualStudio.TestTools.UnitTesting;
Carona_Metodos_Testes;
namespace Carona_Teste
{
[TestClass]
public class Pessoa_Teste
{
Pessoa_Metodos Pessoa = new Pessoa_Metodos();//Estancia o objeto Pessoa
//TESTE QUE TESTA SE A MATRICULA INICIA COM 0 E SE CONTEM 9 NUMEROS
[TestMethod]
public void Testa_Matricula()
{
string mat = "123456789";
//variavel que recebe uma string com uma matricula para testar
Pessoa.recebe_Matricula(mat);//objeto pessoa
Assert.IsNotNull(Pessoa);
//Testa se o objeto no nulo
Assert.IsTrue(Pessoa.Mede_Matricula());
//Testa se a matricula contem 9 digitos
Assert.IsTrue(Pessoa.Confere_Inicio_Matricula_Igual_0());
//Testa se a matricula inicia com 0
}
//TESTE QUE TESTA SE O CPF VALIDO
[TestMethod]
public void Testa_Cpf()
{
string cpf = "000.000.000-00";
//variavel que recebe uma string com um cpf para testar
Assert.IsNotNull(Pessoa);//Testa se o objeto no nulo
Assert.IsTrue(Pessoa.Valida_CPF(cpf));//Testa se o Cpf existente
}
//TESTE QUE TESTA SE EXISTE ALGUM CPF IGUAL CADASTRADO
[TestMethod]
public void Testa_Igualdade_Cpf()
{
string cpf = "000.000.000-00";
//variavel que recebe uma string com um cpf para testar
Assert.IsTrue(Pessoa.Valida_Cpf_Igual(cpf));
//Testa se o Cpf igual a outro existente na base de dados
}
26
//TESTE QUE TESTA SE A DATA DE NASCIMENTO VALIDA

[TestMethod]
public void Testa_Data_Nasc()
{
string _data = "12/12/1994";
//variavel que recebe uma string com uma data para testar
Assert.IsTrue(Pessoa.Valida_Data(_data));//Testa se a data valida
}
//TESTE QUE TESTA SE EXISTE ALGUMA MATRICULA IGUAL CADASTRADA
[TestMethod]
public void Testa_Matricula_Igual()
{
string matricula = "201071082";
//variavel que recebe uma string com uma matricula para testar
Assert.IsTrue(Pessoa.Valida_Matricula_Igual(matricula));
//Testa se a Matricula igual a outro existente na base de dados
}
}
Library Carona_Metodos_Testes com a Classe Pessoa_Metodos, onde esto

todos os mtodos que verificam o cadastro e a alterao de pessoas no sistema:
using
using
using
using
using
using
using
System;
System.Linq;
System.Text;
Carona_ENT;
System.Data.SqlClient;
System.Data;
namespace Carona_Metodos_Testes
{
public class Pessoa_Metodos
{
string mat;//variavel global para testar os metodos
Util conexao = new Util();
//Metodo que insere uma matricula na variavel globa para testar os metodos
public void recebe_Matricula(string recev)
{
mat=recev;
}
//Metodo que conta se h os 9 digitos obrigatorios da matricula
//testado na camada Carona_Teste
public bool Mede_Matricula()
{
bool teste=true;
int i;
i = mat.Length;
if (i != 9)
teste = false;
return teste;
27
}
//Metodo que retorna o inicio matricula
public bool Confere_Inicio_Matricula_Igual_0()
{
bool teste = true;
if (int.Parse(mat[0].ToString()) == 0)
teste = false;
return teste;
}
//Metodo que valida o Cpf
public bool Valida_CPF(string cpf)
{
int[] multiplicador1 = new int[9] { 10, 9, 8, 7, 6, 5, 4, 3, 2 };
int[] multiplicador2 = new int[10] { 11, 10, 9, 8, 7, 6, 5, 4, 3, 2 };
string tempCpf;
string digito;
int soma;
int resto;
cpf = cpf.Trim();
cpf = cpf.Replace(".", "").Replace("-", "");
if (cpf.Length != 11)
return false;
tempCpf = cpf.Substring(0, 9);
soma = 0;
for (int i = 0; i < 9; i++)
soma += int.Parse(tempCpf[i].ToString()) * multiplicador1[i];
resto = soma % 11;
resto = Resto(resto);
digito = resto.ToString();
tempCpf = tempCpf + digito;
soma = 0;
for (int i = 0; i < 10; i++)
soma += int.Parse(tempCpf[i].ToString()) * multiplicador2[i];
resto = soma % 11;
if (resto < 2)
resto = 0;
else
resto = 11 - resto;
digito = digito + resto.ToString();
return cpf.EndsWith(digito);
}
private static int Resto(int resto)
{
if (resto < 2)
resto = 0;
else
resto = 11 - resto;
28
return resto;
}
";
//Metodo que verifica se existe algum cpf existente na base de dados para no
duplicar dois usuarios com cpfs iguais
public bool Valida_Cpf_Igual(string Cpf)
{
bool teste = true;
SqlConnection _conn = new SqlConnection("Data Source=localhost\\
SQLEXPRESS;Initial Catalog=Carona_TCC;Integrated Security=True");
SqlCommand command = new SqlCommand();
_conn.Open();
command.Connection = _conn;
command.CommandType = CommandType.StoredProcedure;
command.CommandText = "[sp_Consulta_Cpf_Igual]
command.Parameters.AddWithValue("@cpf_Pessoa",
SqlDbType.VarChar).Value = Cpf;
SqlDataReader dr = command.ExecuteReader();
if (dr.HasRows)
teste = false;
return teste;
}
//Metodo que valida data se ano bisexto e se um respectivo
mes tem 31,30,29 ou 28 dias
{
bool teste = true;
if ((((_ano - 1900) % 4) != 0) && (_mes == 2) || (_dia > 29))
{ teste = false; }
if (((_mes == 01) || (_mes == 03) || (_mes == 05) || (_mes == 07) ||
(_mes == 08) || (_mes == 10) || (_mes == 12)) && (_dia > 31))
{ teste = false; }
if (((_mes == 04) || (_mes == 06) || (_mes == 09) || (_mes == 11))
&& (_dia > 30))
{ teste = false; }
if ((_mes > 12) || (_dia > 31) || (_dia < 1) || (_mes < 1) ||
(_ano < 1900))
{ teste = false; }
return teste;
}
//Metodo que verifica se existe alguma matricula existente na base de dados
para no duplicar dois usuarios com matriculas iguais
public bool Valida_Matricula_Igual(string Matricula)
{
bool teste = true;
SqlConnection _conn = new SqlConnection("Data Source=localhost\\
SQLEXPRESS;Initial Catalog=Carona_TCC;Integrated Security=True");
SqlCommand command = new SqlCommand();
29
_conn.Open();
command.Connection = _conn;
command.CommandType = CommandType.StoredProcedure;
command.CommandText = "[sp_Consulta_Matricula_Igual]
";
command.Parameters.AddWithValue("@matricula",
SqlDbType.VarChar).Value = Matricula;
SqlDataReader dr = command.ExecuteReader();
if (dr.HasRows)
teste = false;
return teste;
}
Library Carona_Teste com a Classe Rota_Teste, onde esto todos os testes

que verifica o cadastro e alterao das Rotas no sistema:
using
using
using
using
using
using
System;
System.Text;
System.Linq;
Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Carona_Teste
{
[TestClass]
public class Rota_Teste
{
Rota_Metodos objRota = new Rota_Metodos();
//TESTE QUE TESTA SE O NUMERO DE VAGAS NA CARONA COMPATIVEL
COM TIPO DE VEICULO
[TestMethod]
public void Teste_Tipo_Veiculo()
{
string _carro = "Passeio";
//variavel que recebe uma string com um tipo de carro para testar
int _quant = 1;
//variavel que recebe uma quantidade de passageiros para testar
Assert.IsNotNull(objRota);//Testa se o objeto no nulo
Assert.IsTrue(objRota.Quant_por_Veiculo(_carro, _quant));
}
//TESTE QUE TESTA SE A DATA DA CARONA MAIOR OU IGUAL QUE A
DA DATA CADASTRADA
[TestMethod]
public void Teste_Data()
{
string _data = "01/12/2011";
//variavel que recebe uma string com uma data para testar
Assert.IsTrue(objRota.Valida_Data(_data));
//Testa se a data da carona maior que a data cadastrada
}
30
//TESTE QUE TESTA SE A HORA DA CARONA MAIOR OU IGUAL QUE

A DA HORA CADASTRADA
[TestMethod]
public void Teste_Hora()
{
string _hora = "23:59";
//variavel que recebe uma string com alguma hora para testar
Assert.IsTrue(objRota.Valida_Hora(_hora));
//Testa se a hora da carona maior ou igual que a data cadastrada
}
//TESTE QUE TESTA SE A DATA DE SAIDA DA CARONA MENOR QUE A DATA DE CHEGADA
[TestMethod]
public void Testa_HoraComData()
{
DateTime _Data_Saida = Convert.ToDateTime("12/11/2011 23:00:00");
//variavel que recebe uma string com uma data e hora para testar
DateTime _Data_Chegada = Convert.ToDateTime("12/11/2011 23:01:00");
//variavel que recebe uma string com uma data e hora para testar
Assert.IsTrue(objRota.Valida_HoraComData(_Data_Saida, _Data_Chegada));
//Testa se a data de saida da carona menor que a data de chegada
}
}
Library Carona_Metodos_Testes com a Classe Rota_Metodos, onde esto

todos os mtodos que verifica o cadastro e alterao das Rotas no sistema:
using
using
using
using
System;
System.Linq;
System.Text;
namespace Carona_Metodos_Testes
{
public class Rota_Metodos
{
//Metodo que verifica a quantidade maxima e minima de
vagas de carona por veiculo
public bool Quant_por_Veiculo(string tipoCar, int quant)
{
bool teste = false;
if ((tipoCar == "nibus") && (quant <= 48) && (quant > 0))
{ teste = true; }
if ((tipoCar == "Van") && (quant <= 17) && (quant > 0))
{ teste = true; }
if ((tipoCar == "Passeio") && (quant <= 7) && (quant > 0))
{ teste = true; }
if ((tipoCar == "Camioneta") && (quant <= 5) && (quant > 0))
{ teste = true; }
31
if ((tipoCar == "Pickup") && (quant <= 2) && (quant > 0))

{ teste = true; }
if ((tipoCar == "Moto") && (quant <= 1) && (quant > 0))
{ teste = true; }
}
return teste;
//Metodo que valida se a data da carona maior ou

igual que a do dia cadastrada
{
String _data_atual = (DateTime.Today.Day.ToString()+"/"+
DateTime.Today.Month.ToString()+"/"+DateTime.Today.Year.ToString());
bool teste = true;
if (Convert.ToDateTime(_data) < Convert.ToDateTime(_data_atual))
{ teste = false; }
if ((((_ano - 1900) % 4) != 0) && (_mes == 2) || (_dia > 29))
{ teste = false; }
if (((_mes == 01) || (_mes == 03) || (_mes == 05) || (_mes == 07) ||
(_mes == 08) || (_mes == 10) || (_mes == 12)) && (_dia > 31))
{ teste = false; }
if (((_mes == 04) || (_mes == 06) || (_mes == 09) || (_mes == 11))
&& (_dia > 30))
{ teste = false; }
if ((_mes > 12) || (_dia > 31) || (_dia < 1) || (_mes < 1) ||
(_ano < 1900))
{ teste = false; }
return teste;
}
//Metodo que valida se a hora da carona maior ou igual que
a do dia cadastrada
public bool Valida_Hora(String _Hora)
{
int _hora = int.Parse(_Hora.Substring(0, 2));
int _minuto = int.Parse(_Hora.Substring(3, 2));
bool teste = false;
if ((_hora <= 23) && (_minuto <= 59) && (_hora >= 0) && (_minuto >= 0))
{
teste = true;
}
}
return teste;
//Metodo que valida se a data de saida da carona menor que a data de chegada
public bool Valida_HoraComData(DateTime _Data_Saida, DateTime _Data_Chegada)
32
{
bool teste = false;
if (_Data_Saida <_Data_Chegada)
{
teste = true;
}
return teste;
}
5 RESULTADOS E DISCUSSO
33
Atravs do uso de TDD, vrios testes aplicados no sistema de carona

Unifenas possibilitam uma maior qualidade do software.
Os testes podem ser aplicados antes ou juntamente com o desenvolvimento
das classes. Quando uma classe desenvolvida, um plano de teste pode ser
elaborado para que os erros sejam encontrados e corrigidos. Assim, quando for
necessria a integrao entre classes, os riscos so minimizados, pois as mesmas
j foram testadas e suas funcionalidades esto conforme o especificado no projeto.
Verificou-se que a etapa de testes possui um papel muito importante no
desenvolvimento de sistemas, uma vez que erros podem ser encontrados e
corrigidos antes que a camada de interface seja implementada.
6 CONCLUSO
34
Com base nos dados coletados no sistema proposto (software de carona)

percebeu-se que, com a refatorao, o cdigo reduziu em termos de nmero de
linhas de cdigo, tornando-o mais simples. Com a biblioteca de teste criada desde o
incio da codificao, cada modificao feita no sistema verificada rodando a rotina
de teste e, com isso, ocupa menor tempo para testes finais do projeto, compensando
o tempo gasto no incio do projeto para criar os testes. Os testes geraram uma
documentao, o que facilita a manuteno ou at a adio de novas
funcionalidades, se necessrio. Estes fatores, entre outros, aumentam a qualidade
do produto final e, com isso, conclui-se que vivel aplicar TDD na construo de
sistemas.
7 CONSIDERAES FINAIS
35
Aps a execuo da etapa de testes, pode-se notar que os riscos de um

sistema conter falhas diminuem, pois um grupo de erros possveis testado e
analisado, para que possa ser corrigido, caso o funcionamento no esteja dentro do
esperado.
O teste de unidade possui um papel importante na fase de testes de software,
porque se as unidades do sistema no funcionam corretamente, todo o sistema
estar comprometido.
Quando um teste bem planejado e executado, pode-se garantir mais
qualidade, confiabilidade e segurana na entrega do produto final.
Como sugesto para trabalhos futuros, pode-se utilizar TDD em uma outra
ferramenta de desenvolvimento. Pode-se tambm utilizar TDD para executar testes
em banco de dados.
8 REFERNCIAS
36
BECK, K. eXtreme Programming Explained, Addison Wesley, 2000.

BECK, K. Test Driven Development: By Example, Addison Wesley, 2002.
REIS, J.C.S. Engenharia de software: Qualidade de Software. Alfenas, 2011. 115f.
Notas de Aula.
PRESSMAN, ROGER S., Engenharia de Software- 6 edio, So Paulo, Ed.
McGrawHill, 2010.
37
APNDICE A CDIGOS E TELAS DA INTERFASE

Login
Figura 6 - Tela de Login

using
using
using
using
using
using
using
using
using
using
using
using
System;
System.Linq;
System.Web;
System.Web.UI;
System.Web.UI.WebControls;
Carona_BLL;
Carona_ENT;
Carona_DAL;
System.Data;
namespace Exemplo_TCC_web.Views
{
public partial class Login : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
Session["id"] = null;
}
protected void Button1_Click(object sender, EventArgs e)
{
38
SqlConnection conn = new SqlConnection(conexao.GetConnectionString(""));

SqlCommand coman = new SqlCommand();
Pessoa_Metodos Pessoa = new Pessoa_Metodos();
conn.Open();
coman.Connection = conn;
coman.CommandType = CommandType.StoredProcedure;
coman.CommandText = "[sp_Login]";
//Metodo mede_matricula localizado na library Carona_Metodos_Teste na classe
Pessoa_Metodos
//Metodo Confere_Inicio_Matricula_Igual_0 localizado na library
Carona_Metodos_Teste na classe Pessoa_Metodos
Pessoa.recebe_Matricula(txtMatricula.Text);
if ((Pessoa.Mede_Matricula() == false) ||
(Pessoa.Confere_Inicio_Matricula_Igual_0() == false))
{
string Messagem = @"Voc deve digitar a matricula corretamente";
ScriptManager.RegisterStartupScript(Page, this.GetType(),
"alert",
string.Format("alert('{0}');", Messagem), true);
txtMatricula.Text = "";
txtMatricula.BorderColor = System.Drawing.Color.Red;
txtSenha.Text = "";
}
else
{
coman.Parameters.AddWithValue("@matricula",
SqlDbType.VarChar).Value =
txtMatricula.Text;
coman.Parameters.AddWithValue("@senha", SqlDbType.VarChar).Value
= txtSenha.Text;
SqlDataReader dr = coman.ExecuteReader();
if (dr.HasRows)
{
dr.Read();
Session["id"] = dr["id_Pessoa"];
Response.Redirect("~/Home.aspx");
}
else
{
string Messagem = @"Voc no Cadastrado? \n Cadastre-se Agora em
nosso Sistema de Carona Unifenas !!! ";
ScriptManager.RegisterStartupScript(Page, this.GetType(), "alert",
}
}
}
Contato
39
Figura 7 - Tela de Contatos
using
using
using
using
using
using
System;
System.Linq;
System.Web;
System.Web.UI;
namespace Sistema_de_Carona_1._0.Views.Help
{
public partial class Contato : System.Web.UI.Page
{
{
}
}
Help
40
Figura 8 - Tela de Ajuda
using
using
using
using
using
using
System;
System.Linq;
System.Web;
System.Web.UI;
namespace Sistema_de_Carona_1._0.Views.Help
{
public partial class Help : System.Web.UI.Page
{
{
}
}
Home
41
Figura 9 - Tela de Abertura aps o login
using
using
using
using
using
using
System;
System.Linq;
System.Web;
System.Web.UI;
namespace Sistema_de_Carona_TCC
{
public partial class Home : System.Web.UI.Page
{
{
}
Cadastrar Pessoa
42
Figura 10 - Tela de cadastrar Perfil
using
using
using
using
using
using
using
using
using
using
using
using
System;
System.Linq;
System.Web;
System.Web.UI;
Carona_BLL;
Carona_DAL;
Carona_ENT;
System.Data;
namespace Sistema_de_Carona_TCC.Views.Registers
{
public partial class Cadastrar : System.Web.UI.Page
{
{
Session["id"] = null;
}
protected void ddlEstado_SelectedIndexChanged(object sender, EventArgs e)
43
{
try
{
Cidade_BLL objCidade_BLL = new Cidade_BLL();
Cidade objCidade_ENT = new Cidade();
SqlDataReader dr;
List<Cidade> Lista = new List<Cidade>();
objCidade_ENT.Estado = ddlUF.SelectedValue.ToString();
dr = objCidade_BLL.Consulta_Cidade(objCidade_ENT);
if (dr.HasRows)
{
while (dr.Read())
{
Cidade estado = new Cidade();
estado.IdCidade = Convert.ToInt32(dr["id_Cidade"].ToString());
estado.NomeCidade = dr["nome_Cidade"].ToString();
Lista.Add(estado);
}
ddlCidade.DataTextField = "NomeCidade";
ddlCidade.DataValueField = "IdCidade";
ddlCidade.DataSource = Lista;
ddlCidade.DataBind();
}
}
catch (Exception)
{
throw;
}
}
protected void btnCadastrar_Click(object sender, EventArgs e)
{
Pessoa_Metodos _MT = new Pessoa_Metodos();
bool valida = true;
if (_MT.Valida_CPF(txtCPF.Text) == false)
{
valida = false;
txtCPF.Text = "";
txtCPF.BorderColor = System.Drawing.Color.Red;
}
if (_MT.Valida_Cpf_Igual(txtCPF.Text) == false)
{
valida = false;
txtCPF.Text = "";
txtCPF.BorderColor = System.Drawing.Color.Red;
}
if (_MT.Valida_Data(txtDtNascimento.Text) == false)
{
valida = false;
txtDtNascimento.Text = "";
txtDtNascimento.BorderColor = System.Drawing.Color.Red;
}
_MT.recebe_Matricula(txtMatricula.Text);
if (_MT.Mede_Matricula() == false)
{
valida = false;
44
}
if (_MT.Valida_Matricula_Igual() == false)
{
valida = false;
}
if (_MT.Confere_Inicio_Matricula_Igual_0() == false)
{
valida = false;
}
if (valida == false)
{
string Messagem = @" Por favor, verifique os dados preenchidos
nos campos marcados de vermelho\n ";
}
else
{
Pessoa objPessoa = new Pessoa
{
Bairro = txtBairro.Text.ToUpper(),
Complemento = txtComplemento.Text.ToUpper(),
//Metodo Valida_CPF localizado na library Carona_Metodos_Teste na
classe Pessoa_Metodos
Cpf = txtCPF.Text,
//Metodo Valida_Data localizado na library Carona_Metodos_Teste na
DataNascimento = Convert.ToDateTime(txtDtNascimento.Text),
Email = txtEmail.Text,
Foto = "",
Fumante = rbtFumante.SelectedItem.Value.ToString(),
IdCidade = int.Parse(ddlCidade.SelectedValue),
//Metodo mede_matricula localizado na library Carona_Metodos_Teste na
//Metodo Confere_Inicio_Matricula_Igual_0 localizado na library
Carona_Metodos_Teste na classe Pessoa_Metodos
Matricula = txtMatricula.Text.ToUpper(),
Nome = txtNome.Text.ToUpper(),
Numero = txtNumero.Text.ToUpper(),
Rg = txtRG.Text.ToUpper(),
Rua = txtRua.Text.ToUpper(),
Senha = txtSenha.Text.ToUpper(),
Sexo = ddlSexo.SelectedValue.ToString(),
TelCel = mskTelefoneCelular.Text.ToUpper(),
TelCom = mskTelefoneComercial.Text.ToUpper(),
TelFixo = mskTelefoneResidencial.Text.ToUpper(),
PotadorPessoa = rbtPortador.SelectedValue.ToString()
};
Pessoa_BLL pessoa = new Pessoa_BLL();
objPessoa.IdPessoa = pessoa.Insere_Pessoa(objPessoa);
string Messagem = @"Cadastrado com Sucesso!!!";
Session["id"] = objPessoa.IdPessoa; ;
45
Response.Redirect("~/Home.aspx");
}
}
protected void ddlUFCaroneiro_SelectedIndexChanged1(object sender, EventArgs e)
{
try
{
SqlDataReader dr;
objCidade_ENT.Estado = ddlUF.SelectedValue.ToString();
if (dr.HasRows)
{
while (dr.Read())
{
Lista.Add(estado);
}
ddlCidade.DataTextField = "NomeCidade";
ddlCidade.DataValueField = "IdCidade";
ddlCidade.DataSource = Lista;
ddlCidade.DataBind();
}
}
}
}
catch (Exception)
{
throw;
}
Cadastrar Rota
46
Figura 11 - Tela inicial de cadastrar Rota
47
Figura 12 - Tela de cadastro de Rota para oferecedor
48
Figura 13 - Tela de cadastro de Rota para caroneiro
using
using
using
using
using
using
using
using
using
using
using
using
System;
System.Linq;
System.Web;
System.Web.UI;
Carona_BLL;
Carona_DAL;
Carona_ENT;
System.Data;
{
public partial class CadastrarRota : System.Web.UI.Page
{
static int id_Pessoa;
static string tipo, tipo_Rota;
49

{
if (Session["id"] == null)
{
string Messagem = @" Voce tem que ser Cadastrado para usar esta
Funcao!!!";
ScriptManager.RegisterStartupScript(Page, this.GetType(), alert",
pnlOpcaoRota.Visible = false;
Response.AddHeader("REFRESH",
"2;URL=http://localhost:3272/Views/Registers/CadastrarPessoa.aspx");
// Response.Redirect("~/Views/Registers/CadastrarPessoa.aspx");
}
else
{
id_Pessoa = int.Parse(Session["id"].ToString());
}
}
protected void ddlUFinicial_SelectedIndexChanged(object sender, EventArgs e)
{
try
{
SqlDataReader dr;
objCidade_ENT.Estado = ddlUFinicial.SelectedValue.ToString();
if (dr.HasRows)
{
while (dr.Read())
{
Lista.Add(estado);
}
ddlCidadeInicial.DataTextField = "NomeCidade";
ddlCidadeInicial.DataValueField = "IdCidade";
ddlCidadeInicial.DataSource = Lista;
ddlCidadeInicial.DataBind();
}
}
catch (Exception)
{
throw;
}
}
protected void ddlUFFinal_SelectedIndexChanged(object sender, EventArgs e)
{
try
{
SqlDataReader dr;
objCidade_ENT.Estado = ddlUFFinal.SelectedValue.ToString();
50
if (dr.HasRows)
{
while (dr.Read())
{
Lista.Add(estado);
}
ddlCidadeFinal.DataTextField = "NomeCidade";
ddlCidadeFinal.DataValueField = "IdCidade";
ddlCidadeFinal.DataSource = Lista;
ddlCidadeFinal.DataBind();
}
}
catch (Exception)
{
throw;
}
protected void rbtOpcaoRota_SelectedIndexChanged(object sender, EventArgs e)

{
if (rbtOpcaoRota.SelectedValue == "Oferecendo")
{
pnlDadosdaRota.Visible = true;
pnlDadosdoVeiculo.Visible = true;
}
else
if (rbtOpcaoRota.SelectedValue == "Procurando")
{
}
tipo_Rota = rbtOpcaoRota.SelectedValue;
}
protected void btnCadastrarRota_Click(object sender, EventArgs e)
{
bool valida = true;
Rota_Metodos Rota = new Rota_Metodos();
if ((Rota.Valida_Data(txtDataSaida.Text))==false)
{
valida = false;
txtDataSaida.Text = "";
txtDataSaida.BorderColor = System.Drawing.Color.Red;
}
if ((Rota.Valida_Data(txtDataChegada.Text)) == false)
{
valida = false;
txtDataChegada.Text = "";
txtDataChegada.BorderColor = System.Drawing.Color.Red;
}
if ((Rota.Valida_Hora(txtHoraSaida.Text) == false))
{
valida = false;
txtHoraSaida.Text = "";
51
txtHoraSaida.BorderColor = System.Drawing.Color.Red;
}
if ((Rota.Valida_Hora(txtHoraChegada.Text) == false))
{
valida = false;
txtHoraChegada.Text = "";
txtHoraChegada.BorderColor = System.Drawing.Color.Red;
}
if (Rota.Valida_HoraComData(DateTime.Parse(txtDataSaida.Text + " " +
txtHoraSaida.Text), DateTime.Parse(txtDataChegada.Text + " " +
txtHoraChegada.Text)) == false)
{
valida = false;
}
if (valida==false)
{
string Messagem = @" Por favor, verifique os dados preenchidos nos
campos marcados de vermelho\n ";
}
else
{
Rota objRota = new Rota
{
IdPessoa = id_Pessoa,
IdCidadeInicial = int.Parse(ddlCidadeInicial.SelectedValue),
IdCidadeFinal = int.Parse(ddlCidadeFinal.SelectedValue),
//Metodo que valida se a hora da carona maior ou igual que a do dia
cadastrada localizado na library Carona_Metodos_Teste na classe
Rota_Metodos
HoraSaida = DateTime.Parse(txtHoraSaida.Text),
HoraChegada = DateTime.Parse(txtHoraChegada.Text),
//Metodo que valida se a data da carona maior ou igual que a do dia
Rota_Metodos
//Metodo que valida se a data de saida da carona menor que a data de
chegada localizado na library Carona_Metodos_Teste na classe
Rota_Metodos
DataSaida = DateTime.Parse(txtDataSaida.Text),
DataGhegada = DateTime.Parse(txtDataChegada.Text),
TipoViagem = ddlTipoViagem.SelectedValue,
BairroSaida = txtBairroSaida.Text,
BairroChegada = txtBairroChegada.Text,
TipoRota = tipo_Rota
};
if (tipo_Rota == "Oferecendo")
{
if ((Rota.Quant_por_Veiculo(ddlTipoVeiculo.SelectedValue,
int.Parse(txtVagas.Text))) == false)
{
valida = false;
52
txtVagas.Text = "";
ddlTipoVeiculo.BorderColor = System.Drawing.Color.Red;
txtVagas.BorderColor = System.Drawing.Color.Red;
}
if (valida==false)
{
}
else
{
Veiculo objVeiculo = new Veiculo
{
CombustivelVeiculo = ddlCombustivel.SelectedValue,
//Metodo que verifica a quantidade maxima e minima de vagas
de carona por veiculo localizado na library
Carona_Metodos_Teste na classe Rota_Metodos
DescricaoVeiculo = ddlTipoVeiculo.SelectedValue +"-"+
txtDescricaoCarro.Text,
KmPorLitroVeiculo = int.Parse(nrbQuilometroLitro.Text),
QntLugarVeiculo = int.Parse(txtVagas.Text),
PlacaVeiculo = txtPlaca.Text,
PrecoSugeridoVeiculo = float.Parse(txtPreco.Value)
};
Veiculo_BLL veiculo = new Veiculo_BLL();
objVeiculo.IdVeiculo = veiculo.Insere_Veiculo(objVeiculo);
}
}
if (valida == true)
{
Rota_BLL rota = new Rota_BLL();
objRota.IdRota = rota.Insere_Rota(objRota);
}
}
}
Consultar e Alterar meu Perfil
53
Figura 14 - Tela de consulta do Perfil do usuario logado
using
using
using
using
using
using
using
using
using
using
using
using
System;
System.Linq;
System.Web;
System.Web.UI;
Carona_BLL;
Carona_DAL;
Carona_ENT;
System.Data;
{
public partial class CadastrarRota : System.Web.UI.Page
{
static int id_Pessoa;
{
{
54
string Messagem = @" Voce tem que ser Cadastrado para usar esta Funcao!!!";
}
else
{
}
}
{
try
{
SqlDataReader dr;
if (dr.HasRows)
{
while (dr.Read())
{
Lista.Add(estado);
}
}
}
catch (Exception)
{
throw;
}
}
{
try
{
SqlDataReader dr;
if (dr.HasRows)
{
55
while (dr.Read())
{
Lista.Add(estado);
}
}
}
catch (Exception)
{
throw;
}
protected void rbtOpcaoRota_SelectedIndexChanged(object sender, EventArgs e)

{
if (rbtOpcaoRota.SelectedValue == "Oferecendo")
{
pnlDadosdoVeiculo.Visible = true;
}
else
if (rbtOpcaoRota.SelectedValue == "Procurando")
{
}
tipo_Rota = rbtOpcaoRota.SelectedValue;
}
protected void btnCadastrarRota_Click(object sender, EventArgs e)
{
bool valida = true;
{
valida = false;
}
{
valida = false;
}
{
valida = false;
}
{
56
valida = false;
}

valida = false;
}
if (valida==false)
{
string Messagem = @" Por favor, verifique os dados preenchidos nos campos
marcados de vermelho\n ";
}
else
{
{
Rota_Metodos
Rota_Metodos
Rota_Metodos
BairroSaida = txtBairroSaida.Text,
BairroChegada = txtBairroChegada.Text,
TipoRota = tipo_Rota
};
{
int.Parse(txtVagas.Text))) == false)
{
valida = false;
txtVagas.Text = "";
txtVagas.BorderColor = System.Drawing.Color.Red;
57
}
if (valida==false)
{
}
else
{
{
//Metodo que verifica a quantidade maxima e minima de vagas
de carona por veiculo localizado na library
DescricaoVeiculo = ddlTipoVeiculo.SelectedValue +"-"+
txtDescricaoCarro.Text,
KmPorLitroVeiculo = int.Parse(nrbQuilometroLitro.Text),
QntLugarVeiculo = int.Parse(txtVagas.Text),
PrecoSugeridoVeiculo = float.Parse(txtPreco.Value)
};
Veiculo_BLL veiculo = new Veiculo_BLL();
objVeiculo.IdVeiculo = veiculo.Insere_Veiculo(objVeiculo);
}
}
}
}
if (valida == true)
{
Rota_BLL rota = new Rota_BLL();
objRota.IdRota = rota.Insere_Rota(objRota);
}
Consulta minhas reservas
58
Figura 15 - Tela de consulta s reservas do usurio logado
59
Figura 16 - Tela em que aparecem os dados da reserva selecionada

using
using
using
using
using
using
using
using
using
using
using
System;
System.Linq;
System.Web;
System.Web.UI;
System.Data;
Carona_BLL;
Carona_DAL;
Carona_ENT;
namespace Sistema_de_Carona_TCC.Views.Searchs
{
public partial class ConsultaMinhasReservas : System.Web.UI.Page
{
static int id_Pessoa, id_Rota, id_Veiculo,id_Reserva,id_Pessoa_Rota;
static string tipo_Rota;
{
60
{
Funcao!!!";
pnlgridMinhasReservas.Visible = false;
}
else
{
}
}
protected void GridViewMinhasReservas_SelectedIndexChanged(object sender, EventArgs e)

{
id_Pessoa_Rota=int.Parse(GridViewMinhasReservas.DataKeys[GridViewMinhasRes
ervas.SelectedIndex].Values["id_Pessoa_Rota"].ToString());
id_Reserva=int.Parse(GridViewMinhasReservas.DataKeys[GridViewMinhasReserva
s.SelectedIndex].Values["id_Reserva"].ToString());
id_Rota=int.Parse(GridViewMinhasReservas.DataKeys[GridViewMinhasReservas.S
electedIndex].Values["id_Rota_Reserva"].ToString());
id_Veiculo=int.Parse(GridViewMinhasReservas.DataKeys[GridViewMinhasReservas
.SelectedIndex].Values["id_Veiculo"].ToString());
tipo_Rota=GridViewMinhasReservas.DataKeys[GridViewMinhasReservas.SelectedI
ndex].Values["tipo_Rota"].ToString();
try
{
Pessoa objPessoa_ENT = new Pessoa();
Veiculo_BLL objVeiculo_BLL = new Veiculo_BLL();
Veiculo objVeiculo_ENT = new Veiculo();
Reserva_BLL objReserva_BLL = new Reserva_BLL();
Reserva objReserva_ENT = new Reserva();
SqlDataReader dr, drV;
objReserva_ENT.IdPessoa = id_Pessoa;
objReserva_ENT.IdRota = id_Rota;
dr = objReserva_BLL.Seleciona_Reserva(objReserva_ENT);
if (dr.HasRows)
{
pnlgridMinhasReservas.Visible = false;
pnlDadosRota.Visible = true;
pnlRota.Visible = true;
pnlbotoes.Visible = true;
dr.Read();
txtNome.Text = dr["nome_Pessoa"].ToString();
txtEmail.Text = dr["email_Pessoa"].ToString();
txtCelular.Text = dr["telCel_Pessoa"].ToString();
txtCidade.Text = dr["nome_Cidade"].ToString();
txtUF.Text = dr["uf_Cidade"].ToString();
txtSexo.Text = dr["sexo_Pessoa"].ToString();
txtFumante.Text = dr["fumante_Pessoa"].ToString();
61
txtCidadeInicial.Text = dr["nome_CidadeOrigem"].ToString();
txtCidadeFinal.Text = dr["nome_CidadeDestino"].ToString();
txtBairroInicial.Text = dr["bairro_Saida_Rota"].ToString();
txtBairroFinal.Text = dr["bairro_Chegada_Rota"].ToString();
txtDataChegada.Text = String.Format("{0:dd/MM/yyyy}",
dr["data_Chegada_Rota"]);
txtDataSaida.Text = String.Format("{0:dd/MM/yyyy}",
dr["data_Saida_Rota"]);
txtHoraSaida.Text = String.Format("{0:hh:mm:ss}",
dr["hora_Saida_Rota"]);
txtHoraChegada.Text = String.Format("{0:hh:mm:ss}",
dr["hora_Chegada_Rota"]);
txtTipoViagem.Text = dr["frequencia_Viagem_Rota"].ToString();
{
objVeiculo_ENT.IdVeiculo = id_Veiculo;
drV = objVeiculo_BLL.ConsultaVeiculo(objVeiculo_ENT);
pnlVeiculo.Visible = true;
drV.Read();
txtDescricaoVeiculo.Text = drV["descricao_Veiculo"].ToString();
txtVagasDisponiveis.Text = drV["qntLugar_Veiculo"].ToString();
txtPreco.Text = drV["preco_Sugerido_Veiculo"].ToString();
}
}
catch (Exception)
{
throw;
}
}
protected void btnExcluirReserva_Click(object sender, EventArgs e)
{
Reserva_BLL objBLL = new Reserva_BLL();
objBLL.Deleta_Reserva(id_Reserva,id_Pessoa);
string Messagem = @"Reserva Excluida com Sucesso!!! ";
Response.AddHeader("REFRESH", "2;URL=http://localhost:3272/Home.aspx");
}
}
Consulta minha rota
62
Figura 17 - Tela de consultar as rotas do usurio logado
63
Figura 18 - Tela de dados da rota selecionada

using
using
using
using
using
using
using
using
using
using
using
using
System;
System.Linq;
System.Web;
System.Web.UI;
System.Data;
Carona_BLL;
Carona_DAL;
Carona_ENT;
{
public partial class ConsultaMinhasRotas : System.Web.UI.Page
{
static int id_Pessoa, id_Veiculo, id_Rota;
static string tipo, tipo_Rota, tipoVeiculo;
64

{
{
string Messagem = @" Voce tem que ser Cadastrado para usar esta Funcao!!!";
pnlDadosRota.Visible = false;
pnlbotoes.Visible = false;
//Response.Redirect("~/Views/Registers/CadastrarPessoa.aspx");
}
else
{
}
}
protected void GridViewMinhasRotas_SelectedIndexChanged(object sender, EventArgs e)
{
string tipo;
try
{
id_Rota =
int.Parse(GridViewMinhasRotas.DataKeys[GridViewMinhasRotas.SelectedInde
x].Values["id_Rota"].ToString());
id_Veiculo =
int.Parse(GridViewMinhasRotas.DataKeys[GridViewMinhasRotas.SelectedInde
x].Values["id_Veiculo"].ToString());
tipo_Rota=GridViewMinhasRotas.DataKeys[GridViewMinhasRotas.SelectedInd
ex].Values["tipo_Rota"].ToString();
Rota_BLL objRota_BLL = new Rota_BLL();
Rota objRota_ENT = new Rota();
objRota_ENT.IdPessoa = id_Pessoa;
objRota_ENT.IdRota = id_Rota;
dr = objRota_BLL.Seleciona_Rota(objRota_ENT);
if (dr.HasRows)
{
pnlgridMinhasRotas.Visible = false;
pnlbotoes.Visible = true;
dr.Read();
65
ddlTipoViagem.SelectedValue =
dr["frequencia_Viagem_Rota"].ToString();
ddlUFinicial.DataBind();
ddlUFinicial.SelectedValue = dr["uf_CidadeOrigem"].ToString();
ddlUFinicial_SelectedIndexChanged(null, null);
ddlCidadeInicial.SelectedValue = dr["id_CidadeOrigem"].ToString();
ddlUFFinal.DataBind();
ddlUFFinal.SelectedValue = dr["uf_CidadeDestino"].ToString();
ddlUFFinal_SelectedIndexChanged(null, null);
ddlCidadeFinal.SelectedValue = dr["id_CidadeDestino"].ToString();
{
drV.Read();
txtPlaca.Text = drV["placa_Veiculo"].ToString();
txtKmLitro.Text = drV["kmPorLitro_Veiculo"].ToString();
ddlCombustivel.SelectedValue =
drV["combustivel_Veiculo"].ToString();
tipoVeiculo = drV["descricao_Veiculo"].ToString();
int i = 0;
while (tipoVeiculo[i].ToString() != "-")
{
i++;
}
ddlTipoVeiculo.SelectedValue=tipoVeiculo.Substring(0, i);
txtDescricaoVeiculo.Text =
tipoVeiculo.Substring((i+1),tipoVeiculo.Length-(i+1));
}
catch (Exception)
{
throw;
}

{
try
{
66

SqlDataReader dr;
if (dr.HasRows)
{
while (dr.Read())
{
Lista.Add(estado);
}
}
}
catch (Exception)
{
throw;
}
}

{
try
{
SqlDataReader dr;
if (dr.HasRows)
{
while (dr.Read())
{
Lista.Add(estado);
}
}
}
catch (Exception)
{
throw;
}
}
67
protected void btnAlterarPessoa_Click(object sender, EventArgs e)

{
bool valida = true;
{
valida = false;
}
{
valida = false;
}
{
valida = false;
}
{
valida = false;
}
{
valida = false;
}
if (valida==false)
{
string Messagem = @" Por favor, verifique os dados preenchidos nos campos
marcados de vermelho\n ";
}
else
{
{
IdRota = id_Rota,
68

Rota_Metodos
Rota_Metodos
Rota_Metodos
BairroSaida = txtBairroInicial.Text,
BairroChegada = txtBairroFinal.Text,
TipoRota=tipo_Rota
};
{
int.Parse(txtVagasDisponiveis.Text))) == false)
{
valida = false;
txtVagasDisponiveis.Text = "";
txtVagasDisponiveis.BorderColor = System.Drawing.Color.Red;
}
if (valida==false)
{
string Messagem = @" Por favor, verifique os dados preenchidos
nos campos marcados de vermelho\n ";
ScriptManager.RegisterStartupScript(Page, this.GetType(),
"alert",
}
else
{
{
IdVeiculo = id_Veiculo,
//Metodo que verifica a quantidade maxima e minima de
vagas de carona por veiculo localizado na library
DescricaoVeiculo = ddlTipoVeiculo.SelectedValue + "-" +
txtDescricaoVeiculo.Text,
KmPorLitroVeiculo = int.Parse(txtKmLitro.Text),
QntLugarVeiculo = int.Parse(txtVagasDisponiveis.Text),
PrecoSugeridoVeiculo = float.Parse(txtPreco.Text)
};
Veiculo_BLL objVBLL = new Veiculo_BLL();
objVBLL.Altera_Veiculo(objVeiculo);
}
}
if (valida == true)
{
Rota_BLL objBLL = new Rota_BLL();
objBLL.Altera_Rota(objRota);
}
69
}
}
protected void btnExcluirPessoa_Click(object sender, EventArgs e)
{
{
IdRota = id_Rota,
IdPessoa = id_Pessoa
};
Rota_BLL objBLL = new Rota_BLL();
objBLL.Deleta_Rota(objRota);
{
{
IdVeiculo = id_Veiculo,
};
Veiculo_BLL objVBLL = new Veiculo_BLL();
objVBLL.Deleta_Veiculo(objVeiculo);
}
}
Consulta Pessoa
70
Figura 19 - Tela inicial de consultar perfil
Figura 20 - Tela de consulta de todos os usurios
71
Figura 21 - Tela de consulta por nomes
72
Figura 22 - Tela de consulta por cidades
73
Figura 23 - Tela de apresentao dos dados do perfil selecionado
using
using
using
using
using
using
using
using
using
using
using
System;
System.Linq;
System.Web;
System.Web.UI;
System.Data;
Carona_BLL;
Carona_DAL;
Carona_ENT ;
{
public partial class Consulta : System.Web.UI.Page
{
{
{
string Messagem = @" Voce tem que ser Cadastrado para usar
esta
Funcao!!!";
74
pnlOpcao.Visible = false;
}
protected void rbtOpcaoConsPessoa_SelectedIndexChanged(object sender, EventArgs e)
{
if (rbtOpcaoConsPessoa.SelectedValue == "1")
{
pnlGridConsulta.Visible = true;
}
else
{
pnlConsultaNome.Visible = true;
}
else
{
pnlConsultaCidade .Visible = true;
}
}
protected void btnConsultar_Click(object sender, EventArgs e)
{
PanelgridConsultaNome.Visible = true;
}
protected void GridViewConsultaNome_SelectedIndexChanged(object sender, EventArgs e)
{
int id;
id =
int.Parse(GridViewConsultaNome.DataKeys[GridViewConsultaNome.SelectedInde
x].Values["id_Pessoa"].ToString());
try
{
Pessoa_BLL objPessoa_BLL = new Pessoa_BLL();
SqlDataReader dr;
objPessoa_ENT.IdPessoa = id;
dr = objPessoa_BLL.Seleciona_Pessoa(objPessoa_ENT);
if (dr.HasRows)
{
PanelgridConsultaNome.Visible = false;
pnlConsultaPessoa.Visible = true;
pnlConsultaNome.Visible = false;
dr.Read();
75
mskDataNascimento.Text = String.Format("{0:dd/MM/yyyy}",
dr["dtNacs_Pessoa"]);
txtRua.Text = dr["rua_Pessoa"].ToString();
txtUf.Text = dr["uf_Cidade"].ToString();
txtComplemento.Text = dr["complemento_Pessoa"].ToString();
txtBairro.Text = dr["bairro_Pessoa"].ToString();
txtNumero.Text = dr["numero_Pessoa"].ToString();
mskTelefoneCelular.Text = dr["telCel_Pessoa"].ToString();
mskTelefoneResidencial.Text = dr["telCel_Pessoa"].ToString();
mskTelefoneComercial.Text = dr["telCom_Pessoa"].ToString();
rbtFumante.SelectedValue = dr["fumante_Pessoa"].ToString();
rbtPortador.SelectedValue = dr["portador_Pessoa"].ToString();
//foto
}
}
catch (Exception)
{
throw;
}
protected void GridViewConsulta_SelectedIndexChanged(object sender, EventArgs e)

{
int id;
id =
int.Parse(GridViewConsulta.DataKeys[GridViewConsulta.SelectedIndex].Values["id
_Pessoa"].ToString());
try
{
SqlDataReader dr;
if (dr.HasRows)
{
pnlConsultaNome.Visible = false;
pnlGridConsulta.Visible = false;
dr.Read();
76
//foto
}
}
catch (Exception)
{
throw;
}
}
protected void btnConsultarCidade_Click(object sender, EventArgs e)
{
PanelgridConsultaCidade.Visible = true;
}
protected void GridViewConsultaCidade_SelectedIndexChanged(object sender, EventArgs e)
{
int id;
id =
int.Parse(GridViewConsultaCidade.DataKeys[GridViewConsultaCidade.SelectedIndex].
Values["id_Pessoa"].ToString());
try
{
SqlDataReader dr;
if (dr.HasRows)
{
pnlConsultaCidade.Visible = false;
PanelgridConsultaCidade .Visible = false;
dr.Read();
77
//foto
}
}
}
}
catch (Exception)
{
throw;
}
Consulta Rota e Cadastrar Reserva
Figura 24 - Tela de consulta de rotas
78
Figura 25 - Tela de consulta de todas as rotas
Figura 26 - Tela de consultar rotas por cidades
79
Figura 27 - Tela de apresentao dos dados da rota selecionada
using
using
using
using
using
using
using
using
using
using
using
System;
System.Linq;
System.Web;
System.Web.UI;
System.Data;
Carona_BLL;
Carona_DAL;
Carona_ENT;
{
public partial class ConsultaRotas : System.Web.UI.Page
{
static int id_Pessoa, id_Veiculo, id_Rota;
80
{
{
Funcao!!!";
}
else
{
}
}
protected void rbtOpcaoConsRota_SelectedIndexChanged(object sender, EventArgs e)
{
if (rbtOpcaoConsRota.SelectedValue == "1")
{
pnlConsultaNomeCidade.Visible = false;
pnlgridConsultaTodasRotas.Visible = true;
}
else
if (rbtOpcaoConsRota.SelectedValue == "2")
{
pnlConsultaNomeCidade.Visible = true;
}
protected void GridViewTodasRotas_SelectedIndexChanged(object sender, EventArgs e)

{
id_Pessoa =
int.Parse(GridViewTodasRotas.DataKeys[GridViewTodasRotas.SelectedIndex].Val
ues["id_Pessoa_Rota"].ToString());
id_Rota =
int.Parse(GridViewTodasRotas.DataKeys[GridViewTodasRotas.SelectedIndex].Valu
es["id_Rota"].ToString());
id_Veiculo =
int.Parse(GridViewTodasRotas.DataKeys[GridViewTodasRotas.SelectedIndex].Valu
es["id_Veiculo"].ToString());
tipo_Rota =
GridViewTodasRotas.DataKeys[GridViewTodasRotas.SelectedIndex].Values["tipo_R
ota"].ToString();
try
{
81

if (dr.HasRows)
{
pnlBotao.Visible = true;
pnlgridConsultaRotaPorCidade.Visible = false;
pnlgridConsultaTodasRotas.Visible = false;
dr.Read();
{
drV.Read();
}
}
catch (Exception)
{
throw;
}
82
protected void btnReserva_Click(object sender, EventArgs e)

{
Reserva objReserva = new Reserva

{
IdRota = id_Rota
};
Reserva_BLL reserva = new Reserva_BLL();
SqlDataReader dr;
dr = reserva.RetornaID_Reserva(id_Pessoa, id_Rota);
if (dr.HasRows)
{
string Messagem = @" Voc ja se cadastrou nesta RESERVA !!!";
}
else
{
objReserva.IdReserva = reserva.Insere_Reserva(objReserva);
string Messagem = @" Reserva cadastrada com Sucesso !!!";
}
}
protected void GridViewRotaporCidade_SelectedIndexChanged(object sender, EventArgs e)
{
}
protected void btnConsultar_Click(object sender, EventArgs e)
{
pnlgridConsultaRotaPorCidade.Visible = true;
}
protected void GridViewRotaporCidade_SelectedIndexChanged1(object sender, EventArgs e)
{
id_Pessoa =
int.Parse(GridViewRotaporCidade.DataKeys[GridViewRotaporCidade.SelectedInd
ex].Values["id_Pessoa_Rota"].ToString());
id_Rota =
int.Parse(GridViewRotaporCidade.DataKeys[GridViewRotaporCidade.SelectedInde
x].Values["id_Rota"].ToString());
id_Veiculo =
int.Parse(GridViewRotaporCidade.DataKeys[GridViewRotaporCidade.SelectedInde
x].Values["id_Veiculo"].ToString());
tipo_Rota =
GridViewRotaporCidade.DataKeys[GridViewRotaporCidade.SelectedIndex].Values[
"tipo_Rota"].ToString();
try
{
83

if (dr.HasRows)
{
pnlBotao.Visible = true;
pnlgridConsultaRotaPorCidade.Visible = false;
pnlgridConsultaTodasRotas.Visible = false;
dr.Read();
{
drV.Read();
}
}
}
catch (Exception)
{
throw;
}
}
84
APNDICE B CDIGOS DAS CLASSES
Classe Cidade_BLL
using System;
using System.Collections.Generic;
85
using System.Linq;
using System.Text;
using Carona_DAL;
using Carona_ENT;
using System.Data;
using System.Data.SqlClient;
namespace Carona_BLL
{
public class Cidade_BLL
{
//MTODO QUE TRAZ TODAS AS CIDADES DE UM RESPECTIVO ESTADO, CHAMANDO O
MTODO DA CAMADA Cidade_DAL
public SqlDataReader Consulta_Cidade(Cidade objCidade)
{
try
{
Cidade_DAL objDAL = new Cidade_DAL();
return objDAL.Consulta_Cidade(objCidade);
}
catch (Exception)
{
throw;
}
}
}
}
Classe Pessoa_BLL
using
using
using
using
using
using
using
using
System;
System.Linq;
System.Text;
Carona_DAL;
Carona_ENT;
System.Data;
{
public class Pessoa_BLL
{
//MTODO QUE INSERE UMA PESSOA NA TABELA tab_Pessoa CHAMANDO UM MTODO
DA CAMADA Pessoa_DAL
public int Insere_Pessoa(Pessoa objPessoa)
{
try
{
Pessoa_DAL obj_DAL = new Pessoa_DAL();
int id = obj_DAL.Insere_Pessoa(objPessoa);
return id;
}
catch (Exception)
{
throw;
}
}
86
//MTODO QUE SELECIONA OS DADOS DE UMA PESSOA DA TABELA tab_Pessoa

CHAMANDO UM MTODO DA CAMADA Pessoa_DAL
public SqlDataReader Seleciona_Pessoa(Pessoa objPessoa)
{
try
{
Pessoa_DAL objDAL = new Pessoa_DAL();
return objDAL.Seleciona_Pessoa(objPessoa);
}
catch (Exception)
{
throw;
}
}
//MTODO QUE ALTERA UMA PESSOA NA TABELA tab_Pessoa CHAMANDO UM MTODO
DA CAMADA Pessoa_DAL
public void Altera_Perfil(Pessoa objPessoa)
{
try
{
objDAL.Altera_Perfil(objPessoa);
}
catch (Exception)
{
throw;
}
}
//MTODO QUE DELETA UMA PESSOA NA TABELA tab_Pessoa CHAMANDO UM

MTODO DA CAMADA Pessoa_DAL
public void Deleta_Pessoa(Pessoa objPessoa)
{
try
{
objDAL.Deleta_Pessoa(objPessoa);
}
catch (Exception)
{
throw;
}
}
Classe Reserva_BLL
using System;
using System.Collections.Generic;
using System.Linq;
87
using
using
using
using
using
System.Text;
Carona_DAL;
Carona_ENT;
System.Data;
{
public class Reserva_BLL
{
//MTODO QUE INSERE UMA RESERVA NA TABELA tab_Reserva CHAMANDO UM
MTODO DA CAMADA Reserva_DAL
public int Insere_Reserva(Reserva objReserva)
{
try
{
Reserva_DAL obj_DAL = new Reserva_DAL();
return obj_DAL.Insere_Reserva(objReserva);
}
catch (Exception)
{
throw;
}
}
//MTODO QUE RETORNA O ID DAS RESERVAS PARA NO DEIXAR A PESSOA
RESERVAR UMA VIAGEM MAIS DE UMA VEZ, CHAMANDO UM MTODO DA CAMADA
Reserva_DAL
public SqlDataReader RetornaID_Reserva(int id_Pessoa, int id_Rota)
{
try
{
return obj_DAL.RetornaID_Reserva(id_Pessoa, id_Rota);
}
catch (Exception)
{
throw;
}
}
//MTODO QUE DELETA UMA RESERVA NA TABELA tab_Reserva CHAMANDO UM
MTODO DA CAMADA Reserva_DAL
public void Deleta_Reserva(int id_Reserva, int id_Pessoa)
{
try
{
obj_DAL.Deleta_Reserva(id_Reserva, id_Pessoa);
}
catch (Exception)
{
throw;
}
}
//MTODO QUE SELECIONA OS DADOS DE UMA RESERVA DA TABELA tab_Reserva
CHAMANDO UM MTODO DA CAMADA Reserva_DAL
public SqlDataReader Seleciona_Reserva(Reserva objReserva)
{
try
{
88
}
}
return obj_DAL.Seleciona_Reserva(objReserva);
}
catch (Exception)
{
throw;
}
Classe Rota_BLL
using
using
using
using
using
using
using
using
System;
System.Linq;
System.Text;
Carona_DAL;
Carona_ENT;
System.Data;
{
public class Rota_BLL
{
//MTODO QUE INSERE UMA ROTA NA TABELA tab_Rota CHAMANDO UM MTODO DA
CAMADA Rota_DAL
public int Insere_Rota(Rota objRota)
{
try
{
Rota_DAL obj_DAL = new Rota_DAL();
int id = obj_DAL.Insere_Rota(objRota);
return id;
}
catch (Exception)
{
throw;
}
}
//MTODO QUE RETORNA OS DADOS DE UMA ROTA DA TABELA tab_Rota CHAMANDO
UM MTODO DA CAMADA Rota_DAL
public SqlDataReader Seleciona_Rota(Rota objRota)
{
try
{
Rota_DAL objDAL = new Rota_DAL();
return objDAL.Seleciona_Rota(objRota);
}
catch (Exception)
{
throw;
}
}
//MTODO QUE ALTERA UMA ROTA NA TABELA tab_Rota CHAMANDO UM MTODO DA
CAMADA Rota_DAL
public void Altera_Rota(Rota objRota)
89
try
{
objDAL.Altera_Rota(objRota);
}
catch (Exception)
{
throw;
}
//MTODO QUE DELETA UMA ROTA NA TABELA tab_Rota CHAMANDO UM MTODO DA

CAMADA Rota_DAL
public void Deleta_Rota(Rota objRota)
{
try
{
objDAL.Deleta_Rota(objRota);
}
catch (Exception)
{
throw;
}
}
Classe Veiculo_BLL
using
using
using
using
using
using
using
using
System;
System.Linq;
System.Text;
Carona_DAL;
Carona_ENT;
System.Data;
{
public class Veiculo_BLL
{
//MTODO QUE INSERE UM VEICULO NA TABELA tab_Veiculo CHAMANDO UM MTODO
DA CAMADA Veiculo_DAL
public int Insere_Veiculo(Veiculo objVeiculo)
{
try
{
Veiculo_DAL obj_DAL = new Veiculo_DAL();
int id = obj_DAL.Insere_Veiculo(objVeiculo);
return id;
}
catch (Exception)
{
throw;
}
}
90
//MTODO QUE RETORNA OS DADOS DE UM VEICULO DA TABELA tab_Veiculo

CHAMANDO UM MTODO DA CAMADA Veiculo_DAL
public SqlDataReader ConsultaVeiculo(Veiculo objVeiculo)
{
try
{
Veiculo_DAL objDAL = new Veiculo_DAL();
return objDAL.ConsultaVeiculo(objVeiculo);
}
catch (Exception)
{
throw;
}
}
//MTODO QUE ALTERA UM VEICULO NA TABELA tab_Veiculo CHAMANDO UM MTODO
public void Altera_Veiculo(Veiculo objVeiculo)
{
try
{
objDAL.Altera_Veiculo(objVeiculo);
}
catch (Exception)
{
throw;
}
}
//MTODO QUE DELETA UM VEICULO NA TABELA tab_Veiculo CHAMANDO UM MTODO
public void Deleta_Veiculo(Veiculo objVeiculo)
{
try
{
objDAL.Deleta_Veiculo(objVeiculo);
}
catch (Exception)
{
throw;
}
}
}
Classe Cidade_DAL
using
using
using
using
System;
System.Linq;
System.Text;
91
using Carona_ENT;
using System.Data;
using System.Data.SqlClient;
namespace Carona_DAL
{
public class Cidade_DAL
{
//MTODO QUE TRAZ TODAS AS CIDADES DE UM RESPECTIVO ESTADO
public SqlDataReader Consulta_Cidade(Cidade objCidade)
{
try
{
SqlConnection CON = new SqlConnection(conexao.GetConnectionString(""));

SqlCommand COMAN = new SqlCommand();
CON.Open();
COMAN.Connection = CON;
COMAN.CommandType = CommandType.StoredProcedure;
COMAN.CommandText = "[sp_Consulta_Cidade]";
COMAN.Parameters.AddWithValue("@estado", objCidade.Estado );
SqlDataReader dr = COMAN.ExecuteReader();
return dr;
}
}
}
catch (Exception)
{
throw;
}
Classe Pessoa_DAL
using
using
using
using
using
using
using
System;
System.Linq;
System.Text;
Carona_ENT;
System.Data;
{
public class Pessoa_DAL
{
//MTODO QUE INSERE UMA PESSOA NA TABELA tab_Pessoa UTILIZANDO UMA
STORED PROCEDURE
public int Insere_Pessoa(Pessoa objPessoa)
{
try
{
SqlConnection _conn = new SqlConnection(conexao.GetConnectionString(""));
SqlCommand _coman = new SqlCommand();
_conn.Open();
92
_coman.Connection = _conn;
_coman.CommandType = CommandType.StoredProcedure;
_coman.CommandText = "[sp_Insere_Pessoa]";
_coman.Parameters.AddWithValue("@portador_Pessoa", SqlDbType.VarChar).
Value = objPessoa.PotadorPessoa;
_coman.Parameters.AddWithValue("@matricula_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Matricula;
_coman.Parameters.AddWithValue("@senha_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Senha;
_coman.Parameters.AddWithValue("@nome_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Nome;
_coman.Parameters.AddWithValue("@dtNacs_Pessoa", SqlDbType.DateTime).
Value = objPessoa.DataNascimento;
_coman.Parameters.AddWithValue("@rua_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Rua;
_coman.Parameters.AddWithValue("@id_Cidade_Pessoa", SqlDbType.Int).
Value = objPessoa.IdCidade;
_coman.Parameters.AddWithValue("@complemento_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Complemento;
_coman.Parameters.AddWithValue("@bairro_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Bairro;
_coman.Parameters.AddWithValue("@numero_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Numero;
_coman.Parameters.AddWithValue("@telCel_Pessoa", SqlDbType.VarChar).
Value = objPessoa.TelCel;
_coman.Parameters.AddWithValue("@telFixo_Pessoa", SqlDbType.VarChar).
Value = objPessoa.TelFixo;
_coman.Parameters.AddWithValue("@telCom_Pessoa", SqlDbType.VarChar).
Value = objPessoa.TelCom;
_coman.Parameters.AddWithValue("@fumante_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Fumante;
_coman.Parameters.AddWithValue("@cpf_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Cpf;
_coman.Parameters.AddWithValue("@rg_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Rg;
_coman.Parameters.AddWithValue("@email_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Email;
_coman.Parameters.AddWithValue("@sexo_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Sexo;
_coman.Parameters.AddWithValue("@foto_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Foto;
SqlParameter retorna = _coman.Parameters.
AddWithValue("@id_Pessoa", SqlDbType.Int);
retorna.Direction = ParameterDirection.Output;
_coman.ExecuteNonQuery();
return Convert.ToInt32(retorna.Value);
}
catch (Exception)
{
throw;
}
}
//MTODO QUE SELECIONA TODOS OS DADOS DE UMA PESSOA DA TABELA
tab_Pessoa UTILIZANDO UMA STORED PROCEDURE
public SqlDataReader Seleciona_Pessoa(Pessoa objPessoa)
{
try
{
conn.Open();
93
coman.CommandText = "[sp_Seleciona_Dados_Pessoa]";
coman.Parameters.AddWithValue("@id_Pessoa", SqlDbType.Int).
Value = objPessoa.IdPessoa;
return dr;
}
catch (Exception)
{
throw;
}
}
//MTODO QUE ALTERA UMA PESSOA NA TABELA tab_Pessoa UTILIZANDO UMA

STORED PROCEDURE
public void Altera_Perfil(Pessoa objPessoa)
{
try
{
_conn.Open();
_coman.CommandText = "[sp_Altera_Pessoa]";
_coman.Parameters.AddWithValue("@id_Pessoa", SqlDbType.VarChar).
_coman.Parameters.AddWithValue("@portador_Pessoa", SqlDbType.VarChar).
Value = objPessoa.PotadorPessoa;
_coman.Parameters.AddWithValue("@matricula_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Matricula;
_coman.Parameters.AddWithValue("@senha_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Senha;
_coman.Parameters.AddWithValue("@nome_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Nome;
_coman.Parameters.AddWithValue("@dtNacs_Pessoa", SqlDbType.DateTime).
Value = objPessoa.DataNascimento;
_coman.Parameters.AddWithValue("@rua_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Rua;
_coman.Parameters.AddWithValue("@id_Cidade_Pessoa", SqlDbType.Int).
Value = objPessoa.IdCidade;
_coman.Parameters.AddWithValue("@complemento_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Complemento;
_coman.Parameters.AddWithValue("@bairro_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Bairro;
_coman.Parameters.AddWithValue("@numero_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Numero;
_coman.Parameters.AddWithValue("@telCel_Pessoa", SqlDbType.VarChar).
Value = objPessoa.TelCel;
_coman.Parameters.AddWithValue("@telFixo_Pessoa", SqlDbType.VarChar).
Value = objPessoa.TelFixo;
_coman.Parameters.AddWithValue("@telCom_Pessoa", SqlDbType.VarChar).
Value = objPessoa.TelCom;
_coman.Parameters.AddWithValue("@fumante_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Fumante;
_coman.Parameters.AddWithValue("@cpf_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Cpf;
_coman.Parameters.AddWithValue("@rg_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Rg;
_coman.Parameters.AddWithValue("@email_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Email;
_coman.Parameters.AddWithValue("@sexo_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Sexo;
94
_coman.Parameters.AddWithValue("@foto_Pessoa", SqlDbType.VarChar).
Value = objPessoa.Foto;
}
catch (Exception)
{
throw;
}
}
//MTODO QUE DELETA UMA PESSOA NA TABELA tab_Pessoa UTILIZANDO UMA

STORED PROCEDURE
public void Deleta_Pessoa(Pessoa objPessoa)
{
try
{
_conn.Open();
_coman.CommandText = "[sp_Deleta_Pessoa]";
_coman.Parameters.AddWithValue("@id_Pessoa", SqlDbType.Int).
}
catch (Exception)
{
throw;
}
}
Classe Rota_DAL
using
using
using
using
using
using
using
System;
System.Linq;
System.Text;
Carona_ENT;
System.Data;
{
public class Rota_DAL
{
//MTODO QUE INSERE UMA ROTA NA TABELA tab_Rota UTILIZANDO UMA STORED
PROCEDURE
public int Insere_Rota(Rota objRota)
{
try
{
_conn.Open();
95
_coman.CommandText = "[sp_Insere_Rota]";
_coman.Parameters.AddWithValue("@id_Pessoa_Rota", SqlDbType.Int).
Value = objRota.IdPessoa;
_coman.Parameters.AddWithValue("@id_CidadeOrigem_Rota", SqlDbType.Int).
Value = objRota.IdCidadeInicial;
_coman.Parameters.AddWithValue("@id_CidadeDestino_Rota",
SqlDbType.Int).Value = objRota.IdCidadeFinal;
_coman.Parameters.AddWithValue("@hora_Saida_Rota",
SqlDbType.DateTime).Value = objRota.HoraSaida;
_coman.Parameters.AddWithValue("@hora_Chegada_Rota",
SqlDbType.DateTime).Value = objRota.HoraChegada;
_coman.Parameters.AddWithValue("@data_Saida_Rota",
SqlDbType.DateTime).Value = objRota.DataSaida;
_coman.Parameters.AddWithValue("@data_Chegada_Rota",
SqlDbType.DateTime).Value = objRota.DataGhegada;
_coman.Parameters.AddWithValue("@frequencia_Viagem_Rota",
SqlDbType.VarChar).Value = objRota.TipoViagem;
_coman.Parameters.AddWithValue("@bairro_Saida_Rota",
SqlDbType.VarChar).Value = objRota.BairroSaida;
_coman.Parameters.AddWithValue("@bairro_Chegada_Rota",
SqlDbType.VarChar).Value = objRota.BairroChegada;
_coman.Parameters.AddWithValue("@tipo_Rota", SqlDbType.VarChar).
Value = objRota.TipoRota;
SqlParameter retorna = _coman.Parameters.AddWithValue("@id_Rota",
SqlDbType.Int);
}
catch (Exception)
{
throw;
}
}
//MTODO QUE RETORNA OS DADOS DE UMA CERTA ROTA UTILIZANDO UMA STORED
PROCEDURE
public SqlDataReader Seleciona_Rota(Rota objRota)
{
try
{
conn.Open();
coman.CommandText = "[sp_Seleciona_Dados_Rota]";
coman.Parameters.AddWithValue("@id_Rota", SqlDbType.Int).
Value = objRota.IdRota;
return dr;
}
catch (Exception)
{
throw;
}
}
96
//MTODO QUE ALTERA UMA CERTA ROTA NA tab_Rota UTILIZANDO UMA STORED
PROCEDURE
public void Altera_Rota(Rota objRota)
{
try
{
conn.Open();
coman.CommandText = "[sp_Altera_Rota]";
coman.Parameters.AddWithValue("@id_Pessoa_Rota", SqlDbType.Int).
coman.Parameters.AddWithValue("@id_CidadeOrigem_Rota",
SqlDbType.Int).Value = objRota.IdCidadeInicial;
coman.Parameters.AddWithValue("@id_CidadeDestino_Rota",
SqlDbType.Int).Value = objRota.IdCidadeFinal;
coman.Parameters.AddWithValue("@hora_Saida_Rota",
SqlDbType.DateTime).Value = objRota.HoraSaida;
coman.Parameters.AddWithValue("@hora_Chegada_Rota",
SqlDbType.DateTime).Value = objRota.HoraChegada;
coman.Parameters.AddWithValue("@data_Saida_Rota",
SqlDbType.DateTime).Value = objRota.DataSaida;
coman.Parameters.AddWithValue("@data_Chegada_Rota",
SqlDbType.DateTime).Value = objRota.DataGhegada;
coman.Parameters.AddWithValue("@frequencia_Viagem_Rota",
SqlDbType.VarChar).Value = objRota.TipoViagem;
coman.Parameters.AddWithValue("@bairro_Saida_Rota",
SqlDbType.VarChar).Value = objRota.BairroSaida;
coman.Parameters.AddWithValue("@bairro_Chegada_Rota",
SqlDbType.VarChar).Value = objRota.BairroChegada;
coman.Parameters.AddWithValue("@tipo_Rota", SqlDbType.VarChar).
Value = objRota.TipoRota;
coman.ExecuteNonQuery();
}
catch (Exception)
{
throw;
}
}
//MTODO QUE DELETA UMA CERTA ROTA DA TABELA tab_Rota UTILZANDO UMA
STORED PROCEDURE
public void Deleta_Rota(Rota objRota)
{
try
{
conn.Open();
coman.CommandText = "[sp_Deleta_Rota]";
coman.Parameters.AddWithValue("@id_Pessoa_Rota", SqlDbType.Int).
coman.ExecuteNonQuery();
}
97
}
}
catch (Exception)
{
throw;
}
Classe Veirculo_DAL
using
using
using
using
using
using
using
System;
System.Linq;
System.Text;
System.Data;
Carona_ENT;
{
public class Veiculo_DAL
{
//MTODO QUE INSERE UM VEICULO NA TABELA tab_Veiculo UTILIZANDO UMA STORED
PROCEDURE
public int Insere_Veiculo(Veiculo objVeiculo)
{
try
{
CON.Open();
COMAN.CommandText = "[sp_Insere_Veiculo]";
COMAN.Parameters.AddWithValue("@id_Pessoa_Veiculo",
SqlDbType.Int).Value = objVeiculo.IdPessoa;
COMAN.Parameters.AddWithValue("@descricao_Veiculo",
SqlDbType.VarChar).Value = objVeiculo.DescricaoVeiculo;
COMAN.Parameters.AddWithValue("@combustivel_Veiculo",
SqlDbType.VarChar ).Value = objVeiculo.CombustivelVeiculo;
COMAN.Parameters.AddWithValue("@placa_Veiculo", SqlDbType.VarChar ).
Value = objVeiculo.PlacaVeiculo;
COMAN.Parameters.AddWithValue("@kmPorLitro_Veiculo", SqlDbType.Int).
Value = objVeiculo.KmPorLitroVeiculo;
COMAN.Parameters.AddWithValue("@qntLugar_Veiculo", SqlDbType.Int).
Value = objVeiculo.QntLugarVeiculo;
COMAN.Parameters.AddWithValue("@preco_Sugerido_Veiculo",
SqlDbType.Float).Value = objVeiculo.PrecoSugeridoVeiculo;
SqlParameter retorna = COMAN.Parameters.AddWithValue("@id_Veiculo",
SqlDbType.Int);
COMAN .ExecuteNonQuery();
}
catch (Exception)
{
throw;
98
}
}
//MTODO QUE CONSULTA UM CERTO VEICULO DA tab_Veiculo UTILIZANDO UMA STORES
PROCEDURE
public SqlDataReader ConsultaVeiculo(Veiculo objVeiculo)
{
try
{
SqlConnection con = new SqlConnection(conexao.GetConnectionString(""));
con.Open();
coman.Connection = con;
coman.CommandText = "[sp_Consulta_Veiculo]";
coman.Parameters.AddWithValue("@id_Veiculo", SqlDbType.Int).
Value = objVeiculo.IdVeiculo;
return dr;
}
catch (Exception)
{
throw;
}
}
//MTODO QUE ALTERA UM CERTO VEICULO DA tab_Veiculo UTILIZANDO UMA STORES
PROCEDURE
public void Altera_Veiculo(Veiculo objVeiculo)
{
try
{
CON.Open();
COMAN.CommandText = "[sp_Altera_Veiculo]";
COMAN.Parameters.AddWithValue("@id_Veiculo", SqlDbType.Int).
COMAN.Parameters.AddWithValue("@id_Pessoa_Veiculo",
SqlDbType.Int).Value = objVeiculo.IdPessoa;
COMAN.Parameters.AddWithValue("@descricao_Veiculo",
SqlDbType.VarChar).Value = objVeiculo.DescricaoVeiculo;
COMAN.Parameters.AddWithValue("@combustivel_Veiculo",
SqlDbType.VarChar).Value = objVeiculo.CombustivelVeiculo;
COMAN.Parameters.AddWithValue("@placa_Veiculo",
SqlDbType.VarChar).Value = objVeiculo.PlacaVeiculo;
COMAN.Parameters.AddWithValue("@kmPorLitro_Veiculo", SqlDbType.Int).
Value = objVeiculo.KmPorLitroVeiculo;
COMAN.Parameters.AddWithValue("@qntLugar_Veiculo", SqlDbType.Int).
Value = objVeiculo.QntLugarVeiculo;
COMAN.Parameters.AddWithValue("@preco_Sugerido_Veiculo",
SqlDbType.Float).Value = objVeiculo.PrecoSugeridoVeiculo;
COMAN.ExecuteNonQuery();
}
catch (Exception)
{
throw;
}
}
99
//MTODO QUE DELETA UM CERTO VEICULO DA tab_Veiculo UTILIZANDO UMA STORES

PROCEDURE
public void Deleta_Veiculo(Veiculo objVeiculo)
{
try
{
CON.Open();
COMAN.CommandText = "[sp_Deleta_Veiculo]";
COMAN.Parameters.AddWithValue("@id_Veiculo", SqlDbType.Int).
COMAN.Parameters.AddWithValue("@id_Pessoa_Veiculo", SqlDbType.Int).
Value = objVeiculo.IdPessoa;
COMAN.ExecuteNonQuery();
}
catch (Exception)
{
throw;
}
}
}
Classe Reserva_DAL
using
using
using
using
using
using
using
System;
System.Linq;
System.Text;
Carona_ENT;
System.Data;
{
public class Reserva_DAL
{
//MTODO QUE INSERE UMA RESERVA NA TABELA tab_Reserva UTILIZANDO UMA
STORED PROCEDURE
public int Insere_Reserva(Reserva objReserva)
{
try
{
_conn.Open();
_coman.CommandText = "[sp_Insere_Reserva]";
_coman.Parameters.AddWithValue("@id_Pessoa_Reserva", SqlDbType.Int).
Value = objReserva.IdPessoa;
_coman.Parameters.AddWithValue("@id_Rota_Reserva", SqlDbType.Int).
Value = objReserva.IdRota;
100
SqlParameter retorna = _coman.Parameters.AddWithValue("@id_Reserva",

SqlDbType.Int);
}
catch (Exception)
{
throw;
}
//MTODO QUE DELETA UMA RESERVA NA TABELA tab_Reserva UTILIZANDO UMA

STORED PROCEDURE
public void Deleta_Reserva(int id_Reserva,int id_Pessoa)
{
try
{
_conn.Open();
_coman.CommandText = "[sp_Deleta_Reserva]";
Value = id_Pessoa;
_coman.Parameters.AddWithValue("@id_Reserva", SqlDbType.Int).
Value = id_Reserva;
}
catch (Exception)
{
throw;
}
}
//MTODO QUE RETORNA O ID DAS RESERVAS PARA NO DEIXAR A PESSOA
RESERVAR UMA VIAGEM MAIS DE UMA VEZ
public SqlDataReader RetornaID_Reserva(int id_Pessoa,int id_Rota)
{
try
{
_conn.Open();
_coman.CommandText = "[sp_RetornaID_Reserva]";
Value = id_Pessoa;
_coman.Parameters.AddWithValue("@id_Rota_Reserva", SqlDbType.Int).
Value = id_Rota;
return _coman.ExecuteReader();
}
catch (Exception)
{
throw;
}
}
//MTODO QUE OS DADOS DE UMA RESERVA
101
public SqlDataReader Seleciona_Reserva(Reserva objReserva)

{
try
{
conn.Open();
coman.CommandText = "[sp_Seleciona_Dados_Reserva]";
Value = objReserva.IdRota;
Value = objReserva.IdPessoa;
return dr;
}
catch (Exception)
{
throw;
}
Classe Pessoa_ENT
using
using
using
using
System;
System.Linq;
System.Text;
namespace Carona_ENT
{
public class Pessoa
{
private int _idPessoa;
public int IdPessoa
{
get { return _idPessoa; }
set { _idPessoa = value; }
}
private string _matricula;
public string Matricula
{
get { return _matricula; }
set { _matricula = value; }
}
private string _senha;
public string Senha
{
get { return _senha; }
set { _senha = value; }
}
102
private string _nome;

public string Nome
{
get { return _nome; }
set { _nome = value; }
}
private DateTime _dataNascimento;
public DateTime DataNascimento
{
get { return _dataNascimento; }
set { _dataNascimento = value; }
}
private string _rua;
public string Rua
{
get { return _rua; }
set { _rua = value; }
}
private int _idCidade;
public int IdCidade
{
get { return _idCidade; }
set { _idCidade = value; }
}
private string _complemento;
public string Complemento
{
get { return _complemento; }
set { _complemento = value; }
}
private string _bairro;
public string Bairro
{
get { return _bairro; }
set { _bairro = value; }
}
private string _numero;
public string Numero
{
get { return _numero; }
set { _numero = value; }
}
private string _telCel;
public string TelCel
{
get { return _telCel; }
set { _telCel = value; }
}
private string _telFixo;
public string TelFixo
{
get { return _telFixo; }
set { _telFixo = value; }
}
103
private string _telCom;

public string TelCom
{
get { return _telCom; }
set { _telCom = value; }
}
private string _fumante;
public string Fumante
{
get { return _fumante; }
set { _fumante = value; }
}
private string _cpf;
public string Cpf
{
get { return _cpf; }
set { _cpf = value; }
}
private string _rg;
public string Rg
{
get { return _rg; }
set { _rg = value; }
}
private string _email;
public string Email
{
get { return _email; }
set { _email = value; }
}
private string _sexo;
public string Sexo
{
get { return _sexo; }
set { _sexo = value; }
}
private string _foto;
public string Foto
{
get { return _foto; }
set { _foto = value; }
}
private string _potadorPessoa;
public string PotadorPessoa
{
get { return _potadorPessoa; }
set { _potadorPessoa = value; }
}
public Rota Rota
{
get { throw new System.NotImplementedException(); }
set { }
}
104
public Rota Rota1

{
set { }
}
public Reserva Reserva
{
set { }
}
public Veiculo Veiculo
{
set { }
}
}
Classe Rota_ENT
using
using
using
using
System;
System.Linq;
System.Text;
{
public class Rota
{
private int _idRota;
public int IdRota
{
get { return _idRota; }
set { _idRota = value; }
}
public int IdPessoa
{
}
private int _idCidadeInicial;
public int IdCidadeInicial
{
get { return _idCidadeInicial; }
set { _idCidadeInicial = value; }
}
private int _idCidadeFinal;
public int IdCidadeFinal
{
get { return _idCidadeFinal; }
set { _idCidadeFinal = value; }
}
105
private DateTime _horaSaida;

public DateTime HoraSaida
{
get { return _horaSaida; }
set { _horaSaida = value; }
}
private DateTime _horaChegada;
public DateTime HoraChegada
{
get { return _horaChegada; }
set { _horaChegada = value; }
}
private DateTime _dataSaida;
public DateTime DataSaida
{
get { return _dataSaida; }
set { _dataSaida = value; }
}
private DateTime _dataGhegada;
public DateTime DataGhegada
{
get { return _dataGhegada; }
set { _dataGhegada = value; }
}
private string _tipoViagem;
public string TipoViagem
{
get { return _tipoViagem; }
set { _tipoViagem = value; }
}
private string _tipoRota;
public string TipoRota
{
get { return _tipoRota; }
set { _tipoRota = value; }
}
private string _bairroSaida;
public string BairroSaida
{
get { return _bairroSaida; }
set { _bairroSaida = value; }
}
private string _bairroChegada;
public string BairroChegada
{
get { return _bairroChegada; }
set { _bairroChegada = value; }
}
106
public Cidade_Origem Cidade_Origem

{
set { }
}
public Cidade_Destino Cidade_Destino
{
set { }
}
}
Classe Veiculo_ENT
using
using
using
using
System;
System.Linq;
System.Text;
{
public class Veiculo
{
private int _idVeiculo;
public int IdVeiculo
{
get { return _idVeiculo; }
set { _idVeiculo = value; }
}
public int IdPessoa
{
}
private string _descricaoVeiculo;
public string DescricaoVeiculo
{
get { return _descricaoVeiculo; }
set { _descricaoVeiculo = value; }
}
private string _combustivelVeiculo;
public string CombustivelVeiculo
{
get { return _combustivelVeiculo; }
set { _combustivelVeiculo = value; }
}
private string _placaVeiculo;
public string PlacaVeiculo
{
get { return _placaVeiculo; }
set { _placaVeiculo = value; }
107
}
private int _kmPorLitroVeiculo;
public int KmPorLitroVeiculo
{
get { return _kmPorLitroVeiculo; }
set { _kmPorLitroVeiculo = value; }
}
private int _qntLugarVeiculo;
public int QntLugarVeiculo
{
get { return _qntLugarVeiculo; }
set { _qntLugarVeiculo = value; }
}
private float _precoSugeridoVeiculo;
public float PrecoSugeridoVeiculo
{
get { return _precoSugeridoVeiculo; }
set { _precoSugeridoVeiculo = value; }
}
}
Classe Reserva_ENT
using
using
using
using
System;
System.Linq;
System.Text;
{
public class Reserva
{
private int _idReserva;
public int IdReserva
{
get { return _idReserva; }
set { _idReserva = value; }
}
public int IdPessoa
{
}
private int _idRota;
}
}
public int IdRota

{
get { return _idRota; }
set { _idRota = value; }
}
108
Classe Cidade_ENT
using
using
using
using
System;
System.Linq;
System.Text;
{
public class Cidade
{
private string _nomeCidade;
public string NomeCidade
{
get { return _nomeCidade; }
set { _nomeCidade = value; }
}
private string _estado;
public string Estado
{
get { return _estado; }
set { _estado = value; }
}
private int _idCidade;
public int IdCidade
{
get { return _idCidade; }
set { _idCidade = value; }
}
public Rota Rota
{
set { }
}
public Rota Rota1
{
set { }
}
public Pessoa Pessoa
{
set { }
}
public Pessoa Pessoa1
{
set { }
}
}
109
Classe Cidade_Destino_ENT
using
using
using
using
System;
System.Linq;
System.Text;
{
public class Cidade_Destino
{
private int _id_CidDest;
public int Id_CidDest
{
get { return _id_CidDest; }
set { _id_CidDest = value; }
}
private string _nome_CidDest;
public string Nome_CidDest
{
get { return _nome_CidDest; }
set { _nome_CidDest = value; }
}
private string _estado_CidDest;
public string Estado_CidDest

{
get { return _estado_CidDest; }
set { _estado_CidDest = value; }
}
Classe Cidade_Origem_ENT
using
using
using
using
System;
System.Linq;
System.Text;
{
public class Cidade_Origem
{
private int _id_CidOrigem;
public int Id_CidOrigem
{
get { return _id_CidOrigem; }
set { _id_CidOrigem = value; }
}
private string _nome_CidOrigem;
110
public string Nome_CidOrigem

{
get { return _nome_CidOrigem; }
set { _nome_CidOrigem = value; }
}
private string _estado_CidOrigem;
public string Estado_CidOrigem

{
get { return _estado_CidOrigem; }
set { _estado_CidOrigem = value; }
}
Classe Util_ENT
using
using
using
using
using
System;
System.Linq;
System.Text;
System.Configuration;
{
public class Util
{
//METODO QUE RETORNA A CONNECTION STRING PARA A CONEXAO COM O BANCO DE
DADOS
public string GetConnectionString(string str)
{
string conn = string.Empty;
if (!string.IsNullOrEmpty(str))
{
conn = ConfigurationManager.ConnectionStrings[str].
ConnectionString;
}
else
{
conn = ConfigurationManager.ConnectionStrings["ConnectionString"].
ConnectionString;
}
return conn;
}
}
}
111
APNDICE C - DICIONRIO DE DADOS
Nome da Tabela: Tab_Cidade

Chave
Nome
Sim
id_Cidade
No
nome_Cidade
No
uf_Cidade
Relacionamento:
Tab_Cidade - 1 Tab_Pessoa
Tipo
int
varchar
varchar
Tamanho
80
5
Observaes:
Tabela 1 - Dicionrio de dados da Tabela Cidade.
Nome da Tabela: Tab_Pessoa
Descrio
Cdigo da cidade
Nome da cidade
Estado da cidade
112
Chave
Sim
No
No
No
No
No
No
No
No
Nome
Tipo
id_Pessoa
int
portador_Pessoa
varchar
matricula_Pessoa
varchar
senha_Pessoa
varchar
nome_Pessoa
varchar
dtNacs_Pessoa
datetime
rua_Pessoa
varchar
id_Cidade_Pessoa
Int
complemento_Pesso
varchar
a
No
bairro_Pessoa
varchar
No
numero_Pessoa
varchar
No
telCel_Pessoa
varchar
No
telFixo_Pessoa
varchar
No
telCom_Pessoa
varchar
No
fumante_Pessoa
varchar
No
cpf_Pessoa
varchar
No
rg_Pessoa
varchar
No
email_Pessoa
varchar
No
sexo_Pessoa
varchar
No
foto_Pessoa
varchar
Relacionamento:
Tab_Pessoa 1 - Tab_Cidade
Tab_Pessoa 1 - Tab_Veiculo
Tab_Pessoa 1 - Tab_Reserva
Tab_Pessoa 1 - Tab_Rota
Tamanho
20
Descrio
Cdigo da pessoa
Portador de alguma necessidade especial?
Matricula da pessoa
Senha da pessoa
Nome da pessoa
Data de nascimento da pessoa
Rua da pessoa
Chave estrangeira Cdigo da cidade
Informao complementar do endereo da pessoa
50
7
13
13
13
15
15
15
50
10
100
Bairro da pessoa
Rua da pessoa
Telefone celular da pessoa
Telefone fixo da pessoa
Telefone comercial da pessoa
Status de fumante da pessoa
CPF da pessoa
RG da pessoa
Email da pessoa
Sexo da pessoa
Foto da pessoa
50
9
8
50
50
Observaes:
- Se for portador de necessidade especial deve especificar qual .
- Informao complementar = apartamento, casa, etc.
Tabela 2 - Dicionrio de dados da Tabela Pessoa.
Nome da Tabela: Tab_Reserva

Chave
Nome
Tipo
Sim
id_Reserva
Int
No
id_Pessoa_Reserva
Int
No
id_Rota_Reserva
Int
Relacionamento:
Tab_Reserva - 1 Tab_Pessoa
Tab_Reserva - 1 Tab_Rota
Tamanho
Descrio
Cdigo da reserva
Chave estrangeira Cdigo da pessoa
Chave estrangeira Cdigo da rota
Observaes:
Tabela 3 - Dicionrio de dados da Tabela Reserva.

Nome da Tabela: Tab_Rota
Chave
Nome
Sim
id_Rota
No
id_Pessoa_Rota
Tipo
int
int
Tamanho
Descrio
Cdigo da rota
113
No
id_CidadeOrigem_Rota
No
id_CidadeDestino_Rota
No
hora_Saida_Rota
No
hora_Chegada_Rota
No
data_Saida_Rota
No
data_Chegada_Rota
No
frequencia_Viagem_Rota
No
bairro_Saida_Rota
No
bairro_Chegada_Rota
No
tipo_Rota
Relacionamento:
Tab_Rota - 1 Tab_Pessoa
Tab_Rota 1 - Tab_Reserva
int
int
datetime
datetime
datetime
datetime
varchar
varchar
varchar
varchar
30
50
50
50

Hora de sada da viagem
Hora de chegada da viagem
Data de sada da viagem
Data de chegada da viagem
Freqncia de viagem
Bairro de sada da viagem
Bairro de chegada da viagem
Tipo de viagem
Observaes:
Tabela 4 - Dicionrio de dados da Tabela Rota.

Nome da Tabela: tab_Veiculo
Chave
Nome
Tipo
Sim
id_Veiculo
int
No
id_Pessoa_Veiculo
int
No
descricao_Veiculo
Varchar
No
combustivel_Veiculo
varchar
No
placa_Veiculo
Varchar
No
kmPorLitro_Veiculo
int
No
qntLugar_Veiculo
int
No
preco_Sugerido_Veiculo float
Relacionamento:
Tab_Veiculo - 1 Tab_Pessoa
Observaes:
Tamanho
20
15
8
Descrio
Cdigo do veiculo
Descrio do veiculo
Tipo de combustvel do veiculo
Placa do veiculo
kilometragem rodada com 1 litro
Quantidade de lugares disponveis no veiculo
Valor sugerido pela viagem
Tabela 5 - Dicionrio de dados da Tabela Veiculo.
APENDICE D - DESCRIO DOS CASOS DE USO

Nome: Cadastra Pessoa
Atores Principais: Administrador, Internauta.
Pr-Condio: Estar logado como administrador ou como internauta.
Fluxo Principal
1. O usurio fornece os dados necessrios para o cadastramento;
Dados necessrios:
Nome;
Portador;
Matricula;
Senha;
Data de Nascimento;
Logradouro;
114
Estado;
Cidade;
Telefones;
Status de Fumante;
Cpf;
Rg;
E-mail;
Sexo;
Foto;
2. O sistema verifica os dados fornecidos pelo usurio e confirma o cadastro.
Fluxo Alternativo
2a. Os dados esto incorretos;
2a1. Retorna ao passo 1;
Tabela 1-Caso de Uso Cadastrar Pessoa
Nome: Altera Pessoa

Fluxo Principal
1. O usurio seleciona seu perfil;
2. O sistema retorna os dados;
3. O usurio seleciona a causa previsvel;
4. O usurio altera os dados;
5. O sistema processa as novas informaes;
Fluxo Alternativo
5a. Os dados invlidos;
Tabela 2-Caso de Uso Alterar Pessoa
Nome: Excluir Pessoa

Fluxo Principal
3. O usurio confirma a excluso;
4. O sistema solicita confirmao;
5. O sistema processa a excluso;
Fluxo Alternativo
Tabela 3 Caso de Uso Excluir Pessoa
Nome: Cadastra Rota
115

Fluxo Principal
Dados necessrios:
Estado de Origem;
Cidade de Origem;
Bairro de Origem;
Data de Sada;
Hora de Sada;
Estado de Destino;
Cidade de Destino;
Bairro de Destino;
Data de Destino;
Hora de Destino;
Tipo de Rota;
2. O sistema verifica os dados fornecidos pelo usurio e confirma o cadastro;
Fluxo Alternativo
Tabela 4-Caso de Uso Cadastrar Rota
Nome: Altera Rota

Fluxo Principal
1. O usurio visualiza todas as rotas;
2. O usurio seleciona a rota a ser alterada;
Fluxo Alternativo
Tabela 5-Caso de Uso Alterar Pessoa
116
Nome: Excluir Rota

Fluxo Principal
1. O usurio visualiza todas as rotas;
2. O usurio seleciona a rota a ser excluda;
Fluxo Alternativo
Tabela 6-Caso de Uso Excluir Pessoa
Nome: Cadastra Reserva
Fluxo Principal
Dados necessrios;
Rota;
2. O usurio seleciona o tipo de pesquisa;
3.O usurio fornece os dados da pesquisa;
4. O sistema retorna as rotas referentes aos dados da pesquisa;
5. O usurio seleciona a rota escolhida;
6. O sistema retorna os dados da rota selecionada;
7. O usurio cadastra a reserva;
8. O sistema processa os dados para o cadastramento da reserva;
Fluxo Alternativo
4a. O sistema no retorna nenhuma rota;
Tabela 7-Caso de Uso Cadastrar Reserva
Nome: Excluir Reserva
Fluxo Principal
1. O usurio visualiza todas as reservas;
2. O usurio seleciona a reserva a ser excluda;
Fluxo Alternativo
Tabela 8-Caso de Uso Excluir Reserva
117
Nome: Cadastra Cidade

Atores Principais: Administrador.
Pr-Condio: Estar logado como administrador.
Fluxo Principal
1. O administrador fornece os dados necessrios para o cadastramento;
Dados necessrios;
Estado;
Cidade;
2. O sistema verifica os dados fornecidos pelo administrador e confirma o
cadastro;
Fluxo Alternativo
Tabela 9-Caso de Uso Cadastrar Cidade
Nome: Altera Cidade

Fluxo Principal
1. O administrador informa o estado;
3. O administrador seleciona a causa previsvel;
4. O administrador altera os dados;
Fluxo Alternativo
2a. O sistema no retorna dados;
Tabela 10-Caso de Uso Alterar Cidade
Nome: Excluir Cidade
Fluxo Principal
1. O administrador informa o estado;
3. O administrador seleciona o dado a ser excludo;
Fluxo Alternativo
Tabela 11-Caso de Uso Excluir Cidade
118
Nome: Cadastra Veiculo

Fluxo Principal
Dados necessrios:
Descrio;
Combustvel;
Placa;
Quilmetros por Litro;
Quantidade de Lugares;
Preo Sugerido;
2.O sistema verifica os dados fornecidos pelo usurio e confirma o cadastro;
Fluxo Alternativo
Tabela 12-Caso de Uso Cadastrar Veiculo
Nome: Altera Veiculo

Fluxo Principal
1. O sistema retorna suas rotas;
2. O usurio seleciona a rota referente ao veiculo;
Fluxo Alternativo
Tabela 13-Caso de Uso Alterar Veiculo
119
Nome: Excluir Veiculo

Fluxo Principal
1. O sistema retorna suas rotas;
2. O usurio seleciona a rota referente ao veiculo;
Fluxo Alternativo
Tabela 14-Caso de Uso Excluir Veiculo
Nome: Consulta Perfil
Fluxo Principal
1. O usurio Seleciona o tipo de consulta;
2. O usurio informa os dados a serem pesquisados;
3. O sistema retorna os perfis ;
4. O usurio seleciona a perfil escolhido;
Fluxo Alternativo
3a1. Retorne ao passo 2;
Tabela 15-Caso de Uso Consulta Perfil
Nome: Consulta Rotas

Fluxo Principal
1. O usurio Seleciona o tipo de consulta;
2. O usurio informa os dados a serem pesquisados;
3. O sistema retorna as rotas;
4. O usurio seleciona a rota escolhida;
Fluxo Alternativo
3a1. Retorne ao passo 2;
Tabela 16-Caso de Uso Consulta Rotas
120
Nome:Consulta Contatos
Fluxo Principal
1. O usurio seleciona Contatos;
Fluxo Alternativo
Tabela 17-Caso de Uso Consulta Contatos
Nome:Consulta Help
Fluxo Principal
1. O usurio seleciona Help;
Fluxo Alternativo
Tabela 18-Caso de Uso Consulta Help
Nome:Consulta Home
Fluxo Principal
1. O usurio seleciona Home;
Fluxo Alternativo
Tabela 19-Caso de Uso Consulta Home
Nome:Sair
Fluxo Principal
1. O usurio seleciona Sair;
2. O sistema retorna para pagina de Login;
Fluxo Alternativo
Tabela 20-Caso de Uso Sair
Nome: Login
121
Pr-Condio: no precisa estar logado como administrador ou como internauta.

Fluxo Principal.
1. O usurio informa os dados necessrios;
2. O sistema inicia a sesso;
Fluxo Alternativo
2a. O sistema no inicia a sesso;
Tabela 21-Caso de Uso Login
Nome: Consulta Meu Perfil

Fluxo Principal
Fluxo Alternativo
Tabela 22-Caso de Uso Consulta Meu Perfil
APENDICE E - DIAGRAMA DE CASO DE USO
122
Figura 28 - Diagrama da Pessoa
Figura 29 - Diagrama da Reserva
123
Figura 30 - Diagrama da Rota
Figura 31 - Diagrama do Veiculo
124
APENDICE F - MODELO ER
Figura 32 - Modelo ER do banco de dados
125
APENDICE G - DIAGRAMA DE CLASSE E TABELAS
Figura 33 - Diagrama de Classe.
Figura 34 - Diagrama de Tabelas

Tarefa 4.2

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Tarefa 4.2

Încărcat de

Drepturi de autor:

Formate disponibile

0

UNIVERSIDADE JOS DO ROSRIO VELLANO

IDENTIFICANDO E CORRIGINDO FALHAS

GUILHERME FERNANDES GOMES

IDENTIFICANDO E CORRIGINDO FALHAS

Monografia apresentada Universidade Jos do

GUILHERME FERNANDES GOMES

IDENTIFICANDO E CORRIGINDO FALHAS DURANTE O

A banca examinadora abaixo-assinada aprova

Prof. Jos Claudio de Sousa Reis

Prof. Marcos Alberto de Carvalho

Figura 1 - Engenharia de Software em camadas (PRESSMAN, 2010, p.17)............12

Figura 32 - Modelo ER do banco de dados..............................................................124

Tabela 1 - Dicionrio de dados da Tabela Cidade.....................................................112

Com grande demanda, o mercado de software levanta algumas questes, a

1.1 Justificativa: origem e importncia do trabalho

Com grande demanda, o mercado de software levanta questes, sendo a

se o produto vendido confivel. Sendo assim, testes so

fundamentais para construir softwares de qualidade. Atualmente, umas das tcnicas

1.2 Caracterizao do problema em estudo

TDD baseado em um ciclo curto de repeties, no qual se escreve um

(ANGELON, 2006, p.13). Assim, alm de minimizar custos, os testes aumentam a

1.4 Organizao do trabalho

anlise prtica dos testes aplicados ser apresentada no Captulo 4. No Captulo 5

2.1 Engenharia de software

Figura 1 - Engenharia de Software em camadas (PRESSMAN, 2010, p.17)

O Processo tem por funo manter unidas as camadas de tecnologia, permitir

Os mtodos de Engenharia de Software fornecem a tcnica de como fazer

As ferramentas de Engenharia de Software fornecem apoio automatizado ou

2.2 Desenvolvimento gil

As definies modernas de desenvolvimento gil evoluram a partir da dcada

importantes benefcios, mas no so aplicveis a quaisquer projetos, produtos,

2.2.1 Extreme Programming (XP)

O modelo de processo XP como seu padro de desenvolvimento pr-definido

Figura 2 - O processo extreme progamming.(PRESSMAN, 2010, p64)

Tudo implementado imediatamente;

O Projeto XP um projeto simples e sempre o preferido em uma

O conceito-chave da codificao a programao em pares. O XP

real. medida em que os pares de programadores completam seu trabalho, estes

J foi mencionado que criar um teste unitrio primordial antes da

2.3 TDD (Test Driven Development)

Pode-se perder um pouco de um dos maiores benefcios de TDD, o feedback

Figura 3 - O processo TDD

2.4 Carona com tecnologia

Os seguintes mtodos foram utilizados para o desenvolvimento do sistema

Arquitetura em Camadas: sua utilizao permite abstrair toda a lgica de

diversas unidades de software chamadas de objetos;

unicamente na forma de tabelas;

Este trabalho foi desenvolvido em seis etapas:

Na primeira etapa foi desenvolvido um estudo sobre Engenharia de Software.

necessrias que permitissem a implementao do sistema proposto;

As seguintes tecnologias foram utilizadas para o desenvolvimento do sistema

ASP.NET: Plataforma da Microsoft para o desenvolvimento de aplicaes

C#: linguagem de programao orientada a objetos desenvolvida pela

programao, como Delphi e Java.

armazenamentos de dados locais.

Foi desenvolvido um sistema de carona voltado para os alunos da Unifenas,

4.1 Camada de Testes e Mtodos

Figura 4 - Exemplo de um teste falhando na rotina de testes criada

O teste Teste_Data falhou, porque a data de sada para viagem inserida

public bool Valida_Data(string _data)

int _ano = int.Parse(_data.Substring(6, 4));

Figura 5 - Exemplo de uma correo de erro