Asp by Alemao DJ

Sumário

CRIANDO SITES DINÂMICOS COM

ASP 3.0 Júlio Battisti

Criando Sites Dinâmicos com ASP 3.0

Copyright © 2000 by Júlio Battisti Copyright © 2000 by Axcel Books do Brasil Editora Ltda. Nenhuma parte desta publicação poderá ser reproduzida sem autorização prévia e escrita de Axcel Books do Brasil Editora. Editora de Produção: Gisella Narcisi Editor Responsável: Ricardo Reinprecht

Criando Sites Dinâmicos com ASP 3.0 Júlio Battisti ISBN: 85-7323-141-6

Suporte Técnico ao Leitor Limite de garantia: Nosso suporte técnico limita-se ao conteúdo específico do livro, e não a questões gerais referentes ao(s) software(s) descrito(s), cessando caso esta publicação tenha sido esgotada. Para obter esse suporte técnico específico, o leitor deve informar título, autor e página, somente via e-mail. Todos os originais de livros enviados para avaliação pela Editora serão destruídos, caso não sejam aprovados. Não será feita sua devolução em nenhuma hipótese. Os conceitos emitidos nesta obra são de inteira responsabilidade do Autor.

E-mail: editora@axcel.com.br Visite nossa Home Page http://www.axcel.com.br

Axcel Books do Brasil Editora Av. Paris, 571 – Bonsucesso 21041-020 – Rio de Janeiro – RJ Tel. (21) 2564-0085

Sumário

Créditos Produção Alexandre Ramires Carlos Alberto Sá Ferreira

Revisão Vanessa Garcia

Arte e Diagramação Ingo Bertelli

Supervisor de Produção Carlos Alberto Sá Ferreira

Capa Ingo Bertelli

Editora de Produção Gisella Narcisi

Editor Responsável Ricardo Reinprecht

III

Criando Sites Dinâmicos com ASP 3.0

Agradecimentos Embora este seja o meu segundo livro, a emoção e a satisfação de concluir mais esse trabalho é talvez até maior do que no lançamento do primeiro. Foram meses de trabalho árduo, escrevendo capítulos entre uma viagem e outra. Felizmente conseguimos concluir esse livro no tempo estimado. E o principal é que saiu conforme o planejado. Penso que esse livro pode ajudar bastante aqueles que querem aprender a tecnologia ASP, e até mesmo programadores mais experientes. No entanto, um trabalho como este não pode ser realizado sem que várias pessoas contribuam, formando uma verdadeira equipe. Devo citar e agradecer, mais uma vez, a paciência, o amor, a dedicação e o apoio de minha esposa Lu, diante de mais este desafio. Sei que não foi fácil ficar ao meu lado, um final de semana após o outro, apenas escutando o barulho das teclas do computador. Sem o seu apoio e compreensão, tudo seria muito mais difícil, para não dizer impossível. Prometo que o próximo trabalho terá somente umas 200 páginas. Gostaria também de agradecer o amor e apoio da minha mãe – Dona Lucy. Pessoa que sempre me incentivou, apoiou, acreditou no meu trabalho e fez despertar em mim o amor pelos livros. Mãe, mais uma vez agradeço por tudo o que fizestes e continuas fazendo por mim. Agradeço mais do que tudo, o amor que sempre me deste, fazendo com que eu crescesse com a certeza de estar sendo amado e querido. Também quero agradecer a equipe da Axcel Books, pela sua paciência em corrigir e revisar mais este trabalho, sempre com sugestões para a melhoria do mesmo, de tal forma que o amigo leitor possa obter uma obra de qualidade. Devo citar ainda minhas irmãs: Rose, Lacy e Sandra que sempre renovam minhas forças com seus elogios sinceros e verdadeiros. Os momentos que passamos juntos, embora poucos, são verdadeiros e profundos. Uma simples conversa, um almoço, um passeio; são momentos de parada e reflexão. Momentos que nos mostram o quanto a vida vale a pena. Espero podermos passar mais tempo juntos.

Sumário

Sobre o Autor Júlio Battisti é profissional certificado da Microsoft, tendo sido aprovado em 16 Exames da Microsoft, com os quais obteve certificações como: MCP, MCP+I, MCSE, MCSE+I e MCDBA. É Gerente de rede na Secretaria da Receita Federal, e conhece a tecnologia ASP desde sua primeira versão. Também é autor de artigos de informática e trabalha com o desenvolvimento e administração de Web sites. Autor do livro: “Série Curso Básico & Rápido Microsoft Windows 2000 Server”, publicado pela Editora Axcel Books. Atua como instrutor de cursos de informática na Secretaria da Receita Federal, em outros cursos particulares e também para turmas em Universidades.

Criando Sites Dinâmicos com ASP 3.0

Sumário

Sumário Introdução ........................................................................................................................................ 1 Sites Dinâmicos com ASP 3.0 ......................................................................................................... 1 Equipamento e Software Necessário ............................................................................................... 3 Instalando e Testando o IIS 5.0 ........................................................................................................ 4 Novidades e Melhorias do IIS 5.0 .................................................................................................. 10 Administração e Serviços .............................................................................................................. 11 Desenvolvimento de Aplicações Internet/Intranet ................................................................. 12 É Hora de Começar ......................................................................................................................... 13 Visão Geral dos Capítulos do Livro ........................................................................................ 13 Então, “Mãos à obra” ............................................................................................................... 14 Capítulo 1 – Uma Introdução à Tecnologia ASP ......................................................................... 15 Era uma Vez uma Internet com Conteúdo Estático ....................................................................... 16 Um Começo Quase sem Querer .............................................................................................. 16 Uma Visão Geral da Internet e de Seus Elementos ................................................................ 17 Conteúdo Dinâmico na Internet .................................................................................................... 19 A Era do Comércio Eletrônico ....................................................................................................... 23 Aplicações Para a Web ................................................................................................................... 29 A Complexidade de Gerenciamento do Modelo Cliente/Servidor e Aplicações em Duas Camadas .................................................................. 29 Aplicações em Duas Camadas ................................................................................................ 30 Aplicações em Três Camadas ................................................................................................. 31 Aplicações em Quatro Camadas ............................................................................................. 33 Questões a Considerarmos nos Modelos em Três ou Mais Camadas .................................... 34 O que é ASP? .................................................................................................................................. 35 Preparando o Servidor Para Acompanhar os Exemplos ................................................................ 37 Criando a Estrutura de Pastas e Subpastas ............................................................................. 37 Tornando a Pasta Livro Parte dos Servidor IIS ....................................................................... 38 Alguns Exemplos Práticos ...................................................................................................... 44 O Tradicional “Hello World” ................................................................................................... 44 Um Exemplo de Página Dinâmica .......................................................................................... 48 Capítulo 2 – Uma Introdução ao VBScript .................................................................................. 53 Introdução ...................................................................................................................................... 54 O que é VBScript ............................................................................................................................ 54 Uma Revisão Rápida de HTML...................................................................................................... 56 Estrutura Básica de uma Página HTML .................................................................................. 56 Tags Para a Criação de Formulários HTML ............................................................................. 60 Criando o Formulário – a tag <FORM> </FORM> ....................................................... 60 Criando uma Caixa de Texto – a Tag <INPUT TYPE=“TEXT”> ................................... 62 Criando uma Caixa de Texto Para a Digitação de Senhas – a tag <INPUT TYPE=“PASSWORD”> ....................................................... 64 Criando um “Check Box” – a tag <INPUT TYPE=“CHECKBOX”> ............................... 66

VII

Criando Sites Dinâmicos com ASP 3.0

Criando um Conjunto de “Radio Buttons” – a tag <INPUT TYPE=“RADIO”> ............ 68 Criando um Campo Para Digitação de Comentários e Textos Maiores – a tag <TEXTAREA> </TEXTAREA> .............................................. 70 Criando uma Lista de Opções (Caixa de Combinação) – a tag <SELECT></SELECT> em Combinação com <OPTION></OPTION> .................... 72 Finalizando o Formulário com os Botões Enviar Dados e Limpar Dados – as Tags <INPUT TYPE=“SUBMIT”> e <INPUT TYPE=“CLEAR”> ......................... 75 Declaração e Utilização de Variáveis no VBScript ........................................................................ 78 O que é uma Variável ? ........................................................................................................... 78 Inserindo Código VBScript ..................................................................................................... 78 Declaração e “Tipo” de Variável .............................................................................................. 79 Fazendo Cálculos e Comparações com o VBScript – Operadores ................................................ 83 Fazendo Cálculos com os Operadores Aritméticos ................................................................ 83 Comparando Valores com os Operadores de Comparação .................................................... 87 O Escopo das Variáveis, no VBScript ............................................................................................ 91 Estruturas Para Controle de Fluxo em VBScript ........................................................................... 95 Estruturas de Decisão .............................................................................................................. 95 A Estrutura If...Then ........................................................................................................ 96 A Estrutura If...Then...Else ............................................................................................... 96 A Estrutura If...Then...ElseIf...Else ................................................................................... 97 A Estrutura Select...Case .................................................................................................. 99 Estruturas de Repetição ........................................................................................................ 100 A Estrutura For...Next ..................................................................................................... 100 A Estrutura Do...Loop ..................................................................................................... 102 A Estrutura Do While Condição...Loop ......................................................................... 102 A Estrutura Do... Loop While Condição ........................................................................ 103 A Estrutura Do Until Condição...Loop .......................................................................... 106 A Estrutura Do... Loop Until Condição ......................................................................... 107 Conclusão ..................................................................................................................................... 110 Capítulo 3 – Funções, Procedimentos e Eventos com VBScript ................................................ 111 Tipos de Dados e Funções Para Conversão de Tipos ................................................................... 112 Determinando o Tipo de Dados Contido em uma Variável .................................................. 112 A Função IsArray ............................................................................................................ 113 A Função VarType ........................................................................................................... 115 A Função IsDate .............................................................................................................. 118 A Função IsEmpty .......................................................................................................... 121 A Função IsNull .............................................................................................................. 122 A Função IsNumeric ....................................................................................................... 124 A Função IsObject .......................................................................................................... 125 Funções Para Conversão de Tipos ......................................................................................... 127 Função Cbool .................................................................................................................. 127 Função CByte .................................................................................................................. 128 Função CCur ................................................................................................................... 129 Função CDate .................................................................................................................. 130 Função CDbl ................................................................................................................... 131 Função CInt .................................................................................................................... 132 Função CLng ................................................................................................................... 133

VIII

Sumário

Função CSng ................................................................................................................... 134 Função CStr .................................................................................................................... 135 Funções Int e Fix ............................................................................................................ 135 Outras Funções do VBScript – Tratamento de String, Datas e Funções Matemáticas ..................................................................................... 136 Funções Para Tratamento de String ...................................................................................... 136 Função Asc ..................................................................................................................... 136 Função Chr ..................................................................................................................... 136 Função Len ..................................................................................................................... 137 Função LCase .................................................................................................................. 137 Função UCase ................................................................................................................. 138 Função Left ..................................................................................................................... 138 Função Right ................................................................................................................... 138 Função Mid ..................................................................................................................... 139 Função String .................................................................................................................. 140 Funções Para Tratamento de Data e Hora ............................................................................. 140 Função Date .................................................................................................................... 140 Função Time ................................................................................................................... 141 Função Day ..................................................................................................................... 141 Função Month ................................................................................................................. 142 Função Now .................................................................................................................... 142 Função MonthName ....................................................................................................... 143 Função Hour ................................................................................................................... 143 A função DateDiff ........................................................................................................... 144 A Função DateAdd ......................................................................................................... 145 Função Year ..................................................................................................................... 147 Função WeekDay ............................................................................................................ 147 Função WeekDayName ................................................................................................... 148 Funções Para Cálculos Matemáticos ..................................................................................... 149 Criando Suas Próprias Funções e Procedimentos ....................................................................... 151 Criando e Utilizando Sub-rotinas ......................................................................................... 151 Criando e Utilizando Funções ............................................................................................... 154 Trabalhando com Eventos no VBScript ...................................................................................... 157 Principais Eventos dos Objetos do Internet Explorer .......................................................... 159 Conclusão ..................................................................................................................................... 167 Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0 .......................................... 169 Introdução .................................................................................................................................... 170 Entendendo e Utilizando ASP ..................................................................................................... 170 Como e Onde uma Página ASP é Processada? ..................................................................... 171 O que uma Página ASP Retorna Para o Navegador do Cliente? ........................................... 172 O que é Preciso Para Criar e Acessar Páginas ASP? ............................................................. 175 Objetos do ASP 3.0 ....................................................................................................................... 176 Uma Visão Geral do Modelo de Objetos do ASP 3.0 ............................................................ 177 O Objeto Request.......................................................................................................................... 179 Coleções do Objeto Request .................................................................................................. 179 A Coleção Form do Objeto Request .............................................................................. 179 A Coleção QueryString do Objeto Request.................................................................... 186

Criando Sites Dinâmicos com ASP 3.0

Alguns Campos que Merecem Considerações Especiais .............................................. 189 A Coleção ServerVariables do Objeto Request .............................................................. 193 A Coleção Cookies do Objeto Request ........................................................................... 199 A Coleção ClientCertificate do Objeto Request ............................................................. 203 Propriedade do Objeto Request ............................................................................................ 203 Método do Objeto Request .................................................................................................... 204 O Objeto Response ....................................................................................................................... 206 Coleção do Objeto Response ................................................................................................. 206 Propriedades do Objeto Response ........................................................................................ 211 A Propriedade Buffer do Objeto Response .................................................................... 211 A Propriedade CacheControl do Objeto Response ........................................................ 212 A Propriedade CharSet do Objeto Response ................................................................. 213 A Propriedade ContentType do Objeto Response ......................................................... 214 A Propriedade Expires do Objeto Response .................................................................. 215 A Propriedade ExpiresAbsolute do Objeto Response ................................................... 216 A Propriedade IsClientConnected do Objeto Response ................................................ 217 A Propriedade PICS do Objeto Response ...................................................................... 218 A Propriedade Status do Objeto Response .................................................................... 219 Métodos do Objeto Response ................................................................................................ 219 O Método AddHeader do Objeto Response ................................................................... 220 O Método AppendToLog do Objeto Response ............................................................... 220 O Método BinaryWrite do Objeto Response .................................................................. 221 O Método Clear do Objeto Response ............................................................................. 222 O método End do Objeto Response ............................................................................... 223 Comentários ................................................................................................................... 223 O Método Flush do Objeto Response ............................................................................ 224 O Método Redirect do Objeto Response ........................................................................ 225 O Método Write do Objeto Response ............................................................................. 226 Alguns Exemplos Práticos de Aplicação ..................................................................................... 227 Exemplo 1: Validação dos Dados de um Formulário ............................................................ 227 Exemplo 2: Formulário Para Cálculo de Imposto ................................................................. 239 Conclusão ..................................................................................................................................... 248 Capítulo 5 – Conectando Páginas ASP com Bancos de Dados .................................................. 249 Uma Revisão dos Conceitos Básicos de Banco de Dados ........................................................... 251 Entidades e Atributos ............................................................................................................ 251 Chave Primária ...................................................................................................................... 252 Relacionamentos Entre Tabelas ............................................................................................ 253 Relacionamento do Tipo Um Para Um .......................................................................... 254 Relacionamento do Tipo Um Para Vários ...................................................................... 255 Relacionamento do Tipo Vários para Vários ................................................................. 255 Integridade Referencial .................................................................................................. 256 Normalização de Tabelas ...................................................................................................... 257 Primeira Forma Normal .................................................................................................. 258 Segunda Forma Normal .................................................................................................. 259 Terceira Forma Normal ................................................................................................... 260 Passos Para Projetar um Banco de Dados .............................................................................. 261

Sumário

Etapas na Estruturação de um Banco de Dados ............................................................ 261 Dicas Para Determinação dos Campos em uma Tabela ................................................. 262 Como Escolher o Campo que Será a Chave Primária? .................................................. 262 Noções Básicas da Linguagem SQL – Structured Query Language ............................................ 263 Introdução ............................................................................................................................. 263 A Instrução SELECT ............................................................................................................. 264 A Instrução UPDATE ............................................................................................................. 272 A Instrução INSERT .............................................................................................................. 273 A Instrução Delete ................................................................................................................. 274 Uma Visão Geral de ADO e OLE DB ............................................................................................ 275 Um Pouco Sobre ODBC – Open Database Conectivity ........................................................ 275 Criando uma Fonte ODBC Para um Banco de Dados do Microsoft Access 97 ............. 276 Criando uma Fonte ODBC Para um Banco de Dados do Microsoft SQL Server 2000 ....... 282 Um Pouco Sobre OLE DB e ADO .......................................................................................... 288 Uma Visão Geral do Modelo de Objetos ADO ............................................................................ 290 O Objeto Connection ................................................................................................................... 292 O Primeiro Exemplo .............................................................................................................. 295 Modificando um Pouco o Nosso Exemplo ............................................................................ 304 Um Pouco Mais Sobre o Objeto Connection ............................................................................... 306 Criando um Formulário Para Pesquisa ......................................................................................... 311 Criando a Página HTML com o Formulário de Pesquisa ...................................................... 312 Criando a Página ASP Para Pesquisar no Banco de Dados .................................................. 313 Conclusão ..................................................................................................................................... 318 Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I ................................. 321 Introdução .................................................................................................................................... 322 Estabelecendo Conexões sem a Utilização de ODBC .................................................................. 323 A Propriedade ConnectionString ................................................................................................. 324 Configurando Conexões com Bancos de Dados do Microsoft Access .......................... 324 Configurando Conexões com Bancos de Dados do Microsoft SQL Server ................... 326 Configurando Conexões com Bancos de Dados ORACLE ............................................. 331 Alguns Detalhes Finais Sobre o Objeto Connection ................................................................... 333 O Método Close ..................................................................................................................... 333 “Pool” de Conexões ............................................................................................................... 334 O Objeto RecordSet ...................................................................................................................... 335 Cursores .......................................................................................................................... 336 Localização do Cursor .................................................................................................... 339 Lock de Registros ............................................................................................................ 341 Propriedades do Objeto RecordSet ................................................................................ 343 Métodos do Objeto RecordSet ........................................................................................ 345 Uma Página ASP Para Inserir Informações no Banco de Dados ................................................. 347 Editando Registros em um Banco de Dados ................................................................................ 361 A Página ASP Para Selecionar o Produto a ser Alterado – produto.asp .............................. 362 A Página que Localiza o Registro do Produto a ser Atualizado – localiza.asp ........................... 365 A Página que Atualiza os Dados na Tabela Produtos do Banco de Dados Nwind.mdb – Atualiza.asp ........................................................................................ 370 Utilizando o Nosso Exemplo de Alteração de Registro ........................................................ 372 Eliminando Registros de um Banco de Dados ............................................................................ 375

Criando Sites Dinâmicos com ASP 3.0

A Página ASP Para Excluir o Produto Selecionado – Exclui.asp ......................................... 375 Utilizando o Nosso Exemplo de Exclusão de Registro ......................................................... 377 A Propriedade Filter do Objeto RecordSet .................................................................................. 380 Conclusão ..................................................................................................................................... 385 Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II ................................ 387 O Objeto Command ..................................................................................................................... 389 Um Breve Introdução ao Objeto Command ......................................................................... 389 Os Métodos do Objeto Command ......................................................................................... 393 As Propriedades do Objeto Command ................................................................................. 393 Consultas Parametrizadas no Microsoft Access ................................................................... 397 O Objeto Parameter ...................................................................................................................... 402 Utilizando o Objeto Command Para Passar Parâmetros Para uma Consulta Parametrizada ...... 403 Utilizando o Nosso Exemplo ................................................................................................ 414 Um Desafio Para o Amigo Leitor ........................................................................................... 415 Um Pouco Mais Sobre Pesquisas em Banco de Dados ................................................................ 417 A Utilização do Operador Like ............................................................................................. 418 A Utilização de Múltiplos Critérios ...................................................................................... 423 O Operador And ............................................................................................................. 423 O Operador Or ................................................................................................................ 424 Alguns Exemplos de Utilização de Múltiplos Critérios ....................................................... 424 Utilizando Funções de Agregação ......................................................................................... 426 Alguns Exemplos de Utilização de Funções de Agregação .................................................. 427 Um Formulário Genérico Para Pesquisas ..................................................................................... 437 Utilizando o Nosso Formulário de Pesquisa ......................................................................... 446 Conclusão ..................................................................................................................................... 450 Capítulo 8 – Aplicativos Web e Componentes .......................................................................... 453 Introdução .................................................................................................................................... 454 O que é uma Aplicação Web no IIS? ........................................................................................... 454 Uma Aplicação Cliente/Servidor Tradicional ...................................................................... 455 Aplicações Web – um Novo Paradigma ................................................................................ 456 Aplicações Web no IIS .......................................................................................................... 457 O Arquivo Global.asa ................................................................................................................... 465 Um Aplicativo só Pode ter um Arquivo Global.asa ...................................................... 466 O Objeto Application ................................................................................................................... 468 Eventos do Objeto Application ............................................................................................. 469 Evento Application_OnStart .......................................................................................... 469 Evento Application_OnEnd ........................................................................................... 478 Coleções do Objeto Application ........................................................................................... 478 A Coleção Contents ........................................................................................................ 479 A Coleção StaticObjects ................................................................................................. 483 Métodos do Objeto Application ............................................................................................ 483 O Objeto Session .......................................................................................................................... 486 Eventos do Objeto Session .................................................................................................... 487 O Evento Session_OnStart ............................................................................................. 488 Evento Session_OnEnd .................................................................................................. 496 Coleções do Objeto Session .................................................................................................. 496

XII

Sumário

A Coleção Contents ........................................................................................................ 497 A Coleção StaticObjects ................................................................................................. 501 Métodos do objeto Session ................................................................................................... 501 Propriedades do Objeto Session ........................................................................................... 503 Conclusão ..................................................................................................................................... 506 Capítulo 9 – Segurança de Aplicações Web com IIS e ASP ...................................................... 509 Autenticação de Usuários com o IIS 5.0 ..................................................................................... 512 O Acesso Anônimo ...................................................................................................................... 512 Como Definir a Conta Para Acesso Anônimo no IIS 5.0 ...................................................... 515 Verificando as Configurações da Conta Para Acesso Anônimo no Windows 2000 Server ......................................................................... 519 Configurando Permissões NTFS em Pastas do Servidor Web .............................................. 525 Sistemas de Arquivos no Windows 2000 e Permissões NTFS ............................................. 526 Definindo Permissões NTFS .......................................................................................... 529 Autenticação Básica ..................................................................................................................... 539 Autenticação Integrada do Windows ........................................................................................... 540 Autenticação Utilizando Certificados ......................................................................................... 541 Mapeamento do Certificado Cliente ..................................................................................... 541 Configurando o Tipo de Autenticação no IIS .............................................................................. 542 Mais Configurações de Segurança do IIS .................................................................................... 546 Configurando Opções Gerais de Segurança ......................................................................... 546 Configuração de Segurança Para Aplicativos Web no IIS .................................................... 550 Definindo Restrições de Acesso a Nível de Endereço IP ............................................................ 552 Mecanismos de Segurança do Banco de Dados .......................................................................... 557 Conclusão ..................................................................................................................................... 561 Capítulo 10 – Utilizando Componentes do IIS .......................................................................... 563 Introdução .................................................................................................................................... 564 O Objeto Server ............................................................................................................................ 564 Propriedade do Objeto Server ............................................................................................... 565 Métodos do Objeto Server ..................................................................................................... 566 O Método CreateObject .................................................................................................. 566 O Método Execute(“url”) ................................................................................................ 568 Exemplo .............................................................................................................................. 569 O Método GetLastError( ) ............................................................................................... 570 O Método URLEncode(“texto”) ...................................................................................... 571 O Método MapPath(“url”) .............................................................................................. 573 O Método Transfer(“url”) ............................................................................................... 574 O Método HTMLEncode(“texto”) ................................................................................... 575 Um Exemplo Prático de Utilização do Objeto Server ................................................................. 576 Utilizando Componentes do Servidor em Páginas ASP ............................................................. 586 O Componente Content Link ................................................................................................ 586 Criando um Objeto do Tipo Content Link ..................................................................... 588 Métodos do Objeto Content Link ................................................................................... 588 Um Exemplo que Utiliza o Componente Content Link ................................................ 591 O Componente Ad Rotator .................................................................................................... 596 O Arquivo de Programação da Rotatória ....................................................................... 597

XIII

Criando Sites Dinâmicos com ASP 3.0

URL ..................................................................................................................................... 598 Largura ................................................................................................................................ 598 Altura .................................................................................................................................. 598 Borda ................................................................................................................................... 599 URL_anúncio ...................................................................................................................... 599 URL_home_page_anúncio .................................................................................................. 599 Texto .................................................................................................................................... 599 Impressões .......................................................................................................................... 599 Exemplo .............................................................................................................................. 600 O Arquivo de Redirecionamento ................................................................................... 600 Exemplo .............................................................................................................................. 600 Propriedades do Objeto Ad Rotator ............................................................................... 601 Método do Objeto Ad Rotator ........................................................................................ 602 O Componente Page Counter ................................................................................................ 605 Os Métodos do Componente Page Counter ................................................................... 606 O Componente Browser Capabilities – Capacidades do Navegador ................................... 609 Conclusão ..................................................................................................................................... 615 Capítulo 11 – Os Objetos FileSystemObject, Drive, Folder e File ............................................. 617 Introdução .................................................................................................................................... 618 O Objeto FileSystemObject .......................................................................................................... 618 Propriedade do Objeto FileSystemObject ............................................................................. 619 Métodos do Objeto FileSystemObject .................................................................................. 620 Métodos do Objeto FileSystemObject Para Trabalho com Drives ................................. 620 Métodos do Objeto FileSystemObject Para Trabalho com Pastas ................................. 621 Métodos do Objeto FileSystemObject Para Trabalho com Arquivos ............................ 628 O Objeto Drive .............................................................................................................................. 634 Propriedades do Objeto Drive ............................................................................................... 634 O Objeto Folder ............................................................................................................................ 637 Propriedades do Objeto Folder .............................................................................................. 638 Métodos do Objeto Folder ..................................................................................................... 642 O Objeto File ................................................................................................................................ 644 Propriedades do Objeto File .................................................................................................. 644 Métodos do Objeto File ......................................................................................................... 647 Exemplo Prático ........................................................................................................................... 649 Conclusão ..................................................................................................................................... 652 Capítulo 12 – Tratamento de Erros, Transações e Outros Assuntos ......................................... 655 O Objeto ASPError ....................................................................................................................... 657 Propriedades do Objeto ASPError ........................................................................................ 657 Algumas Dicas Para Minimizar Erros .......................................................................................... 658 Erros de Sintaxe .................................................................................................................... 658 Erros de Semântica ou de Tempo de Execução .................................................................... 659 Erros Lógicos ......................................................................................................................... 661 Algumas Dicas Para Reduzir a Ocorrência de Erros ............................................................ 662 O Conceito de Transações e a Utilização de Transações em Páginas ASP ................................. 663 O Conceito de Transação ...................................................................................................... 664

XIV

Sumário

Colocando uma Página ASP no Contexto de uma Transação .............................................. 665 Estabelecendo um Script Transacional ................................................................................ 666 Restabelecendo ou Abortando um Script ............................................................................. 667 Gravando Eventos de Transação ........................................................................................... 667 Registrando um Componente no Gerenciador de Serviços de Componente ...................... 669 Escopo de Objeto ................................................................................................................... 672 Colocando Transações em Fila ............................................................................................. 672 Utilizando a Diretiva #include .................................................................................................... 673 As Diretivas @ ............................................................................................................................. 675 A Diretiva de Processamento @CODEPAGE ........................................................................ 676 A Diretiva de Processamento @ENABLESESSIONSTATE .................................................. 677 A Diretiva de Processamento @LANGUAGE ....................................................................... 678 A Diretiva de Processamento @LCID ................................................................................... 678 A Diretiva de Processamento @TRANSACTION ................................................................. 679 Conclusão ..................................................................................................................................... 680 Apêndice – Referência Rápida da Linguagem VBScript ........................................................... 681 Declarando Variáveis com VBScript ............................................................................................ 683 Operadores ................................................................................................................................... 684 Estruturas de Decisão e Laços de Controle em VBScript ............................................................ 685 Estrutura de Decisão If Then Else ........................................................................................ 685 Estrutura de decisão If Then ElseIf ....................................................................................... 686 O Laço For...Next ................................................................................................................... 686 O Laço For Each...Next .......................................................................................................... 686 A Estrutura Select Case...End Select .................................................................................... 686 A Estrutura Do While Condição...Loop ................................................................................ 687 Loop ....................................................................................................................................... 687 A Estrutura Do... Loop While Condição ............................................................................... 688 A Estrutura Do Until Condição...Loop ................................................................................. 689 A Estrutura Do... Loop Until Condição ................................................................................ 690 Comentários em VBScript ........................................................................................................... 691 Funções no VBScript .................................................................................................................... 692 Funções Para Conversão de Valores ............................................................................................. 692 ASC(String) .................................................................................................................... 692 Chr(número) ................................................................................................................... 692 CBool(expressão) ............................................................................................................ 692 CByte(expressão) ............................................................................................................ 693 CCur(expressão) ............................................................................................................. 693 CDate(data) ..................................................................................................................... 693 CDbl(data) ....................................................................................................................... 694 CInt(expressão) ............................................................................................................... 694 CLng(expressão) ............................................................................................................. 694 CSng(expressão) ............................................................................................................. 694 CStr(expressão) ............................................................................................................... 695 Fix(expressão) ................................................................................................................. 695 Hex(expressão) ............................................................................................................... 695 Int(expressão) ................................................................................................................. 695

Criando Sites Dinâmicos com ASP 3.0

Oct(expressão) ................................................................................................................ 695 Round(expressão,numcasasdecimais) ........................................................................... 695 Sgn(expressão) ................................................................................................................ 696 Funções Para Trabalho com Datas ............................................................................................... 696 Date( ) ............................................................................................................................. 696 DateAdd(intervalo,numerodeintervalos,data) ............................................................... 696 DatePart(intervalo,data) ................................................................................................. 697 DateSerial(ano,mês,dia) ................................................................................................. 698 DateValue(String) ........................................................................................................... 698 Day(data) ........................................................................................................................ 698 Hour(tempo) ................................................................................................................... 698 Minute(tempo) ................................................................................................................ 698 Month(data) .................................................................................................................... 698 MonthName(data) .......................................................................................................... 699 Now( ) ............................................................................................................................. 699 Second(tempo) ............................................................................................................... 699 Time( )............................................................................................................................. 699 TimeSerial(hora,minuto,segundo) ................................................................................. 699 TimeValue(String) .......................................................................................................... 700 WeekDay(data) ................................................................................................................ 700 WeekDayName(número) ................................................................................................ 700 Year(data) ........................................................................................................................ 700 Funções Matemáticas ................................................................................................................... 700 Atn(número) ................................................................................................................... 701 Cos(número) ................................................................................................................... 701 Exp(número) ................................................................................................................... 701 Log(número) ................................................................................................................... 701 Randomize( ) .................................................................................................................. 701 Rnd(número) .................................................................................................................. 701 Sin(número) ................................................................................................................... 702 Sqr(número) ................................................................................................................... 702 Tan(número) ................................................................................................................... 702 Funções Para Manipulação de Strings ......................................................................................... 702 FormatCurrency(expressão) ........................................................................................... 702 FormatDateTime(expressão,opção) ................................................................................ 702 FormatNumber(expressão,numdigitos) ......................................................................... 703 FormatPercent(expressão,numdigitos) ........................................................................... 703 InStr(String1,String2) ..................................................................................................... 703 LCase(string) ................................................................................................................... 704 Left(string,número) ........................................................................................................ 704 Len(string) ...................................................................................................................... 704 LTrim(string) ................................................................................................................... 704 Mid(string,start,número) ................................................................................................ 704 Replace(string,ocorrência,substituição) ........................................................................ 705 Right(string,número) ...................................................................................................... 705 RTrim(string) .................................................................................................................. 705 Space(número) ............................................................................................................... 705 StrComp(String1,String2) .............................................................................................. 705

XVI

Sumário

String(número,caractere) ............................................................................................... 706 StrReverse(string) ........................................................................................................... 706 Trim(string) ..................................................................................................................... 706 UCase(string) .................................................................................................................. 706 Índice Remissivo .......................................................................................................................... 707

XVII

Introdução – Sites Dinâmicos com ASP 3.0

Introdução Sites Dinâmicos com ASP 3.0

Criando Sites Dinâmicos com ASP 3.0

Neste livro vamos abordar diversos assuntos relacionados com a criação de sites dinâmicos. Desta forma, o leitor terá condições de aprofundar os seus conhecimentos em conteúdos de grande importância para a criação de aplicativos para a Web. Iremos apresentar, juntamente com conceitos teóricos, um grande número de exemplos e aplicações práticas em detalhes, para que o leitor tenha condições de entender com clareza os assuntos abordados. O trabalho de criar sites e aplicações para Intranet/Internet tornou-se bastante complexo. O profissional da Web precisa conhecer um número cada vez maior de ferramentas e tecnologias. A criação de sites, simplesmente através da utilização de páginas HTML, já não é capaz de gerar os resultados necessários. Hoje, um site na Internet ou na Intranet de uma empresa, deve apresentar as características destacadas a seguir: ➥ Geração dinâmica de conteúdo. ➥ Conexão de páginas com banco de dados. ➥ Personalização do conteúdo, de acordo com as preferências de cada usuário. ➥ Segurança no acesso a áreas restritas do site, somente para usuários autorizados e com nível de acesso adequado. ➥ Criptografia dos dados transmitidos, ofererecendo garantia de autenticidade e integridade das informações, principalmente para sites de Comércio Eletrônico, onde o usuário deve digitar informações importantes, tais como o número do cartão de crédito. ➥ Serviços como envio de mensagens ou grupos de discussão, diretamente através do site. ➥ Mecanismos de pesquisa rápidos e precisos. ➥ Layout atraente e funcional, de tal forma que o internauta possa, rapidamente, localizar o conteúdo desejado. ➥ Bom conteúdo e atualização constante. Desenvolver um site, que contenha essas características, não é uma tarefa simples. Exige o uso de diversas tecnologias e ferramentas de apoio, além, é claro, de profissionais competentes e adequadamente treinados. Com a utilização da tecnologia ASP 3.0 – Active Server Pages – podemos obter bons resultados na criação de sites com este nível de complexidade. Ao estudar os capítulos deste livro, o leitor aprenderá a utilizar essa tecnologia. O aprendizado de ASP é simples, principalmente para quem já conhece o Visual Basic ou o Visual Basic for Applications (linguagem de desenvolvimento para o Microsoft Office). Em várias situações, o código é bastante semelhante. A tecnologia está disponível através da utilização do Internet Information Services 5.0, como servidor Web, o qual pode ser instalado juntamente com o Windows 2000 Server. Podemos notar uma mudança no nome do servidor Web da Microsoft. A versão anterior era denominada Internet Information Server 4.0 – IIS 4.0; e a nova, Internet Information Services 5.0 – IIS 5.0.

Introdução – Sites Dinâmicos com ASP 3.0

Observe que o Server foi substituído por Services. No tópico sobre as novidades do IIS 5.0, irei explicar o que significa, na prática, esta mudança. Durante a instalação do Windows 2000 Server, podemos optar por instalar, ou não, o Internet Information Services 5.0. Ao longo deste livro estarei utilizando a abreviatura IIS 5.0 (para manter coerência com o padrão utilizado pela Microsoft no Resource Kit do Windows 2000 Server), ao fazer referência ao Internet Information Services 5.0. Caso não tenhamos instalado o IIS 5.0 na instalação do Windows 2000 Server, podemos adicioná-lo quando for necessário. Para isso, utilizamos o ícone Adicionar ou remover programas, no Painel de controle. No próximo tópico desta introdução, veremos como instalar o IIS 5.0. É importante salientar que o IIS 5.0, somente está disponível no Windows 2000 Server. Isso significa que não é possível você continuar utilizando o Windows NT Server 4.0 (com o qual está disponível o IIS 4, através da instalação do Option Pack 4.0) e apenas fazer o upgrade do IIS 4.0 para o IIS 5.0. Também é importante destacar que as novas características do ASP 3.0, somente estão disponíveis no IIS 5.0. Em outro tópico desta introdução estarei abordando essas novas características.

Equipamento e Software Necessário Para acompanhar todos os exemplos propostos no livro, precisamos de um computador com Windows 2000 Server instalado. Também faz-se necessário que o IIS 5.0 esteja instalado e corretamente configurado. A configuração mínima necessária depende de uma série de fatores. Se o equipamento vai ser utilizado como um servidor Web na Internet, vários são os aspectos a serem considerados, tais como: ➥ Aplicações implementadas e recursos de hardware necessários, como memória, disco e processador. ➥ Número estimado de acessos simultâneos e diários, sendo esta uma das estimativas mais difíceis de se obter, uma vez que o sucesso de um site pode ser determinado por um número muito grande de fatores, nem todos de fácil mensuração. ➥ Grau de segurança necessário desejável. Neste caso, entram questões como criptografia, uso de certificados digitais, criação de VPN – Virtual Private Networks (Redes Privadas Virtuais) –, procedimentos de recuperação de falha, plano de contingência, etc. ➥ Percentual de “folga” desejado para recursos tais como: memória, processador, disco. Ao projetar um site, é bastante comum utilizar hardware que atenda as necessidades atuais com uma certa folga, para que seja possível suportar crescimentos maiores do que os

Criando Sites Dinâmicos com ASP 3.0

estimados. Alguns sites famosos já enfrentaram problemas de crescimento além do esperado. Quando isso acontece, mais recursos de hardware precisam ser adicionados com o site em funcionamento. É a bem conhecida situação de “trocar o pneu com o carro andando”. Eu diria que hoje, na velocidade em que as mudanças acontecem, seria um pouco pior, algo como “trocar a turbina com o avião em pleno vôo”. Para maiores informações sobre como planejar a capacidade de hardware para um servidor Web com o IIS 5.0, consulte o capítulo “Capacity Planning” do livro “Internet Information Services Resource Guide”, parte integrante do Windows 2000 Server Resource Kit. Como equipamento para ser utilizado em casa, ou em um laboratório de teste na sua empresa, aconselho a seguinte configuração: ➥ Processador Pentium 200 ou superior. ➥ 64 MB de RAM, sendo 128 MB, altamente recomendável. ➥ 2 GB de disco rígido. Com menos de 64 MB de RAM, o Windows 2000 Server não pode ser instalado. Sendo detectada memória inferior a 64 MB durante o processo de instalação, o mesmo será suspenso. Além do Windows 2000 Server e do IIS 5.0, também precisaremos ter os seguintes programas e serviços instalados, para que possamos acompanhar os exemplos deste livro: ➥ Internet Explorer 4.x (ou superior) ou Netscape Navigator 4.x. ➥ Microsoft Transaction Services (vem junto com o Windows 2000 Server). ➥ Microsoft Index Services (vem junto com o Windows 2000 Server). Em cada um dos capítulos, estaremos apresentando vários exemplos práticos. Através destes exemplos, você poderá entender melhor a aplicação dos conceitos teóricos apresentados. Em muitas situações, a melhor maneira de entender um determinado assunto, é através da utilização do mesmo para resolução de um problema prático do dia-a-dia. Muitos dos exemplos apresentados, podem ser facilmente adaptados para uso em aplicações que você esteja desenvolvendo. Situações como acesso a banco de dados através de páginas Web, indexação e pesquisa de conteúdos, implementação de mecanismos de segurança, etc., são comuns a maioria das aplicações Web atuais. Agora vamos aprender a instalar o IIS 5.0.

Instalando e Testando o IIS 5.0 Caso você não tenha instalado o IIS 5.0, quando da instalação do Windows 2000 Server, é possível fazer a instalação quando for necessário. Agora aprenderemos, passo a passo, a instalar o IIS 5.0. Nunca é demais lembrar que sem o IIS 5.0, não será possível testar os exemplos práticos, propostos neste livro.

Introdução – Sites Dinâmicos com ASP 3.0

Para instalar o IIS 5.0: 1. Faça o logon no Windows 2000 Server. 2. Abra o Painel de controle (Iniciar/Configurações/Painel de controle). 3. Abra a opção Adicionar ou remover programas. 4. Surgirá a janela indicada na Figura 1.1.

Figura I.1: Janela Adicionar ou remover programas. 5. No lado esquerdo da janela, dê um clique na opção Adicionar ou remover componentes do Windows. 6. Surgirá a janela indicada na Figura 1.2.

Figura I.2: Janela para alterar a instalação do Windows.

Criando Sites Dinâmicos com ASP 3.0

7. Dê um clique no botão Componentes. 8. Será exibida, por breves instantes, uma mensagem “Aguarde...”. Depois surge a janela Assistente de componentes do Windows, conforme indicado na Figura 1.3.

Figura I.3: Janela Assistente de componentes do Windows. 9. Utilizando o Assistente de componentes do Windows podemos adicionar novos serviços, ou remover serviços que não sejam mais necessários. 10. Vá descendo com a barra de rolagem vertical, até localizar o item Internet Information Services (IIS), conforme indicado na Figura 1.4. Se esta opção estiver marcada, o IIS 5.0 já está instalado. Neste caso clique no botão Cancelar. Depois é só fechar a janela Adicionar ou remover programas e o Painel de controle. Se esta opção estiver desmarcada, significa que o IIS 5.0 ainda não foi instalado. Marque esta opção para instalar este serviço. Observe que ao marcar a opção, o botão Detalhes é habilitado. O IIS 5.0 é formado por uma série de componentes e funcionalidades. Existe um servidor de páginas (servidor HTTP), um servidor de FTP, um servidor de notícias (NNTP), etc. Ao instalarmos o IIS 5.0, podemos escolher um ou mais dos seus componentes, dependendo das necessidades do nosso site. Não é necessários que todos os componentes do IIS 5.0 sejam instalados. Por exemplo, se o serviço de cópia de arquivos não for necessário, não temos porque instalar o serviço de FTP.

Introdução – Sites Dinâmicos com ASP 3.0

Figura I.4: O serviço Internet Information Services (IIS).

DICA Instale somente os serviços realmente necessários. Não é uma boa idéia instalar todos os serviços disponíveis, já que somente alguns serão utilizados. Quanto mais serviços instalados, maiores as possibilidades de ataque e quebra da segurança do site, por parte de um hacker. 11. Clique no botão Detalhes. 12. Na lista de opções disponíveis, certifique-se de que somente as seguintes estão marcadas: ➥ Arquivos comuns. ➥ Documentação. ➥ Extensões de servidor do FrontPage 2000. ➥ Gerenciador de Internet Services (HTML). ➥ Servidor File Transfer Protocol (FTP). ➥ Servidor World Wide Web. ➥ Snap-In do Internet Information Services. 13. Observe que, após ter selecionado os componentes a serem instalados, o Windows 2000 Server, exibe o espaço em disco necessário, conforme indicado pela Figura 1.5.

Criando Sites Dinâmicos com ASP 3.0

Figura I.5: Indicação do espaço necessário no disco rígido. 14. Dê um clique em OK. Você estará de volta ao Assistente de componentes do Windows. 15. Dê um clique no botão Avançar para ir para a próxima etapa do assistente. 16. O Windows 2000 Server exibe uma janela indicando o progresso da Instalação, como na Figura 1.6.

Figura I.6: Progresso da instalação do IIS 5.0.

Introdução – Sites Dinâmicos com ASP 3.0

17. Caso o Windows 2000 Server não encontre os arquivos necessários à instalação no disco rígido, você será solicitado a inserir o CD de instalação do Windows, conforme indicado pela Figura 1.7.

Figura I.7: Mensagem solicitando o CD de instalação do Windows. 18. Insira o CD e dê um clique em OK. O Windows 2000 Server inicia o processo de cópia dos arquivos. 19. Após finalizada a cópia dos arquivos, o Assistente emite uma mensagem dizendo que o processo foi concluído com sucesso. 20. Dê um clique no botão Concluir para encerrar o Assistente. 21. Você estará de volta à janela Adicionar ou remover programas. Dê um clique no botão Fechar para sair desta janela. 22. Você estará de volta ao Painel de controle. Feche o Painel de controle. 23. Agora o IIS 5.0 está instalado e pronto para funcionar.

IMPORTANTE Caso você não tenha acesso a um computador com o Windows 2000 Server não tem problema. Você pode acompanhar a maioria dos exemplos deste livro, utilizando o Windows 2000 Professional. A maneira de instalar o IIS 5.0 é exatamente a mesma, quer seja no Windows 2000 Server, ou no Windows 2000 Professional. Para os exemplos mais simples, até mesmo o Personal Web Server, que acompanha o Windows 98, pode ser utilizado. Porém no Personal Web Server, não existem os conceitos de Transação e segurança disponíveis no IIS 5.0.

Agora que já temos o IIS 5.0 instalado, vamos testar se o mesmo está funcionando corretamente. Para testar se o IIS 5.0 foi instalado com sucesso: 1. Abra o Internet Explorer. 2. Digite o seguinte endereço: http://localhost.

Criando Sites Dinâmicos com ASP 3.0

Deve surgir uma janela conforme indicado na Figura 1.8.

Figura I.8: A página padrão do IIS 5.0, logo após a instalação. Esta é a página inicial padrão do IIS 5.0 logo após a instalação. Isto comprova que o IIS 5.0 foi instalado com sucesso. 3. Feche o Internet Explorer. No próximo tópico, irei apresentar as melhorias do IIS 5.0, em relação a versão anterior, IIS 4.0, dentre as quais destaca-se a versão 3.0 do ASP – Active Server Pages 3.0, com a qual estaremos trabalhando neste livro.

Novidades e Melhorias do IIS 5.0 O IIS 5.0 é a nova versão do Servidor Web da Microsoft, o qual é disponibilizado como um Serviço (conforme indicado pelo nome Services e não mais Server) do Windows 2000 Server. A versão anterior – IIS 4.0 – era instalada como parte do Option Pack 4.0, para o Windows NT Server 4.0. No Windows 2000 Server, o IIS 5.0 faz parte do próprio Sistema Operacional. Neste tópico, apresentaremos as principais novidades desta nova versão. Para simplificar o entendimento, classificarei as novidades em duas categorias, conforme descrito abaixo:

Introdução – Sites Dinâmicos com ASP 3.0

➥ Administração e serviços (FTP e HTTP). ➥ Desenvolvimento de aplicações Internet/Intranet.

Administração e Serviços Os novos recursos do IIS 5.0 aumentaram a sua estabilidade e segurança. Novos assistentes foram introduzidos para facilitar as tarefas mais comuns de administração e segurança. Eis algumas das novidades: ➥ Reinicialização de download: Agora o serviço de FTP é capaz de reinicializar um download que tenha sido interrompido, a partir do ponto em que a interrupção ocorreu, isso evita que tenhamos que começar do zero. Característica de grande utilidade, principalmente para arquivos grandes, uma vez que a velocidade da Internet ainda não é nenhuma maravilha. ➥ Compactação HTTP: Toda a informação, enviada via HTTP, pode ser compactada. Para arquivos de texto (arquivos com código HTML, por exemplo), o ganho é considerável – na maioria dos casos, acima de 70 %. Podemos utilizar compactação também com arquivos de imagens (.jpg, .gif), ou qualquer outro tipo de arquivo transmitido via HTTP. O browser deve ser capaz de descompactar a informação (Internet Explorer e o Netscape Navigator em versão 4.x, dentre outros). ➥ Assistentes de segurança: Novos assistentes facilitam a execução de tarefas relacionadas com a segurança. Por exemplo, o Assistente de Permissões (Permissions Wizard) facilita a tarefa de atribuir permissões de acesso de arquivo. Esta era uma tarefa complicada em versões anteriores, uma vez que a permissão efetiva, depende da combinação entre as permissões estabelecidas no Sistema Operacional (permissões NTFS) e as do IIS. Temos também um assistente para gerenciar Certificados. ➥ Contabilidade de processos (Process Accounting): Modificações introduzidas no kernel do Windows 2000 Server, permitem um controle bastante refinado nos processos que estão rodando. Com isso, pode ser determinado o quanto de processador cada site virtual está consumindo (lembrando que o IIS admite diversos sites em um único servidor). Com isso é possível determinar se um dos sites está consumindo, desproporcionalmente, tempo do processador. Por exemplo, pode ser que uma página ASP mal implementada, esteja elevando a carga no processador. Esta característica também pode ser utilizada por provedores de conteúdo, os quais hospedam sites de outras empresas, como um parâmetro para a cobrança do serviço de hospedagem do site. ➥ Melhor administração através do browser: Administrar o IIS 5.0, remotamente, através do browser ficou bem mais fácil. Além disso, a maioria das tarefas podem ser executadas através dele, o que não era possível em versões anteriores. O administrador também pode criar “Contas Administrativas” (conhecidas como Operadores), com permissões

Criando Sites Dinâmicos com ASP 3.0

limitadas a determinadas tarefas, por exemplo, criar diretórios virtuais. Com isso é possível distribuir a administração do IIS entre diversos Administradores. ➥ Web Distributed Authoring and Versioning (WebDAV): Permite que o autor de páginas, possa remotamente editar, mover ou eliminar arquivos. Também é possível editar as propriedades de arquivos e diretórios, remotamente, através de uma conecção HTTP. Com WebDAV, o autor está utilizando o HTTP como um protocolo de compartilhamento de arquivo. ➥ Autenticação Digest: Aumenta a segurança e a confiabilidade da autenticação dos usuários. Com a Autenticação Digest, é feito um hash das informações de senha antes da transmissão. Informações ligadas à sessão e a hora do sistema são adicionadas ao hash. Com isso, mesmo que a senha seja interceptada, não poderá ser decifrada. Os demais tipos de autenticação continuam existindo: HTTP Basic, Windows NT Challenge/Response e NTLM authentication (conhecida como “integrated Windows authentication”).

Desenvolvimento de Aplicações Internet/Intranet Muitas melhorias foram feitas nesta área. Vamos descrever, resumidamente, algumas das novidades. ➥ Proteção das aplicações: Por padrão, todas as aplicações rodam em um processo comum, o qual é separado do processo do IIS 5.0. Porém é possível rodar aplicações de maior importância (ou que necessitem de maior desempenho) em um processo separado. ➥ Principais novidades para páginas ASP – Active Server Pages: ➥ Novos métodos para o controle de fluxo da aplicação (Server.Transfer, Server.Execute, etc.). ➥ Melhorias no tratamento de erros. Teremos um capítulo deste livro dedicado ao tratamento de erros em páginas ASP. ➥ Scriptless ASP: Mesmo páginas que contenham somente código HTML podem ter a extensão .ASP. Com isso pode-se criar toda a estrutura do site utilizando páginas com a extensão .ASP e adicionar os scripts no momento oportuno. ➥ Integração com o XML – Extensible Markup Language. Ainda não ouviu falar de XML? O caso é sério. ➥ Novas maneiras para detectar as capacidades do browser do cliente. ➥ Melhorias de performance: Capacidade de self-tunning das páginas ASP. São muitas as novidades do IIS 5.0 e uma das melhores fontes para conhecê-las é o livro Internet Information Services Resource Guide (em Inglês), o qual, conforme descrito anteriormente, faz parte do Windows 2000 Server – Resource Kit.

Introdução – Sites Dinâmicos com ASP 3.0

É Hora de Começar Bem, já estamos com o IIS instalado e funcionando, conhecemos as novidades desta versão e estamos ansiosos para começar a trabalhar com páginas ASP, em sua versão 3.0. Pois é exatamente o que estaremos fazendo deste ponto em diante. Você aprenderá a utilizar os principais recursos do ASP 3.0, podendo criar páginas e aplicações para Web, com diversos recursos e funcionalidades. Abaixo apresento uma pequena descrição do conteúdo de cada capítulo deste livro. Caso você esteja iniciando os estudos sobre ASP, aconselho que leia os capítulos na seqüência apresentada. Caso já trabalhe com ASP, sinta-se a vontade para ler os capítulos na ordem que julgar mais adequada. Cada capítulo apresenta exemplos completos, os quais ilustram os conceitos teóricos apresentados. Em todos os exemplos, estou utilizando a linguagem VBScript, devido a sua funcionalidade e facilidade de aprendizado. Caso o leitor queira utilizar Java Script (agora formalmente ECMA Script), sinta-se à vontade.

Visão Geral dos Capítulos do Livro ➥ Capítulo 1: Apresentaremos uma visão geral sobre a criação de sites dinâmicos, bem como do desenvolvimento de aplicações para Internet/Intranet (também conhecidas como aplicações para a Web). Veremos o que é ASP, bem como as tecnologias utilizadas na criação de aplicações Web. ➥ Capítulo 2: Como em nossos exemplos estaremos utilizando a linguagem VBScript. Neste capítulo serão apresentados os conceitos básicos desta linguagem, juntamente com exemplos práticos de utilização dos conceitos apresentados. ➥ Capítulo 3: Apresentaremos aspectos adicionais da linguagem VBScript, aprendendo a utilizar funções, comandos e outros. Também aprenderemos sobre o conceito de eventos em páginas Web; além de aprender a criar código a ser executado em resposta a determinados eventos de uma página, como por exemplo o clique em um determinado botão de comando. ➥ Capítulo 4: Neste capítulo começaremos a estudar os objetos fornecidos pelo ASP 3.0. Veremos os diversos métodos e propriedades de cada objeto, bem como a relação entre eles. Utilizaremos alguns exemplos práticos para facilitar o entendimento dos conceitos apresentados. ➥ Capítulo 5: Neste capítulo aprenderemos a conectar páginas ASP com bancos de dados. Veremos como criar pesquisas personalizadas, utilizando como critério de pesquisa, valores fornecidos pelo cliente, através de um formulário. Trataremos de diversos métodos de acesso a bases de dados, desde a utilização de meios tradicionais, como

Criando Sites Dinâmicos com ASP 3.0

drivers ODBC, até métodos mais atuais, como a utilização de ADO (ActiveX Data Objects) e OLE-DB Providers. ➥ Capítulo 6: Neste capítulo trataremos de aspectos avançados de conexão de páginas ASP com bancos de dados. Veremos como implementar pesquisas avançadas, efetuar atualizações e alterações em bancos de dados. Analisaremos algumas situações usuais do dia-a-dia. Também serão abordados aspectos ligados à segurança no acesso às informações. ➥ Capítulo 7: Abordaremos a conexão de páginas ASP com banco de dados. Vamos realizar um estudo completo do objeto Command e aprender a utilizá-lo para enviar parâmetros para consultas Parametrizadas do Microsoft Access. ➥ Capítulo 8: Veremos os conceitos de sessão e estado da conexão. Será apresentado o conceito de aplicação Web. Aprenderemos, em detalhes, a utilizar os objetos Application e Session. Também aprenderemos sobre a função e como utilizar o arquivo global.asa. ➥ Capítulo 9: Trataremos de aspectos de segurança envolvendo páginas ASP. ➥ Capítulo 10: Estudaremos diversos componentes que já vem junto com o IIS e fornecem funcionalidades adicionais, bastante úteis na criação de aplicações Web. ➥ Capítulo 11: Neste capítulo faremos um estudo completo sobre um dos objetos mais complexos do ASP: FileSystemObject. Estudaremos todos os seus métodos, bem como os objetos derivados: Drive, Folder e File. ➥ Capítulo 12: Neste capítulo apresentaremos o objeto ASP Error. Também aprenderemos sobre o conceito de Transações, além de aprendermos a utilizar a diretiva #include e as diretivas @. ➥ Apêndice A: Teremos uma listagem dos comandos e funções mais utilizados na linguagem VBScript, que poderá ser usada como uma referência.

Então, “Mãos à obra” Bem, feitas as devidas apresentações, é hora de começarmos nossa jornada, rumo ao aprendizado de ASP. Cabe ressaltar a grande aceitação que vem tendo a tecnologia de Active Server Pages da Microsoft. Basta observar o grande número de sites na Internet que utilizam esta tecnologia. Também é grande o número de empresas que desenvolvem aplicativos para sua Intranet, utilizando-se da tecnologia ASP. Sem a menor sombra de dúvidas, a facilidade no aprendizado, aliada aos recursos oferecidos, é que tornaram a tecnologia de páginas ASP largamente difundida e utilizada. Quem já programa em Visual Basic, ou Visual Basic for Applications, ficará absolutamente à vontade para aprender a tecnologia ASP. Então, mãos à obra, vamos aprender ASP 3.0.

Capítulo 1 – Uma Introdução à Tecnologia ASP

Capítulo 1 Uma Introdução à Tecnologia ASP

Criando Sites Dinâmicos com ASP 3.0

A Internet faz parte da vida de um número cada vez maior de pessoas. Fazer compras, sem sair de casa; receber, diretamente no seu computador, as últimas notícias; comprar e vender ações; procurar emprego pela rede. Todos são exemplos de facilidades oferecidas pelo uso da Internet. Talvez seja mais simples enunciar o que não é possível de se fazer pela rede, do que listar todas suas possibilidades. Mas nem sempre foi assim. Para chegar ao nível que nos encontramos hoje, com a disponibilização dos mais variados serviços via Internet, muita evolução ocorreu. Desde os tempos de conteúdo meramente informativo, até a possibilidade de escutar rádio e fazer compras pela rede, muitas tecnologias novas surgiram. E o ritmo de evolução não pára, pelo contrário, parece acelerar cada vez mais. Neste capítulo veremos um pouco sobre esta evolução da Internet. Passaremos pelas diversas fases, desde a criação de sites com conteúdo estático, até os aplicativos de n-camadas atuais. Também veremos como a tecnologia ASP, contribui para a criação de sites dinâmicos. Com isso você verá em que situações é indicada a utilização de páginas ASP.

Era uma Vez uma Internet com Conteúdo Estático Neste tópico veremos um pouco sobre a história de Internet e seus conceitos básicos. Aprenderemos sobre os diversos elementos envolvidos quando um usuário acessa conteúdo da Internet. Também veremos as limitações e problemas dos sites pioneiros que criavam conteúdo estático.

Um Começo Quase sem Querer Poderíamos dizer que a origem da Internet foi casual e despretensiosa. Inicialmente, foi criada uma rede conhecida como ARPANET, utilizada pelo Departamento de Defesa norte-americano, alguns fornecedores e pesquisadores ligados a este departamento. Como a ARPANET mostrouse de grande utilidade, facilitando a troca de informações, acabou expandindo-se de uma maneira rápida e inesperada. Neste ponto, a idéia de uma rede de computadores para a troca de informações estava lançada. Mais tarde, foi criada uma rede baseada nas mesmas tecnologias da ARPANET, porém com uma abrangência maior (tanto geográfica, quanto de objetivos). A idéia era trazer os benefícios demonstrados pela ARPANET, para um número maior de pessoas e empresas. Eis que nascia a Internet. No final da década de 80, a Internet já era bastante conhecida nos meios acadêmicos do mundo inteiro. Nesta época, porém, ainda tínhamos a Internet sem a interface gráfica. Normalmente a troca de informações era feita por FTP, alguns aplicativos baseados em telnet, ou o popular “gopher”, que tornou-se bastante conhecido nos primeiros anos da década de 90. O gopher, basicamente, era um sistema baseado em opções de menu, para divulgação e pesquisa de informações. Até 1991 era proibido o tráfego de qualquer informação comercial pela Internet. Esta proibição era mantida pela National Science Fundation, entidade que financiou grande parte do desenvolvimento da Internet nos EUA, até este momento. Com a liberação, as empresas

Capítulo 1 – Uma Introdução à Tecnologia ASP

passaram a fazer uso da Internet para fins comerciais. Desde então a rede expandiu-se enormemente, atingindo, hoje, milhões de pessoas em todo o mundo. A popularização definitiva da rede veio com a criação de uma interface gráfica. Com a criação da linguagem HTML, servidores HTTP, e programas para acessar as páginas HTML armazenadas nos servidores (também conhecidos como browser ou navegadores), a Internet tornou-se mais popular do que nunca. Este foi o momento do surgimento da WWW – World Wide Web. Talvez a melhor tradução para World Wide Web seja: “Teia de Alcance Mundial”. Esta é a idéia que temos de Internet. Uma rede (teia) que conecta computadores do mundo inteiro (alcance mundial), proporcionando a troca de informações e uma infinidade de serviços e facilidades para as empresas e para o cidadão comum. Com certeza, os criadores da ARPANET, e depois da Internet, não imaginavam uma expansão e popularização tão rápida da rede. Hoje, vemos anúncios de sites na televisão, durante o Telejornal e na transmissão de partidas de futebol. A maioria dos jornais possui um caderno de informática, quase totalmente dedicado a assuntos relacionados com a Internet. Vemos reportagens sobre a rede em todas as revistas, e não somente nas especializadas em Informática, que agora dedicam quase a totalidade de suas matérias a assuntos da Internet. Enfim, a Internet já faz parte do nosso dia-a-dia; veio para ficar e facilitar a nossa vida. Agora vamos conhecer um pouco mais sobre a Internet e os diversos elementos que a compõem.

Uma Visão Geral da Internet e de Seus Elementos Encontrar uma definição precisa e unânime para a Internet é uma tarefa complexa. Vamos ver os elementos que a compõe, sem nos preocuparmos com definições formais. Por exemplo, o que é preciso para que o usuário doméstico possa acessar a Internet; onde fica e por onde circula a informação que está sendo acessada.

Internet

Usuário Servidor Web Páginas HTML estáticas

Usuário doméstico conectado à Internet através da linha telefônica.

Figura 1.1: Uma visão geral da Internet, com conteúdo estático.

Criando Sites Dinâmicos com ASP 3.0

Antes de continuar com as explicações, considere o diagrama indicado na Figura 1.1. Nesta figura, temos representados os elementos mais comuns da Internet, conforme descrito a seguir. ➥ Usuário: Representamos um usuário residencial. Normalmente este tipo de usuário faz a conexão através da linha telefônica comum. Para isso é preciso a utilização de um provedor de acesso, que fornece a conexão com a Internet. O usuário utiliza um programa conhecido como navegador (browser), para acessar o conteúdo da Internet. Os dois navegadores mais conhecidos são o Internet Explorer da Microsoft, e o Netscape Navigator da Netscape. Quando o usuário acessa um determinado conteúdo, dizemos que ele está acessando um site (também encontramos o uso da palavra “página”, ao invés de site). Por exemplo, quando o usuário acessa o endereço http://www.microsoft.com/brasil, dizemos que ele está acessando a página, ou o site, da Microsoft Brasil. Quando o usuário acessa o endereço http://wwww.microsoft.com/vbasic, dizemos que o usuário está acessando a página do Visual Basic, no site da Microsoft. Durante este livro, estarei utilizando a palavra página, significando que o usuário está acessando um determinado conteúdo na Internet, ou na Intranet da empresa. ➥ Internet: Pelo fato de ser formada por um grande número de equipamentos – servidores, hubs, switch, linhas de comunicação, satélites, etc. –, representamos a Internet como uma nuvem. Esta é a representação que você encontrará na maioria dos livros. ➥ O servidor Web: Neste caso é o servidor que contém a informação solicitada pelo usuário. Por exemplo, ao digitar www.axcel.com.br, no campo endereço do navegador, o usuário está solicitando que seja carregado o conteúdo da página inicial do site da Editora Axcel Books. Observe que o servidor também está conectado à Internet, isto é, faz parte da Internet. As páginas armazenadas no servidor são desenvolvidas utilizandose a linguagem HTML – Hypertext Markup Language. Você pode encontrar muita informação sobre HTML na própria Internet. O órgão responsável pela padronização da linguagem HTML é o w3. No site www.w3.org, você pode encontrar um grande volume de informações sobre HTML. Na Figura 1.1, representamos a primeira geração de conteúdo da Internet. Conforme indicado pela seta maior, a informação trafegava, basicamente, em um único sentido. O usuário solicita um determinado conteúdo, e o mesmo é entregue e exibido no seu navegador. Observe que o usuário não tem a possibilidade de enviar informações para o servidor. Além disso, nesta primeira fase o conteúdo das páginas é estático. Uma vez criada a página (através da utilização do HTML), a mesma não é modificada. Cada vez que o usuário se conectar à página, verá o mesmo conteúdo. A única maneira de alterar o conteúdo, é alterando o código HTML. Com isso, da próxima vez que o usuário se conectar à página, verá a nova versão da mesma. Porém esta metodologia de modificação de páginas é trabalhosa e pouco produtiva. Imagine que você esteja publicando um catálogo de produtos, com informações diversas sobre vários produtos, tais como: código do produto, descrição e

Capítulo 1 – Uma Introdução à Tecnologia ASP

preço. Uma das maneiras de criar este catálogo é através da utilização do código HTML, para criar na página uma tabela com informações sobre os diversos produtos. Porém cada vez que houver uma modificação em um dos produtos, você terá que editar a página e salvar a nova versão da mesma. Convenhamos que é um processo bastante trabalhoso. Embora trabalhoso, era assim que funcionavam os primeiros sites, no início da era WWW. O conteúdo era estático, ou seja, alterações nas páginas, implicavam em alterações, diretamente no código HTML das mesmas. Imagine o trabalho para a manutenção de grandes sites, com diversas áreas de informações, onde o número de páginas pode facilmente chegar na casa dos milhares. Com isso a evolução para a criação de conteúdo mais dinâmico, foi um processo natural e necessário.

Conteúdo Dinâmico na Internet Com o crescimento da Internet e a necessidade de constantes alterações no conteúdo das páginas, surge uma segunda geração de sites na Internet, capazes de entregar conteúdo mais atualizado, além de permitir que o usuário interagisse com as páginas Web, também enviando informações e não apenas recebendo. Nesta fase surge a possibilidade de ligação das páginas HTML com o conteúdo de bancos de dados. Observe o diagrama indicado na Figura 1.2.

A conexão de páginas HTML com bancos de dados, permite a criação de páginas mais dinâmicas e interativas. Internet

Usuário Usuário doméstico conectado a Internet através da linha telefônica.

Servidor Web Páginas HTML dinâmicas

Agora o usuário pode enviar e receber informações.

Servidor de Banco de Dados Ex.: Microsoft SQL Server.

Figura 1.2: Conectando páginas HTML com bancos de dados. Pelo diagrama, podemos ver que o usuário tem possibilidade de enviar informações para a Internet, e não apenas receber. Isto possibilitou o desenvolvimento de uma série de serviços, impossíveis de serem desenvolvidos apenas com a utilização de páginas criadas com HTML.

Criando Sites Dinâmicos com ASP 3.0

Para enviar informações, o usuário preenche os campos de um formulário (o qual é criado com a utilização de HTML) e, ao clicar em um botão Enviar, os dados são enviados para o site da Web. Ao chegar no servidor Web, estes dados precisam ser “recebidos” por um programa capaz de entender o formato dos dados e armazená-los em um banco de dados. Os primeiros programas, capazes de realizar esta tarefa, seguiam a especificação conhecida como CGI – Common Gateway Interface. Muitas aplicações Web foram desenvolvidas utilizando-se a especificação CGI, e várias ainda continuam sendo utilizadas. A utilização de scripts, desenvolvidos na linguagem Perl, é um exemplo de utilização de CGI. O script recebe os dados enviados pelo formulário, os decodifica e armazena o resultado em um banco de dados. Embora bastante funcional, a utilização de CGI começou a apresentar alguns problemas, e novas alternativas foram desenvolvidas. Está fora do escopo deste livro discutir os problemas da utilização de CGI. Dentre as várias alternativas que surgiram para a geração de conteúdo dinâmico, podemos citar a tecnologia de Active Server Pages, a qual faz parte do servidor Web IIS (Internet Information Services), da Microsoft. Podemos criar uma página ASP, capaz de receber os dados enviados por um formulário e armazenar estes dados em um banco de dados, por exemplo o Microsoft Access ou o Microsoft SQL Server. Aprenderemos a criar este tipo de página ASP, no Capítulo 4. Agora veremos apenas alguns exemplos simples da utilização de ASP, sem conexão com bancos de dados. Com a conexão de páginas com bancos de dados, uma série de possibilidades foram abertas, como por exemplo: ➥ Criação de páginas para pesquisa em banco de dados. ➥ Cadastro de usuários que acessam o site, bem como a entrega de conteúdo personalizado, de acordo com as preferências do usuário. Por exemplo, ao entrar no site, o usuário informa um nome e senha, com os quais foi previamente cadastrado. Com isso é aberta uma página com opções e conteúdo personalizados, de acordo com preferências especificadas pelo usuário. ➥ Desenvolvimento de aplicações residentes em servidores Web e acessíveis através do navegador. Devemos observar que estas aplicações ainda eram limitadas e não possuíam todas as funcionalidades das aplicações convencionais, desenvolvidas para o ambiente Windows. Apesar das suas limitações, um novo panorama desenhava-se na Internet com a possibilidade da criação de sites mais dinâmicos, através da conexão com bancos de dados. Apenas para exemplificar o funcionamento de uma pesquisa em banco de dados, através da Internet, observe a Figura 1.3.

Capítulo 1 – Uma Introdução à Tecnologia ASP

A conexão de página HTML com bancos de dados, permite a pesquisa em bancos de dados.

Internet

Agora o usuário pode enviar e receber informações. Usuário Usuário digita o critério de pesquisa em uma página Web.

No servidor Web, um script CGI, ou uma página ASP, recebe o critério de pesquisa, executa a consulta no banco de dados, monta uma página HTML, com o resultado de volta para o navegador do usuário.

Servidor de Banco de Dados Ex. Microsoft SQL Server.

Figura 1.3: Pesquisa em um banco de dados, através da Internet. Vamos analisar os passos executados, desde o momento que o usuário preenche o critério de pesquisa, até o momento em que o resultado da consulta é retornado: ➥ O usuário acessa a página onde temos um formulário para a digitação de um ou mais critérios de pesquisa. Por exemplo, pode ser uma consulta a uma base dos CEP’s de todo o Brasil. O usuário poderia digitar o nome da Cidade, selecionar um Estado e digitar o nome, ou parte do nome, da Rua, conforme indicado pela Figura 1.4. ➥ Após preencher o(s) critério(s) de pesquisa, o usuário clica em um botão Enviar ou Pesquisar. Os dados digitados no formulário são enviados para o servidor. ➥ Um script CGI, ou uma página ASP, no servidor, recebe os dados enviados pelo usuário. Com estes dados, é montado um comando (normalmente uma String SQL – Structured Query Language), o qual vai efetuar a consulta no banco de dados. Após montado o comando, o mesmo é enviado para o servidor de Banco de Dados (que pode ser uma máquina separada, ou pode estar instalado no próprio servidor Web). ➥ O servidor de Banco de Dados recebe o comando de pesquisa, localiza um ou mais registros que atendam o(s) critério(s) de pesquisa e retorna o resultado para o script CGI, ou para a página ASP. ➥ Com o resultado retornado pelo servidor de Banco de Dados, o script CGI, ou a página ASP, monta uma página HTML, normalmente no formato de uma tabela, e envia esta página HTML de volta para o navegador do cliente, conforme indicado na Figura 1.5. Caso não seja encontrado nenhum registro que atenda o(s) critério(s) especificado(s), é retornada uma página com uma mensagem de que não foi encontrado nenhum registro.

Criando Sites Dinâmicos com ASP 3.0

Figura 1.4: Digitando os critérios de pesquisa em um formulário criado com HTML.

Figura 1.5: Resultados obtidos a partir de um banco de dados do CEP.

Capítulo 1 – Uma Introdução à Tecnologia ASP

Veja que ao mesmo tempo em que aumentaram as possibilidades de desenvolvimento, também aumentaram as complexidades a serem gerenciadas, tanto na criação de páginas, quanto no gerenciamento dos sites. Observe que ainda nem falamos de questões tais como segurança, proteção do banco de dados contra acessos não-autorizados, ou até mesmo ataques de hackers tentando roubar informação ou corromper a informação do banco de dados. Além das novas complexidades, novas questões ainda precisavam ser resolvidas (sendo que algumas ainda hoje não estão completamente solucionadas). Por exemplo, para vender pela Internet, as questões de segurança precisavam ser bem resolvidas. Quem arriscaria a colocar o número do cartão de crédito em um site de Comércio Eletrônico, sem a garantia de que o mesmo seja seguro? Além disso, existe a necessidade de troca de informações entre as diversas empresas, via Web. Por exemplo, quando você vai fazer uma compra pela Internet, você digita o número do seu cartão de crédito. Antes de finalizar o pedido, a empresa que está vendendo precisa verificar, junto a operadora do cartão, se o número fornecido é válido, se não é um cartão vencido, se não é um cartão que foi roubado, etc. Todas estas informações precisam ser verificadas rapidamente, em tempo real. O usuário não está a fim de aguardar muito tempo em frente ao computador. Note que um número grande de fatores começa a surgir, principalmente com o início do Comércio Eletrônico. Para resolver tantos problemas, a simples conexão de páginas com bancos de dados, embora necessária, não era mais suficiente. No próximo item veremos um pouco mais sobre esta nova geração de sites Web, os quais fazem uso de diversas tecnologias. Lembrando que a cada dia novidades estão surgindo.

A Era do Comércio Eletrônico Estamos vivendo um nova era, a qual é marcada pelo Comércio Eletrônico, ou o chamado ebusiness. Todas as revistas especializadas e meios de comunicação apresentam matérias, diariamente, sobre Comércio Eletrônico. As possibilidades são inúmeras, tanto para as empresas quanto para os usuários e profissionais envolvidos. O Comércio Eletrônico deixou de ser apenas uma previsão em livros e revistas, e passou a ser uma realidade, presente no dia-a-dia de todos nós. Com isso uma nova geração de sites está sendo criada, muito mais complexa do que a anterior, necessitando de ferramentas de desenvolvimento e gerenciamento cada vez mais sofisticadas. Grande parte do orçamento de informática das empresas está direcionada para atividades ligadas ao Comércio Eletrônico. Novas tecnologias surgem todos os dias, prometendo facilitar a criação de sites para essas e outras atividades relacionadas. Neste tópico veremos quais as tecnologias necessárias para criação destes sites, bem como as complexidades envolvidas.

Criando Sites Dinâmicos com ASP 3.0

O Comércio Eletrônico pode acontecer de duas maneiras distintas: ➥ B2B – Business to Business: Acontece quando são feitas transações comerciais entre duas empresas. Pode ser uma montadora de automóveis comprando peças de um fornecedor, ou uma livraria encomendando livros de uma editora. Em termos de volume financeiro, o B2B é responsável por um grande percentual do que é comercializado via Internet. ➥ B2C – Business to Consumer: É um cliente, como eu e você, comprando um livro ou um CD através de uma loja virtual na Internet. Hoje existem sites de Comércio Eletrônico que vendem uma série de coisas: livros, revistas, cosméticos, CD’s, roupas, e até remédios e carros. À medida que aumenta o número de sites de Comércio Eletrônico, aumenta, também, a concorrência. Portanto, conquistar e manter clientes têm sido o grande desafio. Não basta colocar um catálogo de produtos, garantir a segurança e entregar a mercadoria no local indicado e no prazo estipulado. Embora estas sejam questões fundamentais, não são mais suficientes para garantir a fidelidade do cliente, pois, diferentemente do comércio tradicional, no Comércio Eletrônico, o concorrente está apenas a um clique de mouse. Hoje, um dos grandes desafios é conhecer o cliente, saber identificar seus hábitos e armazenar o maior número de informações sobre ele, tal como o histórico de compras e pesquisas realizadas no catálogo de produtos. De posse destas informações, o site deve ser capaz de fazer ofertas personalizadas para o cliente. Posso citar o meu caso como exemplo. Há tempos que compro livros importados em um determinado site. Ao acessar o site, após me identificar, aparece um link: “Sugestões para o Júlio”. Vejam que até o link já vem personalizado; isso atrai o cliente. É como entrar no mercadinho da esquina e o seu Manoel ir dizendo: “Olá seu Júlio, aquele queijo colonial que o Sr. gosta, chegou.” Ao clicar no link de sugestões, recebo uma listagem de livros. O mais interessante é que, nesta listagem, realmente estão os livros nos quais estou interessado. Que milagre é este? Não é milagre nenhum. Desde a primeira compra, o site vem armazenando informações sobre as pesquisas que faço no catálogo de livros e sobre o que efetivamente compro. Com isso, foi possível identificar minhas preferências e elaborar uma lista de sugestões personalizada. Quanto maior a quantidade de informações, mais precisa será esta lista de sugestões. Vejam que os sites de Comércio Eletrônico estão tentando fazer o que o seu Manoel do mercadinho da esquina faz há muitos anos. Estão tentando dar um tratamento personalizado para os seus clientes, com o objetivo de mantê-los satisfeitos. Clientes satisfeitos significam vendas e lucros para a empresa. Conhecer as preferências do cliente é apenas um dos exemplos de aplicação a partir de dados obtidos pelo site. Com uma base de dados grande e confiável, muitas outras aplicações podem ser construídas sobre esses dados. Por isso que, a maioria dos sites, mesmo os que fornecem serviços gratuitos, exigem que você preencha um cadastro, antes de disponibilizar o acesso a

Capítulo 1 – Uma Introdução à Tecnologia ASP

serviços e informações. Com as informações obtidas através do cadastro, a empresa está tentando montar a sua base de dados. Vejam que os dados precisam ser obtidos e armazenados em um banco de dados. Depois, a segurança dos dados precisa ser garantida. Já pensou se alguém consegue invadir o site de uma empresa e obter uma listagem de números de cartões de crédito? Seria péssimo para a imagem e para as vendas desta empresa. Além da segurança, novas aplicações estão sendo construídas para fazer uso destes dados, com o objetivo não só de melhorar as vendas, mas também de melhorar as relações com os clientes. Não basta que a empresa seja capaz de vender; para sobreviver ela precisa continuar vendendo para o cliente. Para continuar vendendo, isto é, para fidelizar o cliente, a área de atendimento é de fundamental importância. Se você compra, por exemplo, um CD e o mesmo é entregue fora do prazo, você reclama. Se sua reclamação não for satisfatoriamente atendida, você deixará de comprar desta empresa e irá procurar outra. Afinal na Internet, o concorrente está a um clique de mouse. Um dos assuntos mais discutidos no momento é representado pela sigla CRM – Customer Relationship Management. Traduzindo teríamos: Gerenciamento das Relações com o Cliente. CRM representa um conjunto de soluções – de hardware e software –, capazes de melhorar a relação das empresas com os clientes, principalmente no atendimento às questões do cliente, quer seja suporte técnico, dúvidas sobre novos produtos, etc. Quem já não ligou para uma central de atendimento e teve que contar a mesma história uma dezena de vezes. Você liga alguém atende. Você descreve o seu problema, a pessoa diz que não é com ela e passa para um outro setor. Um novo atendente e a mesma história; você é passado para um outro setor. Depois da décima transferência (considerando que você seja uma pessoa paciente, senão após a terceira você já desligaria o telefone), você desliga irritado, sem ter solucionado o problema. Muito provavelmente, esta empresa acaba de perder mais um cliente. Clientes não são raros, raras sãs as empresas que conseguem fidelizá-lo de forma eficiente. Melhorar o atendimento ao cliente, ou de uma maneira mais genérica, a relação dos clientes com a empresa, é o objetivo do CRM. Ao ligar para uma central de atendimento, a pessoa identifica-se através do seu código de cliente, o sistema de CRM busca em uma base de dados consolidada todas as informações sobre o cliente. Então, ele descreve o problema, que é inserido no sistema. Caso o atendente não seja capaz de solucioná-lo, a chamada é transferida diretamente para a pessoa capaz de solucionar o problema. O cliente não precisa repetir toda a história porque toda a descrição do problema também está acessível à pessoa que irá atendê-lo (os dados foram passados pelo sistema de CRM, quando da transferência do chamado). O cliente é atendido, soluciona o seu problema e fica satisfeito. Cliente satisfeito continua comprando.

Criando Sites Dinâmicos com ASP 3.0

A descrição do parágrafo anterior representa uma situação ideal; é claro que os sistemas de CRM ainda não são perfeitos. Porém novas técnicas estão sendo introduzidas, através da possibilidade de atendimentos via Internet, acessando o site da empresa. Com a melhoria dos sistemas de telecomunicações, poderemos tornar realidade um atendimento de alta qualidade e conclusivo, através da Internet. Por exemplo, o cliente está pesquisando o catálogo de produtos. Na página com os dados do produto, existe um link “Outras dúvidas”. Ao clicar neste link, o cliente entra numa seção de bate-papo com um atendente da empresa. O cliente pode colocar as suas dúvidas, que serão respondidas em tempo real. Tendo as dúvidas solucionadas, há maior probabilidade de ser feito um pedido. Além disso as dúvidas do cliente podem ser armazenadas no banco de dados. Quando uma determinada dúvida começar aparecer com certa freqüência, os dados que a solucionam podem ser disponibilizados no catálogo. Assim, os próximos clientes que tiverem a mesma dúvida, não precisarão entrar em contato com o atendimento. Vejam que novamente estamos em um processo de aquisição de informações, através do próprio site, e utilização destas informações para melhorar a qualidade dos serviços e produtos oferecidos. No B2B também existem muitas questões a serem gerenciadas. Para entendermos a complexidade destas situações imagine o seguinte exemplo, ilustrado pela Figura 1.6. Concessionárias

Fornecedores

Servidor

Figura 1.6: A complexidade das questões envolvidas no B2B. Temos uma rede de concessionárias que prestam serviços de manutenção para uma determinada marca de automóveis. O objetivo é ter um controle automatizado de estoque. Cada peça catalogada possui um nível mínimo de unidades em estoque. Quando este nível é atingido, o banco de dados deve lançar um pedido para este item automaticamente. O funcionamento do sistema é descrito a seguir.

Capítulo 1 – Uma Introdução à Tecnologia ASP

O cliente vai na concessionária para comprar uma determinada peça. O atendente efetua a venda e o estoque é atualizado. Se a peça atingir o nível mínimo, previamente estabelecido, um pedido será automaticamente gerado. Este pedido contém informações sobre a concessionária, bem como sobre as peças que estão sendo encomendadas. As informações sobre o pedido são criptografadas para garantir a segurança, e o pedido é enviado, via Internet, para o fornecedor da peça. Dentro de um prazo preestabelecido, a peça é entregue, evitando que a mesma fique com estoque zerado. Observe que, neste caso, existe uma troca de informações entre as concessionárias e os fornecedores. Para que possa haver esta troca de informações, os sistemas das duas empresas devem ser capazes de trocar dados em um formato comum, efetuando negócios através da Internet. Vamos introduzir algumas questões que complicam um pouco mais a infra-estrutura necessária para a realização do B2B. Por exemplo, ao invés de comprar uma determinada peça sempre do mesmo fornecedor, o sistema deve ser capaz de enviar o pedido para vários fornecedores, e selecionar aquele que fizer a melhor oferta, tanto em termos de preço quanto de prazo de entrega. Neste caso, a concessionária lança o pedido no seu site e aguarda as propostas dos fornecedores. Após recebidas as respostas, uma delas é selecionada. Este parece ser um sistema de leilão ao contrário, ou seja, o comprador anuncia que está precisando de um determinado produto, e os fornecedores esforçam-se para fazer a melhor proposta. Esta forma de fazer compras é conhecida como e-procurement. Em determinados casos, a lista de propostas está disponível para todos os fornecedores, isto é, se um fornecedor A fez uma proposta e, depois, ao consultar a lista, viu que um fornecedor B fez uma melhor do que a sua, ele pode alterar a sua proposta, dentro do período de tempo estipulado pelo comprador, no nosso caso, a concessionária. Vejam que mesmo no sistema de B2B, a lógica tem sido revertida em favor do cliente, isto é, os fornecedores é que disputam o cliente, através de boas ofertas, preços competitivos e prazos adequados de entrega. Porém a criação de sistemas deste tipo é uma tarefa complexa. A todo o momento temos acesso a informações de bancos de dados, questões de segurança no acesso a essas informações, além de uma lógica bastante complicada. Em diversos pontos do processo podemos fazer uso da tecnologia ASP, para criar soluções bem interessantes. O uso de páginas ASP, em conjunto com outras tecnologias, possibilita a criação de soluções complexas como as exemplificadas neste capítulo.

Criando Sites Dinâmicos com ASP 3.0

Vamos inserir mais alguns detalhes no nosso exemplo. Pode ser que além de fazer o pedido, uma vez aprovada a compra, a concessionária deva fazer o pagamento do mesmo, por meio de uma transação on-line. O pagamento pode ser feito, por exemplo, através de uma transferência da conta corrente da concessionária para a conta corrente do fornecedor. Neste ponto, precisamos introduzir o conceito de transação, o qual será bastante detalhado no Capítulo 12, Conceitos Avançados: Transações e o Microsoft Transaction Services. Uma transação, de maneira bastante simples, é um conjunto de ações que deve acontecer como um todo, ou seja, todas as ações contidas na transação têm que ser finalizadas com sucesso, ou nenhuma delas deve ser realizada. Caso uma das ações, contida na transação, falhe, as que ainda estiverem pendentes devem ser canceladas; e as ações já realizadas devem ser revertidas. Com isso garantimos que a transação acontece como um todo, ou que nenhuma das suas ações são realizadas. Para entender, na prática, o conceito de transações, vamos voltar ao exemplo anterior. Ao efetuar um pagamento, o sistema deve transferir valores da conta corrente da concessionária, para a conta corrente do fornecedor. Estas duas ações devem acontecer no contexto de uma transação, conforme indicado abaixo: Início da Transação Ação 1: Debita o valor da conta corrente da concessionária. Ação 2: Credita o valor na conta corrente do fornecedor. Final da Transação A primeira ação efetua o débito na conta corrente da concessionária. Suponhamos que a Ação 1 ocorra com sucesso, porém na hora de fazer o crédito na conta corrente do fornecedor, ocorra um problema, o que devemos fazer? O valor deve ser estornado para a conta da concessionária, ou seja, a Ação 1 deve ser cancelada, uma vez que nem todas as ações dentro da transação puderem ser concluídas com êxito. Vejam a importância do conceito de transação, pois neste caso, se não usássemos transação, o valor seria debitado da conta corrente da concessionária e não teria sido creditado na conta corrente do fornecedor. Poderíamos entrar em níveis cada vez mais profundos, sobre os aspectos tecnológicos necessários à realização do Comércio Eletrônico. Porém estas questões fogem ao escopo deste livro (quem sabe em um trabalho futuro...). Neste livro estaremos aprendendo a utilizar a tecnologia ASP para abordar alguns destes aspectos, através de exemplos práticos e detalhadamente explicados.

Capítulo 1 – Uma Introdução à Tecnologia ASP

Aplicações Para a Web Embora utilizamos os exemplos de Comércio Eletrônico, CRM, e-procurement, etc., como situações onde podemos utilizar a tecnologia ASP, não é somente nestas situações que a tecnologia pode ser utilizada. Hoje em dia, com o aumento da complexidade das redes de computadores baseadas em PC’s, existe uma tendência bastante acentuada em favor do desenvolvimento de aplicações que seguem o modelo Web. São aplicações que são acessadas através de um browser. Neste tópico iremos falar um pouco sobre aplicações Cliente/Servidor tradicionais e os problemas deste tipo de modelo. Falaremos sobre aplicações em duas, três ou n camadas, e onde a tecnologia ASP se encaixa, neste mundo de desenvolvimento de aplicações habilitadas para a Web.

A Complexidade de Gerenciamento do Modelo Cliente/Servidor e Aplicações em Duas Camadas O modelo Cliente/Servidor foi criado tendo como base a descentralização dos dados e recursos de processamento, em oposição ao modelo centralizado utilizado na época em que o mainframe dominava absoluto. Neste modelo, conforme indicado pela Figura 1.7, em uma rede de computadores existem uma ou mais máquinas que atuam como Servidores, disponibilizando recursos para as demais máquinas, as quais atuam como Clientes. Servidor de Arquivos

Clientes

Bancos de Dados

Clientes

Outros Servidores

Clientes

Figura 1.7: O Modelo Cliente/Servidor tradicional. Conforme pode ser visto na Figura 1.7, temos servidores para arquivos, banco de dados e outras funções, tais como: Servidores de impressão, servidores Web, etc. Tipicamente estas redes são formadas por servidores, que são equipamentos com um maior poder de processamento e armazenamento do que os Clientes, os quais, na maioria dos casos, são microcomputadores ligados em rede.

Criando Sites Dinâmicos com ASP 3.0

Aplicações em Duas Camadas No início da utilização do modelo Cliente/Servidor, as aplicações foram desenvolvidas utilizando-se um modelo de desenvolvimento em duas camadas. Neste modelo, um programa, normalmente elaborado em um ambiente de desenvolvimento – como o Visual Basic, Delphi ou Power Builder –, é instalado em cada cliente. Este programa acessa dados em um servidor de Banco de dados, conforme ilustrado na Figura 1.8. Banco de Dados

No modelo de duas camadas, toda a "Lógica do negócio" fica no Cliente. Quando o programa Cliente é instalado, são instaladas todas as regras de acesso ao banco de dados.

Cliente

Figura 1.8: O modelo de desenvolvimento em duas camadas. No modelo em duas camadas, temos um programa que é instalado no cliente, e que faz acesso a um banco de dados residente no servidor de Banco de Dados. Na maioria dos casos, a máquina do cliente é um PC rodando Windows, e a aplicação cliente é desenvolvida utilizandose um dos ambientes conhecidos, conforme citado anteriormente. Sendo a aplicação Cliente, um programa para Windows (na grande maioria dos casos), a mesma deve ser instalada em cada um dos computadores da rede, que farão uso da aplicação. É o processo de instalação normal, para qualquer aplicação Windows. No modelo em duas camadas, a aplicação Cliente é responsável pelas seguintes funções: ➥ Apresentação: O código que gera a interface visível do programa faz parte da aplicação Cliente. Todos os formulários, menus e demais elementos visuais, estão contidos no código da aplicação Cliente. Caso sejam necessárias alterações na interface do programa, faz-se necessária a geração de uma nova versão do programa, e todos os computadores que possuem a versão anterior, devem receber a nova versão, para que o usuário possa ter acesso as alterações da interface. Aí que começam a surgir os problemas no modelo em duas camadas: uma simples alteração de interface é suficiente para gerar a necessidade de atualizar a aplicação, em centenas ou milhares de computadores. O gerenciamento desta tarefa é algo extremamente complexo.

Capítulo 1 – Uma Introdução à Tecnologia ASP

➥ Lógica do Negócio: As regras que definem a maneira como os dados serão acessados e processados, são conhecidas como “Lógica do Negócio”. Fazem parte da Lógica do Negócio desde funções simples de validação da entrada de dados, como o cálculo do dígito verificador de um CPF, até funções mais complexas, como descontos escalonados para os maiores clientes, de acordo com o volume da compra. Questões relativas à legislação fiscal e escrita contábil também fazem parte da Lógica do Negócio. Por exemplo, um programa para gerência de Recursos Humanos, desenvolvido para a legislação dos EUA, não pode ser utilizado, sem modificações, por uma empresa brasileira. Isso acontece porque a legislação dos EUA é diferente da legislação brasileira. Em síntese, as regras para o sistema de Recursos Humanos são diferentes. Alterações nas regras do negócio são bastante freqüentes em função das constantes mudanças na legislação do nosso país. Com isso, faz-se necessária a geração de uma nova versão do programa cada vez que uma determinada regra muda, ou quando regras forem sendo acrescentadas ou retiradas. Desta forma, todos os computadores que possuem a versão anterior devem receber a nova versão, para que o usuário possa ter acesso às alterações. Aqui temos mais um problema do modelo em duas camadas: qualquer alteração nas regras do negócio é suficiente para gerar a necessidade de atualizar a aplicação em centenas ou milhares de computadores. O gerenciamento desta tarefa é algo extremamente complexo. Com a evolução do mercado e as alterações da legislação, mudanças nas regras do negócio são bastante freqüentes. Por isso o modelo de duas camadas, demonstrou-se de difícil manutenção e gerenciamento, além de apresentar um TCO muito elevado, conforme comentado na Introdução deste livro. A outra camada, vem a ser o banco de dados, o qual fica armazenado em servidor da rede. Uma aplicação desenvolvida em Visual Basic, a qual acessa um banco de dados em um servidor Microsoft SQL Server, é um típico exemplo de uma aplicação em duas camadas. Em busca de soluções para os problemas do modelo em duas camadas, é que surge a proposta do modelo em três camadas, conforme analisaremos a seguir.

Aplicações em Três Camadas Como uma evolução do modelo em duas camadas, surge o modelo de três camadas. A idéia básica deste novo modelo em três camadas, é retirar as regras do negócio do cliente e centralizálas em um determinado ponto, o qual é chamado de servidor de aplicações. O acesso ao banco de dados é feito através das regras contidas no servidor de Aplicações. Ao centralizar as regras do negócio em um único ponto, fica muito mais fácil a atualização das mesmas. A Figura 1.9, nos dá uma idéia geral do modelo em três camadas.

Criando Sites Dinâmicos com ASP 3.0

Servidor de Banco de Dados

Servidor de Aplicações

No modelo de três camadas, toda a Lógica do Negócio fica no servidor de Aplicações. Com isso, a atualização das regras do negócio fica mais fácil.

Cliente

Figura 1.9: O modelo de desenvolvimento em três camadas. Todo o acesso do cliente ao banco de dados é feito de acordo com as regras contidas no servidor de Aplicações. O cliente não tem acesso ao banco de dados, sem antes passar pelo servidor de Aplicações. Com isso as três camadas são as seguintes: ➥ Apresentação: Continua no programa instalado no cliente. Alterações na interface do programa geram a necessidade de atualizar a aplicação em todos os computadores, onde a mesma está sendo utilizada. Porém, cabe ressaltar que alterações na interface são menos freqüentes do que alterações nas regras do negócio. ➥ Lógica: São as regras do negócio, as quais determinam de que maneira os dados serão utilizados. Esta camada foi deslocada para o servidor de aplicações. Desta maneira, quando uma regra do negócio for alterada, basta atualizá-la no servidor de aplicações. Após a atualização, todos os usuários passarão a ter acesso a nova versão, sem que seja necessário reinstalar o programa em cada um dos computadores da rede. Vejam que ao centralizar as regras do negócio em um servidor de Aplicações, estamos facilitando a tarefa de manter a aplicação atualizada. ➥ Dados: Nesta camada temos o servidor de Banco de Dados, no qual reside toda a informação necessária para o funcionamento da aplicação. Cabe ressaltar que os dados somente são acessados através do servidor de Aplicação, e não diretamente pela aplicação Cliente. Com a introdução da camada de Lógica, resolvemos o problema de termos que atualizar a aplicação em centenas ou milhares de computadores, cada vez que uma regra do negócio fosse alterada. Porém continuamos com o problema de atualização da aplicação, cada vez que sejam necessárias mudanças na interface. Por isso que surgiram os modelos de n-camadas. No próximo tópico, iremos falar um pouco sobre o modelo em quatro camadas. No Capítulo 12, Conceitos Avançados: Transações e o Microsoft Transaction Services, estaremos falando sobre camadas adicionais.

Capítulo 1 – Uma Introdução à Tecnologia ASP

Aplicações em Quatro Camadas Como uma evolução do modelo de três camadas, surge o modelo de quatro camadas. A idéia básica do modelo em quatro camadas é retirar a apresentação do cliente e centralizá-la em um determinado ponto, o qual na maioria dos casos é um servidor Web. Com isso o próprio cliente deixa de existir como um programa que precisa ser instalado em cada computador da rede. O acesso à aplicação é feito através de um navegador, como o Internet Explorer ou o Netscape Navigator. A Figura 1.10 nos dá uma idéia geral do modelo em quatro camadas. Servidor de Aplicações

Servidor Web

Cliente

Servidor de Banco de Dados

Cliente

O Cliente só precisa de um Navegador para ter acesso a aplicação.

Figura 1.10: O modelo de desenvolvimento em quatro camadas. Para acessar a aplicação, o cliente acessa o endereço da aplicação, utilizando o seu navegador. Por exemplo http://www.empresa-abc.com/sistemas/cadastro.asp. Todo o acesso do cliente ao banco de dados é feito de acordo com as regras contidas no servidor de Aplicações. O cliente não tem acesso ao banco de dados, sem antes passar pelo servidor de Aplicações. Com isso as quatro camadas são as seguintes: ➥ Cliente: Neste caso o cliente é o navegador utilizado pelo usuário, quer seja o Internet Explorer, quer seja o Netscape Navigator, ou outro navegador qualquer. ➥ Apresentação: Passa para o servidor Web. A interface pode ser composta de páginas HTML, ASP, ou qualquer outra tecnologia capaz de gerar conteúdo para o navegador. Com isso alterações na interface da aplicação são feitas diretamente no servidor Web, e, portanto, estas alterações estarão, automaticamente, disponíveis para todos os clientes. Com isso não existe a necessidade de reinstalar a aplicação em todos os computadores da rede. Fica muito mais fácil garantir que todos estão tendo acesso à versão mais

Criando Sites Dinâmicos com ASP 3.0

atualizada da aplicação. A única coisa que o cliente precisa ter instalado na sua máquina, é o navegador. O acesso ao banco de dados é feito através do servidor de Aplicações. ➥ Lógica: São as regras do negócio, as quais determinam de que maneira os dados serão utilizados. Esta camada está no servidor de Aplicações. Desta maneira, quando uma regra do negócio for alterada, basta atualizá-la no servidor de Aplicações. Após a atualização, todos os usuários passarão a ter acesso à nova versão, sem que seja necessário reinstalar o programa em cada um dos computadores da rede. Vejam que, ao centralizar as regras do negócio em um servidor de Aplicações, estamos facilitando a tarefa de manter a aplicação atualizada. ➥ Dados: Nesta camada temos o servidor de banco de dados, no qual reside toda a informação necessária para o funcionamento da aplicação. Com o deslocamento da camada de apresentação para um servidor Web, resolvemos o problema de termos que atualizar a aplicação em centenas ou milhares de computadores, cada vez que uma regra do negócio for alterada. Neste ponto a atualização das aplicações é uma tarefa mais gerenciável, muito diferente do que acontecia no caso do modelo em duas camadas. Os servidores de Aplicação, Web e Banco de Dados não precisam ser necessariamente servidores separados, isto é, uma máquina para fazer o papel de cada um dos servidores. O conceito de servidor de Aplicação, Web ou Banco de Dados é um conceito relacionado com a função que o servidor desempenha. Podemos ter, em um mesmo equipamento, um servidor de Aplicações, um servidor Web e um servidor de Banco de Dados. Claro que questões de desempenho devem ser levadas em consideração, conforme analisaremos no próximo tópico.

Questões a Considerarmos nos Modelos em Três ou Mais Camadas Muitas são as vantagens dos modelos em três ou mais camadas em relação à facilidade de gerenciamento e atualização das aplicações. Porém deve-se levar em consideração o desempenho e dimensionamento dos equipamentos que atuarão como servidores. A partir do momento que estamos deslocando funcionalidades (tipicamente lógica e apresentação), do cliente para um ou mais servidores, também estamos deslocando capacidade de processamento em termos de memória RAM e processador. Funções que antes eram executadas pelos clientes, utilizando memória e processador da estação cliente, agora foram deslocadas para os servidores, consumindo memória e processador do servidor. Portanto, um dos fatores chave é o correto dimensionamento dos equipamentos servidores. Para fazer o dimensionamento dos servidores, precisamos conhecer o número de usuários que irão acessar a aplicação, o nível de exigência de cada usuário e os recursos necessários pelos softwares do servidor, entre outros fatores. Para determinar o nível de recursos necessários em cada um dos servidores, você precisa fazer um estudo bem detalhado, de tal forma que o servidor não fique subdimensionado. Quando o servidor não está corretamente dimensionado, a tendência é que o acesso a aplicação fique bastante lento, causando insatisfação entre os usuários.

Capítulo 1 – Uma Introdução à Tecnologia ASP

Neste modelo de desenvolvimento para a Web, em três ou mais camadas, existem diversos pontos nos quais podemos utilizar a tecnologia ASP. Ao desenvolver a interface da aplicação, pode-se combinar código HTML com código ASP. Utilizando ASP, podemos desenvolver páginas que acessam o banco de dados, através do servidor de Aplicações. Questões como autenticação de usuários, determinação do nível de acesso e segurança da aplicação podem ser desenvolvidas com a utilização de ASP. Para que você possa utilizar a tecnologia ASP da melhor maneira, com o objetivo de atender às necessidades da sua aplicação, é importante que você conheça o modelo de desenvolvimento para a Web, bem como a utilização de ASP, para a criação das aplicações. No decorrer deste livro, estaremos abordando diversos tópicos relacionados à criação de aplicações Web.

O que é ASP? Definir exatamente o que é ASP é uma tarefa que pode gerar controvérsias. Eu, particularmente, gosto de definir ASP, como sendo: “Uma tecnologia que permite a criação de páginas dinâmicas, nas quais além de código HTML, temos código ASP. É justamente este código, que fornece a funcionalidade, que torna os sites dinâmicos, possibilitando a criação de aplicações Web”. Não defino ASP como uma linguagem de Script porque, para a criação de páginas ASP, podemos utilizar diferentes linguagens, tais como VBScript e Java Script. Neste livro, estaremos utilizando o VBScript. Teremos os Capítulos 2 e 3 dedicados à linguagem VBScript. Melhor do que definições formais, é entender como funciona uma página ASP. Vamos nos basear na Figura 1.11.

Internet

http://www.abc.com/cep.asp

Servidor Web www.abc.com

A página ASP é processada no servidor. O resultado do processamento é uma página HTML. O que retorna para o cliente é a página HTML, já resultante do processamento no servidor Web.

Figura 1.11: Como funciona o ASP.

Criando Sites Dinâmicos com ASP 3.0

Vamos fazer alguns comentários sobre a Figura 1.11. O servidor Web, no nosso caso o IIS da Microsoft, reconhece que a página solicitada é uma página ASP, pela extensão da página. As páginas ASP devem ter a extensão .asp. Se criarmos uma página ASP e a salvarmos com a extensão .htm ou .html, o IIS simplesmente ignora o código ASP. A criação de páginas ASP está ligada à utilização do IIS. Não podemos, por exemplo, criar páginas ASP e disponibilizá-las utilizando outros servidores Web, como o Netscape Web Server ou o Apache. Já existem empresas trabalhando para disponibilizar a tecnologia ASP para alguns servidores Web, rodando no sistema operacional Unix ou Linux. O usuário digita o endereço http://www.abc.com/cep.asp e tecla Enter. Feito isso, o pedido é enviado para o servidor www.abc.com. O servidor identifica a extensão do arquivo – .asp. Como a extensão é .asp, a página cep.asp é passada para o “Interpretador ASP”, o qual faz parte do IIS. O Interpretador percorre toda a página, executando o código ASP e retornando o código HTML, resultante deste processamento. Com isso o que é retornado para o usuário, que solicitou a página ASP, é apenas o código HTML resultante do processamento da página. Este fato pode ser comprovado pedindo para que o navegador exiba o código fonte da página. No caso do Internet Explorer 5.0, basta selecionar a opção Código fonte, do menu Exibir. O fato do retorno ser HTML puro traz diversos benefícios, dentro os quais podemos destacar: ➥ Os algoritmos, bem como o próprio código ASP, ficam protegidos. Isto significa que o usuário não tem acesso ao código das aplicações Web, desenvolvidas em ASP. Isto é bastante desejável, uma vez que não seria interessante que qualquer usuário pudesse copiar, livremente, os algoritmos e códigos da empresa. ➥ O acesso à páginas ASP é independente do navegador utilizado. Não importa se estamos utilizando o Netscape Navigator, o Internet Explorer, ou qualquer outro navegador. Uma vez que o que retorna é código HTML, qualquer navegador é capaz de acessar uma página ASP. Em contrapartida, o servidor precisa ser o IIS da Microsoft. Outros servidores ainda não possuem um Interpretador ASP, o que inviabiliza a utilização de páginas ASP nos mesmos. Outra questão importante a considerar é o fato de uma página ASP ser interpretada no servidor. Isto significa que você não pode criar uma página ASP e testá-la localmente, simplesmente abrindo-a no navegador. Se você criar uma página ASP, salvá-la no seu disco rígido local e tentar abri-la no navegador, todo o código ASP será ignorado, uma vez que não existe o Interpretador ASP. Para poder testar as suas páginas ASP, você terá que salvá-las em um servidor Web, que esteja rodando o IIS. Para acompanhar os exemplos deste livro, aconselho que você utilize o Windows 2000 Server ou o Windows 2000 Professional, com o IIS 5.0 instalado. Caso você não disponha de um computador, com um destes dois sistemas instalados, você pode utilizar o Windows 98 com

Capítulo 1 – Uma Introdução à Tecnologia ASP

o Personal Web Server instalado. Porém, com o Personal Web Server, alguns dos exemplos deste livro, principalmente os que utilizam as novas características do ASP 3.0, não irão funcionar corretamente. Na Introdução, você aprendeu a instalar o IIS 5.0. No próximo item, aprenderemos a criar um diretório no servidor do IIS e salvar nossas páginas neste local, para depois podermos testálas. Sugiro que você também crie este diretório para salvar nossos exemplos. Iremos criar um diretório para cada capítulo do livro, de tal forma que os exemplos possam ficar melhor organizados.

IMPORTANTE Para os exemplos deste livro, estou utilizando um servidor com o Windows 2000 Server. O nome do servidor é www.groza.com. Se você estiver utilizando um servidor com um nome diferente, substitua www.groza.com, pelo nome do servidor que você estiver utilizando, sempre que o mesmo aparecer nos nossos exemplos.

Preparando o Servidor Para Acompanhar os Exemplos Neste item vamos criar uma pasta chamada livro. Dentro desta pasta vamos criar uma subpasta para cada capítulo do livro: Capitulo1, Capitulo2, e assim por diante, até o Capitulo12. Depois aprenderemos a tornar esta pasta, parte integrante do servidor IIS. Não são todas as pastas de um servidor que podem ser acessadas através do IIS.

Criando a Estrutura de Pastas e Subpastas Utilizando o Windows Explorer, crie uma estrutura de pastas e subpastas, conforme indicado na Figura 1.12. Lembre-se de não utilizar acentos para o nome das subpastas.

IMPORTANTE Estou utilizando o drive C:. Você pode utilizar qualquer um dos drives disponíveis no seu computador.

Agora vamos fazer com que a pasta livro (e conseqüentemente, todas as suas subpastas) passe a fazer parte do servidor IIS www.groza.com.

Criando Sites Dinâmicos com ASP 3.0

Figura 1.12: Criando a estrutura de pastas e subpastas.

Tornando a Pasta Livro Parte dos Servidor IIS Agora vamos aprender passo a passo, como tornar a pasta livro, parte do servidor IIS. Para isso utilizaremos o console “Gerenciamento do Internet Services”, do Windows 2000 Server. Para maiores informações sobre MMC, Snap-in e Consoles administrativos, consulte a Unidade IV, do livro “Série Curso Básico & Rápido, Microsoft Windows 2000 Server”, de minha autoria e publicado pela editora Axcel Books. Tornando a pasta livro parte do servidor IIS www.groza.com: 1. Faça o logon como Administrador. 2. Clique em Iniciar/Programas/Ferramentas administrativas/Gerenciador do Internet Services. 3. Será aberta a janela Internet Information Services, conforme indicado pela Figura 1.13. 4. Dê um clique duplo no nome do computador para abri-lo. No exemplo da Figura 1.13, o nome do computador é servidor. Feito isso são exibidas três opções, conforme indicado pela Figura 1.14.

Capítulo 1 – Uma Introdução à Tecnologia ASP

Figura 1.13: O Gerenciador do Internet Services.

Figura 1.14: Opções de gerenciamento para o IIS 5.0. 5. Dê um clique no sinal de +, ao lado da opção Site da Web padrão, para expandir esta opção. As opções que aparecem são as pastas que já fazem parte do site. 6. Dê um clique com o botão direito do mouse sobre Site da Web padrão. No menu que surge, aponte para Novo. Nas opções que surgem, dê um clique na opção Pasta virtual, conforme indicado pela Figura 1.15.

Criando Sites Dinâmicos com ASP 3.0

Figura 1.15: Criando uma nova pasta virtual, no servidor IIS 5.0. 7. Esta pasta virtual será associada à pasta livros, criada anteriormente. 8. Será exibida a primeira tela do Assistente para a criação de pasta virtual. Dê um clique no botão Avançar, passando à segunda etapa do assistente. 9. Nesta segunda etapa, você precisa definir um nome (Alias) para esta pasta virtual. Utilizaremos o mesmo nome da pasta: livro. Não é obrigatório que seja utilizado o mesmo nome. Por questão de facilidade de administração e gerenciamento, sempre utilizo nomes iguais para o nome da pasta no disco rígido e o nome no IIS 5.0. 10. Digite livro, conforme indicado pela Figura 1.16.

Figura 1.16: Digitando um nome para a pasta no IIS 5.0.

Capítulo 1 – Uma Introdução à Tecnologia ASP

11. Dê um clique no botão Avançar, passando à terceira etapa do assistente. 12. Na terceira etapa, o assistente pergunta qual a pasta a ser associada com o nome virtual informado na etapa anterior. Nesta etapa você pode digitar o caminho completo para a pasta, ou utilizar o botão procurar, para localizar a pasta desejada. No nosso exemplo, vamos digitar C:\livro. Com isso estamos associando a pasta C:\livro com a pasta virtual livro, do servidor IIS 5.0. 13. Digite C:\livro, conforme indicado na Figura 1.17, e dê um clique no botão Avançar, para ir para a quarta etapa do assistente.

Figura 1.17: Informando o caminho da pasta C:\livro. 14. Na quarta etapa do assistente, podemos configurar as permissões de acesso à pasta livro. Certifique-se de que as opções Leitura e Executar scripts (ASP, por exemplo) estejam marcadas, conforme indicado pela Figura 1.18. Se a opção Executar scripts (ASP, por exemplo) não estiver marcada, o código ASP será ignoradas pelo IIS. 15. Dê um clique em Avançar. Surge a tela final do assistente. 16. Dê um clique no botão Concluir, para finalizar o assistente. 17. Você estará de volta ao Gerenciador do Internet Services. 18. Observe que um novo diretório virtual chamado livro, já aparece como parte integrante do servidor IIS, conforme indicado na Figura 1.19.

Criando Sites Dinâmicos com ASP 3.0

Figura 1.18: Configurando as opções de segurança.

Figura 1.19: O diretório virtual livro, recém criado. 19. Feche o Gerenciador do Internet Services. Uma vez criado o diretório virtual livro, o qual está associado à pasta C:\livro, como posso acessar o conteúdo que for colocado dentro da pasta C:\livro, ou em uma das suas subpastas?

Capítulo 1 – Uma Introdução à Tecnologia ASP

A resposta para a questão acima é bastante simples, basta que entendamos como são formados os endereços em um servidor como o IIS. No nosso exemplo, o endereço do servidor é www.groza.com. Ao digitarmos este endereço, estamos acessando a página principal do servidor. Vamos supor que dentro do diretório livro fosse colocada uma página chamada index.asp. Como faríamos para acessar esta página, através do navegador? O endereço da página em questão, seria o seguinte: www.groza.com/livro/index.asp. A Figura 1.20, descreve em detalhes a formação deste endereço.

Nome do diretório virtual

www.groza.com/livro/index.asp

Nome do servidor.

Nome da página a ser acessada

Figura 1.20: A formação de endereços no servidor IIS. Observe que primeiro vem o nome do servidor, depois o nome do diretório virtual e, finalmente, o nome da página a ser acessada. Como é que fica o endereço, quando eu quero acessar uma página que está dentro de uma subpasta da pasta livro? Seguindo o mesmo raciocínio anterior, fica fácil responder a esta pergunta. Vamos supor que você queira acessar uma página chamada cep.asp, que está na subpasta Capitulo1, a qual está na pasta livro. Como fica o endereço para acessar esta página? A Figura 1.21, responde esta questão.

Nome do diretório virtual

Nome da subpasta

www.groza.com/livro/Capitulo1/cep.asp

Nome da página a ser acessada

Nome do servidor

Figura 1.21: A formação de endereços em subpastas do diretorio virtual, no servidor IIS.

Criando Sites Dinâmicos com ASP 3.0

Com isso, podemos ver que existe uma lógica bem definida para a formação dos endereços. Apenas para confirmar, vamos dar mais alguns exemplos de formação de endereços. Considere os casos abaixo indicados: ➥ Qual o endereço de uma página chamada teste.htm, gravada no diretório Capitulo6? Resposta: www.groza.com/livro/Capitulo6/teste.htm. ➥ Qual o endereço de uma página chamada cadastro.asp, gravada no diretório Capitulo10? Resposta: www.groza.com/livro/Capitulo10/cadastro.asp. É importante que você entenda bem a maneira como o servidor IIS constrói os endereços de acesso para as páginas gravadas em seus diretórios virtuais. Observe que o diretório virtual, é simplesmente um nome que nos leva até o diretório real, gravado no disco. Podemos criar diversos diretórios virtuais, em um único servidor IIS. Em um trabalho futuro, estarei escrevendo sobre o IIS 5.0.

IMPORTANTE Você pode criar a estrutura sugerida neste tópico para acompanhar os exemplos deste livro. Você também pode optar pela criação de uma estrutura diferente, neste caso, lembre-se de utilizar a estrutura correta quando estiver acompanhando os nossos exemplos.

Alguns Exemplos Práticos Agora que já sabemos como uma página ASP é processada e retornada para o usuário, e também sabemos como acontece a formação de endereços no servidor IIS, chegou o momento de começar a aprender a criar páginas ASP. Neste item, veremos, através de exemplos simples, como criar código ASP e como testar as páginas criadas. Também comprovaremos, na prática, que o que retorna do servidor para o navegador é apenas código HTML.

O Tradicional “Hello World” Para começar, vamos criar uma página ASP bastante simples. Criaremos uma página ASP que retorna a frase Hello World para o usuário, em diferentes tamanhos, utilizando a tag HTML para cabeçalhos, do <H1> até <H6>. O <H1> é a de maior tamanho, e vai diminuindo até chegar ao menor tamanho que é o <H6>.

NOTA As listagens de código deste livro, apresentam numeração de linhas. Porém, ao criar o código, não devem ser digitados os números das linhas. Os números são utilizados, apenas para facilitar a explicação dos códigos de exemplo.

Capítulo 1 – Uma Introdução à Tecnologia ASP

Abra o Bloco de notas (Iniciar/Programas/Acessórios/Bloco de notas) e digite o texto indicado na Listagem 1.1. Listagem 1.1 – O exemplo do Hello World. 1

<HTML>

<HEAD>

<TITLE>Minha primeira página ASP!!</TITLE>

</HEAD>

<BODY>

Response.Write “<H1> Hello World </H1>”

Response.Write “<H2> Hello World </H2>”

Response.Write “<H3> Hello World </H3>”

Response.Write “<H4> Hello World </H4>”

Response.Write “<H5> Hello World </H5>”

Response.Write “<H6> Hello World </H6>”

</BODY>

</HTML>

IMPORTANTE Não digite o número das linhas. A numeração apenas aparece na listagem, para servir como referência na hora de explicarmos o código ASP.

Salve este documento na subpasta Capitulo1, da pasta livro. Salve o arquivo com o nome de exemplo1.asp. Se você também estiver utilizando o Bloco de notas, é importante digitar a extensão .asp, pois caso contrário o Bloco de notas, colocará a extensão .txt. Antes de explicarmos o código da Listagem 1.1, vamos testá-lo. Para testar o código faça o seguinte: 1. Abra o Internet Explorer. 2. No campo endereço digite o seguinte: www.groza.com/livro/Capitulo1/exemplo1.asp 3. Tecle Enter. Se não foram cometidos erros na hora da digitação da Listagem 1.1, o Internet Explorer mostra o resultado da página exemplo1.asp, conforme indicado na Figura 1.22.

Criando Sites Dinâmicos com ASP 3.0

Figura 1.22: O resultado da página exemplo1.asp. Agora vamos falar um pouco sobre o código da Listagem 1.1. Nas linhas de 1 até 5, temos o código HTML normal para qualquer página. De interessante apenas a tag <TITLE> </TITLE>, que define o título que será exibido na Barra de títulos do Internet Explorer, quando você acessa a página. Isso pode ser comprovado na Figura 1.22, onde vemos a frase: “Minha primeira página ASP!! – Microsoft Internet Explorer”, na Barra de títulos. A partir da linha 6 é que temos novidades. Observe, na linha 6, a utilização de <%. Esta combinação de sinais, indica o início de um trecho com código ASP, ou seja, código que deve ser interpretado pelo servidor IIS. A partir da linha 7, temos a utilização do comando Response.Write. Este comando, retorna para o navegador, o texto que está entre aspas. No exemplo da linha 7, será retornado <H1>Hello World</H1>, que é justamente a tag de cabeçalho do HTML. As demais linhas repetem a operação, para as demais tag’s de cabeçalho do HTML. Na linha 13, a combinação de sinais %>, indica o final do trecho de código ASP, iniciado na linha 6.

Capítulo 1 – Uma Introdução à Tecnologia ASP

IMPORTANTE Todo trecho de código ASP, inicia com um <% e deve ser finalizado com um %>. Podemos ter mais do que um trecho de código ASP, dentro de um mesmo documento. Com isso podemos ir mesclando trechos de código HTML, com trechos de código ASP. Essa possibilidade nos dá uma grande flexibilidade na hora de construir aplicações para a Web. Sempre que for necessário algum tipo de processamento em uma página, podemos inserir código ASP para fazer o processamento desejado, e depois retornar o resultado no formato HTML. As linhas 14 e 15 são tag’s HTML, que aparecem no final de uma página. A tag </BODY> é o fechamento da tag <BODY>, e a tag </HTML> é o fechamento da tag <HTML>. Para maiores detalhes sobre a linguagem HTML, consulte o livro HTML 4 Curso Básico & Rápido, da editora Axcel Books. Conforme descrito anteriormente, o código ASP é processado pelo IIS, e o resultado deste processamento é retornado para o navegador do cliente no formato HTML. Podemos facilmente comprovar isto. Comprovando que o que retorna é somente o código HTML: 1. Se você não estiver com a página exemplo1.asp aberta, abra-a conforme descrito no exemplo anterior. 2. No menu Exibir, clique na opção Código fonte. 3. Será exibida uma janela, conforme indicado pela Figura 1.23.

Figura 1.23: Código HTML, resultante do processamento da página exemplo1.asp.

Criando Sites Dinâmicos com ASP 3.0

4. Observe que o código retornado para o cliente, é código HTML puro, sem nenhum sinal do código ASP. Isso impede com que o usuário possa ter acesso ao código dos aplicativos desenvolvidos em ASP. Além disso qualquer navegador pode ser utilizado para acessar uma página ASP, uma vez que o que é, efetivamente, enviado para o cliente é código HTML. 5. Feche a janela indicada na Figura 1.23. Nesse exemplo, criamos a nossa primeira página ASP. Onde aprendemos alguns detalhes importantes e confirmamos outros, anteriormente apresentados. Apenas para revisar, vamos enunciar os principais tópicos abordados: ➥ Uma página pode conter um ou mais trechos com código ASP. ➥ Cada trecho de código ASP, inicia com <% e termina com %>. ➥ Uma página ASP é identificada pela sua extensão, que deve ser .asp, caso contrário o código ASP será ignorado pelo servidor IIS. ➥ O código ASP é processado pelo servidor IIS, e o resultado desse processamento é que é retornado para o navegador do cliente, no formato de código HTML. Você pode, facilmente, comprovar este fato, selecionando a opção Código fonte, do menu Exibir, do Internet Explorer. ➥ Pelo fato do resultado do processamento de uma página ASP ser código HTML, qualquer navegador está habilitado para acessar páginas ASP, e não somente o Internet Explorer. Para encerrarmos este capítulo, vamos a mais um exemplo prático. Na página exemplo1.asp, não temos nenhuma vantagem em utilizar código ASP. Poderíamos utilizar código HTML, que obteríamos o mesmo resultado, sem maiores problemas. No próximo exemplo, veremos como a utilização de ASP pode facilitar a criação de páginas dinâmicas e aplicativos para a Web. Por enquanto não se preocupe em entender todos os comandos do ASP e do VBScript. Teremos todo este livro para aprendê-los. O objetivo do próximo exemplo é salientar a natureza dinâmica do ASP na geração de páginas.

Um Exemplo de Página Dinâmica Vamos imaginar que você queira criar uma página, onde no início apareça a seguinte frase: “Boqueirão do Leão, 25 de Junho de 2000”; ou seja, o nome da cidade, e data.

NOTA DO AUTOR Estou utilizando Boqueirão do Leão, como exemplo, porque é a minha terra natal. Claro que pouca gente conhece, pois é uma cidade pequena. Mas sempre que o tempo permite, volto para rever familiares e amigos.

Capítulo 1 – Uma Introdução à Tecnologia ASP

Poderíamos criar esta página utilizando HTML, porém todos os dias, no final do dia, teríamos que editar a página para alterar a data, uma vez que a mesma não será atualizada automaticamente. Utilizando código ASP, podemos fazer com que a página acesse a data do servidor IIS e exiba a data sempre atualizada, na página ASP. Com isso, cada vez que a página for acessada pelo usuário, o código ASP irá determinar a data do servidor e enviar uma página com a data atualizada. Este é um exemplo, bastante simples, de uma página dinâmica; pois a data é dinamicamente determinada pelo código ASP. A página da Listagem 1.2 soluciona o problema proposto. Abra o Bloco de Notas (Iniciar/Programas/Acessórios/Bloco de notas) e digite o texto indicado na Listagem 1.2. Listagem 1.2 – Página dinâmica – O exemplo da determinação da data. 1

<HTML>

<HEAD>

<TITLE>Minha segunda página ASP!!</TITLE>

</HEAD>

<BODY>

data_atual=Date()

mes_atual=Month(data_atual)

Select Case mes_atual

10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

Case 1 mes_desc=“Janeiro” Case 2 mes_desc=“Fevereiro” Case 3 mes_desc=“Março” Case 4 mes_desc=“Abril” Case 5 mes_desc=“Maio” Case 6 mes_desc=“Junho” Case 7 mes_desc=“Julho” Case 8 mes_desc=“Agosto”

Criando Sites Dinâmicos com ASP 3.0

Case 9

mes_desc=“Setembro”

Case 10

mes_desc=“Outubro”

Case 11

mes_desc=“Novembro”

Case 12

mes_desc=“Dezembro”

End Select

Response.Write “Boqueirão do Leão, ” & Day(data_atual) & “ de ” & mes_desc & “ de ” & Year(data_atual)

<p> Aqui o restante da página...</p>

</BODY>

</HTML>

IMPORTANTE Não digite o número das linhas. A numeração apenas aparece na listagem para servir como referência na hora de explicarmos o código ASP. Esta orientação é válida para todas as listagens que aparecerem neste livro.

Salve este documento na subpasta Capitulo1, da pasta livro. Salve o arquivo com o nome de exemplo2.asp. Lembre-se de digitar a extensão .asp, pois caso contrário o Bloco de notas, colocará a extensão .txt. Antes de explicarmos o código da Listagem 1.2, vamos testá-lo. Para testar o código faça o seguinte: 1. Abra o Internet Explorer. 2. No campo endereço digite: www.groza.com/livro/Capitulo1/exemplo2.asp. 3. Tecle Enter. 4. Se não foram cometidos erros na hora da digitação da Listagem 1.2, o Internet Explorer mostra o resultado da página exemplo2.asp, conforme indicado na Figura 1.24.

Capítulo 1 – Uma Introdução à Tecnologia ASP

Figura 1.24: O resultado da página exemplo2.asp. Agora vamos falar um pouco sobre o código da Listagem 1.2. Da linha 1 até a linha 5 temos código HTML. A partir da linha 6 é que temos o código ASP, conforme indicado pelo sinal <%. Na linha 7, utilizamos a função Date( ), para atribuir a data do sistema à variável data_atual. Na linha 8, utilizamos a função Month para extrair apenas o mês da data atual, e atribuir este valor a variável mes_atual. A função Month, retorna um número inteiro entre 1 e 12, o qual indica o mês do ano; 1=Janeiro, 2=Fevereiro, 3=Março e assim por diante. Por isso, das linhas 9 até 34, utilizamos o laço de controle Select Case ... End Select para definir a variável mes_desc, com base no valor retornado pela variável mes_atual. Veremos o laço de controle Select Case ... End Select, em detalhes, no Capítulo 2. Finalmente, na linha 35, utilizo o comando Response.Write, para retornar a data no formato desejado. Observe que, com o comando Response.Write, posso retornar diversos valores, quer sejam valores fixos de texto, colocados entre aspas (como no exemplo “Boqueirão do Leão,”), quer sejam valores obtidos de variáveis, como no caso mes_desc. Para juntar as várias partes que devem ser retornadas, utilizamos o operador &. Da linha 37 até a linha 39 temos código HTML. Conforme descrito anteriormente, o código ASP é processado pelo IIS e o resultado deste processamento é retornado para o navegador do cliente no formato HTML. Podemos facilmente comprovar isto.

Criando Sites Dinâmicos com ASP 3.0

Comprovando, mais uma vez, que o que retorna é somente o código HTML. 1. Se você não estiver com a página exemplo2.asp aberta, abra-a conforme descrito no exemplo anterior. 2. No menu Exibir, clique na opção Código fonte. 3. Será exibida uma janela, conforme indicado pela Figura 1.25.

Figura 1.25: Código HTML resultante do processamento da página exemplo2.asp. 4. Observe que o código retornado para o cliente, é código HTML puro, sem nenhum sinal do código ASP. Não vemos as funções utilizadas, nem mesmo o laço de controle Select Case. O que retorna é o resultado do comando Response.Write. Isso impede que o usuário possa ter acesso ao código dos aplicativos desenvolvidos em ASP. Além disso, como já disse anteriormente, qualquer navegador pode ser utilizado para acessar uma página ASP, uma vez que o que é, efetivamente, enviado para o cliente é código HTML. 5. Feche a janela indicada na Figura 1.25. Veja que, neste exemplo, temos uma página em que o conteúdo é gerado dinamicamente, a partir da hora do servidor. Você pode testar este comportamento dinâmico da página, facilmente. Altere a data do servidor. Carregue novamente a página exemplo2.asp. Observe que a mesma já exibe a nova data. Altere novamente a data do servidor e pressione F5 para atualizar a página exemplo2.asp. Isso é geração dinâmica de conteúdo, embora até o momento seja um conteúdo bastante simples. Nos próximos capítulos avançaremos um pouco mais. Agora que já entendemos os diversos aspectos envolvidos com a criação de páginas ASP, estamos aptos a aprender um pouco mais sobre a linguagem VBScript, que estaremos utilizando neste livro. Isso será assunto para os Capítulos 2 e 3.

Capítulo 2 – Uma Introdução ao VBScript

Capítulo 2 Uma Introdução ao VBScript

Criando Sites Dinâmicos com ASP 3.0

Introdução Neste capítulo aprenderemos o básico a respeito de VBScript. Veremos exatamente o que é VBScript, e onde utilizá-lo. Aprenderemos que é possível executar código VBScript, tanto no navegador do cliente, quanto no servidor Web. Depois apresentaremos os aspectos básicos da linguagem, tais como a declaração de variáveis, operadores e laços de controle. À medida em que os conceitos forem sendo apresentados, iremos trabalhando com exemplos práticos, para que os conceitos possam ser melhor entendidos. Também aprenderemos a criar sub-rotinas e funções. Na parte final do capítulo, desenvolveremos alguns exemplos práticos de utilização de VBScript, na criação de páginas. Ao completar este capítulo, você terá uma noção básica de VBScript, e será capaz de criar soluções simples utilizando esta linguagem.

NOTA Os exemplos apresentados nas listagens deste capítulo, podem ser criados utilizando-se um redator de texto, como o Bloco de notas, e salvando os arquivos com a extensão .htm. Depois é só abrir os mesmos no Internet Explorer e testar. Os números das linhas que aparecem nas listagens, não devem ser digitados. Os mesmos foram incluídos, nas respectivas listagens, apenas para facilitar o acompanhamento das explicações de cada exemplo.

O que é VBScript VBScript é uma linguagem de criação de scripts, a qual é derivada do Visual Basic (VB) e do VBA (Visual Basic for Applications). O Visual Basic é o ambiente de desenvolvimento gráfico mais utilizado para o desenvolvimento de aplicações para o ambiente Windows. Como o nome sugere, a programação em Visual Basic é baseada na linguagem de programação Basic. O VBA é derivado do Visual Basic (de certa forma, podemos dizer que é um subconjunto do VB), e é a linguagem utilizada para automatizar tarefas nos aplicativos do Microsoft Office. Por exemplo, quando você precisa criar código para automatizar alguma tarefa no Microsoft Excel ou no Microsoft Access, você está utilizando o VBA. Se você já conhece VB ou VBA irá sentir-se bastante à vontade com VBScript. Muitos dos comandos básicos, como estruturas de controle, declarações de variáveis, operadores e funções, são idênticos. Na verdade alguns artigos definem VBScript como sendo um subconjunto do VB. Devemos considerar alguns fatos importantes, dentre os quais podemos destacar: ➥ VBScript é uma linguagem para a criação de scripts. Um script não é compilado para gerar um programa executável, ao invés disso, cada linha do script é interpretada, e executada.

Capítulo 2 – Uma Introdução ao VBScript

➥ O código é escrito juntamente com uma página HTML. A página é enviada para o navegador, o qual interpreta e executa o código VBScript, uma linha por vez. O suporte à VBScript é nativo no Internet Explorer, já no Netscape Navigator o suporte à VBScript se dá através da instalação de um plug-in.

NOTA Um plug-in é um programa que estende a funcionalidade de um navegador. No nosso exemplo estamos falando de um plug-in que permite que o Netscape Navigator interprete e execute código VBScript. ➥ Com a utilização do VBScript, podemos ampliar as capacidades de uma página HTML, tornando-a mais funcional e interativa. Podemos realizar cálculos, exibir mensagens em janelas pop-up, detectar eventos tais como o clique em um link ou em um botão de comando, criar menus interativos, etc. Podemos utilizar código VBScript para fazer a validação dos dados de um formulário. Caso exista erro em algum campo, ou caso algum campo obrigatório não tenha sido preenchido, podemos retornar uma mensagem para o usuário, com os dados que o mesmo preencheu, indicando qual ou quais campos estão com problema. Com isso o usuário corrige os problemas, antes que os dados sejam enviados para o servidor, reduzindo as possibilidades de erro e agilizando o processamento das informações. São muitas as possibilidades. ➥ A linguagem VBScript foi desenvolvida tendo-se a segurança como uma de suas diretrizes. Através do uso de VBScript, não é possível criar uma página, por exemplo, que tenha acesso ao sistema de arquivos do computador e possa apagar ou modificar informações. Evidentemente que a criatividade de hackers mal intencionados não tem limites. Porém diversos cuidados foram tomados, pela Microsoft, para tornar a VBScript uma linguagem segura. ➥ Pela semelhança com o Visual Basic, VBScript é uma linguagem de fácil aprendizado. Se você já programa em Visual Basic, aprender VBScript será simplesmente uma questão de saber o que é possível fazer com VBScript e quais são as suas limitações. Conforme podemos concluir, VBScript é uma linguagem para a criação de scripts, os quais ampliam a funcionalidade das páginas HTML. No próximo item faremos uma revisão rápida os principais elementos de uma página HTML. Como o código VBScript que roda no cliente é “escrito” dentro da própria página HTML, é importante que saibamos identificar seus principais elementos. Além disso, conforme veremos a partir do Capítulo 4, uma página ASP mistura as tags HTML com elementos de código ASP. Por isso é importante que saibamos reconhecer os principais elementos de uma página HTML. Para maiores informações sobre HTML, consulte o livro HTML 4 Curso Básico & Rápido, da editora Axcel Books.

Criando Sites Dinâmicos com ASP 3.0

Uma Revisão Rápida de HTML Conforme descrevemos na introdução desse livro, as páginas da Internet, são criadas utilizando-se da linguagem HTML – Hypertext Markup Language. Uma tradução seria: Linguagem de Marcação de Texto. As páginas ficam gravadas no servidor Web, e quando o cliente digita um endereço solicitando determinada página, a mesma é transportada até o navegador do cliente. O navegador interpreta o código HTML e exibe a página, já formatada. Neste tópico, faremos uma revisão rápida sobre os principais elementos de uma página HTML, bem como sobre os principais elementos para a construção de formulários, como campos para a digitação de texto, que estarão sendo usados durante os exemplos deste livro.

Estrutura Básica de uma Página HTML Todo documento HTML apresenta a mesma estrutura básica. Documentos HTML são criados utilizando o que chamamos de “tag” ou marcador. Por exemplo, existe uma tag para fazer com que o navegador exiba um determinado texto em negrito, outra tag para exibir texto em itálico, um conjunto de tags para criar as linhas e colunas de uma tabela, e assim por diante. Na Listagem 2.1, vemos um exemplo da estrutura básica de um documento HTML. Listagem 2.1 – O exemplo do Hello World. 1

<HTML>

<HEAD>

<TITLE>Criando Sites dinâmicos com ASP 3.0 !!!</TITLE>

</HEAD>

<BODY>

<P>Uma Página HTML muito simples !!!!</P>

</BODY>

</HTML>

IMPORTANTE Cabe novamente ressaltar, que os números de linha, não fazem parte do código HTML. Apenas foram colocados na listagem para facilitar a explicação da mesma. Esta recomendação é válida para todas as listagens apresentadas neste livro. Com isso, se você for digitar esta listagem, não digite o número das linhas. Este fato pode ser comprovado pela Figura 2.1.

Capítulo 2 – Uma Introdução ao VBScript

As maioria das tags HTML são formadas por pares. Conforme podemos ver na Listagem 2.1, todo documento HTML, começa com a tag <HTML> e termina com uma tag </HTML> (linhas 1 e 9, respectivamente). Logo após a tag <HTML>, temos a tag <HEAD>. Dentro das tags <HEAD> e </HEAD> podemos colocar diversas informações, muitas vezes chamadas de Metainformação. Contida nesta seção do documento está a informação a respeito do próprio documento, como por exemplo: qual o programa utilizado para gerar o documento, nome do autor, data de criação, etc. As informações contidas nesta seção do documento, são utilizadas, muitas vezes, pelos mecanismos de pesquisa da Internet, como o Altavista (www.altavista.digital.com) e o Yahoo (www.yahoo.com). Uma tag especial, que podemos utilizar é a tag <TITLE> </TITLE>. O texto colocado dentro desta tag, será exibido na Barra de títulos do navegador. Este fato pode ser comprovado pela Figura 2.1.

Figura 2.1: Um exemplo de utilização da tag <TITLE> </TITLE>. Observe o título que aparece na Barra de títulos da Figura 2.1. Logo após o título, no caso do Internet Explorer, aparece a expressão: Microsoft Internet Explorer.

Criando Sites Dinâmicos com ASP 3.0

Após o par de tags <HEAD> </HEAD>, temos a tag <BODY>. A partir da tag <BODY>, na linha 6, é que começa a parte do documento que será exibida pelo navegador. Tudo o que estiver entre o par de chaves <BODY> </BODY> é conteúdo que deve ser exibido pelo navegador. Neste nosso exemplo, muito simples, temos apenas um parágrafo de texto sendo exibido. A tag que define uma parágrafo de texto é <P> </P>, conforme indicado na linha 7. Esta é a estrutura básica de todo documento HTML. Cada tag do HTML pode conter um ou mais atributos. Um atributo modifica a maneira como o navegador exibe o conteúdo da página. Por exemplo, na Listagem 2.2, estamos utilizando o atributo color da tag <FONT>, para modificar as características da fonte do texto a ser exibido. Listagem 2.2 – Utilizando atributos da tag <FONT> </FONT>. 1

<HTML>

<HEAD>

<TITLE>Criando Sites dinâmicos com ASP 3.0 !!!</TITLE>

</HEAD>

<BODY>

<P><FONT color=navy><B>Uma Página HTML muito simples !!!!</B></FONT> </P>

</BODY>

</HTML>

Neste caso, na linha 7, o atributo color é definido para o valor navy, o qual equivale a uma fonte de cor azul marinho. Observe que a tag <FONT> </FONT> é utilizada dentro da tag de parágrafo, para modificar as características da fonte deste parágrafo. Também utilizamos a tag <B></B>, para fazer com que o texto fosse exibido em negrito. Ao visualizar este documento, no navegador, o texto “Uma Página HTML muito simples !!!” será exibido em negrito e com fonte de cor azul marinho. Um estudo mais detalhado sobre as tags da linguagem HTML foge ao escopo deste livro. Novamente indico o livro HTML 4 Curso Básico & Rápido, da editora Axcel Books, para maiores informações sobre a linguagem HTML. Apenas como um exemplo de uma página mais completa, considere a Listagem 2.3, onde utilizamos as tags para criação de tabelas. <TABLE> e </TABLE>, para criar a tabela; <TR> e </TR> para criar novas linhas; <TD> e </TD>, para criar as células dentro de uma linha da tabela. Listagem 2.3 – Uma página HTML com diversas tags. 1

<HTML>

<HEAD>

Capítulo 2 – Uma Introdução ao VBScript

<TITLE>Criando Sites dinâmicos com ASP 3.0 !!!</TITLE>

</HEAD>

<BODY>

<P><FONT color=navy><B>Produção de SOJA da Região Sul !!!</B></FONT></P>

9 10 11

<TR> <TD align=middle>Ano de Produção</TD> <TD align=middle>Produção em Toneladas</TD>

</TR>

<TR>

14 15

</TR>

<TR>

</TR>

<TR>

22 23

</TR>

<TR>

26 27

</TR>

</TABLE>

<P>Dados atualizados em -&gt; 30/06/2000.</P>

</BODY>

</HTML>

Na Figura 2.2, temos o documento da Listagem 2.3, sendo exibido no navegador.

Criando Sites Dinâmicos com ASP 3.0

Figura 2.2: Um exemplo de utilização da tag <TABLE> </TABLE>. No próximo item estudaremos algumas tags ligadas a criação de formulários com HTML. Estudaremos estas tags em maiores detalhes, pois estaremos utilizando-as em diversos exemplos deste livro.

Tags Para a Criação de Formulários HTML A criação de formulários, permite que o usuário preencha alguns campos e envie os dados para o servidor Web. Por exemplo, quando você está comprando pela Internet, em um determinado momento, precisa fornecer informações, como o endereço de entrega, telefone de contato, etc. Você preenche estas informações em um formulário. Normalmente, existe um botão “Enviar”, no qual você deve clicar, após ter preenchido os dados necessários. São muitas as aplicações onde utilizamos formulários.

Criando o Formulário – a tag <FORM> </FORM> Um formulário é criado utilizando as tags <FORM> </FORM>. Na Listagem 2.4, temos um exemplo de utilização da tag <FORM>.

Capítulo 2 – Uma Introdução ao VBScript

Listagem 2.4 – Tag para a criação de formulários. 1

<HTML>

<HEAD>

<TITLE>Um exemplo simples de formulário.</TITLE>

</HEAD>

<BODY>

<P>Cadastro de Clientes:<BR>

Preencha os campos e clique no botão Enviar Dados.</P>

<P>

<FORM action=“” id=FORM1 method=post name=FORM1><BR> { Aqui teríamos tags HTML de definição do formulário }

</FORM>

</BODY>

</HTML>

O atributo mais importante da tag <FORM> é o action. No atributo action, devemos informar o endereço de uma página ASP, um script CGI, ou qualquer outro elemento capaz de processar os dados digitados em um formulário. O usuário preenche os campos do formulário, e, ao clicar no botão Enviar, é chamada a página ou programa indicados no atributo action, o qual é responsável por processar as informações do formulário. Na Listagem 2.5, temos um exemplo em que uma página ASP é responsável por processar os dados enviados pelo formulário. Listagem 2.5 – O atributo action contém o endereço de uma página ASP. 1

<HTML>

<HEAD>

<TITLE>Um exemplo simples de formulário.</TITLE>

</HEAD>

<BODY>

<P>Cadastro de Clientes: <BR>

Preencha os campos e clique no botão Enviar Dados.</P>

<P>

Criando Sites Dinâmicos com ASP 3.0

{ Aqui teríamos tags HTML de definição do formulário } 11

</FORM>

</BODY>

</HTML>

A Figura 2.3 ilustra este processo.

Banco de Dados

Cliente

Servidor Web

O usuário preenche os dados do formulário e clica no botão Enviar. A página ASP, especificada na tag action é chamada.

A página ASP, no servidor, recebe os dados enviados pelo formulário e armazena os dados em um banco de dados, como o Microsoft SQL Server, ou Microsoft Access.

Figura 2.3: A Página ASP armazena os dados digitados no formulário, em um banco de dados. Neste caso, a página ASP recebe os dados do formulário preenchido pelo cliente, processa esses dados, e os armazena em um banco de dados. O servidor de Banco de Dados pode ser o mesmo servidor Web, ou um equipamento separado. Após armazenar os dados no banco de dados, a página ASP envia código HTML puro, de volta para o cliente. Normalmente a página HTML, que retorna para o cliente, apresenta uma mensagem dizendo que os dados foram enviados com sucesso, ou, no caso de erros, apresenta uma mensagem de erro, com a possível causa do problema. A partir do Capítulo 4, estaremos aprendendo a criar páginas ASP para tratar com formulários e armazenar os dados enviados em bancos de dados, bem como para fazer pesquisas em banco de dados.

Criando uma Caixa de Texto – a Tag <INPUT TYPE=“TEXT”> A tag <INPUT TYPE=“TEXT”> cria uma caixa de texto, na qual podem ser exibidos e também digitados valores, quer sejam números ou textos. Esta tag possui os seguintes atributos:

Capítulo 2 – Uma Introdução ao VBScript

Tabela 2.1 Atributos da tag <INPUT TYPE=“TEXT”>. Atributo

Descrição

TYPE

Indica o tipo do campo, no caso de campos para digitar ou exibir informação, utilizamos TEXT.

SIZE

Determina o tamanho do campo que será exibido no navegador.

MAXSIZE

Tamanho máximo de caracteres do campo. MAXSIZE pode ser maior do que SIZE. Neste caso o navegador rola o conteúdo do campo, quando o mesmo atingir o número de caracteres definido por SIZE.

NAME

É o nome associado ao campo, o qual será utilizado pela página ASP, para fazer referência a este campo.

VALUE

É o valor padrão do campo. Por exemplo, para um campo Cidade, podemos definir o atributo VALUE como São Paulo. Neste caso, ao carregar o formulário no navegador, o campo Cidade, já vem com o valor São Paulo. Caso seja necessário, o usuário pode modificar este valor.

Utilizado por linguagens de script, como o VBScript.

Na Listagem 2.6, temos um exemplo de criação de um formulário com dois campos para entrada de texto. Um para o nome, outro para o endereço. Listagem 2.6 – Um formulário com dois campos de texto. 1

<HTML>

<HEAD>

</HEAD>

<BODY>

<P>Digite os dados solicitados, depois clique no botão Enviar:</P>

Criando Sites Dinâmicos com ASP 3.0

<P>Endereço: <INPUT type=“text” id=endereco name=endereco maxlength=20 ></P>

</FORM>

</BODY>

</HTML>

Nas linhas 9 e 10, temos o código HTML, que cria os dois campos do formulário. A Figura 2.4 mostra este formulário, sendo visualizado no Internet Explorer, com os dados digitados pelo usuário.

Figura 2.4: Visualizando um formulário simples no Internet Explorer.

Criando uma Caixa de Texto Para a Digitação de Senhas – a tag <INPUT TYPE=“PASSWORD”> A tag <INPUT TYPE=“PASSWORD”> cria uma caixa de texto, apropriada para a digitação de senhas, pois enquanto o usuário digita a senha, são exibidos, somente asteriscos (*). Isso impede que alguém, descubra a senha do usuário, simplesmente observando quando o mesmo está preenchendo o formulário. Esta tag possui os atributos descritos a seguir. Tabela 2.2 Atributos da tag <INPUT TYPE=“PASSWORD”>. Atributo

Descrição

TYPE

Indica o tipo do campo, no caso de campos para digitar senhas, utilizamos PASSWORD.

Capítulo 2 – Uma Introdução ao VBScript

Atributo

Descrição

SIZE

Determina o tamanho do campo que será exibido no navegador.

MAXSIZE

Tamanho máximo de caracteres do campo. MAXSIZE pode ser maior do que SIZE. Neste caso o navegador rola o conteúdo do campo, quando o mesmo atingir o número de caracteres definido por SIZE.

NAME

É o nome associado ao campo, o qual será utilizado pela página ASP, para fazer referência ao campo.

VALUE

É o valor padrão do campo. Normalmente é deixado em branco.

Utilizado por linguagens de script, como o VBScript.

Na Listagem 2.7, temos um exemplo de criação de um formulário com um campo para a digitação de senhas. Listagem 2.7 – Formulário com um campo para a digitação de senha. 1

<HTML>

<HEAD>

</HEAD>

<BODY>

<P>Digite os dados solicitados, depois clique no botão Enviar:</P>

<P>Endereço: <INPUT type=“text” id=endereco name=endereco maxlength=20 ></P>

<P>Senha: <INPUT type=“password” id=senha name=senha maxLength=10></P>

</FORM>

</BODY>

</HTML>

Na linha 11, temos o código HTML, que cria o campo para a digitação de senha. A Figura 2.5, mostra este formulário, sendo visualizado no Internet Explorer, já com os dados digitados pelo usuário.

Criando Sites Dinâmicos com ASP 3.0

Figura 2.5: O campo para senha exibe somente asteriscos (*).

Criando um “Check Box” – a tag <INPUT TYPE=“CHECKBOX”> A tag <INPUT TYPE=“CHECKBOX”> cria um pequeno quadradinho, conhecido como Check Box. Um Check Box, pode estar em dois estados: marcado ou desmarcado. Normalmente é utilizado para a entrada de dados. Por exemplo, você pode estar utilizando um formulário para pesquisa, no qual podem existir questões que permitam a escolha de mais do que uma alternativa. Neste caso, a utilização de várias tags do tipo Check Box é o mais indicado. Esta tag possui os seguintes atributos. Tabela 2.3 Atributos da tag <INPUT TYPE=“CHECKBOX”>. Atributo

Descrição

TYPE

Indica o tipo do campo, neste caso, utilizamos CHECKBOX.

CHECKED

Indica se o Check Box está, inicialmente, marcado ou não.

NAME

É o nome associado ao campo, o qual será utilizado pela página ASP, para fazer referência a este campo.

Utilizado por linguagens de script, como o VBScript.

VALUE

É o valor de retorno do campo, caso o Check Box seja marcado.

Capítulo 2 – Uma Introdução ao VBScript

Na Listagem 2.8, temos um exemplo de criação de um formulário com a utilização de vários Check Box. Listagem 2.8 – Um formulário com vários Check Box. 1

<HTML>

<HEAD>

</HEAD>

<BODY>

<P>Digite os dados solicitados, depois clique no botão Enviar:</P>

<P>Endereço: <INPUT type=“text” id=endereco name=endereco maxlength=20 ></P>

<P>Senha: <INPUT type=“password” id=senha name=senha maxLength=10></P>

<P>Certificações:

<INPUT id=MCP name=MCP type=“checkbox” value=“MCP”> MCP

<INPUT id=MCSE name=MCSE type=“checkbox” value=“MCSE”>MCSE

<INPUT id=MCDBA name=MCDBA type=“checkbox” value=“MCDBA”>MCDBA

</FORM>

</BODY>

</HTML>

Nas linhas de 13 a 16, temos o código HTML que cria os diversos Check Box. Quando o usuário seleciona um determinado Check Box, o valor do atributo value é associado com o Check Box, que, por sua vez, pode ser armazenado em um campo de uma tabela do banco de dados, pela página ASP, responsável pelo processamento dos dados do formulário. A Figura 2.6 mostra este formulário, sendo visualizado no Internet Explorer, onde o usuário digitou dados nos campos e marcou alguns dos Check Box disponíveis. Observe que mais do que um Check Box pode ser marcado.

Criando Sites Dinâmicos com ASP 3.0

Figura 2.6: O usuário selecionou vários Check Box.

Criando um Conjunto de “Radio Buttons” – a tag <INPUT TYPE=“RADIO”> A tag <INPUT TYPE=“RADIO”> cria um Radio Button. Um Radio Button pode estar em dois estados: marcado ou desmarcado. Utilizamos estes elementos em grupos. A característica de um grupo de Radio Buttons é que somente um dos Radio Button do grupo pode estar selecionado. Se você clicar em um Radio Button que não está selecionado, este será selecionado, e o que estava selecionado será desmarcado. Para criar um grupo de Radio Buttons, é bastante simples, basta atribuir o mesmo valor para o atributo name, para todos os Radio Buttons, que farão parte do grupo. Desta maneira, de todos os Radio Buttons que tiverem o mesmo nome, somente um poderá estar selecionado em um determinado momento. Esta tag possui os atributos descritos na Tabela 2.4. Tabela 2.4 Atributos da tag <INPUT TYPE=“RADIO”>. Atributo

Descrição

TYPE

Indica o tipo do campo, neste caso, utilizamos RADIO.

NAME

É o nome associado a todos os Radio Buttons que fazem parte do mesmo grupo, o qual será utilizado pela página ASP, para fazer referência ao campo.

Capítulo 2 – Uma Introdução ao VBScript

Atributo

Descrição

Utilizado por linguagens de script, como o VBScript.

VALUE

É o valor de retorno do campo, caso o Radio Button seja marcado.

Na Listagem 2.9, temos um exemplo de criação de um formulário com a utilização de um grupo de Radio Buttons, para a seleção do tipo de cartão de crédito. Listagem 2.9 – Um formulário com um grupo de Radio Buttons. 1

<HTML>

<HEAD>

</HEAD>

<BODY>

<P>Digite os dados solicitados, depois clique no botão Enviar:</P>

<P>Endereço: <INPUT type=“text” id=endereco name=endereco maxlength=20 ></P>

<P>Senha: <INPUT type=“password” id=senha name=senha maxLength=10></P>

<P>Certificações:

<INPUT id=MCP name=MCP type=“checkbox” value=“MCP”>MCP

<INPUT id=MCSE name=MCSE type=“checkbox” value=“MCSE”>MCSE

<INPUT id=MCDBA name=MCDBA type=“checkbox” value=“MCDBA”>MCDBA

<P>Selecione o Cartão de Crédito:</P>

<P>

<INPUT id=cartao name=cartao type=“radio” value=“Visa”>Visa

<INPUT id=cartao name=cartao type=“radio” value=“Master Card”>Master Card

<INPUT id=cartao name=cartao type=“radio” value=“Outros”>Outros

</P>

</FORM>

</BODY>

</HTML>

Criando Sites Dinâmicos com ASP 3.0

Nas linhas de 19 a 21, temos o código HTML que cria os diversos Radio Buttons. Quando o usuário seleciona um dos Radio Buttons, o valor do atributo value é associado com o grupo de Radio Buttons, que, por sua vez, pode ser armazenado em um campo de uma tabela do banco de dados, pela página ASP responsável pelo processamento dos dados do formulário. A Figura 2.7 mostra este formulário, sendo visualizado no Internet Explorer, onde o usuário digitou dados nos campos e marcou uma das opções disponíveis para o cartão de crédito. Nunca é demais lembrar que o usuário somente conseguirá marcar uma das opções.

Figura 2.7: O usuário somente consegue selecionar uma das opções para o cartão de crédito.

Criando um Campo Para Digitação de Comentários e Textos Maiores – a tag <TEXTAREA> </TEXTAREA> A tag <TEXTAREA> </TEXTAREA> cria um campo para a digitação de quantidades maiores de texto no formulário. Por exemplo, pode ser um campo para digitação de comentários, críticas e sugestões, ou um campo para detalhar a descrição de um produto, no caso de uma página que apresenta um catálogo de produtos. Esta tag possui os seguintes atributos.

Capítulo 2 – Uma Introdução ao VBScript

Tabela 2.5 Atributos da tag <TEXTAREA> </TEXTAREA>. Atributo

Descrição

NAME

É o nome associado ao campo, o qual será utilizado pela página ASP, para fazer referência ao campo.

Utilizado por linguagens de script, como o VBScript.

WRAP

Determina se o texto deve trocar automaticamente de linha, quando for atingido o tamanho limite do campo. O valor padrão para este campo é SOFT.

Na Listagem 2.10, temos um exemplo de criação de um formulário com a utilização de um campo para a digitação de sugestões e comentários. Listagem 2.10 – Um formulário com um campo para sugestões e comentários. 1

<HTML>

<HEAD>

</HEAD>

<BODY>

<P>Digite os dados solicitados, depois clique no botão Enviar:</P>

<P>Endereço: <INPUT type=“text” id=endereco name=endereco maxlength=20 ></P>

<P>Senha: <INPUT type=“password” id=senha name=senha maxLength=10></P>

<P>Certificações:

<INPUT id=MCP name=MCP type=“checkbox” value=“MCP”>MCP

<INPUT id=MCSE name=MCSE type=“checkbox” value=“MCSE”>MCSE

<INPUT id=MCDBA name=MCDBA type=“checkbox” value=“MCDBA”>MCDBA

<P>Selecione o Cartão de Crédito:</P>

<P>

<INPUT id=cartao name=cartao type=“radio” value=“Visa”>Visa

<INPUT id=cartao name=cartao type=“radio” value=“Master Card”>Master Card

Criando Sites Dinâmicos com ASP 3.0

<INPUT id=cartao name=cartao type=“radio” value=“Outros”>Outros

</P>

</FORM>

</BODY>

</HTML>

Na linha 23, temos o código HTML, que cria o campo para a digitação do texto, para as críticas e sugestões. A Figura 2.8 mostra este formulário, sendo visualizado no Internet Explorer, com as críticas e sugestões digitadas pelo usuário.

Figura 2.8: O usuário digita suas críticas e sugestões.

Criando uma Lista de Opções (Caixa de Combinação) – a tag <SELECT></SELECT> em Combinação com <OPTION></OPTION> A tag <SELECT></SELECT> cria a lista, e as tags <OPTION></OPTION> definem os elementos da lista. Esta lista é chamada de “Caixa de combinação”, na qual é apresentada uma

Capítulo 2 – Uma Introdução ao VBScript

lista de valores, dentre os quais o usuário pode clicar selecionando uma ou mais opções. Cada opção (definida pela tag <OPTION></OPTION>) possui um valor que é exibido na lista, e um valor associado, caso esta opção seja selecionada. Este valor associado é que será armazenado no banco de dados, pela página ASP. Veja os principais atributos da tag <SELECT></SELECT>. Tabela 2.6 Atributos da tag <SELECT></SELECT>. Atributo

Descrição

NAME

É o nome associado à lista, o qual será utilizado pela página ASP, para fazer referência ao campo.

Utilizado por linguagens de script, como o VBScript.

MULTIPLE

Pode ser True ou False. Caso seja True, permite que sejam selecionados múltiplo itens.

Na Listagem 2.11, temos um exemplo de um formulário com a criação de uma lista bairro, com três valores possíveis. Listagem 2.11 – Um formulário com uma Caixa de combinação bairro. 1

<HTML>

<HEAD>

</HEAD>

<BODY>

<P>Digite os dados solicitados, depois clique no botão Enviar:</P>

<P>Endereço: <INPUT type=“text” id=endereco name=endereco maxlength=20 ></P>

<P>Senha: <INPUT type=“password” id=senha name=senha maxLength=10></P>

<P>Selecione o bairro:

<OPTION selected value=CENTRO>CENTRO</OPTION>

<OPTION value=CAMOBI>CAMOBI</OPTION>

16 17

<OPTION value=DORES>DORES</OPTION> </SELECT>

</P>

<P>Certificações:

<INPUT id=MCP name=MCP type=“checkbox” value=“MCP”>MCP

<INPUT id=MCSE name=MCSE type=“checkbox” value=“MCSE”>MCSE

Criando Sites Dinâmicos com ASP 3.0

<INPUT id=MCDBA name=MCDBA type=“checkbox” value=“MCDBA”>MCDBA

<P>Selecione o Cartão de Crédito:</P>

<P>

<INPUT id=cartao name=cartao type=“radio” value=“Visa”>Visa

<INPUT id=cartao name=cartao type=“radio” value=“Master Card”>Master Card

<INPUT id=cartao name=cartao type=“radio” value=“Outros”>Outros

</P>

</FORM>

</BODY>

</HTML>

Nas linhas 13 a 17, temos o código HTML que cria a Caixa de combinação. Na primeira opção <OPTION selected value=CENTRO>CENTRO</OPTION>, a palavra “selected”, indica que esta opção deve estar selecionada por padrão. A Figura 2.9 mostra este formulário, com a opção DORES sendo selecionada na Caixa de combinação bairros.

Figura 2.9: Selecionando uma opção, na Caixa de combinação.

Capítulo 2 – Uma Introdução ao VBScript

Finalizando o Formulário com os Botões Enviar Dados e Limpar Dados – as Tags <INPUT TYPE=“SUBMIT”> e <INPUT TYPE=“CLEAR”> Todo formulário deve ter um botão do tipo Submit. Ao clicar neste botão, é chamada a página ASP (ou outro endereço indicado), indicada no atributo “action” do formulário. A página ASP processa os dados enviados pelo formulário HTML, podendo, por exemplo, adicionar os dados digitados em uma tabela de um banco de dados. Na Tabela 2.7, temos os atributos para um botão do tipo Submit. Tabela 2.7 Atributos da tag <INPUT TYPE=“SUBMIT”>. Atributo

Descrição

TYPE

Deve ser definido como Submit.

NAME

Utilizado por linguagens de script, como o VBScript.

VALUE

É o texto que será exibido no botão.

Embora não seja de uso obrigatório, é bastante comum termos um botão do tipo Reset. Ao clicar neste botão, todos os campos do formulário são apagados. O projetista da aplicação Web é quem irá definir a necessidade, ou não, da utilização de um botão do tipo Reset. Na Tabela 2.8, temos os atributos para um botão do tipo Reset. Tabela 2.8 Atributos da tag <INPUT TYPE=“RESET”>. Atributo

Descrição

TYPE

Deve ser definido como Reset.

NAME

Utilizado por linguagens de script, como o VBScript.

VALUE

É o texto que será exibido no botão.

Na Listagem 2.12, completamos o nosso formulário de exemplo, com a adição de um botão do tipo Submit e outro botão do tipo Reset. Listagem 2.12 – O formulário completo, com os botões do tipo Submit e Reset já incluídos. 1

<HTML>

<HEAD>

Criando Sites Dinâmicos com ASP 3.0

</HEAD>

<BODY>

<P>Digite os dados solicitados, depois clique no botão Enviar dados.</P>

<P>Endereço: <INPUT type=“text” id=endereco name=endereco maxlength=20 ></P>

<P>Senha: <INPUT type=“password” id=senha name=senha maxLength=10></P>

<P>Selecione o bairro:

<OPTION selected value=CENTRO>CENTRO</OPTION>

<OPTION value=CAMOBI>CAMOBI</OPTION>

16 17

<OPTION value=DORES>DORES</OPTION> </SELECT>

</P>

<P>Certificações:

<INPUT id=MCP name=MCP type=“checkbox” value=“MCP”> MCP

<INPUT id=MCSE name=MCSE type=“checkbox” value=“MCSE”>MCSE

<INPUT id=MCDBA name=MCDBA type=“checkbox” value=“MCDBA”>MCDBA

<P>Selecione o Cartão de Crédito:</P>

<P>

<INPUT id=cartao name=cartao type=“radio” value=“Visa”>Visa

<INPUT id=cartao name=cartao type=“radio” value=“Master Card”>Master Card

<INPUT id=cartao name=cartao type=“radio” value=“Outros”>Outros

</P>

<P>

Capítulo 2 – Uma Introdução ao VBScript

</P>

</FORM>

</BODY>

</HTML>

Nas linhas 32 e 33, temos o código HTML que cria os botões “Enviar dados” e “Limpar dados”, respectivamente. A Figura 2.10, mostra o nosso formulário de exemplo, já completo.

Figura 2.10: O formulário de exemplo, já completo. Com isso concluímos a nossa revisão, sobre HTML. Esta revisão fez-se necessária, pois, ao longo de todo livro, estaremos utilizando formulários HTML, em conjunto com páginas ASP. No restante deste capítulo, e no seguinte, estarei apresentando os fundamentos do VBScript.

Criando Sites Dinâmicos com ASP 3.0

Declaração e Utilização de Variáveis no VBScript O que é uma Variável ? Uma variável é um espaço da memória do computador, reservado para armazenar valores. Este espaço de memória é ligado ao nome da variável. Na maioria das aplicações, faz-se necessário o uso de variáveis. Por exemplo, você desenvolve uma página para realizar cálculos financeiros, como por exemplo, empréstimos de longo prazo. O usuário digita um valor para o empréstimo e o prazo desejado. Com base na taxa de juros utilizada, é feito o cálculo das prestações. Os valores digitados pelo usuário precisam estar disponíveis no momento do cálculo. A maneira de manter estes dados disponíveis é através da utilização de variáveis. Quando o usuário digita o valor do empréstimo desejado, este valor é armazenado em uma variável, para utilização no momento de realização dos cálculos. Estaremos utilizando variáveis ao longo de todo livro. Este é um conceito existente em todas as linguagens de programação, como por exemplo em Visual Basic, C, C++, e assim por diante.

Inserindo Código VBScript Antes de continuarmos com variáveis, vamos aprender a inserir código VBScript em uma página HTML. Existem marcadores especiais, que indicam o início e o fim de um código VBScript. Para inserir código VBScript, utilizamos a tag <SCRIPT>, conforme indicado abaixo: <SCRIPT LANGUAGE=vbscript> <!— Aqui vamos inserir o código VBScript. —> </SCRIPT>

NOTA Observe a utilização do atributo LANGUAGE. Este atributo define qual a linguagem de script que será utilizada. Além do VBScript, poderíamos utilizar o JavaScript. Neste livro, estaremos utilizando VBScript.

NOTA A utilização de <!— , no início do código, e de —>, no final do código, não é obrigatória. Estas são as tags para comentários em páginas HTML. No entanto, é recomendável que se utilize estas tags. Os navegadores mais antigos, tais como Internet Explorer 1.0, não reconhecem VBScript; se não utilizarmos as tags de comentário, o código VBScript será exibido como se

Capítulo 2 – Uma Introdução ao VBScript

fosse texto, o que não é desejável. Com a utilização das tags de comentário, garantimos que os navegadores que não “entendem” VBScript, simplesmente ignorem o código.

Na Listagem 2.13, temos um exemplo simples da inserção de um script em um página HTML. Listagem 2.13 – Um exemplo simples de VBScript. 1.

<HTML>

<HEAD>

<TITLE>Um exemplo simples de VBScript !!!</TITLE>

</HEAD>

<BODY>

<!—

x=Date()

9 10

MsgBox x —>

</SCRIPT>

<P>UM EXEMPLO SIMPLES DE VBScript !!!</P>

</BODY>

</HTML>

Nas linhas 8 e 9, é que temos o código VBScript, propriamente dito. Não se preocupe com o código, neste momento. Neste e no próximo capítulo, veremos detalhes sobre a utilização de funções, tais como Date( ) e MsgBox. Ao abrir esta página no Internet Explorer, será aberta uma janela, na qual é exibida a data do sistema, conforme indicado na Figura 2.11.

Figura 2.11: Mensagem exibida pelo código VBScript.

Declaração e “Tipo” de Variável No VBScript não é obrigatória a declaração de variáveis. Porém é recomendável que declaremos todas as variáveis, de tal forma que o código fique mais claro e de fácil compreensão. Para declararmos uma variável, utilizamos o comando Dim, conforme exemplificado a seguir:

Criando Sites Dinâmicos com ASP 3.0

Dim x Dim nome Dim teste

O formato geral para o comando Dim é: Dim nome_da_variável. Também podemos declarar mais do que uma variável, com um único comando Dim. Para isto, basta separar as variáveis, com vírgula, conforme exemplificado a seguir: Dim x,y,z Dim nome Dim teste1,teste2

IMPORTANTE Observe que definimos o “tipo” de cada variável. O tipo define quais dados podem ser armazenados em uma variável. Por exemplo, variáveis que armazenam valores numéricos, não devem aceitar caracteres de texto. Variáveis que armazenam datas, não devem aceitar datas inválidas, como por exemplo 30/02/2000. Toda variável no VBScript é do tipo Variant, isto significa que a variável pode ser de qualquer tipo. O que define o tipo da variável é o valor que está armazenado no momento. Existem funções de conversão de tipo, conforme veremos mais adiante.

Também podemos utilizar variáveis que não foram, explicitamente, declaradas com o comando Dim. Com isso, a variável é criada na memória, no momento da sua utilização. Na Listagem 2.14, temos um exemplo simples de utilização de variáveis não declaradas explicitamente. Listagem 2.14 – Utilização de variáveis não declaradas. 1

<HTML>

<HEAD>

<TITLE>Um exemplo simples de VBScript !!!</TITLE>

</HEAD>

<BODY>

<!—

a=5

b=2

c=a+b

Msgbox “A variável C vale: ” & c

—>

</SCRIPT>

<P>Exemplo de utilização de variáveis.</P>

Capítulo 2 – Uma Introdução ao VBScript

</BODY>

</HTML>

Ao abrir esta página no Internet Explorer, será aberta uma janela, conforme indicado na Figura 2.12.

Figura 2.12: Mensagem exibida pelo código VBScript. Podemos fazer com que seja obrigatória a declaração de todas as variáveis. Para isso, basta utilizar o comando Option Explicit. Este comando deve ser inserido, bem no início do bloco de script, antes de qualquer procedimento. Veremos mais sobre procedimentos, no próximo capítulo. Caso você utilize este comando, variáveis não declaradas, serão simplesmente ignoradas, não sendo gerada nenhuma mensagem de erro. Porém os valores que dependem das variáveis não declaradas, não serão corretamente calculados. Na Listagem 2.15, acrescentamos a opção Option Explicit. Listagem 2.15 – Tornando obrigatória a declaração de variáveis. 1

<HTML>

<HEAD>

<TITLE>Um exemplo simples de VBScript !!!</TITLE>

</HEAD>

<BODY>

<!—

Option Explicit

a=5

b=2

c=a+b

Msgbox “A variável C vale: ” & c

—>

</SCRIPT>

<P>Exemplo de utilização de variáveis.</P>

</BODY>

</HTML>

Criando Sites Dinâmicos com ASP 3.0

Ao abrir esta página no Internet Explorer, não será exibida a janela indicada na Figura 2.12; isto porque as variáveis a, b e c não foram declaradas. Uma vez que a declaração tornou-se obrigatória, com a adição do comando Option Explicit, as variáveis simplesmente não existem. O Internet Explorer exibirá somente o texto “Exemplo de utilização de variáveis”, conforme indicado pela Figura 2.13.

Figura 2.13: As variáveis não declaradas foram ignoradas. O tipo Variant é formado de pequenas unidades, chamadas subtipos. Cada subtipo, identifica de que maneira os dados são armazenados em uma variável do tipo Variant. Por exemplo, variáveis do subtipo Integer são armazenadas de uma maneira diferente de variáveis do subtipo Long. Na Tabela 2.9, temos uma descrição dos principais subtipos. Tabela 2.9 Subtipos do tipo Variant. Subtipo

Descrição

Empty

O valor é zero para variáveis numéricas ou uma string de tamanho zero (“ ”), para variáveis de texto.

Null

A variável não contém dados válidos.

Boolean

Contém variáveis que somente podem assumir dois valores: Verdadeiro ou Falso (True ou False).

Byte

Valor inteiro, na faixa de 0 até 255.

Integer

Valor inteiro, na faixa de -32768 até 32767.

Currency

Valores na faixa de –923.337.203.685.447,5808 até 922.337.203.685.447,5807

Capítulo 2 – Uma Introdução ao VBScript

Subtipo

Descrição

Long

Valor inteiro, na faixa de –2.147.483.648 até 2.147.483.647.

Date(Time)

É um número que representa a data entre 01 de Janeiro do ano 100, até 31 de Dezembro de 9999 (olha o bug do ano 10000 chegando).

String

Texto de tamanho variável, pode conter, aproximadamente, dois bilhões de caracteres.

Object

Pode conter um objeto qualquer, como um Controle ActiveX, ou um Objeto COM+.

Error

Pode conter um número de erro.

Fazendo Cálculos e Comparações com o VBScript – Operadores Para realizarmos cálculos e comparações entre variáveis, podemos utilizar operadores. Neste item estaremos tratando sobre operadores aritméticos e operadores de comparação.

Fazendo Cálculos com os Operadores Aritméticos Podemos realizar cálculos, utilizando operadores no VBScript. Na Tabela 2.10, temos uma descrição dos operadores que podemos utilizar. Tabela 2.10 Operadores do VBScript. Operador

Símbolo

Descrição

Adição

Soma o valor de duas ou mais variáveis.

Subtração

Subtração entre duas ou mais variáveis.

Multiplicação

Multiplica os valores de duas ou mais variáveis.

Divisão

Divide o valor de duas ou mais variáveis.

Inteiro da Divisão

Retorna a parte inteira, da divisão entre dois números.

Criando Sites Dinâmicos com ASP 3.0

Operador

Símbolo

Descrição

Exponenciação

x^y – É o valor do número x, elevado na potência y.

Módulo

Mod

Retorna o resto de uma divisão de dois números.

Na Listagem 2.16, temos um exemplo, demonstrando o uso destes diversos operadores. Listagem 2.16 – Exemplo de utilização dos operadores aritméticos. 1

<HTML>

<HEAD>

<TITLE>Um exemplo simples do uso de Operadores Aritméticos !!!</TITLE>

</HEAD>

<BODY>

<!—

Option Explicit

Dim a

Dim b

Dim som, subtr, divis, mult, intdivs, expo, modul

a=25

b=3

som=a+b

subtr=a-b

divis=a/b

mult=a*b

intdivs=a\b

expo=a^b

modul= a mod b

‘Uso de MsgBox para exibir os resultados.

MsgBox “Os números são: ” & a & “ e ” & b & Chr(13)

MsgBox “Soma: ” & som & Chr(13)& “Subtração: ” & subtr & Chr(13)

MsgBox “Divisão: ” & divis & Chr(13)& “Multiplicação: ” & mult & Chr(13)

MsgBox “Divisão inteira: ” & intdivs & Chr(13)& “Exponenciação: ” & expo & Chr(13)

MsgBox “Resto da divisão: ” & modul

Capítulo 2 – Uma Introdução ao VBScript

—>

</SCRIPT>

<P>Exemplo de utilização de Operadores Aritméticos.</P>

</BODY>

</HTML>

Neste exemplo, nas linhas de 14 a 20, utilizamos os operadores aritméticos, para realizar uma série de operações com os valores atribuídos às variáveis “a” e “b”. Depois, da linha 22 até a 26, utilizamos a função MsgBox, para exibir os resultados obtidos. O uso da função MsgBox merece alguns comentários. Primeiro, utilizamos a função MsgBox para exibir mensagens em uma pequena janela, chamada de janela pop-up. Podemos exibir texto e também valores de variáveis. Quando temos que exibir diversos componentes, como um pouco de texto, em seguida o valor de uma variável, depois mais texto, e assim por diante, devemos utilizar o operador de concatenação &. Este operador permite que as diversas partes sejam exibidas como uma única mensagem. Considere o exemplo da linha 22: 22

MsgBox “Os números são: ” & a & “ e ” & b & Chr(13)

Neste exemplo, primeiro, é exibido o texto “Os números são: ”, logo em seguida o valor da variável a. Observe que as duas partes são concatenadas com o operador &. Depois concatenamos o valor da variável b, e finalmente utilizamos a função Chr(13). A função Chr(número) envia o caractere correspondente ao número digitado entre parênteses. Este número é o número do caractere no padrão ASCII (American Standard Caracter Interchange Information). No código ASCII, cada caractere possui um número associado; o número 13, é associado ao <ENTER>. Com isso, estamos enviando um <ENTER> para a caixa de mensagem, o que equivale a uma troca de linha. Portanto, utilizamos o Chr(13) para simular um <ENTER>, de tal maneira que os dados não saiam todos “emendados”, na mesma linha. Ao abrir a página da Listagem 2.16, no Internet Explorer, o código da linha 22, produz a mensagem da Figura 2.14.

Figura 2.14: MsgBox da linha 22. Ao clicar em OK, uma nova mensagem é exibida, devido a função MsgBox da linha 23. O código da linha 23, produz a mensagem da Figura 2.15.

Criando Sites Dinâmicos com ASP 3.0

Figura 2.15: MsgBox da linha 23. Ao clicar em OK, uma nova mensagem é exibida, devido a função MsgBox da linha 24. O código da linha 24, produz a mensagem da Figura 2.16.

Figura 2.16: MsgBox da linha 24. Ao clicar em OK, uma nova mensagem é exibida, devido a função MsgBox da linha 25. O código da linha 25, produz a mensagem da Figura 2.17.

Figura 2.17: MsgBox da linha 25. Ao clicar em OK, uma nova mensagem é exibida, devido a função MsgBox da linha 26. O código da linha 26, produz a mensagem da Figura 2.18.

Capítulo 2 – Uma Introdução ao VBScript

Figura 2.18: MsgBox da linha 26. Com o uso de operadores, podemos realizar uma série de operações sobre as variáveis existentes no script.

Comparando Valores com os Operadores de Comparação Em determinadas situações, existe a necessidade de efetuarmos comparações entre os valores de duas variáveis ou expressões. Com base no resultado da comparação – Verdadeiro ou Falso –, o nosso script pode seguir caminhos diferentes. Normalmente utilizamos comparações, nas estruturas de controle do script, também conhecidas como laços de controle. Para que possamos estudar os operadores de comparação, vamos apresentar uma das estruturas de controle mais simples que existem no VBScript, a estrutura If Then Else. Abaixo temos um exemplo do funcionamento da estrutura If Then Else: If x>y Then ‘ Comandos a serem executados quando x for maior do que y Else ‘ Comandos a serem executados quando x for menor do que y End If

Conforme podemos ver, a estrutura If Then Else é bastante simples. Fazemos um teste no início da estrutura. Se o valor do teste for verdadeiro, executamos os comandos na seqüência, caso contrário, executamos os comandos após o Else. Note que utilizamos o operador de comparação “maior do que >”, no caso x>y, estamos testando se x é maior do que y. Observe que no exemplo acima, não serão executados comandos, caso x seja igual a y. Podemos utilizar laços If Then Else mais complexos, como os do exemplo: If x>y Then ‘ Comandos a serem executados quando x for maior do que y ElseIf x=y Then ‘ Comandos a serem executados quando x for igual a

Else ‘ Comandos a serem executados quando x for menor do que y End If

Criando Sites Dinâmicos com ASP 3.0

Podemos utilizar tantos ElseIf, quantos forem necessários. Na Tabela 2.11, temos uma descrição dos operadores que podemos utilizar. Tabela 2.11 Operadores de comparação do VBScript. Descrição

Símbolo

Descrição

Igualdade

É igual a.

Desigualdade

É diferente de.

Maior que

É maior do que.

Menor que

É menor do que.

Maior ou igual

É maior ou igual a.

Menor ou igual

É menor ou igual a.

Na Listagem 2.17, temos um exemplo, demonstrando o uso destes diversos operadores. Listagem 2.17 – Exemplo de utilização dos operadores de comparação. 1

<HTML>

<HEAD>

<TITLE>Exemplo de utilização dos operadores de comparação.</TITLE>

</HEAD>

<BODY>

<!—

Option Explicit

Dim x,y,z,k

x=12

y=15

z=20

k=15

If x<y Then

MsgBox “x é menor do que y.”

Else

Capítulo 2 – Uma Introdução ao VBScript

MsgBox “x é maior do que y.”

End If

If y<x Then

20 21

MsgBox “y é menor do que x” Else

MsgBox “y é maior do que x”

End If

If y<=k Then

25 26

MsgBox “y é menor ou igual a k” Else

MsgBox “y é maior do que k”

End If

If x<>z Then

30 31

MsgBox “x e z são diferentes” End If

—>

</SCRIPT>

<P>EXEMPLO DE OPERADORES DE COMPARAÇÃO:</P>

</BODY>

</HTML>

Ao carregarmos a página de exemplo da Listagem 2.17, no Internet Explorer, veremos uma seqüência de mensagens, produzidas pela função MsgBox. Na seqüência, descrevo cada uma destas mensagens. O código das linhas 14 até 18 produz a mensagem indicada na Figura 2.19, pois x é menor do que y.

Figura 2.19: MsgBox produzida pela linha 15, uma vez que x é menor do que y.

Criando Sites Dinâmicos com ASP 3.0

Ao clicar em OK, uma nova mensagem é exibida, devido a função MsgBox da linha 22. Como o teste y<x é falso, não é executada a linha 20, mas sim a linha 22. O código da linha 22 produz a mensagem da Figura 2.20.

Figura 2.20: MsgBox produzida pela linha 22, uma vez que y não é menor do que x. Ao clicar em OK, uma nova mensagem é exibida, devido a função MsgBox da linha 25. Como o teste y<=k é verdadeiro (pois os valores de y e de k são iguais), é executada a linha 25. O código da linha 25 produz a mensagem da Figura 2.21.

Figura 2.21: MsgBox produzida pela linha 25, uma vez que y é igual a k. Ao clicar em OK, uma nova mensagem é exibida, devido a função MsgBox da linha 30. Como o teste x<>z é verdadeiro, é executada a linha 30, este código produz a mensagem da Figura 2.22.

Figura 2.22: MsgBox produzida pela linha 30, uma vez que x é diferente de z.

Capítulo 2 – Uma Introdução ao VBScript

O uso de operadores de comparação amplia o leque de possibilidades para nossos scripts. Devemos ter alguns cuidados quando comparamos variáveis que possuem valores de tipos diferentes, como por exemplo, número e texto. A Tabela 2.12 descreve o que acontece, quando comparamos variáveis com valores de tipos diferentes. Tabela 2.12 Comparando valores de tipos diferentes. Comparação

Resultado

Entre duas variáveis com valores numéricos.

Comparação normal.

Entre duas variáveis com valores de texto.

É efetuada uma comparação entre valores de texto. Por exemplo Xuxa é maior do que Abel.

Uma das variáveis possui um valor numérico e a outra possui texto.

O valor numérico é sempre considerado menor do que o texto.

Uma das variáveis possui um valor numérico e a outra esta vazia, atribuindo 0, para a variável vazia.

Efetua uma comparação numérica, sem valor.

Uma das variáveis possui um valor de texto e a outra esta vazia, atribuindo texto de comprimento zero (“ ”), para a variável vazia.

Efetua uma comparação de texto, sem valor.

As duas variáveis possuem um valor vazio.

Ambas são consideradas iguais.

Com a utilização dos operadores aritméticos e de comparação, ampliamos bastante o leque de opções na criação de scripts com o VBScript. No próximo item, veremos alguns detalhes sobre “Escopo” de variáveis.

O Escopo das Variáveis, no VBScript O escopo de uma variável define em que partes do código de um script a variável pode ser utilizada. Em VBScript, podemos ter dois escopos para as variáveis: ➥ Escopo de script: Uma variável declarada dentro do script, mas fora de qualquer procedimento. Com isso a variável pode ser utilizada dentro de todo o bloco de código do script, inclusive dentro dos procedimentos, caso exista algum. Uma variável declarada em nível de script, existe enquanto o mesmo estiver sendo executado. Quando falamos de script, não é um único bloco de script, pois sabemos que uma página pode conter mais do que um bloco. Uma variável declarada em nível de script, poderá ser utilizada em todos os blocos de script da página.

Criando Sites Dinâmicos com ASP 3.0

➥ Escopo de procedimento: A variável somente pode ser utilizada dentro do procedimento onde a mesma é declarada. Se tentarmos utilizar a variável fora do procedimento, onde foi declarada, não teremos acesso a mesma. Uma variável declarada em nível de procedimento existe enquanto o procedimento estiver sendo executado.

NOTA Um procedimento é um bloco de código que pode ser chamado em qualquer ponto do script. Ao chamarmos um procedimento, a execução é deslocada para dentro do procedimento. Após concluído o procedimento, a execução segue com a linha seguinte à que chamou o procedimento. Veremos maiores detalhes sobre procedimentos e funções no final deste capítulo.

Vamos analisar o exemplo da Listagem 2.18, para entendermos melhor este conceito de escopo de uma variável. Neste exemplo, também estaremos introduzindo um conceito muito importante, o conceito de evento e procedimentos que executam código em resposta a eventos. Listagem 2.18 – Exemplo para análise do escopo de variáveis. 1

<HTML>

<HEAD>

<TITLE>Analisando o escopo de variáveis !!!</TITLE>

<!—

‘ No evento onclick, do botão analisar,

‘ chamamos o procedimento proc1.

Sub analisar_onclick

9 10

Call proc1 End Sub

—>

</SCRIPT>

</HEAD>

<BODY>

<!—

‘ As variáveis declaradas abaixo

‘ Serão visíveis em todo o script

Capítulo 2 – Uma Introdução ao VBScript

Dim x, y

x=10

y=20

‘Agora vamos criar um procedimento

‘E declarar duas variáveis dentro deste procedimento.

‘Estas variáveis somente serão visíveis,

‘Dentro deste procedimento.

Sub proc1()

Dim a, b

a=5

b=7

MsgBox “x= ” & x & “ y= ” & y & “ a= ” & a & “ b= ” & b

End Sub

’ Agora vamos tentar utilizar os valores de a e b

’ Fora do procedimento proc1.

’ Observe que a variável aux1 não é calculada

’ corretamente, uma vez que os valores de a e b

’ não estão disponíveis, fora do procedimento proc1.

aux1=a+b

MsgBox “aux1= ” & aux1

—>

</SCRIPT>

<P>EXEMPLO PARA ANÁLISE DO ESCOPO DE VARIÁVIES.</P>

<P>CLIQUE NO BOTÃO ANALISAR - >>

</BODY>

</HTML>

Vamos analisar uma série de detalhes sobre esta listagem. ➥ Na linha 43, temos a tag INPUT, com type=“button”, esta tag insere um botão de comando, no qual o usuário pode clicar. Na Figura 2.23, podemos ver a página com o botão analisar.

Criando Sites Dinâmicos com ASP 3.0

Figura 2.23: Botão analisar, criado com a tag <INPUT TYPE=“BUTTON”>. ➥ Ao carregar esta página no Internet Explorer, serão executadas as linhas 37 e 38, pois todo código, que não estiver dentro de um procedimento, é automaticamente executado quando a página é carregada. Este código exibe o valor da variável aux1. Porém, conforme podemos notar na Figura 2.24, o valor exibido é zero (e não 12 que seria a soma de a=5 com b=7). Isto acontece porque as variáveis “a” e “b” foram definidas dentro do procedimento proc1, e somente existem quando o procedimento proc1 for chamado. Neste caso, como não existem os valores, a variável aux1 fica com o seu valor inicial de quando foi declarada, que por padrão do VBScript é zero.

Figura 2.24: Variável aux1, com seu valor zerado. ➥ Qualquer coisa que o usuário faça em uma página é considerado um evento. Por exemplo, quando o usuário clica no botão analisar, é gerado o evento analisar_onclick. Podemos escrever código VBScript para qualquer evento, definido no modelo de eventos do Internet Explorer. No nosso exemplo, nas linhas de 8 a 10, definimos código em

Capítulo 2 – Uma Introdução ao VBScript

resposta ao evento onclick, do botão analisar. Quando o usuário clicar no botão analisar, este evento é gerado e o código da linha 9 é executado. Este código chama o procedimento proc1. Dentro do procedimento proc1, são definidas as variáveis a e b (linhas 27 a 29). Depois é utilizado o comando MsgBox para exibir os valores das variáveis x, y, a e b. Como as variáveis x e y foram declaradas em nível de script, isto é, fora de qualquer procedimento, as mesmas são acessíveis em qualquer ponto do script. Com isso a mensagem exibe os valores corretamente, conforme indicado na Figura 2.25. Veremos maiores detalhes sobre eventos e procedimentos no Capítulo 4.

Figura 2.25: Variáveis em nível de script são visíveis em toda a página. ➥ Todas as linhas que iniciam com um apóstrofe (‘) são comentários. Linhas de comentários servem para documentar nossos scripts, facilitando a interpretação dos mesmos. Com esse exemplo foi possível verificar, na prática, o conceito de escopo (algumas vezes chamado de visibilidade) das variáveis. No próximo item, trataremos das estruturas e laços de controle, que são elementos muito importantes na criação de scripts.

Estruturas Para Controle de Fluxo em VBScript Para que possamos criar aplicações com utilidade prática, aplicadas na solução de problemas reais, precisamos poder controlar o fluxo de execução de um script. No VBScript, temos diversas “estruturas” que permitem um controle bastante eficaz do fluxo de execução. Neste item, estaremos estudando diversas destas estruturas.

Estruturas de Decisão Em um primeiro grupo, temos as chamadas estruturas de decisão. São estruturas que realizam um teste lógico, e executam determinados comandos quando o teste resultar verdadeiro, ou um conjunto diferente de comandos, quando o teste resultar falso. Agora passaremos a analisar as estruturas de decisão, disponíveis no VBScript.

Criando Sites Dinâmicos com ASP 3.0

A Estrutura If...Then A estrutura If...Then é uma das estruturas de decisão mais conhecidas. Toda linguagem implementa esta estrutura. É utilizada para executar determinados comandos, caso uma condição seja verdadeira. A forma geral desta estrutura é a seguinte: If condição Then Comandos a serem executados, caso a condição seja verdadeira. End If

Uma condição é testada; caso a condição seja verdadeira, um ou mais comandos podem ser executados. Considere o exemplo da Listagem 2.19. Listagem 2.19 – Um exemplo simples da estrutura If...Then. 1

<!—

Dim x, y

x=10

y=15

If x<y Then

MsgBox “x é menor do que y”

End If

—>

</SCRIPT>

Neste exemplo, a mensagem “x é menor do que y”, será exibida, uma vez que o teste x<y é verdadeiro, conforme podemos constatar pelos valores atribuídos às variáveis x e y.

A Estrutura If...Then...Else A estrutura If...Then...Else, acrescenta mais uma possibilidade à estrutura If...Then. É utilizada para executar determinados comandos, caso uma condição seja verdadeira, ou um conjunto diferente de comandos, caso a condição seja falsa. A forma geral desta estrutura é a seguinte: If condição Then Comandos a serem executados, caso a condição seja verdadeira. Else Comandos a serem executados, caso a condição seja falsa. End If

Capítulo 2 – Uma Introdução ao VBScript

Uma condição é testada; caso a condição seja verdadeira, um determinado comando, ou conjunto de comandos será executado; caso a condição seja falsa, um comando, ou conjunto de comandos diferentes, será executado. Considere o exemplo da Listagem 2.20. Listagem 2.20 – Um exemplo simples da estrutura If...Then...Else. 1

<!—

Dim x, y

x=15

y=10

If x<y Then

MsgBox “x é menor do que y”

Else

MsgBox “x é maior do que y”

End If

—>

</SCRIPT>

Neste exemplo, a mensagem “x é maior do que y” será exibida, uma vez que o teste x<y é falso, conforme podemos constatar pelos valores atribuídos às variáveis x e y.

A Estrutura If...Then...ElseIf...Else A estrutura If...Then...ElseIf...Else nos dá um poder maior, para testarmos diversas possibilidades. É utilizada quando precisamos realizar mais do que um teste lógico. Neste caso, para cada novo teste que se faça necessário, utilizamos um ElseIf. A forma geral desta estrutura é a seguinte: If condição Then Comandos a serem executados, caso a condição seja verdadeira. ElseIf condição 2 Comandos a serem executados, caso a condição2 seja verdadeira. ElseIf condição 3 Comandos a serem executados, caso a condição3 seja verdadeira. ... ElseIf condição n Comandos a serem executados, caso a condição n seja verdadeira. Else Comandos a serem executados, caso nenhuma das condições anteriores seja verdadeira. End If

Criando Sites Dinâmicos com ASP 3.0

Uma condição é testada; caso a condição seja verdadeira, um determinado comando, ou conjunto de comandos será executado; caso a condição seja falsa, podemos fazer um segundo teste (condição 2). Caso a segunda condição seja verdadeira, um determinado comando, ou conjunto de comandos será executado, e assim por diante, para n condições. Caso nenhuma das condições seja verdadeira, os comandos após a cláusula Else, serão executados. Considere o exemplo da Listagem 2.21. Listagem 2.21 – Um exemplo simples da estrutura If...Then...ElseIf...Else. 1

<!—

Dim x, y

Dim z, k

Dim w, p

x=35

y=30

z=25

k=20

w=15

p=10

If x<y Then

13 14

MsgBox ElseIf

15 16

MsgBox ElseIf

17 18

ElseIf

21 22

Then

“x é menor do que p”

Else

23 24

Then

“x é menor do que w”

x<p

MsgBox

Then

“x é menor do que k”

x<w

MsgBox

Then

“x é menor do que z”

x<k

MsgBox ElseIf

19 20

“x é menor do que y” x<z

MsgBox

“x é o maior dos números”

End If

—>

</SCRIPT>

Neste exemplo, a mensagem “x é maior dos números” será exibida, uma vez que todos os testes falham (pois x é o maior número). Será executado o comando da linha 23, logo abaixo do Else. Mas o que acontece, quando um dos ElseIf é verdadeiro?

Capítulo 2 – Uma Introdução ao VBScript

Os teste vão sendo feitos. Quando o teste de um dos ElseIf for verdadeiro, os comandos abaixo do ElseIf verdadeiro, serão executados e o laço será encerrado. Em resumo, quando um dos ElseIf apresentar um teste verdadeiros, os comandos relacionados serão executados, e os demais não serão avaliados, seguindo a execução para o primeiro comando, após o End If.

A Estrutura Select...Case Quando precisamos realizar uma série de testes, é mais eficiente utilizarmos uma estrutura Select...Case, do que utilizarmos uma série de testes utilizando a estrutura If...Then...ElseIf. O funcionamento da estrutura Select...Case é bastante intuitivo. Considere o exemplo da Listagem 2.22. Listagem 2.22 – Um exemplo simples da estrutura Select...Case. 1

<!—

Dim x

x=10

Select Case x

Case 2

7 8

MsgBox “x vale 2 !” Case 4

9 10

MsgBox “x vale 4 !” Case 6

11 12

MsgBox “x vale 6 !” Case 8

13 14

MsgBox “x vale 8 !” Case 10

15 16

MsgBox “x vale 10 !” Case Else

17 18

MsgBox “x não é um número par, menor do que 12 ” End Select

—>

</SCRIPT>

A estrutura Select Case x vai testar o valor de x. Em cada um dos Case, o valor de x está sendo testado. Quando for encontrado um valor coincidente com o de x, os comandos abaixo deste Case serão executados. No nosso exemplo, o comando MsgBox “x vale 10 !”, abaixo de Case 10, será executado. O comando abaixo do Case Else somente será executado, se todos os testes anteriores falharem.

Criando Sites Dinâmicos com ASP 3.0

O uso da estrutura Select...Case torna o código mais eficiente e de mais fácil leitura.

Estruturas de Repetição Em determinadas situações, precisamos repetir um ou mais comandos, um número específico de vezes, ou até que uma determinada condição torne-se verdadeira ou falsa. Para isso, utilizamos as chamadas estruturas de repetição, ou laços. A partir de agora, estaremos analisando as estruturas de repetição disponíveis.

A Estrutura For...Next Utilizamos o laço For...Next para repetir um segmento de código, um número determinado de vezes. Utilizamos esta estrutura, quando já sabemos o número de vezes que uma determinada seção de código deve ser repetida. Neste tipo de estrutura, normalmente, utilizamos uma variável como contador. Este contador varia de um valor inicial até um valor final. O formato geral desta estrutura é o seguinte: For contador=inicio to fim incremento Comando1 Comando2 ... Comandon Next

No início a variável contador tem o valor definido para um determinado valor. Em cada passagem do laço, a variável contador é incrementada pelo valor definido em incremento. Caso não seja definido o incremento, será utilizado o padrão 1. Considere o exemplo da Listagem 2.23. Listagem 2.23 – Um exemplo simples da estrutura For...Next. 1

<!—

Dim x

x=10

Soma=0

‘ Faz a soma dos dez primeiros números maiores do que zero

For i=1 to x

Soma = Soma +i

100

Capítulo 2 – Uma Introdução ao VBScript

MsgBox “Valor da Soma = ” & Soma

—>

</SCRIPT>

Neste exemplo, a variável i inicia com o valor 1. Em cada passo, o valor de i é acrescentado à variável Soma. Como o incremento não foi definido, será utilizado o padrão que é 1. Com isso, ao final do laço For...Next, a variável Soma terá armazenado o valor da soma dos dez primeiros números inteiros, conforme indicado pela Figura 2.26.

Figura 2.26: A soma dos dez primeiros números inteiros. Poderíamos utilizar um valor de incremento diferente de 1, por exemplo, para obter a soma somente dos números ímpares, menores do que 10. Considere o exemplo da Listagem 2.24. Listagem 2.24 – Um exemplo simples da estrutura For...Next. 1

<!—

Dim x

x=10

Soma=0

‘ Faz a soma dos cinco primeiros números ímpares maiores do que zero

For i=1 to x Step 2

Soma = Soma +i

MsgBox “Valor da Soma = ” & Soma

—>

</SCRIPT>

Com este script, obtemos o resultado indicado na Figura 2.27.

101

Criando Sites Dinâmicos com ASP 3.0

Figura 2.27: A soma dos cinco primeiros números ímpares.

A Estrutura Do...Loop Esta estrutura pode ser utilizada para repetir um trecho de código, enquanto uma determinada condição for verdadeira, ou até que uma determinada condição torne-se verdadeira. Podemos utilizar dois operadores condicionais diferentes: While ou Until. Os operadores While ou Until, podem ser utilizados de duas maneiras diferentes: no início ou no final do laço. Com isso temos quatro situações distintas; vamos analisar cada uma delas a partir de agora.

A Estrutura Do While Condição...Loop Neste caso, estamos utilizando o operador condicional While, no início do laço. O formato geral, neste caso é o seguinte: Do While condição ‘Comando1 ‘Comando2 ... Comandon Loop

Nesta estrutura, enquanto a condição for verdadeira, o código dentro do laço é executado. Quando a condição tornar-se falsa, o primeiro comando após o final do laço será executado. Neste caso, se a condição for falsa já na primeira vez, o laço não será executado nenhuma vez.

IMPORTANTE O código dentro do laço deve ser capaz de alterar a condição para Falso, quando for necessário, pois caso contrário a condição será sempre verdadeira, e os comandos dentro do laço ficarão em execução infinitamente, ou até o programa travar. A criação de laços infinitos, devido a erros de programação, é uma causa comum de travamentos.

102

Capítulo 2 – Uma Introdução ao VBScript

Considere o exemplo da Listagem 2.25. Listagem 2.25 – Um exemplo simples da estrutura de laço Do While Condição...Loop. 1

<!—

Dim x

x=10

Contador=1

Soma=0

‘ Faz a soma dos dez primeiros números maiores do que zero

Do While Contador <= x

Soma = Soma + Contador

Contador = Contador + 1

Loop

MsgBox “Valor da Soma = ” & Soma

—>

</SCRIPT>

Com esse script, obtemos o resultado indicado na Figura 2.28.

Figura 2.28: A soma dos dez primeiros números inteiros. Observe que dentro do laço, vamos incrementando o valor da variável Contador, uma unidade para cada passagem do laço. Com isso, quando o valor de Contador, atingir 11, o teste do início do laço torna-se falso, e o laço é encerrado.

A Estrutura Do... Loop While Condição Neste caso, deslocamos o teste de condição para o final do laço. Com o teste no final do laço, o código dentro do laço, será executado pelo menos uma vez, pois o teste somente é feito no

103

Criando Sites Dinâmicos com ASP 3.0

final, e continuará sendo executado, enquanto a condição for verdadeira. O formato geral, neste caso é o seguinte: Do ‘Comando1 ‘Comando2 ... Comandon Loop While condição

IMPORTANTE O código dentro do laço deve ser capaz de alterar a condição para Falso, quando for necessário, pois caso contrário a condição será sempre verdadeira, e os comandos dentro do laço ficarão em execução, infinitamente, ou até o programa travar. A criação de laços infinitos, devido a erros de programação, é uma causa comum de travamentos.

Considere o exemplo da Listagem 2.26. Listagem 2.26 – Um exemplo simples da estrutura de laço Do... Loop While Condição. 1

<!—

Dim x

x=10

Contador=1

Soma=0

‘ Faz a soma dos dez primeiros números maiores do que zero

Soma = Soma + Contador

Contador = Contador + 1

Loop While Contador <= x

MsgBox “Valor da Soma = ” & Soma

—>

</SCRIPT>

104

Capítulo 2 – Uma Introdução ao VBScript

Com esse script, obtemos o resultado indicado na Figura 2.29.

Figura 2.29: A soma dos dez primeiros números inteiros. Vamos modificar um pouco o nosso exemplo. Considere o exemplo mostrado na Listagem 2.27. Listagem 2.27 – Outro exemplo simples da estrutura de laço Do... Loop While Condição. 1

<!—

Dim x

x=10

Contador=11

Soma=0

‘ O laço será executado uma única vez, pois a condição

‘ Contador < x é falsa.

Soma = Soma + Contador

Contador = Contador + 1

Loop While Contador <= x

MsgBox “Valor da Soma = ” & Soma

—>

</SCRIPT>

Qual o valor será exibido para a variável Soma? Muito simples. A condição Contador < x é falsa, pois x=10 e Contador=12 (lembre que o Contador foi incrementado de uma unidade na linha 11, antes do teste ser realizado). Neste caso, o laço será executado uma única vez, pois o teste de condição está no final do laço. Quando o laço é executado, a linha 10 atribui o valor 11 para a variável Soma. Com isso, o valor exibido para a variável Soma, será 11, conforme indicado na Figura 2.30.

105

Criando Sites Dinâmicos com ASP 3.0

Figura 2.30: Resultado obtido, com uma única execução do laço.

A Estrutura Do Until Condição...Loop Neste caso, estamos utilizando o operador condicional Until, no início do laço. O formato geral, neste caso é o seguinte: Do Until condição ‘Comando1 ‘Comando2 ... Comandon Loop

Nesta estrutura, enquanto a condição for falsa, o código dentro do laço é executado. Quando a condição tornar-se verdadeira, o primeiro comando após o final do laço será executado. Neste caso, se a condição for verdadeira, já na primeira vez, o laço não será executado nenhuma vez.

IMPORTANTE O código dentro do laço deve ser capaz de tornar a condição Verdadeira, quando for necessário, pois caso contrário a condição será sempre Falsa, e os comandos dentro do laço ficarão em execução, infinitamente, ou até o programa travar. A criação de laços infinitos, devido a erros de programação, é uma causa comum de travamentos.

Considere o exemplo da Listagem 2.27. Listagem 2.28 – Um exemplo simples da estrutura de laço Do Until Condição...Loop. 1

<!—

Dim x

x=10

Contador=1

106

Capítulo 2 – Uma Introdução ao VBScript

Soma=0

‘ Faz a soma dos dez primeiros números maiores do que zero

Do Until Contador > x

Soma = Soma + Contador

Contador = Contador + 1

Loop

MsgBox “Valor da Soma = ” & Soma

—>

</SCRIPT>

Com esse script, obtemos o resultado indicado na Figura 2.31.

Figura 2.31: A soma dos dez primeiros números inteiros. Observe que, dentro do laço, vamos incrementando o valor da variável Contador, uma unidade para cada passagem do laço. Com isso, quando o valor de Contador atingir 11, o teste do início do laço torna-se Verdadeiro, e o laço é encerrado.

A Estrutura Do... Loop Until Condição Neste caso, deslocamos o teste de condição para o final do laço. Com o teste no final do laço, o código dentro do laço, será executado pelo menos uma vez, pois o teste somente é feito no final; e continuará sendo executado, enquanto a condição for Falsa. O formato geral, neste caso, é o seguinte: Do ‘Comando1 ‘Comando2 ... Comandon Loop Until condição

107

Criando Sites Dinâmicos com ASP 3.0

Nesta estrutura, enquanto a condição for Falsa, o código dentro do laço é executado. Quando a condição tornar-se Verdadeira, o primeiro comando após o final do laço será executado. Neste caso, se a condição for Verdadeira, já na primeira vez, o laço será executado uma única vez.

Considere o exemplo da Listagem 2.28. Listagem 2.29 – Um exemplo simples da estrutura de laço Do... Loop Until Condição. 1

<!—

Dim x

x=10

Contador=1

Soma=0

‘ Faz a soma dos dez primeiros números maiores do que zero

Soma = Soma + Contador

Contador = Contador + 1

Loop Until Contador > x

MsgBox “Valor da Soma = ” & Soma

—>

</SCRIPT>

Com esse script, obtemos o resultado indicado na Figura 2.32.

Figura 2.32: A soma dos dez primeiros números inteiros.

108

Capítulo 2 – Uma Introdução ao VBScript

Vamos modificar um pouco o nosso exemplo. Considere o que é mostrado na Listagem 2.30. Listagem 2.30 – Outro exemplo simples da estrutura de laço Do... Loop Until Condição. 1

<!—

Dim x

x=10

Contador=11

Soma=0

‘ O laço será executado uma única vez, pois a condição

‘ Contador >= x é verdadeira.

Soma = Soma + Contador

Contador = Contador + 1

Loop Until Contador >= x

MsgBox “Valor da Soma = ” & Soma

—>

</SCRIPT>

Qual o valor será exibido para a variável Soma? Muito simples. A condição Contador >= x é verdadeira, pois x=10 e Contador=12 (lembre que o Contador foi incrementado de uma unidade, na linha 11, na primeira passagem do laço). Neste caso, o laço será executado uma única vez, pois o teste de condição está ao final. Quando o laço é executado, a linha 10 atribui o valor 11 para a variável Soma. Com isso, o valor exibido para a variável Soma, será 11, indicado na Figura 2.33.

Figura 2.33: Resultado obtido, com uma única execução do laço.

109

Criando Sites Dinâmicos com ASP 3.0

Conclusão Neste capítulo apresentamos diversos conceitos importantes, os quais serão utilizados ao longo de todo livro. Primeiro, definimos o que é VBScript e fizemos uma revisão de HTML, principalmente das tags para a criação de formulários com HTML. Depois, passamos a analisar os aspectos básicos do VBScript. Vimos declaração de variáveis, o comando Option Explicit. Passamos a estudar questões como operadores aritméticos e operadores lógicos de comparação. Também falamos sobre o escopo de variáveis. Depois passamos a tratar de estruturas de controle, onde vimos estruturas como If...Then, If...Then...Else, Select....Case, etc. Diversos exemplos foram apresentados com o objetivo de ilustrar os conceitos, facilitando a compreensão. No próximo capítulo, estaremos analisando alguns aspectos mais avançados do VBScript, tais como a utilização de funções internas do VBScript, além da criação de procedimentos.

110

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

Capítulo 3 Funções, Procedimentos e Eventos com VBScript

111

Criando Sites Dinâmicos com ASP 3.0

Neste capítulo, veremos uma série de aspectos que vão além do básico do VBScript. Iniciaremos falando um pouco mais sobre tipos de dados e funções para conversão de tipos. Este tópico é de grande importância, principalmente quando criamos páginas que efetuam cálculos. Depois passaremos a analisar uma série de funções internas do VBScript. São funções que fazem parte do VBScript, como por exemplo a função Date( ), que retorna a data do sistema. Na seqüência, aprenderemos a criar nossas próprias funções e sub-rotinas. Aprenderemos as diferenças entre uma sub-rotina e uma função, e quando utilizar uma ou outra. Em seguida, trataremos de um assunto muito importante: a utilização de eventos e o modelo de eventos do Internet Explorer. Também falaremos sobre a diferença entre os modelos de eventos dos dois principais navegadores do mercado – o Internet Explorer e o Netscape Navigator. Então, mãos à obra. É hora de aprendermos um pouco mais sobre VBScript, para, a partir do Capítulo 4, começarmos a tratar de ASP 3.0, utilizando os conhecimentos apresentados nestes capítulos iniciais.

NOTA Os exemplos apresentados nas listagens deste capítulo podem ser criados utilizando-se um redator de texto, como o Bloco de notas, e salvando os arquivos com a extensão .htm. Depois é só abrir os mesmos no Internet Explorer e testar. Os números das linhas, que aparecem nas listagens, não devem ser digitados. Os mesmos foram incluídos, apenas para facilitar o acompanhamento das explicações de cada exemplo.

Tipos de Dados e Funções Para Conversão de Tipos Neste item, aprenderemos a determinar qual o tipo de dado que está armazenado em uma variável, bem como a converter valores de um tipo para outro, utilizando as funções para conversão de tipos.

Determinando o Tipo de Dados Contido em uma Variável Existem diversas funções, que permitem que seja determinado o tipo de valor contido em uma variável. Existem diversas aplicações para este tipo de função. Por exemplo, ao digitar dados em um formulário, podemos utilizar uma função para determinar se os valores digitados pelo usuário não apresentam problemas. Por exemplo, o usuário pode ter digitado, por engano, texto em um campo que deve conter valores numéricos.

112

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

A Função IsArray Um Array é um tipo especial de variável, a qual pode armazenar diversos valores em uma única variável. De uma forma simples, um Array é um conjunto. Cada valor armazenado no Array é um elemento do conjunto. Por exemplo, poderíamos criar um Array para armazenar os nomes dos meses do ano. Com isso teríamos um Array de 12 elementos. Cada elemento de um Array é acessado através do nome da variável Array e de um índice. O índice inicia em zero, e não em um. Por isso, se tivermos um Array de dez elementos, teremos o elemento 0, o elemento 1, o elemento 2, e assim por diante, até o elemento 9. O fato do índice começar com 0 influencia na hora de declarar um Array. Para declarar um Array chamado produtos, com 20 elementos, utilizaríamos a seguinte declaração: Dim produtos(19)

O 19 significa que temos 20 elementos (sempre um a mais do que o número que aparece na declaração), isto é, do elemento 0, indicado por produtos(0), até o elemento 20, indicado por produtos(19). Na Listagem 3.1, temos um exemplo simples de utilização de Array. Listagem 3.1 – Utilizando um Array para armazenar os dias da semana. 1

<HTML>

<HEAD>

<TITLE>Utilizando uma variável Array!!</TITLE>

</HEAD>

<BODY>

<P>EXEMPLO DE CRIAÇÃO E UTILIZAÇÃO DE ARRAYS.</P>

<!—

‘Declara um Array de sete posições

‘Como a primeira posição é a posição zero,

‘Indicamos o tamanho como 6, o que significa

‘da posição 0 até a posição 6 = 7 elementos.

Dim Dias(6)

‘Atribuímos valores para os dias da semana

113

Criando Sites Dinâmicos com ASP 3.0

Dias(0)= “Segunda-feira”

Dias(1)= “Terça-feira”

Dias(2)= “Quarta-feira”

Dias(3)= “Quinta-feira”

Dias(4)= “Sexta-feira”

Dias(5)= “Sábado”

Dias(6)= “Domingo”

‘Agora utilizamos um laço For...Next

‘Para criar uma string, com o conteúdo

‘Do Array Dias.

For i=0 to 6

mensagem = mensagem & “Dia: ” & i+1 & “ ” & Dias(i)& Chr(13)

‘Utilizamos uma MsgBox, para exibir a mensagem

‘com o conteúdo do Array Dias.

MsgBox mensagem

—>

</SCRIPT>

</BODY>

</HTML>

Ao carregar este exemplo, no Internet Explorer, será exibida a janela mostrada na Figura 3.1.

Figura 3.1: Um exemplo de utilização de Array.

114

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

Utilizamos a função IsArray, para determinar se uma variável do tipo Variant (lembre que todas as variáveis do VBScript são do tipo Variant) está armazenando um Array. Utilizamos a seguinte sintaxe: IsArray(NomeDaVariável)

A função IsArray retorna verdadeiro se a variável for um Array, e falso em caso contrário. Por exemplo, se adicionássemos, à Listagem 3.1, o comando: MsgBox IsArray(Dias)

o resultado seria o indicado na Figura 3.2.

Figura 3.2: A função IsArray retornando Verdadeiro.

A Função VarType Podemos utilizar a função VarType para determinar o subtipo de uma variável. Como todas as variáveis são do tipo Variant, o subtipo pode ser utilizado para determinar o tipo de dado armazenado na variável. Passamos, para a função, o nome de uma variável ou expressão. A função retorna um número inteiro que indica o subtipo da variável. A sintaxe da função é a seguinte: VarType(NomeDaVariável)

ou VarType(expressão)

Na Tabela 3.1, temos os códigos de retorno da função VarType. Tabela 3.1 Valores de retorno da função VarType. Valor

Descrição

Vazio (não inicializado)

115

Criando Sites Dinâmicos com ASP 3.0

Valor

Descrição

Nulo (dados não válidos)

Inteiro

Inteiro longo

Número de precisão simples

Número de precisão dupla

Monetário

Data

Texto

Objeto de automação

Erro

Boleano

Variant (somente é utilizado com Arrays de variantes)

Objeto para acesso a dados

Byte

8192

Array

Na Listagem 3.2, temos um exemplo de utilização da função VarType. Listagem 3.2 – Utilizando a função VarType. 1

<HTML>

<HEAD>

<TITLE>Exemplo de uso da função VarType!!!</TITLE>

</HEAD>

<BODY>

<P>EXEMPLO DE UTILIZAÇÃO DA FUNÇÃO VarType</P>

<!—

Dim x,y,z

116

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

Dim a, b

Dim c(20)

x=12

y=23.456

y=123456789

a=“Este é um valor de texto!”

‘Utilizamos a função Date( ), para capturar a data do sistema.

b=Date( )

mensagem = “Tipo da variável x: ” & Vartype(x) & Chr(13)

mensagem = mensagem & “Tipo da variável y: ” & Vartype(y) & Chr(13)

mensagem = mensagem & “Tipo da variável z: ” & Vartype(z) & Chr(13)

mensagem = mensagem & “Tipo da variável a: ” & Vartype(a) & Chr(13)

mensagem = mensagem & “Tipo da variável b: ” & Vartype(b) & Chr(13)

mensagem = mensagem & “Tipo da variável c: ” & Vartype(c) & Chr(13)

MsgBox mensagem

—>

</SCRIPT>

</BODY>

</HTML>

Ao carregar este exemplo no Internet Explorer, obteremos o resultado indicado na Figura 3.3.

Figura 3.3: Utilizando a função VarType.

117

Criando Sites Dinâmicos com ASP 3.0

Observe, principalmente, no tipo da variável z, o qual retornou 0. Isto significa que a variável z está vazia, ou seja, não foi inicializada. Este resultado está coerente com a Tabela 3.1. Também podemos salientar o retorno para a variável b, o qual retornou 7, indicando que o valor armazenado nesta variável é do tipo Data. Portanto, também está coerente com a Tabela 3.1, uma vez que usamos a função Date( ), para armazenar a data do sistema, na variável b. Finalmente observe o valor de retorno para a variável c, o qual retornou 8192, indicando que a variável c é um Array. Este resultado está coerente com a Tabela 3.1, e com a declaração da linha 11 – Dim c(20), a qual declarou a variável c como sendo um Array. Muitas são as aplicações práticas para a função VarType, dentre as quais podemos destacar a validação dos dados digitados em um formulário.

A Função IsDate A função IsDate recebe uma variável ou expressão como argumento, e determina se a variável ou expressão é uma data válida, ou pode ser convertida para uma data válida. Caso o argumento passado seja uma data válida, a função retorna Verdadeiro, caso contrário, retorna Falso. Podemos utilizar esta função, por exemplo, para verificar se o usuário digitou uma data válida, em um campo de um formulário. A sintaxe da função IsDate é a seguinte: IsDate(NomeDaVariável)

ou IsDate(expressão)

Na Listagem 3.3, temos um exemplo de utilização da função IsDate. Listagem 3.3 – Utilizando a função IsDate. 1

<HTML>

<HEAD>

<TITLE>Utilizando a função IsDate!!</TITLE>

<!—

Sub verifica_onclick

If IsDate(Window.dataen.value) Then

8 9 10 11

MsgBox “Você digitou uma data válida!” Else MsgBox “Data inválida, digite novamente!” window.dataen.value=“”

118

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

window.dataen.focus

End If

End Sub

—>

</SCRIPT>

</HEAD>

<BODY>

<P>Exemplo de uso da função IsDate</P>

<P>Digite a data de encerramento:

<INPUT id=“dataen” maxLength=10 name=“dataen” > (dd/mm/aaaa)

</P>

<P>Clique no botão para verificar se a data é válida:

</BODY>

</HTML>

A seguir alguns comentários sobre este exemplo. No código HTML do documento – linha 17 à 25 –, colocamos dois elementos de formulário: um campo de texto, que chamamos de dataen; e um botão de comando, do tipo Button, que chamamos de verifica. A Figura 3.4 mostra este documento aberto no Internet Explorer, onde o usuário digitou uma data inválida, no nosso exemplo, o usuário digitou 30/02/2000.

Figura 3.4: O usuário digitou uma data inválida.

119

Criando Sites Dinâmicos com ASP 3.0

Após digitar a data, o usuário clica no botão “Verificar data”, para testar se a data é válida. Esta ação do usuário, gera o evento onclik deste botão. Observe que das linhas 6 a 13, definimos um procedimento que responde ao evento onclick do botão verifica. O que define que este procedimento atua em resposta ao evento onclick, do botão verifica, é o nome do procedimento: Sub verifica_onclick

Esta definição faz parte do modelo de objetos e eventos do Internet Explorer, a qual analisaremos em maiores detalhes mais adiante, ainda neste capítulo. Dentro do procedimento verifica_onclick, utilizamos a função IsDate, para verificar se a data digitada pelo usuário é valida. Se a data for válida, simplesmente exibimos uma mensagem, notificando que a data digitada é válida, conforme indicado na Figura 3.5.

Figura 3.5: A data digitada pelo usuário é válida. Caso a data não seja válida, emitimos uma mensagem avisando – linha 10. Na linha 11, voltamos a utilizar o modelo de objetos do Internet Explorer. A expressão window.dataen.value significa: o valor do campo dataen, da janela atual do navegador. Com este comando, estamos “apagando” a data digitada pelo usuário. Na linha 12, utilizamos o método focus, para posicionar o cursor de volta no campo dataen. Com isso, quando o usuário clicar em OK, na janela da mensagem de data inválida, o campo dataen será apagado (linha 11) e o cursor posicionado no campo (linha 12), para que o usuário possa digitar uma nova data, conforme indicado na Figura 3.6.

Figura 3.6: Cursor posicionado no campo dataen.

120

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

A Função IsEmpty A função IsEmpty recebe uma variável ou expressão como argumento, e determina se, em algum momento, foi atribuído algum valor para a variável ou expressão. Caso tenha sido atribuído algum valor, a função retorna Verdadeiro, caso contrário, retorna Falso. Podemos utilizar esta função, por exemplo, para verificar se um campo de digitação obrigatória, como por exemplo o nome, não foi deixado em branco. A sintaxe da função IsEmpty é a seguinte: IsEmpty(NomeDaVariável)

ou IsEmpty(expressão)

Na Listagem 3.4, temos um exemplo de utilização da função IsEmpty. Listagem 3.4 – Utilizando a função IsEmpty. 1

<HTML>

<HEAD>

<TITLE>Utilizando a função IsEmpty!!</TITLE>

<!—

‘ Vamos declarar uma variável x que nunca

‘ será utilizada no nosso script

Dim a, b, c

Dim x

a=10

b=23

c=a+b

If IsEmpty(x) Then

14 15

MsgBox “A variável x não foi utilizada!” End If

—>

</SCRIPT>

</HEAD>

121

Criando Sites Dinâmicos com ASP 3.0

<BODY>

<P>Exemplo de uso da função IsEmpty</P>

<P>

</P>

</BODY>

</HTML>

Clique no botão para verificar o nome digitado:

Ao abrir este documento, no Internet Explorer, você recebe a mensagem indicada na Figura 3.7.

Figura 3.7: A variável x está vazia.

A Função IsNull A função IsNull recebe uma variável ou expressão como argumento, e determina se, em algum momento, foi atribuído o valor Null para a variável ou expressão. Se tiver sido atribuído o valor Null, a função retorna Verdadeiro, caso contrário, retorna Falso. Para atribuirmos Null para uma variável, utilizamos a seguinte sintaxe: NomeDaVariável = Null

IMPORTANTE Uma variável com valor Null, não é a mesma coisa que uma variável com valor zero, ou uma variável de texto com tamanho zero. Quando é atribuído o valor Null para a variável, a mesma continua existindo na memória, porém sem nenhum valor definido.

A sintaxe da função IsNull é a seguinte: IsNull(NomeDaVariável)

ou IsNull(expressão)

122

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

Na Listagem 3.5, temos um exemplo de utilização da função IsNull. Listagem 3.5 – Utilizando a função IsNull. 1

<HTML>

<HEAD>

<TITLE>Utilizando a função IsNull!!</TITLE>

<!—

‘ Vamos declarar uma variável x, e atribuir

‘ Null para a mesma.

Dim x

x = Null

If IsNull(x) Then

11 12

MsgBox “A variável x é Nula!” End If

—>

</SCRIPT>

</HEAD>

<BODY>

<P>Exemplo de uso da função IsNull.</P>

</BODY>

</HTML>

Ao abrir este documento, no Internet Explorer, você recebe a mensagem indicada na Figura 3.8.

123

Criando Sites Dinâmicos com ASP 3.0

Figura 3.8: A variável x possui o valor Null.

A Função IsNumeric A função IsNumeric recebe uma variável ou expressão como argumento, e determina se o valor atribuído à variável ou expressão é numérico, ou pode ser convertido para numérico. Se o valor for numérico, ou puder ser convertido, a função retorna Verdadeiro, caso contrário, retorna Falso. A sintaxe da função IsNumeric é a seguinte: IsNumeric(NomeDaVariável)

ou IsNumeric(expressão)

Na Listagem 3.6 temos um exemplo de utilização da função IsNumeric. Listagem 3.6 – Utilizando a função IsNumeric. 1

<HTML>

<HEAD>

<TITLE>Utilizando a função IsNumeric!!</TITLE>

<!—

Dim x,y,z

x=123

‘Atribuo um valor que não pode ser convertido

‘para numérico

y= “Riachuelo - 80”

124

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

z = Date()

mensagem = “Valor de x: ” & x &“ É numérico? ” & IsNumeric(x)& Chr(13)

mensagem = mensagem & “Valor de y: ” & y &“ É numérico? ” & IsNumeric(y)& Chr(13)

mensagem = mensagem & “Valor de z: ” & z &“ É numérico? ” & IsNumeric(z)

MsgBox mensagem

—>

</SCRIPT>

</HEAD>

<BODY>

<P>Exemplo de uso da função IsNumeric.</P>

</BODY>

</HTML>

Ao abrir este documento, no Internet Explorer, você recebe a mensagem indicada na Figura 3.9.

Figura 3.9: Utilizando a função IsNumeric. Cabe salientar a utilização da função Date( ), para capturar a data do sistema, e atribuir esta data à variável z. Observe que esta data não foi considerada um valor numérico para a função IsNumeric.

A Função IsObject A função IsObject recebe uma variável como argumento, e determina se o valor atribuído à variável é um objeto ActiveX. Se for, a função retorna Verdadeiro, caso contrário, retorna Falso. Para exemplificarmos esta função, faremos uso de uma página ASP, e iremos utilizar um dos objetos do ASP. Falaremos mais sobre os objetos do ASP no Capítulo 4.

125

Criando Sites Dinâmicos com ASP 3.0

A sintaxe da função IsObject é a seguinte: IsObject(NomeDaVariável)

ou IsObject(expressão)

Na Listagem 3.7 temos um exemplo de utilização da função IsObject. Listagem 3.7 – Utilizando a função IsObject. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<BODY>

<P>Exemplo de utilização da função IsObject!</P>

Set tiponav= Server.CreateObject(“MSWC.BrowserType”)

If IsObject(tiponav) Then

10 11

Response.Write “A variável tiponav é um objeto” Else

Response.Write “A variável tiponav não é um objeto.”

End If

</BODY>

</HTML>

IMPORTANTE Como este é um arquivo .asp, o mesmo não pode ser aberto localmente no Internet Explorer. Toda página .asp é interpretada no servidor, e o resultado do processamento, na forma de HTML puro, é devolvido para o navegador. Para testar um arquivo .asp, o mesmo precisa ser salvo no servidor IIS e acessado utilizando-se o endereço para a página .asp.

Ao abrir este documento, no Internet Explorer, obtemos o resultado indicado na Figura 3.10.

126

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

Figura 3.10: Utilizando a função IsObject. Observe no campo endereço, que estamos acessando a página .asp, em um servidor, e não localmente, conforme indicado pelo endereço: http://servidor/Chap3/IsObject.asp.

Funções Para Conversão de Tipos Neste item aprenderemos a utilizar as principais funções para conversão de tipos. Existem situações em que um determinado tipo de dado deve ser convertido para outro. Por exemplo, se tivermos um número, armazenado na forma de texto, precisamos convertê-lo para inteiro ou double, para que possamos realizar cálculos com o mesmo. Na seqüência, apresento as principais funções de conversão, bem como um pequeno fragmento de código, exemplificando a utilização de cada uma delas.

Função Cbool A função Cbool converte uma variável ou resultado de uma expressão para o subtipo Boolean. Qualquer número, com exceção do zero, é automaticamente convertido para Verdadeira. O valor zero é sempre convertido para Falso. O argumento desta função não pode ser texto, caso contrário será gerado um erro em tempo de execução. Observe esta linha de código: MsgBox Cbool(10>25) & Chr(13) & Cbool(3)

127

Criando Sites Dinâmicos com ASP 3.0

Esta linha gera a mensagem indicada na Figura 3.11.

Figura 3.11: A função Cbool retorna Verdadeiro ou Falso. A expressão 10>25 é avaliada, como a expressão é falsa, a função Cbool retorna Falso. Já no segundo uso da função Cbool, foi passado o parâmetro 3 para a função. Qualquer valor diferente de zero (com exceção de texto) a função interpreta como Verdadeiro, o que é comprovado pela Figura 3.11.

Função CByte A função CByte converte uma variável ou resultado de um expressão para o subtipo Byte. O valor a ser convertido, deve estar na faixa aceitável para o tipo byte, que vai de 0 a 255. Caso o número esteja fora desta faixa, será gerada uma mensagem de erro; e, se o argumento desta função for texto também será gerada uma mensagem de erro, em tempo de execução. Observe esta linha de código: MsgBox CByte(10+34) & Chr(13) & CByte(35)

Esta linha gera a mensagem indicada na Figura 3.12.

Figura 3.12: A função CByte converte os valores para o subtipo Byte. A expressão 10+34 é calculada, e o resultado (44), é convertido para o tipo Byte. A linha de código abaixo, irá gerar uma mensagem de erro, em tempo de execução, pois o valor a ser convertido para byte, está fora da faixa de 0 a 255. MsgBox CByte(100+200)

128

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

Função CCur A função CCur converte uma variável, ou resultado de um expressão, para o subtipo Currency. O argumento desta função não pode ser Texto, caso contrário será gerado um erro. Observe esta linha de código: MsgBox CCur(250.335677+324.3333) & Chr(13) & CCur(1250.326582)

Esta linha gera a mensagem indicada na Figura 3.13.

Figura 3.13: A função CCur converte os valores para o subtipo Currency. A expressão 250.335677+324.3333 é calculada, e o resultado é convertido para o tipo Currency. Se passarmos um argumento de texto para a função CCur será gerado um erro de execução, conforme indicado na Figura 3.14.

Figura 3.14: Erro gerado ao passar um texto como argumento para CCur.

129

Criando Sites Dinâmicos com ASP 3.0

Função CDate A função CDate converte uma variável ou resultado de um expressão para o subtipo Date. O argumento desta função deve estar em um formato que seja aceitável para datas, caso contrário será gerada uma mensagem de erro, em tempo de execução. Observe esta linha de código: MsgBox CDate(“31/10/1980”) & Chr(13) & CDate(“23-01-2007”)

Esta linha gera a mensagem indicada na Figura 3.15.

Figura 3.15: A função CDate converte os valores para o subtipo Date. A linha de código abaixo irá gerar uma mensagem de erro, em tempo de execução, conforme indicado na Figura 3.16. MsgBox CDate(“31/02/1980”)

Figura 3.16: Erro gerado ao passar um argumento com uma data inválida.

130

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

Função CDbl A função CDbl converte uma variável ou resultado de um expressão para o subtipo Double. O argumento desta função não pode ser do tipo texto, caso contrário será gerada uma mensagem de erro, em tempo de execução. Observe esta linha de código: MsgBox CDbl(“4.940651247E-17”)

Esta linha gera a mensagem indicada na Figura 3.17.

Figura 3.17: A função CDouble converte os valores para o subtipo Double. A linha de código abaixo irá gerar uma mensagem de erro, em tempo de execução, conforme indicado na Figura 3.18. MsgBox CDbl(“Teste”)

Figura 3.18: Erro gerado ao passar um argumento de tipo inválido para a função Cdbl.

131

Criando Sites Dinâmicos com ASP 3.0

Função CInt A função CInt converte uma variável ou resultado de um expressão para o subtipo Integer. O argumento desta função não pode ser do tipo texto, caso contrário será gerada uma mensagem de erro, em tempo de execução. Observe esta linha de código: MsgBox CInt(32.36) & Chr(13) & CInt(20.35+40.45)

Esta linha gera a mensagem indicada na Figura 3.19.

Figura 3.19: A função CInt converte os valores para o subtipo Integer. A linha de código abaixo irá gerar uma mensagem de erro, em tempo de execução, conforme indicado na Figura 3.20. MsgBox CInt(“Teste”)

Figura 3.20: Erro gerado ao passar um argumento de tipo inválido para a função CInt.

132

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

Função CLng A função CLng converte uma variável ou resultado de um expressão para o subtipo Long. O argumento desta função não pode ser do tipo texto, caso contrário será gerada uma mensagem de erro, em tempo de execução. O argumento também não pode estar fora da faixa admitida pelo subtipo Long, caso contrário será gerada uma mensagem de erro, em tempo de execução. Observe esta linha de código: MsgBox CLng(“3462315”)

Esta linha gera a mensagem indicada na Figura 3.21.

Figura 3.21: A função CLng converte os valores para o subtipo Long. A linha de código abaixo irá gerar uma mensagem de erro, em tempo de execução, conforme indicado na Figura 3.22. MsgBox CLng(“Teste”)

Figura 3.22: Erro gerado ao passar um argumento de tipo inválido para a função CLng.

133

Criando Sites Dinâmicos com ASP 3.0

Função CSng A função CSng converte uma variável ou resultado de um expressão para o subtipo Single. O argumento desta função não pode ser do tipo texto, caso contrário será gerada uma mensagem de erro, em tempo de execução. O argumento também não pode estar fora da faixa admitida pelo subtipo Single, caso contrário será gerada uma mensagem de erro, em tempo de execução. Observe esta linha de código: MsgBox CSng(“3.1418256927”)

Esta linha gera a mensagem indicada na Figura 3.23.

Figura 3.23: A função CSng converte os valores para o subtipo Single. A linha de código abaixo, irá gerar uma mensagem de erro, em tempo de execução, conforme indicado na Figura 3.24. MsgBox CSng(“Teste”)

Figura 3.24: Erro gerado ao passar um argumento de tipo inválido para a função CSng.

134

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

Função CStr A função CStr converte uma variável ou resultado de um expressão para o subtipo String. Observe esta linha de código: MsgBox CStr(“12345” & “hectares de terra”)

Esta linha gera a mensagem indicada na Figura 3.25.

Figura 3.25: A função CStr converte os valores para o subtipo String.

Funções Int e Fix As funções Int e Fix retornam somente a parte inteira de um determinado número. A diferença, entre as duas funções, é quando o número for negativo. Observe os exemplos abaixo: ➥ Fix(-10.2) – Retorna –10 ➥ Int(-10.2) – Retorna –11 A função Int, retorna, no caso de números negativos, o primeiro número inteiro, menor ou igual ao parâmetro passado. No caso de –10.2, retornou –11. Já Fix, retorna, no caso de números negativos, o primeiro inteiro, maior ou igual ao parâmetro passado. No caso de –10.2, retornou –10. Observe esta linha de código: MsgBox Fix (-7.35) & Chr(13) & MsgBox Int(-7.35)

Esta linha gera a mensagem indicada na Figura 3.26.

Figura 3.26: A diferença entre Int e Fix, para números negativos.

135

Criando Sites Dinâmicos com ASP 3.0

Com isso, terminamos a nossa apresentação sobre as principais funções para a conversão de tipos de dados. No próximo item, estaremos analisando mais algumas funções do VBScript, para operações com dados do tipo String e do tipo Data/Hora.

Outras Funções do VBScript – Tratamento de String, Datas e Funções Matemáticas Neste item, aprenderemos a utilizar as principais funções do VBScript. Apresentaremos as funções divididas em categorias, conforme a funcionalidade das mesmas. Estaremos tratando das seguintes categorias: ➥ Funções para manipulação de String. ➥ Funções para manipulação de Data/Hora. ➥ Funções matemáticas. Para uma referência completa sobre todas as funções do VBScript, você pode consultar o seguinte endereço: http://msdn.microsoft.com/scripting.

Funções Para Tratamento de String Veremos as principais funções para tratamento de String. Nos exemplos práticos, no final do capítulo, estaremos utilizando algumas destas funções.

Função Asc A função Asc retorna o valor numérico do código ASCII, para a primeira letra de uma String. Considere o exemplo: Asc(“Ainda chovia”)

Este exemplo de uso da função retorna o valor 65, o qual é o código ASCII para a letra A maiúscula. Caso fosse a letra a minúscula, o código retornado seria 97.

Função Chr A função Chr(número), recebe um número como parâmetro, e retorna o caractere ASCII, correspondente. Considere o exemplo: Chr(65)

Este exemplo de uso da função retorna o caractere A maiúsculo.

136

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

NOTA Até agora, utilizamos a função Chr em alguns exemplos. Utilizamos o Chr(13) para simular um ENTER, o que faz uma quebra de linha, nas mensagens montadas com o MsgBox.

Função Len Esta função determina o tamanho da String que foi passada como parâmetro para a função. Considere o exemplo: MsgBox Len(“Este é um exemplo de uso da função Len!!”)

Este exemplo de uso da função, retorna 41, conforme indicado na Figura 3.27.

Figura 3.27: Exemplo de uso da função Len.

Função LCase Esta função converte para minúsculas a String que foi passada como parâmetro para a função. Considere o exemplo: MsgBox Lcase(“ESTE É UM EXEMPLO DE USO DA FUNÇÃO LCASE”)

Este exemplo de uso da função converte, o parâmetro passado, para letras minúsculas, conforme indicado na Figura 3.28.

Figura 3.28: Exemplo de uso da função LCase.

137

Criando Sites Dinâmicos com ASP 3.0

Função UCase Esta função converte para maiúsculas a String que foi passada como parâmetro para a função. Considere o exemplo: MsgBox Ucase(“este é um exemplo do uso da função ucase!!”)

Este exemplo de uso da função converte, o parâmetro passado, para letras maiúsculas, conforme indicado na Figura 3.29.

Figura 3.29: Exemplo de uso da função UCase.

Função Left Esta função retorna um número especificado de caracteres, a partir do início (Left – Esquerda) de uma String. É importante salientar que espaços em branco também devem ser considerados. O formato geral da função é o seguinte: Left(String, n)

onde n é o número de caracteres a retornar. Considere o exemplo: MsgBox Left(“Júlio Cesar Fabris Battisti”,5)

Este exemplo de uso da função, retorna as cinco primeiras letras da String passada, neste caso, retornará Júlio. Vamos alterar um pouco o nosso exemplo: MsgBox Left(“Júlio Cesar Fabris Battisti”,7)

Irá retornar: Júlio C. Observe que o espaço em branco também é considerado.

Função Right Esta função retorna um número especificado de caracteres, a partir do final (Right – Direita) de uma String. É importante salientar que espaços em branco também devem ser considerados.

138

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

O formato geral da função é o seguinte: Right(String, n)

onde n é o número de caracteres a retornar. Considere o exemplo: MsgBox Right(“Júlio Cesar Fabris Battisti”,6)

Este exemplo de uso da função, retorna as seis últimas letras da String passada, neste caso, retornará ttisti. Vamos alterar um pouco o nosso exemplo: MsgBox Right(“Júlio Cesar Fabris Battisti”,10)

Irá retornar: s Battisti. Observe que o espaço em branco também é considerado.

Função Mid Esta função retorna um número especificado de caracteres, a partir de uma posição especificada dentro da String. É importante salientar que espaços em branco também devem ser considerados. O formato geral da função é o seguinte: Mid(String, posicao_inicio, n)

onde posicao_inicio é a posição a partir da qual devem ser retornados caracteres, e n é o número de caracteres a retornar. Considere alguns exemplos: Mid(“Júlio Cesar Fabris Battisti”,7,5)

Este exemplo de uso da função, retorna, a partir da posição 7, cinco caracteres, neste caso, retornará Cesar. Mid(“SANTA MARIA”,3,7)

irá retornar NTA MAR. Observe que o espaço em branco também é considerado. Um detalhe interessante, é que podemos utilizar o retorno de uma função, como parâmetro para outra função. Considere o seguinte exemplo: LCase(Mid(“SANTA MARIA”,3,7))

139

Criando Sites Dinâmicos com ASP 3.0

Este exemplo retorna nta mar. A função Mid retira os caracteres NTA MAR, os quais são passados como parâmetros para a função LCase, a qual converte os caracteres para minúsculos.

Função String Esta função retorna um determinado caractere, um número especificado de vezes. O formato geral da função é o seguinte: String(n, Caracter)

onde n é o número de vezes que o caractere deve ser repetido. Considere o exemplo: MsgBox String(35,“*”)

A Figura 3.30 mostra o resultado deste comando.

Figura 3.30: Exemplo de uso da função String.

Funções Para Tratamento de Data e Hora Veremos as principais funções para tratamento de Data e Hora. Nos exemplos práticos, no final do capítulo, estaremos utilizando algumas destas funções.

Função Date Retorna a data corrente do sistema. Não precisamos passar parâmetros para esta função. Considere o exemplo abaixo: MsgBox “Data do Sistema: ” & Date( )

O resultado deste comando está indicado na Figura 3.31.

140

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

Figura 3.32: Exemplo de uso da função Date.

Função Time Retorna a hora corrente do sistema. Não precisamos passar parâmetros para esta função. Considere o exemplo abaixo: MsgBox “Hora do Sistema: ” & Time( )

O resultado deste comando está indicado na Figura 3.32.

Figura 3.32: Exemplo de uso da função Time.

Função Day Recebe como parâmetro uma data, e retorna um número entre 1 e 31, indicando o dia do mês. O formato geral é o seguinte: Day(data)

Considere o exemplo abaixo: MsgBox “Dia do mês: ” & Day(Date( ))

O resultado deste comando está indicado na Figura 3.33. A função Date( ) captura a data do sistema e passa como parâmetro para a função Day, que, por sua vez, retorna apenas o dia do mês.

141

Criando Sites Dinâmicos com ASP 3.0

Figura 3.33: Exemplo de uso da função Day.

Função Month Recebe como parâmetro uma data, e retorna um número entre 1 e 12, indicando o mês do ano. O formato geral é o seguinte: Month(data)

Considere o exemplo abaixo: MsgBox “Mês do ano: ” & Month(Date( ))

O resultado deste comando está indicado na Figura 3.34.

Figura 3.34: Exemplo de uso da função Month. A função Date( ) captura a data do sistema e passa como parâmetro para a função Month, que, por sua vez, retorna apenas o mês do ano.

Função Now Retorna a hora e a data corrente do sistema. Não precisamos passar parâmetros para esta função. Considere o exemplo abaixo: MsgBox “Data e Hora do Sistema: ” & Now( )

O resultado deste comando está indicado na Figura 3.35.

142

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

Figura 3.35: Exemplo de uso da função Now.

Função MonthName Recebe como parâmetro um número, indicativo do mês do ano (1 – Janeiro, 2 – Fevereiro, e assim por diante), e um segundo parâmetro que pode ser Verdadeiro ou Falso. Se o segundo parâmetro for Verdadeiro, o nome do mês será exibido abreviadamente. O formato geral é o seguinte: MonthName(número_do_mês, abreviar)

Considere o exemplo abaixo: MsgBox “Mês do ano: ” & MonthName(Month(Date(),False)

O resultado deste comando está indicado na Figura 3.36.

Figura 3.36: Exemplo de uso da função MonthName. A função Date( ) captura a data do sistema e passa como parâmetro para a função Month. A função Month retorna o número do mês retornado pela data. Este número é passado como primeiro parâmetro para a função MonthName. O segundo parâmetro é definido em Falso, o que significa que é para exibir o nome do mês por extenso, isto é, não abreviado.

Função Hour Recebe como parâmetro uma hora, e retorna um número entre 0 e 23, indicando o hora do dia. O formato geral é o seguinte: Hour(horário)

143

Criando Sites Dinâmicos com ASP 3.0

Considere o exemplo abaixo: MsgBox “Hora do sistema: ” & Hour(Time( ))

O resultado deste comando está indicado na Figura 3.37.

Figura 3.37: Exemplo de uso da função Hour. A função Time( ) captura a hora do sistema e passa como parâmetro para a função Hour, que, por sua vez, retorna apenas a hora do dia.

A função DateDiff Esta função pode ser utilizada para determinar o número de intervalos (em dias, trimestres, semestres, anos, etc.), entre duas datas. A sintaxe desta função é o seguinte: DateDiff(intervalo, data1, data2)

O parâmetro intervalo é uma String que diz que tipo de intervalo vamos calcular. Por exemplo, é este parâmetro que define se queremos calcular o número de dias, ou o número de meses entre duas datas. Na Tabela 3.2, temos os valores possíveis para o parâmetro intervalo. Tabela 3.2 Valores para o parâmetro intervalo. Valor

Descrição

yyyy

Anos

Trimestres

Meses

Dias do ano (o mesmo que dias)

Dias

Semanas

Semanas do ano (o mesmo que semanas)

144

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

Valor

Descrição

Horas

Minutos

Segundos

A título de exemplo, vamos calcular o número de meses, desde o descobrimento do Brasil, até 31 de Dezembro de 1999. Para isso, utilizaríamos o seguinte comando: MsgBox “Meses desde o descobrimento: ” & DateDiff(“m”,“22/04/1500”,“31/12/1999”)

O resultado deste comando pode ser conferido na Figura 3.38.

Figura 3.38: Exemplo de uso da função DateDiff. Vamos modificar um pouco o nosso exemplo, e calcular o número de horas desde o descobrimento. Para isto, podemos utilizar o seguinte comando: MsgBox “Número aproximado de horas, desde o descobrimento: ” & DateDiff(“h”,“22/04/ 1500”,“31/12/1999”)

O resultado deste comando pode ser conferido na Figura 3.39.

Figura 3.39: O número aproximado de horas, desde o descobrimento do Brasil.

A Função DateAdd Esta função pode ser utilizada para determinar uma data futura, com base em uma data fornecida, o tipo de período a ser acrescentado (dias, meses, anos, etc.), e o número de períodos a serem acrescentados. A sintaxe desta função é a seguinte:

145

Criando Sites Dinâmicos com ASP 3.0

DateAdd(intervalo, número_de_intervalos, data)

O parâmetro intervalo é uma String que diz que tipo de intervalo vamos acrescentar. Por exemplo, é este parâmetro que define se queremos acrescentar um número especificado de dias, meses, anos, etc. Na Tabela 3.3, temos os valores possíveis para o parâmetro intervalo. Tabela 3.3 Valores para o parâmetro intervalo. Valor

Descrição

yyyy

Anos

Trimestres

Meses

Dias do ano (o mesmo que dias)

Dias

Semanas

Semanas do ano (o mesmo que semanas)

Horas

Minutos

Segundos

A título de exemplo, vamos calcular a data em que tivemos um período de 1.000 meses, após o descobrimento do Brasil. Para isso, utilizaríamos o seguinte comando: MsgBox “Mil meses após o descobrimento foi em: ” & DateAdd(“m”,1000,“22/04/1500”)

O resultado deste comando pode ser conferido na Figura 3.40.

Figura 3.40: Exemplo de uso da função DateAdd. Vamos modificar um pouco o nosso exemplo, e calcular em que data teremos passado um milhão de dias após o descobrimento.

146

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

MsgBox “Um milhão de dias após o descobrimento em : ” & DateAdd(“d”,1000000,“22/04/1500”)

O resultado deste comando pode ser conferido na Figura 3.41.

Figura 3.41: Em 19/03/4238, o Brasil completará um milhão de dias.

Função Year Recebe como parâmetro uma data, e retorna um número indicativo do ano. O formato geral é o seguinte: Year(data)

Considere o exemplo abaixo: MsgBox “Ano atual: ” & Year(Date( ))

O resultado deste comando está indicado na Figura 3.42.

Figura 3.42: Exemplo de uso da função Year. A função Date( ) captura a data do sistema e passa como parâmetro para a função Year, a qual por sua vez, retorna apenas o ano.

Função WeekDay Recebe como parâmetros uma data, e um parâmetro opcional, que indica qual o primeiro dia da semana. Se este parâmetro for omitido, o primeiro dia da semana será considerado domingo. O valor para o primeiro dia da semana é numérico: 1 – domingo, 2 – segunda-feira, e assim por diante. WeekDay(data, prim_dia_semana.)

147

Criando Sites Dinâmicos com ASP 3.0

Considere o exemplo abaixo: MsgBox “Dia da semana: ” & WeekDay(“31/12/1999”)

O resultado deste comando está indicado na Figura 3.43.

Figura 3.43: Exemplo de uso da função WeekDay. O valor 6 indica que foi uma sexta-feira, o que confere com o calendário. Poderíamos determinar que o primeiro dia da semana é a segunda-feira (2). Com isso o nosso exemplo, ficaria assim: MsgBox “Dia da semana: ” & WeekDay(“31/12/1999”,2)

O resultado deste comando está indicado na Figura 3.44.

Figura 3.44: Definindo a segunda-feira como o primeiro dia da semana. O valor 5 indica que foi uma sexta-feira, pois agora a segunda-feira passou a ser o dia 1, a terça-feira o dia 2, e assim por diante. Novamente confere com o calendário.

Função WeekDayName Recebe como parâmetro um número, indicativo do dia da semana, e um segundo parâmetro que pode ser Verdadeiro ou Falso. Se o segundo parâmetro for Verdadeiro, o nome do dia da semana será exibido abreviadamente. O formato geral é o seguinte: WeekDayName(número_do_dia, abreviar)

148

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

Considere o exemplo abaixo: MsgBox “Dia da semana: ” & WeekDayName(6,False)

O resultado deste comando está indicado na Figura 3.45.

Figura 3.45: Exemplo de uso da função WeekDayName.

Funções Para Cálculos Matemáticos Veremos as principais funções para efetuar cálculos matemáticos. Nos exemplos práticos, no final do capítulo, estaremos utilizando algumas destas funções. Na Tabela 3.4, temos a descrição das principais funções matemáticas, disponíveis no VBScript. Tabela 3.4 Funções para cálculos matemáticos. Função

Descrição

Abs(n)

Retorna o valor absoluto (sem sinal) do número n.

Atn(n)

Retorna o valor do arco, cuja tangente é o número n. O número n deve ser fornecido em radianos.

Cos(n)

Retorna o coseno do número n. O número n deve ser fornecido em radianos.

Exp(n)

Retorna o número e (logaritmo neperiano e=2,7183), elevado no número n.

Log(n)

Retorna o logaritmo natural de um número n.

Rnd(n)

Retorna um número aleatório entre 0 e 1.

Sgn(n)

Retorna um número inteiro, indicando o sinal do número n. Retorna –1 para números negativos e 1 para números positivos.

149

Criando Sites Dinâmicos com ASP 3.0

Função

Descrição

Sin(n)

Retorna o seno do número n. O número n deve ser fornecido em radianos.

Sqr(n)

Retorna a raiz quadrada do número n.

Tan(n)

Retorna a tangente do número n. O número n deve ser fornecido em radianos.

NOTA Para converter graus para radianos, multiplique o valor em graus por π (3.14), e divida o resultado por 180.

Na Tabela 3.5, temos alguns exemplos de utilização das funções matemáticas do VBScript. Tabela 3.5 Alguns exemplos de utilização das funções matemáticas. Exemplo

Valor de retorno

Abs(-2350)

2350

Atn(2)

1,1071487177

Cos(0)

Exp(1)

2,71828182845905

Log(1000)

6,90775527898214

Rnd*10

Gera um número aleatório entre 0 e 10.

Sgn(-235)

Retorna –1, pois o número é negativo.

Sin(0)

Retorna 0

Sqr(400)

Retorna 20

Tan(0)

Retorna 0

Com isso, encerramos a apresentação das principais funções do VBScript. Para uma referência completa, você pode consultar o site http://msdn.microsoft.com/scripting, ou os CD’s da assinatura do MSDN (Microsoft Developer Network). Junto com o Visual Studio 6.0 é fornecida uma cópia do MSDN.

150

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

Criando Suas Próprias Funções e Procedimentos Neste item, aprenderemos a criar nossas próprias funções e sub-rotinas. O princípio, por trás da criação de funções e sub-rotinas, é o de reaproveitamento de código e facilidade de manutenção do programa. Imagine que estejamos criando uma página para cálculos financeiros, por exemplo, depreciação contábil. Vamos supor que, em diversos pontos do nosso script, seja necessária a realização do cálculo de depreciação. Poderíamos colocar o código que faz o cálculo, em cada um dos pontos, onde o mesmo seja necessário. Porém esta não é a melhor maneira de criarmos nosso script. Imagine, por exemplo, quando fosse necessário alterar a maneira de realizar os cálculos. Teríamos que repassar todo o script, procurando os pontos onde o código está, e fazer as alterações. Sem contar que estaríamos criando um script bastante longo, dependendo do número de cálculos necessários. Para resolver estes problemas, poderíamos criar uma função ou sub-rotina que faz os cálculos de depreciação. Depois, em cada local onde precisamos fazer os cálculos, é só chamar a função (ou sub-rotina), para fazer os cálculos. Quando fosse necessária a alteração da metodologia de cálculo, era só alterar a função (ou sub-rotina) e pronto! Os novos cálculos passarão a ser feitos com base na nova metodologia. Isto poupa esforço, reduz o número de linhas do script, facilita a manutenção do mesmo, além de reduzir a possibilidade de erros. Agora é chegada a hora de aprendermos a criar funções e sub-rotinas.

NOTA Um termo que pode aparecer é “procedimento”. Um procedimento é um grupo de instruções que pode ser chamado pelo nome atribuído a ele. Neste contexto, funções e sub-rotinas são tipos de procedimentos.

Criando e Utilizando Sub-rotinas Uma sub-rotina é um grupo de comandos que podem ser executados, simplesmente através da chamada do nome da Sub-rotina. Podemos passar um ou mais argumentos para uma Subrotina. Quando a mesma é chamada, a execução desloca-se para dentro da Sub-rotina e executa todos os comandos. Depois, a execução do script continua, com o comando seguinte ao que chamou a Sub-rotina. A sintaxe para declaração de uma sub-rotina é a seguinte: Sub Nome_da_Sub-rotina(argumento1, argumento2, ..., argumenton) Comando1 Comando2 ... Comandon End Sub

151

Criando Sites Dinâmicos com ASP 3.0

Uma sub-rotina pode, ou não, conter argumentos. Caso sejam necessários argumentos, os mesmos serão passados quando a Sub-rotina for chamada, e devem ser passados, na mesma ordem em que foram definidos.

DICA Quando você criar Sub-rotinas, procure utilizar nomes que descrevam a função que ela tem. Com isso você torna o entendimento do código mais fácil para quem for utilizá-lo.

Considere o seguinte exemplo de declaração de uma Sub-rotina: Sub Calcula_imposto(salario, desconto, extras) Comando1 Comando2 ... Comandon End Sub

Neste caso, declaramos uma Sub-rotina chamada Calcula_imposto, a qual espera receber três parâmetros: salario, desconto e extras. Os parâmetros devem ser fornecidos nesta ordem, para que a Sub-rotina funcione corretamente. Uma vez criada a Sub-rotina, podemos chamá-la, simplesmente digitando o nome, ou utilizando a palavra Call, mais o nome da Sub-rotina. Nos exemplos abaixo, temos dois métodos de chamada da Sub-rotina Calcula_imposto: Calcula_imposto(1500,23,125)

ou Call Calcula_imposto(1500,23,125)

Observe que os parâmetros são passados dentro do parênteses. Também poderíamos declarar uma Sub-rotina sem parâmetros. Neste caso posso simplesmente não utilizar os parênteses após o nome da Sub-rotina, ou utilizar um par de parênteses, sem nada dentro, conforme indicado abaixo: Sub Nome_da_Sub-rotina Comando1 Comando2 ... Comandon End Sub

152

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

Sub Nome_da_Sub-rotina( ) Comando1 Comando2 ... Comandon End Sub

Por exemplo, poderíamos criar uma Sub-rotina que exibe uma caixa de mensagem com a data do sistema e a hora, no formato indicado na Figura 3.46.

Figura 3.46: Exibindo a data e a hora em uma caixa de mensagem. Poderíamos criar todos os comandos necessários, para exibir a hora e a data neste formato, cada vez que a exibição fosse necessária. Porém é mais prático criar uma Sub-rotina que faz este trabalho. Cada vez que precisarmos exibir a data e a hora neste formato, é só chamarmos a Sub-rotina. Na Listagem 3.8, temos o código da Sub-rotina exibe_data_hora, a qual faz a exibição da data e da hora, no formato proposto pela Figura 3.46. Listagem 3.8 – A Sub-rotina exibe_data_hora. 1

Sub exibe_data_hora

mes_atual=Month(Date())

mes_nome=MonthName(mes_atual,False)

153

Criando Sites Dinâmicos com ASP 3.0

mensagem = “Ano atual: ” & Year(Date()) & Chr(13)

mensagem = mensagem & “Mês atual: ” & mes_nome & Chr(13)

mensagem = mensagem & “Hoje é dia: ” & Day(Date())& Chr(13) mensagem = mensagem & Chr(13) & “***************” & Chr(13)& Chr(13)

hora_atual = Hour(Time())

minuto_atual = Minute(Time())

segundo_atual = Second(Time())

mensagem = mensagem & “Hora atual: ” & hora_atual & chr(13)

mensagem = mensagem & “Minuto atual: ” & minuto_atual & chr(13)

mensagem = mensagem & “Segundo atual: ” & segundo_atual

MsgBox mensagem

End Sub

Agora, cada vez que for necessário exibir a data e a hora nos formatos do exemplo, basta chamar a Sub-rotina exibe_data_hora, utilizando um dos seguintes comandos: Call exibe_data_hora

ou exibe_data_hora

Criando e Utilizando Funções Uma função é um grupo de comandos que podem ser executados, simplesmente através da chamada do nome da Função. Podemos passar um ou mais argumentos para uma Função, e quando a mesma é chamada, a execução desloca-se para dentro da Função e executa todos os comandos. Depois, a execução do script continua, com o comando seguinte ao que chamou a Função. A diferença da Função para a Sub-rotina, é que a primeira sempre retorna um valor para o comando que a chamou. A sintaxe para declaração de uma Função é a seguinte: Function Nome_da_Função(argumento1, argumento2, ..., argumenton) Comando1 Comando2 ... Comandon End Function

154

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

Uma Função pode, ou não, conter argumentos. Caso sejam necessários argumentos, os mesmos serão passados quando a Função for chamada, e devem ser passados, na mesma ordem em que foram definidos.

DICA Quando você criar Função, procure utilizar nomes que descrevam os objetivos da Função. Com isso você torna o entendimento do código mais fácil para quem for utilizá-lo.

Considere o seguinte exemplo de declaração de uma Função: Function Converte_para_dolar(valor_em_real, cotacao_dolar) Comando1 Comando2 ... Comandon End Function

Neste caso, declaramos uma Função chamada Converte_para_dolar, a qual espera receber dois parâmetros: um valor em real e a cotação do dólar. Uma vez criada a Função, devemos chamá-la, em um comando de atribuição, isto é, o valor retornado pela função, deve ser atribuído a uma variável, ou exibido através de um comando como MsgBox. No exemplo abaixo, estamos atribuindo o valor de retorno da função, à variável valor_dolar. valor_dolar = Converte_para_dolar (1500,1.81)

Também poderíamos exibir o valor retornado pela função, utilizando o comando MsgBox, conforme indicado a seguir: MsgBox “Valor em dólar: ” & Converte_para_dolar (1500,1.81)

Observe que os parâmetros são passados dentro dos parênteses, e na mesma ordem definida quando da criação da função. Também poderíamos declarar uma Função, sem parâmetros. Neste caso posso simplesmente não utilizar os parênteses após o nome da Função, ou utilizar um par de parênteses, sem nada dentro, conforme indicado a seguir: Function Nome_da_Função Comando1 Comando2 ... Comandon End Function

155

Criando Sites Dinâmicos com ASP 3.0

ou Function Nome_da_Função( ) Comando1 Comando2 ... Comandon End Function

Por exemplo, vamos criar uma Função que converte um valor de um ângulo de graus para radianos. Depois a utilizaremos dentro de um laço For...Next, para exibir o valor em radianos, para os ângulos de 0 a 20 graus. Na Listagem 3.9, temos o exemplo de um script onde foi criada a função CRad, que converte um valor em graus para radianos. Depois utilizamos um laço For para exibir, através de uma caixa de mensagem, os valores em radianos, para os ângulos de 0 a 20 graus. Listagem 3.9 – A Função CRad – Converte valores de graus para radianos. 1

<HTML>

<HEAD>

<TITLE>Exemplo de criação de Função – CRad.</TITLE>

</HEAD>

<BODY>

<!—

‘Criação da função CRad.

Function CRad(valor_graus)

CRad = (valor_graus*3.14)/180

End Function

For i=0 to 20

mensagem = mensagem & “Angulo: ” & i & “Valor em Radianos: ” & FormatNumber(CRad(i),5)& Chr(13)

MsgBox mensagem

156

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

—>

</SCRIPT>

<P>Converte de graus para radianos.</P>

</BODY>

</HTML>

Observe que, dentro da Função, atribuímos à variável CRad um determinado valor. É isso que caracteriza uma Função. Dentro de seu código, devemos atribuir a uma variável que tenha o mesmo nome da Função, um determinado valor. Este valor é que será o valor de retorno da Função. Também cabe salientar o uso da função FormatNumber, dentro do laço For. Essa função é utilizada para formatar a maneira como um número é exibido. Neste caso, utilizamos a função FormatNumber, para limitar o número de casas decimais, a cinco casas depois da vírgula. Em cada passada do laço For...Next chamamos a função CRad, para fazer a conversão de graus para radianos. O valor retornado pela função CRad, é passado para a função FormatNumber, para ser formatado com apenas cinco casas decimais.

OBSERVAÇÃO A linha 13 está sendo exibida em duas linhas, por questões de espaço. Quando for criar este script, todo o conteúdo da linha 13, deve ser digitado em uma única linha.

Trabalhando com Eventos no VBScript Com o Internet Explorer, temos um conjunto de objetos a nossa disposição. Cada um destes objetos possui um conjunto de eventos, para os quais podemos criar código. Um evento é uma ação realizada pelo usuário em uma página. Por exemplo, quando o usuário clica com o mouse, em um botão de comando, é gerado o evento onclick deste botão. Para cada evento, existe uma Sub-rotina associada, para a qual podemos criar código em resposta ao evento. Por exemplo, quando o usuário clica em um botão de comando, podemos colocar código no evento onclick deste botão, que valida os dados digitados pelo usuário. Caso algum dado esteja com problemas, uma mensagem de erro é exibida, solicitando que o usuário corrija os dados com problema. No Modelo de Objetos do Internet Explorer, temos quatro objetos que podem responder a eventos:

157

Criando Sites Dinâmicos com ASP 3.0

➥ Window. ➥ Document. ➥ Form. ➥ Element. Para criar procedimentos que respondam a eventos utilizamos o seguinte formato: <SCRIPT ID=clientEventHandlersVBS LANGUAGE=vbscript> <!— Sub NomeDoObjeto_NomeDoEvento Comando1 Comando2 ... Comandon End Sub —> </SCRIPT>

O nome da Sub-rotina é que define a qual evento a mesma irá responder. O padrão para o nome da Sub-rotina é: NomeDoObjeto_NomeDoEvento. Na Listagem 3.10, temos um exemplo de utilização do evento Onload, do objeto Window. Este evento, conforme o próprio nome sugere, ocorre quando a página é carregada. Observe que o nome da Sub-rotina é: Window_onload, o que conforme descrito, significa o evento Onload do objeto Window. Listagem 3.10 – O evento Onload do objeto Window. 1

<HTML>

<HEAD>

<TITLE>Exemplo de eventos.</TITLE>

<!—

Sub Window_onload

MsgBox “A página está sendo carregada!!”

End Sub

—>

158

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

</SCRIPT>

</HEAD>

<BODY>

<P>Exemplo de utilização do evento onload do objeto Window.</P>

</BODY>

</HTML>

Ao ser carregada esta página, o evento Onload do objeto Window é disparado, e o código da Sub-rotina Window_onload é executado. Com isso é exibida uma caixa de mensagem, conforme indicado na Figura 3.47.

Figura 3.47: Caixa de diálogo criada pelo evento Window_onload.

Principais Eventos dos Objetos do Internet Explorer O objeto Window é o objeto de mais alto nível. Ele representa a janela do Internet Explorer e todos os seus elementos. Existem diversos eventos disponíveis para o objeto Window, conforme descrito na Tabela 3.6. Tabela 3.6 Os eventos do objeto Window. Evento

Descrição

Onbeforeunload

Ocorre quando a janela está para ser fechada.

Onblur

Ocorre quando a janela perde o foco.

Onerror

Ocorre quando um erro é gerado na janela.

Onfocus

Ocorre quando a janela recebe o foco.

Onhelp

Ocorre quando é pressionada a tecla F1.

159

Criando Sites Dinâmicos com ASP 3.0

Evento

Descrição

Onload

Ocorre quando a janela está sendo carregada.

Onresize

Ocorre quando a janela é redimensionada.

Onscroll

Ocorre quando o usuário rola através do conteúdo da janela.

Onunload

Ocorre quando a janela é fechada.

Na Listagem 3.11, temos código definido para os eventos Window_onload, Window_onhelp e Window_onunload. Listagem 3.11 – Utilizando alguns eventos do objeto Window. 1

<HTML>

<HEAD>

<TITLE>Exemplo de eventos.</TITLE>

<!—

Sub Window_onload

MsgBox “A página está sendo carregada!!”

End Sub

Sub Window_onhelp

MsgBox “Você pressionou a tecla F1!!”

End Sub

Sub Window_onunload

13 14

MsgBox “Você está fechando este documento!!!” End Sub

—>

</SCRIPT>

</HEAD>

<BODY>

<P>Exemplo de utilização de eventos do objeto Window.</P>

</BODY>

</HTML>

160

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

NOTA Ao pressionar F1, será exibida a mensagem indicada na Figura 3.48, e logo em seguida será aberta uma janela com a Ajuda do Internet Explorer, conforme indicado na Figura 3.49, uma vez que F1 é a tecla padrão de Ajuda no Windows.

Figura 3.48: Mensagem exibida pelo evento Window_onhelp.

Figura 3.49: Janela com a Ajuda do Internet Explorer. O objeto Document representa todo o conteúdo existente dentro do objeto Window. Existem diversos eventos disponíveis para o objeto Document, conforme descrito na Tabela 3.7.

161

Criando Sites Dinâmicos com ASP 3.0

Tabela 3.7 Os eventos do objeto Documento. Evento

Descrição

Onafterupdate

Ocorre após os dados terem sido enviados para o servidor Web. Por exemplo, quando a página possui um formulário, no qual o usuário preenche os campos e depois clica no botão Enviar, enviando os dados para o servidor Web. Este, na verdade, é um evento que ocorre no objeto Form, mas como o objeto Form está contido no objeto Document, o objeto Documento também é capaz de responder a este evento.

Onbeforeupdate

Ocorre antes que os dados tenham sido enviados para o servidor Web. Por exemplo, quando a página possui um formulário, no qual o usuário preenche os campos e depois clica no botão Enviar, enviando os dados para o servidor Web. Este, na verdade, é um evento que ocorre no objeto Form, mas como o objeto Form está contido no objeto Document, o objeto Document também é capaz de responder a este evento.

Onclick

Ocorre cada vez que o usuário clica no documento.

Ondblclick

Ocorre quando o usuário dá um clique duplo no documento.

Ondragstart

Ocorre quando o usuário começa a arrastar algum elemento no documento.

Onhelp

Ocorre quando o usuário pressiona a tecla F1.

OnKeyDown

Ocorre quando uma tecla é pressionada, com exceção de algumas teclas especiais, como Alt, por exemplo.

OnKeyPress

Ocorre quando qualquer tecla é pressionada, inclusive as teclas especiais.

OnKeyUp

Ocorre quando uma tecla, que estava pressionada, é liberada.

Onmousedown

Ocorre quando um botão do mouse é pressionado.

Onmousemove

Ocorre quando o mouse é movimentado sobre o documento.

Onmouseup

Ocorre quando um botão, que estava pressionado, é liberado.

Onselectstart

Ocorre quando um elemento do documento é selecionado.

162

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

Agora vamos listar os principais eventos do objeto Form. O objeto Form é criado com a tag <FORM> </FORM>. Podemos ter mais do que um objeto Form em um documento, desde que os mesmos possuam nomes diferentes. Existem diversos eventos disponíveis para o objeto Form, conforme descrito na Tabela 3.8. Tabela 3.8 Os eventos do objeto Form. Evento

Descrição

Onafterupdate

Onbeforeupdate

Onclick

Ocorre cada vez que o usuário clica no formulário.

Ondblclick

Ocorre quando o usuário dá um clique duplo no formulário.

Ondragstart

Ocorre quando o usuário começa a arrastar algum elemento no formulário.

Onhelp

Ocorre quando o usuário pressiona a tecla F1.

OnKeyDown

Ocorre quando uma tecla é pressionada, com exceção de algumas teclas especiais, como Alt, por exemplo.

OnKeyPress

Ocorre quando qualquer tecla é pressionada, inclusive as teclas especiais.

OnKeyUp

Ocorre quando uma tecla, que estava pressionada, é liberada.

Onmousedown

Ocorre quando um botão do mouse é pressionado.

Onmousemove

Ocorre quando o mouse é movimentado sobre o formulário.

Onmouseout

Ocorre quando o usuário move o mouse para fora da área do formulário.

Onmouseover

Ocorre quando o mouse é movimentado sobre o formulário.

163

Criando Sites Dinâmicos com ASP 3.0

Evento

Descrição

Onmouseup

Ocorre quando um botão, que estava pressionado, é liberado.

Onselectstart

Ocorre quando um elemento do formulário é selecionado.

Onsubmit

Ocorre quando o usuário clica no botão Enviar do formulário.

Onreset

Ocorre quando o usuário clica no botão Reset do formulário.

Agora vamos listar os principais eventos do objeto Element. O objeto Element, representa qualquer controle ou elemento visível que possa ser colocado em uma página. Podemos ter mais do que um objeto Element em um documento, sendo que cada objeto é identificado pelo seu nome. Não podemos ter dois elementos com o mesmo nome. Existem diversos eventos disponíveis para o objeto Element, conforme descrito na Tabela 3.9. Tabela 3.9 Os eventos do objeto Element. Evento

Descrição

Onafterupdate

Onbeforeupdate

Onblur

Ocorre quando o elemento perde o foco.

Onchange

Ocorre quando os dados do elemento são alterados. Por exemplo, quando alteramos o valor de um campo de texto, em um formulário.

Onclick

Ocorre cada vez que o usuário clica no elemento.

Ondblclick

Ocorre quando o usuário dá um clique duplo no elemento.

Ondragstart

Ocorre quando o usuário começa a arrastar um elemento pela primeira vez.

164

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

Evento

Descrição

Onfocus

Ocorre quando o elemento recebe o foco.

Onhelp

Ocorre quando o usuário pressiona a tecla F1.

OnKeyDown

Ocorre quando uma tecla é pressionada, com exceção de algumas teclas especiais, como Alt, por exemplo.

OnKeyPress

Ocorre quando qualquer tecla é pressionada, inclusive as teclas especiais.

OnKeyUp

Ocorre quando uma tecla, que estava pressionada, é liberada.

Onmousedown

Ocorre quando um botão do mouse é pressionado.

Onmousemove

Ocorre quando o mouse é movimentado sobre o formulário.

Onmouseout

Ocorre quando o usuário move o mouse para fora da área do formulário.

Onmouseover

Ocorre quando o mouse é movimentado sobre o formulário.

Onmouseup

Ocorre quando um botão, que estava pressionado, é liberado.

Onresize

Ocorre quando o elemento é redimensionado.

Onselectstart

Ocorre quando um elemento é selecionado.

Onsubmit

Ocorre quando o usuário clica no botão Enviar do formulário.

Onselect

Ocorre quando o usuário termina de selecionar os dados de um controle de entrada, como uma caixa de texto, por exemplo.

Apenas para exemplificar a utilização de eventos, vamos criar uma página onde temos uma caixa de seleção. Nesta caixa de seleção temos três opções: Axcel Books, Developers Magazine e Microsoft. Quando o usuário seleciona uma destas opções, o Internet Explorer, automaticamente, carrega a página relacionada. A Figura 3.50, mostra a página de exemplo. Para tornar esta lista dinâmica, utilizamos o modelo de eventos e código VBScript, conforme indicado na Listagem 3.12.

165

Criando Sites Dinâmicos com ASP 3.0

Figura 3.50: Criando uma lista de navegação. Listagem 3.12 – Criando uma lista de navegação dinâmica. 1

<HTML>

<HEAD>

<!—

Sub navega_onchange

window.navigate window.navega.value

End Sub

—>

</SCRIPT>

</HEAD>

<BODY>

<P>Selecione uma opção na lista, para ir à página selecionada:</P>

<P>

<OPTION

selected value=Informativo>Selecione uma opção na lista</OPTION>

166

Capítulo 3 – Funções, Procedimentos e Eventos com VBScript

<OPTION

value=http://www.axcel.com.br>Axcel Books Editora</OPTION>

<OPTION

value=http://www.developers.com.br>Developers Magazine</OPTION>

<OPTION

value=http://www.microsoft.com>Microsoft</OPTION>

SELECT>

</P>

</BODY>

</HTML>

Para tornar a lista dinâmica, utilizamos o evento onchange, do controle Navega. O controle navega é uma caixa de combinação. Para maiores informações sobre criação de formulário com HTML, consulte o Capítulo 2. Utilizamos o evento navega_onchange, o qual acontece toda vez que um elemento da lista for selecionado. Vejam que com uma única linha de código, tornamos a lista dinâmica. A linha de código foi a seguinte: window.navigate window.navega.value

A primeira parte utiliza o método Navigate do objeto Window. Este método é utilizado para carregar uma página no Internet Explorer. O método Navigate espera receber um único parâmetro, que é o endereço da página que deve ser carregada. Este parâmetro é obtido a partir da propriedade value do controle Navega. Cada opção da caixa de combinação possui um valor associado. Por exemplo, quando o usuário seleciona Microsoft, a propriedade value é definida como http://www.microsoft.com, e este parâmetro é passado para o método window.navigate, fazendo com que seja carregada a página da Microsoft. Este é o comportamento desejado para a nossa página, ou seja, quando uma opção é selecionada, a página associada a ela, deve ser carregada no Internet Explorer.

IMPORTANTE Estamos utilizando o modelo de objetos e de eventos do Internet Explorer. O Nestcape Navigator possui um modelo de objetos diferente do modelo do Internet Explorer. Por isso, scripts desenvolvidos para o modelo do Internet Explorer, podem não funcionar corretamente no Netscape.

Conclusão Neste capítulo, abordamos diversos tópicos importantes do VBScript. Iniciamos pelas funções para determinação do subtipo de uma variável, bem como funções para conversão de subtipos. Depois passamos a tratar de outras funções, tais como as para tratamento de texto, data e hora e funções matemáticas. Estas funções são utilizadas na criação de aplicações práticas e são de grande ajuda.

167

Criando Sites Dinâmicos com ASP 3.0

Em seguida, aprendemos a criar e utilizar Sub-rotinas e Funções, conhecendo as vantagens de sua utilização. Na parte final do capítulo, tratamos sobre o modelo de objetos do Internet Explorer e os principais eventos associados a cada um dos objetos. Para quem procura maiores informações sobre este assunto, sugiro o seguinte endereço: http://msdn.microsoft.com/scripting. A partir do próximo capítulo estaremos aprendendo a utilizar a tecnologia ASP na criação de páginas e sites dinâmicos. O conteúdo apresentado nestes capítulos iniciais é de fundamental importância para a aprendizagem de ASP, e formam a base para o restante do livro.

168

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

Capítulo 4 A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

169

Criando Sites Dinâmicos com ASP 3.0

Introdução Vamos iniciar, a partir deste capítulo, a nossa jornada rumo a aprendizagem da tecnologia de Active Server Pages – ASP 3.0. Passaremos ao aprendizado de uma série de conceitos importantes, os quais são utilizados na construção de páginas dinâmicas e aplicativos para a Web. Iniciaremos o capítulo com uma apresentação detalhada sobre a tecnologia ASP, para que possam ser solucionadas quaisquer dúvidas, que por ventura o leitor ainda tenha a respeito do que é exatamente esta tecnologia e do que é necessário para utilizá-la. Em seguida, passaremos ao estudo do Modelo de Objetos do ASP 3.0, apresentando uma visão geral sobre o Modelo de Objetos e a função de cada um dos objetos existentes. Feitas as devidas apresentações, passaremos a estudar alguns objetos do ASP 3.0, sempre ilustrando os conceitos apresentados com exemplos práticos e de fácil assimilação. Nos exemplos procuro ilustrar a forma de utilização de cada um dos objetos, de modo que os mesmos possam ser facilmente, adaptados para uso nas aplicações que se esteja desenvolvendo.

NOTA Os objetos, que não forem tratados neste capítulo, serão vistos nos demais capítulos deste livro.

Finalizaremos o capítulo com alguns exemplos mais elaborados, onde procuro apresentar diversas utilizações práticas para os objetos da tecnologia ASP 3.0.

Entendendo e Utilizando ASP Quando começamos a utilizar ASP, surgem algumas dúvidas a respeito desta tecnologia. Conhecer os diversos objetos, métodos e comandos é importante, porém igualmente importante é conhecer o funcionamento de uma página ASP. Para isso temos que responder às seguintes perguntas: ➥ Como e onde uma página ASP é processada? ➥ O que uma página ASP retorna para o navegador do cliente? ➥ O que é preciso para criar e acessar páginas ASP? Vamos às respostas.

170

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

Como e Onde uma Página ASP é Processada? Primeiro devemos lembrar que o que caracteriza uma página como sendo uma página ASP é a extensão .asp. Isto significa que nossas páginas devem ter a extensão .asp e não .htm ou .html, normalmente utilizadas para páginas HTML estáticas. Por exemplo, quando o usuário digita um endereço como o seguinte: http://www.abc.com.br/compras.asp

o servidor identifica a página como sendo uma página ASP, devido a extensão .asp. Uma vez identificada, a página ASP é “processada” pelo servidor Web (que pode ser o IIS ou o Personal Web Server). O servidor, após identificar a página ASP, passa a mesma para uma DLL chamada ASP.DLL. O código contido nesta DLL analisa toda a página ASP, linha por linha, em busca de linhas de código ASP, o qual é executado. Após executado todo o código existente na página, o resultado, no formato de uma página HTML simples, é enviado para o navegador do cliente. Este processo é detalhado na Figura 4.1 e explicado em seguida. 1) www.abc.com.br/page1.asp

Cliente

Servidor Web – IIS 2) Identifica que é uma página ASP. 3) Passa o processamento para ASP.DLL 4) Interpreta e executa o código existente. 5) Retorna um resultado no formato HTML.

Cliente 1) www.abc.com.br/page2.asp

Figura 4.1: O processamento de uma página ASP. Abaixo descrevemos, detalhadamente, os passos indicados na Figura 4.1. 1. O usuário digita o endereço ou clica em um link para uma página ASP, como por exemplo www.abc.com.br/catalogo/precos.asp. O pedido do usuário é enviado para o servidor Web, que no nosso exemplo é o IIS – Internet Information Services.

171

Criando Sites Dinâmicos com ASP 3.0

2. O servidor identifica que o pedido é para uma página que contém código ASP, pois a extensão da página é .asp. No exemplo da Figura 4.1 um dos clientes solicita a página page1.asp e o outro a página page2.asp. 3. Uma vez identificada como uma página ASP, o servidor Web passa o processamento da página para o interpretador ASP (que no caso é a DLL ASP.DLL, normalmente instalada no diretório winnt\System32\inetsrv, o qual é o diretório de instalação do IIS). 4. O interpretador passa linha por linha da página ASP. Sempre que for encontrado código ASP, o mesmo é interpretado e executado. 5. Após todo o código ter sido executado, o resultado do processamento é enviado para o navegador do cliente, no formato de uma página HTML padrão. É importante detalhar bastante este ponto, pois existem muitas confusões e interpretações errôneas a respeito do mesmo. Vamos fazer isso no próximo item. Com isso podemos responder a pergunta do item: como e onde uma página ASP é processada? Uma página ASP é processada no servidor Web (IIS ou Personal Web Server) pelo interpretador ASP (ASP.DLL). O interpretador percorre a página, linha por linha, interpretando e executando todo o código existente na página. Agora vamos detalhar um pouco mais sobre o que a página ASP retorna para o navegador do cliente.

O que uma Página ASP Retorna Para o Navegador do Cliente? Quando o usuário digita o endereço ou clica em um link para uma página ASP, por exemplo www.abc.com.br/page1.asp, a página page1.asp é interpretada e o código ASP executado. Enquanto a página está sendo executada nada é retornado para o cliente (embora possamos ter um certo controle sobre isso, fazendo com que a página seja exibida à medida que a mesma vai sendo interpretada e executada. Aprenderemos a fazer este controle mais adiante.). Após o processamento da página, o resultado é retornado para o navegador do cliente. Nunca é demais repetir que o que é enviado para o navegador do cliente é apenas código HTML padrão, resultante do processamento da página ASP. Isso pode facilmente ser comprovado. No Internet Explorer 5.0 ou superior, basta que o usuário selecione o comando Exibir/Código fonte, no menu de Opções. Isto irá exibir o código fonte da página que é enviada para o navegador do cliente. Uma observação atenta é suficiente para verificar que o resultado é apenas código HTML. Vamos exemplificar este fato. Considere a página ASP, extremamente simples, da Listagem 4.1.

172

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

Listagem 4.1 – Uma página ASP simples – list4-1.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<BODY>

<H1>EXEMPLO DE PÁGINA ASP</H1>

Response.Write “Toda página ASP é interpretada <BR>”

Response.Write “e executada no servidor WEB !!!<BR>”

Response.Write “O resultado que retorna para o navegador<BR>”

Response.Write “do cliente, é código HTML padrão.”

</BODY>

</HTML>

Ao acessar esta página ASP, o servidor Web interpreta e executa todo o código existente. No nosso exemplo, o código ASP inicia na linha 7 e termina na linha 12. Relembrando o que vimos no Capítulo 1: toda seção de código ASP inicia com <% e termina com %>. O resultado, gerado pela página ASP, é código HTML padrão, o qual é enviado para o navegador do cliente. A Figura 4.2, mostra a página list4-1.asp sendo acessada no Internet Explorer.

Figura 4.2: Acessando a página list4-1.asp.

173

Criando Sites Dinâmicos com ASP 3.0

Se escolhermos o comando Exibir/Código fonte, veremos o resultado indicado na Figura 4.3, o que nada mais é do que código HTML. Isto comprova o que foi descrito neste item.

Figura 4.3: Código HTML resultante do processamento da página ASP. Apenas para esclarecer,vamos ver qual o código ASP que gerou a seguinte linha de código HTML: Toda página ASP é interpretada <BR>

Esta linha de código HTML é resultado da execução da seguinte linha de código ASP: Response.Write “Toda página ASP é interpretada <BR>”

Ao executar esta linha de código ASP, o interpretador encontra o comando Response.Write. O interpretador sabe que é para enviar para o navegador do cliente, tudo o que estiver entre aspas, pois o comando Response.Write foi criado justamente para enviar um determinado texto para o navegador do cliente (seria melhor dizer: “O método Write do objeto Response”, ao invés de Response.Write, mas falaremos mais sobre objetos e seus métodos durante todo este capítulo). Neste exemplo, simplesmente estamos utilizando o comando Response.Write para enviar o código HTML para o cliente. A tag <BR> é a utilizada para quebra de linha: BR – Break Row. Outro detalhe interessante a ser observado é que temos código HTML fora da seção de código ASP. Na listagem 4.1, a linha 6 <H1>EXEMPLO DE PÁGINA ASP</H1> é código HTML. Neste caso estamos utilizando a tag <H1> para criar o cabeçalho do documento, conforme indicado na Figura 4.2. Este código HTML, que não é gerado por comandos ASP, é enviado diretamente para o navegador do cliente, quando a página ASP é acessada.

174

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

Veja que a possibilidade de alternar trechos de código HTML, com trechos de código ASP, dentro de uma mesma página ASP, nos dá uma grande flexibilidade. As partes da página que não apresentam natureza dinâmica, podem ser criadas simplesmente utilizando código HTML. Outras partes que necessitam ser dinamicamente criadas, quer seja através da realização de cálculos ou através do acesso a campos de uma tabela de um banco de dados, podem ser criadas utilizando código ASP. Além disso podemos ter várias seções de código ASP dentro de uma mesma página. Para iniciar uma seção utilizo <% e para finalizar a seção utilizo %>. Posso colocar código HTML entre as diversas seções de código ASP. Com isso vou criando a página utilizando HTML nos pontos estáticos e ASP nos pontos que precisam ser dinâmicos.

O que é Preciso Para Criar e Acessar Páginas ASP? Uma página ASP é gravada no servidor, no formato de um arquivo de texto comum, no qual colocamos código HTML e código ASP, conforme descrito anteriormente. Por isso, posso utilizar um redator de texto, como por exemplo o Bloco de Notas, para criação de páginas ASP. Uma vez criado o arquivo .asp, basta salvá-lo em uma pasta no servidor Web e pronto, o mesmo já pode ser acessado pelo navegador do cliente. Também existem ferramentas gráficas que facilitam a criação de aplicações para a Web, utilizando a tecnologia ASP. Uma ferramenta, desenvolvida pela própria Microsoft, é o Microsoft Visual Interdev, o qual está, atualmente, na sua versão 6.0. Como descrito anteriormente, uma página ASP é interpretada e executada no servidor Web. Como servidor Web devemos utilizar o IIS – Internet Information Services 5.0 (o qual faz parte do Windows 2000 Server), ou o Personal Web Server, para Windows 95 ou Windows 98. Não existe, por exemplo, um interpretador ASP para o servidor Web Apache, ou para o Domino da Lotus. Para maiores informações sobre os servidores Web que suportam ASP, consulte a Introdução deste livro. Podemos acessar páginas ASP utilizando qualquer navegador disponível (Internet Explorer, Netscape Navigator, Mosaic, etc.). Isto é possível pelo fato de que uma página ASP é interpretada e executada no servidor Web, retornando apenas código HTML padrão. Qualquer navegador é capaz de exibir o conteúdo do código HTML de retorno. Com isso a utilização de páginas ASP independe do navegador do cliente, o que passa a ser uma preocupação a menos para quem desenvolve as páginas. O fato de uma página ASP ser interpretada e executada no servidor Web traz inúmeras vantagens, conforme já descrevemos, porém traz a desvantagem de não poder ser testada localmente. Isto significa que você não pode simplesmente gravar uma página ASP em uma pasta do seu computador e tentar acessá-la através do seu navegador. Fazendo isso, todo o código ASP será, simplesmente, ignorado. Para que uma página ASP seja processada

175

Criando Sites Dinâmicos com ASP 3.0

corretamente, a mesma precisa estar armazenada em um servidor como o IIS, onde existe o interpretador ASP. A página deve ser acessada utilizando-se o protocolo HTTP, isto é, ou você digita o endereço da página, como por exemplo http://www.abc.com.br/page1.asp, ou clica em um link que aponta para a página ASP gravada no servidor Web. Uma das novidades da tecnologia ASP 3.0 é que podemos ter páginas com a extensão .asp, sem que as mesmas contenham código ASP. Por exemplo, posso ter uma página .asp que contém apenas código HTML. Quando esta página é solicitada, o servidor Web passa a solicitação para o interpretador ASP (ASP.DLL). A primeira coisa que o interpretador faz é verificar se existe algum código a ser interpretado e executado. Caso não exista código ASP, a página é enviada de volta para o IIS, o qual retorna a página para o navegador do cliente. Com este procedimento o interpretador não precisa passar a página, linha por linha. Isto torna a execução das páginas bem mais rápida. Caso a página possua código ASP, o código é interpretado e executado, e o resultado do processamento é retornado para o IIS. Será inserido o código HTML, retornado pelo processador ASP, nos pontos específicos da página, e o IIS enviará, depois, a página resultante no formato HTML para o navegador do cliente. Com isso posso criar todas as páginas com a extensão .asp, mesmo aquelas que não irão conter código ASP. Caso sejam necessárias mudanças nas páginas, posso inserir o código ASP, sem que precise alterar os links do site, pois as extensões das páginas não precisarão ser alteradas (isso aconteceria somente se tivéssemos criado as páginas como .htm e depois trocado a extensão para .asp quando fosse necessário inserir código ASP nas páginas).

Objetos do ASP 3.0 Com a tecnologia ASP 3.0 temos acesso a uma série de objetos e métodos que fazem parte do próprio ASP. Estes objetos e métodos fornecem diversas funcionalidades necessárias à criação de páginas dinâmicas. Como exemplo, temos um objeto chamado Request, o qual pode ser utilizado para processar as informações que o usuário preenche em um formulário. Temos também um objeto Response, do qual já utilizamos o método Write na Listagem 4.1, o qual é utilizado para retornar informações para o navegador do cliente, além de vários outros. Neste item faremos uma apresentação genérica sobre o Modelo de Objetos do ASP 3.0, bem como uma breve descrição de cada objeto. Nos demais itens deste capítulo estaremos tratando, em detalhes, de cada um destes objetos. Estudaremos os objetos através de exemplos práticos de utilização dos mesmos.

176

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

Uma Visão Geral do Modelo de Objetos do ASP 3.0 O Modelo de Objetos do ASP 3.0 apresenta os seguintes objetos: ➥ Response ➥ Request ➥ Application ➥ Session ➥ Server ➥ ASPError (este é novidade do ASP 3.0). Cada um destes objetos pode possuir os seguintes elementos: ➥ Methods (Métodos) ➥ Collections (Coleções) ➥ Properties (Propriedades) ➥ Events (Eventos) Chamamos um método de um objeto para que o mesmo realize uma determinada ação. De maneira geral, sem nos preocuparmos em sermos precisos em relação à teoria de Orientação a Objetos, poderíamos dizer que: “Um método é um comportamento ou ação realizada por um objeto”. Por exemplo, quando utilizamos o método Write do objeto Response (Response.Write), o comportamento esperado é que o método Write envie o texto fornecido entre aspas, para o servidor Web, que por sua vez envia para o navegador do cliente. Conforme pode ser constatado pela Listagem 4.1, para chamarmos um método de um objeto, utilizamos a seguinte sintaxe: Nome_do_objeto.Nome_do_método parâmetros

Observe o exemplo da Figura 4.4.

Método

Response.Write "Objetos do ASP 3.0!!!" Objeto

Parâmetro

Figura 4.4: Utilizando o método Write do objeto Response.

177

Criando Sites Dinâmicos com ASP 3.0

Uma propriedade de um objeto define uma característica ou atributo do mesmo. Por exemplo, temos a propriedade ScriptTimeout, a qual define o tempo máximo em que o código ASP pode ficar sendo executado em uma página, antes que o servidor cancele a execução e retorne uma mensagem de erro. O valor padrão é de 90 segundos. O exemplo seguinte define esta propriedade para 5 minutos (300 segundos): Server.ScriptTimeout = 300

Observe que as propriedades de um objeto são chamadas da mesma maneira que os métodos, isto é: Nome_do_objeto.Nome_da_propriedade = valor

Uma coleção contém um ou mais valores, os quais podem ser acessados pelo código ASP. Por exemplo, a coleção Form, do objeto Request, contém os nomes e valores de todos os controles de um formulário cujos dados foram passados para processamento da página ASP. Lembre que isto é feito através do atributo Action da tag FORM, além disso o atributo Method deve ser definido em POST. Para maiores detalhes sobre os atributos Action e Method, consulte o Capítulo 2.

Figura 4.5: O Modelo de Objetos do ASP 3.0. Um evento é uma determinada ação que acontece, e para a qual podemos escrever código ASP em resposta. Por exemplo, o objeto Session contém um evento OnStart, que ocorre quando um usuário estabelece uma sessão com uma página ASP antes que uma requisição do usuário

178

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

seja executada. Podemos utilizar este evento para iniciar variáveis ou rodar qualquer outro código que seja necessário. Você já deve ter entrado em um site onde é necessário preencher um formulário de cadastramento. Da próxima vez que você entra no site, você recebe uma mensagem dizendo “Bem vindo Fulano de tal!”. Como é que o site sabe que é você, ou pelo menos o seu computador, que está entrando no site? A página utiliza o evento Session.OnStart para ler informações que foram gravadas no seu computador, normalmente na forma de um Cookie e determinar quem está acessando a página. Na Figura 4.5, temos uma visão geral de todos os Objetos, seus métodos, coleções, eventos e propriedades. No restante deste capítulo, estaremos aprendendo a utilizar os objetos Response e Request. Os demais objetos serão vistos ao longo do livro.

O Objeto Request Com o objeto Request podemos ter acesso a diversas informações fornecidas pelo cliente ao acessar uma página ASP, ou ao preencher dados em um formulário e enviá-los. Podemos ter acesso a informações a respeito do navegador que o cliente está utilizando, quais os Cookies gravados no computador do usuário, qual Certificado Digital o usuário está utilizando e muitas outras informações importantes. A partir de agora passaremos a estudar os principais métodos, coleções e propriedades do objeto Request. Analisaremos os diversos aspectos deste objeto, através da utilização de alguns exemplos práticos.

Coleções do Objeto Request O objeto Request possui diversas coleções. Uma coleção nada mais é do que uma estrutura de dados. Nesta estrutura de dados temos diversos valores, e a cada um deles está associada uma chave de identificação, a qual pode ser utilizada para acessar o valor contido na coleção. Através das coleções do objeto Request, podemos ter acesso a diversas informações do cliente, como por exemplo, os dados que digita em um formulário.

A Coleção Form do Objeto Request Para estudar esta coleção, vamos fazer uma revisão rápida sobre a maneira como os dados digitados em um formulário são passados para o servidor para processamento. Considere o formulário da Listagem 4.2.

179

Criando Sites Dinâmicos com ASP 3.0

Listagem 4.2 – Um formulário HTML simples – list4-2.htm. 1

<HTML>

<HEAD>

<TITLE>Formulário para Cadastro de Clientes !!</TITLE>

</HEAD>

<BODY>

<P><STRONG>Formulário para Cadastro de Clientes:</STRONG></P>

<P>Digite os dados solicitados e clique no botão Enviar.</P>

<P>Cidade: <INPUT id=cidade maxLength=30 name=cidade></P>

<P>Cartão Crédito:

<INPUT id=cartao name=cartao type=radio value=“Visa”>Visa

<INPUT id=cartao name=cartao type=radio value=“Master Card”>Master Card

<INPUT id=cartao name=cartao type=radio value=“Outros”>Outros</P>

<P>

</P>

</FORM>

</BODY>

</HTML>

Ao acessarmos o arquivo da Listagem 4.2, no Internet Explorer, obtemos o resultado indicado na Figura 4.6. Para maiores detalhes sobre a construção de formulários HTML, veja o Capítulo 2. Observe que cada campo possui as propriedades “id” e “name” iguais. Definimos estas duas propriedades para de manter a padronização. Para os objetos do ASP, o que é realmente utilizado é a propriedade name, a qual identifica cada um dos campos de um formulário. Observe que o atributo method do formulário, na linha 8, foi definido como post. Quando utilizamos o método post, os dados digitados no formulário são enviados em uma conexão separada, fazendo com que os mesmos não fiquem visíveis na linha de endereço do navegador.

180

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

Além disso o método post permite que mais informações sejam enviadas, do que se estivéssemos utilizando o método get. Falaremos um pouco mais sobre as diferenças entre os métodos post e get, no próximo item.

Figura 4.6: O formulário da Listagem 4.2. O atributo action do formulário, na linha 8, foi definido como list4-2.asp. Isto significa que a página ASP list4-2.asp é que vai processar os dados enviados pelo formulário. Neste caso digitamos somente o nome da página porque a página HTML, que contém o formulário, e a página ASP, que irá processar os dados digitados no formulário, estão na mesma pasta do servidor Web. Poderia acontecer da página ASP estar, inclusive, em um outro servidor. Neste caso devemos digitar o endereço completo da página ASP, como por exemplo: <FORM action=“http://www.abc.com.br/Capitulo4/list4-2.asp” method=“post”>

Ao clicar no botão Enviar, os dados digitados no formulário são passados para a página list42.asp. Precisamos de uma maneira de acessar estes dados. A coleção que nos permite ter acesso a estes dados é a coleção Form do objeto Request.

181

Criando Sites Dinâmicos com ASP 3.0

IMPORTANTE A coleção Form somente é utilizada quando o atributo method do formulário é definido como post. Quando o método for definido como get, conforme veremos mais adiante, devemos utilizar a coleção QueryString, ao invés da coleção Form.

A maneira de acessar os dados é exemplificada abaixo: Request.Form(“Nome_do_Campo”)

Onde Nome_do_Campo é o valor definido no atributo name de cada um dos campos do formulário. Por exemplo, o campo nome, na Listagem 4.2, tem a sua propriedade name definida como nome. Para acessar o valor digitado no campo nome, utilizaríamos o seguinte comando: Request.Form(“nome”)

Na Listagem 4.3, temos um exemplo para a página list4-2.asp, a qual simplesmente informa ao usuário quais os valores que ele digitou em cada um dos campos. Para isso, utilizamos a coleção Form do objeto Request. Listagem 4.3 – A página ASP list4-2.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<BODY>

<h2> Você digitou os seguintes dados !!</h2>

<P>Nome:

=Request.Form(“nome”)

</P>

<p>Rua:

=Request.Form(“rua”)

</p>

<p>Cidade:

182

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

=Request.Form(“cidade”)

</p>

<p>E-mail:

=Request.Form(“email”)

</p>

<p>Cartão de Crédito:

=Request.Form(“cartao”)

</p>

<P><A href=“list4-2.htm”>Clique aqui para voltar ao formulário</A></P>

</BODY>

</HTML>

Observe que vamos alternando trechos de código HTML com trechos de código ASP. Vamos analisar o seguinte trecho de código: 7

<P>Nome:

=Request.Form(“nome”)

</P>

Na linha 7, é aberta uma tag de parágrafo <P>. Dentro deste parágrafo é colocado o texto Nome:. Na linha 8 é aberto um trecho de código ASP, e utilizo a coleção Form do objeto Request para ter acesso ao valor digitado no campo nome. No nosso exemplo, a linha 9 simplesmente retorna o texto digitado no campo nome do formulário. Este nome é colocado logo após Nome:. Finalmente na linha 11 é fechado o parágrafo. O resultado deste trecho de código que retorna para o usuário é o seguinte (supondo que no campo nome tenha sido digitado Júlio Cesar Fabris Battisti): <P>Nome: Júlio Cesar Fabris Battisti</P>

Na Figura 4.7, temos o retorno da página list4-2.asp, para os dados de exemplo indicados na Figura 4.6.

183

Criando Sites Dinâmicos com ASP 3.0

Figura 4.7: O retorno da página list4-2.asp. Observe que, com o uso da coleção Form, podemos ter acesso a todos os campos do formulário. A maneira como a página list4-2.asp foi construída irá funcionar bem, porém poderemos ter alguns problemas. Por exemplo, vamos supor que por algum motivo, o nome de um dos campos do formulário precise ser alterado. Caso isso aconteça, precisaríamos alterar a página ASP, pois a coleção Form, utiliza a propriedade name do campo, para ter acesso ao conteúdo do mesmo. Podemos contornar esta dificuldade utilizando uma estrutura de controle que permite percorrer todos os itens de uma coleção. Percorreremos os itens da coleção Form capturando o nome do campo e o valor do mesmo. Com isso se o nome de algum campo mudar, a mudança será detectada cada vez que a página ASP for chamada, pois o nome do campo não estará fixado dentro do próprio arquivo ASP, como ocorre na Listagem 4.3. A estrutura de controle que permite percorrer todos os elementos de uma coleção possui a seguinte estrutura: For Each membro In Nome_da_Coleção Comando1

184

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

Comando2 ... Comandon Next

Com a estrutura For Each...Next, conseguimos percorrer todos os membros de uma coleção. Considere o seguinte exemplo: <% For Each Item in Request.Form =Item Next %>

Neste caso estaremos listando todos os nomes dos campos do formulário, através da utilização da estrutura For Each...Next. Agora vamos utilizar a estrutura For Each...Next para rescrever a nossa página ASP de uma maneira mais genérica, conforme indicado na Listagem 4.4. Listagem 4.4 – A página ASP list4-2-2.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<BODY>

<H2> Você digitou os seguintes dados !!</H2>

For Each Item in Request.Form %>

<P>

<%=Item%>

<%=Request.Form(Item)%>

</P>

<% Next %>

<P><A href=“list4-2.htm”>Clique aqui para voltar ao formulário</A></P>

</BODY>

</HTML>

185

Criando Sites Dinâmicos com ASP 3.0

Esta página produz o mesmo resultado que a página ASP da Listagem 4.3, porém vejam como o código é bem menor. Além disso este código funciona sempre, mesmo que o nome de algum dos campos do formulário seja alterado. Para testar este código basta salvar esta listagem com o nome de list4-2-2.asp e alterar a página list4-2.htm. No atributo action da tag <FORM> troque action=“list4-2.asp” por action=“list4-2-2.asp”. Também é interessante notar que fomos alternando trechos de código HTML com código ASP. Por exemplo, as linhas 7 e 8 são código ASP, onde é iniciado o laço For Each...Next. Na linha 9 abrimos uma tag de parágrafo. Na linha 10 é exibido o nome do campo, através da utilização de <% = Item%>. Na linha 11 colocamos o sinal : que vai ficar entre o nome do campo e o valor digitado no campo. Na linha 12 é exibido o valor digitado no campo do formulário, cujo atributo nome foi exibido pela linha 10. A linha 13 fecha a tag de parágrafo e, finalmente, a linha 14 encerra o laço For Each...Next. Observe que o laço foi aberto em uma seção de código e fechado em outra, o que nos dá uma grande flexibilidade.

A Coleção QueryString do Objeto Request Utilizamos a coleção QueryString quando o formulário utilizar o método get ao invés do método post. Quando utilizamos o método get, os dados são passados para o servidor, junto com a URL de endereço. Vamos alterar o formulário da Listagem 4.2, para que o mesmo utilize o método get ao invés do método post. Também vamos alterar o atributo action, para que o mesmo chame a página ASP formget.asp, para processar os dados digitados no formulário. Com estas modificações, teremos o formulário indicado na Listagem 4.5. Listagem 4.5 – Um formulário HTML simples – formget.htm. 1

<HTML>

<HEAD>

<TITLE>Formulário para Cadastro de Clientes !! </TITLE>

</HEAD>

<BODY>

<P><STRONG>Formulário para Cadastro de Clientes:</STRONG></P>

<P>Digite os dados solicitados e clique no botão Enviar.</P>

<P>Cidade: <INPUT id=cidade maxLength=30 name=cidade></P>

186

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

<P>Cartão Crédito:

<INPUT id=cartao name=cartao type=radio value=“Visa”>Visa

<INPUT id=cartao name=cartao type=radio value=“Master Card”>Master Card

<INPUT id=cartao name=cartao type=radio value=“Outros”>Outros</P>

<P>

</P>

</FORM>

</BODY>

</HTML>

Ao acessarmos o arquivo da Listagem 4.5, no Internet Explorer, obtemos o resultado indicado na Figura 4.8.

Figura 4.8: O formulário da Listagem 4.5.

187

Criando Sites Dinâmicos com ASP 3.0

Para criar o arquivo formget.asp, basta pegar o código da Listagem 4.4 e trocar Request.Form por Request.QueryString. Com isso teremos o código da Listagem 4.6. Listagem 4.6 – A página ASP formget.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<BODY>

<H2> Você digitou os seguintes dados !!</H2>

For Each Item in Request.QueryString %>

<P>

<%=Item%>

<%=Request.QueryString(Item)%>

</P>

<% Next %>

<P><A href=“formget.htm”>Clique aqui para voltar ao formulário</A></P>

</BODY>

</HTML>

Esta página fornece o retorno indicado na Figura 4.9. Observe que o resultado é praticamente o mesmo da Figura 4.7, porém com a diferença de que os dados foram passados através do endereço de chamada da página. No campo endereço temos o seguinte: http://servidor/Capitulo4/formget.asp?nome=J%FAlio+Cesar+Fabris+Battisti&rua=Sinimbu++456&cidade=Boqueir%E3o+do+Le%E3o&email=batisti@hotmail.com&cartao=Outros&enviar=Submit

Observe que os dados foram passados dentro da própria URL. Caracteres especiais, como o u com acento agudo, são substituídos. Observe que o nome Júlio foi substituído por J%FAlio, ou seja, o ú foi substituído por %FA. Também podemos observar que todo espaço em branco foi substituído pelo sinal +, e assim por diante. Neste caso a coleção QueryString sabe tratar estes caracteres especiais e exibi-los corretamente, conforme indicado pela Figura 4.9. O método get possui limitações quanto a quantidade de informações que o mesmo pode passar para o servidor. Esta limitação está em torno de 1.000 caracteres, conforme definição

188

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

do protocolo HTTP. Além disso, toda a informação passada será visível na URL, o que em muitas situações não é desejado.

Figura 4.9: O retorno da página formget.asp. É por isso que hoje, na maioria dos casos, utilizamos o método post, que não tem as mesmas limitações do método get. Algumas aplicações antigas, com alguns scripts CGI, podem ter sido desenvolvidos para usar o método get, neste caso os mesmos não funcionarão com o método post. No restante deste livro, estaremos utilizando o método post.

Alguns Campos que Merecem Considerações Especiais Um dos campos de formulários que merecem considerações especiais é o grupo de Check Box. Quando temos um grupo de Check Box, um ou mais itens do grupo podem ser selecionados. Neste caso precisamos determinar qual ou quais itens foram selecionados e qual o valor associado a cada um deles. Observe a Listagem 4.7.

189

Criando Sites Dinâmicos com ASP 3.0

Listagem 4.7 – Modificando o formulário formget.htm. 1

<HTML>

<HEAD>

<TITLE>Formulário para Cadastro de Clientes !! </TITLE>

</HEAD>

<BODY>

<P><STRONG>Formulário para Cadastro de Clientes:</STRONG></P>

<P>Digite os dados solicitados e clique no botão Enviar.</P>

<P>Cidade: <INPUT id=cidade maxLength=30 name=cidade></P>

<P>Cartão Crédito:

<INPUT id=cartao name=cartao type=radio value=“Visa”>Visa

<INPUT id=cartao name=cartao type=radio value=“Master Card”>Master Card

<INPUT id=cartao name=cartao type=radio value=“Outros”>Outros</P>

<P>

</P>

<P>

<INPUT id=estado name=estado type=checkbox value=SP>SP

<INPUT id=estado name=estado type=checkbox value=RJ>RJ

<INPUT id=estado name=estado type=checkbox value=RS>RS

<INPUT id=estado name=estado type=checkbox value=SC>SC

<INPUT id=estado name=estado type=checkbox value=PR>PR

</P>

</FORM>

</BODY>

</HTML>

190

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

Ao acessarmos o arquivo da Listagem 4.7, no Internet Explorer, obtemos o resultado indicado na Figura 4.10.

Figura 4.10: Um grupo de Check Box foi adicionado ao formulário. Ao clicar no botão Enviar receberemos os resultados indicados na Figura 4.11. Observe que a nossa página ASP formget.asp já processou corretamente os resultados. Um detalhe que devemos observar é que os valores associados a cada um dos Check Box marcados é o valor do atributo value. Se este atributo não tiver sido definido, será exibido On para cada um dos Check Box marcados. Observe, na Listagem 4.7, que o atributo name é o mesmo para todos os Check Box do grupo. É justamente isto que caracteriza um grupo de Check Box, todos possuem o mesmo valor para a propriedade name.

191

Criando Sites Dinâmicos com ASP 3.0

Figura 4.11: O resultado dos Check Box marcados já é exibido corretamente. Quando a página ASP recebe os dados, ela recebe os valores selecionados, todos no nome do grupo. Por exemplo o seguinte código: <% =Request.QueryString(“estado”)%>

produziria uma saída com o valor dos Check Box selecionados. Caso mais do que um Check Box tenha sido selecionado, os valores serão exibidos separados por vírgula, conforme indicado abaixo: SP, RS, PR

Com isso dizemos que o elemento estado, da coleção QueryString, possui valores múltiplos. Existem situações em que pode ser necessário acessar um destes valores individualmente. Isto é possível, pois cada um dos valores possui uma propriedade de índice associada. O primeiro valor selecionado possui índice 1, o segundo possui índice 2 e assim por diante.

192

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

IMPORTANTE No caso de um grupo de Check Box, os índices não são associados à ordem com que os Check Box são apresentados no formulário, mas sim em relação a quantos são selecionados. Se tivermos 2 Check Box selecionados, somente teremos o índice 1 e o índice 2. O índice 1 é ligado ao primeiro Check Box selecionado que aparece no formulário. O índice 2 é ligado ao próximo Check Box do grupo que aparecer selecionado, e assim por diante.

Caso quiséssemos acessar somente o valor do primeiro Check Box selecionado, utilizaríamos o seguinte código: <% =Request.QueryString(“estado”)(1) %>

Observe a utilização do índice (1) após o nome do campo. Com isso estou pedindo para que seja retornado apenas o valor do primeiro Check Box selecionado. Este código retornaria somente SP, no nosso exemplo.

NOTA Estas mesmas considerações são válidas para elementos do tipo Caixa de seleção e Caixa de combinação.

A Coleção ServerVariables do Objeto Request A coleção ServerVariables possui valores que são somente de leitura, isto é, não podemos modificar os valores desta coleção. São valores enviados através da requisição do navegador do cliente, dentro do cabeçalho do protocolo HTTP, e alguns valores existentes no servidor Web. Podemos acessar o valor de uma determinada variável utilizando a seguinte sintaxe: Request.ServerVariables(“Nome_da_Variável)

Por exemplo, o seguinte código retorna o número IP do computador do cliente: <%=Request.ServerVariables(“remote_addr”)%>

Na Tabela 4.1, temos uma descrição das principais variáveis disponíveis. Tabela 4.1 Variáveis de ambiente acessíveis através da coleção ServerVariables. Nome

Descrição

ALL_HTTP

Retorna todos os cabeçalhos HTTP enviados pelo cliente.

ALL_RAW

Captura todos os cabeçalhos, da maneira como foram enviados pelo cliente.

193

Criando Sites Dinâmicos com ASP 3.0

Nome

Descrição

AUTH_TYPE

Retorna o tipo de autenticação utilizado pelo servidor Web.

AUTH_USER

Retorna o nome do usuário autenticado no servidor Web.

CERT_COOKIE

Retorna um identificador único, ligado ao certificado do cliente.

CERT_FLAGS

Mostra se o certificado do cliente é válido.

PATH_INFO

Retorna informações sobre o caminho relativo à página que está sendo exibida.

PATH_TRANSLATED Retorna informações sobre o caminho físico (por exemplo: c:\inetpu\wwroot\page1.asp), relativo à página que está sendo exibida. QUERY_STRING

Retorna os valores de um formulário passados através do método get.

REMOTE_ADDR

Retorna o endereço IP da máquina do cliente.

REMOTE_HOST

Retorna o nome da máquina do cliente.

REQUEST_METHOD Retorna o método utilizado para a requisição da página: post ou get. SERVER_PORT

Retorna a porta TCP na qual a requisição foi feita. Por padrão, o servidor Web atende requisições na porta 80.

SERVER_PROTOCOL Retorna a versão e o nome do protocolo de requisição, por exemplo HTTP 1.1. SERVER_SOFTWARE Retorna o nome e a versão do servidor HTTP. URL

Retorna a porção básica da URL.

Na Listagem 4.8, utilizamos o laço For Each...Next, para exibir todos os valores contidos na coleção ServerVariables. Listagem 4.8 – Exibindo os valores contidos na coleção ServerVariables – variables.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

194

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

<BODY>

<%For Each Variavel in Request.ServerVariables %>

<TR>

<TD>

<% =Variavel %>

=</TD>

<TD>

<% =Request.ServerVariables(Variavel) %>

&nbsp;</TD></TR>

<%Next%>

</BODY>

</HTML>

Com este código simples conseguimos exibir todo o conteúdo da coleção ServerVariables. Observe, na Listagem 4.8, que utilizamos algumas tags HTML para a construção de tabelas. Estas tags foram utilizadas apenas para melhorar a aparência do documento resultante. Para cada variável exibimos o nome da variável (linha 10) e o valor contido na variável (linha 13). Na linha 14, utilizamos &nbsp. Este é um caractere especial para o HTML e é utilizado para que o navegador do cliente exiba as células da tabela, mesmo quando estas estiverem vazias. O Internet Explorer não exibe os contornos de uma célula, caso não exista nenhum conteúdo na mesma, o que torna o resultado final pouco elegante. Na Figura 4.12, podemos ver a parte final do resultado do processamento do documento variables.asp.

Figura 4.12: Exibindo o conteúdo da coleção ServerVariables.

195

Criando Sites Dinâmicos com ASP 3.0

Observe a variável SERVER_SOFTWARE, a qual exibe o valor Microsoft-IIS/5.0, indicando que esta página está armazenada em um servidor Windows 2000, com servidor Web IIS 5.0. Um pequeno exemplo prático: vamos supor que você deseja construir uma página que somente deve ser acessada por pessoas de uma determinada rede. Os computadores da Internet utilizam um protocolo chamado TCP/IP. Todo computador que faz parte da rede deve possuir um número IP, e não podem existir dois computadores com o mesmo número IP. O número IP é um número no seguinte formato: 10.200.120.135 162.233.140.72

São quatro números separados por um ponto. O valor máximo de cada número é 249, ou seja, não posso ter um endereço IP 10.300.210.143. O 300 é um valor inválido em termos de número IP. Parte do número IP identifica a rede a qual pertence o computador e outra parte identifica o número do computador dentro da rede. Esta fora do escopo deste livro uma discussão mais ampla sobre o protocolo TCP/IP, mas existem excelentes fontes de referência na Internet. Você pode começar pelos sites da CISCO (www.cisco.com) e 3COM (www.3com.com). Vamos supor que somente devem acessar a nossa página computadores cujo endereço IP começa com 10.204.123 (que é exatamente o número da rede que utilizo em minha casa), sendo que o quarto número não importa. Neste caso estamos admitindo que os três primeiros números identificam a rede (10.204.123) e o último número identifica o computador dentro da rede. Neste caso, quero construir uma página que somente permita acesso a computadores da rede 10.204.123. Vamos ver como se faz isto? O algoritmo que utilizaremos é o descrito a seguir. Utilizaremos a variável REMOTE_ADDR para capturar o número IP do computador que está tentando acessar a nossa página. Depois utilizaremos funções do VBScript para capturar apenas a parte do endereço da rede (três primeiros números), e comparo este valor com o valor 10.204.123. Caso o valor esteja OK, o acesso ao restante da página é liberado, caso contrário o usuário será direcionado para um outra página, a qual contém uma mensagem dizendo que o mesmo não tem permissão para acessar a página desejada. A código que implementa o nosso algoritmo é mostrado na Listagem 4.9. Listagem 4.9 – Um exemplo prático de uso da coleção ServerVariables – filtro.asp. 1

<%@ Language=VBScript %>

<HTML>

196

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

<HEAD>

</HEAD>

<BODY>

‘Captura o número IP do computador do Cliente

Dim ip_cliente

Dim num_rede

ip_cliente=Request.ServerVariables(“REMOTE_ADDR”)

‘ Utilizo a função Left para extrair apenas

‘ os 10 primeiros caracteres, os quais devem

‘ ser iguais a 10.204.123

num_rede=Left(ip_cliente,10)

‘ Agora comparo o número de rede do cliente com

‘ o número de rede permitido

If num_rede=“10.204.123" Then

Response.Write “<P>Parabéns !!!</P>”

Response.Write “<P>VOCÊ CONSEGUIU ACESSAR ESTA PÁGINA,<BR> PORQUE O SEU ”

Response.Write “COMPUTADOR<BR> FAZ PARTE DA REDE<BR>” %>

<%=num_rede%>

<% Response.Write “</P>” %>

<% Else

Response.Redirect(“erro.htm”)

End If

</BODY>

</HTML>

Ao acessar esta página de um computador que faz parte da rede 10.204.123, receberemos a página indicada na Figura 4.13.

197

Criando Sites Dinâmicos com ASP 3.0

Figura 4.13: Usuários da rede 10.204.123 têm permissão de acesso. Ao acessar esta página de um computador que não faz parte da rede 10.204.123, receberemos a mensagem de erro indicada na Figura 4.14.

Figura 4.14: Usuários fora da rede 10.204.123 não têm permissão de acesso.

198

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

NOTA Na linha 24 utilizamos o método Redirect do objeto Response (Response.Redirect) para redirecionar o usuário para uma outra página (erro.htm), caso o mesmo não fizesse parte da rede 10.204.123. Falaremos mais sobre o objetos Response e seus métodos ainda neste capítulo.

A Coleção Cookies do Objeto Request Esta coleção contém os valores de todos os Cookies enviados pelo navegador do cliente, juntamente com a requisição da página ASP. Conforme descrevemos anteriormente, Cookies são pequenos arquivos que são gravados no computador do usuário. A informação contida nestes Cookies, normalmente, é utilizada para o site poder identificar o usuário na próxima vez que for acessado. Quando o usuário acessa uma determinada página, o navegador envia, junto com a requisição da página, todos os Cookies relacionados com o site que está sendo acessado. Cada Cookie pode conter um ou mais valores, e podem existir um ou mais Cookies associados ao site acessado. Todos os valores de todos os Cookies são acessíveis através da coleção Cookies do objeto Request. Estes valores são somente para leitura, isto é, não podem ser modificados. Os Cookies são gravados utilizando o método Cookies do objeto Response. Veremos o objeto Response em mais detalhes ainda neste capítulo. A título de exemplo, vamos considerar a página da Listagem 4.10. Listagem 4.10 – Criando um Cookie no computador do usuário – CreateCookie.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<BODY>

<p>ESTA PÁGINA CRIA UM COOKIE CHAMADO TESTE_COOKIE</p>

Response.Cookies(“TESTE_COOKIE”)(“Nome”)= “Júlio Battisti”

Response.Cookies(“TESTE_COOKIE”)(“Cidade”)= “Boqueirão do Leão”

Response.Cookies(“TESTE_COOKIE”)(“Data”)= Date()

</BODY>

</HTML>

A página da Listagem 4.10 cria um Cookie chamado TESTE_COOKIE. Dentro deste Cookie são gravados três campos ou chaves, conforme indicado na Tabela 4.2.

199

Criando Sites Dinâmicos com ASP 3.0

Tabela 4.2 Valores gravados no Cookie TESTE_COOKIE. Campo/Chave

Valor

Nome

Júlio Battisti

Cidade

Boqueirão do Leão

Data

3/7/1999

Na Figura 4.15, temos o resultado do acesso à página da Listagem 4.10.

Figura 4.15: Criando um Cookie no computador do usuário. Observe que o endereço desta página, no nosso exemplo é: http://servidor/Capitulo4/ CreateCookie.asp. Conforme descrevemos anteriormente, o Cookie é associado com o domínio no qual reside a página. No nosso exemplo, todas as páginas que estiverem em http://servidor poderão acessar informações deste Cookie. Para acessar as informações do Cookie, podemos utilizar a coleção Cookies do objeto Request, conforme indicado na Listagem 4.11. Listagem 4.11 – Acessando os valores gravados no Cookie TESTE_COOKIE – getCookie.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

200

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

<BODY>

<B><FONT COLOR=BLUE> Seja bem vindo:

<%Response.Write Request.Cookies (“TESTE_COOKIE”)(“Nome”)& “<br>”%>

</FONT></B>

Response.Write “Valores presentes em Cookies” & “<br>”

Response.Write Request.Cookies (“TESTE_COOKIE”)(“Nome”)& “<br>”

Response.Write Request.Cookies (“TESTE_COOKIE”)(“Cidade”)& “<br>”

Response.Write Request.Cookies (“TESTE_COOKIE”)(“Data”)& “<br>”

</BODY>

</HTML>

Observe que a sintaxe para acessar os valores da coleção Cookie é a seguinte: Request.Cookies(“Nome_do_Cookie”) (“Nome_da_chave”)

Por exemplo, a linha de código: 11

Response.Write Request.Cookies (“TESTE_COOKIE”)(“Nome”)& “<br>”

acessa o valor da chave nome, do Cookie TESTE_COOKIE. Este valor é retornado para o navegador do cliente pelo método Write do objeto Response. Na Figura 4.16, temos o resultado do acesso à página da Listagem 4.11.

Figura 4.16: Acessando os valores, utilizando a coleção Cookies do objeto Request.

201

Criando Sites Dinâmicos com ASP 3.0

Também podemos utilizar a estrutura For Each...Next para percorrer todos os valores de um determinado Cookie, exibindo o nome das chaves e o valor associado à cada chave, conforme indicado na Listagem 4.12. Listagem 4.12 – Utilizando a estrutura For Each...Next, para acessar as chaves do Cookie TESTE_COOKIE – forCookie.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<BODY>

<I><B><FONT COLOR=RED><P>Valores de Cookies:</P></FONT></B></I>

For Each Chave in Request.Cookies(“TESTE_COOKIE”)

Response.Write Chave & “: ”

10 11

Response.Write Request.Cookies(“TESTE_COOKIE”)(Chave) & “<BR>” Next

</BODY>

</HTML>

Na Figura 4.17, temos o resultado do acesso à página da Listagem 4.12.

Figura 4.17: Utilizando a estrutura For Each...Next para acessar todas as chaves do Cookie TESTE_COOKIE.

202

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

A Coleção ClientCertificate do Objeto Request Com a necessidade de serem efetuadas operações seguras através da Internet, foi criada a tecnologia de Certificados Digitais. Um Certificado funciona como uma espécie de carteira de identidade do usuário ou do site que está sendo acessado, e pode conter diversas informações, tais como nome, e-mail, endereço, telefone, etc. Quando o usuário acessa uma determinada página, o navegador envia informações sobre seu Certificado Digital, caso possua um. Para acessar as informações sobre o Certificado Digital do Cliente, podemos utilizar a coleção ClientCertificate do objeto Request. A sintaxe para utilizarmos a coleção ClientCertificate é a seguinte: Request.ClientCertificate(Chave[Subchave])

Onde temos: ➥ Chave: É o nome do campo do certificado a ser acessado. Por exemplo, o campo ValidForm retorna a data a partir da qual o certificado é válido; o campo ValidUntil, determina a data de expiração do Certificado; e assim por diante. A código da linha abaixo irá exibir a data de expiração do Certificado do cliente: Response.Write “Seu Certificado expira em: ” Response.Write Request.ClientCertificate(“ValidUntil”)

Propriedade do Objeto Request O objeto Request apresenta uma única propriedade: TotalBytes. Esta propriedade informa o número total de bytes enviados pelo navegador do cliente. Esta informação está ligada a utilização do método post, para enviar as informações digitadas em um formulário. A sintaxe é bastante simples, conforme indicado no exemplo seguinte. total_bytes = Request.TotalBytes

Na Listagem 4.13 temos um exemplo da utilização da propriedade TotalBytes. Este exemplo é uma pequena modificação do exemplo da Listagem 4.4, onde incluímos código para informar quantos bytes foram enviados pela requisição do usuário (linhas 7 até 9). Listagem 4.13 – Utilizando a propriedade TotalBytes do objeto Request – TotalBytes.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<BODY>

<B><P>A sua requisição enviou o seguinte quantitativo de bytes para o servidor:</B></P>

203

Criando Sites Dinâmicos com ASP 3.0

Response.Write Request.TotalBytes

<H2> Você digitou os seguintes dados !!</H2>

For Each Item in Request.Form %>

<P>

<%=Item%>

<%=Request.Form(Item)%>

</P>

<% Next %>

<P><A href=“list4-2.htm”>Clique aqui para voltar ao formulário</A></P>

</BODY>

</HTML>

O código da linha 8 informa quantos bytes foram enviados pelo navegador do cliente.

Método do Objeto Request O objeto Request apresenta um único método: BinaryRead(quantidade_de_bytes). Este método é utilizado para capturar um determinado número de bytes, do total de bytes que foram enviados pela requisição do cliente, através do método post. O número de bytes a ser capturado é definido pelo parâmetro “quantidade_de_bytes”. Não podemos utilizar este método na mesma página ASP em que utilizamos Request.Form, ou utilizamos a coleção Request.Form, ou o método BinaryRead. A sintaxe para utilização deste método é a seguinte: tantos_bytes = Request.BinaryRead(tantos_bytes).

O exemplo abaixo coloca os 100 primeiros bytes enviados pelo cliente, na variável 100_bytes: 100_bytes = Request.BinaryRead(100)

Na Listagem 4.14 temos um exemplo onde tentamos utilizar a propriedade BinaryRead e a coleção Request.Form, na mesma página. Listagem 4.14 – Não podemos utilizar Request.BinaryRead e Request.Form na mesma página – BinaryRead.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

204

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

<BODY>

<P>Não podemos utilizar Request.BinaryRead e</P>

<P>Request.Form na mesma página!</P>

Dim vinte_bytes

vinte_bytes=Request.BinaryRead(20)

‘ Esta linha irá gerar um erro.

Nome=Request.Form(“Nome”)

</BODY>

</HTML>

Ao tentarmos acessar esta página, receberemos a mensagem de erro indicada na Figura 4.18.

Figura 4.18: Mensagem de erro. Com isso, encerramos o estudo do objeto Request. Vimos todos as coleções, propriedades e métodos do objeto Request, lembrando que o mesmo não possui nenhum evento. Com a utilização do objeto Request, podemos ter acesso a diversas informações enviadas pelo cliente, como por exemplo, informações enviadas através do preenchimento de um formulário.

205

Criando Sites Dinâmicos com ASP 3.0

No próximo item passaremos ao estudo do objeto Response. Os demais objetos do Modelo de Objetos do ASP 3.0 serão estudados em outros capítulos deste livro.

O Objeto Response Utilizamos o objeto Response para retornar o resultado do processamento de uma página ASP, para o navegador do cliente. Conforme descrito anteriormente, o resultado retornado é código HTML puro. Podemos utilizar o objeto Response para montar uma página de retorno, por exemplo, com os resultados de uma pesquisa em um banco de dados. Nos exemplos do final deste capítulo, teremos uma introdução ao acesso à bancos de dados, através de páginas ASP. Também podemos utilizar o objeto Response para gravar Cookies no computador do cliente. A partir de agora passaremos a estudar os principais métodos, coleções e propriedades do objeto Response. Analisaremos os diversos aspectos do objeto através da utilização de alguns exemplos práticos.

Coleção do Objeto Response O objeto Response possui uma única coleção: Cookies. Esta coleção é utilizada para gravar informações no equipamento do cliente. Estas informações são conhecidas como Cookies. Existem diversas aplicações práticas para os Cookies. Por exemplo, quando estamos fazendo compras em um site de Comércio Eletrônico, vamos escolhendo os itens a serem comprados. Quando selecionamos um determinado item, adicionamos o mesmo à lista de compras. Ao sairmos da página da lista de compras para selecionarmos mais itens, precisamos guardar a informação sobre os itens já selecionados, caso contrário esta informação será perdida e somente seria possível adquirir um item por vez. Muitos bancos de dados gravam a informação da lista de compras em um banco de dados no servidor e as informações sobre a identificação do usuário em um Cookie, na máquina do usuário. Com isso, quando o usuário volta à lista de compras, é identificado através da leitura das informações contidas no Cookie, as quais são utilizadas para pesquisar o banco de dados e exibir sua lista de compras. Outra abordagem seria gravar os itens da compra em um Cookie, e enviar estas informações para o servidor, somente quando o usuário finalizar a compra. As possibilidades são variadas, depende da necessidade de cada aplicação. Outro detalhe importante que devemos conhecer é quando o navegador envia para o servidor, um Cookie gravado no cliente. Cada Cookie está associado com um determinado domínio. Por exemplo, a primeira vez que você acessa o site http://www.abc.com, vamos supor que seja gravado um Cookie no seu computador. Toda vez que você acessar uma página no domínio www.abc.com, as informações contidas neste Cookie serão enviadas para o site, mesmo que a página que esteja sendo acessada não utilize estas informações. Quando você acessa, por

206

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

exemplo, a página: http://www.abc.com/cadastro/index.asp, as informações contidas no Cookie associado ao domínio www.abc.com serão enviadas para o servidor, mesmo que a página index.asp não utilize estas informações. Podemos ter mais do que um Cookie associado com um determinado domínio. Neste caso, todos os Cookies associados com o domínio serão enviados quando uma página deste domínio for acessada. A página que cria o Cookie também pode determinar a qual domínio o mesmo está relacionado, podendo inclusive precisar que o Cookie somente esteja relacionado com uma determinada área do site. Por exemplo, posso determinar que o Cookie somente seja enviado para o servidor quando forem acessadas páginas da seguinte área: http://www.abc.com/cadastro. Também podemos definir uma data de expiração para o Cookie. Vamos estudar estas possibilidades através de exemplos práticos. Na Listagem 4.15, temos um exemplo de criação de um Cookie chamado Cliente. Listagem 4.15 – Criando um Cookie associado ao domínio http://servidor – CriandoCookie.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<BODY>

<B>

<P>Esta página cria um Cookie associado ao domínio

http://servidor. Toda vez que uma página do domínio

http://servidor for acessada, as informações contidas

neste Cookie serão enviadas.

</B>

</P>

‘ Cria um Cookie chamado Cliente

Response.Cookies(“Cliente”)(“Nome”)= “Júlio Battisti”

Response.Cookies(“Cliente”)(“Endereco”)=“Boqueirão do Leão”

Response.Cookies(“Cliente”)(“Email”)=“juliobattisti@hotmail.com”

Response.Cookies(“Cliente”)(“Cartao”)=“ABC”

Response.Cookies(“Cliente”)(“Preferencial”)=“Sim”

207

Criando Sites Dinâmicos com ASP 3.0

O Cookie Cliente foi criado com sucesso. <br>

Foram adicionadas as seguintes informações:

</FONT></P>

‘ Exibe os valores gravados no Cookie Cliente.

For Each Chave in Request.Cookies(“Cliente”)

Response.Write Chave & “: ”

29 30

Response.Write Request.Cookies(“Cliente”)(Chave) & “<BR>” Next

</BODY>

</HTML>

Na Figura 4.19, temos o resultado do acesso à página da Listagem 4.15.

Figura 4.19: O Cookie Cliente foi gravado com sucesso. Conforme descrito anteriormente, podemos definir o domínio, ou uma área do site, ao qual o Cookie está associado, bem como a data para expiração. Para isso utilizamos os comandos abaixo indicados. Para definir o domínio ao qual o Cookie está associado: Response.Cookies(“Nome_do_Cookie”).domain=“URL do domínio” EX: Response.Cookies(“Cliente”).domain=“http://servidor”

208

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

Para associar o Cookie apenas com uma determinada área do site: Response.Cookies(“Nome_do_Cookie”).path=“caminho virtual” EX: Response.Cookies(“Cliente”).path=“/cadastro”

Assim, estou dizendo que o Cookie somente deve ser enviado quando o usuário acessar páginas que estão dentro do seguinte endereço: http://servidor/cadastro, como por exemplo: http:// servidor/cadastro/index.asp ou http://servidor/cadastro/carros.asp. Se você quiser que o Cookie seja enviado para qualquer página do site, utilize o seguinte comando: Response.Cookies(“Cliente”).path=“/”

Para definir uma data de expiração para o Cookie: Response.Cookie(“Nome_do_Cookie”).expires=#data# EX: Response.Cookie(“Cliente”).expires=#31/12/2000#

Neste exemplo, estou definindo a data de expiração do Cookie para 31 de Dezembro de 2000. Se não for definida uma data de expiração para o Cookie, o mesmo será eliminado quando o usuário fechar o navegador.

IMPORTANTE Em versões anteriores do ASP, o código para criar Cookies deveria ser colocado no cabeçalho do documento, antes da tag <BODY>. Isso era necessário, porque o Cookie deveria ser criado, antes que qualquer conteúdo fosse enviado para o navegador do cliente. Isso porque, nas versões anteriores do ASP, o conteúdo ia sendo enviado para o cliente à medida em que a página era processada. No ASP 3.0, o conteúdo somente é enviado quando toda a página foi processada com sucesso, ou quando for utilizado o comando Response.Flush. Este comportamento pode ser controlado através da habilitação ou não de “buffer” para a página, conforme veremos mais adiante neste capítulo.

Na Listagem 4.16, temos um exemplo definindo algumas características do Cookie Cliente2. Listagem 4.16 – Criando um Cookie Cliente2 – CriandoCliente2.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<BODY>

<B><P>Esta página cria um Cookie associado ao caminho

http://servidor/Capitulo4.

Toda vez que uma página do caminho

http://servidor/Capitulo4, ou um dos

209

Criando Sites Dinâmicos com ASP 3.0

seus subdiretórios, for acessada, as informações

contidas neste Cookie serão enviadas.

</B></P>

‘ Cria um Coockie chamado Cliente2

‘ E define algumas propriedades adicionais

Response.Cookies(“Cliente2”).domain=“http://servidor”

Response.Cookies(“Cliente2”).path=“/Capitulo4"

Response.Cookies(“Cliente2”).expires=#31/12/2000#

Response.Cookies(“Cliente2”)(“Nome”)= “Júlio Battisti”

Response.Cookies(“Cliente2”)(“Endereco”)=“Boqueirão do Leão”

Response.Cookies(“Cliente2”)(“Email”)=“juliobattisti@hotmail.com”

Response.Cookies(“Cliente2”)(“Cartao”)=“ABC”

Response.Cookies(“Cliente2”)(“Preferencial”)=“Sim”

O Cookie Cliente2 foi criado com sucesso. <br>

Foram adicionadas as seguintes informações:

</FONT></P>

For Each Chave in Request.Cookies(“Cliente”)

Response.Write Chave & “: ”

32 33

Response.Write Request.Cookies(“Cliente”)(Chave) & “<BR>” Next

</BODY>

</HTML>

Na Figura 4.20, temos o resultado do acesso à página da Listagem 4.20. O Cookie Cliente2 é um Cookie com múltiplos valores, isto é, temos armazenado diversos campos de informação, tais como: Nome, Endereço, Email, etc. Também podemos ter os chamados Cookies simples, os quais contém um único valor. O seguinte código cria um Cookie simples: Response.Cookies(“Cliente”)=“Júlio Battisti”

Nós podemos utilizar o atributo HasKeys, para determinar se um Cookie possui um único valor ou possui múltiplos valores. Considere a seguinte linha de código: Response.Write Response.Cookies(“Cliente2”).HasKeys

210

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

Figura 4.20: O Cookie Cliente2 foi gravado com sucesso. Caso o Cookie Cliente2 possua múltiplos valores, esta linha de código retorna Verdadeiro, caso contrário retorna Falso. Agora passaremos ao estudo das propriedades do objeto Response.

Propriedades do Objeto Response O objeto Response possui diversas propriedades, as quais são utilizadas para definir algumas características da comunicação entre o servidor Web e o navegador do cliente. A correta utilização destas propriedades permite um controle refinado sobre a maneira como as informações são enviadas do servidor Web para o navegador do cliente.

A Propriedade Buffer do Objeto Response Esta propriedade é do tipo Boolean, isto é, pode ser definida como Verdadeiro (True) ou Falso (False). Os comportamentos desta propriedade, de acordo com o seu valor, são os seguintes: ➥ Verdadeiro (True): Quando esta propriedade for definida como Verdadeiro, o servidor Web somente enviará conteúdo para o navegador do cliente depois que todo o código ASP da página for executado; isto é, à medida que a página for sendo processada, o

211

Criando Sites Dinâmicos com ASP 3.0

resultado do processamento é mantido em um Buffer do servidor Web. Após todo o código da página ter sido processado, o conteúdo do Buffer é enviado para o navegador do cliente. Este é o comportamento padrão no ASP 3.0. Também é possível enviar o conteúdo já processado para o navegador do cliente, a qualquer momento, utilizandose os métodos Response.Flush ou Response.End. Falaremos mais sobre estes dois métodos no próximo item. ➥ Falso (False): Quando a propriedade Buffer for definida como Falso, à medida em que a página for sendo processada, o conteúdo será enviado para o navegador do cliente; isto é, o conteúdo processado não fica armazenado em um Buffer no servidor Web. Esta propriedade deve ser definida antes que qualquer conteúdo tenha sido enviado para o navegador do cliente. O código da Listagem 4.17 mostra onde é o local mais indicado para definirmos esta propriedade. Listagem 4.17 – Definindo a propriedade Buffer do objeto Response. 1

<%@ Language=VBScript %>

<% Response.Buffer=False%>

<HTML>

<HEAD>

</HEAD>

<BODY>

<P>Documento com Buffer desabilitado</P>

</BODY>

</HTML>

Observe que devemos utilizar as expressões em inglês: True, para Verdadeiro, e False, para Falso. Também não devemos esquecer que, por padrão, no ASP 3.0, esta propriedade é definida como True. Em situações onde devemos efetuar algum processamento, tais como cálculos ou pesquisas em banco de dados, antes de enviar a página para o navegador do cliente é interessante mantermos a propriedade Buffer em seu valor padrão True. Em situações onde não sejam necessários processamentos deste tipo, podemos desabilitar o Buffer definindo esta propriedade como False.

A Propriedade CacheControl do Objeto Response Hoje em dia é muito comum a utilização de servidores Proxy para acesso a Internet. As diversas máquinas da Rede Local acessam a Internet através deste servidor. Com isso, é possível aumentar a segurança de mecanismos do próprio servidor. Uma das funções que o servidor Proxy pode executar é o Cache de páginas. Quando alguém acessa uma determinada página, uma cópia da mesma é gravada no Cache do servidor Proxy. O servidor armazena páginas HTML em Cache para que solicitações repetidas da mesma página possam ser retornadas

212

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

com rapidez e eficiência aos navegadores. Na próxima vez que alguém for acessar esta página, e a mesma estiver no Cache, não existe necessidade de carregar novamente a página da Internet. A cópia que está no Cache é enviada para o navegador do cliente. O uso de Cache no servidor Proxy agiliza o acesso, principalmente, às páginas mais utilizadas. Por padrão, o ASP instrui servidores Proxy a não armazenarem a própria página ASP em cache (embora imagens, mapas de imagens, miniaplicativos e outros itens aos quais a página faz referência sejam armazenados em Cache). Você pode permitir o armazenamento de determinadas páginas em Cache usando a propriedade Response.CacheControl. Com o uso da propriedade CacheControl podemos definir se uma página ASP deve ou não ser mantida no Cache do servidor Proxy. Este controle nos é oferecido devido à natureza dinâmica das páginas ASP, as quais mudam constantemente. Caso uma página tenha sido colocada no Cache do servidor Proxy, o usuário corre o risco de estar recebendo uma versão desatualizada da página. Esta propriedade deve ser definida antes que qualquer conteúdo tenha sido enviado para o navegador do cliente. O código da Listagem 4.18 mostra onde é o local mais indicado para definirmos esta propriedade. Listagem 4.18 – Definindo a propriedade CacheControl do objeto Response. 1

<%@ Language=VBScript %>

<% Response.CacheControl=“Public”%>

<HTML>

<HEAD>

</HEAD>

<BODY>

<P>Definindo a propriedade CacheControl do objeto Response.</P>

</BODY>

</HTML>

Esta propriedade pode assumir os seguintes valores: ➥ Public: Permite que a página ASP seja armazenada no Cache do servidor Proxy. ➥ Private: Faz com que a página ASP não seja armazenada no Cache do servidor Proxy.

A Propriedade CharSet do Objeto Response Quando o servidor envia informações para o cliente, antes de mandar o conteúdo da página propriamente dito, é enviado um cabeçalho (Header) de informações. Neste cabeçalho existem diversas definições importantes, tais como o tipo de conteúdo que está sendo enviado. Uma das informações contidas neste cabeçalho é qual o conjunto de caracteres a ser utilizado para exibir o conteúdo enviado. Para ter uma noção exata do que significa um conjunto de caracteres

213

Criando Sites Dinâmicos com ASP 3.0

basta observar as diferenças entre uma página desenvolvida para o idioma Português e outra para ser exibida no idioma Chinês ou Japonês. Esta propriedade deve ser definida antes que qualquer conteúdo tenha sido enviado para o navegador do cliente. O código da Listagem 4.19 mostra onde é o local mais indicado para definirmos esta propriedade. Listagem 4.19 – Definindo a propriedade Charset do objeto Response. 1

<%@ Language=VBScript %>

<% Response.Charset(“ISO-LATIN-1”)”%>

<HTML>

<HEAD>

</HEAD>

<BODY>

<P>Definindo a propriedade Charset do cabeçalho do documento.</P>

</BODY>

</HTML>

IMPORTANTE Todas as propriedades que alteram alguma característica do cabeçalho do documento devem ser definidas antes que qualquer conteúdo visível seja enviado para o navegador do cliente. Por isso, o local mais indicado para definir estas propriedades é antes da abertura da tag <BODY>, que é onde realmente começa o conteúdo que comporá a página a ser enviada.

A Propriedade ContentType do Objeto Response Esta propriedade define o tipo de conteúdo que será enviado para o cliente. Os tipos de conteúdo são definidos por um padrão conhecido como MIME-type. A propriedade ContentType informa ao navegador qual o tipo de conteúdo que o mesmo deverá receber. Apenas para exemplificar, vamos citar alguns dos tipos mais conhecidos: ➥ “text/html”: Define o arquivo como sendo do tipo texto, com conteúdo de código HTML. É o tipo padrão, isto é, se não for definido outro tipo, este será o utilizado. ➥ “image/gif”: O navegador espera receber um arquivo de imagem do tipo .gif. ➥ “image/jpg”: O navegador espera receber um arquivo de imagem do tipo .jpg. Esta propriedade deve ser definida antes que qualquer conteúdo tenha sido enviado para o navegador do cliente. O código da Listagem 4.20 mostra onde é o local mais indicado para definirmos esta propriedade.

214

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

Listagem 4.20 – Definindo a propriedade ContentType do objeto Response. 1

<%@ Language=VBScript %>

<% Response.ContentType = “text/html” %>

<HTML>

<HEAD>

</HEAD>

<BODY>

<P>Definindo a propriedade ContentType para o cabeçalho do documento.</P>

</BODY>

</HTML>

A Propriedade Expires do Objeto Response A propriedade Expires especifica o tempo decorrido antes que uma página armazenada no Cache de um navegador perca a validade. Se o usuário retornar para a mesma página antes dela expirar, a versão armazenada em Cache será exibida. A sintaxe para esta propriedade é a seguinte: Response.Expires=Número

onde Número é especificado em minutos. Quando a página .asp chama Response.Expires, o IIS cria um cabeçalho HTTP indicando a hora no servidor. Se a hora do sistema do cliente é anterior à hora do sistema do servidor (caso o cliente ou servidor não tenham uma configuração de hora precisa ou haja diferenças de fuso horário) a configuração do parâmetro como 0 não terá o efeito de expirar a página imediatamente. Você pode usar a propriedade Response.ExpiresAbsolute (veja próximo item) para obter a expiração imediata de uma página. Além disso, pode usar um número negativo para a propriedade Expires. Por exemplo: <% Response.Expires = -1 %>

expirará a resposta imediatamente.

NOTA Se existirem várias chamadas para Response.Expires em uma única página, o servidor usará o período de tempo mais curto.

Esta propriedade deve ser definida antes que qualquer conteúdo tenha sido enviado para o navegador do cliente. O código da Listagem 4.21 mostra onde é o local mais indicado para definirmos esta propriedade.

215

Criando Sites Dinâmicos com ASP 3.0

Listagem 4.21 – Definindo a propriedade Expires do objeto Response. 1

<%@ Language=VBScript %>

<% Response.Expires = 1440 %>

<HTML>

<HEAD>

</HEAD>

<BODY>

<P>Definindo a propriedade Expires para o cabeçalho do documento.</P>

</BODY>

</HTML>

Neste exemplo estou definindo em um dia (1.440 minutos) o tempo de expiração para a página. Para forçar uma nova requisição para o servidor Web, a cada solicitação da página, podemos utilizar o seguinte código: <% Response.Expires = 0 %>

Com isso a página expira imediatamente. Na próxima requisição do cliente, a página será novamente carregada a partir do servidor. Isto garante que sempre a última versão da página será enviada do servidor Web para o navegador do cliente.

A Propriedade ExpiresAbsolute do Objeto Response A propriedade ExpiresAbsolute especifica a data e a hora na qual uma página armazenada em Cache em um navegador expira. Se o usuário retornar para a mesma página antes dessa data e hora, a versão em Cache será exibida. Se uma hora não for especificada, a página expirará à meia-noite desse dia. Se uma data não for especificada, a página expirará na hora determinada no dia que o script for executado. A sintaxe para esta propriedade é a seguinte: Response.ExpiresAbsolute =#[data] [hora]#

NOTA Se essa propriedade for definida mais de uma vez em uma página, a data ou hora de expiração mais próxima à atual será usada. Se tentarmos definir a data de expiração como uma data que já passou, a data e hora atuais serão utilizadas como de expiração.

Esta propriedade deve ser definida antes que qualquer conteúdo tenha sido enviado para o navegador do cliente. O código da Listagem 4.22 mostra onde é o local mais indicado para definirmos esta propriedade.

216

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

Listagem 4.22 – Definindo a propriedade ExpiresAbsolute do objeto Response. 1

<%@ Language=VBScript %>

<% Response.ExpiresAbsolute=#May 29,2002 18:30:35# %>

<HTML>

<HEAD>

</HEAD>

<BODY>

<P>Definindo a propriedade ExpiresAbsolute para o cabeçalho do documento.</P>

</BODY>

</HTML>

NOTA Observe que a data e a hora devem estar entre os caracteres #.

A Propriedade IsClientConnected do Objeto Response A propriedade IsClientConnected é uma propriedade somente de leitura que indica se o cliente foi desconectado do servidor. A sintaxe para esta propriedade é a seguinte: Response.IsClientConnected ( )

IMPORTANTE Essa propriedade permite que você tenha um maior controle sobre as circunstâncias nas quais o cliente pode ter se desconectado do servidor. Por exemplo, se um longo período de tempo tiver decorrido entre o momento de uma solicitação do cliente e o momento em que o servidor respondeu, talvez seja benéfico garantir que o cliente ainda esteja conectado antes de continuar a processar o script.

Esta propriedade retorna True (Verdadeiro) ou False (Falso). Se o cliente continua conectado a propriedade retorna True, caso contrário retorna False. O código da Listagem 4.23 mostra um exemplo de utilização desta propriedade. Listagem 4.23 – Utilizando a propriedade IsClientConnected do objeto Response. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

217

Criando Sites Dinâmicos com ASP 3.0

<BODY>

<P>Exemplo de utilização da propriedade IsClientConnected.</P>

<% If Response.IsClientConnected( ) Then

Response.Write “O Cliente continua conectado.”

Else

Response.Write “O Cliente foi desconectado.”

End If

</BODY>

</HTML>

A Propriedade PICS do Objeto Response Um rótulo PICS – Platform for Internet Content Selection (Plataforma para Seleção de Conteúdo da Internet) é um rótulo que define uma página em termos do seu conteúdo, tais como: ➥ Infantil ➥ Sexo ➥ Violência Estes rótulos podem ser utilizados para classificar a informação da Internet. Os principais navegadores do mercado permitem que seja ativado um Supervisor de Conteúdo com a definição de uma senha. Para alterar as definições do Supervisor de Conteúdo, somente com o conhecimento da senha. Pais podem usar este Supervisor de Conteúdo para evitar que os filhos tenham acesso a sites com conteúdo de sexo explícito ou violência. A sintaxe para esta propriedade é a seguinte: Response.PICS(PICSLabel)

IMPORTANTE A propriedade PICS insere qualquer seqüência de caracteres no cabeçalho, independente dela representar ou não um rótulo PICS válido.

Exemplo: <% Response.PICS(“(PICS-1.1 <http://www.rsac.org/ratingv01.html> labels on ” & chr(34) & “1997.01.05T08:15-0500” & chr(34) & “ until” & chr(34) & “1999.12.31T23:590000” & chr(34) & “ ratings (v 0 s 0 l 0 n 0))”) %>

218

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

NOTA Para maiores informações sobre a Classificação de Conteúdo consulte os sites www.rsac.org ou os www.w3.org, ou o livro “Internet Explorer 5.0 – Resource Kit”.

A informação do cabeçalho PICS é enviada para o navegador do cliente. Com base na classificação da página e das configurações do navegador, o conteúdo da página pode não ser exibido, como no exemplo de pais que bloqueiam o acesso a sites de sexo.

A Propriedade Status do Objeto Response A propriedade Status define a mensagem que será enviada para o cliente, dentro do cabeçalho HTTP da resposta. Esta mensagem pode ser utilizada para indicar um erro ou o processamento com sucesso da requisição do usuário. Os valores de Status são definidos na especificação HTTP. A sintaxe para esta propriedade é a seguinte: Response.Status = DescriçãoDoStatus

Exemplo: <% Response.Status = “410 Unauthorized” %>

ou <% Response.Status = “404 Not Found” %>

Abaixo temos uma descrição das principais mensagens de status de erro: ➥ 400 Bad Request ➥ 410 Unauthorized – Login Failed ➥ 404 Not Found ➥ 414 Request – URL Too Long ➥ 500 Internal Server Error ➥ 501 Not Implemented Com isso encerramos o estudo das propriedades do objeto Response. Agora passaremos ao estudo dos métodos do objeto Response.

Métodos do Objeto Response O objeto Response possui diversos métodos, os quais permitem o controle sobre o conteúdo que será enviado para o cliente. Um método, conforme já descrito anteriormente, realiza uma

219

Criando Sites Dinâmicos com ASP 3.0

determinada ação. Por exemplo, já utilizamos inúmeras vezes o método Write do objeto Response. Este método é utilizado para enviar conteúdo do servidor Web para o navegador do cliente.

O Método AddHeader do Objeto Response O método AddHeader adiciona um cabeçalho HTML com um valor especificado. Esse método sempre adiciona um novo cabeçalho HTTP à resposta. Ele não substituirá um já existente de mesmo nome. Uma vez que um cabeçalho tenha sido adicionado, ele não poderá ser removido.

NOTA Este método é pouco utilizado, se outro método Response fornecer a funcionalidade necessária, é recomendável que você o utilize.

Como o protocolo HTTP requer que os cabeçalhos sejam enviados antes do conteúdo, em geral, você deve modificar todos os cabeçalhos enviados antes que seu script ASP gere alguma saída. No IIS 4.0, isso significava que era necessário chamar AddHeader no script antes que alguma saída (como aquela gerada pelo código HTML ou pelo método Write) fosse enviada ao cliente, normalmente antes da tag <BODY>. No IIS 5.0, com ASP 3.0, o Buffer é ativado por padrão, conforme descrito anteriormente. Portanto, você pode chamar o método AddHeader em qualquer ponto do script, desde que o Buffer não tenha sido desativado (Response.Buffer=False) e que ele preceda todas as chamadas para Flush. O código da Listagem 4.24 mostra um exemplo de utilização deste método. Listagem 4.24 – Utilizando o método AddHeader do objeto Response. 1

<%@ Language=VBScript %>

<% Response.AddHeader “AVISO IMPORTANTE” , “Servidor Indisponível” %>

<HTML>

<HEAD>

</HEAD>

<BODY>

<P>Exemplo de utilização do método AddHeader.</P>

</BODY>

</HTML>

O Método AppendToLog do Objeto Response Todo servidor Web mantém um arquivo de Log. Neste arquivo são gravadas diversas informações, tais como o número IP da máquina do cliente, a página que o mesmo está acessando, a hora de acesso, etc. Estas informações podem ser utilizadas para, por exemplo,

220

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

gerar estatísticas de acesso. No IIS 5.0 podemos configurar quais tipos de informação devem ser gravadas no Log. Além disso, temos o método AppendToLog, o qual adiciona uma seqüência de caracteres ao final da entrada de Log do servidor Web. Você pode chamá-lo várias vezes em uma seção do script. Cada vez que o método é chamado, ele anexa a seqüência de caracteres especificada à entrada existente. Este método utiliza a seguinte sintaxe: Response.AppendToLog seqüência de caracteres

O código da Listagem 4.25 mostra um exemplo de utilização deste método. Listagem 4.25 – Utilizando o método AppendToLog do objeto Response. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<BODY>

<P>Exemplo de utilização do método AppendToLog.</P>

7 8

<% Response.AppendToLog “Início da página.” %> <P>Conteúdo da Página.</P>

<% Response.AppendToLog “Final da página” %>

</BODY>

</HTML>

Este exemplo adiciona os textos “Início da página” e “Final da página” ao Log do IIS.

O Método BinaryWrite do Objeto Response O método BinaryWrite grava as informações especificadas na saída HTTP atual sem nenhum caractere de conversão. Esse método é útil para gravar informações que não são seqüências de caracteres como dados binários requeridos por um aplicativo personalizado, ou quando é preciso enviar qualquer tipo de dado que não seja do tipo text/html. Este método apresenta a seguinte sintaxe: Response.BinaryWrite dados

Considere o exemplo abaixo: <% Response.BinaryWrite dados_enviar %>

221

Criando Sites Dinâmicos com ASP 3.0

Onde dados_enviar pode ser um objeto que contém, por exemplo, um trecho de vídeo no formato .avi.

O Método Clear do Objeto Response O método Clear limpa todas as saídas HTML armazenadas no Buffer. No entanto, este método limpa apenas o conteúdo do corpo da resposta; ele não limpa os cabeçalhos. Utilizamos a seguinte sintaxe para o método Clear: Response.Clear

ou Response.Clear( )

IMPORTANTE Esse método causará um erro de tempo de execução se Response.Buffer não tiver sido definido para True, isto é, se não houver conteúdo no Buffer, a chamada ao método Response.Clear causará um erro.

O código da Listagem 4.26 mostra um exemplo de utilização deste método quando o Buffer está desabilitado, isto irá gerar a mensagem de erro indicada na Figura 4.21. Este erro é causado por termos desabilitado o Buffer (Response.Buffer=False) e mesmo assim tentar utilizar o método Response.Clear. Listagem 4.26 – Utilizando o método Response.Clear – ErroClear.asp. 1

<%@ Language=VBScript %>

<% Response.Buffer = False %>

<HTML>

<HEAD>

</HEAD>

<BODY>

<P>A próxima linha irá gerar um erro.</P>

<% Response.Clear %>

</BODY>

</HTML>

222

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

Figura 4.21: Erro causado pelo uso do método Response.Clear.

O método End do Objeto Response O método End faz com que o servidor Web páre o processamento do script e retorne o resultado atual. O conteúdo restante do arquivo não será processado. Utilizamos a seguinte sintaxe: Response.End

ou Response.End( )

Comentários Se Response.Buffer tiver sido definido para True (o que é o padrão no ASP 3.0), a chamada de Response.End liberará o Buffer. Se você não deseja que a saída retorne para o usuário, deve chamar primeiro Response.Clear, conforme indicado no exemplo abaixo: <% Response.Clear Response.End %>

223

Criando Sites Dinâmicos com ASP 3.0

O Método Flush do Objeto Response O método Flush envia, imediatamente, a saída armazenada no Buffer do servidor. Esse método causará um erro de tempo de execução se Response.Buffer tiver sido definido para False. Utilizamos a seguinte sintaxe: Response.Flush

ou Response.Flush( )

O código da Listagem 4.27 mostra um exemplo de utilização deste método quando o Buffer está desabilitado, isto irá gerar a mensagem de erro indicada na Figura 4.22. Este erro é causado por termos desabilitado o Buffer (Response.Buffer=False) e depois de desabilitá-lo tentamos utilizar o método Response.Flush.

Figura 4.22: Erro causado pelo uso do método Response.Flush. Listagem 4.27 – Utilizando o método Response.Flush – ErroFlush.asp. 1

<%@ Language=VBScript %>

<% Response.Buffer = False %>

<HTML>

<HEAD>

</HEAD>

224

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

<BODY>

<P>A próxima linha irá gerar um erro.</P>

<% Response.Flush( ) %>

</BODY>

</HTML>

O Método Redirect do Objeto Response O método Redirect faz com que o navegador tente acessar a página passada como parâmetro para o método. Por exemplo, podemos utilizar o método Redirect para carregar uma página personalizada, dependendo das opções que o usuário preencheu em um determinado formulário. A sintaxe para este método é a seguinte: Response.Redirect URL

Como exemplo, vamos supor que o usuário preencheu um formulário onde existe um campo chamado Destino. Este campo pode ter um dos seguintes valores: ➥ Brasil ➥ Canadá ➥ EUA ➥ Europa ➥ Outros Com base no valor selecionado neste campo, você deseja enviar o usuário para uma página personalizada para cada caso. Na listagem 4.28 temos um exemplo de código que soluciona o problema proposto. Listagem 4.28 – Utilizando o método Response.Redirect. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<BODY>

<P>Aguarde – Redirecionando...</P>

7 8

<% Vai_para = Request.Form(“Destino”)

Select Case Vai_para

Case “Brasil”

225

Criando Sites Dinâmicos com ASP 3.0

Response.Redirect “http://www.abc.com/brasil”

Case “Canadá”

Response.Redirect “http://www.abc.com/canada”

Case “EUA”

Response.Redirect “http://www.abc.com/eua”

Case “Europa”

Response.Redirect “http://www.abc.com/europa”

Case “Outros”

Response.Redirect “http://www.abc.com/outros”

End Select

</BODY>

</HTML>

O Método Write do Objeto Response Já utilizamos o método Write inúmeras vezes. Este método é utilizado para enviar uma seqüência de caracteres para a saída HTML, enviada para o navegador do cliente. Esta seqüência de caracteres pode ser texto comum, tags HTML, valor de variáveis calculadas pela página ASP ou até mesmo valores de campos de dados em um banco de dados. Em resumo, podemos dizer que o método Write é utilizado para montar a página HTML que retorna para o usuário. A sintaxe para o método é bastante simples: Response.Write Conteúdo

O seguinte exemplo envia texto para a saída HTML, que é enviada para o cliente: Response.Write “Bem vindos à tecnologia de Páginas Dinâmicas.”

No próximo exemplo, além do texto, enviamos uma tag HTML de quebra de linha: Response.Write “Utilização do método Write <BR>”

Assim, o seguinte conteúdo é enviado para o navegador do cliente: Utilização do método Write <BR>

O texto “Utilização do método Write” é exibido e a tag <BR> é reconhecida como sendo uma tag HTML que orienta o navegador a fazer uma quebra de linha. Com certeza este é o método que mais utilizaremos ao longo deste livro. Agora encerramos o estudo do objeto Response, do qual estudamos todos os métodos, propriedades e a coleção Cookies. A partir de então, passaremos a analisar alguns exemplos práticos de utilização do conteúdo visto até agora.

226

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

Alguns Exemplos Práticos de Aplicação Neste item veremos alguns exemplos práticos de aplicação do conteúdo visto até o momento. Serão propostos alguns problemas e, para resolvê-los, utilizaremos o conhecimento aprendido, com a utilização dos objetos ASP já apresentados, além de elementos da linguagem VBScript. Também precisaremos dos conhecimentos de HTML introduzidos no Capítulo 2.

Exemplo 1: Validação dos Dados de um Formulário Descrição do problema: vamos supor que tenhamos um formulário para cadastro dos nossos clientes em um banco de dados. Alguns campos deste formulário são de preenchimento obrigatório, isto é, não podem ficar em branco ou conter valores nulos. Caso o usuário deixe um ou mais destes campos sem preencher, devemos retornar o formulário para o cliente, indicando qual ou quais campos de preenchimento obrigatório não foram preenchidos. Ao voltar o formulário para o cliente, não podemos fazer com que ele tenha que preencher todos os campos novamente, mas somente os que estiverem faltando. Portanto, o formulário voltará para o cliente, mantendo os valores que ele já preencheu, apenas indicando quais campos obrigatórios não foram preenchidos.

NOTA Na prática os valores preenchidos no formulário deveriam ser armazenados em um banco de dados como o Microsoft SQL Server 7.0 ou o Microsoft Access 2000. Como ainda não aprendemos a trabalhar com banco de dados, vamos apenas validar os dados digitados. Caso o usuário tenha digitado todos os dados corretamente, apenas informaremos que os dados foram digitados com sucesso e exibiremos os valores. No próximo capítulo estaremos tratando sobre a conexão de páginas ASP com bancos de dados.

Na Listagem 4.29 temos o formulário que o usuário deverá preencher. Neste formulário, são de preenchimento obrigatório os seguintes campos: ➥ Nome ➥ Rua ➥ Cidade ➥ Bairro ➥ email ➥ CPF

227

Criando Sites Dinâmicos com ASP 3.0

Listagem 4.29 – Formulário para cadastro do cliente – exemplo-1.htm. 1

<HTML>

<HEAD>

<TITLE>Formulário para Cadastro de Clientes !!</TITLE>

</HEAD>

<BODY>

<P><STRONG>Formulário para Cadastro de Clientes:</STRONG></P>

<P>Digite os dados solicitados e clique no botão Enviar.</P>

<P>Cidade: <INPUT id=cidade maxLength=30 name=cidade>(*)

Bairro: <INPUT id=Bairro maxLength=20 name=Bairro></P>

<P>e-mail: <INPUT id=email maxLength=50 name=email>(*)

Fone:<INPUT id=fone maxLength=15 name=fone></P>

<P>CPF: <INPUT id=cpf maxLength=11 name=cpf>(*)

<FONT size=2><STRONG>(Digite sem o ponto e sem o traço)

</STRONG></FONT></P>

<P>Cartão Crédito:

<INPUT id=cartao name=cartao type=radio value=“Visa”>Visa

<INPUT id=cartao name=cartao type=radio value=“Master Card”>Master Card

<INPUT id=cartao name=cartao type=radio value=“Outros”>Outros

</P>

<BR>

(*)->Campos de digitação obrigatória.<BR></P>

</FORM>

</BODY>

</HTML>

Ao visualizarmos este formulário no Internet Explorer, obtemos o resultado mostrado na Figura 4.23. Observe, na linha 8, que o atributo action, da tag FORM é definido como exemplo-1.asp. Agora precisamos criar a página exemplo-1.asp, a qual vai processar os dados digitados no formulário quando o usuário clicar no botão Enviar. A página exemplo-1.asp deve verificar se todos os campos obrigatórios foram digitados. Em caso afirmativo a página informará os valores digitados pelo usuário, caso contrário, o formulário será enviado de volta, indicando quais os campos obrigatórios que não foram preenchidos. Além disso ao enviar o formulário de volta para o usuário, os valores digitados pelo usuário serão preservados, evitando que seja preciso digitar todos os campos novamente.

228

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

Figura 4.23: O formulário para cadastro de clientes. Existem diversas maneiras e algoritmos diferentes para solucionar este problema. Na Listagem 4.30 apresentamos uma solução para o problema proposto. Listagem 4.30 – Fazendo a validação dos dados obrigatórios – exemplo-1.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<BODY>

‘ Inicia a verificação para saber se todos

‘ os campos obrigatórios foram preenchidos.

‘ Atribui os campos obrigatórios à variáveis.

nome = Request.Form(“nome”)

rua = Request.Form(“rua”)

cidade = Request.Form(“cidade”)

229

Criando Sites Dinâmicos com ASP 3.0

email = Request.Form(“email”)

cpf = Request.Form(“CPF”)

‘Verifica se os campos obrigatórios foram preenchidos.

‘Qualquer dado obrigatório que não tenha sido preenchido,

‘definirá a variável faltou_dado em Sim.

If (nome=“”)Then

mensagem_nome=“Preencha o campo Nome:”

faltou_dado=“Sim”

faltou_nome=“Sim”

End If

If (rua=“”)Then

mensagem_rua=“Preencha o campo Rua:”

faltou_dado=“Sim”

faltou_rua=“Sim”

End If

If (cidade=“”)Then

mensagem_cidade=“Preencha o campo Cidade:”

faltou_dado=“Sim”

faltou_cidade=“Sim”

End If

If (email=“”)Then

mensagem_email=“Preencha o campo email:”

faltou_dado=“Sim”

faltou_email=“Sim”

End If

If (cpf=“”)Then

mensagem_cpf=“Preencha o campo CPF:”

faltou_dado=“Sim”

faltou_cpf=“Sim”

End If

‘Caso todos os campos obrigatórios tenham sido

‘preenchidos, apenas informo os valores digitados.

If faltou_dado<>“Sim” Then

230

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

Response.Write “<P>Você digitou os seguintes dados !</P>”

Response.Write “<HR>”

For Each Dado in Request.Form %>

<P>

<% =Dado %>

<%=Request.Form(Dado)%>

</P>

<%Next

End If

‘Caso algum dado obrigatório não tenha sido digitado

‘Envia o formulário de volta para o cliente,

‘preservando os valores que o mesmo já digitou.

‘Observe que utilizamos Response.Write para ir

‘recriando todo o formulário.

‘Também observe que o formulário é enviado de volta

‘na página exemplo-1.asp e que o atributo action

‘da tag FORM é definido como exemplo-1.asp, ou seja

‘a página exemplo-1.asp chama a si mesma após o

‘usuário clicar no botão Enviar.

‘Esta é uma técnica bastante interessante.

‘Antes de enviar o formulário, informamos quais

‘os campos obrigatório que não foram preenchidos.

If faltou_nome=“Sim” Then

Response.Write “O campo Nome deve ser preenchido. <BR>”

End If

If faltou_rua=“Sim” Then

Response.Write “O campo Rua deve ser preenchido. <BR>”

End If

If faltou_cidade=“Sim” Then

Response.Write “O campo Cidade deve ser preenchido. <BR>”

End If

If faltou_email=“Sim” Then

Response.Write “O campo email deve ser preenchido. <BR>”

231

Criando Sites Dinâmicos com ASP 3.0

End If

If faltou_cpf=“Sim” Then

Response.Write “O campo CPF deve ser preenchido. <BR>”

End If

‘Começo a reenviar o formulário para o usuário.

<P><B>Formulário para Cadastro de Clientes:</B></P>

<P>Digite os dados solicitados e clique no botão Enviar.</P>

<% Response.Write “Caso queira alterar algum dado, digite no formulário abaixo.”

If faltou_nome=“Sim” Then

Response.Write “<P>Nome: <INPUT id=nome maxLength=50 name=nome size=50>(*)</P>”

Else

Response.Write “<P>Nome: <INPUT id=nome maxLength=50 name=nome size=50 value=” & Chr(34)& Request.Form(“nome”) & Chr(34) & “>(*)</P>”

End If

If faltou_rua=“Sim” Then

Response.Write “<P>Rua: <INPUT id=rua maxLength=35 name=rua size=35> (*)</P>”

Else

Response.Write “<P>Rua: <INPUT id=rua maxLength=35 name=rua size=35 value=” & Chr(34)& Request.Form(“rua”) & Chr(34) & “>(*)</P>”

End If

100

If faltou_cidade=“Sim” Then

101

Response.Write “<P>Cidade: <INPUT id=cidade maxLength=30 name=cidade size=18>(*)”

102

Else

103

Response.Write “<P>Cidade: <INPUT id=cidade maxLength=30 name=cidade size=18 value=” & Chr(34) & Request.Form(“cidade”) & Chr(34) & “>(*)”

104

End If

232

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

105

Response.Write “Bairro:<INPUT id=bairro maxLength=25 name=bairro value=” & Chr(34) & Request.Form(“bairro”) & Chr(34) & “></P>”

106

If faltou_email=“Sim” Then

107

Response.Write “<P>Email: <INPUT id=email maxLength=35 name=email size=19>(*)</P>”

108

Else

109

Response.Write “<P>Email: <INPUT id=email maxLength=30 name=email size=19 value=” & Chr(34)& Request.Form(“email”) & Chr(34) & “>(*)”

110

End If

111

Response.Write “Fone:<INPUT id=fone maxLength=15 name=fone value=” & Chr(34) & Request.Form(“fone”) & Chr(34) & “></P>”

112

If faltou_cpf=“Sim” Then Response.Write “<P>CPF: <INPUT id=cpf maxLength=11 name=cpf size=11>(*)”

113

Else

114

Response.Write “<P>CPF: <INPUT id=cpf maxLength=11 name=cpf size=11 value=” & Chr(34)& Request.Form(“cpf”) & Chr(34) & “>(*)”

115 116

End If Response.Write “<FONT size=2><B>(Digite sem o ponto e sem o traço) </B></FONT></P>”

117

Response.Write “<P>Cartão Crédito: ”

118

If Request.Form(“cartao”)=“Visa” Then

119

Response.Write “<INPUT id=cartao name=cartao type=radio value=Visa checked>Visa”

120

Else

121

Response.Write “<INPUT id=cartao name=cartao type=radio value=Visa>Visa”

122

End If

121

If Request.Form(“cartao”)=“Master Card” Then

122

Response.Write “<INPUT id=cartao name=cartao type=radio value=” & Chr(34) & “Master Card” & Chr(34)& “ checked>Master Card”

123

Else

124

Response.Write “<INPUT id=cartao name=cartao type=radio value=” & Chr(34) & “Master Card” & Chr(34)& “ checked>Master Card”

125

End If

233

Criando Sites Dinâmicos com ASP 3.0

126

If Request.Form(“cartao”)=“Outros” Then

127

Response.Write “<INPUT id=cartao name=cartao type=radio value=Outros checked>Outros”

128

Else

129

Response.Write “<INPUT id=cartao name=cartao type=radio value= Outros>Outros</P>”

130

End If

131

Response.Write “<P><INPUT id=enviar name=enviar type=submit value=Enviar> ”

132

Response.Write “<INPUT id=limpar name=limpar type=reset value=Reset>”

133

Response.Write “<BR>”

134

Response.Write “(*)->Campos de digitação obrigatória.</P>”

135

‘Neste ponto encerro a montagem do formulário

136

137

</FORM>

138

</BODY>

139

</HTML>

Algumas observações sobre a Listagem 4.30: ➥ Linhas de código como a do seguinte exemplo: 111

Response.Write “Fone:<INPUT id=fone maxLength=15 name=fone

value=” & Chr(34) & Request.Form(“fone”) & Chr(34) & “></P>”

devem ser digitadas em uma única linha. A linha aparece dividida por questões de espaço para exibição, quando for digitar esta linha, digite-a como uma linha única. ➥ O exemplo foi desenvolvido de maneira que o código fosse de fácil compreensão, além disso foram inseridas diversas linhas de comentário para facilitar o acompanhamento do exemplo proposto. Cabe lembrar que, para criarmos uma linha de comentário, devemos iniciar a mesma com o sinal de apóstrofe. ➥ Observe o seguinte fragmento de código: 18

If (nome=“”)Then

mensagem_nome=“Preencha o campo Nome:”

faltou_dado=“Sim”

21 22

faltou_nome=“Sim” End If

Neste fragmento, estamos testando se o campo obrigatório “nome” foi preenchido. Caso o mesmo não tenha sido preenchido, definimos a variável faltou_dado como sendo igual a

234

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

Sim. Também definimos a variável faltou_nome como sendo igual a Sim. Este procedimento é repetido para os demais campos obrigatórios. Desta forma, qualquer campo obrigatório que esteja faltando, irá definir a variável faltou_dado como sendo igual a Sim. Estas variáveis serão utilizadas mais adiante para informar quais campos obrigatórios estão faltando, e caso nenhum esteja faltando, para informar os valores digitados pelo usuário. ➥ Observe o seguinte fragmento de código: 45

If faltou_dado<>“Sim” Then

Response.Write “<P>Você digitou os seguintes dados !</P>”

Response.Write “<HR>”

For Each Dado in Request.Form %>

<P>

<% =Dado %>

<%=Request.Form(Dado)%>

</P>

<%Next

End If

Neste fragmento, verificamos se não faltou nenhum dado (faltou_dado<>“Sim”), em caso afirmativo, simplesmente exibimos os dados digitados pelo usuário. Veja que utilizamos a estrutura For Each...Next para percorrer todos os valores do formulário. ➥ A partir da linha 69 começo a enviar mensagens, informando os campos de preenchimento obrigatório que não foram digitados. Considere o fragmento abaixo: 69

If faltou_nome=“Sim” Then

70 71

Response.Write “O campo Nome deve ser preenchido. <BR>” End If

Neste caso, se o campo nome não foi digitado, envio a seguinte mensagem: “O campo Nome deve ser preenchido.” ➥ A partir da linha 90: 90

If faltou_nome=“Sim” Then

verifico um a um os campos obrigatórios para ver qual ou quais estão faltando. Caso o campo esteja faltando, emito uma mensagem dizendo que o mesmo deve ser digitado, caso contrário crio o campo do formulário e defino o seu valor conforme digitado pelo usuário. Observe o fragmento de código abaixo: 90

If faltou_nome=“Sim” Then

Response.Write “<P>Nome: <INPUT id=nome maxLength=50 name=nome size=50>(*)</P>”

Else

235

Criando Sites Dinâmicos com ASP 3.0

93 94

Response.Write “<P>Nome: <INPUT id=nome maxLength=50 name=nome size=50 value=” & Chr(34)& Request.Form(“nome”) & Chr(34) & “>(*)</P>” End If

Primeiro (linha 90), testamos se o nome não foi digitado. Em caso afirmativo criamos o campo nome, em branco. Isto é feito pela linha 91: 91

Response.Write “<P>Nome: <INPUT id=nome maxLength=50 name=nome size=50>(*)</P>”

Esta linha envia o texto entre aspas para o navegador do cliente: <P>Nome: <INPUT id=nome maxLength=50 name=nome size=50>(*)</P>

E este é justamente o código HTML que cria o campo nome e define os seus atributos. Veja que estamos utilizando Response.Write para recriar o formulário HTML original. Caso o campo tenha sido preenchido, criamos o campo novamente com o cuidado de já preenchêlo com o valor digitado previamente pelo usuário. Isto é feito pelo código abaixo: 93

Response.Write “<P>Nome: <INPUT id=nome maxLength=50 name=nome size=50 value=” & Chr(34)& Request.Form(“nome”) & Chr(34) & “>(*)</P>”

Veja que esta instrução Response.Write é um pouco mais complexa. A instrução é formada por diversas partes, sendo que cada parte é concatenada pelo operador &. Na primeira parte é enviado o texto: “<P>Nome: <INPUT id=nome maxLength=50 name=nome size=50 value=

A segunda parte Chr(34) envia um sinal de aspas (“). Depois do sinal de aspas, usamos Request.Form(“nome”) para capturar o nome digitado pelo usuário. Vamos supor que o usuário tenha digitado José da Silva no campo nome. Neste ponto, o nosso comando estaria assim: “<P>Nome: <INPUT id=nome maxLength=50 name=nome size=50 value=“José da Silva

Depois enviamos mais um sinal de aspas, Chr(34), e a parte final “>(*)</P>”. Com isso o código enviado por este comando é o seguinte: “<P>Nome: <INPUT id=nome maxLength=50 name=nome size=50 value=”José da Silva”>(*)</P>

que é justamente o código HTML necessário para criar o campo Nome e definir o seu valor conforme o valor digitado pelo usuário. Um detalhe importante a salientar é a utilização do Chr(34) antes e depois do nome do usuário. Precisamos envolver o nome digitado entre aspas, pois caso contrário o nome seria truncado no primeiro espaço em branco. Se o usuário digitasse José da Silva, sem as aspas seria retornado apenas José. Tudo o que vier depois do primeiro espaço em branco será ignorado, por isso que utilizamos uma sinal de aspas antes e outro depois. Veja que com a utilização de código ASP vamos recriando o formulário original. Além disso mesclamos diversos trechos de código ASP com HTML. Perceba que dentro do código ASP podemos utilizar todos os recursos da linguagem VBScript, ou seja, as possibilidades são variadas.

236

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

Agora vamos a alguns exemplos de utilização da nossa aplicação. Na figura 4.24, temos um exemplo onde o formulário original foi aberto no Internet Explorer e o usuário preencheu todos os campos, isto é, não deixou de preencher nenhum campo obrigatório.

Figura 4.24: O usuário preencheu todos os campos. Ao clicar no botão Enviar os dados são enviados para a página exemplo-1.asp. Como todos os campos obrigatórios foram preenchidos, a página simplesmente exibe os valores digitados pelo usuário, conforme mostrado na Figura 4.25.

Figura 4.25: A página ASP informa os valores digitados.

237

Criando Sites Dinâmicos com ASP 3.0

Além de informar os valores digitados, a página retorna o formulário com os dados digitados pelo usuário. Caso o usuário queira alterar algum valor digitado é só fazer as alterações necessárias e clicar no botão Enviar. O formulário aparece abaixo da informação dos valores digitados, mais no final da página, conforme indicado na Figura 4.26.

Figura 4.26: O usuário pode alterar os valores digitados. Vamos testar uma outra situação do nosso aplicativo. Suponhamos que o usuário deixe de preencher um dos campos obrigatórios. No exemplo da Figura 4.27, o usuário não preenche o campo Cidade.

Figura 4.27: O usuário não preencheu um campo obrigatório.

238

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

Neste caso, ao clicar no botão Enviar, o usuário recebe uma página contendo uma mensagem que avisa que o campo Cidade é de preenchimento obrigatório, e contendo o formulário somente com o campo Cidade em branco para que o mesmo seja preenchido, conforme indicado pela Figura 4.28.

Figura 4.28: Formulário informando que o campo Cidade é obrigatório.

Exemplo 2: Formulário Para Cálculo de Imposto Descrição do problema: vamos supor que tenhamos um formulário para pedido de mercadorias. O usuário preenche o formulário com os produtos desejados e clica em um botão Calcular. Este botão chama uma página ASP que retorna o formulário de pedidos mais o valor do frete e do imposto, bem como o valor total do pedido. Vamos supor que, por motivos de simplicidade, somente são possíveis entregas para os estados do RS, PR, SC, SP e RJ. Sendo que o imposto e a taxa de frete é diferente para cada um destes estados. Tabela 4.3 Valores de frete e imposto para cada estado. Estado

Frete (R$)

Imposto (%)

3,50

4,50

239

Criando Sites Dinâmicos com ASP 3.0

Estado

Frete (R$)

Imposto (%)

4,20

5,50

O frete é único para o pedido, independente do número de itens. O imposto será calculado sobre o total da Nota, sem contar o valor do frete, isto é, sobre o valor total das mercadorias. O nosso pedido permitirá a entrada de até três produtos. Também faremos uso de tabelas para facilitar o layout da página. Na Listagem 4.31 temos o formulário de pedidos. Listagem 4.31 – Formulário de pedidos – exemplo-2.htm. 1

<HTML>

<HEAD>

<TITLE>Pedido de mercadorias.</TITLE>

</HEAD>

<BODY>

<P><B>FORMULÁRIO DE PEDIDOS:</B></P>

<P>Digite até três produtos a serem entregues.</P>

<P>

<TR>

<TD>Descrição</TD>

<TD>Quant.</TD>

<TD>Subtotal</TD>

</TR>

<TR>

240

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

</TR>

<TR>

</TR>

<TR>

</TR>

</TABLE>

<OPTION selected value=“”>Estado -></OPTION>

</SELECT>

</P>

</FORM>

</BODY>

</HTML>

Na Figura 4.29, podemos ver este formulário no Internet Explorer.

241

Criando Sites Dinâmicos com ASP 3.0

Figura 4.29: Formulário para preenchimento do pedido. Agora vamos criar a página ASP (exemplo2-asp) que faz o cálculo de cada item individualmente, depois calcula o total dos três itens e, finalmente, aplica o imposto e o frete de acordo com o estado selecionado pelo cliente. Após fazer os cálculos a página ASP retorna os valores fornecidos pelo usuário mais os cálculos realizados. Na Listagem 4.32 temos o código para a página – exemplo-2.asp. Sempre lembrando que procuramos desenvolver o código pensando na facilidade do entendimento. Diversas soluções diferentes poderiam ser adotadas, com a obtenção do mesmo resultado. Listagem 4.32 – A página ASP para cálculo do total do pedido. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<BODY>

Response.Write “<B>VALORES TOTAIS PARA O SEU PEDIDO:</B><BR>”

242

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

‘Crio uma variável para o subtotal de cada produto.

If Request.Form(“unit1”)<>“” Then

10 11 12

subtot1=CSng(Request.Form(“unit1”))*Csng(Request.Form(“quant1”)) Else subtot1=0

End If

If Request.Form(“unit2”)<>“” Then

15 16 17

subtot2=CSng(Request.Form(“unit2”))*Csng(Request.Form(“quant2”)) Else subtot2=0

End If

If Request.Form(“unit3”)<>“” Then

20 21 22

subtot3=CSng(Request.Form(“unit3”))*Csng(Request.Form(“quant3”)) Else subtot3=0

End If

total_inicial=subtot1+subtot2+subtot3

‘Agora acrescento o imposto e o frete com base no estado.

Select Case Request.Form(“estado”)

Case “RS”

total_imposto=total_inicial+total_inicial*0.12

total_geral=total_imposto+3.50

valor_frete=3.50

Case “SC”

total_imposto=total_inicial+total_inicial*0.13

total_geral=total_imposto+4.20

valor_frete=4.20

Case “PR”

total_imposto=total_inicial+total_inicial*0.11

total_geral=total_imposto+4.50

valor_frete=4.50

Case “SP”

243

Criando Sites Dinâmicos com ASP 3.0

total_imposto=total_inicial+total_inicial*0.17

total_geral=total_imposto+5.50

valor_frete=5.50

Case “RJ”

total_imposto=total_inicial+total_inicial*0.14

total_geral=total_imposto+5.50

valor_frete=5.50

End Select

‘A partir de agora começo a devolver a página

‘com os valores digitados pelo usuário, mais

‘os valores calculados.

<TR>

<TD>Descrição</TD>

<TD>Quant.</TD>

<TD>Subtotal</TD>

</TR>

<TR>

61 62

<TD><INPUT id=prod1 name=prod1 value=“ <%=Request.Form(“prod1”)%> ”></TD> <TD><INPUT id=unit1 name=unit1 value=“ <%=Request.Form(“unit1”)%>” style=“HEIGHT: 22px; WIDTH: 37px”></TD>

<TD><INPUT id=quant1 name=quant1 value=“<%=Request.Form(“quant1”)%>” style=“HEIGHT: 22px; WIDTH: 37px”></TD>

</TR>

<TR>

<TD><INPUT id=unit2 name=unit2 value=“ <%=Request.Form(“unit2”)%>” style=“HEIGHT: 22px; WIDTH: 37px”></TD>

244

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

<TD><INPUT id=quant2 name=quant2 value=“<%=Request.Form(“quant2”)%>”

style=“HEIGHT: 22px; WIDTH: 37px”></TD> 71 72

</TR> <TR>

<TD><INPUT id=unit3 name=unit3 value=“ <%=Request.Form(“unit3”)%>” style=“HEIGHT: 22px; WIDTH: 37px”></TD>

<TD><INPUT id=quant3 name=quant3 value=“<%=Request.Form(“quant3”)%>”

style=“HEIGHT: 22px; WIDTH: 37px”></TD> 77

</TR>

‘Agora monto uma linha para o total de produtos.

‘Uma linha para o valor do frete.

‘Uma linha para o valor do imposto.

‘Uma linha para o total geral.

<TR>

<TD>TOTAL PROD.->></TD>

</TR>

<TR>

<TD>IMPOSTO ->></TD>

</TR>

<TR>

<TD>FRETE ->></TD>

245

Criando Sites Dinâmicos com ASP 3.0

100

101 </TR> 102 <TR> 103

<TD>TOTAL GERAL ->></TD>

104

105

106

107 </TR> 108 </TABLE> 109 <A HREF=“exemplo-2.htm”>Clique aqui para voltar a página de Pedidos.</A> 110 </BODY> 111 </HTML>

Algumas observações sobre a Listagem 4.31: ➥ Linhas de código como a do seguinte exemplo: 74

<TD><INPUT id=unit3 name=unit3 value=“ <%=Request.Form(“unit3”)%>” style=“HEIGHT: 22px; WIDTH: 37px”></TD>

devem ser digitadas em uma única linha. A linha aparece dividida por questões de espaço para exibição; quando for digitá-la, digite-a como uma linha única. ➥ O exemplo foi desenvolvido de maneira que o código fosse de fácil compreensão, além disso foram inseridas diversas linhas de comentário para facilitar o acompanhamento do exemplo proposto. Cabe lembrar que para criarmos uma linha de comentário devemos iniciar a mesma com o sinal de apóstrofe. ➥ Observe que utilizamos diversos elementos da linguagem VBScript, tais como a estrutura Select Case...End Select, para calcular o imposto e o frete, com base no Estado selecionado pelo cliente. Utilizamos também a função Csng para converter os valores de Preço Unitário e Quantidade em valores numéricos, de tal forma que fosse possível realizar cálculos com estes valores. Utilizamos a função FormatNumber para formatar os valores calculados, de tal forma a exibir os valores com duas casas decimais, conforme mostrado no fragmento de código a seguir: <% =FormatNumber(valor_frete,2)%>

Agora vamos a um exemplo de utilização da nossa aplicação. Na figura 4.30, temos um exemplo onde o formulário de pedidos foi aberto no Internet Explorer e o usuário preencheu o pedido com três produtos. O estado selecionado foi SP.

246

Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0

Figura 4.30: Preenchendo os dados do pedido. Ao clicar no botão Calcular Total será chamada a página exemplo-2.asp, a qual faz os cálculos e exibe os resultados, conforme indicado na Figura 4.31.

Figura 4.31: Resultados calculados para o pedido.

247

Criando Sites Dinâmicos com ASP 3.0

Com isso comprovamos que a nossa página, para cálculo do Total do Pedido, está funcionando corretamente.

Conclusão Neste capítulo aprendemos aspectos fundamentais do ASP 3.0. Primeiro, aprendemos exatamente o que é uma página ASP, onde a mesma é processada e qual o resultado que retorna para o navegador do cliente. Depois tivemos uma visão geral sobre o Modelo de Objetos do ASP 3.0. Em seguida fizemos um estudo completo sobre os objetos Request e Response. Estudamos todas as coleções, métodos e propriedades destes objetos. Para cada elemento apresentado foram colocados exemplos de código, facilitando o entendimento. Na parte final do capítulo apresentamos dois exemplos mais elaborados, onde utilizamos diversos conceitos apresentados até o momento, tais como o conhecimento dos objetos Request e Response e da linguagem VBScript. Mas, para que nossos exemplos assumam um aspecto mais profissional, precisamos aprender a acessar bancos de dados a partir de páginas ASP. Este é o assunto do Capítulo 5. Então, vamos lá, sem mais demoras.

248

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

Capítulo 5 Conectando Páginas ASP com Bancos de Dados

249

Criando Sites Dinâmicos com ASP 3.0

Estamos vivendo na Era da Informação. Os aplicativos, quer sejam os tradicionais quer sejam aplicativos para a Web, são todos ligados à informações de bancos de dados. Quando você faz o cadastro em um site de Comércio Eletrônico, os dados fornecidos são armazenados em um banco de dados. Da próxima vez que você visitar o site, estas informações poderão ser recuperadas a partir deste banco de dados. Quando ligamos para a companhia telefônica para reclamar, o atendente pede que seja informado o nosso código de cliente. É através deste código que as informações sobre o cliente são recuperadas, a partir do banco de dados da empresa. Existem incontáveis exemplos de aplicações que usam bancos de dados, não importando se este está residente em um Mainframe ou em um servidor de Rede que roda um servidor de banco de Dados, como o Microsoft SQL Server 2000. Devemos salientar a importância e a necessidade da utilização de banco de dados para o armazenamento de um volume cada vez maior de informações, sendo que estas informações e sua correta utilização são de fundamental importância para a empresa. Durante muito tempo, os bancos de dados residiam em computadores de grande porte, os conhecidos Mainframe. Depois veio uma onda de descentralização, na qual a grande estrela eram as Redes Locais de microcomputadores, com bancos de dados em servidores de Rede. Esta foi a época da criação das aplicações em duas camadas, no tradicional modelo ClienteServidor. Com o avanço do modelo Web e da Internet, surgiu a necessidade do desenvolvimento de aplicações Web com conexão a banco de dados. Hoje esta necessidade está mais do que justificada: não existe aplicação Web que não faça conexão com bancos de dados. Desde um simples formulário para consulta ao CEP até aplicações mais complexas de cotação eletrônica de preços, todas necessitam de acesso a bancos de dados. Neste capítulo aprenderemos a utilizar a tecnologia ASP 3.0 para conectar nossas páginas com banco de dados. Iniciaremos por uma revisão de dois conceitos muito importantes: ➥ Modelo Relacional de dados. ➥ Linguagem SQL – Structured Query Language. Uma vez revistos estes conceitos partiremos para a conexão de páginas ASP com bancos de dados utilizando os objetos do ASP. Uma vez estabelecida a conexão aprenderemos a utilizar objetos do ASP que recuperam informações do banco de dados. Diversos exemplos práticos serão apresentadospara facilitar o entendimento dos conceitos apresentados. Também veremos como inserir informações em um Banco de dados, a partir de um formulário HTML. Para facilitar o acompanhamento dos exemplos apresentados, estaremos utilizando um banco de dados do Microsoft Access. Este capítulo fornece a base necessária para conectar páginas ASP com bancos de dados, além da revisão dos conceitos básicos relativos a bancos de dados e à linguagem SQL. No próximo capítulo estaremos abordando diversos aspectos avançados em relação a utilização de bancos de dados com páginas ASP.

250

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

Uma Revisão dos Conceitos Básicos de Banco de Dados Neste item iremos revisar alguns conceitos básicos sobre bancos de dados. Estes conceitos são importantes para o projeto, a criação e a correta utilização dos bancos de dados. Em muitas situações teremos que conectar nossas páginas ASP com bancos de dados já existentes, neste caso precisamos conhecer os conceitos aqui apresentados, para podermos otimizar sua utilização. Em outras situações teremos que criar o banco de dados a ser utilizado pela aplicação Web. Neste caso, os conceitos apresentados neste item auxiliam na criação de um banco de dados melhor estruturado e otimizado, tanto em termos de espaço de armazenamento, quanto da qualidade e disponibilidade das informações nele contidas. Revisaremos os seguintes conceitos: ➥ Entidades e Atributos. ➥ Chave Primária. ➥ Relacionamentos entre Entidades (Tabelas). ➥ Integridade Referencial. ➥ Normalização de Tabelas.

Entidades e Atributos Toda informação de um banco de dados é armazenada em Tabelas, que também são chamadas de Entidades. Por exemplo, poderíamos ter uma tabela “Clientes”, onde seriam armazenadas informações sobre os diversos clientes. Sobre cada um dos clientes poderíamos armazenar informações tais como: Nome, Rua, Bairro, Telefone, CEP, Data de Nascimento, etc. Essas diversas características de cada cliente são os “atributos” do cliente, muitas vezes chamados de Campos da entidade Cliente. O conjunto de todos os atributos de um cliente e os valores dos mesmos forma o Registro do cliente. Com isso teremos a tabela constituída por um conjunto de registros (uma linha completa com informações sobre o cliente) e cada registro formado por um conjunto de atributos (Nome, Endereço, etc.). Resumindo: ➥ Entidade ou Tabela – Conjunto de Registros. ➥ Campos ou Atributos – Características individuais da Entidade. Considere o exemplo da Figura 5.1, onde temos uma tabela Cliente com os seus diversos campos (atributos):

251

Criando Sites Dinâmicos com ASP 3.0

Figura 5.1: A entidade (tabela) Clientes e seus diversos atributos (campos). No exemplo da Figura 5.1, temos uma entidade – Clientes – e seus diversos atributos – Código do Cliente, Nome da Empresa, Nome do Contato, Cargo do Contato, Endereço, etc. Em cada linha temos um conjunto de atributos e seus valores. Cada linha forma um registro. Cada coluna é um atributo da tabela Clientes. Um dos grandes desafios em se projetar um banco de dados com sucesso é a correta determinação das entidades que existirão, bem como dos atributos de cada uma delas.

Chave Primária O conceito de Chave Primária é fundamental para o correto entendimento do funcionamento de um banco de dados. Vamos procurar entender o que significa um campo ser a chave primária de uma tabela. Ao definirmos um campo como sendo uma chave primária, estamos informando ao banco de dados que não podem existir dois registros com o mesmo valor de chave primária, ou seja, os valores neste campo precisam ser únicos. Por exemplo, se defino o campo Número da Identidade da tabela Clientes como sendo uma chave primária, estou dizendo ao banco de dados que não podem existir dois clientes com o mesmo valor neste campo. Na prática, estou garantindo que não podem ser cadastrados dois clientes com o mesmo Número de Identidade. Em outras palavras poderíamos dizer que o campo chave primária identifica de maneira única cada registro de uma tabela, isto é, de posse do valor da chave primária somente localizaremos um registro com determinado valor neste campo.

252

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

Este é um conceito muito importante, pois, conforme veremos mais adiante, os conceitos de Integridade Referencial e Normalização estão diretamente ligados ao conceito de chave primária. Na Figura 5.2 vemos um exemplo da tabela Clientes onde o campo Código do Cliente é definido como uma chave primária. Observe que não existem dois clientes com o mesmo código.

Figura 5.2: O campo Código do Cliente é uma chave primária. Um detalhe importante é que a chave primária pode ser formada pela combinação de mais de um campo. Podem existir casos em que um único campo não é capaz de atuar como chave primária, pelo fato do mesmo apresentar valores repetidos. Nestes casos podemos definir uma combinação de dois ou mais campos para ser a nossa chave primária. Lembre-se que uma tabela pode ter somente uma chave primária, seja ela simples ou composta.

Relacionamentos Entre Tabelas Na prática, em um banco de dados existem diversas tabelas, como por exemplo: Clientes, Produtos, Pedidos, Detalhes do Pedido, etc. Embora as informações estejam separadas em cada uma das tabelas, na prática devem existir relacionamentos entre elas. Por exemplo: um pedido é feito para um cliente e neste pedido podem existir diversos itens, os quais são armazenados na tabela Detalhes do Pedido. Além disso cada pedido tem um número único, e um mesmo cliente pode fazer diversos pedidos.

253

Criando Sites Dinâmicos com ASP 3.0

Em um banco de dados precisamos de uma maneira para representar estes relacionamentos, da vida real, em termos das tabelas e atributos. Isto é possível com a utilização de relacionamentos entre tabelas, os quais podem ser de três tipos: ➥ Um para Um ➥ Um para Vários ➥ Vários para Vários

Relacionamento do Tipo Um Para Um Esta relação existe quando os campos que se relacionam são ambos chaves primárias em suas respectivas tabelas. Cada um dos campos não apresenta valores repetidos. Na prática existem poucas situações onde utilizaremos um relacionamento deste tipo. Um exemplo poderia ser o seguinte: imagine uma escola com um cadastro de alunos na tabela Alunos. Apenas uma pequena parte deles participa da Banda da escola. Por questões de projeto do banco de dados, podemos optar por criar uma segunda tabela Alunos da Banda, a qual pode se relacionar com a tabela Alunos através de um relacionamento Um para Um. Cada aluno somente é cadastrado uma vez na tabela Alunos e uma única vez na tabela Alunos da Banda. Poderíamos utilizar o campo Matrícula do Aluno como o campo que relaciona as duas tabelas. Na tabela Alunos da Banda poderíamos colocar apenas o Número da Matrícula do aluno, além das informações a respeito do instrumento que ele toca, tempo de banda, etc. Quando for necessário buscar as informações tais como nome, endereço, etc., as mesmas podem ser recuperadas através do relacionamento existente entre as duas tabelas, evitando, com isso, que a mesma informação (Nome, Endereço, etc.) tenha que ser duplicada nas duas tabelas, o que diminui a probabilidade de erros de digitação. Na Figura 5.3 vemos o exemplo de um relacionamento do tipo Um para Um entre as tabelas Alunos e Alunos da Banda.

Figura 5.3: Um relacionamento do tipo Um para Um.

254

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

Relacionamento do Tipo Um Para Vários Este, com certeza, é o tipo de relacionamento mais comum entre duas tabelas. Uma das tabelas (o lado Um do relacionamento) possui um campo que é a chave primária e a outra tabela (o lado Vários) se relaciona através de um campo cujos valores relacionados podem se repetir várias vezes. Considere o exemplo entre a tabela Clientes e Pedidos. Cada Cliente somente é cadastrado uma única vez (por isso o campo Código do Cliente é uma chave primária, indicando que não podem existir dois clientes com o mesmo código); portanto a tabela Clientes será o lado Um do relacionamento. Porém cada cliente pode fazer diversos pedidos, por isso que o Código do Cliente poderá aparecer várias vezes na tabela Pedidos, tantas vezes quantos forem os pedidos que o cliente tiver feito. Por isso que temos um relacionamento do tipo Um para Vários entre a tabela Clientes e Pedidos, através do campo Código do Cliente, indicando que um mesmo cliente pode realizar diversos pedidos. Na Figura 5.4 vemos um exemplo de um relacionamento Um para Vários entre as tabelas Clientes e Pedidos, através do campo Código do Cliente.

Figura 5.4: Um relacionamento do tipo Um para Vários. No lado Um do relacionamento o campo é definido como uma chave primária (campo CódigoDoCliente na tabela Clientes) e no lado Vários não (campo CódigoDoCliente na tabela Pedidos), indicando que no lado Vários o Código do Cliente pode se repetir várias vezes, uma vez que um mesmo cliente pode fazer diversos pedidos.

Relacionamento do Tipo Vários para Vários Este tipo de relacionamento ocorre em uma situação onde, em ambos os lados do relacionamento, os valores poderiam se repetir. Vamos considerar o caso entre Produtos e Pedidos. Posso ter vários Pedidos nos quais aparece um determinado produto, além disso vários Produtos podem aparecer no mesmo Pedido. Esta é uma situação em que temos um relacionamento do tipo Vários para Vários: Vários produtos podem aparecer em Vários pedidos.

255

Criando Sites Dinâmicos com ASP 3.0

Na prática não temos como implementar um relacionamento deste tipo, devido a uma série de problemas que este procedimento implicaria. Por exemplo, na tabela Pedidos teríamos que repetir o Número do Pedido, Nome do Cliente, Nome do Funcionário, Data do Pedido, etc. para cada item do Pedido. Para evitar este tipo de problema é bastante comum quebrarmos um relacionamento do tipo Vários para Vários em dois relacionamento do tipo Um para Vários. Isso é feito através da criação de uma nova tabela, a qual fica com o lado Vários dos relacionamentos. No nosso exemplo poderíamos criar a tabela Detalhes do Pedido, onde ficam armazenadas as informações sobre os diversos itens de cada pedido. Então, ao invés de termos um relacionamento do tipo Vários para Vários, teremos dois relacionamentos do tipo Um para Vários, conforme indicado na Figura 5.5.

Figura 5.5: “Quebrando” um relacionamento Vários para Vários. Esta situação em que um relacionamento Vários para Vários é “quebrado” em dois relacionamentos do tipo Um para Vários é bastante comum. Diversas vezes utilizamos esta técnica para eliminar uma série de problemas no banco de dados, tais como informação repetida e inconsistência de dados. Agora que já conhecemos os tipos de relacionamentos existentes, no próximo item veremos o conceito de Integridade Referencial como uma maneira de garantir a consistência dos dados.

Integridade Referencial A Integridade Referencial é utilizada para garantir a integridade dos dados entre as tabelas relacionadas, evitando inconsistências dos dados, bem como repetições desnecessárias. Por exemplo, existe um relacionamento do tipo Um para Vários entre a tabela Clientes e a tabela Pedidos (um cliente pode fazer vários pedidos). Com a Integridade Referencial, o banco de dados não permite que seja cadastrado um pedido para um cliente ainda não cadastrado. Também podemos garantir o seguinte:

256

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

➥ Quando o código de um cliente for alterado na tabela Clientes, o banco de dados atualiza, automaticamente, todos os Códigos do Cliente na tabela Pedidos, de tal maneira que não fiquem registros órfãos, isto é, registros de Pedidos com um código de cliente que não existe mais na tabela Clientes. Esta ação é conhecida como “Propagar atualização dos campos relacionados”. ➥ Quando um cliente for excluído da tabela Clientes, podemos pedir para que o banco de dados exclua, na tabela Pedidos, todos os pedidos do cliente que está sendo excluído. Essa opção é conhecida como “Propagar exclusão dos registros relacionados” e pode ser habilitada ou não, dependendo da especificação do banco de dados. Caso seja necessário manter todo o histórico de compras do cliente, por exemplo, esta opção não deve ser habilitada. Com isso, quando o cliente for eliminado da tabela Clientes, os seus pedidos continuarão gravados na tabela Pedidos. Essas opções são definidas no momento da criação das tabelas e dos relacionamentos entre as tabelas do banco de dados. A opção de “Propagar atualização dos campos relacionados” é utilizada na maioria das situações, já a opção de “Propagar exclusão dos registros relacionados” deve ser estudada, caso a caso.

Normalização de Tabelas O conceito de Normalização foi criado no início da década de 70. O objetivo da Normalização é evitar os problemas provocados por falhas no projeto do banco de dados, bem como eliminar a mistura de assuntos e as correspondentes redundâncias de dados. Uma regra de ouro que devemos observar durante a elaboração do projeto de banco de dados é a de “Não misturar assuntos em uma mesma tabela”. Por exemplo na tabela Clientes devemos colocar somente campos relacionados com o assunto Clientes. Não devemos misturar campos relacionados com outros assuntos, tais como Pedidos, Produtos, etc. Essa “mistura de assuntos” em uma mesma tabela acaba por gerar repetição desnecessária dos dados bem como inconsistência dos mesmos. O processo de Normalização aplica uma série de regras sobre as entidades de um banco de dados, para verificar se as mesmas estão corretamente projetadas. Embora existam cinco Formas Normais (ou regras de Normalização), na prática usamos um conjunto de três Formas Normais. Com freqüência, após a aplicação das regras de Normalização, algumas tabelas acabam se dividindo em duas ou mais, o que no final gera um número maior de tabelas do que o originalmente existente. Este processo causa a simplificação dos atributos de uma tabela, colaborando para a estabilidade do modelo, reduzindo-se consideravelmente as necessidades de manutenção.

257

Criando Sites Dinâmicos com ASP 3.0

Vamos estudar e entender o processo de Normalização na prática, através de exemplos.

Primeira Forma Normal Uma tabela está na Primeira Forma Normal quando seus atributos não contém Grupos de Repetição. Por isso dizemos que uma tabela que possui Grupos de Repetição não está na Primeira Forma Normal. Considere a tabela indicada na Figura 5.6.

Figura 5.6: Uma tabela que não está na Primeira Forma Normal. Podemos notar que uma tabela com esta estrutura apresentaria diversos problemas. Por exemplo, se um casal tiver mais de um filho, teríamos que digitar o nome do pai e o nome da mãe diversas vezes, tantas quantas forem os filhos. Isso forma um Grupo de Repetição. Além do mais, pode ser que por erro de digitação o nome dos pais não seja digitado exatamente igual todas as vezes, o que pode acarretar problemas na hora de fazer pesquisas ou emitir relatórios. Este problema ocorre porque misturamos assuntos em uma mesma tabela. Colocamos as informações dos pais e dos filhos em uma mesma tabela. A resolução para este problema é simples: criamos uma tabela separada para a informação dos pais e relacionamos a tabela Pais com a tabela Filhos através de um relacionamento do tipo Um para Vários, ou seja, Um casal pode ter Vários filhos. Esta solução é indicada na Figura 5.7. As duas tabelas resultantes desse processo de Normalização, Pais e Filhos, estão na Primeira Forma Normal; a tabela original, a qual misturava informações de Pais e Filhos, não estava na Primeira Forma Normal.

258

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

Figura 5.7: As tabelas Pais e Filhos estão na Primeira Forma Normal.

Segunda Forma Normal Ocorre quando a chave primária é composta por mais de um campo. Neste caso, devemos observar se todos os campos que não fazem parte da chave primária dependem de todos os campos que a compõem. Se algum campo depender somente de parte da chave composta, então este campo deve pertencer a outra tabela. Observe o exemplo indicado na tabela da Figura 5.8.

Figura 5.8: Uma tabela que não está na Segunda Forma Normal. A chave primária composta é formada pela combinação dos campos NúmeroDaMatrícula e CódigoDoCurso. O campo Avaliação depende tanto do CódigoDoCurso quanto do NúmeroDaMatrícula, porém o campo DescriçãoDoCurso, depende apenas do CódigoDoCurso. Com isso temos um campo que não faz parte da chave primária e depende apenas de um dos campos que a compõem, por isso dizemos que esta tabela não está na Segunda Forma Normal. A resolução para este problema também é simples: dividimos a tabela, que não está na Segunda Forma Normal, em duas outras tabelas, conforme indicado pela Figura 5.9, sendo que as duas tabelas resultantes estão na Segunda Forma Normal.

259

Criando Sites Dinâmicos com ASP 3.0

Figura 5.9: Duas tabelas na Segunda Forma Normal.

NOTA A distinção entre a Segunda e a Terceira Formas Normais, que veremos no próximo item, muitas vezes é confusa. A Segunda Forma Normal, na maioria das vezes, está ligada a ocorrência de chaves primárias compostas.

Terceira Forma Normal Na definição dos campos de uma entidade podem ocorrer casos em que um campo não seja dependente diretamente da chave primária, ou de parte dela, mas sim dependente de um outro atributo constante na tabela e que não é a chave. Quando isto ocorre, dizemos que a tabela não está na Terceira Forma Normal, conforme indicado pela tabela da Figura 5.10.

Figura 5.10: Uma tabela que não está na Terceira Forma Normal. Observe que o campo DescriçãoDoCurso depende apenas do campo CódigoDoCurso, o qual não faz parte da chave primária. Por isso dizemos que esta tabela não está na Terceira Forma Normal. A solução para este caso também é simples. Novamente basta dividir a tabela em duas outras, conforme indicado pela Figura 5.11. As duas tabelas resultantes estão na Terceira Forma Normal.

260

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

Figura 5.11: Duas tabelas na Terceira Forma Normal.

IMPORTANTE Com isso podemos concluir que, como resultado do processo de Normalização, iremos obter um número maior de tabelas, porém sem problemas de redundância e inconsistência dos dados, ou com estes problemas minimizados.

Passos Para Projetar um Banco de Dados Neste item iremos apresentar os passos básicos para projetar um banco de dados. Aplicaremos os conhecimentos sobre Entidades, Atributos, Relacionamentos, Chave Primária e Normalização. Um banco de dados bem projetado fornece um acesso conveniente às informações desejadas. Com uma boa estrutura, gasta-se menos tempo na construção do banco de dados e, ao mesmo tempo, assegura-se resultados mais rápidos e precisos.

Etapas na Estruturação de um Banco de Dados ➥ Determinar qual o objetivo do banco de dados. Isto ajuda na determinação de quais os dados devem ser armazenados. ➥ Determinar as tabelas necessárias. Após definirmos o objetivo do banco de dados, as informações devem ser definidas e separadas em assuntos diferentes, tais como Clientes, Empregados, Pedidos, pois cada um irá compor uma tabela no banco de dados. ➥ Determinar os campos necessários em cada tabela. Definir quais informações devem ser mantidas em cada tabela. Por exemplo, a tabela Clientes poderia ter um campo para o Código do Cliente, outro para o Nome do Cliente e assim por diante. ➥ Determinar, em cada tabela, qual ou quais campos serão utilizados como chave primária. Esta é uma etapa importante para a definição dos relacionamentos que vem a seguir. ➥ Determinar os relacionamentos. Decidir como os dados de uma tabela se relacionam com os dados de outras tabelas. Por exemplo, clientes podem fazer vários pedidos. fornecedores podem fornecer vários produtos, etc.

261

Criando Sites Dinâmicos com ASP 3.0

➥ Refinar a estrutura do banco de dados. Antes de inserir muitos dados, ou até mesmo antes de inserir qualquer dado, verificar se a estrutura contém erros, isto é, verificar se os resultados obtidos são os desejados. Isto, freqüentemente, pode ser obtido através do processo de Normalização. Caso necessário, deve-se alterar a estrutura do banco de dados.

Dicas Para Determinação dos Campos em uma Tabela ➥ Relacionar diretamente cada campo ao assunto da tabela. Se um campo descreve o assunto de uma tabela diferente, este campo deve pertencer a outra tabela. O mesmo acontece quando uma informação se repete em diversas tabelas. Este é um indício de que existem campos desnecessários em algumas tabelas. ➥ Não incluir dados derivados ou calculados. Não é recomendado armazenar o resultado de cálculos nas tabelas. O correto é que o cálculo seja executado quando necessitarmos do resultado. ➥ Incluir todas as informações necessárias. Como é fácil esquecer informações importantes, deve-se ter em mente todas as informações coletadas desde o início do processo e verificar se com elas é possível obter todos os resultados desejados. ➥ Armazenar todas as informações separadamente. Existe uma tendência em armazenar informações em um único campo, por exemplo o nome do curso e o tempo de duração em um mesmo campo. Como as duas informações foram combinadas em um único campo, ficará difícil conseguir um relatório classificado pelo tempo de duração dos cursos, por exemplo.

Como Escolher o Campo que Será a Chave Primária? Um bom Sistema Gerenciador de Banco de Dados (SGBD) é aquele que encontra e nos fornece, rapidamente, todas as informações necessárias que nele estejam armazenadas, mesmo que em diferentes tabelas. Para que isto seja possível é necessário incluir um campo ou conjunto de campos que identifiquem de modo único cada registro de uma tabela. Esta informação é chamada Chave Primária, conforme descrito anteriormente. Deve-se ter certeza que este campo (ou conjunto de campos) seja sempre diferente para cada registro, por não ser permitido valores duplicados em um campo de chave primária. Ao escolher campos de chave primária, considere os seguintes detalhes: ➥ Não é permitido duplicidade de valores ou nulos (informações desconhecidas). Caso não exista um identificador único para uma determinada tabela, pode-se usar um campo que numere os registros seqüencialmente. ➥ Pode-se utilizar o valor deste campo para encontrar registros.

262

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

➥ O tamanho da chave primária afeta a velocidade das operações, portanto, para um melhor desempenho, devemos utilizar o menor tamanho que acomode os valores necessários para armazenar no campo.

Noções Básicas da Linguagem SQL – Structured Query Language Em diversas situações estaremos utilizando a linguagem SQL em nossas páginas ASP. Para recuperar dados, inserir novas informações ou, até mesmo, para atualizar informações em um banco de dados, estaremos utilizando a linguagem SQL. Por isso que é importante conhecermos os aspectos básicos desta linguagem, conforme veremos neste item.

Introdução Na Figura 5.12 temos um exemplo de uma instrução SQL. Embora possa parecer complexa, em um primeiro momento, veremos que a linguagem SQL é bastante simples e de fácil aprendizado.

Figura 5.12: Um exemplo de instrução SQL. Uma instrução SQL descreve o conjunto de dados que você deseja recuperar (campos, de quais tabelas, critérios, classificação, expressões calculadas, etc.). Todas as instruções SQL são conduzidas com um único comando que contém uma descrição completa da informação exigida. Ao escrever uma instrução SQL, você não deve se preocupar em como os dados são recuperados, mas somente com o conteúdo do conjunto de dados. Esse é o principal benefício do método SQL.

263

Criando Sites Dinâmicos com ASP 3.0

Lembre-se que o SQL é um padrão genérico para expressões de consulta em banco de dados. Embora a maior parte das versões do SQL compartilhe elementos básicos, elas não são idênticas. O Access SQL usa algumas palavras-chave que você não encontra em outras versões do SQL. Também existem pequenas diferenças entre o Microsoft Access e o Microsoft SQL Server, conforme iremos salientar durante este capítulo. Veremos através de exemplos a utilização das principais palavras-chave do SQL para a construção de expressões SQL para pesquisa em banco de dados.

A Instrução SELECT Esta é com certeza, a instrução SQL mais importante; não existe pesquisa que não utilize esta instrução. Agora vamos conhecê-la em detalhes. A instrução Select é utilizada para especificar quais os campos de quais tabelas farão parte da consulta, quais critérios de pesquisa serão utilizados, qual a ordem de classificação, etc. A sintaxe simplificada da instrução é conforme indicado abaixo: SELECT campo1, campo2, campo3 FROM nome_da_tabela [WHERE condição ] [GROUP BY nome_do_campo ] [HAVING ... ] [ORDER BY... ]

Na Tabela 5.1 temos uma descrição destes elementos. Tabela 5.1 Os principais elementos da instrução Select. Elemento

Descrição

campo1, campo2 ... campon

Nome dos campos a serem retornados a partir de uma ou mais tabelas.

nome_da_tabela

Nome da tabela a partir da qual os dados devem ser recuperados.

WHERE

Permite que sejam especificados critérios de pesquisa.

GROUP BY

Podemos agrupar os resultados em torno de um ou mais campos de dados.

264

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

Elemento

Descrição Por exemplo, em um relatório de vendas anuais, posso ter os resultados agrupados por mês, com a soma das vendas do mês logo após a listagem de vendas do mês.

HAVING

Especifica critérios para serem utilizados juntamente com Group By.

ORDER BY

Podemos ordenar os resultados obtidos com base em um ou mais campos de dados. Por exemplo, podemos ordenar uma listagem de vendas em ordem alfabética do nome do cliente ou do nome do vendedor.

Vamos analisar alguns exemplos práticos de utilização da linguagem SQL.

Exemplo 1 Criar uma instrução SQL que retorne o campo NúmeroDoPedido, o campo DataDoPedido, o campo Frete e o campo PaísDeDestino da tabela Pedidos. SELECT Pedidos.NúmeroDoPedido, Pedidos.DataDoPedido, Pedidos.PaísDeDestino, Pedidos.Frete FROM Pedidos;

Toda instrução SQL deve terminar com um ponto e vírgula (;), conforme indicado no Exemplo 1. Observe que os nomes dos campos estão separados por vírgula, além disso estamos utilizando o nome completo, isto é: Nome_da_tabela.Nome_do_campo. Também poderíamos utilizar o comando, sem o nome da tabela antes do nome do campo, conforme indicado no seguinte comando: SELECT NúmeroDoPedido, DataDoPedido, PaísDeDestino, Frete FROM Pedidos;

IMPORTANTE Somente é obrigatória a utilização do nome da tabela antes do nome do campo quando o mesmo campo existir em duas ou mais tabelas que fazem parte da instrução SQL. Por exemplo, imagine que estejamos escrevendo uma instrução SQL para criar uma listagem com o código e o nome do cliente, bem como todos os pedidos efetuados pelo cliente. Acontece que o Código do Cliente, no nosso exemplo, existe nas duas tabelas: Clientes e Pedidos. Neste caso devemos especificar o nome da tabela, antes do nome do campo.

265

Criando Sites Dinâmicos com ASP 3.0

Exemplo 2 Alterar a instrução SQL anterior para que os registros sejam classificados em ordem crescente pelo valor do Frete. SELECT NúmeroDoPedido, DataDoPedido, PaísDeDestino, Frete FROM Pedidos ORDER BY Frete;

Observe a utilização da cláusula “ORDER BY Frete” para classificar os registros em ordem crescente. A classificação em ordem crescente é a padrão . Quando formos classificar em ordem decrescente, precisamos especificar a palavra DESC, conforme indicado no seguinte comando: SELECT NúmeroDoPedido, DataDoPedido, PaísDeDestino, Frete FROM Pedidos ORDER BY Frete DESC;

Exemplo 3 Agora vamos começar a inserir condições. Muitas vezes as condições são chamadas de filtro; uma vez estabelecida uma condição, somente os registros que atendem a condição especificada serão retornados. Desta forma a condição atua como se fosse um filtro. Neste exemplo vamos alterar a instrução SQL anterior para que sejam exibidos somente os pedidos cujo PaísDeDestino seja Brasil. SELECT NúmeroDoPedido, DataDoPedido, PaísDeDestino, Frete FROM Pedidos WHERE PaísDeDestino=“Brasil” ORDER BY Frete;

Observe a utilização da cláusula WHERE para filtrar somente os pedidos cujo PaísDeDestino seja Brasil. Como o campo PaísDeDestino é um campo do tipo texto, o valor do critério (Brasil) tem que vir entre aspas. Se fosse um campo do tipo data, o valor do critério teria que vir delimitado pelo sinal #, por exemplo #01/01/1995#. Vamos trabalhar um pouco mais com a cláusula WHERE.

Exemplo 4 Altere a instrução SQL anterior para que sejam exibidos somente os pedidos para o Brasil ou Alemanha como PaísDeDestino. SELECT NúmeroDoPedido, DataDoPedido, PaísDeDestino, Frete FROM Pedidos WHERE (((Pedidos.PaísDeDestino)=“Brasil” Or (Pedidos.PaísDeDestino)=”Alemanha”)) ORDER BY Frete;

Observe a utilização da cláusula OR ligando os dois critérios. Lembre que a cláusula OR retorna um registro se o PaísDeDestino atender a um dos dois critérios, ou seja, se for Brasil ou se for Alemanha, o registro será selecionado, isto é exatamente o que desejamos: todos os pedidos para o Brasil ou para a Alemanha.

266

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

Exemplo 5 Altere a instrução SQL anterior, retirando o critério para PaísDeDestino. Adicione um critério para NúmeroDoPedido maior do que 10500, retire a classificação do campo Frete a classifique pelo campo NúmeroDoPedido. SELECT NúmeroDoPedido, DataDoPedido, PaísDeDestino, Frete FROM Pedidos WHERE NúmeroDoPedido>10500 ORDER BY NúmeroDoPedido;

Observe a cláusula WHERE utilizando o operador de comparação maior do que (>) e a classificação através da cláusula ORDER BY no campo NúmeroDoPedido. Podemos ver, através dos exemplos, que a linguagem SQL não é tão difícil como pode parecer à primeira vista. Observe que a sintaxe da linguagem é bastante intuitiva e orientada a extração de dados através das consultas. Vamos continuar analisando alguns exemplos de aplicação da linguagem SQL com a utilização de recursos mais avançados.

Exemplo 6 Alterar a instrução SQL anterior, e adicionar um critério de tal maneira que somente sejam exibidos os pedidos para o ano de 1995. Tirar o critério do campo NúmeroDoPedido. SELECT NúmeroDoPedido, DataDoPedido, PaísDeDestino, Frete FROM Pedidos WHERE ((Year([DataDoPedido])=1995)) ORDER BY NúmeroDoPedido;

Observe a utilização da função Year (Ano) para extrairmos apenas o ano do campo DataDoPedido a fim de especificarmos como critério o Ano=1995. Também a cláusula ORDER BY foi mantida, classificando a listagem em ordem crescente pelo número do pedido. A utilização de funções junto com os comando SQL nos fornece inúmeras possibilidades de refinamento em nossas consultas.

Exemplo 7 Alterar a instrução SQL anterior, para que sejam exibidos somente os pedidos no período de 01/ 01/1995 até 31/07/1995 e que tenham como PaísDeDestino Brasil, Argentina, Alemanha ou Canadá. SELECT NúmeroDoPedido, DataDoPedido, PaísDeDestino, Frete FROM Pedidos WHERE (((DataDoPedido) Between #1/1/95# And #8/31/95#) AND ((PaísDeDestino) In (“Brasil”,“Argentina”,“Alemanha”,”Canadá”))) ORDER BY Pedidos.NúmeroDoPedido;

267

Criando Sites Dinâmicos com ASP 3.0

Observe a utilização de vários critérios em diferentes campos. Colocamos critérios nos campos DataDoPedido e PaísDeDestino. Os critérios de dois ou mais campos são ligados através do operador AND, indicando que um registro deve atender ambos os critérios para ser selecionado. Também temos a utilização dos operadores Between (Entre) para selecionar as datas dentre um determinado intervalo e do operador In (Em) para selecionar o campo PaísDeDestino que seja igual a um dos valores apresentados na lista. Observe também que os valores de data vem delimitados pelos marcadores #, conforme descrito anteriormente. A utilização dos parênteses visa facilitar o entendimento da instrução e facilitar a avaliação da expressão.

IMPORTANTE Algumas destas funcionalidades podem necessitar de pequenas alterações para funcionar em nossas páginas ASP, conforme veremos mais adiante neste capítulo.

Exemplo 8 Criar uma instrução SQL que retorne os campos NúmeroDoPedido, DataDoPedido, DataDeEntrega, Frete e PaísDeDestino da tabela Pedidos. Criar uma coluna adicional que calcula o número de dias entre a DataDeEntrega e a DataDoPedido. Chamar esta coluna de Dias_Ped_Entr. SELECT NúmeroDoPedido, DataDoPedido, DataDeEntrega, PaísDeDestino, Frete, [DataDeEntrega]-[DataDoPedido] AS Dias_Ped_Entr FROM Pedidos WHERE (((DataDoPedido) Between #1/1/95# And #8/31/95#) AND ((PaísDeDestino) In (“Brasil”,“Argentina”,“Alemanha”,“Canadá”))) ORDER BY Pedidos.NúmeroDoPedido;

Veja que a coluna calculada [DataDeEntrega]-[DataDoPedido] está junto com a listagem dos campos no início da instrução SELECT. Além disso foi utilizada a palavra AS para atribuir um nome (apelido) para esta coluna calculada. Este nome é o que será utilizado para fazer referência à coluna, no nosso código ASP. Você também pode classificar a listagem em ordem crescente ou decrescente de um campo calculado. Por exemplo, se você quisesse classificar a listagem do item anterior, em ordem crescente, do número de dias entre a DataDeEntrega e a DataDoPedido, bastaria utilizar a seguinte instrução SQL: SELECT NúmeroDoPedido, DataDoPedido, DataDeEntrega, PaísDeDestino, Frete, [DataDeEntrega]-[DataDoPedido] AS Dias_Ped_Entr FROM Pedidos WHERE (((DataDoPedido) Between #1/1/95# And #8/31/95#) AND ((PaísDeDestino) In (“Brasil”,“Argentina”,“Alemanha”,“Canadá”))) ORDER BY [DataDeEntrega]-[DataDoPedido];

268

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

Exemplo 9 Alterar a instrução SQL anterior, eliminando os critérios para a DataDoPedido e para o PaísDeDestino. Colocar um novo critério para PaísDeDestino, onde sejam exibidos apenas os pedidos cujo PaísDeDestino tem a primeira letra na faixa de A até M. Utilize o operador Like. SELECT NúmeroDoPedido, DataDoPedido, DataDeEntrega, PaísDeDestino, Frete, [DataDeEntrega]-[DataDoPedido] AS Dias_Ped_Entr FROM Pedidos WHERE ((PaísDeDestino) Like “[A-M]%”)) ORDER BY PaísDeDestino;

Observe a utilização do operador Like (Como) como critério de pesquisa para esta consulta. Nunca é demais salientar que a utilização das instruções SQL juntamente com as funções de operadores como o Like, nos fornece um amplo conjunto de possibilidades. O caractere % é utilizado como um caractere curinga. Por exemplo, se especificarmos o seguinte critério: WHERE NomeDoCliente Like “João%”

serão retornados todos os registros para Clientes cujo nome inicia com João. O caractere curinga % significa, em termos simples, “qualquer coisa”, ou seja, o critério especifica que o nome inicie com João, não importando (qualquer coisa) o que vier depois.

IMPORTANTE Aqui cabe um aviso importante para os usuários do Microsoft Access. No Microsoft Access, o caractere curinga é o *, já na construção de páginas ASP, utilizamos como caractere curinga o %, o qual também é utilizado no Microsoft SQL Server.

Até agora estivemos trabalhando com instruções que selecionam registros de uma única tabela. Porém é bastante comum criarmos instruções SQL baseadas em duas ou mais tabelas. Quando criamos instruções SQL que buscam dados em duas ou mais tabelas, dizemos que está sendo feito um “Join” entre as duas tabelas. Normalmente este Join (ou ligação) é feito através de um campo comum às duas tabelas. Por exemplo, NúmeroDoPedido na tabela Pedidos e NúmeroDoPedido na tabela Detalhes do Pedido. Outro exemplo, CódigoDoCliente na tabela Pedidos e CódigoDoCliente na tabela Clientes. Pode acontecer de termos consultas que trabalham com três ou mais tabelas, neste caso teremos diversos Joins. Agora passaremos e explorar na prática, através de exemplos, a construção de instruções SQL que trabalham com duas ou mais tabelas.

269

Criando Sites Dinâmicos com ASP 3.0

Exemplo 10 Criar uma instrução SQL que selecione os seguintes campos: ➥ NúmeroDoPedido da tabela Pedidos. ➥ DataDoPedido da tabela Pedidos. ➥ PaísDeDestino da tabela Pedidos. ➥ Frete da tabela Pedidos. ➥ CódigoDoProduto, PreçoUnitário e quantidade da tabela DetalhesdoPedido. Além disso, as tabelas Pedidos e DetalhesdoPedido estão relacionadas através do campo NúmeroDoPedido, através de um relacionamento do tipo Um para Vários. Classificar a listagem em ordem crescente do NúmeroDoPedido. Para resolver este exemplo podemos utilizar a seguinte instrução SQL: SELECT Pedidos.NúmeroDoPedido, Pedidos.DataDoPedido, Pedidos.PaísDeDestino, Pedidos.Frete, DetalhesdoPedido.CódigoDoProduto, DetalhesdoPedido.PreçoUnitário, DetalhesdoPedido.Quantidade FROM Pedidos INNER JOIN DetalhesdoPedido ON Pedidos.NúmeroDoPedido=DetalhesdoPedido.NúmeroDoPedido ORDER BY Pedidos.NúmeroDoPedido;

Primeiro devemos observar que, pelo fato de estarmos tratando com dados de duas tabelas, estamos utilizando a nomenclatura completa, isto é, Nome_da_tabela.Nome_do_campo. Observe a utilização da cláusula INNER JOIN, ligando as tabelas Pedidos e DetalhesdoPedido, através do campo NúmeroDoPedido, conforme especificado na cláusula ON, onde temos o seguinte: ON Pedidos.NúmeroDoPedido=DetalhesdoPedido.NúmeroDoPedido

Observe que esta listagem irá trazer vários registros para cada pedido, tantos quantos forem os itens de cada pedido. E se, ao invés do CódigoDoProduto, nós quisermos que seja exibida a descrição do produto? Em primeiro lugar, esta informação encontra-se na tabela Produtos, logo teremos que adicionar a tabela à nossa consulta, a qual irá se ligar à tabela DetalhesDoPedido através do campo CódigoDoProduto. Logo, teremos mais um Join. Após adicionar a tabela Produtos e substituir o campo CódigoDoProduto pelo campo NomeDoProduto, a nossa instrução SQL deve ficar conforme indicado no seguinte comando: SELECT Pedidos.NúmeroDoPedido, Pedidos.DataDoPedido, Pedidos.PaísDeDestino, Pedidos. Frete, Produtos.NomeDoProduto, DetalhesdoPedido.PreçoUnitário, DetalhesdoPedido.Quantidade

270

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

FROM Produtos INNER JOIN (Pedidos INNER JOIN DetalhesdoPedido ON Pedidos.NúmeroDoPedido=Detalhesdo Pedido.NúmeroDoPedido) ON Produtos.CódigoDoProduto=DetalhesdoPedido.CódigoDoProduto ORDER BY Pedidos.NúmeroDoPedido;

Observe que neste caso temos um INNER JOIN dentro do outro. Dentro do parênteses é feita a ligação entre as tabelas Pedidos e DetalhesdoPedido, através do campo NúmeroDoPedido, e externamente é feita a ligação entre as tabelas Produtos e DetalhesdoPedido, através do campo NúmeroDoPedido. Podemos utilizar diversos níveis de INNER JOIN, embora esta não seja uma prática recomendada, pois se aumentarmos muito os níveis de INNER JOIN, podemos ter pesquisas mais lentas, em conseqüência do aumento da complexidade das mesmas. Até três ou quatro níveis é considerado normal, acima disso é preciso repensar a maneira de construir a consulta.

Exemplo 11 Alterar a instrução SQL do item anterior para que somente sejam exibidos os pedidos para os produtos cujo NomeDoProduto inicie com uma letra na faixa de A até J. Tirar a classificação do campo NúmeroDoPedido e classificar em ordem crescente do campo NomeDoProduto. SELECT Pedidos.NúmeroDoPedido, Pedidos.DataDoPedido, Pedidos.PaísDeDestino, Pedidos.Frete, Produtos.NomeDoProduto, DetalhesdoPedido.PreçoUnitário, DetalhesdoPedido.Quantidade FROM Pedidos INNER JOIN (Produtos INNER JOIN DetalhesdoPedido ON Produtos.CódigoDoProduto=DetalhesdoPedido.CódigoDoProduto) ON Pedidos.NúmeroDoPedido=DetalhesdoPedido.NúmeroDoPedido WHERE (((Produtos.NomeDoProduto) Like “[A-J]*”)) ORDER BY Produtos.NomeDoProduto;

Observe, além dos dois INNER JOIN, a utilização da cláusula WHERE com o operador Like para especificar o critério desejado. Até este momento estivemos construindo instruções SQL que executam consultas no banco de dados. Especificamos quais campos serão exibidos, critérios de filtragem para estes campos e uma ordem de classificação. A partir de agora aprenderemos a utilizar instruções SQL para a construção de outros tipos de instruções SQL, as quais realizam alterações e inclusões em tabelas de banco de dados.

271

Criando Sites Dinâmicos com ASP 3.0

A Instrução UPDATE A instrução UPDATE é utilizada para alterar informações em um banco de dados. Podemos criar um formulário onde o usuário pode alterar os seus dados cadastrais. Primeiro os dados são recuperados a partir do banco de dados, em seguida as alterações são enviadas de volta para o banco de dados, através de uma instrução UPDATE. Vamos estudar esta instrução através de exemplos, assim como fizemos com a instrução SELECT.

Exemplo 1 Criar uma instrução SQL que aumenta o PreçoUnitário em 20 % na tabela DetalhesdoPedido, devido a um ajuste na moeda e uma desvalorização em relação ao Dólar. UPDATE DetalhesdoPedido SET PreçoUnitário = PreçoUnitário*1.2;

Observe a simplicidade da instrução SQL. Utilizamos uma instrução UPDATE, seguida do nome da tabela onde será feita a atualização. Em seguida uma instrução SET com a expressão de atualização para aumentar em 20 % o PreçoUnitário. Vamos alterar a instrução anterior, para incluir um critério na consulta de atualização.

Exemplo 2 Alterar a instrução SQL do item anterior para que somente sejam aumentados os registros cujo PreçoUnitário for maior ou igual a R$ 20,00. UPDATE DetalhesdoPedido SET PreçoUnitário = PreçoUnitário*1.2 WHERE PreçoUnitário>=20;

Apenas foi adicionada uma cláusula WHERE, para atualizar apenas os registros cujo PreçoUnitário seja maior ou igual a R$ 20,00.

Exemplo 3 Alterar a instrução SQL do exemplo anterior para que somente sejam aumentados os registros cujo PreçoUnitário for maior ou igual a R$ 20,00 e cujo NúmeroDoPedido seja menor do que 10500. UPDATE DetalhesdoPedido SET PreçoUnitário = PreçoUnitário*1.2 WHERE (((PreçoUnitário)>=20) AND ((NúmeroDoPedido)<10500));

272

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

Observe que utilizamos critérios em dois campos (PreçoUnitário e NúmeroDoPedido) e que estes critérios estão ligados por um operador AND, o que significa que um registro, somente será atualizado se ele atender aos dois critérios ao mesmo tempo (PreçoUnitário maior ou igual a 20 e NúmeroDoPedido menor do que 10500). Se o registro atender a apenas uma das condições, o mesmo não terá o seu PreçoUnitário atualizado. Vamos refinar um pouco mais a nossa consulta de atualização. Vamos fazer com que somente sejam atualizados os pedidos para o ano da DataDoPedido igual a 1995, e ainda iremos manter os critérios adicionados até agora.

Exemplo 4 Alterar a instrução SQL do exemplo anterior para incluir um critério para que o ano da DataDoPedido seja 1995. Você terá que incluir a tabela Pedidos, uma vez que o campo DataDoPedido, encontra-se nesta tabela. UPDATE Pedidos INNER JOIN DetalhesdoPedido ON Pedidos.NúmeroDoPedido = DetalhesdoPedido.NúmeroDoPedido SET DetalhesdoPedido.PreçoUnitário = PreçoUnitário*1.2 WHERE (((DetalhesdoPedido.PreçoUnitário)>=20) AND ((DetalhesdoPedido.NúmeroDoPedido)<10500) AND (Year([DataDoPedido])=1995));

Temos diversos detalhes interessantes a observar nesta instrução SQL. Primeiro um INNER JOIN relacionando as tabelas Pedidos e DetalhesdoPedido, através do campo NúmeroDoPedido. Isso mostra que é perfeitamente possível utilizar um INNER JOIN dentro de uma consulta de atualização. Segundo, temos a utilização da função Year para extrair apenas o ano do campo DataDoPedido e compará-lo com o critério 1995. Novamente, a utilização de operadores e funções nos fornece uma grande flexibilidade em termos de construção de nossas consultas.

A Instrução INSERT A instrução INSERT é utilizada para gravar registros em uma tabela de um banco de dados. Por exemplo, quando o usuário preenche os dados de um formulário de cadastro e os envia para uma página ASP, podemos utilizar a instrução INSERT para os inserir em um banco de dados. Vamos analisar alguns exemplos.

273

Criando Sites Dinâmicos com ASP 3.0

Exemplo 1 Este exemplo cria um novo registro na tabela Funcionários: INSERT INTO Funcionários (Nome, Sobrenome, Cargo) VALUES (‘Paulo’, ‘Braga’, ‘Estagiário’);

Esta instrução insere um registro na tabela Funcionários com os seguintes dados: ➥ Nome: Paulo ➥ Sobrenome: Braga ➥ Cargo: Estagiário

Exemplo 2 Este exemplo seleciona todos os estagiários de uma tabela Estagiários que tenham sido contratados há mais de 30 dias e adiciona os registros selecionados à tabela Funcionários. INSERT INTO Funcionários SELECT Estagiários.* FROM Estagiários WHERE DataDaContratação < Hoje() - 30;

Observe que utilizamos a função Hoje( ) para capturar a data do sistema e subtraímos 30, para obter apenas os funcionários contratados a mais do que 30 dias.

A Instrução DELETE A instrução DELETE é utilizada para excluir registros de um banco de dados. Vamos supor que você tenha desenvolvido uma aplicação Web para agenda eletrônica, onde o usuário pode cadastrar contatos, endereços, telefones e compromissos. Podemos criar uma página ASP que permite ao usuário eliminar dados que não sejam mais necessários na agenda. Neste caso podemos fazer uso da instrução DELETE. Vamos a um exemplo prático.

Exemplo 1 Criar uma instrução SQL que elimine todos os pedidos da tabela Pedidos cujo PaísDeDestino seja a Alemanha. DELETE Pedidos.PaísDeDestino FROM Pedidos WHERE (((Pedidos.PaísDeDestino)=“Alemanha”));

A instrução é tão simples, que praticamente dispensa comentários. A única recomendação importante é que não devemos utilizar uma instrução DELETE, sem a utilização de uma

274

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

cláusula WHERE. Utilizar um DELETE sem uma cláusula WHERE significa que estaremos eliminando todos os registros da tabela. Agora que já revisamos os aspectos básicos relacionados a bancos de dados e à linguagem SQL, chegou o momento de aprendermos a conectar nossas páginas ASP com bancos de dados.

Uma Visão Geral de ADO e OLE DB A Microsoft vem há muito tempo desenvolvendo tecnologias que permitam acesso às mais variadas fontes de dados, quer sejam dados estruturados em bancos de dados tradicionais, como o Microsoft SQL Server, dados nos formatos mais tradicionais, como os armazenados em Mainframes, até dados não estruturados, como mensagens de correio eletrônico e arquivos com conteúdo multimídia, como sons e imagem. A expressão por trás deste esforço é conhecida como “Acesso Universal aos Dados” ou UDA do inglês – Universal Data Access. Porém, na tentativa de disponibilizar o Acesso Universal aos Dados, muitas tecnologias foram criadas, causando uma certa confusão e até desconforto para quem trabalha com desenvolvimento de aplicações. Isso porque, a cada nova tecnologia anunciada, um novo ciclo de aprendizado se inicia, sem contar que muitas vezes a comunicação entre as diferentes tecnologias não é exatamente a esperada. Neste mundo de tecnologias já nos deparamos com siglas como: ➥ DAO – Data Access Objects. ➥ RDS – Remote Data Access. ➥ ADO – Activex Data Object. ➥ ODBC – Open Database Conectivity. ➥ OLE DB. É normal que o desenvolvedor fique um pouco confuso com esta “sopa de letrinhas”. Mais importante do que decorar o significado de cada sigla é entender a tecnologia que fornece acesso aos dados e saber utilizá-las corretamente. Hoje, a tecnologia mais utilizada, e recomendada pela Microsoft, é a dobradinha ADO/OLE DB. A utilização de ODBC é bastante forte e deve se manter por um bom período. Por isso, analisaremos estas duas opções neste capítulo, e muitas vezes estaremos utilizando as duas ao mesmo tempo; mas isto será mais adiante, agora vamos procurar entender um pouco melhor estas tecnologias.

Um Pouco Sobre ODBC – Open Database Conectivity ODBC é um padrão da indústria de informática para acesso a bancos de dados estruturados. Um banco de dados estruturado utiliza o tradicional modelo Relacional, onde temos tabelas

275

Criando Sites Dinâmicos com ASP 3.0

e relacionamentos entre tabelas. São exemplos de bancos de dados estruturados: o Microsoft SQL Server, Oracle, Microsoft Access, Sybase, DB2 da IBM, etc. ODBC é uma interface que permite que os aplicativos acessem qualquer base de dados para a qual existe um driver ODBC. Utilizando ODBC, podemos criar páginas ASP que acessem dados para os quais existam drives ODBC, de uma maneira simples e rápida. Com a utilização de ODBC, podemos criar aplicações que se tornam independentes do sistema de banco de dados que está sendo utilizado. Por exemplo, desenvolvemos uma aplicação para acessar uma fonte de dados ODBC. A fonte de dados ODBC está ligada a um banco de dados do Microsoft Access. Em determinado momento resolvemos migrar do Microsoft Access para o Microsoft SQL Server. Sem problemas. Basta alterar nossa fonte de dados ODBC para que a mesma passe a referenciar o banco de dados no Microsoft SQL Server e pronto! A nossa aplicação passa a utilizar a nova fonte de dados de maneira transparente, através do driver ODBC. Na Figura 5.13, temos uma visão geral do acesso aos dados utilizando ODBC. Aplicação Web

Gerenciador ODBC

Driver ODBC SQL Server

Driver ODBC Microsoft Access

Driver ODBC Oracle

Figura 5.13: ODBC para acesso a dados. Para que uma fonte ODBC possa ser utilizada a mesma precisa ser previamente criada, utilizando-se o Gerenciador ODBC, o qual é acessível através das Ferramentas administrativas do menu Programas. Agora aprenderemos a criar fontes de dados ODBC. Ao desenvolver o aplicativo, o desenvolvedor fará referência a fonte ODBC criada. A título de exemplo, iremos criar duas fontes, uma para um banco de dados Microsoft Access 97 e outra para um banco de dados Microsoft SQL Server 2000 – Beta 2.

Criando uma Fonte ODBC Para um Banco de Dados do Microsoft Access 97 Vamos criar uma fonte para um banco de dados do Microsoft Access 97. Utilizaremos uma base de exemplo que já vem com o Microsoft Access 97 – nwind.mdb. No nosso exemplo esta fonte estará localizada em C:\Meus documentos.

276

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

IMPORTANTE Dependendo da versão do ODBC instalado em seu computador, as telas apresentadas podem ser um pouco diferentes das aqui apresentadas.

Para criar uma fonte ODBC chamada nwind: 1. Abra o Gerenciador de fontes ODBC (Iniciar/Programas/Ferramentas administrativas/ Fontes da dados (ODBC). 2. Surge a janela indicada na Figura 5.14.

Figura 5.14: O Gerenciador de fontes ODBC. 3. Uma fonte de dados é chamada de DSN – Data Source Name, a qual pode ser de três tipos: ➥ User DSN ➥ System DSN ➥ File DSN No nosso caso estaremos trabalhando, sempre, com System DSN.

277

Criando Sites Dinâmicos com ASP 3.0

NOTA Para maiores informações sobre os diferentes tipos de DSN consulte o site http:// msdn.microsoft.com. 4. Dê um clique na guia System DSN. 5. Surge a janela indicada na Figura 5.15.

Figura 5.15: Criando uma fonte do tipo System DSN. 6. Dê um clique no botão Add, para criar uma nova fonte ODBC. 7. Surge uma janela perguntando qual o tipo de banco de dados que você deseja acessar. Selecione Drive do Microsoft Access (*.mdb), conforme indicado na Figura 5.16.

278

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

Figura 5.16: Selecionando o banco de dados a ser usado. 8. Dê um clique no botão Concluir. É aberta a janela Configurar ODBC para Microsoft Access, conforme indicado na Figura 5.17.

Figura 5.17: Definições para a fonte ODBC para o Microsoft Access. 9. Nesta janela devemos fornecer diversas informações, tais como o nome para a fonte ODBC, a localização do arquivo .mdb, etc. 10. No campo Nome da fonte de dados, digite nwind.

279

Criando Sites Dinâmicos com ASP 3.0

11. No campo Descrição digite Fonte de dados Access. 12. A janela Configurar ODBC para Microsoft Access deve estar conforme indicado na Figura 5.18.

Figura 5.18: Definindo a fonte ODBC. 14. Dê um clique no botão Selecionar. Utilizamos este botão para selecionar o arquivo .mdb que será relacionado à fonte ODBC que está sendo criada. 15. Surge a janela Selecionar banco de dados. 16. Navegue até a pasta onde está o arquivo .mdb. No nosso exemplo vamos navegar até a pasta Meus documentos do drive C:, e dentro da pasta Meus documentos vou selecionar nwind.mdb, conforme indicado na Figura 5.19. 17. Dê um clique no botão OK e você estará de volta à janela Configurar ODBC para Microsoft Access. 18. Dê um clique no botão OK para fechar esta janela. 19. Você estará de volta à janela do Gerenciador de fontes ODBC, com a fonte ODBC nwind já criada, conforme indicado pela Figura 5.20.

280

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

Figura 5.19: Selecionando o arquivo C:\Meus documentos\nwind.mdb.

Figura 5.20: Fonte ODBC nwind já criada.

NOTA Estaremos utilizando esta fonte ODBC em diversos exemplos deste livro.

281

Criando Sites Dinâmicos com ASP 3.0

Criando uma Fonte ODBC Para um Banco de Dados do Microsoft SQL Server 2000 Vamos criar uma fonte para um banco de dados do Microsoft SQL Server 2000. Utilizaremos o banco de dados de exemplo que já vem com o Microsoft SQL Server 2000 – pubs. No nosso exemplo, o nome do servidor SQL é SERVIDOR. Caso você esteja trabalhando em um servidor com um nome diferente, utilize o nome do servidor no qual você está trabalhando.

IMPORTANTE Dependendo da versão do ODBC instalado em seu computador, as telas apresentadas podem ser um pouco diferentes das aqui apresentadas.

Para criar uma fonte ODBC chamada sqlpubs: 1. Abra o Gerenciador de fontes ODBC (Iniciar/Programas/Ferramentas administrativas/ Fontes da dados (ODBC). 2. Dê um clique na guia System DSN. 3. Dê um clique no botão Add para criar uma nova fonte ODBC. 4. Surge uma janela perguntando qual o tipo de banco de dados que você deseja acessar. Selecione SQL Server, conforme indicado na Figura 5.21.

Figura 5.21: Definindo uma fonte para o SQL Server.

282

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

5. Dê um clique no botão Concluir. É aberta a janela Create a New Data Source to SQL Server, conforme indicado na Figura 5.22.

Figura 5.22: Definições para a fonte ODBC para o SQL Server. 6. Nesta janela devemos fornecer diversas informações, tais como o nome para a fonte ODBC, o nome do servidor, etc. 7. No campo Name digite sqlpubs. 8. No campo Description digite Fonte de dados SQL Server. 9. Na lista Server, selecione o nome do Servidor SQL a ser utilizado. 10. A janela Create a New Data Source to SQL Server deve estar conforme indicado na Figura 5.23. 11. Dê um clique no botão Avançar para ir para a próxima etapa. 12. Aceite as opções selecionadas e dê um clique no botão Avançar, indo para a terceira etapa. 13. Surge a janela indicada na Figura 5.24. 14. Em um servidor SQL Server podem existir diversos bancos de dados. Neste caso precisamos definir a qual banco de dados a nossa fonte ODBC irá conectar-se. 15. Marque a opção Change the default database to. 16. Na lista abaixo desta opção selecione pubs, conforme indicado na Figura 5.25.

283

Criando Sites Dinâmicos com ASP 3.0

Figura 5.23: Definições para a fonte ODBC.

Figura 5.24: Definindo a qual banco de dados a fonte ODBC irá conectar-se.

284

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

Figura 5.25: Fazendo conexão com o Banco de dados pubs. 17. Dê um clique no botão Avançar para ir para a última etapa. 18. Nesta etapa podemos definir diversas opções, tais como: ➥ O idioma para as mensagens do SQL Server. ➥ Se devemos ou não utilizar criptografia dos dados para aumentar a segurança. ➥ Se devemos utilizar as configurações regionais tais como hora, data e formato para números em geral e para valores monetários. 19. Selecione as opções conforme indicado na Figura 5.26.

Figura 5.26: Finalizando a configuração da fonte ODBC.

285

Criando Sites Dinâmicos com ASP 3.0

20. Dê um clique no botão Concluir para finalizar a criação da fonte ODBC. 21. Surge a janela ODBC Microsoft SQL Server Setup, a qual informa as diversas opções selecionadas, conforme indicado na Figura 5.27.

Figura 5.27: Resumo das opções selecionadas para a fonte ODBC. 22. Nesta janela podemos clicar no botão Test Data Source..., para verificar se a conexão com o banco de dados está OK. 23. Dê um clique neste botão. 24. Deve surgir uma janela indicando que o teste foi realizado com sucesso, conforme indicado na Figura 5.28. 25. Dê um clique em OK para fechar a janela de teste. 26. Dê um clique em OK para fechar a janela de resumo. 27. Você estará de volta à janela do Gerenciador de fontes ODBC, com a fonte ODBC sqlpubs já criada, conforme indicado pela Figura 5.29. 28. Dê um clique em OK para fechar o Gerenciador de fontes ODBC.

NOTA Estaremos utilizando esta fonte ODBC em diversos exemplos deste livro.

286

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

Figura 5.28: Teste indicando que a conexão está OK.

Figura 5.29: Fonte ODBC sqlpubs já criada.

287

Criando Sites Dinâmicos com ASP 3.0

Agora que já sabemos um pouco sobre ODBC vamos falar sobre OLE DB.

Um Pouco Sobre OLE DB e ADO OLE DB é uma nova tecnologia, baseada na tecnologia COM da Microsoft, para acesso a bases de dados. Uma das grandes novidades trazidas pela tecnologia OLE DB é a possibilidade de acesso a bases não estruturadas, como por exemplo arquivos de mensagens de correio eletrônico, arquivos de texto, e bancos de dados de documentos como o Lotus Notes ou o Microsoft Exchange. Além disso, a tecnologia OLE DB foi construída tendo a performance como uma de suas diretivas. Diferente do ODBC, não existe um driver OLE DB para cada fonte de dado. Na tecnologia OLE DB, o conector para uma fonte de dados é chamado de OLE DB Provider. Por exemplo, existe um OLE DB Provider para Microsoft Access, um para Microsoft SQL Server, um OLE DB Provider para mensagens de correio do Microsoft Exchange, um para bancos de dados Oracle e assim por diante. OLE DB é a tecnologia preferencial, segundo a Microsoft, para acesso a dados estruturados ou não. Em diversos documentos e manuais oficiais da Microsoft, existem referências a utilização de OLE DB como a tecnologia a ser utilizada para acesso a qualquer fonte de dados. Muitos usuários pensam que OLE DB veio para substituir completamente o padrão ODBC. Na verdade, isto pode até acontecer daqui a algum tempo. Porém, na prática, existe um OLE DB Provider para ODBC. Com isso, utilizando OLE DB podemos ter acesso a qualquer fonte de dados ODBC. O ODBC funciona como se fosse um subconjunto de OLE DB, uma vez que OLE DB fornece acesso a todas as fontes de dados ODBC (utilizando o OLE DP Provider para ODBC), mais as fontes de dados não estruturadas para as quais existem OLE DB Provider disponíveis. Na Figura 5.30, temos uma visão geral do acesso a fontes de dados, utilizando OLE DB. Veja que é possível o acesso a qualquer fonte de dados ODBC. Também é possível o acesso sem a utilização de ODBC, utilizando-se o OLE DB Provider adequado para cada situação. Quanto estamos utilizando OLE DB temos a figura da fonte de dados e do consumidor de dados. Um OLE DB Provider é a fonte de dados, já o aplicativo é o consumidor de dados. No próximo item criaremos páginas ASP que acessam dados de um arquivo do Microsoft Access. Com isso, nossas páginas ASP atuarão como consumidores de dados. Porém, OLE DB, na verdade, é uma API (Application Programming Interface) baseada na tecnologia COM da Microsoft. Utilizar diretamente uma API é algo que requer conhecimentos avançados de programação, tais como o domínio das linguagens C e C++. Embora seja factível utilizar diretamente OLE DB, é muito pouco produtivo, além de exigir profissionais com conhecimentos avançados de programação.

288

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

OLE DB

OLE DB Providers Jet Provider

Jet Provider

Exchange Server Provider

Drivers ODBC

Microsoft Access

Microsoft SQL Server

Gerenciador ODBC

Driver ODBC SQL Server

Driver ODBC Microsoft Access

Driver ODBC Oracle

Microsoft SQL Server

Microsoft Access

ORACLE

Microsoft Exchange Server

Fontes de dados: Estruturadas e Não estruturadas.

Figura 5.30: Acessando fontes de dados com OLE DB. Para solucionar o problema de utilização direta de OLE DB foi criada uma camada adicional de programação, a qual é conhecida como ADO – ActiveX Data Objects. Com a utilização de ADO temos acesso a uma série de objetos e seus métodos. A utilização dos objetos ADO é bem mais simples do que a utilização direta da API OLE DB. Com a utilização de ADO, a produtividade do desenvolvedor aumenta bastante, pois seus objetos são de fácil aprendizagem e utilização, principalmente para quem já programa em Visual Basic. Quando utilizamos um objeto ADO, o próprio objeto sabe como converter a chamada feita em ADO, para comandos que a API OLE DB entende e é capaz de executar. Neste livro, sempre que formos fazer acesso a bases de dados, estaremos utilizando objetos ADO. Por exemplo, quando estabelecemos uma conexão com um banco de dados, estaremos utilizando o objeto Connection; para extrair informações de uma tabela estaremos utilizando um objeto chamado Recordset e assim por diante. Na Figura 5.31, representamos o acesso a dados através de ADO, o qual se comunica com a API OLE DB.

IMPORTANTE Com isso, terminamos nosso estudo sobre os aspectos teóricos necessários ao entendimento da conexão de páginas ASP com bancos de dados. A partir do próximo item estaremos aprendendo, na prática, a escrever páginas ASP que fazem conexão com banco de dados. Grande parte do nosso trabalho será estudar os objetos, métodos, propriedades e eventos da tecnologia ADO. Nunca é demais salientar que ADO é a forma de acesso a dados indicada pela Microsoft. No

289

Criando Sites Dinâmicos com ASP 3.0

site msdn.microsoft.com existem diversos documentos que ensinam como migrar de outras tecnologias mais antigas (como DAO, por exemplo), para a tecnologia ADO/OLE DB. Além disso, a Microsoft vem anunciando que as tecnologias mais antigas (como DAO e RDO) serão descontinuadas, isto é, serão substituídas por ADO.

ADO

OLE DB

OLE DB Providers Jet Provider

Jet Provider

Exchange Server Provider

Drivers ODBC

Microsoft Access

Microsoft SQL Server

Microsoft Exchange Server

Gerenciador ODBC

Driver ODBC SQL Server

Driver ODBC Microsoft Access

Driver ODBC Oracle

Microsoft SQL Server

Microsoft Access

ORACLE

Fontes de dados: Estruturadas e Não estruturadas.

Figura 5.31: Acessando fontes de dados com ADO/OLE DB. Outro ponto importante a salientar é que ADO não é somente para uso em aplicações Web. Podemos utilizar ADO para qualquer aplicação, como as tradicionais aplicações Cliente/ Servidor de duas camadas desenvolvidas em Visual Basic ou qualquer outra linguagem com suporte a ADO/OLE DB.

Uma Visão Geral do Modelo de Objetos ADO Neste item será apresentada uma visão geral do Modelo de Objetos do ADO. Nos demais itens deste capítulo e do próximo capítulo iremos aprender a utilizar diversos objetos deste modelo, à medida que forem apresentados exemplos práticos. Na Figura 5.32 temos uma visão geral dos principais objetos do Modelo de Objetos ADO.

290

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

Connection Errors

Error

Properties

Property

Parameters

Parameter

Properties

Property

Command

Recordset Fields

Field

Properties

Property

Fields

Field

Record

Stream

Figura 5.32: O Modelo de Objetos ADO. Abaixo uma descrição resumida dos principais objetos: ➥ Connection: Este objeto é utilizado para estabelecer uma conexão com uma fonte de dados, seja através de um Driver ODBC ou de um OLE DB Provider. O primeiro passo para acessar uma fonte de dados é estabelecer uma conexão com esta fonte. Uma vez estabelecida esta conexão, podemos utilizar outros objetos para extrair, alterar, inserir dados ou qualquer outra operação que seja permitida pela fonte de dados. Quando estabelecemos a conexão, também podemos passar informações de autenticação, tais como o nome do usuário e senha, de tal forma que seja dado acesso aos dados de acordo com as permissões de cada usuário. Por exemplo, podem existir usuários que devem ter permissão somente para leitura dos dados; já outros usuários podem necessitar de permissão para leitura e alteração. Um detalhe importante a ser salientado é que a criação de uma conexão com um banco de dados, através da utilização do objeto Connection, não é obrigatória. Podemos utilizar diretamente os objetos Command, Recordset e Record, pois cada vez que utilizarmos um destes objetos, uma conexão será automaticamente criada. Porém, pode ser mais prática a criação explícita de uma conexão, principalmente em situações em que muitos comandos são executados contra a fonte de dados. Neste caso a criação de uma conexão, com a utilização do objeto Connection, pode melhorar o desempenho da aplicação Web.

291

Criando Sites Dinâmicos com ASP 3.0

➥ Command: Este objeto pode ser utilizado para executar um comando (uma instrução SQL por exemplo) em uma fonte de dados. Podemos utilizar este objeto para efetuar uma consulta em um banco de dados e retornar o resultado em um objeto Recordset. Também podemos utilizar este objeto para alterar a estrutura de um banco de dados, desde que tenhamos permissão para isso. ➥ Recordset: Este objeto representa um conjunto de registros obtidos a partir de um banco de dados. Este conjunto de registros pode, por exemplo, ter sido retornado devido a uma operação do objeto Command. Todo objeto Recordset é formado por linhas e colunas, como se fosse uma tabela de um banco de dados. ➥ Record: Este objeto representa uma única linha (ou seja, um único registro) de um objeto Recordset. ➥ Stream: Este objeto é utilizado para manipular dados não estruturados, normalmente organizados em formas de árvores hierárquicas. Pode ser utilizado para acessar informações de um sistema de arquivos ou um sistema de correio eletrônico. Cada um destes objetos apresenta uma série de métodos, propriedades, eventos e coleções. Iniciaremos o estudo de cada objeto com uma apresentação rápida de cada um destes elementos. À medida que formos utilizando estes métodos, propriedades, eventos e coleções, apresentaremos maiores detalhes sobre cada um deles.

IMPORTANTE Na maioria das situações utilizamos os objetos Connection e Recordset juntos em uma mesma página. No próximo item iremos estudar o objeto Connection, porém já fazendo uso do objeto Recordset nos exemplos práticos. No item a seguir será apresentado apenas o básico sobre o objeto Recordset. Na parte final do capítulo e nos próximos capítulos estudaremos maiores detalhes sobre o objeto Recordset.

O Objeto Connection Conforme descrevemos anteriormente, o primeiro passo para conectar uma página ASP com uma fonte de dados, é estabelecer uma “conexão” com a fonte de dados. Para estabelecermos esta conexão utilizamos o objeto Connection. Ao estabelecermos uma conexão estamos informando para a nossa página ASP uma série de detalhes que a mesma necessita para poder acessar os dados. Utilizando o objeto Connection podemos definir qual o OLE DB Provider a ser utilizado, qual a fonte de dados e demais informações, tais como nome de usuário e senha, caso sejam necessários. Na Tabela 5.2 temos uma breve descrição dos principais métodos do objeto Connection.

292

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

Tabela 5.2 Os principais métodos do objeto Connection. Método

Descrição

BeginTrans

Inicia uma nova transação. Falaremos mais sobre Transações no Capítulo 12.

Cancel

Cancela a execução assíncrona dos comandos Execute e Open.

Fecha uma conexão que esteja aberta e quaisquer objetos que sejam dependentes desta conexão.

CommitTrans

Salva as alterações que foram feitas e encerra a transação corrente.

Execute

Executa um consulta, um comando ou uma instrução SQL e retorna um objeto do tipo Recordset. Pode, por exemplo, ser utilizado para obter uma listagem de vendas de um banco de dados, ou qualquer outra listagem podendo ser obtida a partir de uma instrução SQL.

Open

Abre uma conexão com uma fonte de dados. Feito isso, comandos podem ser executados através desta conexão.

OpenSchema

Utilizado para obter informação sobre a estrutura de uma fonte de dados, tais como as definições de tabelas e relacionamentos de um banco de dados relacional.

RoolbackTrans

Cancela quaisquer alterações que tenham sido feitas pela transação e finaliza a transação.

Na Tabela 5.3 temos uma breve descrição das principais propriedades do objeto Connection. Tabela 5.3 As principais propriedades do objeto Connection. Propriedade

Descrição

Attributes

Indica uma ou mais características de um objeto Connection. Retorna um valor Long.

CommandTimeout

Indica o tempo máximo de execução de um comando. Caso o comando demore mais do que o tempo definido nesta propriedade, será gerado um erro. O valor padrão é 30 segundos.

293

Criando Sites Dinâmicos com ASP 3.0

Propriedade

Descrição

ConnectionString

Contém todas as informações utilizadas para estabelecer a conexão com a fonte de dados.

ConnectionTimeout

Indica o tempo máximo para tentativa de estabelecer uma conexão. Caso a conexão não seja estabelecida em um tempo menor ou igual ao definido em ConnectionTimeout, a conexão será encerrada e um erro gerado. Por padrão este valor é definido em 15 segundos.

CursorLocation

Define ou retorna a localização do cursor, se no servidor ou no cliente. Iremos falar um pouco mais sobre cursores no próximo capítulo.

DefaultDatabase

Indica qual o banco de dados padrão para um objeto Connection. Por exemplo, quando estamos conectando com um servidor SQL precisamos definir qual a base de dados que será acessada. Fazemos isso definindo qual o banco de dados padrão, através da utilização da propriedade DefaultDatabase.

Errors

Contém todos os objetos Error criados em resposta a falhas envolvendo o provedor de dados. Falaremos mais sobre o objeto Error no Capítulo 11.

IsolationLevel

Define o nível de isolamento das transações para um objeto Connection. Voltaremos a este assunto no Capítulo 12.

Mode

Indica as permissões disponíveis para modificação de dados através de uma conexão.

Properties

Contém todos os objetos Property de um determinado objeto Connection.

Provider

Retorna o nome do Provedor para uma determinada conexão.

State

Indica se a conexão está aberta ou fechada.

Version

Retorna a versão da tecnologia ADO. Por exemplo, 2.0 ou 2.5.

294

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

Na Tabela 5.4 temos uma breve descrição dos principais eventos do objeto Connection. Tabela 5.4 Os principais eventos do objeto Connection. Evento

Descrição

BeginTransComplete

Ocorre após o término de uma operação BeginTrans.

CommitTransComplete

Ocorre após o término de uma operação CommitTrans.

ConnectComplete

Ocorre após o início de uma conexão.

Disconnect

Ocorre após o término de uma conexão.

ExecuteComplete

Ocorre após o término da execução de um comando.

InfoMessage

Ocorre sempre que a operação ConnectionEvent ocorre com sucesso e uma informação adicional é retornada pelo provedor de dados.

RollBackTransComplete

Ocorre após a execução da operação RollbackTrans.

WillConnect

Ocorre antes do início de uma conexão.

WillExecute

Ocorre antes que um comando pendente seja executado em uma determinada conexão.

O Primeiro Exemplo Neste item vamos utilizar o conhecimento que já temos para criar uma página ASP que conecta o banco de dados Nwind e mostra uma listagem de clientes com as seguintes informações: ➥ Código do Cliente (CodigoDoCliente) ➥ Cargo (Cargo) ➥ Endereço (Endereco) ➥ Telefone (Fone)

NOTA O nome entre parênteses é o nome do campo na tabela clientes do banco de dados Nwind. Caso você esteja utilizando outro banco de dados ou outra tabela, utilize os nomes de campo adequados. O banco de dados Nwind é um banco de exemplo que é instalado juntamente com o Microsoft Access.

295

Criando Sites Dinâmicos com ASP 3.0

Na Figura 5.33 podemos ver a estrutura da tabela Clientes que está sendo utilizada no nosso exemplo.

Figura 5.33: A tabela Clientes do banco de dados Nwind. Pode acontecer que a estrutura do Nwind esteja em inglês. Os nomes dos campos aparecem com CustomerID, City, Address e assim por diante. Utilize os nomes conforme os mesmos se apresentam na sua cópia do banco de dados Nwind.mdb. Na Listagem 5.1 apresentamos uma página ASP que faz a conexão com o banco de dados Nwind e exibe uma listagem de clientes. Logo após explicaremos cada um dos comandos utilizados. Listagem 5.1 – Uma página ASP que conecta com o banco de dados Nwind – clientes.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

<TITLE>Listagem de Clientes</TITLE>

</HEAD>

<BODY>

<H1>

<FONT color=navy>Clientes da Empresa ABC Ltda.</FONT>

</H1>

‘O Primeiro passo é criar a conexão com o banco de dados

‘Para isto crio um objeto do tipo Connection

296

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

13 14

‘Cria um objeto do tipo ADODB.Connection Set conn = Server.CreateObject(“ADODB.Connection”)

‘Agora abro uma conexão com a fonte ODBC “nwind”

‘criada anteriormente.

conn.Open “nwind”

‘O próximo passo é criar uma instrução SQL

‘a qual é utilizada para criar a listagem de clientes.

inst_sql=“SELECT Clientes.CodigoCliente, Clientes.Cargo, Clientes.Endereco, Clientes.Fone FROM Clientes”

‘Esta instrução SQL retorna os campos CodigoCliente, Cargo,

‘Endereco e Fone, da tabela Clientes.

‘Agora criamos um objeto RecordSet.

‘Este objeto irá executar a instrução SQL e

‘receber o resultado da consulta.

Set Clientes = Server.CreateObject(“ADODB.Recordset”)

‘Agora executamos a instrução SQL

‘retornando os registros da tabela Clientes.

Clientes.Open inst_sql, conn, 3, 3

‘Os dois últimos parâmetros serão discutidos

‘no próximo capítulo.

‘Neste ponto já tenho todos os registros retornados

‘pela instrução SQL. Estes registros estão armazenados

‘no objeto Clientes, que é um objeto do tipo Recordset.

‘Agora passo a montar a página que será retornada para o

‘navegador do cliente. Vamos montar uma tabela com o

‘resultado da consulta.

297

Criando Sites Dinâmicos com ASP 3.0

<P>

<HR>

<TR>

<TD align=middle bgColor=gray>Código</TD>

<TD align=middle bgColor=gray>Cargo</TD>

<TD align=middle bgColor=gray>Endereço</TD>

</TR>

‘Inicio um Loop para percorrer todos os registros

‘do RecordSet Clientes, exibindo um registro em

‘cada linha da tabela.

Do Until Clientes.eof %>

<TR>

</TR>

Clientes.MoveNext

Loop %>

</TABLE>

</P>

<HR>

</BODY>

</HTML>

298

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

Ao carregar esta página no Internet Explorer, o usuário recebe uma listagem conforme indicado na Figura 5.34.

Figura 5.34: A listagem de clientes do banco de dados Nwind. Antes de comentarmos esta listagem gostaria de salientar a natureza dinâmica das páginas criadas com ASP. Neste exemplo, qualquer alteração que seja feita na tabela Clientes, será exibida na listagem de clientes, na próxima vez que o usuário carregar a página Clientes.asp. Isto acontece porque a listagem é montada, a partir do banco de dados, cada vez que a página é carregada. Com isso ao carregar a página, todos os dados existentes na tabela Clientes serão exibidos. Por isso que dizemos que a página é criada dinamicamente, ou seja, cada vez que a página é solicitada, o código ASP estabelece a conexão com o banco de dados, solicita a listagem de clientes e apresenta a listagem no formato de uma tabela, conforme definimos. Agora vamos às explicações a respeito do código da Listagem 5.1. Embora existam diversos comentários na própria listagem, cabe aqui alguns esclarecimentos. Vamos detalhar diversos trechos de código desta listagem, pois estaremos utilizando estas técnicas ao longo do livro.

299

Criando Sites Dinâmicos com ASP 3.0

➥ Trecho 1: Considere o seguinte trecho de código: 14

Set conn = Server.CreateObject(“ADODB.Connection”)

Esta linha cria um objeto Connection chamado conn. Poderíamos utilizar qualquer nome válido para este objeto. Um ponto importante a salientar é a utilização da instrução Set. Sempre que formos criar um objeto (Connection, Recordset, etc.), devemos usar a instrução Set. Se não utilizarmos esta instrução na criação de objetos, obteremos um erro na hora de carregar a página. Também é importante observarmos o seguinte: Server.CreateObject(“ADODB.Connection”)

Este código cria um objeto no servidor, que é do tipo ADODB.Connection, ou seja, uma conexão ADO para banco de dados. Após a execução deste comando, um objeto Connection foi criado, porém o mesmo ainda não faz referência a nenhum banco de dados específico. ➥ Trecho 2: Considere o seguinte trecho de código: 15

‘Agora abro uma conexão com a fonte ODBC “nwind”

‘criada anteriormente.

conn.Open “nwind”

Na linha 17 estou associando a conexão conn com uma fonte ODBC nwind. Lembrando que esta fonte ODBC foi criada previamente. Caso você esteja utilizando uma fonte ODBC diferente, utilize o nome adequado. Esta associação é feita através do método Open, do objeto Connection. A partir deste momento, a minha conexão “conn” está associada ao banco de dados Nwind, conforme definido pela fonte ODBC nwind. Uma vez estabelecida a conexão é hora de recuperar dados, isto é, registros, a partir do banco de dados. Isto é feito pelo seguinte trecho de código: ➥ Trecho 3: Considere o seguinte trecho de código. 20

inst_sql=“SELECT Clientes.CodigoCliente, Clientes.Cargo, Clientes.Endereco, Clientes.Fone FROM Clientes”

‘Esta instrução SQL retorna os campos CodigoCliente, Cargo,

‘Endereco e Fone, da tabela Clientes.

‘Agora criamos um objeto RecordSet.

‘Este objeto irá executar a instrução SQL e

‘receber o resultado da consulta.

300

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

Set Clientes = Server.CreateObject(“ADODB.Recordset”)

‘Agora executamos a instrução SQL

‘retornando os registros da tabela Clientes.

Clientes.Open inst_sql, conn, 3, 3

‘Os dois últimos parâmetros serão discutidos

‘no próximo capítulo.

Na linha 20, criamos uma variável chamada inst_sql, a qual contém a instrução SQL que será executada no banco de dados Nwind. Observe que é uma instrução SQL bastante simples, a qual, basicamente, seleciona os campos CodigoCliente, Cargo, Endereco e Fone da tabela Clientes do banco de dados Nwind. Uma vez definida a instrução SQL, partimos para a criação de um objeto RecordSet. A criação do objeto RecordSet, chamado Clientes, é feita na linha 26. Poderíamos ter escolhido qualquer nome para este objeto. Observe a utilização da instrução Set. Como estamos criando um objeto (do tipo RecordSet), devemos utilizar a instrução Set. Agora devemos executar a instrução SQL para que o objeto Recordset contenha os registros retornados pela instrução. Isto é feito pelo seguinte código: 29

Clientes.Open inst_sql, conn, 3, 3

Neste caso utilizamos o método Open do objeto RecordSet Clientes. O primeiro parâmetro é a instrução SQL a ser utilizada – inst_sql. O segundo parâmetro é o nome da conexão a ser utilizada – conn. O terceiro e quatro parâmetros definem comportamentos para o objeto RecordSet, tais como se é possível mover-se para frente e para trás, avançando e voltando pelos registros, se os registros retornados são apenas para leitura ou para leitura e alterações e assim por diante. Estudaremos estas opções no próximo capítulo. Bem, neste momento já temos um objeto RecordSet chamado Clientes, o qual possui uma série de registros obtidos a partir da tabela Clientes do banco de dados Nwind. Cada registro possui quatro campos, conforme foi definido pela nossa instrução SQL que somente retorna os campos CodigoCliente, Cargo, Endereco e Fone. ➥ Trecho 4: Considere o seguinte trecho de código. 41

<TR>

<TD align=middle bgColor=gray>Código</TD>

301

Criando Sites Dinâmicos com ASP 3.0

<TD align=middle bgColor=gray>Cargo</TD>

<TD align=middle bgColor=gray>Endereço</TD>

</TR>

Do Until Clientes.eof %>

<TR>

56 TD>

<TD align=middle bgColor=gray><%=Clientes.Fields(“Endereco”)%></

</TR>

Clientes.MoveNext

Loop %>

</TABLE>

Uma vez que o RecordSet Clientes foi criado com sucesso, é hora de criarmos uma tabela que exibe os dados do objeto RecordSet. Começamos criando a primeira linha da tabela, a qual irá conter o título das colunas. Isto é feito pelo seguinte código: 41

<TR>

<TD align=middle bgColor=gray>Código</TD>

<TD align=middle bgColor=gray>Cargo</TD>

<TD align=middle bgColor=gray>Endereço</TD>

46 47

Observe que para criar o cabeçalho da tabela, utilizamos código HTML puro. Veja que estamos criando uma tabela com quatro colunas. Vamos exibir um registro por linha, como cada registro possui quatro campos, precisamos de uma tabela com quatro colunas. Esta tabela terá tantas linhas quantos forem os registros do objeto Clientes. A construção do corpo da tabela é feita com o seguinte trecho de código: 52 53 54

Do Until Clientes.eof %> <TR> <TD align=middle bgColor=gray><%=Clientes.Fields(“CodigoCliente”)%></TD>

302

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

57 58

Clientes.MoveNext

Loop %>

</TABLE>

Na linha 52, iniciamos um laço Do Until Condição... Loop. Como condição utilizamos a propriedade Eof do objeto Clientes. O laço continua sendo executado até que a condição Clientes.eof se torne Verdadeira. Esta condição somente irá tornar-se Verdadeira quando o indicador de registro já estiver além do último registro. Com isso, o laço somente será encerrado depois que tivermos percorrido todos os registros do objeto Clientes, que é exatamente o que queremos. Para cada registro é criada uma nova linha na tabela. Isto é feito pelo seguinte trecho de código: 53

<TR>

57 58

Observe o seguinte fragmento de código: <%=Clientes.Fields(“CodigoCliente”)%>

Este fragmento retorna o valor do campo CodigoCliente do registro atual do Recordset Clientes. Com isso vamos preenchendo cada coluna com os respectivos valores. A primeira coluna com o campo CodigoCliente, a segunda com o campo Cargo, e assim por diante. Neste caso, utilizamos a coleção Fields do RecordSet Clientes, a qual nos dá acesso aos campos individuais de cada registro. As linhas seguintes são de grande importância: 59

Clientes.MoveNext

Loop %>

</TABLE>

Se não colocássemos a linha 60, esta página ASP entraria em Loop infinito e somente o primeiro registro seria exibido repetidamente, até congelar a página. Quando criamos um objeto RecordSet, por padrão, o indicador de registro é posicionado no primeiro registro. Utilizamos o método MoveNext para mover o indicador para o próximo registro. Com isso, a cada passagem do laço Do

303

Criando Sites Dinâmicos com ASP 3.0

Until, o indicador é posicionado no próximo registro, até o momento em que todos os registros foram percorridos. Se não houvesse esta linha, o indicador ficaria sempre no primeiro registro e o laço nunca seria encerrado, pois a condição Clientes.eof seria sempre verdadeira, impedindo o encerramento do laço. A linha 62 é simplesmente a tag HTML de fechamento da tabela.

Modificando um Pouco o Nosso Exemplo Vamos fazer uma pequena modificação no exemplo anterior, com o objetivo de salientar a importância de conhecermos a linguagem SQL. Conforme podemos observar pela Figura 5.34, a listagem foi exibida na mesma ordem em que encontrava-se na tabela Clientes, isto é, ordenada pelo campo CodigoCliente. Mas, vamos supor que fosse necessária uma listagem ordenada pelo campo Cargo. Como faríamos isso? Muito simples, basta modificar a instrução SQL para incluir a ordenação. Isto é feito, modificando-se a linha 20 da Listagem 5.1. A nova instrução SQL, já ordenando pelo campo Cargo ficaria assim: 20

inst_sql=“SELECT Clientes.CodigoCliente, Clientes.Cargo, Clientes.Endereco, Clientes.Fone FROM Clientes ORDER BY Clientes.Cargo”

Feita esta alteração, ao acessarmos esta página no Internet Explorer, obteremos o resultado indicado na Figura 5.35.

Figura 5.35: A listagem de clientes do banco de dados Nwind, ordenada pelo campo Cargo.

304

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

Observe que uma simples modificação na instrução SQL já produz os resultados desejados. Também poderíamos sugerir outra alteração. Vamos supor que foi solicitado que retirássemos o campo Fone e incluíssemos o campo Fax. Esta mudança também é extremamente simples. Bastaria alterar as seguintes linhas: ➥ A instrução SQL na linha 20 ficaria assim: 20

inst_sql=“SELECT Clientes.CodigoCliente, Clientes.Cargo, Clientes.Endereco, Clientes.Fax FROM Clientes ORDER BY Clientes.Cargo”

➥ O cabeçalho da quarta coluna, na linha 46 ficaria assim: 46

➥ Na linha 57 basta trocar o nome do campo de Fone para Fax, conforme indicado: 57

Com estas três alterações, obteremos os resultados indicados na Figura 5.36.

Figura 5.36: A listagem de clientes do banco de dados Nwind, com o campo Fax. Com a utilização de SQL e ASP fica fácil fazer alterações em nossas páginas. A partir do próximo item estudaremos mais detalhes sobre o objeto Connection. Ainda neste capítulo, aprenderemos a criar um formulário onde o usuário pode digitar um critério e pesquisar registros que atendam ao critério digitado. Conforme descrito, continuaremos

305

Criando Sites Dinâmicos com ASP 3.0

fazendo uso de objetos RecordSet, embora somente iremos estudar os mesmos, em detalhes, no próximo capítulo.

Um Pouco Mais Sobre o Objeto Connection Neste item iremos testar algumas propriedades e métodos do objeto Connection. É importante conhecermos estes métodos e propriedades, pois o objeto Connection é de fundamental importância para a conexão de páginas ASP com bancos de dados. Considere o exemplo da Listagem 5.2. Listagem 5.2 – As propriedades do objeto Connection – propconn.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

<TITLE>Propriedades do Objeto Connection!!</TITLE>

</HEAD>

<BODY>

<H3>

<FONT color=navy>Tabela com as propriedades do objeto Connection !!!

</FONT>

</H3>

‘Cria um objeto do tipo ADODB.Connection

Set obj_conn=Server.CreateObject(“ADODB.Connection”)

‘Agora abro uma conexão com a fonte ODBC “nwind”

‘criada anteriormente.

obj_conn.Open “nwind”

‘O próximo passo é criar uma instrução SQL

inst_sql=“SELECT Clientes.CodigoCliente, Clientes.Cargo, Clientes.Endereco, Clientes.Fax FROM Clientes ORDER BY Clientes.Cargo”

306

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

‘Esta instrução SQL retorna os campos CodigoCliente, Cargo,

‘Endereco e Fax, da tabela Clientes.

‘Agora passamos a exibir as propriedades da

‘conexão obj_conn, em uma tabela de duas colunas.

‘Agora passo a montar a página que será retornada para o

‘navegador do cliente. Vamos montar uma tabela com as

‘propriedades da conexão obj_conn

<P>

<HR>

<TR>

<TD align=middle bgColor=gray>Propriedade</TD>

<TD align=middle bgColor=gray>Valor</TD>

</TR>

<TR>

35 36

<TD align=middle bgColor=gray>Attributes</TD> <TD align=middle bgColor=gray><%=obj_conn.Attributes %></TD>

</TR>

<TR>

39 40

<TD align=middle bgColor=gray>CommandTimeout</TD> <TD align=middle bgColor=gray><%=obj_conn.CommandTimeout %></TD>

</TR>

<TR>

43 44

<TD align=middle bgColor=gray>ConnectionString</TD> <TD align=middle bgColor=gray><%=obj_conn.ConnectionString %></TD>

</TR>

<TR>

<TD align=middle bgColor=gray>ConnectinTimeout</TD>

</TR>

307

Criando Sites Dinâmicos com ASP 3.0

50 51 52

<TR> <TD align=middle bgColor=gray>CursorLocation</TD> <TD align=middle bgColor=gray><%=obj_conn.CursorLocation %></TD>

</TR>

<TR>

55 56

<TD align=middle bgColor=gray>DefaultDatabase</TD> <TD align=middle bgColor=gray><%=obj_conn.DefaultDatabase %></TD>

</TR>

<TR>

59 60

<TD align=middle bgColor=gray>IsolationLevel</TD> <TD align=middle bgColor=gray><%=obj_conn.IsolationLevel %></TD>

</TR>

<TR>

<TD align=middle bgColor=gray>Provider</TD>

</TR>

<TR>

67 68

<TD align=middle bgColor=gray>State</TD> <TD align=middle bgColor=gray><%=obj_conn.State %></TD>

</TR>

<TR>

71 72

<TD align=middle bgColor=gray>Version</TD> <TD align=middle bgColor=gray><%=obj_conn.Version %></TD>

</TR>

</TABLE>

<% obj_conn.Close %>

</P>

<HR>

</BODY>

</HTML>

Ao acessarmos esta página, utilizando o Internet Explorer, obtemos o resultado indicado na Figura 5.37.

308

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

Figura 5.37: As principais propriedades do objeto Connection. Agora vamos detalhar alguns aspectos do código da Listagem 5.2: ➥ Estamos utilizando a mesma conexão utilizada no exemplo anterior, a qual utiliza a fonte ODBC nwind. ➥ Outro aspecto a ser salientado é a forma como utilizamos as propriedades do objeto Connection: <%=obj_conn.CommandTimeout %>

Este trecho de código ASP retorna o valor da propriedade CommandTimeout do objeto obj_conn, o qual por sua vez é um objeto Connection. A sintaxe para acessar as propriedades é a mesma para qualquer objeto, conforme indicado abaixo: Nome_do_objeto.Nome_da_propriedade

➥ Algumas propriedades são somente para leitura, isto é, somente podemos verificar o valor da propriedade. Como exemplo de propriedades que são apenas para leitura, podemos citar as propriedades State e Version. ➥ Outras propriedades são para leitura e escrita, isto é, além de acessarmos o valor atual da propriedade, podemos alterá-lo. A título de exemplo, vamos supor que quiséssemos

309

Criando Sites Dinâmicos com ASP 3.0

alterar a propriedade ConnectionTimeout para 200 segundos, ao invés de manter o padrão que é 15 segundos. Para isto, bastaria que utilizássemos o seguinte comando: obj_conn.ConnectionTimeout = 200

NOTA Cuidado! A propriedade ConnectionTimeout deve ser definida antes da conexão ser aberta com a utilização do método Open, caso contrário será gerado um erro e a página não será carregada. ➥ Observe a propriedade ConnectionString, cujo valor para o nosso exemplo é o seguinte: Provider=MSDASQL.1;Data Source=nwind;Extended Properties=“DSN=nwind; DBQ=C:\MEUS DOCUMENTOS\NWIND.MDB;DriverId=281; FIL=MS Access;MaxBufferSize=2048;PageTimeout=5;”

Estes valores são obtidos a partir da fonte ODBC nwind.

IMPORTANTE Uma dúvida que muitos usuários têm é sobre a obrigatoriedade ou não de utilizarmos ODBC. A utilização de uma fonte ODBC não é obrigatória, podemos montar uma conexão OLE DB diretamente para qualquer fonte de dados. Basta, para isso, montar a String de conexão correta e passá-la como um parâmetro para o método Open da conexão, que irá referenciar, diretamente, a fonte de dados, sem a necessidade de uma fonte ODBC estar configurada.

Agora vamos fazer alguns comentários sobre os valores padrão de algumas propriedades. A propriedade CursorLocation pode apresentar os valores indicados na Tabela 5.5. Tabela 5.5 – Valores da propriedade CursorLocation. Valor

Descrição

Não utiliza os serviços de cursor. Falaremos mais sobre cursores no próximo capítulo.

Este é o valor padrão, conforme pode ser comprovado na Figura 5.37. Com este valor são utilizados os serviços de cursor do provedor de dados, isto é, no lado do Servidor.

Utiliza cursor no Cliente.

310

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

A propriedade State pode apresentar os valores indicados na Tabela 5.6. Tabela 5.6 – Valores da propriedade State. Valor

Descrição

Indica que a conexão está fechada.

Indica que a conexão está aberta.

Indica que a conexão está sendo efetuada.

Indica que está sendo executado um comando através da conexão.

Indica um resultado sendo retornado, como por exemplo, os registros de um Recordset.

➥ Por último gostaria de salientar a utilização do método Close, para fechar a conexão, conforme indicado no seguinte trecho de código: 75

<% obj_conn.Close %>

Agora vamos explorar mais um exemplo de utilização da conexão de páginas ASP com banco de dados.

Criando um Formulário Para Pesquisa Vamos aprender mais alguns detalhes, através da utilização de um exemplo bastante comum no dia-a-dia. Problema: Criar um formulário, onde o usuário possa digitar o número do produto e clicar em um botão Pesquisar. Ao clicar neste botão é chamada uma página ASP (definida no atributo action da tag FORM), que conecta com o banco de dados Nwind.mdb, através da fonte ODBC nwind e exibe as informações da tabela Produtos, para o produto cujo código foi digitado no formulário de pesquisa. A página ASP deve ter um formulário para o usuário digitar outro código e clicar em um botão Pesquisar para buscar as informações de outro produto. Neste caso, ao clicar no botão Pesquisar da página ASP, a própria página será chamada (através da definição do atributo action da tag FORM). A página ASP fará a pesquisa para o novo código digitado e exibirá o produto correspondente. Solução: Para solucionar este problema, temos duas etapas: ➥ A criação da página HTML com o formulário de pesquisa. ➥ A criação da página ASP para responder a requisição do formulário de pesquisa.

311

Criando Sites Dinâmicos com ASP 3.0

Criando a Página HTML com o Formulário de Pesquisa A criação desta página é extremamente simples, utilizando os conhecimentos que foram apresentados até o momento. Na Listagem 5.3 temos o código para criação do formulário de pesquisa. Listagem 5.3 – O formulário de pesquisa para o usuário digitar o código do produto – produto.htm. 1

<HTML>

<HEAD>

<TITLE>Pesquisa de Produtos !!!</TITLE>

</HEAD>

<BODY>

<B>PESQUISA DE PRODUTOS.</B>

</FONT>

</P>

<P><FONT color=#000080><B>Digite o Código (de 1 a 77):

</B>

</FONT></P>

</FONT>

</B>

</P>

</FORM>

</BODY>

</HTML>

312

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

Ao visualizarmos este formulário no Internet Explorer, obtemos o resultado indicado na Figura 5.38.

Figura 5.38: O formulário para pesquisa do produto.

NOTA Estamos pedindo para que seja digitado um número entre 1 e 77 pois estes são os dados existentes para produtos no banco de dados Nwind.mdb. Porém, vamos fazer um teste: iremos digitar um código 95 e mandar pesquisar. A nossa página ASP detectará que não existe nenhum produto com este código e avisará que nenhum produto foi encontrado para o código digitado.

Criando a Página ASP Para Pesquisar no Banco de Dados A criação desta página apresenta alguns elementos novos, ainda não apresentados até o momento. Na Listagem 5.4 temos o código para criação da página ASP. Após a Listagem apresentaremos os esclarecimentos necessários. Listagem 5.4 – A página ASP para pesquisar no banco de dados – produto.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

<TITLE>Pesquisa de Produto !!</TITLE>

</HEAD>

313

Criando Sites Dinâmicos com ASP 3.0

<BODY>

<H2>

<FONT color=navy>Resultado para a Pesquisa.</FONT>

</H2>

<B>PESQUISA DE PRODUTOS.</B>

</FONT>

</P>

<P><FONT color=#000080><B>Digite o Código (de 1 a 77):

</B>

</FONT></P>

</FONT>

</B>

</P>

</FORM>

‘O primeiro passo é criar a conexão com o banco de dados

‘Para isto crio um objeto do tipo Connection

‘Cria um objeto do tipo ADODB.Connection

Set conn=Server.CreateObject(“ADODB.Connection”)

‘Agora abro uma conexão com a fonte ODBC “nwind”

‘criada anteriormente.

conn.Open “nwind”

‘O próximo passo é criar uma instrução SQL

sqlbuscaproduto =“SELECT * FROM Produtos where ProductID=” & Request.Form(“codigo”)

‘Esta instrução SQL retorna o produto cujo código

314

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

‘é igual ao código digitado no formulário de pesquisa.

‘Agora criamos um objeto RecordSet.

‘Este objeto irá executar a instrução SQL e

‘receber o resultado da consulta.

Set Produto = Server.CreateObject(“ADODB.Recordset”)

‘Agora executamos a instrução SQL

Produto.Open sqlbuscaproduto, conn, 3, 3

‘Os dois últimos parâmetros serão discutidos

‘no próximo capítulo.

‘Agora retorno as informações do produto encontrado.

‘Caso não tenha sido encontrado nenhum produto, informo.

<HR>

If Produto.RecordCount = 0 Then

Response.Write “Nenhum produto foi encontrado para o código: ”

Response.Write Request.Form(“codigo”) & “<BR>”

Response.Write “Tente pesquisar um outro código !”

Response.Write “<HR>”

Else

Response.Write “<B>DADOS DO PRODUTO:</B><BR>”

Response.Write “Código: ” & produto.Fields(“ProductID”) & “<BR>”

Response.Write “Nome: ” & produto.Fields(“ProductName”) & “<BR>”

Response.Write “Cód. Fornec.: ” & produto.Fields(“SupplierID”) & “<BR>”

Response.Write “Cód. Categ.: ” & produto.Fields(“CategoryID”) & “<BR>”

Response.Write “Preço Unit.: ” & produto.Fields(“UnitPrice”) & “<BR>”

Response.Write “Estoque: ” & produto.Fields(“UnitsInStock”) & “<BR>”

Response.Write “<HR>”

End If

</BODY>

</HTML>

315

Criando Sites Dinâmicos com ASP 3.0

Agora vamos testar o nosso exemplo. Na figura 5.39 temos o formulário de pesquisa carregado, onde o usuário digitou o código 32.

Figura 5.39: Pesquisando o produto cujo código é 32. Ao clicarmos no botão “Clique aqui para pesquisar o produto !!”, é retornado o resultado indicado na Figura 5.40.

Figura 5.40: O resultado da pesquisa para o produto com código 32.

316

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

Observe que no próprio formulário do resultado, colocamos a opção do usuário entrar com um novo código para fazer outra pesquisa, conforme havíamos proposto na apresentação deste problema. Agora vamos fazer o seguinte teste: vamos digitar um código para um produto que não existe e clicar fazer a pesquisa. Por exemplo, digite o código 89 e clique no botão de pesquisa. Você obterá o resultado indicado na Figura 5.41. Observe que, além de informar que o produto não foi encontrado, é informado qual o código que foi digitado. Agora vamos fazer alguns comentários sobre a Listagem 5.4.

Figura 5.41: Resultados para a pesquisa de um produto que não existe. ➥ O primeiro ponto a comentar é a construção da instrução SQL na linha 34. 34

sqlbuscaproduto =“SELECT * FROM Produtos where ProductID=” & Request.Form(“codigo”)

Nesta construção estamos utilizando a cláusula Where para especificar um critério. Ao executar a página ASP, o código Request.Form(“Código”) é substituído pelo valor digitado pelo usuário. Vamos supor que o usuário digitou 32 para o código. Neste caso a nossa instrução SQL ficaria assim: SELECT * FROM Produtos where ProductID=32

que é justamente, a instrução que retorna o produto cujo código é igual ao digitado no formulário de pesquisa. Esta é uma técnica bastante útil, pois inúmeras vezes precisamos construir instruções semelhantes a esta em nossas aplicações Web.

317

Criando Sites Dinâmicos com ASP 3.0

Um detalhe que devemos levar em consideração é quando o critério a ser pesquisado é do tipo texto. Neste caso, devemos colocar o critério entre apóstrofes. Para fazer isso utilizamos a função Chr(39) (39 é o código ASCII para o apóstrofe) antes e depois do critério, pois se digitarmos o código diretamente na página ASP, será gerado um erro em tempo de execução. No exemplo a seguir é ilustrada esta técnica, onde estamos especificando um critério para o campo Cidade, o qual é do tipo texto: sqlbuscaproduto =“SELECT * FROM Clientes where Cidade=” & Chr(39) Request.Form(“Cidade”) & Chr(39).

Observe o Chr(39) antes e depois do critério. Também gostaria de comentar o seguinte trecho de código: 50

If Produto.RecordCount = 0 Then

Response.Write “Nenhum produto foi encontrado para o código: ”

Response.Write Request.Form(“codigo”) & “<BR>”

Response.Write “Tente pesquisar um outro código !”

54 55

Response.Write “<HR>” Else

Response.Write “<B>DADOS DO PRODUTO:</B><BR>”

Response.Write “Código: “ & produto.Fields(“ProductID”) & “<BR>”

Response.Write “Nome: ” & produto.Fields(“ProductName”) & “<BR>”

Response.Write “Cód. Fornec.: ” & produto.Fields(“SupplierID”) & “<BR>”

Response.Write “Cód. Categ.: ” & produto.Fields(“CategoryID”) & “<BR>”

Response.Write “Preço Unit.: ” & produto.Fields(“UnitPrice”) & “<BR>”

Response.Write “Estoque: ” & produto.Fields(“UnitsInStock”) & “<BR>”

Response.Write “<HR>”

End If

Neste caso utilizamos a propriedade RecordCount do objeto Recordset. Caso esta propriedade seja igual a zero, significa que nenhum registro foi encontrado. Neste caso, informamos ao usuário que nenhum produto foi encontrado. Caso tenha sido encontrado algum produto, retornamos os dados sobre o Produto, o que é feito na parte Else do laço If..Then...Else. No próximo capítulo iremos tratar de algumas técnicas mais avançadas de pesquisa.

Conclusão Neste capítulo foram apresentados diversos conceitos fundamentais para a utilização de banco de dados com páginas ASP.

318

Capítulo 5 – Conectando Páginas ASP com Bancos de Dados

Começamos com uma revisão do Modelo Relacional de banco de dados, onde vimos conceitos como Entidades, Atributos, Chave Primária, relacionamentos e Normalização. Em seguida fizemos uma rápida revisão da linguagem SQL que, conforme descrito anteriormente, é de fundamental importância em se tratando de banco de dados. Na seqüência, vimos as tecnologias para acesso a fontes de dados; conceitos como ODBC, OLE DB e ADO e a maneira como os mesmos se relacionam. Também aprendemos a criar uma fonte ODBC para um banco de dados do Microsoft Access e do Microsoft SQL Server 2000. Depois estudamos o Modelo de Objetos do ADO, onde vimos em detalhes o objeto Connection. Nos exemplos de aplicação vimos como conectar uma página ASP para exibir uma listagem a partir de uma tabela de um banco de dados do Microsoft Access. Também aprendemos alguns detalhes sobre o objeto Recordset, que será melhor detalhado no próximo capítulo. Para finalizar o capítulo foi apresentado um exemplo no qual o usuário digita um critério e é efetuada uma pesquisa em uma tabela do banco de dados, com base no critério digitado pelo usuário.

319

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

Capítulo 6 Bancos de Dados com ASP – Conceitos Avançados Parte I

321

Criando Sites Dinâmicos com ASP 3.0

Introdução Neste capítulo veremos uma série de conceitos avançados sobre a conexão de páginas ASP com bancos de dados. Aprenderemos mais detalhes sobre conexões com fontes de dados, inclusive como conectar, sem a utilização de ODBC, somente através da utilização do objeto Connection e de sua propriedade ConnectionString. Estudaremos, detalhadamente, o objeto Recordset, aprendendo a utilizar suas propriedades, métodos e coleções. Teremos um item sobre a utilização de Cursores e sobre Lock em banco de dados. Estes são conceitos de grande importância que são, muitas vezes, ignorados. A correta utilização de cursores é fundamental para a construção de aplicações Web, utilizando ASP. Também aprenderemos a interagir com fontes de dados, não somente através de consultas. Aprenderemos a inserir, alterar e excluir dados que não sejam mais necessários. Neste item continuaremos utilizando, intensamente, as propriedades, métodos e coleções do objeto Recordset. Serão apresentados alguns exemplos práticos de utilização, como o clássico exemplo de construção de uma Caixa de combinação de maneira dinâmica. Por exemplo, em um determinado formulário, necessito de uma Caixa de combinação que liste todos os Bairros da cidade de Porto Alegre. Podemos construir esta lista, dinamicamente, a partir de um banco de dados, onde tenhamos esta informação armazenada em uma tabela. Veremos exemplos práticos de operações de inserção, alteração e exclusão de registros, utilizando páginas ASP. Também aprenderemos a filtrar os registros retornados por um objeto RecordSet. Veremos como construir instruções SQL que utilizam funções para gerar campos calculados, os quais não existem nas tabelas dos banco de dados. Por exemplo, utilizaremos a função Year para criar um campo que retorna apenas o ano de um campo data. Depois utilizaremos este campo para filtrar os resultados obtidos. Com os assuntos tratados neste capítulo, teremos estudado diversos aspectos do Modelo de Objetos ADO. Mas de maneira alguma teremos esgotado o assunto, uma vez que o mesmo é bastante extenso. Nos demais capítulos do livro continuaremos a aprender um pouco mais sobre ADO, além de outros assuntos, como gerenciamento de sessões e aplicações, utilização de componentes ASP do servidor, segurança e tratamento de erros dentre outros.

322

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

Estabelecendo Conexões sem a Utilização de ODBC Vamos repetir uma figura que foi apresentad no Capítulo 5, a qual ilustra a conexão de páginas ASP com fontes de dados, através da utilização de OLE DB, conforme indicado na Figura 6.1. OLE DB

OLE DB Providers Jet Provider

Jet Provider

Exchange Server Provider

Drivers ODBC

Microsoft Access

Microsoft SQL Server

Microsoft Exchange Server

Gerenciador ODBC

Driver ODBC SQL Server

Driver ODBC Microsoft Access

Driver ODBC Oracle

Microsoft SQL Server

Microsoft Access

ORACLE

Fontes de dados: Estruturadas e Não estruturadas.

Figura 6.1: Acessando fontes de dados com OLE DB. Conforme ilustrado nesta figura, é possível o acesso a fontes de dados sem a utilização de ODBC. Este é um ponto de confusão entre muitos programadores iniciantes em ASP. Em diversas conversas com colegas que estavam iniciando o estudo de ASP, surgiu esta dúvida: “É possível conectar com uma fonte de dados, como por exemplo um banco de dados do Microsoft Access, sem a utilização de um driver ODBC?” A resposta é sim; é perfeitamente possível. Para isto basta criar um objeto Connection e configurar corretamente a sua propriedade ConnectionString. A propriedade ConnectionString deve conter as informações necessárias para estabelecer a conexão com uma fonte de dados. Através desta propriedade, devemos fornecer informações tais como: ➥ Provedor ➥ Nome do usuário ➥ Senha do usuário ➥ Nome do arquivo

323

Criando Sites Dinâmicos com ASP 3.0

➥ Nome do servidor (como no caso de um servidor SQL Server) ➥ Nome do banco de dados no servidor São informações necessárias para que a página ASP possa estabelecer a conexão com a fonte de dados, utilizando o OLE DB Provider correto. Pode até ser que seja utilizado o OLE DB Provider para ODBC, mas isto não é obrigatório. Agora aprenderemos um pouco mais sobre a propriedade ConnectionString. Também veremos alguns exemplos de utilização desta propriedade.

A Propriedade ConnectionString Esta propriedade deve ser configurada de maneira diferente, de acordo com a fonte de dados que estiver sendo utilizada. Por exemplo, a configuração para acessar um banco de dados do Microsoft Access é diferente da configuração para acessar um banco de dados do Microsoft SQL Server ou do Oracle. Vamos estudar como configurar esta propriedade para acessar algumas das principais fontes de dados: Microsoft Access, Microsoft SQL Server e Oracle. A propriedade ConnectionString possui uma série de comandos no formato: argumento = valor

onde argumento pode ser a informação sobre o provedor, o nome do usuário, etc. Apenas a título de exemplo, listamos a seguir a propriedade ConnectionString do exemplo da Listagem 5.2, do capítulo anterior: Provider=MSDASQL.1;Data Source=nwind;Extended Properties=“DSN=nwind;DBQ=C:\MEUS DOCUMENTOS\NWIND.MDB;DriverId=281;FIL=MS Access;MaxBufferSize=2048;PageTimeout=5;”

Agora vamos decifrar e aprender a utilizar esta propriedade.

Configurando Conexões com Bancos de Dados do Microsoft Access Para configurar a propriedade ConnectionString para estabelecer uma conexão com um banco de dados do Microsoft Access, podemos configurar os parâmetros indicados na Tabela 6.1. Tabela 6.1 Definindo a propriedade ConnectionString para uma fonte do Microsoft Access. Propriedade

Descrição

Provider

Deve ser especificado o OLE DB Provider para o Microsoft Access. Para esta propriedade utilizamos o seguinte valor: Microsoft.Jet.OLEDB.4.0.

324

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

Propriedade

Descrição

Data Source

Informamos o caminho para o arquivo .mdb. Por exemplo, C:\Arquivos de programas\office\nwind.mdb.

User ID

Especifica o nome do usuário com a qual a conexão será estabelecida. Caso esta propriedade não seja informada, a mesma será definida como “admin”, o qual é o usuário padrão.

Password

Informa a senha para o usuário que fará a conexão. Caso não esta propriedade não seja informada, a mesma será definida como “ ”.

IMPORTANTE Por padrão, o OLE DB Provider para Microsoft Access (também chamado de Jet OLE DB Provider), abre o banco de dados com permissão de leitura e escrita, isto é, os dados também podem ser modificados. Para alterar o modo de abertura, para, por exemplo, somente escrita, devemos utilizar a propriedade Mode, do objeto Connection.

Abaixo temos um exemplo de uma conexão com um banco de dados, utilizando a propriedade ConnectionString: 1 Set conn=Server.CreateObject(“ADODB.Connection”) conn.Open “PROVIDER=MICROSOFT.JET.OLEDB.4.0;DATA SOURCE=c:\meus documentos\ nwind.mdb”

Primeiro criamos um objeto do tipo Connection. Depois utilizamos o método Open, para abrir esta conexão. Observe que após o método Open é passada uma String de conexão com o parâmetro para o método Open. Este parâmetro é a propriedade ConnectionString. Poderíamos obter o mesmo resultado de uma maneira diferente: primeiro vamos definir a propriedade ConnectionString, depois simplesmente chamamos o método Open. Ao chamar o método Open, o mesmo verifica se a propriedade ConnectionString já está definida e utiliza a mesma. Nosso exemplo ficaria assim: 1

Set conn=Server.CreateObject(“ADODB.Connection”)

conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0;DATA SOURCE=c:\meus documentos\nwind.mdb”

conn.Open

Neste caso, na linha 2 foi definida a propriedade ConnectionString e na linha 3 utilizamos o método Open.

325

Criando Sites Dinâmicos com ASP 3.0

OBSERVAÇÃO Utilizamos os números de linha apenas para referência. Quando criamos nossas páginas ASP não devemos utilizar números de linhas.

NOTA A linha 2 aparece “quebrada” em duas linhas por questões de espaço para exibição, mas a mesma deve ser digitada em uma única linha.

No exemplo a seguir, temos um caso onde foi fornecido o nome do usuário e a senha para conexão: 1

Set conn=Server.CreateObject(“ADODB.Connection”)

conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0;DATA SOURCE=c:\meus documentos\nwind.mdb; User ID=jsilva;Password=senha12”

conn.Open

Para maiores detalhes sobre segurança de bancos de dados do Microsoft Access, consulte a documentação do próprio Access.

Configurando Conexões com Bancos de Dados do Microsoft SQL Server Para configurar a propriedade ConnectionString para estabelecer uma conexão com um banco de dados do Microsoft SQL Server, podemos configurar os parâmetros indicados na Tabela 6.2. Tabela 6.2 Definindo a propriedade ConnectionString para uma fonte do Microsoft Access. Propriedade

Descrição

Provider

Deve ser especificado o OLE DB Provider para o Microsoft SQL Server. Para esta propriedade utilizamos o seguinte valor: SQLOLEDB.

Data Source ou Server

Informamos o nome do servidor SQL.

Initial Catalog ou Database

Nome do banco de dados a ser utilizado. Em um servidor SQL, podem existir vários bancos de dados.

User ID ou uid

Especifica o nome do usuário com o qual a conexão será estabelecida.

326

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

Propriedade

Descrição

Password ou pwd

Informa a senha para o usuário que fará a conexão. Caso esta propriedade não seja informada, a mesma será definida como “ ”.

Na Listagem 6.1, temos um exemplo de uma conexão com um banco de dados do Microsoft SQL Server, utilizando a propriedade ConnectionString: Listagem 6.1 – Conectando com um banco de dados do Microsoft SQL Server 2000 – nwind_sql.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

<TITLE>Conectando com o SQL Server 2000</TITLE>

</HEAD>

<BODY>

<H1>

<FONT color=navy>Pedidos da Empresa ABC Ltda.</FONT>

</H1>

‘O primeiro passo é criar a conexão com o banco de dados

‘Para isto crio um objeto do tipo Connection

‘Cria um objeto do tipo ADODB.Connection

Set conn=Server.CreateObject(“ADODB.Connection”)

‘Agora defino a propriedade ConnectionString do objeto Connection

‘criado anteriormente.

conn.ConnectionString = “PROVIDER=SQLOLEDB; Data Source=SERVIDOR\SERVIDOR;Initial Catalog=Northwind; User ID=sa;Password=senha123"

conn.Open

‘O próximo passo é criar uma instrução SQL

20 inst_sql=“SELECT Orders.OrderID, Orders.OrderDate, Orders.ShipCity, Orders.ShipCountry FROM Orders ORDER BY Orders.OrderDate”

327

Criando Sites Dinâmicos com ASP 3.0

‘Esta instrução SQL retorna os campos OrderID, OrderDate, ‘ShipCity e ShipCountry, da tabela Orders, do banco de dados NorthWind.

‘Agora criamos um objeto RecordSet.

‘Este objeto irá executar a instrução SQL e

‘receber o resultado da consulta.

Set Pedidos = Server.CreateObject(“ADODB.Recordset”)

‘Agora executamos a instrução SQL

Pedidos.Open inst_sql, conn, 3, 3

‘Neste ponto já tenho todos os registros retornados

‘pela instrução SQL. Estes registros estão armazenados

‘no objeto Pedidos, que é um objeto do tipo Recordset.

‘Agora passo a montar a página que será retornada para o

‘navegador do cliente. Vamos montar uma tabela com o

‘resultado da consulta.

<P>

<HR>

<TR>

<TD align=middle bgColor=gray>Código</TD>

<TD align=middle bgColor=gray>Cidade</TD>

</TR>

‘Inicio um Loop para percorrer todos os registros

‘do RecordSet Pedidos, exibindo um registro em

‘cada linha da tabela.

Do Until Pedidos.eof %>

328

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

<TR>

</TR>

<% Pedidos.MoveNext

Loop %>

</TABLE>

</P>

<HR>

</BODY>

</HTML>

Ao acessarmos este arquivo, obtemos o resultado indicado na Figura 6.2.

Figura 6.2: Dados carregados a partir do Microsoft SQL Server.

329

Criando Sites Dinâmicos com ASP 3.0

Alguns detalhes importantes a serem comentados a respeito deste exemplo: ➥ Primeiro, vamos considerar o seguinte fragmento de código: 17

conn.ConnectionString = “PROVIDER=SQLOLEDB; Data Source=SERVIDOR\SERVIDOR;Initial Catalog=Northwind; User ID=sa;Password=senha123"

conn.Open

Observe que, neste caso, primeiro definimos a propriedade ConnectionString, depois utilizamos o método Open, para abrir a conexão. O método Open utiliza as informações da propriedade ConnectionString, já definida, para estabelecer a conexão com o banco de dados. ➥ Segundo, vamos considerar a String de conexão: “PROVIDER=SQLOLEDB; Data Source=SERVIDOR\SERVIDOR; Initial Catalog=Northwind; User ID=sa;Password=senha123"

Observe que estamos informando os parâmetros descritos na tabela a seguir. Tabela 6.3 Parâmetros para a String de conexão com o servidor SQL Server. Parâmetro

Valor fornecido

Provider

SQLOLEDB

Data Source ou Server

SERVIDOR\SERVIDOR

Initial Catalog ou

Northwind

User ID ou uid

Password ou pwd

senha123

Temos dois parâmetros que merecem maiores comentários. O parâmetro Data Source ou Server foi informado da seguinte maneira: SERVIDOR\SERVIDOR

Este formato é uma novidade do Microsoft SQL Server 2000. O valor antes da barra (\) é o nome do servidor e o valor depois da barra é o nome da “instância” do SQL Server a ser utilizada (neste exemplo é igual ao nome do servidor, mas poderia ser diferente). Com o Microsoft SQL Server 2000, posso ter várias instâncias do servidor SQL, isto é como se eu tivesse vários servidores SQL Server 2000 diferentes no mesmo equipamento, sendo que cada um deles deve possuir um nome diferente. Assim poderíamos ter o seguinte exemplo:

330

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

SERVIDOR\SERVIDOR SERVIDOR\PRODUCAO SERVIDOR\ESPECIAL

Neste caso temos três “instâncias” do servidor SQL Server 2000 no computador de nome SERVIDOR. As três instâncias são: SERVIDOR PRODUCAO ESPECIAL

Quando vou definir a String de conexão, preciso definir a qual instância quero conectar a página ASP. Se você estiver utilizando o Microsoft SQL Server 7.0, basta fornecer o nome do servidor. Neste caso definiríamos a propriedade ConnectionString da seguinte maneira: “PROVIDER=SQLOLEDB; Data Source=SERVIDOR; Initial Catalog=Northwind; User ID=sa;Password=senha123”

➥ Observe que estamos conectando com o banco de dados Northwind. Dentro deste banco de dados, a nossa instrução SQL acessa dados da tabela Orders, conforme indicado pelo seguinte fragmento de código: 20

inst_sql=“SELECT Orders.OrderID, Orders.OrderDate, Orders.ShipCity, Orders.ShipCountry FROM Orders ORDER BY Orders.OrderDate”

Com esta instrução são retornados os campos OrderID, OrderDate, ShipCity e ShipCountry. Além disso a listagem obtida é classificada pelo campo OrderDate, conforme pode ser confirmado pelos resultados exibidos na Figura 6.2.

Configurando Conexões com Bancos de Dados ORACLE Para configurar a propriedade ConnectionString para estabelecer uma conexão com um banco de dados de um servidor ORACLE, podemos configurar os parâmetros indicados na Tabela 6.4: Tabela 6.4 Definindo a propriedade ConnectionString para uma fonte ORACLE. Propriedade

Descrição

Provider

Deve ser especificado o OLE DB Provider para o ORACLE. Para esta propriedade utilizamos o seguinte valor: MSDAORA.

Data Source

Informamos o nome do servidor ORACLE.

331

Criando Sites Dinâmicos com ASP 3.0

Propriedade

Descrição

User ID

Especifica o nome do usuário com o qual a conexão será estabelecida.

Password

Informa a senha para o usuário que fará a conexão.

Abaixo temos um exemplo de uma conexão com um banco de dados, utilizando a propriedade ConnectionString: 1

Set conn=Server.CreateObject(“ADODB.Connection”)

conn.Open “Provider=MSDAORA;Data Source=SERVIDOR;User ID=admin; Password=admin123”

Primeiro criamos um objeto do tipo Connection. Depois utilizamos o método Open, para abrir esta conexão. Observe que após o método Open é passada uma String de conexão como parâmetro para o método Open. Este parâmetro é a propriedade ConnectionString. Poderíamos obter o mesmo resultado de uma maneira diferente: primeiro vamos definir a propriedade ConnectionString, depois simplesmente chamamos o método Open. Ao chamar o método Open, o mesmo verifica se a propriedade ConnectionString já está definida e a utiliza. Nosso exemplo ficaria assim: 1

Set conn=Server.CreateObject(“ADODB.Connection”)

conn.ConnectionString = “Provider=MSDAORA;Data Source=SERVIDOR; User ID=admin; Password=admin123”

conn.Open

Neste caso, na linha 2 foi definida a propriedade ConnectionString e na linha 3 utilizamos o método Open.

OBSERVAÇÕES Utilizamos os números de linha apenas para referência. Quando criamos nossas páginas ASP não devemos utilizar números de linhas.

NOTA A linha 2 aparece “quebrada” em duas linhas por questões de espaço para exibição, mas a mesma deve ser digitada em uma única linha.

IMPORTANTE Para maiores detalhes sobre o ORACLE, consulte a documentação do produto.

332

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

Microsoft Access, Microsoft SQL Server e ORACLE são os casos mais comuns de conexões de páginas ASP com fontes de dados. Porém, conforme descrito no Capítulo 5, através de OLE DB podemos estabelecer conexões com qualquer fonte de dados para a qual esteja disponível um OLE DB Provider, inclusive fontes de dados não estruturadas no formato de bancos de dados relacionais. Como exemplos de fontes que não possuem o tradicional formato dos bancos de dados relacionais, poderíamos citar os arquivos de mensagens de correio eletrônico do Microsoft Exchange ou do Lotus Notes, um catálogo de indexação do Microsoft Index Server ou, até mesmo, uma fonte de dados residente em um Mainframe.

Alguns Detalhes Finais Sobre o Objeto Connection Agora veremos mais alguns detalhes importantes sobre o objeto Connection. Conforme mostrado nos exemplos práticos, para conectar uma página ASP com uma fonte de dados, estamos utilizando os seguintes passos: ➥ Criamos um objeto do tipo Connection e conectamos este objeto com uma fonte de dados, quer seja via ODBC (como nos exemplos do Capítulo 5), quer seja via OLE DB (como nos exemplos deste capítulo). ➥ Criamos um objeto do tipo RecordSet e executamos uma instrução SQL. Feito isto, o objeto RecordSet conterá os dados retornados pela fonte de dados. Uma vez obtidos os dados, utilizamos código ASP para exibir os resultados desejados. Esta metodologia funciona sem maiores problemas, porém existem alguns aspectos importantes a serem considerados, tais como o encerramento de uma conexão e o nível de acesso aos dados oferecido por determinada conexão.

O Método Close O método Close é utilizado para fechar/encerrar uma conexão e quaisquer outros objetos que sejam dependentes da conexão. Por exemplo, se criamos um objeto RecordSet que obteve dados a partir da conexão que está sendo encerrada, o objeto RecordSet também será encerrado. A sintaxe deste método é bastante simples. Vamos supor que tenhamos criado uma conexão chamada Clientes; para encerrá-la, poderíamos utilizar o seguinte código: <% Clientes.Close %>

Ao fecharmos um objeto, estaremos liberando os recursos computacionais que o mesmo utilizava, tais como conexões e uso do processador. Porém o objeto continua na memória, com isso podemos utilizar o método Open para abrir novamente a conexão e voltar a utilizá-

333

Criando Sites Dinâmicos com ASP 3.0

la. No exemplo abaixo, fechamos o objeto Clientes e depois voltamos a abri-lo, utilizando o método Open. <%

Clientes.Close Clientes.Open

Neste caso poderíamos voltar a utilizar o objeto Clientes. Para remover um objeto, em definitivo, da memória, devemos definir o seu valor como “Nothing”, conforme indicado no exemplo: <% Set Clientes = Nothing %>

Feito isso, somente poderemos voltar a utilizar o objeto se o mesmo for novamente criado, utilizando o seguinte código: Set Clientes = Server.CreateObject(“ADODB.Connection”)

Observe que, pelo fato de Clientes ser um objeto (do tipo Connection) e não simplesmente uma variável, devemos utilizar o operador Set. Se tentarmos criar ou remover um objeto, sem a utilização do operador Set, obteremos uma mensagem de erro e a página não será exibida.

“Pool” de Conexões Quando um usuário fecha uma conexão, através da utilização do método Close, conforme descrito anteriormente, esta conexão é mantida na memória e adicionada a um “Pool” de conexões inativas. Da próxima vez que o mesmo usuário, ou qualquer outro, for abrir uma nova conexão, o OLE DB primeiro verifica se, no Pool de conexões inativas, existe uma conexão exatamente igual ao que o usuário está solicitando. Se for encontrada, a mesma será utilizada, caso contrário uma nova conexão será criada e enviada para o usuário que solicitou. O OLE DB mantém um Pool de conexões porque o processo de criar uma conexão é o que mais exige recursos do servidor Web. Sempre que uma conexão puder ser reaproveitada, a partir do Pool de conexões, estaremos economizando recursos do servidor. As conexões inativas não permanecem indefinidamente no Pool de conexões. Após um período padrão sem utilização, as mesmas são removidas, para não onerar os recursos do servidor Web, sem que estejam sendo utilizadas. A utilização de Pool de conexões é de grande importância, principalmente para servidores Web muito acessados, em que novas conexões estão sendo criadas e fechadas a todo instante. Neste caso o Pool de conexões representa um alívio na carga de recursos como memória RAM e processador.

334

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

O Objeto RecordSet Nos exemplos que foram apresentados até aqui, já utilizamos o RecordSet. Agora chegou o momento de fazer um estudo mais aprofundado deste objeto. O objeto RecordSet contém o resultado de uma instrução SQL executada em um banco de dados. Contém um conjunto de Registros. É como se fosse uma tabela, onde cada linha é um registro, e cada registro é formado por um conjunto de campos (colunas da tabela). Por exemplo, ao executarmos a seguinte instrução SQL: Select * from Pedidos

Estaremos selecionando todos os registros da tabela Pedidos, os quais poderão ser acessados através de um objeto do tipo RecordSet. Existem detalhes importantes que devemos conhecer a respeito do acesso aos dados. Devemos considerar questões como: ➥ O acesso deve ser somente para leitura dos dados ou devem ser permitidas alterações e inserções de novos dados? ➥ Como tratar questões sobre o acesso simultâneo aos dados? Por exemplo, como tratar a situação em que dois usuários tentam alterar o mesmo registro, ao mesmo tempo? Estas são questões importantes e devem ser consideradas sempre que formos disponibilizar acesso aos dados da nossa empresa, para usuários da Internet. Também precisamos conhecer o que são Cursores, quais os tipos disponíveis e para que utilizamos. Vamos estudar estes pontos neste tópico. Para criar um objeto RecordSet, utilizamos a seguinte sintaxe: Set Pedidos = Server.CreateObject(“ADODB.Recordset”)

Neste exemplo estamos criando um RecordSet chamado Pedidos. Uma vez criado o RecordSet, o próximo passo é utilizarmos o método Open. Este método possui a seguinte sintaxe: recordset.Open Source, ActiveConnection, CursorType, LockType, Options

Considere o exemplo: Pedidos.Open inst_sql, conn, 3, 3

Os parâmetros a serem passados para o método Open estão descritos na Tabela 6.5.

335

Criando Sites Dinâmicos com ASP 3.0

Tabela 6.5 Parâmetros do método Open do objeto RecordSet. Parâmetro

Descrição

Source

Pode ser o nome de um objeto Command; uma instrução SQL ou o nome de uma variável que contém uma instrução SQL; o nome de uma tabela ou de um Store Procedure do banco de dados; ou até uma URL que aponta para uma fonte de dados.

ActiveConnection O nome da conexão a ser utilizada ou a String de conexão para uma fonte de dados ODBC ou OLE DB. É opcional. CursorType

É um valor que determina o tipo de cursor que será utilizado pelo provedor de dados na abertura do RecordSet. É opcional. Falaremos mais sobre tipos de cursores ainda neste item.

LockType

É um valor que determina o tipo de Lock que será utilizado pelo provedor de dados na abertura do RecordSet. É opcional. Falaremos mais sobre tipos de Lock ainda neste item.

Options

Um valor do tipo Long, o qual define como o provedor de dados deve avaliar o argumento Source, quando o mesmo for algo diferente de um objeto Command, ou quando o RecordSet deve ser recuperado a partir de um arquivo salvo previamente.

Cursores Um Cursor é o mecanismo utilizado em ADO para gerenciar o conjunto de registros de um objeto RecordSet. Somente podemos ter acesso a um registro chamado de Registro Corrente. Quando utilizamos o método Open, por padrão, o primeiro registro é o Registro Corrente. Um Cursor também é utilizado para determinar qual o Registro Corrente, bem como para movimentar o indicador de registro entre os diversos registros do objeto RecordSet. O mecanismo que identifica qual é o Registro Corrente é chamado de “Record pointer”. Quem lida com a manipulação do Record pointer é o Cursor. Por isso quando utilizamos os métodos MoveNext (mover para o próximo registro), MovePrevious (mover para o registro anterior) ou qualquer outro método de movimentação, estamos utilizando o Cursor. O mecanismo do Cursor também gerencia situações em que tentamos avançar além do último registro ou voltar além do primeiro registro, ou quando acessamos o valor de um campo de

336

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

um registro. De uma maneira simples, podemos afirmar que grande parte da funcionalidade de um objeto RecordSet é fornecida pelo mecanismo do Cursor. Quando utilizamos o método Open, podemos definir diferentes formas de comportamento para o mecanismo do Cursor. São estas formas que determinam os tipos de Cursores disponíveis, conforme a Tabela 6. 6. O tipo do Cursor pode ser definido com um valor numérico ou através de uma constante. Tabela 6.6 Tipos de Cursores disponíveis. Valor/Constante

Tipo/Descrição

3 adOpenStatic

Define um Cursor do tipo Static. Um Cursor deste tipo contém uma cópia estática dos registros. O conteúdo do RecordSet é definido no momento da criação do mesmo. Caso sejam feitas alterações no banco de dados, estas alterações não serão visíveis para o RecordSet que utiliza um Cursor do tipo Static. Somente recriando o RecordSet é que poderemos ter acesso às alterações efetuadas. Podemos movimentar o ponteiro de registro em ambas as direções, isto é, podemos utilizar os métodos MoveNext, MovePrevious e assim por diante.

0 Cria um Cursor do tipo Forward Only. Este é o valor adOpenForwardOnly padrão que será utilizado caso não seja definido nenhum outro tipo. Somente podemos utilizar o método MoveNext. Se tentarmos utilizar um outro método de movimentação, será gerado um erro e a página não será carregada. Também é um Cursor do tipo Static, com a diferença que somente podemos nos movimentar para a frente. 2 adOpenDynamic

Cria um Cursor do tipo Dynamic. Um Cursor deste tipo não possui um conjunto fixo de registros. Quaisquer alterações, adições e exclusões feitas por outros usuários serão visíveis para o objeto RecordSet, sem que o mesmo tenha que ser eliminado e recriado. Podemos nos movimentar em ambas as direções dentro do RecordSet.

1 adOpenKeyset

Cria um Cursor do tipo Keyset. Um Cursor deste tipo é parecido com um Cursor Dynamic, com a exceção de que o conjunto de registros é fixo. O RecordSet enxerga as alterações feitas por outros usuários, porém a adição de novos registros não é visível para um

337

Criando Sites Dinâmicos com ASP 3.0

Valor/Constante

Tipo/Descrição RecordSet deste tipo. Caso algum registro seja eliminado por outros usuários, o respectivo registro estará inacessível. podemos nos movimentar em ambas as direções dentro do RecordSet.

O tipo de Cursor a ser utilizado depende da aplicação que estamos desenvolvendo. Por exemplo, se estamos desenvolvendo uma página ASP apenas para exibir um conjunto de registros, podemos utilizar um cursor do tipo Static. Cursores mais simples, como o do tipo Static, consomem menos recursos. Cursores mais sofisticados, como o do tipo Dynamic, consomem mais recursos computacionais. Estes recursos podem ser consumidos na estação do cliente ou no servidor Web, dependendo da localização do Cursor. Veremos como definir a localização do Cursor através da utilização da propriedade CursorLocation, no próximo item. Agora alguns exemplos de utilização do método Open. Este exemplo cria um RecordSet chamado Clientes e define um cursor do tipo Static: <% inst_sql=“Select * from Clientes” Set Clientes = Server.CreateObject(“ADODB.Recordset”) Clientes.Open inst_sql, conn, 3, 3 %>

Ao invés de utilizarmos o valor 3, podemos utilizar a constante correspondente adOpenStatic, conforme o exemplo: <% inst_sql=“Select * from Clientes” Set Clientes = Server.CreateObject(“ADODB.Recordset”) Clientes.Open inst_sql, conn, adOpenStatic, 3 %>

O próximo exemplo cria um RecordSet chamado Clientes e define um Cursor do tipo Keyset. <% inst_sql=“Select * from Clientes” Set Clientes = Server.CreateObject(“ADODB.Recordset”) Clientes.Open

inst_sql,

conn,

338

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

Ao invés de utilizarmos o valor 1, podemos utilizar a constante correspondente adOpenKeyset, conforme o exemplo: <% inst_sql=“Select * from Clientes” Set Clientes = Server.CreateObject(“ADODB.Recordset”) Clientes.Open inst_sql, conn, adOpenKeyset, 3 %>

Localização do Cursor O Cursor pode estar localizado no servidor Web ou no cliente que está acessando os dados. Algumas fontes de dados, como o Microsoft SQL Server, podem oferecer serviços de Cursor no servidor. O Microsoft Access não oferece serviços de Cursor e, com isso, o mesmo fica localizado no cliente. Quando acessamos fontes de dados, utilizando OLE DB, podemos utilizar o serviço de Cursor oferecido pelo próprio OLE DB. A opção padrão, caso não seja definido nada em contrário, é que o Cursor esteja no servidor. Para definir a localização do cursor, devemos utilizar a propriedade CursorLocation, do objeto RecordSet. Definimos esta propriedade antes da utilização do método Open deste objeto. A Tabela 6.7 descreve os valores possíveis para esta propriedade. Tabela 6.7 Valores para a propriedade CursorLocation. Valor/Constante

Tipo/Descrição

3 adUseClient

Utiliza serviços de Cursor no cliente.

1 adUseNone

Não utiliza serviços de Cursor. Somente é mantido por questões de compatibilidade com as versões anteriores.

2 adUseServer

Utiliza serviços de Cursor do servidor ou do provedor OLE DB.

No próximo exemplo, definimos o Cursor no cliente: <% inst_sql=“Select * from Clientes” Set Clientes = Server.CreateObject(“ADODB.Recordset”) Clientes.CursorLocation = 3 Clientes.Open inst_sql, conn, 3, 3 %>

339

Criando Sites Dinâmicos com ASP 3.0

IMPORTANTE A propriedade CursorLocation deve ser definida antes da utilização do método Open. Se tentarmos definir a propriedade CursorLocation, com o RecordSet aberto, obteremos a seguinte mensagem de erro: Tipo de erro: ADODB.Recordset (0x800A0E79) Operation is not allowed when the object is open. /Capitulo6/pubs_sql.asp, line 40

A mensagem indica que a operação (definir a localização do Cursor) não é permitida quando o objeto está aberto.

Ao invés de utilizarmos o valor 3, podemos utilizar a constante correspondente, adUseClient, conforme o exemplo: <% inst_sql=“Select * from Clientes” Set Clientes = Server.CreateObject(“ADODB.Recordset”) Clientes.CursorLocation = adUseClient Clientes.Open inst_sql, conn, adOpenStatic, 3 %>

Quando criamos um RecordSet com o Cursor no servidor, é responsabilidade do servidor gerenciar a navegação e as atualizações do RecordSet, sendo que serão consumidos recursos no servidor. Ao utilizar o Cursor no cliente, todo o conteúdo do RecordSet é copiado para a estação do cliente e gerenciado por um Cursor local. Devemos considerar a questão da velocidade da conexão do usuário com a Internet ou com a Intranet da empresa, pois se o RecordSet for muito grande, isto é, um grande número de registros, o tempo para copiá-lo todo será considerável. Porém, uma vez copiado o RecordSet para a estação do cliente, a utilização do mesmo é mais rápida, pois não é preciso acessar o servidor para simples operações, tais como movimentar-se para o próximo registro. Quando uma aplicação Web é desenvolvida, a localização dos Cursores deve ser discutida na fase de projeto, sempre procurando propiciar o melhor desempenho possível para a aplicação. Em uma mesma aplicação posso ter páginas que utilizam o Cursor no servidor e outras que utilizam o Cursor no cliente, depende apenas da natureza de cada página. No próximo exemplo, definimos o Cursor no servidor: <% inst_sql=“Select * from Clientes”

340

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

Set Clientes = Server.CreateObject(“ADODB.Recordset”) Clientes.CursorLocation = 2 Clientes.Open inst_sql, conn, 3, 3 %>

Ao invés de utilizarmos o valor 2, podemos utilizar a constante correspondente, adUseServer, conforme o exemplo: <% inst_sql=“Select * from Clientes” Set Clientes = Server.CreateObject(“ADODB.Recordset”) Clientes.CursorLocation = adUseServer Clientes.Open inst_sql, conn, adOpenStatic, 3 %>

Lembrando que não é necessário definir o Cursor no servidor, pois essa é a definição padrão, ou seja, se não for definida, explicitamente, a propriedade CursorLocation assume o valor adUseServer.

Lock de Registros Os bancos de dados utilizam o Lock de registros como uma maneira de garantir a integridade dos dados. Com a utilização do Lock garantimos que um mesmo registro não esteja sendo alterado, simultaneamente, por mais do que um usuário. Quando um usuário acessa um registro para fazer alguma alteração, o mesmo é bloqueado, de tal forma que outros usuários não possam ter acesso a ele. O acesso ao registro somente será liberado após as alterações terem sido salvas no banco de dados. O tipo de Lock é definido pela propriedade LockType do objeto RecordSet. Existem diferentes maneiras de se fazer o Lock dos registros, conforme descrito na Tabela 6.8. Tabela 6.8 Tipos de Lock. Valor/Constante

Tipo/Descrição

1 adLockReadOnly

Cria um Lock do tipo Read Only. É o tipo padrão de Lock. O RecordSet é somente leitura, isto é, os registros não podem ser modificados, logo não precisam ser bloqueados. Com isso tem um processamento mais rápido, porém perde-se a capacidade de fazer alterações nos registros.

2 adLockPessimistic

Cria um Lock do tipo Pessimistic. O provedor OLE DB tenta bloquear o registro no momento em que o mesmo começa a ser editado. Isso é feito para tentar garantir que o registro será editado com sucesso.

341

Criando Sites Dinâmicos com ASP 3.0

Valor/Constante

Tipo/Descrição

3 adLockOptimistic

Cria um Lock do tipo Optimistic. O registro não é bloqueado enquanto as alterações não forem salvas no banco de dados através da utilização do método Update do RecordSet.

4 Cria um Lock do tipo Batch Optimistic. Este tipo de adLockBatchOptimistic Lock permite que vários registros sejam modificados. Os registros somente serão bloqueados quando for chamado o método UpdateBatch do objeto RecordSet. -1 adLockUnspecified

Não define o tipo de Lock. Quando utilizamos o método Clone, para criar uma cópia do RecordSet, o Clone será criado com o mesmo tipo de Lock do RecordSet original.

A maneira e os tipos de Lock possíveis de serem utilizados também dependem da fonte de dados que está sendo utilizada. Quando não existe a necessidade de fazer alterações nos registros, devemos utilizar, sempre, um Lock do tipo Read Only (ou seja, como o RecordSet é apenas leitura, os registros não precisam ser bloqueados), pois isso evita que o Provider tenha que fazer verificações ao acessar cada registro, para verificar se o registro não está bloqueado no momento. Assim teremos um processamento bem mais rápido. Um registro bloqueado não pode nem sequer ser visualizado pelos usuários, evitando-se que seja exibido um registro que está sendo alterado. Para definir o tipo de Lock, utilizamos a propriedade LockType, conforme indicado no exemplo a seguir, onde definimos o tipo de Lock como Optimistic: <% inst_sql=“Select * from Clientes” Set Clientes = Server.CreateObject(“ADODB.Recordset”) Clientes.LockType = 3 Clientes.Open inst_sql, conn, 3, 3 %>

IMPORTANTE A propriedade LockType deve ser definida antes da utilização do método Open. Ao tentarmos definir a propriedade CursorLocation, com o RecordSet aberto, obteremos a seguinte mensagem de erro:

342

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

Tipo de erro: ADODB.Recordset (0x800A0E79) Operation is not allowed when the object is open. /Capitulo6/pubs_sql.asp, line 40

A mensagem indica que a operação (definir a localização do Cursor) não é permitida quando o objeto está aberto.

Ao invés de utilizarmos o valor 3, podemos utilizar a constante correspondente, adLockOptimistic, conforme o exemplo: <% inst_sql=“Select * from Clientes” Set Clientes = Server.CreateObject(“ADODB.Recordset”) Clientes.LockType = adLockOptimistic Clientes.Open inst_sql, conn, adOpenStatic, 3 %>

Agora que já discutimos um pouco sobre Cursores, localização do Cursor e Lock de registros, podemos partir para o estudo de mais alguns detalhes do objeto RecordSet.

Propriedades do Objeto RecordSet Através da utilização de propriedades de um objeto podemos definir algumas de suas características e também retornar as características do mesmo. Algumas propriedades são somente para leitura, isto significa que apenas podemos verificar o valor da propriedade. Outras são de leitura e escrita, isto é, podemos definir seu valor. Para definir o valor de uma propriedade, utilizamos a seguinte sintaxe: <% RecordSet.nome_da_propriedade = valor %>

Na Tabela 6.9 estão listadas as principais propriedades do objeto RecordSet. Tabela 6.9 Principais propriedades do objeto RecordSet. Propriedade

Descrição

AbsolutePage

Retorna a página do Registro Corrente. Página é um conceito de armazenamento de banco de dados.

AbsolutePosition

Indica a posição do Registro Corrente, dentro do RecordSet.

343

Criando Sites Dinâmicos com ASP 3.0

Propriedade

Descrição

ActiveCommand

Retorna o objeto Command utilizado para criar o RecordSet, caso tenha sido utilizado um objeto Command. Esta propriedade é somente leitura.

BOF

Esta propriedade torna-se verdadeira quando estivermos no primeiro registro e utilizarmos o método MovePrevious, ou seja, indica uma tentativa de voltarmos além do primeiro registro. É somente leitura.

Bookmark

Retorna um marcador (bookmark) que identifica de maneira única cada registro do RecordSet. Também pode ser utilizado para tornar o registro identificado pelo Bookmark como o Registro Corrente. Nem todas as fontes de dados e seus respectivos OLE DB Providers oferecem esta propriedade.

CacheSize

Indica o número de registros do RecordSet que devem ser mantidos no Cache local de memória. Também pode ser utilizada para definir este número de registros.

CursorLocation

Pode ser utilizada para definir ou retornar a posição do Cursor.

CursorType

Indica o tipo de Cursor utilizado em um objeto RecordSet. Também pode ser utilizada para definir o tipo de Cursor. Deve ser utilizada antes do método Open, caso contrário irá provocar um erro quando a página for carregada.

EditMode

Retorna um valor que indica o status de edição do registro atual. Este valor pode ser: 0 – indica que não existe edição em andamento; 1– indica que os dados do registro atual foram modificados, porém ainda não foram salvos; 2 – indica que o método AddNew foi chamado e o registro que está sendo criado, ainda não foi salvo no banco de dados; 4 – indica que o registro atual foi deletado. É somente leitura.

EOF

Esta propriedade torna-se verdadeira quando estivermos no último registro e utilizarmos o método MoveNext, ou seja, indica uma tentativa de avançarmos além do último registro. É somente leitura.

344

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

Propriedade

Descrição

Filter

Pode ser utilizada para filtrar os registros de um RecordSet de acordo com um critério definido. Falaremos sobre esta propriedade mais adiante. Também serão mostrados alguns exemplos práticos.

LockType

Indica o tipo de Lock que está sendo utilizado. Também pode ser utilizada para definir o tipo de Lock, antes que o método Open tenha sido utilizado.

MaxRecords

Define o número máximo de registros que uma consulta deve retornar para o objeto RecordSet. O valor padrão é zero, o que significa sem limite de registros.

PageCount

Indica quantas páginas de dados o objeto RecordSet contém. É somente leitura.

PageSize

Indica o número de registros por página.

RecordCount

Indica o número de registros do objeto RecordSet. É somente leitura.

Sort

Especifica um ou mais campos para ordenação do RecordSet, além do tipo de ordenação se ascendente ou descendente. Para utilizarmos esta propriedade devemos utilizar o Cursor no cliente.

Source

Indica as fontes dos dados de um objeto RecordSet. Por exemplo, exibe a instrução SQL que deu origem aos dados ou o nome da tabela ou consulta que originou os dados do objeto RecordSet.

State

Indica o estado do objeto RecordSet. Indica se o mesmo está aberto, fechado ou executando uma operação de maneira assíncrona. É somente leitura.

Métodos do Objeto RecordSet O objeto RecordSet nos fornece diversos métodos, os quais podem ser utilizados para nos deslocar através dos registros, fazer uma cópia do RecordSet, etc. Para utilizarmos um método do objeto RecordSet, utilizamos a seguinte sintaxe: <% RecordSet.nome_do_método parâmetro1, parâmetro2, ..., parâmetron

Na Tabela 6.10 estão listados os principais métodos do objeto RecordSet.

345

Criando Sites Dinâmicos com ASP 3.0

Tabela 6.10 Principais métodos do objeto RecordSet. Método

Descrição

AddNew

Utilizado para adicionar um novo registro em um RecordSet que seja atualizável.

Cancel

Cancela a execução de uma operação Open assíncrona.

CancelBatch

Cancela uma operação de atualização em Batch.

CancelUpdate

Cancela qualquer alteração feita no Registro Corrente, ou alterações feitas em um novo registro antes da chamada do método Update.

Clone

Cria uma cópia do objeto RecordSet.

Fecha o objeto RecordSet e todos os objetos dele dependentes.

Delete

Elimina o registro corrente ou um grupo de registros selecionados.

Find

Pesquisa no RecordSet por um registro que atende um critério especificado.

GetRows

Retorna registros de um RecordSet e os armazena em um array.

GetString

Retorna todo o RecordSet como uma String.

Move

Movimenta o indicador de registro a partir de uma posição especificada de um determinado número de registros. Por exemplo, posso movimentar o indicador dez registros a partir do registro 10, com isso o indicador fica no registro 20.

MoveFirst

Movimenta o indicador para o primeiro registro.

MoveLast

Movimenta o indicador para o último registro.

MoveNext

Movimenta o indicador para o próximo registro.

MovePrevious

Movimenta o indicador para o registro anterior.

Open

Abre o objeto RecordSet.

Requery

Atualiza o conjunto de registros do RecordSet, executando novamente a consulta que deu origem ao RecordSet.

346

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

Método

Descrição

Resync

Atualiza os dados do RecordSet, buscando os dados a partir do banco de dados.

Save

Salva o conteúdo do RecordSet em um arquivo.

Update

Salva quaisquer alterações que tenham sido feitas para o objeto RecordSet.

Agora vamos aprender a executar algumas operações bastante comuns em aplicações Web. Aprenderemos a inserir, excluir e alterar um determinado registro.

Uma Página ASP Para Inserir Informações no Banco de Dados Neste exemplo aprenderemos a construir uma página ASP que recebe os dados digitados em um formulário HTML e os armazena no registro de uma tabela. Também faremos a validação para verificar se todos os campos obrigatórios foram preenchidos. Caso algum campo obrigatório não tenha sido preenchido, devolvemos o formulário para o usuário informando qual ou quais campos obrigatórios não foram preenchidos. Caso todos os campos tenham sido preenchidos corretamente, os valores digitados serão gravados no banco de dados. Podemos utilizar este exemplo para criar um formulário de cadastro de usuários ou qualquer outra aplicação que necessite armazenar os dados digitados em um formulário.

NOTA Eu, por exemplo, utilizo uma aplicação deste tipo para fazer a avaliação dos treinamentos que ministro em todo o país. Ao final do treinamento, os usuários, sem se identificar, preenchem um formulário com as opiniões sobre o treinamento, o material e o desempenho do instrutor. Estes dados são armazenados diretamente em um banco de dados do Microsoft Access, a partir do qual faço uma série de estatísticas.

Na Listagem 6.2 temos o código HTML para a criação do formulário de cadastro, no qual o usuário poderá digitar os dados. Listagem 6.2 – O formulário para digitação dos dados – cadastro.htm. 1

<HTML>

<HEAD>

347

Criando Sites Dinâmicos com ASP 3.0

<TITLE>Cadastro de novos Clientes !!</TITLE>

</HEAD>

<P>

<B>Empresa ABC Ltda. - (0-xx-11-1111-2222)</B>

</FONT>

</P>

<P>

<B><EM>CADASTRO DE NOVOS CLIENTES:</EM></B>

</FONT>

</P>

<P>

<EM>Digite os dados solicitados e clique no botão Enviar.</EM>

</FONT>

</P>

<P>

23 <TABLE bgColor=#ffffff border=1 cellPadding=1 cellSpacing=1 width=“100%” style=“HEIGHT: 161px; WIDTH: 340px”> 24

<TR>

<TD><INPUT id=nome maxLength=50 name=nome size=35>&nbsp;

</TR>

<TR>

32 33

348

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

<TR>

<TD>Bairro:</TD>

</TR>

<TR>

<TD>Cidade:</TD>

</TR>

<TR>

<TD><INPUT id=cep maxLength=10 name=cep size=10>&nbsp;

<FONT color=red><FONT color=#000000>nnnnn-nnn

</FONT><B>(*)</B></FONT></TD>

</TR>

<TR>

</TR>

<TR>

56 57 58

<TD>Cartão:</TD>

<TD>

<INPUT id=cartaotipo name=cartaotipo type=radio value=Visa>Visa

62 Card

<INPUT id=cartaotipo name=cartaotipo type=radio value=Master_Card>Master

<INPUT id=cartaotipo name=cartaotipo type=radio value=Outros>Outros

</TD>

</TR>

<TR>

349

Criando Sites Dinâmicos com ASP 3.0

</TD>

</TR>

</TABLE>

</FORM>

</P><BR>

<FONT color=red><B>(*)

<FONT color=navy>Campos de preenchimento obrigatório.</FONT></B></FONT>

</BODY>

</HTML>

Ao carregarmos o exemplo da Listagem 6.2, obteremos o resultado indicado na Figura 6.3.

Figura 6.3: O formulário para digitação dos dados.

350

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

Agora precisamos construir a página – cadastro.asp, a qual irá verificar se todos os campos de preenchimento obrigatório foram preenchidos. Se todos os campos obrigatórios foram preenchidos, os dados serão gravados em um banco de dados, caso contrário o formulário é enviado para o usuário, solicitando que o mesmo preencha os campos que estão faltando. Para armazenar os dados, utilizaremos um banco de dados do Microsoft Access – clientes.mdb. Este banco de dados está gravado em C:\Meus documentos. Neste banco de dados temos uma tabela chamada Cadastro, com a estrutura indicada na Figura 6.4.

Figura 6.4: Tabela Cadastro do banco de dados Clientes. Para acessar este banco de dados utilizaremos OLE DB, sem a necessidade da criação de uma fonte ODBC. Faremos isto através da utilização da propriedade ConnectionString, já descrita neste capítulo. A página cadastro.asp fará o seguinte: ➥ Estabelece conexão com o banco de dados clientes.mdb e cria um RecordSet chamado Cadastro, o qual está ligado à tabela Cadastro do banco de dados. ➥ Depois a página verifica se algum campo obrigatório não foi preenchido. ➥ Caso todos os campos obrigatórios tenham sido preenchidos, os dados são gravados na tabela Cadastro do banco de dados clientes.mdb. ➥ Caso algum campo obrigatório não tenha sido preenchido, a página ASP informa quais campos obrigatórios não foram preenchidos, e retorna o formulário para o usuário,

351

Criando Sites Dinâmicos com ASP 3.0

mantendo os campos que já haviam sido preenchidos, para que o usuário possa preencher somente os campos que estão faltando. Na Listagem 6.3 temos o código para a página cadastro.asp. Listagem 6.3 – Página ASP para processamento dos dados – cadastro.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<BODY>

‘O primeiro passo é criar a conexão com o banco de dados

‘Para isto crio um objeto do tipo Connection

‘Cria um objeto do tipo ADODB.Connection

Set conn=Server.CreateObject(“ADODB.Connection”)

‘Agora abro uma conexão com o arquivo clientes.mdb

‘utilizando OLE DB.

conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0;

conn.Open

‘Agora criamos um objeto RecordSet.

‘Este objeto irá acessar a tabela Cadastro.

Set Cadastro = Server.CreateObject(“ADODB.Recordset”)

Cadastro.Open “Cadastro”, conn, 3, 3

‘Neste ponto tenho o objeto Cadastro ligado com a tabela

‘Cadastro do banco de dados clientes.mdb.

‘**************************************************

‘ Inicia a verificação para saber se todos

‘ os campos obrigatórios foram preenchidos.

DATA SOURCE=c:\meus documentos\clientes.mdb”

‘**************************************************

352

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

‘ Atribuo os campos obrigatórios à variáveis, para facilitar a verificação.

nome=Request.Form(“nome”)

rua =Request.Form(“rua”)

bairro=Request.Form(“bairro”)

cidade=Request.Form(“cidade”)

cep=Request.Form(“cep”)

cartao=Request.Form(“cartaotipo”)

‘Verifica se os campos obrigatório foram preenchidos.

‘Qualquer dado obrigatório que não tenha sido preenchido,

‘definirá a variável faltou_dado em Sim.

If (nome=“”)Then

mensagem_nome=“Preencha o campo Nome:”

faltou_dado=“Sim”

faltou_nome=“Sim”

End If

If (rua=“”)Then

mensagem_rua=“Preencha o campo Rua:”

faltou_dado=“Sim”

faltou_rua=“Sim”

End If

If (bairro=“”)Then

mensagem_bairro=“Preencha o campo Bairro:”

faltou_dado=“Sim”

faltou_bairro=“Sim”

End If

If (cidade=“”)Then

mensagem_cidade=“Preencha o campo Cidade:”

faltou_dado=“Sim”

faltou_cidade=“Sim”

End If

If (cep=“”)Then

mensagem_cep=“Preencha o campo CEP:”

faltou_dado=“Sim”

faltou_cep=“Sim”

353

Criando Sites Dinâmicos com ASP 3.0

End If

If (cartao=“”)Then

mensagem_cartao=“Preencha o campo Cartão:”

faltou_dado=“Sim”

faltou_cartao=“Sim”

End If

‘Caso todos os campos obrigatórios tenham sido

‘preenchidos, gravo os dados no banco de dados.

‘e informo que a operação foi realizada com sucesso.

If faltou_dado<>“Sim” Then

Cadastro.AddNew

Cadastro.Fields(“Nome”)= Request.Form(“nome”)

Cadastro.Fields(“Rua”)= Request.Form(“rua”)

Cadastro.Fields(“Bairro”)= Request.Form(“bairro”)

Cadastro.Fields(“Cidade”)= Request.Form(“cidade”)

Cadastro.Fields(“Cep”)= Request.Form(“cep”)

Cadastro.Fields(“Fone”)= Request.Form(“fone”)

Cadastro.Fields(“Fax”)= Request.Form(“fax”)

Cadastro.Fields(“Cartao”)= Request.Form(“cartaotipo”)

Cadastro.Update

Cadastro.Close

Set Cadastro = Nothing

Response.Write “CLIENTE CADASTRADO COM SUCESSO<BR>”

Response.Write “<A href=cadastro.htm>Clique aqui para cadastrar outro cliente</A>”

Response.Write “<HR>”

End If

‘Caso algum dado obrigatório não tenha sido digitado

‘Envia o formulário de volta para o cliente,

‘preservando os valores que o mesmo já digitou.

‘Observe que utilizamos Response.Write para ir

‘recriando todo o formulário.

‘Também observe que o formulário é enviado de volta

‘na página cadastro.asp e que o atributo action

‘da tag FORM é definido como cadastro.asp, ou seja

354

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

‘a página cadastro.asp chama a si mesma após o

‘usuário clicar no botão Enviar.

‘Esta é uma técnica bastante interessante.

‘Antes de enviar o formulário, informamos quais

‘os campos obrigatório que não foram preenchidos.

If faltou_nome=“Sim” Then

Response.Write “<B>O campo Nome deve ser preenchido.</B> <BR>”

100

End If

101

If faltou_rua=“Sim” Then

102 103

Response.Write “<B>O campo Rua deve ser preenchido.</B> <BR>” End If

104 If faltou_cidade=“Sim” Then 105

Response.Write “<B>O campo Cidade deve ser preenchido.</B> <BR>”

106

End If

107

If faltou_bairro=“Sim” Then

108

Response.Write “<B>O campo Bairro deve ser preenchido.</B> <BR>”

109

End If

110

If faltou_cep=“Sim” Then

111

Response.Write “<B>O campo CEP deve ser preenchido.</B> <BR>”

112 End If 113

If faltou_cartao=“Sim” Then

114

Response.Write “<B>O campo Cartão deve ser preenchido.</B> <BR>”

115

End If

116

117 <% 118 ‘Começo a reenviar o formulário para o usuário, utilizando Response.Write. 119 ‘Caso esteja faltando algum dado, envio o formulário 120 ‘para o usuário preencher os campos que estão faltando. 121 ‘Os valores já digitados, são preservados. 122 %> 123 <% If faltou_dado=“Sim” Then

355

Criando Sites Dinâmicos com ASP 3.0

124 Response.Write “<BODY bgColor=#c0c0c0>” 125 Response.Write “<P><FONT color=white size=6 style=BACKGROUND-COLOR: navy><STRONG>Empresa ABC LTDA - ” 126 Response.Write “(0-xx-11-1111-2222)<BR>

”

127 Response.Write “</STRONG></FONT><FONT color=#000000><FONT size=5 ><STRONG><EM>CADASTRO DE NOVOS ” 128 Response.Write “CLIENTES:</EM></STRONG></FONT> <BR></FONT><FONTcolor=navy size=4><EM>Digite os dados solicitados e clique no botão ” 129 Response.Write “Enviar.</EM></FONT></P>” 130 Response.Write “<P>” 131 Response.Write “Caso queira alterar algum dado” 132 Response.Write “ digite no formulário abaixo.<BR>” 133 Response.Write “<FORM ACTION=cadastro.asp METHOD=post id=form1 name=form1>” 134 Response.Write “<TABLE bgColor=#ffffff border=1 cellPadding=1 cellSpacing=1 width=100% style=HEIGHT: 161px; WIDTH: 340px>” 135 Response.Write “<TR>” 136 Response.Write “<TD>Nome:</TD>” 137 Response.Write “<TD><INPUT id=nome maxLength=50 name=nome size=35 value=” & Chr(34) & Request.Form(“nome”) & Chr(34) & “>&nbsp;<FONT ” 138 Response.Write “color=red><B>(*)</B></FONT></TD></TR>” 139 Response.Write “<TR>” 140 Response.Write “<TD>Rua:</TD>” 141 Response.Write “<TD><INPUT id=rua maxLength=30 name=rua size=35 value=” & Chr(34) & Request.Form(“rua”) & Chr(34) & “><FONT Color=red><B>(*)</B></FONT></ TD></TR>” 142 Response.Write “<TR>” 143 Response.Write “<TD>Bairro:</TD>” 144 Response.Write “<TD><INPUT id=bairro maxLength=20 name=bairro value=” & Chr(34) & Request.Form(“bairro”) & Chr(34) &”><FONT ” 145 Response.Write “color=red><B>(*)</B></FONT></TD></TR>” 146 Response.Write “<TR>” 147 Response.Write “<TD>Cidade:</TD>” 148 Response.Write “<TD><INPUT id=cidade maxLength=25 name=cidade value=” & Chr(34) & Request.Form(“cidade”) & Chr(34) 149 Response.Write “size=25><FONT color=red><B>(*)</B></FONT></TD></TR>”

356

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

150 Response.Write “<TR>” 151 Response.Write “<TD>CEP:</TD>” 152 Response.Write “<TD><INPUT id=cep maxLength=10 name=cep value=” & Chr(34)& 153 Request.Form(“cep”)& Chr(34) 154 Response.Write “size=10>&nbsp;<FONT color=red><FONT color=#000000>nnnnn-nnn ” 155 Response.Write “</FONT><B>(*)</B></FONT></TD></TR>” 156 Response.Write “<TR>” 157 Response.Write “<TD>Fone:</TD>” 158 Response.Write “<TD><INPUT id=fone maxLength=20 name=fone value=” & Chr(34) & 159 Request.Form(“fone”) & Chr(34) & “></TD></TR>” 160 Response.Write “<TR>” 161 Response.Write “<TD>Fax:</TD>” 162 Response.Write “<TD><INPUT id=fax maxLength=20 name=fax value=” & Chr(34) & Request.Form(“fax”) & Chr(34) & “></TD></TR>” 163 Response.Write “<TR>” 164 Response.Write “<TD>Cartão:</TD>” 165

If Request.Form(“cartaotipo”)=“Visa” Then

166

Response.Write “<TD><INPUT id=cartaotipo name=cartaotipo type=radio CHECKED>Visa”

167

Else

168

Response.Write “<TD><INPUT id=cartaotipo name=cartaotipo type=radio>Visa”

169

End If

170

If Request.Form(“cartaotipo”)=“Master Card” Then

171

Response.Write “<INPUT id=cartaotipo name=cartaotipo type=radio CHECKED>Master Card <INPUT id=cartaotipo ”

172

Else

173

Response.Write “<INPUT id=cartaotipo name=cartaotipo type=radio>Master Card <INPUT id=cartaotipo ”

174

End If

175

If Request.Form(“cartaotipo”)=“Outros” Then

176 177 178 179

Response.Write “name=cartaotipo type=radio CHECKED>Outros” Else Response.Write “name=cartaotipo type=radio>Outros” End If

180 Response.Write “<FONT color=red><B>(*)</B></FONT></TD></TR>” 181 Response.Write “<TR>”

357

Criando Sites Dinâmicos com ASP 3.0

182 Response.Write “<TD colSpan=2><INPUT id=enviar name=enviar style=HEIGHT: 24px; WIDTH: 109px type=submit value=Enviar_dados.>&nbsp;” 183 Response.Write “<INPUT id=limpar name=limpar type=submit value=Limpar_formulário.></TD></TR>” 184 Response.Write “</TABLE>” 185 Response.Write “</FORM>” 186 Response.Write “</P><FONT color=red><B>(*) <FONT color=navy>Campos de preenchimento ” 187 Response.Write “obrigatório.</FONT></B></FONT>” 188 End If 189 %> 190 </BODY> 191 </HTML>

NOTA Algumas linhas aparecem divididas em duas ou mais linhas. Nunca é demais lembrar que estas linhas devem ser digitadas como uma linha única. As mesmas estão exibidas em duas ou mais linhas apenas por questão de espaço.

Algumas observações sobre a Listagem 6.3: ➥ A primeira observação a ser feita é a respeito do código que insere um novo registro na tabela Cadastro do Banco de dados clientes.mdb. O código ASP que realiza esta tarefa é o seguinte: 68 If faltou_dado<>“Sim” Then 69

Cadastro.AddNew

Cadastro.Fields(“Nome”)= Request.Form(“nome”)

Cadastro.Fields(“Rua”)= Request.Form(“rua”)

Cadastro.Fields(“Bairro”)= Request.Form(“bairro”)

Cadastro.Fields(“Cidade”)= Request.Form(“cidade”)

Cadastro.Fields(“Cep”)= Request.Form(“cep”)

Cadastro.Fields(“Fone”)= Request.Form(“fone”)

Cadastro.Fields(“Fax”)= Request.Form(“fax”)

Cadastro.Fields(“Cartao”)= Request.Form(“cartaotipo”)

Cadastro.Update

Cadastro.Close

Set Cadastro = Nothing

Response.Write “CLIENTE CADASTRADO COM SUCESSO<BR>”

Response.Write “<A href=cadastro.htm>Clique aqui para cadastrar outro cliente</A>”

Response.Write “<HR>”

84 End If

358

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

Neste código, utilizamos o método AddNew do objeto RecordSet Cadastro. Depois vamos preenchendo cada novo campo do registro, com o respectivo valor preenchido pelo usuário no formulário. No final, utilizamos o método Update para salvar o registro na tabela. O método Close é utilizado para fechar o RecordSet Cadastro e, por fim, tiramos o objeto Cadastro da memória. Isto é feito atribuindo-se o valor “Nothing” para o objeto Cadastro. É importante lembrar que para atribuir valor para um objeto, devemos utilizar o operador Set, caso contrário obteremos uma mensagem de erro. ➥ Também gostaria de observar a situação em que o usuário deixa de preencher algum campo obrigatório. Neste caso, o usuário é informado a respeito de qual ou quais campos não foram preenchidos. O formulário é retornado para o usuário, juntamente com os valores já digitados, para que o usuário não precise redigitar todos os valores novamente. Observe que todo o código HTML que gera o formulário é retornado utilizando-se Response.Write – da linha 124 à linha 189. ➥ Vamos testar o funcionamento da página cadastro.asp. Na Figura 6.5, o usuário preencheu alguns campos, porém não preencheu os campos obrigatórios Bairro e Rua.

Figura 6.5: Os campos obrigatórios Bairro e Rua não foram preenchidos. Ao clicar no botão Enviar dados, a página cadastro.asp detecta que alguns campos obrigatórios não foram preenchidos e informa isto ao usuário, conforme indicado na Figura 6.6.

359

Criando Sites Dinâmicos com ASP 3.0

Figura 6.6: O usuário é informado que alguns campos obrigatórios não foram preenchidos. Agora o usuário preenche os campos obrigatórios que estão faltando, conforme indicado na Figura 6.7.

Figura 6.7: O usuário preenche os campos que estão faltando.

360

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

Ao clicar em Enviar dados, as informações serão salvas no banco de dados. A página cadastro.asp informa que os dados foram salvos com sucesso e retorna um link para que o usuário possa voltar ao formulário de cadastro e cadastrar outro cliente, conforme indicado na Figura 6.8.

Figura 6.8: O cliente foi cadastrado com sucesso.

Editando Registros em um Banco de Dados Neste tópico aprenderemos a criar uma página ASP que atualiza um registro do banco de dados. Nosso exemplo será composto dos seguintes elementos: ➥ Uma página ASP – produto.asp, onde temos um campo com a listagem de produtos disponíveis na tabela Produtos, do banco de dados Nwind. Esta listagem será construída dinamicamente, isto é, cada vez que a página for carregada, a listagem será construída a partir das informações disponíveis na tabela Produtos. ➥ Após selecionar o produto a ser alterado, o usuário clica em um botão Localizar produto. Feito isso, a página produto.asp chama uma página chamada localiza.asp, que localiza o registro selecionado no banco de dados. Com isso, o usuário pode alterar os dados do produto. ➥ Após alterar os dados desejados, o usuário clica em um botão Atualizar produto. A página localiza.asp chama a página atualiza.asp, que acessa o banco de dados e faz as alterações solicitadas pelo usuário. Ao final é emitida uma mensagem indicando que os dados foram atualizados com sucesso.

NOTA Existem maneiras mais simples para executar este procedimento. Optei pela utilização de três páginas, para que os passos envolvidos ficassem bem claros. O código ASP também foi desenvolvido de uma maneira didática, visando facilitar o entendimento do mesmo.

361

Criando Sites Dinâmicos com ASP 3.0

A Página ASP Para Selecionar o Produto a ser Alterado – produto.asp Na Listagem 6.4 temos o código ASP para a criação da página produto.asp. Listagem 6.4 – A página ASP para selecionar o produto a ser alterado – produto.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

<TITLE>Selecione o produto a ser alterado.</TITLE>

</HEAD>

<BODY>

‘O primeiro passo é criar a conexão com o banco de dados.

‘Para isto crio um objeto do tipo Connection.

‘Cria um objeto do tipo ADODB.Connection

Set conn=Server.CreateObject(“ADODB.Connection”)

‘Agora abro uma conexão com o arquivo nwind.mdb

‘utilizando OLE DB.

conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0;

conn.Open

‘Agora criamos um objeto RecordSet.

‘Este objeto irá acessar o campo ProductName

‘da tabela Produtos

Set Produtos = Server.CreateObject(“ADODB.Recordset”)

Produtos.Open “Select ProductName from Produtos Order By ProductName”, conn, 3, 3

‘Neste ponto tenho o objeto Produtos ligado com a tabela

‘Produtos do banco de dados nwind.mdb.

DATA SOURCE=c:\meus documentos\nwind.mdb”

362

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

<P><B>Selecione o produto a ser alterado.</B></P>

<P><B><I>Depois clique no botão Localizar Produto.</I></B></P>

‘Agora construo a lista de opções a partir dos

‘dados obtidos da tabela Produtos.

‘Para cada produto obtido, crio uma nova opção

‘na lista.

Do While Not Produtos.EOF

Response.Write “<OPTION value=” & Chr(34) & Produtos.Fields(“ProductName”) & Chr(34) & “>” & Produtos.Fields(“ProductName”)& “</OPTION>”

Produtos.MoveNext

Loop

</SELECT>

<BR>

<HR>

</FORM>

</BODY>

</HTML>

Para esta listagem vamos comentar apenas o código ASP que constrói a lista com os nomes de produtos disponíveis. Lembrando da nossa revisão de HTML, o código para construir uma Caixa de combinação é o seguinte: <SELECT id=select1 name=Item1> <OPTION value=Item1>Item1</OPTION> <OPTION value=Item2>Item2</OPTION>

363

Criando Sites Dinâmicos com ASP 3.0

Neste exemplo temos uma lista com três itens. Para cada produto encontrado devemos criar um item da lista, o que é feito com as tags <OPTION> </OPTION>. Por exemplo, para o produto “Alice Mutton”, teríamos que criar a seguinte opção: <OPTION value=Alice Mutton>Alice Mutton</OPTION>

A primeira vez que aparece o nome – value=Alice Mutton – é a designação do nome associado com cada opção. Na segunda vez que aparece o nome, é a definição do texto que será exibido na lista. Para construir esta lista dinamicamente, utilizamos o seguinte código ASP: 33

Do While Not Produtos.EOF

Response.Write “<OPTION value=” & Chr(34) & Produtos.Fields(“ProductName”) & Chr(34) & “>” & Produtos.Fields(“ProductName”)& “</OPTION>”

35 36

Produtos.MoveNext Loop

Para preencher a lista com os nomes do produto, utilizamos Produtos.Fields(“ProductName”), com isso, vou construindo uma nova opção da lista, para cada nome de produto encontrado na tabela Produtos. É justamente isto que queremos. A construção dinâmica de listas é bastante útil, sendo que esta técnica pode ser aplicada em diversas situações práticas no desenvolvimento de aplicações Web.

IMPORTANTE Observe que utilizamos Chr(34) antes e depois de Produtos.Fields(“ProductName”), na definição do atributo value, conforme indicado a seguir: Chr(34) & Produtos.Fields(“ProductName”) & Chr(34)

Isto é feito para tratar o caso de nomes de produtos que tem espaço em branco no nome. Se não utilizássemos as aspas (Chr(34)), somente o primeiro nome do produto seria utilizado. Por exemplo, um produto chá mate, seria truncado em chá. Com isso, na hora de pesquisar o nome do produto, não iríamos encontrá-lo na tabela Produtos. Ao carregarmos a página produto.asp, obteremos o resultado indicado na Figura 6.9. Nesta página o usuário seleciona o produto a ser alterado, conforme indicado na Figura 6.10, onde o usuário selecionou o produto Camembert Pierrot. Após selecionar o produto, o usuário clica no botão Localizar Produto. Ao fazer isso, é chamada a página localiza.asp, que irá carregar o registro correspondente ao produto selecionado.

364

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

Figura 6.9: A página produto.asp.

Figura 6.10: O usuário seleciona um produto na lista de produtos.

A Página que Localiza o Registro do Produto a ser Atualizado – localiza.asp A página localiza.asp é indicada na Listagem 6.5.

365

Criando Sites Dinâmicos com ASP 3.0

Listagem 6.5 – Página ASP que carrega o registro a ser alterado. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<TITLE>Altere os dados do produto.</TITLE>

<BODY>

‘O primeiro passo é criar a conexão com o banco de dados.

‘Para isto crio um objeto do tipo Connection.

‘Cria um objeto do tipo ADODB.Connection

Set conn=Server.CreateObject(“ADODB.Connection”)

‘Agora abro uma conexão com o arquivo nwind.mdb

‘utilizando OLE DB.

conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0;

conn.Open

‘Agora criamos um objeto RecordSet.

‘Este objeto irá acessar os campos

‘da tabela Produtos

Set Produtos = Server.CreateObject(“ADODB.Recordset”)

inst_sql=“Select * from Produtos WHERE Produtos.ProductName=‘” & Request.Form(“listaprodutos”)& “’”

Produtos.Open inst_sql,conn,3,3

‘Neste ponto tenho o objeto Produtos ligado com a tabela

‘Produtos do banco de dados nwind.mdb.

DATA SOURCE=c:\meus documentos\nwind.mdb”

<P><FONT color=navy size=5><STRONG>Altere os campos que forem necessários.</STRONG></FONT></P>

<P><I><B><FONT size=4> Depois clique no botão Atualizar Produto</FONT>.</B></I></P>

366

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

‘Agora construo o formulário e exibo os dados

‘do produto para que o usuário possa alterar

‘os campos que forem necessários.

<TABLE>

Response.Write “<TR><TD>Código:</TD><TD><INPUT id=ProductID maxLength=10 name=ProductID size=10 value=” & Chr(34)& Produtos.Fields(“ProductID”) & Chr(34)& “></TD></TR>”

Response.Write “<TR><TD>Nome:</TD><TD><INPUT id=ProductName maxLength=35 name=ProductName size=35 value=” & Chr(34)& Produtos.Fields(“ProductName”) & Chr(34)& “></TD></TR>”

Response.Write “<TR><TD>Fornecedor:</TD><TD><INPUT id=SupplierID maxLength=30 name=SupplierID size=15 value=” & Chr(34) & Produtos.Fields(“SupplierID”) & Chr(34) & “></TD></TR>”

Response.Write “<TR><TD>Categoria:</TD><TD><INPUT id=CategoryIDmaxLength=10 name= CategoryID size=10 value=” & Chr(34) & Produtos.Fields(“CategoryID”) & Chr(34) & “></TD></TR>”

Response.Write “<TR><TD>Quant/unid:</TD><TD><INPUT id=QuantityPerUnit maxLength=20 name=QuantityPerUnit size=20 value=” & Chr(34) & Produtos.Fields(“QuantityPerUnit”) & Chr(34) & “></TD></TR>”

Response.Write “<TR><TD>Preço Unit:</TD><TD><INPUT id=UnitPrice 42 maxLength=10 name=UnitPrice size=10 value=” & Chr(34) & 43 Produtos.Fields (“UnitPrice”) & Chr(34) & “></TD></TR>”

Response.Write “<TR><TD>Estoque:</TD><TD><INPUT id=UnitsInStockmaxLength=10 name=UnitsInStock size=10 value=” & Chr(34) & Produtos.Fields(“UnitsInStock”) & Chr(34) & “></TD></TR>”

Response.Write “<TR><TD>Unid. Pedid:</TD><TD><INPUT id=UnitsOnOrder maxLength=10 name=UnitsOnOrder size=10 value=” & Chr(34) & 45Produtos.Fields(“UnitsOnOrder”) & Chr(34) & “></TD></TR>”

367

Criando Sites Dinâmicos com ASP 3.0

Response.Write “<TR><TD>Nível Ordenação:</TD><TD><INPUT id=ReorderLevel maxLength=10 name=ReorderLevel size=10 value=” & Chr(34) & Produtos.Fields(“ReorderLevel”) & Chr(34) & “></TD></TR>”

Response.Write “<TR><TD>Descontinuado:</TD><TD><INPUT id=Discontinued maxLength=10 name=Discontinued size=10 value=” & Chr(34) & Produtos.Fields(“Discontinued”) & Chr(34) & “></TD></TR>”

</TABLE>

<BR>

<HR>

</FORM>

</BODY>

</HTML>

NOTA Algumas linhas aparecem divididas em duas ou mais linhas. Nunca é demais lembrar que as mesmas devem ser digitadas como uma linha única; apenas estão exibidas, em duas ou mais linhas, por questão de espaço.

Alguns comentários sobre o código: ➥ Primeiro vamos tratar da construção da instrução SQL, conforme indicado no seguinte trecho de código: 20 inst_sql=“Select * from Produtos WHERE Produtos.ProductName=‘” & Request.Form(“listaprodutos”)& “’”

Esta é uma instrução SQL, que utiliza a cláusula WHERE para pesquisar apenas o registro cujo nome do produto foi selecionado na lista de produtos. Vamos supor que o usuário tenha selecionado o produto Geitost. A instrução SQL para localizar o registro para este produto, deve ser a seguinte: Select * from Produtos WHERE Produtos.ProductName=‘Geitost’

Observe no código da linha 20 que colocamos o apóstrofe logo após o sinal de igual (=), depois utilizamos Request.Form(“listaprodutos”), para capturar o valor do produto que o usuário selecionou na lista de produtos e, finalmente, anexamos o apóstrofe final (“ ’ ”). Com isso o código ASP monta a instrução SQL correta, seja qual for o produto selecionado na lista de produtos. Um detalhe importante a ser observado é que o critério, quando for um campo de texto, deve vir entre os sinais de apóstrofe. Já para um campo do tipo data, o critério deve vir entre os sinais #.

368

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

Uma vez montada a instrução SQL corretamente, a mesma é passada como parâmetro para o método Open do RecordSet Produtos. Com isso, apenas o registro para o produto selecionado, será retornado pelo banco de dados. ➥ Após termos recuperado o registro para o produto selecionado, passamos a montar um formulário, onde são exibidos os diversos campos do produto selecionado. Observe que utilizamos uma tabela para facilitar o posicionamento e o alinhamento dos campos. Cada uma das linhas da tabela, possui duas colunas: uma onde vai a descrição do campo e outra que exibe o campo propriamente dito. No exemplo abaixo, é montada a primeira linha da tabela, onde é exibido o campo ProductID: 35 Response.Write “<TR><TD>Código:</TD><TD><INPUT id=ProductID maxLength=10 name=ProductID size=10 value=“ & Chr(34)& Produtos.Fields(“ProductID”) & Chr(34)& “></TD></TR>”

Uma linha semelhante é utilizada para todos os demais campos do produto selecionado. ➥ Na Figura 6.11, o usuário selecionou o produto Queso Cabrales.

Figura 6.11: O usuário seleciona o produto a ser alterado. Ao clicar no botão “Localizar Produto”, será chamada a página localiza.asp, a qual localiza o registro do produto selecionado e exibe o mesmo em um formulário, para que o usuário possa alterar os campos que forem necessários, conforme indicado na Figura 6.12. O usuário pode alterar um ou mais campos, simplesmente clicando no campo e digitando um novo valor. Após ter alterado os campos necessários, é só clicar no botão Atualizar Produto, que os dados para o produto serão atualizados na tabela Produtos do banco de dados nwind.mdb.

369

Criando Sites Dinâmicos com ASP 3.0

Figura 6.12: O usuário pode alterar quaisquer campos do produto.

A Página que Atualiza os Dados na Tabela Produtos do Banco de Dados Nwind.mdb – Atualiza.asp Quando o usuário clica no botão Atualizar Produto, é chamada a página atualiza.asp, a qual é indicada na Listagem 6.6. Listagem 6.6 – Página ASP que atualiza os dados no banco de dados – atualiza.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<TITLE>Dados atualizados com sucesso.</TITLE>

<BODY>

‘O primeiro passo é criar a conexão com o banco de dados.

370

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

‘Para isto crio um objeto do tipo Connection.

‘Cria um objeto do tipo ADODB.Connection

Set conn=Server.CreateObject(“ADODB.Connection”)

‘Agora abro uma conexão com o arquivo nwind.mdb

‘utilizando OLE DB.

conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0; DATA SOURCE=c:\meus documentos\nwind.mdb”

conn.Open

‘Agora criamos um objeto RecordSet.

‘Este objeto irá acessar o registro do Produto

‘que será alterado.

Set Produtos = Server.CreateObject(“ADODB.Recordset”)

inst_sql=“Select * from Produtos WHERE Produtos.ProductName=‘” & Request.Form(“ProductName”)& “’”

Produtos.Open inst_sql,conn,3,3

‘Começo a alterar os campos do registro

Produtos.Fields(“ProductName”)= Request.Form(“ProductName”)

Produtos.Fields(“SupplierID”)= Request.Form(“SupplierID”)

Produtos.Fields(“CategoryID”)= Request.Form(“CategoryID”)

Produtos.Fields(“QuantityPerUnit”)= Request.Form(“QuantityPerUnit”)

Produtos.Fields(“UnitPrice”)= Request.Form(“UnitPrice”)

Produtos.Fields(“UnitsInStock”)= Request.Form(“UnitsInStock”)

Produtos.Fields(“UnitsOnOrder”)= Request.Form(“UnitsOnOrder”)

Produtos.Fields(“ReorderLevel”)= Request.Form(“ReorderLevel”)

Produtos.Fields(“Discontinued”)= Cbool(Request.Form(“Discontinued”))

‘Atualizo o registro, utilizando o método Update.

Produtos.Update

Response.Write “PRODUTO :”

Response.Write Request.Form(“ProductName”)

Response.Write “ Atualizado com sucesso <BR>”

Response.Write “<HR>”

<A HREF=produto.asp>Clique aqui para atualizar outro produto</A>

</BODY>

</HTML>

Para atualizar o registro utilizamos o seguinte código: 23

Produtos.Fields(“ProductName”)= Request.Form(“ProductName”)

Produtos.Fields(“SupplierID”)= Request.Form(“SupplierID”)

Produtos.Fields(“CategoryID”)= Request.Form(“CategoryID”)

Produtos.Fields(“QuantityPerUnit”)= Request.Form(“QuantityPerUnit”)

371

Criando Sites Dinâmicos com ASP 3.0

Produtos.Fields(“UnitPrice”)= Request.Form(“UnitPrice”)

Produtos.Fields(“UnitsInStock”)= Request.Form(“UnitsInStock”)

Produtos.Fields(“UnitsOnOrder”)= Request.Form(“UnitsOnOrder”)

Produtos.Fields(“ReorderLevel”)= Request.Form(“ReorderLevel”)

Produtos.Fields(“Discontinued”)= Cbool(Request.Form(“Discontinued”))

‘Atualizo o registro, utilizando o método Update.

Produtos.Update

Cada campo do registro recebe o valor contido no campo respectivo do formulário da Figura 6.12. Depois utilizamos o método Update para atualizar o registro. No momento que chamamos o método Update é que as atualizações são gravadas no banco de dados.

Utilizando o Nosso Exemplo de Alteração de Registro Vamos utilizar o nosso exemplo, passo a passo, para que possamos visualizar o funcionamento completo do mesmo. Conforme indicado na Figura 6.13, carregamos a página produto.asp e selecionamos o produto Ravioli Angelo.

Figura 6.13: Selecionando o produto Ravioli Angelo. Ao clicarmos no botão Localizar Produto, é carregada a página localiza.asp, a qual nos exibe os campos do produto Ravioli Angelo, conforme indicado na Figura 6.14. Nesta página vamos alterar o valor do campo Preço Unit. Vamos alterar de 19,52 para 25,34, conforme indicado na Figura 6.15.

372

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

Figura 6.14: O registro do produto Ravioli Angelo foi localizado.

Figura 6.15: Alterando o valor do campo Preço Unit. Ao clicar no botão Atualizar Produto, é chamada a página atualiza.asp, que faz as atualizações no banco de dados, exibe uma mensagem de que estas atualizações foram feitas com sucesso

373

Criando Sites Dinâmicos com ASP 3.0

e apresenta um link para que o usuário possa voltar para a página produto.asp para selecionar um outro produto a ser atualizado, conforme indicado na Figura 6.16.

Figura 6.16: Os dados foram alterados com sucesso. Na Figura 6.17, abrimos a tabela Produtos do banco de dados C:\meus documentos\ nwind.mdb, na qual podemos comprovar que o preço unitário para o produto Ravioli Angelo foi realmente alterado para 25,34.

Figura 6.17: Comprovando as alterações efetuadas.

IMPORTANTE Veja que através da utilização de ASP podemos construir aplicações Web com as mesmas funcionalidades de banco de dados existentes em aplicações tradicionais. Podemos inserir, pesquisar e alterar registros. No próximo item aprenderemos a eliminar registros, utilizando ASP.

374

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

Eliminando Registros de um Banco de Dados Neste tópico aprenderemos a criar uma página ASP que elimina um registro do banco de dados. Nosso exemplo será composto dos seguintes elementos: ➥ Uma página ASP – produto.asp, onde temos um campo com a listagem de produtos disponíveis na tabela Produtos, do banco de dados Nwind. Esta listagem será construída dinamicamente, isto é, cada vez que a página for carregada, a listagem será construída a partir das informações disponíveis na tabela Produtos. Está página já foi construída no exemplo do item anterior, consulte a Listagem 6.4. ➥ Após selecionar o produto a ser alterado, o usuário clica em um botão Localizar produto. Feito isso, a página produto.asp chama uma página chamada localiza.asp, a qual localiza o registro selecionado no banco de dados. Com isso, o usuário pode conferir se este realmente é o produto que ele deseja eliminar. Esta página já foi construída no item anterior, consulte a Listagem 6.5, sendo que apenas iremos alterar a legenda do botão de comando, ao invés de Alterar Produto, teremos Excluir Produto. Também será alterado o atributo action da tag FORM, para que aponte para a página exclui.asp, ao invés de apontar para a página atualiza.asp. ➥ Após conferir se o produto a ser excluído é o que está sendo exibido, o usuário clica no botão Excluir produto. Então, a página localiza.asp chama a exclui.asp, que acessa o banco de dados e exclui o produto selecionado pelo usuário. Ao final é emitida uma mensagem indicando que os dados foram atualizados com sucesso.

A Página ASP Para Excluir o Produto Selecionado – Exclui.asp Na Listagem 6.7 temos o código ASP para a criação da página exclui.asp. Listagem 6.7 – Página ASP para excluir o produto selecionado – exclui.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<TITLE>Produto excluído com sucesso.</TITLE>

<BODY>

‘O primeiro passo é criar a conexão com o banco de dados.

‘Para isto crio um objeto do tipo Connection.

375

Criando Sites Dinâmicos com ASP 3.0

‘Cria um objeto do tipo ADODB.Connection

Set conn=Server.CreateObject(“ADODB.Connection”)

‘Agora abro uma conexão com o arquivo nwind.mdb

‘utilizando OLE DB.

conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0;

conn.Open

‘Agora criamos um objeto RecordSet.

‘Este objeto irá acessar o registro do Produto

DATA SOURCE=c:\meus documentos\nwind.mdb”

‘que será excluído.

Set Produtos = Server.CreateObject(“ADODB.Recordset”)

inst_sql=“Select * from Produtos WHERE Produtos.ProductName=‘” & Request.Form (“ProductName”)& “’”

Produtos.Open inst_sql,conn,3,3

If Produtos.RecordCount <> 1 Then

Response.Write “<B>O produto não existe, ou ”

Response.Write “existe mais do que um <BR> produto com este nome: </B>”

25 26

Response.Write Request.Form(“ProductName”) Else

Produtos.Delete

Response.Write “PRODUTO: ”

Response.Write Request.Form(“ProductName”)

Response.Write “ foi excluído da tabela de Produtos. <BR>”

End If

Response.Write “<HR>”

<A HREF=produto.asp>Clique aqui para selecionar outro produto a ser excluído.</A>

</BODY>

</HTML>

NOTA Algumas linhas aparecem divididas em duas ou mais linhas. Nunca é demais lembrar que estas devem ser digitadas como uma linha única. As mesmas estão exibidas em duas ou mais linhas apenas por questão de espaço.

Comentário sobre o código: ➥ A única novidade na Listagem 6.7 é o trecho indicado a seguir: 22 23

If Produtos.RecordCount <> 1 Then Response.Write “<B>O produto não existe, ou ”

376

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

24 25 26

Response.Write “existe mais do que um <BR> produto com este nome: </B>” Response.Write Request.Form(“ProductName”) Else

Produtos.Delete

Response.Write “PRODUTO: ”

Response.Write Request.Form(“ProductName”)

30 31

Response.Write “ foi excluído da tabela de Produtos. <BR>” End If

Neste código utilizamos o método RecordCount para verificar se não foi encontrado nenhum produto (RecordCount = 1) ou foi encontrado mais do que um produto (RecordCount>1). Nestas duas situações informamos que o produto não existe ou existe mais do que um produto com o nome selecionado. Em ambos os casos não podemos utilizar o método Delete. Caso tenha sido encontrado somente um registro (RecordCount = 1), utilizamos o método Delete do objeto Produtos, para eliminar o registro encontrado. Neste exemplo, utilizamos o método Delete sem nenhum parâmetro, o que faz com que seja eliminado somente o registro atual. Podemos passar um parâmetro para o método Delete, o qual altera o comportamento do mesmo. Para isso utilizaríamos a seguinte sintaxe: RecordSet.Delete parâmetro

Na Tabela 6.11, descrevemos os valores mais utilizados para o parâmetro do método Delete. Tabela 6.11 Valores de parâmetro para o método Delete. Valor

Descrição

Elimina o registro atual, isto é, o registro no qual está o indicador de registros.

Elimina somente os registros selecionados através da utilização da propriedade Filter do objeto RecordSet. A propriedade Filter já deve ter sido definida anteriormente.

Elimina todos os registros do objeto RecordSet.

Utilizando o Nosso Exemplo de Exclusão de Registro Vamos utilizar o nosso exemplo, passo a passo, para que possamos visualizar o funcionamento completo do mesmo. Conforme indicado na Figura 6.18, carregamos a página produto.asp e selecionamos o produto Filo Mix.

377

Criando Sites Dinâmicos com ASP 3.0

Figura 6.18: Selecionando o produto Filo Mix. Ao clicarmos no botão Localizar Produto, é carregada a página localiza.asp, a qual nos exibe os campos do produto Filo Mix, conforme indicado na Figura 6.19.

Figura 6.19: O registro do produto Filo Mix foi localizado.

378

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

Os dados do produto Filo Mix são exibidos para que o usuário confira se este realmente é o produto a ser excluído no banco de dados. Para excluir o produto selecionado é só clicar no botão Excluir Produto. Ao clicar no botão Excluir Produto, é chamada a página exclui.asp, que exclui o produto selecionado, e exibe uma mensagem de que a exclusão foi realizada com sucesso e apresenta um link para que o usuário possa voltar para a página produto.asp para selecionar um outro produto a ser excluído, conforme indicado na Figura 6.20.

Figura 6.20: O produto Filo Mix foi excluído com sucesso. Na Figura 6.21, abrimos a tabela Produtos do banco de dados C:\meus documentos\ nwind.mdb, na qual podemos comprovar que o produto Filo Mix foi realmente excluído.

Figura 6.21: Comprovando a exclusão do produto Filo Mix.

379

Criando Sites Dinâmicos com ASP 3.0

A Propriedade Filter do Objeto RecordSet Podemos configurar a propriedade Filter para exibir apenas um conjunto de registros que satisfaçam uma ou mais condições. Por exemplo, posso ter criado um RecordSet que retorna todos os registros da tabela Pedidos (Orders) do banco de dados nwind.mdb. Depois posso configurar a propriedade Filter para que somente sejam exibidos os registros cujo País de destino seja o Brasil. A configuração da propriedade Filter apenas faz com que seja limitada a visibilidade do RecordSet. Podemos redefinir a propriedade Filter, de tal maneira que todos os registros voltem a estar disponíveis. Na Listagem 6.8, criamos uma página que acessa a tabela Orders, do banco de dados nwind.mdb. São recuperados os campos OrderID, OrderDate, ShipCity e ShipCountry. Depois utilizamos a propriedade Filter, para exibir somente os pedidos para o ano de 1994. Listagem 6.8 – Exibindo somente os pedidos para o ano de 1994 – filter_pedidos.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<TITLE>Utilizando a propriedade Filter.</TITLE>

<BODY>

‘O primeiro passo é criar a conexão com o banco de dados.

‘Para isto crio um objeto do tipo Connection.

‘Cria um objeto do tipo ADODB.Connection

Set conn=Server.CreateObject(“ADODB.Connection”)

‘Agora abro uma conexão com o arquivo nwind.mdb

380

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

‘utilizando OLE DB.

conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0;DATA SOURCE=c:\meus documentos\nwind.mdb”

conn.Open

‘Agora criamos um objeto RecordSet.

‘Este objeto irá acessar o campo ProductName

‘da tabela Orders.

Set Pedidos = Server.CreateObject(“ADODB.Recordset”)

inst_sql=“SELECT Orders.OrderID, Orders.OrderDate, Orders.ShipCity, Orders. ShipCountry, Year([OrderDate]) AS AnoPedido FROM Orders Order By ShipCountry ”

Pedidos.Open inst_sql, conn, 3, 3

‘Neste ponto tenho o objeto Pedidos ligado com a tabela

‘Produtos do banco de dados nwind.mdb.

<P><FONT color=navy size=6><B>Empresa ABC Ltda.</B></FONT></P>

<P><B><I>Listagem de Produtos para o ano de: <FONT color=red>1994</FONT>

</I></B>

<HR>

</P>

‘Configura a propriedade Filter para exibir

‘somente os registros em que o ano do campo

‘OrderDate é igual a 1994.

Pedidos.Filter = “AnoPedido=1994”

‘Agora construo uma tabela para exibir os resultados.

381

Criando Sites Dinâmicos com ASP 3.0

<TABLE>

<TR>

<TD>Código</TD>

<TD>Cidade</TD>

</TR>

Pedidos.MoveFirst

Do Until Pedidos.EOF %>

<TR>

<TD><% =Pedidos.Fields(“OrderID”)

%></TD>

<TD><% =Pedidos.Fields(“OrderDate”)

%></TD>

<TD><% =Pedidos.Fields(“ShipCity”)

%></TD>

<TD><% =Pedidos.Fields(“AnoPedido”)

%></TD>

</TR>

Pedidos.MoveNext

Loop

</TABLE>

</BODY>

</HTML>

Ao carregarmos esta página, obteremos o resultado indicado na Figura 6.22.

382

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

Figura 6.22: Pedidos para o ano de 1994. Vamos fazer alguns comentários sobre o código. ➥ Primeiro gostaria de comentar a construção da instrução SQL: 20

inst_sql=“SELECT Orders.OrderID, Orders.OrderDate, Orders.ShipCity, Orders.ShipCountry, Year([OrderDate]) AS AnoPedido FROM Orders Order By ShipCountry”

Observe que na instrução SQL, utilizamos a função Year(NomeDoCampo), para criar um campo chamado AnoPedido, o qual contém apenas o ano da data do Pedido. Esta construção mostra o poder e a simplicidade da linguagem SQL, motivo pelo qual foi colocado anteriormente sobre a importância de aprendermos a utilizar com eficiência a linguagem SQL. ➥ Agora vamos observar a utilização da propriedade Filter, no seguinte fragmento de código: 34

Pedidos.Filter = “AnoPedido=1994”

Com este comando estamos restringindo os registros de tal forma que somente sejam exibidos os registros cujo campo AnoPedido seja igual a 1994. Para salientar a flexibilidade desta propriedade, vamos considerar um outro exemplo. Vamos supor que seja necessário exibir apenas os pedidos para o ano de 1994 e cujo país de destino fosse o Brazil (com “z” porque no banco de dados Nwind está com “z”). Para obter este resultado, bastaria definir a propriedade Filter da seguinte maneira: Pedidos.Filter = “AnoPedido=1994 And ShipCountry=“Brazil’”

383

Criando Sites Dinâmicos com ASP 3.0

Quando queremos que os registros atendam a dois ou mais critérios, simultaneamente, utilizamos o operador And. Neste caso somente serão exibidos os registros em que o campo AnoPedido for 1994 e o campo ShipCountry for Brazil, conforme indicado na Figura 6.23.

Figura 6.23: Pedidos para o “Brazil” no ano de 1994. Vamos refinar um pouco mais. Vamos fazer com que sejam exibidos apenas os registros para o ano de 1994 e para Brazil ou Germany (Alemanha). Pedidos.Filter = “(AnoPedido=1994 And ShipCountry=‘Brazil’) OR (AnoPedido=1994 And ShipCountry=‘Germany’)”

Este comando deve ser digitado em uma única linha, além disso os espaços devem ser rigorosamente respeitados. Após fechar parênteses, apenas um espaço, após o OR mais um espaço e assim por diante. Na Figura 6.24 temos o resultado desta pesquisa, na qual são exibidos apenas os pedidos para o Brazil e para a Germany, no ano de 1994. Observe que, com a correta utilização da propriedade Filter, podemos obter resultados interessantes. Voltaremos a utilizar esta propriedade em outros exemplos deste livro. Para eliminar qualquer filtro aplicado e voltar a disponibilizar todos os registros, basta utilizar os seguinte comando: Pedidos.Filter = “ ”

384

Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I

Figura 6.24: Pedidos para “Brazil” e para “Germany” no ano de 1994. Com isso elimino qualquer filtro que tenha sido aplicado. Também podemos utilizar o operador Like para fazer uma pesquisa por padrões. Por exemplo, vamos supor que queremos filtrar apenas os registros cujo campo NomeCliente inicie com a letra J. Poderíamos utilizar o seguinte comando: Pedidos.Filter = “NomeCliente Like ‘J%’ ”

Neste caso o % funciona como um caractere curinga, isto é, a primeira letra do nome deve ser J e o que vem depois não importa. Neste caso seriam retornados registros tais como: ➥ José da Silva ➥ Juvenal Pereira ➥ Júlio Battisti

Conclusão No início do capítulo aprendemos a estabelecer conexões com banco de dados, sem utilizar ODBC. Fizemos isto, definimos a propriedade ConnectionString do objeto Connection,

385

Criando Sites Dinâmicos com ASP 3.0

acessando as fontes de dados utilizando o provedor OLE DB para cada fonte. Foram apresentados exemplos para o Microsoft Access, Microsoft SQL Server e ORACLE. Neste capítulo também fizemos um estudo detalhado do objeto RecordSet. Saber utilizar o objeto RecordSet é de fundamental importância para a criação de aplicações Web com acesso a bancos de dados. Estudamos os diversos métodos, propriedades e eventos deste objeto. Aprendemos a criar páginas ASP que fazem operações bastante comuns em aplicações Web, tais como: ➥ Pesquisar registros em um banco de dados. ➥ Alterar registros. ➥ Eliminar registros. ➥ Fazer a validação dos dados digitados em um formulário. ➥ Filtrar os registros retornados por um objeto RecordSet.

386

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

Capítulo 7 Bancos de Dados com ASP – Conceitos Avançados Parte II

387

Criando Sites Dinâmicos com ASP 3.0

Neste capítulo serão apresentados mais alguns tópicos sobre o acesso a banco de dados. Iniciaremos por um estudo do objeto Command, o qual pode ser utilizado para retornar um conjunto de registros em um objeto RecordSet e para efetuar operações que envolvem diversos registros – como, por exemplo, atualizar o campo PreçoUnitário em todos os registros da tabela Produtos. O objeto Command também pode ser utilizado para passar parâmetros para uma Consulta Parametrizada. Faremos um exemplo completo sobre a passagem de parâmetros para uma Consulta Parametrizada do Microsoft Access. Com a utilização de Consultas Parametrizadas podemos criar páginas ASP bastante flexíveis, que nos permitem executar consultas de maneira interativa com o banco de dados. O usuário seleciona um valor para um ou mais parâmetros e executa a consulta. Caso deseje uma nova consulta é só selecionar novos valores para os parâmetros e executar novamente a consulta. Com isso podemos obter uma série de resultados de maneira simples e prática. Veremos exemplos de acesso a banco de dados com a utilização dos métodos e propriedades do objeto Command. Serão apresentadas tabelas com a descrição dos principais métodos e propriedades deste objeto. A utilização do objeto Command é especialmente indicada para situações onde temos que passar parâmetros para Consultas Parametrizadas ou para Stored Procedures. Através da utilização do objeto Command e de seus métodos, propriedades e coleções, podemos criar os diversos parâmetros necessários, passá-los para o banco de dados e, até mesmo, receber valores de retorno de Stored Procedures em parâmetros definidos para o objeto Command. Também estudaremos o objeto Parameter, utilizado na criação e definição dos parâmetros a serem utilizados pelo objeto Command. Veremos como criar e definir um determinado parâmetro. Também serão apresentadas tabelas com a descrição dos principais métodos e propriedades dos diversos objetos estudados. Na seqüência, analisaremos mais alguns exemplos de pesquisa em banco de dados, utilizando páginas ASP. Trataremos um pouco mais sobre a construção de instruções SQL avançadas, as quais utilizam o operador Like e funções de agregação como Sum, Avg, Min e Max. Também trataremos, diretamente em uma instrução SQL, da utilização dos operadores And e Or, bem como de funções como Year, Month e Day. Como exemplo de aplicação, no final do capítulo, criaremos um formulário que permite que o próprio usuário defina a pesquisa a ser realizada. No formulário, o usuário poderá fazer pesquisa na tabela Orders do banco de dados Nwind. O usuário poderá decidir se deseja fazer a pesquisa por País de destino, País de destino e Cidade, por Ano da Data do Pedido ou

388

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

Mês da Data do Pedido. Também utilizaremos o modelo de eventos do Internet Explorer para ativar ou desativar campos à medida em que o usuário seleciona opções no formulário. Neste capítulo, estaremos utilizando como exemplo o banco de dados nwind.mdb do Microsoft Access. Existem pequenas diferenças na linguagem SQL do Microsoft Access e do Microsoft SQL Server. Para maiores detalhes sobre a criação de instruções com o Microsoft SQL Server, consulte a documentação do produto.

O Objeto Command Utilizamos o objeto Command para definir um determinado “comando” que deverá ser executado em um fonte da dados, como um banco de dados do Microsoft Access ou do Microsoft SQL Server. O objeto Command é especialmente indicado para a execução de comandos que necessitem de parâmetros, com por exemplo, Stored Procedures de um banco de dados do Microsoft SQL Server, ou Consultas Parametrizadas do Microsoft Access.

NOTA Uma Consulta Parametrizada é um tipo especial de consulta, a qual espera receber um ou mais valores (os parâmetros). Os valores recebidos são utilizados, normalmente, como critérios de pesquisa, de tal forma que somente serão retornados os registros que atenderem os critérios especificados. Por exemplo, poderíamos ter um parâmetro no campo ShipCountry da tabela Orders do banco de dados nwind.mdb. Se passarmos para este parâmetro o valor Germany, serão retornados apenas os registros em que o campo ShipCountry for igual a Germany.

Um Breve Introdução ao Objeto Command Para criar um objeto Command utilizamos a seguinte sintaxe: Set nome_objeto = Server.CreateObject(“ADODB.Command”)

O exemplo, a seguir, cria o objeto Command chamado Pedidos: Set Pedidos = Server.CreateObject(“ADODB.Command”).

IMPORTANTE Nunca é demais lembrar que, para criar um objeto, devemos utilizar o operador Set, caso contrário obteremos um erro quando a página for carregada.

Para iniciarmos o estudo do objeto Command, vamos analisar o exemplo da Listagem 7.1.

389

Criando Sites Dinâmicos com ASP 3.0

Listagem 7.1 – Utilizando o objeto Command para retornar dados – command1.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<TITLE>Utilizando o objeto Command.</TITLE>

<BODY>

‘O primeiro passo é criar a conexão com o banco de dados.

‘Para isto crio um objeto do tipo Connection.

‘Cria um objeto do tipo ADODB.Connection

Set conn=Server.CreateObject(“ADODB.Connection”)

‘Agora abro uma conexão com o arquivo nwind.mdb

‘utilizando OLE DB.

conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0;

conn.Open

‘Agora crio um objeto do tipo Command, o qual será,

‘automaticamente, associado com a conexão conn.

Set com_orders = Server.CreateObject(“ADODB.Command”)

com_orders.CommandText = “Select * From Orders Order By OrderDate”

com_orders.ActiveConnection = conn

‘Agora retorno o resultado do comando, utilizando o

DATA SOURCE=c:\meus documentos\nwind.mdb”

‘método Execute.

‘Este resultado será armazenado em um objeto RecordSet

‘chamado Ped.

Set Ped= Server.CreateObject(“ADODB.RecordSet”)

Set Ped=com_orders.Execute

390

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

<HR>

<TABLE>

<TR>

<TD>Código</TD>

<TD>Data

</TD>

</TR>

34 35

Do Until Ped.EOF

<TR>

<TD><%=Ped.Fields(“OrderID”)

%> </TD>

</TR>

Ped.MoveNext

Loop

</TABLE>

<HR>

</BODY>

</HTML>

Ao carregarmos este arquivo obtemos o resultado indicado na Figura 7.1. A novidade na Listagem 7.1 é a utilização do objeto Command para a obtenção do RecordSet Ped. Vamos analisar os métodos e propriedades que foram utilizados. Primeiro criamos um objeto do tipo Command, conforme indicado pelo seguinte comando: 18

Set com_orders = Server.CreateObject(“ADODB.Command”)

391

Criando Sites Dinâmicos com ASP 3.0

Figura 7.1: Carregando a página comand1.asp. O próximo passo é definir a propriedade CommandText. Esta propriedade foi configurada com a instrução SQL que deverá ser executada no banco de dados, para retornar os registros desejados. No nosso exemplo, a instrução SQL retorna todos os registros da tabela Orders e ordena a listagem pelo campo OrderDate, conforme indicado no seguinte comando: 19

com_orders.CommandText = “Select * From Orders Order By OrderDate”

Em seguida definimos a conexão com a qual o objeto com_orders está associado. Para isto definimos a propriedade ActiveConnection, conforme indicado no seguinte comando: 20

com_orders.ActiveConnection = conn

A partir de agora, os comandos executados pelo objeto Command serão executados na conexão conn, que está ligada ao banco de dados nwind.mdb. Agora criamos um objeto do tipo RecordSet chamado Ped: 25

Set Ped= Server.CreateObject(“ADODB.RecordSet”)

O último passo é utilizar o método Execute do objeto com_orders. Ao utilizarmos este método, é executada a instrução contida na propriedade CommandText. O resultado é retornado para o objeto RecordSet especificado no comando, conforme indicado abaixo: 26

Set Ped=com_orders.Execute

392

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

Neste caso após a execução do método Execute, os registros retornados estarão armazenados no objeto Ped, o qual é um objeto do tipo RecordSet. Veja que o que fizemos foi, simplesmente, utilizar um objeto Command e as propriedades CommandText, ActiveConnection e o método Execute, para criar um objeto RecordSet com todos os registros da tabela Orders. Você pode estar questionando: “Por que todos esses passos, se podemos simplesmente utilizar o método Open do objeto RecordSet, como já fizemos nos capítulos anteriores?”. A resposta é simples. Estamos estudando o objeto Command porque existem determinadas operações que somente podem ser executadas com este objeto, como por exemplo, passar parâmetros para um Stored Procedure ou uma Consulta Parametrizada. Agora que já fizemos um estudo preliminar do objeto Command, vamos apresentar as demais propriedades e métodos deste objeto.

Os Métodos do Objeto Command Na Tabela 7.1 temos uma descrição dos métodos do objeto Command. Tabela 7.1 Os métodos do objeto Command. Método

Descrição

Cancel

Cancela a execução do método Execute caso a mesma ainda esteja pendente.

CreateParameter

Cria um novo objeto do tipo Parameter. Pode ser utilizado, por exemplo, para passar parâmetros para Consultas Parametrizadas do Microsoft Access.

Execute

Executa uma pesquisa, instrução SQL ou Stored Procedure especificado na propriedade CommandText.

Ainda neste item veremos exemplos de aplicação destes métodos.

As Propriedades do Objeto Command Na Tabela 7.2 temos uma descrição das propriedades do objeto Command.

393

Criando Sites Dinâmicos com ASP 3.0

Tabela 7.2 As propriedades do objeto Command. Propriedade

Descrição

ActiveConnection

Determina a qual conexão o objeto Command estará ligado, isto é, através de qual conexão os comandos serão executados.

CommandText

Contém o texto do comando que será executado contra a conexão definida na propriedade ActiveConnection.

CommandTimeout

Indica por quanto tempo o comando pode ser executado. Caso o comando não retorne um resultado no tempo especificado por esta propriedade, será gerada uma mensagem de erro e a execução do comando será suspensa. O tempo é especificado em segundos e o valor padrão é 30 segundos.

CommandType

Indica o tipo de comando que será executado. Na tabela 7.3 temos uma descrição dos tipos de comandos possíveis.

Name

Indica o nome do objeto Command.

Parameters

Contém todos os objetos do tipo Parameter definidos para o objeto Command.

Prepared

Indica se é para salvar ou não uma versão compilada do objeto Command após a execução do mesmo. O armazenamento de versões compiladas melhora o desempenho do banco de dados. Esta possibilidade depende do banco de dados que está sendo acessado. O Microsoft SQL Server 2000 permite que sejam criadas e armazenadas versões compiladas dos comandos e Store Procedures executados. Assim, da próxima vez que o comando for executado, o mesmo não precisa ser novamente interpretado para gerar a versão compilada. Em ambientes acessados por um grande número de usuários, este recurso pode ser de grande valia para melhorar o desempenho.

Properties

Contém todos os objetos do tipo Property definidos para o objeto Command.

State

Indica se o objeto Command está aberto (Open) ou fechado (Closed). Esta propriedade é somente para leitura.

394

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

Na Tabela 7.3, temos uma relação dos tipos de comandos possíveis, os quais são definidos pela propriedade CommandType. Tabela 7.3 Valores possíveis para a propriedade CommandType. Valor/Constante

Tipo de comando

-1/adCmdUnspecified

Não especifica o tipo de Comando.

1/adCmdText

Avalia o texto definido na propriedade CommandText, o qual pode ser uma instrução SQL ou uma chamada para um Stored Procedure do banco de dados.

2/adCmdTable

Considera o valor da propriedade CommandText como sendo o nome de uma tabela que foi gerada a partir de uma instrução SQL. Somente retorna as colunas definidas pela instrução SQL. Para retornar todas as colunas, devemos utilizar o tipo 512 – adCmdTableDirect.

4/adCmdStoredProc

Considera o valor da propriedade CommandText como sendo o nome de um Stored Procedure.

8/adCmdUnknown

Considera o valor da propriedade CommandText como sendo de tipo desconhecido. É o valor padrão.

256/adCmdFile

Considera o valor da propriedade CommandText como sendo o nome de um RecordSet armazenado em um arquivo.

512/adCmdTableDirect

Considera o valor da propriedade CommandText como sendo o nome de um tabela em que todos os campos são retornados.

A sintaxe para definir a propriedade CommandType é a seguinte: Objeto.CommandType = valor

ou Objeto.CommandType = constante

Observe que podemos utilizar o valor numérico ou uma constante predefinida. Por exemplo, podemos utilizar o valor 1 ou a constante adCmdText para definir o tipo do comando como sendo texto.

395

Criando Sites Dinâmicos com ASP 3.0

Existe um grande número de constantes predefinidas para os objetos ADO. Estas constantes estão localizadas nos seguintes arquivos: ➥ adovbs.inc: Constantes para a linguagem VBScript. ➥ adojavas.inc: Constantes para a linguagem JScript. Estes arquivos estão localizados, normalmente, em uma das seguintes pastas: ➥ Para o Windows 2000 em Português: Arquivos de programas\Arquivos comuns\System\ADO. ➥ Para o Windows 2000 em Inglês: Program Files\Common Files\system\ado. Para que possamos utilizar estas constantes, devemos utilizar uma diretiva include para incluir estes arquivos, ou definir uma referência utilizando a tag a seguir: <!- -METADATA TYPE=“typelib” uuid=”{00000205-0000-0010-8000-00AA006D2EA4}” – ->

Esta tag deve ser incluída dentro da seção <HEAD></HEAD> de cada página ASP que utilizará as constantes ou no arquivo global.asa. Ao serem incluídas no arquivo global.asa, as constantes estarão disponíveis para qualquer página ASP que faça parte da aplicação Web.

NOTA Voltaremos a falar sobre o arquivo global.asa.

Agora vamos ver alguns exemplos de código para o objeto Command, alguns de seus métodos e propriedades. Vamos iniciar criando um objeto Connection e um objeto Command, conforme indicado pelo trecho a seguir: ‘Criamos um objeto do tipo Connection Set conn=Server.CreateObject(“ADODB.Connection”) ‘Agora abro uma conexão com o arquivo nwind.mdb ‘utilizando OLE DB. conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0; DATA SOURCE=c:\meus documentos\nwind.mdb” conn.Open ‘Agora crio um objeto do tipo Command Set com_orders = Server.CreateObject(“ADODB.Command”)

396

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

Uma vez criado o objeto Command, vamos definir qual a conexão que o mesmo utilizará. Para isso definimos a propriedade ActiveConnection: com_orders.ActiveConnection = conn

Agora vamos definir o tipo de comando. Para isso utilizaremos a propriedade CommandType: com_orders.CommandType = 1

Ao invés do valor numérico podemos utilizar a constante equivalente, conforme indicado no exemplo: com_orders.CommandType = adCmdText

Agora vamos definir o comando que o objeto Command executará. Para isso definimos a propriedade CommandText: com_orders.CommandText = “Select * From Orders Order By OrderDate”

Vamos definir o TimeOut em 2 minutos (120 segundos) para a execução deste objeto Command, utilizando a propriedade CommandTimeout: com_orders.CommandTimeout= 120

Agora vamos criar um objeto RecordSet e utilizar o método Execute do objeto Command para retornar registros para o objeto RecordSet: Set Ped= Server.CreateObject(“ADODB.RecordSet”) Set Ped=com_orders.Execute

Consultas Parametrizadas no Microsoft Access Conforme descrito anteriormente, podemos utilizar o objeto Command para passar parâmetros para Consultas Parametrizadas do Microsoft Access ou para Stored Procedures do Microsoft SQL Server. Neste tópico aprenderemos a trabalhar com parâmetros.

NOTA Para saber mais sobre a criação de consultas no Microsoft Access, consulte a documentação do produto ou consulte o livro “Microsoft Access 2000 Curso Básico e Rápido”, da editora Axcel Books.

Na Figura 7.2 temos uma consulta do Microsoft Access. A consulta é baseada na tabela Orders e foram incluídos os seguintes campos: ➥ OrderID ➥ OrderDate ➥ ShipName

397

Criando Sites Dinâmicos com ASP 3.0

➥ ShipCity ➥ ShipCountry

Figura 7.2: Consulta no Microsoft Access. Ao executarmos esta consulta, no Microsoft Access, são exibidos todos os pedidos, pois nenhum critério de filtragem foi imposto. Na Figura 7.3, vemos o resultado da execução desta consulta.

Figura 7.3: Execução da consulta sem critérios de filtragem.

398

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

Podemos definir um critério de filtragem. Por exemplo, queremos que sejam exibidos os pedidos apenas para a Argentina. Para isso poderíamos especificar um critério para o campo ShipCountry, conforme indicado na Figura 7.4.

Figura 7.4: Especificando um critério para o campo ShipCountry. Ao executarmos esta consulta, no Microsfot Access, serão exibidos apenas os pedidos em que o campo ShipCountry seja igual a Argentina. Na Figura 7.5, vemos o resultado da execução desta consulta.

Figura 7.5: Execução da consulta com um critério de pesquisa.

399

Criando Sites Dinâmicos com ASP 3.0

Observe que somente foram exibidos os pedidos para a Argentina, o que confirma o correto funcionamento do critério que foi especificado. Porém esta maneira de especificar critérios é pouco flexível, pois cada vez que quisermos alterar o critério, teremos que digitar o novo critério, salvar a consulta e executá-la novamente. Podemos obter uma maior flexibilidade especificando um parâmetro para a consulta. Depois, colocamos este parâmetro como critério no campo ShipCountry. Ao especificarmos um parâmetro como critério para este campo, cada vez que a consulta for executada, o Microsoft Access nos pergunta o valor do parâmetro. Nós digitamos o valor desejado que passa a servir como critério de filtragem. Para definir um parâmetro, selecione o menu Consulta -> Parâmetros. Na janela que surge digite Pais (sem acento) para o nome do parâmetro e selecione Texto para o tipo do parâmetro, conforme indicado na Figura 7.6.

Figura 7.6: Definindo um parâmetro para a consulta. Depois basta colocar como critério, no campo ShipCountry, o nome do parâmetro entre colchetes, conforme indicado na Figura 7.7. Ao executar esta consulta, o Microsoft Access reconhece a existência do parâmetro, e abre uma janela pedindo para que o usuário digite um valor para o parâmetro, conforme indicado na Figura 7.8. Vamos supor que o usuário digite France e dê um clique em OK. Serão exibidos todos os pedidos em que o campo ShipCountry seja igual a France, conforme indicado na Figura 7.9.

400

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

Figura 7.7: Definindo o parâmetro como critério para o campo ShipCountry.

Figura 7.8: O usuário deve digitar um valor para o parâmetro.

Figura 7.9: Execução da consulta com o valor do parâmetro definido como France.

401

Criando Sites Dinâmicos com ASP 3.0

Utilizando parâmetros, cada vez que a consulta é executada, podemos fornecer um valor diferente para o parâmetro, valor esse que serve para filtrar os resultados. Podemos definir parâmetros em mais do que um campo da consulta, com isso, ao executar a consulta, serão pedidos valores para cada um dos parâmetros definidos. O nosso objetivo é poder, a partir de uma página ASP, executar uma Consulta Parametrizada do Microsoft Access. Para isso, precisamos passar, a partir da página ASP, os valores para os parâmetros definidos na consulta. Isso é possível de ser feito com a utilização do objeto Parameter e a propriedade Parameters do objeto Command. Na seqüência deste capítulo estudaremos o objeto Parameter, bem como a passagem de parâmetros utilizando o objeto Command.

NOTA Esta consulta foi salva com o nome de con_pedidos. Utilizaremos este nome em exemplos mais adiante. Caso você tenha criado uma consulta com um nome diferente, utilize o nome da consulta que você criou, nos exemplos deste capítulo.

O Objeto Parameter O objeto Parameter representa parâmetros associados com Consultas Parametrizadas ou argumentos de entrada e valores de retorno para Stored Procedures. Com a utilização do objeto Parameter podemos definir, detalhadamente, os parâmetros que serão enviados para uma Consulta Parametrizada, ou os argumentos de entrada enviados para um Stored Procedure. Na Tabela 7.4, temos uma descrição das principais propriedades do objeto Parameter. Tabela 7.4 Principais propriedades do objeto Parameter. Propriedade

Descrição

Attributes

Indica uma ou mais características do objeto Parameter.

Direction

Define se o objeto Parameter representa um parâmetro de entrada, de saída ou ambos; ou indica se o parâmetro é um valor de retorno de um Stored Procedure.

Name

Contém o nome do objeto Parameter.

NumericScale

Indica uma faixa de valores numéricos aceitáveis para o valor do parâmetro.

402

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

Propriedade

Descrição

Precision

Indica a precisão a ser utilizada para valores numéricos.

Size

Indica o tamanho máximo do parâmetro, em bytes ou caracteres.

Type

Indica o tipo de dados para o objeto Parameter.

Value

Indica o valor associado com o objeto Parameter.

NOTA Um Stored Procedure é um conjunto de comandos gravados com um nome no banco de dados. Podemos, por exemplo, criar um Stored Procedure que gera uma listagem com o total de vendas por mês do ano. Um Stored Procedure pode receber valores como argumentos de entrada. Um exemplo de argumento de entrada poderia ser o ano para o qual deve ser gerada uma listagem do total de vendas mensais. Um Stored Procedure também pode retornar valores após a sua execução. Podemos utilizar o objeto Parameter para enviar argumentos de entrada e também para receber os valores calculados pelo Stored Procedure.

Para cada parâmetro, que o objeto Command precisa tratar, é criado um objeto Parameter. Todos os objetos Parameter podem ser acessados através da coleção Parameters do objeto Command. Para criar um objeto do tipo Parameter, podemos utilizar o método CreateParameter do objeto Command.

Utilizando o Objeto Command Para Passar Parâmetros Para uma Consulta Parametrizada Neste item vamos utilizar o objeto Command e a sua coleção Parameters para acessar a consulta con_pedidos e passar um valor para o parâmetro Pais da consulta. Vamos criar um formulário, onde temos uma lista, gerada dinamicamente pelo ASP, na qual temos a listagem dos países em ordem alfabética. O usuário seleciona um país na lista e clica no botão Pesquisar. Feito isso será chamada uma página procurapais.asp, que passa o valor selecionado na lista como parâmetro para a consulta con_pedidos, a qual retorna a listagem dos pedidos para o país selecionado. A página inicial, na qual construiremos a listagem de países, será chamada de command2.asp. Na Figura 7.10 temos um diagrama do funcionamento do nosso exemplo.

403

Criando Sites Dinâmicos com ASP 3.0

command2.asp

procurapais.asp

nwind.mdb Consulta: con_pedidos

Figura 7.10: Diagrama de funcionamento do exemplo proposto. Na Listagem 7.2 temos o código que cria a página command2.asp. Listagem 7.2 – Criando a lista com o nome dos países – command2.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<TITLE>Selecione o País de destino.</TITLE>

<BODY>

‘O primeiro passo é criar a conexão com o banco de dados.

‘para isto crio um objeto do tipo Connection.

‘Cria um objeto do tipo ADODB.Connection

Set conn=Server.CreateObject(“ADODB.Connection”)

‘Agora abro uma conexão com o arquivo nwind.mdb

‘utilizando OLE DB.

conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0; DATA SOURCE=c:\meus documentos\nwind.mdb”

conn.Open

‘Agora criamos um objeto RecordSet.

‘Este objeto irá acessar o campo ProductName

‘da tabela Produtos

Set Paises = Server.CreateObject(“ADODB.Recordset”)

404

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

20 Paises.Open “Select ShipCountry from Orders Group By ShipCountry Order By ShipCountry”, conn, 3, 3 21

‘Neste ponto tenho o objeto Paises com uma listagem

‘em ordem ascendente, dos países para os quais existem

‘pedidos efetuados.

<P><B>Selecione o país a ser pesquisado.</B></P>

<P><B><I>Depois clique no botão Pesquisar.</I></B></P>

‘Agora construo a lista de opções a partir dos

‘dados obtidos da tabela Orders.

‘Para cada país obtido, crio uma nova opção

‘na lista.

Do While Not Paises.EOF

Response.Write “<OPTION value=” & Chr(34) & Paises.Fields(“ShipCountry”) & Chr(34) & “>” & Paises.Fields(“ShipCountry”)& “</OPTION>”

Paises.MoveNext

Loop

</SELECT>

<BR>

<HR>

</FORM>

</BODY>

</HTML>

405

Criando Sites Dinâmicos com ASP 3.0

Agora precisamos construir a página procurapais.asp. Esta página receberá o valor selecionado na lista, passará este valor para o parâmetro Pais da consulta con_pedidos, a qual irá retornar somente os pedidos para o país selecionado. A página procurapais.asp também exibirá os resultados obtidos. Na Listagem 7.3 temos o código que cria a página procurapais.asp. Listagem 7.3 – Passando um valor para o parâmetro Pais da consulta con_pedidos. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<TITLE>Resultados da pesquisa.</TITLE>

<BODY>

‘O primeiro passo é criar a conexão com o banco de dados.

‘para isto crio um objeto do tipo Connection.

‘Cria um objeto do tipo ADODB.Connection

Set conn=Server.CreateObject(“ADODB.Connection”)

‘Agora abro uma conexão com o arquivo nwind.mdb

‘utilizando OLE DB.

conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0; DATA SOURCE=c:\meus documentos\nwind.mdb”

conn.Open

‘Agora criamos um objeto RecordSet para reapresentar

‘a lista de países no final, para que o usuário possa

‘fazer uma nova pesquisa.

Set Paises = Server.CreateObject(“ADODB.Recordset”)

Paises.Open “Select ShipCountry from Orders Group By ShipCountry Order By ShipCountry”, conn, 3, 3

‘Agora crio um objeto do tipo Command

‘defino a conexão ativa utilizando a propriedade ActiveConnection.

‘Depois defino o tipo de comando utilizando a propriedade

406

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

‘CommandType. O valor 4 significa que é um Stored Procedure.

‘Para o caso de consultas do Microsoft Access devemos definir

‘o tipo como sendo Stored Procedure.

‘Ao invés do valor 4 poderíamos utilizar a constante

‘adCmdStoredProc

Set com_paises = Server.CreateObject(“ADODB.Command”)

com_paises.ActiveConnection = conn

com_paises.CommandType = 4

‘Agora começo a definir as características do parâmetro.

‘Crio variável para definir o nome do parâmetro.

nome_par = “Pais”

‘Crio uma variável para conter o valor do parâmetro.

‘Defino este valor como sendo o valor selecionado

‘na lista de países.

valor_par= Request.Form(“listapaises”)

‘Agora crio variáveis que definem as demais

‘ características do parâmetro.

tipo_par = 129 ‘parâmetro do tipo string.

tama_par = 50 ‘define o tamanho do parâmetro.

dire_par = 1

‘Agora crio um objeto do tipo Parameter

Set pais_par=com_paises.CreateParameter

‘define um parâmetro de entrada.

(nome_par,tipo_par,dire_par,tama_par,valor_par) 46

‘Adiciono o parâmetro à coleção Parameters.

com_paises.Parameters.Append pais_par

‘Defino o comando a ser executado como sendo o nome

407

Criando Sites Dinâmicos com ASP 3.0

‘da consulta con_pedidos

com_paises.CommandText = “con_pedidos”

‘Crio um objeto RecordSet e utilizo o método

‘execute do objeto Command para retornar valores

‘para o objeto RecordSet.

Set Resultados = Server.CreateObject(“ADODB.RecordSet”)

Set Resultados = com_paises.Execute

‘Reexibo a lista de países para que o usuário possa

‘pesquisar os pedidos para um outro país.

<P><B>Para pesquisar outro país, selecione na lista.</B></P>

<P><B><I>Depois clique no botão Pesquisar.</I></B></P>

63 64

‘Agora construo a lista de opções a partir dos

‘dados obtidos da tabela Orders.

‘Para cada país obtido, crio uma nova opção

‘na lista.

Do While Not Paises.EOF

Response.Write “<OPTION value=” & Chr(34) & Paises.Fields(“ShipCountry”) & Chr(34)

If Paises.Fields(“ShipCountry”)= Request.Form(“listapaises”) Then

Response.Write “SELECTED”

End If

Response.Write “>” & Paises.Fields(“ShipCountry”)& “</OPTION>”

Paises.MoveNext

Loop

408

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

</SELECT>

</FORM>

‘Exibo os resultados obtidos a partir da consulta

‘con_pedidos.

<B>Relação de pedidos para: <% =Request.Form(“listapaises”) %>.</B>

<HR>

<% ‘Agora exibo os resultados utilizando uma tabela. %>

<TR>

<TD><B>Código</B></TD>

<TD><B>Cidade</B></TD>

94 95

</TR> <%

96 97

Do While Not Resultados.EOF %>

<TR>

<TD><% =Resultados.Fields(“OrderID”)

%></TD>

100

<TD><% =Resultados.Fields(“OrderDate”)

%></TD>

101

<TD><% =Resultados.Fields(“ShipCity”)

%></TD>

102

103

</TR>

104 <% Resultados.MoveNext 105 Loop 106 %>

409

Criando Sites Dinâmicos com ASP 3.0

107 </TABLE> 108 <BR> 109 <HR> 110 </BODY> 111 </HTML>

A Listagem 7.3 salienta diversos pontos importantes na utilização do objeto Command para a execução de Consultas Parametrizadas, através da passagem de parâmetros utilizando o objeto Parameter. Vamos detalhar alguns trechos desta listagem. Observe o seguinte trecho de código: 29

Set com_paises = Server.CreateObject(“ADODB.Command”)

com_paises.ActiveConnection = conn

com_paises.CommandType = 4

Inicialmente criamos um objeto do tipo Command, depois definimos a sua propriedade ActiveConnection como sendo a conexão conn. Por último definimos a propriedade CommandType com o valor 4. Ao invés do valor 4 poderíamos ter utilizado a constante adCmdStoredProc, o que significa que o valor passado para a propriedade CommandText deve ser o nome de uma consulta (no caso do Microsoft Access), ou de um Stored Procedure (no caso do Microsoft SQL Server). Como queremos executar a consulta con_pedidos, definimos a propriedade CommandType com o valor 4.

NOTA Na Tabela 7.3 estão listados os valores e respectivas constantes para a propriedade CommandType.

Em seguida começo a definir as características do parâmetro que será criado e passado para a consulta. Isto é feito com o seguinte trecho de código: 32

‘Agora começo a definir as características do parâmetro.

‘Crio variável para definir o nome do parâmetro.

nome_par = “Pais”

‘Crio uma variável para conter o valor do parâmetro.

‘Defino este valor como sendo o valor selecionado

‘na lista de países.

410

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

valor_par= Request.Form(“listapaises”)

‘Agora crio variáveis que definem as demais

‘ características do parâmetro.

tipo_par = 129 ‘parâmetro do tipo string.

tama_par = 50 ‘define o tamanho do parâmetro.

dire_par = 1

‘define um parâmetro de entrada.

Primeiro definimos o nome do parâmetro, que deve ser o mesmo utilizado para a definição do parâmetro, quando da criação da consulta no Microsoft Access. Neste caso criamos uma variável chamada nome_par e definimos o seu valor como “Pais”. Logo em seguida criamos a variável valor_par, a qual irá conter o valor que será passado para o parâmetro Pais. Este valor é o selecionado na lista de países da página command2.asp, conforme indicado pelo código abaixo: 38

valor_par= Request.Form(“listapaises”)

Seguindo as definições, criamos uma variável para o tipo do parâmetro – tipo_par. A esta variável foi atribuído o valor 129. Ao invés do valor 129 poderíamos ter utilizado a constante adChar, que define o parâmetro como sendo uma String, isto é, do tipo texto. Na Tabela 7.5 temos uma listagem com os principais valores e respectivas constantes que podem ser definidas para o tipo do parâmetro. Tabela 7.5 Principais Valores/Constantes para definição do tipo do parâmetro. Valor/Constante

Descrição

0x2000/adArray

Um valor de Flag indicativo de que temos um array de valores, o qual deve ser combinado com outro valor indicativo de tipo. Este valor indica um array de parâmetros de um determinado tipo.

20/adBigInt

Indica um inteiro de 8 bytes.

128/adBibary

Indica um valor binário.

11/adBoolean

Indica um valor boleano, do tipo Verdadeiro ou Falso, Sim ou Não.

8/sdBSTR

Indica uma String de caracteres de terminação nula (Unicode).

129/adChar

Indica um valor de String, isto é, texto.

411

Criando Sites Dinâmicos com ASP 3.0

Valor/Constante

Descrição

6/adCurrency

Indica um valor do tipo currency, o qual é um número com quatro casas decimais fixas.

7/adDate

Indica um valor do tipo Data.

134/adDBTime

Indica um valor de hora, no formato hhmmss.

135/adDBTimeStamp

Indica um valor de data/hora no formato yyyymmddhhmmss

14/adDecimal

Indica um valor decimal.

5/adDouble

Indica um valor numérico de precisão dupla.

0/adEmpty

Não define nenhum valor.

10/adError

Indica um código de erro de 32 bits.

72/adGUID

Indica um valor do tipo GUID – Globally Unique Identifier.

3/adInteger

Indica um valor inteiro de 4 bytes.

4/adSingle

Indica um valor numérico de precisão simples.

Em seguida definimos um tamanho máximo em bytes para o parâmetro, que no nosso exemplo foi definido para 50, conforme indicado pelo seguinte comando: 42

tama_par = 50 ‘define o tamanho do parâmetro.

Finalmente definimos uma variável para conter o valor de definição para a propriedade Direction do parâmetro. Este valor foi definido em 1, o que significa um parâmetro de entrada, isto é, um parâmetro que envia um valor para a consulta do Microsoft Access. Esta definição está indicada no código a seguir: 43

dire_par = 1

‘define um parâmetro de entrada.

Ao invés do valor 1, poderíamos ter utilizado a constante adParamInput. Na Tabela 7.6 temos uma listagem com os valores e respectivas constantes que podem ser definidas para a propriedade Direction. Tabela 7.6 Valores/Constantes para a propriedade Direction. Valor/Constante

Descrição

1/adParamImput

Indica um parâmetro de entrada. É o valor padrão.

2/adParamOutput

Indica que o parâmetro é de saída.

412

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

Valor/Constante

Descrição

3/adParamInputOutput

Indica que o parâmetro é de entrada e saída.

4/adParamReturnValue

Indica que o parâmetro representa um valor de retorno.

0/adParamUnknown

Indica um parâmetro com direção desconhecida.

NOTA Criamos variáveis para conter estes valores. Depois passaremos estas variáveis para o método CreateParameter. Ao invés de criarmos as variáveis, poderíamos passar os valores diretamente para o método CreateParameter. Adotamos este procedimento para facilitar o entendimento do código.

O próximo passo é criar um objeto do tipo Parameter, utilizando o método CreateParameter do objeto Command. Chamamos este objeto de pais_par, conforme indicado abaixo: 44

‘Agora crio um objeto do tipo Parameter

Set pais_par=com_paises.CreateParameter (nome_par,tipo_par,dire_par,tama_par,valor_par)

A sintaxe para o método CreateParameter é a seguinte: Set nome_parameter = nome_command.CreateParameter (Name, Type, Direction, Size, Value)

Onde temos: ➥ Name: O nome do parâmetro. ➥ Type: O tipo do parâmetro. Os principais valores de tipo possíveis estão listados na Tabela 7.5. ➥ Direction: Definição da direção do parâmetro. Os principais valores de direção possíveis, estão listados na Tabela 7.6. ➥ Size: Define o tamanho máximo para o parâmetro. ➥ Value: Define o valor do parâmetro. No nosso caso é o valor que será enviado para a consulta con_pedidos, e que servirá como critério de filtragem para o campo ShipCountry. Uma vez criado o parâmetro é hora de adicioná-lo à coleção Parameters do objeto Command. Para fazer isso, utilizamos o método Append da coleção Parameters, conforme indicado a seguir: 46

‘Adiciono o parâmetro à coleção Parameters.

com_paises.Parameters.Append pais_par

413

Criando Sites Dinâmicos com ASP 3.0

Observe que passamos para o método Append o nome do objeto Parameter a ser adicionado a coleção Parameters. Utilizando Append, podemos adicionar novos parâmetros. Agora preciso definir a propriedade CommandText do objeto com_paises. Como definimos a propriedade CommandType como 4 (Stored Procedure), vamos passar para o objeto CommandText o nome da consulta a ser executada, que no nosso exemplo é con_pedidos. Isto é feito com o seguinte código: 50

com_paises.CommandText = “con_pedidos”

O passo final é criar um objeto RecordSet utilizando o método Execute do objeto Command. Isto é feito com o seguinte código: 54

Set Resultados = Server.CreateObject(“ADODB.RecordSet”)

Set Resultados = com_paises.Execute

Assim, o valor selecionado na lista de países é passado para a consulta con_pedidos. A consulta é executada e somente são retornados os registros em que o campo ShipCountry contém o valor selecionado na lista de países. Com a utilização do objeto Command e do objeto Parameter foi possível executar uma Consulta Parametrizada no Microsoft Access, passando o valor do parâmetro para a consulta.

Utilizando o Nosso Exemplo Agora vamos utilizar o nosso exemplo, para comprovar o correto funcionamento do mesmo. Ao carregar a página command2.asp, obtemos o resultado indicado na Figura 7.11.

Figura 7.11: Selecionando um país da lista.

414

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

Vamos supor que o usuário selecionou “Norway”, na lista de países. Ao clicar no botão Pesquisar serão exibidos apenas os pedidos para o país selecionado, conforme indicado na Figura 7.12.

Figura 7.12: Exibindo os pedidos para Norway. Observe que novamente é exibida a lista de países e o país selecionado anteriormente aparece selecionado na lista. Para pesquisar os pedidos para outro país é só selecionar o país desejado e clicar no botão Pesquisar. Veja que com isso construímos um formulário de pesquisa bastante interativo. O usuário seleciona o país desejado e manda pesquisar. Cada vez que o usuário seleciona um país diferente na lista, e clica no botão Pesquisar, o novo valor selecionado é passado como parâmetro para a consulta con_pedidos. A consulta é executada e retorna somente os registros que atendem ao critério passado como parâmetro.

Um Desafio Para o Amigo Leitor Agora que já conhecemos vários detalhes sobre o acesso a bancos de dados, através de páginas ASP, fica aqui um pequeno desafio para o amigo leitor.

415

Criando Sites Dinâmicos com ASP 3.0

Desafio: Modificar o exemplo anterior fazendo as seguintes melhorias. ➥ Modificar a consulta con_pedidos incluindo um parâmetro chamado AnoPedido. Este parâmetro será utilizado para filtrar somente os registros de um determinado ano. Adicionar um campo calculado à consulta, que exiba somente o ano do campo OrderDate. ➥ Modificar a página command2.asp para que, além de uma lista com os nomes dos países, seja exibida uma lista com a relação de anos para os quais existem pedidos. Construir esta lista dinamicamente, assim como foi construída a lista para os países. ➥ Modificar a página procurapais.asp, para que a mesma crie mais um parâmetro chamado ano_ped e passe esse parâmetro para a consulta con_pedidos, de tal forma que somente sejam retornados os pedidos para o País selecionado e para o Ano selecionado. Vamos exemplificar como deve ser o resultado final, após estas alterações. Ao carregar a página command2.asp, obtemos o resultado indicado na Figura 7.13.

Figura 7.13: Selecione um país da lista País e o ano na lista Ano. Vamos supor que o usuário selecionou “Brazil”, na lista de países e 1994 na lista Ano. Ao clicar no botão Pesquisar serão exibidos apenas os pedidos para país e ano selecionados, conforme indicado na Figura 7.14. Para fazer uma nova pesquisa, basta selecionar novos critérios e clicar no botão Pesquisar.

416

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

Figura 7.14: Pedidos para “Brazil” no ano de 1994. Em caso de dificuldades na criação da nova versão do nosso exemplo é só entrar em contato pelo e-mail: juliobattisti@hotmail.com. Mas antes de entrar em contato procure revisar os conceitos já apresentados até o momento. Praticar é muito importante para conseguir fixá-los.

Um Pouco Mais Sobre Pesquisas em Banco de Dados Neste item iremos explorar um pouco mais a utilização da linguagem SQL em páginas ASP.

IMPORTANTE Estaremos utilizando exemplos que acessam bancos de dados do Microsoft Access. Para o acesso a outros bancos de dados, podem existir pequenas diferenças, dependendo do OLE DB Provider para cada caso. Caso você esteja utilizando outro banco de dados, consulte a documentação do padrão SQL do mesmo.

417

Criando Sites Dinâmicos com ASP 3.0

Trataremos dos seguintes tópicos: ➥ A utilização do operador Like. ➥ Definindo múltiplos critérios. ➥ Utilizando funções de agregação.

A Utilização do Operador Like Com o operador Like, podemos criar consultas que retornam resultados contendo um determinado padrão. Por exemplo, podemos fazer uma consulta que localize todos os clientes em que o primeiro nome inicie com “Jo”. Neste caso serão retornados os registros de João da Silva, João Santos, José da Silva, Josimar da Silva e assim por diante. O operador Like nos dá uma flexibilidade bastante grande, pois permite que façamos pesquisa, digitando apenas parte do valor procurado. Considere a seguinte instrução SQL: SELECT CustomerID, CompanyName, ContactName FROM Customers WHERE CompanyName Like ‘La%’

NOTA Estamos tomando como base a tabela Customers do banco de dados nwind.mdb.

Esta instrução iria selecionar apenas os registros cujo campo CompanyName iniciasse com La.

IMPORTANTE Quando utilizamos o Microsoft Access, utilizamos o “*” como caractere coringa; já em ASP utilizamos o “%”. Outra diferença importante é em relação a critérios de texto. Quando utilizamos o Microsoft Access, todo critério de texto deve vir entre aspas (“), já no caso de páginas ASP, todo critério de texto deve vir entre apóstrofes (‘).

Na Listagem 7.4 temos exemplo de página que utiliza o operador Like. Listagem 7.4 – Utilizando o operador Like para fazer pesquisas – exlike.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

418

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

<TITLE>Utilizando o operador Like.</TITLE>

<BODY>

Set conn=Server.CreateObject(“ADODB.Connection”)

‘Agora abro uma conexão com o arquivo nwind.mdb

‘utilizando OLE DB.

conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0;

DATA SOURCE=c:\meus documentos\nwind.mdb”

conn.Open

‘Agora crio uma instrução SQL que utiliza o operador Like.

inst_sql=“Select * from Customers where CompanyName Like ‘La%’”

Set Cust= Server.CreateObject(“ADODB.RecordSet”)

Cust.Open inst_sql,conn,3,3

<P>

Relação de Clientes cujo nome começa com La.

</B></FONT>

</P>

<HR>

<TABLE>

<TR>

<TD><B>Código</B></TD>

<TD><B>Cidade

</TR>

</B></TD>

419

Criando Sites Dinâmicos com ASP 3.0

Do Until Cust.EOF

<TR>

<TD><%=Cust.Fields(“CustomerId”)

37 38

%> </TD>

Ped.MoveNext

Loop

</TABLE>

<HR>

</BODY>

</HTML>

Ao carregarmos este exemplo no Internet Explorer, obteremos o resultado indicado na Figura 7.15.

Figura 7.15: Resultados obtidos com o operador Like. Agora vamos supor que você quisesse uma listagem de todos os consumidores que possuem o texto “La” em qualquer parte do nome, não necessariamente no início. Mais uma vez a

420

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

utilização do operador Like facilita a nossa vida. Para obter o resultado desejado, bastaria alterar a instrução SQL da Listagem 7.4. A instrução deve ficar da seguinte maneira: inst_sql=“Select * from Customers where CompanyName Like ‘%La%’”

Bastou colocar mais um caractere % antes do La. Com isso serão retornados todos os registros que contiverem La em qualquer parte do campo CompanyName, conforme indicado na Figura 7.16.

Figura 7.16: Mais um exemplo de utilização do operador Like. Poderíamos começar a refinar mais ainda a nossa consulta. Vamos pesquisar todos os registros em que o Nome do Cliente (campo CompanyName) possui “La” e o CEP (campo PostalCode) possui o número 3. Para obter o resultado desejado, bastaria alterar a instrução SQL da Listagem 7.4. A instrução deve ficar da seguinte maneira: inst_sql=“Select * from Customers where CompanyName Like ‘%La%’ and PostalCode Like ‘%3%’”

Na Figura 7.17 temos a listagem obtida após esta alteração da instrução SQL.

421

Criando Sites Dinâmicos com ASP 3.0

Figura 7.17: Utiliando o operador Like e And. Agora vamos supor que você queira uma listagem somente com os registros em que o campo CompanyName inicie com uma letra na faixa de A até M, isto é, a primeira letra do nome deve estar entre A e M. Além disso você deseja que esta listagem seja classificada em ordem ascendente do campo CompanyName. Para obter este resultado, basta utilizar a instrução SQL a seguir: inst_sql=“Select * from Customers where CompanyName Like ‘[A-M]%’ Order By CompanyName”

O resultado desta pesquisa está indicado na Figura 7.18.

NOTA Ao invés de digitar a instrução SQL diretamente no código ASP, a mesma pode ser construída a partir de valores digitados ou selecionados em um formulário. No final do capítulo, criaremos um formulário genérico para pesquisas, onde o usuário poderá definir por qual ou quais critérios deseja fazer a pesquisa e selecionar um valor para os critérios. Ao clicar em um botão Pesquisar, os dados são enviados para uma página ASP, que monta a instrução SQL de acordo com as opções selecionadas pelo usuário. Com estes exemplos, podemos comprovar a versatilidade e facilidade de uso do operador Like.

422

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

Figura 7.18: Utiliando o operador Like e uma faixa inicial.

A Utilização de Múltiplos Critérios Para realizarmos uma pesquisa com mais de um critério, utilizamos os operadores And e Or. Inicialmente vamos salientar a diferença entre ambos.

O Operador And Quando utilizamos o operador And para “ligar” dois critérios, somente serão selecionados os registros que atenderem, ao mesmo tempo, aos dois critérios. Caso o registro somente atenda a um dos critérios, não será selecionado. Considere o seguinte exemplo: inst_sql=“Select * from Orders where ShipCountry = ‘France’ and ShipCity = ‘Lyon’ ”

Neste caso somente serão selecionados os registros em que o país for France e a cidade Lyon, isto é, somente os registros que atenderem aos dois critérios. Podemos utilizar mais do que um operador And. Com isso podemos especificar três ou mais critérios. Mas, a regra se mantém: para que um registro seja selecionado, ele precisa atender

423

Criando Sites Dinâmicos com ASP 3.0

a todos os critérios ligados pelos operadores And. Se um único critério falhar, o registro não será selecionado.

O Operador Or Quando utilizamos o operador Or para “ligar” dois critérios, somente serão selecionados os registros que atenderem, pelo menos, a um dos dois critérios. O registro somente não será selecionado se não atender a nenhum dos dois critérios. Considere o seguinte exemplo: inst_sql=“Select * from Orders where ShipCountry = ‘France’ Or ShipCity = ‘Lyon’”

Neste caso serão selecionados todos os registros que atenderem a pelo menos um dos critérios, isto é, se o país for igual a France, o registro será selecionado, independente da cidade. Se a cidade for igual a Lyon, o registro será selecionado, independente do país. Caso o registro atenda aos dois critérios também será selecionado. A única situação em que o registro não será selecionado é quando não atender a nenhum dos dois critérios ligados pelo operador Or. Podemos utilizar mais do que um operador Or. Com isso podemos especificar três ou mais critérios. Mas a regra se mantém, para que um registro seja selecionado, ele precisa atender a pelo menos um dos critérios ligados pelos operadores Or. Somente se todos os critérios falharem é que o registro não será selecionado.

Alguns Exemplos de Utilização de Múltiplos Critérios Exemplo 1: Vamos supor que desejamos uma listagem dos pedidos que atendam aos seguintes critérios: ➥ Campo ShipCountry = France ➥ OrderDate deve estar dentro do ano de 1994. A instrução SQL é a seguinte: inst_sql=“Select * from Orders where ShipCountry=‘France’ And OrderDate>#01/01/1994# And OrderDate<#31/12/1994#”

Observe que quando formos definir um critério para um campo do tipo Data, devemos colocar o valor entre os sinais de #. Na figura 7.19, temos o resultado da execução da instrução SQL do nosso exemplo.

424

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

Figura 7.19: Especificando critérios para o País e para a Data. Exemplo 2: Se, no exemplo anterior, trocarmos o primeiro And por um Or e utilizarmos parênteses para determinar a ordem de avaliação, conforme indicado no exemplo: inst_sql=“Select * from Orders where ShipCountry=‘France’ Or (OrderDate>#01/01/1994# And OrderDate<#31/12/1994#)”

qual seria o resultado desta instrução SQL? Seriam retornados todos os pedidos para o país France, independente do ano. Também seriam retornados todos os pedidos para o ano de 1994, independente do País. Lembre que para ser selecionado, basta que o registro atenda um dos critérios ligados pelo Or. Ao colocarmos os parênteses, estamos forçando que os critérios da data sejam avaliados de uma maneira única. O resultado desta comparação é que é ligado pelo Or à primeira parte do critério. Exemplo 3: Vamos fazer uma pesquisa em que sejam exibidos os pedidos para todos os países, com exceção dos pedidos em que o campo ShipCountry seja igual a France. Podemos utilizar a seguinte instrução SQL: inst_sql=“Select * from Orders where ShipCountry <>‘France’”

425

Criando Sites Dinâmicos com ASP 3.0

Neste caso fizemos uso do operador diferente <>. Com isso estamos dizendo que devem ser selecionados todos os registros em que o campo ShipCountry for diferente de France. Exemplo 4: Queremos pesquisar por registros que possam apresentar dois ou mais valores em um determinado campo, como por exemplo, pesquisar todos os pedidos para Brazil, France, Argentina ou Germany. Poderíamos utilizar vários critérios ligados pelo operador Or, porém existe uma maneira mais simples de fazer isso, que é através da utilização do operador In, conforme indicado no exemplo abaixo: inst_sql=“Select * from Orders where ShipCountry In (‘France’,‘Argentina’, ‘Brazil’, ‘Germany’) Order By ShipCountry”

Com o uso do operador In, podemos definir dois ou mais critérios para um determinado campo. A lista de critérios vem entre parênteses, cada critério deve ser colocado entre apóstrofes e separados por vírgula. Exemplo 5: Vamos “inverter” um pouco o exemplo anterior: criar uma listagem de todos os pedidos, com exceção dos pedidos enviados para os seguintes países: ➥ Argentina ➥ Brazil ➥ France ➥ Germany Podemos utilizar a mesma instrução anterior, apenas colocando o operador Not, antes do operador In, conforme indicado a seguir: inst_sql=“Select * from Orders where ShipCountry Not In (‘France’,‘Argentina’, ‘Brazil’, ‘Germany’) Order By ShipCountry”

O Not informa que devem ser selecionados todos os registros, com exceção daqueles em que o campo ShipCountry contiver os valores especificados como parâmetros do operador In. A utilização de operadores nos permite criar consultas bastante avançadas, combinando critérios, e utilizando critérios múltiplos. Também podemos utilizar as chamadas funções de agregação, que será o assunto do próximo item.

Utilizando Funções de Agregação As funções de agregação nos permitem criar valores consolidados dos dados de uma ou mais tabelas, como por exemplo: ➥ A soma de todos os pedidos enviados para a Argentina. ➥ A média dos pedidos para um determinado cliente.

426

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

➥ O número de pedidos enviados para um determinado país em determinado ano. ➥ O menor e o maior pedido para um determinado cliente ou país. Para obter estes resultados consolidados, podemos utilizar as diversas funções de agregação disponíveis. Na Tabela 7.7, temos a descrição das principais funções de agregação disponíveis. Tabela 7.7 Funções de agregação. Função

Descrição

Count( )

É utilizada para efetuar uma contagem. Pode ser uma contagem geral, como por exemplo o número de registros de uma tabela, ou específica, como o número de pedidos para cada país.

AVG( )

É utilizada para cálculo de médias. Calcula a média aritmética de um determinado campo. Somente pode ser utilizada com campos numéricos. Valores do tipo Null serão ignorados.

Sum( )

É utilizada para efetuar a soma de campos numéricos.

Max( )

É utilizada para determinar o maior valor de um campo numérico.

Min( )

É utilizada para determinar o menor valor de um campo numérico.

Alguns Exemplos de Utilização de Funções de Agregação Exemplo 1: Vamos começar com um exemplo em que seja exibida uma listagem, com o número de pedidos para cada país, classificada pelo nome do país de destino. inst_sql=“Select ShipCountry, Count(OrderID) As Totais from Orders Group By ShipCountry Order By ShipCountry”

Na Listagem 7.5, temos um exemplo de uma página ASP, excount.asp, que faz uso desta instrução SQL. Listagem 7.5 – Utilizando a função de agregação Count( ) – excount.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

427

Criando Sites Dinâmicos com ASP 3.0

<TITLE>Utilizando a função Count.</TITLE>

<BODY>

‘O primeiro passo é criar a conexão com o banco de dados.

‘Para isto crio um objeto do tipo Connection.

‘Cria um objeto do tipo ADODB.Connection

Set conn=Server.CreateObject(“ADODB.Connection”)

‘Agora abro uma conexão com o arquivo nwind.mdb

‘utilizando OLE DB.

conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0; DATA SOURCE=c:\meus documentos\nwind.mdb”

conn.Open

‘Agora crio um objeto do tipo RecordSet, o qual será,

‘automaticamente associado com a conexão conn.

inst_sql=“Select ShipCountry, Count(OrderID) As Totais from Orders Group By ShipCountry Order By ShipCountry”

Set Ped= Server.CreateObject(“ADODB.RecordSet”)

Ped.Open inst_sql,conn,3,3

<P>

Número de pedidos por país de destino.

</B></FONT>

</P>

<HR>

<TR>

428

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

31 32

<TD><B>Pedidos

</B></TD>

</TR>

Do Until Ped.EOF

<TR>

<TD>

<TD><B><%=Ped.Fields(“Totais”)

<%=Ped.Fields(“ShipCountry”)

</TD>

%> </B></TD>

</TR>

Ped.MoveNext

Loop

</TABLE>

<HR>

</BODY>

</HTML>

Na Figura 7.20, temos o resultado da página excount.asp, quando a mesma é carregada no Internet Explorer.

Figura 7.20: Resultados obtidos com a utilização da função Count( ).

429

Criando Sites Dinâmicos com ASP 3.0

Exemplo 2: Vamos supor que devêssemos alterar a nossa listagem, para classificá-la em ordem descendente do número de pedidos, isto é, devem ser listados primeiro os países com o maior número de pedidos. Para obter este resultado, bastaria alterar a instrução SQL, deixandoa da seguinte maneira: inst_sql=“Select ShipCountry, Count(OrderID) As Totais from Orders Group By ShipCountry Order By Count(OrderID)Desc”

Ao utilizarmos esta instrução, obteremos o resultado indicado na Figura 7.21.

Figura 7.21: Resultados em ordem decresente do número de pedidos.

IMPORTANTE Quando formos fazer a ordenação, utilizando a cláusula Order By, não podemos utilizar o “aliás” do campo. O aliás é o nome que damos ao campo que está sendo calculado. No nosso exemplo, chamamos o campo com o total de pedidos de Totais. Um aliás é criado com a palavra “As”. Se utilizarmos um aliás na cláusula Order By, obteremos um erro e a página não será carregada. A instrução a seguir comete este erro.

430

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

Cuidado – instrução incorreta: inst_sql=“Select ShipCountry, Count(OrderID) As Totais from Orders Group By ShipCountry Order By Totais Desc”

Se utilizarmos esta instrução, ao tentarmos carregar a página, obteremos o erro indicado na Figura 7.22.

Figura 7.22: Erro causado pelo uso de um aliás na cláusula Order By. Exemplo 3: Agora vamos utilizar a função Sum para retornar a soma do valor do Frete (Freight) para cada país. Para obter este resultado, podemos utilizar o comando SQL a seguir: inst_sql=“Select ShipCountry, Sum(Freight) As SomFrei from Orders Group By ShipCountry Order By Sum(Freight) Desc”

Na Listagem 7.6, temos um exemplo de uma página ASP, exsum.asp, que faz uso desta instrução SQL. Listagem 7.6 – Utilizando a função de agregação Sum ( ) – exsum.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<TITLE>Utilizando a função Sum.</TITLE>

<BODY>

431

Criando Sites Dinâmicos com ASP 3.0

‘O primeiro passo é criar a conexão com o banco de dados.

‘Para isto crio um objeto do tipo Connection.

‘Cria um objeto do tipo ADODB.Connection

Set conn=Server.CreateObject(“ADODB.Connection”)

‘Agora abro uma conexão com o arquivo nwind.mdb

‘utilizando OLE DB.

conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0; DATA SOURCE=c:\meus documentos\nwind.mdb”

conn.Open

‘Agora crio um objeto do tipo RecordSet, o qual será,

‘automaticamente associado com a conexão conn.

inst_sql=“Select ShipCountry, Sum(Freight) As SomFrei from Orders Group By ShipCountry Order By Sum(Freight) Desc”

Set Ped= Server.CreateObject(“ADODB.RecordSet”)

Ped.Open inst_sql,conn,3,3

<P>

Soma do frete por país de destino.

</B></FONT>

</P>

<HR>

<TR>

30 31 32

<TD><B>País</B></TD> <TD><B>Soma do Frete </B></TD> </TR>

432

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

Do Until Ped.EOF

<TR>

<TD>

<TD align=Right><B><%=FormatNumber(Ped.Fields(“SomFrei”),2)

39 40

<%=Ped.Fields(“ShipCountry”)

</TD>

%> </B></TD> </TR>

Ped.MoveNext

Loop

</TABLE>

<HR>

</BODY>

</HTML>

Na Figura 7.23, temos o resultado da página exsum.asp, quando a mesma é carregada no Internet Explorer.

Figura 7.23: Resultados obtidos com a utilização da função Sum( ).

433

Criando Sites Dinâmicos com ASP 3.0

Apenas um comentário sobre a utilização da função FormatNumber: esta função foi utilizada para delimitar o resultado da soma em duas casas decimais. Exemplo 3: Ao invés da função Sum, vamos utilizar a função Avg, para retornar a média aritmética do valor do Frete (Freight) para cada país. Para obter este resultado, podemos utilizar o comando SQL a seguir: inst_sql=“Select ShipCountry, Avg(Freight) As AvgFrei from Orders Group By ShipCountry Order By Avg(Freight) Desc”

O resultado obtido com esta instrução é mostrado na Figura 7.24.

Figura 7.24: Resultados obtidos com a utilização da função Avg( ). Exemplo 4: Vamos construir um exemplo um pouco mais sofisticado. Vamos fazer com que sejam listados todos os pedidos, cujo valor do frete seja maior do que o valor médio do frete. A listagem será classificada em ordem decrescente do valor do frete. Podemos utilizar a seguinte instrução SQL: Select ShipCountry, OrderID, OrderDate, Avg(Freight) As AvgFrei from Orders Group By ShipCountry, OrderID, OrderDate Having Avg(Freight)>Davg(‘Freight’,’Orders’) Order By Avg(Freight) Desc

Observe que nesta instrução utilizamos algumas elementos novos, como por exemplo:

434

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

➥ A cláusula Having: quando utilizamos a cláusula Group By, devemos utilizar a cláusula Having ao invés da cláusula Where. ➥ Utilizamos a função Davg, que é uma função chamada de domínio. A função Davg foi utilizada para calcular a média geral do frete na tabela Orders. Utilizamos a seguinte sintaxe: Davg(‘Nome_campo’,‘Nome_da_tabela’)

Ao executarmos esta instrução SQL, obteremos os resultados indicados na Figura 7.25.

Figura 7.25: Resultados obtidos com a utilização da função de domínio Davg( ). Exemplo 5: Agora vamos utilizar as funções Max e Min, para retornar o pedido com o menor valor de frete e o pedido com o maior valor de frete. Na Listagem 7.7, temos um exemplo de uma página ASP, exmaxmin.asp, a qual faz uso das funções Max e Min Listagem 7.7 – Utilizando as funções de agregação Max ( ) e Min( )– exmaxmin.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<TITLE>Utilizando as funções Max e Min.</TITLE>

435

Criando Sites Dinâmicos com ASP 3.0

<BODY>

‘O primeiro passo é criar a conexão com o banco de dados.

‘Para isto crio um objeto do tipo Connection.

‘Cria um objeto do tipo ADODB.Connection

Set conn=Server.CreateObject(“ADODB.Connection”)

‘Agora abro uma conexão com o arquivo nwind.mdb

‘utilizando OLE DB.

conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0;

conn.Open

‘Agora crio um objeto do tipo RecordSet, o qual será,

‘automaticamente associado com a conexão conn.

DATA SOURCE=c:\meus documentos\nwind.mdb”

inst_sql=“Select Max(Freight) As MaiorFrete, Min(Freight) As MenorFrete From Orders”

Set Ped= Server.CreateObject(“ADODB.RecordSet”)

Ped.Open inst_sql,conn,3,3

<P>

Valores Máximos e Mínimos de Frete.

</B></FONT>

</P>

<HR>

<TR>

<TD><B>Máximo</B></TD>

<TD><B>Mínimo</B></TD>

</TR>

<TR>

<TD>

<%=Ped.Fields(“MaiorFrete”)

436

</TD>

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

<TD>

</TR>

</TABLE>

<HR>

</BODY>

</HTML>

<%=Ped.Fields(“MenorFrete”)

</TD>

A Figura 7.26 mostra o resultado da página exmaxmin.asp, ao ser carregada no Internet Explorer.

Figura 7.26: Resultados obtidos com a utilização das funções Max( ) e Min( ). Agora vamos ao nosso exemplo final, no qual iremos construir um formulário genérico, onde o usuário poderá selecionar por qual campo e por qual critério deseja fazer a pesquisa.

Um Formulário Genérico Para Pesquisas Para finalizar este capítulo vamos criar um formulário que permite pesquisas genéricas por até três critérios: ➥ País de destino. ➥ Ano do pedido. ➥ Parte do endereço.

437

Criando Sites Dinâmicos com ASP 3.0

O formulário permite que sejam feitas pesquisa utilizando um ou mais destes critérios. Na Figura 7.27 temos um exemplo do formulário geral.asp, onde o usuário pode selecionar por quais campos deseja pesquisar a tabela Orders e qual o valor para cada campo.

Figura 7.27: O formulário onde o usuário define os critérios a serem utilizados – geral.asp. Na Listagem 7.8, temos o código para a página geral.asp. Listagem 7.8 – O formulário para definição dos critérios de pesquisa – geral.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<HR>

438

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

<B>

Formulário para pesquisas na

tabela de Pedidos.<BR>

Selecione por qual ou quais campos deseja fazer a pesquisa,

<BR>

depois defina valores para os campos selecionados.<BR>

<HR>

‘O primeiro passo é criar a conexão com o banco de dados.

‘Para isto crio um objeto do tipo Connection.

‘Cria um objeto do tipo ADODB.Connection

Set conn=Server.CreateObject(“ADODB.Connection”)

‘Agora abro uma conexão com o arquivo nwind.mdb

‘utilizando OLE DB.

conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0;

conn.Open

‘Agora criamos os objetos RecordSet,

‘para criação das listas com os nomes dos países e

‘com a lista de anos para os quais existem pedidos.

Set Paises = Server.CreateObject(“ADODB.Recordset”)

Set Anos = Server.CreateObject(“ADODB.Recordset”)

Paises.Open “Select ShipCountry from Orders Group By ShipCountry Order By ShipCountry”, conn, 3, 3

Anos.Open “Select Year(OrderDate) As AnoPedido from Orders Group By Year(OrderDate) Order By Year(OrderDate)”, conn, 3, 3

‘Neste ponto tenho os objetos RecordSet necessários para a

‘criação das listas.

DATA SOURCE=c:\meus documentos\nwind.mdb”

439

Criando Sites Dinâmicos com ASP 3.0

Pesquisar por País?

<INPUT id=pesqpais name=pesqpais type=radio value=Sim>Sim

</FONT></B></FONT>

‘Agora construo a lista de opções a partir dos

‘dados obtidos da tabela Orders.

Do While Not Paises.EOF

Response.Write “<OPTION value=” & Chr(34) & Paises.Fields(“ShipCountry”) & Chr(34) & “>” & Paises.Fields(“ShipCountry”)& “</OPTION>”

Paises.MoveNext

Loop

</SELECT>

<B>

<HR>

Pesquisar pelo Ano?

<INPUT id=pesqano name=pesqano type=radio value=Sim>Sim

<INPUT CHECKED id=pesqano name=pesqano type=radio value=Nao>Não

<BR>

</FONT>

</B>

</FONT>

440

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

‘Agora construo a lista de opções a partir dos

‘dados obtidos da tabela Orders.

‘Para cada ano obtido, crio uma nova opção

‘na lista.

Do While Not Anos.EOF

Response.Write “<OPTION value=” & Chr(34) & Anos.Fields(“AnoPedido”) & Chr(34) & “>” & Anos.Fields(“AnoPedido”)& “</OPTION>”

Anos.MoveNext

Loop

</SELECT>

<B>

<HR>

O campo endereço deve conter?

<INPUT id=pesqend name=pesqend type=radio value=Sim>Sim

<INPUT CHECKED id=pesqend name=pesqend type=radio value=Nao>Não

<BR>

Digite parte do endereço:</FONT></B></FONT>

<HR>

</FORM>

</BODY>

</HTML>

Observe que mais uma vez as listas com os nomes dos países e os anos, para os quais existem pedidos, foram construídas dinamicamente, a partir dos dados da tabela Orders. Ao construir as listas dinamicamente, evitamos que o usuário tente pesquisar, por exemplo, os pedidos para um país que não existe na tabela Orders. Com isso o usuário não perde tempo e faz as pesquisas apenas para os países para os quais realmente existem pedidos cadastrados. O mesmo é válido para a lista com os anos para os quais existem pedidos cadastrados.

441

Criando Sites Dinâmicos com ASP 3.0

O próximo passo é construir a página pesquisa.asp. Esta página irá montar uma instrução SQL de acordo com as opções selecionadas pelo usuário na página geral.asp. Por exemplo, se o usuário marcar Sim somente para a lista de países e selecionar Argentina, a página pesquisa.asp terá que montar uma instrução SQL que pesquise a tabela Orders e retornar somente os pedidos em que o campo ShipCountry for igual a Argentina. Então vamos à construção da página pesquisa.asp. O ponto central da página pesquisa.asp é a montagem da instrução SQL com base nas opções selecionadas pelo usuário. O usuário possui três opções para definir parâmetros de pesquisa: ➥ País ➥ Data ➥ Endereço O usuário poderá selecionar uma ou mais opções. Com isto teremos oito possibilidades a serem consideradas; o usuário está pesquisando: ➥ Apenas pelo nome do país. ➥ Apenas pelo ano da data do pedido. ➥ Apenas pelo endereço ou parte do endereço. ➥ Pelo nome do país e pelo ano da data do pedido. ➥ Pelo nome e pelo endereço ou parte do endereço. ➥ Pelo ano da data do pedido e pelo endereço ou parte do endereço. ➥ Com base nos três critérios. Ou ainda: ➥ O usuário não especificou nenhum critério de pesquisa. A página pesquisa.asp terá que analisar essas oito possibilidades e montar uma instrução SQL diferente para cada uma delas. Na Listagem 7.9, temos o código para a página pesquisa.asp. Listagem 7.9 – O formulário para definição dos critérios de pesquisa – pesquisa.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

<TITLE>Resultado da pesquisa! </TITLE>

</HEAD>

442

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

‘O primeiro passo é criar a conexão com o banco de dados.

‘para isto crio um objeto do tipo Connection.

‘Cria um objeto do tipo ADODB.Connection

Set conn=Server.CreateObject(“ADODB.Connection”)

‘Agora abro uma conexão com o arquivo nwind.mdb

‘utilizando OLE DB.

conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0;

conn.Open

‘Agora passamos a analisar cada uma das oito possibilidades.

‘**************************************************

‘A primeira possibilidade é o caso em que o usuário

‘selecionou apenas um país na lista de países.

If (Request.Form(“pesqpais”)=“Sim” And Request.Form(“pesqano”)=“Nao” And

DATA SOURCE=c:\meus documentos\nwind.mdb”

Request.Form(“pesqend”)=“Nao”) Then 21

inst_sql=“Select * from orders where ShipCountry=’” & Request.Form (“listapaises”) & “‘“

Response.Write “Você pesquisou pelo critério País = <B>” & Request.Form (“listapaises”) & “</B><HR>”

End If

‘**************************************************

‘A segunda possibilidade é o caso em que o usuário

‘selecionou apenas um ano na lista de anos.

If (Request.Form(“pesqpais”)=“Nao” And Request.Form(“pesqano”)=“Sim” And Request.Form(“pesqend”)=“Nao”) Then

inst_sql=“Select * from orders where Year(OrderDate)=” & Request.Form (“listaano”)

Response.Write “Você pesquisou pelo critério Ano = <B>” & Request.Form (“listaano”) & “</B><HR>”

End If

‘**************************************************

‘A terceira possibilidade é o caso em que o usuário

‘digitou um critério para pesquisar no endereço.

443

Criando Sites Dinâmicos com ASP 3.0

If (Request.Form(“pesqpais”)=“Nao” And Request.Form(“pesqano”)=“Nao” And Request.Form(“pesqend”)=“Sim”) Then

inst_sql=“Select * from orders where ShipAddress Like ‘%” & Request.Form (“partend”) & “%’”

Response.Write “Você pesquisou pelo critério Endereço contendo: <B>” & Request.Form(“partend”) & “</B><HR>”

End If

‘**************************************************

‘A quarta possibilidade é o caso em que o usuário

‘selecionou um país na lista de países e também

‘selecionou um ano na lista de anos.

If (Request.Form(“pesqpais”)=“Sim” And Request.Form(“pesqano”)=“Sim” And Request.Form(“pesqend”)=”Nao”) Then

inst_sql=“Select * from orders where ShipCountry=’” & Request.Form (“listapaises”) & “‘ and Year(OrderDate)=” & Request.Form(“listaano”)

Response.Write “Você pesquisou pelos seguintes critérios <BR>”

Response.Write “País = <B>” & Request.Form(“listapaises”) & “</B><BR>”

Response.Write “Ano = <B>” & Request.Form(“listaano”) & “</B><BR><HR>”

End If

‘**************************************************

‘A quinta possibilidade é o caso em que o usuário

‘selecionou um país na lista de países e também

‘digitou um critério para pesquisar no endereço.

If (Request.Form(“pesqpais”)=“Sim” And Request.Form(“pesqano”)=“Nao” And Request.Form(“pesqend”)=“Sim”) Then

inst_sql=“Select * from orders where ShipCountry=’” & Request.Form (“listapaises”) & “‘ and ShipAddress Like ‘%” & Request.Form(“partend”)& “%’”

Response.Write “Você pesquisou pelos seguintes critérios <BR>”

Response.Write “País = <B>” & Request.Form(“listapaises”) & “</B><BR>”

Response.Write “Endereço contendo:<B>” & Request.Form(“partend”) & “</B><BR><HR>”

End If

‘**************************************************

‘A sexta possibilidade é o caso em que o usuário

‘selecionou um ano na lista de anos e também

‘digitou um critério para pesquisar no endereço.

If (Request.Form(“pesqpais”)=“Nao” And Request.Form(“pesqano”)=”Sim” And Request.Form(“pesqend”)=“Sim”) Then

inst_sql=“Select * from orders where Year(OrderDate)=” & Request.Form (“listaano”) & “ and ShipAddress Like ‘%” & Request.Form(“partend”)& “%’”

Response.Write “Você pesquisou pelos seguintes critérios <BR>”

444

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

Response.Write “Ano = <B>” & Request.Form(“listaano”) & “</B><BR>”

Response.Write “Endereço contendo:<B>” & Request.Form(“partend”) & “</B><BR><HR>”

End If

‘**************************************************

‘A sétima possibilidade é o caso em que o usuário

‘não selecionou nenhum dos três critérios.

If (Request.Form(“pesqpais”)=“Nao” And Request.Form(“pesqano”)=“Nao” And Request.Form(“pesqend”)=“Nao”) Then

inst_sql=“Select * from orders”

Response.Write “Você não especificou nenhum critério. <BR>”

Response.Write “Foram retornados todos os registros.<HR>”

End If

‘**************************************************

‘A oitava possibilidade é o caso em que o usuário

‘selecionou os três critérios

If (Request.Form(“pesqpais”)=“Sim” And Request.Form(“pesqano”)=“Sim” And Request.Form(“pesqend”)=“Sim”) Then

inst_sql=“Select * from orders where Year(OrderDate)=” & Request.Form (“listaano”) & “ and ShipAddress Like ‘%” & Request.Form(“partend”)& “%’ and ShipCountry=’” & Request.Form(“listapaises”) & “‘“

Response.Write “Você pesquisou pelos seguintes critérios <BR>”

Response.Write “País = <B>” & Request.Form(“listapaises”) & “</B><BR>”

Response.Write “Ano = <B>” & Request.Form(“listaano”) & “</B><BR>”

Response.Write “Endereço contendo:<B>” & Request.Form(“partend”) & “</B><BR><HR>”

End If

‘Agora criamos um objeto RecordSet.

Set Pedidos = Server.CreateObject(“ADODB.Recordset”)

Pedidos.Open inst_sql, conn, 3, 3

‘Neste ponto tenho o objeto RecordSet com

‘os resultados da pesquisa.

‘*************************************************

‘Passo a exibir os resultados obtidos.

Response.Write “<B>Foram Encontrados: ” & Pedidos.RecordCount & “Registros </B><HR>”

<A HREF=“geral.asp”>Clique aqui para fazer outra pesquisa.</A>

<HR>

445

Criando Sites Dinâmicos com ASP 3.0

<TR>

<TD><B>Código

</B></TD>

100

<TD><B>Data

</B></TD>

101

<TD><B>Endereço</B></TD>

102

<TD><B>País

</B></TD>

103 </TR> 104 <% 105 Do While Not Pedidos.EOF 106 %> 107 <TR> 108

<TD><% =Pedidos.Fields(“OrderID”)

%></TD>

109

<TD><% =Pedidos.Fields(“OrderDate”)

%></TD>

110

111

112 </TR> 113 <% 114 Pedidos.MoveNext 115 Loop 116 %> 117 </TABLE> 118 </BODY> 119 </HTML>

Observe que a página pesquisa.asp não tem nada de especial. Apenas testamos as oito possibilidades descritas anteriormente. Para cada uma das possibilidades montamos a instrução SQL correspondente e informamos os critérios de pesquisa especificados pelo usuário.

Utilizando o Nosso Formulário de Pesquisa Agora vamos demonstrar a utilização do nosso formulário genérico para pesquisas na tabela Orders. Na Figura 7.28 temos um exemplo onde o usuário apenas definiu um país como critério, no caso o país selecionado foi Austria.

446

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

Figura 7.28: Pesquisando os pedidos para Austria. Ao clicar no botão Pesquisar, são obtidos os resultados indicados na Figura 7.29. Observe que foram encontrados 40 registros para Austria.

Figura 7.29: Listagem de pedidos para Austria.

447

Criando Sites Dinâmicos com ASP 3.0

Agora vamos clicar no link Clique aqui para fazer outra pesquisa, com isso voltaremos para a página geral.asp, onde poderemos definir outros critérios de pesquisa. Vamos refinar um pouco mais a nossa pesquisa. Selecione Austria na lista País e 1994 na lista Ano. Não esqueça de marcar a opção Sim ao lado de cada critério selecionado, caso contrário o critério será ignorado. O formulário de pesquisa deverá estar igual ao indicado na Figura 7.30.

Figura 7.30: Pesquisando os pedidos para Austria no ano de 1994. Ao clicar no botão Pesquisar, são obtidos os resultados indicados na Figura 7.31. Observe que foram encontrados cinco registros para Austria no ano de 1994. Agora vamos fazer uma pesquisa envolvendo os três critérios. Vamos definir os seguintes critérios: ➥ País: Brazil ➥ Ano: 1994 ➥ Endereço contendo: Rua Clique no link Clique aqui para fazer outra pesquisa, com isso voltaremos para a página geral.asp. Defina os critérios de pesquisa conforme indicado na Figura 7.32.

448

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

Figura 7.31: Listagem de pedidos para Austria no ano de 1994.

Figura 7.32: Pesquisando os pedidos para Brazil, no ano de 1994 e com o endereço contendo a palavra Rua.

449

Criando Sites Dinâmicos com ASP 3.0

Ao clicar no botão Pesquisar, são obtidos os resultados indicados na Figura 7.33. Observe que foram encontrados seis registros para Brazil, no ano de 1994, com o endereço contendo a palavra Rua.

Figura 7.33: Listagem de pedidos para Brazil, no ano de 1994, com o endereço contendo a palavra Rua. Veja que, através deste exemplo, conseguimos criar um formulário de pesquisa extremamente versátil. Podemos definir de um a três critérios de pesquisa, além de definir o valor para cada critério. Este exemplo demonstra as possibilidades na utilização de ASP para a construção de sites dinâmicos.

Conclusão Neste capítulo aprendemos uma série de técnicas úteis na construção de aplicações Web profissionais. Iniciamos pelo estudo dos objetos Command e Parameter, os quais facilitam a execução de Consultas Parametrizadas, bem como o envio de parâmetros e o recebimento de valores de retorno dos Stored Procedures. Além disso, utilizando os métodos e propriedades dos objetos

450

Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II

Command e Parameter podemos ter um controle bastante apurado sobre tipo, tamanho e outras características dos parâmetros a serem passados para consultas e Stored Procedures. Foram apresentados exemplos práticos de utilização destes dois objetos. Depois passamos a estudar alguns conceitos avançados na utilização da linguagem SQL. Aprendemos a utilizar os operadores Like, And e Or, In e Not. Também aprendemos a utilizar as funções de agregação e a função de domínio Davg. Foram apresentados exemplos práticos de utilização dos conceitos avançados da linguagem SQL. Por fim, apresentamos um exemplo prático que salienta a natureza dinâmica e as capacidades do ASP 3.0, na construção de sites dinâmicos, principalmente no que se refere a conexão e pesquisas em bancos de dados. Os exemplos deste capítulo foram baseados no arquivo nwind.mdb, o qual é fornecido juntamente com o Microsoft Access. O nome dos campos estão em inglês. Caso você esteja utilizando uma versão do nwind.mdb que esteja com o nome dos campos em português, utilize os nomes de campos da sua versão. No próximo capítulo falaremos um pouco mais sobre o que é uma aplicação Web e sobre os conceitos de Sessão e Aplicação, além de aprendermos o conceito de componentes ASP.

451

Capítulo 8 – Aplicativos Web e Componentes

Capítulo 8 Aplicativos Web e Componentes

453

Criando Sites Dinâmicos com ASP 3.0

Introdução Neste capítulo veremos o que significa uma “Aplicação Web” criada em ASP, que fica armazenada no servidor IIS. Veremos exatamente quais os componentes que formam uma aplicação Web. Revisaremos o conceito de estado e os problemas oriundos do fato do protocolo HTTP não manter uma conexão aberta após o carregamento da página. Iremos conhecer a utilização e o funcionamento do arquivo global.asa, o qual é de grande importância para o gerenciamento de aplicações Web no IIS. Em seguida passaremos a estudar o objeto Session. Com o objeto Session, podemos manter valores para um determinado usuário, enquanto o mesmo estiver acessando uma aplicação Web. Por exemplo, quando um usuário passa de uma página para outra, a página acessada não teria como acessar as opções selecionadas pelo usuário e os dados da página anterior, a não ser que tivessem sido armazenados em um banco de dados. Então, a página que está sendo acessada, recuperaria estas informações a partir deste banco de dados. Porém, trabalhar intensivamente com o banco de dados pode degradar o desempenho da aplicação. Com o objeto Session podemos armazenar informações utilizadas em uma sessão do usuário. As variáveis armazenadas no objeto Session não serão perdidas quando o usuário acessar outras páginas da nossa aplicação Web. Estas variáveis somente serão descartadas quando o usuário sair da aplicação, ou quando a sessão for encerrada por TimeOut. O objeto Application pode ser utilizado para compartilhar informações entre todos os usuários que estão acessando uma determinada aplicação Web. Enquanto o objeto Session permite que um usuário tenha acesso à variáveis armazenadas nele; o objeto Application permite que todos os usuários que estão acessando a aplicação Web tenham acesso às informações armazenadas neste objeto. Veremos exemplos de código que utilizam os objetos Session e Application, bem como os diversos métodos, propriedades e eventos destes objetos.

O que é uma Aplicação Web no IIS? Antes de definirmos exatamente o que compõe uma aplicação Web no IIS, vamos fazer uma comparação entre as aplicações Cliente/Servidor tradicionais e as aplicações Web, com ênfase no conceito de conexão e estado.

454

Capítulo 8 – Aplicativos Web e Componentes

Uma Aplicação Cliente/Servidor Tradicional Em uma aplicação Cliente/Servidor tradicional, temos a aplicação Cliente instalada em cada uma das estações da rede que farão acesso a aplicação, e podemos ter uma camada de lógica instalada no servidor de Aplicações, através da qual é feito o acesso ao banco de dados. Quando o usuário inicia a aplicação Cliente, o mesmo se identifica, normalmente através de um nome de usuário (username ou login) e de uma senha. As informações de identificação são utilizadas para estabelecer uma “conexão” com o servidor. Esta conexão é mantida enquanto a aplicação Cliente estiver sendo utilizada. Através desta conexão, o lado servidor da aplicação consegue identificar o usuário. Com a identificação do usuário podem ser aplicadas regras de segurança, como níveis de permissão de acesso aos dados, níveis de permissão para as funcionalidades da aplicação, log das ações realizadas pelo usuário, etc. Por exemplo, as opções de menu da aplicação Cliente podem ser montadas com base nas permissões de acesso que o usuário possui. Se o usuário não possui permissões para alterar os dados, o menu com as opções de alteração não será exibido para ele. Através da manutenção da conexão e da respectiva possibilidade de identificar unicamente cada um dos usuários conectados, podemos implementar a maioria das funcionalidades essenciais nas aplicações Cliente/Servidor tradicionais. Porém, existem diversos problemas na atualização e manutenção deste tipo de aplicação, dentre os quais podemos destacar: ➥ A atualização dos sistemas é problemática pois, neste modelo, cada vez que houver alteração na camada de apresentação (no modelo de n camadas) ou até mesmo na camada de Lógica do Negócio (no modelo mais antigo de duas camadas), a aplicação terá que ser atualizada em todas as estações de trabalho que utilizam a aplicação.

NOTA Para maiores detalhes sobre os modelos de aplicação de duas ou mais camadas, consulte o Capítulo 1. ➥ Controle de versão: Garantir que todas as estações de trabalho estejam com a última versão da aplicação é uma tarefa nada fácil, a qual, dependendo do número de estações da rede da empresa, pode exigir uma equipe de Help Desk praticamente dedicada a esta tarefa. ➥ Problemas de conflitos de DLL e padronização de ambiente tornam a manutenção e o gerenciamento destas aplicações uma tarefa difícil e de custo elevado.

455

Criando Sites Dinâmicos com ASP 3.0

Estes problemas surgem para cada aplicação Cliente/Servidor tradicional que estiver sendo usada. Agora imagine o caso de uma grande empresa, com milhares de computadores ligados em rede, com dezenas de aplicações. A situação torna-se insustentável, além do custo de manutenção e suporte atingir patamares impraticáveis. Para resolver estes e outros problemas das aplicações Cliente/Servidor tradicionais é que começaram a ser desenvolvidas aplicações para a Web, das quais vamos falar um pouco mais.

Aplicações Web – um Novo Paradigma Para resolver os tradicionais problemas das aplicações Cliente/Servidor é que surge o conceito de aplicação Web. Para acessar uma aplicação Web o único programa que o usuário precisa é um navegador instalado na sua estação. Existem inclusive aplicações Web bem projetadas que não obrigam o usuário a utilizar um navegador específico, o que aumenta mais ainda a flexibilidade. Uma aplicação Web reside no servidor, no nosso caso no IIS. Toda e qualquer alteração que se fizer necessária na aplicação, será feita diretamente no servidor Web, sem que seja necessária nenhuma modificação nas estações dos usuários. Na próxima vez que o usuário acessar a aplicação, utilizando o navegador instalado em sua estação, já estarão disponíveis as alterações efetuadas. Com este modelo não é necessária a “atualização” (que muitas vezes significa uma reinstalação) da aplicação em todas as estações da rede, cada vez que forem feitas alterações na aplicação. Com isso, a equipe de suporte fica dispensada da tediosa tarefa de atualização da aplicação em cada estação da rede. O modelo de aplicações Web traz inúmeras vantagens, dentre as quais podemos destacar: ➥ Atualização das aplicações centralizada no servidor Web, sem a necessidade de atualizar todas as estações da rede que acessam a aplicação. ➥ Facilidade de manutenção e suporte, uma vez que o cliente precisa somente de um navegador para acessar a aplicação. ➥ Redução do chamado TCO – Total Cost Ownership (Custo Total de Propriedade). O TCO é uma medida de quanto custa, por ano, a manutenção de uma estação de rede em funcionamento. O cálculo do TCO leva em consideração diversos fatores. Para maiores informações sobre este cálculo acesse o site do Gardner Group na Internet. Porém nem tudo são vantagens. Pela natureza e implementação do modelo Web, o qual faz uso do protocolo HTTP, as aplicações Web não têm como manter uma conexão permanente com o usuário. Por isso que o modelo Web, muitas vezes, é conhecido como “State Less”, isto é, “Sem estado”. Isso acontece porque após ter enviado a página solicitada pelo usuário, a

456

Capítulo 8 – Aplicativos Web e Componentes

conexão é encerrada, não sendo possível continuar trocando informações com o usuário, a não ser que uma nova conexão seja estabelecida. Para vencer as limitações impostas por este modelo “State Less”, é que iremos estudar os objetos Application e Session do ASP, além de aprendermos sobre o que é e como utilizar o arquivo global.asa. Através da utilização destes objetos, podemos manter diversas informações sobre o usuário que está acessando a aplicação Web. Na verdade estamos “simulando” uma conexão, porém utilizando os recursos disponibilizados pelos objetos Application e Session. A possibilidade de diferenciar cada usuário que está acessando uma aplicação Web é de fundamental importância, para que possamos criar conteúdos mais personalizados e interativos, além da possibilidade de aplicar conceitos como níveis de permissão de acesso aos dados e auditoria de acesso.

Aplicações Web no IIS Agora que já sabemos que o modelo de desenvolvimento baseado na Web é o modelo dominante para o desenvolvimento de novas aplicações, vamos aprender a identificar quais os elementos que compõem uma aplicação Web no IIS. De uma maneira simples e didática poderíamos definir uma aplicação Web desenvolvida com ASP como sendo: “Uma pasta virtual e todas as suas subpastas, com o conjunto de páginas ASP e componentes COM ou COM+, projetadas para executar uma ou mais tarefas específicas, por exemplo um sistema para controle do departamento de Recursos Humanos.” Conforme detalharemos mais adiante, componentes COM ou COM+ (no Windows 2000 o padrão COM foi aperfeiçoado e transformado em COM+) são elementos de software que desempenham funções específicas. Por exemplo, a minha aplicação de controle do departamento de Recursos Humanos pode fazer uso de um componente COM+ o qual faz cálculos previdenciários. Um componente COM+ pode ser desenvolvido internamente na empresa, para ser utilizado por uma ou mais aplicações ou pode ser adquirido de empresas especializadas no desenvolvimento de componentes. O nosso conjunto de páginas ASP pode fazer uso dos diversos componentes disponíveis para a aplicação Web.

NOTA No Capítulo 10 voltaremos a falar de componentes e do Microsoft Transaction Services.

457

Criando Sites Dinâmicos com ASP 3.0

No IIS, o ponto de partida para criar uma aplicação Web é criar uma pasta. O próximo passo é transformar esta pasta em uma “Pasta Virtual” do servidor IIS.

NOTA Para saber como transformar uma pasta em uma “Pasta Virtual” do IIS, consulte o Capítulo 1, no item “Tornando a pasta livro, parte do servidor IIS”. Vamos supor que você tenha criado uma pasta chamada WebApl no drive (C:\WebApl), de um servidor IIS chamado www.abc.com.br. Agora você registrou esta pasta como uma pasta virtual chamada WebApl. Dentro do diretório você criou uma página ASP chamada index.asp, a qual será a página inicial da aplicação Web. Você lembra como seria o endereço para acessar a página index.asp do diretório virtual WebApl do servidor www.abc.com.br? O endereço seria o seguinte: http://www.abc.com.br/WebApl/index.asp

Dentro da pasta WebApl poderíamos criar outras pastas, conforme a necessidade da nossa aplicação Web. As pastas criadas dentro de uma pasta virtual, já passam a ser acessíveis para o servidor Web. Por exemplo, dentro da pastas WebApl criamos uma pasta chamada Seguranca. Dentro dela colocamos um arquivo chamado login.asp. O endereço para acessar o arquivo login.asp seria o seguinte: http://www.abc.com.br/WebApl/Seguranca/login.asp

Todos as subpastas da pasta WebApl também farão parte da aplicação Web. Com isso podemos concluir, em um primeiro momento, que uma aplicação Web do IIS está ligada à criação de uma pasta virtual no servidor IIS. O próximo passo é configurar as propriedades da aplicação Web. Para isso utilizamos o Gerenciador do Internet Services, conforme ilustrado nos passos a seguir. Para configurar as propriedades de uma aplicação Web faça o seguinte: 1. Faça o logon no Windows 2000 Server, com permissões de administrador. 2. Abra o Gerenciador do Internet Services: Iniciar/Programas/Ferramentas administrativas/ Gerenciador do Internet Services. 3. Surge a janela indicada na Figura 8.1.

458

Capítulo 8 – Aplicativos Web e Componentes

Figura 8.1: Gerenciador do Internet Services. 4. Esta é a janela do console de administração do IIS 5.0. 5. Dê um clique duplo no nome do computador. No nosso exemplo o nome é servidor. 6. Surgem as opções indicadas na Figura 8.2.

Figura 8.2: Opções de gerenciamento do IIS. 7. Todos os aplicativos Web estão disponíveis através da opção Site da Web Padrão. Dê um clique no sinal de + ao lado desta opção para abri-la. 8. Serão exibidas todas as pastas virtuais disponíveis no servidor IIS, conforme indicado na Figura 8.3.

459

Criando Sites Dinâmicos com ASP 3.0

Figura 8.3: Pastas virtuas do servidor IIS. 9. No nosso exemplo queremos configurar as propriedades da pasta virtual WebApl. Neste ponto o conceito de pasta virtual confunde-se com o de aplicação Web. Na verdade, a nossa aplicação WebApl está contida na pasta virtual WebApl. 10. Dê um clique com o botão direito do mouse sobre WebApl. 11. No menu de opções que surge dê um clique em Propriedades. 12. Será exibida a janela Propriedades de WebApl, conforme indicado na Figura 8.4. Observe que nesta janela temos diversas informações, tais como: ➥ Caminho da pasta: C:\WebApl. Este é o caminho físico onde são gravados os elementos da aplicação Web. No nosso exemplo, é a pasta WebApl do drive C:. ➥ Permissões de acesso à pasta virtual da aplicação: Observe que, por padrão, somente são marcadas as opções de leitura, criação de log e indexação. Falaremos mais sobre estas permissões no Capítulo 9, sobre segurança em aplicações desenvolvidas com ASP. No Capítulo 9 também falaremos das opções: Permissões de execução e Proteção do aplicativo.

460

Capítulo 8 – Aplicativos Web e Componentes

Figura 8.4: Propriedades da aplicação Web – WebApl. ➥ Nome do aplicativo: No nosso exemplo é WebApl. A principal opção desta janela é o botão Configuração. 13. Dê um clique no botão Configuração. 14. Surge a janela Configuração de aplicativo, indicada na Figura 8.5.

Figura 8.5: Configurando as propriedades da aplicação Web – WebApl.

461

Criando Sites Dinâmicos com ASP 3.0

Na primeira guia, Mapeamento de aplicativo, temos a indicação de qual componente do IIS irá processar cada requisição do usuário. Este mapeamento é baseado na extensão do arquivo. Por exemplo, toda página com a extensão .asp será processada pela DLL asp.dll (que na verdade é o interpretador ASP), conforme indicado pela Figura 8.6.

Figura 8.6: A DLL asp.dll é responsável pelo processamento das páginas ASP. 15. Não iremos alterar nenhuma opção nesta guia. 16. Dê um clique na guia Opções de aplicativo. 17. Nesta segunda guia, temos diversas configurações importantes, conforme indicado na Figura 8.7.

Figura 8.7: Opções da guia Opções de aplicativo.

462

Capítulo 8 – Aplicativos Web e Componentes

Abaixo temos a descrição destas opções: ➥ Ativar o estado da sessão: Use essa caixa de seleção para ativar ou desativar o estado da sessão. Quando o estado da sessão é ativado, o Active Server Pages cria uma sessão para cada usuário que acessa um aplicativo ASP, de modo que você possa identificar o usuário através das páginas do aplicativo. Quando o estado da sessão é desativado, o ASP não controla usuários e não permite que um script do ASP armazene informações no objeto Session ou use os eventos Session.OnStart ou Session.OnEnd. Uma sessão é finalizada automaticamente se o usuário não solicitou ou atualizou uma página em um aplicativo no fim do tempo limite – TimeOut. Um script pode terminar explicitamente uma sessão com o método Session.Abandon. Mesmo que o estado da sessão esteja ativado em um aplicativo, você poderá desativá-lo em uma página ASP individual usando a diretiva <%@ ENABLESESSIONSTATE = False %>, no cabeçalho da página. Veremos mais detalhes sobre o objeto Session, ainda neste capítulo. ➥ Tempo limite da sessão: No nosso exemplo está definido em 20 minutos. Uma sessão é finalizada automaticamente se o usuário não solicitou ou atualizou uma página em um aplicativo por um tempo maior do que o tempo limite – TimeOut. ➥ Ativar o Buffer: Por padrão esta opção é ativada no IIS 5.0. Nas versões anteriores esta propriedade era desativada por padrão. Quando o Buffer está ativo, o resultado do processamento de uma página ASP somente é enviado para o navegador do cliente, quando toda a página tiver sido processada, a menos que seja utilizado o método Flush do objeto Response. ➥ Ativar os caminhos pai: Marque esta caixa de seleção para permitir que as páginas ASP usem os caminhos relativos do diretório pai do diretório atual (caminhos que usam a sintaxe ..), também conhecidos como endereços relativos.

IMPORTANTE Se você ativar essa opção, não forneça acesso de execução aos diretórios pai, caso contrário, um script poderá tentar executar um programa não autorizado em um diretório pai. ➥ Linguagem ASP padrão: Por padrão é definida como sendo VBScript. Caso deseje, pode alterar para JScript. Também podemos especificar o nome de qualquer outra linguagem para a qual tenhamos o interpretador instalado no servidor IIS, como por exemplo Perl. Esta opção define a linguagem que será utilizada para interpretar os comandos dentro das tags <% e %>.

463

Criando Sites Dinâmicos com ASP 3.0

➥ Tempo limite do script ASP: Especifica o período de tempo durante o qual o ASP permitirá a execução de um script. Se a execução do script não terminar ao final do período de tempo limite, o ASP irá pará-lo e gravar um evento no arquivo de log de eventosYdo Windows 2000. Você pode definir o período de tempo limite como um valor entre 1 e 2147483647, além de poder substituir essa opção em uma página ASP usando o método Server.ScriptTimeout. 18. Não iremos alterar nenhuma opção nesta guia. 19. Dê um clique na guia Depuração de aplicativo. 20. Na guia Depuração de aplicativo, temos diversas configurações relacionadas com a depuração de erros em páginas ASP, conforme indicado na Figura 8.8.

Figura 8.8: Opções da guia Depuração de aplicativo. Abaixo temos a descrição das opções: ➥ Ativar a depuração de script ASP do lado do servidor: Marque esta opção para permitir que o servidor Web entre no depurador de scripts da Microsoft durante o processamento de páginas ASP. Em seguida, você pode usar o depurador para examinar seus scripts. Por questões de desempenho, a depuração do ASP não é recomendada em um ambiente de produção.

464

Capítulo 8 – Aplicativos Web e Componentes

➥ Ativar a depuração de script ASP do lado do cliente: Essa caixa de seleção está reservada para uso futuro e não tem efeito sobre a versão atual do ASP (esta é a informação contida na própria documentação do IIS 5.0). ➥ Enviar mensagens de erro do ASP detalhadas para o cliente: Selecione essa opção para enviar informações específicas de depuração (incluindo o nome do arquivo, a mensagem de erro e o número da linha) para o navegador. Principalmente quando estamos desenvolvendo nossas aplicações é importante que esta opção esteja selecionado, pois ao testarmos uma página, se a mesma contiver um erro, o navegador informa o número da linha onde está o erro, o que facilita a correção do script. ➥ Enviar mensagem de erro de texto para o cliente: Selecione esta opção para enviar uma mensagem de erro padrão ao navegador quando algum erro impedir o servidor Web de processar a página ASP. Uma mensagem de erro específica é gravada no log de erros. Você pode alterar a mensagem de erro padrão digitando uma nova mensagem na caixa de texto. Não é recomendada a utilização desta opção no ambiente de desenvolvimento, pelos motivos descritos no parágrafo anterior. 21. Não iremos alterar nenhuma opção nesta guia. 22. Dê um clique no botão OK para fechar a janela de configuração. 23. Dê um clique no botão OK para fechar a janela de propriedades da pasta virtual WebApl. 24. Você estará de volta ao Gerenciador do Internet Services. 25. Feche-o. Bem, agora já conhecemos o que é uma aplicação Web do IIS e quais os elementos que a compõem. Um último elemento, porém não menos importante, é um arquivo chamado global.asa. No próximo item iremos aprender o que é este arquivo.

O Arquivo Global.asa O arquivo global.asa é um arquivo opcional, porém é bastante comum a utilização do mesmo em nossas aplicações Web residentes no IIS. A extensão .asa é uma abreviatura para Active Server Applications. O arquivo global.asa trabalha em conjunto com os objetos Application e Session, para permitir o gerenciamento das informações de estado de cada usuário que acessa a aplicação. No arquivo global.asa é possível especificar scripts de eventos e declarar os objetos que têm escopo de sessão (Session) ou de aplicação (Application). Não se trata de um arquivo de conteúdo exibido para os usuários; em vez disso, o arquivo armazena informações de eventos e os objetos utilizados globalmente pelo aplicativo. Esse arquivo deve ser nomeado como global.asa e armazenado na pasta raiz do aplicativo.

465

Criando Sites Dinâmicos com ASP 3.0

Um Aplicativo só Pode ter um Arquivo Global.asa A capacidade de manter informações sobre cada usuário conectado com a aplicação é de fundamental importância, conforme já descrito anteriormente. Quando a aplicação é acessada pela primeira vez, o arquivo global.asa é carregado na memória do servidor Web. Depois é utilizado para acompanhar eventos da aplicação como um todo e de cada usuário conectado. Através do arquivo global.asa podemos acompanhar, para o objeto Session, os seguintes eventos: ➥ Session_OnStart: Este evento ocorre quando o usuário acessa uma das páginas da aplicação Web. Quando o usuário acessar outras páginas, dentro da mesma aplicação, este evento não ocorrerá novamente, ou seja, o evento Session_OnStart somente ocorre para a primeira página da aplicação que o usuário acessar; ele ocorre quando o servidor cria uma nova sessão. O servidor processa esse script antes de executar a página solicitada. O evento Session_OnStart é o momento adequado para definir as variáveis no nível de sessão, porque as mesmas serão definidas antes de se acessar quaisquer páginas. ➥ Session_OnEnd: Este evento ocorre quando a sessão do usuário é encerrada por TimeOut ou quando o usuário acessar uma página de outra aplicação Web. Estes eventos são utilizados para o acompanhamento de informações de sessões individuais de cada usuário, através da utilização do objeto Session. O objeto Session pode ser utilizado para passar informações entre as diversas páginas ASP da aplicação, dentro de uma sessão de usuário. Não podemos utilizar o objeto Session para passar informações entre sessões de usuários diferentes, para isso utilizamos o objeto Application. Para o objeto Application podemos acompanhar os eventos: ➥ Application_OnStart: Ocorre quando o primeiro usuário acessar uma das páginas da aplicação Web. O evento Application_OnStart ocorre antes da criação da primeira sessão nova, isto é, antes do evento Session_OnStart. Por exemplo, se você está desenvolvendo uma aplicação de Comércio Eletrônico, na qual os preços estão em dólar, mas o usuário tem a opção de converter os valores para reais, você pode utilizar o evento Application_OnStart para tornar disponível a cotação do dólar, para qualquer página dentro da aplicação. ➥ Application_OnEnd: O evento Application_OnEnd ocorre quando o aplicativo é encerrado, após o evento Session_OnEnd. Estes objetos são utilizados para monitorar todos os objetos Application, os quais contém informações disponíveis para quaisquer usuários que acessarem a aplicação. Na Listagem 8.1, temos um exemplo de um arquivo global.asa típico.

466

Capítulo 8 – Aplicativos Web e Componentes

Listagem 8.1 – Um exemplo de arquivo global.asa. 1

‘Sub Session_OnStart

‘** Código para o evento.

‘End Sub

‘EventName

Description

‘Session_OnStart

Runs the first time a user runs any page in your application

‘Session_OnEnd

Runs when a user’s session times out or quits your application

‘Application_OnStart

Runs once when the first page of your application is run for the first 9 time by any user

‘Application_OnEnd

Runs once when the web server shuts down

</SCRIPT>

Sub Application_OnStart

Application(“nwind_ConnectionString”) = “DSN=nwind;DBQ=C:\MEUS DOCUMENTOS\NWIND.MDB;DriverId=281;FIL=MS Access;MaxBufferSize=2048;PageTimeout=5;”

Application(“nwind_ConnectionTimeout”) = 15

Application(“nwind_CommandTimeout”) = 30

Application(“nwind_CursorLocation”) = 3

Application(“nwind_RuntimeUserName”) = “”

Application(“nwind_RuntimePassword”) = “”

End Sub

</SCRIPT>

Observe que no evento Application_OnStart configuramos os parâmetros para uma conexão, via ODBC, com o banco de dados C:\Meus documentos\nwind.mdb. Estas informações estarão disponíveis para qualquer usuário que acessar a nossa aplicação Web, pois as mesmas foram definidas através do evento Application_OnStart. Agora que já conhecemos a anatomia de uma aplicação Web no IIS, bem coma a função do arquivo global.asa, vamos estudar os objetos Session e Application, para que possamos aprender na prática a utilizá-los.

467

Criando Sites Dinâmicos com ASP 3.0

O Objeto Application Conforme descrito anteriormente, podemos utilizar o objeto Application para compartilhar informações entre todos os usuários de um determinado aplicativo. Um aplicativo Web baseado no ASP é definido como todos os arquivos .asp em uma pasta virtual e seus subdiretórios. Como o objeto Application pode ser compartilhado por mais de um usuário, existem os métodos Lock e Unlock para garantir que vários usuários não tentarão alterar uma propriedade ao mesmo tempo. Itens do objeto Application podem ser variáveis necessárias para todos os usuários que acessam uma aplicação, como a cotação do dólar ou o índice da poupança. Também podemos utilizar o objeto Application para criar uma instância de um componente que fornece uma determinada funcionalidade utilizada pela nossa aplicação Web. Uma aplicação Web é inicializada quando qualquer uma de suas páginas ASP for acessada. A partir do momento em que a primeira página ASP for acessada, o objeto Application estará disponível e quaisquer valores que tenham sido definidos por este objeto, estarão disponíveis para todos os usuários que acessarem a aplicação. O diagrama da Figura 8.9, demonstra a relação entre o objeto Application, o servidor Web e as diversas aplicações Web hospedadas no servidor. Usuário 1 Aplicação: web1 objeto Application

Usuário 2 Usuário 3

Aplicação: web2 objeto Application

Usuário 4 Usuário 5

Servidor Web Aplicação: web3 objeto Application

Usuário 6

Cada aplicação possui o seu próprio objeto Application.

Figura 8.9: Relação entre o objeto Application, o servidor Web e as diversas aplicações. Cada aplicação Web possui seu próprio objeto Application e informações disponíveis no objeto Application podem ser acessadas por quaisquer usuário que estiverem acessando a

468

Capítulo 8 – Aplicativos Web e Componentes

aplicação. Também podemos notar, na Figura 8.9, que em um mesmo servidor Web podemos ter várias aplicações Web. Agora passaremos a estudar os eventos, coleções e métodos do objeto Application.

Eventos do Objeto Application Na Tabela 8.1 temos a descrição dos eventos do objeto Application. Tabela 8.1 Os eventos do objeto Application. Evento

Descrição

OnStart

Ocorre quando a aplicação Web é iniciada (quando a primeira página da aplicação é acessada), antes da página solicitada pelo usuário ser interpretada e antes que qualquer objeto Session tenha sido criado. É por isso que o objeto Session pode utilizar valores armazenados no objeto Application, pois obrigatoriamente o objeto Application será criado antes de qualquer objeto Session. Este evento pode ser utilizado para inicializar variáveis, criar objetos ou rodar código necessário à inicialização da aplicação.

OnEnd

Ocorre quando a aplicação Web é finalizada. Isto acontece após o encerramento do último objeto Session e depois que o código para o evento Session_OnEnd é executado. Todas as variáveis existentes são retiradas da memória quando a aplicação é encerrada. O encerramento da sessão normalmente ocorre quando existia somente um usuário conectado e o mesmo fecha o navegador ou acessa outro site ou outra aplicação dentro do mesmo site.

O código para os eventos OnStart e OnEnd deve ser colocado no arquivo global.asa. Agora passaremos a estudar a utilização destes dois eventos.

Evento Application_OnStart A seguir é mostrada a sintaxe para este evento.

469

Criando Sites Dinâmicos com ASP 3.0

Sintaxe para o evento OnStart: <SCRIPT LANGUAGE=Linguagem_de_script RUNAT=Server> Sub Application_OnStart ’ Código para o evento OnStart. . . End Sub </SCRIPT>

A seguir temos um exemplo de definição de código para o evento OnStart. Neste exemplo são criadas duas variáveis de nível de aplicação. Uma com a estação do ano e outra com cotação do dólar. <SCRIPT LANGUAGE=“VBScript” RUNAT.= “Server”> Sub Application_OnStart Application(“EstacaoAno”) = “Inverno” Application(“CotDolar”) = 1.77 End Sub </SCRIPT>

Uma das principais utilização do evento Application_OnStart é para a criação e inicialização de variáveis em nível de aplicação ou até mesmo objetos, como por exemplo, uma conexão com um banco de dados. Para criar uma variável em nível de aplicação, utilizamos a seguinte sintaxe: Application(“Nome_da_Variável”) = Valor_da_Variável

As variáveis EstacaoAno e CotDolar podem ser acessadas por qualquer usuário, em qualquer página ASP da aplicação Web, pois são variáveis de nível de aplicação, tecnicamente falando, diríamos que são variáveis de nível do objeto Application. Um detalhe importante a ser lembrado é que não é apenas no evento Application_OnStart que podemos definir variáveis de nível de aplicação. Em qualquer página ASP podemos definir uma variável que estará disponível para todos os usuários da aplicação. Para isso utilizamos a mesma sintaxe utilizada no arquivo global.asa, conforme indicado abaixo: Application(“Nome_da_Variável”) = Valor_da_Variável

Para acessar os valores das variáveis do objeto Application é muito simples, basta utilizar a sintaxe: <% = Application(“Nome_da_Variável”) %>

Com isso será retornado o valor da variável.

470

Capítulo 8 – Aplicativos Web e Componentes

Vamos a um exemplo prático. Suponhamos que tenham sido definidas três variáveis no evento Application_OnStart da aplicação Web denominada Capitulo8, conforme indicado na Listagem 8.2, onde temos o arquivo global.asa para a aplicação Capitulo8. Listagem 8.2 – Arquivo global.asa onde são definidos três variáveis de nível de aplicação. 1

Sub Application_OnStart

Application(“Mensagem”)= “Bem vindo ao site da empresa ABC Ltda!”

‘Cotação do dólar até o meio-dia

Application(“CotAM”)= 1.50

‘Cotação do dólar após o meio-dia.

Application(“CotPM”)= 2.00

End Sub

</SCRIPT>

Neste exemplo de arquivo global.asa, no evento Application_OnStart, definimos as variáveis Mensagem, CotAM e CotPM. Estas são variáveis do objeto Application, portanto disponíveis para qualquer página da aplicação. Agora vamos criar uma página ASP que faz uso destas variáveis. A página usa_appvar.asp irá detectar a hora do dia. Até às 11:59 será apresentada a mensagem “Bom Dia” e será informado a cotação do dólar armazenada na variável CotAM. A partir de 12:00 será apresentada a mensagem “Boa Tarde” e será informada a cotação do dólar armazenada na variável CotPM. Em ambos os casos será emitida a mensagem contida na variável Mensagem. Na Listagem 8.3 temos o código para a página usa_appvar.asp. Listagem 8.3 – Utilizando variáveis do objeto Application. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

<TITLE> Utilizando variáveis em nível de aplicação !!</TITLE>

</HEAD>

<BODY>

471

Criando Sites Dinâmicos com ASP 3.0

‘ Atribui a hora do dia para a variável hora_dia

hora_dia = hour(Time())

If hora_dia<12 Then

Response.Write “<HR>”

Response.Write “Bom Dia ! <BR>”

Response.Write “Cotação do dólar: “ & Application(“CotAM”) & “<BR>”

Response.Write Application(“Mensagem”)

Response.Write “<HR>”

Else

Response.Write “<HR>”

Response.Write “Boa tarde ! <BR>”

Response.Write “Cotação do dólar: “ & Application(“CotPM”) & “<BR>”

Response.Write Application(“Mensagem”)

Response.Write “<HR>”

End If

</BODY>

</HTML>

Observe que utilizamos a função hour(Time( )); como parâmetro para a função hour, passamos a função Time. A função Time captura a hora do servidor Web e a função hour retira apenas o valor numérico da hora. Observe que, para ter acesso a uma variável do objeto Application, é só utilizar a sintaxe: Application(“Nome_da_Variável”)

Ao visualizarmos o arquivo da Listagem 8.3, antes do meio-dia, obteremos o resultado indicado na Figura 8.10. Já, ao visualizarmos o arquivo da Listagem 8.3, após o meio-dia, obteremos o resultado indicado na Figura 8.11. A possibilidade de criar variáveis no evento Application_OnStart é bastante interessante, principalmente pelo fato de que estas variáveis estarão disponíveis para qualquer usuário que acessar a aplicação Web.

472

Capítulo 8 – Aplicativos Web e Componentes

Figura 8.10: Resultado obtido antes do meio-dia.

Figura 8.11: Resultado obtido após o meio-dia. Porém não estamos limitados à criação de variáveis simplesmente. Podemos criar objetos no evento OnStart. Por exemplo, posso criar um objeto do tipo ADODB.Connection e utilizar o método Open do mesmo. Com isso estou disponibilizando uma conexão de banco de dados para todas as páginas da minha aplicação. Esta técnica apresenta, dentre outras, duas vantagens importantes: ➥ Não é necessário a colocação do código para criação da conexão, em cada página que precisar da mesma. Isto facilita a construção das páginas e reduz a possibilidade de erros.

473

Criando Sites Dinâmicos com ASP 3.0

➥ Se, por algum motivo, for necessária a alteração das propriedades da conexão, basta alterar a String de conexão em um único local (no arquivo global.asa), e não em todas as páginas que fazem uso da conexão que está sendo alterada. Na Listagem 8.4, temos um exemplo de conexão criada no evento Application_OnStart. Listagem 8.4 – Criando uma conexão no evento Application_OnStart. 1

Sub Application_OnStart

Application(“Mensagem”)= “Bem vindo ao site da empresa ABC Ltda!”

‘Cotação do dólar até o meio-dia

Application(“CotAM”)= 1.50

‘Cotação do dólar após o meio-dia.

Application(“CotPM”)= 2.00

‘Agora cria uma conexão com o banco de dados

‘C:\Meus documentos\nwind.mdb

‘Esta conexão estará disponível para todas as

‘páginas da aplicação.

Set Application(“conn”)=Server.CreateObject(“ADODB.Connection”)

Application(“conn”).ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0; DATA SOURCE=c:\meus documentos\nwind.mdb”

Application(“conn”).Open

End Sub

</SCRIPT>

IMPORTANTE Para que o objeto conn seja uma conexão do objeto Application, e com isso disponível para todas as páginas da aplicação, devemos utilizar a sintaxe indicada na Listagem 8.4, ou seja: 12

Set Application(“conn”)=Server.CreateObject(“ADODB.Connection”)

Desta forma, precisamos utilizar Application(“Nome_do_Objeto”), pois se utilizarmos simplesmente o nome do objeto, o mesmo não pertencerá ao objeto Application e não estará disponível em todas as páginas. O mesmo é válido na definição da propriedade ConnectionString e na utilização do método Open.

474

Capítulo 8 – Aplicativos Web e Componentes

Agora que criamos uma conexão no evento OnStart, podemos utilizar esta conexão em qualquer página da aplicação. Vamos a um exemplo de página ASP que utiliza esta conexão. Na Listagem 8.5 temos uma página ASP que utiliza a conexão criada no evento OnStart. Observe que estamos criando um objeto RecordSet que utiliza esta conexão como parâmetro para o método Open do objeto RecordSet. Listagem 8.5 – Utilizando a conexão criada no evento OnStart – usa_appcon.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

<TITLE> Utilizando uma conexão criada no arquivo global.asa.</TITLE>

</HEAD>

<BODY>

‘Nesta página estamos criando um objeto RecordSet,

‘o qual utiliza a conexão Conn criada no evento

‘Application_OnStart.

‘O código que cria a conexão está no arquivo global.asa.

Set Pedidos = Server.CreateObject(“ADODB.Recordset”)

Pedidos.Open “Select * from Orders Order By OrderID”, Application(“conn”), 3, 3

‘Neste ponto tenho o objeto Pedidos ligado com a tabela

‘Orders do banco de dados nwind.mdb.

‘Agora passo a exibir os resultados.

<P><B>Utilizei uma conexão criada no arquivo global.asa.</B></P>

<TR>

<TD><B>Código</B></TD>

<TD><B>Cidade</B></TD>

</TR>

475

Criando Sites Dinâmicos com ASP 3.0

‘Agora exibo os registros obtidos a partir da tabela Orders.

Response.Write “Foram encontrados: ” & Pedidos.RecordCount & “ Registros.<HR>”

Pedidos.MoveFirst

Do While Not Pedidos.EOF

<TR>

<TD><% =Pedidos.Fields(“OrderID”)

%></TD>

<TD><% =Pedidos.Fields(“OrderDate”)

%></TD>

<TD><% =Pedidos.Fields(“ShipCity”)

%></TD>

</TR>

Pedidos.MoveNext

Loop

</TABLE>

<BR>

<HR>

</BODY>

</HTML>

Na Figura 8.12 vemos o resultado quando a página usa_appcon.asp é carregada no Internet Explorer.

IMPORTANTE No evento Application_OnStart não podemos utilizar os seguintes objetos: ➥ Response ➥ Request ➥ Session Se tentarmos utilizar um destes objetos no evento Application_OnStart, obteremos a mensagem de erro indicada na Figura 8.13.

476

Capítulo 8 – Aplicativos Web e Componentes

Figura 8.12: Página que utiliza uma conexão criada no arquivo global.asa.

Figura 8.13: Erro devido à utilização de Response no evento Application_OnStart.

477

Criando Sites Dinâmicos com ASP 3.0

Evento Application_OnEnd Embora possamos criar variáveis e objetos no evento Application_OnEnd isto não teria utilidade prática. Normalmente utilizamos o evento OnEnd para funções administrativas, tais como gravar informações em um log de auditoria ou parar um determinado serviço para manutenção. A seguir é mostrada a sintaxe para este evento. Sintaxe para o evento Application_OnEnd: <SCRIPT LANGUAGE=Linguagem_de_script RUNAT=Server> Sub Application_OnEnd ’ Código para o evento OnEnd. . . End Sub </SCRIPT>

A seguir temos um exemplo de definição de código para o evento OnEnd. Neste exemplo estamos retirando o objeto conn da memória. <SCRIPT LANGUAGE=“VBScript” RUNAT.= “Server”> Sub Application_OnEnd Set Application(“conn”) = Nothing End Sub </SCRIPT>

NOTA Uma situação especial em que o evento Application_OnEnd ocorre é quando o arquivo global.asa precisa ser novamente interpretado e carregado na memória. Isto acontece quando este arquivo é alterado e as alterações são salvas.

Coleções do Objeto Application Na Tabela 8.2 temos a descrição das coleções do objeto Application.

478

Capítulo 8 – Aplicativos Web e Componentes

Tabela 8.2 As coleções do objeto Application. Coleção

Descrição

Contents

Contém todos os itens que foram adicionados ao objeto Application, com exceção dos que foram declarados com a tag <OBJECT>. Todas as variáveis e objetos criados com Set, fazem parte desta coleção. Podemos usar a coleção Contents para obter a lista de itens aos quais tenha sido atribuído escopo do aplicativo ou para especificar um item específico para ser o destino de uma operação. É possível também remover os itens da coleção com os métodos Remove e RemoveAll. No próximo tópico falaremos sobre os métodos do objeto Application.

StaticObjects A coleção StaticObjects contém todos os objetos criados com as tags <OBJECT> dentro do escopo do objeto Application. Podemos usar esta coleção para determinar o valor de uma propriedade específica de um objeto ou fazer interação através da coleção e recuperar todas as propriedades dos objetos estáticos. Agora passaremos a estudar a sintaxe e alguns exemplos de utilização das coleções do objeto Application.

A Coleção Contents Para acessarmos um item da coleção Contents, utilizamos a seguinte sintaxe: Application.Contents(Chave)

onde Chave é o nome do item a ser recuperado. Por exemplo, vamos supor que as seguintes variáveis tenham sido criadas no arquivo global.asa, no evento Application_OnStart: Application(“Var1”) = “José da Silva” Application(“Var2”) = “Maria do Socorro” Application(“HoraDia”) = Hour(Time( ))

Poderíamos exibir o valor destas variáveis utilizando o seguinte código: <% Response.Write “Variáveis de nível de aplicação.<HR>” Response.Write “Var1: ” & Application.Contents(“Var1”)

479

& “<BR>”

Criando Sites Dinâmicos com ASP 3.0

Response.Write “Var2: ” & Application.Contents(“Var2”) & “<BR>” Response.Write “Hora do início da aplicação: ” & Application.Contents(“HoraDia”) & “<BR>” %>

O comando Application.Contents(“Var1”) retorna o valor da variável de aplicação Var1. O comando Application.Contents(“Var2”) retorna o valor da variável de aplicação Var2 e assim por diante. Como estamos trabalhando com uma coleção, podemos utilizar o operador For Each...Next para percorrer todos os itens da coleção Contents. No exemplo de código a seguir, exibimos o nome de todos os elementos da coleção Contents. <% For Each elemento in Application.Contents Response.Write “Nome do elemento: ” & elemento & “<BR>” Next %>

Considere a Listagem 8.6, onde fazemos uso do operador For Each...Next para exibir o nome de todos os itens da coleção Contents do objeto Application. Listagem 8.6 – Acessando os elementos da coleção Contents – contents.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

<TITLE>Utilizando a coleção Contents</TITLE>

</HEAD>

<BODY>

<HR>

Response.Write “Elementos da coleção Contents. <HR>”

For Each elemento in Application.Contents

Response.Write “Elemento: ” & elemento & “<BR>”

Response.Write “<HR>”

</BODY>

</HTML>

Ao carregarmos esta página no Internet Explorer, obtemos o resultado indicado na Figura 8.14.

480

Capítulo 8 – Aplicativos Web e Componentes

Figura 8.14: Usando For Each...Next para exibir o nome dos elementos da coleção Contents.

NOTA Neste caso a página contents.asp faz parte da aplicação que utiliza o arquivo global.asa da Listagem 8.4. Observe que inclusive o elemento conn, o qual é um objeto do tipo Connection, faz parte da coleção Contents.

Poderíamos modificar a Listagem 8.6, para que, além de exibir o nome de cada elemento, a mesma exibisse o valor de cada um dos elementos. Esta alteração está indicada na Listagem 8.7. Listagem 8.7 – Exibindo o nome e o conteúdo dos elementos da coleção Contents. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

<TITLE>Utilizando a coleção Contents</TITLE>

</HEAD>

<BODY>

<HR>

9 10

<TR> <TD><B>Elemento</B></TD>

481

Criando Sites Dinâmicos com ASP 3.0

<TD><B>Valor</B></TD>

12 13

</TR> <%

Response.Write “Elementos da coleção Contents. <HR>”

For Each elemento in Application.Contents %>

<TR>

</TR>

Response.Write “<HR>”

</TABLE>

</BODY>

</HTML>

Ao carregarmos esta nova versão da página, no Internet Explorer, obtemos o resultado indicado na Figura 8.15.

Figura 8.15: Usando For Each...Next para exibir o nome e o conteúdo dos elementos da coleção Contents.

482

Capítulo 8 – Aplicativos Web e Componentes

A Coleção StaticObjects Para acessarmos um item da coleção StaticObjects, utilizamos a seguinte sintaxe: Application.StaticObjects(Chave)

onde Chave é o nome do item a ser recuperado. Como estamos trabalhando com uma coleção, podemos utilizar o operador For Each...Next para percorrer todos os itens da coleção Contents. No exemplo de código a seguir, exibimos o nome de todos os elementos da coleção StaticObjects. <% For Each elemento in Application.StaticObjects Response.Write “Nome do elemento: ” & elemento & “<BR>” Next %>

Agora que já conhecemos os eventos e coleções do objeto Application, vamos ao estudo dos métodos deste objeto.

Métodos do Objeto Application Na Tabela 8.3 temos a descrição dos métodos do objeto Application. Tabela 8.3 Os métodos do objeto Application. Método

Descrição

Contents.Remove

O método Application.Contents.Remove exclui um item de uma coleção. Este método considera uma seqüência de caracteres ou um inteiro como um parâmetro de entrada. Se o parâmetro de entrada for uma seqüência de caracteres, o método pesquisará a coleção Contents para localizar um item com esse mesmo nome e o removerá. Se o parâmetro de entrada for um inteiro, o método contará o número de itens equivalente a partir do início da coleção e removerá o item correspondente.

Contents.RemoveAll O método Application.Contents.RemoveAll remove todos os itens que foram adicionados à coleção Application.Contents.

483

Criando Sites Dinâmicos com ASP 3.0

Método

Descrição

Lock

O método Lock impede que outros clientes modifiquem as variáveis armazenadas no objeto Application, garantindo que apenas um cliente de cada vez possa alterar ou acessar as variáveis do objeto Application. Se o método Unlock não for chamado explicitamente, o servidor desbloqueará o objeto Application bloqueado quando o arquivo .asp for concluído ou atingir seu tempo limite – TimeOut.

Unlock

O método Unlock permite que outros clientes modifiquem as variáveis armazenadas no objeto Application após ele ter sido bloqueado usando o método Lock. Se você não chamar explicitamente esse método, o servidor Web desbloqueará objeto Application quando o arquivo .asp for concluído ou atingir seu tempo limite – TimeOut.

Agora vamos analisar alguns exemplos de código que utilizam os métodos do objeto Application. A sintaxe para o método Contents.Remove é a seguinte: Application.Contents.Remove(Nome_da_Variável)

No exemplo a seguir são adicionadas três variáveis em nível de aplicação. Depois utilizamos o método Contents.Remove para remover uma das variáveis. <% Application(“Nome”) = Request.Form(“nome”) Application(“Idade”)

= Request.Form(“idade”)

Application(“ValorDolar”)

= 1.72

Application.Contents.Remove(Idade) %>

A sintaxe para o método Contents.RemoveAll é a seguinte: Application.Contents.RemoveAll( )

No exemplo a seguir são adicionadas três variáveis em nível de aplicação. Depois utilizamos o método Contents.RemoveAll para remover todas as variáveis, inclusive variáveis que tenham sido adicionadas em outras páginas ASP da aplicação, ou através do arquivo global.asa. <% Application(“Nome”) = Request.Form(“nome”) Application(“Idade”)

= Request.Form(“idade”)

484

Capítulo 8 – Aplicativos Web e Componentes

Application(“ValorDolar”)

= 1.72

Application.Contents.RemoveAll( ) %>

A sintaxe para o método Lock é a seguinte: Application.Lock

No exemplo a seguir, o método Lock impede que mais de um cliente acesse a variável NumVisitantes ao mesmo tempo. Se o aplicativo não tivesse sido bloqueado, dois clientes poderiam tentar incrementar a variável NumVisitantes simultaneamente. <% Application.Lock Application(“NumVisitantes”) = Application(“NumVisitantes”) + 1 Application(“DataUltimaVisita”) = Now() Application.Unlock Response.Write “Esta aplicação já foi visitada: ” %> <% = Application(“NumVisitantes”) %> <% Response.Write “ Vezes!!!” %>

Vezes !!!

A sintaxe para o método UnLock é a seguinte: Application.Unlock

No exemplo a seguir, o método Unlock libera o objeto bloqueado para que o próximo cliente possa incrementar NumVisitantes. <% Application.Lock Application(“NumVisitantes ”) = Application(“NumVisitantes ”) + 1 Application(“DataUltimaVisita ”) = Now() Application.Unlock %>

IMPORTANTE O método Lock do aplicativo é cumulativo, significando que se o mesmo script chamar Lock várias vezes, ele também deverá chamar Unlock o mesmo número de vezes para liberar totalmente o aplicativo. Se isso não ocorrer, o bloqueio do aplicativo será mantido até que o script termine de executar.

485

Criando Sites Dinâmicos com ASP 3.0

Com isso encerramos o estudo do objeto Application. Conforme estudamos, podemos criar variáveis que estarão acessíveis para todos os usuários da aplicação (semelhante ao conceito de variável global nas aplicações tradicionais); podemos criar objetos, como por exemplo um objeto Connection, de tal forma que qualquer página ASP da aplicação utilize-o sem que para isso o mesmo tenha que ser criado em cada página. Agora passaremos ao estudo do objeto Session.

O Objeto Session Podemos usar o objeto Session para armazenar as informações necessárias para uma determinada sessão de usuário. As variáveis armazenadas no objeto Session não são descartadas quando o usuário alterna entre as páginas do aplicativo; em vez disso, essas variáveis persistem durante toda a sessão de usuário. O servidor Web cria automaticamente um objeto Session quando uma página da Web de um aplicativo é solicitada por um usuário que não tem uma sessão. O servidor descarta o objeto Session quando a sessão expira (por TimeOut) ou é abandonada. Um uso comum para o objeto Session é para armazenar as preferências do usuário. Por exemplo, se um usuário indicar que prefere não visualizar elementos gráficos, você deverá armazenar essa informação no objeto Session. O diagrama da Figura 8.16 demonstra a relação entre o objeto Application, os diversos objetos Session, o servidor Web e as diversas aplicações Web hospedadas no servidor. Cada aplicação Web possui seu próprio objeto Application e informações disponíveis neste objeto podem ser acessadas por qualquer usuário que estiver acessando a aplicação. Para cada usuário que acessa a aplicação Web é criado um objeto Session, onde ficam armazenadas as informações relacionadas a ele. Também podemos notar, na Figura 8.16, que em um mesmo servidor Web podemos ter várias aplicações Web. Informações armazenadas no objeto Session do usuário podem ser acessadas em qualquer página da aplicação Web, desta forma é possível passar informações entre as diversas páginas da aplicação Web durante a existência do objeto Session.

IMPORTANTE O objeto Session é baseado em Cookies, por isso o estado da sessão só é mantido para navegadores que suportam Cookies.

486

Capítulo 8 – Aplicativos Web e Componentes

Usuário 1 Aplicação: web1 objeto Application Sessão1 Sessão2 Sessão3

Usuário 2

Usuário 3

Aplicação: web2 objeto Application Sessão4 Sessão5

Usuário 4

Usuário 5

Aplicação: web3 objeto Application Sessão6

Usuário 6

Cada aplicação Web possui o seu próprio objeto Application. Para cada usuário conectado é criado um objeto Session Diferente, o qual mantem informações relativas a cada usuário.

Figura 8.16: Para cada usuário conectado é criado um objeto Session. Agora passaremos a estudar os eventos, coleções, propriedades e métodos do objeto Session.

Eventos do Objeto Session Na Tabela 8.4, temos uma descrição dos eventos do objeto Session. Tabela 8.4 Os eventos do objeto Session. Evento

Descrição

OnStart

O evento Session_OnStart ocorre quando o servidor cria uma nova sessão, processando esse script antes de executar a página solicitada. O evento Session_OnStart é uma ótima oportunidade de definir as variáveis no nível de sessão, porque as mesmas serão definidas antes de se acessar quaisquer páginas. Todos os objetos incorporados (Application, ObjectContext, Request, Response, Server e Session) estão disponíveis e podem ser referenciados no script do evento Session_OnStart. Você pode chamar o método Redirect no evento Session_OnStart, por exemplo, para assegurar que os usuários sempre iniciem uma sessão em determinada página da Web. Quando o usuário entrar no aplicativo, o servidor criará uma sessão para este usuário e processará o script do evento Session_OnStart. É possível incluir um script nesse evento para verificar se a página aberta pelo usuário é a página inicial e, se não for, podemos redirecioná-lo para a página inicial através de uma chamada ao método Response.Redirect.

487

Criando Sites Dinâmicos com ASP 3.0

Evento

Descrição

OnEnd

O evento Session_OnEnd ocorre quando uma sessão é abandonada ou o tempo limite expira – TimeOut. Para esse evento, somente estão disponíveis os objetos Application, Server e Session.

O Evento Session_OnStart A seguir é mostrada a sintaxe para este evento: <SCRIPT LANGUAGE=Linguagem_de_script RUNAT=Server> Sub Session_OnStart ’ Código para o evento Session_OnStart. . . End Sub </SCRIPT>

A seguir temos um exemplo de definição de código para o evento Session_OnStart. Neste exemplo são criadas duas variáveis de nível de sessão. Uma com a estação do ano e outra com cotação do dólar. <SCRIPT LANGUAGE=“VBScript” RUNAT.= “Server”> Sub Session_OnStart Session(“EstacaoAno”) = “Inverno” Session(“CotDolar”) = 1.77 End Sub </SCRIPT>

Uma das principais utilizações do evento Session_OnStart é para a criação e inicialização de variáveis em nível de sessão ou até mesmo objetos, como por exemplo, uma conexão com um banco de dados. Para criar uma variável em nível de sessão, utilizamos a seguinte sintaxe: Session(“Nome_da_Variável”) = Valor_da_Variável

As variáveis EstacaoAno e CotDolar podem ser acessadas, pelo usuário conectado, em qualquer página ASP da aplicação Web, pois são variáveis de nível de sessão, tecnicamente falando, diríamos que são variáveis de nível do objeto Session, as quais estão disponíveis, em qualquer página, para o usuário ligado à sessão.

488

Capítulo 8 – Aplicativos Web e Componentes

Um detalhe importante a ser lembrado é que não é apenas no evento Session_OnStart que podemos definir variáveis de nível de sessão. Em qualquer página ASP podemos definir uma variável que estará disponível em nível de sessão. Para isso utilizamos a mesma sintaxe utilizada no arquivo global.asa, conforme indicado abaixo: <% Session(“Nome_da_Variável”) = Valor_da_Variável %>

Para acessar os valores das variáveis do objeto Session é muito simples, basta utilizar a sintaxe: <% = Session(“Nome_da_Variável”) %>

Com isso será retornado o valor da variável. Vamos a um exemplo prático. Suponhamos que tenham sido definidas três variáveis no evento Session_OnStart, conforme indicado na Listagem 8.8, onde temos o arquivo global.asa para a aplicação Capitulo8. Listagem 8.8 – Arquivo global.asa onde são definidos três variáveis de nível de sessão. 1

Sub Session_OnStart

Session(“Mensagem”)= “Bem-vindo ao site da empresa ABC Ltda !”

‘Cotação do dólar até o meio-dia

Session(“CotAM”)= 1.50

‘Cotação do dólar após o meio-dia.

Session(“CotPM”)= 2.00

End Sub

</SCRIPT>

Neste exemplo de arquivo global.asa, no evento Session_OnStart, definimos as variáveis Mensagem, CotAM e CotPM. Estas são variáveis do objeto Session, portanto disponíveis para qualquer página a ser acessada pelo usuário, desde que tenha sido estabelecida uma conexão. Lembre que se o usuário estiver utilizando um navegador que não suporta Cookies, ou tiver desabilitado o suporte a Cookies, a sessão não será estabelecida e as informações disponíveis no objeto Session não estarão disponíveis.

489

Criando Sites Dinâmicos com ASP 3.0

Agora vamos criar uma página ASP que faz uso destas variáveis. A página usa_sessionvar.asp irá detectar a hora do dia. Até às 11:59 será apresentada a mensagem “Bom Dia” e será informado a cotação do dólar armazenada na variável CotAM. A partir de 12:00 será apresentada a mensagem “Boa Tarde” e será informada a cotação do dólar armazenada na variável CotPM. Em ambos os casos será emitida a mensagem contida na variável Mensagem. Na Listagem 8.9 temos o código para a página usa_sessionvar.asp. Listagem 8.9 – Utilizando variáveis do objeto Session. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

<TITLE> Utilizando variáveis em nível de Sessão !!</TITLE>

</HEAD>

<BODY>

‘ Atribui a hora do dia para a variável hora_dia

hora_dia = hour(Time())

10 11

Response.Write “Hora do dia: ” & hora_dia & “<HR>” If hora_dia<12 Then

Response.Write “<HR>”

Response.Write “Bom Dia! <BR>”

Response.Write “Cotação do dólar: ” & Session(“CotAM”) & “<BR>”

Response.Write Session(“Mensagem”)

Response.Write “<HR>”

Else

Response.Write “<HR>”

Response.Write “Boa tarde ! <BR>”

Response.Write “Cotação do dólar: ” & Session(“CotPM”) & “<BR>”

Response.Write Session(“Mensagem”)

Response.Write “<HR>”

End If

</BODY>

</HTML>

Observe que utilizamos a função hour(Time( )); como parâmetro para a função hour, passamos a função Time ( ). A função Time( ) captura a hora do servidor Web e a função hour retira apenas o valor numérico da hora.

490

Capítulo 8 – Aplicativos Web e Componentes

Observe que para ter acesso a uma variável do objeto Session é só utilizar a seguinte sintaxe: Session(“Nome_da_Variável”).

Ao visualizarmos o arquivo da Listagem 8.9, após o meio-dia, obteremos o resultado indicado na Figura 8.17.

Figura 8.17: Resultado obtido após o meio-dia. Já, ao visualizarmos o arquivo da Listagem 8.3, antes do meio-dia, obteremos o resultado indicado na Figura 8.18.

Figura 8.18: Resultado obtido antes do meio-dia.

491

Criando Sites Dinâmicos com ASP 3.0

A possibilidade de criar variáveis no evento Session_OnStart é bastante interessante, principalmente pelo fato de que estas variáveis estarão disponíveis para o usuário em todas as páginas que ele acessar na aplicação Web. Por exemplo, uma vez identificado o usuário, podemos carregar, a partir de um banco de dados, uma série de informações sobre o mesmo e atribui-las a variáveis do objeto Session. Com isso, em qualquer página da aplicação, as informações sobre o usuário estarão disponíveis. Um exemplo de utilização do objeto Session é encontrado em sites que oferecem treinamento pela Internet. O usuário faz o cadastro no site e recebe um username e uma senha. Ao entrar no site, o usuário se identifica através do seu username e senha. Após identificado, podemos utilizar o objeto Session para localizar informações sobre os cursos em que o usuário está cadastrado, os módulos já cursados e as suas preferências, tais como idioma de exibição da página. Com isso posso criar um conteúdo personalizado para cada usuário, baseado nas preferências do mesmo. Porém não estamos limitados a criação de variáveis simplesmente. Podemos criar objetos no evento Session_OnStart. Por exemplo, posso criar um objeto do tipo ADODB.Connection e utilizar o método Open do mesmo. Com isso estou disponibilizando uma conexão de banco de dados para o usuário, e em qualquer página da aplicação esta conexão pode ser utilizada. Esta técnica apresenta, dentre outras, duas vantagens importantes: ➥ Não é necessário a colocação do código para criação da conexão, em cada página que precisar da mesma. Isto facilita a construção das páginas e reduz a possibilidade de erros. ➥ Se, por algum motivo, for necessária a alteração das propriedades da conexão, basta alterar a String de conexão em um único local (no arquivo global.asa), e não em todas as páginas que fazem uso da conexão que está sendo alterada. Na Listagem 8.10, temos um exemplo de conexão criada no evento Session_OnStart. Listagem 8.10 – Criando uma conexão no evento Session_OnStart. 1

Sub Session_OnStart

Session(“Mensagem”)= “Bem-vindo ao site da empresa ABC Ltda!”

‘Cotação do dólar até o meio-dia

Session (“CotAM”)= 1.50

‘Cotação do dólar após o meio-dia.

Session (“CotPM”)= 2.00

492

Capítulo 8 – Aplicativos Web e Componentes

‘Agora cria uma conexão com o banco de dados

‘C:\Meus documentos\nwind.mdb

‘Esta conexão estará disponível para todas as

‘páginas da aplicação.

Set Session (“conexao”)=Server.CreateObject(“ADODB.Connection”)

Session (“conexao”).ConnectionString =“PROVIDER=MICROSOFT.JET.OLEDB.4.0; DATA SOURCE=c:\meus documentos\nwind.mdb”

Session(“conexao”).Open

End Sub

</SCRIPT>

IMPORTANTE Para que o objeto conexao seja uma conexão do objeto Session, e com isso esteja disponível para todas as páginas que o usuário acessar dentro da aplicação, devemos utilizar a sintaxe indicada na Listagem 8.10, ou seja: 12

Set Session(“conexao”)=Server.CreateObject(“ADODB.Connection”)

Desta forma, precisamos utilizar Session(“Nome_do_Objeto”), pois se utilizarmos simplesmente o nome do objeto, a mesma não pertencerá ao objeto Session e não estará disponível em todas as páginas. O mesmo é válido na definição da propriedade ConnectionString e na utilização do método Open.

Agora que criamos uma conexão no evento Session_OnStart, podemos utilizar esta conexão em qualquer página da aplicação. Vamos a um exemplo de página ASP que utiliza esta conexão. Na Listagem 8.11 temos uma página ASP que utiliza a conexão criada no evento Session_OnStart. Observe que estamos criando um objeto RecordSet que utiliza esta conexão como parâmetro para o método Open do objeto RecordSet. Listagem 8.11 – Utilizando a conexão criada no evento OnStart – usa_sessioncon.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

<TITLE> Utilizando uma conexão criada no arquivo global.asa.</TITLE>

</HEAD>

<BODY>

493

Criando Sites Dinâmicos com ASP 3.0

‘Nesta página estamos criando um objeto RecordSet,

‘o qual utiliza a conexão Conn criada no evento

‘Session_OnStart.

‘O código que cria a conexão está no arquivo global.asa.

Set Pedidos = Server.CreateObject(“ADODB.Recordset”)

Pedidos.Open “Select * from Orders Order By OrderID”, Session(“conexao”), 3, 3

‘Neste ponto tenho o objeto Pedidos ligado com a tabela

‘Orders do banco de dados nwind.mdb.

‘Agora passo a exibir os resultados.

<P><B>Utilizei uma conexão criada no arquivo global.asa.</B></P>

<TR>

<TD><B>Código</B></TD>

<TD><B>Cidade</B></TD>

</TR>

‘Agora exibo os registros obtidos a partir da tabela Orders.

Response.Write “Foram encontrados: ” & Pedidos.RecordCount & “ Registros.<HR>”

Pedidos.MoveFirst

Do While Not Pedidos.EOF

32 33

<TR> <TD><% =Pedidos.Fields(“OrderID”)

494

%></TD>

Capítulo 8 – Aplicativos Web e Componentes

<TD><% =Pedidos.Fields(“OrderDate”)

%></TD>

<TD><% =Pedidos.Fields(“ShipCity”)

%></TD>

</TR>

Pedidos.MoveNext

Loop

</TABLE>

<BR>

<HR>

</BODY>

</HTML>

Na Figura 8.19 vemos o resultado quando a página usa_sessioncon.asp é carregada no Internet Explorer.

Figura 8.19: Página que utiliza uma conexão criada no evento Session_OnStart.

495

Criando Sites Dinâmicos com ASP 3.0

Evento Session_OnEnd Embora possamos criar variáveis e objetos no evento Application_OnEnd isto não teria utilidade prática. Normalmente utilizamos o evento OnEnd para funções administrativas, tais como gravar informações em um log de auditoria ou para gravar escolhas feita pelo usuário em um banco de dados. A seguir é mostrada a sintaxe para este evento. Sintaxe para o evento Session_OnEnd: <SCRIPT LANGUAGE=Linguagem_de_script RUNAT=Server> Sub Application_OnEnd ’ Código para o evento OnEnd. . . End Sub </SCRIPT>

A seguir temos um exemplo de definição de código para o evento OnEnd. Neste exemplo estamos retirando o objeto conexao da memória, para liberar recursos no servidor Web. <SCRIPT LANGUAGE=“VBScript” RUNAT.= “Server”> Sub Application_OnEnd Set Application(“conexao”) = Nothing End Sub </SCRIPT>

Coleções do Objeto Session Na Tabela 8.5 temos a descrição das coleções do objeto Session. Tabela 8.5 As coleções do objeto Session. Coleção

Descrição

Contents

Contém todos os itens que foram adicionados para uma sessão, com exceção dos que foram declarados com a tag <OBJECT>. Todas as variáveis e objetos criados com Set, fazem parte desta coleção. Podemos usar a coleção Contents para obter uma lista de itens aos quais tenha sido atribuído escopo da sessão. É possível também remover os itens da coleção com os métodos Remove e RemoveAll.

496

Capítulo 8 – Aplicativos Web e Componentes

Coleção

Descrição

StaticObjects A coleção StaticObjects contém todos os objetos criados com as tags <OBJECT> dentro do escopo da sessão. Podemos usar esta coleção para determinar o valor de uma propriedade específica de um objeto ou fazer interação através da coleção e recuperar todas as propriedades de todos os objeto.

Agora passaremos a estudar a sintaxe e alguns exemplos de utilização das coleções do objeto Session.

A Coleção Contents Para acessarmos um item da coleção Contents, utilizamos a seguinte sintaxe: Session.Contents(Chave)

onde Chave é o nome do item a ser recuperado. Por exemplo, vamos supor que as seguintes variáveis tenham sido criadas no arquivo global.asa, no evento Application_OnStart Session(“Var1”) = “José da Silva” Session (“Var2”) = “Maria do Socorro” Session (“HoraDia”) = Hour(Time( ))

Poderíamos exibir o valor destas variáveis utilizando o seguinte código: <% Response.Write “Variáveis de nível de sessão.<HR>” Response.Write “Var1: ” & Session.Contents(“Var1”)

& “<BR>”

Response.Write “Var2: ” & Session.Contents(“Var2”) & “<BR>” Response.Write “Hora do início da aplicação: ” & Session.Contents(“HoraDia”) & “<BR>” %>

O comando Session.Contents(“Var1”) retorna o valor da variável de sessão Var1. O comando Session.Contents(“Var2”) retorna o valor da variável de sessão Var2 e assim por diante. Como estamos trabalhando com uma coleção, podemos utilizar o operador For Each...Next para percorrer todos os itens da coleção Contents. No exemplo de código a seguir, exibimos o nome de todos os elementos da coleção Contents.

497

Criando Sites Dinâmicos com ASP 3.0

<% For Each elemento in Session.Contents Response.Write “Nome do elemento: ” & elemento & “<BR>” Next %>

Considere a Listagem 8.12, onde fazemos uso do operador For Each...Next para exibir o nome de todos os itens da coleção Contents do objeto Session. Listagem 8.12 – Acessando os elementos da coleção Contents – contents2.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

<TITLE>Utilizando a coleção Contents</TITLE>

</HEAD>

<BODY>

<HR>

Response.Write “Elementos da coleção Contents. <HR>”

For Each elemento in Session.Contents

Response.Write “Elemento: ” & elemento & “<BR>”

Response.Write “<HR>”

</BODY>

</HTML>

Ao carregarmos esta página no Internet Explorer, obtemos o resultado indicado na Figura 8.20.

498

Capítulo 8 – Aplicativos Web e Componentes

Figura 8.20: Usando For Each...Next para exibir o nome dos elementos da coleção Contents. Poderíamos modificar a Listagem 8.11, para que além de exibir o nome de cada elemento, a mesma exibisse o valor de cada um dos elementos. Esta alteração está indicada na Listagem 8.12. Listagem 8.12 – Exibindo o nome e o conteúdo dos elementos da coleção Contents. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

<TITLE>Utilizando a coleção Contents</TITLE>

</HEAD>

<BODY>

<HR>

<TR>

<TD><B>Elemento</B></TD>

<TD><B>Valor</B></TD>

12 13

</TR> <%

499

Criando Sites Dinâmicos com ASP 3.0

Response.Write “Elementos da coleção Contents. <HR>”

For Each elemento in Application.Contents %>

<TR>

</TR>

Response.Write “<HR>”

</TABLE>

</BODY>

</HTML>

Ao carregarmos esta nova versão da página, no Internet Explorer, obtemos o resultado indicado na Figura 8.21.

Figura 8.21: Usando For Each...Next para exibir o nome e o conteúdo dos elementos da coleção Contents.

500

Capítulo 8 – Aplicativos Web e Componentes

A Coleção StaticObjects Para acessarmos um item da coleção StaticObjects, utilizamos a seguinte sintaxe: Session.StaticObjects(Chave)

onde Chave é o nome do item a ser recuperado. Como estamos trabalhando com uma coleção, podemos utilizar o operador For Each...Next para percorrer todos os itens da coleção Contents. No exemplo de código a seguir, exibimos o nome de todos os elementos da coleção StaticObjects. <% For Each elemento in Session.StaticObjects Response.Write “Nome do elemento: ” & elemento & “<BR>” Next %>

Agora que já conhecemos os eventos e coleções do objeto Session, vamos ao estudo dos métodos deste objeto.

Métodos do objeto Session Na Tabela 8.6 temos a descrição dos métodos do objeto Session. Tabela 8.6 Os métodos do objeto Session. Método

Descrição

Abandon

O método Abandon elimina todos os objetos armazenados em um objeto Session e libera seus recursos. Se você não chamar o método Abandon explicitamente, o servidor eliminará esses objetos quando a sessão atingir seu tempo limite. Quando o método Abandon é chamado, o objeto Session atual é colocado em fila para exclusão, mas na verdade não é excluído até que todos os comandos de script da página atual tenham sido processados. Isso significa que você pode acessar as variáveis armazenadas no objeto Session na mesma página que utilizou o método Abandon, mas não em quaisquer páginas subseqüentes da aplicação Web.

501

Criando Sites Dinâmicos com ASP 3.0

Método

Descrição

Contents.Remove

O método Session.Contents.Remove exclui um item especificado da coleção Contents. O método Contents.Remove considera uma seqüência de caracteres ou um inteiro como um parâmetro de entrada. Se o parâmetro de entrada for uma seqüência de caracteres, o método pesquisará a coleção Contents para localizar um item com esse mesmo nome e o removerá. Se o parâmetro de entrada for um inteiro, o método contará o número de itens equivalente a partir do início da coleção e removerá o item correspondente.

Contents.RemoveAll O método Session.Contents.RemoveAll remove todos os itens que foram adicionados à coleção Session.Contents. Agora vamos analisar alguns exemplos de código que utilizam os métodos do objeto Session. A sintaxe para o método Contents.Remove é a seguinte: Session.Contents.Remove(Nome_da_Variável)

No exemplo a seguir são adicionadas três variáveis em nível de sessão. Depois utilizamos o método Contents.Remove para remover uma das variáveis. <% Session(“Nome”) = Request.Form(“nome”) Session (“Idade”)

= Request.Form(“idade”)

Session (“ValorDolar”)

= 1.72

Session.Contents.Remove(Idade) %>

A sintaxe para o método Contents.RemoveAll é a seguinte: Session.Contents.RemoveAll( )

No exemplo a seguir são adicionadas três variáveis em nível de sessão. Depois utilizamos o método Contents.RemoveAll para remover todas as variáveis, inclusive as que tenham sido adicionadas pela sessão do usuário, em outras páginas ASP da aplicação, ou através do arquivo global.asa utilizando o método Session_OnStart. <% Session (“Nome”) = Request.Form(“nome”) Session (“Idade”)

= Request.Form(“idade”)

502

Capítulo 8 – Aplicativos Web e Componentes

Session (“ValorDolar”)

= 1.72

Session.Contents.RemoveAll( ) %>

A sintaxe para o método Abandon é a seguinte: <% Session.Abandon %>

Observe o exemplo a seguir, onde utilizamos o método Session.Abandon, porém após termos utilizado este método, definimos e exibimos uma variável em nível de sessão. Esta variável será exibida pois, conforme descrito anteriormente, a sessão somente será destruída após todas as linhas de Script da página que chamou o método Session.Abandon terem sido executadas. <% Session.Abandon Session(“NomeUsuario”) = “José da Silva” Response.Write “Nome do usuário: ” & Session (“NomeUsuario”) %>

NOTA O servidor cria um novo objeto Session quando você abre uma página subseqüente da aplicação Web depois de abandonar uma sessão. Você pode armazenar variáveis e objetos nesse novo objeto Session.

Agora vamos ao estudo das propriedades do objeto Session.

Propriedades do Objeto Session Na Tabela 8.7 temos a descrição das propriedades do objeto Session. Tabela 8.7 Propriedades do objeto Session. Propriedade

Descrição

CodePage

É uma propriedade de leitura e escrita, representada por um número inteiro. A propriedade CodePage determina a página de código que será usada para exibir o conteúdo dinâmico de uma página ASP. Uma página de código é um conjunto de caracteres que pode incluir números, marcas de pontuação e

503

Criando Sites Dinâmicos com ASP 3.0

Propriedade

Descrição outros hieróglifos. Diferentes idiomas e locais podem usar diferentes páginas de código. Por exemplo, a página de código ANSI 1252 é usada para o inglês americano e a maioria dos idiomas europeus; a página de código OEM 932 é usada para o Kanji japonês.

LCID

A propriedade LCID determina o identificador de local que será usado para exibir o conteúdo dinâmico.

SessionID

A propriedade SessionID retorna o identificador da sessão, um identificador exclusivo que é gerado pelo servidor quando a sessão é criada. Uma identificação da sessão é retornada como um tipo de dado LONG.

TimeOut

A propriedade TimeOut especifica o tempo limite de duração do objeto Session para esse aplicativo, em minutos. Se o usuário não atualizar ou solicitar uma página dentro do período de limite de tempo, a sessão é encerrada pelo servidor IIS.

Vamos estudar mais alguns detalhes sobre estas propriedades. A sintaxe para a propriedade CodePage é a seguinte: <% Session.CodePage = número_página_código %> Por exemplo: <% Session.CodePage = 1252 %>

Na Tabela 8.8 temos o número para algumas páginas de código. Tabela 8.8 Principais páginas de Código Número

Descrição

437

MS-DOS / EUA

850

MS-DOS / Internacional

1251

Windows / Rússia

504

Capítulo 8 – Aplicativos Web e Componentes

Número

Descrição

1252

Windows/ ANSI

1253

Windows/ Grécia

10000

Macintosh/ Padrão

A sintaxe para a propriedade LCID é a seguinte: <% Session.LCID = número_indicador_local %> Por exemplo: <% Session.LCID = 0816 %>

Este comando define as configurações de localidade para o Português de Portugal. O código para o Brasil é 0416.

NOTA As configurações de localidade definem diversas configurações, como por exemplo o símbolo da moeda, o número de casas decimais, o formato da data e da hora, etc. São as opções configuradas através do ícone Opções regionais do Painel de Controle. Para maiores detalhes sobre a configuração das Opções regionais, consulte o Capítulo 2 do livro “Microsoft Windows 2000 Server Curso Básico & Rápido”, de minha autoria e publicado pela editora Axcel Books.

A sintaxe para a propriedade SessionID é a seguinte: Session.SessionID Por exemplo: <% Response.Write “Identificador da sessão: ” & Session.SessionID %>

Este comando retorna um resultado semelhante ao seguinte: Identificador da Sessão: 117013627

O número varia, pois para cada sessão este número é gerado automaticamente pelo servidor IIS.

505

Criando Sites Dinâmicos com ASP 3.0

IMPORTANTE Você não deve usar a propriedade SessionID para gerar valores de chave primária para um aplicativo de banco de dados. Isso porque se o servidor Web for reinicializado, alguns valores de SessionID poderão ser os mesmos daqueles gerados antes do servidor ser parado. Em vez disso, você deve usar os campos de auto-incremento do próprio banco de dados.

A sintaxe para a propriedade TimeOut é a seguinte: Session.TimeOut = minutos Por exemplo: <% Session.TimeOut = 20 %>

Este comando define o TimeOut da sessão para 20 minutos. Com isso encerramos o estudo destes dois importantes objetos do ASP: Application e Session.

Conclusão Neste capítulo estudamos alguns conceitos fundamentais, tais como: ➥ O que é uma aplicação Web no IIS. ➥ Quais os componentes de uma aplicação Web no IIS. ➥ O problema de manter o estado de uma conexão. Aprendemos sobre quais elementos que compões uma aplicação Web no servidor IIS. Também tratamos sobre as configurações de uma aplicação Web, utilizando o Gerenciador do Internet Services. Aprendemos sobre diversas propriedades que podem ser configuradas para uma aplicação Web. Na seqüência aprendemos sobre o arquivo global.asa. Vimos que toda aplicação Web pode conter um arquivo global.asa, no qual podem ser definidas variáveis de inicialização, tanto em nível de aplicação quanto em nível de sessão. Para isso utilizamos, basicamente, quatro eventos para os quais podemos escrever código no arquivo global.asa. Os eventos são os seguintes: ➥ Application_OnStart ➥ Application_OnEnd ➥ Session_OnStart ➥ Session_OnEnd

506

Capítulo 8 – Aplicativos Web e Componentes

Fizemos um estudo detalhado do objeto Application. Foram explicados e exemplificados todos os métodos, coleções e eventos deste objeto. Apresentamos alguns exemplos completos de utilização deste objeto, tanto no arquivo global.asa quanto em páginas ASP. Também aprendemos que, além de variáveis, é possível a criação de objetos no evento Application_OnStart. A título de exemplos criamos um objeto que representa uma conexão com um Banco de dados. O próximo passo foi o estudo detalhado do objeto Session. Foram explicados e exemplificados todos os métodos, coleções, eventos e propriedades deste objeto. Apresentamos alguns exemplos completos de utilização do objeto Session, tanto no arquivo global.asa quanto em páginas ASP. Criamos um objeto do tipo ADODB.Connection, no evento Session_OnStart e depois utilizamos este objeto em exemplos de páginas ASP. No próximo capítulo iremos estudar alguns aspectos de segurança. Hoje em dia, com a crescente onda de ataques a sites e aplicativos Web, em um mundo em que milhões de usuários estão conectados a Internet, a questão de segurança é crítica. Iremos analisar algumas medidas que podem melhorar o nível de segurança de nossos sites e aplicações Web, embora a “criatividade” dos ataques tem sido cada vez mais surpreendente.

507

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

Capítulo 9 Segurança de Aplicações Web com IIS e ASP

509

Criando Sites Dinâmicos com ASP 3.0

Quando se fala de Internet nos dias de hoje, o assunto mais tratado, sem nenhuma dúvida, é Segurança. Muitos relatos, alguns verdadeiros e outros mais fantasiosos, sobre invasões mirabolantes, roubo de número de cartões de créditos, acesso a informações sigilosas de órgãos governamentais e assim por diante. Não podemos negar que o problema de segurança existe e é crítico, principalmente hoje quando o Comércio Eletrônico é, mais do que uma realidade, uma necessidade e um diferencial competitivo para as empresas. O diferencial competitivo não é entrar ou não no mundo do ebusiness, e sim criar serviços agregados ao Comércio Eletrônico, capazes de gerar diferenciais competitivos. Assuntos como fidelização do cliente, melhorias nos sistemas de CRM – Customer Relationship Management (Gerenciamento das Relações com o Cliente), B2B – Bussines to Bussines, B2C – Bussines to Consumer e outros, estão em evidência. Porém, sistemas de Comércio Eletrônico, CRM e assemelhados, exigem acesso a um conjunto de dados estratégicos da empresa. Uma vez que estes sistemas estão acessíveis na Internet, os dados empresariais precisam estar protegidos. Neste ponto é que a questão segurança é de fundamental importância. Existem os mais variados tipos de ataques pela Internet. Um engano comum é pensar que único tipo ataque capaz de causar prejuízos é aquele que rouba ou destrói dados. No caso de um site de Comércio Eletrônico, qualquer ataque que torne o site indisponível por um determinado período de tempo causa prejuízos incalculáveis. Isso porque, além das compras que deixaram de ser realizadas no período de indisponibilidade, tem a questão da imagem da empresa, e da possibilidade de o cliente ter feito a compra no site do concorrente, gostar, e passar a fazer as próximas compras lá. Por todos estes motivos é que a questão de segurança é fundamental e deveria ser prioritária quando tratamos de aplicações Web. Outro fato importante a ser mencionado é que a maioria dos ataques, ao contrário do que muitos pensam, é originado na Intranet da própria empresa. Pode ser um funcionário descontente ou desonesto, ou um usuário com permissões de acesso indevidas que causa algum prejuízo por imperícia técnica. O fato é que a Segurança não deve ser tratada apenas como uma questão de proteção contra “as forças do mal que vem da Internet”. O que precisa-se é definir uma política de segurança que permita que todos possam realizar o seu trabalho, porém com os níveis de permissão adequados. Além de definir uma política de segurança, é necessária a ampla divulgação da mesma. É alarmante constatar que muitas empresas não possuem uma política de segurança definida e amplamente divulgada. Outro erro bastante comum é achar que a questão de segurança é responsabilidade somente da equipe de desenvolvimento ou do administrador da rede. Na verdade o item segurança é

510

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

bastante complexo e exige que o pessoal de desenvolvimento trabalhe em sintonia com a administração da rede. Conforme veremos neste capítulo, existem aspectos de segurança que são de responsabilidade do desenvolvimento e outros que são de responsabilidade da administração de rede. Na verdade, o que se faz é criar várias barreiras para que o hacker não tenha sucesso em sua tentativa de invasão. Algumas destas barreiras são criadas na própria rede da empresa e outras em nível de aplicação Web. Neste capítulo estaremos tratando de: ➥ Questões como autenticação do usuário com o servidor Web. ➥ Aspectos de segurança a nível de Windows 2000 Server. ➥ Aspectos de segurança no IIS 5.0. ➥ Implementação de segurança a nível de banco de dados. De maneira alguma temos a pretensão de que este capítulo seja um guia completo para a segurança na Internet e para o Comércio Eletrônico. O objetivo é fornecer as informações básicas para que o usuário possa tomar as medidas mínimas necessárias para garantir algum grau de segurança para seu site e suas aplicações Web. Quando trabalhamos com ASP, IIS e Windows 2000 Server, o endereço a seguir é de consulta obrigatória para assuntos relacionados à segurança de tecnologias Microsoft: http://www. microsoft.com/security. Neste site são publicados boletins sobre segurança dos produtos Microsoft. Sempre que algum novo problema é descoberto, são divulgadas informações sobre o problema, bem como a maneira de corrigi-los. Também são disponibilizados arquivos para download. Estes arquivos normalmente contém correções (Hot-fix) que devem ser aplicadas para solucionar problemas de segurança.

NOTA Para acompanhar este capítulo o usuário deve conhecer alguns aspectos básicos do Windows 2000 Server, tais como: Permissões NTFS; Contas de Usuários e Grupos de Usuários; Utilização do MMC – Microsoft Management Console e de Snap-in.

DICA Para informações sobre estes itens, consulte o livro Windows 2000 Server Curso Básico & Rápido, de minha autoria, publicado pela editora Axcel Books.

511

Criando Sites Dinâmicos com ASP 3.0

Autenticação de Usuários com o IIS 5.0 Quando um usuário tenta acessar uma página, a primeira coisa que o servidor precisa determinar é a identidade deste usuário, isto é, o IIS precisa conhecer “quem” está tentando acessar a página. Uma das maneiras de saber quem é o usuário que está acessando o site, é através da utilização de um username e senha. Porém não seria nada “simpático” apresentar uma tela de logon para o usuário a primeira vez que ele está acessando o site. Até mesmo nas próximas tentativas de acesso, a necessidade de logon pode acabar afastando o usuário. Através da autenticação do usuário, podem ser definidos os níveis de acesso a informação que o mesmo tem, bem como podem ser feitos registros das ações realizadas pelo usuário, mediante a gravação de logs de acesso. Existem diversos tipos de autenticação possíveis com o IIS. Passaremos a estudá-los individualmente. Os tipos de autenticação que estudaremos são os seguintes: ➥ Anônima. ➥ Básica. ➥ Avançada. ➥ Integrada ao Windows 2000. ➥ Com certificados.

O Acesso Anônimo Um tipo de autenticação bastante comum é o que permite o acesso anônimo. O IIS permite que seja configurado um tipo de acesso chamado Acesso Anônimo, no qual não é necessário que o usuário forneça um username e senha para ter acesso ao site. Este acesso anônimo está ligado a uma única conta de usuário do Windows 2000 Server. Todo o usuário que acessar um site configurado para permitir acesso anônimo, será identificado como se estivesse autenticado usando a conta de usuário configurada para este tipo de acesso. A conta de usuário para acesso anônimo é automaticamente criada quando instalamos o Internet Information Services 5.0. Por padrão esta conta possui o seguinte nome: IUSR_NOME_DO_COMPUTADOR

Por exemplo, ao instalarmos o IIS em um servidor chamado SERVER02SP, será criada a seguinte conta para permitir o acesso anônimo: IUSR_SERVER02SP

A autenticação anônima fornece aos usuários acesso a áreas públicas do seu site, sem solicitar um nome de usuário ou uma senha.

512

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

Por padrão, a conta IUSR_NOME_DO_COMPUTADOR é incluída no grupo de usuários “Convidados do Windows”. Esse grupo tem restrições de segurança, impostas pelas permissões do NTFS (sistema de arquivos do Windows 2000 que possui recursos de segurança mais avançados do que o sistema FAT ou FAT32), que designam o nível de acesso e o tipo de conteúdo disponível para os usuários públicos. Com isso o usuário possui limitações sobre os recursos que o mesmo pode acessar no servidor, sendo que estas limitações já atuam como um nível de segurança. Se existem vários sites no seu servidor ou áreas no seu site que exigem privilégios de acesso diferentes, você pode criar várias contas anônimas, uma para cada área site, diretório ou arquivo. Por exemplo, você pode querer medir o nível de acesso a diferentes áreas do seu site, utilizando para isso diferentes contas para o acesso anônimo a cada uma destas áreas. O IIS usa a conta IUSR_NOME_DO_COMPUTADOR da seguinte forma: ➥ A conta IUSR_NOME_DO_COMPUTADOR é adicionada ao grupo Convidados no computador, conforme descrito anteriormente. ➥ Quando uma solicitação é recebida, o IIS representa a conta IUSR_NOME_DO_COMPUTADOR antes de executar qualquer código ou acessar qualquer arquivo. O IIS pode representar a conta IUSR_NOME_DO_COMPUTADOR pois conhece o nome de usuário e a senha dessa conta. ➥ Antes de retornar uma página ao cliente, o IIS verifica as permissões dos arquivos e diretórios do NTFS para ver se a conta IUSR_NOME_DO_COMPUTADOR tem permissão para acessar o arquivo. Neste ponto é que podemos limitar as áreas as quais o usuário, que entra como anônimo, tem acesso. Basta configurar as permissões NTFS para que a conta associada ao acesso anônimo somente tenha acesso às áreas públicas do site. ➥ Se o acesso for permitido, a autenticação é concluída e os recursos tornam-se disponíveis para o usuário. ➥ Se o acesso não for permitido, o IIS tenta usar outro método de autenticação. Se nenhum método for selecionado, o IIS retorna uma mensagem de erro “HTTP 403 Acesso negado” ao navegador do cliente.

NOTA Veremos sobre os outros métodos de autenticação ainda neste capítulo.

Na Figura 9.1, temos uma representação desta seqüência para o acesso anônimo.

513

Criando Sites Dinâmicos com ASP 3.0

IUSR_SERVER02SP tem permissões NTFS, então acesso OK.

Usuário

IUSR_SERVER02SP não tem permissões NTFS, acesso negado.

Autenticado: IUSR_SERVER02SP

Servidor: SERVER02SP

Figura 9.1: Acesso anônimo no IIS. Se a autenticação anônima for ativada, o IIS tentará sempre a autenticação usando-a primeiro, mesmo se outros métodos forem ativados. Em alguns casos, o navegador solicitará ao usuário um nome de usuário e uma senha. Você pode alterar a conta usada para a autenticação anônima no Snap-in do IIS, no nível de serviço do servidor Web ou para diretórios virtuais ou arquivos individuais. A conta anônima deve ter o direito de usuário de efetuar logon localmente. Se a conta não tiver a permissão “Efetuar logon localmente”, o IIS não poderá atender qualquer solicitação anônima. Ao instalarmos o IIS, automaticamente, a permissão “Efetuar logon localmente” é concedida à conta IUSR_NOME_DO_COMPUTADOR.

NOTA As contas IUSR_NOME_DO_COMPUTADOR em controladores de domínio não são adicionadas ao grupo Convidados do domínio, por padrão, e devem ser alteradas para Efetuar logon localmente a fim de permitir logon anônimo.

Agora vamos aprender a efetuar as seguintes atividades práticas: ➥ Definir a conta para acesso anônimo no IIS. ➥ Verificar a que grupos pertence a conta IUSR_NOME_DO_SERVIDOR.

514

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

➥ Verificar a permissão Efetuar logon local para a conta IUSR_NOME_DO_SERVIDOR. ➥ Definir permissões NTFS para uma conta de usuário. Estas atividades são importantes, não só para as configurações do acesso anônimo, mas para a configuração de qualquer tipo de acesso.

DICA Para informações mais detalhadas sobre estes itens, consulte o livro Windows 2000 Server Curso Básico & Rápido de minha autoria, publicado pela editora Axcel Books.

Como Definir a Conta Para Acesso Anônimo no IIS 5.0 Para definir qual conta será utilizada para o acesso anônimo siga os seguintes passos: 1. Faça o logon no Windows 2000 Server, com permissões de administrador. 2. Abra o Gerenciador do Internet Services: Iniciar/Programas/Ferramentas administrativas/Gerenciador do Internet Services. 3. Surge a janela indicada na Figura 9.2

Figura 9.2: O Gerenciador do Internet Services. 4. Esta é a janela do console de administração do IIS 5.0. 5. Dê um clique duplo no nome do computador. No nosso exemplo o nome é Servidor. 6. Surgem as opções indicadas na Figura 9.3.

515

Criando Sites Dinâmicos com ASP 3.0

Figura 9.3: Opções de gerenciamento do IIS. 7. Neste momento podemos configurar o acesso anônimo para todos os aplicativos Web contidos no servidor ou para cada aplicativo individualmente. Inclusive podemos configurar diferentes contas do Windows 2000 Server, para serem utilizadas para o acesso anônimo em diferentes áreas do site. Podemos configurar uma conta a nível do servidor Web, de cada aplicação e até mesmo para uma pasta dentro de uma aplicação. Com isso poderíamos ter diferentes pastas, dentro de uma mesma aplicação Web (que para o IIS é representada por uma pasta virtual, conforme descrito no capítulo anterior), com diferentes contas para acesso anônimo. 8. No nosso exemplo, iremos configurar uma única conta para acesso anônimo para todo o site. O procedimento é o mesmo quer seja para o site como um todo, para uma aplicação Web do site ou para uma pasta dentro da aplicação Web. 9. Clique com o botão direito do mouse sobre a opção Site da Web padrão (ou na opção correspondente, caso você tenha alterado este nome). No menu de opções que surge dê um clique em Propriedades. 10. Será exibida a janela Propriedades de Site Web padrão, conforme indicado na Figura 9.4. 11. Dê um clique na guia Segurança de pasta. Serão exibidas as opções indicadas na Figura 9.5. 12. A primeira opção desta guia é Controle de acesso anônimo e autenticação. Dê um clique no botão Editar, ao lado desta opção. Surge a janela Métodos de autenticação, indicada na Figura 9.6. 13. A primeira opção desta janela é Acesso anônimo. Para que o acesso anônimo seja permitido, esta opção deve estar marcada. 14. Para definir a conta que será utilizada para o acesso anônimo, dê um clique no botão Editar desta opção. 15. Será exibida a janela Conta de usuário anônimo, conforme indicado na Figura 9.7.

516

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

Figura 9.4: Propriedades do Site Web padrão.

Figura 9.5: As opções da guia Segurança de pasta.

517

Criando Sites Dinâmicos com ASP 3.0

Figura 9.6: As opções para métodos de autenticação.

Figura 9.7: Definindo a conta para usuário anônimo. 16. Nesta janela você pode definir a conta que será utilizada para o acesso anônimo. Observe que por padrão é definida a conta IUSR_NOME_DO_COMPUTADOR. No exemplo da Figura 9.7, aparece IUSR_SERVIDOR, pois o computador que estou utilizando para escrever este livro tem o nome de SERVIDOR. 17. Caso você queira utilizar outra conta e não lembre o nome da mesma, é só clicar no botão Procurar, que será exibida uma lista de usuários do Windows 2000. 18. A opção Permitir que o IIS controle a senha é interessante de ser comentada. Esta opção quando selecionada permite ao IIS sincronizar automaticamente as configurações de senha anônima com aquelas definidas no Windows 2000. Se a senha fornecida à

518

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

conta anônima e a senha do Windows para a conta forem diferentes, a autenticação anônima não funcionará. Este é um dos erros mais comuns e a causa mais freqüente de indisponibilidade de um site IIS. Por algum motivo esta opção não está marcada, com isso é preciso digitar a senha para a conta IUSR_NOME_DO_COMPUTADOR. O usuário digita a senha e OK. Porém mais adiante, por algum motivo ou por solicitação do Administrador do IIS, a senha para esta conta é alterada no Windows 2000. Como a sincronização não está ativada, o IIS continua tentando usar a senha antiga. Como as duas senhas estão diferentes o acesso é negado e o usuário recebe uma mensagem de acesso negado ao tentar acessar o site.

IMPORTANTE A sincronização de senhas deve ser usada somente com contas de usuário anônimas definidas no computador local e não com contas anônimas de computadores remotos. 19. Após ter configurado as informações para a conta de acesso anônimo, dê um clique em OK. 20. Você estará de volta à janela Métodos de autenticação, dê um clique em OK para fechá-la. 21. Você estará de volta à janela Propriedades do site da Web padrão, dê um clique em OK para fechá-la. 22. Você estará de volta ao Gerenciador do Internet Services. Feche-o.

NOTA Para definir uma conta de acesso anônimo diferente para uma das aplicações Web do site, ou até mesmo para uma subpasta de uma aplicação Web, basta repetir os passos indicados.

Verificando as Configurações da Conta Para Acesso Anônimo no Windows 2000 Server Conforme descrito anteriormente, a conta IUSR_NOME_DO_COMPUTADOR deve ter algumas configurações especiais (relativas a permissões e direitos), definidas no Windows 2000 Server. Agora veremos como conferir se as configurações para esta conta estão corretas. Vamos verificar duas configurações a respeito desta conta: ➥ A que Grupos de Usuários do Windows 2000 pertence esta conta. ➥ Se a conta possui permissão de fazer o logon localmente.

519

Criando Sites Dinâmicos com ASP 3.0

Para verificar a que grupos pertence a conta IUSR_NOME_DO_COMPUTADOR: 1. Faça o logon no Windows 2000 Server, com permissões de administrador. 2. Abra o Console para Gerenciamento do computador: Iniciar/Programas/Ferramentas administrativas/Gerenciador do Computador.

NOTA Se o servidor que você estiver utilizando for um controlador de domínio, você deve abrir o console para Gerenciamento do Active Directory. As opções que surgem podem ser um pouco diferentes das apresentadas neste exemplo. 3. Surge a janela indicada na Figura 9.8.

Figura 9.8: O console para Gerenciamento do computador. 4. Dê um clique no sinal de + ao lado da opção Ferramentas de sistema, para abri-la. 5. Nas opções que surgem, abaixo de Ferramentas de sistema, dê um clique no sinal de + ao lado da opção Usuários e grupos locais para abri-la. 6. Surgem as opções indicadas na Figura 9.9. 7. Dê um clique na opção Usuários. Surge, no painel da direita, uma listagem com o nome de todos os usuários, conforme indicado na Figura 9.10. 8. Na lista de usuários, do painel da direita, localize o usuário IUSR_NOME_DO_COMPUTADOR e dê um clique duplo sobre o mesmo para abrir a janela de propriedades do usuário, coforme indicado na Figura 9.11. No nosso exemplo é o usuário IUSR_SERVIDOR, pois conforme descrito anteriormente, o computador que estou utilizando é chamado SERVIDOR.

520

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

Figura 9.9: Informações sobre os usuários e Grupos de usuário do Windows 2000.

Figura 9.10: Listagem dos usuários cadastrados. 9. Para saber a quais grupos o usuário pertence, dê um clique na guia Participante de, com isso veremos que o usuário IUSR_SERVIDOR somente pertence ao grupo Convidados. Se estivéssemos em um servidor que atua como controlador de domínio, teríamos o grupo Convidados do domínio.

521

Criando Sites Dinâmicos com ASP 3.0

Figura 9.11: Propriedades para o usuário IUSR_SERVIDOR.

DICA Para informações mais detalhadas sobre Controladores de domínio e Active Directory, consulte o livro Windows 2000 Server Curso Básico & Rápido, de minha autoria, publicado pela editora Axcel Books. 10. Quando o IIS é instalado, a conta IUSR_SERVIDOR é criada e automaticamente adicionada ao grupo Convidados. 11. Muito cuidado ao adicionar a conta IUSR_SERVIDOR a outros grupos. Quando uma conta de usuário é adicionada a um grupo, ela herda as permissões atribuídas ao grupo e com isso passa a ter acesso aos recursos que o grupo tem acesso. A maior insanidade que o administrador Web poderia cometer seria adicionar a conta IUSR_SERVIDOR ao grupo Administradores. Com isso estaria dando permissões máximas aos usuários que fazem acesso anônimo. Seria caso de internação do seu administrador Web. 12. Clique no botão OK para fechar a janela com as propriedades da conta IUSR_SERVIDOR. 13. Você estará de volta ao Gerenciador do computador, feche-o.

522

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

Agora precisamos verificar se a conta IUSR_SERVIDOR tem a permissão para efetuar logon local. Para verificar isso: 1. Faça o logon no Windows 2000 Server, com permissões de administrador. 2. Abra o Console Configurações locais de segurança/Programas/Ferramentas administrativas/Diretivas de segurança local.

Figura 9.12: Configurações locais de segurança. 4. Dê um clique no sinal de + ao lado da opção Diretivas locais, para abri-la. 5. Nas opções que surgem, abaixo de Diretivas locais, dê um clique no sinal de + ao lado da opção Atribuição de direitos de usuário, para abri-la. 6. Surgem as opções indicadas na Figura 9.13. 7. No painel da direita surgem as diversas permissões disponíveis. 8. Na listagem de permissões, localize Efetuar logon local, conforme indicado na Figura 9.14.

523

Criando Sites Dinâmicos com ASP 3.0

Figura 9.13: Atribuições de direitos para contas e Grupos de usuários.

Figura 9.14: A permissão Efetuar logon local. 9. Dê um clique duplo sobre a permissão Efetuar logon local, para exibir a janela de configurações para esta Diretiva de segurança local. Nesta janela surge uma lista dos usuários que possuem a permissão de Efetuar logon local, conforme indicado na Figura 9.15. O usuário IUSR_SERVIDOR deve fazer parte da lista. 10. Caso o usuário IUSR_SERVIDOR não estivesse na lista, você poderia adicioná-lo utilizando o botão Adicionar.

524

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

Figura 9.15: Lista de usuários com direito a Efetuar logon local. 11. A permissão Efetuar logon local autoriza o usuário a fazer o logon no console do servidor, isto é, localmente no servidor. A conta utilizada para acesso anônimo precisa desta permissão, caso contrário o acesso anônimo não irá funcionar. 12. Dê um clique no botão OK para voltar ao console Configurações locais de segurança. 13. Feche-o. Com isso já sabemos que a conta para acesso anônimo está configurada corretamente. No próximo item vamos retirar as permissões NTFS da conta de acesso anônimo de uma das aplicações Web do servidor. Vamos tentar acessar esta aplicação e observar os resultados obtidos.

Configurando Permissões NTFS em Pastas do Servidor Web Uma das medidas básicas de segurança é a utilização de drives formatados com o sistema de arquivos NTFS, ao invés de FAT e FAT32. O motivo é bastante simples, pois através da utilização do sistema de arquivos NTFS, podemos ter um controle bastante refinado sobre o acesso às informações, mediante a atribuição de permissões de pasta e de arquivos. Quando estamos tratando de permissões NTFS, já estamos em um nível de segurança que é gerenciado pelo Sistema Operacional. É através da utilização do Windows 2000 Server que

525

Criando Sites Dinâmicos com ASP 3.0

definimos permissões NTFS. Isso reforça o fato de que a segurança é tanto responsabilidade do grupo de desenvolvimento, quanto do administrador da rede. No exemplo do acesso anônimo, o usuário é identificado para o Windows 2000, como se fosse o usuário IUSR_NOME_DO_COMPUTADOR. Este usuário somente terá acesso às pastas e arquivos para os quais o usuário IUSR_NOME_DO_COMPUTADOR tiver permissões de acesso e com os níveis de permissões definidos. Antes de aprendermos a definir permissões NTFS vamos aprender um pouco mais sobre as mesmas.

Sistemas de Arquivos no Windows 2000 e Permissões NTFS Agora vamos ver alguns detalhes sobre os sistemas de arquivos que o Windows 2000 Server reconhece e também sobre permissões NTFS. Um sistema de arquivos determina a maneira como o Windows 2000 Server organiza e recupera as informações no disco rígido ou em outros tipos de mídia. O Windows 2000 Server reconhece os seguintes sistemas de arquivos: ➥ FAT ➥ FAT32 ➥ NTFS ➥ NTFS 5 O sistema FAT vem desde a época do DOS e tem sido mantido por questões de compatibilidade. Além disso, se você tiver instalado mais de um Sistema Operacional no seu computador, alguns sistemas mais antigos (DOS, Windows 3.x e as primeiras versões do Windows 95) somente reconhecem o sistema FAT. Com o sistema de arquivos FAT, a única maneira de restringir o acesso ao conteúdo de uma pasta compartilhada, é através das permissões de compartilhamento, as quais, não tem efeito no caso de acessos pela Internet, através do IIS. Com a utilização do sistema FAT, alguns recursos avançados, tais como compressão, criptografia e auditoria, não estão disponíveis. O sistema FAT32 apresenta algumas melhorias em relação ao sistema FAT. Existe um melhor aproveitamento do espaço no disco, com conseqüente menor desperdício. Um grande inconveniente do sistema FAT32 é que ele não é reconhecido pelo Windows NT Server 4.0. Com o sistema de arquivos FAT32, a única maneira de restringir o acesso ao conteúdo de uma pasta compartilhada, é através das permissões de compartilhamento. Assim como ocorre com a utilização do FAT, no sistema FAT32, alguns recursos avançados, tais como compressão, criptografia e auditoria, não estão disponíveis.

526

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

O sistema de arquivos NTFS é utilizado no Windows NT Server 4.0 e foi mantido e melhorado no Windows 2000 Server, por questões de compatibilidade, já que uma nova versão do NTFS foi introduzida com o Windows 2000 – NTFS 5. É um sistema bem mais eficiente do que FAT e FAT32, além de permitir uma série de recursos avançados, tais como: ➥ Permissões a nível de arquivos e pastas. ➥ Compressão. ➥ Auditoria de acesso. ➥ Partições bem maiores do que as permitidas com FAT e FAT32. ➥ Desempenho bem superior do que com FAT e FAT32. Uma das principais vantagens do NTFS é que o mesmo permite que sejam definidas permissões de acesso a nível de arquivo e de pastas, isto é, posso ter arquivos em uma mesma pasta, com permissões diferentes para usuários diferentes. Além disso, as permissões NTFS têm efeito localmente, isto é, mesmo que o usuário faça o logon no computador onde um determinado arquivo existe, se o usuário não tiver as permissões NTFS necessárias, ele não poderá acessar o arquivo. Isso confere um alto grau de segurança, desde que as permissões NTFS sejam configuradas corretamente. No Windows 2000 Server, conforme descrito anteriormente, temos também o NTFS 5, o qual apresenta diversas melhorias em relação ao NTFS, tais como: ➥ Criptografia de arquivos e pastas (a criptografia é uma maneira de “embaralhar” a informação de tal forma que mesmo que um arquivo seja copiado, o mesmo se torna ininteligível, a não ser para a pessoa que possui a “chave” para descriptografá-lo). ➥ Cotas de usuário, fazendo com que seja possível limitar o espaço em disco que cada usuário pode utilizar. ➥ Gerenciamento e otimização melhorados. Um inconveniente do NTFS 5 é que ele não é reconhecido pelas versões anteriores, tais como o Windows NT Server 4.0. Caso você possua uma rede na qual estão presentes servidores com o Windows 2000 Server e com o Windows NT Server 4.0, planeje com bastante cuidado a utilização do NTFS 5. Conforme descrito anteriormente, podemos definir permissões de acesso a nível da pasta ou arquivo, mas somente em unidades formatadas com o sistema de arquivos NTFS (seja na versão do NT Server 4.0 ou o NTFS 5 do Windows 2000 Server). Portanto, é aconselhável instalar o Windows 2000 Server sempre em unidades formatadas com NTFS, pois isso melhora a segurança. Com relação às permissões NTFS, temos um conjunto diferente de permissões quando tratamos de pastas ou arquivos. Nas Tabelas 9.1 (para pastas) e 9.2 (para arquivos), são apresentadas as permissões e o nível de acesso para cada uma delas.

527

Criando Sites Dinâmicos com ASP 3.0

Tabela 9.1 Permissões NTFS para pastas. Permissão

Nível de acesso

Leitura

Permite ao usuário listar as pastas e arquivos dentro da pasta; permite que sejam exibidas as permissões, donos e atributos.

Gravar

Permite ao usuário criar novos arquivos e subpastas dentro da pasta, alterar seus atributos e visualizar o dono e as permissões da mesma.

Listar conteúdo de pastas

Permite ao usuário ver o nome dos arquivos e subpastas.

Ler e executar

Permite ao usuário navegar através das subpastas para chegar a outras pastas e arquivos, mesmo que o usuário não tenha permissão de acesso às pastas pelas quais está navegando. Além disso, possui os mesmos direitos que as permissões Leitura e Listar conteúdo de pastas.

Modificar

Permite ao usuário eliminar a pasta, e mais todas as ações permitidas pelas permissões Gravar e Ler e executar.

Controle total

Permite que sejam alteradas as permissões; permite ao usuário tornar-se dono da pasta, eliminar subpastas e arquivos, e mais todas as ações permitidas por todas as outras permissões NTFS.

Tabela 9.2 Permissões NTFS para arquivos. Permissão

Nível de acesso

Leitura

Permite ao usuário ler o arquivo; permite que sejam exibidas as permissões, dono e atributos.

Gravar

Permite ao usuário gravar um arquivo com o mesmo nome sobre o arquivo, alterar seus atributos e visualizar o dono e as permissões do mesmo.

528

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

Permissão

Nível de acesso

Ler e executar

Permite ao usuário executar aplicativos (normalmente programas .exe, .bat ou .com) e mais todos os direitos da permissão Leitura.

Modificar

Permite ao usuário modificar e eliminar o arquivo e mais todas as ações permitidas pela permissão Gravar e pela permissão Ler e executar.

Controle total

Permite que sejam alteradas as permissões; permite ao usuário tornar-se dono do arquivo, e mais todas as ações permitidas por todas as outras permissões NTFS.

Todo arquivo ou pasta em uma unidade formatada com NTFS, possui uma Lista de Controle de Acesso (Access Control List ) – ACL. Nesta ACL ficam uma lista de todas as contas de usuários e grupos para os quais foi garantido acesso para o recurso, bem como o nível de acesso de cada um deles. Existem alguns detalhes que devemos observar sobre permissões NTFS: ➥ Permissões NTFS são cumulativas, isto é, se um usuário pertence a mais de um grupo, o qual tem diferentes níveis de permissão para um recurso, a permissão efetiva do usuário é a soma das permissões. ➥ Permissões NTFS para um arquivo têm prioridade sobre permissões NTFS para pastas. Por exemplo se um usuário têm permissão NTFS de escrita em uma pasta, mas somente permissão NTFS de leitura para um arquivo dentro desta pasta, a sua permissão efetiva será somente a de leitura, pois a permissão para o arquivo tem prioridade sobre a permissão para a pasta. ➥ Negar uma permissão NTFS tem prioridade sobre Permitir. Por exemplo, se um usuário pertence a dois grupos diferentes. Se para um dos grupos foi dada permissão de leitura para um arquivo e para o outro grupo foi negada, o usuário não terá o direito de leitura, pois Negar tem prioridade sobre Permitir. Agora que já conhecemos um pouco mais sobre permissões NTFS, podemos aprender como configurar estas permissões.

Definindo Permissões NTFS Neste exemplo prático vamos fazer o seguinte: ➥ Vamos retirar as permissões NTFS do usuário IUSR_SERVIDOR da pasta de um aplicativo Web.

529

Criando Sites Dinâmicos com ASP 3.0

➥ Vamos tentar acessar o aplicativo e observar a mensagem de erro que recebemos. ➥ Vamos restaurar as permissões originais e tentar acessar a página novamente. Para acessar as permissões NTFS de uma pasta e retirar as permissões do usuário IUSR_SERVIDOR, faça o seguinte: 1. Faça o logon com privilégios de administrador. 2. Utilizando o Windows Explorer, localize a pasta cujas permissões NTFS serão alteradas. 3. Dê um clique com o botão direito do mouse sobre a pasta. No menu de opções que surge dê um clique em Propriedades. 4. Surge a janela indicada na Figura 9.16.

Figura 9.16: Janela com as propriedades da pasta. 5. Dê um clique na guia Segurança. 6. Surge a janela indicada na Figura 9.17.

530

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

Figura 9.17: As configurações de segurança para a pasta selecionada. 7. Observe que a conta com a descrição Conta de convidado da Internet é a conta para acesso anônimo, que no nosso exemplo é IUSR_SERVIDOR. Somente possuem permissão de acesso, as contas que fazem parte desta lista. 8. Dê um clique no botão Avançado. Surge a janela indicada na Figura 9.18. 9. Observe que a conta para acesso anônimo, possui permissão somente de leitura. 10. Vamos remover as permissões da conta IUSR_SERVIDOR (Conta de convidado da Internet). Para isso dê um clique sobre a conta para marcá-la, depois dê um clique no botão Remover. 11. A conta IUSR_SERVIDOR não aparece mais na listagem. 12. Marque a opção Redefinir opções em todos os objetos filhos e permitir a propagação das permissões herdades. Esta opção deve ser marcada para que as alterações que estão sendo feitas na pasta, sejam propagadas para todas as subpastas e arquivos pertencentes a esta pasta. Esta modificação é necessária para que a permissão para o usuário IUSR_SERVIDOR seja retirada de todos os arquivos pertencentes a pasta que está sendo alterada.

531

Criando Sites Dinâmicos com ASP 3.0

Figura 9.18: A conta IUSR_SERVIDOR possui permissão somente para leitura. 13. Dê um clique no botão OK para voltar à janela de propriedades da pasta. 14. Surge uma janela pedindo confirmação. Dê um clique em Sim para continuar. 15. Você estará de volta à janela de propriedades da pasta. 16. Na lista de usuários, remova os usuários IUSR_SERVIDOR e o grupo Todos. Para isso basta clicar no nome do usuário ou grupo e depois clicar no botão Remover. 17. A sua lista de permissões deve estar semelhante a indicada na Figura 9.19. 18. Dê um clique no botão OK para fechar esta janela. Agora que retiramos as permissões do usuário anônimo, se alguém tentar acessar algum arquivo que está na pasta cujas permissões foram retiradas, irá receber uma mensagem de erro, conforme indicado na Figura 9.20. Veja que a mensagem informa que o acesso à página solicitada foi negado. Isto acontece porque o usuário IUSR_SERVIDOR não possui as permissões NTFS necessárias.

532

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

Figura 9.19: Lista de permissões, onde foi retirada a permissão de acesso para o usuário anônimo.

Figura 9.20: Mensagem de erro ao tentar acessar uma página para a qual o usuário anônimo (conta IUSR_SERVIDOR, no nosso exemplo) não tem mais permissão de acesso.

533

Criando Sites Dinâmicos com ASP 3.0

IMPORTANTE Caso você teste o acesso localmente no servidor onde a página está gravada e a autenticação integrada esteja habilitada, você terá acesso à página. Isto acontece porque o IIS tenta primeiro acesso com a autenticação anônima. Não obtém sucesso. Se a autenticação integrada (a qual utiliza a conta do Windows que você utilizou para fazer o logon) estiver habilitada, o IIS tenta utilizá-la. Caso a conta que você utilizou para fazer o logon tenha permissão de acesso à página, o IIS libera o acesso. Isto também é válido para usuários da sua rede local que fizeram o logon em um domínio do Windows NT Server 4.0 ou do Windows 2000 e cujas contas ou grupos a que pertencem possuam permissão de acesso para o arquivo solicitado. Nos próximos itens veremos mais sobre a autenticação integrada.

Agora vamos restaurar as permissões NTFS para o usuário IUSR_SERVIDOR e testar para ver se ele voltou a ter acesso. Para atribuir novamente as permissões NTFS para o usuário IUSR_SERVIDOR. 1. Utilizando o Windows Explorer, localize a pasta cujas permissões NTFS serão alteradas. 2. Dê um clique com o botão direito do mouse sobre a pasta. No menu de opções, que surge, dê um clique em Propriedades. 3. Na janela de propriedades dê um clique na guia Segurança. 4. Surge a janela indicada na Figura 9.21.

Figura 9.21: As configurações de segurança para a pasta selecionada.

534

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

5. Observe que a conta com a descrição Conta de convidado da Internet, que é a conta para acesso anônimo (no nosso exemplo, IUSR_SERVIDOR), não aparece na lista de usuários, portanto a mesma não possui permissões de acesso. 6. Dê um clique no botão Avançado. Observe que, na janela que surge, a conta IUSR_SERVIDOR também não está na listagem, conforme indicado na Figura 9.22.

Figura 9.22: A conta IUSR_SERVIDOR não aparece na lista de contas. 7. Dê um clique no botão Adicionar. Surge uma janela com a listagem de usuários. Localize o usuário IUSR_SERVIDOR e dê um clique sobre o mesmo para marcá-lo, conforme indicado na Figura 9.23. 8. Dê um clique no botão OK. Surge uma janela pedindo para que você defina as permissões NTFS para o usuário IUSR_SERVIDOR. 9. Defina as permissões conforme indicado na Figura 9.24 e dê um clique no botão OK. 10. Você estará de volta à janela de opções avançadas. Certifique-se de que a opção – Redefinir permissões em todos os objetos filho e permitir a propagação das permissões herdadas – esteja marcada. 11. Dê um clique no botão OK para voltar à janela de propriedades da pasta.

535

Criando Sites Dinâmicos com ASP 3.0

Figura 9.23: Adicionando novamente o usuário IUSR_SERVIDOR.

Figura 9.24: Restaurando as permissões para o usuário IUSR_SERVIDOR. 12. Surge uma janela pedindo confirmação, conforme indicado na Figura 9.25. Dê um clique em Sim para continuar.

536

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

Figura 9.25: Confirmando as alterações. 13. Você estará de volta a guia Segurança da janela de propriedades da pasta. 14. Vamos adicionar o usuário IUSR_SERVIDOR para que ele tenha permissões de acesso à pasta. 15. Dê um clique no botão Adicionar. Surge a janela Selecione Usuários, Computadores ou Grupos. Localize o usuário IUSR_SERVIDOR e dê um clique sobre o mesmo para marcá-lo. Depois dê um clique no botão Adicionar para incluir o usuário na parte inferior da janela, conforme indicado na Figura 9.26.

Figura 9.26: Adicionando o usuário IUSR_SERVIDOR na lista de usuários que tem permissão de acesso à pasta selecionada.

537

Criando Sites Dinâmicos com ASP 3.0

16. Dê um clique no botão OK. Observe que o usuário IUSR_SERVIDOR já consta na listagem de usuários. 17. Defina as permissões conforme indicado na Figura 9.27 e dê um clique no botão OK.

Figura 9.27: Redefinindo as permissões de acesso à pasta selecionada. Feito isso foram reatribuídas as permissões NTFS originais e qualquer usuário volta a ter acesso à pasta (no nosso exemplo era a pasta Capitulo6) e a todo o seu conteúdo, porém com permissão somente para leitura. Agora, o usuário já poderá acessar a página que não será mais retornada a mensagem de acesso negado. Com este exemplo, podemos constatar que o servidor IIS trabalha em sintonia com o Windows 2000, de tal forma que os recursos de segurança do Sistema Operacional podem ser utilizados pelo IIS. Nós detalhamos um pouco mais o primeiro tipo de acesso – Acesso anônimo –, para explicar alguns conceitos importantes em detalhes. Agora passaremos a estudar outros tipos de

538

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

autenticação possíveis com o IIS. Lembrando que a autenticação com o IIS é apenas um dos tantos níveis de segurança que podemos configurar.

Autenticação Básica A autenticação básica é uma das mais antigas que existem, desenvolvidas desde a época dos primeiros servidores Web como o NCSA e o Cern HTTP. Neste tipo de autenticação, o usuário precisa fornecer um username e uma senha. O método de autenticação básica é um padrão de mercado amplamente usado para coletar informações de nome de usuário e senha. A autenticação básica funciona da seguinte forma: 1. O navegador exibe uma caixa de diálogo na qual o usuário pode digitar seu username e senha de conta do Windows 2000 atribuídos anteriormente. Por isso, é um prérequisito da autenticação básica que o usuário já possua uma conta cadastrada no Windows 2000. 2. O navegador tenta estabelecer uma conexão usando essas informações (a senha é codificada com Base64 antes de ser enviada pela rede). 3. Se o servidor rejeita as informações, o navegador da Web exibe repetidamente a caixa de diálogo até que o usuário digite um nome de usuário e uma senha válidos ou feche a caixa de diálogo. 4. Quando o servidor Web verifica que o nome de usuário e a senha correspondem a uma conta de usuário do Windows 2000 válida, a conexão é estabelecida e o acesso à página solicitada é liberado. A autenticação básica apresenta como principal requisito o fato de que o usuário deve ter uma conta no Windows 2000. Para sites que são acessados por um grande número de usuários pode não ser uma boa opção. Além disso, o fato do usuário ter que digitar um username e senha não é muito “simpático”. Uma das grandes desvantagens deste método de autenticação é o fato de que a senha não é criptografada ao ser transmitida pela rede. A codificação que é feita é extremamente simples de ser quebrada, por isso este método de autenticação não é dos mais seguros. A vantagem da autenticação básica é que ela faz parte da especificação do HTTP e tem suporte da maioria dos navegadores. A desvantagem é que, pelo fato dos navegadores que usam a autenticação básica transmitirem senhas de forma descriptografada, ao monitorar as comunicações na sua rede, alguém pode interceptar e decifrar facilmente essas senhas usando ferramentas disponíveis publicamente na própria Internet. Portanto, a autenticação básica não é recomendada, a menos que você tenha certeza que a conexão entre o usuário e seu servidor Web é segura, como uma conexão direta via cabo ou uma linha dedicada.

539

Criando Sites Dinâmicos com ASP 3.0

IMPORTANTE A autenticação integrada do Windows (que veremos logo em seguida) tem prioridade sobre a autenticação básica. O navegador escolherá a autenticação integrada do Windows e tentará usar as informações de logon atuais do Windows antes de solicitar ao usuário um nome e senha. Atualmente, somente o Internet Explorer, versão 2.0 e posterior, oferece suporte à autenticação integrada do Windows.

Autenticação Integrada do Windows A autenticação integrada do Windows (chamada anteriormente NTLM ou autenticação de desafio/resposta do Windows NT) é uma forma segura de autenticação pois o nome de usuário e a senha são enviados pela rede criptografados. Quando você ativa a autenticação integrada do Windows, o navegador do usuário verifica a validade da senha através de uma troca criptográfica com o servidor Web. A autenticação integrada do Windows pode usar o protocolo de autenticação Kerberos versão 5 e o seu próprio protocolo de autenticação desafio/resposta. Se os Serviços de diretório estiverem instalados no servidor e o navegador for compatível com o protocolo de autenticação Kerberos versão 5, os protocolos Kerberos versão 5 e desafio/resposta serão usados; caso contrário, somente o protocolo desafio/resposta será usado. O protocolo de autenticação Kerberos versão 5 é um recurso da arquitetura do Windows 2000 Distributed Services. Para que a autenticação deste protocolo seja bem-sucedida, o cliente e o servidor devem ter uma conexão confiável com um Key Distribution Center (KDC) e devem ser compatíveis com os Serviços de diretório. A situação ideal é onde o cliente utiliza o Windows 2000 Professional. A autenticação integrada do Windows funciona da seguinte forma: 1. Diferentemente da autenticação básica, ela não solicita inicialmente um nome de usuário e uma senha. As informações atuais de usuário do Windows sobre o computador cliente são usadas para a autenticação integrada do Windows.

NOTA O Internet Explorer, versão 4.0 e posterior, pode ser configurado para solicitar inicialmente informações do usuário, se necessário. Para obter mais informações, consulte a documentação do Internet Explorer.

540

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

2. No entanto, se a troca da autenticação não consegue identificar o usuário, o navegador solicita ao usuário um nome e uma senha de conta de usuário do Windows, que ele processa usando a autenticação integrada do Windows. 3. O Internet Explorer continuará a solicitar ao usuário até que ele digite um nome de usuário e uma senha válidos ou feche a caixa de diálogo de solicitação. Embora a autenticação integrada do Windows seja segura, ela tem duas limitações: ➥ Somente o Microsoft Internet Explorer, versão 2.0 ou posterior, oferece suporte a esse método de autenticação. ➥ A autenticação integrada do Windows não funciona em conexões feitas através de um servidor Proxy. Portanto, a autenticação integrada do Windows é mais adequada para um ambiente de Intranet, no qual o usuário e o servidor Web estão no mesmo domínio e os administradores podem garantir que todos os usuários tenham o Microsoft Internet Explorer, versão 2.0 ou posterior.

Autenticação Utilizando Certificados Este é um dos métodos de autenticação que mais vem crescendo. Inicialmente os Certificados Digitais foram projetados como um instrumento de autenticação segura para a Internet, porém o seu uso apresentou tantas vantagens que hoje é bastante comum sua utilização em Intranets e Extranets. A tecnologia de certificados usa os recursos de segurança de Secure Sockets Layer (SSL, camada de soquetes de segurança) do servidor Web para dois tipos de autenticação. É possível usar um certificado de servidor para permitir que os usuários façam a autenticação do seu site da Web antes de transmitir informações pessoais, como um número de cartão de crédito. Além disso, você pode usar certificados de cliente para autenticar os usuários que solicitam informações no seu site da Web. O SSL faz a autenticação, verificando o conteúdo de uma identificação digital (Certificado Digital) criptografada, submetida pelo navegador do usuário durante o processo de logon. (Os usuários obtêm certificados de cliente de uma organização independente mutuamente confiável.) Os certificados de servidor contêm geralmente informações sobre sua empresa e a organização que emitiu o certificado. Os certificados de cliente contêm normalmente informações de identificação sobre o usuário e a organização que emitiu o certificado.

Mapeamento do Certificado Cliente Você pode associar, ou mapear, certificados de cliente a contas de usuário do Windows no IIS. Depois que você cria e ativa um mapa de certificado, sempre que um usuário faz logon

541

Criando Sites Dinâmicos com ASP 3.0

com um certificado de cliente, seu servidor Web associa automaticamente esse usuário à conta de usuário do Windows apropriada. Dessa forma, você pode autenticar automaticamente os usuários que fazem logon com certificados de cliente, sem exigir o uso da autenticação básica ou integrada do Windows. É possível mapear um certificado de cliente para uma conta de usuário do Windows ou muitos certificados de cliente para uma conta. Por exemplo, se você tivesse vários departamentos ou empresas diferentes no seu servidor, cada uma com seu próprio site da Web, seria possível usar o mapeamento vários-para-um para mapear todos os certificados de cliente de cada departamento ou empresa para o próprio site da Web. Dessa forma, cada site forneceria acesso somente aos próprios clientes. No próximo capítulo veremos um pouco mais sobre Certificados Digitais. O tipo de autenticação é apenas um dos aspectos que precisam ser definidos; devem ser consideradas diversas outras questões. A seguir, algumas questões que devem ser levadas em considerações na hora de decidir sobre o tipo de autenticação que iremos configurar no IIS, ou se devemos configurar mais do que um tipo de autenticação. ➥ Para um site público, ou áreas de acesso público, a autenticação utilizando acesso anônimo é a mais indicada, pois evita que o usuário tenha que fornecer um username e senha. ➥ Para acesso ao conteúdo de uma Intranet, uma das primeiras opções a serem pensadas é a utilização da autenticação integrada do Windows. Pois sendo uma Intranet um ambiente controlado, é possível garantir que todos os clientes satisfaçam as condições exigidas pela autenticação integrada. ➥ Para sites que trabalham com dados sensíveis como serviços bancários pela Internet e Comercio Eletrônico, sem dúvida que a utilização de Certificados Digitais é o mais indicado. Em Intranets os certificados também têm sido utilizados, pois conforme descrevemos no início do capítulo, a maioria dos ataques parte de usuários da Intranet da empresa. Muitas vezes nos preocupamos muito com os ataques externos e esquecemos as ameaças que vem de dentro da própria empresa.

Configurando o Tipo de Autenticação no IIS Neste item veremos como configurar uma ou mais opções de autenticação no IIS. Lembrando que podemos ter diferentes tipos de autenticação em diferentes partes de um site armazenado em um servidor IIS. Por exemplo, para uma área de acesso público podemos utilizar autenticação anônima, para uma área mais restrita podemos utilizar somente autenticação integrada do Windows. Podemos inclusive configurar o nível de autenticação para uma página HTML ou ASP, individualmente. Para configurar o tipo de autenticação faça o seguinte:

542

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

1. Faça o logon no Windows 2000 Server, com permissões de administrador. 2. Abra o Gerenciador do Internet Services: Iniciar/Programas/Ferramentas administrativas/Gerenciador do Internet Services. 3. É aberto o console de gerenciamento do IIS. 4. Dê um clique duplo no nome do computador. No nosso exemplo o nome é Servidor. 5. Surgem as opções indicadas na Figura 9.28.

Figura 9.28: Opções de gerenciamento do IIS. 6. Neste momento podemos configurar o tipo de autenticação para todos os aplicativos Web contidos no servidor ou para cada aplicativo individualmente. 7. A título de exemplo, vamos configurar o tipo de autenticação para o site Web padrão. 8. Clique com o botão direito do mouse sobre a opção Site da Web padrão (ou na opção correspondente, caso você tenha alterado este nome). No menu de opções que surge, dê um clique em Propriedades. 9. Será exibida a janela Propriedades de Site Web padrão. 10. Dê um clique na guia Segurança de pasta. Serão exibidas as opções indicadas na Figura 9.29. 11. A primeira opção desta guia é Controle de acesso anônimo e autenticação. Dê um clique no botão Editar, ao lado desta opção. Surge a janela Métodos de autenticação, indicada na Figura 9.30. 12. Observe que, por padrão, estão definidas as opções Acesso anônimo e Autenticação integrada do Windows. 13. Nesta janela você pode definir qual ou quais tipos de autenticação que o servidor IIS deverá suportar para o Site Web padrão. Além disso, você pode configurar qual a conta que será utilizada para o acesso anônimo, conforme descrito anterioremente.

543

Criando Sites Dinâmicos com ASP 3.0

Figura 9.29: As opções da guia Segurança de pasta.

Figura 9.30: As opções para métodos de autenticação.

544

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

14. Selecione as opções desejadas. Se você clicar na opção Autenticação básica, o IIS emite um aviso de que para esta opção as senhas serão transmitidas sem criptografia, conforme indicado na Figura 9.31.

Figura 9.31: Avisa de que na autenticação básica a senha é transmitida sem criptografia. 15. Dê um clique em Sim e a autenticação básica será habilitada. 16. Dê um clique no botão OK para fechar a janela de configuração dos tipos de autenticação. 17. Você estará de volta à janela de Propriedades de Site da Web padrão. Dê um clique no botão OK para fechá-la. 18. Caso alguma aplicação Web ou pasta virtual do servidor possua uma configuração diferente da definida para o Site da Web padrão, o IIS abre uma janela informando qual site possui uma configuração diferente e perguntando se você deseja estender as configurações do site Web padrão para as pastas virtuais e aplicativos Web internos, conforme indicado na Figura 9.32.

Figura 9.32: Estendendo as configurações para as aplicações e pastas virtuais.

545

Criando Sites Dinâmicos com ASP 3.0

19. Para estender as configurações basta selecionar uma ou mais das opções mostradas e clicar no botão OK. Você também pode utilizar o botão Selecionar tudo e depois clicar em OK. 20. Você estará de volta ao Gerenciador do Internet Services. Feche-o. Para configurar as opções para uma pasta virtual em particular, basta localizá-la abaixo da opção Site da Web padrão, clicar com o botão direito sobre a mesma e clicar na opção Propriedades. Depois é só seguir os passos indicados anteriormente.

Mais Configurações de Segurança do IIS Podemos efetuar outras configurações relacionadas com segurança, no servidor IIS. Existem algumas opções que limitam o tipo de ação que o usuário pode tomar em uma determinada pasta virtual ou em uma página especificamente. Neste item iremos estudar diversas destas opções. Dividiremos as mesmas em dois grupos: ➥ Opções gerais de segurança. ➥ Opções relacionadas com uma aplicação Web.

Configurando Opções Gerais de Segurança Estas configurações são definidas, normalmente, a nível de pasta virtual. Para configurar estas opções faça o seguinte: 1. Faça o logon no Windows 2000 Server, com permissões de administrador. 2. Abra o Gerenciador do Internet Services: Iniciar/Programas/Ferramentas administrativas/Gerenciador do Internet Services. 3. É aberto o console de gerenciamento do IIS. 4. Dê um clique duplo no nome do computador. No nosso exemplo o nome é Servidor. 5. Dê um clique no sinal de + ao lado de Site da Web padrão. Serão exibidas as diversas pastas virtuais disponíveis no servidor. 6. A título de exemplo, vamos configurar as opções gerais de segurança para a pasta Capitulo6, conforme indicado na Figura 9.33.

NOTA Caso você não tenha criado uma pasta virtual Capítulo6, utilize qualquer pasta virtual disponível no seu servidor IIS. 7. Clique com o botão direito do mouse sobre a opção Capitulo6. No menu de opções que surge, dê um clique em Propriedades.

546

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

Figura 9.33: Configurando opções gerais de segurança para a pasta Capitulo6. 8. Será exibida a janela Propriedades de Capitulo6. 9. Na guia Pasta (que já deve estar sendo exibida), existem diversas opções de configuração. Abaixo descrevemos cada uma destas opções. ➥ Acesso ao código fonte do Script: Selecione esta opção para permitir que os usuários acessem o código fonte se a permissão de leitura ou gravação estiver definida. O código fonte inclui Scripts nos aplicativos ASP. ➥ Leitura: Selecione esta opção para permitir que os usuários leiam ou façam o download dos arquivos ou diretórios e de suas propriedades associadas. ➥ Gravação: Selecione esta opção para permitir que os usuários carreguem os arquivos e suas propriedades associadas no diretório ativado no servidor ou alterem o conteúdo de um arquivo ativado para gravação. A gravação só poderá ser feita com um navegador que dê suporte ao recurso PUT do protocolo padrão HTTP 1.1. Cuidado com esta permissão. Dificilmente você precisará habilitar permissão de Gravação para áreas em que é permitida a autenticação com usuário anônimo. ➥ Pesquisa em Pasta: Selecione esta opção para permitir que o usuário veja uma listagem em hipertexto dos arquivos e subdiretórios deste diretório virtual. Os diretórios virtuais não aparecerão nas listagens de diretórios; os usuários devem saber o alias do diretório virtual. Caso o usuário digite o endereço para o caminho da pasta e não especifique um documento a ser carregado, será exibida uma listagem semelhante a indicada na Figura 9.34.

547

Criando Sites Dinâmicos com ASP 3.0

Figura 9.34: Listagem exibida quando a opção Pesquisa em Pasta está habilitada. Caso esta opção não esteja marcada e o usuário digite o endereço para a pasta, sem especificar um arquivo a ser carregado, será retornada a mensagem de erro indicada na Figura 9.35.

Figura 9.35: Mensagem de erro quando a opção Pesquisa em Pasta estiver desabilitada.

548

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

➥ Criar log de visitantes: Selecione esta opção para registrar as visitas feitas a este diretório em um arquivo de Log. As visitas serão registradas somente se o log estiver ativado para este site da Web. ➥ Indexar este recurso: Para permitir que o Serviço de indexação da Microsoft (Index Services) inclua este diretório em um índice de texto completo do site da Web, selecione esta opção. De uma maneira geral, recomendo que as opções Gravação e Pesquisa em pasta sejam marcadas somente em situações especiais e para áreas que não contenham dados confidenciais. Uma questão importante é a combinação entre as permissões definidas no IIS e as permissões NTFS. Por exemplo, vamos supor que o usuário tenha sido autenticado como usuário anônimo e está tentando gravar conteúdo em uma pasta virtual na qual o IIS possui permissão de gravação, porém as permissões NTFS não permitem que o usuário anônimo faça gravações. Como fica esta combinação? Quando uma página é solicitada, o IIS segue a seqüência indicada na Figura 9.36.

Servidor Web recebe requisição.

Endereço IP permitido?

Usuário permitido?

Permissões do servidor Web concedem acesso?

Permissões do NTFS concedem acesso?

Acesso concedido.

Acesso negado.

Figura 9.36: Seqüência de verificação do IIS.

549

Criando Sites Dinâmicos com ASP 3.0

Observe que primeiro o IIS verifica se o usuário tem permissões da Web para o recurso solicitado. Se o usuário não tiver, a solicitação falha e o usuário recebe uma mensagem “403 Acesso proibido”. Depois, o IIS verifica as permissões do NTFS para o recurso. Se o usuário não tiver permissões do NTFS para o recurso, a solicitação falha e o usuário recebe uma mensagem “401 Acesso negado”. Então a resposta para o nosso exemplo é que o usuário não conseguiria gravar o conteúdo, pois o mesmo não teria as permissões NTFS necessárias e receberia a mensagem de erro “401 Acesso negado”.

Configuração de Segurança Para Aplicativos Web no IIS Estas configurações são definidas, também utilizando a guia Pasta da janela de Propriedades para a pasta virtual que representa a aplicação Web. Para configurar estas opções faça o seguinte: 1. Faça o logon no Windows 2000 Server, com permissões de administrador. 2. Abra o Gerenciador do Internet Services: Iniciar/Programas/Ferramentas administrativas/Gerenciador do Internet Services. 3. É aberto o console de gerenciamento do IIS. 4. Dê um clique duplo no nome do computador. No nosso exemplo o nome é Servidor. 5. Dê um clique no sinal de + ao lado de Site da Web padrão. Serão exibidas as diversas pastas virtuais disponíveis no servidor. 6. A título de exemplo, vamos configurar as opções de aplicação para a pasta Capitulo6.

NOTA Caso você não tenha criado uma pasta virtual Capítulo6, utilize qualquer pasta virtual disponível no seu servidor IIS. 7. Clique com o botão direito do mouse sobre a pasta Capitulo6. No menu de opções que surge dê um clique em Propriedades. 8. Será exibida a janela Propriedades de Capitulo6. 9. Certifique-se de que estão sendo exibidas as opções da guia Pasta. 10. Na parte de baixo da guia Pasta, temos um grupo de opções chamado Configurações do aplicativo. A seguir temos uma descrição de cada uma destas opções. Conforme descrito anteriormente, um aplicativo da Web do IIS é definido pela estrutura de diretórios em que está localizado. Para obter mais informações, consulte o Capítulo 8 deste livro.

550

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

➥ Nome do aplicativo: Normalmente utilizamos o mesmo nome da pasta virtual. ➥ Botão Remover: Se clicarmos neste botão removemos todas as opções de aplicativo, e transformamos o aplicativo Web em uma simples pasta virtual, para a qual não se aplicam os conceitos dos objetos Application, Session e do arquivo global.asa. Para maiores informações sobre os objetos Application, Session e o arquivo global.asa, consulte o Capítulo 8 deste livro, bem como para informações sobre as opções do botão Configuração. ➥ Permissões de execução: Esta opção determina o nível de execução de programa permitido para recursos de diretórios virtuais ou deste site. Temos três opções: ◆

Nenhum: Somente arquivos estáticos, como os arquivos HTML (Hypertext Markup Language, linguagem de marcação de hipertexto) ou os arquivos de imagem, podem ser acessados. Não permite que scripts ASP sejam executados.

◆

Somente scripts: Somente scripts, como os scripts ASP, podem ser executados. Este é o padrão normalmente definido.

◆

Scripts e executáveis: Todos os tipos de arquivos podem ser acessados ou executados. Cuidado com esta configuração. Muitos dos ataques conhecidos consistem em enviar e executar arquivos executáveis no servidor a ser atacado. Os executáveis enviados, normalmente, abrem portas de segurança que estavam fechadas pelo administrador.

➥ Proteção do aplicativo: Temos três opções: ◆

Baixa: Selecione esta opção para que os aplicativos sejam executados no mesmo processo que os serviços da Web (opção baixo). Neste caso se um dos aplicativos apresentar problema e desativar o processo do servidor Web, todos os aplicativos ficarão indisponíveis até que o servidor Web tenha sido normalizado.

◆

Média (em pool): Selecione esta opção para que a aplicação Web seja executada em um processo em pool isolado em que outros aplicativos também são executados.

◆

Alta (isolada): Neste caso a aplicação Web será executada em seu próprio espaço de endereçamento e se a mesma apresentar problemas, as outras aplicações Web, bem como o servidor IIS continuam funcionando normalmente. A execução isolada aumenta a disponibilidade do servidor Web, pois problemas em uma aplicação não irão afetar todo o servidor, porém consome mais recursos, como memória, pois cada aplicação é executada em seu próprio espaço de memória.

NOTA Para determinar qual opção representa uma aplicação Web e qual é simplesmente uma pasta virtual é só observar o ícone ao lado do nome, no Gerenciador do Internet Services. Opções que são simplesmente uma pasta virtual são representadas por um envelope amarelo, já aplicações Web possuem um ícone que parece uma caixa aberta, conforme indicado na Figura 9.37.

551

Criando Sites Dinâmicos com ASP 3.0

Figura 9.37: Ícones para uma aplicação Web e para uma pasta virtual.

Definindo Restrições de Acesso a Nível de Endereço IP Podemos definir restrições de acesso a nível de endereço IP. Por exemplo, vamos supor que existe uma área do site que é para desenvolvimento, e que a mesma não deva ser acessada nem por usuários da Intranet da empresa, muito menos por usuários da Internet. Somente os participantes do grupo de desenvolvimento é que devem ter acesso a esta parte do site. Podemos, sem maiores problemas, limitar o acesso, de tal maneira que somente as estações de trabalho dos desenvolvedores tenham acesso a área de desenvolvimento do site. Neste item aprenderemos a configurar uma aplicação Web ou uma pasta virtual do IIS, para limitar o acesso com base no endereço IP do usuário. Para definir restrições de acesso a nível de endereço IP faça o seguinte: 1. Faça o logon no Windows 2000 Server, com permissões de administrador. 2. Abra o Gerenciador do Internet Services: Iniciar/Programas/Ferramentas administrativas/Gerenciador do Internet Services. 3. É aberto o console de gerenciamento do IIS. 4. Dê um clique duplo no nome do computador. No nosso exemplo o nome é Servidor. 5. Nas opções que surgem, dê um clique com o botão direito do mouse sobre a opção Site da Web padrão (ou na opção correspondente, caso você tenha alterado este nome). No menu de opções que surge dê um clique em Propriedades.

552

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

6. Será exibida a janela Propriedades de Site Web padrão. 7. Dê um clique na guia Segurança de pasta. 8. O segundo grupo de opções desta guia é Restrições de nome de domínio e endereço IP. Dê um clique no botão Editar, ao lado desta opção. Surge a janela, indicada na Figura 9.38.

Figura 9.38: Janela para configuração das restrições de nome de domínio e endereço IP. Observe que temos duas opções para configuração, conforme descrito a seguir: ➥ Acesso permitido: Se esta opção estiver marcada, todos terão acesso ao site, com exceção dos endereços IP que estiverem indicados na listagem Exceto os listados abaixo. Este mecanismo é chamado de “Lista Negra”, ou seja, todo mundo tem acesso, com exceção de quem está na lista. ➥ Acesso negado: Se esta opção estiver marcada, ninguém terá acesso ao site, com exceção dos endereços IP que estiverem indicados na listagem Exceto os listados abaixo. Este mecanismo é chamado de “Lista Branca”, ou seja, ninguém tem acesso, com exceção de quem está na lista. 9. A título de exemplo, deixe marcada a opção Acesso permitido. Agora vamos negar acesso para um computador específico.

NOTA No exemplo do livro estarei negando acesso para o IP: 10.204.123.1, que é o endereço IP do meu computador. Utilize o endereço IP do equipamento para o qual você quer negar acesso, a nível de teste. 10. Dê um clique no botão Adicionar. Surge a janela indicada na Figura 9.39.

553

Criando Sites Dinâmicos com ASP 3.0

Figura 9.39: Definindo o alcance das restrições impostas. Nesta janela temos três opções a serem escolhidas, conforme explicado a seguir: ➥ Um computador: Neste caso estamos negando acesso para um computador específico. Basta digitar o endereço IP do mesmo. No nosso exemplo, utilizaremos esta opção e iremos digitar o IP 10.204.123.1. ➥ Grupo de computadores: Se você marcar esta opção, surge, na parte de baixo da janela, mais um campo, Máscara de sub-rede, conforme indicado na Figura 9.40. Podemos utilizar esta opção para negar acesso a uma rede ou segmento de rede inteiro.

Figura 9.40: Negando acesso para um grupo de computadores. Por exemplo, podemos negar acesso a qualquer computador da rede 10.204.123, para isso preencheríamos os campos da seguinte maneira:

554

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

➥ Identificação da rede: 10.204.123.0 ➥ Máscara de sub-rede: 255.255.255.0 Para negar acesso a todas as máquinas da rede 161.147, utilizaríamos a seguinte configuração: ➥ Identificação da rede: 161.147.0.0 ➥ Máscara de sub-rede: 255.255.0.0 ➥ Nome de domínio: Esta opção permite que neguemos acesso com base no nome DNS de um grupo de computadores. Por exemplo, podemos negar acesso para setor de contabilidade empresa, negando acesso para o domínio: contabilidade.abc.com.br. Ao tentar utilizar esta opção, o IIS emite uma mensagem avisando que o desempenho do servidor pode ser prejudicado pela ativação desta opção, e perguntando se você realmente deseja ativá-la. 11. Vamos negar o acesso apenas para um computador – 10.204.123.1. Certifique-se de que a opção Um computador esteja marcada e no campo Endereço IP, digite 10.204.123.1, conforme indicado na Figura 9.41.

Figura 9.41: Negando acesso para o computador 10.204.123.1. 12. Dê um clique no botão OK para incluir o computador com endereço IP 10.204.123.1, na lista dos computadores com acesso negado, conforme indicado na Figura 9.42. 13. Dê um clique no botão OK e você estará de volta à janela Propriedades do Site da Web padrão. 14. Dê um clique no botão OK para fechar a janela de propriedades. 15. Caso alguma aplicação Web ou pasta virtual do servidor possua uma configuração diferente da definida para o site Web padrão, o IIS abre uma janela informando qual site possui uma configuração diferente e perguntando se você deseja estender as configurações do site Web padrão para as pastas virtuais e aplicativos Web internos.

555

Criando Sites Dinâmicos com ASP 3.0

Figura 9.42: O computador com endereço IP 10.204.123.1 já aparece na lista. 16. Para estender as configurações basta selecionar uma ou mais das opções mostradas e clicar no botão OK. Você também pode utilizar o botão Selecionar tudo e depois clicar em OK. 17. Você estará de volta ao Gerenciador do Internet Services. Feche-o. Agora vou tentar acessar uma página do servidor IIS para qual o acesso foi negado para o IP do meu computador – 10.204.123.1. Ao tentar fazer o acesso, recebo a mensagem indicada na Figura 9.43.

Figura 9.43: Mensagem de que o acesso foi negado.

556

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

Observe que a mensagem informa que o endereço IP foi rejeitado. Para que o endereço IP 10.204.123.1 volte a ter acesso ao site, é so seguir os passos indicados anteriormente e removêlo da lista de endereços IP com acesso negado.

Mecanismos de Segurança do Banco de Dados Um outro nível de segurança que pode ser configurado é no nível de banco de dados. Os programas gerenciadores de banco de dados, como o Microsoft SQL Server, Oracle, Microsoft Access, Sybase, etc., fornecem diversos mecanismos de segurança que, se adequadamente configurados, aumentam bastante o nível de segurança das informações. No Microsoft SQL Server podemos atribuir níveis de permissão para os usuários do Windows 2000, e até mesmo para o usuário utilizado para acesso anônimo. Na Figura 9.44, temos um exemplo onde o usuário IUSR_SERVIDOR está recebendo permissão somente para leitura na tabela Orders do banco de dados Northwind em um servidor com o Microsoft SQL Server 2000 – Beta 2.

Figura 9.44: Definindo permissões de banco de dados no Microsoft SQL Server 2000.

557

Criando Sites Dinâmicos com ASP 3.0

NOTA Para maiores informações sobre configurações de segurança no Microsoft SQL Server 2000, consulte a documentação do produto.

Na maioria dos bancos de dados pode ser necessário o fornecimento de um username e senha para que o acesso seja liberado. Podemos construir um formulário HTML com dois campos, onde o usuário digita o username e a senha. Ao clicar em um botão Logon, os valores digitados são enviados para uma página ASP que monta a String de conexão de acordo com os dados fornecidos pelo usuário, incluindo o username e senha. Na Listagem 9.1, temos um exemplo de formulário, onde temos dois campos: username e senha, nos quais o usuário irá digitar as informações de logon. Listagem 9.1 – Formulário para digitação do username e da senha – logon.htm. 1

<HTML>

<HEAD>

<TITLE>Informações de Logon!!</TITLE>

</HEAD>

<BODY>

Digite os dados para efetuar o logon no servidor SQL:

</B></FONT></P>

<P>

<TR>

<TD>Username:</TD>

</TR>

<TR>

17 18 19

<TD>Senha:</TD> <TD><INPUT id=senha maxLength=15 name=senha type=password></TD> </TR>

558

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

<TR>

</TR>

</TABLE>

</P>

</FORM>

</BODY>

</HTML>

Na Figura 9.45, temos o formulário logon.htm carregado, onde o usuário digita as informações para o logon.

Figura 9.45: Username e senha para logon no servidor SQL.. Ao clicar no botão Logon, os dados digitados pelo usuário são enviados para a página logon.asp, a qual monta uma String de conexão, com base nos dados informados pelo usuário. Na Listagem 9.2, temos um exemplo da página logon.asp. Listagem 9.2 – Página ASP que monta a String de conexão para o servidor SQL – logon.asp. 1

<%@ Language=VBScript %>

<HTML>

559

Criando Sites Dinâmicos com ASP 3.0

<HEAD>

</HEAD>

<BODY>

‘O primeiro passo é criar a conexão com o banco de dados

‘Para isto crio um objeto do tipo Connection

‘Cria um objeto do tipo ADODB.Connection

Set conn=Server.CreateObject(“ADODB.Connection”)

‘Agora defino a propriedade ConnectionString do objeto Connection

‘criado anteriormente.

conn.ConnectionString = “PROVIDER=SQLOLEDB; Data Source=SERVIDOR\SERVIDOR;Initial Catalog=Northwind;User ID=” & Request.Form(“username”)& “;Password=” & Request.Form(“senha”)

conn.Open

<HR>

Response.Write “Conexão estabelecida com sucesso !!”

<HR>

</BODY>

</HTML>

Se o usuário digitou as informações de logon corretamente, ao acessar a página logon.asp, ele obterá o resultado indicado na Figura 9.46.

Figura 9.46: Conexão efetuada com sucesso.

560

Capítulo 9 – Segurança de Aplicações Web com IIS e ASP

Se o usuário cometer um erro na digitação do nome de usuário ou da senha, obteremos uma mensagem de erro conforme indicado na Figura 9.47.

Figura 9.47: Erro no logon com o banco de dados. Observe que a mensagem informa que houve um erro no logon do usuário sa. O ideal é que estas situações de erro sejam tratadas e ao invés do IIS simplesmente enviar uma página com uma mensagem de erro padrão, podemos interceptar a ocorrência do erro e enviar para o usuário uma página mais trabalhada, onde o mesmo tenha a opção de entrar novamente com as informações de logon. Aprenderemos a fazer o tratamento de erros no Capítulo 11.

Conclusão Neste capítulo aprendemos sobre aspectos básicos de segurança, tais como: ➥ Tipos de autenticação. ➥ Permissões NTFS do Windows 2000. ➥ Opções de segurança do IIS. ➥ Permissões a nível de banco de dados. Muito existe a ser tratado sobre segurança. Livros inteiros já foram escritos sobre o assunto. Pela experiência de anos trabalhando com ambientes de Rede Locais e acesso a dados críticos

561

Criando Sites Dinâmicos com ASP 3.0

posso afirmar com convicção: “O primeiro passo para estabelecer um ambiente seguro é a definição de um política de segurança e a ampla divulgação da mesma, para que todos estejam conscientes de suas responsabilidades em relação à segurança.” Muitas vezes cuida-se muito da segurança de acesso lógico aos dados, com a otimização das configurações de segurança do Sistema Operacional, do servidor Web e do servidor de Banco de dados. São gastos milhares de dólares em equipamentos e programas sofisticados para atuarem como Firewall. Investe-se em roteadores modernos, com capacidades de filtragem de pacotes, detecção de tentativas de invasão e assim por diante. E, muitas vezes, a segurança física é esquecida. De que adianta toda esta segurança no acesso lógico, se um desconhecido pode, facilmente, invadir a sala dos servidores e sair com uma meia dúzia de fitas de backup em baixo do braço? Obviamente que o investimento em segurança de acesso lógico aos dados é necessária, porém o aspecto da segurança no acesso físico é igualmente importante. Pontos como estes devem ser definidos na política de segurança da empresa, a qual deve ser continuamente revisada para se adaptar às freqüentes mudanças no mundo da tecnologia. No próximo capítulo veremos alguns conceitos avançados do ASP 3.0.

562

Capítulo 10 – Utilizando Componentes do IIS

Capítulo 10 Utilizando Componentes do IIS

563

Criando Sites Dinâmicos com ASP 3.0

Introdução Neste capítulo estaremos tratando de uma série de objetos do ASP e outros assuntos importantes na construção de aplicativos Web com ASP 3.0. Iniciaremos o capítulo por um estudo do objeto Server e dos seus diversos métodos e propriedades. Veremos como solucionar problemas práticos, bastante comuns na construção de aplicações Web. Apresentaremos um exemplo prático que ilustra uma necessidade típica de aplicações Web. No nosso exemplo, o usuário selecionará o nome de um país em uma lista de países. Ao clicar em um botão Pesquisar, será retornada uma lista, em forma de tabela, com todos os Clientes para o País selecionado. O nome do Cliente será um link, que ao ser clicado abrirá uma página com as informações sobre o mesmo. Para construir esta página teremos que utilizar alguns métodos do objeto Server. Em seguida, passaremos ao estudo de alguns componentes ASP. Veremos com mais detalhes o conceito de componentes. Também aprenderemos a utilizar diversos componentes que são fornecidos juntamente com o IIS. Estudaremos os seguintes componentes: ➥ Content Link. ➥ Ad Rotator. ➥ Browser Capabilities. ➥ Page Counter. Estes componentes são fornecidos juntamente com o IIS e oferecem uma série de funcionalidades bastante interessantes, conforme veremos mais adiante.

O Objeto Server O objeto Server nos fornece a possibilidade de estender as capacidades de nossas páginas ASP, através da utilização de objetos e componentes externos. Estes objetos e componentes fornecem funcionalidades específicas as quais são necessárias à aplicação que está sendo desenvolvida. A utilização de componentes externos faz parte da filosofia de desenvolvimento de aplicações baseadas em componentes. Para o mundo Windows, os componentes devem seguir o padrão COM (Component Object Model), que no Windows 2000 recebe a denominação de COM+ (COM Plus).

564

Capítulo 10 – Utilizando Componentes do IIS

Já utilizamos, em diversas oportunidades neste livro, o objeto Server e o seu método CreateObject, para criar objetos como ADODB.Connection e ADODB.RecordSet. Na maioria dos exemplos de acesso a Banco de dados, utilizamos o método CreateObject para criar estes objetos. Com o objeto Server, podemos ter acesso aos componentes que são fornecidos juntamente com o IIS, bem como a qualquer componente que tenha sido desenvolvido por uma empresa de desenvolvimento de software. O requisito para que o componente possa ser utilizado é que o mesmo siga o padrão COM/COM+ e tenha sido registrado no servidor Web. Existem diversas empresas que produzem componentes e objetos para serem utilizados em páginas ASP. Existem componentes para as mais diversas funcionalidades, tais como: ➥ Envio de e-mail a partir de páginas ASP. ➥ Impressão de bloquetos de cobrança bancária. ➥ Verificação de número de CPF, CNPJ ou cartão de crédito. ➥ Cálculo de impostos e outros acréscimos legais. ➥ Cálculos específicos para setores, como por exemplo: Recursos Humanos, Contabilidade, etc. ➥ Componentes para criação de gráficos em páginas Web. ➥ Componentes que facilitam a pesquisa em bancos de dados. Agora passaremos ao estudo do objeto Server. Analisaremos os seus métodos e sua propriedade (isso mesmo, propriedade no singular, pois temos uma única propriedade).

Propriedade do Objeto Server O objeto Server possui uma única propriedade: ScriptTimeout. Esta propriedade pode ser utilizada para definir ou retornar o número de segundos que uma página pode ficar em execução antes que a mesma seja interrompida pelo IIS e uma mensagem de erro seja retornada. O valor padrão é 90 segundos. Esta propriedade é importante, principalmente em páginas que apresentam um Loop infinito, devido a erros de programação. Neste caso, após o período definido pela propriedade ScriptTimeout, a página terá sua execução encerrada. Com isso evita-se que a página fique consumindo recursos no servidor até causar uma parada do mesmo. Uma prática comum é aumentar o valor desta propriedade para determinadas páginas, como, por exemplo, para um formulário de compras. Se a página demorar para aparecer e retornar um erro, o usuário poderá desconfiar de que a compra foi efetivada e não irá recarregar a página com medo de duplicar o seu pedido.

565

Criando Sites Dinâmicos com ASP 3.0

A sintaxe para esta propriedade é bastante simples: <% Server.ScriptTimeout = segundos %> Por exemplo: <% Server.ScriptTimeout = 300 %>

Este exemplo define o TimeOut da página para 5 minutos (300 segundos).

IMPORTANTE O tempo limite definido pela propriedade ScriptTimeout não terá efeito enquanto um componente do servidor estiver processando. Por isso, caso você esteja utilizando um componente com defeitos, o mesmo continuará em execução independente do valor definido por esta propriedade.

Também podemos atribuir o valor armazenado nesta propriedade a uma variável, como no exemplo a seguir: <% tempo_limite = Server.ScriptTimeout Response.Write tempo_limite %>

Métodos do Objeto Server Conforme descrito anteriormente, já utilizamos diversas vezes, neste livro, o método CreateObject do objeto Server. Agora estudaremos este e os demais métodos do objeto Server. Coincidentemente, vamos começar justamente com o método CreateObject.

O Método CreateObject O método CreateObject é utilizado para criar uma instância de um componente ou objeto existente no servidor. O termo “existente no servidor” significa que o objeto deve ter sido previamente instalado e registrado no IIS. Diversos objetos e componentes fazem parte da instalação padrão do IIS e iremos estudá-los ainda neste capítulo. A sintaxe para o método CreateObject é a seguinte: Set nome_objeto = Server.CreateObject(“Identificador_do_objeto”)

566

Capítulo 10 – Utilizando Componentes do IIS

Onde temos: ➥ nome_objeto: É o nome da variável que será utilizada para fazer referência ao objeto na página ASP onde o objeto é criado. Em diversos exemplos deste livro criamos um objeto para conexão com banco de dados e atribuímos o mesmo a uma variável chamada conn. O nome da variável é determinado pelo desenvolvedor; poderíamos ter utilizado qualquer nome de variável válido. ➥ Identificador_do_objeto: Especifica o tipo de objeto a ser criado. O formato é [Fornecedor.]Componente[.Versão]. Em diversos exemplos do livro utilizamos os seguintes identificadores: ADODB.Connection ADODB.RecordSet

Este é o nome com que o componente está registrado no servidor Windows 2000. As informações, sobre o registro do componente, ficam armazenadas na Registry do Windows 2000, conforme indicado na Figura 10.1.

Figura 10.1: Informações na Registry sobre o componente ADODB.Connection.2.5. Por padrão, os objetos criados pelo método Server.CreateObject têm escopo de página. Isso significa que eles são automaticamente destruídos pelo servidor quando ele termina o processamento da página ASP atual. Para criar um objeto com escopo de sessão ou aplicativo, você poderá usar a marca <OBJECT> no arquivo global.asa e definir o atributo SCOPE para SESSION ou APPLICATION, ou armazenar o objeto em uma variável de sessão ou aplicativo. No Capítulo 8, criamos um objeto do tipo ADODB.Connection e o armazenamos em uma variável de nível da aplicação, utilizando o objeto Application.

567

Criando Sites Dinâmicos com ASP 3.0

Já um objeto criado em nível de Sessão, será destruído quando a sessão for encerrada. Isto acontece quando a sessão atinge o tempo limite ou o método Abandon é chamado. No exemplo abaixo criamos um objeto em nível de sessão chamado Rodar. Este componente é, na verdade, uma instância do componente AdRotator. Estudaremos o mesmo mais adiante neste capítulo. <% Set Session(“rodar”) = Server.CreateObject(“MSWC.AdRotator”) %>

Podemos destruir um objeto atribuindo a variável que representa o objeto, o valor Nothing. <% Session(“rodar”) = Nothing %>

NOTA Destruir o objeto significa retirá-lo da memória, de maneira que não possa mais ser utilizado e os recursos que o mesmo utilizava são liberados.

IMPORTANTE Não podemos criar uma instância de objeto com o mesmo nome de um objeto interno. O exemplo a seguir retorna um erro: <% Set Response = Server.CreateObject(“Response”) %>

Não podemos criar uma instância de objeto chamada Response, uma vez que no Modelo de Objetos do ASP já existe um objeto chamado Response, conforme estudado em capítulos anteriores.

O Método Execute(“url”) O método Execute chama um arquivo .asp e o processa como se ele fosse parte da chamada do script ASP. A execução da página corrente é suspensa e o controle é transferido para a página especificada no parâmetro URL. O método Execute é similar a uma chamada de procedimento em muitas linguagens de programação. A página, chamada utilizando o método Execute, é processada e, após o término da execução, o controle retorna para a página que fez a chamada. O método Execute possui a seguinte sintaxe: Server.Execute(“url”)

568

Capítulo 10 – Utilizando Componentes do IIS

onde URL é uma seqüência de caracteres especificando o local do arquivo .asp a ser executado. Se um caminho absoluto for especificado para esse parâmetro, então, ele deverá ser para um arquivo .asp dentro do mesmo espaço do aplicativo, isto é, dentro da mesma pasta virtual que representa o aplicativo. O método Server.Execute fornece uma maneira de dividir um aplicativo complexo em módulos individuais. Empregando este método, você pode desenvolver uma biblioteca de arquivos .asp que pode ser chamada quando necessário. Esse enfoque é uma alternativa para inclusões do lado do servidor, utilizando a diretiva #include. Depois que o IIS processa o arquivo .asp especificado no parâmetro url de Server.Execute, a resposta é retornada ao script ASP que fez a chamada. O arquivo .asp executado pode modificar cabeçalhos HTTP. No entanto, como em qualquer arquivo .asp, se o mesmo tentar modificar os cabeçalhos HTTP depois que enviar uma resposta para o cliente, gerará um erro. O parâmetro url pode ser referente a um caminho absoluto ou relativo. Se o caminho for absoluto, ele deverá mapear para um script ASP no mesmo aplicativo do arquivo ASP que fez a chamada. O parâmetro caminho pode conter uma seqüência de caracteres de consulta.

Exemplo O exemplo a seguir demonstra a execução de um arquivo .asp que retorna algum texto. No arquivo chamador.asp temos uma chamada do método Execute para o arquivo chamado.asp. Ao encontrar esta chamada, a execução desloca-se para o arquivo chamado.asp, o qual é executado. Ao encerrar a execução do arquivo chamado.asp, a execução continua no arquivo chamador.asp, com a linha seguinte a que utilizou o método Execute. Listagem 10.1 – Arquivo que utiliza o método Execute – chamador.asp. 1

<HTML>

<BODY>

Response.Write “A próxima linha utiliza o método Execute para chamar chamado.asp <BR>”

Server.Execute(“chamado.asp”)

Response.Write “O arquivo chamado.asp já foi executado”

Response.Write “Estamos de volta ao arquivo chamador.asp”

</BODY>

</HTML>

569

Criando Sites Dinâmicos com ASP 3.0

Listagem 10.2 – Arquivo chamado pelo método Execute – chamado.asp. 1

<HTML>

<BODY>

Response.Write “<HR>”

Response.Write “Executando o arquivo chamado.asp........”

Response.Write “<HR>”

</BODY>

</HTML>

Ao carregarmos o arquivo chamador.asp, obtemos o resultado indicado na Figura 10.2.

Figura 10.2: Resultado da utilização do método Execute.

O Método GetLastError( ) O método GetLastError retorna um objeto do tipo ASPError que descreve a condição de erro que ocorreu. Esse método só está disponível antes do arquivo .asp ter enviado algum conteúdo para o cliente. Sintaxe Server.GetLastError ()

570

Capítulo 10 – Utilizando Componentes do IIS

NOTA Votaremos a estudar este método, com maiores detalhes, no Capítulo 11, sobre tratamentos de erro em páginas ASP.

O Método URLEncode(“texto”) Passamos uma String como parâmetro para o método URLEncode. Por exemplo, posso passar o meu nome como argumento: Júlio Cesar Fabris Battisti

O método URLEncode converte os caracteres especiais, tais como letras acentuadas, espaços em brancos e outros sinais que não são caracteres válidos para fazerem parte de uma URL, nos equivalentes que são válidos. O meu nome seria convertido da seguinte maneira: J%FAlio+Cesar+Fabris+Battisti

Observe que o ú (que não é um caractere válido para fazer parte de uma URL) foi substituído por %FA (caractere válido para fazer parte de uma URL) e cada espaço em branco foi substituído por um sinal de +. Podemos notar esta substituição, claramente, quando os dados que preenchemos em um formulário são enviados através do método get. Conforme descrito anteriormente neste livro, no método get as informações que foram digitadas em um formulário, são enviadas junto com a URL da página que está sendo chamada. Para capturar estes dados, precisamos utilizar o método QueryString do objeto Request – Request.QueryString (“NomeDoCampo”). Mais adiante estaremos apresentando um exemplo prático que fará uso do método URLEncode e também do Método HTMLEncode, que veremos ainda neste item. Outros exemplos de conversão feitas pelo método URLEncode: Orlando Fração

é convertido para

Orlando+Fra%E7%E3o

Urlândia Alta

é convertido para

Url%E2ndia+Alta

Boqueirão do Leão

é convertido para

Boqueir%E3o+do+Le%E3o

José da Silva

é convertido para

Jos%E9+da+Silva

Normalmente utilizamos o método URLEncode para converter um valor de texto normal em um valor codificado que deverá fazer parte de uma URL. Os dados enviados na URL podem ser recuperados por uma página ASP através do método Request.QueryString e utilizados para pesquisar um banco de dados e retornar um determinado resultado.

571

Criando Sites Dinâmicos com ASP 3.0

Considere o exemplo a seguir, onde temos uma URL bastante longa, a qual é resultado do envio dos dados que foram preenchidos em um formulário, utilizando o método get ao invés do método post: http://servidor/capitulo10/cadastro.asp?nome=Jos%E9+da+Silva& rua=Orlando+Fra%E7%E3o&bairro=Url%E2ndia+Alta&cidade=Boqueir%E3o+do+Le%E3o& cep=97050-010&fone=2225211&fax=2226502&cartaotipo=Visa&enviar=Enviar+dados.

Observe que os dados preenchidos no formulário são enviados junto com a URL no formato de pares e codificados de tal maneira que os caracteres especiais são convertidos em seus equivalentes. Por exemplo, observe o seguinte trecho da URL: nome=Jos%E9+da+Silva

Este trecho está indicando que o campo nome foi preenchido com o valor José da Silva. Lembre que cada espaço é substituído por um sinal de + e o “é” foi substituído por seu equivalente válido para fazer parte de uma URL – %E9. No trecho de código a seguir, temos um exemplo dos resultados obtidos com a utilização de Request.QueryString: <% Response.Write Request.QueryString(“nome”)

& “<BR>”

Response.Write Request.QueryString(“rua”)

& “<BR>”

Response.Write Request.QueryString(“bairro”)

& “<BR>”

Response.Write Request.QueryString(“cidade”)

& “<BR>”

Response.Write Request.QueryString(“cep”)

& “<BR>”

Response.Write Request.QueryString(“fone”)

& “<BR>”

Response.Write Request.QueryString(“fax”)

& “<BR>”

Response.Write Request.QueryString(“cartao”)

& “<BR>”

Este trecho de código retornaria o seguinte resultado: José da Silva Orlando Fração Urlândia Alta Boqueirão do Leão 97050-010 2225211 2226502 Visa

Observe que o método QueryString decodifica os valores especiais de volta para os valores originais. Por exemplo, o %E9 é substituído de volta para o original “é”.

572

Capítulo 10 – Utilizando Componentes do IIS

O Método MapPath(“url”) O método MapPath(“url”) retorna o caminho físico no servidor, correspondente a URL passada como parâmetro. Um caminho físico é um caminho do tipo: D:\Inetpub\wwwroot\Capitulo10. O parâmetro URL especifica o caminho relativo ou virtual a ser mapeado para um diretório físico. Se Caminho iniciar com uma barra simples (/) ou invertida (\), o método MapPath retornará o caminho como se fosse um virtual completo. Se Caminho não iniciar com uma barra, o método MapPath retornará um caminho relativo ao diretório do arquivo .asp que está sendo processado. Na Listagem 10.3, temos um exemplo de utilização do método MapPath. Listagem 10.3 – Utilizando o método MapPath – exmap.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

<TITLE>Utilizando o método MapPath.</TITLE>

</HEAD>

<BODY>

<HR>

Response.Write Server.MapPath(“/”) & “<BR>”

Response.Write Server.MapPath(“Capitulo6”) & “<BR>”

Response.Write Server.MapPath(“/Capitulo10”) & “<BR>”

Response.Write Server.MapPath(“/Capitulo10/exmap.asp”) & “<BR>”

Response.Write Server.MapPath(“/iishelp”) & “<BR>”

Response.Write Server.MapPath(“\”) & “<BR>”

<HR>

</BODY>

</HTML>

Na Figura 10.3 temos o resultado da página da Listagem 10.3 quando carregada no Internet Explorer.

573

Criando Sites Dinâmicos com ASP 3.0

Figura 10.3: Resultado da utilização do método Server.MapPath. Observe que tanto a barra normal (/), quanto a barra invertida (\) podem ser utilizadas como parâmetro para que o método MapPath retorne o caminho físico para o diretório raiz do servidor IIS.

NOTA O método MapPath não verifica se o caminho que ele retorna é válido ou existe no servidor. Ele apenas retorna qual seria o caminho físico para o endereço relativo que foi passado. O método faz esta determinação com base no caminho físico do diretório raiz.

IMPORTANTE Não podemos utilizar o método MapPath nos eventos Application_OnEnd e Session_OnEnd.

O Método Transfer(“url”) O método Transfer(“url”) pára a execução da página atual, e transfere a execução para a página especificada no parâmetro URL. Caso tenham sido definidas informações para o objeto Session ou informações de transação, as mesmas serão transferidas para a nova página. Porém, o método Transfer(“url”), após finalizar a execução da página que foi chamada, não retorna o controle para a página original, como acontece no método Execute.

574

Capítulo 10 – Utilizando Componentes do IIS

Quando você chama Server.Transfer, as informações sobre o estado de todos os objetos incorporados são incluídas na transferência. Isso significa que todas as variáveis ou objetos aos quais foi atribuído um valor no escopo da sessão ou do aplicativo serão mantidos. Além disso, todos os conteúdos atuais das coleções Request estarão disponíveis para o arquivo .asp que está recebendo a transferência. Se o caminho que você especificar no parâmetro URL for de um arquivo .asp em outro aplicativo, o arquivo .asp será executado como se estivesse no aplicativo que contém o comando Server.Transfer. Em outras palavras, todas as variáveis e objetos, aos quais foram dados escopo de aplicativo por outros arquivos .asp no aplicativo, ou pelo arquivo global.asa do aplicativo, estarão disponíveis para o arquivo .asp chamado. A seguir temos alguns exemplos de código para o método Transfer: <% Server.Transfer(“outra.asp”) %>

ou podemos também utilizar: <% Server.Transfer(“/Capitulo10/outra.asp”) %>

O Método HTMLEncode(“texto”) O método HTMLEncode converte os caracteres especiais do texto, passado como parâmetro, para caracteres reconhecidos no código HTML. Considere os exemplos: á

é substituído por

&aacute;

é substituído por

&eacute;

é substituído por

&iacute;

é substituído por

&oacute;

é substituído por

&uacute;

é substituído por

&gt;

é substituído por

&lt;

é substituído por

&amp;

e assim por diante.

575

Criando Sites Dinâmicos com ASP 3.0

Um Exemplo Prático de Utilização do Objeto Server Neste item vamos propor a solução para o seguinte problema:

PROBLEMA Vamos criar um exemplo que faz conexão com o banco de dados nwind.mdb. No nosso exemplo, será apresentada uma página – principal.asp – na qual o usuário selecionará o nome de um país em uma lista de países. Esta lista de países será montada, dinamicamente, a partir da tabela Customers, de tal maneira que somente sejam exibidos os países para os quais existem clientes cadastrados. Além disso a listagem será classificada em ordem alfabética. Após selecionar o país, o usuário clica em um botão Pesquisar. Com isso será retornada uma lista, em forma de tabela, com todos os Clientes para o País selecionado – página listaclientes.asp. O nome do Cliente será um link, que ao ser clicado abrirá uma página com as informações sobre o mesmo – página cliente.asp. Para construir esta página teremos que utilizar alguns métodos do objeto Server.

Na Listagem 10.4, temos o código para a construção da página principal.asp. Listagem 10.4 – Criando, dinamicamente, uma lista de países – principal.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<TITLE>Gera uma lista de Países dinamicamente.</TITLE>

<BODY>

‘O primeiro passo é criar a conexão com o banco de dados.

‘Para isto crio um objeto do tipo Connection.

‘Cria um objeto do tipo ADODB.Connection

Set conn=Server.CreateObject(“ADODB.Connection”)

‘Agora abro uma conexão com o arquivo nwind.mdb

‘utilizando OLE DB.

conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0; DATA SOURCE=c:\meus documentos\nwind.mdb”

576

Capítulo 10 – Utilizando Componentes do IIS

conn.Open

‘Agora criamos um objeto RecordSet para reapresentar

‘a lista de países.

Set Paises = Server.CreateObject(“ADODB.Recordset”)

19 Paises.Open “Select ShipCountry from Orders Group By ShipCountry Order By ShipCountry”, conn, 3, 3 20

‘Exibo a lista de países.

<P><B>Selecione um país na lista de países.</B></P>

<P><B><I>Depois clique no botão Pesquisar.</I></B></P>

‘Agora construo a lista de opções a partir dos

‘dados obtidos da tabela Orders.

‘Para cada país obtido, crio uma nova opção

‘na lista.

Do While Not Paises.EOF

Response.Write “<OPTION value=” & Chr(34) & Paises.Fields(“ShipCountry”) & Chr(34)

If Paises.Fields(“ShipCountry”)= Request.Form(“listapaises”) Then

Response.Write “SELECTED”

End If

Response.Write “>” & Paises.Fields(“ShipCountry”)& “</OPTION>”

Paises.MoveNext

Loop

</SELECT>

577

Criando Sites Dinâmicos com ASP 3.0

<HR>

</FORM>

</BODY>

</HTML>

A Listagem 10.4 dispensa maiores comentários. Já analisamos diversos exemplos semelhantes no Capítulo 7. Agora precisamos criar a página listaclientes.asp. Está página deverá fazer o seguinte: ➥ Receber o valor do país selecionado na lista. ➥ Criar um RecordSet com todos os Clientes para o país selecionado. ➥ Na hora de exibir os resultados, transformar o nome do funcionário em um link que, ao ser clicado, chama a página cliente.asp. No próprio link será passado o Código do Cliente junto com a URL. Este código será utilizado, pela página cliente.asp, para localizar o registro do Cliente na tabela Customers. ➥ Para construir este link, utilizaremos o método URLEncode. Na Listagem 10.5, temos o código para a construção da página listaclientes.asp. Listagem 10.5 – Retornando a lista de clientes para o país selecionado – listaclientes.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<TITLE>Lista de Clientes para o País selecionado.</TITLE>

<BODY>

‘O primeiro passo é criar a conexão com o banco de dados.

‘Para isto crio um objeto do tipo Connection.

‘Cria um objeto do tipo ADODB.Connection

Set conn=Server.CreateObject(“ADODB.Connection”)

‘Agora abro uma conexão com o arquivo nwind.mdb

‘utilizando OLE DB.

578

Capítulo 10 – Utilizando Componentes do IIS

conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0;

conn.Open

‘Agora criamos um objeto RecordSet para reapresentar

‘a lista de países.

Set Clientes = Server.CreateObject(“ADODB.Recordset”)

DATA SOURCE=c:\meus documentos\nwind.mdb”

19 Clientes.Open “Select * from Customers where Country=’” & Request.Form(“listapaises”) & “‘ Order By CompanyName”, conn, 3, 3 20

‘Exibo a lista de Clientes e o País.

<HR>

<B>Lista de Clientes para:

<% =Request.Form(“listapaises”) %>

<HR>

<TR>

<TD><B>Nome do Cliente</B></TD>

</TR>

Clientes.MoveFirst

Do Until Clientes.EOF

<TR>

<TD>

<P>

<A HREF=“http://servidor/Capitulo10/cliente.asp?Codigo=<%

579

Criando Sites Dinâmicos com ASP 3.0

=server.URLEncode(Clientes.Fields(“CustomerID”))%>”> <%=Clientes.Fields(“CompanyName”)%> 40

</A>

</FONT>

</TD>

</TD>

</TR>

Clientes.MoveNext

Loop

</TABLE>

<HR>

</BODY>

</HTML>

O que temos de especial na página listaclientes.asp é o seguinte trecho de código: 36

<TD>

<P>

</A>

</FONT>

</TD>

Neste trecho estamos montando a primeira coluna da tabela. Utilizamos a tag HTML <A HREF=> </A> para construir um link. Dentro deste link, construímos a seguinte URL: http://servidor/capitulo10/cliente.asp?Codigo=

Depois utilizamos o seguinte código ASP: <% =server.URLEncode(Clientes.Fields(“CustomerID”))%>

580

Capítulo 10 – Utilizando Componentes do IIS

Este código passa o campo CustomerID como parâmetro para o método URLEncode, o qual irá converter qualquer caractere não permitido em uma URL para o equivalente permitido, conforme descrito anteriormente. Vamos supor que o código do clientes seja JSILVA. Neste ponto o nosso link estará assim: http://servidor/capitulo10/cliente.asp?Codigo=JSILVA

Depois utilizamos o seguinte código ASP: <%=Clientes.Fields(“CompanyName”)%>

Este código simplesmente exibirá o Nome do Cliente, que é o texto que aparecerá como texto do link. Observe que montamos o link de tal forma que o parâmetro que será passado na URL é o Código do Cliente (CustomerID), porém o texto que será exibido na página é o Nome do Cliente (CompanyName). Estamos passando o Código do Cliente como parâmetro, porque este campo é uma chave primária e, portanto, não existirão dois clientes com o mesmo código. Porém, existe a possibilidade de existirem dois clientes com o mesmo nome. Com isso montamos, facilmente, um link no nome de cada cliente. Quando o usuário clicar no nome do cliente, será passado, juntamente com a URL o Código do Cliente como parâmetro de pesquisa para a página cliente.asp. O passo final da nossa aplicação é construir a página cliente.asp e depois testar o funcionamento da mesma. Na Listagem 10.6, temos o código para a construção da página cliente.asp. Listagem 10.6 – Localizando o registro do cliente. – cliente.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

<TITLE>Lista para o Cliente <% = Request.QueryString(“Codigo”) %> !!</TITLE>

</HEAD>

<BODY>

‘O primeiro passo é criar a conexão com o Banco de dados.

‘Para isto crio um objeto do tipo Connection.

‘Cria um objeto do tipo ADODB.Connection

Set conn=Server.CreateObject(“ADODB.Connection”)

‘Agora abro uma conexão com o arquivo nwind.mdb

581

Criando Sites Dinâmicos com ASP 3.0

‘utilizando OLE DB.

conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0;

conn.Open

‘Agora criamos um objeto RecordSet para reapresentar

DATA SOURCE=c:\meus documentos\nwind.mdb”

‘o Cliente. 17

Set Cliente = Server.CreateObject(“ADODB.Recordset”) Cliente.Open “Select * from Customers where CustomerID=’” & Request.QueryString(“codigo”) & “‘“, conn, 3, 3

‘Exibo os dados do Cliente.

<HR>

<B>REGISTRO PARA O CLIENTE:</B>

<% =Cliente.Fields(“CompanyName”)%>

<HR>

<A HREF=“principal.asp”>Clique aqui para selecionar outro país.</A>

<HR>

<TR>

28 29

<TD>Código do Cliente:</TD> <TD><B><% =Cliente.Fields(“CustomerID”)%></B></TD>

</TR>

<TR>

<TD>Nome do Cliente:</TD>

</TR>

<TR>

<TD>

Contato:</TD>

582

Capítulo 10 – Utilizando Componentes do IIS

</TR>

<TR>

<TD>

</TR>

<TR>

44 45

<TD>

Endereço:</TD>

Cidade:

</TD>

</TR>

<TR>

<TD>

</TR>

<TR>

CEP:</TD>

<TD>

</TR>

<TR>

Fone:</TD>

<TD>

</TR>

<TR>

60 61

<TD>

Fax:</TD>

País:</TD>

</TR>

<HR>

64 </TABLE> 65

</BODY>

</HTML>

583

Criando Sites Dinâmicos com ASP 3.0

Observe que utilizamos código ASP na tag <TITLE></TITLE>, o que é possível, sem maiores problemas. Outro detalhe a ser observado é que utilizamos o método Request.QueryString. Isto foi feito, porque o Código do Cliente foi passado na própria URL. É como se estivéssemos utilizando o método get da tag <FORM>. Por isso, para recuperar o valor passado como parâmetro, precisamos utilizar o método Request.QueryString ao invés de Request.Form. Agora vamos ver a nossa aplicação em funcionamento. Na Figura 10.4 vemos que foi carregada a página principal.asp e o usuário selecionou Argentina na lista de países.

Figura 10.4: O usuário selecionou Argentina na lista de países. Ao clicar no botão Pesquisar é chamada a página listaclientes.asp, a qual exibe uma listagem com todos os Clientes da Argentina, conforme mostrado na Figura 10.5. Observe que o nome de cada Cliente é um link. Se clicarmos no nome do cliente, será chamada a página cliente.asp e será passado, na própria URL, o código do cliente. Com isso são exibidos os dados do Cliente. Na Figura 10.6, temos o exemplo para o caso em que o usuário clicou no link para o cliente Rancho Grande. Observe no campo endereço, que temos a seguinte URL: http://servidor/Capitulo10/cliente.asp?Codigo=RANCH

584

Capítulo 10 – Utilizando Componentes do IIS

Figura 10.5: A listagem dos clientes da Argentina.

Figura 10.6: Dados do cliente Rancho Grande. O Código do Cliente foi “passado” na própria URL. O usuário pode clicar no link Clique aqui para selecionar outro país, para voltar à página principal.asp e fazer uma nova pesquisa. O usuário também pode clicar no botão Voltar do

585

Criando Sites Dinâmicos com ASP 3.0

próprio navegador, para retornar à página listaclientes.asp, com a lista de Clientes da Argentina e clicar em um outro Cliente para ver os dados do mesmo. Com este exemplo prático, encerramos o estudo do objeto Server. Nos próximos itens aprenderemos a utilizar alguns componentes que são fornecidos juntamente com o IIS.

Utilizando Componentes do Servidor em Páginas ASP Agora passaremos ao estudo de diversos componentes que fazem parte da instalação básica do IIS, ou seja, ao instalarmos o IIS os mesmos já estão disponíveis para serem utilizados. Vamos estudar os chamados Active Server Componnents. São componentes que executam no servidor IIS, retornando um determinado resultado para a página ASP, que os utiliza, ou efetuando uma determinada operação. Nós já utilizamos diversos componentes, principalmente ao conectar com banco de dados, utilizando ADO – Acivex Data Objects. ADO nada mais é do que uma biblioteca de componentes, especialmente projetada para possibilitar o acesso a fontes diversas de dados, tanto através de OLE DB quanto de ODBC. Além dos componentes que já são fornecidos com o IIS e o Windows 2000, podem ser adquiridos componentes de empresas desenvolvedoras de software. Existe uma infinidade de componentes disponíveis na Internet, inclusive, gratuitos. Quando adquirimos um componente, junto com o mesmo recebemos a documentação sobre como instalar, quais os métodos, propriedades, eventos e coleções que o mesmo disponibiliza. A partir do momento que o componente foi instalado, o mesmo pode ser utilizado em qualquer página ASP do servidor onde foi instalado. Os componentes desenvolvidos para serem utilizados por páginas ASP, no servidor IIS, devem seguir o padrão COM (e no Windows 2000, o COM+). Estes componentes podem ser criados utilizando-se ambientes de desenvolvimento como o Microsoft Visual Basic 6.0 ou o Microsoft Visual C 6.0. Vamos aprender a utilizar os principais componentes disponibilizados pelo IIS.

O Componente Content Link Este componente é utilizado para auxiliar no gerenciamento de links para uma série de documentos, sendo de grande utilidade na criação de estruturas de navegação. Por exemplo, vamos supor que você tenha uma pasta virtual onde será publicado um manual de procedimentos para a seção onde você trabalha. Ao publicar este manual, você gostaria que, junto com cada

586

Capítulo 10 – Utilizando Componentes do IIS

página, fosse exibido uma lista de links, de forma que o usuário pudesse se deslocar para uma parte específica do manual e também uma barra de navegação com links para o próximo documento, o documento anterior, para o primeiro documento e para o último documento. Obviamente que esta estrutura de navegação pode ser criada manualmente. Porém pequenas modificações como a inserção ou inclusão de páginas, farão com que toda a estrutura de navegação tenha que ser alterada. Para facilitar a criação de uma estrutura de navegação deste tipo, podemos utilizar o componente Content Link. O objeto Content Link é fornecido através da DLL Nextlink.dll, a qual encontra-se, normalmente, na pasta \winnt\system32\inetsrv, do drive onde está instalado o Windows 2000. A sintaxe para criar um objeto do tipo Content Link é a seguinte: Set meu_objeto = Server.CreateObject(“MSWC.Nextlink”)

onde MSWC.Nextlink é a identificação com que o objeto Content Link foi registrado. Para salientar a utilização do componente Content Link, vamos criar um exemplo onde temos um manual com cinco capítulos, além da Introdução. Queremos utilizar o componente Content Link para exibir, em todas as páginas do manual, um índice com links para a Introdução e para os cinco capítulos; e no final e início de cada documento, uma barra de navegação com links para o próximo, anterior, primeiro e o último documento. Os documentos para o nosso exemplo serão os indicados na Tabela 10.1. Tabela 10.1 Documentos para o nosso manual de exemplo. Documento

Descrição

intro.asp

Página de abertura e Introdução do manual.

cap1.asp

Capítulo 1 do manual de exemplo.

cap2.asp

Capítulo 2 do manual de exemplo.

cap3.asp

Capítulo 3 do manual de exemplo.

cap4.asp

Capítulo 4 do manual de exemplo.

cap5.asp

Capítulo 5 do manual de exemplo.

O componente Content Link trabalha em conjunto com um arquivo de texto, o qual é conhecido como “Lista de conteúdo”. Neste arquivo de texto cada linha representa um documento que fará parte da Lista de conteúdo. Cada linha possui o seguinte formato: URL-Página

Descrição

Comentário

Cada um dos elementos deve ser separado do anterior por uma tabulação.

587

Criando Sites Dinâmicos com ASP 3.0

Este arquivo, além de descrever quais os documentos que farão parte da Lista de conteúdo, também define a ordem do documento nesta lista. Por exemplo, se estamos no arquivo cap3.asp e clicamos no link próximo, será carregada a página cap4.asp. Esta seqüência é definida pela ordem das linhas no arquivo que contém a Lista de conteúdo. Para o nosso exemplo, teremos o seguinte arquivo de texto – conteudo.txt: intro.asp

Introdução

Página inicial do manual e introdução

cap1.asp

Capítulo 1

Capítulo 1 do Manual

cap2.asp

Capítulo 2

Capítulo 2 do Manual

cap3.asp

Capítulo 3

Capítulo 3 do Manual

cap4.asp

Capítulo 4

Capítulo 4 do Manual

cap5.asp

Capítulo 5

Capítulo 5 do Manual

Chamaremos este arquivo de conteudo.txt, o qual será salvo na mesma pasta que os demais arquivos. Uma vez criado o objeto, o próximo passo é definir qual o arquivo de texto que será utilizado pelo componente Content Link. A etapa final é utilizar os métodos do objeto Content Link para criar a estrutura dinâmica de navegação. Antes de criarmos o nosso exemplo, vamos aprender a criar um objeto associado a um componente do tipo Content Link. Também vamos estudar os métodos deste componente.

Criando um Objeto do Tipo Content Link Para criarmos um objeto do tipo Content Link, utilizamos a seguinte sintaxe: Set conteudo=Server.CreateObject(“MSWC.Nextlink”)

Métodos do Objeto Content Link Vamos fazer um estudo de cada um dos métodos do objeto Content Link. ➥ O método GetListCount: Este método retorna um número inteiro, o qual indica o número de páginas listadas no arquivo de conteúdo que é passado como parâmetro.

588

Capítulo 10 – Utilizando Componentes do IIS

A sintaxe para este método é a seguinte: Response.Write conteudo.GetListCount(“conteudo.txt”)

No nosso exemplo, como o arquivo conteudo.txt possui seis linhas, este comando irá retornar o valor 6. É importante saber o número total de páginas na Lista de conteúdo, para que a estrutura de navegação possa ser criada corretamente. A contagem dos elementos inicia com 1, e não zero como no caso de outros elementos. Assim, o primeiro elemento é o de índice 1, o segundo é o de índice 2 e assim por diante. Se o arquivo passado como parâmetro não for encontrado, o método GetListCount irá retornar 0. ➥ O método GetListIndex: Este método retorna o número do índice do elemento atual no arquivo de conteúdo. A cada momento somente existe um item que é o atual. Podemos alterar o item atual utilizando os métodos GetNextURL e GetPreviousURL, que estudaremos mais adiante. Isto é semelhante ao conceito de registro corrente de um objeto RecordSet e à utilização dos métodos MoveNext e MovePrevious do objeto RecordSet. O método retorna 0 se a página atual não estiver incluída no arquivo de conteúdo. A sintaxe para este método é a seguinte: Response.Write conteudo.GetListIndex(“conteudo.txt”)

Este comando retorna o valor do índice do elemento atual. Utilizando os métodos GetListCount e GetListIndex, podemos criar estruturas de navegação bastante interessantes. Por exemplo, se estivermos na última página de uma Lista de conteúdo, podemos fazer com que o link Próxima não seja exibido. Para fazer isso é só detectar se o índice atual é igual ao valor retornado por GetListCount (número total de páginas). O código da Listagem 10.7 ilustra como detectar se a página atual é a última da lista de conteúdo. Na Listagem 10.7, uma preliminar da página intro.asp. Listagem 10.7 – Utilizando os métodos GetListCount e GetListIndex. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

<TITLE> Utilizando o componente Content Link</TITLE>

</HEAD>

<BODY>

‘O primeiro passo é criar um objeto do tipo MSWC.Nextlink

Set conteudo=Server.CreateObject(“MSWC.Nextlink”)

589

Criando Sites Dinâmicos com ASP 3.0

Response.Write “Número total de páginas:” & conteudo.GetListCount(“conteudo.txt”) & “<BR>”

ultimo = conteudo.GetListCount(“conteudo.txt”)

atual = conteudo.GetListIndex(“conteudo.txt”)

If atual=ultimo Then

15 16

Response.Write “A última página é a página atual.” Else

Response.Write “A página atual é: ” & atual

End If

</BODY>

</HTML>

➥ O método GetNextUrl: Esse método retorna a URL do próximo item especificada no arquivo de conteúdo. Se a página atual não estiver especificada no arquivo de conteúdo, o método GetNextURL retornará a URL da última página da lista. Por exemplo, se você estiver na página cap3.asp do nosso exemplo, o método GetNextURL(“conteudo.txt”) irá retornar cap4.asp, que é a próxima página, na linha logo abaixo da linha de cap3.asp. A sintaxe para este método é a seguinte: conteudo.GetNextURL(“conteudo.txt”)

onde o único parâmetro a ser passado é o arquivo de conteúdo. ➥ O método GetNextDescription: Esse método retorna a descrição do próximo item do arquivo de conteúdo. Se a página atual não estiver especificada no arquivo de conteúdo, o método GetNextDescription retornará a descrição da última página da lista. A sintaxe para este método é a seguinte: conteudo.GetNextDescription(“conteudo.txt”)

onde o único parâmetro a ser passado é o arquivo de conteúdo. ➥ O método GetNthDescription: Esse método retorna a descrição do enésimo item do arquivo de conteúdo. A sintaxe para este método é a seguinte: conteudo.GetNthDescription(“conteudo.txt”,3)

590

Capítulo 10 – Utilizando Componentes do IIS

onde os parâmetros a serem passados são o arquivo de conteúdo e o índice do elemento cuja descrição deve ser retornada. ➥ O método GetNthUrl: Esse método retorna a URL do enésimo item, especificada no arquivo de conteúdo. A sintaxe para este método é a seguinte: conteudo.GetNthURL(“conteudo.txt”,3)

onde os parâmetros a serem passados são o arquivo de conteúdo e o índice do elemento cuja URL deve ser retornada. ➥ O método GetPreviousURL: Esse método retorna a URL do item anterior ao atual, especificada no arquivo de conteúdo. Se a página atual não estiver especificada, o método GetPreviousURL retornará a URL da primeira página da lista. Por exemplo, se você estiver na página cap3.asp do nosso exemplo, o método GetPreviousURL (“conteudo.txt”) irá retornar cap2.asp, que é a página anterior a cap3.asp, na linha logo acima da linha de cap3.asp. A sintaxe para este método é a seguinte: conteudo.GetPreviousURL(“conteudo.txt”)

onde o único parâmetro a ser passado é o arquivo de conteúdo. ➥ O método GetPreviousDescription: Esse método retorna a descrição do item anterior ao atual, especificado no arquivo de conteúdo. Se a página atual não estiver especificada no arquivo de conteúdo, o método GetPreviousDescription retornará a descrição da primeira página da lista. A sintaxe para este método é a seguinte: conteudo.GetPreviousDescription(“conteudo.txt”)

onde o único parâmetro a ser passado é o arquivo de conteúdo.

Um Exemplo que Utiliza o Componente Content Link Então, mãos à obra. Vamos criar o nosso exemplo proposto, passo a passo. Todas as nossas páginas terão a mesma estrutura. Na coluna da esquerda, teremos o menu de navegação (criado dinamicamente através da utilização dos métodos do objeto Content Link), e na parte superior e inferior da página teremos um menu com as opções de ir para a próxima, para a anterior, para a última ou para a primeira página. Na Listagem 10.8, temos a página inicial do manual intro.asp.

591

Criando Sites Dinâmicos com ASP 3.0

Listagem 10.8 – A página inicial do manual – intro.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

<TITLE> Utilizando o componente Content Link</TITLE>

</HEAD>

<BODY>

‘O primeiro passo é criar um objeto do tipo MSWC.Nextlink

Set conteudo=Server.CreateObject(“MSWC.Nextlink”)

ultimo = conteudo.GetListCount(“conteudo.txt”)

primeiro = 1

<% ‘Agora construo a barra de navegação do topo da página. %>

<TR>

<TD colSpan=2> <A HREF=“<%=conteudo.GetNthURL(“conteudo.txt”,primeiro)%>”>[Início]</A> <A HREF=“<%=conteudo.GetPreviousURL(“conteudo.txt”)%>”>[Anterior]</A> <A HREF=“<%=conteudo.GetNextURL(“conteudo.txt”)%>”>[Próxima]</A> <A HREF=“<%=conteudo.GetNthURL(“conteudo.txt”,ultimo)%>”>[Última]</A>

</TD>

</TR>

<% ‘Agora construímos o menu de navegação na coluna da esquerda %>

<TR>

592

Capítulo 10 – Utilizando Componentes do IIS

For i=1 to ultimo %>

28 29

</TD> <% ‘A próxima célula é a célula de conteúdo. %>

<P><B>MANUAL DE PROCEDIMENTOS PARA A SEÇÃO DE ATENDIMENTO.</B></P>

<HR>

<P><I>INTRODUÇÃO</I></P>

<HR>

<P>Aqui colocaríamos o conteúdo da Introdução.</P>

<HR>

</TD>

</TR>

<% ‘Agora construo a barra de navegação do topo da página.%>

<TR>

<A HREF=“<%=conteudo.GetNthURL(“conteudo.txt”,primeiro)%>”>[Início]</A>

<A HREF=“<%=conteudo.GetPreviousURL(“conteudo.txt”)%>”>[Anterior]</A>

<A HREF=“<%=conteudo.GetNextURL(“conteudo.txt”)%>”>[Próxima]</A>

<A HREF=“<%=conteudo.GetNthURL(“conteudo.txt”,ultimo)%>”>[Última]</A>

</TD>

</TR>

</TABLE>

</BODY>

</HTML>

593

Criando Sites Dinâmicos com ASP 3.0

Ao carregarmos a página intro.asp, no Internet Explorer, obtemos o resultado indicado na Figura 10.7.

Figura 10.7: A página intro.asp. Todos os links desta página foram construídos utilizando os métodos do objeto conteudo, o qual é uma instância de um componente Content Link. Observe o trecho de código a seguir, responsável pela criação do menu de navegação superior e inferior: 16

</TD>

Observe que utilizamos os métodos GetPreviousURL, GetNextURL e GetNthURL para retornar as respectivas URL a partir do arquivo de conteúdo. Por exemplo, estamos com a página intro.asp carregada. O método GetNextURL retornará a URL da linha seguinte à linha de intro.asp no arquivo de conteúdo. No nosso exemplo retornará cap1.asp, que é justamente a próxima página do nosso manual. Também fizemos uso de duas variáveis: primeiro contém o

594

Capítulo 10 – Utilizando Componentes do IIS

valor 1 para fazer referência à primeira URL do arquivo de conteúdo, e ultimo contém o valor retornado pelo método GetListCount, que é o índice da última URL. Outro detalhe importante a observar é o caso de estarmos na primeira ou na última página. Se estivermos na primeira página, o método GetPreviousURL retorna o endereço da última página. Se estivermos na última página, o método GetNextURL retorna o endereço da primeira página. Também gostaria de comentar a maneira como foi montado o menu de opções da coluna da esquerda. Neste caso, utilizamos um laço For, variando de 1 até último, para montar um menu com links para todas as páginas do arquivo de conteúdo. Você pode estar se perguntando: “Por que utilizar o componente Content Link, se poderia ter criado todos estes links manualmente”? A resposta é simples. O componente Content Link facilita a nossa vida quando precisamos inserir ou excluir páginas que não estão no início ou no fim do conteúdo. Vamos supor que precisássemos inserir uma nova página cap3.asp, de tal forma que a cap3.asp antiga passasse a ser cap4.asp, a cap4.asp antiga passasse a ser cap5.asp, e assim por diante. Se tivéssemos criado os links manualmente, teríamos que revisar todas as páginas e alterá-los. Se estivermos utilizando o componente Content Link, a única coisa que precisa ser feita é alterar o arquivo de conteúdo, inserindo a nova página na posição correta e renomear as demais, conforme indicado a seguir: intro.asp

Introdução

Página inicial do manual e introdução

cap1.asp

Capítulo 1

Capítulo 1 do Manual

cap2.asp

Capítulo 2

Capítulo 2 do Manual

cap3.asp

Capítulo 3

Capítulo 3 do Manual

cap4.asp

Capítulo 4

Capítulo 4 do Manual

cap5.asp

Capítulo 5

Capítulo 5 do Manual

cap6.asp

Capítulo 6

Capítulo 6 do Manual

e todos os links serão, automaticamente, recalculados. Pode parecer que não é vantagem utilizar o componente Content Link quando utilizamos um número pequeno de páginas, porém quando o número de páginas começa a crescer (eu diria cinco ou mais páginas) para uma determinada documentação, o componente Content Link é um auxiliar valioso. Na Figura 10.8, vemos o resultado quando o usuário carrega a página cap4.asp.

595

Criando Sites Dinâmicos com ASP 3.0

Figura 10.8: A página cap4.asp. Se você posicionar o mouse sobre os links, sem clicar, verá que os mesmos foram automaticamente recalculados. Por exemplo, o link [Próxima] aponta para cap5.asp, o link [Anterior] aponta para cap3.asp e assim por diante. As outras páginas do nosso manual somente irão diferir da página intro.asp no conteúdo que apresentam. Para isto basta inserir o conteúdo específico de cada página, a partir do seguinte parágrafo: 35

<P>Aqui colocaríamos o conteúdo da Introdução.</P>

Com isso encerramos o estudo do componente Content Link.

O Componente Ad Rotator O componente Ad Rotator permite que uma página ASP exiba um gráfico diferente a cada vez em que é carregada. Sempre que um usuário abre ou recarrega a página da Web, o componente Ad Rotator exibe um novo anúncio baseado nas informações especificadas em um arquivo de texto, conhecido como Arquivo de Programação de Rotatória. Neste arquivo estão as diversas informações necessárias para que o componente funcione corretamente.

596

Capítulo 10 – Utilizando Componentes do IIS

Este componente normalmente é utilizado para exibir imagens animadas que funcionam como anúncios e propaganda. Cada vez que o usuário carrega a página é exibido um anúncio diferente. Além disso, é possível registrar quantos usuários clicam em cada anúncio definindo o parâmetro URL no Arquivo de Programação de Rotatória para redirecionar os usuários para uma determinada página, quando o usuário clicar no anúncio. Quando especificamos esse parâmetro, cada salto para a URL de um anunciante é registrado nos logs de atividade do servidor Web. No Arquivo de Programação de Rotatória também podemos configurar uma determinada freqüência para cada um dos anúncios, de tal maneira que um anúncio apareça um número maior de vezes do que os outros. Desta forma estaríamos priorizando um ou mais anúncios em detrimento de outros. Para utilizar este componente necessitamos dos seguintes arquivos: ➥ adrot.dll: Este é o arquivo onde está implementada a funcionalidade do componente. Este arquivo encontra-se, normalmente, na pasta \winnt\system32\inetsrv, do drive onde está instalado o Windows 2000. ➥ Arquivo de Programação da Rotatória: Um arquivo de texto que contém informações sobre o arquivo e a programação de exibição de anúncios, tais como quais os anúncios que serão exibidos e qual o percentual de vezes, em relação ao total, que cada um deve ser exibido. Esse arquivo deve estar disponível em um caminho virtual do servidor da Web. ➥ Arquivo de Redirecionamento: Um arquivo opcional que implementa o redirecionamento e permite que o componente Rotatória de anúncios registre quantos usuários clicam em cada anúncio. Para criar um objeto do tipo Ad Rotator, podemos utilizar a seguinte sintaxe: Set nome_objeto = Server.CreateObject( “MSWC.AdRotator” )

onde MSWC.AdRotator é o nome com o qual o componente Ad Rotator foi registrado no servidor onde está instalado o IIS. Agora vamos conhecer um pouco mais sobre o Arquivo de Programação da Rotatória e o Arquivo de Redirecionamento.

O Arquivo de Programação da Rotatória O Arquivo de Programação de Rotatória contém informações que o componente Ad Rotator usa para gerenciar e exibir as várias imagens de anúncios. Podemos especificar os detalhes dos anúncios, como o tamanho do espaço do anúncio, arquivos de imagem a serem usados e porcentagem de tempo de exibição de cada arquivo.

597

Criando Sites Dinâmicos com ASP 3.0

O Arquivo de Programação de Rotatória tem duas seções. A primeira seção define parâmetros que se aplicam a todas as imagens de anúncios na programação de rotação. A segunda seção especifica as informações sobre o arquivo e a localização de cada anúncio individual e a porcentagem de tempo de exibição que cada anúncio deve receber. As duas seções são separadas por uma linha que contém somente um asterisco (*). Na primeira seção existem quatro parâmetros globais, cada um consistindo em uma palavrachave e um valor. Todos eles são opcionais. Se você não especificar valores para os parâmetros globais, o componente Ad Rotator usará os valores padrão. Nesse caso, a primeira linha do arquivo deve conter somente um asterisco (*). Sintaxe [REDIRECT URL] [WIDTH Largura] [HEIGHT Altura] [BORDER Borda] * URL_anúncio URL_home_page_anúncio Texto impressões

Vamos entender o que significa cada um destes parâmetros:

URL Especifica o caminho para o arquivo dynamic link library (.dll, biblioteca de link dinâmico) ou de aplicativo (.asp) que implementa o redirecionamento. Esse caminho pode ser especificado por completo (http://MyServer/MyDir/redirect.asp) ou em relação ao diretório virtual (/MyDir/redirect.asp).

Largura Especifica a largura do anúncio na página, em pixels. O padrão são 440 pixels.

Altura Especifica a altura do anúncio na página, em pixels. O padrão são 60 pixels.

598

Capítulo 10 – Utilizando Componentes do IIS

Borda Especifica a espessura da borda do link em torno do anúncio, em pixels. O padrão é uma borda de 1 pixel. Defina esse parâmetro para 0 para um link sem borda. Estes quatro primeiros parâmetros são opcionais e caso sejam definidos têm efeitos sobre todos os anúncios a serem exibidos. Caso um ou mais destes parâmetros não seja definido, serão utilizados os valores padrão. Mesmo que nenhum destes parâmetros seja definido, devemos colocar o * em uma linha, antes de iniciarmos a segunda seção do documento. A partir de agora veremos os parâmetros para a segunda seção do documento, após a linha com *. Estes parâmetros definem cada um dos anúncios a serem exibidos, individualmente.

URL_anúncio A localização do arquivo de imagem do anúncio. Por exemplo: images/anuncio1.gif.

URL_home_page_anúncio A localização da home page do anúncio, isto é, a página que será carregada se o usuário clicar no anúncio. Se o anúncio não tiver uma home page, coloque um hífen (-) nessa linha para indicar que não existe qualquer link para esse anúncio.

Texto Um texto alternativo exibido se o navegador não oferecer suporte a elementos gráficos ou se seus recursos gráficos estiverem desativados.

Impressões Um número entre 0 e 10000 que indica a densidade relativa do anúncio. Por exemplo, se um Arquivo de Programação de Rotatória contém três anúncios com o parâmetro impressões definido para 2, 3 e 5, o primeiro anúncio será exibido durante 20 % do tempo, o segundo, durante 30 % do tempo e o terceiro, durante 50 % do tempo. Se a soma dos parâmetros de impressão de todos os itens exceder 10000, será gerado um erro na primeira vez que o Arquivo de Programação de Rotatória for acessado por uma chamada do método GetAdvertisement.

599

Criando Sites Dinâmicos com ASP 3.0

Exemplo O script a seguir demonstra como você pode usar um Arquivo de Programação de Rotatória para exibir vários anúncios e como incluir um arquivo de redirecionamento. Capitulo10\rotatoria.txt WIDTH 236 HEIGHT 56 BORDER 4 * /capitulo10/imagens/anuncio1.gif Página do Anunciante 1 20 /capitulo10/imagens/anuncio2.gif http://servidor/capitulo10/anunciante2.htm Página do Anunciante 2 30 /capitulo10/imagens/anuncio3.gif http://servidor/capitulo10/anunciante3.htm Página do Anunciante 3 50

Observe que quando for exibido anuncio1.gif, o mesmo não será exibido como um link.

O Arquivo de Redirecionamento O Arquivo de Redirecionamento é um arquivo criado pelo desenvolvedor da aplicação Web. Ele inclui geralmente um script para a análise da seqüência de caracteres da solicitação pelo objeto Ad Rotator e para o redirecionamento do usuário para a URL associada ao anúncio no qual o usuário clicou. Você também pode incluir um script no Arquivo de Redirecionamento para contar o número de usuários que clicaram em um anúncio específico e salvar essas informações em um arquivo no servidor.

Exemplo O exemplo a seguir redireciona o usuário para a home page do anúncio.

600

Capítulo 10 – Utilizando Componentes do IIS

redireciona.asp <%

Response.Redirect(Request.QueryString(“url”)) %>

Observe que o parâmetro URL é passado no próprio link quando o usuário clica no anúncio. É por isso que estamos utilizando Request.QueryString. O nome do arquivo de imagem também é passado como parâmetro através da URL. Podemos utilizar este parâmetro para calcular o número de vezes que cada anúncio é clicado. No fragmento de código abaixo temos um exemplo de como calcular quantas vezes foram clicados cada um dos anúncios do nosso exemplo: ➥ anuncio1.gif ➥ anuncio2.gif ➥ anuncio3.gif Arquivo redireciona.asp que faz a contabilidade de cliques em cada anúncio: <% Select case Request.QueryString(“image”) Case “anuncio1.gif” count_anuncio1=count_anuncio1+1 Case “anuncio2.gif” count_anuncio2=count_anuncio2+1 Case “anuncio3.gif” count_anuncio3=count_anuncio3+1 End Select Código para salvar o valor do contador para cada anúncio no banco de dados ... Código para redirecionar para a página específica de cada anúncio ... %>

Onde temos “Código para salvar o valor do contador para cada anúncio no banco de dados”, poderíamos estabelecer uma conexão com um banco de dados e salvar o valor de cada contador no banco de dados, pois após a página de redirecionamento ter sido abandonada, os valores dos contadores seriam perdidos. Assim, salvando-os no banco de dados, podemos mantê-los, que é justamente o objetivo.

Propriedades do Objeto Ad Rotator Na Tabela 10.2, temos uma descrição das propriedades do objeto Ad Rotator.

601

Criando Sites Dinâmicos com ASP 3.0

Tabela 10.2 Propriedades do objeto Ad Rotator. Propriedade

Descrição

Border

Especifica o tamanho da borda em torno do anúncio. Para definir a borda utilizamos a sintaxe:objeto.border=tamanho. Onde tamanho especifica a espessura da borda que circunda o anúncio exibido. O padrão é o valor definido no cabeçalho do Arquivo de Programação de Rotatória. Ex: objeto.border = 2.

Clickable

Define se o anúncio será ou não um link para uma outra página. Pode ter os valores True ou False. A sintaxe para esta propriedade é a seguinte: objeto.clickable=true ou objeto.clickable=false.

TargetFrame

Esta propriedade especifica o nome do Frame onde deve ser carregado o anúncio. Utilizamos a seguinte sintaxe: objeto.TargetFrame=nome_do_frame.

Método do Objeto Ad Rotator É isto mesmo: método do objeto Ad Rotator, já que o mesmo só possui um método, o GetAdvertisement. O método GetAdvertisement recupera o próximo anúncio do arquivo de programação de rotatória. Sempre que o script é executado, ou quando um usuário abre ou atualiza uma página, o método recupera o próximo anúncio programado. Sintaxe: GetAdvertisement(arquivo de rotatória)

O único parâmetro para este método especifica o local do arquivo de programação de rotatória em relação ao diretório virtual. Por exemplo, se o caminho físico fosse C:\Inetpub\wwwroot\ Ads\Adrot.txt (no qual wwwroot é o diretório virtual “/”), você especificaria o caminho \Ads\ Adrot.txt. No nosso exemplo, temos a pasta Capitulo10 dentro da pasta wwwroot, a qual está localizada em E:\Inetpub\wwwroot\Capitulo10\rotatoria.txt. Vamos especificar \Capitulo10\ rotatoria.txt. Este método retorna o código HTML que exibe o anúncio na página atual. Vamos a um exemplo de utilização do componente Ad Rotator. Considere a página usaadrotator.asp da Listagem 10.9.

602

Capítulo 10 – Utilizando Componentes do IIS

Listagem 10.9 – Utilizando o componente Ad Rotator – usaadrotator.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<BODY>

‘ Cria um objeto do tipo AdRotator

Set conteudo=Server.CreateObject(“MSWC.AdRotator”)

conteudo.Clickable = True

<HR>

<P>Clique no Banner abaixo:</P>

<HR>

<% =conteudo.GetAdvertisement(“/Capitulo10/rotatoria.txt”)

<HR>

<P> Conteúdo da Página.</P>

</BODY>

</HTML>

Na Figura 10.9, vemos o resultado quando o usuário carrega a página usaadrotator.asp. Se o usuário atualizar a página, será carregado um anúncio diferente, conforme indicado na Figura 10.10. Os anúncios serão carregados na proporção definida no arquivo rotatoria.txt que é a seguinte: anuncio1.gif

20%

anuncio2.gif

30%

anuncio3.gif

50%

603

Criando Sites Dinâmicos com ASP 3.0

Figura 10.9: A página usaadrotator.asp.

Figura 10.10: Ao carregar a página foi exibido um anúnicio diferente. Assim, em metade das vezes que a página for acessada, será exibido o anúncio 3 (50%).

604

Capítulo 10 – Utilizando Componentes do IIS

O Componente Page Counter O componente Page Counter pode ser utilizado para contar quantas vezes uma determinada página é acessada pelos usuários. A informação sobre o número de acessos é salva em um arquivo de texto, de tal forma que quando o IIS é “parado” por algum motivo, a informação sobre o número de acessos não é perdida. O componente Page Counter cria um objeto PageCounter que conta e exibe o número de vezes em que uma página da Web foi aberta. A intervalos regulares, o objeto grava o número de acessos em um arquivo de texto para que, no caso de o servidor desligar, os dados não sejam perdidos. O componente Contador de página usa um objeto Central Management interno para registrar quantas vezes cada página do aplicativo foi aberta. Quando uma instância do objeto PageCounter é criada em uma página pelo método Server.CreateObject, o objeto recupera a contagem atual de acessos à página da Web especificada do objeto Central Management. Em seguida, o objeto pode ser manipulado com os métodos que expõe. O componente Contador de página usa os seguintes arquivos: ➥ Pagecnt.dll: Este é o arquivo onde está implementada a funcionalidade do componente. Este arquivo encontra-se, normalmente, na pasta \winnt\system32\inetsrv, do drive onde está instalado o Windows 2000. ➥ Arquivo Hit Count Data: Este é um arquivo de texto, onde periodicamente são salvas as informações sobre o número de acessos à página. Este arquivo é gerenciado pelo objeto Central Management, não sendo recomendada a edição desse arquivo, pois erros na formatação do mesmo não permitirão que o objeto PageCounter carregue apropriadamente as informações de contagem de acessos. Para criar um objeto Page Counter, utilizamos a seguinte sintaxe: Set nome_objeto = Server.CreateObject( “MSWC.PageCounter” )

onde nome_objeto especifica o nome do objeto PageCounter criado pela chamada do Server.CreateObject. O componente Contador de página cria entradas na Registry do Windows 2000. Ele adiciona a chave MSWC.PageCounter ao registro quando o objeto é compilado ou registrado. A chave é adicionada abaixo de HKEY_CLASSES_ROOT e contém os seguintes valores nomeados: ➥ File_Location: Uma seqüência de caracteres que especifica o caminho e o nome do arquivo Hit Count Data. O nome de arquivo padrão é Hitcnt.cnt. Esse arquivo está localizado em diretório \winnt\system32\inetsrv\Data. O ideal é deixar que o próprio IIS gerencie este arquivo.

605

Criando Sites Dinâmicos com ASP 3.0

➥ Save_Count: Um parâmetro, do tipo DWORD, que especifica o número de acessos antes que a contagem de acessos seja salva no arquivo Hit Count Data. Observe que esse número é o número total de acessos, não o número de acessos por página. O valor padrão é 25. Abaixo temos um exemplo de criação de um objeto do tipo Page Counter: <% Set contador = Server.CreateObject(“MSWC.PageCounter”) %>

Antes de apresentarmos um exemplo prático de utilização deste componente, vamos aprender a utilizar os métodos do mesmo.

Os Métodos do Componente Page Counter A seguir temos uma descrição dos métodos do objeto Page Counter. ➥ Método Hits: O método Hits retorna o número de vezes, que uma página da Web especificada, foi aberta. Utilizamos a seguinte sintaxe: nome_objecto.Hits( [Info_caminho] )

Considere o exemplo: contador.Hits(“/capitulo10/anuncio1.asp”)

NOTA O método Hits retorna um número do tipo LONG que indica o número de vezes que uma página da Web específica foi aberta. ➥ PageHit: O método PageHit incrementa em 1 a contagem de acessos à página da Web atual. Utilizamos a seguinte sintaxe: nome_objeto.PageHit( )

Considere o exemplo: contador.PageHit( )

➥ Reset: O método Reset define a contagem de acessos à uma página da Web especificada para 0.

606

Capítulo 10 – Utilizando Componentes do IIS

Utilizamos a seguinte sintaxe: nome_objeto.Reset([Info_caminho])

Veja o exemplo: contador.Reset(“/capitulo10/anuncio1.asp”)

Onde: Info_caminho é um parâmetro opcional que especifica o PATH_INFO da página da Web usando o formato /nome_do_diretório_virtual/nome_do_arquivo.asp. Se esse parâmetro não for especificado, a contagem de acessos para a página atual será redefinida. Vamos a um exemplo de utilização do componente Page Counter. Considere a página usapagecounter.asp da Listagem 10.10. Listagem 10.10 – Utilizando o componente Page Counter – usapagecounter.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

<TITLE>Página que usa o componente Page Counter.</TITLE>

</HEAD>

<BODY>

<HR>

<FONT color=#000080 size=6><B>Página da empresa ABC:</B></FONT>

‘ O primeiro passo é criar o objeto Page Counter.

Set contador=Server.CreateObject(“MSWC.PageCounter”)

<FONT color=#000080 size=6><B>Esta página já foi acessada:

contador.PageHit

Response.Write contador.Hits

If contador.Hits =1 Then

Response.Write “Vez”

607

Criando Sites Dinâmicos com ASP 3.0

Else

Response.Write “Vezes”

End If

</B></FONT>

<HR>

</BODY>

</HTML>

Na primeira vez que esta página for acessada, obteremos o resultado indicado na Figura 10.11.

Figura 10.11: O primeiro acesso à página usapagecounter.asp. Na segunda vez que a página for acessada o contador já estará em 2, conforme indicado na Figura 10.12, e assim sucessivamente.

Figura 10.12: O contador é incrementado a cada acesso à página.

608

Capítulo 10 – Utilizando Componentes do IIS

Na Figura 10.13, temos uma noção do arquivo hitcnt.cnt onde são armazenadas as informações sobre o número de acessos.

Figura 10.13: O arquivo \winnt\system32\inetsrv\Data\hitcnt.cnt.

O Componente Browser Capabilities – Capacidades do Navegador Um dos maiores problemas do desenvolvimento para a Web foi, e continua sendo, as diferenças entre os principais navegadores do mercado, notadamente o Internet Explorer e o Netscape Navigator. Diferente do ambiente Cliente/Servidor tradicional, onde podemos controlar o aplicativo que será instalado na máquina de cada cliente, quando desenvolvemos para a Internet não podemos exigir que o usuário esteja utilizando um navegador específico. Claro que é inviável desenvolver levando em consideração todos os navegadores existentes, porém, no mínimo precisamos criar aplicações Web que rodem sem problemas no Internet Explorer e no Netscape Navigator. Porém esta, realmente, não é uma tarefa simples. Apenas para ter uma idéia das dificuldades: ➥ Os Modelos de Objetos do Internet Explorer e do Netscape Navigator são diferentes. ➥ Existem, também, diferenças na implementação de DHTML e Java Script, que no Internet Explorer era conhecido como JScript, agora foi definido um “padrão conhecido com ECMA Script”, na tentativa de unificar a implementação dos dois principais navegadores. ➥ A maneira como as tags são interpretadas não é exatamente a mesma, podendo existir diferenças na apresentação das páginas. Isto significa que o desenvolvimento Web para a Internet é uma missão quase impossível? De maneira alguma, esta aí o sucesso da Internet e dos sites de Comércio Eletrônico para comprovar que o modelo Web já se estabeleceu e só tende a crescer. Para procurar resolver os problemas de compatibilidade entre os navegadores é que foi desenvolvido o componente Browser Capabilities. Com ele podemos detectar as diversas

609

Criando Sites Dinâmicos com ASP 3.0

capacidades do navegador do cliente, e com base nestas capacidades, carregar uma ou outra versão da página, específica para cada caso. O componente Browser Capabilities cria um objeto do tipo BrowserType, o qual disponibiliza para o script, uma descrição dos recursos do navegador da Web do cliente. Quando um navegador se conecta com o servidor Web, ele envia automaticamente um cabeçalho “Agente de usuário do HTTP”. Esse cabeçalho é uma seqüência de caracteres ASCII que identifica o navegador e seu número de versão. O objeto BrowserType compara o cabeçalho com entradas no arquivo Browscap.ini. Se ele encontrar uma correspondência, o objeto BrowserType assumirá as propriedades da listagem do navegador que correspondeu ao cabeçalho Agente de usuário. Se o objeto não encontrar uma correspondência para o cabeçalho no arquivo browscap.ini, ele procurará a correspondência mais próxima usando os curingas * e ?. Se não for possível encontrar uma correspondência usando os curingas, o objeto usará as configurações do navegador padrão, se elas tiverem sido especificadas no arquivo browscap.ini. Se o objeto não encontrar uma correspondência e as configurações do navegador padrão não tiverem sido especificadas no arquivo browscap.ini, o objeto definirá todas as propriedades para a seqüência de caracteres “UNKNOWN”. Você pode adicionar propriedades ou novas definições de navegador a esse componente simplesmente atualizando o arquivo browscap.ini. O componente Browser Capabilities usa os seguintes arquivos: ➥ Browscap.dll: Este é o arquivo onde está implementada a funcionalidade do componente. Este arquivo encontra-se, normalmente, na pasta \winnt\system32\inetsrv, do drive onde está instalado o Windows 2000. ➥ Browscap.ini: É um arquivo de texto que mapeia os recursos do navegador para o cabeçalho Agente de usuário do HTTP. Esse arquivo deve estar no mesmo diretório que o arquivo Browscap.dll. Utilizamos a seguinte sintaxe para criar um objeto do tipo BrowserType: Set nome_objeto = Server.CreateObject(“MSWC.BrowserType”)

Onde temos: ➥ nome_objeto: Especifica o nome do objeto BrowserType criado pela chamada do Server.CreateObject. ➥ MSWC.BrowserType: É o nome pelo qual o componente é identificado no servidor IIS.

610

Capítulo 10 – Utilizando Componentes do IIS

Na Listagem 10.11, temos um pequeno exemplo retirado do Help do IIS, onde são detectadas algumas capacidades do navegador. Listagem 10.11 – Utilizando o componente Browser Capabilities – capacidades.asp. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<BODY>

<TR>

Set bc = Server.CreateObject(“MSWC.BrowserType”) %>

<TD>Browser</TD>

<TD>

11 12

<%= bc.browser

%> </TD>

<TR> <TD>Version</TD>

<TD>

</TR>

<TR>

<%= bc.version

<TD>Frames</TD>

<TD>

</TD>

if (bc.frames = TRUE) then

else

end if

TRUE

FALSE %>

<TD> 21

</TR>

<TR>

<TD>Tables</TD>

<TD>

if (bc.tables = TRUE) then

else

%> FALSE

end if

</TD>

</TR>

611

TRUE

Criando Sites Dinâmicos com ASP 3.0

<TR>

<TD>BackgroundSounds</TD>

<TD>

if (bc.BackgroundSounds = TRUE) then

else

end if

35 36 37

TRUE

%> FALSE %> </TD>

</TR> <TR>

<TD>VBScript</TD>

<TD>

if (bc.vbscript = TRUE) then

else

%> FALSE

end if

</TD>

</TR>

<TR>

<TD>JScript</TD>

<TD>

if (bc.javascript = TRUE) then

else

end if

</TD>

</TR>

</TABLE>

</BODY>

</HTML>

TRUE

%> FALSE %>

Ao carregarmos este exemplo no Internet Explorer, obtemos o resultado indicado na Figura 10.14. Ao carregarmos este mesmo exemplo no Nestcape Navigator, obtemos o resultado indicado na Figura 10.15.

612

Capítulo 10 – Utilizando Componentes do IIS

Figura 10.14: O arquivo capacidades.asp carregado no Internet Explorer. Conforme podemos observar na Listagem 10.11, utilizamos uma série de propriedades do objeto Browser Capabilities. Na Tabela 10.3 temos uma descrição das propriedades do objeto Browser Capabilities.

Figura 10.15: O arquivo capacidades.asp carregado no Netscape Navigator.

613

Criando Sites Dinâmicos com ASP 3.0

Tabela 10.3 Propriedades do objeto Browser Capabilities. Propriedade

Descrição

ActiveXControls

Retorna True se o navegador suporta controles ActiveX.

Backgroundsounds

Retorna True se o navegador suporta sons de fundo.

Beta

Retorna True se o navegador for uma versão Beta.

Browser

Retorna o nome do navegador.

Retorna True se o navegador suporta Cookies.

Frames

Retorna True se o navegador suporta Frames.

JScript

Retorna True se o navegador suporta JScript.

Plataform

Especifica a plataforma (Sistema Operacional), no qual roda o navegador.

Tables

Retorna True se o navegador suporta Tabelas.

VBScript

Retorna True se o navegador suporta VBScript.

Version

Retorna a versão do navegador.

Como um exemplo final, podemos utilizar este componente para detectar se o navegador é o Internet Explorer ou o Netscape e, com base nesta informação, redirecionar o usuário para uma página desenvolvida especificamente para cada um dos navegadores. Na Listagem 10.12, temos este exemplo. Listagem 10.12 – Utilizando o componente Browser Capabilities para redirecionar o usuário. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<BODY>

<% If bc.browser=“IE” Then

Set bc = Server.CreateObject(“MSWC.BrowserType”) %>

Response.Redirect(“paginaie.asp”)

614

Capítulo 10 – Utilizando Componentes do IIS

ElseIf bc.browser=“Default” Then

Response.Redirect(“paginanetscape.asp”)

Else

Response.Redirect(“outros.asp”)

End If

</BODY>

</HTML>

Ao carregarmos esta página no Internet Explorer, o servidor redireciona o usuário para a página paginaie.asp. Na prática, será carregada a página paginaie.asp. Com isso a página pode ser desenvolvida para utilizar quaisquer recursos do Internet Explorer. Ao carregarmos esta página no Netscape Navigator, o servidor redireciona o usuário para a página paginanetscape.asp. Na prática, será carregada a página paginanetscape.asp. Com isso a página pode ser desenvolvida para utilizar quaisquer recursos do Netscape Navigator. Ao carregarmos esta página em qualquer outro navegador, o servidor redireciona o usuário para a página outros.asp. Na prática, será carregada a página outros.asp. Portanto, a página deverá ser desenvolvida utilizando somente elementos que são padrão e comuns à maioria dos navegadores.

Conclusão Neste capítulo estudamos, detalhadamente, alguns componentes importantes na criação de aplicativos Web, utilizando ASP e o IIS. Iniciamos o capítulo por um estudo completo do objeto Server. Vimos todos os métodos e a única propriedade deste objeto. Depois, foi apresentado um exemplo prático, o qual soluciona um problema bastante comum na criação de aplicações Web: como tornar o nome de um usuário ou produto em um link, para o registro do funcionário ou produto no banco de dados. Com a utilização dos métodos do objeto Server foi simples a solução deste problema. Depois, passamos a estudar uma série de componentes do IIS. Estudamos em detalhes, cada um dos seguintes componentes: ➥ Content Link. ➥ Ad Rotator. ➥ Page Counter. ➥ Browser Capabilities.

615

Criando Sites Dinâmicos com ASP 3.0

Para cada um destes componentes foram apresentados exemplos completos, que ilustraram a utilização e as capacidades dos mesmos. No próximo capítulo estaremos tratando de alguns tópicos avançados na criação de aplicações Web com ASP. Até lá então.

616

Capítulo 11 – Os Objetos FileSystemObject, Drive, Folder e File

Capítulo 11 Os Objetos FileSystemObject, Drive, Folder e File

617

Criando Sites Dinâmicos com ASP 3.0

Introdução Iniciaremos o capítulo por um estudo detalhado do objeto FileSystemObject. Este objeto nos fornece uma série de recursos para acesso ao sistema de arquivos do servidor, através de nossas páginas ASP. Veremos uma série de métodos e uma propriedade que fazem parte deste objeto. Com a utilização do objeto FileSystemObject podemos criar páginas ASP para execução de funções administrativas, como por exemplo: ➥ Verificação do espaço disponível em disco e unidades da rede. ➥ Efetuar cópia de segurança entre unidades de disco. ➥ Verificar se determinadas unidades, como gravador de CD ou ZIP Drive, estão disponíveis para uso. ➥ Fazer um levantamento do espaço utilizado em cada drive do sistema. O objeto FileSystemObject é, com certeza, um dos que oferece o maior número de métodos. Vamos estudar todos, detalhadamente. Também estudaremos alguns objetos derivados do objeto FileSystemObject. Vamos estudar o objeto Drive e suas diversas propriedades. Um pequeno exemplo de utilização destas propriedades será apresentado. Vamos estudar também os objetos Folder e File suas diversas propriedades e métodos. Um pequeno exemplo de utilização das propriedades de cada objeto será apresentado. No final do capítulo, apresentaremos um exemplo prático que utiliza os diversos objetos que foram mostrados neste capítulo.

O Objeto FileSystemObject O objeto FileSystemObject nos fornece uma série de recursos para acesso ao sistema de arquivos do servidor, através de nossas páginas ASP. Com os recursos oferecidos por este objeto, podemos manipular arquivos de texto, pastas e drives a partir do código ASP. Para criarmos um objeto do tipo FileSystemObject, podemos utilizar a seguinte sintaxe: Set nome_objeto = Server.CreateObject(“Scripting.FileSystemObject”)

Por exemplo, podemos criar um objeto chamado fileobj: Set fileobj = Server.CreateObject(“Scripting.FileSystemObject”)

Agora vamos passar ao estudo da propriedade e dos métodos deste objeto.

618

Capítulo 11 – Os Objetos FileSystemObject, Drive, Folder e File

Propriedade do Objeto FileSystemObject Temos uma única propriedade que é a propriedade Drives, a qual retorna todos os drives disponíveis no servidor IIS onde a página está gravada, inclusive drives de rede mapeados. Considere o próximo fragmento de código: <% ‘ O primeiro passo é a criação do objeto FileSystemObject. Set fileobj=Server.CreateObject(“Scripting.FileSystemObject”) For each drive in fileobj.Drives Response.Write drive & “<BR>” Next %>

Este fragmento produz a saída indicada na Figura 11.1:

Figura 11.1: Resultado produzido pelo uso da propriedade Drives. Agora vamos passar ao estudo dos métodos do objeto FileSystemObject.

619

Criando Sites Dinâmicos com ASP 3.0

Métodos do Objeto FileSystemObject Este objeto apresenta uma série de métodos, os quais facilitam o trabalho com drives, pastas e arquivos. Por isso iremos dividir a apresentação dos métodos, conforme os mesmos se destinam: ao trabalho com drives, pastas ou arquivos.

Métodos do Objeto FileSystemObject Para Trabalho com Drives Temos três métodos para tratar com drives: ➥ O método DriveExist: Este método retorna True se o drive passado como parâmetro existe e False caso contrário. O parâmetro passado para este método pode ser uma letra de drive (inclusive de um drive mapeado), uma String de texto ou o caminho completo para uma pasta ou arquivo. Para drives de dispositivos removíveis, como um CD-ROM ou um ZIP Drive, este método retorna True, mesmo que não exista uma mídia no drive.

NOTA Podemos utilizar a propriedade IsReady do objeto Drive para determinar se o mesmo está pronto para ser acessado. No exemplo do CD-ROM, podemos utilizar a propriedade IsReady para determinar se existe ou não um CD-ROM no drive de CD. Aprenderemos a utilizar a propriedade IsReady quando estudarmos o objeto Drive mais adiante neste capítulo.

A seguir temos um exemplo de utilização deste método: <% Set fileobj = CreateObject(“Scripting.FileSystemObject”) If fileobj.DriveExists(“X:”) Then Response.Write “Drive X: Existe !!” Else Response.Write “Drive X: Não Existe !!” End If %>

➥ O método GetDrive: Este método retorna um objeto do tipo Drive, correspondente ao caminho passado como parâmetro. Podemos passar como parâmetro a identificação de um drive, como por exemplo: “d”, “d:”, “d:\” ou um caminho para um drive da rede, no tradicional formato \\nome_do_computador\nome_do_compartilhamento.

620

Capítulo 11 – Os Objetos FileSystemObject, Drive, Folder e File

NOTA Estudaremos o objeto Drive mais adiante neste capítulo.

A seguir temos um exemplo de utilização deste método: <% Set drive = fileobj.GetDrive(“E:”) ‘Agora vamos calcular o espaço livre no drive E: espaco=(drive.freespace)/(1024*1024) Response.Write “Espaço livre em E: ” & FormatNumber(espaco,0) & “ MB” %>

Neste exemplo utilizamos a propriedade freespace do objeto Drive e a dividimos duas vezes por 1024 para obter o espaço livre em MB. Depois utilizamos a função FormatNumber, para exibir o valor obtido sem as casas decimais. O resultado deste trecho de código é algo do tipo: Espaço livre em E: 1.070 MB

➥ O método GetDriveName: Este método retorna o nome do drive que foi passado como parâmetro. A seguir temos um exemplo de utilização deste método. <% ‘ O primeiro passo é a criação do objeto FileSystemObject. Set fileobj=Server.CreateObject(“Scripting.FileSystemObject”) For each drive in fileobj.Drives Response.Write drive & “<BR>” Response.Write “Nome do drive: ” & fileobj.GetDriveName(drive) & “<BR>” Next %>

Com isso encerramos o estudo dos métodos para tratamento de drives.

Métodos do Objeto FileSystemObject Para Trabalho com Pastas Temos dez métodos para tratar com pastas. ➥ Método BuildPath(caminho,nome): Este método adiciona o arquivo ou pasta especificado no parâmetro nome à pasta especificada no parâmetro caminho. Caso seja necessário, o método adiciona o separador de pastas “\”.

621

Criando Sites Dinâmicos com ASP 3.0

Considere o seguinte exemplo: <% Set fileobj=Server.CreateObject(“Scripting.FileSystemObject”) novapasta = fileobj.BuildPath(“C:\”,“pasta123") Response.Write novapasta %>

Este fragmento produz a seguinte saída: C:\pasta123. É importante observar que a pasta C:\pasta123 não será criada pela utilização deste método. Apenas estamos atribuindo à variável novapasta, o caminho C:\pasta123. Para criar uma nova pasta, podemos utilizar o método CreateFolder, que veremos logo adiante. ➥ O método CopyFolder “fonte”,“destino”,substituir: Copia uma ou mais pastas especificadas no parâmetro fonte. Podemos copiar mais do que um pasta, pois podemos utilizar caracteres curinga, como por exemplo C:\documentos\*. As pastas de origem são copiadas para a pasta especificada pelo parâmetro destino. Todos os arquivos contidos nas pastas de origem serão copiados para o destino. O parâmetro substituir é opcional. Ele pode conter os valores True ou False. Este parâmetro especifica se arquivos já existentes no destino devem ou não ser sobrescritos. Se a pasta de destino já existe e o parâmetro substituir é definido em Falso, irá ocorrer um erro. O valor padrão para o parâmetro substituir é True.

IMPORTANTE Somente podemos utilizar caracteres curinga na parte final do caminho. Considere o seguinte exemplo: FileSystemObject.CopyFolder “C:\mydocuments\letters\*”, “C:\tempfolder\”

Porém o próximo exemplo está incorreto: FileSystemObject.CopyFolder “C:\mydocuments\*\*”, “C:\tempfolder\”

Se a pasta de destino ainda não existe, será criada, e a pasta de origem e todo o seu conteúdo serão copiados. Se o parâmetro de destino for o nome de um arquivo existente, ocorrerá um erro. Se o destino for o nome de uma pasta, o método tentará copiar a pasta de origem e todo o seu conteúdo para a pasta de destino. Se um arquivo que está sendo copiado já existir na pasta de destino e o parâmetro substituir estiver definido como False, irá ocorrer um erro. Caso contrário, o arquivo do diretório de origem será copiado sobre o arquivo do diretório de destino.

622

Capítulo 11 – Os Objetos FileSystemObject, Drive, Folder e File

O método CopyFolder pára na ocorrência do primeiro erro. Nenhuma tentativa de reverter as alterações que já foram feitas será efetuada, isto é, os arquivos que foram copiados antes da ocorrência do erro não serão eliminados da pasta de destino. Considere o seguinte exemplo: fileobj.CopyFolder “C:\meus documentos”,“C:\teste”

Esta linha de código irá copiar todo o conteúdo da pasta C:\meus documentos para a pasta C:\teste. Caso a pasta C:\teste não exista, a mesma será automaticamente criada antes que a cópia seja efetuada. ➥ O método CreateFolder(nomepasta): Este método cria uma pasta de acordo com o parâmetro que foi passado para o mesmo. Caso a pasta já exista, será gerado um erro. O exemplo a seguir, cria uma pasta chamada C:\teste123: fileobj.CreateFolder(“C:\teste123”)

Caso a pasta já exista obteremos a mensagem de erro indicada na Figura 11.2.

Figura 11.2: Erro gerado pelo método CreateFolder quando a pasta já existe. ➥ O método DeleteFolder(pastaname,force): Este método elimina a pasta especificada no parâmetro pastaname e todo o seu conteúdo. O parâmetro force pode ser True ou False. Este parâmetro determina se o conteúdo de uma pasta, que possui o atributo de somente leitura, é para ser deletado ou não. O valor padrão é False.

623

Criando Sites Dinâmicos com ASP 3.0

Será gerado um erro se a pasta especificada pelo parâmetro pastaname não for encontrada. Este método encerra a sua execução na ocorrência do primeiro erro, sendo que as alterações que já foram feitas não serão desfeitas. Considere o exemplo: fileobj.DeleteFolder(“C:\teste123”)

Este comando elimina a pasta C:\teste123. Caso a pasta a ser eliminada não exista, obteremos a mensagem de erro indicada na Figura 11.3.

Figura 11.3: Erro gerado pelo método DeleteFolder quando a pasta não existe. ➥ O método FolderExists(nomepasta): Este método retorna True se a pasta passada como parâmetro existe e False caso contrário. O parâmetro nomepasta pode conter um caminho absoluto ou relativo. Considere o exemplo abaixo: <% Set fileobj=Server.CreateObject(“Scripting.FileSystemObject”) For each drive in fileobj.Drives

624

Capítulo 11 – Os Objetos FileSystemObject, Drive, Folder e File

Response.Write drive & “<BR>” caminho=fileobj.BuildPath(drive,“\meus documentos”) If fileobj.FolderExists(caminho) then Response.Write “<B>Este drive possui a pasta Meus documentos<B> <HR>” Else Response.Write “<B>Este drive não possui a pasta Meus documentos <B><HR>” End If Next %>

Este fragmento produz o resultado indicado na Figura 11.4.

Figura 11.4: Utilizando o método FolderExists. ➥ O método GetAbsolutePathName(parâmetro): Este método recebe como parâmetro o nome de uma pasta ou outra especificação de caminho válida, e retorna o caminho completo para esta pasta, tendo como base a pasta atual. Por exemplo, se a pasta atual

625

Criando Sites Dinâmicos com ASP 3.0

for C:\meus documentos e o parâmetro passado para este método for “cartas”, o valor de retorno será C:\meus documentos\cartas. Vamos a mais alguns exemplos para esclarecer o comportamento deste método. Vamos supor que a pasta atual é C:\meus documentos\cartas. Na Tabela 11.1 temos alguns exemplos de retorno deste método. Tabela 11.1 Valores de retorno do método GetAbsolutePathName. Parâmetro

Valor de retorno

“C:”

“C:\meus documentos\cartas”

“C:..”

“C:\meus documentos”

“C:\\\”

“C:\”

“C:*.*\abril96”

“C:\meus documentos\cartas\*.*\abril96”

“filial5”

“C:\meus documentos\cartas\filial5”

➥ O método GetFolder(caminhopasta): Retorna um objeto do tipo Folder, correspondente à pasta que foi passada como parâmetro. Ocorrerá um erro se a pasta, passada como parâmetro, não existir. Estudaremos o objeto Folder em detalhes ainda neste capítulo. Considere o seguinte exemplo: <% ‘ O primeiro passo é a criação do objeto FileSystemObject. Set fileobj=Server.CreateObject(“Scripting.FileSystemObject”) Set pasta=fileobj.GetFolder(“C:\meus documentos”) For each subpasta in pasta.subfolders Response.Write subpasta & “<HR>” Next %>

O resultado deste fragmento de código é indicado na Figura 11.5.

626

Capítulo 11 – Os Objetos FileSystemObject, Drive, Folder e File

Figura 11.5: Utilizando o método GetFolder. Observe que já utilizamos a coleção subfolders do objeto Folder. Conforme citado anteriormente, estudaremos o objeto Folder em detalhes, ainda neste capítulo. ➥ O método GetParentFolderName(pasta): Este método retorna uma String com o nome da pasta na qual está contido pasta ou arquivo passado como parâmetro. Este método não faz a verificação para saber se a pasta existe ou não. Se a pasta ou arquivo já estiver na raiz do drive, será retornada uma String de tamanho zero. Considere o exemplo: pastacontem = fileobj.GetParentFolderName(“C:\meus documentos\word”)

Este comando retorna na variável pastacontem a String: C:\meus documentos. ➥ O método GetSpecialFolder(folderespvalor): Retorna um objeto do tipo Folder, correspondente a um dos tipos especiais de pasta do Windows. Os valores possíveis para folderespvalor são os seguintes: 0 – Pasta do Windows. 1 – Pasta de Sistema. 2 – Pasta temporária.

627

Criando Sites Dinâmicos com ASP 3.0

Considere o exemplo a seguir: <% ‘ O primeiro passo é a criação do objeto FileSystemObject. Set fileobj=Server.CreateObject(“Scripting.FileSystemObject”) Set temppasta=fileobj.GetSpecialFolder(2) %>

Com este fragmento de código, criamos um objeto do tipo Folder, o qual está ligado à pasta temporária do Windows e pode ser acessado pela variável temppasta. ➥ O método MoveFolder(origem,destino): Move a pasta especificada no parâmetro origem, para a pasta especificada no parâmetro destino. Podemos incluir caracteres curinga na origem, porém não no destino. Se a origem contém caracteres curinga ou o destino termina com o caractere “\”, o método MoveFolder considera que o destino representa o nome de uma pasta já existente, para a qual deve ser movida a pasta de origem. Caso contrário o método assume que o parâmetro destino especifica o nome de uma pasta que deve ser criada e para a qual deve ser movido o conteúdo da pasta de origem. Em ambos os casos, devemos considerar o seguinte: 1. Se a pasta de destino não existe, a pasta de origem será movida, sendo que a pasta de destino será criada antes, pelo próprio método MoveFolder. 2. Se o parâmetro destino for o nome de um arquivo, será gerado um erro. 3. Se o parâmetro destino for o nome de uma pasta que já existe, será gerado um erro. O método MoveFolder será interrompido na ocorrência do primeiro erro. Quaisquer alterações que tenham sido feitas não serão revertidas. Considere o exemplo: fileobj.MoveFolder “C:\teste1”, “C:\teste2”

Com isso encerramos o estudo dos métodos para tratamento de Pastas.

Métodos do Objeto FileSystemObject Para Trabalho com Arquivos Temos onze métodos para tratar com arquivos. ➥ Método CopyFile(origem,destino,substituir): Copia um ou mais arquivos especificados pelo parâmetro origem (podemos utilizar caracteres curinga) para a pasta especificada no parâmetro destino. Se a origem contém caracteres curinga ou o destino termina com o caractere “\”, o método CopyFile considera que o destino representa o nome de uma pasta já existente, para a qual

628

Capítulo 11 – Os Objetos FileSystemObject, Drive, Folder e File

devem ser copiados os arquivos especificados pelo parâmetro origem. Caso contrário o método assume que o parâmetro destino especifica o nome de um arquivo que deve ser criado. Em ambos os casos, devemos considerar o seguinte: 1. Se a pasta de destino não existe, os arquivos especificados no parâmetro origem serão copiados, sendo que a pasta de destino será criada antes, pelo próprio método CopyFile. 2. Se o parâmetro destino for o nome de um arquivo que já existe, será gerado um erro caso o parâmetro substituir esteja definido como False; caso contrário o arquivo existente será substituído. 3. Se o parâmetro destino for o nome de uma pasta, será gerado um erro. O método CopyFile será interrompido na ocorrência do primeiro erro. Quaisquer alterações que tenham sido feitas não serão revertidas. A seguir temos um exemplo de utilização do método CopyFile: FileSystemObject.CopyFile “c:\meus documentos\oficios\*.doc”, “e:\copia de segurança\ oficios\”

➥ O método CreateTextFile(nomearquivo,substituir,unicode): Este método cria o arquivo de texto especificado pelo parâmetro nomearquivo e retorna um objeto do tipo TextStream, o qual pode ser utilizado para gravar informações no arquivo e ler informações do arquivo. O parâmetro substituir pode assumir os valores True ou False. Quando este parâmetro tiver o valor True, se o arquivo já existir, o mesmo será eliminado e um novo arquivo será criado. O padrão para o parâmetro substituir é False. Este parâmetro é opcional. O parâmetro unicode pode assumir os valores True ou False. Se este parâmetro tiver o valor True, o texto será salvo com caracteres unicode, os quais utilizam 2 bytes por caractere, ao invés de 1 byte por caractere como é o caso do padrão ASCII. O valor padrão para o parâmetro unicode é False. Este parâmetro é opcional. Considere o exemplo a seguir: <% Set fileobj=Server.CreateObject(“Scripting.FileSystemObject”) Set arqtexto = fileobj.CreateTextFile(“c:\teste.txt”,true) arqtexto.WriteLine(“*************************”) arqtexto.writeline(“LINHA 1 DO TEXTO”) arqtexto.writeline(“LINHA 2 DO TEXTO”) arqtexto.writeline(“LINHA 3 DO TEXTO”) arqtexto.writeline(“*************************”) %>

629

Criando Sites Dinâmicos com ASP 3.0

Este fragmento de código cria um objeto do tipo TextStream, o qual é associado à variável arqtexto. Depois utilizamos o método writeline para escrever linhas de texto no arquivo c:\teste.txt. Na Figura 11.6 temos o conteúdo do arquivo teste.txt, após a execução do código do nosso exemplo.

Figura 11.6: Utilizando o método CreateTextFile. ➥ O método DeleteFile(arquivo,force): Este método elimina um ou mais arquivos definidos pelo parâmetro arquivo. Podem ser utilizados caracteres curinga. O parâmetro force pode assumir os valores True ou False. Se o parâmetro force for definido como True, o arquivo será eliminado mesmo se tiver o atributo de Somente leitura marcado. O valor padrão do atributo force é False. Se o arquivo especificado não for encontrado, será gerado um erro. O método DeleteFile será interrompido na ocorrência do primeiro erro. Quaisquer alterações que tenham sido feitas não serão revertidas. Considere o exemplo: fileobj.DeleteFile(“C:\meus documentos\oficio.doc”,true)

➥ O método FileExists(arquivo): Este método retorna True se o arquivo passado como parâmetro existe, caso contrário o método irá retornar False. Considere o seguinte exemplo: <% If fileobj.FileExists(“C:\meus documentos\relatorio.doc”) Then Response.Write “O arquivo com o relatório já foi salvo na pasta Meus documentos” Else Response.Write “O arquivo com o relatório ainda não foi salvo na pasta Meus documentos” End If %>

630

Capítulo 11 – Os Objetos FileSystemObject, Drive, Folder e File

➥ O método GetBaseName(arquivo): Este método retorna apenas o nome do arquivo passado como parâmetro, sem a extensão ou qualquer informação de caminho. Considere o exemplo: <% Response.Write fileobj.GetBaseName(“C:\meus documentos\vendas.xls”) %>

Este comando retorna apenas vendas. ➥ O método GetExtensionName(arquivo): Este método retorna apenas a extensão do arquivo passado como parâmetro. Uma String de tamanho zero “ ” será retornada se o arquivo passado como parâmetro não for encontrado. Considere o exemplo: <% Response.Write fileobj.GetExtensionName(“C:\meus documentos\vendas.xls”) %>

Este comando irá retornar apenas xls. ➥ O método GetFile(arquivo): Este método retorna um objeto do tipo File e ligado ao arquivo passado como parâmetro. Se o arquivo passado como parâmetro não existir, será gerado um erro.

NOTA Iremos estudar o objeto File em detalhes, ainda neste capítulo.

Considere o exemplo: <% Set fileobj=Server.CreateObject(“Scripting.FileSystemObject”) Set arquivo=fileobj.GetFile(“C:\autoexec.bat”) Response.Write “Caminho do arquivo: ” & arquivo.path & “<HR>” Response.Write “Data de criação: ” & arquivo.DateCreated & “<HR>” Response.Write “Data último acesso: ” & arquivo.DateLastAccessed & “<HR>” %>

O resultado deste fragmento de código é indicado na Figura 11.7.

631

Criando Sites Dinâmicos com ASP 3.0

Figura 11.7: Utilizando o método GetFile.

NOTA Observe que já utilizamos algumas propriedades do objeto File. Conforme descrito anteriormente, iremos estudar este objeto ainda neste capítulo. ➥ O método GetFileName(caminho): Retorna o nome do último arquivo ou pasta que foi especificado no parâmetro caminho. Por exemplo, se passarmos C:\meus documentos\clientes.mdb como parâmetro será retornado clientes.mdb. Já se passarmos C:\meus documentos, será retornado meus documentos. Se o parâmetro passado não terminar com o nome de uma pasta ou arquivo, o método GetFileName retornará uma String de tamanho zero “ ”.

NOTA Este método não verifica se o caminho passado como parâmetro existe ou não. ➥ O método GetTempName( ): Retorna o nome de um arquivo ou pasta, nome este que é gerado randomicamente. Este arquivo ou pasta pode ser utilizado para operações que necessitam de um local de armazenamento temporário. Este método não cria um arquivo temporário. Ele apenas gera um nome que pode ser utilizado pelo método CreateTextFile, o qual pode ser usado para criar o arquivo. Considere o exemplo: <% Set fileobj=Server.CreateObject(“Scripting.FileSystemObject”)

632

Capítulo 11 – Os Objetos FileSystemObject, Drive, Folder e File

tempname=fileobj.GetTempName Set txttemp=fileobj.CreateTextFile(tempname) %>

➥ O método MoveFile(origem, destino): Este método pode ser utilizado para mover o arquivo passado no parâmetro origem para a localização especificada no parâmetro destino. Podemos utilizar caracteres curinga na origem, porém não no destino. Se a origem contém caracteres curinga ou o destino termina com o caractere “\”, o método MoveFile considera que o destino representa o nome de uma pasta já existente, para a qual deve ser movido o arquivo de origem. Caso contrário, o método assume que o parâmetro destino especifica o nome de uma pasta e arquivo para o qual deve ser movido o arquivo de origem. Em ambos os casos, devemos considerar o seguinte: 1. Se o destino não existe, o arquivo de origem será movido, sendo que a pasta de destino será criada antes, pelo próprio método MoveFile. 2. Se o parâmetro destino for o nome de um arquivo existente, será gerado um erro. 3. Se o parâmetro destino for o nome de uma pasta, será gerado um erro. O método MoveFile será interrompido na ocorrência do primeiro erro. Quaisquer alterações que tenham sido feitas não serão revertidas. Considere o exemplo: <% Set fileobj=Server.CreateObject(“Scripting.FileSystemObject”) fileobj.MoveFile “C:\teste.txt”, “D:\documentos\teste.txt” %>

➥ O método OpenTextFile(arquivo,iomode,create,format): Cria um arquivo com o nome passado no parâmetro arquivo ou abre um arquivo existente. Este método retorna um objeto do tipo TextStream que faz referência ao arquivo especificado pelo parâmetro arquivo. O parâmetro iomode determina o tipo de acesso que teremos ao arquivo. Os valores permitidos para este parâmetro são os seguintes: 1 – ForReading: Somente para leitura. Este é o valor padrão. 2 – ForWriting: Somente para escrita. Não podemos ler o conteúdo já existente. 8 – ForAppending: Abre o arquivo e grava informações no final do mesmo. Se o parâmetro create for definido como True quando tentarmos escrever ou adicionar (Appending) conteúdo a um arquivo que não existe, um novo arquivo será criado. O valor padrão para este parâmetro é False.

633

Criando Sites Dinâmicos com ASP 3.0

O parâmetro format pode assumir os seguintes valores: 0 – TristateFalse: Abre o arquivo como sendo ASCII. É o valor padrão. -1 – TristateTrue: Abre o arquivo como sendo Unicode. -2 – TristateUseDefault: Abre o arquivo utilizando o formato padrão do sistema. Considere o exemplo: <% Set fileobj=Server.CreateObject(“Scripting.FileSystemObject”) Set arquivo = fileobj.OpenTextFile(“C:\testfile.txt”, ForWriting, True) %>

Com isso finalizamos o estudo dos métodos relacionados com arquivos e também o estudo do objeto FileSystemObject. Agora iniciaremos o estudo dos objetos Drive, Folder e File.

O Objeto Drive Para criar um objeto do tipo Drive, utilizamos o método GetDrive do objeto FileSystemObject, conforme descrito anteriormente. No exemplo a seguir, criamos um objeto do tipo Drive, chamado driveobj: <% Set fileobj=Server.CreateObject(“Scripting.FileSystemObject”) Set driveobj = fileobj.GetDrive(“D:”) %>

Agora podemos ter acesso a todas as propriedades do objeto driveobj. Então vamos ao estudo destas propriedades.

Propriedades do Objeto Drive Na Tabela 11.2 temos uma descrição das propriedades do objeto Drive. Tabela 11.2 Propriedades do objeto Drive. Propriedade

Descrição

AvailableSpace

Retorna a quantidade de espaço livre, disponível no drive para o usuário. Esta propriedade leva em consideração a definição de quotas de disco e outras restrições que podem

634

Capítulo 11 – Os Objetos FileSystemObject, Drive, Folder e File

Propriedade

Descrição ser impostas pelo Windows 2000. O valor retornado é em bytes. Caso não existam definição de quotas ou outras restrições, esta propriedade retornará o mesmo valor que a propriedade FreeSpace.

DriveLetter

Retorna a letra do drive.

DriveType

Retorna o tipo do drive. Os valores de retorno são os seguintes: Desconhecido (0), Removível (1), Fixo (2), Rede (3), CD-Rom (4) e RamDisk (5). Esta propriedade retorna o valor numérico, isto é, 0, 1, 2, 3, 4 ou 5.

FileSystem

Retorna o tipo de sistema de arquivo que está sendo utilizado. Os valores possíveis são: FAT, FAT32, NTFS ou CDFS.

FreeSpace

Retorna a quantidade total de espaço livre, disponível no drive. O valor retornado é em bytes.

IsReady

Retorna True se o drive está pronto para ser usado e False em caso contrário. Por exemplo, se um drive de CD-Rom estiver sem CD esta propriedade irá retornar False.

Path

Retorna o caminho para o drive, no seguinte formato C:, D:, etc.

RootFolder

Retorna um objeto do tipo Folder, o qual representa a pasta raiz do drive.

SerialNumber

Retorna um número serial, utilizado para identificar de maneira única o drive.

ShareName

Retorna o nome do compartilhamento de rede para o drive, se o mesmo for um drive de rede.

TotalSize

Retorna o tamanho total do drive em bytes.

VolumeName

Pode ser utilizado para definir ou retornar o Label do drive.

Na Listagem 11.1, podemos ver um exemplo de utilização das propriedades do objeto Drive.

635

Criando Sites Dinâmicos com ASP 3.0

Listagem 11.1 – Utilizando as propriedades do objeto Drive. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

<TITLE>Utilizando o objeto Drive. </TITLE>

</HEAD>

<BODY>

‘ O primeiro passo é a criação do objeto FileSystemObject.

Set fileobj=Server.CreateObject(“Scripting.FileSystemObject”)

<HR>

Set objdrive=fileobj.GetDrive(“D:”)

Response.Write “Espaço disponível em D para o usuário atual:<B> ” & objdrive. AvailableSpace & “</B><BR>”

Response.Write “Letra do drive D:<B> ” & objdrive.DriveLetter & “</B><BR>”

Response.Write “Tipo do drive D: <B>” & objdrive.DriveType & “</B><BR>”

Response.Write “Sistema de arquivos do drive D:<B> ” & objdrive.FileSystem & “</B><BR>”

Response.Write “Espaço livre em D:<B> “ & objdrive.FreeSpace & “</B><BR>”

Response.Write “O drive D: pode ser usado? <B>” & objdrive.IsReady & “</B><BR>”

Response.Write “Caminho para o drive D: —><B>” & objdrive.Path & “</B><BR>”

Response.Write “Pasta raiz para o drive D: <B>” & objdrive.RootFolder & “</B><BR>”

Response.Write “Número Serial do drive D: <B>” & objdrive.SerialNumber &

Response.Write “Espaço total do drive D: <B>” & objdrive.TotalSize & “ bytes</B><BR>”

Response.Write “Nome do drive D: <B>” & objdrive.VolumeName & “</B><BR>”

<HR>

</BODY>

</HTML>

Ao carregarmos esta página, obteremos os resultados indicados na Figura 11.8.

636

“</B><BR>”

Capítulo 11 – Os Objetos FileSystemObject, Drive, Folder e File

Figura 11.8: Utilizando as propriedades do objeto Drive. Com isso encerramos o estudo do objeto Drive. Agora vamos ao estudo do objeto Folder.

O Objeto Folder Para criar um objeto do tipo Folder, utilizamos o método GetFolder ou o método GetSpecialFolder do objeto FileSystemObject, conforme descrito anteriormente. Um objeto do tipo Folder também é retornado pela propriedade RootFolder do objeto Drive. No exemplo a seguir, criamos um objeto do tipo Folder, chamado folderobj: <% Set fileobj=Server.CreateObject(“Scripting.FileSystemObject”) Set folderobj = fileobj.GetFolder(“D:\meus documentos”) %>

Agora podemos ter acesso a todas as propriedades e métodos do objeto folderobj. Então vamos ao estudo destas propriedades e métodos.

637

Criando Sites Dinâmicos com ASP 3.0

Propriedades do Objeto Folder Na Tabela 11.3, temos uma descrição das propriedades do objeto Folder. Tabela 11.3 Propriedades do objeto Folder. Propriedade

Descrição

Attributes

Pode ser utilizada para definir ou retornar os atributos para a pasta. Os valores possíveis são os seguintes: 0 - Arquivo normal, sem nenhum atributo definido; 1 - Somente leitura; 2- Arquivo oculto; 4 - Arquivo de sistema; 8 - Label do drive; 16 - Pasta ou subpasta; 32 - Indica se o arquivo foi alterado desde o último backup; 64 - Link ou atalho e 128 - Arquivo compactado.

DateCreated

Retorna a data e a hora de criação da pasta.

DateLastAccessed

Retorna a data e a hora da última vez que a pasta foi acessada.

DateLastModified

Retorna a data e a hora da última vez que a pasta foi modificada.

Drive

Retorna a letra do drive onde está a pasta.

Files

Retorna uma coleção, a qual contém todos os arquivos existentes no objeto Folder.

IsRootFolder

Retorna True se a pasta for a raiz do drive e False caso contrário.

Name

Pode ser utilizada para definir ou retornar o nome da pasta.

ParentFolder

Retorna um objeto Folder que é o objeto de nível superior para a pasta, isto é, é a pasta dentro da qual a pasta atual encontra-se. Por exemplo, para a pasta C:\documentos\cartas, a pasta de nível superior é C:\documentos. Em inglês o termo é conhecido como “Parent Folder”.

Path

Retorna o caminho completo para a pasta, inclusive utilizando nomes longos.

ShortName

Retorna o nome no formato antigo 8.3 da época do DOS.

638

Capítulo 11 – Os Objetos FileSystemObject, Drive, Folder e File

Propriedade

Descrição

ShortPath

Retorna o caminho completo no formato antigo da época do DOS, sem a utilização de nomes longos.

Size

Retorna o tamanho total da pasta, incluindo todos os seus arquivos e subpastas.

SubFolders

Retorna uma coleção, a qual contém todas as subpastas, inclusive as subpastas ocultas e de sistema.

Type

Retorna uma String que é a descrição do tipo da pasta.

No exemplo da Listagem 11.2, podemos ver um exemplo de utilização das propriedades do objeto Folder. Listagem 11.2 – Utilizando as propriedades do objeto Folder. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

<TITLE>Utilizando o objeto Folder. </TITLE>

</HEAD>

<BODY>

‘ O primeiro passo é a criação do objeto FileSystemObject.

Set fileobj=Server.CreateObject(“Scripting.FileSystemObject”)

<HR>

Set objfolder=fileobj.GetFolder(“C:\meus documentos”)

Response.Write “Atributos de C:\Meus documentos:<B> ” & objfolder.Attributes & “</B><BR>”

Response.Write “Data e hora de criação de C:\Meus documentos:<B> ” & DateCreated & “</B><BR>”

Response.Write “Data e hora do último acesso à C:\Meus documentos:<B> ” &objfolder. DateLastAccessed & “</B><BR>”

Response.Write “Data e hora da última modificação em C:\Meus documentos:<B> ” & objfolder.DateLastModified & “</B><BR>”

639

objfolder.

Criando Sites Dinâmicos com ASP 3.0

Response.Write “A pasta C:\Meus documentos está no drive:<B> ” & objfolder.Drive & “</B><BR>”

Response.Write “A pasta C:\Meus documentos é raiz? <B> ” & objfolder. IsRootFolder & “</B><BR>”

Response.Write “Nome da pasta C:\Meus documentos:<B> ” & objfolder.Name & “</B> <BR>”

Response.Write “Parent Folder de C:\Meus documentos:<B> ” & objfolder. ParentFolder & “</B><BR>”

Response.Write “Path de C:\Meus documentos:<B> ” & objfolder.Path & “</B><BR>”

Response.Write “Nome curto de C:\Meus documentos:<B> ” & objfolder.ShortName & “</B> <BR>”

Response.Write “Nome curto do caminho de C:\Meus documentos:<B> ” & objfolder. ShortPath & “</B><BR>”

Response.Write “Tamanho total de C:\Meus documentos:<B> ” & objfolder.Size & “ bytes</B><BR>”

Response.Write “Tipo de C:\Meus documentos:<B> ” & objfolder.Type & “</B><BR>”

Response.Write “<HR>”

Response.Write “SUBPASTAS DA PASTA C:\MEUS DOCUMENTOS <HR>”

For each pasta in objfolder.subfolders

30 31

Response.Write “Pasta de C:\meus documentos: <B><I>” & pasta & “</B></I><BR>” Next

Response.Write “<HR>”

Response.Write “ARQUIVOS DA PASTA C:\MEUS DOCUMENTOS <HR>”

For each arquivo in objfolder.Files

35 36

Response.Write “Arquivo de C:\meus documentos: <B><I>” & arquivo & “</B></I><BR>” Next

</BODY>

</HTML>

A Figura 11.9 mostra a parte inicial do resultado desta página ao ser carregada no Internet Explorer.

640

Capítulo 11 – Os Objetos FileSystemObject, Drive, Folder e File

Figura 11.9: Utilizando as propriedades do objeto Drive. Na Figura 11.10 vemos uma parte do resultado, onde são exibidos os elementos da coleção Files.

Figura 11.10: A coleção Files do objeto Folder.

641

Criando Sites Dinâmicos com ASP 3.0

Métodos do Objeto Folder O objeto Folder possui quatro métodos. ➥ Método Copy(destino,substituir): Este método copia o objeto Folder atual, para o local especificado no parâmetro destino. Se o destino termina com o caractere “\”, o método Copy considera que o destino representa o nome de uma pasta já existente, para a qual deve ser copiada a pasta representada pelo objeto Folder. Caso contrário o método assume que o parâmetro destino especifica o nome completo de uma nova pasta que deve ser criada. O parâmetro substituir pode assumir os valores True ou False. O valor padrão é True. Se a pasta especificada no parâmetro destino já existe e o parâmetro substituir estiver definido em False, ocorrerá um erro. Considere o exemplo: <% Set fileobj=Server.CreateObject(“Scripting.FileSystemObject”) Set folderobj = fileobj.GetFolder(“D:\meus documentos”) folderobj.copy(“E:\meus documentos”,true) %>

➥ O método CreateTextFile(nomearquivo,substituir,unicode): Este método cria o arquivo de texto especificado pelo parâmetro nomearquivo e retorna um objeto do tipo TextStream, o qual pode ser utilizado para gravar informações no arquivo e ler informações do arquivo. O parâmetro substituir pode assumir os valores True ou False. Quando este parâmetro tiver o valor True, se o arquivo já existir o mesmo será eliminado e um novo arquivo será criado. O padrão para o parâmetro substituir é False. Este parâmetro é opcional. O parâmetro unicode pode assumir os valores True ou False. Se este parâmetro tiver o valor True, o texto será salvo com caracteres unicode, os quais utilizam 2 bytes por caractere, ao invés de 1 byte por caractere como é o caso do padrão ASCII. O valor padrão para o parâmetro unicode é False. Este parâmetro é opcional. Considere o exemplo a seguir: <% Set fileobj=Server.CreateObject(“Scripting.FileSystemObject”) Set folder=fileobj.GetFolder(“C:\”) Set arqtexto = folder.CreateTextFile(“C:\teste.txt”,true) arqtexto.WriteLine(“*************************”)

642

Capítulo 11 – Os Objetos FileSystemObject, Drive, Folder e File

arqtexto.writeline(“LINHA 1 DO TEXTO”) arqtexto.writeline(“LINHA 2 DO TEXTO”) arqtexto.writeline(“LINHA 3 DO TEXTO”) arqtexto.writeline(“*************************”) %>

Este fragmento de código cria um objeto do tipo TextStream, o qual é associado à variável arqtexto. Depois utilizamos o método writeline para escrever linhas de texto no arquivo C:\teste.txt. Na Figura 11.11 temos o conteúdo do arquivo teste.txt, após a execução do código do nosso exemplo.

Figura 11.11: Utilizando o método CreateTextFile do objeto Folder. ➥ O método Delete(force): Este método elimina a pasta associada com o objeto Folder e todo o seu conteúdo, isto é, arquivos e subpastas. O parâmetro force pode assumir os valores True ou False. Se o parâmetro force for definido como True, a pasta será eliminada mesmo se a mesma ou qualquer um de seus arquivos ou subpastas, tiver o atributo de Somente leitura marcado. O valor padrão do atributo force é False. Considere o exemplo: folderobj.Delete(True)

➥ O método Move destino: Move a pasta e todo o seu conteúdo, para a pasta especificada no parâmetro destino. Se o destino termina com o caractere “\”, o método Move considera que o destino representa o nome de uma pasta já existente, para a qual deve ser movida a pasta. Caso contrário o método assume que o parâmetro destino especifica o nome de uma nova pasta que deve ser criada e para a qual deve ser movido o conteúdo da pasta de origem. Caso a pasta de destino já exista, ocorrerá um erro.

643

Criando Sites Dinâmicos com ASP 3.0

Considere o exemplo: folderobj.Move “C:\copia de seguranca\documentos”

Com isso, encerramos o estudo do objeto Folder. Agora vamos ao estudo do objeto File.

O Objeto File Para criar um objeto do tipo File, utilizamos o método GetFile do objeto FileSystemObject, conforme descrito anteriormente. No exemplo a seguir, criamos um objeto do tipo File, chamado arqobj: <% Set fileobj=Server.CreateObject(“Scripting.FileSystemObject”) Set arqobj = fileobj.Getfile(“C:\meus documentos\nwind.mdb”) %>

Agora podemos ter acesso a todas as propriedades e métodos do objeto arqobj. Então vamos ao estudo destas propriedades e métodos.

Propriedades do Objeto File Na Tabela 11.4 temos uma descrição das propriedades do objeto File. Tabela 11.4 Propriedades do objeto File. Propriedade

Descrição

Attributes

Pode ser utilizada para definir ou retornar os atributos para o arquivo. Os valores possíveis são os seguintes: 0 - Arquivo normal, sem nenhum atributo definido; 1 - Somente leitura; 2- Arquivo oculto; 4 - Arquivo de sistema; 16 - Pasta ou subpasta; 32 - Indica se o arquivo foi alterado desde o último backup; 1024 - Link ou atalho e 2048 - Arquivo compactado.

DateCreated

Retorna a data e a hora de criação do arquivo.

DateLastAccessed

Retorna a data e a hora da última vez que o arquivo foi acessado.

DateLastModified

Retorna a data e a hora da última vez que o arquivo foi modificado.

644

Capítulo 11 – Os Objetos FileSystemObject, Drive, Folder e File

Propriedade

Descrição

Drive

Retorna a letra do drive onde está o arquivo.

Name

Pode ser utilizada para definir ou retornar o nome do arquivo.

ParentFolder

Retorna um objeto Folder que é o objeto de nível superior para o arquivo, ou seja, é a pasta dentro da qual o arquivo encontra-se. Por exemplo, para o arquivo C:\documentos\nwind.mdb, a pasta de nível superior é C:\documentos. Em inglês o termo é conhecido como “Parent Folder”.

Path

Retorna o caminho completo para o arquivo, inclusive utilizando nomes longos.

ShortName

Retorna o nome no formato antigo 8.3 da época do DOS.

ShortPath

Retorna o caminho completo no formato antigo da época do DOS, sem a utilização de nomes longos.

Size

Retorna o tamanho total do arquivo em bytes.

Type

Retorna uma String que é a descrição do tipo do arquivo, como por exemplo Documento do Word para um arquivo .doc.

No exemplo da Listagem 11.3, podemos ver um exemplo de utilização das propriedades do objeto File. Listagem 11.3 – Utilizando as propriedades do objeto File. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

<TITLE>Utilizando o objeto File. </TITLE>

</HEAD>

<BODY>

‘ O primeiro passo é a criação do objeto FileSystemObject.

Set fileobj=Server.CreateObject(“Scripting.FileSystemObject”)

645

Criando Sites Dinâmicos com ASP 3.0

<HR>

Set arqobj=fileobj.GetFile(“C:\meus documentos\nwind.mdb”)

Response.Write “Atributos de nwind.mdb:<B> ” & arqobj.Attributes & “</B><BR>”

Response.Write “Data e hora de criação de nwind.mdb:<B> ” & arqobj.DateCreated & “</B><BR>”

Response.Write “Data e hora do último acesso a nwind.mdb:<B> ” & arqobj.DateLastAccessed & “</B><BR>”

Response.Write “Data e hora da última modificação em nwind.mdb:<B> ” & arqobj.DateLastModified & “</B><BR>”

Response.Write “O arquivo nwind.mdb está no drive:<B> ” & arqobj.Drive & “</B><BR>”

Response.Write “Nome do arquivo nwind.mdb:<B> ” & arqobj.Name & “</B><BR>”

Response.Write “Parent Folder do arquivo nwind.mdb:<B> ” & arqobj.ParentFolder & “</B><BR>”

Response.Write “Path do arquivo nwind.mdb:<B> ” & arqobj.Path & “</B><BR>”

Response.Write “Nome curto do arquivo nwind.mdb:<B> ” & arqobj.ShortName & “</B><BR>”

Response.Write “Nome curto do caminho de C:\Meus documentos\nwind.mdb:<B> ” & arqobj.ShortPath & “</B><BR>”

Response.Write “Tamanho total do arquivo nwind.mdb:<B> ” & arqobj.Size & “bytes</B><BR>”

Response.Write “Tipo do arquivo nwind.mdb:<B> ” & arqobj.Type & “</B><BR>”

Response.Write “<HR>”

</BODY>

</HTML>

A Figura 11.12 mostra a página da Listagem 11.3 carregada no Internet Explorer.

646

Capítulo 11 – Os Objetos FileSystemObject, Drive, Folder e File

Figura 11.12: Utilizando as propriedades do objeto File.

Métodos do Objeto File O objeto File possui quatro métodos. ➥ Método Copy(destino,substituir): Este método copia o objeto File atual, para o local especificado no parâmetro destino. Se o destino termina com o caractere “\”, o método Copy considera que o destino representa o nome de uma pasta já existente, para a qual deve ser copiado o arquivo representado pelo objeto File. Caso contrário o método assume que o parâmetro destino especifica o nome completo de um novo arquivo a ser criado. O parâmetro substituir pode assumir os valores True ou False. O valor padrão é True. Se o arquivo especificado no parâmetro destino já existe e o parâmetro substituir estiver definido em False, ocorrerá um erro. Considere o exemplo: <% Set fileobj=Server.CreateObject(“Scripting.FileSystemObject”) Set arqobj = fileobj.GetFile(“C:\meus documentos\nwind.mdb”) arqobj.copy(“E:\backup\nwind.mdb”,true) %>

647

Criando Sites Dinâmicos com ASP 3.0

➥ O método Delete(force): Este método elimina o arquivo associado com o objeto File. O parâmetro force pode assumir os valores True ou False. Se o parâmetro force for definido como True, o arquivo será eliminado mesmo que tenha o atributo de Somente leitura. O valor padrão do atributo force é False. Considere o exemplo: arqobj.Delete(True)

➥ O método Move destino: Move o arquivo para a pasta especificada no parâmetro destino. Se o destino termina com o caractere “\”, o método Move considera que o destino representa o nome de uma pasta já existente, para a qual deve ser movido o arquivo. Caso contrário o método assume que o parâmetro destino especifica o nome de um novo arquivo que deve ser criado. Caso o arquivo especificado pela parâmetro destino já exista, ocorrerá um erro. Considere o exemplo: arqobj.Move “C:\copia de seguranca\”

➥ O método OpenAsTextStream (iomode,format): Abre o arquivo associado ao objeto File. Este método retorna um objeto do tipo TextStream que faz referência ao arquivo ligado ao objeto File. O parâmetro iomode determina o tipo de acesso que teremos ao arquivo. Os valores permitidos para este parâmetro são os seguintes: 1 – ForReading: Somente para leitura. Este é o valor padrão. 2 – ForWriting: Somente para escrita. Não podemos ler o conteúdo já existente. 8 – ForAppending: Abre o arquivo e grava informações no final do mesmo. O parâmetro format pode assumir os seguintes valores: 0 – TristateFalse: Abre o arquivo como sendo ASCII. É o valor padrão. -1 – TristateTrue: Abre o arquivo como sendo Unicode. -2 – TristateUseDefault: Abre o arquivo utilizando o formato padrão do sistema. Considere o exemplo: <% Set fileobj=Server.CreateObject(“Scripting.FileSystemObject”) Set arqobj = fileobj.GetFile(“C:\testfile.txt”) arqobj.OpenAsTextStream(1,0) %>

Este exemplo abre o arquivo C:\testfile.txt como somente leitura e no formato ASCII.

648

Capítulo 11 – Os Objetos FileSystemObject, Drive, Folder e File

Com isso encerramos o estudo do objeto File. Agora vamos a um exemplo prático de aplicação do que nos aprendemos neste capítulo.

Exemplo Prático Neste exemplo vamos considerar o problema a seguir. Temos uma pasta virtual no servidor IIS chamada informativos. Dentro desta pasta colocamos diariamente informativos, que são numerados: inf01.htm, inf02.htm e assim por diante. Dentro da pasta informativos existe, também, um arquivo index.asp que apresenta uma tabela com todos os informativos disponíveis. Porém não queremos atualizar esta tabela manualmente. Desejamos que cada vez que um novo arquivo seja salvo na pasta informativos, o mesmo, automaticamente apareça na tabela de informativos do arquivo index.asp. O nosso trabalho será construir a página index.asp, de tal maneira que a mesma seja capaz de ler e identificar os arquivos inf01.htm, inf02.htm, etc. existentes, e criar uma tabela com um link para todos estes arquivos. Além disso esta tabela deve exibir um máximo de seis colunas. Então, mãos à obra, vamos pôr os objetos que aprendemos neste capítulo para funcionar. Na Listagem 11.4, temos a solução para o problema proposto. Listagem 11.4 – Gerando uma tabela de conteúdo automaticamente. 1

<%@ Language=VBScript %>

<HTML>

<HEAD>

</HEAD>

<BODY>

<P align=center><FONT size=4><B>INFORMATIVOS da Empresa ABC Ltda.

</B></FONT>

</P>

<HR>

‘Crio um objeto do tipo FileSystemObject.

Set fileobj=Server.CreateObject(“Scripting.FileSystemObject”)

‘Crio um objeto do tipo Folder, utilizando o método GetFolder.

Set informativos = fileobj.GetFolder(“E:\inetpub\wwwroot\informativos”)

649

Criando Sites Dinâmicos com ASP 3.0

‘Agora posso utilizar a coleção files do objeto

‘Folder para percorrer todos os arquivos da pasta

‘E:\inetpub\wwwroot\informativos

linha=0

Response.Write “<TABLE border=1>”

For each arquivo in informativos.Files

If arquivo.name<>“index.asp” then

If linha=0 Then

Response.Write “<TR>”

End If

Response.Write “<TD><A HREF=http://servidor/informativos/” & arquivo.name & “>” & Left(arquivo.name,5) & “</TD>”

linha=linha+1

If linha=6 Then

Response.Write “</TR>”

linha=0

30 31

End If End If

Response.Write “</TABLE>”

</BODY>

</HTML>

Neste exemplo criamos um objeto do tipo FileSystemObject, depois utilizamos o método GetFile para obter um objeto do tipo Folder. O nosso objeto Folder está ligado à pasta E:\inetpub\wwwroot\informativos, que é justamente onde estão os informativos do nosso problema. Depois, utilizamos a coleção Files do objeto Folder, para acessar todos os arquivos desta pasta. Também fizemos uso de uma variável auxiliar – linha. Está variável é utilizada para que possamos exibir seis links por linha. Além disso fizemos uso da propriedade nome para cada um dos arquivos, de tal maneira que sejam exibidos apenas os nomes dos arquivos, e não o caminho completo. Por exemplo, ao invés de exibirmos E:\inetpub\wwwroot\informativos\inf01.htm,

650

Capítulo 11 – Os Objetos FileSystemObject, Drive, Folder e File

utilizando a propriedade name, exibimos apenas inf01.htm. Mas, além disso, fizemos uso da função Left(arquivo.nome,5), de tal maneira que fosse exibido apenas o nome do arquivo (cinco primeiros caracteres), sem a extensão. Desta forma é exibido apenas inf01. Conforme podemos ver na Figura 11.13, existem 20 informativos na pasta E:\inetpub\ wwwroot\informativos.

Figura 11.13: Existem 20 informativos na pasta de informativos. Na Figura 11.14, vemos o resultado ao carregar o arquivo index.asp.

Figura 11.14: O arquivo index.asp monta a tabela de links automaticamente.

651

Criando Sites Dinâmicos com ASP 3.0

Agora toda vez que um novo informativo for gravado na pasta informativos, o usuário, ao carregar a página index.asp, já verá o link para o novo informativo. Por exemplo, vamos supor que foram adicionados os informativos inf21.htm e inf22.htm. Bastaria recarregar a página index.asp que o link para os dois novos informativos já seriam, automaticamente, exibidos, conforme indicado na Figura 11.15.

Figura 11.15: Exibindo os links para os novos informativos.

Conclusão Neste capítulo fizemos um estudo completo do objeto FileSystemObject e de seus derivados, tais como os objetos Drive, Folder e File. Com o entendimento destes objetos podemos construir aplicações bastante interessantes utilizando ASP. Desde funções administrativas, tais como gravar informações em um arquivo de Log, monitorar a ocupação de espaço de diversos drives, até a criação dinâmica de links conforme o exemplo mostrado no item anterior. Com certeza o objeto FileSystemObject é um dos mais complexos devido ao grande número de métodos e objetos derivados que o mesmo apresenta. Porém, conforme podemos constatar no decorrer deste capítulo, é extremamente simples sua utilização.

652

Capítulo 11 – Os Objetos FileSystemObject, Drive, Folder e File

Alguns cuidados devem ser tomados, principalmente, com métodos que movem ou eliminam arquivos, pois se ocorrem erros, o método terá a execução suspensa na ocorrência do primeiro erro e modificações que já tenham sido feitas não serão revertidas. Por exemplo, se estivermos movendo uma pasta e todas as suas subpastas de uma localização para outra e ocorrer um erro no meio do processo, alguns arquivos terão sido movidos e outros não. Aqueles que foram movidos não serão restaurados ao local de origem. Por isso, sempre é uma boa idéia testar a página ASP que utiliza estes métodos em um ambiente de testes, para somente depois colocá-las em produção. Aliás, ter um ambiente específico para testes é uma excelente idéia não só no desenvolvimento para a Web, mas em qualquer tipo de desenvolvimento de software. No capítulo final deste livro estudaremos uma série de técnicas adicionais que auxiliam e facilitam a criação e a padronização no desenvolvimento de páginas ASP.

653

Capítulo 12 – Tratamento de Erros, Transações e Outros Assuntos

Capítulo 12 Tratamento de Erros, Transações e Outros Assuntos

655

Criando Sites Dinâmicos com ASP 3.0

No início deste capítulo aprenderemos um pouco sobre tratamento de erro em ASP. Apresentaremos o objeto ASPError, bem como algumas dicas e técnicas para o tratamento de erros em páginas ASP. O tratamento de erros é uma das partes mais importantes de qualquer aplicação. Porém, muitas vezes, é simplesmente ignorado, ou não é feito como deveria ser. Sem um tratamento de erro adequado, a aplicação retorna mensagens pouco elucidativas, ou simplesmente pára de funcionar. Com o tratamento de erros, tratamos situações de exceção, procurando prever o maior número possível de casos que podem gerar erros. Além de prever estas situações, escrevemos código para tratá-las adequadamente. Um dos exemplos clássicos de tratamento de erro é o de validação dos dados de um formulário. Vamos supor que tenhamos criado um formulário para cadastro de clientes. Este formulário irá gravar um registro em uma tabela de um banco de dados do Microsoft Access. Vamos supor que os campos Nome e CPF tenham sido definidos como obrigatórios no banco de dados, isto é, o Microsoft Access não irá aceitar que estes campos sejam deixados em branco. Se não fizermos a validação dos dados do formulário, antes de tentar gravar o registro no banco de dados, pode acontecer de o usuário ter deixado um dos campos obrigatórios em branco. Neste caso, ao tentar gravar o registro no banco de dados, será retornada uma página com uma mensagem de erro técnica do tipo: Erro Driver ODBC 840c..... Para usuário comum, esta mensagem de erro é “grego”. O ideal é escrevermos código para verificar se todos os campos obrigatórios foram digitados. Caso algum campo obrigatório não tenha sido preenchido, devolvemos o formulário para o usuário, indicando qual o campo obrigatório que está faltando e mantendo os demais valores já digitados. Com isso o usuário pode preencher o valor que está faltando e salvar o registro sem maiores problemas.

NOTA Implementamos esta técnica de validação de campos em um formulário, em um exemplo do Capítulo 6.

Com isso podemos notar que um correto tratamento de erros torna os nossos aplicativos Web mais “amigáveis” e fáceis de trabalhar. Sempre que possível devemos evitar situações onde o usuário recebe mensagens de erro técnicas, enviadas pelo servidor. Sempre que possível devemos introduzir código para tratamento destes erros, de tal forma que os mesmos possam ser interceptados e, se não corrigidos a tempo, pelo menos possamos enviar uma mensagem mais “amigável”, para que o usuário saiba onde está o problema. Na seqüência aprenderemos sobre o conceito de transações e o Microsoft Transaction Services. Veremos que a utilização do conceito de transações garante que nossas aplicações Web tenham acesso a dados mais depurados e livres de erros.

656

Capítulo 12 – Tratamento de Erros, Transações e Outros Assuntos

Na parte final do capítulo estaremos tratando de assuntos diversos, tais como a utilização da diretiva #include e também o uso de diretivas como @CODEPAGE e @TRANSACTION.

O Objeto ASPError O objeto ASPError é uma das novidades da versão 3.0 do ASP. Para obtermos um objeto do tipo ASPError, utilizamos o método GetLastError do objeto Server. O objeto ASPError, através de suas diversas propriedades, nos fornece uma série de informações a respeito do último erro ocorrido em nossa aplicação Web.

NOTA Quando o IIS encontrar um erro ao compilar ou executar um arquivo .asp, ele gerará um erro personalizado 500;100. Por padrão, todos os aplicativos e sites da Web irão transferir o processamento de um erro personalizado 500;100 para o arquivo .asp padrão. Após a geração de um erro personalizado 500;100, o IIS também criará uma instância do objeto ASPError que descreverá a condição de erro.

Antes de apresentarmos um exemplo de utilização, vamos estudar as propriedades do objeto ASPError.

Propriedades do Objeto ASPError Para utilizar as propriedades do objeto ASPError, utilizamos a sintaxe padrão para acesso às propriedades, conforme indicado a seguir: nome_objeto.Nome_propriedade

Na Tabela 12.1, temos a descrição de todas as propriedades do objeto ASPError. Tabela 12.1 Propriedades do objeto ASPError. Propriedade

Descrição

ASPCode

Retorna um número inteiro, correspondente ao número do erro gerado pelo IIS.

ASPDescription

Retorna uma descrição mais detalhada a respeito do erro.