fundamentos do zope

Fundamentosdo ZopeMaterial produzido pela Equipe STC do

Programa Interlegis

Fundamentos do Zope 1

Índice geralFundamentos do Zope ...................................................................................................................4

Web Applications .......................................................................................................................4O que o Zope é?..........................................................................................................................5Instalação ......................................................................................................................................5Resumo ..........................................................................................................................................7

Iniciando ............................................................................................................................................8Preparação ....................................................................................................................................8A tela de gerenciamento ...........................................................................................................9Objetos ........................................................................................................................................11Gerenciamento de Objetos ....................................................................................................20Aquisição de Objetos ..............................................................................................................20Resumo .......................................................................................................................................20

As guias do Zope ..........................................................................................................................21A barra de guias do Zope ......................................................................................................21O botão “Import /Export” .......................................................................................................27O link “Help” .............................................................................................................................28O painel de controle do Zope ...............................................................................................29Resumo .......................................................................................................................................31

ZPT ...................................................................................................................................................32Problemas com DTML.............................................................................................................32TAL – Template Attribute Language ...................................................................................32

Python ..............................................................................................................................................38Introdução ao Python ..............................................................................................................38Delimitação de Blocos .............................................................................................................38Variáveis e Identificadores ....................................................................................................38Tipos de Dados Internos ........................................................................................................39Estrutura de Dados ..................................................................................................................40Estruturas de Controle de Fluxo: .........................................................................................44Funções: ......................................................................................................................................47Módulos e pacotes: ..................................................................................................................49Classes: .......................................................................................................................................50Métodos: .....................................................................................................................................50Construtor: .................................................................................................................................51Atributos: ...................................................................................................................................51Atributos e métodos privados: ............................................................................................51Variáveis Estáticas: ..................................................................................................................52

Python e Zope ................................................................................................................................54Python Script .............................................................................................................................54Métodos Externos .....................................................................................................................55O que é um Produto? ..............................................................................................................55Criando um pacote ..................................................................................................................55Criando um Produto ...............................................................................................................56Subclasses de classes Zope ..................................................................................................59

Zope e Banco de Dados ...............................................................................................................61ZODB............................................................................................................................................61RDBMS.........................................................................................................................................61


Zope e o Gadfly .........................................................................................................................62Métodos ZSQL...........................................................................................................................64Resumo .......................................................................................................................................66

A linguagem DTML.......................................................................................................................67Fundamentos .............................................................................................................................67“Namespace” .............................................................................................................................67A sintaxe do DTML..................................................................................................................68Tags e mais Tags ......................................................................................................................69Resumo .......................................................................................................................................76

File System Product ......................................................................................................................77O que é um Produto? ..............................................................................................................77Criando um pacote ..................................................................................................................77Criando um Produto ...............................................................................................................78Subclasses de classes Zope ..................................................................................................80


1Fundamentos do Zope

Este capítulo introduz o uso do Zope para desenvolvimento Web, comoservidor de aplicações e gerenciador de conteúdo Web.

Web ApplicationsA World Wide Web (WWW) já não é mais uma coleção de páginas estáticas, ela

se tornou um grande meio para o transporte de vários serviços. Nesses serviçosincluem- se base de dados, mecanismos de busca, softwares, portais, etc. Algunsdestes serviços são considerados Web Applications porque necessitam de apenasde um navegador para serem acessados e utilizados.

A alta complexidade de algumas Web Applications tornou os recursosoferecidos pela tradicional programação CGI (Commom Gateway Interface)insuficientes ou inadequados, assim fez- se necessário a criação de tecnologiasalternativas como ColdFusion, JSP, ASP, PHP e outras para tornar a criação de WebApplications mais fácil e rápida.

São várias as vantagens oferecidas pelo Zope aos desenvolvedores de WebApplications, dentre elas podemos destacar:

• O Zope possui um servidor web e um servidor de banco de dadosorientado a objetos integrados.

• O Zope é orientado a objetos.

• O Zope pode se conectar a servidores de banco de dados relacionais taiscomo: Oracle, MySQL, MSSQL e PostgreSQL.

• O Zope permite o desenvolvimento de sistemas via Web utilizandoapenas o Navegador.

• O Zope possui código aberto e livre com licença de uso extremamenteflexível.

• O Zope possui total integração com a linguagem orientada a objetosPython o que lhe implementa alto poder de codificação.

• DTML, a primeira linguagem de templates do Zope, permite a codificaçãorápida e eficaz numa sintaxe de tags.

• A linguagem de templates, ZPT, segue a sintaxe XML e permite a criaçãode modelos de páginas para apresentação, além de possibilitar a ediçãode código Zope na maioria dos editores de HTML.


O que o Zope é?Um Servidor de Aplicações WEB

Um servidor de aplicações Web funciona como uma ponte entre o navegador, ossoftwares de aplicações e o banco de dados. O Zope, como servidor de aplicações,funciona como essa ponte provendo a base para o desenvolvimento de aplicaçõesWeb, possibilitando ao desenvolvedor misturar HTML, XML, DTML, SQL, Python eoutras tecnologias no desenvolvimento de aplicações.

InstalaçãoRequisitos

Atualmente a instalação do Zope não necessita de grande quantidade derecursos, o arquivo de instalação para Windows possui, aproximadamente, 10MB epara Linux, aproximadamente, 3MB. Comparado com outros servidores deaplicação Web, o Zope requer poucos recursos sendo que um Pentiun II com 128MBde RAM é suficiente para utilização dos seus recursos. O Zope executa em sistemasWindows 98 e superiores e sistemas Linux e Solaris.

Windows

No Windows, a instalação é feita a partir de um executável que pode ser obtidoem www.zope.org , a partir da execução do mesmo a instalação é iniciada:

Figura 1.1 – Tela de boas vindas da instalação do Zope.


Figura 1.2 – Local de instalação do Zope.

Figura 1.3 – Escolha do tipo de instalação do Zope.


Figura 1.4 – Nome da pasta no Menu Iniciar

Figura 1.5 – Rodar instância Zope como Serviço no Windows?


Figura 1.6 – Local de Instalação da Instância Zope.

Figura 1.7 – Senha do usuário “admin' da instância inicial.


Figura 1.8 – Tela de aviso das opções de instalação.

Figura 1.9 – Progresso da instalação do Zope.


Figura 1.10 – Tela de finalização de instalação.

Após as boas- vindas da instalação selecione o diretório em que você desejainstalar o Zope e o tipo de instalação. Se estiver instalando o Zope em um sistemaWindows NT ou Windows 2000 será apresentada a opção de iniciar o Zope comoum serviço do Windows, caso deseje isto, marque esta opção. A tela seguintesolicita o local onde a instância Zope será instalada. A partir do Zope 2.7.x oservidor Zope(matriz) é instalado em um local e as instâncias são instaladas ecriadas em outro local. Instâncias são, a grosso modo, instalações Zope executáveisque compartilham recursos na instalação matriz. Será perguntado então, a senhado administrador inicial, usuário “admin”, lembre - se desta senha, pois será útilpara que você possa trabalhar com a instância Zope. Se você estiver instalando oZope sob o Windows 9x deverá iniciar o Zope manualmente executando o arquivo“runzope.bat” localizado no diretório de instalação do Zope, se escolheu a opçãode serviço Windows, vá para a administração de serviços do Windows e inicie oserviço Zope. Após isso o Zope será iniciado e por padrão o Zope estará acessívelatravés da URL http: / / localhost:8080 ou http: / / 127.0.0.1:8080 / que deverá serdigitada no seu navegador de preferência.

Para utilizar o Zope, vá ao diretório de instalação ou no menu iniciar ache apasta do Zope e execute o arquivo “runzope.bat” para iniciar a execução doservidor Zope. Para parar o serviço feche a janela de console aberta ao rodarrunzope.bat ou pare o serviço no gerenciador de servições do windows.

Linux

A instalação do Zope no linux é um pouco mais complicada que a instalaçãopara o windows, mas nada que assuste. Aliás o linux é a plataforma aconselhável


para a instalação do Zope, pois oferece maior robustez e melhor performance alémde ser um software livre como é o caso do Zope.

Em primeiro lugar é aconselhado você possuir o Python 2.3.3 ou superiorinstalado na máquina.

1. Acesse a máquina como um usuário ou crie um usuário específico para oZope. Exemplo: zopeuser

2. Faça o download do python source (código fonte) em python.org e coloque napasta de seu usuário, geralmente: /home / no me usuario

3. Faça o download do zope source (código fonte) em zope.org e coloque napasta de seu usuário, geralmente: /home / no me usuario

4. Na pasta de seu usuário descompacte o python e o zope:

>>tar xzvf nomedofontepython.tar.gz

>>tar xzvf nomedofontezope.tar.gz

5. Entre no diretório do python e digite:

>>./configure –-prefix=/home /seuusuario / nomepastapython>>make>>make install

Se tudo ocorrer bem, o python foi instalado na área do usuário na mesmapasta onde está o código fonte. Caso tenha ocorrido algum problema, lembre-se que o python possui dependências com os pacotes task - c- devel e task -c++ - devel.

6. Entre no diretório do zope e digite:

>>./configure –prefix=/home / seuusuario / nomedapastazope --with- python=/home / seuusuario /nomedapastapython / python >>make >>make install

Se tudo ocorrer bem, o zope foi instalado na área de usuário na mesma pastaem que foi descompactado utilizando o python do usuário escolhido.

7. Em seguida é necessário criar uma instância zope, a partir de uma instalaçãovocê pode ter n instâncias para execução. Lembrando que, cada instância deverodar em portas diferentes. Para isso vã para o diretório do Zope e digite:

>>bin/mkzopeinstance.py

8. Após esse comando, você deverá informar o diretório onde a instância serácolocada e usuário e senha de adminstração do zope. Experimente:

Directory: /home/seuusuario/instancia1


Username: admin Password: suasenhaVerify password: suasenha

9. Agora você já possui uma instância zope instalada e deve iniciá- la, para istová para o diretório da instância e digite:

>>bin/zopectl fg

Espere a mensagem “Zope Ready to handle requests”

10. Após a execução o Servidor estará acessível através da URL:http: / / localhost:8080 ou http: / / 127.0.0.1:8080 / que deverá ser digitada noseu navegador de preferência.

ResumoNeste capítulo você aprendeu como instalar o Zope e como o mesmo é

poderoso e útil no que se refere ao provimento de aplicações via Web. No próximocapítulo, você aprenderá os conceitos básicos para o desenvolvimento deaplicações no Zope.


2Iniciando

Neste capítulo, você será apresentado à interface de gerenciamento de objetosdo Zope e aos principais componentes necessários para iniciar o desenvolvimentode aplicações. Você verá também, os principais conceitos relacionados àprogramação orientada a objetos e aos mais importantes objetos do Zope, taiscomo: documentos e métodos DTML.

PreparaçãoPara iniciar o uso do Zope algumas configurações são necessárias após a

instalação.

1. Inicie o servidor através do script runzope.bat (windows) ou runzope ezopectl (linux).

2. Abra o navegador de sua preferência.

3. Digite http: / / localhost:8080 / e leia as informações que serão apresentadas(figura 2.1).Se desejar acessar diretamente o sistema de administração digitehttp: / / localhost:8080 / ma nage / (figura 2.2).

4. Entre o nome e senha apresentados na instalação do sistema.

Figura 2.1 – Tela de início do servidor Zope.


Figura 2.2 – Tela de gerenciamento do Zope.

Criando Contas de Usuários

Após a visualização da tela de gerenciamento, crie uma conta para você,seguindo os passos:

1. Clique em acl_users (figura 2.3).

2. Em seguida, clique em Add.

3. Entre com o nome de usuário (username) e a senha (password e confirm).

4. Selecione Manager nas opções listadas em Roles.

Figura 2.3 – Folder acl_users

A tela de gerenciamentoVamos dar uma olhada na tela de gerenciamento do Zope e ver como ela

trabalha. Primeiramente, feche o seu navegador. Agora abra o seu navegador eentre no Zope com o usuário e senha criados anteriormente, a tela degerenciamento será apresentada (figura 2.4) e nela podemos identificar três partes.


Figura 2.4 – Tela de gerenciamento apresentada ao usuário do tipo Manager.

A parte esquerda nos mostra a visão hierárquica das pastas (Folders) e outrosobjetos containers do Zope (figura 2.5).

Figura 2.5 – Visão hierárquica do Zope.

A parte superior informa o usuário corrente e menu de opções de navegação(figura 2.6).

Figura 2.6 – Informações de usuário e menu de navegação.


A parte direita nos mostra a visão dos objetos de um dado container ou folder,menu de objetos para adição e nas guias superiores as várias páginas degerenciamento do objeto selecionado (figura 2.7).

Figura 2.7 – Guias, objetos e menu de objetos.

ObjetosVamos ver agora, como é a abordagem de orientação a objetos do Zope.

Mostraremos como copiar, criar, remover e renomear objetos no Zope bem comoefetuar outras tarefas básicas.

Zope e a OOP

A principal característica do Zope é o fato dele ser orientado a objetos. Aorientação a objetos é um paradigma de programação baseado na idéia de que omundo é constituído de objetos. Um objeto é algo real ou não que possui estado,habilidade de executar ações e capacidade de se comunicar com outros objetos. Emprogramação podemos representar qualquer objeto, real ou não, através depropriedades (características ou atributos) e métodos (ações ou funções).

Por exemplo, podemos representar um cd- player através de suascaracterísticas como: marca, peso, cor, modelo e etc; e através de ações que eleexecuta: tocar, pausar, avançar e etc. Assim um cd- player pode ser representadoatravés de um objeto com propriedades e métodos.

Contudo, se avançarmos um pouco mais, nós veremos que a maioria dos cd-players possui atributos e métodos comuns, sendo assim, quando definimos aestrutura de atributos e métodos de um cd- player estamos definindo uma classeque agrupa todos os cd- players. Assim um objeto é cada instância de uma classe,


isto é, cada cd- player existente no mundo é um objeto da classe cd- players quedefinimos anteriormente.

Quando estiver trabalhando com o Zope você estará, basicamente, trabalhandocom objetos, pois cada folder, método dtml, ou outro objeto criado no Zope seráuma instância das classes folder, Dtml Method, e outras classes presentes no Zope.

A seguir, veremos os objetos fundamentais do Zope e suas principaisfuncionalidades.

Folders

Um folder (pasta) é um objeto que pode conter outros objetos. Para criar umfolder vá para o folder onde o novo folder será criado e selecione “Folder” no menu“Select type to add” (presente no lado direito da tela de gerenciamento) e entãoforneça a informação necessária para a criação do folder (figura 2.8)

• Id: Nome pelo qual o Zope identifica o objeto, deve ser único em umdado folder.

• Title: Campo opcional que provê uma descrição detalhada do folder queajuda na identificação do mesmo.

• Create public interface: Se selecionar esta opção um documento DTMLchamado index_html será criado dentro do novo folder. UmPageTemplate com o nome index_html é o documento padrãovisualizado pelo usuário quando o mesmo acessar um folder vianavegador.

• Create user folder: Selecionando esta opção criará um user folder (folderde usuário) dentro do qual você pode definir que usuários terãopermissão de acesso a esse folder e seus objetos.

Figura 2.8 – Tela de informações para adição de um Folder.

Exemplo:

Vamos criar um folder para conter imagens, siga os passos:

1. Vá para a raiz do Zope (indicado pelo símbolo /) e crie um folder com Idigual a Imagens, deixe as opções de Public interface e User foldervazias. Se desejar escreva algo no campo Title.

2. Clique em Add para confirmar (figura 2.9).


3. Clique no novo folder para abrí - lo e então você verá que o mesmo estávazio (figura 2.10).

Figura 2.9 – Informações do folder de imagens.

Figura 2.10 – Folder Imagens sem nenhum conteúdo.

Todos objetos contidos em um folder, tais como imagens e arquivos, sãoatribuídos ao folder que os contêm e se tornam atributos deste folder. Objetos quepodem conter outros objetos, tais como os “folders”, são chamados de containeres,pois possuem a funcionalidade de conter outros objetos.

Arquivos

Antes que você possa trabalhar com imagens e arquivos no Zope, é necessárioque você os crie. Para criar objeto imagens escolha Image no menu “Select type toadd”, para todos os outros tipos de arquivos selecione o objeto File.

Você deve preencher o formulário (figura 2.11) para cada objeto File ou Imageque você deseja inserir.

• Id: Identificador interno do Zope.

• Title: Título opcional.

• File: Caminho completo até o arquivo. Use o botão browse paraselecionar o arquivo desejado.


Figura 2.11 – Formulário de informações para adição de uma imagem.

Exemplo:

Vamos inserir uma imagem ao folder Imagens:

1. Entre no folder Imagens criado anteriormente.

2. Selecione Image no menu “Select type to add...”.

3. Forneça um Id e um Title para o objeto.

4. Especifique o caminho da imagem ou selecione utilizando o botãobrowse e escolha um imagem a ser adicionada.

5. Clique em Add (figura 2.12), para adicionar o objeto ao folder Imagens.

Figura 2.12 – Informações da imagem adicionada.

6. Após a inserção, clique sobre a imagem.

Visualize suas propriedades na guia Properties (figura 2.13).


Figura 2.13 – Informações da guia Properties.

7. Visualize a sua aparência na guia View (figura 2.14).

Figura 2.14 – Informações da guia View.


Documentos e Métodos DTML

Até agora você aprendeu como inserir folders, imagens e arquivos em seuservidor Zope, agora daremos uma olhada em documentos e métodos DTML.Embora haja alguma semelhança, esses objetos se diferem na forma de uso efuncionalidade.

DTML (Document Template Markup Language) é a linguagem do Zope quepermite a criação de conteúdo dinâmico, assim como scripts ASP e JSP, a DTMLpossui um conjunto de tags que permite a criação de páginas dinâmicas na WEB.Você pode utilizar a DTML tanto em documentos DTML (DTML Documents) comoem métodos DTML (DTML methods).

Em geral, os documentos DTML são usados para armazenar texto, documentoscomplexos e com grande conteúdo de informação; eles são como páginas web, mascom a possibilidade de geração dinâmica de conteúdo.

Já os métodos DTML são usados para a execução de ações sobre dados econteúdo. Os métodos DTML, ao contrário dos documentos DTML, não possuempropriedades próprias, isto é, eles assumem as propriedades do documento que osinvocar ou utilizam, funcionam assim, como uma função que executa alguma ação.Os métodos DTML são os objetos mais indicados para a geração dinâmica deconteúdo e para criação de componentes genéricos, pois possuem umafuncionalidade maior que os documentos DTML.

Documentos DTML

Para criar um documento DTML, vá ao folder no qual deseja inserir o novodocumento (se possível utilize o folder Imagens criado anteriormente) e selecioneDTML Document no menu de “Select type to add”, complete o formulário (figura2.14) com as seguintes informações:

• Id: Identificador interno do Zope.

• Title: Título opcional.

• File: Insere conteúdo de um arquivo no documento DTML. Use o botãobrowse para selecionar o arquivo desejado.

• Add: Clique neste botão para criar o documento DTML. Se desejar criar ejá iniciar a edição do documento clique no botão Add and Edit.


Figura 2.15 – Formulário de informações para criação de um documento DTML.

Para editar o documento clique sobre o mesmo e então surgirá a tela de ediçãocom suas guias de opções. Na guia Edit é possível editar o conteúdo do documento(figura 2.16) e fazer a carga de arquivos (upload) para o documento DTML.Experimente visualizar o conteúdo das outras guias para se familiarizar cominformações que serão vistas futuramente e colocar o conteúdo do documentoDoc1 de acordo o visto na figura 2.16.

Figura 2.16 – Tela de edição de um documento DTML (Doc1).


Métodos DTML

Agora, vamos criar um método DTML que define a forma que as figurascontidas no folder Imagens (criado anteriormente) serão apresentadas.

1. Abra o folder onde você quer criar o método (se possível utilize o folderImagens criado anteriormente) e selecione DTML Method no menu “Selecttype to add” e então preencha os campos apresentados (figura 2.17).

Figura 2.17 – informações para a criação de um método DTML.

2. Clique Add and Edit.

3. Substitua o código existente na caixa de texto pelo código apresentado nafigura abaixo (figura 2.18).

4. Clique em Save Changes.

5. Clique em View e visualize sua primeira página Web criada com o Zope.Ela deverá se parecer com a página mostrada na figura abaixo (figura2.19).


Figura 2.18 – Código fonte do método DTML 1.

Figura 2.19 – Exemplo de Visualização da página gerada pelo método DTML 1.


Gerenciamento de ObjetosVamos aprender como gerenciar os principais objetos vistos neste capítulo,

nós veremos como copiar, mover e renomear folder, métodos DTML, documentosDTML, etc.

Você pode mudar determinadas propriedades dos objetos inseridos noservidor Zope. O Id, por exemplo, só pode ser alterado no folder ou container quepossui o objeto através do botão “Rename”. Já, a propriedade “Title” pode seralterada na própria guia “Edit” do objeto com o uso de sua caixa de texto.

Através do botão “Copy”, “Cut” e “Delete” você pode copiar, recortar e removerobjetos de um folder ou container e através do botão Paste colar objetos para umfolder ou container.

Aquisição de ObjetosO Zope organiza o relacionamento de seus objetos através de um mecanismo

chamado aquisição. É através da aquisisção que o Zope consegue cria umaestrutura eficiente no tratamento de informação.

A idéia da aquisição é a seguinte: quando você coloca um objeto em um folderou “sub- folders”, você acaba criando uma hierarquia de objetos que o Zope usarápara reconhecer um objeto chamado. Assim, objetos em um folder herdam todasas propriedades do folder que os contém, criando um conjunto de atributos que oobjeto pode acessar. A esse conjunto é dado o nome de “namespace”. Em um“namespace” de um objeto estão todos os atributos diretamente acessíveis a esseobjeto.

O Zope monta o “namespace” de um objeto através do mecanismo deaquisição. Por exemplo, ao criar um documento DTML em um folder, o Zope saberáque o “namespace” deste objeto é o conjunto de todos atributos do próprio objetomais os atributos de todos os “folders” hierarquicamente superiores. Assim,quando um objeto referencia um outro objeto o Zope procura o objeto referenciadono folder corrente do objeto e na hierarquia superior até que o encontre.

Caso um objeto deseje referenciar um outro objeto ou um atributo que não estáem seu “namespace”, ou melhor, em sua hierarquia de mesmo nível ou superior,ele deverá referenciá- lo explicitamente através da tag “with” que será vista nocapítulo 5.

ResumoNeste capítulo, as principais guias e botões do Zope se tornaram familiares a

você. Conceitos fundamentais foram expostos e você está pronto para seaprofundar no uso do Zope e começar a desenvolver pequenas aplicações em Zopeatravés de seus objetos e de sua linguagem, a DTML.


3As guias do Zope

Este capítulo mostrará como usar as guias do Zope para executar váriasfunções para diferentes tipos de objetos existentes.

A barra de guias do ZopeA barra de guias do Zope permite o acesso a várias interfaces que podem ser

usadas para configurar objetos do Zope. As guias e funções disponíveis dependemde qual objeto está selecionado e de quais permissões o usuário corrente possuiem relação ao objeto selecionado.

Veremos agora, as funcionalidades das principais guias.

A guia “Contents”

Quando você seleciona um objeto do tipo folder ou outro objeto do tipocontainer na tela de gerenciamento, a guia “Contents” se abre e lhe mostra todos osobjetos daquele folder juntamente com seus “Id´s” e “Titles” (figura 3.1).

Figura 3.1 – A guia “Contents”


Essa guia permite a você criar, renomear, copiar, recortar, mover, excluir,importar e exportar objetos através de botões situados na parte inferior da tela,além de permitir a adição de objetos através de um menu de escolha “Select type toadd...” e um botão “Add”, situados na parte superior da tela de gerenciamento.

A guia “Edit”

Quando um objeto é do tipo não container, ao ser clicado o Zope lhe mostrará aguia “Edit” que permitirá a edição do conteúdo dos objetos. Exemplos de objetosnão containeres que podem ser editados são métodos e documentos DTML, jáoutros objetos como: Imagens (“Images”) ou Arquivos (“Files”), não podem sereditados sendo permitido apenas a mudança de “Id´s”, “Title´s” e atualização doobjeto. Portanto, cada objeto possui diferentes funcionalidades na guia “Edit”dependendo de seu conteúdo e tipo.

Clique sobre um documento ou método DTML e a guia “Edit” aparecerá (figura3.2). Os botões “Taller”, “Shorter”, “Wider” e “Narrower” permitem a mudança detamanho da caixa de edição de texto, experimente - os e veja o que acontece. Casovocê faça alguma alteração de conteúdo clique sobre o botão “Save Changes” parasalvar o conteúdo alterado. Caso deseje visualizar as alterações feitas clique naguia “View” (descrita a seguir) e no botão “Back” de seu navegador para retornar àguia “Edit”.

Figura 3.2 – A guia “Edit”.

A guia “View”


A guia “View” permite a visualização de objetos da forma como os mesmosserão apresentados pelo navegador (figura 3.3), ela estará disponível somente paraobjetos que podem ser exibidos através do navegador, tais como: imagens,métodos e documentos DTML e etc.

Figura 3.3 – A guia “View”.

A guia “History”

Esta guia aparece somente para documentos e métodos DTML, scripts e “PageTemplates”, ela possibilita a visualização de qualquer modificação feita no objetoarmazenando assim a história do objeto (figura 3.4). Ela funciona como um controlede versão possibilitando a comparação entre dois objetos (botão “Compare”) eainda a recuperação de um documento antigo para a versão atual (botão “Copy topresent”).


Figura 3.4 – A guia “History”.

A guia “Undo”

A guia “Undo” é utilizada para desfazer ações. Na guia “Undo” é possívelvisualizar todas as ações executadas como o objeto (figura 3.5). Caso este objetoseja um folder ou container serão apresentadas todas as ações executadas paratodos os objetos contidos no folder ou container.

Nela você poderá desfazer todas ações executadas pelo usuário corrente emuma ordem de execução que garanta integridade às ações.

Figura 3.5 – A guia “Undo”


A guia “Find”

A guia “Find” (figura 3.6) possibilita uma variedade de pesquisas em objetosdo Zope, ela é utilizada para encontrar objetos no Zope. Experimente buscarobjetos selecionando várias opções de pesquisa para se familiarizar com esta guia.

Figura 3.6 – A guia “Find”

A guia “Properties”

Lembre- se de que tudo no Zope é objeto, assim como objetos possuempropriedades esta guia permite a você criar, remover e alterar propriedades paraum objeto (Figura 3.7). Por exemplo, você possuir um documento DTML quearmazene um texto e neste documento adicionar propriedades que armazenarãocaracterísticas deste texto. Assim você pode adicionar propriedades como linhas,auto, palavras chaves e outros ao documento DTML para que o mesmo possaarmazenar informações sobre o texto que possui.


Figura 3.7 – A guia “Properties”

Cada propriedade adicionada possui um nome, um valor e um tipo. Tipos como“boolean”(lógico), “date”(data), “float”(real), “int”(inteiro), “string”(cadeia decaracteres) e “long”(inteiro longo) são auto descritivos, mas existem tipos quecabem uma descrição mais detalhada

• “Lines” – é o tipo que produz uma lista de valores. Se desejar usá - lodeixe o campo “Value” vazio, pois a inclusão de valores será permitidaapós a inserção da propriedade.

• “Text” – assim como o tipo string, este tipo consiste em uma cadeia decaracteres. A diferença consiste no fato de que o tipo “Text” permite acriação de texto com múltiplas linhas.

• “Tokens” – consiste de uma linha de valores separados por espaço. Afuncionalidade do tipo “Tokens” é que ele permite um busca otimizada.

• “Selection” e “Multiple Selection” – o tipo “Selection” cria uma lista “Pull-Down” de valores onde apenas uma pode ser selecionada (no tipo“Multiple Selection” é permitido a seleção de vários valores). No campo“Value” deve- se colocar o nome de uma propriedade ou método quepossui a lista de valores a serem apresentados.

• Não deixe de experimentar a criação de propriedades para algunsobjetos, pois é através do uso e da pesquisa que aprendemos.

A guia “Ownership”

A guia “Ownership” permite a configuração de um proprietário para o objeto.Quando você cria um objeto, o Zope automaticamente o coloca como proprietáriodaquele objeto e através desta guia será possível dar permissões de propriedade ausuários (veja capitulo 6 para maiores detalhes sobre permissões).


Figura 3.8 – A guia “Ownership”

O botão “Import/Export”O botão “Import /Export” permite a importação e exportação de objetos Zope.

Todos os objetos criados no Zope são armazenados em uma base de dados que seencontra no arquivo data.fs no diretório var dentro do diretório de instalação doZope. Para trocar objetos entre servidores Zope é necessário a exportação econseqüente importação dos objetos desejados em arquivos.

Para exportar um objeto, selecione- o e clique no botão Import /Export e entãoselecione se a exportação se dará no servidor (“Save to file on server”) ou namáquina local (“Download to local machine”) e se o formato se dará em XML (figura3.9). Se você não sabe o que é XML não deixe de pesquisar, pois o XML (eXtensibleMarkup Language) tem se tornado o formato padrão para o intercâmbio deinformação entre aplicações. Bem, voltando, após a seleção das opções acima cliqueno botão “Export” e então o arquivo será criado no servidor ou máquina local e noformato desejado. Caso você não tenha escolhido o formato XML um arquivo noformato .zexp será criado, este arquivo é extremamente menor do que o formatoXML, porém ele é um formato interno do Zope que não possui a mesmaflexibilidade do formato XML.


Figura 3.9 – Importação e Exportação de um objeto.

Para importar um objeto, você deve informar o caminho completo do arquivoem sua máquina local e escolher entre se tornar proprietário (Take ownership ofimported objects) ou manter as propriedades originais (Retain existing ownershipinformation).

O link “Help”Como cantavam os Beatles, “Help, I need somebody…”. Em todos os softwares

que utilizamos há momentos em que necessitamos de ajuda. O Zope possui umaajuda poderosa, só que em inglês, mas vale à pena quando você estiver com dúvidasobre alguma funcionalidade clicar no link “Help” localizado no canto superiordireito das telas do Zope. Esse link trará informações sobre o tópico corrente alémde uma árvore de opções para seleção e pesquisa de assuntos (figura 3.10). Paraaqueles em que o inglês não é problema acredito ser o “Help” uma ótima fonte deconhecimento.


Figura 3.10 – O “Help” do Zope.

O painel de controle do ZopeO Zope possuir um folder especial chamado Control Panel (Painel de Controle),

este folder está localizado abaixo do folder Root e possui informações sobre oservidor Zope (figura 3.11).

Figura 3.11 – Tela inicial do Painel de Controle.


O botão “Shutdown”

Este botão permite você parar o servidor Zope sendo que o acesso ao servidorestará disponível somente após nova inicialização. Seja cuidadoso ao usar estebotão, pois se algum usuário estiver utilizando o Zope e possuir conteúdo nãosalvo, estas informações serão perdidas.

O botão “Restart”

Este botão estará visível para instalações executando como um serviço Win32do Windows ou como um “daemon” no Unix ou Linux. Ele permite que o servidorseja desligado e imediatamente reiniciado. Como o anterior deve ser utilizado comcautela.

“Database Management”

Esta opção possibilitará a configuração da base de dados do Zope, através deguias (figura 3.12) é possível configurar parâmetros de cache e do banco de dados.A principal opção de gerenciamento da base de dados é a opção “Pack” que permiteque você discarte a história de objetos mais velhos que o número de diasselecionados. Assim a base de dados se tornará menor e seu desempenho seráotimizado. É aconselhável que utilize esta opção toda vez que observar que seuarquivo Data.fs esta grande demais e que existem muitos objetos na guia “History”e “Undo”.

Figura 3.12 – Guias do “Database Management”.

“Version Management”

O Zope possui um controle de versão que permite que você execute tarefas quenão estarão acessíveis a outros usuários do Zope enquanto você ainda não finalizouo trabalho. Assim ao final essas modificações serão disponibilizadas todas de umaúnica vez (veja Capítulo 5 para maiores detalhes).

“Product Management”

A tela de gerenciamento de produtos possibilita a visualização de todos osprodutos instalados no Zope (figura 3.13). O gerenciamento de produtos está forado escopo desta obra, sendo que maiores informações podem ser obtidas emfuturos lançamentos por esta editora ou pelo site www.zope.org .


Figura 3.13 – Guias de “Product Management”

“Debugging information”

A tela de depuração do Zope permite a visualização de informação que oajudaram a encontrar e reparar erros de execução do servidor Zope. Este é mais umtópico avançado que está fora do alcance desta obra e que será abordado em obrasfuturas, maiores informações sobre este tópico podem ser obtidas em futuroslançamentos desta editora ou pelo site www.zope.org .

“WebDAV Lock Manager”

Esta tela permite a visualização e gerenciamento dos objetos que estãobloqueados pelo protocolo WebDAV. Este é outro tópico que foge ao escopo destaobra, maiores informações no site www.zope.org ou em outras obras sobre oassunto.

ResumoNeste capítulo você se familiarizou com as principais funcionalidades de

administração e configuração do Zope. No próximo capítulo você verá detalhessobre a linguagem de script do Zope, a DTML. É ela que propiciará a você a criaçãode conteúdo dinâmico em web sites através do Zope. Lembre - se que a prática levaao conhecimento, portanto destine algumas horas para revisão e uso dos conceitosaprendidos até esse momento.


4ZPT

Neste capítulo falaremos sobre o ZPT ou Zope Page Templates, uma linguagemde templates inserida na versão 2.5 do Zope.

Problemas com DTMLO ZPT é a nova linguagem de Templates do Zope, pois antes da versão 2.5 do

Zope, o mesmo só possuia a DTML como linguagem de templates. Porém, o DTMLapresenta alguns problemas:

● DTML não é reconhecido por editores HTML's padrões, pois possui umconjunto de tags próprias

● As tags DTML se misturam às tags HTML o que torna o código confuso

● DTML enfatiza a mistura de apresentação e lógica, o que é uma má práticade programação.

● DTML não é renderizável em editores WYSIWYG

TAL – Template Attribute LanguageO ZPT constitui - se de uma linguagem chamada TAL que é uma linguagem de

atributos cuja sintaxe é baseada em XHTML. A idéia básica do ZPT é que oscomando de processamento fiquem dentro das Tags HTML ou XML.

Exemplo:

<span tal:replace=”user/getUserName”>Aqui entra o nome do usuário</span>

No exemplo acima, a tag span será substituida pelo conteúdo deuser /getUserName. O comando tal:replace é um dos comandos da ZPT e é um XMLnamespace seguido do atributo(namespace:atributo).

Comandos TAL

O tal define alguns comando para a adição de conteúdo dinâmico aos arquivosHTML e XML, são eles: replace, content, repeat, condition, attributes, define, omit -tag e on- error

replace

O comando replace substitui o conteúdo e a própria tag com o resultado daexpressão.


Exemplo:

<b tal:replace=”here/title”> Título</b>

<i tal:replace=”string: usuario: ${user/getUserName}”>Usuário</i>

<td tal:replace=”python: request.get('logado',0)”>Logado</td>

Nos exemplos acima, apesar de todos os comandos estarem dentro de tags queimprimem alguma formatação à saída, nenhuma formatação será gerada, pois tantoo conteúdo (Título, Usuário, Logado) como as próprias tags (b, i, td) serãosubstituídas pelo valor das expressões tal:replace.

content

Esse comando tal é praticamente idêntico ao comando replace, exceto pelo fatoque apenas o conteúdo da tag será substituído pelo valor da expressão. Nesse casoentão, a formatação é respeitada.

Exemplo:

<b tal:content=”here/title”> Título</b>

<i tal:content=”string: usuario: ${user/getUserName}”>Usuário</i>

<td tal:content=”python: request.get('logado',0)”>Logado</td>

Nos exemplos acima, as tags (b, i, td) serão respeitadas e as formataçõesaplicadas serão renderizadas para o cliente.

define

O comando define permite a definição de variáveis de bloco para uso emexpressões tal.

Exemplo:

<table tal:define=”username user/getUserName”><tr>

<td tal:content=”username”>Aqui entra o nome do usuário</td></tr></table>

repeat

O comando repeat permite a iteração sobre valores de uma lista. Ele seassemelha aos comandos de laço das linguagens de programação.

Exemplo:

<table><tr tal:repeat=”id here/objectIds”>

<td tal:content=”id”>Id do Objeto</td></tr>

</table>

condition

O comando condition permite o teste de condição em uma expressão, com afinalidade de tomar decisão em relação à apresentação de um conteúdo.

Exemplo:


<table><tr >

<td tal:condition=”request/logado | nothing”> Já está logado</td><td tal:condition=”not :request/logado | nothing”> Não está logado</td>

</tr></table>

No exemplo acima, a variável de request “logado” foi usada para verificar qual amensagem deverá ser apresentada na tabela.

attributes

O comando attributes permite a criação ou alteração de valores de atributos detags HTML ou XML dinamicamente. Por exemplo, vamos supor que o link, atributohref, de uma tag <a>, dependa do contexto do objeto corrente. Nesse caso, épossivel usar o comando attributes para resolver criar ou mudar o atributo href datag <a>.

Exemplos:

<a href=”#” tal:attibutes=”href here/absolute_url”>Link</a><td width=”0” tal:attributes=”width python: here.width/2”>Célula</td><font tal:attributes=”color string:#FFFF${here/color}”>Texto</font>

omit- tag

O comando omit - tag faz o contrário do comando content. Enquanto o comandocontent substitui o conteúdo de uma tag com o valor da expressão, deixando a tagem que foi colocado intacta; o comando omit - tag retira a tag em que é colocado,deixando o conteúdo interno intacto. Se a expressão avaliada pelo omit - tag forfalsa a tag é retirada e se for verdadeira a tag é deixada. Porém, deve- se lembrarque o conteúdo dentro da tag em que o comando é colocado é sempre mantido.

Exemplo:

<div tal:omit-tag=”here/valor” bgcolor=”#333333”><p> Não sei a cor de fundo</p>

</div>

Se a expressão here /valor for verdadeira então a tag div será retirada e a tag<p> aparecerá normalmente. Porém, se a expressão here /valor for falsa a tad<div> é mantida.

on- error

O comando on- error permite o tratamento de erros ocorridos em um trecho decódigo, possibilitando a apresentação de uma mensagem, o redirecionamento parauma página, a execução de um objeto e outras atividades a fim de minimizar outratar o erro.

Exemplo:

<div tal:repeat=”registro here/registros” tal:on-error=”python: here/trataerro”><span tal:replace=”registro/id”/>

</div>

No exemplo acima , caso ocorra um erro ao manipular os registros o script“trataerro” será invocado.


Ordem de precedência e execução dos comandos TAL

Você pode utilizar vários comandos TAL em uma única tag XML ou HTML, masdeve- se lembrar que existe uma ordem de execução dos comandos

1. define

2. condition

3. repeat

4. content ou replace

5. attributes

6. omit - tag

Expressões

Você já deve ter observado que, nos exemplos, usamos vários formatos deexpressões nos comandos TAL. Existem várias maneiras de escrever expressões emTAL, sendo elas

1. path – a expressão é constituída de um caminho ao objeto, método oupropriedade a ser avaliada.

2. python – a expressão é uma expressão escrita em python utilizando ooperador de ponto para caminhar aos objetos, propriedades e métodos.

3. string – a expressão é uma string onde alguns elementos dinâmicos sãoinseridos através do uso de ${path} ou $name.

4. not – nega a expressão path que vem a seguir, muito usada emtal:condition.

5. exists – testa a existência de um path returnando verdadeiro ou falso.

6. nocall – usada quando se deseja capturar um objeto executável como:scripts, templates e dtml's, mas sem executá - lo ou renderizá - lo e sim teracesso a seus métodos e propriedades.

Exemplos:

<span tal:content=”here/title”>Título</span><span tal:content=”python: here.title>Título</span><span tal:content=”string: Titulo:${here/title}”> Título com label</span><span tal:condition=”not: here/title”>Título Vazio</span><span tal:define=”pagina nocall:here/page1”>

<span tal:replace=”pagina/title”/></span>

O domínio do uso dos Page Templates está na capacidade de escrever e utilizarexpressões.

METAL – Macro Expansion TAL


Além de comandos básicos, vistos anteriormente, o TAL possui a possibilidadede criação e utilização de macros. Em outras palavras, podemos definir quedeterminado bloco de código TAL é um bloco que está acessível a outros PageTemplates para reuso, incorporando ao TAL a reutilização de trechos de código.Aliado a isso o mecanismo de macros permite a criação de espaços (SLOTS) quepodem ser preenchidos pelos utilizadores das macros, fazendo assim com que asmesmas possam ser parametrizadas.

A grosso modo podemos dizer que uma macro é uma função definida dentrode um template e seus slot são parâmetros que podem ser passados pelosutilizadores das macros. Com essa visão vemos que o ZPT extende em muito acapacidade de criação, reutilização e flexibilização do uso de trechos de códigosHTML ou XML.

A METAL constituí - se de 4 comandos básicos:

● metal:define- macro – define um nome de macro para o techo de código.Esse nome é usado pelos outros templates para referenciar a macro dentrodaquele template.Exemplo:

<table tal:define-macro=”tabela1”><tr>

<td> Macro Tabela 1</td></tr>

</table>

● metal:use - macro – comando utilizados pelos templates que desejamutilizar macros definidas em outros templates.Exemplo:Suponha que o trecho de código anterior esteje no template chamadotabelas, então se desejar usar a macro tabela1, o novo template deveescrever algo como:

<span metal:use-macro=”here/tabelas/macros/tabela1”/>

● metal:define- slot – comando que, dentro de uma definição de macro,permite a definição de espaços a serem preenchidos pelo utilizador damacro.

Exemplo:

<table tal:define-macro=”tabela1”><tr>

<td> Macro Tabela 1</td><td metal:define-slot=”slot1”>Default Slot</td>

</tr> </table>

● metal:fill - slot – comando que, dentro de um uso de macro, permite opreenchimento dos espaços(SLOTS) definidos na macro.

Exemplo:

<span metal:use-macro=”tabela1”> <td metal:fill-slot=”slot1”> Preenchendo o SLOT</td></span>


Nomes Pré- Definidos

No ZPT existem alguns nomes previamente definidos para utilização dentro dotemplate, eles facilitam a codificação permitindo o acesso a várias informações deforma rápida e segura.

São eles:

● nothing – valor que representa o None ou Null.

● defaul – valor usado para informar que o texto existente não deve sersubstituído pelo valor da expressão.

● options – argumentos passados ao template.

● root – a raiz do zope.

● here – o objeto ao qual o template está sendo aplicado ou utilizado,também chamado de contexto.

● container – a pasta onde está localizado o template.

● template – o próprio template.

● request – o objeto REQUEST.

● user – o usuário autenticado.

● repeat – variáveis de repetição, quando dentro de um comando tal:repeat.

● attrs – dicionário com valores padrões do atributos da tag.

● CONTEXTS – lista de nomes padrões de váriaveis que podem ser acessadascaso tenham sido localmente sobrescritas.

Exemplos:

<span tal:content=”request/nome | nothing”> Nome ou nada</span>

<span tal:content=”request/nome | default”> Nome ou “Nome”</span>

<span tal:content=”template/nome | nothing”> Nome do template</span>

<span tal:content=”user/id”> Id do Usuário</span>

<span tal:content=”containter/title”> Título da Pasta</span>


5Python

Neste capítulo estudaremos os conceitos básicos da linguagem de programaçãoPython. Será abordado os tipos de dados, controles de fluxos, funções e módulos

Introdução ao PythonComo descrito anteriormente o Python é um linguagem moderna e por isso

agrega características típicas de linguagens atuais como: orientação à objetos emultiplataforma. Alem destas, o Python, ao contrário de Java, pode ser usada comouma linguagem procedural, pois o uso da orientação à objetos não é obrigatório.Como Java, Python é semi - interpretada ou semi- compilada, pois o código originalé compilado para um código de bytes (byte- code) e então interpretado pelocompilador Python o que aumenta performance em relação à linguagensinterpretadas comuns e adiciona flexibilidade em relação às linguagenscompiladas. Python possui tipagem dinâmica onde o tipo de uma váriavel e objetoé determinado dinamicamente pelo seu valor insto implementa grandeflexibilidade em relação à outras linguagens fortemente tipadas e indica quePython é uma boa escolha para o uso em scripts e manipulação de strings e dados.

Delimitação de BlocosPython difere da maioria das linguagens, pois estas utilizam o conceito de abre

e fecha bloco (seja com { e } ou com begin e end . Python utiliza a endentação parafazer a delimitação do bloco de código. Ex.:

for (condição_booleana):

comando 1

.

.

.

comando n

Isto deixa o código mais organizado, com uma estrutura fixa, independente dequem esteja programando (todos tendem a seguir o mesmo padrão).

Variáveis e Identificadores


Python é uma linguagem que utiliza tipagem dinâmica, ou seja, não existe anecessidade de declarar o tipo de uma variável. Ex.:

x = "Rodrigo Senra"

x = 131

O identificador é um nome dado a um objeto criado pelo programador. Umidentificador Python não pode começar com números. Outra característicaimportante é que os identificadores são sensíveis a letras maiúsculas, ou seja, oidentificador nome é diferente do identificador Nome.

Tipos de Dados Internos

Números:

Existem quatro tipos numéricos em Python: inteiros, inteiros longos, pontoflutuante e números complexos.

Inteiros: são números decimais propriamente dito. ex.: 10, 8 , - 310.Normalmente a representação destes números é de 32 bits.

Inteiros Longos: é um número decimal também, mas este por sua vez temuma precisão ilimitada, tendo como seu fator limitante a quantidade de memóriadisponível na máquina. Para representar um inteiro longo é preciso escrever onúmero seguido pela letra 'l' ou 'L'. Ex.: 200L, 33333333l.

Ponto Flutuante: é qualquer número real. Estes números são representadospor notação científica ou por ponto decimal. Ex.: 10.3, - 10.9, 3e10, 2e- 2.

Número Complexo: um número complexo é composto por dois númerosreais, um sendo a parte real e outra a parte imaginária. Um número complexo érepresentado como: <parte real> + <parte real>j. Ex.: 3.43 + 10.8j, 2 - j.

Strings:

Uma string é uma seqüência de caracteres entre aspas simples ou duplas. Ex.:"Hello World", 'Hello World'.

Pode- se ainda representar uma string com a utilização de três aspas duplasou três aspas simples. A vantagem de se utilizar esta notação é que não énecessário utilizar caracteres especiais para inserir aspas como um caracter dastring e que a string pode ser definida em mais de uma linha de código. Ex.: """ Estaé a

terceira forma de se representar uma string


em Python."""

Verdadeiro e Falso:

Em Python não há um valor previamente definido para definir verdadeiro efalso. Qualquer variável pode ser testada para obter um valor lógico que sejaverdadeiro ou falso. Existem algumas condições que Python já considera comosendo falsa. São elas:

None

Zero de qualquer tipo numérico: 0, 0l, 0.0

Seqüência Vazia: ( ) [ ]

Dicionário vazio: { }

Todos os outros valores são considerados verdadeiros.

Estrutura de Dados

Python utiliza dois tipos de estruturas de dados que são chamados deseqüências e dicionários.

Uma seqüência é um conjunto de caracteres que podem ser acessados emqualquer ordem.

Um dicionário é um conjunto de elementos indexados por chave, cadaelemento em um dicionário possui uma chave associado a ele.

Seqüências:

Strings:

Como dito anteriormente, strings são seqüências de caracteres delimitadospor aspas. Ex.: "Interlegis - STC"

Listas:

As listas são seqüências de elementos entre colchetes e separados por vírgula.Uma lista pode conter qualquer tipo de dado como elemento, podendo serdiferentes entre si. Uma lista pode ser alterada, expandida ou diminuída. Ex.:


x = [1,2.3]

x.append [4]

x

[1,2,3,4]

Tuplas:

As tuplas são seqüências de elementos entre parênteses separados porvírgulas. Eles são muito parecidos com as listas, mas com a diferença de que astuplas não podem ser alteradas (são imutáveis). Ex.:

x = ("Rodrigo", "Rogério", "Wilton")

Operação (Seqüência) Descrição

x in s 1 se x estiver contido em s, 0 do contrá rio

x not in s 1 se x não estiver contido em s, 0 docontrá rio

s + t Concatenação de s com t

s *n n cópias de s concatenado

s[i] Elemento cujo índice é i, primeiro índice é0

s[i:j] Seqüência de elementos entre os ínidices ie j

len(s) Número de elementos da sequencia

min(s) Menor valor da seqüência

max(s) Maior valor da seqüência

Exemplos:

>>> a = [1,2,3,5]

>>> s = [4,6]

>>> x = 5

>>> x in a

1

>>> x not in s

1

>>> a + s

[1,2,3,5,4,6]


>>> a*2

[1,2,3,5,1,2,3,5]

>>> max(s)

6

>>> min(a)

1

Operação (Listas) Descrição

s[i] = j Substi tui o elemento no índice i peloelemento j

s[i:j] = t Substi tui o grupo de elementos peloelemento t

del s[i:j] Remove um grupo de elementos

s.append(x) Adiciona um elemento ao final da lista

s.extend(x) Adiciona uma lista

s.count(x) Retorna o número de vezes que x está nalista

s.index(x) Retorna o menor índice do elemento x

s.insert(i, x) Insere o elemento x no ínidice i

s.pop([i]) Retira um elemento da posição i. Padrão i= - 1 (último elemento)

s.remove(x) Remove um elemen to

s.reverse() Inverte a ordem da lista

s.sort([cmpfunc]) Ordena a lista

Exemplos:

>>> a = [1,2,3,4]

>>> a[1] = 10

>>> a

[1,10,3,4]

>>> a.append(30)

>>>a

[1,10,3,4,30]

>>> a.extend([90, 32])

>>>a

[1,10,3,4,30,90,32]


>>> a.reverse()

>>>a

[32,90,30,4,3,10,1]]

Dicionários:

Os dicionários associam um objeto (chamado chave) a outro objeto (chamadode valor). As chaves podem ser que qualquer tipo, com exceção dos tipos lista,dicionário e objetos que não possam ter um valor hash para comparação.

Dicionários são criados como um conjunto de "chaves: valor" separados porvirgula. Ex.:

"jack": 10, "tequila":11

Uma vez criado um dicionário, você pode acessar os valores contidos neleatravés de suas respectivas chaves (que são únicas). Ex.:

x = "um": 1, "dois": 2, "três":3

>>> x = 'a':1, 'b':2,'c':3

>>> x['c']

3

Operação (Dicionário) Descrição

len(a) Número de elementos

a[k] Valor da chave k

a[k] = v Altera o valor da chave k

del a[k] Remove uma chave e seu valor

a.clear() Apaga todos os elementos

a.copy() Retorna uma cópia do dicionário

a.has_key(k) Verdadeiro se existe a chave

a.items(0 Lista de Tuplas (chave, valor) com todos oselementos

a.keys() Lista de todas as chaves

a.update(b) O mesmo que for k in b.keys(): a[k] = b[k]

a.values() Lista com todos so valores


len(a) Número de elementos

a.get(k[,x]) Se existe a chave k retorna a[k], casocontrá rio retorna x

a.setdefaul t(k[,x]) Se existe a chave k retorna a[k], casocontrá rio retorna x e associa a[k] = x

Exemplo:

>>> a{'a':1, 'b':2, 'c':3}

>>> a['b']

2

>>> len(a)

3

>>> del a['b']

>>> a

{'c':3, 'a':1}

>>> a['d'] = 4

>>>a

{'d':4, 'c':3,'a':1}

>>> a.items()

[('d',4),('c',3), ('a', 1)]

>>> a.keys()

['d','a','c']

>>> a.values()

[4,1,3]

Estruturas de Controle de Fluxo:Estas instruções podem ser combinadas, de acordo com a endentação, para

formar um bloco de código. Esse bloco de código pode ser usado pela estrutura decontrole de fluxo. Este bloco pode então, ser executado mais de uma vez.

if, else, elif:

As estruturas if, else e elif executam determinado bloco de códigodependendo da expressão lógica (condição) ser verdadeira ou falsa.

if (expressão lógica):

bloco


[elif (expressão lógica):

bloco]

[else:

bloco]

Ex.:

>>> a = 1

>>> if a:

... print a

...

1

>>> a = 2

>>> if a != 2:

... print a

>>> else:

... a = a + 1

...

3

while:

A estrutura while executará o bloco de código enquanto a expressão lógicafor verdadeira e o bloco de código associado ao comando else será executadoquando a expressão lógica for falsa.

while (condição lógica):

bloco

[else :

bloco]

Ex.:

>>> a = 0

>>> while a < 3:

... a = a+1

... print a

...


0

1

2

for:

A estrutura for executará o bloco de código para cada elemento de umaseqüência. A variável receberá o elemento propriamente dito da seqüência. Quandoo loop acabar ou se a seqüência estiver vazia, bloco de código associado a instruçãoelse será executado.

for variável in seqüência:

bloco

[else :

bloco:]

Ex.:

>>> a = [3,10,4]

>>> for i in a:

... print i

...

3

10

4

>>> for i in range(3):

... print i

...

0

1

2

pass :

Essa instrução é usada para definir um bloco de código vazio, ou seja, nadaserá executado. Ex.:

if a == 1:

pass


break:

A instrução break deve ser usada somente nos blocos de códigos dasestruturas for e while . Essa instrução informa à estrutura para terminar o loopimediatamente. Ex.:

a = 1

while a > 10:

a += 1

if a == 5:

break

print a

5

continue:

A instrução continue deve ser executada somente nos blocos de códigos dasestruturas for e while . Essa instrução informa à estrutura para voltar ao início dobloco de código e continuar com a próxima interação imediatamente. Ex.:

a = 1

b = 1

while a < 10:

a + = 1

if b >= 5:

continue

b += 1

print a

10

print b

5

Funções:Funções tem como objetivo principal dividir tarefas (bloco de códigos) em

subtarefas. A função é invocada pelo seu nome e pode ter vários parâmetros deentrada e retornar ou não um valor.


Uma função em Python é definida com a palavra def seguida do nome dafunção e seus parâmetros entre ( ).

def nome ([arg1, arg2, ...]):

c =a+b

O retorno de valores das funções é por meio da palavra return seguida dovalor. Essa palavra fará com que a execução da função se encerre imediatamente,retornando o valor em questão. Ex.:

def func (a,b):

c = a+b

return c

func (10, 5)

15

Os parâmetros das funções podem ter valores iniciais pré- definidos. Quandouma função com parâmetros iniciais pré- definidos for invocada, esses parâmetrospodem ser informados, ou não. Caso não seja informado, o valor inicial pré -definido será assumido. Ex.:

def func (a, b= 5, c=3):

c=a+b+c

return c

func(10)

18

func(10,8)

21

func(10, c=4)

19

Python suporta funções com número de parâmetros variáveis. O caractere ‘*’precedido do nome do parâmetro informa que todos os parâmetros serãoagrupados em uma tupla. O mesmo acontece com os caracteres ‘**’ precedidos donome do parâmetro, e nesse caso, os parâmetros serão agrupados em umdicionário. Ex.:


def func (a, *b):

c = 0

for i in b:

c += i

c+= a

return c

func (1,2,3,4,5)

15

O escopo das variáveis definidas dentro de uma função são locais da função,ou seja, existem, enquanto a função está sendo executada. Python permite acessaruma variável de escopo global dentro de uma função, desde que isso sejaexplicitamente declarado usando a palavra chave global . Ex.:

a = 10

def func (b,c):

global a

return a + b + c

func(1,2)

13

É possível inserir uma documentação para explicar uma função. Ex.:

>>> def func ():

... “””Esta é a documentação explicando a função!”””

print “Função func”

>>> func.__doc__

'Esta é a documentação explicando a função!'

Módulos e pacotes:Um módulo é um conjunto de funções, classes e/ou variáveis. Os módulos

podem ser implementados em Python e/ou C. para incorporar um módulo ao seuprograma, deve- se usar a palavra import .

import módulo [as nome][,módulo [as nome]...]


ou

from módulo import identificador [as nome] [, identificador [as nome]...]

O procedimento para incorporar os módulos se divide em duas partes: (1)procura o módulo e inicializa - o; (2) define o escopo do módulo. A forma usandoimport (sem o from ) efetua as duas etapas para cada módulo, a forma from efetuaa primeira etapa apenas uma vez e a segunda etapa para cada identificador.Basicamente o que difere uma forma da outra é o acesso ao conteúdo do módulo.Na forma usando apenas o import o conteúdo é acessado precedido o nome domódulo mais ‘.’, na forma usando form o conteúdo é acessado usando apenas onome do identificador. Na forma usando from o identificador poderá sersubstituído por um ‘*’, nesse caso todo o conteúdo do módulo será incorporado aoprograma, exceto os conteúdos precedidos de ‘_’. Ex.:

import sys

from sys import path

Classes:Python é uma linguagem orientada à objetos, você pode definir suas

próprias classes com métodos e atributos privados, herdar classes já existentes eredefinir métodos (encapsulamento, herança e polimorfismo respectivamente). Apalavra class é usada para definir uma classe.

class nome [(nomeclassepai1, nomeclassepai2,...)]:

bloco

As classes são instanciadas da mesma forma que executa uma função. Seusmétodos e atributos são acessados com o nome da instância seguido de um ‘.’ maiso nome do método /a t ributo. Ex.:

a= ClasseTeste() #Criação de uma classe

a.método () #execução de um método

a.atributo=”teste” #atributo

Métodos:

Os métodos das classes são definidos da mesma forma que as funções (def ),sendo que é obrigatório que cada método tenha, o self como primeiro parâmetro.Esse parâmetro contém a instância da classe propriamente dita. Ex.:

class Mensagem:

def obterMsg(self):

return “Hello World!”


Construtor:O construtor da classe deve ser de declarado usando o método especial cujo o

nome é: ‘__init__’. Ex.:

class Mensagem:

def __init__(self):

pass

Atributos:Existem dois tipos de atributos: atributos relacionados à classe propriamente

dita e atributos relacionados à instância da classe. Os atributos relacionados àclasse podem ser declarados em qualquer lugar do bloco de código relativo a class .Os atributos relacionados a instância da classe deve ser declarados dentro dosmétodos usando o parâmetro self . Ex.:

class Mensagem:

mensagem=”Hello World” #atributo da classe (global a classe)

def __init__(self, nome):

self.dados = nome #Atributo da instância

Atributos e métodos privados:Métodos e atributos privados não podem ser acessados externamente a classe.

Somente a instância da classe ou da classe hierarquicamente herdada podemacessar métodos e atributos privados.

Os métodos e atributos privados são definidos com dois ‘_’ precedidos do seunome. Ex.:

class Mensagem:

def __init__(self):

self.dados = “alo”

def __configurarDados(self, nome) #Método privado

self.nome = nome

Os métodos possuem seguintes atributos especiais:

__doc__ Retorna a documentação do método

__name__ Retorna o nome do método

Ex.:


class Metodo:

def __init__(self):

“Esse é uma documentação do método”

print Metodo.__init__.__doc__

Variáveis Estáticas:Uma variável estática é criada em uma classe antes da definição de qualquer

método. Uma vez criada esta variável, ela vai estar acessível com o mesmo valorpara todas as instâncias da classe, e caso este valor seja alterado em uma instânciae acessado em outra instância então o valor será aquele que foi alterado. Ex.:

class Exemplo:

cont = 0

def __init__(self):

cont +=1

def __mostrar contador(self):

print cont

>>> a = Exemplo()

>>> a.mostrarcontador()

1

>>> b = Exemplo()

>>> b.mostrarcontador()

2

>>> print Exemplo.cont

2


6Python e Zope

Python ScriptPython script é um objeto Zope que pode implementar métodos e atributos

que o programador deseje criar. Com ele é possível utilizar alguns módulos dalinguagem Python, aproveitando assim, algumas funcionalidades já existentes.

Como a maioria dos objetos em Zope, alguns métodos de seguranção sãoadotados para que um script não danifique uma instância Zope.

A maioria das funcões se comportam da mesma forma que em Python.

Quando você cria um script, ele contém alguns exemplos de códigos quedemonst ram diversas funções úteis. Ex.:

#import a standard function, and get the HTML request and response objects.

request = container.REQUEST

RESPONSE = request.RESPONSE

# Return a string identifying this script.

print “Esté é o “, script.meta_type, '”5s”' % script.getId().

if script.title:

print “(%s)” % html_quote(script.title),

print “in”, container.absolute_url()

return prited

Chamando scripts a partir de DTML

Você invoca um script da mesma forma que você invocaria um método DTML.Ex.:

Suponha a existência do script “teste”.


<dtml-var expr=”Rodando um script”>

<dtml-var teste>

Métodos ExternosZope provê outra maneira de escrever Python scripts, que são os métodos

externos. Eles são chamados Métodos Externos porque o code que você escreve ficasituado fora do ZODB, residindo nos arquivos de sistema. Um método externo ésimplesmente um método, escrito em Python, cujo módulo está situado na pasta /Extensions da sua instalação Zope. Para criar um Método Externo, você precisaacessar o arquivo de sitema diretamente, ou via FTP.

Como exemplo, você pode criar um arquivo chamado Ola.py contendo:

def olaMundo(nome = “Mundo”):

return “Ola %s!” % nome

Agora salve este arquivo na pasta /Extensions da sua aplicação Zope. Se vocênão pode acessar o arquivo de sistem onde sua aplicação Zope está instalada,consulte o seu administrador para que ele possa fazer para você.

Após o módulo ter sido inserido no arquivo de sistema, crie um objetoMétodo Externo na aba Add menu. Digite olaExterno como Id, Ola como nome domódulo e olaMundo como nome da função. Clique em add. Agora você deve teruma objeto Zope chamado olaExterno. Você pode invocá- lo a partir de um métodoDTML.

O que é um Produto?

Produtos são pacotes adicionados ao Zope. Eles são objetos customizados eque têm uma funcionalidade muito útil. Criar e utilizar um Produto Zope é bemparecido com criar e utilizar pacotes e módulos. Outro fato importante é ter a idéiade criar um pacote e depois mudá - lo para um produto, pois com essa idéia emmente, você criará produtos mais facilmente.

Criando um pacote

Inicialmente crie um diretório chamado /dirOla dentro da pasta /bin de suainstalação Zope.

Dentro do seu diretório, crie um arquivo vazio chamado __init__.py. Agoravamos criar um módulo chamado ModuloOla.py e vamos editá - lo:


class ClasseOla:

def __init__(self, nome='Mundo'):

self.nome = nome

def falar(self):

return 'Olá, %s. ' & (self.nome)

def editar(self, nome):

self.nome = nome

Agora salve este arquivo, testando - o logo a seguir:

>>>from dirOla import ModuloOla

>>>from ModuloOla import ClasseOla

>>> a = ClasseOla()

>>>a.falar()

'Olá, Mundo'

Criando um Produto

Agora que você já tem seu pacote montado vamos criar seu produto.Primeiramente, copie seu diretório dirOla para /lib / python /Products da suaaplicação Zope e renomeie este diretório para produtoOla.

Uma vez feito isto, você deve então editar seu arquivo __init__.py como oexemplo:

import ModuloOla

def initialize(context):

context.registerClass(

ModuloOla.ClasseOla,

permission=”Adicionar um Objeto Ola”,

constructors=(ModuloOla.manage_addOlaForm,

ModuloOla.manage_addOla)

)


Agora salve seu arquivo. Uma dica importante é criar um arquivo vaziorefresh.txt para o seu diretório ProdutoOla para permitir a funcionalidade deatualizar quando você estiver desenvolvendo seu produto.

Agora vamos alterar um pouco seu arquivo ModuloOla.py:

def manage_addOlaForm(self):

“ “

def manage_addOla(self):

“ “

class ClasseOla:


self.nome = nome

meta_type = “Objeto Olá”

def falar(self):



self.nome = nome

Agora salve seu arquivo. Os métodos addOlaForm e addOla serãomodificados posteriormente.

Adicionamos o meta_type que faz a descrição da classe.

Com estas mudançãs, o Zope será capaz de registrar corretamente o produtoquando você estartar ou reiniciar o servidor Zope. Você será capaz de ver oproduto, mas não conseguirá adicionar o produto dentro de um folder. Isso édevido ao fato dos métodos manage_addOlaForm e manage_addOla não estaremimplementando funcionalidades que interagem com o tipo de código depresistência que o Zope utiliza.

Para uma perfeita funcionalidade, vamos agora alterar os métodos citadosacima:

Preenchendo os métodos manage_add


Os métodos então ficarão da seguinte forma:

def manage_addOlaForm(self, REQUEST):

"Form para adicionar um objeto Ola."

return """

<html>

<head></head>

<body>

<form method="post" action="./manage_AddOla">

<input type="submit" value="Add Olá">

</form>

</body>

</html>

"""

def manage_addOla(self, id, REQUEST):

"Método para adicionar um objeto Olá"

ola = ClasseOla(id)

self._setObject(id, ola)

return self.manage_main(self, REQUEST)

Deve ser feita agora uma mudançã na classe ClasseOla, para que o objetoreconheça seu próprio id:

class ClasseOla:

def __init__(self, id, nome = "Mundo"):

self.id = id

self.nome = nome

meta_type = "Objeto Ola"

def falar(self):

return "Olá, " + self.nome



self.nome = nome

Feito tudo isso, você pode atualizar seu produto Zope na aba refresh, e clicarno botão para atualizar o produto. Isto habilitará as mudanças que você fez sem terque reiniciar o servidor Zope.

Subclasses de classes ZopeSeu produto parece pronto para ser usado, contudo se você fizer isto, um

erro ocorrerae não adicionará o seu objeto. Isso ocore porque a ClasseOla não sabecomo representar ela mesma na interface de gerenciamento do Zope ou no seubanco de dados. Para remediar isto, você deve importar algumas classes padrõesdo Zope.

Para interagir corretamente com a interface de gerenciamento, você deveimportar a classe OFS.SimpleItem.Item:

from OFS.SimpleItem import Item

para interagir com o ZODB, você deve importar a classe Globals.Persistent:

from Globals import Persistent

para interagir com os atributos de aquisição você deve importar a classeAcquisition.Implicit:

from Acquisition import Implicit

adicione essas três linhas de código no topo de seu arquivo ModuloOla.py emude a definição da classe ClasseOla para ela interagir com estas três classesbases:

class ClasseOla (Item, Persistent, Implicit):

Após fazer estas mudanças, atualize seu produto e tente adicionar o objetoOla novamente. Selecione a opção Objeto Ola que se encontra no menu Add . Oformulário para adiconar deve aparecer.


Digite então TesteOla no formulário e clique no botão add Olá. Isto deve tetrazer de volta para a página principal e você deve ver um objeto TesteOla listado.

Parabéns, você conseguiu com êxito criar um produto que pode seradicionado através da interface de gerenciamento do Zope.


7Zope e Banco de Dados

Neste capítulo veremos como o Zope se relaciona com os sistemas degerenciamento de banco de dados para a construção de aplicações. Em primeirolugar cabe ressaltar que o Zope utiliza um banco de dados próprio, chamadoZODB, para o armazenamento de seus objetos internos. O ZODB é um banco dedados orientado a objeto e é extremamente eficaz no armazenamento de objetos noZope, pois ele é destinado ao armazenamento de objetos no formato ideal para serutilizado pelo Zope.

ZODBO ZODB é um sistema de gerenciamento de banco de dados orientado a objetos

que pode ser usado com ou sem o Zope. Ele oferece um série de funcionalidades:

• Armazenamento múltiplo.

• Transparência em relação aos objetos.

• Transacional.

• Alta performance.

• Cancelamento de ações.

RDBMSSistema de banco de dados relacionais é o modo padrão para o armazenamento

e recuperação de grandes quantidades de dados e informações. Assim, deve- sediscutir a possibilidade de se utilizar bancos de dados relacionais para oarmazenamento de dados e informações contidas em uma aplicação implementadae hospedada no Zope.

As vantagens de se utilizar um banco de dados relacional para oarmazenamento de dados incluem:

• O modelo relacional permite a criação de relações e regras complexasentre os dados de forma fácil.

• O armazenamento de grande quantidade de dados e sua rápidarecuperação.

• Possibilidade de uso da SQL para obtenção de informação.


• Outros softwares e aplicações não hospedadas no Zope podem acessar ainformação armazenada.

• Você pode separar de forma mais concreta os dados e código da aplicação.

O Zope permite a comunicação com diversos banco de dados comerciais elivres como Oracle, Sybase, PostgreSQL, Interbase, MySQL, Gadfly além do uso deinterface ODBC. A comunicação entre o Zope e o Banco de Dados se dá através deadaptadores que devem ser instalados de acordo com o banco de dados a serutilizado. O Gadfly é o único banco de dados relacional que não necessita deadaptador, pois já acompanha a instalação original do Zope.

Zope e o GadflyComeçaremos pela conexão com o Gadfly um banco de dados relacional que

acompanha o Zope e que não necessita de adaptador externo. Por exemplo,suponha que você queira armazenar as informações a respeito de um catálogo deCDs em um banco de dados relacional ao invés de deixar que o Zope as armazeneno ZODB. Para fazer isso você deve criar um repositório para os CDs indo aodiretório /var /Gadfly e criando um diretório com o nome do repositório que seráusado pelo Gadfly. A partir de então você poderá criar as tabelas e usar a o bancode dados para o armazenamento. Para visualizarmos melhor vamos executar oseguintes passos:

• Após adicionar um diretório BDCDs em var/Gadfly abaixo do diretório deinstalação do Zope.

• Vá até a raiz da interface de gerencimento do Zope e no menu “Select typeto add...” escolha Z Gadfly Database Connection.

• Na interface apresentada preencha “CdCon” no campo Id e no campo Titlecoloque “Conexão ao BDCD” e selecione BDCDs na lista Data Source (figura8.1).

• Selecione a nova conexão criada para visualizar suas guias(figura 8.2).

• Selecione as guias para se familiarizar com as informações contidas emcada uma.

Figura 8.1 – Propriedades da conexão CdCon.


Figura 8.2 - Status da conexão criada.

Vamos testar a nossa conexão através da guia Test, para isso vamos realizaruma instrução SQL para criar a tabela que irá armazenar as informações para cadaCD de nossa aplicação.

• Vá para a guia Test.

• Escreva a instrução SQL (Listagem 8.1).

• E depois da confirmação de execução selecione a guia Browse paravisualizar o conteúdo do banco de dados (figura 8.3).

create table

CDS(

Titulo varchar,

Cantor varchar,

Gravadora varchar,

Data_de_Lancamento varchar,

Preco float,

Genero varchar

)

Listagem 8.1 – Código SQL para criação da Tabela CDS.

Figura 8.3 – Visualização do conteúdo do banco de dados.


Métodos ZSQLMétodos ZSQL são métodos que o Zope utiliza para realizar operações sobre

um banco de dados através de uma conexão. Assim, um método ZSQL está sempreassociado a uma conexão e pode realizar consultas, inserções, alterações equalquer outra instrução SQL além de poder conter mais de uma instrução SQL.

Vamos criar um método ZSQL que permitirá a inserção de um CD na tabelaCDS no banco de dados BDCDs através da conexão CdCon. Vá para o folder CDs eno menu “Select type to add...” escolha Z SQL Method e clique em Add, então serámostrado uma interface para a configuração do método ZSQL e nela coloque asinformações abaixo:

• Id: InsereCd.

• Title: SQL para inserção de um CD no BD.

• ConnectionId: CdCon.

• Arguments: Titulo Cantor Gravadora Lancamento Preco Genero.

• Query Template: Método Z SQL para inserção do CD (figura 8.4).

Figura 8.4 – Interface (InsereCd) para edição de um método ZSQL.


8.5.1 Usando o método ZQL.

Para se utilizar um método ZSQL é preciso ir à guia Test do mesmo ou criaruma interface personalizada que faça uso do ZSQL. Essa interface personalizadapode ser um método DTML que através de um formulário invoca o método ZSQL.Como exemplo você deve ir ao folder CDs e então selecionar Z Search Interface nomenu “Select type to add...” e prencher as informações solicitadas na interface(figura 8.5).

Figura 8.5 – Adicionando uma interface (InserirForm) para a inserção de um CD.


Após clicar em Add dois métodos DTML chamados Inserir e InserirForm.InserirForm corresponde à interface para adição de um novo CD já inserir é ummétodo que executar a inserção do novo cd invocando o método ZSQL InsereCdpara que ele efetue a inserção no banco de dados.

Você pode também fazer a invocação direta do método ZSQL InsereCdatravés da passagem de parâmetros em formato de função ou CGI.

8.5.2 Tags DTML

Em um ZSQL Method é disponibilizado um conjunto de tags especiais(sqlgroup, sqltest, sqlvar) para a criação de sql's dinâmicos. Essas tags sãodescritas no apêndice A.

ResumoNeste capítulo você se familiarizou com o uso do Zope se comunicando com

um banco de dados relacional e como um método ZSQL é independente deconexão.


8A linguagem DTML

Neste capítulo você aprenderá os conceitos básicos da linguagem DTML.Explicaremos o conceito de camadas, “namespace” e variáveis no Zope. Este é oprincipal capítulo para que você comece a produzir conteúdo dinâmico a partir doservidor Zope.

FundamentosO servidor Zope possui três níveis ou camadas de desenvolvimento. Na

primeira camada estão todos os códigos fontes do Zope bem como todas asmodificações ou expansões do servidor que foram construídas através dalinguagem Python (linguagem na qual o Zope foi construído), as expansões são, emgeral, chamadas de produtos e adicionam alguma funcionalidade ao Zope.

Na segunda camada do Zope estão as telas de gerenciamento. São elas quepermitem a você o uso e a administração do servidor Zope.

A terceira camada é o que os usuários vêem em seus navegadores quandoacessam algum objeto publicado através de um servidor Zope. É importantesalientar o código DTML editado na segunda camada nunca é enviado ao cliente naterceira camada.

O Zope possui o conceito de variáveis que se assemelha muito ao conceitotradicional de algo que possui valor modificável. No Zope, além desta visãotradicional, é possível observar que quaisquer objetos ou propriedades de objetospodem ser usados como variável, pois seus valores dependerão do contexto queestão inseridos e do valor atribuído aos mesmos.

“Namespace”Um “namespace” DTML é um objeto que contem nomes de variáveis de um

objeto, assim cada objeto possui um “namespace” contendo todos os nomes devariáveis acessíveis pelo objeto bem como os valores associados a essas variáveis.O “namespace” DTML possui conteúdo dinâmico o que indica que seu conteúdopode variar de objeto para objeto. Os nomes de variáveis disponíveis no“namespace” são obtidos através do processo chamado de “aquisition” (visto nocapítulo 2). A visão do “namespace” é semelhante ao de uma pilha de valores ondeos valores mais altos da pilha são aqueles que estiverem mais próximos ao objetocorrente.

Exemplo: Suponha a hierarquia de objetos descrita na figura 9.1.


Figura 9.1 - Hierarquia dos objetos.

Assim para o objeto example.html a pilha se pareceria com a tabela 9.1

Mas para o objeto Files a pilha do “namespace” seria com a tabela 9.2.

example.htmlexample.txt

Files, addFile, getFiles, getLink, getSize, index_htmlFileLibrary, GuestBook, Navigation, ShoppingCart, examples.css, index_html

Examples, QuickStart, imagens, man, site…

Tabela 9.1 – “Namespace” do objeto example.html.

Isto ocorre porque a pilha é construída para cada objeto levando - se em contasua posição relativa na árvore hierárquica.

FilesaddFile, getFiles, getLink, getSize, index_html

FileLibrary, GuestBook, Navigation, ShoppingCart, examples.css, index_htmlExamples, QuickStart, imagens, man, site…

Tabela 9.2 – “Namespace” do objeto Files

A sintaxe do DTMLA linguagem DTML (Document Template Markup Language) é fácil de aprender,

e para aqueles familiarizados com a HTML será como conhecer novas tags. Assimcomo a HTML, a DTML segue o conceito de tags para a utilização de comando, ondetags são nomes especiais contidos entre os sinais < e >.


Exemplo de uma tag HTML é:

<br>

Exemplo de tag DTML é:

<dtml-var ...>

As tags DTML podem ter nenhum ou vários atributos. Atributos são nomesseguidos de sinal de igualdade de seus valores entre aspas.

Exemplo:

<dtml-var name=”teste”>

Alguns atributos não necessitam de valores, assim o sinal de igualdade não énecessário.

Exemplo:

<dtml-var name=”teste” capitalize>

Assim capitalize é um atributo sem valor.

Algumas tags são ditas vazias (assim como o <br> em HTML e <dtml-var> emDTML), pois não possuem corpo após o sinal de >. Porém, outras tags exigem anecessidade de um corpo (que pode ser vazio) após a tag de abertura.

Exemplo:

<dtml-if expr=”x==y”>

<p>

x=y

</p>

</dtml-if>

A tag acima por necessita saber o que fazer caso a condição “x=y” sejasatisfeita, assim a tag <dtml-if> é uma tag não vazia, pois exige a existência deum corpo e que a mesma seja fechada com </dtml-if>. As tags não vaziaspossuem tags de fechamento que seguem o padrão da HTML, isto é, se a tag se abrecom <dtml-xxx> ela se fechará com </dtml-xxx>.

Tags e mais TagsMostraremos agora as principais tags que você usará para construir conteúdo

dinâmico no Zope através da DTML.

A tag “var”

A tag var insere a representação textual de uma variável (lembre- se que avariável pode ser um objeto ou propriedade) em um documento ou método DTML.Lembre - se que o conteúdo gerado é textual assim se você inserir um objetoimagem, o conteúdo gerado é a forma textual de representar a imagem no HTML.

Exemplo:

Suponha que você inseriu um objeto imagem do logotipo da sua empresa naraiz do Zope e o nome do objeto é “Logotipo”. Se você utilizar a tag <dtml-varname= ”Logotipo”> em um documento ou método DTML o conteúdo gerado será:


<img src=http://localhost:8080/Logotipo width=”100” heigth=”50” border=”0”>

Isto será interpretado corretamente por um navegador web, mas poderá causartranstornos em um dispositivo móvel ou outro cliente, pois o texto será enviadopara o mesmo e não será interpretado corretamente.

Alguns atributos da tag var:

“name”

Atributo opcional que específica a variável a ser inserida.

“expr”

Usado para avaliar expressões complexas.

“html_quote”

Converte caracteres que têm significado especial em HTML para códigoHTML de exibição.

“missing=st ring”

Especifica um valor caso o Zope não possa achar a variável.

“fmt=st ring”

Formata uma variável. Zope provê alguns formatos embutidos:

· whole- dollars: Formata a variável em dólares.

· dollars - and- cents: Formata a variável em dólares e centavos.

· collection- length: Retorna o comprimento da variável.

· structured - text: Formata a variável como Texto Estruturado. Para maisinformação consulte o “Help” (Ajuda) ou www.zope.org.

“null=string”

Um valor opcional no caso da variável ser null.

“lower”

Letras maiúsculas são convertidas para minúsculas.

“upper”

Letras minúsculas são convertidas para maiúsculas.

“capitalize”

Coloca o primeiro caracter maiúsculo.

“url_quote”

Caracteres não válidos em URL são convertidos para caracteres válidos.

“newline_to_br”

Converte caracteres de nova linha para a tag <br> em HTML.

“size=arg”

Trunca a variável no determinado comprimento, mostrando o valor atéaquele tamanho.


“etc=arg”

Especifica uma string a ser adicionada ao final da string que for truncada. Ovalor padrão é ‘...’

Exemplos:

Inserindo uma variável em um documento:

<dtml-var standard_html_header>

ou

<dtml-var name="standard_html_header">

Limitando o tamanho:

<dtml-var name="cores" size=5>

Inserindo uma variável “link” dentro de um HTML uma tag <a> com a sintaxede entidade (sintaxe antiga da DTML e deve ser evitada):

<a href = "&dtml-link"; >Link </a>

Sintaxe atual:

<a href = "<dtml-var name-link>">Link </a> .

A tag “call”

A tag “call” o deixa chamar um método sem inserir os resultados na saída.

Sintaxe:

<dtml-call name="objeto" ou expr ="Expressão">

Se a tag “call” usar um objeto, os argumentos são passados automaticamentepor DTML da mesma maneira que a tag “var”. Se o método é especificado em umaexpressão, então você tem que passar os argumentos.

Exemplos:

Chamando através de name="objeto":

<dtml-call UpdateInfo>

ou

<dtml-call name="UpdateInfo">

Isto chama o objeto “UpdateInfo” passando argumentos automaticamente.

Chamando através de expressão:

<dtml-call expr ="RESPONSE.setHeader ('content-type', ' text/plain ')">

A tag “comment”

A tag “comment” permite a você documentar o seu DTML com comentários.Você também pode usar isto para impedir certos comandos do DTMLtemporariamente para realizar teste.

Sintaxe:

<dtml-comment>

</dtml-comment>


Entre as tags “comment” os comandos não são executados e também nãoaparecem na saída.

Exemplos:

Documentando em DTML:

<dtml-comment>

Este conteúdo não é executado e não aparece na saída.

</dtml-comment>

ou

<dtml-comment>

Este DTML é inválido e não será executado.

dtml-call someMethod>

</dtml-comment>

A tag “if”

A tag “if” permite testar condições e tomar ações diferentes que dependendodo resultado das condições. A tag “if” faz o mesmo que o “if/elif /else” do Python.

Sintaxe:

<dtml-if Objeto ou expr="expressão">

[<dtml-elif Objeto ou expr="expressão">]

...

[<dtml-else>]

</dtml-if>

As tags “elif” e “else” são opcionais. Assim, se o objeto ou expressão avaliadafor verdadeira então o bloco if é executado. Senão o bloco “elif” (se houver) ou“else” (se houver) será executado.

Exemplos:

Testando para uma variável:

<dtml-if cobrar>

A variável ou objeto cobrar é verdade

</dtml-if>

ou

<dtml-if expr ="num>5">

num é maior que cinco

<dtml-elif expr="num<5">

num é menor que cinco

<dtml-else>

num é cinco

</dtml-if>


A tag “unless”

A tag “unless” provê um atalho para testar condições negativas.

Sintaxe

<dtml-unless Objeto ou expr="expressão">

</dtml-unless>

A tag “unless” executa ações se a variável de condição ou expressão for falsa eentão o bloco contido dentro da tag é executado.

Exemplos

Testando uma variável:

<dtml-unless Teste>

<dtml-call Operacao>

</dtml-unless>

O bloco será executado se Teste não existe, ou se existe, mas é falso.

A tag “in”

A tag in lhe oferece um poderoso controle de laço ou loop.

Sintaxe:

<dtml-in Variável de Sequência ou expr="expressão de sequencia">

[<dtml-else>]

</dtml-in>

O bloco in será repetido para cada item da variável de sequência ou daexpressão.

Se não houver nenhum item na variável de seqüência ou na expressão, o blocoelse (opcional) é executado.

Atributos:

“mapping”

Trabalha com os objetos diretamente ao invés de cópias. Isto permite teracesso valores dos objetos mapeados como variáveis de DTML.

“reverse”

Ordem contrária.

“sort=st ring”

Ordena a sequência pelo determinado atributo.

“start=int”

O número do primeiro item a ser mostrado, onde os itens são numerados apartir de um.

“end=int”

O número do último item a ser mostrado.


“size=int”

O tamanho do grupo a ser mostrado.

“skip_unauthorized”

Não causa uma exceção se um artigo sem autorização de acesso éencontrado.

“orphan=int”

O tamanho de grupo mínimo desejado. Isto controla como as sequências sãogeradas em grupos. Se um grupo menor que o tamanho de orphan ocorrer, entãonenhuma divisão é gerada e um grupo maior de resultados é gerado.

Por exemplo, se o tamanho da sequência for 12, o tamanho de grupo é 10 e otamanho de órfão é 3, então o resultado é um grupo com todos os 12 itens ao invésde dividir os itens em dois grupos, pois isso resultaria em um grupo menor que otamanho orphan. O valor de padrão é 0 (zero).

“overlap=int”

O número de itens para sobrepor entre os grupos. O padrão é no overlap.

“previous”

Volta para o grupo anterior, se houver.

“next”

Avança para o próximo grupo, se houver.

“sort_expr=expression”

Ordena a sequência por um atributo nomeado pelo valor da expressão. Istolhe permite ordenar em atributos diferentes.

“reverse_expr=expression”

Ordena a sequência por um atributo nomeado pelo valor da expressão deforma contrária.

Exemplos:

Laço em objetos:

<dtml-in objectValues>

title: <dtml-var title><br>

</dtml-in>

Laço sobre dois conjuntos através de índices:

<dtml-let rows="(1,2,3)" cols="(4,5,6)">

<dtml-in rows prefix="row">

<dtml-in cols prefix="col">

<dtml-var expr="row_item * col_item"><br>

<dtml-if col_end>

<dtml-var expr="col_total_item * row_mean_item">

</dtml-if>


</dtml-in>

</dtml-in>

</dtml-let>

Criando uma tabela colorida:

<table>

<dtml-in objectValues>

<tr <dtml-if sequence-odd>bgcolor="#EEEEEE"

<dtml-else>bgcolor="#FFFFFF"

</dtml-if>

<td><dtml-var title></td></tr>

</dtml-in>

</table>

Processando grupos

<p>

<dtml-in largeSequence size=10 start=start previous>

<a href="<dtml-var absolute_url>

<dtml-var sequence-query>start=<dtml-var previous-sequence-start-number>">Previous</a>

</dtml-in>

</p>

<dtml-in largeSequence size=10 start=start next>

<a href="<dtml-var absolute_url>

<dtml-var sequence-query>start=<dtml-var next-sequence-start-number>">Next</a>

</dtml-in>

</p>

<p>

<dtml-in largeSequence size=10 start=start>

<dtml-var sequence-item>

</dtml-in>

</p>

A tag “with”

A tag “with” coloca um objeto sobre a pilha do DTML “namespace”. Variáveisserão observadas neste objeto empilhado.

Sintaxe:

<dtml-with Variável ou expr ="Expressão">

</dtml-with>

Atributos:


“only”

Limita o namespace de DTML para incluir só o objeto dentro da tag with.

“mapping”

Indica que a variável ou expressão é um objeto.

Exemplos:

Observando uma variável no REQUEST:

<dtml-with PEDIDO only>

<dtml-if id>

<dtml-var id>

<dtml-else>

' id' não estava no pedido.

</dtml-if>

</dtml-with>

Colocando o primeiro objeto no namespace de DTML:

<dtml-with expr = " objectValues () [0]">

Primeiro o id: <dtml-var id>

</dtml-with>

A tag “return”

A tag return pára a execução do DTML e devolve os dados. Reflete o comandoreturn do Python.

Sintaxe:

<dtml-return Variável ou expr =" ReturnExpression ">

Exemplos:

Devolvendo uma variável:

<dtml-return result>

Devolvendo um dicionário de Python:

<dtml-return expr=" {' hi':200, ' lo':5}">

ResumoNeste capítulo você teve contato com os principais conceitos e sintaxes da

linguagem DTML, no capítulo DTML avançado você aprenderá um pouco mais sobrea linguagem DTML, mas agora você está pronto para desenvolver uma pequenaaplicação usando o Zope.


9 File System Product

O que é um Produto?

Produtos são pacotes adicionados ao Zope. Eles são objetos customizados eque têm uma funcionalidade muito útil. Criar e utilizar um Produto Zope é bemparecido com criar e utilizar pacotes e módulos. Outro fato importante é ter a idéiade criar um pacote e depois mudá - lo para um produto, pois com essa idéia emmente, você criará produtos mais facilmente.

Criando um pacote

Inicialmente crie um diretório chamado /dirOla dentro da pasta /bin de suainstalação Zope.

Dentro do seu diretório, crie um arquivo vazio chamado __init__.py. Agoravamos criar um módulo chamado ModuloOla.py e vamos editá - lo:

class ClasseOla:


self.nome = nome

def falar(self):



self.nome = nome

Agora salve este arquivo, testando - o logo a seguir:

>>>from dirOla import ModuloOla


>>>from ModuloOla import ClasseOla

>>> a = ClasseOla()

>>>a.falar()

'Olá, Mundo'

Criando um Produto

Agora que você já tem seu pacote montado vamos criar seu produto.Primeiramente, copie seu diretório dirOla para /lib / python /Products da suaaplicação Zope e renomeie este diretório para produtoOla.

Uma vez feito isto, você deve então editar seu arquivo __init__.py como oexemplo:

import ModuloOla

def initialize(context):

context.registerClass(

ModuloOla.ClasseOla,

permission=”Adicionar um Objeto Ola”,

constructors=(ModuloOla.manage_addOlaForm,

ModuloOla.manage_addOla)

)

Agora salve seu arquivo. Uma dica importante é criar um arquivo vaziorefresh.txt para o seu diretório ProdutoOla para permitir a funcionalidade deatualizar quando você estiver desenvolvendo seu produto.

Agora vamos alterar um pouco seu arquivo ModuloOla.py:

def manage_addOlaForm(self):

“ “

def manage_addOla(self):

“ “

class ClasseOla:


self.nome = nome


meta_type = “Objeto Olá”

def falar(self):



self.nome = nome

Agora salve seu arquivo. Os métodos addOlaForm e addOla serãomodificados posteriormente.

Adicionamos o meta_type que faz a descrição da classe.

Com estas mudançãs, o Zope será capaz de registrar corretamente o produtoquando você estartar ou reiniciar o servidor Zope. Você será capaz de ver oproduto, mas não conseguirá adicionar o produto dentro de um folder. Isso édevido ao fato dos métodos manage_addOlaForm e manage_addOla não estaremimplementando funcionalidades que interagem com o tipo de código depresistência que o Zope utiliza.

Para uma perfeita funcionalidade, vamos agora alterar os métodos citadosacima:

Preenchendo os métodos manage_add

Os métodos então ficarão da seguinte forma:

def manage_addOlaForm(self, REQUEST):

"Form para adicionar um objeto Ola."

return """

<html>

<head></head>

<body>

<form method="post" action="./manage_AddOla">

<input type="submit" value="Add Olá">

</form>

</body>

</html>


"""

def manage_addOla(self, id, REQUEST):

"Método para adicionar um objeto Olá"

ola = ClasseOla(id)

self._setObject(id, ola)

return self.manage_main(self, REQUEST)

Deve ser feita agora uma mudançã na classe ClasseOla, para que o objetoreconheça seu próprio id:

class ClasseOla:

def __init__(self, id, nome = "Mundo"):

self.id = id

self.nome = nome

meta_type = "Objeto Ola"

def falar(self):

return "Olá, " + self.nome


self.nome = nome

Feito tudo isso, você pode atualizar seu produto Zope na aba refresh, e clicarno botão para atualizar o produto. Isto habilitará as mudanças que você fez sem terque reiniciar o servidor Zope.

Subclasses de classes ZopeSeu produto parece pronto para ser usado, contudo se você fizer isto, um

erro ocorrerae não adicionará o seu objeto. Isso ocore porque a ClasseOla não sabecomo representar ela mesma na interface de gerenciamento do Zope ou no seubanco de dados. Para remediar isto, você deve importar algumas classes padrõesdo Zope.


Para interagir corretamente com a interface de gerenciamento, você deveimportar a classe OFS.SimpleItem.Item:

from OFS.SimpleItem import Item

para interagir com o ZODB, você deve importar a classe Globals.Persistent:

from Globals import Persistent

para interagir com os atributos de aquisição você deve importar a classeAcquisition.Implicit:

from Acquisition import Implicit

adicione essas três linhas de código no topo de seu arquivo ModuloOla.py emude a definição da classe ClasseOla para ela interagir com estas três classesbases:

class ClasseOla (Item, Persistent, Implicit):

Após fazer estas mudanças, atualize seu produto e tente adicionar o objetoOla novamente. Selecione a opção Objeto Ola que se encontra no menu Add . Oformulário para adiconar deve aparecer.

Digite então TesteOla no formulário e clique no botão add Olá. Isto deve tetrazer de volta para a página principal e você deve ver um objeto TesteOla listado.

Parabéns, você conseguiu com êxito criar um produto que pode seradicionado através da interface de gerenciamento do Zope.


10 Plone

O Plone é um produto Zope escrito em python que provê uma maneira rápida eeficaz de se desenvolver portais de conteúdo. Ele é o que, normalmente, chamamosde CMS (Content Management System) ou Sistema de Gerenciamento de Conteúdo.

O Plone é, hoje, um dos principais produtos desenvolvidos para Zope e possuiuma comunidade ativa e motivada (www.plone.org) .

Em www.plone.org você encontrará instaladores do Plone para Windows epacotes compactados para instalação em uma instância Zope já existente emwindows, linux ou outros SO's.

Veremos agora como instalar o Plone para Windows, a partir de um pacoteexecutável e como adicioná - lo a uma instância Zope já existente em qualquer SO's.

Instalação do Plone no Windows● Em www.plone.org clique em downloads e busque a distribuição voltada

para o sistema windows. Provavelmente, um executável comaproximadamente 20MB.

● Faça o download desta distribuição e após o término do download executeo arquivo .exe baixado.

A instalação prossegue da seguinte forma:

Tela de bem- vindo do plone


Tela de licenciamento do Plone.

Tela de usuário e senha de administração.


Local de instalação.

Tela de opções selecionadas antes da instalação.


Progresso da Instalação.

Finalização da Instalação.

● Após o término da instalação vá para o menu iniciar e veja que umacategoria de programa com o nome Plone foi criada.

Instalação do Plone para Linux


● Após a instalação do Zope e criação de uma instância, visitewww.plone.org e em downloads escolha em Plone Core a distribuição quemais se aproxima do seu SO's. Essa distribuição será, provavelmente, umarquivo compactado do tipo tar.gz.

● Após o download, descompacte o arquivo:

tar xzvf nomedoarquivo

● Após a descompatação uma pasta contendo subpastas será criada. Essassubpastas são os Produtos, escritos em python, que constituem o Plone.

● Copie as subpastas para a pasta Products da sua instância Zope. Isso faráque na próxima inicialização da instância o Zope reconheça os produtosinstalados e habilite um objeto do tipo Plone Site na ZMI.

● Inicie a instância Zope e verifique se, na lista de componentes disponíveis,aparece o componente Plone Site.

● Crie um objeto Plone Site com um id qualquer, por exemplo “plone”.

● Abra outra janela do navegador e digite http: / / localhost:porta / iddoobjetoe assim você verá um CMS ou Portal Plone em funcionamento.
