Zope Básico

Licenciamento de Uso
Este documento é propriedade intelectual © 2002 do Centro de Computação da Unicamp

e distribuído sob os seguintes termos:
1.As apostilas publicadas pelo Centro de Computação da Unicamp podem ser

reproduzidas e distribuídas no todo ou em parte, em qualquer meio físico ou
eletrônico, desde que os termos desta licença sejam obedecidos, e que esta
licença ou referência a ela seja exibida na reprodução.
2.Qualquer publicação na forma impressa deve obrigatoriamente citar, nas páginas

externas, sua origem e atribuições de direito autoral (o Centro de Computação da
Unicamp e seu(s) autor(es)).
3.Todas as traduções e trabalhos derivados ou agregados incorporando qualquer

informação contida neste documento devem ser regidas por estas mesmas
normas de distribuição e direitos autorais. Ou seja, não é permitido produzir um
trabalho derivado desta obra e impor restrições à sua distribuição. O Centro de
Computação da Unicamp deve obrigatoriamente ser notificado
(treinamentos@ccuec.unicamp.br) de tais trabalhos com vista ao aperfeiçoamento
e incorporação de melhorias aos originais.
Adicionalmente, devem ser observadas as seguintes restrições:

• A versão modificada deve ser identificada como tal
• O responsável pelas modificações deve ser identificado e as modificações
datadas
• Reconhecimento da fonte original do documento
• A localização do documento original deve ser citada
• Versões modificadas não contam com o endosso dos autores originais a
menos que autorização para tal seja fornecida por escrito.
A licença de uso e redistribuição deste material é oferecida sem nenhuma garantia de

qualquer tipo, expressa ou implícita, quanto a sua adequação a qualquer finalidade. O
Centro de Computação da Unicamp não assume qualquer responsabilidade sobre o
uso das informações contidas neste material.
Índice
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
Última atualização em 09/10/2002

Programação para a Web utilizando Zope
O que é Zope?
O nome Zope vem de Z Object Publishing Environment, que é uma plataforma de

desenvolvimento de aplicativos web dinâmicos com interface de administração via
browser e orientada a objeto. A maioria de seu código foi escrito em uma linguagem de
programação orientada a objeto de alto nível chamada Python, e sua licença de uso é
aberta. O conjunto de ferramentas que formam o Zope são muito interessantes, e o
destacam em comparação a outras ferramentas. Entre suas características estão:
• Banco de dados transacional orientado a objeto, o ZODB : No Zope

existe um banco de dados transacional orientado a objeto chamado ZODB (Zope
Object DataBase) , no qual são armazenados todos os objetos criados na sua
interface administrativa, tanto pelo sistema, quanto pelos usuários. Normalmente o
Zope armazena seus objetos no ZODB, porém, existem outros bancos de dados que
suportam o armazenamento desses objetos, como por exemplo o Oracle Storage e o
Berkeley Storage. Na grande maioria das instalações usa-se o ZODB, o qual é o
padrão do Zope.
• Servidor Web, o ZServer : O ZServer é um servidor web multiprotocolo que

suporta uma variedade de padrões abertos, como por exemplo, HTTP, FTP, XML-
RPC e WebDAV. Se houver necessidade, ele pode trabalhar conjuntamente com
outros servidores web, como por exemplo o Apache, o IIS e qualquer outro que
suporte PCGI, FastCGI ou mesmo redirecionamentos como o ProxyPass do Apache,
desde que se use products específicos no Zope, no caso, o SiteAccess e
VirtualHostMonster.
• Interface de administração pelo navegador : A interface administrativa do

Zope é acessada através de um navegador, através da qual o administrador do site
poderá fazer o gerenciamento dos conteúdos, como por exemplo, inserir novas
imagens, páginas HTML, entre outros objetos disponíveis dentro do Zope para
gerenciamento de aplicativos web dinâmicos.
Divisão de Serviços à Comunidade – Centro de Computação – Unicamp 1

• Document Template Markup Language, o DTML : DTML é a linguagem

de marcação que o Zope usa para gerenciar contextos dinâmicos nos documentos
que estão armazenados na sua estrutura. Existe a opção de não utilizá-lo, colocando
somente códigos HTML nos documentos, porém estes documentos não estariam
utilizando um dos recursos mais poderosos da plataforma, que justamente é a
facilidade de se conseguir desenvolver contextos dinâmicos com códigos pequenos e
de grande eficiência na manutenção. Pode-se, e também aconselhado, utilizar códigos
em Python e Perl para lógicas complexas, aumentando ainda mais a quantidade de
recursos para utilização no desenvolvimento de aplicações web dinâmicas.
• Integração com Banco de dados Relacional : O Zope suporta conexões

com os bancos de dados relacionais mais utilizados no mercado atualmente, como o
Oracle, SyBase, PostgreSQL e MySQL. Dentro da sua distribuição existe um banco de
dados relacional simples que geralmente é utilizado para testes que se chama Gadfly,
também desenvolvido em Python.
• Products : Os Products são como plug-ins desenvolvidos em Python ou ZClasses,

que extendem as funcionalidades do Zope. Por exemplo, as conexões para banco de
dados relacionais são Products que são instalados na plataforma. Existem muitos
destes Products armazenados no site oficial do Zope, em
http://www.zope.org/Products , que podem ser utilizados livremente.

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 .
Quem pode se beneficiar com o Zope?
É 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:
• Consumidores usam o site para localizar e trabalhar com conteúdo relevante;

• Usuários comerciais criam e gerenciam o conteúdo do site;
• Projetistas do site criam a interface do site e sua arquitetura;
• Desenvolvedores do site criam os serviços oferecidos pelo site;
• Os administradores mantêm o software e o ambiente funcionando;
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.

Quem já utiliza o Zope no Brasil?
Apesar de pouco difundido no país, encontramos grandes empresas já utilizando os

recursos desta poderosa plataforma, algumas delas listadas abaixo:
• 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
Comunicação cliente X servidor web
Quando é digitado um endereço no navegador para acessar uma página na internet, o

que acontece é uma requisição (request) do cliente (navegador) ao servidor web. O
servidor processa essa requisição e retorna uma resposta (response) ao cliente, que por
sua vez interpreta o código retornado e formata a página para a sua visualização. Esse
procedimento acontece em todas as requisições feitas pelo navegador.
• TCP/IP e HTTP: O procedimento anterior só é possível através dos protocolos

TCP/IP e HTTP. O TCP/IP é o protocolo básico para a comunicação entre as
máquinas conectadas à internet, que gerencia toda a parte de transmissão e
distribuição dos dados na rede. O HTTP (Hypertext Tranfer Protocol) é o protocolo que
gerencia e formaliza as requisições e as respostas trafegadas entre o cliente e o
servidor web. Caso o servidor web encontre a página, ela será enviada em partes ao
navegador, caso contrário, o servidor enviará uma mensagem de erro.

Formato das requisições e respostas HTTP
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:
Formato da requisição HTTP
• Linha de requisição : É sempre a primeira linha da requisição, a qual precisa

conter um comando HTTP válido, o caminho da página requerida e a versão do
protocolo HTTP:
Exemplo:
GET /artigos/artigos1.html HTTP/1.1
Os comandos HTTP mais usados são:
GET – faz requisições específicas e sua funcionalidade é limitada, porém é o método

mais usado.

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.

Formato da resposta HTTP
• Linha de resposta : Apenas uma linha indicando a versão do HTTP e o código de

resposta do servidor:
Exemplo:
HTTP/1.1 200 OK
100-199 informativo, indica que a requisição está sendo processada
200-299 requisição bem-sucedida, o servidor enviará o código HTML sem

nenhum problema
300-399 Redirecionamento
400-499 o cliente passou uma requisição incorreta ao servidor, no qual não pôde
ser executada
500-599 a requisição foi enviada corretamente, porém o servidor não pôde

executá-la por estar com problemas internos
• Cabeçalho: Idem ao cabeçalho de requisição, porém este enviará as informações

sobre os aplicativos utilizados no servidor:
Exemplo:
Date: Mon, 11st Feb. 2001, 08:02:43 GMT

Server: Apache/1.3.22 (Unix)
Last-modified: Fri, 08TH Feb 2001, 06:10:00 GMT

• 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.

Instalando e Acessando o Zope
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.
• Instalando : Para instalar o Zope, é necessário descompactar o pacote binário:
$ tar xvzf Zope-2.5.1-linux2-x86.tgz
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:
$ ./bin/python zpasswd.py access

Este script pedirá valores para os seguintes campos:
• Username;
• Password;
• Verify Password;
• Enconding (o padrão é SHA);
• Domain restriction (somente este campo é opcional);
• Acessando : Antes de explicar o procedimento de inicialização dos processos no

servidor, é necessário explicar que a porta padrão para HTTP que o Zope (neste caso
o ZServer) utiliza é a 8080, e para FTP, 8021. Se por algum motivo houver a
necessidade de alterá-las, edite o arquivo z2.py, que está no diretório raiz do Zope.
Neste arquivo existem as variáveis HTTP_PORT e FTP_PORT. Altere os valores que
serão usados e salve o arquivo. Agora precisaremos somente executar o script de
inicialização:
$ ./start &
Com um navegador (browser) como o Internet Explorer, Netscape ou Opera, digitamos na

barra de endereços o seguinte endereço:
http://localhost:8080
Será exibida a página de apresentação da ferramenta, porém, se quisermos acessar sua

interface administrativa, digitamos na barra de endereços o seguinte endereço:
http://localhost:8080/manage
Aparecerá uma janela pedindo as informações de usuário e senha para autenticação.

Deve-se digitar os respectivos valores de usuário e senha do usuário criado na instalação
do Zope. Este procedimento apresentará a interface administrativa do Zope,que se
dividide em três partes:

• Topo : Além de exibir o usuário autenticado no sistema, esta parte tem

funcionalidades de configuração da interface, como as opções Set preferences, na
qual por exemplo, pode-se configurar o tamanho dos campos de edição dos
documentos e métodos; a opção Logout, que expira o acesso do usuário autenticado
no momento, e a opção Zope Quick Start, que exibe a página de apresentação do
Zope.
• Navegador : Esta parte tem como finalidade mostrar a estrutura de navegação

existente dentro do Zope. De forma geral, funciona semelhantemente à gerenciadores
de arquivos, como por exemplo o Windows Explorer do Windows e o Konqueror do
KDE. Como nestes aplicativos, as estruturas que contém sub-estruturas ficam
sinalizadas com o sinal ‘+’ ao lado esquerdo de sua representação visual na interface,
e quando clicado, exibe a sua hierarquia interna tanto nesta parte quanto na parte
explicada a seguir.
• Á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.
• Usuário de emergência ou inicial : É importante observar que este tipo de

usuário não tem acesso para criar nenhum tipo de objeto dentro do Zope, sua
única função é ser utilizado quando perdemos a senha do usuário
administrador, ou quando este é apagado acidentalmente. Para criar um
usuário administrador, o qual possa criar qualquer objeto ou executar qualquer
ação que necessite deste tipo de acesso, deve-se clicar na pasta chamada
acl_users, e logo após no botão Add.

Objetos Básicos do Zope
O responsável pela estruturação do website precisa criar pastas no servidor para

armazenar arquivos de imagens, animações, sons e páginas HTML. No Zope também
temos que criar estes arquivos, mas neste caso específico, em forma de objetos de tipos
como Image, File, DTML Document, entre outros. Explicaremos melhor alguns destes
tipos neste capítulo:
• 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:
• Em Select type to add..., selecionaremos o objeto do tipo Folder;

• Será apresentada uma página com quatro campos a serem preenchidos, onde
somente o campo id é obrigatório, porque este campo é justamente o identificador
dele dentro do Zope.;
• Observação: O formato de um id de objeto pode ser quaisquer valores
alfanuméricos, podendo começar com números e caracteres que não
sejam especiais, como por exemplo, @,#,%, os quais são impróprios
para utilização em uma URL;
• Neste exemplo em específico, vamos colocar o valor engenharia no campo id e o
valor Engenharia no campo Title;
• Os campos Create public interface e Create user folder quando selecionados, criam,
respectivamente, um objeto documento que se chama index_html, que no Zope é a
página inicial do Folder (mais chamado como container ou pasta) e uma pasta de
usuários, chamada acl_users. Neste exemplo não selecionaremos estes campos,
então, clicando no botão Add, efetuamos a operação, que logo após adicionar o
objeto, retorna a interface administrativa, na qual podemos visualizar o Folder criado.
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:

• Contents – exibe todos os objetos inseridos no Folder, este método sempre é o

primeiro a ser chamado quando acessamos os objetos dentro da interface
administrativa;
• View – exibe a página inicial do Folder que, como padrão, pode ser qualquer
documento com o id index_html;
• Properties – exibe todas as propriedades do objeto. Neste tópico, pode-se adicionar

mais propriedades de qualquer tipo suportado pelo Zope;
• 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;
• Ownership – exibe o nome do proprietário do Folder.
• Find – permite fazer pesquisas no Folder. Este tópico fará as pesquisas somente a
partir deste objeto.
• DTML Document : Estes objetos têm a finalidade de armazenar códigos que

geram documentos para a web, como por exemplo, uma página HTML com ou sem
recursos dinâmicos. Vamos adicionar uma página inicial no Folder engenharia com
um objeto deste tipo para entendê-lo melhor:
• Em Select type to add..., selecionaremos o objeto do tipo DTML Document;
• Será apresentada uma página com três campos a serem preenchidos, onde somente
o campo Id é obrigatório;
• Vamos colocar o valor index_html no campo id e deixaremos o campo title vazio;
• 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>
O código acima pertence ao objeto recém-adicionado index_html. Vemos que existem

algumas tags (ou marcações) que não são do HTML. Estas são chamadas de DTML
(Document Template Markup Language), que fazem parte da estrutura do Zope e serão
explicadas nos próximo capítulo. Logo abaixo do campo de edição, existem cinco botões
para configuração de largura, altura e gravação do conteúdo editado neste campo. A
seguir, definimos melhor estes botões que gerenciam o campo de edição :
• Save Changes – salva todas as aletrações feitas no campo de edição do

documento;
• Taller – aumenta o tamanho do campo de edição do documento na vertical;
• Shorter – diminui o tamanho do campo de edição do documento na vertical;
• Wider – aumenta o tamanho do campo de edição do documento na horizontal;
• Narrower – diminui o tamanho do campo de edição do documento na horizontal;
Como em todos os objetos, o DTML Document também tem as abas ou tabs na parte
superior da área de trabalho:
• Edit – exibe a página de edição do documento;
• View – exibe a página de resultado do documento;
• Properties – exibe todas as propriedades do objeto. Neste tópico, pode-se

adicionar mais propriedades de qualquer tipo suportado pelo Zope;
• 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;
• DTML Method : Este tipo de objeto é muito semelhante ao objeto descrito

anteriormente. Sua API e seu funcionamento contêm a grande maioria das
opções necessárias para armazenar conteúdos como no DTML Document,
porém sua utilidade principal é armazenar métodos e scripts para
manipulação de outros objetos. Pode-se colocar qualquer código em um
DTML Method, mas existem alguns tipos de trabalho onde o DTML
Document é mais adequado, como por exemplo, no armazenamento de
uma página HTML que contenha um formulário para receber dados de um
cadastro de clientes no banco de dados. Neste caso, o código que executa
o cadastro do cliente com os dados postados no formulário ficaria em um
DTML Method.:

• File : Quando se insere arquivos de sons, vídeos, entre outros formatos de

arquivos, utiliza-se o objeto do tipo File. É muito simples adicionar e trabalhar com
este tipo de objeto, como mostram as instruções a seguir:
• Em Select type to add..., selecionaremos o objeto do tipo File;
• Será apresentada uma página com três campos a serem preenchidos,

onde somente o campo id é obrigatório, porém, se nenhum arquivo for
selecionado no campo File, o Zope criará um arquivo sem nenhum valor
dentro do Folder;
• Selecionando um arquivo no campo File, não é necessário colocar um id,

pois o Zope atribui o nome do arquivo selecionado como o valor deste
campo. Em seguida, clicamos em Add para que o Zope crie o arquivo e
retorne para a área de trabalho do Folder;
• 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:
<img src=”logo.gif” alt=”logo.gif” width=”150” height=”63”

border=”0”>
Ou podemos utilizar código DTML:
<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:
<img src=”logo.gif” alt=”logo.gif” width=”150” height=”63”

border=”0”>
• 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:
• Join/Leave – exibe a página em que podemos inicializar a sessão;
• Save/Discard – exibe a página para salvar ou descartar as alterações

feitas na sessão;
• Properties – neste objeto esta tab tem a função somente de alterar o valor
do campo Title do objeto;
• 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;

• Em Select type to add..., selecionaremos o objeto do tipo Version;
• 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;
• Para fazer o teste final com o objeto Version curso_zope_sessao, acesse-o e

clique na tab Save/Discard, em que encontramos um campo de edição e os
botões Save e Discard, para salvar ou descartar as alterações feitas na sessão.
Vamos fazer o teste com as duas opções, mesmo que tenhamos que refazer os
passos anteriores, para que vejam os resultados de cada um deles;
• 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
• Introdução ao DTML : O DTML (Document Template Markup Language) é a

linguagem de apresentação do Zope. Tem como finalidade organizar conteúdos do
website de forma dinâmica para uma apresentação eficiente dos dados gerados pelas
lógicas mais simples, como por exemplo, apenas a apresentação do conteúdo de uma
página HTML, ou mesmo pelas lógicas mais complexas, como por exemplo, cálculos
processados por Scripts Python ou External Methods. DTML é executada no servidor
web, para depois enviar o conteúdo resultante, que na verdade, são códigos em
HTML, ao navegador. Suas formações básicas são os recursos descritos neste
capítulo.
• DTML Namespace : O DTML Namespace é uma pilha na qual são armazenados os

nomes de variáveis, atributos e métodos válidos para determinados objetos chamados
no contexto atual. O Zope faz a procura por esses valores sempre de cima para baixo
na pilha de nomes. Primeiramente procurando no objeto cliente, que está no topo da
pilha, para depois procurar no objeto REQUEST, que é sempre o último objeto da
pilha. O objeto cliente depende do tipo que estamos utilizando, por exemplo, o DTML
Document é seu próprio cliente, enquanto o DTML Method utiliza como cliente o
objeto que o chamou, utilizando a aquisição para conseguir ter este contexto de objeto
cliente.
• DTML REQUEST : O DTML REQUEST é o objeto que fica sempre por

último na pilha do DTML Namespace, e este carrega consigo um conjunto
de variáveis de ambiente provenientes da requisição do cliente web
(navegador), e possui a seguinte ordem:

• Ambiente de programação CGI: variáveis padrões do ambiente a serem

utilizadas por scripts web dinâmicos que são oferecidos pelo Zope ao
namespace do objeto REQUEST.
• Formulário: dados relacionados aos campos de formulários do HTML

também se encontram no DTML REQUEST;
• Cookies: dados relacionados aos cookies;
• Variáveis adicionais: outras variáveis de ambiente importantes como por

exemplo URL, BASE e AUTHENTICATED_USER.
• Propriedades no Zope : Como visto anteriormente, a maioria dos objetos do Zope

tem suporte para trabalhar com alguns tipos de propriedades, que auxiliam muito
quando estamos desenvolvendo aplicativos dinâmicos para a web. As propriedades
são variáveis criadas para adicionar mais funcionalidades aos objetos. Os tipos
suportados serão listados a seguir:
• String: uma string é uma espécie de comprimento arbitrário de caracteres.

String é o tipo mais básico e útil das propriedades do Zope;
• 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;
• Long: é um inteiro que não tem nenhuma limitação;
• Float: é um ponto flutuante ou número decimal. Por exemplo, valores

monetários ou frações usam floats;
• Lines: é uma sequência de strings separadas por linhas, e funciona como o

tipo de variável lista do Python;
• Tokens: é uma lista de palavras separadas por espaços;
• Text: funciona como uma string, a não ser pelo fato do Zope normalizar os
caracteres de fim de linha;
• Selection: É uma propriedade especial e é usada para executar um controle

de entradas selecionadas no HTML.

• dtml-var : a tag var tem como finalidade apresentar conteúdos de

propriedades, variáveis e métodos dos objetos passados como parâmetro, por
exemplo:
<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:
<dtml-var nome missing=”Nome Inexistente!”>
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.

• dtml-let : a tag let tem como finalidade adicionar um novo namespace, ou

um namespace temporário para o contexto, isto é, pode-se adicionar novas
variáveis dentro da pilha do namespace, para nosso exemplo, vamos criar um
DTML Document com id teste_dtml-let, e inserir o seguinte conteúdo na sua
estrutura :
<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>
Neste exemplo, criou-se um novo namespace temporário com as variáveis end,

cid e area, porém a variável title foi adquirida do objeto que está armazenando
este código, no caso, em um DTML Document chamado teste_dtml-let. Quando
fechamos a tag let, o namespace criado é retirado do contexto atual:

• dtml-if : como em outras linguagens, o DTML também contém um comando

condicional, a tag if. Esta tag testa as expressões passadas como parâmetro,
direcionando o contexto para o bloco referenciado pela expressão verdadeira.
Como em outras tags, a if aceita testar apenas o nome de variáveis ou
expressões Python. Ela retorna condição falsa caso sejam retornados valores
como 0, None, strings vazias ou seqüências vazias, como no exemplo
abaixo, o qual colocaremos dentro de um DTML Document com id teste_dtml-
if:
<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-if “nome == ‘José’”>

A variável Nome contém - <b><dtml-var nome></b>!
<dtml-elif “nome == ‘João’”>
<dtml-elif “nome == ‘Joaquim’”>
<dtml-else>
A variável Nome contém outro nome qualquer!
</dtml-if>

• dtml-in : a tag in tem como finalidade percorrer uma seqüência de

itens de uma lista que lhe é passada como parâmetro. Esta tag tem a
mesma função do comando for de linguagens como C/C++, Perl e PHP.
Abaixo está um exemplo de sua utilização, o qual colocaremos dentro
de um DTML Document com o id teste_dtml-in:
<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:

<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>
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:
<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>

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:
• sequence-item: corresponde ao valor do item corrente. Caso seja preciso

fazer um teste condicional desta variável, precisaremos utilizar a sintaxe de
expressões do Python, como foi utilizada para ver se o item da seqüência era
igual a Leão.
• sequence-start: contém um valor do tipo boolean que diz se o item da

seqüência é o primeiro da lista.
• sequence-end: contém um valor do tipo boolean que diz se o item da

seqüência é o último da lista.
• sequence-index: funciona como uma variável contadora. Contendo o índice

da seqüência da lista, que começa com o valor 0.
• sequence-number: funciona como uma variável condicional na lista, e

diferente da variável anterior, esta começa com o valor 1, como é mostrado no
exemplo testado.
• sequence-length: contém o valor total de itens na seqüência, no exemplo

testado, ela assume o valor 6.
• next-sequence: contém um valor do tipo boolean, que quando chamada,

(com o dtml-call) pula para o próximo item da seqüência, como usado no
exemplo testado.
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-unless : a tag unless tem como finalidade executar um bloco de

código caso a expressão passada como parâmetro seja falsa. Esta tag
tem a função inversa da tag if, como mostramos no exemplo abaixo, o
qual colocaremos em um DTML Document com id teste_dtml-unless:
<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 : a tag comment tem como finalidade comentar

blocos de códigos. Diferente dos comentários do HTML, os comentários
do DTML nunca irão para o navegador como parte do código. Ótimos
recursos para documentar seus códigos:
<dtml-comment>
este é um comentário em DTML
</dtml-comment>

Conexão com Banco de Dados Relacionais (Nível Básico)
Como explicado anteriormente, o Zope suporta conexões com bancos de dados

relacionais como MySQL, PostgreSQL e Oracle. O objetivo deste capítulo é explicar a
criação de uma estrutura básica para trabalhar com bancos de dados relacionais. Será
utilizado o Gadfly, um banco de dados desenvolvido em Python por Aaron Waters, que foi
incluído ao Zope para demonstração de pequenos conjuntos de dados. Uma página de
cadastro e uma listagem de funcionários serão os nossos exemplos para mostrar como
esta interação do Zope com bases de dados relacionais é feita. Esta atividade foi dividida
em duas partes, uma parte é a criação da estrutura de armazenamento, ligada
diretamente ao Gadfly, e a segunda parte é a criação da estrutura de apresentação e
ligação com a estrutura de armazenamento.
• Primeira parte – estrutura de armazenamento : vamos criar o banco de

dados no sistema operacional e o objeto de ligação entre os aplicativos criados
no Zope e o banco de dados:
Criar um diretório chamado funcionarios em <zope_dir>/var/gadfly,

onde <zope_dir> é o diretório raiz do Zope, como mostrado abaixo;
$ cd <zope_dir>/var/
$ mkdir gadfly
$ mkdir gadfly/funcionarios
$ chown nobody.nobody –R gadfly/
Criar um Folder com id Func e title Funcionários;

Criar um objeto do tipo Z Gadfly Database Connection, o qual
conecta o Zope ao Gadfly, com id conexao_funcionarios_bd, e
Data Sources funcionarios;
Acessando o objeto de conexão ao banco de dados recém-criado,
clicamos na tab test e digitamos a seguinte instrução SQL na caixa
de texto;
create table dados (nome varchar, unidade varchar, ramal varchar)

• Segunda parte – estrutura de apresentação e ligação com o banco de

dados : agora criaremos a parte dos objetos que gerenciarão os dados no
banco, como por exemplo um objeto documento e objetos que executam
instruções SQL:
Criar um objeto do tipo Z SQL Method com id

sql_insere_funcionarios, com arguments nome_arg,
unidade_arg e ramal_arg (separados por espaços em branco) e
com instrução SQL como a abaixo, que conecta as informações
passadas como parâmetro ao banco de dados funcionarios;
insert into dados values(

<dtml-sqlvar nome_arg type=”string”>,
<dtml-sqlvar unidade_arg type=”string”>,
<dtml-sqlvar ramal_arg type=”string”>)
Novamente, criaremos um objeto do tipo Z SQL Method, agora com

id sql_seleciona_funcionarios, e com instrução SQL como a
abaixo;
select * from dados
Agora criaremos um DTML Document com id index_html e

alteraremos seu conteúdo para ficar como o código abaixo;
<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>
Criar um objeto do tipo DTML Method com id cadastra_func_proc,

e com o código a seguir:
<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
•The Zope Book – http://www.zope.org/Members/michel/ZB
•Introdução ao Zope – http://www.laranja.org/ZopeIntro

Autor: Lalo Martins
•Tradução do Zope Book – http://www.tchezope.org

Autores: Equipe TcheZope
• Colaboradores: Alexandre Arroyo, Marcelo G. Malheiros.
Onde obter ajuda
Para ajudá-lo a solucionar dúvidas de informática, utilize o sistema Rau-Tu de perguntas e

respostas, que foi desenvolvido pelo Centro de Computação da Unicamp em conjunto
com o Instituto Vale do Futuro. Tem por objetivo possibilitar que um time de colaboradores
possa responder a perguntas colocadas por qualquer pessoa no site, cobrindo diversas
áreas de conhecimento.
Acesse: www.rau-tu.unicamp.br

Zope Básico

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Zope Básico

Hochgeladen von

Copyright:

Verfügbare Formate

Licenciamento de Uso

Este documento é propriedade intelectual © 2002 do Centro de Computação da Unicamp

1.As apostilas publicadas pelo Centro de Computação da Unicamp podem ser

2.Qualquer publicação na forma impressa deve obrigatoriamente citar, nas páginas

3.Todas as traduções e trabalhos derivados ou agregados incorporando qualquer

Adicionalmente, devem ser observadas as seguintes restrições:

A licença de uso e redistribuição deste material é oferecida sem nenhuma garantia de

Última atualização em 09/10/2002

O nome Zope vem de Z Object Publishing Environment, que é uma plataforma de

• Banco de dados transacional orientado a objeto, o ZODB : No Zope

• Servidor Web, o ZServer : O ZServer é um servidor web multiprotocolo que

• Interface de administração pelo navegador : A interface administrativa do

Divisão de Serviços à Comunidade – Centro de Computação – Unicamp 1

• Document Template Markup Language, o DTML : DTML é a linguagem

• Integração com Banco de dados Relacional : O Zope suporta conexões

• Products : Os Products são como plug-ins desenvolvidos em Python ou ZClasses,

Divisão de Serviços à Comunidade – Centro de Computação – Unicamp 2

Quem pode se beneficiar com o Zope?

• Consumidores usam o site para localizar e trabalhar com conteúdo relevante;

Divisão de Serviços à Comunidade – Centro de Computação – Unicamp 3

Quem já utiliza o Zope no Brasil?

Apesar de pouco difundido no país, encontramos grandes empresas já utilizando os

Comunicação cliente X servidor web

Quando é digitado um endereço no navegador para acessar uma página na internet, o

• TCP/IP e HTTP: O procedimento anterior só é possível através dos protocolos

Divisão de Serviços à Comunidade – Centro de Computação – Unicamp 4

Formato das requisições e respostas HTTP

Formato da requisição HTTP

• Linha de requisição : É sempre a primeira linha da requisição, a qual precisa

GET /artigos/artigos1.html HTTP/1.1

Os comandos HTTP mais usados são:

GET – faz requisições específicas e sua funcionalidade é limitada, porém é o método

Divisão de Serviços à Comunidade – Centro de Computação – Unicamp 5

Divisão de Serviços à Comunidade – Centro de Computação – Unicamp 6

Formato da resposta HTTP

• Linha de resposta : Apenas uma linha indicando a versão do HTTP e o código de

100-199 informativo, indica que a requisição está sendo processada

200-299 requisição bem-sucedida, o servidor enviará o código HTML sem

500-599 a requisição foi enviada corretamente, porém o servidor não pôde

• Cabeçalho: Idem ao cabeçalho de requisição, porém este enviará as informações

Date: Mon, 11st Feb. 2001, 08:02:43 GMT

Divisão de Serviços à Comunidade – Centro de Computação – Unicamp 7

Divisão de Serviços à Comunidade – Centro de Computação – Unicamp 8

Instalando e Acessando o Zope

• Instalando : Para instalar o Zope, é necessário descompactar o pacote binário:

$ tar xvzf Zope-2.5.1-linux2-x86.tgz

$ ./bin/python zpasswd.py access

Divisão de Serviços à Comunidade – Centro de Computação – Unicamp 9

Este script pedirá valores para os seguintes campos:

• Acessando : Antes de explicar o procedimento de inicialização dos processos no

Com um navegador (browser) como o Internet Explorer, Netscape ou Opera, digitamos na

Será exibida a página de apresentação da ferramenta, porém, se quisermos acessar sua

Aparecerá uma janela pedindo as informações de usuário e senha para autenticação.

Divisão de Serviços à Comunidade – Centro de Computação – Unicamp 10

• Topo : Além de exibir o usuário autenticado no sistema, esta parte tem

• Navegador : Esta parte tem como finalidade mostrar a estrutura de navegação

• Usuário de emergência ou inicial : É importante observar que este tipo de

Divisão de Serviços à Comunidade – Centro de Computação – Unicamp 11

Objetos Básicos do Zope

O responsável pela estruturação do website precisa criar pastas no servidor para

• Em Select type to add..., selecionaremos o objeto do tipo Folder;

Divisão de Serviços à Comunidade – Centro de Computação – Unicamp 12

• Contents – exibe todos os objetos inseridos no Folder, este método sempre é o

• Properties – exibe todas as propriedades do objeto. Neste tópico, pode-se adicionar