¡Maestría en Plone!¶

Próximos entrenamientos¶

Mastering Plone 5 Development: 2. - 6 de Marzo de 2015, en Múnich

por Philip Bauer y Patrick Gerken

Entrenamientos previos¶

El entrenamiento “Maestría en Plone” se celebró públicamente en las siguientes ocasiones:

• Plone Conference 2014, Bristol

• Junio de 2014, Caracas

• Mayo de 2014, Múnich

• PythonBrasil/Plone Conference 2013, Brasilia
• PyCon DE 2012, Leipzig

• Plone Conference 2012, Arnhem

• PyCon De 2011, Lipsia

Entrenadores¶

Los siguientes entrenadores han dado entrenamiento basado en el material “Maestría en Plone”:

Leonardo Caballero

Leonardo J. Caballero G. de Maracaibo, Venezuela, es Director Técnico de Covantec R.L. y Conectivo C.A. Leonardo mantiene las traducciones en español de más de 49 complementos de Plone, así como documentación en español para Plone. Ha contribuido con varios complementos de Plone que forman parte de PloneGov. Actualmente sirve a la Junta de Plone como Embajador de Plone, Leonardo también ha servido como un miembro de la Junta Asesora y ha hablado o ayudado en la organización eventos de Plone y código abierto en toda América del Sur.

Philip Bauer

Philip Bauer es un desarrollador web de Munich que se enamoró de Plone en 2005 y desde entonces trabaja casi exclusivamente con Plone. Un historiador por educación que derivó hacia la creación de sitios web en los años 90 y fundó la empresa Starzel.de en 2000. Es miembro de la Fundación Plone, ama la enseñanza y se dedica al Open Source. Entre otros proyectos relacionados con Plone, comenzó a crear el manual de entrenamiento “Maestría en Plone” para que todos puedan convertirse en programadores Plone.

Patrick Gerken

Patrick Gerken trabaja con Python desde 2002. Comenzó a trabajar con aplicaciones Zope puras y ahora desarrolla principalmente con Plone, Pyramid y Javascript, además de hacer tareas de lo que se llama DevOps. Trabaja en Starzel.de.

Steve McMahon

Steve McMahon es un miembro de la comunidad Plone hace mucho tiempo, colaborador y entrenador. Él es el creador del producto PloneFormGen, el cual es un generador de formulario a traves de la Web para Plone y el mantenedor del instalador unificado. Steve también escribió varios capítulos del libro ‘Practical Plone’ y es un orador e instructor experimentado.

Steffen Lindner

Steffen Lindner comenzó a desarrollar Plone en 2006. Trabajó en pequeños sitios de Plone y también en enormes sitios de intranet. Como desarrollador de Open Source / Software Libre se unió al equipo de desarrolladores del núcleo de Plone en 2011 y trabaja en Starzel.de.

Usando la documentación para un entrenamiento¶

Siéntase libre para organizar un entrenamiento por ti mismo. Por favor, sea tan amable de aportar cualquier corrección de errores o mejoras que haya realizado en la documentación de su entrenamiento.

El entrenamiento se genera mediante la herramienta Sphinx y se basa en dos sabores:

por defecto

La versión detallada utilizada para la documentación en línea y para el instructor. Para construirlo con Sphinx, ejecute el el comando make html o use la versión en línea.

presentation

Una versión abreviada utilizada para el proyector durante un entrenamiento. Ese debe usar más lista de viñetas que texto detallado. Para construirlo con Sphinx, ejecute el el comando make presentation.

..  admonition:: Solution
    :class: toggle

Exercise 1
^^^^^^^^^^

Your mission, should you choose to accept it...

..  admonition:: Solution
    :class: toggle

    To save the world with only seconds to spare do the following:

    .. code-block:: python

        from plone import api

from plone import api

$ git clone https://github.com/plone/training.git
$ cd training
$ virtualenv-2.7 .
$ source bin/activate
$ pip install -r requirements.txt
$ make html

Contribuyendo¶

Todos están invitados a contribuir. Los cambios de errores menores pueden ser empujados directamente en el repositorio, los cambios más grandes deben haber como un pull requests y discutirlos previamente en tickets.

Licencia¶

El entrenamiento “Maestría en Plone” es licenciado bajo la Creative Commons Attribution 4.0 International License.

Asegúrese que usted ha completado el Acuerdo de contribuidor.

Si usted no ha completado un Acuerdo de colaborador, todavía puede aportar. Póngase en contacto con el equipo de documentación, por ejemplo a través de la lista de correo o directamente enviar un correo a plone-docs@lists.sourceforge.net. Básicamente, todo lo que necesitamos es la confirmación por escrito de que usted está de acuerdo que su contribución puede ser bajo licencia Creative Commons. También puede agregar en un comentario con su pull request “Yo, <nombre completo>, estoy acuerdo en que esta publicado bajo licencia Creative Commons 4.0 International BY”.

¿Quien eres tu?¶

Cuéntenos acerca de usted:

• Nombre, compañía, país...

• ¿Como ha sido tu experiencia en Plone?

• ¿Cual ha sido tu experiencia en desarrollo de aplicaciones?

• ¿Cuales son tus expectativas con este tutorial?

• ¿Cual es tu editor favorito?

• Si este entrenamiento incluirá los capítulos de desarrollo:

  • ¿Usted entiende lo que hace el siguiente código HTML?

    <div class="hiddenStructure"
         tal:repeat="num python:range(1, 10, 5)"
         tal:content="structure num"
         tal:omit-tag="">
      This is some weird sh*t!
    </div>
    

    La respuesta es:

    1 6
    

  • ¿Usted sabe lo que podría retornar el siguiente código Python?:

    [(i.Title, i.getURL()) for i in context.getFolderContents()]
    

¿Qué haremos?¶

Algunas tecnologías y herramientas que usaremos en el entrenamiento:

• Para el entrenamiento básico o principiante:

  • Virtualbox
  • Vagrant
  • Ubuntu linux

  • A través de la Web (TTW)

  • Buildout

  • Un poco de XML

  • Un poco de Python

• Para los capítulos avanzados:

  • Git
  • Github

  • Prueba Git (Una introducción agradable para git y github)

  • TAL
  • METAL
  • ZCML
  • Python
  • Dexterity
  • Viewlets
  • JQuery

¿Qué no haremos?¶

Nosotros no cubriremos los siguientes tópicos:

• Archetypes
• Portlets
• z3c.forms
• Theming
• Testing

• i18n y locales

• Desarrollo, hosting y cacheo de contenidos

• Grok

• Referencias / Relaciones

Otros tópicos están ligeramente cubiertos:

• Arquitectura de componentes Zope

• GenericSetup
• ZODB
• Security
• Permissions

• Desempeño y Cacheo de contenidos

¿Qué esperar?¶

Al final de los dos primeros días de entrenamiento, conocerá muchas de las herramientas necesarias para la instalación, integración y configuración de Plone. Usted será capaz de instalar los paquetes complementarios y conocerá algo sobre las tecnologías que subyacen a Plone y sus historias. Usted estará listo para extender sus habilidades a través de la lectura de libros como Practical Plone y la documentación de Plone.

Al final de los segundo dos días, usted no será un completo programador profesional de Plone, pero conocerá algunas de las características más potentes de Plone y debe ser capaz de construir un sitio web más Plone y debería ser capaz de construir un sitio web más complejo con temas y paquetes personalizados. Usted debe también ser capaz de encontrar dónde buscar instrucciones para hacer tareas que no cubrimos en este entrenamiento. Usted conocerá la mayoría la mayoría de las principales tecnologías de núcleo involucradas en la programación de Plone.

Si quieres convertirte en un desarrollador profesional de Plone o un integrador altamente sofisticado de Plone, usted definitivamente debe leer el libro de Martins y después volver a leerlo de nuevo mientras actualmente este haciendo un complejo proyecto.

Más importante es ¡usted debe practicar sus habilidades y no detenerte aquí pero debe seguir delante! una vía recomendada para esto es debe realizar los pasos del tutorial todo-app.

Documentación¶

Sigue el entrenamiento en http://plone-training.readthedocs.io/en/legacy/

Lecturas recomendadas¶

• Martin Aspeli: Professional Plone4 Development
• Practical Plone

• Referencia de Zope Page Templates

Instalando Plone¶

Plone 4.3.x requiere Python 2.7 y varias otras herramientas del sistema que no todos los sistemas operativos proporciona por defecto. Por lo tanto la instalación de Plone es diferente en cada sistema. Aquí hay algunas maneras que Python se puede utilizar:

• utilizar un Python que viene instalado previamente en su sistema operativo (en la mayoría de GNU/Linux y Mac OS tienen uno incorporado)

• use el python buildout

• instale los paquetes construido en su sabor de Linux

• homebrew (Mac OS X)
• PyWin32 (Windows)

MacOS 10.8 y Ubuntu 14.04 tendrán instalado por defecto un Python 2.7. Los usuarios de estos sistemas son los afortunados. Para ejecutar una versión de Plone anterior a la 4.0 usted necesita Python 2.4. No siempre es fácil de instalar.

La mayoría de los desarrolladores suelen utilizar su sistema primario para desarrollar Plone. Para configuraciones complejas que a menudo usan máquinas virtuales en Linux.

• OS X: Usa el buildout de python para compilar todas las versiones necesarias de Python y la herramienta homebrew para instalar algunas herramientas de Linux.

• Linux: Dependiendo de su sabor de Linux que usted podría tener que construir Python por ti mismo e instalar algunas herramientas.

• Windows: Alan Runyan (uno de los fundadores Plone) lo utiliza. Un inconveniente: Plone parece funcionar mucho más lento en Windows.

Plone ofrece múltiples opciones para que se instale:

1. Instaladores de un clic para Mac y de Windows

2. Unified installers (todos los Unix, incluyendo MacOS)

3. Un kit de instalación vagrant/virtualbox (todas las plataformas)

4. Utilice su propio Buildout

Puede descargar todo esto en https://old.plone.org/products/plone/releases/4.3.4

Para el entrenamiento vamos a utilizar la opción 3 y 4 para instalar y ejecutar Plone. Vamos a crear nuestro propio Buildout y lo extenderemos como deseamos. Pero lo haremos en una máquina vagrant. Para sus primeros experimentos propios se recomienda la opción 2 o 3 (si usted tiene una portátil con Windows o al encontrar problemas en su proceso de instalación). Más adelante usted debería ser capaz de utilizar su propio Buildout (lo cubriremos más adelante).

Alojando Plone¶

Si usted desea alojando un sitio real de Plone por si mismo entonces ejecutarlo desde su computadora portátil no es una opción viable.

Puede alojar Plone...

• con uno de los muchos proveedores de alojamiento

• en un servidor privado virtual

• en los servidores dedicados

• en heroku puede ejecutar Plone para uso gratis usando el Heroku buildpack para Plone

• en la nube (por ejemplo, el uso de Amazon EC2 o Codio.com)

Despliegue en ambientes de producción¶

La manera en que estamos montando un sitio Plone durante esta clase puede ser adecuado para un sitio pequeño - o incluso uno muy grande que no está muy ocupado - pero es muy probable que desee hacer mucho más si estás usando Plone para ninguna demanda.

• El uso de un servidor web de producción como Apache o Nginx para la reescritura de URL, SSL y combinación de múltiples, las mejores soluciones de su clase todo en un solo sitio web.

• El almacenamiento en caché de proxy inverso con una herramienta como Varnish para mejorar el rendimiento del sitio.

• El balanceo de carga para hacer el mejor uso de núcleo múltiple de CPU e incluso múltiples servidores.

• Optimización cabeceras de caché y esquemas de caché interna de Plone con el paquete plone.app.caching.

Y, usted necesita aprender estrategias eficientes para la copia de seguridad y rotación del archivo de los registros.

Todos estos temas son introducidos en la Guía para el despliegue e instalación de Plone en producción.

Instalando Plone sin Vagrant¶

Si usted esta experimentado con ejecutar Plone en su propio ordenador portátil, te animamos a hacerlo, ya que tendrá ciertos beneficios:

• Usted puede usar el editor, que usted usa.

• Puede utilizar la receta Buildout llamada omelette tener todo el código de Plone a su alcance.

• Usted no tiene que cambiar entre diferentes del sistema operativo durante el entrenamiento.

Si se siente cómodo, por favor, trabaje en su propia máquina con su propio Python. Pero por favor asegúrese de que usted tiene un sistema que funcione, ¡ya que no queremos que pierda un tiempo valioso!

sudo apt-get install python-setuptools python-virtualenv python-dev build-essential libssl-dev libxml2-dev libxslt1-dev libbz2-dev libjpeg62-dev
sudo apt-get install libreadline-dev wv poppler-utils
sudo apt-get install git

Instalar Plone para el entrenamiento debe ser de esta forma si usted utiliza su propio sistema operativo (Linux o Mac):

$ mkdir training
$ cd training
$ git clone https://github.com/collective/training_buildout.git buildout
$ cd buildout
$ git checkout plone4
$ virtualenv-2.7 py27

Ahora puede ejecutar el buildout por primera vez:

$ ./py27/bin/python bootstrap.py
$ ./bin/buildout

Esto tomará algún tiempo y producir una gran cantidad de mensaje en consola de comando debido a que descarga y configura Plone. Una vez hecho esto usted puede comenzar a instancia con el siguiente comando:

$ ./bin/instance fg

La salida por la consola de comando es similar a:

2015-09-24 15:51:02 INFO ZServer HTTP server started at Thu Sep 24 15:51:02 2015
        Hostname: 0.0.0.0
        Port: 8080
2015-09-24 15:51:05 WARNING PrintingMailHost Hold on to your hats folks, I'm a-patchin'
2015-09-24 15:51:05 WARNING PrintingMailHost

******************************************************************************

Monkey patching MailHosts to print e-mails to the terminal.

This is instead of sending them.

NO MAIL WILL BE SENT FROM ZOPE AT ALL!

Turn off debug mode or remove Products.PrintingMailHost from the eggs
or remove ENABLE_PRINTING_MAILHOST from the environment variables to
return to normal e-mail sending.

See https://pypi.python.org/pypi/Products.PrintingMailHost

******************************************************************************

2015-09-24 15:51:05 INFO ZODB.blob (54391) Blob directory `.../buildout/var/blobstorage` is unused and has no layout marker set. Selected `bushy` layout.
2015-09-24 15:51:05 INFO ZODB.blob (54391) Blob temporary directory '.../buildout/var/blobstorage/tmp' does not exist. Created new directory.
2015-09-24 15:51:09 INFO Plone OpenID system packages not installed, OpenID support not available
2015-09-24 15:51:11 INFO PloneFormGen Patching plone.app.portlets ColumnPortletManagerRenderer to not catch Retry exceptions
2015-09-24 15:51:11 INFO Zope Ready to handle requests

La salida por consola debe decir INFO Zope Ready to handle requests lo cual significa su instalación esta en correctamente iniciada.

Si abre su navegador Web local en la dirección URL http://localhost:8080 se ve que Plone está ejecutando. Ahora cree un nuevo sitio Plone haciendo clic en “Crear un nuevo sitio Plone”. El nombre de usuario y la contraseña son “admin” (Nota: ¡Nunca haga esto en un sitio real!).

Ahora tiene un sitio Plone en funcionamiento y puede continuar con el siguiente capítulo. Puede detener la instancia en ejecución en cualquier momento utilizando la combinación de teclas ctrl + c.

Instalando Plone sin vagrant¶

Para no perder demasiado tiempo con la instalación y la depuración de las diferencias entre los sistemas, utilizamos una máquina virtual (Ubuntu 14.04) para ejecutar Plone durante el entrenamiento. Contamos con Vagrant y VirtualBox para dar el mismo medio de ambiente de desarrollo para todos.

Vagrant es una herramienta para la creación de entornos de desarrollo completos. Lo usamos en conjunto con Oracle’s VirtualBox para crear y administrar un entorno virtual.

$ mkdir training
$ cd training

$ vagrant plugin install vagrant-vbguest

$ wget https://raw.githubusercontent.com/plone/training/master/_static/plone_training_config.zip
$ unzip plone_training_config.zip

$ vagrant up

Skipping because of failed dependencies

$ vagrant provision

ssh_exchange_identification: read: Connection reset by peer

$ vagrant ssh

vagrant@training:~$ cd /vagrant/buildout
vagrant@training:/vagrant/buildout$ ./bin/instance fg
2015-09-24 15:51:02 INFO ZServer HTTP server started at Thu Sep 24 15:51:02 2015
        Hostname: 0.0.0.0
        Port: 8080
2015-09-24 15:51:05 WARNING PrintingMailHost Hold on to your hats folks, I'm a-patchin'
2015-09-24 15:51:05 WARNING PrintingMailHost

******************************************************************************

Monkey patching MailHosts to print e-mails to the terminal.

This is instead of sending them.

NO MAIL WILL BE SENT FROM ZOPE AT ALL!

Turn off debug mode or remove Products.PrintingMailHost from the eggs
or remove ENABLE_PRINTING_MAILHOST from the environment variables to
return to normal e-mail sending.

See https://pypi.python.org/pypi/Products.PrintingMailHost

******************************************************************************

2015-09-24 15:51:05 INFO ZODB.blob (54391) Blob directory `.../buildout/var/blobstorage` is unused and has no layout marker set. Selected `bushy` layout.
2015-09-24 15:51:05 INFO ZODB.blob (54391) Blob temporary directory '.../buildout/var/blobstorage/tmp' does not exist. Created new directory.
2015-09-24 15:51:09 INFO Plone OpenID system packages not installed, OpenID support not available
2015-09-24 15:51:11 INFO PloneFormGen Patching plone.app.portlets ColumnPortletManagerRenderer to not catch Retry exceptions
2015-09-24 15:51:11 INFO Zope Ready to handle requests

ValueError: unknown locale: UTF-8

export LC_ALL=en_US.UTF-8
export LANG=en_US.UTF-8

Zope2¶

• Zope es un framework de aplicación Web, el cual Plone corre encima de él.

• Ese sirve aplicaciones que comunica con usuarios vía HTTP.

Antes de Zope, generalmente era un servidor Apache el que debía llamar a un script y dar la petición como una entrada. La secuencia de comando sería entonces simplemente imprimir HTML en la salida estándar. El servidor Apache retornó eso al usuario. La apertura de las conexiones de base de datos, verificando las restricciones de permisos, la generación de HTML válido, la configuración de almacenamiento en caché, la interpretación de los datos del formulario y todo lo que tiene que hacer por su cuenta. Cuando la segunda petición llega, usted tiene que hacer todo de nuevo.

Jim Fulton pensaba que esto era un poco tedioso. Así que escribió el código para manejar las peticiones. Él creía que el contenido del sitio es orientado a objetos y que la URL de alguna manera debe apuntar directamente a la jerarquía de objetos, por lo que escribió una base de datos orientada a objetos, llamada ZODB.

El ZODB es una base de datos ACID totalmente compatible con integridad transaccional automático. Se asigna automáticamente el recorrido en la jerarquía de objetos a rutas URL, así que no hay necesidad de objetos “cableados” o nodos de bases de datos a las direcciones URL. Esto da Plone sus fáciles de generar direcciones URL amigables a las técnicas SEO.

Transversal a través de la base de datos de objeto tiene la seguridad comprobada en todos los puntos a través de listas de control de acceso muy detallado.

Una pieza que falta el cual es importante y a la ves complicada es la: Acquisition.

La adquisición, es una especie de magia. Imagine un sistema de programación en el que no accede al sistema de archivos y donde usted no necesita importar código. Usted trabaja con objetos. Un objeto puede ser una carpeta que contiene más objetos, una página HTML, datos, u otro script. Para acceder a un objeto, lo que necesita saber dónde está el objeto. Los objetos se encuentran por las rutas que parecen direcciones URL, pero sin el nombre de dominio. Ahora la Adquisición permite escribir una ruta incompleta. Una ruta incompleta es una ruta relativa, ese no establece explícitamente cual es la ruta que inicia desde la raíz, ese se inicia en relación con donde esta el contenido del objeto – eso es el contexto. Si Zope no puede resolver la ruta de un objeto relativo a su código, ese trata la misma ruta en la carpeta que lo contiene. Y a continuación, la carpeta que contiene la carpeta.

Esto puede sonar extraño, ¿qué gano yo con esto?

Usted puede tener diferentes datos o códigos en función de su contexto. Imagínese que usted desea tener imágenes de cabecera diferentes para cada sección de la página, a veces, incluso diferentes para una sub-sección específica de su sitio. Así se define una ruta a la header_image y pone una imagen de cabecera en la raíz de su sitio. Si quieres una carpeta a una imagen de cabecera diferente, se pone la imagen de cabecera en esta carpeta. Por favor, tómese un minuto para dejar que esto se asimile mejor y piense, lo que esto le permite hacer.

• formularios de contacto con diferentes direcciones de correo electrónico por sección.

• diferentes estilos CSS para diferentes partes de su sitio.

• Un sitio, varios clientes, todo se ve diferente para cada cliente.

Al igual que con toda la magia de programación, adquisición exige un precio. El código de Zope debe ser escrito cuidadosamente si es necesario para evitar heredar efectos secundarios a través de la adquisición. La comunidad Zope expresa esto con la máxima Python (Monty): Cuidado con el Spammish de la Adquisición.

Básicamente esto es Zope.

Content Management Framework¶

• CMF (Content Management Framework) es un complemento para Zope para construir sistemas de gestión de contenido (como Plone).

Después de muchos sitios web creados con éxito basado en Zope, una serie de requisitos que se repiten surgieron, y algunos desarrolladores Zope comenzaron a escribir CMF, el Content Management Framework.

La CMF ofrece muchos servicios que le ayudan a escribir un CMS basado en Zope. La mayoría de los objetos que ve en la ZMI son parte de la CMF de alguna manera.

Los desarrolladores detrás CMF no ven CMF como un producto listo para usar CMS. Ellos crearon un sitio CMS que era utilizable fuera de la caja, pero dejó deliberadamente feo, porque usted tiene que personalizar todas formas.

Todavía estamos en los tiempo de la prehistoria aquí. En ese entonces no existían los paquetes eggs (paquetes Python), Zope no consistía en mas de 100 componentes de software independientes, pero era una gran conjunto.

Muchas partes de Plone se derivan de la CMF, pero es una herencia mixta. El CMF es un proyecto independiente de software, y se ha movido a menudo más lentamente que Plone. Plone está eliminando gradualmente la dependencia de la mayoría de las partes de la CMF.

Zope Toolkit / Zope3¶

• Zope 3 fue originalmente creada como una profunda re-escritura de Zope.

• Plone usa partes provistas por el Zope Toolkit (ZTK).

Por desgracia, nadie empezó a usar Zope 3, nadie migró a Zope 3, porque nadie sabía cómo hacerlo.

Pero había muchas cosas útiles en Zope 3 que las personas querían usar en Zope 2, por lo que la comunidad Zope adaptado algunas partes para que pudieran utilizarlos en Zope 2. A veces, una clase wrapper de algún tipo era necesario, estos por lo general son ofrecidos por paquetes de los cinco espacios de nombres.

Para hacer la historia completa, ya que la gente se quedó en Zope 2, la comunidad Zope renombrado Zope 3 a Bluebream, por lo que la gente no piensa que Zope 3 era el futuro. No era nada más.

Zope Component Architecture (ZCA)¶

La Zope Component Architecture, que fue desarrollado como parte de Zope 3, es un sistema que permite componente de tipo pluggability y despacho complejo basado en objetos que implementan una interfaz (una descripción de una funcionalidad). Pyramid, y el servidor de aplicaciones Web Python independiente, utiliza la ZCA “bajo la capucha” para ejecutar despacho de vistas y otras tareas de configuración de aplicación.

Pyramid¶

• Pyramid es un framework de desarrollo de aplicaciones Web en Python, el cual a veces es visto como el sucesor natural de Zope.

• Eso hace menos que Zope, es muy configurable y usa la Zope Component Architecture.

Se puede utilizar con una base de datos relacional en lugar de ZODB si quieres, o usar las dos bases de datos o ninguno de ellos.

Aparte del hecho de que Pyramid no se vio obligado a soportar todas las funcionalidades legado, que puede hacer las cosas más complicadas, el desarrollador original tenía una postura muy diferente sobre cómo el software debe ser desarrollado. Mientras tanto Zope y Pyramid tienen una buena de la pruebas de software, Pyramid tiene una buena documentación; algo que estaba muy descuidado en Zope, y en ocasiones en Plone también.

Ya sea que si ¿la arquitectura de componentes es mejor en Pyramid o no?, no nos atrevemos a decir, pero nos gusta más. Pero tal vez es sólo porque fue documentada.

Detalle¶

La conferencia de Plone toma lugar cada año y todos los desarrolladores al menos intentan ir.

Requerimientos¶

• Como un visitante, yo quiero encontrar información actualizada en la conferencia.

• Como visitante, yo quiero registrarme para la conferencia.

• Como visitante, yo quiero ver las charlas y ordenarlas por mis preferencias.

• Como un ponente, yo quiero ser capaz de enviar charlas.

• Como un ponente, yo quiero ver y editar mis charlas enviadas.

• Como miembro del jurado, yo quiero votar en las charlas.

• Como miembro del jurado, yo quiero decidir, cuales charlas aceptar, y cuales no.

• Como organizador, yo quiero ver una lista de todas las charlas propuestas.

• Como organizador, yo quiero tener un resumen acerca de cuantas personas están registradas.

Tenga en cuenta que todos nuestros requisitos deben conectar los roles con sus capacidades. Esto es importante porque vamos a querer limitar las capacidades de aquellos a los que asignamos roles particulares.

Iniciando y Deteniendo Plone¶

Tenemos el control de Plone con un pequeño script llamado “instance” a continuación un ejemplo de su uso:

$ ./bin/instance fg

Esto comando anterior, arranca Plone en el modo foreground para que podamos ver lo que está haciendo mediante el control de los mensajes de consola. Este es un método de desarrollo importante. Tenga en cuenta que cuando Plone se inicia en el modo foreground, es también automáticamente en el modo de desarrollo. Modo de desarrollo da una mejor respuesta, pero es mucho más lento, particularmente en Windows.

Usted puede detener el proceso presionando ctrl + c.

El script instance ofrece las siguientes opciones:

$ ./bin/instance fg
$ ./bin/instance start
$ ./bin/instance stop
$ ./bin/instance -O Plone debug
$ ./bin/instance -O Plone run myscript.py
4 ./bin/instance adduser

Dependiendo del equipo, puede tardar hasta un minuto hasta que Zope le dirá que ya está listo para servir peticiones. En un portátil decente debe estar en ejecución en menos de 15 segundos.

Una instalación estándar escucha en el puerto 8080, así que vamos a echar un vistazo a nuestro sitio Zope visitando http://localhost:8080

¡Como puede ver, no hay Plone todavía!

Tenemos un Zope corriendo con una base de datos pero no el sitio Plone. Pero, afortunadamente, hay un botón para crear un sitio Plone. Haga clic en el botón Crear un nuevo sitio Plone (inicio de sesión: admin:admin). Esto abre un formulario para crear un sitio Plone. Utilice Plone como el identificador del sitio.

Ahora tiene la opción de seleccionar algunos complementos antes de crear el sitio. Dado que vamos a utilizar Dexterity desde el principio seleccionamos el complemento Dexterity-based Plone Default Types. De esta manera, incluso el contenido inicial en nuestra página será construido con dexterity por el complemento plone.app.contenttypes que será el predeterminado en Plone 5.

Usted será automáticamente redirigido al sitio nuevo.

Usuarios¶

Vamos a crear nuestros primeros usuarios en Plone. Hasta ahora hemos utilizado el usuario admin (admin:admin) configurado en el buildout. Este usuario es a menudo se le llama “el administrador de Zope” y con este usuario no se gestiona en Plone mas sólo es usado para la gestión de Zope. Por lo tanto el usuario le faltan algunas características como el correo electrónico y el nombre completo y no va a ser capaz de utilizar algunas de las características de Plone. Sin embargo, el usuario tiene todos los permisos posibles. Al igual que con el usuario root de un servidor, que es una mala práctica hacer uso innecesario del raíz de Zope. Se usa para crear sitios Plone y sus usuarios iniciales, pero no mucho más.

También puede agregar los usuarios Zope a través del terminal ejecutando el siguiente comando:

$ ./bin/instance adduser <someusername> <supersecretpassword>

De esa manera usted puede tener acceso a las bases de datos que recibe de los clientes donde no tienes usuario Plone.

Para agregar un nuevo usuario haga clic en el nombre admin ubicado en la esquina superior derecha y luego en Configuración del sitio. Este es el panel de control de Plone. También puede acceder a él por la dirección URL a http://localhost:8080/Plone/@@overview-controlpanel

Haga clic en Usuarios y Grupos, entonces añada un usuario. Si ha configurado un servidor de correo, Plone puede enviarle un correo electrónico con un enlace a un formulario donde puede elegir una contraseña. Establezca una contraseña aquí porque no ha configurado aun un servidor de correo.

Estableciendo a este usuario con su nombre un Administrador del sitio.

A continuación, cree otro usuario llamado testuser. Hágalo un usuario normal. Puede utilizar este usuario para ver cómo luce Plone y se comporta a los usuarios que no tienen permiso de administrador.

Ahora vamos a ver el sitio en tres (03) navegadores diferentes, con tres roles diferentes:

• como anónimo.

• como editor.

• como administrador.

Configurar un servidor de correo¶

Tenemos que configurar un servidor de correo desde temprano vamos a crear algunas acciones de contenido que envían mensajes de correo electrónico cuando el nuevo contenido se pone en nuestro sitio.

• Servidor: mail.gocept.net

• Nombre de usuario: training@neww.de

• Contraseña: training2014

Por favor, no abuses de esto. Vamos a deshabilitar esta cuenta después de la capacitación.

Tutorial de la interfaz de usuario¶

Vamos a ver lo que está ahí...

• portal-top:

  • personaltools: nombre, salir etc.

  • logo: con un enlace a la página principal

  • buscar

  • navegación global

• portal-columns: un contenedor que contienen:

  • portal-column-one: portlets (cajas configurables como herramientas para navegación, noticias etc.)

  • portal-column-content: el contenido y el editor

  • barra de edición: opciones de edición del contenido

  • portal-column-two: portlets
• portal-footer: viewlets

Estos son también los clases CSS de los respectivos de DIV del HTML. Si usted quiere hacer la temas visuales usted los necesita.

En la barra de edición, encontramos opciones que afectan el contexto actual...

• Contenidos

• Visualizar

• Editar

• Reglas

• Compartir

• Mostrar

• Agregar nuevo...

• Estado

Algunas opciones de la barra de edición sólo muestran cuando proceda; por ejemplo, la carpeta Contenidos y Agregar nuevo... sólo se muestran para carpetas. Las opción Reglas esta actualmente invisible porque no tenemos reglas de contenido disponible.

Tipos de Contenidos¶

Editar una página:

• Edite el documento front-page

• Titulo Plone Conference 2014, Bristol

• Descripción Tutorial

• Texto ...

Crear un estructura del sitio:

• Agregar carpeta “El Evento” y que contenga...

  • Carpeta “Charlas”

  • Carpeta “Entrenamientos”

  • Carpeta “Sprint”

• En la ruta /news: Agregar una Noticia “¡Sitio Web de la Conferencia esta en linea!” con una imagen

• En la ruta /news: Agregar una Noticia “¡Enviar sus charlas!”

• En la ruta /news: Agregar un Evento “Fecha limite para enviar charlas” Fecha 10.10.2014

• Agregar carpeta llamada “Registro”

• Eliminar la carpeta llamada “Members” (Usuarios)

• Agregar carpeta llamada “Intranet”

Los tipos de contenidos por defecto:

• Documento

• Noticia

• Evento

• Archivo

• Imagen

• Enlace

• Carpeta

• Colección

Carpetas¶

• Ir a ‘el-evento’

• explicar title/id/url

• explicar /folder_contents

• cambiar orden

• acciones masivas

• menú desplegable “Mostrar”

• default_pages

• Agregar una página a ‘el-evento’: “El Evento” y hacerlo su página por defecto

• El futuro: wildcard.foldercontents

Colecciones¶

• agregar nueva colección: “todos los contenidos que este pendiente por revisión”.

• explicar la colección por defecto de eventos en http://localhost:8080/Plone/events/aggregator/edit

• explicar Tópicos

• mencionar portlets de colección

• multiples rutas a consultar

• restricciones, ej. /Plone/folder::1

Reglas de Contenido¶

• ¡Crear una nueva regla “una nueva charla está presente”!

• Nuevo contenido en Carpeta “Charlas” -> Enviar correo a revisores.

Histórico¶

Mostrar y explicar; el control de versiones y su relación con los tipos.

Administrar usuarios y grupos¶

• agregar / editar / eliminar Usuarios

• roles

• grupos

  • Agregar grupo “Editores” y agregar el usuario ‘editor’ a ese.

  • Agregar grupo: orga

  • agregar grupo: jury y agregue usuario ‘jurymember’ a ese.

Flujos de trabajos¶

Echa un vistazo al menú desplegable Estado en la barra de edición en la página principal. Ahora, vaya a una de las carpetas que acaba de añadir. La página principal tiene el estado Publicado y el nuevo contenido es Privado.

Echemos un vistazo a las transiciones de estado disponibles para cada tipo. Podemos hacer un artículo publicado en privado y un artículo privado se pueda publicar. También podemos enviar un artículo para su revisión.

Cada uno de esos estados conecta los roles a permisos.

• En el estado Publicado, el contenido está disponible para los visitantes anónimos;

• En el estado Privado, el contenido es sólo visible para el autor (propietario) y los usuarios que tienen el rol local Puede ver para el contenido.

Un estado de flujo de trabajo es una asociación entre un rol y uno o más permisos. Pasar de un estado a otro es una transición. Las transiciones (como Enviar a revisión) pueden tener acciones - como la ejecución de una regla de contenido o un script - asociado a ellos.

Un conjunto completo de estados de flujo de trabajo y las transiciones constituyen un flujo de trabajo. Plone le permite seleccionar entre varios flujos de trabajo preconfigurados que son apropiados para los diferentes tipos de sitios. Tipos de contenido individuales pueden tener su propio flujo de trabajo. O, lo que es particularmente interesante, sin flujo de trabajo. En ese caso, que se aplica inicialmente a presentar y la subida de imágenes, el objeto de contenido hereda el flujo de trabajo de su contenedor.

Lea más en: http://docs.plone.org/4/en/working-with-content/collaboration-and-workflow/index.html

Copia de trabajo¶

El contenido publicado, incluso en un entorno de Intranet, puede plantear un problema especial para la edición. Puede ser necesario revisar antes de que los cambios se hacen disponible. De hecho, el autor original podría incluso no tener permiso para cambiar el documento sin revisión. O bien, puede que tenga que hacer una edición parcial. En cualquiera de los casos, puede ser deseable para que los cambios sean visibles inmediatamente.

El producto Soporte de Copia de Trabajo resuelve este problema mediante la adición una acción para Retirar revisión o Guardar nueva revisión de cambios para el contenido - disponible en el menú de acciones. Un elemento de contenido puede guardar nueva revisión, trabajado en una copia del elemento y después se guardar nueva revisión de nuevo. O Cancelar retirada de revisión si los cambios no eran aceptables. Hasta no guardar una nueva revisión de los cambios, el contenido anterior sera visible.

Mientras este complemento viene incorporado en Plone, el soporte de copia de trabajo no es una necesidad común. Así que, si usted lo necesita, usted necesita para activarlo a través de la página de configuración de Complementos. A menos que se active este complemento, las opciones de Retirar revisión / Guardar nueva revisión no son visibles.

Flujos de trabajo Placeful¶

Usted puede necesitar tener diferentes flujos de trabajo en diferentes partes de un sitio. Por ejemplo, creamos una carpeta intranet. Dado que este es para uso de nuestros organizadores de la conferencia - pero no para el público - el sencillo flujo de trabajo que deseamos utilizar para que el resto del sitio no será deseable aquí.

El paquete Soporte de Copia de Trabajo te da la posibilidad de configurar diferentes flujos de trabajo en las diferentes secciones de un sitio. Normalmente, se utiliza para configurar un flujo de trabajo especial en una carpeta que regirá todo bajo esa carpeta. Ya que tiene efecto en un “lugar” en un sitio, este mecanismo es a menudo llamado “flujo de trabajo Placeful”.

Tanto como el Soporte de Copia de Trabajo, como el Soporte de Política de Flujo de trabajo Placeful viene incorporados en Plone, pero tiene que ser activadas a través de la página de configuración de Complementos. Una vez se ha añadido, una opción Política... aparecerá en el menú de Estado para permitir el establecimiento de una política de flujo de trabajo Placeful.

El panel de control¶

Las partes más importantes de Plone pueden ser configuradas en el panel de control.

• Haga clic en el nombre de usuario, en la esquina superior derecha de su pantalla

• Haga clic en “Configuración del Sitio”

Nosotros explicaremos cada página y mencionaremos algunas cosas que puedes hacer aquí.

1. Complementos (después)

2. Calendario

3. Registro de Configuración

4. Reglas de contenido (Ya lo sabemos)

5. Discusión

6. Edición

7. Errores

8. Filtrado HTML

9. Manejo de Imágenes

10. Idioma

11. Correo

12. Mantenimiento

13. Etiquetado

14. Navegación

15. Buscar

16. Seguridad

17. Sitio

18. Sindicación

19. Temas

20. Editor visual TinyMCE

21. Tipos

22. Usuarios y Grupos

23. Interfaz de administración de Zope (Aquí hay dragones, ¡Precaución!)

Por debajo en los enlaces encontraras información de las versiones en tu Plone, Zope y Python y un indicador de cualquier cosa que usted está funcionando en el modo de producción o desarrollo.

Portlets¶

• @@manage-portlets

• Interfaz de usuarios para editores inteligentes de contenido

• Varios tipos

• La configuración de Portlets es heredada

• Son administrados

• Ordenando / ponderación

• En el futuro: será reemplazado por tiles

Ejemplo:

• Valla a la dirección URL http://localhost:8080/Plone/@@manage-portlets

• Agregue un portlet “Patrocinadores” en el lado derecho.

• Remueve los nuevos portlets y agrega uno nuevo en el lado izquierdo.

• Ve a la carpeta de training: http://localhost:8080/Plone/training y has clic Administrar portlets

• Agregue un portlet estático. “Entrenamiento destacada: Conviértete en un Rockstar de Plone en la ¡Maestría en Plone!”

Viewlets¶

• @@manage-viewlets

• Viewlet no poseen Interfaz de usuario

• No recomendado para editores de contenido

• No es localmente agregable, no posee herencia configurable.

• Usado globalmente (depende del código)

• ¿Sera reemplazado por los tiles?

• El código es mucho más simple (crearemos uno mañana)

• En tiempo real en la herramienta administradores de viewlet, pueden ser anidadas (agregando un viewlet que contenga un administrador de viewlet)

• El reordenamiento a través de la Web solo puede ser dentro de su mismo administrador de viewlet

• el código decide cuando, dónde y que muestra

Portlets guarda datos, los Viewlets usualmente no lo hacen, los Viewlets a veces son usados para elementos de Interfaz de usuario.

Ejemplo:

• Valla a la dirección URL http://localhost:8080/Plone/@@manage-viewlets

• Ocultar Colofón (Ocultar pie de página)

ZMI¶

Valla a dirección URL http://localhost:8080/Plone/manage

Zope es la base de Plone. Aquí puedes acceder igualmente al funcionamiento interno de Zope y Plone.

Nosotros sólo cubrimos las tres partes de la personalización en el ZMI ahora. Más tarde, cuando agreguemos nuestro propio código fuente vamos a volver a la ZMI y lo buscaremos.

En algún momento tendrá que aprender, sobre todos los objetos que hay allí. Pero no hoy.

#visual-portal-wrapper {
    margin: 0 auto;
    position: relative;
    width: 1024px;
}

@media only screen and (max-width: 980px) {
   #visual-portal-wrapper {
       position: relative;
       width: auto;
   }
}

@media only screen and (max-width: 768px) {
   #portal-columns > div {
       width: 97.75%;
       margin-left: -98.875%;
       clear: both;
   }

   .searchButton,
   .searchSection {
       display: none;
   }
}

Resumen¶

Puedes configurar y personalizar muchas cosas en Plone a través de la Web. Las opciones más importantes son accesibles en el panel de control de Plone pero aun más están escondidas en la ZMI. La cantidad y presentación de la información es abrumadora, pero usted conseguirá la caída de ella a través de mucha práctica.

Tecnologías de extensión¶

¿Cómo extender Plone?

Esto depende de que tipo de extensión usted quiere crear.

• Puede crear extensiones con nuevos tipos de objetos para añadir a su sitio Plone. Por lo general, estos son los tipos de contenido.

• Puede crear una extensión que cambia o se extiende la funcionalidad. Por ejemplo, para cambiar la forma en que Plone muestra los resultados de búsqueda, o hacer a las imágenes que sean analizadas en búsqueda del algún texto que incluya en la misma mediante la adición de un convertidor de JPG a texto.

¿Cuáles son los componentes?, ¿Que es el ZCML?¶

¿Cuál es la manera más simple absoluta para ampliar la funcionalidad?

Monkey Patching.

Eso significa que usted puedo cambiar el código en otros archivos mientras mi archivo se carga.

Si usted quiere tener un registro extensible de iconos para los distintos tipos de contenido, usted podría crear un diccionario global, y que implementa en un nuevo icono para un tipo de contenido diferente, podría añadir una entrada en mi diccionario durante el tiempo de importación.

Este enfoque, como subclases mediante herencia múltiple, no escala. Múltiples extensiones pueden sobrescribir los demás, usted debería explicar a la gente que tiene que reordenar las importaciones, y luego, de repente, se le importar característica A antes que B, B antes de C y C antes de A, o de lo contrario la aplicación no funcionará.

La arquitectura de componentes de Zope con su configuración ZCML es la respuesta para sus problemas.

Con ZCML declarar las utilidades, los adaptadores y las browser views en ZCML, el cual es un dialecto de XML que significa Zope Component Markup Language.

Los componentes se diferencian entre sí por las interfaces (definiciones formales de funcionalidad) que requieren o proporcionan.

Durante el inicio, Zope lee todas estas declaraciones ZCML, valida que no hay dos declaraciones que tratan de registrar los mismos componentes y sólo entonces registra todo. Todos los componentes están registrados por interfaces necesarias y proporcionadas. Los componentes con las mismas interfaces también pueden opcionalmente ser nombrados.

Esta es una buena cosa. ZCML es por cierto sólo una manera de declarar su configuración.

Grok proporciona otra manera, donde un poco de magia Python permite usar decoradores para registrar clases Python y funciones como componentes. Usted puede usar tanto ZCML y Grok juntos si usted lo desea.

A algunos les gusta Grok porque le permite hacer casi todo en sus archivos fuentes Python. No requiere cableado adicional XML. Si usted es alérgico a XML , Grok es su boleto al nirvana Python.

Tenga en cuenta que no todo el mundo le encanta Grok. Algunas partes de la comunidad Plone piensan que sólo puede haber un lenguaje de configuración, otros están en contra de añadir la gran dependencia relativa de Grok para Plone. Un problema real es el hecho de que no se puede personalizar componentes declarados con Grok con técnicas jbot (del que hablaremos más adelante). Grok no está permitido en el núcleo de Plone por estas razones.

La elección de Grok o no Grok es suya. En cualquier caso, si usted comienza a escribir una extensión que es reutilizable, convertir sus declaraciones Grok a ZCML para conseguir la máxima aceptación.

Personalmente, me resulta engorroso pero incluso para mí como un desarrollador que ofrece una buena ventaja: gracias a ZCML, casi nunca tengo dificultades para averiguar qué y dónde extensiones o personalizaciones. Para mí, los archivos ZCML son como una guía telefónica.

¿Como buscar complementos?¶

• https://pypi.python.org/pypi - ¡Use el formulario de búsqueda!

• https://github.com/collective > 1200 repositorios

• https://github.com/plone > 260 repositorios

• http://news.gmane.org/gmane.comp.web.zope.plone.user

• Navegando en Google (por ejemplo Plone+Slider)

• Verifica una lista corta en Plone Paragon (Lanzado en Agosto de 2014)

• Pregunta en el canal irc y la lista de correo

Algunos complementos notables¶

Products.PloneFormGen

Un generador de formularios

collective.plonetruegallery

Galerías de fotos con una gran selección de varios librerías Javascript

collective.cover

Interfaz para crear páginas de inicios (landing pages) complejas

collective.geo

Paquete flexible de complementos para georeferenciar contenido y mostrar mapas

collective.mailchimp

Permite a los visitantes suscribirse a noticias Mailchimp

eea.facetednavigation

Crear la navegación facetada y búsquedas a través de la Web.

webcouturier.dropdownmenu

Convierte la navegación global en menú desplegables

collective.quickupload

Subida de múltiples archivos usando el concepto drag & drop

Products.Doormat

Un flexible pie de página basado en el patrón de diseño Doormat

collective.behavior.banner

Agrega banners decorativos y pasarelas

plone.app.multilingual

Permite sitios plurilingüe mediante la traducción de contenido

Plomino

Un poderoso y flexible constructor de aplicaciones basado en Web para Plone

Instalando complementos¶

La instalación es un proceso de dos pasos.

$ cd /vagrant/buildout
$ bin/buildout
$ bin/instance fg

PloneFormGen¶

Hay muchas formas de crear formularios en Plone:

• Puro: HTML y Python en una vista

• Usando framework: z3c.form, formlib, deform

• A través de la Web: Products.PloneFormGen

El concepto básico de PloneFormGen es usted construye un formulario mediante la adición de una carpeta de formulario, a esta agrega campos de formulario como elementos de contenido. Se añaden, eliminar, editar campos y mueven al igual que con cualquier otro tipo de contenido. Los envíos de formularios pueden ser enviados por correo electrónico de forma automática y / o guardarse para descargar, por ejemplo en un archivo CSV. Hay muchas complementos para PloneFormGen que proporcionan los tipos de campo adicionales y acciones.

Vamos a construir un formulario de registro:

• Activar PloneFormGen para este sitio a través del panel de configuración Complementos en la Configuración del sitio.

• Agrega un objeto del nuevo tipo ‘Form Folder’ en el raíz del sitio llamado “Registro”

• Guarde y ver el resultado, un sencillo formulario de contacto el cual puede personalizar

• Haga clic en QuickEdit (para la edición rápida)

• Remueva el campo “Subject”

• Añadir campos para preferencia de alimentos y el tamaño de la camisa

• Agregar un adaptador DataSave

• Personalizar el script de envío de correo

Por cierto, mientras PloneFormGen es bueno en lo que hace, no es un buen modelo para el diseño de sus propias extensiones. Se fue creado antes de la arquitectura de componentes de Zope convirtió ampliamente utilizado. Los autores desean escribir de manera muy diferente si estaban empezando desde cero.

Agregar Galerías de fotos con collective.plonetruegallery¶

Para promocionar la conferencia queremos mostrar algunas fotos mostrando conferencias pasadas y la ciudad donde la conferencia se esta realizando.

En vez de crear tipos de contenido personalizados para galerías, este se integra con la funcionalidad de Plone para elegir diferentes vistas de tipos de contenidos en carpeta.

https://pypi.python.org/pypi/collective.plonetruegallery

• Activar el producto

• Habilitar el comportamiento Plone True Gallery en el tipo Carpeta: http://localhost:8080/Plone/dexterity-types/Folder/@@behaviors (sólo este paso es necesario porque PloneTrueGallery todavía no sabe sobre los nuevos tipos de contenidos en el paquete plone.app.contenttypes, entonces hay activamos para reemplazar viejos tipos de contenido de Plone con más nuevos, de estilo Dexterity.)

• Agregue una carpeta /el-evento/ubicacion

• Suba algunas fotos desde http://lorempixel.com/600/400/city/

• Habilite la vista galleryview

collective.plonetruegallery es un mejor modelo para escribir una extensión de Plone.

Internacionalización¶

Plone puede ejecutar el mismo sitio en múltiples lenguajes.

No estamos haciendo esto con el sitio de la conferencia ya que la lengua franca de la comunidad Plone es el Ingles.

Para esto debe usar https://pypi.python.org/pypi/plone.app.multilingual. Ese es el sucesor del Products.LinguaPlone (el cual solo usa tipos de contenidos Archetypes).

Resumen¶

Ahora somos capaces de personalizar y ampliar muchas partes de nuestro sitio web. Incluso podemos instalar extensiones que añaden nuevas funcionalidades.

Pero:

• ¿Podemos enviar Charlas al jurado evaluador ahora?

• ¿Podemos crear listas con las propiedades mas importantes de cada tarea?

• ¿Podemos permitir a un miembro del jurado votar en las Charlas?

Algunas veces trabajamos con data estructurada. Hasta un grado podemos hacer todo a través de la Web, pero a algún punto nos encontramos con barreras, en la siguiente parte de nuestro entrenamiento, te enseñaremos como romper esas barreras.

Ejemplo Diazo¶

• Activar Diazo vía el formulario del panel de control Complementos

• Valla al panel de control Temas

• Activar el tema Twitter Bootstrap

• Mire los cambios del sitio

• Remplace “localhost” en su dirección URL con “127.0.0.1”

• Vuelva al panel de control Temas, eche una mirada al panel Configuración Avanzada

• Desactivar el tema

• Copie el tema Twitter Bootstrap Example, use el botón Copiar para crear un tema en base a esta copia y poder modificar el tema para ver las reglas Diazo.

Ejemplo de Plantilla¶

• Use la ZMI para ver la herramienta portal_view_customizations

• Echa un vistazo a plone.belowcontenttitle.documentbyline — tener una idea de cómo se utiliza la lógica TAL para tirar en el contenido de contexto.

• Cambiar “History” a “Herstory” :)

Seleccionando la herramienta adecuada¶

Si todo lo que tienes es un martillo, todo parece un clavo

Hacer un buen trabajo con la tematización de Plone significa elegir la herramienta adecuada para el trabajo.

Si eres muy bueno con Diazo, que puede hacer casi todo con reglas Diazo. Es enteramente posible sustituir y reordenar los componentes más pequeños de un viewlet con una aplicación inteligente de una regla Diazo o un poco de XSL.

También es perfectamente posible hacer todo su tematización mediante la personalización de los archivos de plantilla. Después de todo, su sitio original Plone es tematizado (con un tema llamado Sunburst), incluso sin necesidad de activar Diazo. Antes Diazo ser unido a Plone (como un complemento en Plone 4.0), este es la forma en que Plone era tematizado.

Así que, ¿cuál es su estrategia?

• Para los sencillos temas del sitio son estructuralmente similares a los de fuera de la caja es Plone, sólo tiene que añadir CSS. Nada más se necesita.

• Para más temas complejos o uno en el se proporcionan con un tema de HTML, CSS y JS, use Diazo para mover las cosas, para poner las piezas del rompecabezas donde pertenecen.

• Si es necesario cambiar un viewlet o la vista de un tipo de contenido, utilice plantillas TAL.

Pero, no es necesario molestarse en aprender a cómo trabajar con los administradores viewlet de Plone. Sí, una vez fue necesario, pero Diazo es una mejor solución a este problema.

¿Quieres aprender realmente tematización?¶

Los buenos puntos de partida:

• Diazo (plone.app.theming): Este es la forma moderna para hacerlo y el tema por defecto en Plone 5 será un tema Diazo, esta disponible desde Plone 4.2 y versiones posteriores.

• Usted puede utilizar (y adaptar) una de las muchas temas Diazo disponible públicamente: https://pypi.python.org/pypi?%3Aaction=search&term=plonetheme&submit=search (intente con plonetheme.onegov por ejemplo)

• Creando un tema personalizado

• Un punto de partida puede ser el editor incorporados de temas Diazo

• Los temas a la vieja escuela (ampliando el tema por defecto integrado)

• Deliverance/XDV

Si usted busca un entrenamiento sobre Diazo se recomienda un entrenamiento por Chrissy Wainwright o Maik DerStappen

¿Qué es un tipo de contenido?¶

Un tipo de contenido es una variedad de objetos que pueden almacenar información y es editable por los usuarios. Tenemos diferentes tipos de contenido para reflejar los diferentes tipos de información sobre la que tenemos que recopilar y mostrar la información. Páginas, carpetas, eventos, noticias, archivos (binarios) y las imágenes son todos los tipos de contenido.

Es común en el desarrollo de un sitio Web usted necesitará versiones personalizadas de los tipos de contenido comunes, o tal vez incluso totalmente nuevos tipos.

¿Recuerda los requisitos para nuestro proyecto? Queríamos ser capaces de solicitar y editar charlas de la conferencia. Podríamos utilizar el tipo de contenido Página para ese propósito. Sin embargo, hay bits de información que necesitamos para asegurarnos de que obtenemos sobre una charla y no sería seguro de obtener esa información si sólo pedimos ponentes potenciales para crear una página. Además, vamos a querer ser capaz de mostrar las charlas que ofrecen esa información especial, y nosotros queremos ser capaces de mostrar las colecciones de charlas. Un tipo de contenido personalizado será ideal.

Los elementos de un tipo de contenido Plone¶

Cada tipo de contenido Plone tiene las siguientes partes:

Esquema

Una definición de campos que comprenden un tipo de contenido; propiedades de un objeto.

FTI

La “Factory Type Information” configura el tipo de contenido en Plone, asigna un nombre, un icono, características adicionales y posibles vistas.

Vistas

Una vista es una representación del objeto y el contenido de sus campos que pueden prestarse en respuesta a una solicitud. Usted puede tener una o más vistas de un objeto. Algunos pueden ser visuales - destinados a la pantalla en forma de páginas Web - otros pueden estar destinados a satisfacer las peticiones AJAX y estar en formatos como JSON o XML.

Dexterity y Archetypes - Una comparación¶

Hay dos frameworks de contenido en Plone

• Dexterity: nuevo y el que vendrá por defecto

• Archetypes: los tipos de contenidos viejos, intentados y probados

• Archetypes: extenso sin embargo con complementos

• Plone 4.x: Archetypes es el predeterminado, con Dexterity disponible

• Plone 5.x: Dexterity es el predeterminado, con Archetypes disponible

• Por tanto, añadir y editar formularios se crean automáticamente a partir de un esquema

¿Cuales son las diferencias?

• Dexterity: Nuevo, más rápido, modular, hay magia oscura para los métodos getters y setters

• Archetypes tiene métodos setter / getter mágico - usa talk.getAudience() para el campo ‘audience’

• Dexterity: los campos son atributos: talk.audience en vez de talk.getAudience()

A través de la Web:

• Dexterity tiene una buena experiencia a través de la Web.

• Archetypes no tiene experiencia a través de la Web, por defecto, solo vía productos adicionales de tercero sin soporte oficial.

• Modelado UML: ArchGenXML para Archetypes, agx para Dexterity

Enfoques para Desarrolladores:

• Esquema en Dexterity: A través de la Web, XML, Python. Interface = esquema, a menudo no hay clase necesaria

• Esquema en Archetypes: Esquemas solamente en Python

• Dexterity: Permisos fácil por cada campo. fácil personalización de formularios.

• Archetypes: Permisos por campo duros, los formularios personalizados aún más difícil.

• Si tiene que programar para los sitios antiguos ¡usted necesita saber Archetypes!

• Si empieza desde cero en nuevo sitios, ¡use Dexterity!.

Extendiendo:

• Dexterity tiene Comportamientos: fácilmente ampliable. Basta con activar un comportamiento a través de la Web y su tipo de contenido es, por ejemplo traducible (con el complemento plone.app.multilingual).

• Archetypes tiene el producto archetypes.schemaextender. Potente pero no tan flexible.

Sólo hemos utilizado Dexterity en los últimos años. Enseñamos Dexterity y no Archetypes porque es más accesible a los principiantes, tiene una gran experiencia a través de la Web y es el futuro.

Vistas:

• Tanto Dexterity y Archetypes tienen una vista predeterminada de tipos de contenido.

• Las Browser Views proveen vistas personalizadas.

• A través de la Web (en el futuro)

• Formularios de visualización

Instalación¶

Usted no tiene que modificar el archivo buildout puesto este esta incorporado desde Plone 4.2 y versiones posteriores con Dexterity. Sólo tienes que activarlo en el panel de control para Complementos.

Esta vez, sin razón aparente que no sea cada vez se sienta más cómodo con el ZMI, utilizaremos la herramienta portal_quickinstaller para instalar Dexterity.

• Ir a la herramienta portal_quickinstaller en la ZMI.

• Instale el producto “Tipos de contenido Dexterity”.

Modificando tipos existentes¶

• Ir a panel de control http://localhost:8080/Plone/@@dexterity-types

• Inspecciona algunos de los tipos de contenido existentes por defecto

• Seleccione el tipo de contenidos Noticias y agregar un nuevo campo Hot News de tipo Sí/No

• En otra pestaña agregar un tipo de contenido Noticia y entonces se ve el nuevo campo.

• Valla al editor de esquema y haga clic en Editar el modelo de campo XML.

• Note que el único campo en el esquema XML de la Noticia, es el que acaba de agregar. Todos los demás son proporcionados por los comportamientos.

• Editar el tipo de widget del formulario por lo que dice:

  <form:widget type="z3c.form.browser.checkbox.SingleCheckBoxFieldWidget"/>
  

• Edite de nuevo el elemento de Noticia. El widget de cambiado de un campo de radio a una casilla de verificación.

• El nuevo campo Hot News no se visualiza cuando se representa la Noticia. Nosotros nos ocuparemos de esto más adelante.

Creando tipos de contenidos a través de la Web¶

En este paso vamos a crear un tipo de contenido llamado Talk (para las charlas) y probarlo. Cuando esté listo vamos a mover el código fuente de la Web para el sistema de archivos y en nuestro propio complemento. Más tarde vamos a ampliar ese tipo, los comportamientos y añadir un viewlet de las Charlas.

• Agregar un nuevo tipo de contenido llamado “Talk” y algunos campos para el:

  • Agregue el campo “Type of talk”, de tipo “Selección”. Agregar opciones talk, keynote, training

  • Agregue el campo “Details”, de tipo “Rich Text” con un tamaño máximo de 2000

  • Agregue el campo “Audience”, de tipo “Selección múltiple”. Agregar opciones: beginner, advanced, pro

  • Marque los comportamientos que están habilitados: Metadatos Dublin Core, Nombre a partir del título. ¿Tenemos todos necesitamos?

• Pruebe el tipo de contenido

• Regrese al panel de control http://localhost:8080/Plone/@@dexterity-types

• Extiende el nuevo tipo

  • “Speaker”, tipo: “Línea de texto (cadena de caracteres)”

  • “Email”, tipo: “Línea de texto (cadena de caracteres)”

  • “Image”, tipo: “Image”, no requerido

  • “Speaker Biography”, tipo: “Rich Text”

• Probar otra vez

Aquí está el código completo de esquema XML creado por nuestras acciones.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

<model xmlns:security="http://namespaces.plone.org/supermodel/security" xmlns:marshal="http://namespaces.plone.org/supermodel/marshal" xmlns:form="http://namespaces.plone.org/supermodel/form" xmlns="http://namespaces.plone.org/supermodel/schema">
  <schema>
    <field name="type_of_talk" type="zope.schema.Choice">
      <description/>
      <title>Type of talk</title>
      <values>
        <element>Talk</element>
        <element>Training</element>
        <element>Keynote</element>
      </values>
    </field>
    <field name="details" type="plone.app.textfield.RichText">
      <description>Add a short description of the talk (max. 2000 characters)</description>
      <max_length>2000</max_length>
      <title>Details</title>
    </field>
    <field name="audience" type="zope.schema.Set">
      <description/>
      <title>Audience</title>
      <value_type type="zope.schema.Choice">
        <values>
          <element>Beginner</element>
          <element>Advanced</element>
          <element>Professionals</element>
        </values>
      </value_type>
    </field>
    <field name="speaker" type="zope.schema.TextLine">
      <description>Name (or names) of the speaker</description>
      <title>Speaker</title>
    </field>
    <field name="email" type="zope.schema.TextLine">
      <description>Adress of the speaker</description>
      <title>Email</title>
    </field>
    <field name="image" type="plone.namedfile.field.NamedBlobImage">
      <description/>
      <required>False</required>
      <title>Image</title>
    </field>
    <field name="speaker_biography" type="plone.app.textfield.RichText">
      <description/>
      <max_length>1000</max_length>
      <required>False</required>
      <title>Speaker Biography</title>
    </field>
  </schema>
</model>

Moviendo el tipo de contenido dentro del código fuente¶

Es impresionante que podemos hacer tanto a través de la Web. Pero también es un callejón sin salida si queremos volver a utilizar este tipo de contenido en otros sitios.

También, para el desarrollo profesional, queremos ser capaces de utilizar el control de versiones para nuestro trabajo, y vamos a querer ser capaz de añadir la clase de lógica de negocio que requerirá de programación.

Por lo tanto, vamos a última instancia querer mover nuestro nuevo tipo de contenido en un paquete Python. Nos faltan algunas habilidades para hacer eso, y vamos a cubrir aquellos en los próximos dos capítulos.

Ejercicios¶

<model xmlns:security="http://namespaces.plone.org/supermodel/security"
       xmlns:marshal="http://namespaces.plone.org/supermodel/marshal"
       xmlns:form="http://namespaces.plone.org/supermodel/form"
       xmlns="http://namespaces.plone.org/supermodel/schema">
  <schema>
    <field name="first_name" type="zope.schema.TextLine">
      <title>First Name</title>
    </field>
    <field name="last_name" type="zope.schema.TextLine">
      <title>Last Name</title>
    </field>
    <field name="email" type="zope.schema.TextLine">
      <title>Email</title>
    </field>
    <field name="homepage" type="zope.schema.TextLine">
      <required>False</required>
      <title>Homepage</title>
    </field>
    <field name="biography" type="plone.app.textfield.RichText">
      <required>False</required>
      <title>Biography</title>
    </field>
    <field name="company" type="zope.schema.TextLine">
      <required>False</required>
      <title>Company</title>
    </field>
    <field name="twitter_name" type="zope.schema.TextLine">
      <required>False</required>
      <title>Twitter-Name</title>
    </field>
    <field name="irc_name" type="zope.schema.TextLine">
      <required>False</required>
      <title>IRC-Name</title>
    </field>
    <field name="image" type="plone.namedfile.field.NamedBlobImage">
      <required>False</required>
      <title>Image</title>
    </field>
  </schema>
</model>

Sintaxis¶

La sintaxis de los archivos de configuración de despliegue es similar a los archivos clásicos ini. Usted escribe un nombre de parámetro, un signo igual y el valor. Si introduce otro valor en la siguiente línea y indentada, Buildout entiende que ambos valores pertenecen al nombre del parámetro y el parámetro almacena todos los valores en forma de lista.

Un Buildout consta de múltiples secciones. Las secciones comienzan con el nombre de la sección entre corchetes. Cada sección declara una parte diferente de su aplicación. Como analogía aproximada, su archivo Buildout es un libro de cocina con múltiples recetas.

Hay una sección especial, llamada [buildout]. En esta sección se puede cambiar el comportamiento de la propia Buildout. Las variables parts define, cuál de las secciones existentes deben ser efectivamente utilizadas.

Recetas¶

Buildout por si mismo no tiene idea de como instalar Zope. Buildout es un sistema basado en plugin, este viene con un pequeño conjunto de plugins para crear archivos de configuración y descargar paquetes eggs con sus dependencias y su versión apropiada. Para instalar un sitio Zope, necesitas un plugin de terceros. El plugin provee nuevas recetas que tu tienes que declarar y configurar en una sección.

Un ejemplo es esta sección.

[instance]
recipe = plone.recipe.zope2instance
user = admin:admin

Esto usa el paquete de python plone.recipe.zope2instance para crear y configurar la instancia Zope 2 la cual usamos para ejecutar Plone. Todas las lineas después de recipe = xyz son la configuración de la receta usada.

Referencias¶

Buildout le permite usar referencias en la configuración. Una declaración de variable no sólo puede mantener el valor de variable, pero también una referencia al lugar donde buscar el valor de la variable.

Si usted tiene una gran instalación con muchos sitios Plone con pequeños cambios entre cada configuración, se puede generar una plantilla de configuración, y cada sitio hace referencia a todo, desde la plantilla y sobrescribe justo en lo que necesita ser cambiado.

Incluso en los buildouts más pequeños esta es una característica útil. Estamos utilizando collective.recipe.omelette. Una receta muy práctica, la cual crea un directorio virtual para facilitar la navegación al código fuente de cada paquete egg.

La receta omelette tiene que saber cuales son los paquetes eggs para hacer referencia. Queremos los mismos paquetes eggs usados por nuestra instancia Zope, por lo que nos referimos a los paquetes eggs de la instancia en lugar de repetir toda la lista.

Otro ejemplo: Digamos usted crea archivos de configuración para un servidor Web como Nginx, puede definir el puerto de destino para el Proxy inverso al mirar hacia arriba a partir de la receta zope2instance.

La configuración de sistemas complejos siempre implica una gran cantidad de duplicación de la información. El uso de referencias en la configuración buildout le permite minimizar estas duplicaciones.

Un ejemplo de la vida real¶

Examinemos el archivo buildout.cfg para el entrenamiento y miremos algunas de las variables más importantes:

[buildout]
extends =
    http://dist.plone.org/release/4.3.10/versions.cfg

# We add our own versions
    versions.cfg

versions = versions

extensions = mr.developer
# Tell mr.developer to ask before updating a checkout.
always-checkout = true
show-picked-versions = true
sources = sources

# Put checkouts in src-mrd. We keep our own package in src
sources-dir = src-mrd

# The directory this buildout is in. Modified when using vagrant.
buildout_dir = ${buildout:directory}

# We want to checkouts these eggs directly from github
auto-checkout =
#    ploneconf.site_sneak
#    starzel.votable_behavior
#    ploneconf.site

parts =
    checkversions
    codeintel
    instance
    mrbob
    packages
#    robot
    test
    zopepy
#    zopeskel

eggs =
    Plone
    Pillow

# development tools
    z3c.jbot
    plone.api
    plone.reload
    Products.PDBDebugMode
    plone.app.debugtoolbar
    Products.PrintingMailHost

# 3rd party addons
    Products.PloneFormGen
    collective.plonetruegallery
    collective.js.datatables
    eea.facetednavigation
    collective.behavior.banner

# dexterity default types
    plone.app.contenttypes

# The addon we develop in the training
#    ploneconf.site

# Voting on content
#    starzel.votable_behavior

zcml =

test-eggs +=
#    ploneconf.site [test]

[instance]
recipe = plone.recipe.zope2instance
user = admin:admin
http-address = 8080
debug-mode = on
verbose-security = on
deprecation-warnings = on
eggs = ${buildout:eggs}
zcml = ${buildout:zcml}
file-storage = ${buildout:buildout_dir}/var/filestorage/Data.fs
blob-storage = ${buildout:buildout_dir}/var/blobstorage

[test]
recipe = zc.recipe.testrunner
eggs = ${buildout:test-eggs}
defaults = ['--exit-with-status', '--auto-color', '--auto-progress']

[packages]
recipe = collective.recipe.omelette
eggs = ${buildout:eggs}
location = ${buildout:buildout_dir}/packages

[codeintel]
recipe = corneti.recipes.codeintel
eggs = ${buildout:eggs}

[checkversions]
recipe = zc.recipe.egg
eggs = z3c.checkversions [buildout]

[zopepy]
recipe = zc.recipe.egg
eggs = ${buildout:eggs}
interpreter = zopepy
scripts = zopepy

[zopeskel]
recipe = zc.recipe.egg
eggs =
    ZopeSkel
    Paste
    PasteDeploy
    PasteScript
    zopeskel.diazotheme
    zopeskel.dexterity
    zest.releaser
    ${buildout:eggs}

[mrbob]
recipe = zc.recipe.egg
eggs =
    mr.bob
    bobtemplates.plone

[sources]
# ploneconf.site = fs ploneconf.site full-path=${buildout:directory}/src/ploneconf.site
starzel.votable_behavior = git https://github.com/collective/starzel.votable_behavior.git pushurl=git@github.com:collective/starzel.votable_behavior.git

Cuando usted ejecuta el comando ./bin/buildout sin argumentos, Buildout buscara por este archivo.

Echemos un vistazo más de cerca a algunas variables.

extends =
    http://dist.plone.org/release/4.3.10/versions.cfg
    versions.cfg

Esta línea le dice al Buildout lea más archivos de configuración. Puede hacer referencia a los archivos de configuración locales en el equipo o los archivos de configuración en Internet, accesible a través de protocolo HTTP. Puede utilizar varios archivos de configuración para compartir entre múltiples configuraciones Buildouts, o para separar los diferentes aspectos de su configuración en archivos diferentes. Ejemplos típicos son especificaciones de la versión o la configuración que difieren entre los diferentes entornos de instalación como desarrollo, calidad, producción.

eggs =
    Plone
    Pillow
    z3c.jbot
    plone.api
    plone.reload
    Products.PDBDebugMode
    plone.app.debugtoolbar
    Paste
    Products.PloneFormGen
    collective.plonetruegallery
    collective.js.datatables
    eea.facetednavigation
    collective.behavior.banner
    plone.app.contenttypes
#    ploneconf.site
#    starzel.votable_behavior

Esta es la lista de los paquetes eggs que nosotros configuramos para estar disponible para Zope. Estos paquetes eggs se ponen en el PYTHONPATH del script bin/instance con el cual se iniciara y detendrá con Plone.

El paquete egg Plone es una envoltura sin código fuente. Entre sus dependencias esta Products.CMFPlone que es el paquete egg en el cual esta propiamente de Plone.

El resto son complementos que ya hemos usado o usará más tarde. Los últimos paquetes eggs están comentadas por lo que no se instalarán por Buildout.

El archivo versions.cfg se incluye por la declaración extends = ... contiene las versiones que definimos:

[versions]
# dev tools
z3c.jbot = 0.7.2
plone.api = 1.1.0
plone.app.debugtoolbar = 1.0a3
...

Esta es otra sección especial. Se ha convertido en una sección especial de declaración. En nuestra sección [buildout] establecemos una variable versions = versions. Esto le dice a buildout, existe una sección denominada versions, conteniendo información de las versiones a usar. Cuando Buildout instala paquetes eggs se utilizará la versión definida en esta sección.

¡Hola mr.developer!¶

Hay muchas cosas más importantes que debe saber, y no podemos pasar por ellos en todos los detalles, pero quiero centrarme en una característica específica: mr.developer

Con mr.developer puede declarar los paquetes que desee comprobar desde o hacia un sistema de control de versiones y de cual dirección URL del repositorio. Usted puede comprobar código fuente desde diversos CVS como git, subversion, bzr, hg y quizá más. También, se puede indicar a Buildout algún código fuente se encuentran en el sistema de archivos local sin aplicar control de versiones.

mr.developer viene con un comando, ./bin/develop. Se puede utilizar para actualizar su código fuente, para comprobar los nuevos cambios y así sucesivamente. Usted puede activar y desactivar sus checkouts de sus código fuente. Si usted desarrolla sus extensiones en los paquetes eggs con checkouts separadas, lo cual es una buena práctica, usted puede planear publicaciones por tener todas los checkouts desactivados, y sólo activarlos, al escribir los cambios que requieren una nueva versión. Usted puede activar y desactivar los paquetes eggs a través del comando develop o vía la configuración Buildout. Siempre debe usar la forma Buildout. Su commit sirve como documentación.

Extensible¶

Usted puede haber notado que la mayoría, si no toda la funcionalidad sólo está disponible a través de plugins. Una de las cosas que sobresale en Buildout sin ningún plugin, es la resolución de dependencias. Usted puede ayudar a Plone en la resolución de dependencias, al declarar exactamente cual versión de un paquete egg usted desea. Esto es sólo un caso de uso. Otra es mucho más importante: Si usted quiere tener un Buildout repetible, el cual funcione de dos meses a partir de ahora también, se debe declarar todas sus versiones de paquete egg. De otro modo Buildout podría instalar las nuevas versiones.

Sea un McGuyver¶

Como puede ver, usted puede construir sistemas muy complejos con Buildout. Es hora de algunas advertencias. Sea selectivo en sus recetas. Supervisor es un programa para gestionar servidores en ejecución, es bastante bueno. No hay una receta para ello.

¡La configuración para esta receta es más complicada que la propia configuración del Supervisor en si! Mediante el uso de esta receta, se fuerza a los demás a comprender la sintaxis de configuración específica recetas y la sintaxis Supervisor. Para tales casos, collective.recipe.template presenta una mejor coincidencia.

Otro problema es el manejo de errores. ¿Buildout intenta instalar una rara dependencia que en realidad no quiere? Buildout no le dirá, lo que está viniendo.

Si hay un problema, siempre se puede ejecutar Buildout con la opción -v, para obtener una salida más detallada, a veces ayuda.

$ ./bin/buildout -v

Si se solicitan las versiones de paquetes eggs extraños, verifique la declaración de las dependencias de los paquetes eggs y su versión definida.

Algunas partes de Buildout interpretan nombres de paquete egg entre mayúsculas y minúsculas, otros no. Esto puede dar lugar a problemas de divertidos.

Verifique siempre el orden de su configuraciones extendidas, utilice siempre el comando annotate de Buildout para ver si se interpreta la configuración diferente a la que usted definió. Restringirse a los archivos de despliegue simples. Puede hacer referencia a variables de otras secciones, incluso se puede utilizar toda una sección como plantilla. Hemos aprendido que esto no funciona bien con jerarquías complejas y se tuvo que abandonar esa característica.

En el capítulo Buildout - Parte II: Cómo prepararse para el despliegue veremos una configuración de despliegue lista para entornos de producción de Plone que tiene muchas características útiles.

Creando la distribución¶

Nuestro propio código tiene que ser organizado como un paquete egg. Un paquete egg es un archivo zip o un directorio que sigue ciertas convenciones. Vamos a utilizar bobtemplates.plone para crear un proyecto de esqueleto. Tan sólo hay que responder a las preguntas del generador, las cuales crearán archivos necesarios para trabajar.

Nosotros accedemos al directorio src y ejecutamos un script llamado mrbob ubicado en nuestros directorio bin del buildout.

$ mkdir src      # (if src does not exist already)
$ cd src
$ ../bin/mrbob -O ploneconf.site bobtemplates:plone_addon

Tenemos que responder a algunas preguntas sobre el complemento. Vamos a presionar la tecla Enter (es decir, elegir el valor por defecto) para todas las preguntas, excepto la 3era pregunta (donde ingresa su nombre de usuario github si tiene uno) y la 5ta pregunta (versión Plone), donde ingresa 4.3.10.

--> What kind of package would you like to create? Choose between 'Basic', 'Dexterity', and 'Theme'. [Basic]:

--> Author's name [Philip Bauer]:

--> Author's email [bauer@starzel.de]:

--> Author's github username: fulv

--> Package description [An add-on for Plone]:

--> Plone version [4.3.9]: 4.3.10

Generated file structure at /vagrant/buildout/src/ploneconf.site

Si este es su primer paquete egg, éste es un momento muy especial. Vamos a crear el paquete egg con un script que genera una gran cantidad de archivos necesarios. Todos ellos son necesarios, pero a veces de una manera sutil. Se toma un tiempo entiendo su significado pleno. Sólo el año pasado he aprendido y entendido por qué debería tener un archivo MANIFEST.in. Usted puede vivir sin uno, pero confía en mí, te llevas mejor con un archivo de manifiesto adecuada.

Inspeccionando la distribución¶

En la carpeta src ahora hay una nueva carpeta ploneconf.site y ahí está la nueva distribución. Echemos un vistazo a algunos de los archivos:

bootstrap-buildout.py, buildout.cfg, travis.cfg, .travis.yml, .coveragerc

Puede pasar por alto estos archivos por ahora. Ellos están aquí para crear un buildout sólo para este paquete egg para hacer las pruebas más fáciles. Una vez que empezamos a escribir las pruebas para este paquete tendremos que actualizar estos archivos a las actuales mejores prácticas y versiones.

README.rst, CHANGES.rst, CONTRIBUTORS.rst, docs/

La documentación y el archivo de registro de cambios, el archivo de la lista de contribuidores y el archivo de la licencia de su paquete egg van allí.

setup.py

Este archivo configura el paquete, su nombre, las dependencias y algunos metadatos como el nombre del y correo electrónico del autor. Las dependencias listadas aquí son descargadas automáticamente por buildout.

src/ploneconf/site/

La distribución Python en si misma vive dentro de una estructura de carpetas especial. Eso parece confuso, pero es necesario para tener buena habilidad de prueba. Nuestra distribución contiene un paquete de espacio de nombres llamado ploneconf.site y debido a esto hay una carpeta ploneconf con un archivo __init__.py y allí hay otra carpeta site y ahí finalmente está nuestro código. Desde la perspectiva de buildout, nuestro código está en la ruta <su directorio buildout>/src/ploneconf.site/src/ploneconf/site/<real code>

configure.zcml (src/ploneconf/site/configure.zcml)

La guía de los paquetes. De su lectura se puede averiguar qué funcionalidad está registrado a través de la arquitectura de componentes.

setuphandlers.py (src/ploneconf/site/setuphandlers.py)

Esto contiene el código que se ejecuta automáticamente al instalar y desinstalar nuestro complemento.

interfaces.py (src/ploneconf/site/interfaces.py)

Aquí se define un browserlayer en una simple clase de python. Lo necesitaremos más tarde.

testing.py

Esta contiene la configuración para correr las pruebas del paquete.

tests/

Esta contiene las pruebas del paquete.

browser/

Este directorio es un paquete python (porque tiene un __init__.py) y por convención contiene la mayoría de las cosas que son visibles en el navegador.

browser/configure.zcml

La guía del paquete del browser. Aquí se registran vistas, recursos y sobre-escrituras de Plone.

browser/overrides/

Este complemento ya está configurado para permitir la sustitución o sobre-escritura de las plantillas por defecto de Plone existentes.

browser/static/

Un directorio que contiene los recursos estáticos (archivos de imágenes, CSS y JS). Los archivos aquí serán accesibles a través de las URLs como ++resource++ploneconf.site/myawesome.css

profiles/default/

La carpeta contiene el perfil GenericSetup. Durante el entrenamiento pondrán algunos archivos XML ahí que tienen la configuración para el sitio.

profiles/default/metadata.xml

Número de versión y dependencias que son auto-instalado cuando esta instalando su propio complemento.

Incluyendo el paquete egg en Plone¶

Antes de poder utilizar nuestro nuevo complemento tenemos que indicarle de la existencia de este a Plone. Entonces edite el archivo buildout.cfg y descomente el paquete egg ploneconf.site en las secciones eggs y sources:

eggs =
    Plone
    ...
    ploneconf.site
#    starzel.votable_behavior

...

[sources]
collective.behavior.banner = git https://github.com/collective/collective.behavior.banner.git pushurl=git@github.com:collective/collective.behavior.banner.git rev=af2dc1f21b23270e4b8583cf04eb8e962ade4c4d
ploneconf.site = fs ploneconf.site full-path=${buildout:directory}/src/ploneconf.site
# starzel.votable_behavior = git https://github.com/collective/starzel.votable_behavior.git pushurl=git://github.com/collective/starzel.votable_behavior.git

Esto le dice a Buildout agregue el paquete egg ploneconf.site. Dado que también se encuentra en la sección sources en Buildout no intentará descargarlo de PYPI pero esperará en src/ploneconf.site. La opción fs le permite añadir paquetes en el sistema de ficheros sin un sistema de control de versiones, o con uno compatible.

Ahora ejecute buildout para reconfigurar Plone con la configuración actualizada:

$ ./bin/buildout

Después reinicie Plone con el comando ./bin/instance fg el nuevo complemento ploneconf.site está disponible para instalar como PloneFormGen o Plone True Gallery.

No vamos a instalarlo ahora, ya que no añadimos aun nada de nuestro propio código fuente o configuración todavía. Vamos a hacer eso.

Volver Dexterity: para mover tipos de contenidos a código fuente¶

¿Recuerda el tipo de contenido Talk que hemos creado a través de la Web con Dexterity? Vamos a pasar ese nuevo tipo de contenido a dentro de nuestro paquete egg para que pueda ser instalado en otros sitios sin manipulación a través de la Web.

Pasos:

• Volver al panel del control Tipos de contenido Dexterity

• Haga clic en la casilla junto al Tipo de contenido Talk y hace clic en el botón Exportar los perfiles del tipo y guardarlo en el archivo

• Elimine el Tipo de contenido Talk desde el panel del control Tipos de contenido Dexterity en su sitio Plone ante de instalarlo desde el sistema de archivo

• Extrae los archivos desde el archivo tar exportado y agréguelo entonces en nuestro paquete en la ruta ploneconf/site/profiles/default/

El archivo ploneconf/site/profiles/default/types.xml le dice a que allí tiene un nuevo tipo de contenido definido en el archivo talk.xml.

<?xml version="1.0"?>
<object name="portal_types" meta_type="Plone Types Tool">
 <property name="title">Controls the available content types in your portal</property>
 <object name="talk" meta_type="Dexterity FTI"/>
 <!-- -*- more types can be added here -*- -->
</object>

Tras la instalación, Plone lee el archivo ploneconf/site/profiles/default/types/talk.xml y registra un nuevo tipo de contenido en la herramienta portal_types (puede encontrar esta en el ZMI) con la información tomada de ese archivo.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

  <?xml version="1.0"?>
  <object name="talk" meta_type="Dexterity FTI" i18n:domain="plone"
     xmlns:i18n="http://xml.zope.org/namespaces/i18n">
   <property name="title" i18n:translate="">Talk</property>
   <property name="description" i18n:translate="">None</property>
   <property name="icon_expr">string:${portal_url}/document_icon.png</property>
   <property name="factory">talk</property>
   <property name="add_view_expr">string:${folder_url}/++add++talk</property>
   <property name="link_target"></property>
   <property name="immediate_view">view</property>
   <property name="global_allow">True</property>
   <property name="filter_content_types">True</property>
   <property name="allowed_content_types"/>
   <property name="allow_discussion">False</property>
   <property name="default_view">view</property>
   <property name="view_methods">
    <element value="view"/>
   </property>
   <property name="default_view_fallback">False</property>
   <property name="add_permission">cmf.AddPortalContent</property>
   <property name="klass">plone.dexterity.content.Container</property>
   <property name="behaviors">
    <element value="plone.app.dexterity.behaviors.metadata.IDublinCore"/>
    <element value="plone.app.content.interfaces.INameFromTitle"/>
   </property>
   <property name="schema"></property>
   <property
      name="model_source">&lt;model xmlns:security="http://namespaces.plone.org/supermodel/security" xmlns:marshal="http://namespaces.plone.org/supermodel/marshal" xmlns:form="http://namespaces.plone.org/supermodel/form" xmlns="http://namespaces.plone.org/supermodel/schema"&gt;
      &lt;schema&gt;
        &lt;field name="type_of_talk" type="zope.schema.Choice"&gt;
          &lt;description/&gt;
          &lt;title&gt;Type of talk&lt;/title&gt;
          &lt;values&gt;
            &lt;element&gt;Talk&lt;/element&gt;
            &lt;element&gt;Training&lt;/element&gt;
            &lt;element&gt;Keynote&lt;/element&gt;
          &lt;/values&gt;
        &lt;/field&gt;
        &lt;field name="details" type="plone.app.textfield.RichText"&gt;
          &lt;description&gt;Add a short description of the talk (max. 2000 characters)&lt;/description&gt;
          &lt;max_length&gt;2000&lt;/max_length&gt;
          &lt;title&gt;Details&lt;/title&gt;
        &lt;/field&gt;
        &lt;field name="audience" type="zope.schema.Set"&gt;
          &lt;description/&gt;
          &lt;title&gt;Audience&lt;/title&gt;
          &lt;value_type type="zope.schema.Choice"&gt;
            &lt;values&gt;
              &lt;element&gt;Beginner&lt;/element&gt;
              &lt;element&gt;Advanced&lt;/element&gt;
              &lt;element&gt;Professionals&lt;/element&gt;
            &lt;/values&gt;
          &lt;/value_type&gt;
        &lt;/field&gt;
        &lt;field name="speaker" type="zope.schema.TextLine"&gt;
          &lt;description&gt;Name (or names) of the speaker&lt;/description&gt;
          &lt;title&gt;Speaker&lt;/title&gt;
        &lt;/field&gt;
        &lt;field name="email" type="zope.schema.TextLine"&gt;
          &lt;description&gt;Adress of the speaker&lt;/description&gt;
          &lt;title&gt;Email&lt;/title&gt;
        &lt;/field&gt;
        &lt;field name="image" type="plone.namedfile.field.NamedBlobImage"&gt;
          &lt;description/&gt;
          &lt;required&gt;False&lt;/required&gt;
          &lt;title&gt;Image&lt;/title&gt;
        &lt;/field&gt;
        &lt;field name="speaker_biography" type="plone.app.textfield.RichText"&gt;
          &lt;description/&gt;
          &lt;max_length&gt;1000&lt;/max_length&gt;
          &lt;required&gt;False&lt;/required&gt;
          &lt;title&gt;Speaker Biography&lt;/title&gt;
        &lt;/field&gt;
      &lt;/schema&gt;
    &lt;/model&gt;</property>
   <property name="model_file"></property>
   <property name="schema_policy">dexterity</property>
   <alias from="(Default)" to="(dynamic view)"/>
   <alias from="edit" to="@@edit"/>
   <alias from="sharing" to="@@sharing"/>
   <alias from="view" to="(selected layout)"/>
   <action title="View" action_id="view" category="object" condition_expr=""
      description="" icon_expr="" link_target="" url_expr="string:${object_url}"
      visible="True">
    <permission value="View"/>
   </action>
   <action title="Edit" action_id="edit" category="object" condition_expr=""
      description="" icon_expr="" link_target=""
      url_expr="string:${object_url}/edit" visible="True">
    <permission value="Modify portal content"/>
   </action>
  </object>

Ahora nuestro paquete tiene algunos contenidos reales. Por lo tanto, tendremos que volver a instalarlo (si está instalado antes).

• Reinicie Plone.

• Reinstale el paquete ploneconf.site (desactive y active).

• Valla a la ZMI y vea la definición del nuevo tipo de contenido en la herramienta portal_types.

• Pruebe el tipo de contenido agregando un objeto o la edición de una de las entradas antiguas.

• Mire cómo se presentan los tipo de contenidos talks en el navegador.

Una simple browser view¶

Antes de escribir la vista de tipo de contenido talk en sí, retrocedemos y hablamos un poco sobre las vistas y las plantillas.

Una vista en Plone suele ser un BrowserView. Puede contener mucho código de python, pero primero nos centraremos en la plantilla.

Edite el archivo browser/configure.zcml y registre una nueva vista llamada training:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

<configure
  xmlns="http://namespaces.zope.org/zope"
  xmlns:browser="http://namespaces.zope.org/browser"
  xmlns:plone="http://namespaces.plone.org/plone"
  i18n_domain="ploneconf.site">

  <!-- Set overrides folder for Just-a-Bunch-Of-Templates product -->
  <include package="z3c.jbot" file="meta.zcml" />
  <browser:jbot
    directory="overrides"
    layer="ploneconf.site.interfaces.IPloneconfSiteLayer"
    />

  <!-- Publish static files -->
  <browser:resourceDirectory
    name="ploneconf.site"
    directory="static"
    />

  <browser:page
    name="training"
    for="*"
    template="templates/training.pt"
    permission="zope2.View"
    />

</configure>

Agregue un archivo browser/templates/training.pt:

<h1>Hello World</h1>

• Reiniciar Plone y abra en la dirección http://localhost:8080/Plone/@@training.

• Usted debería ver “Hello World”.

Ahora tenemos todo en su lugar para aprender sobre las Zope Page Templates - ZPT.

TAL y TALES¶

Vamos a añadir un poco de magia y modificar la etiqueta <p>:

<p tal:content="string:blue">red</p>

Esto resultará en el siguiente código HTML:

<p>blue</p>

Sin reiniciar Plone abra en el navegador http://localhost:8080/Plone/@@demoview.

Lo mismo ocurre con los atributos. Remplace en la línea <p> con el siguiente código:

<a href="http://www.mssharepointconference.com"
   tal:define="a_fine_url string:http://www.ploneconf.org"
   tal:attributes="href a_fine_url"
   tal:content="string:A even better conference">
    A sharepoint conference
</a>

resultado en:

<a href="http://www.ploneconf.org">
    A even better conference
</a>

Nosotros hemos utilizado los tres atributos TAL aquí. Esta es la lista completa de los atributos TAL:

tal:define

definir las variables. Nosotros definimos la variable url para la cadena “http://www.ploneconf.org“

tal:content

reemplazar el contenido de un elemento. Hemos sustituido el valor por defecto de contenido con algunas como “A even better conference”

tal:attributes

cambiar dinámicamente atributos de los elementos. Nosotros hemos establecido el atributo href html a la variable a_fine_url

tal:condition

pruebas, si la expresión es verdadera o falsa.

tal:repeat

repite un elemento iterable, en nuestro caso, la lista de charlas.

tal:replace

reemplazar el contenido de un elemento como tal:content , pero se elimina el elemento sólo dejando el contenido.

tal:omit-tag

eliminar un elemento, dejando el contenido del elemento.

tal:on-error

controlar los errores.

<p tal:define="title context/title"
   tal:content="python:title.upper()">
   A big title
</p>

<p tal:define="talks python:['Dexterity for the win!',
                             'Deco is the future',
                             'A keynote on some weird topic',
                             'The talk that I did not submit']"
   tal:content="python:talks[0]">
    A talk
</p>

tal:condition="talks"

tal:condition="python:len(talks) >= 1"

tal:condition="python:'Deco is the future' in talks"

<p tal:define="talks python:['Dexterity for the win!',
                             'Deco is the future',
                             'A keynote on some weird topic',
                             'The talk that I did not submit']"
   tal:repeat="talk talks"
   tal:content="talk">
   A talk
</p>

<ul tal:define="talks python:['Dexterity for the win!',
                              'Deco is the future',
                              'A keynote on some weird topic',
                              'The talk that I did not submit']">
    <li tal:repeat="talk talks"
        tal:content="talk">
          A talk
    </li>
    <li tal:condition="not:talks">
          Sorry, no talks yet.
    </li>
</ul>

<p tal:content="context/title"></p>

<p tal:content="context/REQUEST/form"></p>

<p tal:content="context/title | context/id"></p>

<p tal:replace="talk/average_rating | nothing"></p>

<p tal:replace="nothing">
    this comment will not be rendered
</p>

<dl tal:define="path_variables_dict CONTEXTS">
  <tal:vars tal:repeat="variable path_variables_dict">
    <dt tal:content="variable"></dt>
    <dd tal:content="python:path_variables_dict[variable]"></dd>
  </tal:vars>
</dl>

<tal:block attribute="expression">some content</tal:block>

<tal:block define="id template/id">
...
  <b tal:content="id">The id of the template</b>
...
</tal:block>

<tal:news condition="python:context.content_type == 'News Item'">
    This text is only visible if the context is a News Item
</tal:news>

<p>
    <img tal:define="tag string:<img src='https://plone.org/logo.png'>"
         tal:replace="tag">
</p>

<p>
    &lt;img src='https://plone.org/logo.png'&gt;
</p>

<p>
    <img tal:define="tag string:<img src='https://plone.org/logo.png'>"
         tal:replace="structure tag">
</p>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

  <table tal:define="talks python:[{'title':'Dexterity for the win!',
                                    'subjects':('content-types', 'dexterity')},
                                   {'title':'Deco is the future',
                                    'subjects':('layout', 'deco')},
                                   {'title':'The State of Plone',
                                    'subjects':('keynote',) },
                                   {'title':'Diazo designs dont suck!',
                                    'subjects':('design', 'diazo', 'xslt')}
                                  ]">
      <tr>
          <th>Title</th>
          <th>Topics</th>
      </tr>
      <tr tal:repeat="talk talks">
          <td tal:content="talk/title">A talk</td>
          <td tal:define="subjects talk/subjects">
              <span tal:repeat="subject subjects"
                    tal:replace="subject">
              </span>
          </td>
      </tr>
  </table>

METAL y macros¶

¿Por qué nuestra vista es tan feo?, ¿Cómo conseguimos nuestro HTML para representar en la interfaz de usuario de Plone?

Utilizamos METAL (extensión macro para TAL) para definir ranuras que podemos llenar y macros que podemos reutilizar.

Agregamos a la etiqueta <html>:

metal:use-macro="context/main_template/macros/master"

Y a continuación, ajustar el código que queremos poner en el área de contenido de Plone en:

<metal:content-core fill-slot="content-core">
    ...
</metal:content-core>

Esto pondrá a nuestro código de una sección definida en el main_template llamado “content-core”.

Ahora la plantilla debería tener el siguiente aspecto:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en"
      lang="en"
      metal:use-macro="context/main_template/macros/master"
      i18n:domain="ploneconf.site">
<body>

<metal:content-core fill-slot="content-core">

<table tal:define="talks python:[{'title':'Dexterity for the win!',
                                  'subjects':('content-types', 'dexterity')},
                                 {'title':'Deco is the future',
                                  'subjects':('layout', 'deco')},
                                 {'title':'The State of Plone',
                                  'subjects':('keynote',) },
                                 {'title':'Diazo designs are great',
                                  'subjects':('design', 'diazo', 'xslt')}
                                ]">
    <tr>
        <th>Title</th>
        <th>Topics</th>
    </tr>
    <tr tal:repeat="talk talks">
        <td tal:content="talk/title">A talk</td>
        <td tal:define="subjects talk/subjects">
            <span tal:repeat="subject subjects"
                  tal:replace="subject">
            </span>
        </td>
    </tr>
</table>

</metal:content-core>

</body>
</html>

<metal:block fill-slot="top_slot"
    tal:define="dummy python:request.set('disable_border', 1)" />

<div metal:define-macro="my_macro">
    <p>I can be reused</p>
</div>

<browser:page
  for="*"
  name="ploneconf.site.macros"
  template="templates/macros.pt"
  permission="zope2.View"
  />

<div metal:use-macro="view/context/@@ploneconf.site.macros/my_macro">
    Instead of this the content of the macro will appear...
</div>

Accediendo a Plone desde la plantilla¶

En nuestra plantilla tenemos acceso al objeto de contexto en el que la vista se llama en adelante, la propia browser-views (es decir, todos los métodos de python vamos a poner en el punto de vista más adelante), los objetos request y response y con ellas podemos conseguir casi cualquier cosa.

En las plantillas también podemos acceder a otras browser-views. Algunos de los que existen para facilitar el acceso a los métodos que a menudo necesitamos:

tal:define="context_state context/@@plone_context_state;
            portal_state context/@@plone_portal_state;
            plone_tools context/@@plone_tools;
            plone_view context/@@plone;"

@@plone_context_state

El BrowserView plone.app.layout.globals.context.ContextState tiene métodos útiles que tienen que ver con el objeto de contexto actual como is_default_page

@@plone_portal_state

El BrowserView plone.app.layout.globals.portal.PortalState tiene métodos para el portal como portal_url

@@plone_tools

El BrowserView plone.app.layout.globals.tools.Tools da acceso a las herramientas más importante como el plone_tools/catalog

Estos son muy utilizados y hay muchos más.

Lo que echamos de menos¶

Hay algunas cosas que no nos cubrimos hasta el momento:

tal:condition="exists:expression"

comprueba si existe un objeto o un atributo (rara vez utilizada)

tal:condition="nocall:context"

que explícitamente no llamar a un método invocable.

Si nos referimos a objetos de contenido sin usar el modificador nocall: estos objetos son innecesariamente representados en la memoria como la expresión se evaluada.

i18n:translate y i18n:domain

las cadenas que ponemos en las plantillas se pueden traducir de forma automática.

Hay mucho más acerca de TAL, TALES y METAL que no hemos cubierto. Usted solamente aprenderá si sigues leyendo, escribiendo y personalización de plantillas.

Chameleon¶

Chameleon es el sucesor de TAL y serán incorporado en Plone 5.

• Plip para Chameleon: https://dev.plone.org/ticket/12198

• Página principal: http://www.pagetemplates.org/

• Capa de Integración para Plone: five.pt

En Plone 4 nosotros usaremos ZPT por defecto.

El archivo newsitem.pt¶

Queremos mostrar la fecha de una Noticia se publica. De esta manera la gente puede ver a simple vista que la está mirando es una noticia de actualidad o una noticia antigua.

Para ello vamos a personalizar las plantillas que es utilizanda para representar una Noticia.

Básicamente haremos lo mismo que cuando se utilizó en portal_skins (personalizamos el pie de página), pero ahora vamos a hacerlo todo a mano en nuestro paquete.

• Cree el directorio browser/template_overrides

• Agregue el siguiente en el archivo browser/configure.zcml:

<browser:jbot directory="template_overrides" />

• Para completar, agregue z3c.jbot a las dependencias en el archivo setup.py a la lista install_requires.

• Buscar el archivo plone/app/contenttypes/browser/templates/newsitem.pt en el directorio omelette (en la instalación Vagrant esto esta en /home/vagrant/omelette).

• Cópielo dentro de la nueva carpeta, ejecutando el siguiente comando Linux: cp /home/vagrant/omelette/plone/app/contenttypes/browser/templates/newsitem.pt /vagrant/buildout/src/ploneconf.site/ploneconf/site/browser/template_overrides

• Renombre el nuevo archivo desde newsitem.pt a plone.app.contenttypes.browser.templates.newsitem.pt.

• Reinicie Plone

Ahora Plone debería usar el nuevo archivo sobrescribiendo el original.

Edite la plantilla plone.app.contenttypes.browser.templates.newsitem.pt e inserte el siguiente código antes el <div id="parent-fieldname-text"...:

<p tal:content="python: context.Date()">
    The current Date
</p>

• Abra un existente elemento de Noticia en el navegador Web

Esto mostrara algo como esto: 2013-10-02 19:21:15. No es muy amigable. Vamos a ampliar el código y utilizar una de las muchas funciones helpers que ofrece Plone.

<p tal:define="toLocalizedTime nocall:context/@@plone/toLocalizedTime;
               date python:context.Date()"
   tal:content="python:toLocalizedTime(date)">
        The current Date in its local short-format
</p>

Ahora debería verse la fecha en un formato amigable como 17.02.2013.

• Con nocall: prevenimos que el método toLocalizedTime sea llamado, ya que sólo queremos que esté disponible para su uso.

• El método toLocalizedTime es proveído por la BrowserView Products.CMFPlone.browser.ploneview.Plone y ejecuta el objeto Date (tipo Fecha) a través del translation_service de Plone y regresa la Fecha en el actual formato de locales, así transformando 2013-02-17 19:21:15 en 17.02.2013.

En antigua versiones de Plone nosotros usamos python:context.toLocalizedTime(context.Date(), longFormat=False). Que llamo al script python toLocalizedTime.py en la Carpeta Products/CMFPlone/skins/plone_scripts/.

Esa carpeta plone_scripts todavía tiene una gran cantidad de scripts útiles que son ampliamente utilizados. Pero todos ellos están obsoletos y honestamente se espera retirar en Plone 5 los cuales sean reemplazados por métodos Python adecuados en BrowserViews.

El archivo summary_view.pt¶

Utilizamos la vista “Vista de resumen” a la lista de noticias publicadas. También deben tener la fecha. La plantilla asociada con esa vista es summary_view.pt.

Echemos un vistazo a la plantilla folder_summary_view.pt:

plone/app/contenttypes/browser/templates/summary_view.pt

Cópielo al directorio browser/template_overrides/ y renómbrelo a plone.app.contenttypes.browser.templates.summary_view.pt.

Agregue lo siguiente después de la linea 29:

<p tal:condition="python:item_type == 'News Item'"
   tal:content="python:toLocalizedTime(item.Date())">
        News date
</p>

El método toLocalizedTime ya está definido en la plantilla cuya macro usa esta plantillas. ¿Porqué es eso?

El secreto es la linea del archivo summary_view.pt:

<metal:block use-macro="context/standard_view/macros/entries">

use-macro le dice a Plone reusar el macro entries desde la vista standard_view la cual se encuentra en la plantilla plone/app/contenttypes/browser/templates/standard_view.pt.

Las plantillas summary_view.pt y folder_summary_view.pt (las cuales es lo mismo, pero para las carpetas, no para las colecciones) están muy difundidas y también ampliamente personalizadas, para requisitos particulares, por lo que también podría llegar a conocerlo un poco.

Nuestra adiciones hace que la fecha de los objetos respectivo que las iteraciones de plantilla (por lo tanto item en lugar de context desde context sería la colección de la agregación de las noticias).

La fecha solamente es mostrada si la variable item_type (definida en la linea 42 de la vista standard_view.pt) sea News Item.

Hay mucho más en standard_view.pt y summary_view.pt pero vamos a dejar las cosas así.

Buscando la correcta plantilla¶

Hemos cambiado la pantalla de la lista de elementos de noticias en http://localhost:8080/Plone/news. Pero, ¿cómo sabemos que plantilla para personalizar?

Si usted no sabe con qué plantilla utiliza la página que estás viendo, usted puede hacer una conjetura, iniciar una sesión de depuración o use el paquete plone.app.debugtoolbar para obtener una vista que ofrece información de depuración del actual contexto.

1. Pudimos comprobar el HTML con la herramienta Firebug y buscar una estructura en el área de contenido que parece único. También podríamos buscar la clase CSS del cuerpo

   <body class="template-summary_view portaltype-collection site-Plone section-news subsection-aggregator icons-on userrole-anonymous" dir="ltr">
   

   La clase template-summary_view nos dice que el nombre de la vista (pero no necesariamente el nombre de la plantilla) el cual es summary_view. Así que podríamos buscar en todos los archivos *.zcml la cadena name="summary_view" o buscar todas las plantillas llama summary_view.pt y probablemente encontrar la vista y también la plantilla correspondiente. Pero probablemente sólo porque esa no nos diría si ya está siendo sobrescrita la plantilla.

2. El método es más seguro está usando el paquete plone.app.debugtoolbar. Ya lo tenemos en nuestra configuración buildout definidos y sólo hay que instalarlo. Ese agregue un menú desplegable “Debug” en la parte superior de la página. La sección “Publicado” muestra la ruta completa a la plantilla que se utiliza para representar la página que estás viendo.

3. La sesión de depuración para encontrar la plantilla es un poco más complicado. Entonces tenemos el producto Products.PDBDebugMode en nuestra configuración buildout podemos llamar /pdb desde nuestra página.

   El objeto que las URL apunta por defecto self.context. Pero el primer problema es que la dirección URL que estamos viendo no es la dirección URL de la colección en la que queremos modificar ya que la colección es la página por defecto de la carpeta news.

   >>> (Pdb) self.context
   <Folder at /Plone/news>
   >>> (Pdb) obj = self.context.aggregator
   >>> (Pdb) obj
   <Collection at /Plone/news/aggregator>
   >>> (Pdb) context_state = obj.restrictedTraverse('@@plone_context_state')
   >>> (Pdb) template_id = context_state.view_template_id()
   >>> (Pdb) template_id
   'summary_view'
   >>> (Pdb) view = obj.restrictedTraverse('summary_view')
   >>> (Pdb) view
   <Products.Five.metaclass.SimpleViewClass from /Users/philip/.cache/buildout/eggs/plone.app.contenttypes-1.1b2-py2.7.egg/plone/app/contenttypes/browser/templates/summary_view.pt object at 0x10b00cd90>
   >>> view.index.filename
   u'/Users/philip/workspace/training_without_vagrant/src/ploneconf.site/ploneconf/site/browser/template_overrides/plone.app.contenttypes.browser.templates.summary_view.pt'
   

   Ahora puede ver que nosotros personalizamos la plantilla.

Plantillas skins¶

¿Por qué no siempre sólo utilizamos plantillas? Porque lo que se quiere hacer es algo más complicado que obtener un atributo de formulario en el contexto y hacer su valor en alguna etiqueta HTML.

Es una tecnología obsoleta llamada ‘skin-templates’ que le permite añadir simplemente alguna página en la plantilla (por ejemplo, ‘old_style_template.pt’) a una carpeta determinada en el ZMI o su paquete egg) y se puede acceder a ella en el navegador mediante la dirección URL como esta http://localhost:8080/Plone/old_style_template y se mostrara. Pero nosotros no lo usamos y usted también no hay que a pesar de que estos de las skin-templates siguen siendo todo Plone.

Desde que usamos el paquete plone.app.contenttypes no encontramos nunca más muchas plantillas skin cuando se trata de contenidos. Pero más a menudo que usted no tendrás que personalizar un sitio antiguo que aún utiliza la plantillas skin.

Las plantillas Skins y los script Python están ubicados en la herramienta portal_skin están descontinuados porque:

• ellos son Python restringido

• no tienen buena manera de adjuntar código Python a ellos

• ellos son siempre invocable para todo el mundo (ellos no pueden ser fácilmente unidos a una interfaz)

Vista de clases¶

Anteriormente hemos escrito una vista de demostración que también utilizamos para experimentar con las plantillas de página. Vamos a echar un vistazo a la ZCML y la Page Template de nuevo. Yo he ampliado el código sólo un poco.

El archivo browser/configure.zcml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

<configure xmlns="http://namespaces.zope.org/zope"
    xmlns:browser="http://namespaces.zope.org/browser"
    i18n_domain="ploneconf.site">

    <browser:page
       name="demoview"
       for="*"
       layer="zope.interface.Interface"
       class=".views.DemoView"
       template="templates/demoview.pt"
       permission="zope2.View"
       />

</configure>

El archivo browser/views.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

from Products.Five.browser import BrowserView

class DemoView(BrowserView):
    """ This does nothing so far
    """

    def __init__(self, context, request):
        self.context = context
        self.request = request

    def __call__(self):
        # Implement your own actions

        # This renders the template that was registered in zcml like this:
        #   template="templates/demoview.pt"
        return super(DemoView, self).__call__()
        # If you don't register a template in zcml the Superclass of
        # DemoView will have no __call__-method!
        # In that case you have to call the template like this:
        # from Products.Five.browser.pagetemplatefile import ViewPageTemplateFile
        # class DemoView(BrowserView):
        # template = ViewPageTemplateFile('templates/demoview.pt')
        # def __call__(self):
        #    return self.template()

¿Recuerdas el término MultiAdapter? La browser page es sólo un MultiAdapter. La declaración ZCML browser:page registra un MultiAdapter y agrega cosas adicionales que se necesitan para una browser view.

Un adaptador adapta cosas, un MultiAdapter adapta múltiple cosas.

Al introducir una dirección URL, Zope trata de encontrar un objeto para él. Al final, cuando Zope no encuentra ningún objeto más, pero todavía hay un elemento de ruta, o no hay más elementos de rutas, Zope busca un adaptador que va a responder a la solicitud.

El adaptador se adapta la solicitud y el objeto que Zope ha encontrado con la dirección URL. La clase de adaptador se crea instanciada con los objetos que han de adaptarse, entonces se llama.

El código fuente anterior hace la misma cosa que la implementación estándar haría. Hace que el contexto y la solicitud estén disponibles como variables en el objeto.

Yo he escrito estos métodos porque es importante entender algunos conceptos importantes.

El método init es llamado mientras Zope es todavía esta tratando de encontrar una vista. En esa fase, la seguridad no se ha resuelto. El código no comprueba la seguridad. Por razones históricas, muchos errores que se producen en el método init puede resultar en una página no encuentre el error en lugar de una excepción.

No hagas mucho a todos en el método init. En su lugar usted tiene la garantía que el método call es llamado antes de cualquier otra cosa (excepto el método init). Tiene los controles de seguridad en su lugar y así sucesivamente.

Desde un punto de vista práctico, considere el método call en su método init, la mayor diferencia es que este método debe retornar el HTML listo. Deje a su clase base manejar la generación de HTML.

La vista por defecto¶

Ahora nosotros finalmente agregamos la vista por defecto para las charlas en views.py

El archivo browser/configure.zcml

<browser:page
   name="talkview"
   for="*"
   layer="zope.interface.Interface"
   class=".views.TalkView"
   template="templates/talkview.pt"
   permission="zope2.View"
   />

El archivo browser/views.py

from plone.dexterity.browser.view import DefaultView

...

class TalkView(DefaultView):
    """ The default view for talks
    """

La clase base DefaultView en el paquete plone.dexterity solamente existe para los Objetos Dextertity y tiene algo de gran utilidad a disposición de la plantilla:

• view.w es un diccionario de todos los widgets de pantalla, con clave de nombres de campos. Esto incluye widgets de conjunto de campos alternativos.

• view.widgets contiene una lista de widgets en esquema de ordenar para el conjunto de campos predeterminado.

• view.groups contiene una lista de conjunto de campos con el fin de ordenar conjunto de campo.

• view.fieldsets contiene un nombre de conjunto de campo mapeado un diccionario a conjunto de campo

• En un conjunto de campos (grupo), puede acceder a una lista de widgets para obtener los widgets en ese conjunto de campo

La plantilla templates/talkview.pt usa el patrón view/w/<fieldname>/render para hacer algunos widgets.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en"
    lang="en"
    metal:use-macro="context/main_template/macros/master"
    i18n:domain="ploneconf.site">
<body>
    <metal:content-core fill-slot="content-core">
        <p>Suitable for <em tal:replace="structure view/w/audience/render"></em>
        </p>

        <div tal:content="structure view/w/details/render" />

        <div tal:content="context/speaker">
            User
        </div>
    </metal:content-core>
</body>
</html>

Después de un reinicio, podemos probar nuestra vista, yendo a un tipo de contenido talk agregado y agrégale a la dirección URL /talkview.

Debemos decirle a Plone, que la vista talkview debe ser utilizado como la vista predeterminada para las charlas en lugar de la vista incorporada.

Esta es una configuración que puede cambiar en tiempo de ejecución y se almacena en la base de datos, como tal, también es gestionado por perfiles GenericSetup.

Abra el archivo profiles/default/types/talk.xml:

1
2
3
4
5
6
7

...
<property name="default_view">talkview</property>
<property name="view_methods">
    <element value="talkview"/>
    <element value="view"/>
</property>
...

Vamos a tener que reinstalar nuestro complemento o ejecutar el paso GenericSetup llamado typeinfo entonces Plone aprende sobre el cambio.

También podríamos decirle a Plone sobre esto en el ZMI: http://localhost:8080/Plone/portal_types/talk/manage_propertiesForm

Mejoremos la vista talkview para mostrar toda la información que queremos.

El archivo templates/talkview.pt:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"
      metal:use-macro="context/main_template/macros/master"
      i18n:domain="ploneconf.site">
<body>
    <metal:content-core fill-slot="content-core">

        <p>
            <span tal:content="context/type_of_talk">
                Talk
            </span>
            suitable for
            <span tal:replace="structure view/w/audience/render">
                Audience
            </span>
        </p>

        <div tal:content="structure view/w/details/render">
            Details
        </div>

        <div class="newsImageContainer">
            <img tal:condition="python:getattr(context, 'image', None)"
                 tal:attributes="src string:${context/absolute_url}/@@images/image/thumb" />
        </div>

        <div>
            <a class="email-link" tal:attributes="href string:mailto:${context/email}">
                <strong tal:content="context/speaker">
                    Jane Doe
                </strong>
            </a>
            <div tal:content="structure view/w/speaker_biography/render">
                Biography
            </div>
        </div>

    </metal:content-core>
</body>
</html>

Ejercicio¶

Agregar el nuevo campo “room” con el tipo de contenido Talk (a través de la Web) y mostrarlo debajo del campo Audience en la browser view, debe contener los siguientes datos:

• Título: Room

• Posible valores: Room 101, Room 102, Auditorium

<p>
    <span tal:replace="structure view/w/room/render">
        Room
    </span>
</p>

Usando portal_catalog¶

Digamos que queremos mostrar una lista de todas las charlas que se presentaron durante la conferencia. Sólo podemos ir a la carpeta y seleccione un método de visualización que nos convenga. Pero ninguno lo hace porque queremos para mostrar al público objetivo en nuestro listado.

Así que tenemos que conseguir todas las charlas. Para ello utilizamos la vista de la clase Python para consultar en el catálogo las charlas.

El catálogo es como un motor de búsqueda por el contenido de nuestro sitio. Contiene información sobre todos los objetos, así como algunos de sus atributos como título, descripción, desde estado de flujo de trabajo, palabras clave que fueron etiquetadas, autor, tipo de contenido, su ruta en el sitio, etc. Sin embargo, no se mantiene el contenido de campos “pesado” como imágenes o archivos, campos texto enriquecidos y el campo que acabamos de definir nosotros mismos.

Es la forma más rápida de obtener el contenido que existe en el sitio y hacer algo con él. A partir de los resultados del catálogo podemos conseguir los mismos objetos, pero a menudo no lo necesita, pero sólo las propiedades que los resultados ya tienen.

El archivo browser/configure.zcml

1
2
3
4
5
6
7
8

<browser:page
   name="talklistview"
   for="*"
   layer="zope.interface.Interface"
   class=".views.TalkListView"
   template="templates/talklistview.pt"
   permission="zope2.View"
   />

El archivo browser/views.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

from Products.Five.browser import BrowserView
from plone import api
from plone.dexterity.browser.view import DefaultView


class DemoView(BrowserView):
    """ This does nothing so far
    """


class TalkView(DefaultView):
    """ The default view for talks
    """


class TalkListView(BrowserView):
    """ A list of talks
    """

    def talks(self):
        results = []
        portal_catalog = api.portal.get_tool('portal_catalog')
        current_path = "/".join(self.context.getPhysicalPath())

        brains = portal_catalog(portal_type="talk",
                                path=current_path)
        for brain in brains:
            talk = brain.getObject()
            results.append({
                'title': brain.Title,
                'description': brain.Description,
                'url': brain.getURL(),
                'audience': ', '.join(talk.audience),
                'type_of_talk': talk.type_of_talk,
                'speaker': talk.speaker,
                'uuid': brain.UID,
                })
        return results

Nosotros consultamos el catálogo para dos cosas:

• portal_type = "talk"
• path = "/".join(self.context.getPhysicalPath())

Obtenemos la ruta del contexto actual para consultar sólo para los objetos en la ruta actual. De lo contrario íbamos a obtener todas las charlas en todo el sitio. Si nos trasladamos algunas charlas a una parte diferente del sitio (por ejemplo, un sub-conferencia para universidades con una especial lista charla) puede ser que no quiera ver así en nuestra lista.

Nosotros iteramos sobre la lista de resultados que el catálogo nos devuelve.

Creamos un diccionario que contiene toda la información que queremos mostrar en la plantilla. De esta manera no tiene que poner ninguna lógica compleja en la plantilla.

Cerebros y objetos¶

Los objetos normalmente no se cargan en la memoria, pero permanecen latentes en el base de datos ZODB. Despertar objetos hasta puede ser lento, especialmente si usted está despertando una gran cantidad de objetos. Afortunadamente nuestros tipos de contenidos no son especialmente pesados, ya que son:

• objetos dexterity que son más ligeros que sus hermanos archetypes

• relativamente pocos, ya que no tenemos miles de charlas en nuestra conferencia

Queremos mostrar la audiencia destinada de la charla, pero esos atributos de las charlas no está en el catálogo. Esto es por qué necesitamos llegar a los objetos mismos.

También podríamos agregar un nuevo índice al catálogo que agregará ‘audience’ a las propiedades de los cerebros. Tenemos que ponderar los pros y contras:

• charlas son importantes y por lo tanto más probable es que siempre este en memoria

• prevenir la inflamación del catálogo con índices

from plone.indexer.decorator import indexer
from ploneconf.site.talk import ITalk

@indexer(ITalk)
def talk_audience(object, **kw):
     return object.audience

<adapter name="audience" factory=".indexers.talk_audience" />

¿Por qué utilizar el catálogo en absoluto?, comprueba los permisos, y sólo devuelve las charlas que el usuario actual puede ver. Puede ser que sean privados u ocultos a usted, ya que son parte de una súper conferencia secreta para los desarrolladores del núcleo de Plone (¡no hay tal cosa!).

La mayoría de los objetos en Plone son como diccionarios, por lo que podían hacer context.values() para obtener todos sus contenidos.

Por razones históricas, algunos atributos de los cerebros y los objetos se escriben de manera diferente:

>>> obj = brain.getObject()

>>> obj.title
u'Talk-submission is open!'

>>> brain.Title == obj.title
True

>>> brain.title == obj.title
False

¿Quién puede adivinar lo que brain.title volverán ya que el cerebro no tiene ese atributo?

La Adquisición puede ser nocivo. Los cerebros no tienen el atributo ‘getLayout’ brain.getLayout():

>>> brain.getLayout()
'folder_listing'

>>> obj.getLayout()
'newsitem_view'

>>> brain.getLayout
<bound method PloneSite.getLayout of <PloneSite at /Plone>>

Lo mismo es cierto para los métodos:

>>> obj.absolute_url()
'http://localhost:8080/Plone/news/talk-submission-is-open'
>>> brain.getURL() == obj.absolute_url()
True
>>> brain.getPath() == '/'.join(obj.getPhysicalPath())
True

Consultando el catálogo¶

Hay muchos índices de catálogo para consultar. He aquí algunos ejemplos:

>>> portal_catalog = getToolByName(self.context, 'portal_catalog')
>>> portal_catalog(Subject=('cats', 'dogs'))
[]
>>> portal_catalog(review_state='pending')
[]

Llamando al catálogo sin parámetros devuelven todo el sitio:

>>> portal_catalog()
[<Products.ZCatalog.Catalog.mybrains object at 0x1085a11f0>, <Products.ZCatalog.Catalog.mybrains object at 0x1085a12c0>, <Products.ZCatalog.Catalog.mybrains object at 0x1085a1328>, <Products.ZCatalog.Catalog.mybrains object at 0x1085a13 ...

Ejercicios¶

Ya que ahora saben cómo consultar el catálogo es el momento para un poco de ejercicio.

1
2
3
4
5
6
7
8

def get_news(self):

    portal_catalog = api.portal.get_tool('portal_catalog')
    return portal_catalog(
        portal_type='News Item',
        review_state='published',
        sort_on='effective',
    )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

def keynotes(self):

    portal_catalog = api.portal.get_tool('portal_catalog')
    brains = portal_catalog(
        portal_type='Talk',
        review_state='published')
    results = []
    for brain in brains:
        # There is no catalog-index for type_of_talk so we must check
        # the objects themselves.
        talk = brain.getObject()
        if talk.type_of_talk == 'Keynote':
            results.append(talk)
    return results

La plantilla para la lista¶

A continuación, crear una plantilla en la usa los resultados del método ‘talks’.

Trate de mantener la lógica mayormente en Python. Esto es por dos razones:

Legibilidad:

Es mucho más fácil de leer Python que complejas estructuras de TAL.

Velocidad:

El código Python es más rápido que el código ejecutado en las plantillas. También es fácil de añadir almacenamiento en caché a los métodos.

Don’t Repeat Yourself (DRY):

En Python se puede volver a utilizar métodos y refactorizar código fácilmente. Refactorizando TAL generalmente significa tener que hacer grandes cambios en la estructura HTML que se traduce en diffs incomprensible.

El esquema MVC no se aplica directamente a Plone pero míralo de esta manera:

Modelo:

el objeto

Vista:

la plantilla

Controlador:

la vista

La vista y el controlador están muy mezclados en Plone. Especialmente cuando nos fijamos en algunos de los códigos más antiguos de Plone verás que la política de mantener la lógica en Python y representación en las plantillas no siempre se cumple.

¡Pero usted debe, no obstante, que lo haga! Usted va a terminar con más que suficiente lógica en las plantillas de todos modos.

Agregar esta sencilla tabla al archivo templates/talklistview.pt:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

<table class="listing">
    <thead>
        <tr>
            <th>
                Title
            </th>
            <th>
                Speaker
            </th>
            <th>
                Audience
            </th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>
               The 7 sins of plone-development
            </td>
            <td>
                Philip Bauer
            </td>
            <td>
                Advanced
            </td>
        </tr>
    </tbody>
</table>

Después usted lo transforma dentro de una lista:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

<table class="listing" id="talks">
    <thead>
        <tr>
            <th>
                Title
            </th>
            <th>
                Speaker
            </th>
            <th>
                Audience
            </th>
        </tr>
    </thead>
    <tbody>
        <tr tal:repeat="talk view/talks">
            <td>
                <a href=""
                   tal:attributes="href talk/url;
                                   title talk/description"
                   tal:content="talk/title">
                   The 7 sins of plone-development
                </a>
            </td>
            <td tal:content="talk/speaker">
                Philip Bauer
            </td>
            <td tal:content="talk/audience">
                Advanced
            </td>
        </tr>
        <tr tal:condition="not:view/talks">
            <td colspan=3>
                No talks so far :-(
            </td>
        </tr>
    </tbody>
</table>

Hay algunas cosas que necesitan explicación:

tal:repeat="talk view/talks"

Este itera sobre la lista de diccionarios devueltos por la vista. La vista view/talks llama al método talks de nuestro vista y cada talk es a su vez regresa uno de los diccionarios que son devueltos por este método. Desde las expresiones de ruta TAL para la búsqueda de los valores en los diccionarios es la misma que los atributos de los objetos se puede escribir talk/somekey como pudimos view/somemethod. Práctico, pero a veces irritante ya de mirar la page template solos a menudo no tenemos forma de saber si algo es un atributo, un método o el valor de un diccionario. Sería una buena práctica para escribir tal:repeat="talk python:view.talks()".

tal:content="talk/speaker"

‘speaker’ es una clave en el diccionario ‘talk’. También podríamos escribir tal:content="python:talk['speaker']"

tal:condition="not:view/talks"

Esta es una alternativa en caso de no se devuelven las charlas. A continuación, devolver una lista vacía (¿recuerda results = []?)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

<table class="listing" id="talks">
    <thead>
        <tr>
            <th>
                Title
            </th>
            <th>
                Speaker
            </th>
            <th>
                Audience
            </th>
        </tr>
    </thead>
    <tbody tal:define="talks python:view.talks()">
        <tr tal:repeat="talk talks">
            <td>
                <a href=""
                   tal:attributes="href python:talk['url'];
                                   title python:talk['description']"
                   tal:content="python:talk['title']">
                   The 7 sins of plone-development
                </a>
            </td>
            <td tal:content="python:talk['speaker']">
                Philip Bauer
            </td>
            <td tal:content="python:talk['audience']">
                Advanced
            </td>
        </tr>
        <tr tal:condition="python:not talks">
            <td colspan=3>
                No talks so far :-(
            </td>
        </tr>
    </tbody>
</table>

Configuración de una vista personalizada como vista por defecto en un objeto¶

No queremos tener siempre que a anexar /@@talklistview a nuestra carpeta para obtener la vista. Hay una manera muy fácil de configurar la vista de la carpeta con el ZMI.

Si agregamos /manage_propertiesForm podemos establecer la propiedad “layout” para la vista talklistview.

Para hacer vistas configurables para que los editores pueden elegir entonces tenemos que registrar la vista para el tipo de contenido que nos ocupa, en que es FTI. Para activar si todas las carpetas tiene esta vista se añade un nuevo archivo profiles/default/types/Folder.xml

1
2
3
4
5
6
7

<?xml version="1.0"?>
<object name="Folder">
 <property name="view_methods" purge="False">
  <element value="talklistview"/>
 </property>
  <alias from="@@talklistview" to="talklistview"/>
</object>

Después de volver a aplicar el perfil typeinfo del complemento (o, simplemente, volver a instalarlo) el tipo de contenido “Carpeta” se amplía con nuestro método de vista adicional y aparece en la lista desplegable Mostrar.

La opción purge="False" anexa a la vista de los ya existentes en lugar de reemplazarlos.

Agregando un poco de Javascript (collective.js.datatables)¶

Aquí se utiliza una de las muchas agradables característica construida en Plone. La class=”listing” da la tabla un buen estilo y hace que la tabla se puede ordenar con un poco de Javascript.

Pero podríamos mejorar esa tabla aún más mediante el uso de una buena librería Javascript llamada “datatables”. Incluso podría llegar a ser parte del core de Plone en algún momento.

Al igual que para muchas librerías Javascript, ya hay un paquete que hace la integración de Plone por nosotros: collective.js.datatables. Al igual que todos los paquetes Python usted lo puede encontrar en PYPI: https://pypi.python.org/pypi/collective.js.datatables

Ya hemos añadido el complemento a nuestra buildout, sólo tienes que activarlo en nuestra plantilla.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"
      metal:use-macro="context/main_template/macros/master"
      i18n:domain="ploneconf.site">
<body>

<metal:head fill-slot="javascript_head_slot">
    <link rel="stylesheet" type="text/css" media="screen" href="++resource++jquery.datatables/media/css/jquery.dataTables.css">

    <script type="text/javascript" src="++resource++jquery.datatables.js"></script>
    <script type="text/javascript">
        $(document).ready(function(){
            var oTable = $('#talks').dataTable({
            });
        })
    </script>
</metal:head>

<metal:content-core fill-slot="content-core">

    <table class="listing" id="talks">
        <thead>
            <tr>
                <th>
                    Title
                </th>
                <th>
                    Speaker
                </th>
                <th>
                    Audience
                </th>
            </tr>
        </thead>
        <tbody>
            <tr tal:repeat="talk view/talks">
                <td>
                    <a href=""
                       tal:attributes="href talk/url;
                                       title talk/description"
                       tal:content="talk/title">
                       The 7 sins of plone-development
                    </a>
                </td>
                <td tal:content="talk/speaker">
                    Philip Bauer
                </td>
                <td tal:content="talk/audience">
                    Advanced
                </td>
            </tr>
            <tr tal:condition="not:view/talks">
                <td colspan=3>
                    No talks so far :-(
                </td>
            </tr>
        </tbody>
    </table>

</metal:content-core>
</body>
</html>

Nosotros no necesitamos la clase CSS listing nunca más, ya que podría entrar en conflicto con la librería datatables (no es así, pero aún así ...).

La documentación de la librería datatables está más allá de nuestro entrenamiento.

Utilizamos METAL de nuevo pero esta vez para llenar un slot diferente. El “javascript_head_slot” es parte de área <head> del HTML en Plone y se puede ampliar de esta manera. También podríamos simplemente poner el código fuente en línea, pero con HTML muy bien ordenado es una buena práctica.

Hagamos una prueba con la siguiente dirección URL: http://localhost:8080/Plone/talklistview

Resumen¶

Hemos creado un bonito listado, que se puede llamar en cualquier lugar en el sitio web.

Enfoque Dexterity¶

Dexterity tiene una solución para ello, con adaptadores especiales los cuales se llaman y registran por el nombre del comportamiento.

Un comportamiento puede ser agregado a cualquier tipo de contenido a través de la Web y durante el tiempo de ejecución.

Todas las vistas predeterminadas deben conocer el concepto de comportamientos y cuando renderizar los formularios, las vistas también comprueban si hay comportamientos referenciados con el contexto actual y si estos comportamientos tienen un esquema propio, esos campos se mostraran adicionalmente.

Nombres y Teoría¶

El nombre del comportamiento no es un término estándar en el desarrollo de software. Pero es una buena idea pensar en un comportamiento como un aspecto. Usted está agregando un aspecto a tu tipo de contenido y usted quiere escribir su aspecto de tal manera, que funciona independientemente del tipo de contenido en el que se aplica el aspecto. Usted no debe tener dependencias a campos específicos de su objeto o de otros comportamientos.

Como un objeto le permite aplicar el principio Abierto/cerrado a los objetos de Dexterity.

Ejemplo práctico¶

Así que, vamos a escribir nuestro propio pequeño comportamiento.

En el futuro, queremos que nuestra presentación este representada también en Lanyrd (un Directorio Conferencia Social - Lanyrd.com). Por ahora nos limitaremos a ofrecer un enlace para que los visitantes puedan colaborar fácilmente con el sitio Lanyrd.

Así que por ahora, nuestro comportamiento sólo añade un nuevo campo para almacenar la dirección URL del servicio Lanyrd.

Queremos mantener una estructura limpia, así que creamos primero un directorio llamado behaviors, y luego lo incluimos dentro de las declaraciones ZCML de nuestro archivo configure.zcml.

<include package=".behaviors" />

Entonces, agregamos un archivo vació behaviors/__init__.py y un archivo behaviors/configure.zcml conteniendo el siguiente código:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

<configure
    xmlns="http://namespaces.zope.org/zope"
    xmlns:plone="http://namespaces.plone.org/plone"
    i18n_domain="ploneconf.site">

  <plone:behavior
      title="Social Behavior"
      description="Adds a link to lanyrd"
      provides=".social.ISocial"
      />

</configure>

Y un archivo behaviors/social.py conteniendo el siguiente código:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

from plone.supermodel import model, directives
from plone.autoform.interfaces import IFormFieldProvider
from zope import schema
from zope.interface import alsoProvides


class ISocial(model.Schema):

    directives.fieldset(
        'social',
        label=u'Social',
        fields=('lanyrd',),
    )

    lanyrd = schema.URI(
        title=u"Lanyrd-link",
        description=u"Add URL",
        required=False,
    )

alsoProvides(ISocial, IFormFieldProvider)

Vamos a llevarlo a través de este paso a paso.

1. Registramos un comportamiento en el archivo behaviors/configure.zcml. Nosotros decimos para qué tipo de contenido este comportamiento es válido. Para hacer esto, a través de la Web o en el perfil GenericSetup.

2. Creamos una interfaz marker en behaviors/social.py para nuestro comportamiento y hacerlo también un esquema el cual contiene los campos que queremos declarar. Podríamos simplemente utilizar definiciones de campos de esquema en una clase zope.interface, pero utilizaremos un formulario extendido desde el paquete plone.supermodel, de lo contrario nosotros podríamos no usar las características del conjunto de campos.

3. También añadimos un fieldset para que nuestros campos no se mezclen con los campos normales del objeto.

4. Añadimos un campo de esquema URI normal para almacenar la dirección URI del servicio Lanyrd.

5. Nosotros marcamos nuestro esquema como una clase que también implementa la interfaz IFormFieldProvider. Se trata de una interfaz marker, nosotros no necesitamos implementar nada para proporcionar la interfaz.

Agregándolo a nuestra Talk¶

Podríamos añadir este comportamiento ahora a través del panel de control de Plone llamado Tipos de contenidos Dexterity. Pero en cambio, lo haremos directamente de forma apropiada en nuestro perfil GenericSetup

Debemos agregar el comportamiento al archivo profiles/default/types/talk.xml:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

<?xml version="1.0"?>
<object name="talk" meta_type="Dexterity FTI" i18n:domain="plone"
   xmlns:i18n="http://xml.zope.org/namespaces/i18n">
   ...
 <property name="behaviors">
  <element value="plone.app.dexterity.behaviors.metadata.IDublinCore"/>
  <element value="plone.app.content.interfaces.INameFromTitle"/>
  <element value="ploneconf.site.behaviors.social.ISocial"/>
 </property>
 ...
</object>

Un viewlet para el comportamiento social¶

Un viewlet no es una vista, pero es un fragmento de HTML y la lógica Python que se puede colocar en varios lugares en el sitio. Estos lugares se llaman ViewletManager.

• Inspeccione y administre los viewlets existentes yendo a la dirección URL http://localhost:8080/Plone/@@manage-viewlets.

• Ya hemos personalizado un viewlet (el archivo collophon.pt). Ahora agregamos un nuevo viewlet.

• Los viewlets no guardan los datos (los portlets si lo hacen).

• Los viewlets no tienen interfaz de usuario (los portlets lo hacen).

El viewlet social-viewlet¶

Vamos a añadir un enlace al sitio que utiliza la información que hemos recopilado utilizando el comportamiento social.

Registramos el viewlet en el archivo browser/configure.zcml, agregando el siguiente código ZCML:

1
2
3
4
5
6
7
8
9

<browser:viewlet
  name="social"
  for="ploneconf.site.behaviors.social.ISocial"
  manager="plone.app.layout.viewlets.interfaces.IBelowContentTitle"
  class=".viewlets.SocialViewlet"
  layer="zope.interface.Interface"
  template="templates/social_viewlet.pt"
  permission="zope2.View"
  />

Esto registra un viewlet llamado social. Es visible en todos los contenidos que implementa la interfaz ISocial de nuestro comportamiento. También es una buena práctica de obligar a la BrowserLayer llamada IPloneconfSiteLayer de nuestro complemento para que sólo sea mostrado si nuestro complemento esta instalado en realidad.

La clase viewlet SocialViewlet se espera en un archivo browser/viewlets.py, agregando el siguiente código Python:

1
2
3
4

from plone.app.layout.viewlets import ViewletBase

class SocialViewlet(ViewletBase):
    pass

Esta clase no hace nada excepto hacer que la plantilla asociada (Esa tenemos aún que escribirla)

1
2
3
4
5
6

from five import grok
from plone.app.layout.viewlets import interfaces as viewletIFs
from zope.component import Interface

class SocialViewlet(grok.Viewlet):
    grok.viewletmanager(viewletIFs.IBelowContentTitle)

Vamos a agregar el archivo de la plantilla restante templates/social_viewlet.pt.

1
2
3
4
5
6
7
8
9

<div id="social-links">
    <a href="#"
       class="lanyrd-link"
       tal:define="link view/lanyrd_link"
       tal:condition="link"
       tal:attributes="href link">
         See this talk on Lanyrd!
    </a>
</div>

Como se puede ver esto no es un documento válido HTML. Eso no es necesario, porque no queremos una view completa aquí, sólo un fragmento de código HTML.

Hay una sentencia tal:define, para la consulta view/lanyrd_link. Al igual en la page templates de la plantilla tiene acceso a su clase.

Entonces, ahora tenemos que ampliar el Viewlet Social para añadir el atributo que le falta, agregando el siguiente código Python:

1
2
3
4
5
6
7
8

from plone.app.layout.viewlets import ViewletBase
from ploneconf.site.behaviors.social import ISocial

class SocialViewlet(ViewletBase):

    def lanyrd_link(self):
        adapted = ISocial(self.context)
        return adapted.lanyrd

Hasta ahora, hemos hecho:

• Registrar el viewlet al contenido que tiene la interfaz ISocial.

• Adaptar el objeto a su comportamiento para ser capaz de acceder a los campos del comportamiento.

• Devolver el enlace.

Ejercicio 1¶

Registrar una viewlet number_of_talks en el pie de página que es visible sólo para los administradores del sitio (el permiso que usted busca es cmf.ManagePortal). Utilice sólo una plantilla (sin clase) para mostrar el número de charlas ya enviadas. Sugerencia: Utilice Aquisition para obtener al catálogo (Usted sabe, no debe hacer esto, pero hay un montón de código por ahí que lo hace...)

<browser:viewlet
  name="number_of_talks"
  for="*"
  manager="plone.app.layout.viewlets.interfaces.IPortalFooter"
  layer="zope.interface.Interface"
  template="templates/number_of_talks.pt"
  permission="cmf.ManagePortal"
  />

<div class="number_of_talks"
     tal:define="catalog python:context.portal_catalog;
                 talks python:len(catalog(portal_type='talk'));">
    There are <span tal:replace="talks" /> talks.
</div>

<div class="number_of_talks"
     tal:define="catalog context/@@plone_tools/catalog;
                 talks python:len(catalog(portal_type='talk'));">
    There are <span tal:replace="talks" /> talks.
</div>

<div class="number_of_talks"
     tal:define="catalog python:context.restrictedTraverse('plone_tools').catalog();
                 talks python:len(catalog(portal_type='talk'));">
    There are <span tal:replace="talks" /> talks.
</div>

Ejercicio 2¶

Registrar una viewlet days_to_conference en la cabecera. Utilice una clase y una plantilla para mostrar el número de días hasta la conferencia. Usted consigue muchos puntos de bonificación si se muestra en un formato agradable (pensar “En 2 días” y “Último mes”) utilizando un Javascript existentes o biblioteca Python.

plone.api¶

La herramienta mas importante actualmente para desarrolladores Plone es el complemento plone.api , el cual cubre el 20% de las tareas que cualquier desarrollador Plone que normalmente hace en 80% de su tiempo. Si no estas seguro de como manejar alguna tarea, verifica primero si plone.api tiene una solución para ti.

El api esta divido en 5 secciones. Este es un ejemplo de cada uno:

• Contenido: Crear contenido

• Portal: Enviar E-Mail

• Grupos: Asignar roles al grupo

• Usuarios: Obtener roles de usuario

• Entorno: Cambiar roles dentro de un bloque

plone.api aun no es parte del núcleo de Plone, Por lo tanto, no veras ningún uso de plone.api dentro de Plone. Pero estamos seguros que sera parte de Plone.

En el código existente, a veces encontraras métodos que no significan nada para usted. Usted tiene que usar la fuente para averiguar que hacen.

Algunos de estos siguientes métodos serán reemplazados por plone.api en el futuro:

• Products.CMFCore.utils.getToolByName -> api.portal.get_tool
• zope.component.getMultiAdapter -> api.content.get_view

Herramientas del portal¶

Algunas partes de Plone son módulos muy complejos entre si (ej. el blanco mecanismo de versionado de Products.CMFEditions). Algunos de ellos tienen una api que usted aprenderá a usar tarde o temprano.

Aquí tienes unos ejemplos:

portal_catalog

unrestrictedSearchResults() regresa los resultados de búsqueda sin verificar si el usuario actual tiene permiso de acceso a los objetos.

uniqueValuesFor() regresa todas las entradas en un índice

portal_setup

runAllExportSteps() genera un archivo comprimido en formato Tar conteniendo los artefactos de todos los pasos de exportación.

portal_quickinstaller

isProductInstalled() verifica si un producto esta instalado.

Usualmente la mejor forma para aprender acerca de la herramienta de un api es mirando en el archivo interfaces.py en el respectivo paquete y leer la documentación incluida en formato docstrings.

Depurando¶

Aquí hay algunas herramientas y técnicas que usamos frecuentemente cuando desarrollamos y depuramos. Usamos algunas de ellas en varias situaciones durante el entrenamiento.

Rastreos y el registro

El log (y la consola cuando ejecutamos en modo foreground) recolecta todos los mensajes de log que Plone imprime. Cuando ocurre una excepción Plone lanza un rastreo. La mayoría del tiempo el rastreo es todo lo que necesitas para averiguar que esta sucediendo. También agregar tu propia información de rastreo al log es muy simple.

pdb

El depurador de Python pdb, es la herramienta simple mas importante para nosotros cuando programemos. ¡Solo agrega import pdb; pdb.set_trace() en tu código y empieza a depurar!

ipdb

Mejorar pdb con el poder de IPython, por ejemplo, la implementación del tabulador, resaltado de sintaxis, mejores rastreos y la introspección. También funciona muy bien con el complemento Products.PDBDebugMode.

Products.PDBDebugMode

Un complemento que tiene dos características esenciales para su uso.

Post-mortem debugging: le lanza en un pdb cuando ocurra una excepción. de esta forma puedes averiguar que es lo que esta mal.

pdb-view: simplemente agregando /pdb a una dirección URL, le lanza a una sesión pdb con el contexto actual como self.context. De allí puedes hacer casi todo.

Modo Depuración

Cuando se inicia Plone usando el comando ./bin/instance debug -O Plone usted terminara en una sesión de comando del depurador Interactivo.

plone.app.debugtoolbar

Un complemento que permite inspeccionar todo muy cercanamente. Incluso tiene una consola interactiva y un probador para expresiones TALES.

plone.reload

Un complemento que permite recargar el código que has cambiado sin reiniciar el sitio. Esto es también es usado por el complemento plone.app.debugtoolbar.

Products.PrintingMailHost

Un complemento que previene a Plone enviar mensajes. Los mensajes son registrados como eventos en el log del servicio.

Products.Ienablesettrace

Complemento que permite usar pdb y ipdb en scripts python skin. Eso es muy útil.

verbose-security = on

Una opción para la receta plone.recipe.zope2instance que hace a los logs de las razones detalladas sobre por que un usuario no puede ser autorizado a ver algo.

./bin/buildout annotate

Una opción que cuando se ejecute buildout realiza un log de los paquetes traídos y sus versiones.

Sentry

Sentry es una aplicación de log de errores que puede usar usted mismo. Agrega rastreos de muchas fuentes y (aquí viene la característica esencial para su uso) incluso los valores de las variables en el Stack trace. Lo usamos en todos nuestro sitios en producción.

zopepy

Buildout puede crear un shell script de Python para ti que tiene los paquetes de su sitio Plone en su PYTHONPATH. Puede agrega la parte Buildout a la suya con la siguiente configuración:

[zopepy]
recipe = zc.recipe.egg
eggs = ${instance:eggs}
interpreter = zopepy

Agregar una interfaz marker para el tipo de contenido talk¶

1
2
3
4
5
6

from zope.interface import Interface


class ITalk(Interface):
    """Marker interface for Talks
    """

<plone:behavior
  title="Talk"
  description="Marker interface for talks to be able to bind views to."
  provides="..interfaces.ITalk"
  />

1
2
3
4
5
6

<property name="behaviors">
 <element value="plone.app.dexterity.behaviors.metadata.IDublinCore"/>
 <element value="plone.app.content.interfaces.INameFromTitle"/>
 <element value="ploneconf.site.behaviors.social.ISocial"/>
 <element value="ploneconf.site.interfaces.ITalk"/>
</property>

<browser:page
  name="talkview"
  for="ploneconf.site.interfaces.ITalk"
  layer="zope.interface.Interface"
  class=".views.TalkView"
  template="templates/talkview.pt"
  permission="zope2.View"
  />