Escolar Documentos
Profissional Documentos
Cultura Documentos
Introdução ................................................................................................................................... 1
Comunicação Cliente x Servidor web ........................................................................................ 4
Ambiente CGI ............................................................................................................................ 8
Instalando e Acessando o Zope ................................................................................................. 9
Instalando ........... .......................................................................................................... 9
Acessando ..................................................................................................................... 10
Objetos Básicos do Zope ......................................................................................................... 12
Folder ............................................................................................................................ 12
DTML Documet ............................................................................................................. 13
DTML Method ............................................................................................................... 15
File ................................................................................................................................ 16
Image ............................................................................................................................ 16
Version .......................................................................................................................... 17
DTML Básico .............................................................................................................................. 19
Introdução ao DTML ....................................................................................................... 19
DTML Namepsace .......................................................................................................... 19
DTML REQUEST .......................................................................................................... 19
Propriedades no Zope .................................................................................................... 20
dtml-var .......................................................................................................................... 21
dtml-let ........... ............................................................................................................... 22
dtml-if ............................................................................................................................. 23
dtml-in ............................................................................................................................ 24
dtml-unless .................................................................................................................... 28
dtml-comment................................................................................................................. 28
Conexão com Banco de Dados Relacionais (Nível Básico) ..................................................... 29
Primeira parte ................................................................................................................ 29
Segunda parte ............................................................................................................... 30
Referência Bibliográfica............................................................................................................... 32
O que é Zope?
História
Em 1996, Jim Fulton, o CTO da empresa Digital Creations, atual Zope Corporation, e
expert em Python, foi chamado para dar aulas de programação CGI, assunto sobre o
qual sabia pouco. Jim estudou toda a documentação existente sobre CGI no caminho
para a sala de aula. Na volta, Jim pensou sobre o que não gostava dos ambientes de
programação CGI existentes, sua fragilidade, falta de orientação a objeto, e como ela
expõe os detalhes do servidor. A partir destas considerações iniciais, o núcleo do Zope
foi escrito no avião de volta da aula que havia ministrado.
A empresa Digital Creations liberou três pacotes de software de código aberto para
suportar publicação via web, chamados Bobo, Document Template e BoboPOS. Estes
softwares foram escritos em Python. Eles evoluíram nos componentes base do Zope
oferecendo o web ORB (Object Request Broker), a linguagem de script DTML e um
banco de dados orientado a objeto.
Nesta época, a Digital Creations havia desenvolvido uma aplicação comercial baseada
em três componentes de código aberto. Este produto se chamava Principia. Em
novembro de 1998, o investidor Hadar Pedhazur convenceu a empresa a liberar o código
fonte do Principia. Este produto veio então a se chamar Zope e está hospedado em
http://www.zope.org .
É preciso que muitas pessoas trabalhem juntas para criar serviços web. Gerenciar e
coordenar estas pessoas em websites de larga escala pode ser uma tarefa muito difícil.
Identificamos alguns papéis neste cenário:
O Zope pode instalar produtos Zope focados em audiências diferentes. Por exemplo,
Squishdot é uma weblog popular, escrita em Zope, que funciona logo após sua instalação
sem a necessidade de configuração. Os usuários deste product não precisam saber que o
Zope está funcionando por baixo. Outros produtos baseados em Zope, como o CMF, ou
Content Management Framework da Zope Corporation assumem o mesmo enfoque,
visando atender um público que não precisa saber da existência do Zope por baixo.
• Ambev – http://www.ambev.com.br
• IDGNow – http://www.idgnow.com.br
• Revista Época - http://www.epoca.com.br
• Jornal do Brasil – http://www.jb.com.br
• Além destas empresas, a equipe de software livre da Unicamp também já utiliza a
plataforma – http://www.softwarelivre.unicamp.br
Os formatos das requisições e das respostas HTTP são idênticos, como mostramos a
seguir:
Linha de requisição/resposta
Cabeçalho
Corpo
A diferença entre as duas é o conteúdo de cada parte descrita, as quais vamos falar
separadamente:
Exemplo:
POST – este método é mais abrangente que o GET, e é usado para passar informações
para o servidor. Normalmente usado em formulários, que enviam dados ao servidor para
serem manipulados.
• Cabeçalho: trecho composto por várias linhas, que carregam informações sobre o
cliente, como por exemplo, o tipo e a versão do navegador, a data e as informações
gerais dos clientes. Seu conteúdo pode ser variado, contendo outros tipos de linhas, e
para saber quando o cabeçalho termina e o corpo começa, utilizamos uma linha em
branco. No mínimo, uma requisição deve conter uma linha de requisição e um
cabeçalho HOST.
Exemplo:
Accept: */*
Accept-Language: pt-br
Connection: keep-alive
Host: www.zopeteste.com.br
Referer: http://www.zopeteste.com.br/listagem?id=1
User-Agent: Mozilla (X11; I ; Linux I686)
• Corpo: Caso o método GET seja usado na requisição, o corpo estará vazio, mas se
o método utilizado for o POST e a página em questão contiver um formulário HTML
com alguns campos, esses valores serão passados pelo corpo da requisição.
Exemplo:
HTTP/1.1 200 OK
300-399 Redirecionamento
400-499 o cliente passou uma requisição incorreta ao servidor, no qual não pôde
ser executada
Exemplo:
• Corpo: Caso a requisição seja aceita e executada sem problemas pelo servidor web,
o código HTML requerido será enviado ao navegador.
Ambiente CGI
Muitas pessoas têm uma visão distorcida sobre o Common Gateway Interface, pensam
que é uma linguagem de programação, o que não é correto. CGI é uma interface de
comunicação entre o servidor web e programas externos, que normalmente são utilizados
para gerar contextos dinâmicos em páginas HTML. Estes tipos de programas podem ser
desenvolvidos em qualquer linguagem que o sistema operacional do servidor web usado
possa executar, como por exemplo, C, Perl, Python, PHP, Delphi entre outros. Apesar de
seu uso ainda ser muito utilizado, este recurso já está se tornando obsoleto, dando lugar
aos módulos embutidos nos servidores web, que na verdade, podem conter o
interpretador inteiro da linguagem, ou somente parte dele. Linguagens como Perl, Python
e PHP já suportam esse recurso, que tem como vantagem, a maior velocidade de
processamento em relação aos programas CGI, por serem executados pelo próprio
servidor web e não por processos externos, que demandam mais tempo.
Para fazer adquirir os pacotes do Zope precisaremos acessar sua área de downloads em
http://www.zope.org/Products. Nesta página encontram-se os binários e os fontes do
Zope. Nas versões listadas, existem pacotes para Windows, Linux e outros. Deve-se
escolher a versão atualmente estável para a plataforma desejada.
Este comando criará um diretório com todo o conteúdo do Zope, que precisa ser
acessado para executar o script de instalação:
$ cd Zope-2.5.1-linux2-x86
$ ./install
$ chown nobody.nobody –R var/
Por padrão o Zope cria um usuário chamado de emergência ou inicial, que tem o perfil de
administrador (Manager), e as informações sobre este usuário aparecem logo após a
instalação do Zope. O username é admin, e sua senha é gerada automaticamente, sendo
apresentada logo após o username do usuário. Caso não queira utilizar o usuário e senha
criados automaticamente, execute o script chamado zpasswd.py, que está no mesmo
diretório:
• Username;
• Password;
• Verify Password;
• Enconding (o padrão é SHA);
• Domain restriction (somente este campo é opcional);
$ ./start &
http://localhost:8080
http://localhost:8080/manage
• Área de trabalho : Esta parte tem como funcionalidade permitir a manipulação dos
objetos contidos na estrutura atual. Ainda nesta parte, pode-se inserir, renomear,
alterar, deletar, importar ou exportar quaisquer objetos de qualquer dos tipos
suportados pelo Zope.
• Folder : Estes objetos são mais conhecidos como containers ou pastas, que
podem conter outras pastas, documentos, imagens, arquivos de sons, entre
outros tipos suportados. Um Folder trabalha como um diretório no sistema
operacional, porém, gravando seus dados dentro do ZODB. Para adicioná-lo
deve-se seguir o roteiro a seguir:
Clicando no objeto recém-criado, verificamos que ele está vazio, e que na parte superior
da área de trabalho existem abas ou tabs, que servem para configurar os métodos e
atributos de um objeto no Zope, estas tabs são mais bem definidas a seguir:
• View – exibe a página inicial do Folder que, como padrão, pode ser qualquer
documento com o id index_html;
• Security – exibe todas as configurações feitas para o acesso deste objeto, criação de
perfis de usuários, entre outras opções;
• Undo – recurso do Zope que exibe todas as transações feitas no objeto, no qual
podemos recuperar transações feitas por engano;
• Find – permite fazer pesquisas no Folder. Este tópico fará as pesquisas somente a
partir deste objeto.
• Será apresentada uma página com três campos a serem preenchidos, onde somente
o campo Id é obrigatório;
• O campo file nos oferece o recurso de fazer o upload de uma página que já está
pronta, poupando da redigitação desnecessária. Clicando no botão Add, efetuamos a
operação, que logo após adicionar o objeto, retorna para a interface administrativa, na
qual podemos visualizar o documento criado, ou senão clicando em Add and edit, cria-
se o objeto e nos é apresentada a página de edição deste documento. No nosso
exemplo, vamos clicar em Add and edit;
<dtml-var standard_html_header>
<h2><dtml-var title_or_id></h2>
<p>
This is the <dtml-var id> Document.
</p>
<dtml-var standard_html_footer>
Como em todos os objetos, o DTML Document também tem as abas ou tabs na parte
superior da área de trabalho:
• Proxy (Roles) – define com qual perfil este objeto será executado. Se nenhum
perfil for selecionado, o objeto utilizará o perfil do Folder em que está contido;
• History – exibe o histórico das alterações feitas no documento. Este tópico tem a
opção de comparar as alterações feitas com versões mais antigas do documento e
de copiá-las para a presente versão;
• Security – exibe todas as configurações feitas para o acesso deste objeto, criação
de perfis de usuários, entre outras opções;
• Undo – recurso do Zope que exibe todas as transações feitas no objeto, no qual
podemos recuperar transações feitas por engano;
• Image : Um objeto do tipo Image é similar ao objeto do tipo File, com algumas
diferenças, que são propriedades e métodos específicos para a manipulação de
imagens. O Zope consegue manipular e identificar imagens do tipo JPEG, GIF e PNG,
e o procedimento para adiciocnar imagens é exatamente igual ao objeto File. Para
inserir imagens nos documentos, pode-se usar o método normal, que seria
basicamente igual ao código abaixo, em HTML:
<dtml-var logo.gif>
Utilizando este código, temos o mesmo efeito que o código em HTML. Olhemos o código
fonte da página e vejamos o resultado:
• Version : Este é um tipo de objeto muito importante dentro do Zope. Este objeto
abre uma sessão em que podemos alterar, criar e apagar objetos sem que essas
alterações sejam atualizadas imediatamente no website. Pode-se também descartar
essas alterações ou não. Logo após a apresentação das tabs da Version serão
listadas as instruções para criar, inicializar e testar os recursos deste tipo de objeto:
• Properties – neste objeto esta tab tem a função somente de alterar o valor
do campo Title do objeto;
• Será apresentada uma página com dois campos a serem preenchidos, onde
somente o campo id é obrigatório, no nosso exemplo, colocaremos o valor
curso_zope_sessao neste campo. Logo após digitar o valor deste campo,
visualizamos o objeto recém-criado na área de trabalho do Folder;
• Clicando no objeto, vemos que ele possui um botão com o texto Start working in
curso_zope_sessão, o qual inicializará a sessão quando acionado. No nosso
exemplo, acionemos o botão para testarmos suas funcionalidades;
• Vemos que quando acionado, este botão ativa o seguinte texto na parte superior
da área de trabalho, You are currently working in Version
/engenharia/curso_zope_sessao , o qual permanecerá no local até que a
sessão seja fechada;
• Para testar os recursos deste tipo de objeto, adicionemos o valor Página Inicial no
campo title do documento index_html;
• Logo após esta ação, adicionemos um novo objeto do tipo DTML Document, com
o id index_html_2, com o valor Página Inicial 2 no campo title;
• Depois de executar estas duas ações, vemos que na área de trabalho do Folder,
os dois objetos do tipo DTML Document estão com uma figura vermelha com
formato de um diamante, que significa que eles foram alterados ou criados dentro
de uma sessão;
• Um detalhe importante, caso seja necessário sair da sessão, mas sem perder
nenhuma alteração feita dentro dela, e ao mesmo tempo, sem alterar o conteúdo
atual, clique na tab Join/Leave, e logo após em Quit working in
/engenharia/curso_zope_sessão, e para reativá-la, clique novamente neste
botão;
DTML Básico
• Int: é um inteiro que pode ser qualquer número positivo ou negativo que não
seja uma fração. Um int é aproximadamente um inteiro com 32 bits;
• Text: funciona como uma string, a não ser pelo fato do Zope normalizar os
caracteres de fim de linha;
<dtml-var nome>
Neste caso, a tag var mostrará o conteúdo da variável nome. Caso ela não exista
ou não esteja em um namespace válido para o objeto onde está sendo chamada,
será gerada uma página de erro. Existem muitos atributos nesta tag, como por
exemplo o atributo missing, que gera uma exceção caso não exista a variável
nome:
Lembrando que a tag var faz primeiramente uma procura no namespace do objeto
corrente, depois em seu repositório, e finalmente no objeto REQUEST da web.
Outro atributo interessante é o html_quote, ele faz com que o conteúdo inserido
seja visualizado corretamente caso haja caracteres como < ou & no HTML. Uma
listagem mais aprofundada destes atributos é encontrada no apêndice A do Zope
Book.
<ul>
<dtml-let end=” ‘Cid. Univ.’ ” cid=” ‘Campinas’ ” area=”19”>
<li><dtml-var end></li>
<li><dtml-var cid></li>
<li><dtml-var area></li>
<li><dtml-var title_or_id></li>
</dtml-let>
</ul>
<dtml-if nome>
<dtml-var nome>
</dtml-if>
Se a variável nome contiver algum valor verdadeiro, seu valor será exibido, caso
contrário, nada será mostrado. Mesmo sendo retornado um valor falso, queremos
mostrar alguma mensagem para tratar essa exceção, para isso, utilizamos a tag
else:
<dtml-if nome>
<dtml-var nome>
<dtml-else>
<h1>Não existem nenhum valor verdadeiro nesta variável!</h1>
</dtml-if>
Ainda podemos fazer a verificação de múltiplos valores na estrutura da tag if, caso
haja a necessidade deste recurso, utilizamos a tag elif:
<dtml-let lista=”[‘Onça-Pintada’,’Quati’,
’Bicho-Preguiça’,’Tucunaré’,’Sucuri’,’Leão’]”>
<ul>
<dtml-in lista>
<li><dtml-var sequence-item></li>
</dtml-in>
</ul>
</dtml-let>
Neste exemplo foi passada uma variável do tipo lista com 6 itens como parâmetro.
Neste caso, a tag in percorrerá a lista do primeiro ao último item adicionando ao
código HTML o texto do item corrente. Podemos também pegar uma lista
dinamicamente, como por exemplo, pedir uma listagem dos Folders inseridos no
contexto atual. No Folder engenharia, vamos inserir alguns objetos do tipo Folder
para testar o exemplo. Vamos seguir a tabela abaixo:
Id Title
quimica Química
computacao Computação
eletrica Elétrica
civil Civil
Observação: não criar a página inicial nem a pasta de usuário para estes objetos.
Agora, vamos criar um objeto do tipo DTML Method chamado index_html. Caso já
exista um objeto com este nome, renomei-o para index_html_antigo. Alteremos o
código padrão do objeto para ficar como mostra o quadro a seguir:
<dtml-var standard_html_header>
<h2><dtml-var title_or_id> <dtml-var document_title></h2>
<p>
<ul>
<dtml-in “objectValues(‘Folder’)”>
<li><dtml-var title_or_id></li>
</dtml-in>
</ul>
</p>
<dtml-var standard_html_footer>
Nestes dois primeiros exemplos, utilizamos o básico da tag in, então vamos
adicionar mais alguns recursos neste exemplo. Alteremos código do DTML
Document teste_dtml-in para ficar como o exemplo a seguir:
<dtml-var standard_html_header>
<h2><dtml-var title_or_id></h2>
<p>
<ul>
<dtml-let lista=”[‘Onça-Pintada’,’Quati’,
’Bicho-Preguiça’,’Tucunaré’,’Sucuri’,’Leão’]”>
<p><dtml-var lista></p>
<dtml-in lista>
<dtml-if sequence-start>
<p>Números de itens na listagem:
<b><dtml-var sequence-length></b></p>
</dtml-if>
<dtml-if “_[‘sequence-item’] == ‘Leão’”>
<dtml-call next-sequence>
<dtml-else>
<li><dtml-var sequence-number> -
<dtml-var sequence-item></li>
</dtml-if>
</dtml-in>
</dtml-let>
</ul>
</p>
<dtml-var standard_html_footer>
Neste caso foi feito o uso de algumas variáveis que a tag in oferece para tratar os
dados da lista. Abaixo, a explicação destas variáveis e outras que também são
muito importantes:
Como na tag if, a tag in também utiliza a tag condicional else. Novamente,
alteremos o primeiro exemplo para ficar como o código a seguir:
<ul>
<dtml-let lista=”[]”>
<dtml-in lista>
<li><dtml-var sequence-item></li>
<dtml-else>
<li><h3>Não existe nenhum animal nesta lista!</h3></li>
</dtml-in>
</dtml-let>
</ul>
Neste caso, como foi passada uma lista vazia para a tag in, será executada a
excessão na tag else.
<dtml-let teste_var=”0”>
<ul>
<dtml-if teste_var>
<li>Esta variável existe!</li>
</dtml-if>
<dtml-unless teste_var>
<li><font color=”red”>Esta variável não existe!
</font></li>
</dtml-unless>
</ul>
</dtml-let>
<dtml-comment>
este é um comentário em DTML
</dtml-comment>
$ cd <zope_dir>/var/
$ mkdir gadfly
$ mkdir gadfly/funcionarios
$ chown nobody.nobody –R gadfly/
<dtml-var standard_html_header>
<h2><dtml-var title_or_id></h2>
<p>
<h3>Cadastro de Funcionários</h3>
</p>
<form method=”post” action=”cadastra_func_proc”>
<table>
<tr>
<td>Nome:</td>
<td><input type=”text” name=”nome_func”></td>
</tr>
<tr>
<td>Unidade:</td>
<td><input type=”text” name=”unidade_func”></td>
</tr>
<tr>
<td>Ramal:</td>
<td><input type=”text” name=”ramal_func”></td>
</tr>
<tr>
<td><input type=”submit” name=”submit” value=”Cadastrar”></td>
<td></td>
</tr>
</table>
</form>
<p>
<table border=1>
<dtml-in sql_seleciona_funcionarios>
<tr>
<td><dtml-var nome></td>
<td><dtml-var unidade></td>
<td><dtml-var ramal></td>
</tr>
<dtml-else>
<tr>
<td><h3>Não existem funcionários cadastrados!</h3></td>
</tr>
</table>
</dtml-in>
<p>
</p>
<dtml-var standard_html_footer>
<dtml-call “sql_insere_funcionarios(nome_arg=nome_func,
unidade_arg=unidade_func,ramal_arg=ramal_func)”>
<dtml-call “RESPONSE.redirect(‘Func/’)”>
Referência Bibliográfica