Personal tools

Skip to content. | Skip to navigation

Sections

Blog

You are here: Home Blog

Blog

Showing blog entries tagged as: Plone

Até logo Mr. Lepri!

Posted by Érico Andrei at 04/02/2013 16:42

Um agradecimento a um profissional que nos fez um time melhor.

Até logo Mr. Lepri! | Comentários

Read More…

Cafecito Sprint: the lost post

Posted by Héctor Velarde at 10/01/2013 15:45

The long awaited first public release of collective.cover is finally available for download.

Cafecito Sprint: the lost post | Comentários

Read More…

Entendendo a expiração/publicação de objetos no Plone

Posted by Thiago Tamosauskas at 14/12/2012 13:31

O Plone possui um recurso poderoso para agendar a publicação e despublicação de um conteúdo. Essa funcionalidade se usada com inteligência pode ser muito interessante, mas pode também causar certa confusão numa primeira abordagem.  Para deixar as coisas mais claras Kees Hink publicou em seu blog um resumo simples mas valioso sobre o assunto:

  • Quando um item chegar à sua data de expiração ele será marcado como "expirado" em vermelho.
  • Um item cuja data de publicação ainda não tenha chegado não será marcado de forma nenhuma.
  • Em ambos os casos, o item permanece "despublicado" mas não confunda isso com seu estado de workflow.
  • Um item "despublicado" apenas não aparecerá nas listagens e buscas.
  • Essas listagens e buscas incluem as listagens da pastas e coleções
  • Contudo o dono do item de conteúdo ainda poderá vê-lo. Isso é útil porque as pessoas gostam de ver o conteúdo que criaram para seu site.
  • A permissão que controla esse acesso é "Access inactive portal content."
  • Itens expirados quando podem ser vistos em uma pasta serão devidamente marcados.
  • Não há uma maneira rápida de ver itens em uma pasta que ainda não foram publicados.
  • Quando você define um item despublicado como exibição padrão de uma pasta ele aparecerá para todos.
  • Despublicar um item não afeta os usuários administradores. Eles sempre verão os itens não publicados em suas listas e buscas.
  • Dar aos usuários normais permissão de "adicionar", "editar" e "revisar" em um item não faz esse item menos "despublicado" para eles.
  • Uma maneira prática de permitir que usuários não administradores acessem um item despublicado é acessá-lo usando a URL direta do objeto.
| Comentários

Products.contentmigration saves the day

Posted by Érico Andrei at 12/12/2012 18:16
Filed under: Migration, Transmogrifier, Plone

You write your transmogrifier pipeline, import content into Plone, see your images listed there just to -- at the last possible moment -- find out they were imported as files. No time to run the pipeline again... Then, the old, Products.contentmigration comes to rescue you

Products.contentmigration saves the day | Comentários

Read More…

Plone 4.3 fará as pazes com os designers

Posted by Thiago Tamosauskas at 26/10/2012 11:50
Filed under: Diazo, Plone, Temas
Plone 4.3 fará as pazes com os designers

Um dos treinamentos mais legais que faço hoje em dia é sobre a criação de temas em Diazo. Embora sejam divertidos esses treinamentos mostram que o processo de criação de layouts para Plone ainda não é simples o suficiente para que todo e qualquer designer possa participar sem uma instrução prévia específica. felizmente estes dias parecem estar no fim, e muito em breve o Plone será um dos CMS mais amigável entre todos para a criação de temas.

A comunidade Plone colaborou recentemente com o Diazo Work Group de Los Angeles, da Universidade da California para dar um salto evolutivo em termos de  interface de design. O resultado é um editor fácil de ser usado que roda no próprio Plone e será acompanhado de ferramentas para criação avançada de temas e testes.

Tudo isso já estará disponível a partir do Plone 4.3. A idéia principal é que o usuário possa fazer upload de uma página estática com HTML e CSS e então por meio da ferramenta gerar automaticamente o XML com as regras do Diazo. Em outras palavras importar temas se tornará algo bem mais simples.

O resultado desses esforços é tornar a customização de layouts algo bem mais fácil e agradável dentro do Plone. Desta forma as portas do Plone estarão em breve  escancaradas para que novos designers (não-desenvolvedores) possam colaborar e criar seus temas sem precisar acessar o filesytem, rodar buildouts ou programar em python para implementarem seus temas. 

 

| Comentários

Collectice.cover pega pra capa

Posted by Thiago Tamosauskas at 15/10/2012 10:00
Filed under: Produtos, Plone

O Plone é uma excelente ferramenta de gestão de conteúdo, não é surpresa portanto que seja escolhido para portais de notícias e sites com grande produção de informação. Entretanto sites deste porte exigem sempre a edição de uma ou mais capas editoriais, seja na página inicial ou em subseções. Uma maneira de organizar e apresentar todo conteúdo produzido. O Plone já possuiu alguns produtos específicos para isso mas eles sempre apresentaram barreiras ou serem complexos demais ou por não serem flexíveis o bastante. Com o lançamento do collective.cover esses obstáculos foram finalmente superados.

O collective.cover nasceu graças a um esforço conjunto da Comunidade Plone da América do Sul durante o primeiro "Cafecito Sprint"  e foi criado tendo foco em portais de notícias, sites governamentais e intranets mas de uma maneira que fosse flexível o bastante para ser usado sem nenhuma dificuldade por sites menores. 

Toda edição é feita por meio de páginas simples e interfaces drag-and-drop. Em primeiro lugar você cria sua capa ("cover") escolhendo entre um dos layouts pré-definidos ou criando um novo do zero. Depois disso você seleciona "screenlets" que nada mais são do que maneiras diversas de apresentar um conteúdo. Um screenlet pode ser uma coleção de itens, um destaque único ou mesmo um carrossel de slides, entre outras opções. Um detalhe importante é que uma vez construído esse layout ele pode ser salvo para ser usado em outros lugares no seu mesmo Plone site.

Com seu layout pronto você agora só precisa se preocupar com a gestão do conteúdo propriamente dita, ou seja, selecionar as notícias ou páginas arrastando elas para seus respectivos screenlets. Este é um ponto importante porque significa que a diagramação foi separada com perfeição da edição de conteúdo de maneira que durante o dia a dia ao mudar os destaques de uma página o usuário do site não precisará preocupar-se com detalhes técnicos desnecessários.  

Apesar de ser um produto novo o Collective.cover já foi muito bem recebido pela Comunidade Plone internacional e, foi apresentato por André Nogueira e Hector Velarde da Simples Consultoria recentemente na Plone Conference e já está em uso em alguns sites como o da VTV -  TV Estatal da Venezuela . Se você se interessou em conhecer ou mesmo colaborar com este produto acesse o repositório: https://github.com/collective/collective.cover

| Comentários

Special report from São Paulo, Brazil: Cafecito Sprint Day 9

Posted by Héctor Velarde at 04/07/2012 13:15
Filed under: JQuery, Sprint, usabilidade, Plone
Special report from São Paulo, Brazil: Cafecito Sprint Day 9

Day 9 (Thursday, June 28)

Early in the morning hvelarde get mad when he realized the team had only 2 days to complete the sprint and not enough work had been done on the tiles stuff yet. We had to change that!

Happily, agnogueira had created a bunch of tile mockups so we could concentrate on this.

Frontend Team

flecox implemented some UI on the permission stuff developed by frapell.

quimera stopped working on the resizing of the columns, for now; he implemented the delete tile feature and the UI to show if a tile allows certain content type to be dragged on it.

Backend Team

frapell added a permission check to the populate_with_object method so it won't modify an object if the user has no permission to do so.

jpg_rcom fixed a bug in the data manager that was affecting the creation of the tile and implemented the basic tile image scaling. Now, when the object dragged to a tile contains an image, the tile shows it. Great!

hvelarde created a file tile, removed a bunch of legacy code and added more tests to the package.

| Comentários

Special report from São Paulo, Brazil: Cafecito Sprint Day 8

Posted by Héctor Velarde at 28/06/2012 21:46
Filed under: JQuery, Sprint, usabilidade, Plone
Special report from São Paulo, Brazil: Cafecito Sprint Day 8

Day 8 (Wednesday, June 27)

Oliver joined the sprinters and succeeded to commit his first sprint group photo.

Frontend Team

quimera spent the whole day trying to implement columns drag&drop; he almost succeeded… Holy cow! Did I said "almost"?

flecox added support for column permissions on the layout user interface. Now you can set group permissions to all tiles inside a column in an easy way: if a user does not belong to a group with editing permissions on a tile, he will not be able to modify the content on it.

Backend Team

frapell added plone.app.stagingbehavior to provide versioning, working copy, and locking functionality. He also created an event to move annotations from the working copy to the baseline when a check-in is applied.

jpg_rcom created a custom ITileDataManager to store image modification time.

hvelarde replaced the way we were registering tiles for the package: we now use plone.registry and we have a vocabulary for listing the available tiles; he also made some code cleaup.

Have you tried the package lately? It's really amazing!

| Comentários

Special report from São Paulo, Brazil: Cafecito Sprint Day 7

Posted by Héctor Velarde at 27/06/2012 14:30
Filed under: JQuery, Sprint, usabilidade, Plone
Special report from São Paulo, Brazil: Cafecito Sprint Day 7

Day 7 (Tuesday, June 26)

Frontend Team

quimera worked on the drag&drop feature for tiles and columns; he also fixed many bugs. We can now create and save layouts; we only need to implement more tiles now.

flecox worked on modal windows to select the type of tile being added to a layout and to configure them.

davi-lima made some code cleanup.

Backend Team

frapell worked on adding a permission subsystem, so now we are able to grant groups permissions to edit tiles content. The edit-tile view now checks for that when trying to render, and it will raise an Unauthorized exception if the user doesn’t belong to the specific group. Kudos!

jpg_rcom fixed the basic tile he started last week, and started implementing an image field with blob support.

hvelarde cleaned up the buildout configuration used for development, and implemented locking behavior for the composition content type.

| Comentários

Special report from São Paulo, Brazil: Cafecito Sprint Day 6

Posted by Héctor Velarde at 27/06/2012 12:50
Filed under: JQuery, Sprint, usabilidade, Plone
 Special report from São Paulo, Brazil: Cafecito Sprint Day 6

Day 6 (Monday, June 25)

Frontend Team

quimera continued working on the edition of layouts: he added a Saving event, error handling for the Save action, fixed the JSON structure in the layout view and made other minor fixes.

flecox worked on the column resizing feature and the Content Tree screenlet.

davi-lima made some refactoring on the tile template for the layout.

agnogueira created a set of tile mockups that we will need to implement on the first release of the package.

Backend Team

frapell continued working on the tile configlets based on z3c.form; he also added configuration templates for base widgets, richtext widgets and textline widgets, and added a new data manager for the tiles, so we can handle configurations before they are rendered.

nueces added a "tail" for a collection content type; we are still trying to figure out where to put it on the package.

hvelarde worked on packaging and documentation stuff, and spent most of the evening understanding, the wrong way, that sometimes collaboration in Open Source projects among different languages, cultures, and time zones is hard.

| Comentários

Special report from São Paulo, Brazil: Cafecito Sprint Day 5

Posted by Héctor Velarde at 25/06/2012 20:05
Filed under: JQuery, Sprint, Usabilidade, Plone
Special report from São Paulo, Brazil: Cafecito Sprint Day 5

Day 5 (Friday, June 22)

Frontend Team

flecox and davi-lima continued to work on the screenlets, implementing both the Recent Items and Content Tree tabs and also making room for the clipboard one, which will be developed next (based on a catalog filter for content UUID).

quimera implemented a Save functionality to export the designed layout into a JSON structure which is AJAX-stored as an annotation in the context. That was amazing!

They also spent big time debugging and cleaning up the code as well as preparing icons, internationalizing and localizing templates and improving documentation.

Backend

frapell updated package's documentation to explain how to create a tile to use in the composition; he also made a configuration template for automatic rendering a Configure mode for the widgets in the tile by using z3c.form. Really cool!

hvelarde worked on moving Carlos de la Guardia's original collective.composition repository to the Collective just to have the issue tracker there; he also added i18n code to plone.app.tiles and Brazilian Portuguese and Spanish translations to the package, and tried to fix the basic tile but he failed miserably: wish him better luck next time.

| Comentários

Special report from São Paulo, Brazil: Cafecito Sprint Day 4

Posted by Héctor Velarde at 22/06/2012 18:45
Filed under: JQuery, Sprint, usabilidade, Plone
Special report from São Paulo, Brazil: Cafecito Sprint Day 4

Day 4 (Thursday, June 21)

The day started with a hangout of the sprinters with Rok Garbas (garbas); he has been working on plone.app.deco lately and he wanted to find out if we can collaborate in some way.

We followed closely his presentation and explained him that the goal of the sprint is to release an usable package to create front pages for projects we are working on, and to release it for the community.

Maybe after that we can start looking how to generalize what we are learning.

Frontend Team

davi-lima and flecox worked on refactoring the "screenlet" mechanism for providing the windows and overlays that will display tools and settings used in the Compose and Layout tabs for the Composition object. The work is not finished but the screenlet also knows how to update itself based on user interaction, like content filtering, based on text filters and eventually tabs.

quimera worked in the HTML serialization of a created layout and the save functionality.

Backend Team

Juan Pablo Giménez (jpg_rcom) joined (remotely from Rosario, Argentina) frapell on the backend team; jpg_rcom is a long time Plone contributor and co-author of Plone 3 Products Development Cookbook book.

frapell tried to implement a configuration view for the tiles. This view will allow us to adjust how fields will show up: we could have a tile that displays a title, a description and an image and we will be able to change the order of the fields, the alignment of the text or the size of the image.

jpg_rcom created a new basic tile that will display title, summary and an image for most standard content types.

agnogueira and hvelarde found a nice icon for the package; if only we could find a good name also…

| Comentários

Special report from São Paulo, Brazil: Cafecito Sprint Day 3

Posted by Héctor Velarde at 21/06/2012 18:40
Filed under: JQuery, Sprint, usabilidade, Plone
Special report from São Paulo, Brazil: Cafecito Sprint Day 3

Day 3 (Wednesday, June 20)

We need your help to find a better name for this package!

If you have an idea, please let us know.

Frontend Team

flecox created a screenlet to search for content types and drag&drop them on tiles, after the drop is done an AJAX call send the UID of the object and the id of the tile and return the HTML of the tile with the data of the content.

quimera decided to divide in two the layout: layout view to create the “layout” with rows and cells and a permissions view to wrap the parts of the layouts in groups and add permissions to them.

Backend Team

frapell made some advances adding functionality that will allow to send an object to a tile and update its content, and to delete tiles data to maintain integrity.

A major change was made into the way the composition use the layout. Now, the layout gets stored in the composition itself, so it is independent from what it is in the registry, and from other compositions. In the moment that the composition gets created, random ids get assigned to the tiles.

Some bug fixes were tackled too, and more functionality was included into the recursive layout renderer, which can identify which view is being rendered on, and can render different content accordingly.

And finally, a new functionality was included into the tiles, that will allow to return a list of accepted content types that can be dropped into a tile.

hvelarde spent part of the day preparing the blog posts for the first two days of the sprint and made some code review (mainly PEP 8/Pyflakes) to Plone core packages like plone.app.blocks, plone.app.tiles and plone.tiles.

At the end of the day both teams merged code and got something almost usable; the day was very productive and what we have now looks pretty good!

Download the development buildout and check it by yourself ;-)

| Comentários

Special report from São Paulo, Brazil: Cafecito Sprint Day 2

Posted by Héctor Velarde at 20/06/2012 14:30
Filed under: JQuery, Sprint, usabilidade, Plone
Special report from São Paulo, Brazil: Cafecito Sprint Day 2

Day 2 (Tuesday, June 19)

Frontend Team

Ricardo Bánffy (rbanffy) joined agnogueira, davi-lima, flecox and quimera on the front end team; rbanffy is founding member of Associação Python Brasil and long time technology advisor at Simples Consultoria.

Once again the team begun the day discussing the implementation of the whole front end, with lots of drawings in the whiteboard. The team realized that, to be grid-friendly, they need to allow users to draw all the possible layouts with our “Groups” and “Tiles” entities and then implement the right combination of “row” and “cell” CSS classes from Deco.gs (or the similar ones from the other grid systems).

The team noticed they are going to have a lot of trouble very soon dealing with nested rows, cells and all their width calculation using percentage values . They decided to start with baby steps and, following the mockups, create a simple static layout that can´t be modified, but can be used by an “Editor” to add content to the static tiles.

Finally, they discussed the format of the JSON they'll deliver to the backend to inform about the structure of the created layout.

Backend Team

The layout data structure was initially designed by frapell, and he also implemented a recursive renderer for it. Finally, the layout structure was included in the main composite view and a temporal way of editing the tiles was added.

Unneeded code was successfully removed by hvelarde; he also added some basic tests and made some updates on i18n.

| Comentários

Special report from São Paulo, Brazil: Cafecito Sprint Day 1

Posted by Héctor Velarde at 20/06/2012 12:30
Filed under: JQuery, Sprint, usabilidade, Plone
Special report from São Paulo, Brazil: Cafecito Sprint Day 1

Day 1 (Monday, June 18)

Work started late thanks to a broken fiber optics cable brought to us by Vivo (Telefônica Brasil).

Coffee after lunch was courtesy of Leo's Cafecito.

Frontend Team

The team was formed by agnogueira, davi-lima, flecox and quimera.

They begun the day discussing how some grid systems (like Deco.gs) can disturb responsive design principles, with rows preventing cells from floating one below the other when screen is shrinked. So, even though inspired by Deco.gs, they decided to begin with their own set of CSS classes to indicate widths and floats, but not positions.

For tiles' drag&drop and resizing functionalities they chose to start with jQuery UI since it's being included in Plone anyway. The team decided to begin with the resizing so they wrote code implementing the "Groups and Tiles" mockup as a proof of concept. They couldn't use the native snap functionality, because of the lack of a "snap" event in the resize API, so they found some trouble calculating exactly when enough pixels were dragged to update the tile CSS class which defines its width. At first they tried binding the math into the jQuery UI resize event but it was too expensive and lagged, so they went for start and stop events.

Generally it was a nice first day ending with important discussions with the backend team on how we'll persist the layouts after the user presses the Save button on the Layout tab.

Backend Team

The team was formed by frapell, hvelarde and nueces.

The team decided to take on the problem using the collective.composition approach. Based on a blog post by David Glick, they merged back the tiles implementation in collective.composition from frapell's fork and moved the package into the Collective. The idea was to remove some of the content types implemented and start adding different tiles types.

They debated a bit on which would be the best implementation, first they wanted to use recursive tiles and implement a “folder” tile to hold other tiles, but plone.app.blocks doesn’t work that way. So, the main idea will be to use panels to store the tiles. Then they’ll store the panels and tiles HTML structure in a field for the "Composition” object. This way we can have versioning and working copy for free. Global layouts will be added in the Plone registry, that way, we can use Generic Setup to import and export layouts.

Take a look (and help out!) at the full development buildout running on https://github.com/collective/collective.composition.

| Comentários

Design responsivo com Plone tem novo release

Posted by Érico Andrei at 21/03/2012 18:55
Filed under: Tablet, Plone 4, Design, Tema, Plone

Acabamos de fazer o release da versão 0.3 do beyondskins.responsive, design responsivo para sites Plone com a tecnologia Diazo.

Design responsivo com Plone tem novo release | Comentários

Read More…

JavaScript Minify com Python

Posted by Cleber J Santos at 17/03/2012 19:30
JavaScript Minify com Python

Trabalhando em um projeto recentemente precisei gerar um arquivo menor do jQuery que eu havia modificado, e com isso comecei a me perguntar como o jquery.com o fazia com seus arquivos por exemplo: 

  • jquery-1.7.1.js 244K
  • jquery-1.7.1.min.js 92K

Notaram  a diferença de tamanho? Pois bem, isso me levou a pesquisas, que por sua vez me levou a diversos resultados, uma delas é o link http://www.refresh-sf.com/yui/ que nada mais é que uma interface Web que reduz o arquivo como eu queria fazer.
 
Porém que queria mais que isso, não quero depender de entrar em um site para gerar um arquivo menor, então achei Egg que faz exatamente o que eu queria, e melhor que isso, é pytonica :D http://pypi.python.org/pypi/jsmin
 
Vamos então a solução, para isso vamos usar o próprio jQuery só para testarmos que funciona após ter minimizado o tamanho do arquivo, é claro que isso é apenas um teste, pois o jQuery já lhe dará o arquivo dele como mostrado acima, compactado.
 
Vamos criar uma pasta chamada cobaia, dentro dessa pasta baixe o arquivo mencionado e visualize o tamanho dele:
 
$ mkdir cobaia
$ curl -O http://code.jquery.com/jquery-1.4.4.js
$ ls -hs *.js
No momento você verá o que o arquivo contém 180K, agora vamos criar um arquivo menor. Instale o egg jsmin no seu python com o comando:
 
$ easy_install jsmin
Ou 
$ pip install jsmin
Feito isso acesse o prompt do Python (Estou usando Python 2.6) e vamos converter assim:
$ python
>>> from os import path
>>> from os.path import join
>>>
>>> # Usei o cStringIO por ser mais rápido que o StringIO implementado em Python
>>> from cStringIO import StringIO
>>> 
>>> # As linha abaixo é o que nos garante o uso do jsmin
>>> import jsmin
>>> jmin = jsmin.JavascriptMinify()
>>>
>>> base = path.dirname(path.abspath(path.realpath(__name__)))
>>>
>>> # Abrimos o arquivo original apenas como leitura 
>>> filejs = open(join(base, 'jquery-1.4.4.js'),'r')
>>>
>>> # Pegamos o nome do arquivo original e concatenamos com .min.js
>>> filename_out =  str(str(filejs.name.split('/')[-1]).split('.js')[0] + '.min.js')
>>>
>>> file_out = StringIO()
>>> file_out.write("")
>>>
>>> # Gerando um novo arquivo com modo de escrita
>>> file_out = open(join(base, filename_out),'wb')
>>>
>>> # Por fim passamos para o minify um arquivo de entrada e o de saída
>>> jmin.minify(filejs,file_out)
>>> file_out.close()
 
CTRL+D para sair do console python.
 
Mantive o exemplo acima comentado para que possam melhor entender o que foi feito. Agora podemos usar novamente o comando para ver o tamanho dos arquivos, antes e depois.
$ ls -hs *.js
Note que agora temos um novo arquivo com o nome de jquery-1.4.4.min.js com apenas 112k, pode não parecer muito, mas tenha certeza que isso ajuda muito no desempenho do seu site, ainda mais se você tiver bem mais arquivos.
 
Fiz este mesmo teste em um arquivo que eu tinha de 152k e ele foi para 64k, então veja bem a diferença. Vale testar com seus arquivos, claro que é sempre bom fazer um backup antes ;)

Outra forma de fazer.

Essa é a outra forma de fazer, mas não é pythonica. Achei importante mencionar essa outra forma de fazer, que na verdade é exatamente de onde partiu a idéia em Python e provavelmente as demais ;)
 
O código e projeto original do JSMin é escrito e mantido por Douglas Crockford em C e pode ser acessado em https://github.com/douglascrockford/JSMin.
 
Jsmin é um filtro que omite ou modifica alguns caracteres. Isto não altera o comportamento do programa que estamos reduzindo. O resultado pode ser mais difícil depurar. Vai ser mais difícil de ler.
 
Após baixar o jsmin.c, vamos compilar e usar, abaixo mostro como compilar e como usar, lembrando que estamos usando o arquivo do jquery como modelo. O comando segue o mesmo modelo que em Python, neste caso o binário do jsmin também requer um arquivo de entrada e outro de saída.
 
$ gcc jsmin.c -o jsmin
$ ./jsmin < jquery-1.4.4.js > jquery-1.4.4.min.js
Pronto! Agora temos um arquivo com 108k, menor ainda que o gerado em Python :D
 

O pulo do gato.

Descobri ainda que o jQuery usa o chamado packer (http://dean.edwards.name/packer/) que nada mais é que um compressor de JavaScript, após passar o arquivo que temos de 108k o resultado foi 60k, então aqui descobrimos o pulo do grato usado pelo jQuery.
 
É isso ai, agora você já pode começar a se divertir e colocar um pouco mais de performance em seu site.
| Comentários

Como adicionar Eventos do Plone no Google Calendar

Posted by Thiago Tamosauskas at 19/08/2011 12:35
Filed under: Google, Plone, ZPT
Como adicionar Eventos do Plone no Google Calendar

O 'Evento' e um tipo padrão do Plone que, entre outros recursos, possui alguns links (iCal e vCal) que permitem adicionar o evento do seu site ao calendário de aplicativos como o Mozilla Sunbird, Microsoft Outlook e similares... Este é um recurso maravilhoso, que nunca vi ninguém usar o_O .

Por outro lado todos os meus heróis que não morreram de overdose usam hoje o Google Calendar para organizar seu dia a dia. Pensando nisso imaginei uma maneira de termos um link nos eventos do Plone que adicione ele as agendas do Google Calendar.

Você vai precisar:

1 - Um script python para formatar a data, que chamaremos, Dataformat.py:

from DateTime import DateTime
if not dt:
 dt = DateTime()

if not format:
 format = "%Y%m%dT%H%M00"

if not same_type(dt, DateTime()):
 dt = DateTime(dt)

print dt.strftime(format)
return printed

Este script é necessário para formatar as datas iniciais e finais do evento no formato usado pelo Google Calendar

2 - Colocar a seguinte expressão em Zope Page Template no seu template event_view.pt

<a href="#" title="Add to Google Calendar" target="_blank" 
            tal:define="atDate here/start;
                        inicio python: context.Dataformata(atDate);
                        fim python: context.Dataformata(atDate)"
            tal:attributes="href string:http://www.google.com/calendar/render?
action=TEMPLATE&text=${context/Title}&dates=${inicio}/${fim}&location=
${context/getLocation}&details=Detalhes:${context/absolute_url}&trp=false">
    Google Calendar
</a>

Seguindo os passos acima você terá um link que incluirá o evento em questão a sua agenda do Google Calendar. Veja um exemplo no site de um de nossos clientes: http://www.proparts.esp.br/events/copa-sram-1a-etapa-sram-50k/view

| Comentários

Migrando Varnish 2.1 para Varnish 3.0

Posted by Cleber J Santos at 14/08/2011 00:35
Migrando Varnish 2.1 para Varnish 3.0

Nas últimas semanas tenho tido a oportunidade de ficar mais próximo do Varnish, e nas últimas três semanas comecei a migrar do varnish 2.1 para Varnish 3, posso dizer desde já que teve um grande salto de melhorias e também de implementações. Mas neste post irei tratar apenas de como preparar sua configuração de vcl para não ser pego de supresa quando fazer um upgrade da versão.

O exemplo de vcl a seguir foi retirado do svn do Varnish: https://www.varnish-cache.org/trac/browser/etc/zope-plone.vcl e será com base neste vcl que iremos efetuar a migração.

Breve resumo das mudanças de 2.1.5 para 3.0.0

  • Suporte ao módulo VMODs [3].
  • Suporte a Compressão e descompressão, incluindo compressão de fragmentos ESI.
  • Suporte a carregamento preliminar de streaming, tanto em cache ou não.
  • Melhor documentação.
  • Melhor valores padrão para parâmetros.
  • varnishncsa agora com suporte de log com formatos personalizado.
  • varnishlog, varnishncsa  e varnishhist agora com suporte a filtros de registros que correspondem múltiplas expressões.

Para uma lista mais detalhada de alterações leia o documento de alterações.
 

Alterações na VCL.

  

  • log foi movido para o vmod std.[4]

log "Olá mundo";
torna-se
import std;
std.log "Olá mundo";
Nota. A importação do std só é preciso ser feito uma única vez e usada por toda a VCL.
 
 

  • purge agora torna-se o chamadas ban, ou como dito na VCL, são funções ban.

purge() e purge_url() são agora, respectivamente ban() e ban_url(), sendo assim deve-se substituir todas as ocorrências: 
purge(“req.url = ” req.url);
para
ban(“req.url = ” + req.url);

purge
 continua existindo porém não leva nenhum argumento mais, e ainda pode ser usado em vcl_hit ou vcl_miss para fazer purge de itens do cache, onde você iria reduzir o ttl a 0 no Varnish 2.1.
 sub vcl_hit {
   if (req.request == “PURGE”) {
      set obj.ttl = 0s; error 200 “Purged.”;
   }
}
torna-se
sub vcl_hit {
   if (req.request == “PURGE”) {
      purge; error 200 “Purged.”;
   }
}

 

  • beresp.cacheable está fora.

beresp.cacheable está fora do Varnish 3, mas pode ser substituído por beresp.ttl> 0s

 

  • returns agora é feito com a função return()

pass, pipe, lookup, deliver, fetch, hash, pipe e restart não são mais palavras-chave, mas argumentos para a função return(), então:

sub vcl_pass {
   pass;
}

torna-se

sub vcl_pass {
   return(pass);
}

 

  • req.hash foi substituído por hash_data()

Não apendamos mais o hash com +=
set req.hash += req.url;
Agora torna-se
hash_data(req.url);

 

  • esi substituído por beresp.do_esi

Não habilitamos ESI com esi.
esi;
no vcl_fetch tonar-se
set beresp.do_esi = true;

 

pass em vcl_fetch foi renomeado para hit_for_pass

A diferença no comportamento do pass em vcl_recv e vcl_fetch confundem as pessoas, apenas para torna mais claro as coisas, eles são diferentes :) e agora devemos usar return(hit_for_pass) onde usava-se pass no vcl_fetch.

 

  • NOTA.

O Varnish 3 também teve uma mudança de comportamento, isso significa que ele irá retornar um erro quando cabeçalhos forem muito grandes ao em vez de apenas ignorá-los. E se os limites são muito baixos, retornará HTTP 413, então deve-se  alterar limits por http_req_hdr_len e http_req_size. Essas alterações devem ser feitas em tempo de execução, o que significa adicionar como parâmetro do executável varnishd,   exemplo (-p http_req_hdr_len=4096 -p http_req_size=1024).

Para maiores informações sobre parâmetros em tempo de execução acesse a documentação[5].

 

Migrando.

 

Eis aqui nosso exemplo retirado do svn do Varnish, porém convertido para a versão 3.0, retirei quais quer comentários da VCL e efetuei a migração, acredito que depois da explicação dos parâmetros acima você seja capaz de migrar a sua configuração.

 

backend default {
	.host = "127.0.0.1";
	.port = "9673";
}

acl purge {
	"localhost";
	"192.0.2.0"/24;
}

sub vcl_recv {
        if (req.http.host ~ "(www.)?example.com") {
                set req.http.host = "example.com";
		set req.url = regsub(req.url, "^", "/VirtualHostBase/http/example.com:80/example.com/VirtualHostRoot");
        } elsif (req.http.host ~ "(www.)?example.org") {
                set req.http.host = "example.org";
		set req.url = regsub(req.url, "^", "/VirtualHostBase/http/example.org:80/example.org/VirtualHostRoot");
        } else {
                error 404 "Unknown virtual host.";
        }

        if (req.request != "GET" && req.request != "HEAD") {
                if (req.request == "POST") {
                        return(pass);
                }
                
                if (req.request == "PURGE") {
                        if (!client.ip ~ purge) {
                                error 405 "Not allowed.";
                        }
                        return(lookup);
                }
        }
        if (req.http.Cookie && req.http.Cookie ~ "__ac(|_(name|password|persistent))=") {
		if (req.url ~ "\.(js|css)") {
                        remove req.http.cookie;
                        return(lookup);
                }
                return(pass);
        }
}

sub vcl_hit {
        if (req.request == "PURGE") {
                purge;
                error 200 "Purged";
        }
}

sub vcl_miss {
        if (req.request == "PURGE") {
                error 404 "Not in cache";
        }
}

sub vcl_fetch {
        if (beresp.ttl < 3600s) {
                set beresp.ttl = 3600s;
        }
} 

 

Indicação de leitura.

| Comentários

Plone 4, velocidade e Chameleon tudo em comum.

Posted by Cleber J Santos at 14/07/2011 14:30
Plone 4, velocidade e Chameleon tudo em comum.

Num post anterior escrito pelo amigo simplificador @Tamosauskas (Plone mais rápido com Chameleon), foi mencionado a preocupação e empenho que a comunidade Plone tem tido quando o assunto é desempenho. Pois bem, neste post pretendo reforçar este aspecto, lembrando que essa é umas das preocupações da comunidade, tenho também como maior delas a segurança é claro.

Como dito no post do @Tamosauskas, a cada nova versão do Plone percebemos um ganho de desempenho, desde a versão 2.5 até a mais atual em desenvolvimento 4.1rc3 (Atual até a data que estou escrevendo este post), e claro, ganho de novas funcionalidades mudanças significativas para  criação de novos produtos e tipos e a mudança da skin padrão.

O que exatamente é o tal do Chameleon?

No site oficial a melhor definição é "Chameleon is an open-source template engine written in Python.
", de fato, trata-se de um modelo de templates escrito em Python, ele foi escrito para gerar documentos de marcação HTML ou XML para aplicações Web.

Ele usa a linguagem do Page Template, só que sua implementação é bem mais rápida e independente, no qual trás um conjunto de novos recursos e podemos usar em qualquer aplicação escrita em Python (2.5 e superior, incluindo 3.x e PyPy), algumas de suas características são:
 
  • Rápido - Os templates são compilados para byte-code.
  • Extensível - É fácil de estender uma linguagem ou criar sua própria.
  • Testado - Testes automatizados que protege contra regressões.
 
Para o Python 2.7 e superior não existem dependências de bibliotecas, já nas versões 2.5 e 2.6 a ordereddict e unittest2 são pacotes definidos como dependências, mas para se ter uma idéia de como Chameleon é independente, seu sistema de tradução é plugável e baseado em gettext. 
 
Não há um suporte embutido para o pacote zope.i18n. Mas se o pacote for instalado, ele será usado por padrão. O pacote translationstring[3] oferece algumas das mesmas classes de utilidades auxiliares, sem a interface do Zope.
 

Usando Chameleon no seu buildout.

Adicione as linhas em seu buildout:
eggs = ... five.pt>=2.1
zcml = ... five.pt
Estes testes foram efetuados nas versões 4.0.7 e 4.1rc3 do Plone, para um teste simples crie um Page template e coloque o seguinte conteúdo:
 
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en"
      xmlns:tal="http://xml.zope.org/namespaces/tal"
      xmlns:metal="http://xml.zope.org/namespaces/metal"
      xmlns:i18n="http://xml.zope.org/namespaces/i18n"
      lang="en"
      metal:use-macro="context/main_template/macros/master"
      i18n:domain="plone">
 <body>
  <metal:main fill-slot="main" tal:define="name string:world">
   Hello ${name}!
  </metal:main>
 </body>
</html>
 
Note que não precisei colocar tal:content para imprimir o texto da variável name, abaixo mais 2 exemplos:
 
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en"
      xmlns:tal="http://xml.zope.org/namespaces/tal"
      xmlns:metal="http://xml.zope.org/namespaces/metal"
      xmlns:i18n="http://xml.zope.org/namespaces/i18n"
      lang="en"
      metal:use-macro="context/main_template/macros/master"
      i18n:domain="plone">

 <body>
  <metal:main fill-slot="main">
   <div tal:replace="python:'here==context:'+str(here==context)" />
   <div tal:replace="python:'here==container:'+str(here==container)" />
   <div tal:replace="string:root:${root/getPhysicalPath}" />
   <div tal:replace="string:nothing:${nothing}" />
   <div tal:define="cgi python:modules['cgi']"
        tal:replace="python: dir(cgi)" />
  </metal:main>
 </body>
</html>
 
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en"
      xmlns:tal="http://xml.zope.org/namespaces/tal"
      xmlns:metal="http://xml.zope.org/namespaces/metal"
      xmlns:i18n="http://xml.zope.org/namespaces/i18n"
      lang="en"
      metal:use-macro="context/main_template/macros/master"
      i18n:domain="plone">

 <body>
  <metal:main fill-slot="main">
    <table border="1">
      <tr tal:repeat="row python:['apple', 'banana', 'pineapple']">
        <td tal:repeat="col python:['juice', 'muffin', 'pie']">
           ${row/capitalize} ${col}
        </td>
      </tr>
    </table>
  </metal:main>
 </body>
</html>
Para realizar outros testes e aproveitar bem o Chameleon, leia a documentação[1] e sugiro a leitura dos códigos dos produtos Chameleon e five.pt.
 

| Comentários
Document Actions
Spinner