apostila - asp active server pages

ACTIVE SERVER

PAGES

Rua dos Otoni, 881/9º andar - Funcionários PABX/FAX : (31) 3273-2822

CEP 30150-270 - Belo Horizonte - MG

“ Todos direitos reservados. Proibida a reprodução, mesmo parcial, por qualquer processo mecânico, eletrônico, reprográfico, etc.”

Rua dos Otoni, 881 - 9º Andar Belo Horizonte - MG - 30150-270 www.zargon.com.br (31) 3273-2822

ACTIVE SERVER PAGES

S U M Á R I O

INTRODUÇÃO AO ASP ............................................................................................................................................................1

COMPARANDO O ASP COM OUTRAS TECNOLOGIAS ..................................................................................................2 TECNOLOGIAS INICIAIS ...............................................................................................................................................................2 TECNOLOGIAS ADICIONAIS PARA IIS ..........................................................................................................................................2

COMO FUNCIONA UMA PÁGINA ASP?...............................................................................................................................3

O AMBIENTE DE DESENVOLVIMENTO .............................................................................................................................4 PLATAFORMAS DE DESENVOLVIMENTO DO ASP .........................................................................................................................4

Microsoft Personal Web Server .............................................................................................................................................4 Microsoft Internet Information Server (IIS) ...........................................................................................................................5

TRABALHANDO COM O ASP.................................................................................................................................................8 CONHECENDO A ESTRUTURA DA PROGRAMAÇÃO ASP................................................................................................................8

OS OBJETOS DO ASP .............................................................................................................................................................11 OBJETO RESPONSE ....................................................................................................................................................................11 OBJETO REQUEST......................................................................................................................................................................12 OBJETO SERVER........................................................................................................................................................................12 OBJETO APPLICATION ...............................................................................................................................................................13 OBJETO SESSION .......................................................................................................................................................................13

A LINGUAGEM VBSCRIPT ...................................................................................................................................................15 A LINGUAGEM VBSCRIPT POSSIBILITARÁ, POR MEIO DO ASP, A CRIAÇÃO DA APLICAÇÃO VALIDANDO AS INFORMAÇÕES E ARMAZENANDO-AS NO BANCO DE DADOS. O ASP EXECUTARÁ AS SOLICITAÇÕES DO VBSCRIPT JUNTO COM SEUS OBJETOS E DEVOLVERÁ UMA RESPOSTA AO CLIENTE NO FORMATO HTML. ASSIM, O VBSCRIPT É EXECUTADO NO SERVIDOR. .................15 VARIÁVEIS E TIPOS DE DADOS..................................................................................................................................................15 OPERADORES ............................................................................................................................................................................16

Operadores aritméticos........................................................................................................................................................16 Operador de concatenação ..................................................................................................................................................17 Operadores relacionais........................................................................................................................................................17 Operadores lógicos ..............................................................................................................................................................17

PRINCIPAIS COMANDOS DO VBSCRIPT ......................................................................................................................................18 Comandos Condicionais ......................................................................................................................................................18 Comandos de repetição........................................................................................................................................................19

FUNÇÕES ...................................................................................................................................................................................19 Funções para verificação de tipo de variáveis ....................................................................................................................20 Funções para conversão de tipos.........................................................................................................................................20 Funções para manipulação de números: .............................................................................................................................21 Funções para manipulação de datas ...................................................................................................................................21 Funções para manipulação de strings .................................................................................................................................22

CÓDIGOS PARA TESTES DOS COMANDOS E FUNÇÕES VBSCRIPT ................................................................................................23 Estrutura condicional select case.........................................................................................................................................23 </BODY></HTML>............................................................................................................................................................24 Estrutura de repetição FOR.................................................................................................................................................24 Estrutura de repetição while ................................................................................................................................................24

AS ROTINAS...............................................................................................................................................................................26


ACTIVE SERVER PAGES

TESTANDO OS OBJETOS DO ASP.......................................................................................................................................28 TESTE DO OBJETO RESPONSE.....................................................................................................................................................28

Método Write........................................................................................................................................................................28 método end ...........................................................................................................................................................................28 método redirect ....................................................................................................................................................................28 Propriedade Buffer...............................................................................................................................................................30 Coleção Cookie ....................................................................................................................................................................30

TESTANDO O OBJETO SESSION ...................................................................................................................................................31 TESTE DO OBJETO REQUEST ......................................................................................................................................................33

Recuperando Cookies...........................................................................................................................................................33 Recuperando informações de formulários ...........................................................................................................................34 Recuperando informações da string de pesquisa da URL ...................................................................................................36 Ações do formulário em outro arquivo ................................................................................................................................39

TESTE DO OBJETO APPLICATION ................................................................................................................................................41 TESTANDO OBJETO SERVER ......................................................................................................................................................45

O método mappath ...............................................................................................................................................................45 O método createobject .........................................................................................................................................................46

CONHECENDO O SITE...........................................................................................................................................................51 O BANCO DE DADOS DO SITE .....................................................................................................................................................51 O MAPA DO SITE ........................................................................................................................................................................53

A DIRETIVA INCLUDE ..........................................................................................................................................................56

ACESSO AO BANCO DE DADOS..........................................................................................................................................59 CONHECENDO OS OBJETOS ADO ...............................................................................................................................................59 QUE TIPO DE PROVEDOR UTILIZAR ODBC OU OLE DB?...........................................................................................................60 PASSOS PARA ACESSAR O BANCO DE DADOS..............................................................................................................................60

A LINGUAGEM SQL ...............................................................................................................................................................64 O COMANDO SELECT.................................................................................................................................................................64

critérios de seleção para texto .............................................................................................................................................67 Critérios de seleção com valores .........................................................................................................................................71 Ordenando os Dados............................................................................................................................................................71 CALCULANDO VALORES ..................................................................................................................................................72 Agrupando valores ...............................................................................................................................................................74

O COMANDO INSERT...............................................................................................................................................................76 O COMANDO UPDATE ................................................................................................................................................................78 O COMANDO DELETE.................................................................................................................................................................78

CRIANDO A PÁGINA DE CADASTRO ................................................................................................................................79

CRIANDO A PÁGINA DE LOGIN .........................................................................................................................................92 O ARQUIVO LOGOUT.ASP ..........................................................................................................................................................95 O ARQUIVO DEFAULTON.ASP.....................................................................................................................................................95

CRIANDO A PÁGINA DE RESTRIÇÃO...............................................................................................................................96

CRIANDO A PÁGINA DE PESQUISA...................................................................................................................................97 BUSCANDO AS CATEGORIAS DO BANCO DE DADOS ....................................................................................................................98 CRIANDO A PESQUISA................................................................................................................................................................98


ACTIVE SERVER PAGES

CRIANDO PÁGINA DE COMPRA ......................................................................................................................................104 PREPARANDO O FORMULÁRIO PARA A GRAVAÇÃO DO PRODUTO COMPRADO...........................................................................105 INSERINDO O PRODUTO NO CARRINHO .....................................................................................................................................107

CRIANDO A PÁGINA DE PRODUTOS COMPRADOS ...................................................................................................110 EXCLUINDO ITENS DO CARRINHO ............................................................................................................................................112

CRIANDO A PÁGINA FINALIZA........................................................................................................................................116 ENVIANDO O E-MAIL DE CONFIRMAÇÃO ..................................................................................................................................121

CONCLUSÃO ..........................................................................................................................................................................123

Rua dos Otoni, 881 - 9º Andar Pág.: Belo Horizonte - MG - 30150-270 www.zargon.com.br (31) 3273-2822

1

ACTIVE SERVER PAGES

INTRODUÇÃO AO ASP ASP (Active Server Pages - Páginas de Servidor Ativas) é um ambiente para

programação por scripts no servidor, que você pode usar para criar páginas dinâmicas, interativas e de alta performance. Como as páginas ASP, os scripts são executados no servidor e não no browser do cliente. É o próprio servidor que transforma os scripts em HTML padrão, fazendo com que qualquer browser do mercado seja capaz de acessar um site que usa ASP.

O ASP surgiu juntamente com o lançamento do Internet Information Server 3.0 (IIS), hoje já se encontra na versão 5.0. Esta é uma solução Microsoft, exigindo que o servidor execute um sistema operacional da Microsoft (Windows 95/98, NT ou 2000). Os seguintes servidores suportam o uso de páginas ASP:

• Microsoft Internet Information Server versão 4.0 no Windows NT Server.

• Microsoft Internet Information Server versão 5.0 no Windows 2000.

• Microsoft Personal Web Server no Windows NT Workstation

• Microsoft Personal Web Server no Windows 95 ou Windows 98

A grande vantagem é que você fica independe do browser que o cliente utiliza, pois o servidor é que possui a exigência de ter um sistema operacional Microsoft. Assim, o cliente pode navegar num site construído em ASP com qualquer browser (seja ele Internet Explorer ou Netscape Navigator).

Entre os recursos que podem ser implementados via ASP, podemos citar:

• Programação em VBScript ou Jscript.

• Acesso à banco de dados.

• Acesso a arquivos textos.

• Captação de informações de formulários.

• Captação de informações sobre o visitante e sobre o servidor.

• Uso de variáveis e loops.


2

ACTIVE SERVER PAGES

COMPARANDO O ASP COM OUTRAS TECNOLOGIAS Precisamos neste momento explicar porque escolhemos o ASP, visto que temos

outras tecnologias que podem ser utilizadas para conteúdo dinâmico. O que o ASP oferece de melhor em relação às outras tecnologias?

TECNOLOGIAS INICIAIS

Desde a primeira versão do IIS (Internet Information Server) o conteúdo dinâmico pode ser adicionado ao site por: aplicações CGI, extensões e filtros ISAPI, Internet Database Connector (IDC). A partir da versão 3.0 o ASP foi incluído nestas opções. Quais as vantagens do ASP em relação a estas tecnologias? É que ele reuniu o que tinha de melhor em todas elas. Abaixo alistamos as principais vantagens do uso do ASP.

• Facilidade de programação e acesso a banco de dados (como o IDC), fácil acesso ao sistema operacional (como o CGI ou ISAPI) e velocidade (como o ISAPI).

• Ambiente baseado em script de servidor, que conduz a aplicações dinâmicas, interativas, que não consomem muito tempo de processamento.

• Há muitas ferramentas RAD (Rapid Application Development) disponíveis como, por exemplo, o Visual InterDev, que permitem que você crie facilmente páginas ASP.

TECNOLOGIAS ADICIONAIS PARA IIS

Allaire ColdFusion: servidor de aplicações da Web que permite que você construa páginas sofisticadas. Usa um ambiente de script de servidor baseado em tags. Possui um IDE (Integrated Development Environment) e pode ser usado para criar aplicativos dimensionáveis

Aplicações do Visual Basic para a Web: integradas com o ASP, as aplicações do VB6 são visualizadas como "páginas da Web encapsuladas". O código está contido em um único componente do Visual Basic, permitindo que você acesse os mesmos recursos que acessaria em uma página do ASP, porém com as melhorias de desempenho do processamento em uma linguagem compilada.


3

ACTIVE SERVER PAGES

COMO FUNCIONA UMA PÁGINA ASP? Quando o cliente acessa uma página ASP, imediatamente o Servidor IIS ou PWS

entra em ação e executa todos os scripts contidos nessa página, caso essa página faça algum tipo de acesso à banco de dados, ele também é feito e o resultado desse acesso é enviado para o servidor. Após tudo isso, o servidor retorna para o cliente uma página HTML simples, contendo o resultado de suas requisições.

Observe o esquema a seguir:

Browser Cliente

Páginas ASP *

Servidor IIS **

Acesso ao BD

HTML ***

* Rotina ASP

** Gera HTML dinamicamente

*** Resultado mostrado ao cliente


4

ACTIVE SERVER PAGES

O AMBIENTE DE DESENVOLVIMENTO Como os arquivos .asp são arquivos do tipo texto, eles podem ser escritos em

qualquer editor de texto simples, como o bloco de notas. Existem vários editores que tornam mais fácil a programação em ASP por deixarem o código colorido, um exemplo é o EditPlus. Mas, se você deseja um ambiente mais profissional, o Microsoft Visual InterDev é o indicado.

PLATAFORMAS DE DESENVOLVIMENTO DO ASP

O ASP acha-se disponível em várias plataformas, devemos escolher a que se adapta ao nosso ambiente. Exemplos:

MICROSOFT PERSONAL WEB SERVER

O PWS é um servidor da Web desenvolvido para empresas ou pessoas que precisam de um IIS em escala reduzida para aplicações e desenvolvimentos de intranets.

A vantagem do PWS é que ele pode ser executado em um sistema operacional Windows 95, Windows 98 ou Windows NT Workstation de baixo custo.

Recursos principais do PWS para plataforma Windows 9x:

• Suporte para ASP.

• Serviço WWW.

• Interface Easy Web para administração.

• Suporte para Microsoft Transaction Server.

• Suporte para Microsoft Message Queue Server.

• FrontPage Extensions para facilitar a atualização de sites.

• Suporte para Activex Data Objects (ADO) e Remote Data Services (RDS).

• É um servidor da Web com baixo volume, é limitado a um máximo de dez usuários.

Os seguintes recursos estão disponíveis só na plataforma Windows NT Workstation:

• Serviço de FTP.

• Interface com Optional Internet Service Manager (ISM) para administração.

• Suporte para Autenticação.

• Publicação com o uso de unidades locais e de rede.


5

ACTIVE SERVER PAGES

MICROSOFT INTERNET INFORMATION SERVER (IIS)

O IIS é um servidor da Web que se integra no Windows NT Server e no Windows 2000. O IIS permite que você publique informações na Web e execute várias aplicações de negócios usando o ASP. Esta é a plataforma de desenvolvimento que utilizaremos em nosso treinamento.

Recursos principais do IIS:

• Index Server para indexação textual e pesquisa do conteúdo de um site.

• Site Server Express para a análise do conteúdo e do uso do site.

• Serviço de SMTP para o envio de e-mail.

• Serviço de NNTP para a hospedagem de newsgroup particulares.

• Certificate Server para a emissão de certificados que podem ser usados para a garantia de sites da Web.

• Não há limites para usuários.

ONDE SALVAR OS ARQUIVOS ASP

Quando o IIS é instalado no Windows NT ou no Windows 2000 é criada a pasta Inetpub onde estão os diretórios que o IIS precisa para poder trabalhar o diretório onde ficam armazenadas os arquivos de um site é o wwwroot. Dentro dessa pasta devemos criar uma pasta para o site e armazenar todos os arquivos asp, htm, gifs, jpgs, etc. dentro dele.

Mas não basta apenas criar a pasta com os arquivos do site é necessário configurar a pasta criada como uma pasta virtual, ou seja, uma pasta que possa ser acessada pelo browser sem indicarmos todo o caminho físico.

Para fazer essa configuração entre no Gerenciador do ISS (que no Windows 2000 está localizado no Painel de Controle dentro da pasta Ferramentas administrativas).


6

ACTIVE SERVER PAGES

Clique sobre a pasta do site que você criou com o botão direito do mouse e selecione a opção Propriedades (Properties).


7

ACTIVE SERVER PAGES

Deixe as opções marcadas como na tela acima, dessa forma você poderá acessar o site diretamente de seu computador digitando o nome da sua máquina seguido do Local Path definido nas propriedades. Você também pode digitar http://localhost/o Local Path definido.


8

ACTIVE SERVER PAGES

TRABALHANDO COM O ASP Assim chegamos a conclusão que a linguagem ASP é uma junção de programação

em VBScript (ou qualquer outro script que suporte o modelo ActiveX Scripting, como o JavaScript),Objetos ActiveX e os seus próprios objetos.

VBScript é uma linguagem criada a partir do Visual Basic, mas com algumas limitações, por motivos de segurança, são os blocos de construção básicos usados nas páginas ASP. É usada como padrão atualmente pelos programadores ASP.

Objetos ActiveX são funções prontas, já existentes no servidor. Essas funções captam os parâmetros de entrada dos dados, manipula-os de acordo com seu objetivo e então os envia para a saída. Um exemplo de ActiveX é o Objeto ASPMail, o qual capta os dados de entrada (nome, email, corpo da mensagem, etc), cria um email com esses dados e depois envia a mensagem usando o servidor de SMTP configurado.

Objetos são add-ons que dão a capacidade de captura e transmissão de variáveis entre as páginas, de criação e manipulação de cookies, sessions e publicidade rotativa nos sites, a capacidade de captura de informações sobre o Browser do usuário e sobre o servidor, de consulta, alteração e adição de dados em Bando de Dados, de envio e recebimento de emails via página WEB, e uma infinidade outras funções.

O ASP serve para você disponibilizar em seu site conteúdo dinâmico, ou seja, deixar o usuário livro para solicitar informações sobre o que ele quiser. Como o código é armazenado no servidor e o usuário recebe apenas o HTML, você está garantindo a sua propriedade intelectual.

Imagine que você possui um banco de dados com vários artigos, sobre diferentes assuntos. Se montar um site apenas com HTML, você precisará criar inúmeras páginas com cada um dos artigos e links que direcionam para esta pasta. Com o ASP, você criará apenas uma página onde o usuário escolhe o assunto e vê a lista com os assuntos disponíveis. E uma outra página padrão que será montado quando ele selecionar o artigo que deseja ler. Você conseguirá sites úteis, rápidos e com as informações realmente necessárias para cada usuário individualmente.

CONHECENDO A ESTRUTURA DA PROGRAMAÇÃO ASP

Uma vez que a linguagem ASP é embutida dentro de páginas HTML, existe um símbolo para diferenciar o que é código HTML do que é código ASP: <% código asp %>

Abaixo um exemplo de página em HTML e ASP:

<html>

<title>Exemplo</title>

<p>Estou aprendendo ASP</p>

<%

' aspas simples significam comentários dentro do código ' a linha abaixo tem o mesmo efeito do código HTML acima

response.write "<p> Estou aprendendo ASP </p>"


9

ACTIVE SERVER PAGES

%>


10

ACTIVE SERVER PAGES

</html>

ASP é uma linguagem que veio para complementar a linguagem HTML. Observe o código abaixo:

<html>

<head><title>Como funciona o ASP?</title></head>

<body bgcolor="#FFFFFF">

<p><font face=”Verdana,Arial”><b>Olá Mundo!!!</font></b></p>

<%

response.write "<p><font face=’Verdana,Arial’><i>Olá Mundo!!!</font></i></p>"

%>

<p><%= "Olá Mundo!!!" %></p>

</body></html>

Abaixo segue a simbologia e as convenções de uso da linguagem ASP: <% início do trecho de código ASP

%> final do trecho de código ASP

' (aspas simples) usada antes de comentários dentro do código. Quando fazemos referência a código HTML dentro das tags ASP, e os valores das tags HTML precisem estar entre aspas, devemos utilizar as aspas simples; como no exemplo anterior. Abaixo temos o erro que é gerado pelo servidor web (PWS ou IIS) quando cometemos o erro de trabalhar com aspas duplas para HTML dentro do ASP.

= é usado no modo de programação para a mesclagem de códigos HTML e ASP.


11

ACTIVE SERVER PAGES

OS OBJETOS DO ASP O ASP possui alguns objetos que operam as funcionalidades de uma aplicação (um

site). Estes objetos são responsáveis pelas respostas aos clientes e pelo recebimento de requisições dos clientes, também criam e destroem seções, entres outras coisas.

Estes objetos são constituídos de propriedades, coleções e métodos. Os cinco objetos são:

• Response

• Request

• Session

• Application

• Server

Ao criar um site que efetua um cadastro de clientes, você precisará recuperar as informações digitadas no browser para serem utilizadas ou armazenadas no servidor, um dos objetos do ASP é o responsável em recuperar essas informações. Se ocorrer algum problema na gravação dos dados digitados no banco de dados, será necessário enviar uma mensagem ao usuário informando o que aconteceu, um objeto do ASP é o responsável por enviar mensagens do servidor para o usuário. Portanto, é de grande importância conhecermos e utilizarmos estes objetos de maneira correta.

OBJETO RESPONSE

É o objeto responsável pelos dados enviados do servidor para o cliente (informação enviada do servidor para o browser do cliente). Este objeto tem os seguintes Métodos e Propriedades:

Métodos Propriedades e Coleções

Write enviar texto ao browser. Buffer avisa o browser que a página só deverá ser mostrada após ser totalmente carregada.

Redirect redireciona o browser para um endereço especificado, só pode ser usado antes do browser divulgar qualquer mensagem na tela.

Cookies grava informações no cookie do browser.

End pára a execução do script da página. Expires define o tempo de expiração de uma página ou de um cookie.

OBSERVAÇÃO:

Se você não indicar quando o cookie irá expirar, o cookie apenas fica valendo enquanto o browser do cliente estiver aberto, assim que fechar o cookie desaparece.


12

ACTIVE SERVER PAGES

OBJETO REQUEST

É o objeto responsável pelos dados enviados do cliente para o servidor, ou seja, qualquer informação requisitada pelo servidor ao cliente.

Propriedades e Coleções

Form recupera valores enviados pelo formulário, via método Post.

Querystring recupera valores enviados pelo formulário, via método Get, isto é, as informações são obtidas através da string de pesquisa http, esta string se encontra após o ponto de interrogação na linha do endereço.

Cookies recupera informações do cookie do cliente.

Servervariables recupera valores sobre o browser do cliente e sobre o servidor Web.

Variáveis do sistema que podem ser recuperadas pelo Servervariables:

CONTENT_LENGTH

Retorna o tipo de conteúdo que foi enviado ao servidor. QUERY_STRING

String que sucede o ? no endereço URL. REMOTE_ADDR

IP do usuário. REMOTE_HOST

Nome do servidor correspondente ao REMOTE_ADDR (nome do provedor de acesso do usuário). REQUEST_METHOD

Método usado para transmissão das variáveis de uma página para outra (GET ou POST). SERVER_NAME

Nome do servidor de hospedagem, como usado no URL (pode ser o IP ou DNS). URL

endereço URL requisitado (sem a query_string).

OBJETO SERVER

É o objeto responsável por permitir acesso e configuração de algumas funções e métodos ligados ao servidor.


13

ACTIVE SERVER PAGES

Método

Createobject cria uma instância de um componente no servidor.

Exemplo: set conexao = server.createobject("adodb.connection") // Cria objeto de conexão

Componentes são bibliotecas de objetos que possuem finalidades diversas. Ex.: componentes que operam serviços de e-mail, que manipulam banco de dados, etc..

Mappath mapeia arquivos de acordo com o caminho físico, a partir do caminho virtual.

Exemplo: server.MapPath ("mdb\dblivraria")

OBJETO APPLICATION

É o objeto responsável por armazenar e compartilhar valores, estados e propriedades de um grupo. Um exemplo seria armazenar o número total de clientes no site num instante. É também possível controlar erros causados por tentativas de alterações simultâneas de variáveis.

Aplicação é todo o conjunto de páginas ASP e HTML que formam o programa (site) como um todo. Com o objeto Application podemos criar variáveis que estão disponíveis em qualquer momento no site.

Declaração de variáveis Application:

Application(“nomedavariavel”) = conteudo

Método

Lock trava o acesso às variáveis Application.

Unlock destrava o acesso às variáveis Application, disponibiliza as variáveis novamente.

OBJETO SESSION

É o objeto responsável por armazenar valores ligados a cada visitante enquanto ele utiliza uma aplicação. Uma session é criada quando o cliente entra no site e é destruída quando o cliente sai do site (seja por logoff ou por tempo expirado, que por padrão é 20 minutos).

A declaração de variáveis do tipo session possibilita que as mesmas estejam disponíveis durante toda a permanência do cliente no site. São úteis quando desejamos identificar características do cliente em qualquer ponto do site.

Declaração de variáveis Session:

Session(“nomedavariavel”) = conteudo

Exemplo de utilização: quando o cliente se logar, podemos guardar numa session – seu nome, e-mail e login e ainda contar seu tempo de permanência no site, se fizermos isso em conjunto com uma variável Application.


14

ACTIVE SERVER PAGES

Métodos Propriedades e Coleções

Abandon encerra a session. TimeOut determina qual o tempo máximo, em minutos, de inatividade do visitante até que a session seja considerada abandonada.

Cada um desses objetos será utilizado em testes que faremos juntamente com os comandos de VBScript.


15

ACTIVE SERVER PAGES

A LINGUAGEM VBSCRIPT Como o código do ASP é utilizado com instruções VBScript nesse momento faz-se

necessário uma pequena explicação sobre o funcionamento dessa linguagem. Vamos analisar variáveis e seus tipos, funções pré-definidas, operadores, comandos principais e rotinas (procedimentos e funções).

Scripts são linguagens que permitem a criação rápida de aplicações para Internet. Sendo assim, são mais fáceis de aprender e desenvolver do que as linguagens de programação atuais.

O VBScript (ou Visual Basic Script) é uma das possibilidades de linguagem de script que executam no servidor. Ela é a linguagem padrão no IIS e no PWS, mas podemos utilizar outras, uma bastante comum é o JavaScript.

Algumas características do VbScript:

• É similar ao Visual Basic Application.

• Permite a manipulação de números, datas e strings.

• Permite a utilização de todos os comandos do Visual Basic, exceto os de acesso ao banco de dados, que é feito através do objeto ADO.

Pense que você precisa desenvolver uma aplicação que cadastre os clientes de sua empresa pela Internet. Os dados devem ser armazenados em um banco de dados e várias validações dos dados digitados pelos usuários devem ser feitas.

A linguagem VBScript possibilitará, por meio do ASP, a criação da aplicação validando as informações e armazenando-as no banco de dados. O ASP executará as solicitações do VBScript junto com seus objetos e devolverá uma resposta ao cliente no formato HTML. Assim, o VBScript é executado no servidor.

VARIÁVEIS E TIPOS DE DADOS

As variáveis são criadas quando precisamos armazenar valores na memória que existirão durante a execução do programa, auxiliando e permitindo que informações sejam manipuladas (entrada e saída).

A declaração de uma variável é feita por meio da palavra-chave do VBScript: DIM

Exemplo:

DIM var

var = “Algum texto” ‘var recebeu um valor string

var = 20 ‘var recebeu um valor inteiro


16

ACTIVE SERVER PAGES

Quando apenas definimos o nome da variável, estamos indicando que ela é do tipo variant, pois não foi especificado o seu tipo. No VBScript não se faz necessário a declaração do tipo de variável.

TIPOS DE DADOS

Os principais tipos de dados que o VBScript trabalha, são:

Tipo Descrição

Empty Variável que contém 0 para valores numéricos e "" (string vazia) para strings.

Null Variável que não contém nenhum valor.

Boolean Variável que contém valores True ou False.

Byte Números inteiros entre 0 e 255.

Integer Números inteiros no intervalo de -32,768 a 32,767.

Long Números inteiros no intervalo de -2,147,483,648 a 2,147,483,647.

Single Números com ponto flutuante de precisão simples na faixa de -3.402823E38 a -1.401298E-45 para números negativos e 1.401298E-45 a 3.402823E38 paranúmeros positivos.

Double Números com ponto flutuante de dupla precisão na faixa de -1.79769313486232E308 a -4.94065645841247E-324 para números negativos e4.94065645841247E-324 a 1.79769313486232E308 para números positivos.

Date (Time) Valores no formato de Data (data e hora) na faixa de 1 de janeiro de 100 a 31de dezembro de 999. (January 1, 100 a December 31, 9999).

String Contém dados no formato de string, que podem ter até aproximadamente 2bilhões de caracteres de tamanho.

OPERADORES

Os operadores são utilizados para fazer cálculos, comparações e junções, tanto no código VBScript, quanto no código ASP.

OPERADORES ARITMÉTICOS

+ Adição

- Subtração

* Multiplicação

/ Divisão

\ Divisão inteira (retorna só a parte inteira)

Mod Resto da divisão inteira

^ Potenciação


17

ACTIVE SERVER PAGES

OPERADOR DE CONCATENAÇÃO

& Concatenação de strings

OPERADORES RELACIONAIS

= Igual a

< Menor que

<= Menor ou igual que

> Maior que

>= Maior ou igual que

<> Diferente de

OPERADORES LÓGICOS

And E

Or Ou

Not Não

Eqv Equivalência

Imp Implicação lógica

Xor Ou exclusivo

Os operadores lógicos são avaliados de acordo com as tabelas a seguir:

AND OR

Expressão 1 Expressão 2 Resultado Expressão 1 Expressão 2 Resultado

T T T T T T

T F F T F T

F T F F T T

F F F F F F

EQV IMP

Expressão 1 Expressão 2 Resultado Expressão 1 Expressão 2 Resultado

T T T T T T

T F F T F F

F T F F T T

F F T F F T


18

ACTIVE SERVER PAGES

XOR NOT

Expressão 1 Expressão 2 Resultado Expressão Resultado

T T F T F

T F T F T

F T T

F F F

PRINCIPAIS COMANDOS DO VBSCRIPT

COMANDOS CONDICIONAIS

IF – THEN – ELSE

O comando IF testa uma condição e executa os comandos que estão após o THEN se essa condição for verdadeira e executa os comandos que estão após o ELSE, caso essa condição seja falsa.

Sintaxe:

IF condição THEN Comandos

END IF

IF condição THEN Comandos ELSE Comandos END IF

SELECT CASE

Utilizado quando se têm várias opções para determinada variável ou expressão. Sintaxe:

SELECT CASE variável ou expressão

CASE valores

comandos

CASE valores

comandos

CASE valores

comandos

CASE valores

comandos

CASE ELSE

comandos

END SELECT


19

ACTIVE SERVER PAGES

COMANDOS DE REPETIÇÃO

WHILE ... END

Enquanto uma condição for verdadeira o loop é executado. Sintaxe:

WHILE condição

comandos

WEND

DO WHILE ... LOOP

Executa os comandos enquanto a condição for verdadeira. Sintaxe:

DO WHILE condição

comandos

LOOP

FOR ... TO ... NEXT

Executa os comandos até que o contador do loop atinja um valor pré-determinado. Sintaxe:

FOR contador = valor inicial TO valor final

comandos

NEXT

FUNÇÕES

As funções no VBScript servem para que os tipos de dados não sejam interpretados de maneira incorreta e gerem erros nos códigos. Isso é muito importante levando em consideração que a Internet está disponível em vários países e cada tem uma maneira de visualizar valores, por exemplo.

Imagine que está recebendo um valor de um formulário para ser inserido em um banco de dados. Este valor deve ser numérico para não gerar nenhum erro de tipo de dado no banco de dados. Os dados digitados em um formulário HTML são passados como texto (string), então será necessário converter este texto em número. Conseguiremos isso por meio das funções de conversão.

Também será necessário fazermos validação de dados, testarmos se é uma data, um número, etc.. As funções de verificação nos auxiliarão.


20

ACTIVE SERVER PAGES

FUNÇÕES PARA VERIFICAÇÃO DE TIPO DE VARIÁVEIS

FUNÇÕES PARA CONVERSÃO DE TIPOS

Função Descrição Sintaxe

CBool retorna True ou False de acordo com o valor da expressão avaliada.

CBool (nome da variável / expressão)

CByte converte a expressão dada em um valor do tipo byte.

CByte (nome da variável / expressão)

CDate converte a expressão dada em um valor do tipo data/hora.

CDate (nome da variável / expressão)

CDbl converte a expressão dada em um valor do tipo double.

CDbl (nome da variável / expressão)

CInt converte a expressão dada em um valor do tipo integer.

CInt (nome da variável / expressão)

CLng converte a expressão dada em um valor do tipo long.

CLng (nome da variável / expressão)

CStr converte a expressão dada em um valor do tipo string.

CStr (nome da variável / expressão)

CSng converte a expressão dada em um valor do tipo single.

CSng (nome da variável / expressão)


IsArray retorna True se uma variável é um array (vetor), caso contrário retorna False.

IsArray (nome da variável)

IsDate retorna True se uma variável é uma data, caso contrário retorna False.

IsDate (nome da variável)

IsEmpty retorna True se uma variável contém 0 (no caso de ser numérica) ou "" (no caso de ser string), caso contrário retorna False.

IsEmpty (nome da variável)

IsNull retorna True se a variável não contém valores válidos, caso contrário retorna False.

IsNull (nome da variável)

IsNumeric retorna True se uma variável contém um valor numérico, caso contrário retorna False.

IsNumeric (nome da variável)


21

ACTIVE SERVER PAGES

FUNÇÕES PARA MANIPULAÇÃO DE NÚMEROS:


Abs retorna o valor absoluto de um valor numérico.

Abs (número)

Fix retorna a parte inteira de um número. Fix (número)

Int retorna a parte inteira de um número, caso o número seja negativo, é retornado o valor imediatamente menor.

Int (número)

Sqr retorna o valor da raiz quadrada do número (esse valor deve ser maior ou igual a zero).

Sqr (número)

FUNÇÕES PARA MANIPULAÇÃO DE DATAS


Day retorna o dia do mês de uma determinada data.

Day (data)

Month retorna o mês de uma determinada data.

Month (data)

Year retorna o ano de uma determinada data.

Year (data)

Weekday retorna o dia da semana de uma determinada data.

Weekday (data)

Hour retorna a hora de um determinado tempo.

Hour (tempo)

Minute retorna o minuto de um determinado tempo.

Minute (tempo)

Second retorna o segundo de um determinado tempo.

Second (tempo)

Now retorna a data e hora atual (data e hora que consta no relógio do servidor).

Now

Time retorna a hora atual (hora que consta no relógio do servidor).

Time

Date retorna a data atual (data que consta no relógio do servidor).

Date


22

ACTIVE SERVER PAGES

FUNÇÕES PARA MANIPULAÇÃO DE STRINGS


Asc retorna o caractere (pela tabela ANSI) correspondente à primeira letra da string de entrada.

Asc (string)

Chr retorna o caractere correspondente a um determinado código (numérico) da tabela ANSI.

Chr (código)

InStr retorna a posição da primeira ocorrência de uma string dentro da outra, é possível delimitar a partir de qual caractere será feita tal procura.

InStr (posição inicial, string, string de comparação)

LCase converte todos os caracteres de uma string para minúsculo.

LCase (string)

UCase converte todos os caracteres de uma string para maiúsculo.

UCase (string)

Left retorna um determinado número de caracteres a partir do lado esquerdo da string.

Left (string, número de caracteres)

Len retorna o número de caracteres numa string (contando espaços em branco), ou, no caso de variáveis numéricas ou no formato de data, retorna a quantidade de bytes necessários para armazenar aquela expressão.

Len (string)

Mid quebra uma string. Delimita-se a posição inicial, a string e a quantidade de caracteres a partir da posição inicial que devem ser deixados na string de retorno.

Mid (string, posição inicial, tamanho)

Right retorna um determinado número de caracteres a partir do lado direito da string.

Right (string, número de caracteres)

Ltrim retorna uma cópia da string de entrada, mas sem os espaços no início da string.

LTrim (string)

Rtrim retorna uma cópia da string de entrada, mas sem os espaços no final da string.

RTrim (string)

Trim retorna uma cópia da string de entrada, mas sem os espaços no início e no final da string.

Trim (string)


23

ACTIVE SERVER PAGES

CÓDIGOS PARA TESTES DOS COMANDOS E FUNÇÕES VBSCRIPT

Teste para a estrutura condicional IF.

<HTML>

<TITLE>Teste de VBSCRIPT</TITLE>

<BODY bgcolor = #FFFFFF>

<font face = verdana size = 2>

<% ' Teste do Comando IF

Dim I ' Declara a variável I

I = 9 ‘ Inicializa a variável

IF I >= 10 THEN

‘Usamos o comando condicional para testar o valor da variável %>

<p> O valor de I é maior ou igual a 10. </p>

<p> O valor de I é <% = I %> e seu quadrado é <% = I * I %></p>

<% ELSE %>

<p> O valor de I é menor que 10. </p>

<p>O valor de I é <% = I %> e seu cubo é <% = I * I * I %></p>

<% END IF %>

</BODY></HTML> Você pôde observar que como a condição do comando IF foi falsa, os comandos

executados foram os do comando ELSE. Para testarmos a condição verdadeira do IF altere o valor inicial de I para 15. Lembre-se de salvar o código no servidor Web para que você consiga efetuar todos os testes.

ESTRUTURA CONDICIONAL SELECT CASE

Preciso informar ao usuário do site quantos minutos da hora atual ele se encontra, depois qual é a hora atual, qual será a próxima hora e a data e a hora atual. Como aprendemos, para testarmos várias opções de uma única vez usamos o comando SELECT CASE do VBScript.

<HTML>




<% ' Teste do comando SELECT CASE

SELECT CASE Minute(Now)

CASE 0,1,2,3,4,5,6,7,8,9,10 %>

<p> Passam até 10 minutos da hora atual. </p>

<% CASE 11,12,13,14,15,16,17,18,19,20 %>


<% CASE 21,22,23,24,25,26,27,28,29,30 %>


24

ACTIVE SERVER PAGES


<% CASE 31,32,33,34,35,36,37,38,39,40 %>


<% CASE 41,42,43,44,45,46,47,48,49,50 %>


<% CASE ELSE %>

<p> Faltam menos de 10 minutos para a próxima hora. </p>

<% END SELECT %>

<p> A hora atual é <%= Hour(now)%> </P>

<p> a próxima hora é <% = Hour(now) + 1%> </p>

<p> o minuto agora é <% = Minute(now)%> </p>

<p> a data e hora agora é <% = Now %> </p>

</BODY></HTML>

ESTRUTURA DE REPETIÇÃO FOR

Gostaria de saber o segundo da hora atual até que o valor de uma variável chegue até 10. Digite o código abaixo no bloco de notas:

<HTML>




<% ' Teste do comando FOR

DIM Segundo ‘Declara a variável

Segundo ="" ‘Inicia a variável

FOR I = 1 TO 10

‘O contador começa com 1. O loop é feito até o mesmo atingir 10.

Segundo = Second(Now)

‘ Função utilizada para buscar o segundo da hora atual %>

<br><font face = "Verdana" Size = 2>O segundo da hora atual é: <% = Segundo %>

</font>

<% NEXT %>

</BODY></HTML>

ESTRUTURA DE REPETIÇÃO WHILE

Preciso saber a quantidade de caracteres de uma frase, qual a primeira e a última letra e qual a letra do meio. Digite o código abaixo no bloco de notas:

<HTML>





25

ACTIVE SERVER PAGES

<% ' Teste do comando WHILE


26

ACTIVE SERVER PAGES

'Declara variáveis para auxiliar funções DIM LetraMeio, TamFrase, Cont, Frase

LetraMeio = ""

TamFrase = ""

Cont = 0

Frase ="Active Server Pages"

WHILE Cont < 3

‘ Conta o número de caracteres da frase e acha a metade desse valor Carac = Len(Frase)

Meio = Carac / 2 %>

<p> Tamanho da Frase =<% =Carac %>

Ultima letra da Frase = <% =Right(Frase,1) %> <br>

Primeira Letra da Frase = <% =Left(Frase,1) %> <br>

Letra do Meio da Frase = <% =Mid(Frase,Carac,1) %> <br></p>

<% Cont = Cont + 1

WEND %>

</BODY></HTML>

AS ROTINAS

As rotinas em uma linguagem de programação servem para agrupar códigos que funcionarão várias vezes em vários programas diferentes, ou dentro de um mesmo programa o código deve ser acessado em vários momentos.

Muitos dos bancos de dados utilizados nos sites estão armazenados em servidores com padrão de data americano. Ao mostrar as datas armazenadas no banco para o usuário do site, esta deve estar no padrão que ele reconhece, levando em conta que iremos trabalhar com usuários brasileiros; a data deve ser mostrada no formato dia, mês e ano.

Será necessário converter a data que está armazenada no banco de dados para o padrão brasileiro em vários pontos do mesmo programa e do site, então criamos uma rotina para armazenar o código que faz esta transformação e a mesma poderá ser acessada apenas usando uma chamada pelo nome dado à rotina.

Existem dois tipos de rotinas: funções (rotinas que retornam valor) e procedimentos (rotinas que não retornam valor, simplesmente executam alguma ação). O exemplo mencionado acima deve ser criado uma rotina que retorna valor, uma função. Mas quando vamos, por exemplo, fazer a conexão com um banco de dados, o código deve ser repetido em todas as páginas que acessem o banco, mas não é necessário retornar nenhum valor, então usamos um procedimento.


27

ACTIVE SERVER PAGES

Sintaxe das funções:

FUNCTION nome (parâmetros)

comandos

END FUNCTION

Sintaxe dos procedimentos:

SUB nome (parâmetros)

comandos

END SUB


28

ACTIVE SERVER PAGES

TESTANDO OS OBJETOS DO ASP Ao testarmos os objetos do ASP estaremos nos preparando para criarmos o site da

Livraria ClaraLuz. Como já vimos cada um dos objetos está interagindo com o cliente e o servidor.

TESTE DO OBJETO RESPONSE

Já sabemos que o objeto Response é o responsável por enviar dados do servidor para o cliente. E também já conhecemos seus métodos e propriedades. Vamos testar cada um dos métodos e propriedades.

MÉTODO WRITE

Este método nós já estamos utilizando desde o nosso primeiro exemplo. Ele envia texto ao browser do cliente.

Sintaxe:

<% Response.write “Mensagem” %>

Esta sintaxe deve ser utilizada quando estamos trabalhando num bloco de comandos VBScript. Quando temos apenas que enviar um dado para o cliente no meio de um código HTML, utilizamos a seguinte sintaxe:

<% = variável %>

É esta sintaxe que estamos utilizando até o momento.

MÉTODO END

Sempre que quisermos encerrar o carregamento da página em um determinado ponto do código, utilizaremos o método End do ASP.

Sintaxe:

<% Response.End %>

MÉTODO REDIRECT

Em determinados momentos da execução de um programa é necessário desviar a execução para um outro programa. Por exemplo, se o usuário já estiver cadastrado no site ele deve ser direcionado para a página de usuários cadastrados, se não estiver cadastrado ele deve ser direcionado para a página de cadastro. Para conseguirmos redirecionar um usuário para uma outra página do site utilizamos o método Redirect, com a seguinte sintaxe:

<% Response.Redirect(“URL”) %>


29

ACTIVE SERVER PAGES

Onde a URL pode ser substituída por um endereço http ou o nome de um arquivo do site.


30

ACTIVE SERVER PAGES

O método Redirect deve ser utilizado antes que qualquer tag HTML seja enviada ao browser. Se desejar utiliza-lo depois que um código HTML foi enviado ao browser, utilize a propriedade Buffer.

PROPRIEDADE BUFFER

Este comando deve ser o primeiro da página, antes de qualquer outro código, quer seja HTML, VBScript, etc.. Ele avisará ao browser que só após todo o código ter sido carregado no cliente é que o conteúdo da página poderá ser mostrado.

Por padrão o valor deste comando é FALSE, ou seja, a página vai sendo mostrada à medida que o código é enviado ao browser. Para ativa-lo utilize a sintaxe abaixo:

<% Response.Buffer = true %>

COLEÇÃO COOKIE

Com os cookies podemos armazenar informações em formato texto no micro do cliente. Informações como a hora do acesso, a data, ou qualquer outra informação que você possa recuperar a qualquer momento no site.

Existem dois tipos de cookies: os de sessão e os permanentes. Os cookies de sessão só existem enquanto o browser do cliente está aberto. Os cookies permanentes nós controlamos até quando eles permanecerão no disco rígido do cliente.

Lembre-se que o usuário pode travar a máquina para não receber cookies, ou apaga-los a qualquer momento.

Os cookies devem ser utilizados principalmente quando você for personalizar a entrado do site, ou buscar a data da última visita do cliente ao site, etc.. Muitos têm medo dos cookies, pensam que os mesmos podem estar trazendo vírus. Mas, os cookies são apenas arquivos de texto que armazenam as informações que você solicitou e algumas informações sobre o site. Nunca utilize cookies para armazenar informações confidenciais do usuário, porque ele não tem segurança.

Para gravar um cookie utilize a seguinte sintaxe:

<% Response.cookie ( “Nome do Cookie”)(“Nome do Campo”) = valor %>

O Nome do Cookie será o nome do arquivo armazenado no disco rígido do usuário. E o Nome do campo serão as informações que você armazenou identificadas de maneira correta.

Com o comando acima, assim que o usuário sair da janela do Browser o cookie será perdido. Para manter o cookie armazenado durante um período utilize a propriedade Expires, que pode ser utilizada da seguinte maneira:

<% Response.Expires = “data” %> Vamos criar um programa que armazena no cliente um cookie com a data e a hora

atual, e o nome do site. Digite o código abaixo no bloco de notas:


31

ACTIVE SERVER PAGES

<%

Response.Buffer = True

'Ira apresentar a página somente após ser totalmente carregada

'Cookies -> ira gravar informações locais na maquina do cliente Response.Cookies("Teste") ("DataAtual") = Date

Response.Cookies("Teste") ("HoraAtual") = Time

Response.Cookies("Teste") ("Site") = "Curso de ASP"

Response.Cookies("Teste").Expires = "01/11/2005"

%>

<HTML>

<HEAD>

<TITLE>Utilizando o objeto RESPONSE</TITLE>

</HEAD>

<BODY bgcolor = #99CCFF>

<font face = arial size = 4 color = Black >

O cookie Teste foi armazenado no seu Computador!

</font>

</BODY>

</HTML> Depois de executar o programa, vá até a pasta Windows/cookies e organize pela

data, existirá um arquivo txt com o nome do servidor WEB. Abra este arquivo e visualize as informações gravadas.

TESTANDO O OBJETO SESSION

Você já aprendeu que o objeto Session é o responsável por armazenar valores ligados a cada visitante enquanto ele utiliza uma aplicação. Uma session é criada quando o cliente entra no site e é destruída quando o cliente sai do site (seja por logoff ou por tempo expirado, que por padrão é 20 minutos).

Também podemos criar variáveis em nível de Sessão, que podem ser recuperadas enquanto o usuário não fechar o browser ou o tempo de expiração não se cumprir.

A sintaxe para criação de uma variável em nível de sessão é:

<% Session(“Variável”) = Valor %>

Esta variável pode ser recuperada a qualquer momento dentro daquela visita do usuário no site.

Quando acessamos sites de compras, de banco ou que trazem informações que só interessam ao usuário naquele momento, sempre encontramos uma opção para abandonar aquela área do site, que provavelmente utilizamos uma senha para poder acessar. Isto é feito pelo método Abandon do objeto Session. A sintaxe é a seguinte:


32

ACTIVE SERVER PAGES

<% Session.abandon %>

Vamos gravar algumas variáveis de sessão que serão recuperadas mais tarde.

<%

Session("DataConexao") = Date

Session("HoraConexao") = Time

‘Armazena qual o número equivalente ao dia da semana da data armazenada anteriormente Session("DiadaSemana") = Weekday(session("DataConexao"))

%>

<HTML>

<HEAD>

<TITLE>Utilizando o objeto SESSION</TITLE>

</HEAD>

<BODY bgcolor = #99CC99>

<font face = arial size = 4 color = Black > As variáveis de Sessão foram armazenadas!

</font>

</BODY>

</HTML> O código abaixo recuperará as informações, e como a função Weekday retorna o

número do dia da semana, vamos testar qual é esse número e mostrar o dia da semana por extenso.

<HTML>

<HEAD>

<TITLE>Utilizando o objeto SESSION</TITLE>

</HEAD>


<H2 ALIGN=CENTER> Recuperando as variáveis de Sessão </h2>


<p> Data da Conexão = <% = Session("DataConexao")%></p>

<p> Hora da Conexão = <% = Session("HoraConexao")%></p>

<p> Dia da Semana =

<% Select Case Session("DiadaSemana")

Case 1

response.write "Domingo"

Case 2

response.write "Segunda-Feira"

Case 3

response.write "Terça-Feira"

Case 4

response.write "Quarta-Feira"

Case 5


33

ACTIVE SERVER PAGES

response.write "Quinta-Feira"

Case 6

response.write "Sexta-Feira"

Case 7

response.write "Sábado"

end select%></p>

</font>

</BODY>

</HTML> Desta maneira, qualquer informação que for acessada vária vezes enquanto o

usuário está no site pode ser armazenada em uma variável do objeto Session.

TESTE DO OBJETO REQUEST

É o objeto responsável pelos dados enviados do cliente para o servidor, ou seja, qualquer informação requisitada pelo servidor ao cliente.

Podemos recuperar qualquer informação que está armazenada no cliente com o objeto Request. Essas podem estar vindo do servidor, de um formulário, de um cookie ou até mesmo da string de pesquisa da URL.

RECUPERANDO COOKIES

No programa feito anteriormente gravamos alguns cookies, abaixo emos um exemplo de um programa para recuperar os cookies gravados. .

No programa citado foram armazenadas dentro do cookie teste as variáveis: DataAtual, HoraAtual e Site. O código abaixo recupera as variáveis armazenadas no cookie:

<HTML>

<HEAD>

<TITLE>Objeto REQUEST - Recuperando Cookies</TITLE>

</HEAD>



<p><B>Buscando os cookies armazenados:</b></p>

<p>Data do último acesso:

<% = request.cookies("Teste")("DataAtual")%></p>

<p>Hora do último acesso:

<% = request.cookies("Teste")("HoraAtual")%></p>

<p>Site: <% = request.cookies("Teste")("Site")%></p>

</font>

</BODY>

</HTML>


34

ACTIVE SERVER PAGES

Utilize os cookies para buscar informações que serão úteis em uma outra visita do usuário.

RECUPERANDO INFORMAÇÕES DE FORMULÁRIOS

Quando trabalhamos com formulários no HTML, temos dois métodos de enviar os dados preenchidos: o GET e o POST. Qual a diferença de um para o outro? O método GET envia todos os dados preenchidos no formulário usando a string de pesquisa da URL.

Mas o que é a string de pesquisa da URL? São todos os valores que são informados após a ?(interrogação) no endereço da página acessada. Enviando os valores desta maneira temos o problema da limitação da quantidade de valores enviados. E os mesmos ficam visíveis ao usuário.

Pelo método POST os dados são enviados de maneira oculta para o servidor, como se fosse um arquivo anexado. Vamos trabalhar usando este método, porque temos maior flexibilidade nos dados que podem ser enviados ao servidor.

AÇÕES DO FORMULÁRIO NO MESMO ARQUIVO

O nosso primeiro teste usando formulário será bem simples. Crie uma página html com o seguinte formulário:

O method do formulário será Post. O action é o que será executado quando o usuário clicar no botão submit do formulário. Neste caso ele executará o próprio arquivo.

O que quero que aconteça quando o usuário clicar no botão enviar? O que ele preencheu nos campos de nome e email deve ser mostrado e um link para ele voltar à página deve ser acrescentado. Mas estas ações vão estar dentro do mesmo arquivo do formulário. Como vamos identificar quando o visitante clicou no botão enviar ou não?

Todos os campos do formulário são reconhecidos apenas depois do clique no botão submit. Então, criaremos um campo oculto que será o identificador do envio do formulário. Acrescente a seguinte linha após o comando FORM do seu arquivo:

<input type=”hidden” name=”hidEnviando” value=”ok”>

Então, quando o usuário clicar no botão Enviar, todos os campos do formulário são transmitidos via POST. Vou testar se o campo hidEnviando é igual a ok, se sim vou mostrar os dados digitados no formulário e criar um link para mostrar o arquivo novamente. Abaixo está o código final para esta página:


35

ACTIVE SERVER PAGES


36

ACTIVE SERVER PAGES

<HTML>

<HEAD>

<TITLE>Objeto Request - Recuperando informações do FORM</TITLE>

</HEAD>

<BODY font = arial size = 3 bgcolor = #ffffcc>

<font color = Black face=tahoma size=2>

<%

'Testa se o campo oculto está com o valor OK

if Request.Form("hidEnviando")="ok" then

Response.Write "<Font Color = #330066> <b>”

Response.Write “Dados enviados com sucesso <br>"

'Busca do formulário o nome digitado

Response.Write "Nome : " & Request.Form("txtNome") & "<br>"

'Busca do formulário o email digitado

Response.Write "Email: " & Request.Form("txtEmail") & "<br> </font>"

%>

<a href = "testeASP5.asp"> <p><p> Voltar </a>

<%else%>

<b> Cadastre o seu nome e email </b> <br> <br>

<form method=post action = testeASP5.asp >

<input type = hidden Name = hidEnviando value=ok >

Nome: <input type=text name = txtNome Size = 50> <br>

Email : <input type=text name = txtEmail Size = 50> <br>

<p> <input type = Submit Value = Enviar >

</form>

</font>

<%end if %>

</BODY>

</HTML> Ao clicar no link voltar, o arquivo será carregado novamente e como o campo

hidEnviando neste momento não existe mais, porque não estamos clicando no botão Enviar; ele montará o formulário novamente.

RECUPERANDO INFORMAÇÕES DA STRING DE PESQUISA DA URL

Outra maneira de passarmos informações para serem usadas durante a execução dos programas em ASP é pala string de pesquisa da URL, também conhecido como o método GET de envio de informações.

A string de pesquisa de uma URL começa depois do sinal de ? (interrogação) no endereço solicitado. Para recuperarmos estas informações usaremos o objeto Request, com a propriedade Querystring.

Neste teste daremos ao visitante duas opções de escolha. Ele poderá escolher informar sobre a opção de língua estrangeira que ele deseja ou o nível de aprendizado que se

37

ACTIVE SERVER PAGES

encontra. Se escolher a opção de língua estrangeira, ele será direcionado para uma página com um

parâmetro, passado pela string de pesquisa, informando que a parte do código que deve ser executada é a da língua estrangeira. Se escolher o nível de aprendizado, será passado o parâmetro indicando que deve ser executada a parte do código relacionada com o nível de aprendizado.

Observe o código:

<HTML>

<HEAD>

<TITLE>Objeto Request - Propriedade QueryString</TITLE>

</HEAD>

<BODY BGCOLOR=#ffffff>

<FONT FACE=verdana SIZE=2 COLOR=#003333>

<p>Escolha uma opção:</p>



<a href=”TesteASP7.asp?acao=opcao”>Opção de Lingua </a><br>

<a href=”TesteASP7.asp?acao=nivel”>Nivel de aprendizado </a>

</Font>

</BODY>

</HTML> Precisamos testar qual foi o valor passado pela string de pesquisa da URL para que

o arquivo monte o formulário correto. O código da página chamada é o seguinte:

<HTML>

<HEAD>

<TITLE>Formulários</TITLE>

</HEAD>

<BODY BGCOLOR=#FFFFFF>

<FONT FACE=verdana SIZE=2 COLOR=#003333>

<% 'Avalia a string de pesquisa passada na URL é a opcao

if Request.QueryString("acao")="opcao" then %>

<Form method=post action=TesteASP8.asp>

Digite seu nome e escolha a opção de lingua de sua preferência:

<br><br>

Nome: <input type=text name=nome size=30> <br> <br>

Opção de Língua: <br>

<input type=radio name=Lingua value=Inglês> Inglês

<input type=radio name=Lingua value=Espanhol> Espanhol

<input type=radio name=Lingua value=Frances> Francês

<br> <br>

<input type=submit value=Enviar>

</form>


38

ACTIVE SERVER PAGES

<% 'Avalia se astring de pesquisa passada na URL é nivel

elseif Request.QueryString("acao")="nivel" then %>

<form method=post action=TesteASP8.asp>

Digite seu nome e seu nível de aprendizagem no idioma: <br><br>


39

ACTIVE SERVER PAGES

Nome: <input type=text name=nome size=30><br><br>

Nível de aprendizagem no idioma: <br>

<input type=checkbox name=Escrita value=Ok> Escrita

<input type=checkbox name=Leitura value=Ok> Leitura

<input type=checkbox name=Conversa value=Ok> Conversação <br><br>

<input type=submit value=Enviar>

</form>

<%'Se nenhuma opção foi selecionada

else%>

<a href=TesteASP6.asp> Vá para o Teste9.asp </a>

<%end if%>

</font>

</BODY>

</HTML>

É importante ressaltarmos a importância de todos os nomes que foram utilizados nos formulários e strings de pesquisa da URL estarem exatamente como foram criados, ou seja, devemos respeitar as letras maiúsculas e minúsculas utilizadas nos nomes.

OBSERVAÇÃO

Se algum erro ocorrer na execução dos arquivos, você deve primeiro conferir a sintaxe de cada um dos comandos. Ver se não esqueceu uma aspa, ou digitou o nome de um objeto com letra maiúscula e era minúscula.

Agora precisamos criar um outro arquivo para que o action dos formulários acima funcionem.

AÇÕES DO FORMULÁRIO EM OUTRO ARQUIVO

Uma outra situação que encontramos muito nos sites atuais é as ações de um formulário chamando um outro arquivo para validar as informações. Como em uma página onde é necessário entrarmos com um usuário e senha, será chamado um arquivo externo para validar o usuário e a senha digitados, ou quando estamos fazendo compras em um site, assim

que digitamos a quantidade de produtos desejada e confirmamos a compra um programa é acionado para gravar as informações.

O arquivo testeASP7 está chamando o arquivo testeASP8. Note que os dois formulários chamam este arquivo. Como poderemos identificar qual foi o formulário que chamou o testeASP8 para que as informações passadas sejam corretas? Utilizaremos novamente o recurso do campo oculto ao usuário.

O primeiro formulário será chamado de A. Então acrescente a seguinte linha logo abaixo do primeiro FORM no arquivo do formulário:

<input type=hidden name=Formulario value=A>


40

ACTIVE SERVER PAGES

Abaixo do segundo FORM acrescente esta linha:

<input type=hidden name=Formulario value=B> Assim sendo, o campo do tipo oculto será enviado junto com os outros campos do

formulário pelo método POST e poderemos avalia-lo no arquivo que executa as ações, para mostrarmos os dados corretos ao usuário. O código que validará as informações passadas pelos formulários é o seguinte:

<HTML>

<HEAD>

<TITLE>Objeto Request - Busca de informações de outro formulário</TITLE>

</HEAD>

<BODY BGCOLOR=#FFFFFF>

<FONT FACE=verdana SIZE=2S COLOR=#003333>

<%

If Request.Form("Formulario")= "A" then

Response.Write "Informações enviadas: <br><br>"

Response.Write "Seu Nome: <b>" & Ucase (Request.Form("Nome")) & "</b></br>"

Response.Write "Opção de Lingua: " & Ucase (Request.Form("Lingua")) & "<br>"

Elseif Request.Form ("Formulario")="B" then

Response.Write "Informações enviadas: <br><br>"

Response.Write "Seu nome:<b> :" & Ucase (Request.Form ("Nome")) &"</b><br>"

If Request.Form ("Leitura")="Ok" then

Response.write "Leitura <br>"

End if

If Request.Form ("Escrita")="Ok" then

Response.Write "Escrita <br>"

End if

If Request.Form ("Conversa")="Ok" then

Response.Write "Conversação <br>"

End if

End if%>

<center><a href=testeASP6.asp> Voltar </a>

</center>

</Font>

</BODY>

</HTML>


41

ACTIVE SERVER PAGES

TESTE DO OBJETO APPLICATION

É o objeto responsável por armazenar e compartilhar valores, estados e propriedades de um grupo. Um exemplo seria armazenar o número total de clientes no site num instante. É também possível controlar erros causados por tentativas de alterações simultâneas de variáveis.

Aplicação é todo o conjunto de páginas ASP e HTML que formam o programa (site) como um todo. Com o objeto Application podemos criar variáveis que estão disponíveis em qualquer momento no site.

Declaração de variáveis Application:

Application(“nomedavariavel”) = conteudo

Para entendermos melhor a função deste objeto, vamos pensar no controle do número de usuários em um determinado momento no site e no número de usuários que já acessaram o site, e quando chegar ao acesso 500 direcionar o usuário para a página user500.asp . Poderíamos até utilizar um banco de dados para guardar essas informações, mas isso geraria um fluxo muito grande de processamento no servidor, porque a cada usuário que acesse o site ele deveria abrir o banco de dados, gravar as informações e fecha-lo novamente.

As variáveis Application ficam disponíveis durante todo o funcionamento do site, independente de qual usuário está conectado. Em qualquer momento e qualquer programa pode acessar as informações gravadas nestas variáveis. Elas só são perdidas caso o servidor que armazena a aplicação (site) for desligado.

Portanto, as variáveis que vão contar o número total de usuários e os usuários em um determinado momento devem ser iniciadas quando o primeiro usuário acessar o site. E caso seja necessário reiniciar o servidor Web, as informações armazenadas nas variáveis devem ser gravadas para serem recuperadas depois.

E a cada usuário que acessar uma página do site, um acesso deve ser contabilizado e quando sair deve ser retirado dos usuários atuais.

Para conseguirmos tal funcionamento das variáveis precisamos utilizar um arquivo especial do ASP, o arquivo global.asa. Este arquivo deve ser armazenado na raiz do site (no caso do PWS, só existirá um global.asa ativo, mesmo que existam subpastas), ele é executado automaticamente, como um autoexec do DOS. Em seu conteúdo temos apenas quatro rotinas, que só podem ser utilizadas dentro do global.asa, que são mostradas a seguir:

<script language=VBScript Runat=Server>

‘O comando acima define que o código será escrito na linguagem VBScript

‘e será executado no servidor

Sub Application_OnStart

‘Comandos que serão executados quando o primeiro usuário acessar

‘o aplicativo

End sub

Sub Application_OnEnd


42

ACTIVE SERVER PAGES

‘Comando que serão executado quando o servidor for desligado

End sub


43

ACTIVE SERVER PAGES

Sub Session_OnStart

‘Comandos executados quando um usuário entrar no site

End sub

Sub Session_OnEnd

‘Comandos executados quando o usuário sai do site

End sub

</script>

Vamos criar o arquivo global.asa que conta os usuários correntes e o total de usuários e direciona o usuário 500 para o arquivo user500.asp . O código será o seguinte:

<script language=VBScript Runat=Server>

‘O comando acima define que o código será escrito na linguagem VBSCript

‘e ‘será executado no servidor

Sub Application_OnStart

‘Vamos travar a variável para que mais de um processo não a acesse

‘simultaneamente

Application.Lock

Application(“UsuariosAtuais”) = 0

Application(“TotalUsuarios”) = 0

‘Destrava as variáveis

Application.Unlock

End sub

Sub Session_OnStart

Application.Lock

Application(“UsuariosAtuais”) = Application(“UsuariosAtuais”) + 1

Application(“TotalUsuarios”) = Application(“TotalUsuarios”) + 1

If Application(“TotalUsuarios”) = 500 then

Response.redirect(“user500.asp”)

End if

Application.Unlock

End sub

Sub Session_OnEnd

Application.Lock

Application(“UsuariosAtuais”) = Application(“UsuariosAtuais”) - 1

Application.Unlock

End sub

</script>

Esse arquivo deve estar dentro da pasta do site no servidor web, com o nome global.asa.

Abaixo um código para podermos visualizar o conteúdo das variáveis Application.

<HTML>


44

ACTIVE SERVER PAGES

<HEAD>


45

ACTIVE SERVER PAGES

<TITLE> Objeto APPLICATION - Buscando informações do Global.asa</TITLE>

</HEAD>

<BODY BGCOLOR="#FFFFFF" text="#000000">

<font face = "Verdana" Size =2>

<p> Visitantes atualmente no site:

<%= Application("UsuariosAtuais")%></p>

<p> Total de visitantes do site até o momento:

<%= Application("TotalUsuarios")%></p>

</BODY>

</HTML>

TESTANDO OBJETO SERVER

É o objeto responsável por permitir acesso e configuração de algumas funções e métodos ligados ao servidor.

Com este objeto podemos controlar o tempo que máximo para carregamento e execução de uma página, codificar textos com caracteres especias, mapear os arquivos físicos do site através do caminho virtual, a criação de instâncias de objetos Activex, a criação de arquivos de texto, etc..

É importante ressaltarmos que utilizaremos muito a criação de instâncias de objetos no site que criaremos a seguir, principalmente os relacionados a banco de dados.

O MÉTODO MAPPATH

Este método recupera, a partir do caminho virtual da aplicação, o caminho físico do arquivo específicado. Mas, não podem existir arquivos homônimos no mesmo domínio para que o método retorne corretamente o caminho físico.

Gostaria de saber o caminho físico do arquivo global.asa que criamos no recurso anterior. <HTML>

<HEAD>

<TITLE> Objeto SERVER - Mapeando o caminho dos arquivos</TITLE>

</HEAD>



<p> Caminho físico do arquivo global.asa:

<%= server.Mappath("global.asa")%></p>

</BODY>

</HTML> Este método é muito útil quando estamos criando uma aplicação em uma máquina

e depois será transportada para outra, assim evitamos o problema de nomes físicos diferentes nas máquinas gerarem erros em nosso programa.

46

ACTIVE SERVER PAGES

O MÉTODO CREATEOBJECT

Utilizamos o método Createobject quando necessitamos utilizar dentro de nossa aplicação um objeto que está armazenado no servidor. Assim estamos criando uma instância do objeto dentro do programa.

Mas o que é uma instância? É uma cópia de execução do objeto em questão. Por exemplo, você precisa acessar o banco de dados da empresa para mostrar a categoria dos produtos, ou acessar a tabela de departamentos da empresa para que o visitante do site mande um e-mail para o departamento correto. Também quando formos enviar e-mails pelo site, precisaremos criar uma instância do objeto do ISS que trata desse envio.

A sintaxe do ASP utilizada para instanciar uma objeto é:

Server.CreateObject(“ProgId”)

Onde o ProgId é como o objeto é conhecido dentro do servidor Web. Durante o nosso curso conheceremos alguns.

Para exemplificar como escreveríamos este código dentro do VBScript, vamos citar o objeto Dicitionary. Este objeto é uma maneira poderosa de armazenarmos informações associadas a uma chave que identifica o valor. Ao declararmos um objeto Dictionary em uma instância o comando seria o seguinte:

set Dicionario = server.createobject(“scripting.dictionary”) Na linha acima utilizamos a forma de declaração SET que é utilizada para variáveis

que receberão a instância de um objeto. Variáveis comuns devem ser declaradas apenas com a instrução DIM.

Vamos criar um exemplo que armazena as mensagens de um usuário no dicionário. Este dicionário será uma variável de sessão.

<HTML>

<HEAD>

<TITLE> Objeto SERVER - Criando um dicionário</TITLE>

</HEAD>



<form method="post" action="testeServer1.asp">



<input type="hidden" name="Enviando" value="Sim">

<p> Digite a sua mensagem: <input type="text" name="txtMensagem" size="50"> </p>

<p> <input type="submit" value="Armazenar">

</form>

<% Dim varMensagem 'Declaração de Variável

'Testa se o formulário foi enviado.


47

ACTIVE SERVER PAGES

'Apenas quando o visitante clica no botão submit que os campos

‘do formulário passam a existir.


48

ACTIVE SERVER PAGES

if request.form("Enviando") = "Sim" then

'Carrega a variável varMensagem com o que o usuário digitou

varMensagem = request.form("txtMensagem")

'Verifica se o dicionário já foi criado

If IsEmpty(Session("DicionarioUsuario")) then

'Se a variável for Empty, significa que ela não existe

‘e precisa ser criada

'Criação da variável que receberá uma instância do dicionário

Set Session("DicionarioUsuario") = server.createobject("scripting.dictionary")

end if

'Define uma variável para receber o dicionário

Dim MeuDicionario

set MeuDicionario = Session("DicionarioUsuario")

'Adiciona a mensagem no dicionário na posição indicada pelo número

‘atual de items mais um

MeuDicionario.Add cStr(MeuDicionario.count + 1), varMensagem

end if

%>

</BODY>

</HTML> Teste digitando algumas mensagens e vá armazenando. Agora precisamos

recuperar as mensagens armazenadas na variável Session. O objeto Dictionary tem a propriedade Count que nos informa quantos itens foram armazenados. O índice do dicionário começa de 0, então se temos dez (10) mensagens armazenadas o índice final será 9. Para recuperarmos as nove(9) mensagens será preciso criar um loop até o número final do índice, para isso usaremos um cálculo o valor do count – 1. Então, digite o código abaixo no bloco de notas:

<HTML>

<HEAD>

<TITLE> Objeto SERVER - Lendo um dicionário</TITLE>

</HEAD>



<% 'Verifica se o dicionário já foi criado

If IsEmpty(Session("DicionarioUsuario")) then

'Se a variável for Empty, significa que ela não existe e precisamos

‘informar ao visitante que nenhuma mensagem foi gravada

response.write "Nenhuma mensagem encontrada"

else

Dim MeuDicionario, aMensagens 'Declaração de Variável

'Define uma variável para receber o dicionário

set MeuDicionario = Session("DicionarioUsuario")


49

ACTIVE SERVER PAGES

'Cria um array para receber o conteúdo do dicionário

aMensagens = MeuDicionario.Items


50

ACTIVE SERVER PAGES

'O índice do dicionário inicia-se de zero. Vamos criar um loop para

‘ler o dicionário até o final

for i = 0 to Meudicionario.count - 1

‘O count retorna o total de itens começando de um, como o índice

‘para busca inicia-se de zero temos de subtrair um do número total de

‘itens

response.write "<br>" & aMensagens(i)

next

end if

%>

</BODY>

</HTML>


51

ACTIVE SERVER PAGES

CONHECENDO O SITE Como já conhecemos os objetos do ASP e os principais comando VBScript e

algumas funções nós já podemos conversar sobre o site da Livraria ClaraLuz que vamos produzir. Lembre-se que não nos atentamos ao designer do site, mas sim a sua funcionalidade e programação, para que seu aprendizado de ASP seja o mais proveitoso possível.

O objetivo do site da Livraria ClaraLuz é permitir aos clientes cadastrados fazer compras e downloads dos produtos da loja. Nós não faremos nenhum programa para a área administrativa do site, ou seja, todos os dados relacionados aos produtos serão inseridos diretamente nas tabelas do banco de dados.

O BANCO DE DADOS DO SITE

Então precisaremos desenvolver o banco de dados do site, que será em Access e acrescentar alguns dados.

Vamos analisar quais são as tabelas necessárias para o funcionamento do site. Como já informamos o objetivo do site é permitir que usuários cadastrados tenham acesso a compras dos produtos da loja e downloads. Se são apenas os cadastrados, precisaremos de uma tabela de Clientes e uma para Produtos. Neste contexto, acrescentamos que os produtos são divididos por categorias onde o cliente poderá selecionar os produtos que deseja pelo nome ou parte dele, e pela categoria do produto.

Como o cliente efetuará uma compra será gerado um pedido que contêm os produtos selecionados com seus respectivos preços e quantidades. Até aqui são necessárias mais três tabelas Categorias, Pedidos, e a tabela que relaciona o pedido com os produtos que será a ProdutosPedidos. Mas, como você já deve ter observado em sites de compras, enquanto não confirmamos a compra os produtos selecionados ficam armazenados em um carrinho de compras, que uma tabela de uso temporário, ou seja, apenas enquanto o cliente está no site é que ela armazena as compras. Então, mais uma tabela a do Carrinho.

No total temos seis tabelas que são: Clientes, Produtos, Categorias, Pedidos, ProdutosPedidos e Carrinho. A estrutura das tabelas é mostrada nas imagens a seguir:


52

ACTIVE SERVER PAGES

Após criar cada uma das tabelas é necessário fazermos os relacionamentos entre elas, a figura a seguir mostra como deverão ser estes relacionamentos:

Adicione as categorias que os produtos poderão estar na tabela de Categorias. Sugestões: Livro, CD, Brinquedo, Revista, Software, etc..


53

ACTIVE SERVER PAGES

Adicione alguns produtos, sugerimos que cadastre pelo menos três produtos para cada categoria. Nesta tabela temos o campo preço e o preçodesconto. O campo preço armazena o preço normal do produto e o precodesconto armazena o valor do produto já com desconto. Cadastre alguns produtos com precodesconto.

As outras tabelas serão alimentadas por meio da programação que estaremos fazendo nas páginas do site.

O MAPA DO SITE

Agora que já temos o banco de dados precisamos conhecer o funcionamento das páginas do site. Observe o esquema abaixo:

LIVRARIA CLARALUZ

A página Default.asp é a página inicial do site, o visitante não cadastrado tem acesso ao login e ao cadastro. O cliente cadastrado depois de se logar tem acesso ao restante do site. Como será feita a restrição do acesso a algumas páginas do site? Pelo arquivo restrito.asp que verificará se aquele cliente está logado.

Ao se logar o cliente poderá sair do site (logout.asp), fazer download dos livros (download.asp) e pesquisar (pesquisa.asp) os produtos para fazer as compras (compra.asp).

Em todas as páginas no site estarão visíveis as páginas login, topo e rodape. Todas as páginas que fizerem acesso ao banco de dados terão que conter o código do conecta, e todos terão o teste de restrição de acesso ao site. A página Default.asp terá a seguinte aparência:

CADASTRO.ASP DEFAULT.ASP

DEFAULTON.ASP VALIDALOG.ASP LOGOUT.ASP

DOWNLOAD.ASP

COMPRA.ASP

RODAPE.ASP TOPO.ASP LOGIN.ASP

CONECTA.ASP RESTRITO.ASP

PESQUISA.ASP

COMPRADOS.ASP

FINALIZA.ASP


54

ACTIVE SERVER PAGES


55

ACTIVE SERVER PAGES

56

ACTIVE SERVER PAGES

A DIRETIVA INCLUDE Como já dissemos em todas as páginas do site os arquivos topo, que é a parte do

cabeçalho da página; rodapé, que é a parte que garante a autoria do site; e o login, onde o visitante pode digitar seu login e senha e se conectar ao site; estarão sendo visualizados. Isto não quer dizer que tenhamos que copiar o código de cada um desses arquivos e colar no arquivo default. Como o ASP monta dinamicamente o HTML que será enviado ao cliente temos uma diretiva que insere o código de um arquivo em outro.

Usamos a diretiva Include quando temos códigos que se repetem em várias páginas. Em vez de digitar este código em cada uma das páginas, você cria um arquivo com o código padrão e usa a diretiva para incluir aquele arquivo em qualquer ponto do código que você está escrevendo.

Em quase todos os sites é utilizada uma barra de navegação, que normalmente aparecem em todas as páginas do site. Essa barra de navegação sempre sofre mudanças em virtude das atualizações do site, imagine que você tivesse que entrar em cada uma das páginas e alterar a barra de navegação, isto pode gerar erro e alguma página pode não ser alterada.

Usando a diretiva Include você cria um arquivo com o código que será inserido em um arquivo e usa a diretiva em cada um dos arquivos que receberá o código. Este código pode ser puro HTML ou funções que vão ser utilizadas pelo ASP.

A sintaxe da diretiva Include é a seguinte:

 Onde ext é a extensão do arquivo que será inserido, que pode ser asp, htm, js,

etc..

Para montarmos qualquer página do nosso site serão utilizados quatro arquivos: topo, login, o conteúdo e o rodapé. Onde o conteúdo (miolo) vai depender de cada página, ou seja, é variável.

A página default.asp é o miolo ou o conteúdo principal desta página. Mas na parte superior precisamos que apareça a logo da livraria, o banner e a barra de navegação. À esquerda do miolo aparecerá o login para o visitante entrar no site e efetuar suas compras e abaixo de tudo está o rodapé. Observe o esquema a seguir:

57

ACTIVE SERVER PAGES

Topo.asp

Login.asp Default.asp

Rodape.asp

Para melhor visualização de cada um dos códigos destes arquivos é melhor criarmos uma tabela para que cada parte fique colocada corretamente.

Como o arquivo topo é o primeiro a aparecer vamos começar a tabela neste arquivo. Abra o arquivo topo.asp e acrescente as linhas abaixo no final do código html. Lembre-se que este é o primeiro código que será inserido na página, então os comandos </html> e </body> devem ser apagados, se existirem.

<table border=0 width=100% cellspacing=5 cellpadding=5>

<tr> Salve o arquivo. Agora podemos voltar ao arquivo default e acrescentarmos a

diretiva Include, para inserirmos os três arquivos. O arquivo topo será o primeiro a ser inserido e só ele tem as tags iniciais do código HTML. A primeira linha do arquivo default.asp será:

 A partir deste ponto temos a segunda linha do esquema anterior, onde na coluna

da esquerda será incluído o arquivo login.asp e a direita o conteúdo do arquivo default. Logo depois da primeira linha do arquivo default.asp, que o código acima, insira as seguintes linhas:

<td valign=”top” width=20%></td>

<td width=80%> Depois de todo o código do default, ou seja, no final do arquivo digite o seguinte

código:

</td></tr>

 Salve o arquivo default.asp.


58

ACTIVE SERVER PAGES

O mesmo precisa ser feito nas páginas download.asp, pesquisa.asp, defaulton.asp, compra.asp, comprados.asp, cadastro.asp e finaliza.asp. Faça as mesmas alterações que você fez no arquivo default.asp neste outros arquivos.


59

ACTIVE SERVER PAGES

ACESSO AO BANCO DE DADOS Como o desenho do site está pronto precisamos começar a cadastrar os clientes

para que todo o processo de compra seja efetuado.

Sempre que formos gravar, ler, excluir ou alterar informações em uma base de dados, precisamos primeiro, acessar esses dados para que as ações sejam efetuadas.

Como a primeira tarefa do nosso site é o cadastro, ou seja, gravar informações no banco de dados, precisamos acessar o banco de dados. Depois precisaremos pesquisar os produtos cadastrados, gravar a quantidade comprada e atualizar o estoque quando a compra for efetuada, todos estes processos exigem conexão com o banco de dados.

A interface de comunicação dos dados com o ASP é o Activex Data Objects (ADO). O ADO é neutro quanto à linguagem de programação, ele pode ser acessado em VBScript, Jscript, Visual Basic e qualquer linguagem que trate de objetos.

O ADO também é neutro quanto ao provedor de acesso aos dados. Então podemos utilizar um provedor rápido, por exemplo OLE DB ou um provedor confortável como o ODBC. Mas o que é o OLE DB e o ODBC?

O OLE DB é um conjunto de interfaces de programação no nível de sistema que fornece acesso a diversas informações e fonte de dados localizadas em qualquer lugar. Usando este tipo de provedor o programado tem total controle sobre as interfaces, entretanto, o mesmo precisará ter algum conhecimento da linguagem C++.

O ODBC (Open Database Connectivity) fornece uma interface que permite aos aplicativos acessarem os dados de várias fontes de dados. É uma maneira aberta e neutra quanto ao fabricante de acessar dados que estão armazenados em formatos e bancos diferentes.

Agora, por que devemos utilizar ADO para acessar os dados? Porque é a maneira mais confortável de acessar qualquer banco de dados, os objetos ADO são fáceis de usar, ele fornece acesso de alta velocidade com overhead baixa de memória e footprint de disco pequeno. E quando estamos tratando de um servidor Web que atendo simultâneas requisições de usuários essas vantagens são muito importantes.

CONHECENDO OS OBJETOS ADO

O ADO tem objetos que nos ajudam a conectarmos a um banco de dados e manipularmos seus dados. Abaixo alistamos os principais objetos ADO.

Connection – representa a conexão com uma fonte de dados.

Recordset – é o conjunto de registros retornados de uma consulta ao banco e um cursor para aqueles registros.

Field – é o conteúdo de uma única coluna e informações sobre os dados. O objeto Recordset fornece a coleção Fields, que contêm todos objetos Field de um recordset.


60

ACTIVE SERVER PAGES

QUE TIPO DE PROVEDOR UTILIZAR ODBC OU OLE DB?

Agora que vamos fazer a nossa conexão com o banco de dados que criamos no Access para o site da livraria ClaraLuz precisamos definir se utilizaremos ODBC ou OLE DB para acessarmos os dados.

Quando utilizamos o servidor ODBC para termos acesso a um banco de dados, precisamos criar um Data Source Name (DSN), que é um nome para base de dados desejada. Para isso é necessário acessar o Painel de Controle do computador e acessar as fontes de dados ODBC. Na guia NFD de Sistema bastaria acrescentar um novo DSN para o banco de dados livraria. Qual a primeira desvantagem de utilizar o ODBC, se você trocar o seu aplicativo de máquina precisará configurar o ODBC novamente. Segunda desvantagem, a conexão é mais lenta, porque o ADO precisará passar pelo ODBC e pelo OLE DB para fazer a conexão, ou seja precisou utilizar duas camadas para se conectar ao banco. O esquema abaixo ilustra isso:

Quando utilizamos a conexão OLE DB estamos fazendo uma conexão direta com o banco de dados. Não é necessário fazer nenhum tipo de configuração no Painel de Controle e nem altera-lo quando trocar o aplicativo de computador. A principal vantagem que temos é que a conexão por ser direta é muito mais rápida. Para cada banco de dados a string de conexão OLE DB varia um pouco, por se tratar de modelos de banco de dados diferentes. O esquema abaixo ilustra como funciona a conexão OLE DB.

PASSOS PARA ACESSAR O BANCO DE DADOS

Para recuperarmos os dados de um banco de dados precisamos seguir os seguintes passos:

1. Abrir a conexão com o banco de dados.

2. Criar um recordset que fornece acesso aos campos de dados de cada registro.

ADO

OLE DB

ODBC

Banco de Dados

ADO

OLE DB

Banco de Dados


61

ACTIVE SERVER PAGES

3. Recuperar os dados do recordset.

4. Fechar o recordset e a conexão.

Seguindo estes passos sempre teremos resultados bons no acesso ao banco de dados.

Como precisaremos em vários momentos do nosso site acessar o banco de dados, abrir e fechar a conexão vamos criar um arquivo que apenas cria a conexão e a abre e fecha. O código abaixo deve ser digitado no bloco de notas:

<%

'Procedimentos utilizados no Site Livraria

'Variáveis

Dim StrCon 'String de conexão OLE DB

Dim Conexao 'Objeto de conexão

Set Conexao = Server.CreateObject("ADODB.CONNECTION")

conStr =”DRIVER={Microsoft Access Driver (*.mdb)}; DBQ=" & server.MapPath("bdLivrariaASP")

Sub AbreConexao()

Conexao.Open StrCon

End sub

Sub FechaConexao()

Conexao.close

end sub

%> Primeiro criamos duas variáveis uma para receber a string de conexão e uma outra

que seria a instância do objeto Connection do ADO, que é o representante da conexão com o banco.

Depois a instância do objeto Connection é armazenada na variável Conexao.

O script estabelece uma conexão física com o banco de dados, para isso precisamos definir essa conexão. Essas definições físicas da conexão são chamadas de String de conexão. Esta foi armazenada na variável StrCon. O valor da string, que deve vir entre aspas, por não ser um código ASP. Está é a string para Microsoft Access 2000.

Nesta string encontramos o tipo de banco, no nosso caso Access. O DBQ é arquivo mdb que estamos procurando. Aqui poderíamos digitar o caminho físico do banco de dados, por exemplo: p:\livrariaclaraluz\bdlivrariaASP. Mas encontraríamos o problema de migrar o aplicativo para outra máquina e qualquer mudança na unidade de disco teríamos que abrir este arquivo e alterar o caminho físico do banco. Usando o objeto Server com o método Mappath estamos pegando o caminho físico do site através do caminho virtual, independente de qual unidade o aplicativo esteja ele buscará o caminho correto.


62

ACTIVE SERVER PAGES

Você pode notar a presença do & (e comercial) entre a string OLE DB e o objeto Server do ASP. Lembre-se que este símbolo serve para concatenar, ou seja, unir um código ASP a um outro código como HTML, SQL, Strings de conexão e etc..


63

ACTIVE SERVER PAGES

A string para Microsoft Access 97 é a seguinte:

"DRIVER={Microsoft Access Driver (*.mdb)}; DBQ=" & server.MapPath("bdLivraria") & "; uid=sa; pwd=;"

E quando estamos utilizando Access 97 precisamos ainda acrescentar os atributos de usuário e senha, conforme o exemplo anterior.

Se estiver utilizando SQL Server 7 utilize a seguinte string de conexão:

"Provider=SQLOLEDB.1;Data Source=Curso;User Id=sa;Password=;Initial Catalog=Livraria; Connect Timeout=10"

Onde Data Source é o nome do servidor SQL Server 7, User ID o usuário de acesso ao banco de dados, Password a senha do usuário utilizado, Initial Catalog o nome do banco a ser acessado no servidor SQL Server e o Connect Timeout o tempo que uma conexão com o banco pode ficar ociosa.

Depois criamos uma sub (procedimento) chamada AbreConexao que abre a instância do objeto Connection com as definições da string.

Uma outra sub foi criada para fechar a conexão com o banco de dados.


64

ACTIVE SERVER PAGES

A LINGUAGEM SQL SQL é a Structured Query Language, ou a linguagem de consultas estruturada

usada para consultar, atualizar e gerenciar os bancos de dados relacionais. Usando SQL podemos acessar praticamente todos os bancos de dados existentes, bastando saber seus comandos básicos e a estrutura do banco de dados a ser acessado.

Com a linguagem SQL fazemos tudo dentro de um banco de dados. Para trabalharmos com os dados em um site conheceremos apenas os comandos de manipulação de dados. Por exemplo, será necessário validar se um usuário está cadastrado em nosso banco de dados para acessar algumas páginas como a de pesquisa, a de download e etc. Para isso precisamos acessar o banco de dados e procurar na tabela cliente se aquele login existe, esta é uma operação de seleção de dados que a linguagem SQL que faz.

Se o visitante não for cadastrado no site será necessário inseri-lo na tabela de clientes, também uma operação que é feita pela linguagem SQL. E assim por diante, se precisarmos atualizar um valor dentro de uma tabela, excluir algum registro, todas essas operações são efetuadas pela linguagem SQL, que é chamada linguagem universal de banco de dados.

Quando estamos trabalhando com um banco de dados podemos manipular os dados para:

• Selecionar (SELECT).

• Inserir (INSERT).

• Atualizar (UPDATE).

• Apagar (DELETE).

A partir de agora estaremos testando estes comandos da linguagem SQL para depois prosseguirmos com a criação do nosso site.

OBSERVAÇÃO

Todos os comandos SQL utilizados neste material referem-se ao Access, algumas particularidades são diferentes em outros bancos de dados como SQL Server e Oracle. Por isso, alguns comandos podem gerar erro se forem executados em outros bancos.

Dos quatro comandos citados acima o mais utilizado e o que tem mais particularidades é o comando SELECT, que será o nosso primeiro objeto de estudo da linguagem SQL.

O COMANDO SELECT

Este é o comando utilizado para selecionar os dados de uma tabela. Também conhecido como comando de leitura. A sintaxe do comando SELECT é:

SELECT campo, campo FROM tabela

65

ACTIVE SERVER PAGES

Para testar, vamos criar uma página que mostra todas as categorias de produtos cadastradas em nosso banco de dados:



<HTML>

<HEAD>

<TITLE> Categorias</TITLE></HEAD>


<center> <table border="1" width= "80%" cellpadding="0" cellspacing="0">

<tr align = "center">

<td colspan =2><font face="Verdana" Size="2"> Lista de Categorias </font></td>

</tr> <% 'Declaração de Variáveis

Dim ComandoSQL, rsCategorias

‘Executa o procedimento que está no arquivo conecta.asp

AbreConexao

'Comando SQL para buscar os campos da tabela categorias

ComandoSQL = "SELECT CodCategoria, NomeCategoria FROM Categorias"

'Execução do comando SQL para gerar um recordset

Set rsCategorias = conexao.execute(ComandoSQL)

'Mostrar todas as categorias até o fim do recordset

While not rsCategorias.EOF%>

<tr><td><font face="Verdana" Size="2">

<%=rsCategorias("CodCategoria")%> </font></td>

<td><font face="Verdana" Size="2">

<%=rsCategorias("NomeCategoria")%> </font></td></tr>

<% rsCategorias.MoveNext

Wend

rsCategorias.close

FechaConexao

'Liberando espaço de memória

Set rsCategorias = nothing %>

</BODY>

</HTML> Na linha ComandoSQL = "SELECT CodCategoria, NomeCategoria FROM Categorias"

armazenamos a instrução SQL para ser executada no banco.

Depois criamos a instância do recordset que recebeu o resultado do comando SQL executado no banco de dados, como a linha abaixo mostra:


O comando Execute faz parte do objeto ADO de acesso a banco de dados, ele executa o comando que estiver entre os parênteses. Como este comando retorna dados é


66

ACTIVE SERVER PAGES

necessário o uso de recordset, ou seja, sempre que utilizarmos o comando SELECT do SQL é necessário o uso de um recordset.


67

ACTIVE SERVER PAGES

O recordset possui duas propriedades que indicam o início e o final dos dados. BOF para início dos dados e EOF para final dos dados. No comando de repetição While testamos se não era o final do arquivo para que todos os dados fossem mostrados.

Para mostrar o conteúdo de cada um dos Fields (campos) dentro do Recordset utilizamos o comando <%=rsCategorias("NomeCategoria")%> que equivale ao objeto Response do ASP. Como você pode notar a sintaxe para exibir o conteúdo de um dos campos do recordset é:

NomedoRecordset(“NomedoCampo”)

Para que fosse possível movermos entre os registros retornados utilizamos um dos métodos do recordset, o MoveNext (porque estávamos com o ponteiro parado no primeiro registro). Temos também os seguintes métodos para movimentação entre os registros:

MoveFirst – vai para o primeiro registro do recordset. MoveNext – vai para o próximo registro. MovePrevious – vai para o registro anterior e MoveLast – vai para o último registro.

Quando o fim do recordset é atingido o While é encerrado e o recordset fechado, procedimento que não deve ser esquecido para não consumirmos recursos do servidor. Também a conexão com o banco foi fechada através da chamada do procedimento FechaConexao. E a variável utilizada como instância do recordset liberada da memória pelo comando Set rsCategorias = nothing.

A maioria dos nossos programas seguirá estes passos:

1. Inclusão do arquivo conecta para que a conexão com o banco de dados seja possível.

2. Declaração das variáveis.

3. Criação do comando SQL.

4. Execução do comando SQL no banco de dados, com o retorno de recordset ou não.

5. Mostrar os dados recuperados com o uso de uma estrutura de repetição.

6. O fechamento do recordset (quando este existir) e da conexão com o banco de dados.

7. E a liberação de variáveis de memória.

CRITÉRIOS DE SELEÇÃO PARA TEXTO

Muitas consultas que vamos fazer nos bancos de dados precisam de critérios para não retornar dados que não são úteis a quem está navegando pelo site, ou até mesmo dados

desnecessários naquele momento da consulta. Desta maneira, precisamos acrescentar a cláusula WHERE no comando SQL que for passado ao banco. A sintaxe é a seguinte:


68

ACTIVE SERVER PAGES

SELECT campo, campo FROM tabela WHERE critério


69

ACTIVE SERVER PAGES

Por exemplo, preciso selecionar os produtos que começam com uma determinada letra.


<HTML>

<HEAD>

<TITLE> Produtos</TITLE>

</HEAD>


<center>

<table border="1" width= "80%" cellpadding="0" cellspacing="0">


<td colspan =3><font face="Verdana" Size="2"> Lista de Produtos

</font></td></tr>

<tr>

<td><font face="Verdana" Size="2">Nome do Produto</font></td>

<td><font face="Verdana" Size="2">Estoque</font></td>

<td><font face="Verdana" Size="2">Preco</font></td></tr>

<% 'Declaração de Variáveis

Dim ComandoSQL, rsProdutos

AbreConexao

'Comando SQL para buscar os campos da tabela Produtos

ComandoSQL = "SELECT Nomeproduto, Estoque, preco FROM Produtos “

ComandoSQL = ComandoSQL & “ WHERE NomeProduto LIKE 'M%' "


Set rsProdutos = conexao.execute(ComandoSQL)

'Mostrar todas as produtos até o fim do recordset

While not rsProdutos.EOF%>

<tr>


<%=rsProdutos("NomeProduto")%> </font></td>


<%=rsProdutos("Estoque")%> </font></td>


<%=rsProdutos("Preco")%> </font></td></tr>

<% rsProdutos.MoveNext

Wend

rsProdutos.close

FechaConexao


Set rsProdutos = nothing %>

</BODY>

</HTML>


70

ACTIVE SERVER PAGES


71

ACTIVE SERVER PAGES

Na linha ComandoSQL = "SELECT Nomeproduto, Estoque, preco FROM Produtos WHERE NomeProduto LIKE 'M%' " armazenamos a instrução SQL para ser executada no banco. Note a presença da cláusula WHERE que indica: selecionar o nome do produto, o estoque e o preço da tabela Produtos quando o nome do produto for como (LIKE) ‘M%’. Toda vez que vamos comparar textos no SQL utilizamos aspas simples para separa o texto da comparação do comando SQL. O sinal % (percentagem) é o caractere curinga do SQL, o mesmo que o * faz no VBScript. Ele substitui qualquer letra que vier depois de M, ou seja, selecionará todos os produtos que começam com a letra M.

Lembre-se de colocar a letra inicial de um dos produtos que você cadastrou no banco de dados.

CRITÉRIOS DE SELEÇÃO COM VALORES

Também precisamos em vários momentos fazer seleções com critérios de valores. Agora quero selecionar todos os produtos que estejam com o estoque abaixo de 30.

Altere a linha do comando SQL para:

ComandoSQL = "SELECT Nomeproduto, Estoque, preco FROM Produtos WHERE Estoque < 30 "

ORDENANDO OS DADOS

Você pode notar que os produtos foram alistados fora da ordem alfabética. Para uma melhor leitura dos dados pelo visitante e conseqüentemente melhor satisfação podemos estar ordenando os dados. Basta acrescentar a cláusula ORDER BY. A sintaxe é a seguinte:

SELECT campo, campo FROM tabela WHERE critério ORDER BY campo

A cláusula ORDER BY pode ser usado também quando o WHERE não existir no comando SQL. Vamos ordenar os dados mostrados no arquivo anterior. Modifique a linha do comando SQL para:

ComandoSQL = "SELECT Nomeproduto, Estoque, preco FROM Produtos WHERE Estoque < 30 " ComandoSQL = ComandoSQL & " ORDER BY NomeProduto"

Como a linha já estava muito grande é muito comum utilizarmos a concatenação do conteúdo da variável, como você pode ver nas linhas de código acima. Então é a variável que recebe ela mesma concatenada (&) com a string restante.

Se quiser colocar em ordem decrescente basta acrescentar DESC. A sintaxe é a seguinte:

SELECT campo, campo FROM tabela WHERE critério ORDER BY campo DESC


72

ACTIVE SERVER PAGES

CALCULANDO VALORES

Em muitas ocasiões precisamos calcular totais na seleção dos dados. Por exemplo, preciso saber a quantidade total de produtos em cada categoria. Também saber a média de preços dos produtos, etc..

Abaixo alistamos alguns comandos de cálculo que podem ser utilizados na linguagem SQL.

• COUNT – Conta o número de registros.

• SUM – Soma o conteúdo de campos numéricos.

• AVG – Calcula a média de campos numéricos.

• MAX – Encontra o maior valor dentro de um campo numérico.

• MIN – Encontra o menor valor dentro de um campo numérico.

Vamos fazer um programa que encontra o preço mais caro do nosso estoque.


<HTML>

<HEAD>

<TITLE> Produtos</TITLE>

</HEAD>


<center>



<td colspan =3><font face="Verdana" Size="2"> Produto mais caro</font></td>

</tr>



AbreConexao

'Comando SQL para buscar o maior preço da tabela Produtos

ComandoSQL = "SELECT MAX(preco) AS MaiorPreco FROM Produtos"



'Mostrar o maior preço até o fim do recordset


<tr>

<td align="center"><font face="Verdana" Size="2">

<%= formatnumber(rsProdutos("Maiorpreco"),2)%> </font>


73

ACTIVE SERVER PAGES

</td> </tr>


74

ACTIVE SERVER PAGES


Wend

rsProdutos.close

FechaConexao


Set rsProdutos = nothing

%>

</BODY>

</HTML>

Na linha ComandoSQL = "SELECT MAX(preco) AS MaiorPreco FROM Produtos" utilizamos um recurso para nomear o campo calculado. A cláusula AS define um nome que pode ser referenciado na hora de mostrarmos o conteúdo do campo calculado. Este recurso pode ser utilizado para qualquer tipo de campo.

Na linha <%= formatnumber(rsProdutos("Maiorpreco"),2)%> utilizamos uma função do VBScript que formata os números com a quantidade de casas decimais especificadas pelo programador. A sintaxe da função é a seguinte:

Formatnumber(valor,casas decimais)

AGRUPANDO VALORES

Quando precisamos calcular totais em grupos utilizamos a cláusula GROUP BY da linguagem SQL.

Vamos criar um programa que calcule o total de produtos por categoria. Digite o código abaixo no bloco de notas:


<HTML>

<HEAD><TITLE> Produtos</TITLE></HEAD>


<center>



<td colspan =2><font face="Verdana" Size="2">

Total de Produtos por Categoria</font></td></tr>

<tr align="center">

<td><font face="Verdana" Size="2"> Categoria</font></td>

<td><font face="Verdana" Size="2"> Quantidade Total em Estoque </font></td>

</tr>



AbreConexao

'Comando SQL para buscar os campos da tabela Categorias e calcular o


75

ACTIVE SERVER PAGES

‘estoque


76

ACTIVE SERVER PAGES

ComandoSQL = "SELECT NomeCategoria, SUM(estoque) AS TotEstoque “

ComandoSQL = ComandoSQL & “ FROM Produtos, Categorias "

ComandoSQL = ComandoSQL & " WHERE Produtos.codCategoria=Categorias.CodCategoria “

ComandoSQL = ComandoSQL & " GROUP BY NomeCategoria "



'Mostrar todas as categorias até o fim do recordset


<tr>


<%= rsProdutos("NomeCategoria")%> </font></td>


<%= formatnumber(rsProdutos("totEstoque"),2)%> </font></td></tr>


Wend

rsProdutos.close

FechaConexao


Set rsProdutos = nothing

%>

</BODY>

</HTML> Na linha do SELECT criada neste programa utilizamos a cláusula GROUP BY para

agrupar os valores pelo Nome da Categoria. No resultado do programa veremos qual a quantidade de produtos em estoque para cada uma das categorias cadastradas em nosso banco de dados.

O COMANDO INSERT

Este é o comando utilizado para inserir dados em uma tabela. Também conhecido como comando de gravação. A sintaxe do comando INSERT é:

INSERT INTO tabela (campo, campo, campo) VALUES (valores,valores, valores)

Para testarmos vamos criar um programa que insere uma nova categoria na tabela de categorias e depois mostra todos os valores armazenados nesta tabela. A seguir o exemplo de um código para inserção em uma tabela:

‘Comando SQL para inserir a nova Categoria

ComandoSQL = "INSERT INTO Categorias (NomeCategoria) VALUES ('Brinquedo')"

'O comando insert não gera retorno, então não é necessário uso do recordset


77

ACTIVE SERVER PAGES

conexao.execute(ComandoSQL)


78

ACTIVE SERVER PAGES

O COMANDO UPDATE

Este é o comando utilizado para alterar dados em uma tabela. Também conhecido como comando de gravação. A sintaxe do comando UPDATE é:

UPDATE tabela SET campo = valor WHERE critério Utilizaremos este comando quando formos por exemplo alterar o estoque de um

produto depois de uma compra, ou quando um cliente alterar o seu cadastro, etc..

O COMANDO DELETE

Este é o comando utilizado para excluir dados em uma tabela. Também conhecido como comando de exclusão. A sintaxe do comando DELETE é:

DELETE tabela WHERE critério Utilizaremos este comando quando for preciso excluir um dos registros de uma

tabela.


79

ACTIVE SERVER PAGES

CRIANDO A PÁGINA DE CADASTRO A página cadastro servirá para o cliente informar seus dados pessoais para que

possamos efetuar as suas compras.

O nosso objetivo nesta página é reunir todos os conhecimentos adquiridos até o momento com uma aplicação prática do ASP. Está página fará testes de validação dos dados digitados e armazenará mensagens de erro em um dicionário. E se o cliente preencher todos os dados corretamente será inserido na tabela de Clientes.

Suponhamos que já temos o formulário que será preenchido pelo cliente montado. O que acontecerá quando o cliente clicar no botão Enviar?

Os dados com asterisco devem ser validados, se houver algum erro a mensagem será armazenada em um dicionário e depois que todas as validações forem feitas testaremos se alguma mensagem foi gravada no dicionário. Se houver alguma mensagem gravada mostraremos as mensagens e o formulário novamente. Se não houver nenhuma mensagem armazenada, vamos inserir os dados na tabela clientes e mostrar uma mensagem para o cliente indicando que o cadastro foi efetuado com sucesso.

Primeiro nós faremos as validações. Todos os campos, exceto o lembrete devem ser preenchidos, este o primeiro teste.

Na senha testar se a senha e a confirmação foram digitadas corretamente. No estado precisamos saber se o valor do campo é igual a selecione.

E no e-mail além de testarmos se foi preenchido precisamos testar se o @ foi digitado, porque este é o identificador de um e-mail correto.

O próprio arquivo cadastro será executado quando o cliente clicar no botão Enviar. Como saberemos que o cliente clicou no botão Enviar? Como já vimos anteriormente basta criarmos um campo oculto dentro do formulário.

Por que é necessário este campo? Porque as validações só podem ser executadas se o cliente tiver clicado no botão Enviar.

Então vamos acrescentar a ação em nosso formulário. No action do comando Form coloque o arquivo cadastro.asp, conforme a linha abaixo.

<form method=post action=”cadastro.asp”> Depois deste comando acrescente o comando input para criar o campo oculto que

testaremos para saber se o cliente clicou no botão Enviar. A linha a seguir mostra o comando a ser acrescentado:

<input type=”hidden” name=”enviando” value=”sim”>

Como este arquivo acessará o banco de dados vamos inserir o arquivo conecta. Basta colocar a diretiva include, conforme a linha a seguir, no início do arquivo.



80

ACTIVE SERVER PAGES

O primeiro passo é testar se o cliente está enviando o arquivo, se o teste for verdadeiro fazer as validações.

No caso da validação do e-mail, isso poderá acontecer inúmeras vezes no site, o ideal é criarmos uma função que possa ser acessada por qualquer arquivo. Vamos criar esta função dentro do arquivo conecta.asp, abra este arquivo e acrescente o seguinte código:

Function validaEmail(email)

Dim totCaracteres,Caractere

totCaracteres = Len(email)

for I = 1 to totCaracteres

Caractere = Mid(email,I,1)

if Caractere = "@" then

validaEmail = "Verdadeiro"

exit for

else

validaEmail = "Falso"

end if

next

end function Esta função recebe o e-mail, conta o número de caracteres neste e-mail para que

possamos passar caractere por caractere para testar se o @ foi digitado. Em um loop usando for até o total de caracteres, usamos a função MID para pegar cada caractere na posição indicada pelo índice do FOR, depois testamos se este caractere é o @. Se o teste for verdadeiro a função retornará Verdadeiro e sairá do FOR, ou seja, não é mais necessário testar. Se o teste for falso a função retornará Falso.

No programa do cadastro criaremos uma variável para receber o resultado da função e testaremos se a mesma é falsa para gravarmos a mensagem de erro.

<font face=verdana size=2>

<p align=center>Preencha o formulário abaixo:<br>

Campos com * são de preenchimento obrigatório.</p>

<%

if Request.Form("enviando") = "sim" then

Dim Dicionario 'Mensagens de erro

Dim i 'Contador de erros

Dim comandoSql 'Comando SQL a ser executado

Dim Rs 'Resultado da consulta - registro

Dim Vet 'Vetor de erros

set Dicionario = CreateObject("scripting.dictionary")

i = 0

if Request.Form("nome")="" then

Dicionario.add i, "Preencha o Nome!"

i = i+1

end if


81

ACTIVE SERVER PAGES

if Request.Form("email")="" then


82

ACTIVE SERVER PAGES

Dicionario.add i, "Preencha o E-mail!"

i = i+1

end if

Email = ValidaEmail(request.form("email"))

if Email = "Falso" then

Dicionario.add i, "E-mail preenchido incorretamente!"

i = i+1

end if

AbreConexao

'Comando SQL para testar se o login digitado pelo cliente já existe

comandoSql = "Select login FROM Clientes WHERE login = “

comandoSql = ComandoSQL & ”'" & Request.Form("login") &"'"

set RS = Conexao.execute(comandoSql)

if not Rs.Eof then

Dicionario.add i, "Login já cadastrado!"

i = i+1

end if

FechaConexao

if Request.Form("senha")="" then

Dicionario.add i, "Preencha a Senha!"

i = i+1

end if

if Request.Form("confirma")="" then

Dicionario.add i, "Preencha a confirmação da Senha!"

i = i+1

end if

if Request.Form("confirma")<> Request.Form("senha") then

Dicionario.add i, "A senha e a confirmação estão diferentes!"

i = i+1

end if

if Request.Form("endereco")="" then

Dicionario.add i, "Preencha o Endereço!"

i = i+1

end if

if Request.Form("Cidade")="" then

Dicionario.add i, "Preencha a Cidade!"

i = i+1

end if

if Request.Form("estado")="UF" then

Dicionario.add i, "Preencha o Estado!"


83

ACTIVE SERVER PAGES

i = i+1

end if


84

ACTIVE SERVER PAGES

Vet = Dicionario.items

if Dicionario.Count<>0 then

Response.Write "<center><font face=verdana size=1 color=red>"

Response.Write "O(s) seguintes dado(s) está(ão) incorreto(s)<br>"

for i = 0 to Dicionario.Count - 1

Response.Write vet(i) & "<br>"

next

Response.Write "</font></center>"

end if

end if

%> Se você testar o código até aqui notará que os campos que estavam corretos foram

perdidos e o cliente teve que digitá-los novamente. Isso não é muito agradável. Como faremos para que os campos voltem preenchidos quando acontecer o erro?

Nos campos do tipo Text bastar acrescentar o atributo Value igual ao que o ASP conseguiu recuperar quando o cliente clicou no botão Enviar. A seguir temos os campos de texto com o acréscimo do atributo, o que está em negrito deve ser acrescentado ao código:

<tr><td><font face=verdana size=2> Nome:* </font></td>

<td><input type=text name=nome size=60 maxlength=60

value = "<%=request.form("nome")%>" > </td></tr>

<tr><td><font face=verdana size=2>Login:*</font></td>

<td><input type=text name=login size=20 maxlength=20

value="<%=request.form("login")%>"></td></tr>

<tr><td><font face=verdana size=2> Senha:*</font></td>

<td><input type=password name=senha size=20 maxlength=10

value="<%=request.form("senha")%>"></td></tr>

<tr><td><font face=verdana size=2> Confirmação:*</font></td>

<td><input type=password name=confirma size=20 maxlength=10

value="<%=request.form("confirma")%>"></td></tr>

<tr><td><font face=verdana size=2> Lembrete:</font></td>

<td><input type=text name=lembrete size=40 maxlength=40

value="<%=request.form("lembrete")%>"></td></tr>

<tr><td><font face=verdana size=2> Endereço:*</font></td>

<td><input type=text name=endereco size=60 maxlength=60

value="<%=request.form("endereco")%>"></td></tr>

<tr><td><font face=verdana size=2> Cidade:*</font></td>

<td><input type=text name=cidade size=30 maxlength=40

value="<%=request.form("cidade")%>"></td></tr>

<tr><td><font face=verdana size=2> Estado:*</font></td>

<td><select name=estado>

<option selected value=UF>Selecione</option>


85

ACTIVE SERVER PAGES

<option value=AM>Amazonas</option>


86

ACTIVE SERVER PAGES

<option value=AC>Acre</option>

<option value=BA>Bahia</option>

<option value=MG>Minas Gerais</option>

<option value=RJ>Rio de Janeiro</option>

<option value=SP>São Paulo</option>

<option value=RS>Rio Grande do Sul</option>

<option value=MT>Mato Grosso</option>

<option value=TO>Tocantins</option>

<option value=PE>Pernambuco</option>

<option value=RN>Rio Grande do Norte</option>

<option value=ES>Espírito Santo</option>

<option value=AP>Amapá</option>

<option value=RO>Rondônia</option>

<option value=RR>Roraima</option> </select></td></tr>

<tr><td><font face=verdana size=2>Sexo:*</font></td>

<td><font face=verdana size=2>

<input type="radio" value="F" name="Sexo"> Feminino

<input type="radio" value="M" checked name="Sexo">

Masculino</font></td></tr>

<tr><td> <font face=verdana size=2> E-mail:*</font></td>

<td><input type="text" name="email" size="59"

value="<%=request.form("email")%>"></td></tr> Agora precisamos também fazer com que o estado volte com o valor selecionado

pelo cliente antes do erro. Precisamos testar se aquele foi o valor selecionado, se for verdadeiro o teste então vamos colocar o campo como selecionado.

Abaixo o código com as alterações, o que está em negrito deve ser acrescentado ao código:

<tr><td><font face=verdana size=2> Estado:*</font></td>

<td><select name=estado>

<option <% if request.form("estado") = "UF" then %>selected <%end if%>

value=UF> Selecione</option>

<option <% if request.form("estado") = "AM" then %>selected <%end if%>

value=AM> Amazonas</option>

<option <% if request.form("estado") = "AC" then %>selected <%end if%>

value=AC> Acre</option>

<option <% if request.form("estado") = "BA" then %>selected <%end if%>

value=BA> Bahia</option>

<option <% if request.form("estado") = "MG" then %>selected <%end if%>

value=MG> Minas Gerais</option>

<option <% if request.form("estado") = "RJ" then %>selected <%end if%>

value=RJ> Rio de Janeiro</option>


87

ACTIVE SERVER PAGES

<option <% if request.form("estado") = "SP" then %>selected <%end if%>


88

ACTIVE SERVER PAGES

value=SP> São Paulo</option>

<option <% if request.form("estado") = "RS" then %>selected <%end if%>

value=RS> Rio Grande do Sul</option>

<option <% if request.form("estado") = "MT" then %>selected <%end if%>

value=MT> Mato Grosso</option>

<option <% if request.form("estado") = "TO" then %>selected <%end if%>

value=TO> Tocantins</option>

<option <% if request.form("estado") = "PE" then %>selected <%end if%>

value=PE> Pernambuco</option>

<option <% if request.form("estado") = "RN" then %>selected <%end if%>

value=RN> Rio Grande do Norte</option>

<option <% if request.form("estado") = "ES" then %>selected <%end if%>

value=ES> Espírito Santo</option>

<option <% if request.form("estado") = "AP" then %>selected <%end if%>

value=AP> Amapá</option>

<option <% if request.form("estado") = "RO" then %>selected <%end if%>

value=RO> Rondônia</option>

<option <% if request.form("estado") = "RR" then %>selected <%end if%>

value=RR> Roraima</option> </select></td></tr> O campo sexo também precisa voltar com o valor selecionado pelo cliente antes do

erro. Precisamos testar se aquele foi o valor selecionado, se for verdadeiro o teste então vamos colocar o campo como selecionado.

Abaixo o código com as alterações, o que está em negrito deve ser acrescentado ao código:

<tr><td><font face=verdana size=2>Sexo:*</font></td>


<%if Request.Form("Sexo") = "M" then %>

<td width="80%">

<input type="radio" name="Sexo" value="F">

<font face="Tahoma" size="2">Feminino</font>

<input type="radio" value="M" name="Sexo" checked>

<font face="Tahoma" size="2">Masculino</font></td>

<% elseif Request.Form("Sexo") = "F" then%>

<td width="80%">

<input type="radio" name="Sexo" value="F" checked>


<input type="radio" value="M" name="Sexo" >


<% else %>

<td width="80%">

<input type="radio" name="Sexo" value="F">


89

ACTIVE SERVER PAGES


<input type="radio" value="M" name="Sexo">


90

ACTIVE SERVER PAGES


<% end if%> Agora que todas as validações estão prontas e os valores preenchidos

anteriormente já estão sendo mostrados, precisamos programar para que se não acontecer nenhum erro gravar os dados no banco de dados e mostrar uma mensagem para o cliente informando que os dados foram armazenados com sucesso.

A condição para gravar os dados é não ter nenhuma mensagem de erro armazenada. Nós já estamos testando se aconteceu algum erro, basta colocarmos o ELSE e os comandos para inserir os dados na tabela.

Abaixo temos o código com as modificações que você precisa fazer, o que está em negrito deve ser acrescentado ao código existente:

if Dicionario.Count<>0 then

Response.Write "<center><font face=verdana size=1 color=red>"

Response.Write "O(s) seguintes dado(s) está(ão) incorreto(s)<br>"

for i = 0 to Dicionario.Count - 1

Response.Write vet(i) & "<br>"

next

Response.Write "</font></center>"

else 'caso não encontrou erro

AbreConexao

ComandoSql = "INSERT INTO Clientes(nomecliente, login, email, senha, “

ComandoSql = ComandoSql & “lembrete, endercliente, cidade, estado, “

ComandoSql = ComandoSql & “ dtcadastro) "

ComandoSql = ComandoSql & "VALUES('" & Request.Form("nome") & "','"

ComandoSql = ComandoSql & Request.Form("login") & "','"

ComandoSql = ComandoSql & Request.Form("email") &"','"

ComandoSql = ComandoSql & Request.Form("senha") &"','"

ComandoSql = ComandoSql & Request.Form("lembrete") &"','"

ComandoSql = ComandoSql & Request.Form("endereco") &"','"

ComandoSql = ComandoSql & Request.Form("cidade") &"','"

ComandoSql = ComandoSql & Request.Form("estado") &"','" & now() &"')"

conexao.execute(comandoSql)

end if Se fossemos escrever o comando SQL em uma única linha ele ficaria assim

ComandoSql = "INSERT INTO Clientes(nomecliente, login, email, senha, lembrete, endercliente, cidade, estado, dtcadastro) VALUES('" & Request.Form("nome") & "','" Request.Form("login") &"','" &Request.Form("email")&"','" & Request.Form("senha") & "','" & Request.Form("lembrete") &"','" & Request.Form("endereco") &"','" & Request.Form("cidade") &"','" & Request.Form("estado") &"','" & now() &"')"

A princípio este comando parece confuso por causa de tantas aspas duplas e simples. Vamos tentar relembrar algumas regras de ASP e SQL.


91

ACTIVE SERVER PAGES

No ASP tudo que não seja código ASP ou VBScript de ser escrito entre aspas duplas, como aconteceu no comando acima. Quando preciso juntar um código não ASP com um código ASP tenho que fechar as aspas do código que não é ASP usar o símbolo concatenador (&) digitar o código ASP, usar o símbolo concatenador se o código não ASP for continuar e abrir as aspas duplas novamente e fecha-las quando chegarmos ao final do código não ASP.

Outra regra que não podemos nos esquecer é que na linguagem SQL todo valor do tipo String deve ser passado entre aspas simples. No caso do nosso comando INSERT todos os valores que devem ser acrescentados na tabela clientes são do tipo String, inclusive a data. Então, as aspas simples devem ser abertas antes do valor e fechadas depois dele. Foi o que aconteceu no nosso comando SQL.

Depois que os dados foram inseridos não precisamos mostrar o formulário mais mas sim a mensagem que o cadastro foi efetuado com sucesso. A única maneira de controlarmos este processo é criarmos uma variável auxiliar, onde o valor dela será modificado quando os dados forem inseridos e para que o formulário seja mostrado o valor dessa variável deve ser testado.

Vamos criar esta variável antes do IF que testa se o formulário foi enviado, bem no início do arquivo. Acrescente o seguinte código.

Dim Cadastrado

Cadastrado = False Depois de inserir os dados na tabela a conexão é fechada, então o valor de

Cadastrado deve ser modificado para True. Acrescente o seguinte código depois do comando FechaConexao encontrado após o comando INSERT.

Cadastrado = True Agora temos que testar o conteúdo desta variável para mostrarmos o formulário ou

a mensagem de cadastrado com sucesso. Logo após o segundo ENF IF que está depois do cadastrado = true acrescente o seguinte código, só o que está em negrito deve ser acrescentado:

Cadastrado = True

end if

end if

if Cadastrado = False then

%> No final do arquivo devemos acrescentar o ELSE que receberá o código a ser

visualizado pelo cliente quando o cadastro for efetuado com sucesso. Logo depois do comando </FORM> no final do arquivo acrescente o seguinte código:

</form>

<% else 'significa que Efetuado=true %>

<center> <br><br>

<font face=verdana size=2><b>

<% =Request.Form("nome")%> </b>, seu cadastro foi efetuado com sucesso!

</center></font>

<% end if %>


92

ACTIVE SERVER PAGES

CRIANDO A PÁGINA DE LOGIN A página login serve para que o cliente cadastrado tenha acesso a promoções

especiais e possa efetuar suas compras, fazer downloads e etc..

Esta página servirá para aplicarmos mais alguns dos conhecimentos adquiridos até o momento. Trabalharemos com o objeto Session e com acesso ao banco de dados.

Suponhamos que já temos o formulário que será preenchido pelo cliente montado. Quando o cliente clicar no botão OK precisamos procurar o login e a senha digitados dentro do banco de dados, se encontrarmos o cliente será direcionado para a página com as promoções especiais, se não encontrarmos o cliente no banco de dados mostraremos uma mensagem solicitando que ele digite novamente o login e a senha.

Qual será o arquivo executado quando o cliente clicar no botão OK? Será o arquivo de validação que em nossa apostila chamaremos de validalogin.asp. Altere o action do formulário do arquivo login para valida login.asp conforme o código a seguir:

<form method="post" action="validalogin.asp">

Salve o arquivo Login e crie um arquivo novo.

O arquivo validalogin acessará o banco de dados e fará uma seleção na tabela clientes com os dados digitados pelo visitante. Se estes dados forem encontrados, o código, o nome e o email do cliente serão armazenados em variáveis de sessão para serem usados em qualquer ponto do site. Este arquivo contém apenas código ASP.


<% AbreConexao

Dim Sql 'Comando SQL

Dim RS 'Recordset para receber o resultado do select

Sql = "Select * FROM Clientes WHERE login = '" & Request.Form("login")

Sql = Sql & "' AND senha='" & Request.Form("senha") & "' "

set Rs = conexao.execute(Sql)

if not rs.eof then 'encontrou o registro procurado

session("CodCliente") = RS("CodCliente")

Session("NomeCliente") = RS("nomeCliente")

Session("Email") = RS("email")

Response.Redirect("defaulton.asp")

else

Response.Redirect("default.asp")

end if

FechaConexao

%> Ao logar-se o usuário será direcionado para a página defaulton.asp, mas nada

modificou-se na página login. O login e a senha continuam sendo solicitados, o certo seria ao


93

ACTIVE SERVER PAGES

conectar-se mostrar uma mensagem e darmos uma opção para encerrar a sessão. Então precisamos saber se o cliente está logado ou não. Como sabemos isso?


94

ACTIVE SERVER PAGES

Através da variável de sessão Codcliente. Se ela estiver vazia é porque a busca no banco não foi bem sucedida, se estiver com algum valor é porque o cliente digitou um login e uma senha válidos.

Então abra o arquivo login e faça as seguintes alterações:

<% if session("CodCliente") <> "" then

'usuário logou no site com e-mail e senha corretos %>


<b><center>

Você pode agora adquirir os livros que mais deseja! </b>

<br><a href="logout.asp"><img border="0" src="images/encerrar.gif">

</a><br>

</center>

<% else

if session("CodCliente") = "" then %>


<b><center>

Login Inválido! Tente Novamente! </b>

</center>

<%else%>


<b>

Já é cadastrado? Digite seu login e senha </b>

<%end if%>

<form method="post" action="validalogin.asp">

<table border=0>

<tr>

<td><font face=verdana size=2>Login </font></td>

<td><input type=text name=login size=15></td></tr>

<tr>

<td><font face=verdana size=2>Senha </font></td>

<td><input type=password name=senha size=15></td></tr>

<tr><td colspan=2 align=center>

<input border="0" src="images/ok.gif" name="I1" type="image"></td></tr>

</table></form></font>

<%end if%> O que fizemos neste código? Primeiro testamos se a variável de sessão codcliente

estava diferente de vazia, se o teste for verdadeiro é mostrada um mensagem e um botão para encerrar a sessão, ou seja, sair da área restrita aos clientes cadastrados.


95

ACTIVE SERVER PAGES

Quando esta variável não é diferente de vazio precisamos testar outras duas situações que podem ocorrer com o cliente, se ele digitou o login incorreto ou se é a primeira vez que ele está acessando o site, para que sejam mostradas mensagens corretas. Porque se o login está incorreto uma mensagem é mostrada se é a primeira vez que está acessando o site outra mensagem é mostrada. E o formulário deve ser mostrado nas duas situações, por isso o IF apenas nas mensagens.

O ARQUIVO LOGOUT.ASP

Mas se você clicar no botão Encerrar Seção o Internet Explorer retornará o erro que não foi possível encontrar o arquivo. Então vamos criar o arquivo para encerrar a sessão que em nosso exemplo se chamará logout.asp.

Este arquivo finalizará a seção e o usuário será direcionado para a página principal do site. O código a seguir deve ser digitado em um arquivo novo do bloco de notas:

<% session.Abandon

Response.Redirect("default.asp") %> Teste digitando o login de um cliente que você cadastrou e a senha, se tiver dúvida

consulte o banco de dados. Depois que você for direcionado para a página defaulton.asp clique no botão Encerrar seção e note que você será solicitado a digitar login e senha na tela inicial do site.

O ARQUIVO DEFAULTON.ASP

Quando logamos com um cliente cadastrado estamos sendo direcionados para a página defaulton.asp, nesta temos um Olá, onde depois dele deveria se mostrado o nome do cliente. Para isso vamos utilizar a variável de sessão NomeCliente.

Olá <%= Session("NomeCliente")%>, Ao digitar o login de um cliente que você cadastrou e a senha, você será

direcionado para a página defaulton.asp observe que o nome do cliente está sendo mostrado.

96

ACTIVE SERVER PAGES

CRIANDO A PÁGINA DE RESTRIÇÃO Essa página servirá para restringir o acesso de usuários não logados à partes do

site que só podem ser usadas por clientes cadastrados e que tenha efetuado login correto.

Clique no botão Encerrar seção e tente acessar a página de downloads. Mesmo não estando conectado como um usuário você acessou esta página. Como havíamos dito no início do curso, essa página e a página de pesquisa que estão na barra de navegação do site só estão disponíveis para clientes cadastrados e que se logaram no site. Então precisamos avaliar se o cliente se logou ou não ao site para que o conteúdo da página seja mostrado.

Vamos criar um arquivo novo que conterá o código para prevenir que usuários que não tenham permissão acessem certas páginas do site. O código é o seguinte, digite-o no bloco de notas:

<%if Session("CodCliente")="" or Session("CodCliente") = False then %>



<table border=0 width=100% height=65% cellspacing=5 cellpadding=5>

<tr>

<td width=80% align=center><font face=verdana size=2>

<p>Você não tem permissão para acessar esta página. <br>

Identifique-se, usando seu login (e-mail) e senha.</p>

<p>Caso não possua um, clique no link Cadastro.</p>

<p>Cordialmente,</p>

<p>Livraria Leitura Obrigatória</p></td>

<td width=20%></td></tr>

</table>

</table>



<%Response.End

End if%> Primeiro testamos se a variável de sessão CodCliente estava vazia ou não existia,

se este teste for verdadeiro é montada uma página no padrão de todas as outras do site informando que é necessário se logar ao site para ter acesso àquelas páginas. Depois de montada colocamos um comando Response.End que para a execução do arquivo naquele ponto. Se o teste for falso o conteúdo da página será montado normalmente.

Para que esses testes passe a funcionar todos os arquivos restritos devem possuir a diretiva include com a chamada para o arquivo restrito na primeira linha do arquivo.

Abra o um dos arquivos que o usuário não pode ter acesso se não estiver logado e acrescente a seguinte linha no início do arquivo antes qualquer código, exceto do Response.buffer = true.


97

ACTIVE SERVER PAGES

CRIANDO A PÁGINA DE PESQUISA A página de pesquisa dá a oportunidade do cliente procurar o produto desejado

para efetuar a compra.

Com a página de pesquisa temos resultados dinâmicos e rápidos sobre os produtos cadastrados no banco de dados. O cliente pode digitar uma parte do nome do produto ou apenas selecionar uma categoria ou fazer uma combinação dos critérios de seleção obtendo um resultado resumido e rápido com apenas o que o interessa.

Se não tivéssemos esta página seria necessário mostrar uma página HTML com todos os produtos cadastrados no banco de dados e o cliente teria que ir procurando qual o produto desejado. Isso traria um grande trabalho para o cliente o que conseqüentemente o afastaria do site.

Nós já temos o formulário que será preenchido pelo cliente montado. É o mostrado na figura abaixo:

Como o nosso código deverá funcionar? Temos que avaliar quais as situações que podem ocorrer neste formulário para que possamos escrever o código. A primeira é o cliente digitar uma parte do nome ou o nome todo do produto e não selecionar a categoria. A segunda é o cliente digitar uma parte do nome ou o nome todo do produto e selecionar a categoria. A terceira é o cliente selecionar apenas a categoria e a quarta situação é o cliente não digitar nada e não selecionar a categoria e depois de qualquer uma dessas situações clicar no botão pesquisar.

Como sabemos que o cliente clicou no botão pesquisar? Criando um campo do tipo hidden (oculto) que é enviado junto com os outros campos do formulário.

Crie um campo do tipo hidden logo após o comando <FORM>, conforme a linha a seguir:

<input type=”hidden” name=”Pesquisando” value=”Sim”> Mas as categorias dos produtos vêm do banco de dados e são dinâmicas. Se uma

nova categoria for incluída no banco de dados automaticamente o cliente a visualizará. Primeiro vamos modificar o conteúdo da caixa de seleção que mostrará o conteúdo das categorias cadastradas no banco de dados.


98

ACTIVE SERVER PAGES

BUSCANDO AS CATEGORIAS DO BANCO DE DADOS

Para acessarmos o banco de dados será necessário fazer a conexão. Usando a diretiva include acrescente o arquivo conecta.asp no início do arquivo pesquisa, logo depois do restrito.asp.

A tag HTML que cria a caixa de seleção é o <SELECT> que nós já temos em nosso arquivo. Precisamos fazer com que as opções do <SELECT> sejam buscadas do banco de dados, sendo que a opção que deve ser mostrada como padrão é o Selecione.

No comando <option> precisamos armazenar um value para a opção que for selecionada pelo cliente. No nosso caso o value será o código da categoria. Por que? Porque é como poderemos fazer uma pesquisa mais rápida no banco de dados para encontrar os produtos daquela categoria.

Mas se o cliente visualizar o código isso não significará nada para ele. Então vamos armazenar o código mas mostrar a descrição da categoria.

Acrescente o código abaixo logo depois do comando <option selected value=0>.

<% AbreConexao

ComandoSQL = "SELECT * FROM Categorias"


while not RsCategorias.EOF %>

<option value="<%=RsCategorias("codCategoria")%>">

<%=RsCategorias("nomeCategoria")%> </option>

<% rsCategorias.MoveNext

wend

FechaConexao%>

Teste digitando o login de um cliente que você cadastrou e a senha, se tiver dúvida consulte o banco de dados. Clique no link Pesquisa/Compra e clique na seta da categoria. Note que as categorias que você cadastrou no banco de dados estão sendo visualizadas.

Para testar, abra o banco de dados, acrescente uma nova categoria e feche o banco. Volte ao Internet Explorer e atualize a página, abra novamente a seta das categorias e a nova categoria digitada no banco de dados já está visível para o cliente.

Pronto! Agora podemos procurar no banco de dados os produtos.

CRIANDO A PESQUISA

Nós já sabemos que o cliente está pesquisando se o campo Pesquisando do formulário for Sim. E também sabemos quais as situações que podem ocorrer, vamos relembrar:

• Digitar apenas uma parte do nome ou o nome completo do produto e não selecionar a categoria.


99

ACTIVE SERVER PAGES

• Digitar apenas uma parte do nome ou o nome completo do produto e selecionar a categoria.

• Selecionar apenas a categoria do produto.

• E não selecionar nem digitar nada.

Na programação do comando SQL estas quatro hipóteses podem ser escritas com um IF simples. O código abaixo mostra como ficará a instrução SQL. E quando os dados forem encontrados montará uma tabela com o resultado da pesquisa.

Nessa tabela será mostrado o nome, a categoria, o estoque e o preço do produto. O nome do produto será um link com a chamada para o arquivo compra.asp enviando uma string de pesquisa com o código do produto.

O produto tem dois preços: o preço normal e o preço com desconto. Quando o preço com desconto existir ele deve ser mostrado, se não existir temos que mostrar o preço normal do produto.

Acrescente este código antes da frase de instruções de como deve ser feita a pesquisa.

<% if Request.Form("Pesquisando") = "Sim" then

Dim Sql, RS

AbreConexao

if Request.Form("categoria") = 0 then

Sql = "SELECT * FROM Produtos, Categorias”

Sql = Sql & “ WHERE Produtos.CodCategoria = “

Sql = Sql & “ Categorias.CodCategoria"

Sql = Sql & " AND nomeProduto LIKE '%" & Request.Form("produto")

Sql = Sql & "%' ORDER BY nomeProduto"

set Rs = conexao.execute(sql)

else

Sql = "SELECT * FROM Produtos, Categorias

Sql = Sql & “WHERE nomeProduto LIKE '%"

Sql = Sql & Request.Form("produto")&"%' "

Sql = Sql & " AND Produtos.CodCategoria = Categorias.CodCategoria”

Sql = Sql & “ AND Produtos.codCategoria = "

Sql = Sql & Request.Form("categoria")

Sql = Sql & " ORDER BY nomeProduto"

set Rs = conexao.execute(sql)

end if

if not Rs.Eof then

%>



100

ACTIVE SERVER PAGES

<b> O(s) seguinte(s) registro(s) foi(ram) encontrado(s)</b></font><br><br>


101

ACTIVE SERVER PAGES

<table border=1 width=100% cellpadding=3>

<tr>

<th align=center><font face=verdana size=2> Produto </font></th>

<th align=center><font face=verdana size=2> Categoria </font></th>

<th align=center><font face=verdana size=2> Estoque </font></th>

<th align=center><font face=verdana size=2> Preço Unitário </font></th></tr>

<% while not Rs.eof %>

<tr>


<a href=compra.asp?codigo=<%=Rs("codProduto")%>>

<%=RS("nomeProduto")%> </a></font></td>

<td><font face=verdana size=2><%=RS("NomeCategoria")%>

</font></td>

<td align=right><font face=verdana size=2><%=RS("estoque")%>

</font></td>

<% if RS("PrecoDesconto") = 0 then%>

<td align=right><font face=verdana size=2> R$

<%=formatNumber(RS("preco"),2)%> </font></td></tr>

<% else %>

<td align=right><font face=verdana size=2> R$

<%=formatNumber(RS("precoDesconto"),2)%> </font></td></tr>

<%end if

Rs.MoveNext

wend

FechaConexao%>

</table>

<%end if

end if%> Ao testar notará que o resultado da pesquisa é visualizado mas o formulário é

montado novamente depois da pesquisa. Isso não está correto. O formulário só pode ser montado se o pesquisando for diferente de Sim.

Então o último end if do código ASP antes do formulário deve ser substituído por ELSE e no final do código, antes do include do rodapé acrescente o código <% end if %> para finalizar o if que está aberto.

No código atual temos um IF para testar se não estamos no final do arquivo, se este teste for verdadeiro ele monta a tabela com o resultado. Mas não fizemos um código para quando este teste for falso. Então vamos acrescentar um ELSE antes do end if para mostrar uma mensagem caso nenhum produto seja selecionado.

Encontre o END IF antes do ELSE próximo a montagem do formulário e acrescente este código antes dele.


102

ACTIVE SERVER PAGES


103

ACTIVE SERVER PAGES

<%else %>

<b><center><font face=verdana size=4>

Nenhum Produto encontrado!<br></b>

<a href=pesquisa.asp> Retornar </a></center> Agora que toda a página de pesquisa está concluída precisamos trabalhar no

arquivo compra.

104

ACTIVE SERVER PAGES

CRIANDO PÁGINA DE COMPRA A página de compra permite que o cliente digite a quantidade daquele produto ele

deseja comprar, assim que o cliente clicar no botão comprar aquele produto é inserido no carrinho e uma página com os produtos selecionados para a compra, até o momento é mostrada.

Como estamos trabalhando com um site dinâmico não podemos definir para o cliente qual o produto e a quantidade que ele vai comprar. Esta informação deve ser passada pelo cliente. A página de compra recebe essas informações e armazena na tabela carrinho que é a tabela temporária com as compras do cliente.

Essa página deve mostrar o nome do produto selecionado, sua categoria e o preço e uma caixa para digitar a quantidade desejada. Agora precisamos pegar o código passado pela string de pesquisa do arquivo pesquisa.asp para mostrar o produto correto para o cliente. O código da página será o seguinte, só o código em negrito deve ser acrescentado à página (o código html já está pronto no arquivo que o seu instrutor forneceu):

<td width=20% valign=top></td>

<td width=80% align=center> <font face=verdana size=2>

<% AbreConexao

Dim Cod

‘Buscando o código passado pela string de pesquisa e convertendo em inteiro

Cod = int(Request.QueryString("codigo"))

Sql ="SELECT * FROM Produtos, Categorias”

Sql = Sql & “ WHERE Produtos.CodCategoria = Categorias.CodCategoria “

Sql = Sql & “AND codProduto = "& cod

Set Rs = conexao.execute(Sql)

%>

<center>


<tr>

<td><font face=verdana size=2><b> Produto: </b></font> </td>

<td><font face=verdana size=2> <%=Rs("nomeProduto")%> </font> </td>

</tr>

<tr>

<td><font face=verdana size=2><b> Categoria:</font></b> </td>

<td><font face=verdana size=2><%=RS("NomeCategoria")%> </font></td>

</tr>

<tr>

<td><font face=verdana size=2><b> Preço: </font></b> </td>


<%if Rs("PrecoDesconto") = 0 or Isnull(RS("PrecoDesconto")) then

Response.Write formatnumber(RS("Preco"),2)

else


105

ACTIVE SERVER PAGES

Response.Write formatnumber(RS("PrecoDesconto"),2)

end if %></font></td></tr>

<tr>

<td><font face=verdana size=2>Quantidade:</font></td>

<td><font face=verdana size=2><input type=text name=Quantidade size=5>

</font></td></tr>

<tr>

<td colspan= 2 align=center>

<p><input border="0" src="images/comprar.gif" name="I1" type="image"></p></td>

</tr></font>

<% FechaConexao %>

</table></center> Teste o arquivo digitando o login de um cliente que você cadastrou e a senha.

Clique no link Pesquisa/Compra e digite uma parte do nome de um dos produtos que você cadastrou ou selecione uma categoria e mande pesquisar. No resultado da pesquisa clique em um dos produtos e você será direcionado para a página compra que mostrará o nome do produto, a categoria e o preço e a caixa para digitar a quantidade. Esse é o resultado esperado do código anterior. Agora será necessário confirmar a digitação da quantidade e gravar a compra no carrinho.

PREPARANDO O FORMULÁRIO PARA A GRAVAÇÃO DO PRODUTO COMPRADO

Mas o botão comprar por enquanto não está fazendo nada. Mas o que ele efetuará nesta página?

Quando o cliente clicar no botão comprar, as informações sobre o código do produto, o preço e a quantidade devem ser armazenados dentro da tabela carrinho. Depois o cliente deve ser direcionado para a página que mostra os produtos comprados até o momento. A própria página compra efetuará este processo.

Para que a própria página execute este processo precisamos primeiro criar o formulário que efetuará as ações e os campos ocultos que receberão os valores dos campos. Antes do <TR> que cria o campo da quantidade insira o seguinte código:

<form method=post action=compra.asp >

<input type=hidden name=Comprando value=Sim>

<input type=hidden name=CodProduto value="<%=cod%>">

O campo Comprando identifica se o cliente clicou no botão comprar. O campo CodProduto armazena o código do produto comprado, que está na variável que nós criamos no início do arquivo para receber a string de pesquisa. Salve o arquivo.

Precisamos armazenar também o preço do produto, a quantidade já está sendo armazenada em um campo do formulário. Ao mostrarmos o preço podemos criar uma variável que armazena o preço e depois jogar essa variável para o campo oculto. Então no IF que define se será o mostrado o preço ou preço com desconto faça as modificações que estão em negrito:


106

ACTIVE SERVER PAGES


107

ACTIVE SERVER PAGES

<% if Rs("PrecoDesconto") = 0 or Isnull(RS("PrecoDesconto")) then

Response.Write formatnumber(RS("Preco"),2)

preco = RS("Preco")

else

Response.Write formatnumber(RS("PrecoDesconto"),2)

preco = RS("PrecoDesconto")

end if %> Depois vamos criar mais um campo oculto depois do campo CodProduto. Insira a

seguinte linha depois do INPUT do CodProduto.

<input type=hidden name=Preco value="<%= preco %>">

Como vamos direcionar o cliente para um arquivo que mostra todos os produtos comprados, precisamos trabalhar com a propriedade Buffer (mostra a página depois que tudo foi executado). Insira o código abaixo depois da diretiva include para o arquivo restrito.

<% Response.Buffer = true %>

INSERINDO O PRODUTO NO CARRINHO

Agora podemos criar o código que testará se o cliente clicou no botão comprar e se esse teste for verdadeiro vamos acrescentar o produto na tabela carrinho e chamar a página que mostra os produtos comprados até o momento.

Insira o código a seguir no início do arquivo, antes da declaração de variável com a instrução DIM e logo depois do abreconexao.

dim sql, rs, Quantidade, codProduto, CodCliente, Preco

'Testa se o cliente clicou no botão comprar

if Request.Form("Comprando") = "Sim" then

'Armazena os valores passados pelo métod POST em variáveis

Quantidade = int(Request.Form("Quantidade"))

CodProduto = int(Request.Form("CodProduto"))

Preco = csng(Request.Form("Preco"))

'Busca o código do cliente que está armazenado em uma

‘variável de sessão

CodCliente = int(Session("CodCliente"))

'Seleciona o produto e testa se o estoque está suficiente

‘para eefetuar a compra

Sql = "SELECT * FROM Produtos WHERE codProduto = " & CodProduto

Set RS = conexao.execute(Sql)

if Quantidade > Rs("Estoque") then

Response.Write "Impossível realizar a compra, pois o estoque atual do livro é " & Rs("estoque") & "<br>"

else

'Se o estoque é suficiente, insere o produto no carrinho


108

ACTIVE SERVER PAGES

Sql = "INSERT INTO Carrinho “


109

ACTIVE SERVER PAGES

Sql = Sql & “ (codProduto,codCliente,quantidade,preco) "

Sql = Sql & "VALUES (" & codProduto & "," & codCliente & ", "

Sql = sql & Quantidade & "," & Preco & ")"

conexao.execute(Sql)

'Direciona o cliente para a página que mostra os produtos

‘comprados até o momento

Response.Redirect ("comprados.asp")

end if

else

'Se o cliente não clicou no botão pesquisar, apenas alista o produto ‘selecionado na pesquisa

No final do arquivo, antes do comando FECHACONEXAO acrescente o comando END IF que fecha o IF que testa se o cliente clicou no botão comprar ou não. Para testar, atualize a página compra, digite uma quantidade e clique no botão comprar, será mostrado um erros que o arquivo comprados.asp não existe.

110

ACTIVE SERVER PAGES

CRIANDO A PÁGINA DE PRODUTOS COMPRADOS A página de produtos comprados mostra ao cliente todos os produtos que ele

selecionou até o momento. Também dá a oportunidade de excluir o produto do carrinho, voltar para fazer uma nova pesquisa e finalizar a compra.

Esta página da ao cliente a oportunidade de ir acompanhando as suas compras e definindo o que deseja fazer, continuar comprando ou finalizar a compra.

Essa página deve mostrar o item, o nome do produto, a categoria, o preço, a quantidade comprada e o total daquele produto. Na última linha da tabela devemos mostrar o total do pedido. A tabela já está montada no código que você abriu.

Os dados que serão mostrados nesta tela vêm da tabela carrinho. O que identifica os produtos que o cliente está comprado é o campo Codcliente, então devemos selecionar todos os registros da tabela carrinho referente ao código do cliente armazenado na variável de sessão.

Todo o código em negrito abaixo deve ser acrescentado ao código que você abriu:

<td valign= top width=20%> 

<td width=80%>

<% AbreConexao

Dim Sql, RS

Sql = "SELECT nomeProduto, Quantidade, Carrinho.preco, “

Sql = Sql & “ Carrinho.codCarrinho,

Sql = Sql & “ NomeCategoria FROM Carrinho, Produtos, Categorias”

Sql = Sql & “ WHERE Produtos.CodCategoria = Categorias.CodCategoria"

Sql = Sql & " AND Produtos.codProduto = Carrinho.CodProduto “

Sql = sql & “ AND Carrinho.codCliente = " & Session("codCliente")

set Rs = conexao.Execute(Sql)

%>


<b> Produto(s) escolhido(s) até o momento:</b></font><br><br>


<tr>

<th align=center><font face=verdana size=2> Item </font></th>

<th align=center><font face="verdana" size="2">Produto</font></th>

<th align=center><font face="verdana" size="2">Categoria</font></th>

<th align=center><font face=verdana size=2> Quantidade </font></th>

<th align=center><font face=verdana size=2> Preço<br> Unitário </font></th>

<th align=center><font face=verdana size=2> Total </font></th>

</tr>

<% Dim total,totalGeral

while not Rs.eof %>


111

ACTIVE SERVER PAGES

<tr>

<td align=center><input type=checkbox name="C"


112

ACTIVE SERVER PAGES

value="<%=Rs("codCarrinho")%>"> </td>

<td><font face=verdana size=2><%=RS("nomeProduto")%> </font></td>

<td align=right><font face=verdana size=2><%=RS("nomeCategoria")%>

</font></td>

<td align=right><font face=verdana size=2><%=RS("quantidade")%>

</font></td>

<td align=right><font face=verdana size=2>R$

<% = FormatNumber(Rs("preco"),2)%></font></td>

<% total = Rs("quantidade") * Rs("Preco")%>


<%= FormatNumber(total,2)%> </font></td></tr>

<%totalGeral = totalGeral + total

Rs.MoveNext

wend %>

<tr>

<td colspan=5 align=right><font face=verdana size=2>Total Geral </font></td>


<%= FormatNumber(totalGeral,2)%> </font></td></tr>

<tr>

<td align=center>

<p><input border="0" src="images/excluir.gif" name="I1" width="65"

height="21" type="image"> </p> </td>

<td colspan=5 align=center>

<p><a href = pesquisa.asp><img border="0" src="images/continuar.gif"

width="70" height="23"></a>

<a href = finaliza.asp><img border="0" src="images/finalizar.gif"

width="68" height="25" > </a></p> </td></tr>

</table></form>

<% fechaConexao %></table> No Select deste arquivo repetimos o procedimento de relacionarmos as tabelas

usando suas chaves primárias e as estrangeiras para que tivéssemos integridade nos dados exibidos.

Teste digite o login de um cliente que você cadastrou e a senha, faça uma pesquisa e efetue a compra, repita este processo algumas vezes.

EXCLUINDO ITENS DO CARRINHO

Nessa tela temos o botão Excluir que servirá para o cliente quando selecionar um item excluí-lo da lista.

Na linha de comando <td align=center><input type=checkbox name="C" value="<%=Rs("codCarrinho")%>"> criamos um checkbox de nome C onde o valor que ele armazena é o código do carrinho. Imagine que o cliente poderá excluir mais de um item ao


113

ACTIVE SERVER PAGES

mesmo tempo. Como o ASP reconhecerá qual dos itens deve ser apagado, se todos tem o mesmo nome?


114

ACTIVE SERVER PAGES

Primeiro será necessário criar um contador para cada produto que for mostrado na tela de comprados. Acrescente a seguinte linha de comando logo depois de While not rs.eof:

Num = Num + 1 Nessa linha estamos criando um contador que será incrementado a cada registro

que for sendo mostrado para o cliente. Com esse contador podemos também identificar qual o checkbox foi marcado pelo cliente, porque, como sabemos, um campo de formulário do tipo checkbox só passa a existir se estiver marcado.

Então no name do input type=checkbox faça a seguinte alteração:

name="C<%=Num%>" Nesse caso cada checkbox receberá o nome C seguido do conteúdo da variável

Num. Salve o arquivo.

Também precisamos criar um formulário que indica que aquele campo pode ser utilizado na programação. Logo depois dos comandos

<b> Produto(s) escolhido(s) até o momento:</b></font><br><br>

<table border=1 width=100% cellpadding=1> Acrescente as seguintes linhas:

<form method=post action="comprados.asp">

<input type=hidden name=excluindo value=sim>

Essas duas linha indicam que quando o cliente clicar no botão excluir o arquivo comprados será executado novamente, e o campo oculto que identifica que o formulário foi enviado é o que recebe o nome de excluindo. Também precisamos fechar esse formulário. Antes do comando <%fechaConexao %> no final do arquivo acrescente o comando </form>. Salve o arquivo.

Mas como o programa conseguirá rastrear todos os checkbox que foram criados dinamicamente? A variável Num armazena este número, mas quando o cliente clicar no botão Excluir o arquivo comprados será recarregado e as variáveis conseqüentemente inicializadas. Então, precisamos armazenar este valor em um outro campo oculto do formulário.

Acrescente a seguinte linha antes do comando </form>:

<input type=hidden name=QtItens value="<%=Num%>">

Como já encontramos a quantidade de itens gerados dinamicamente e já temos os nomes dos checkbox criados, podemos testar se o botão excluir foi pressionado testando a existência do campo oculto Excluindo e se ele existir fazer o procedimento que percorrerá os checkbox e o que existir, ou seja, o que foi marcado ser excluído da tabela carrinho.

Acrescente o seguinte código logo depois do comando Abreconexao no início do arquivo:


115

ACTIVE SERVER PAGES

if Request.Form("excluindo") = "sim" then

Dim N,I, Nomec

N = cint(Request.Form("QtItens"))

for I=1 to N

Nomec = "C"&I

if Request.Form(Nomec) <> false then

Sql = "DELETE * FROM Carrinho WHERE codCarrinho ="

Sql = Sql & cint(Request.Form(Nomec))


end if

next

end if Depois de testarmos o valor do campo excluindo criamos três variáveis a N que

servirá para armazenar a quantidade de checkbox gerados, a variável I que serve como o incrementador do loop For e a variável NomeC que remonta o nome do checkbox que a letra C mais o valor do número.

O loop será feito até o total de itens que armazenamos na variável N. o nome do checkbox é remontado dentro do loop. Testamos se este nome existe, ou se é diferente de false, porque ele só será True se o cliente marcar um dos itens. Quando o nome existe fazemos um DELETE na tabela Carrinho onde o código do carrinho for o mesmo armazenado no value do campo checkbox.

Depois que o cliente conferiu o carrinho ele desejará finalizar sua compra.


116

ACTIVE SERVER PAGES

CRIANDO A PÁGINA FINALIZA Essa é a página que efetua todo o processo de compra, criando um pedido,

armazenando os itens do pedido, atualizando o estoque, apagando os itens do carrinho e mostrando os valores das compras do dia.

Essa página faz todo o processamento da compra já efetuada pelo cliente, provendo as informações necessárias para uma consulta pelo pessoal de vendas da livraria e qualquer outro tipo de relatório que seja necessário ser feito em cima das vendas feitas pela Internet.

Essa página deve mostrar o número do pedido, o nome do produto, a categoria, o preço, a quantidade comprada e o total daquele produto. Na última linha da tabela devemos mostrar o total das compras do dia e a mensagem informando que o usuário receberá um e-mail com a confirmação da compra.

A tabela já está montada no código que você abriu. O código que deve ser inserido nessa página fará as seguintes ações:

1. Criar o pedido na tabela de pedidos.

2. Armazenar o código que foi gerado pelo Access.

3. Selecionar os produtos que estão na tabela carrinho.

4. Carregar os valores do primeiro registro nas variáveis.

5. Iniciar o loop até que encontre o fim do conjunto de registros.

6. Inserir na tabela de produtospedidos os itens comprados.

7. Mover o ponteiro para o início do conjunto de registros logo depois do fim do loop.

8. Carregar os valores do primeiro registro nas variáveis.

9. Iniciar o loop até que encontre o fim do conjunto de registros.

10. Atualizar o estoque dos produtos comprados.

11. Totalizar a venda.

12. Limpar o carrinho.

Insira o seguinte código logo depois do comando AbreConexao no início do arquivo (fornecido pelo instrutor):

<% AbreConexao

dim Sql, Rs, CodProduto, CodCliente, Quantidade, Preco, dia, mes, ano, hora, minuto, segundos

'Busca o código do cliente


117

ACTIVE SERVER PAGES

CodCliente = Session("codCliente")

'Montando a data para ser armazenada

Dia = day(Now)

Mes = month(Now)

Ano = year(Now)

Hora = Hour(now)

Minuto = Minute(Now)

Segundos = Second(Now)

Data = dia & "/" & mes & "/" & ano & " " & Hora & ":" & Minuto & ":" & Segundos

'Atualizando a tabela de Pedidos

Sql = "INSERT INTO Pedidos (codCliente,dataPedido) "

Sql = Sql & "VALUES (" & CodCliente & ",'" & data & "')"

conexao.execute(sql)

'Seleciona o número do último pedido gerado para inserir os itens

‘do pedido

Sql = "SELECT MAX(CodPedido) as ultPedido FROM Pedidos"

set Pedido = conexao.execute(sql)

'Seleção no Carrinho para inserir os produtos na tabela de Produtos

‘Pedidos

Sql = "SELECT * FROM Carrinho WHERE codCliente = "& codCliente

Set Rs = conexao.Execute(Sql)

'Carrega as variáveis para o primeiro INSERT do loop

CodProduto = Rs("CodProduto")

Quantidade = RS("Quantidade")

Preco = RS("Preco")

While not rs.Eof

'Atualizando a tabela ProdutosPedidos

Sql = "INSERT INTO ProdutosPedidos

Sql = Sql & “ (codPedido,codProduto,quantidade,Preco) "

Sql = Sql & "VALUES (" & Pedido("ultPedido") & "," & codProduto & ","

Sql = Sql & quantidade & "," & Preco & ")"

conexao.execute(sql)

rs.movenext

if not rs.EOF then ' Testa se ainda não está no final do RecordSet

'Carrega as variáveis para o próximo INSERT



Preco = RS("Preco")

end if

wend

'Move o ponteiro para o primeiro registro


118

ACTIVE SERVER PAGES

rs.MoveFirst

'Carrega as variáveis para o primeiro UPDATE



Preco = RS("Preco")

While not Rs.eof

'Atualizando o estoque de Produtos

response.write "Atualizando estoque"

Sql = "UPDATE Produtos SET estoque = estoque -" & quantidade

Sql = Sql & " WHERE codProduto = " & codProduto


rs.movenext

if not rs.EOF then ' Testa se ainda não está no final do RecordSet

'Carrega as variáveis para o próximo INSERT



Preco = RS("Preco")

end if

wend

'Totalizando a Venda

Sql = "SELECT SUM(quantidade*preco) AS total FROM Carrinho ‘

Sql = Sql & “ WHERE codCliente = " & Session("codCliente")

Set Rs = conexao.execute(Sql)

'Limpando o Carrinho

sql = "DELETE FROM Carrinho WHERE codCliente =" & Session("codCliente")


%> Agora precisamos selecionar os dados do Pedido e do ProdutosPedidos, Categorias

e Clientes para montar a tabela e a mensagem de confirmação. Então entre a primeira linha da tabela e a segunda acrescente o seguinte código:

<% Dim total,totalGeral,Num

ComandoSQL = "SELECT P.nomeProduto, C.nomecategoria, PP.quantidade ,

ComandoSQL = ComandoSQL & “ PP.Preco, PE.CodPedido “

ComandoSQL = ComandoSQL & " FROM Produtos P, Pedidos Pe,Categorias C, “

ComandoSQL = ComandoSQL & " ProdutosPedidos PP, Clientes CL “

ComandoSQL = ComandoSQL & “ WHERE Pe.CodCliente = " & codCliente

ComandoSQL = ComandoSQL & " AND Pe.codPedido = PP.CodPedido "

ComandoSQL = ComandoSQL & " AND PP.CodProduto = P.CodProduto “

ComandoSQL = ComandoSQL & “ AND P.CodCategoria = C.CodCategoria "


119

ACTIVE SERVER PAGES

ComandoSQL = ComandoSQL & " AND Pe.CodCliente = CL.Codcliente "

ComandoSQL = ComandoSQL & " AND day(dataPedido) = '" & day(now) &"'"

ComandoSQL = ComandoSQL & " AND Month(dataPedido) = '"& month(now) &"'"

ComandoSQL = ComandoSQL & " AND year(dataPedido) = '" & year(now) & "'"

set RsPedidos = conexao.execute(ComandoSQL)

while not RsPedidos.eof %> Agora na segunda linha da tabela precisam ser mostrados os campos selecionados.

O que estiver em negrito altere em seu arquivo:

<tr>

<td><font face=verdana size=2><%=RSPedidos("CodPedido")%> </font></td>

<td><font face=verdana size=2><%=RSPedidos("nomeProduto")%>

</font></td>

<td align=right><font face=verdana size=2>

<%=RSPedidos("nomeCategoria")%> </font></td>

<td align=right><font face=verdana size=2><%=RSPedidos("quantidade")%> </font></td>


<% = FormatNumber(RsPedidos("preco"),2)%></font></td>

<% total = RsPedidos("quantidade") * RsPedidos("Preco")%>


<%= FormatNumber(total,2)%> </font></td></tr>

<%totalGeral = totalGeral + total

if not rsPedidos.eof then

RsPedidos.MoveNext

end if

wend %>

<tr>

<td colspan=5 align=right><font face=verdana size=2>Total Geral

</font></td>


<%= FormatNumber(totalGeral,2)%> </font></td>

</table>

<% fechaConexao %> Salve o arquivo. Mas no corpo da mensagem precisamos mostrar também algumas

informações que foram selecionadas sobre o cliente. No final do arquivo temos o texto que será mostrado para o cliente. O que estiver de negrito altere em seu arquivo.

Verifique as informações que irão no e-mail: <br><br>

Nome: <%=session("nomeCliente")%><br>

E-mail: <%=session("email")%><br>

Total Compra: R$ <%=formatNumber(TotalGeral,2)%><br>

Obrigado pelas compras e aproveite seus livros.<br></p>

<i>Livraria ClaraLuz</i>


120

ACTIVE SERVER PAGES


121

ACTIVE SERVER PAGES

Salve o arquivo. Para testar acesse o site e efetue uma compra.

ENVIANDO O E-MAIL DE CONFIRMAÇÃO

Para enviarmos o e-mail de confirmação usaremos o componente Persists do ASP. Este componente já está embutido nos servidores web. Como poderemos enviar e-mail em qualquer ponto do nosso aplicativo vamos criar a função que envia e-mail dentro do arquivo conecta. Assim, quando você precisar de enviar e-mail basta incluir esse arquivo com a diretiva include no código que você estiver criando.

Abra o arquivo conecta.asp, digite o código abaixo logo depois do end function.

Function EnviaEmail(nome, email, total)

set mail = server.CreateObject("Persits.MailSender")

Dim corpo1, corpo2, corpo3, corpo4

corpo1 = "Prezado(a)"

corpo2 = ", <br><br>Sua compra foi efetuada. Para receber seus livros em casa, pague a quantia de:"

corpo3 = ". Deposite este valor no banco XYZ. agência 0337, conta corrente 112244-1. “

corpo4 = “<br><br>Cordialmente, <br><br>Livraria ClaraLuz"

mail.host = "mail.provedor.com.br" 'Servidor de envio de e-mail

mail.from = "[email protected]" 'Endereço de e-mail do remetente

mail.fromName = "Leitura ClaraLuz" 'Nome do Remetente

mail.IsHTML = true 'Tipo de e-mail html ou texto

mail.addAddress email, nome 'método para receber o email e o nome do destinatário

mail.subject = "Compra Efetuada" 'Assunto do e-mail

mail.body = corpo1 & nome & corpo2 & total & corpo3 & corpo4

mail.send 'Metódo para enviar

enviaemail = true

end function Essa função recebe três parâmetros o nome do cliente, o e-mail dele e o valor da

compra, esses parâmetros serão passados pela chamada que for feita dentro do programa que utilizar essa função.

Depois que recebemos os valores criamos um instância do componente Persists com o objeto MailSender, que é um do componentes que envia os e-mails no ASP. Então, criamos quatro variáveis que receberam o corpo do e-mail e alguns dos parâmetros que foram passados para a função.

Assim usamos algumas propriedades e métodos do objeto que são:

Host define qual o servidor de mensagens será usado para enviar o e-mail.


122

ACTIVE SERVER PAGES

From define quem está enviando o e-mail, será o DE quando o cliente receber o e-mail.

FromName define o nome que será mostrado no campo DE da mensagem.

IsHTML define o formato da mensagem para o padrão HTML.

AddAddress é o método do objeto que recebe o endereço de e-mail do destinatário e o seu nome.

Subject define o assunto da mensagem.

Body define o corpo de texto da mensagem.

Send é o método que envia a mensagem.

E como estamos trabalhando com uma função ela deve retornar um valor, neste caso programamos que ela retorne verdadeiro.

Agora precisamos fazer a chamada da função dentro do arquivo finaliza. Se o arquivo não estiver aberto, abra-o e logo depois dos comandos que limpam o carrinho e antes de fechar a tag ASP, acrescente o seguinte código:

' Enviando o e-mail de confirmação

EnviaEmail Session("nomeCliente"), Session("email"), Rs("total")

%> O e-mail não será enviado, porque precisamos de um servidor de e-mail

configurado.


123

ACTIVE SERVER PAGES

CONCLUSÃO

Esperamos que o conteúdo desta apostila tenha servido de suporte para as suas aulas. Lembre-se que nada substitui uma boa aula de seu professor.

A informática sofre mudanças bruscas muito rapidamente, procure no futuro uma biblioteca auxiliar e fique atento ao lançamento de novos aplicativos e versões.

A Zargon Computação estará sempre ao seu dispor para solucionar dúvidas quando necessário.

Atenciosamente,

Diretoria de Treinamento Zargon Tecnologia em Informática

apostila - asp active server pages

Documents