Tech stuff by MrTango

ES6 (vanilla Javascript) replacements for jQuery

2025-07-28T00:00:00+03:00

In jQuery one hase a lot of helpful methods. This is a list of vanilla Javascript way's to do the same without jQuery.

Loading Page HTML Fragments

jQuery

In jQuery one can use the load function to load a HTML fraction via Ajax.

$( "#result" ).load( "ajax/test.html #container" );

ES6

In plain JavaScript this could be done as follow.

function selectFragment(selector, html) {
    let df = document.createDocumentFragment();
    let tmpDiv = document.createElement('div');
    tmpDiv.innerHTML = html;
    df.appendChild(tmpDiv);
    return df.querySelector(selector);
}

const url = "ajax/test.html";
const response = await fetch(url, { method: "GET" });
const responseHtml = await response.text();
const contentHtml = selectFragment("#container", responseHtml);
let target = document.querySelector("#result");
target.innerHTML = contentHtml.innerHTML;

Document Ready

jQuery

$(document).ready(function() {
    console.log("DOM fully loaded and parsed");
});

ES6

document.addEventListener("DOMContentLoaded", (event) => {
    console.log("DOM fully loaded and parsed");
});

Install Plone 6 classic UI with PDM

2024-07-31T00:00:00+03:00

PDM is a modern Python package manager, which can install Plone and it's dependencies and keep it consistent. I have setup an example repository everyone can use to setup Plone with PDM. It supports both simple standalone and RelStorage setups.

checkout this repository like this:

git clone https://github.com/collective/plone-classicui-pdm-installer.git plone6classicui
cd plone6classicui

creating a venv:

python3.11 -m venv venv

installing PDM with pip:

./venv/bin/pip install pdm

add needed Plone Add-on's in the pyproject.toml:

dependencies = [
    "Products.CMFPlone>=6.0.4",
    "plone.app.caching",
    "plone.app.iterate",
    "plone.app.upgrade",
    "Products.CMFPlacefulWorkflow",
    ### only needed when using relstorage
    "relstorage",
    "psycopg2",
    ###
    "collective.easyform",
    "plone.gallery",
    "collective.collectionfilter",
]

Install Plone and all dependencies:

./venv/bin/pdm install

Standalone setup

Create a Zope instance:

./venv/bin/pdm run create_instance

Adjust the instance port in instance1/etc/zope.ini

[server:main]
use = egg:waitress#main
host = 127.0.0.1
port = 8080

RelStorage setup

Alternatively you can also create a RelStorage setup like this:

./venv/bin/pdm run create_relstorage_instance

Adjust the data base connection string in instance1/etc/zope.conf:

<zodb_db main>
    <relstorage>
    blob-dir $INSTANCE/var/blobstorage
    <postgresql>
        dsn dbname='my_plone_database' user='my_plone_db_user' host='localhost' password='SECRET'
    </postgresql>
    </relstorage>
mount-point /
</zodb_db>

Start the instance

./venv/bin/pdm run start_instance

In production you want to add this to something like supervisor or a systemd script.

Plone: Restrict subscriber to Plone sides where the addon is enabled

2023-08-18T00:00:00+03:00

Since subscribers and adapters are not allowing us to define a browser layer in the registration, like browser views do, we have to find another way, to make sure our subscribe only effects the Plone side where we enable the addon.

Let's define the code for the event subscriber.

from ../interfaces import IAddonBrowserLayer

def handler(event):
    """ Event handler
    """
    if not IAddonBrowserLayer.providedBy(event.object.REQUEST):
        return

    # handle your event here

Here we exist the subscriber when ever the current request, does not have the needed Browser Layer attached.

Now let's register this function for the Plone PrincipalCreatedEvent event, in our configure.zcml.

<subscriber
    for="* Products.PluggableAuthService.interfaces.events.IPrincipalCreatedEvent"
    handler=".user_added.handler"
    />

Realizing an optgroup-Tag based selection in Plone, by using TreeVocabularies

2023-05-23T00:00:00+03:00

Optgroup tags in selections are a good way of grouping items of a selection list. In Plone you can archive this by using a TreeVocabulary with a SelectionWidget.

What we want to archive is something like this:

In a Dexterity content type, you could do the following:

from plone.app.z3cform.widget import SelectFieldWidget
from plone.autoform import directives
from plone.dexterity.content import Item
from plone.supermodel import model
from pprint import pprint
from zope import schema
from zope.interface import implementer
from zope.schema.vocabulary import TreeVocabulary

import pycountry


def available_things_factory():
    terms = {}
    for country in pycountry.countries:
        subdivs = pycountry.subdivisions.get(country_code=country.alpha_2)
        terms[(country.alpha_2, country.name)] = {}
        for subdiv in subdivs:
            terms[(country.alpha_2, country.name)][(subdiv.code, subdiv.code, f"{subdiv.name}")] = {}
    pprint(terms)
    return TreeVocabulary.fromDict(terms)


class ITodoTask(model.Schema):
    """Marker interface and Dexterity Python Schema for TodoTask"""

    directives.widget(country=SelectFieldWidget)
    country = schema.Choice(
        required=True,
        title=u"Country",
        vocabulary=available_things_factory(),
    )


@implementer(ITodoTask)
class TodoTask(Item):
    """Content-type class for ITodoTask"""

Here we are using the pycountry module to get some example data we can nest. We are iterating over all Countries and nest the Subdivision of each Country in it.

Building multi column add/edit forms for DX Content Types in Plone

2023-04-26T00:00:00+03:00

Edit and Add forms in Plone are usually auto generated from a list of defined fields and fieldsets. With CSS Grid it is today easy to build multi column forms and views for them.

We can define each fieldset of our forms as a CSS grid and define our columns.

The following CSS is defining a grid with 4 columns of equal width and a gap of 0.5em between them. For the legend we enforce a span over of all 4 columns.

body.template-view #portal-column-content #content-core fieldset,
body.template-edit #portal-column-content #content-core fieldset,
body.viewpermission-add-portal-content #portal-column-content #content-core fieldset{
    display: grid;
    gap: 0.5em;
    grid-template-columns: 1fr 1fr 1fr 1fr;
    grid-auto-flow: row;
}

body.template-view #portal-column-content #content-core legend,
body.template-edit #portal-column-content #content-core legend,
body.viewpermission-add-portal-content #portal-column-content #content-core legend{
    grid-column: 1 / span 4;
}

Now lets make sure that the text field is spanning over 4 columns too.

body.template-view #portal-column-content #content-core #formfield-form-widgets-text,
body.template-edit #portal-column-content #content-core #formfield-form-widgets-text,
body.viewpermission-add-portal-content #portal-column-content #content-core #formfield-form-widgets-text{
    grid-column: 1 / span 4;
}

we can not only define the span of a field, but also the position in the columns and rows. Let's say we want the description field show under the rich text field. We can set this with grid-row. As the title and done fields are in row 1 and the text field spans over 4 columns and is taking row 2, we have to move the description field into row 3.

Inspecting CSS Grid

body.template-view #portal-column-content #content-core #formfield-form-widgets-IBasic-description,
body.template-edit #portal-column-content #content-core #formfield-form-widgets-IBasic-description,
body.viewpermission-add-portal-content #portal-column-content #content-core #formfield-form-widgets-IBasic-description{
    grid-column: 1 / span 2;
    grid-rowpd2023-grid-columns.pngw: 3 / span 1;
}

Define registry settings for Plone 5 and Plone 6 in your add-on

2023-02-16T00:00:00+02:00

Since Plone 6 moved a lot of settings from Products.CMFPlone to plone.base, the registry settings between Plone 5 and 6 are differ a bit. I'm showing you how to register settings for both major Plone versions.

To archive this, we need to separate the registry settings from our default profile. We instead use a profile for Plone 5 and 6 each which different registry settings..

post_install hook method

The following configure.zcml entries define a default profile and our two new profiles for plone5 or plone6. The profiles have the same name, but only one is actually registered at a time, depending on the zcml:condition="have plone-5" or zcml:condition="have plone-6".

<genericsetup:registerProfile
    name="default"
    directory="profiles/default"
    title="collective.resourcebooking"
    description="Installs the collective.resourcebooking add-on."
    provides="Products.GenericSetup.interfaces.EXTENSION"
    post_handler=".setuphandlers.post_install"
    />

<genericsetup:registerProfile
    name="z-conditionals"
    directory="profiles/plone5"
    title="collective.resourcebooking"
    description="Installs the collective.resourcebooking add-on."
    provides="Products.GenericSetup.interfaces.EXTENSION"
    zcml:condition="have plone-5"
    />

<genericsetup:registerProfile
    name="z-conditionals"
    directory="profiles/plone6"
    title="collective.resourcebooking"
    description="Installs the collective.resourcebooking add-on."
    provides="Products.GenericSetup.interfaces.EXTENSION"
    zcml:condition="have plone-6"
    />

Note

make sure that your configure.zcml file has xmlns:zcml="http://namespaces.zope.org/zcml" defined in the configure tag.

The default profile is loaded by default, but our z-conditionals profiles are not. We have to load them our self. To do this, we use the post_install hook of the default profile and load the "z-conditionals" profile via Python code.

In our setuphandlers.py we should have the following code:

def post_install(context):
    """Post install script"""
    # Do something at the end of the installation of this package.
    loadMigrationProfile(
        context,
        "profile-collective.resourcebooking:z-conditionals",
    )

With this configuration in place, we need to add two new sub folders ('plone5', 'plone6') in our profiles folder. In these folders we create a registry folder where our registry files live.

Now let's fill the profiles with registry settings.

In the plone5 folder we want to set settings for the Navigation like this:

<?xml version='1.0' encoding='UTF-8'?>
<registry>
<records interface="Products.CMFPlone.interfaces.controlpanel.INavigationSchema" prefix="plone">
    <value key="displayed_types" purge="false">
        <element>ResourceBooking</element>
        <element>Resources</element>
        <element>Bookings</element>
    </value>
</records>
</registry>

for Plone 6 on the other hand, we want to set it like this:

<?xml version='1.0' encoding='UTF-8'?>
<registry>
<records interface="plone.base.interfaces.controlpanel.INavigationSchema" prefix="plone">
    <value key="displayed_types" purge="false">
        <element>ResourceBooking</element>
        <element>Resources</element>
        <element>Bookings</element>
    </value>
</records>
</registry>

Alternative approach

Another way to load additional profiles would be, to depend on them in the default profile. But it is not as robust in my opinion.

In your configure.zcml you can register your profiles like this:

<genericsetup:registerProfile
    name="install-base"
    title="collective.resourcebooking BASE"
    directory="profiles/base"
    description="Installs the collective.resourcebooking add-on."
    provides="Products.GenericSetup.interfaces.EXTENSION"
    post_handler=".setuphandlers.post_install"
    />
<genericsetup:registerProfile
    description="Installs the collective.resourcebooking add-on."
    directory="profiles/plone5"
    name="default"
    provides="Products.GenericSetup.interfaces.EXTENSION"
    title="collective.resourcebooking"
    zcml:condition="have plone-5"
/>
<genericsetup:registerProfile
    description="Installs the collective.resourcebooking add-on."
    directory="profiles/plone6"
    name="default"
    provides="Products.GenericSetup.interfaces.EXTENSION"
    title="collective.resourcebooking"
    zcml:condition="have plone-6"
/>

Note

make sure that your configure.zcml file has xmlns:zcml="http://namespaces.zope.org/zcml" defined in the configure tag.

The default profile folder we rename to base.

In our plone5/plone6 folders we add a metadata.xml with a dependency to the install-base profile.

<?xml version="1.0"?>
<metadata>
<dependencies>
    <dependency>profile-collective.resourcebooking:install-base</dependency>
</dependencies>
</metadata>

Fixing PDF indexing / missing pdf_to_text transform in Plone

2023-02-05T00:00:00+02:00

If poppler-utils was not installed when a Plone site was created, the pdf transforms are missing. Just installing poppler-utils will not ad them automatically. We show here, how to fix it in the debug shell.

First make sure you have the system dependencies installed, we need poppler-utils and it's dependencies.

To open the debug shell, we run ./bin/instance debug. Now run the following Python commands.

from zope.component.hooks import setSite
from Products.PortalTransforms.transforms import initialize
portal = app.Plone
setSite(portal)
initialize(portal.portal_transforms)
import transaction
transaction.commit()

Note

In the debug mode, app will be your Zope root object. To get your Plone site object with the name Plone, you just use app.Plone.

After restarting your instance, you should have pdf_to_text and pdf_to_html in your portal_transforms tool. It make sense that you reindex all your content, to have existing PDF files indexed.

Assign permission roles based on workflow state and group membership

2023-01-20T00:00:00+02:00

In Plone we can assign permission roles to user and groups. We also can assign roles based on context. But what many don't know, this is also possible based on group membership and workflow state.

First we need to add some groups we want to manage and assign them to the workflow:

then we can map groups to permission roles for each workflow state:

ES6 (vanilla Javascript) alternative to jQuery on()

2022-09-08T00:00:00+03:00

In jQuery one can use the on() method (event delegation) to register an event handler for example on the body tag and match bubbling events. This is a vanilla Javascript way to do the same without jQuery.

To register an event handler on the document root and filter the events for the one we are interested, we can do the following.

document.addEventListener("click", (e) => {
    if (e.target.parentNode.querySelector("a.speciallink") != e.originalTarget){
        return
    }
    e.preventDefault();
    // handle event
});

Plone: subscribe to an event when a new user is registered

2020-09-08T00:00:00+03:00

When a new user is registered in Plone, we want to do automated actions with the user.

Let's define the code for the automated action to run, when a new Plone user is registered.

from datetime import datetime
from plone import api

def user_registered(user, event):
    if not hasattr(user, '__ac_permissions__'):
        # not a Plone user
        return
    member = api.user.get(userid=user.getId())
    now = datetime.now()
    member.setMemberProperties(
        mapping={
            'custom_registration_date': now,
        },
    )

Now let's register this function for the Plone PrincipalCreatedEvent event, in our configure.zcml.

<subscriber
    for="* Products.PluggableAuthService.interfaces.events.IPrincipalCreatedEvent"
    handler=".events.user_registered"
    />

Smart compact vhost config for nginx Webserver as HTTPS-Proxy for Plone CMS

2020-07-09T00:00:00+03:00

Nginx is one of the most used webserver/proxy in front of Plone CMS. This example showes how to setup a compact virtual host for Plone.

The following nginx vhost configuration applies to "derico.de" and "www.derico.de". And does a redirect for the non-www domain to the www-version.

The first too rewrites are taking care of the NON-WWW to WWW and HTTP to HTTPS redirects, by using only the host and server_name variables. This make it very easy to reuse for other vhosts.

The proxy_pass does the VirtualHostRoot rewriting and includes the Plone-site-id, which in this case is "Plone".

server {
    server_name www.derico.de derico.de;
    listen xxx.xx.xx.xxx:80;
    listen xxx.xx.xx.xxx:443 ssl;
    ssl_certificate /etc/ssl/derico.de.pem;
    ssl_certificate_key /etc/ssl/derico.de.key;
    if ( $host != $server_name ) {
        return 301 $scheme://$server_name$request_uri;

    }
    if ( $scheme != "https") {
        rewrite ^ https://$host$uri permanent;

    }
    proxy_read_timeout 300;
    location / {
        proxy_pass http://127.0.0.1:8080/VirtualHostBase/https/$server_name:443/Plone/VirtualHostRoot/$request_uri;

    }
}

Creating an Odoo Meeting object from an Opportunity in a Python Automated Action

2020-04-29T00:00:00+03:00

In Odoo you can create objects from an automated action, with a bit of Python code. But creating a Meeting was a bit tricky.

env['calendar.event'].create({
    'name': 'Outward flight: {0}'.format(record.display_name),
    'start_date': record.flight_outward_date,
    'stop_date': record.flight_outward_date,
    'allday': True,
})

The first you would try, is to create the required fields, like name and the obvious ones like start_date and stop_date. But this will not work, as other field depend on start/stop fields. Even though there are normally set by on_change handlers automatically, this only happend in formulars, but not when you create a Meeting in Python.

env['calendar.event'].create({
    'name': 'Outward flight: {0}'.format(record.display_name),
    'start_date': record.flight_outward_date,
    'start': datetime.datetime.combine(record.flight_outward_date, datetime.time.min),
    'stop_date': record.flight_outward_date,
    'stop': datetime.datetime.combine(record.flight_outward_date, datetime.time.max),
    'allday': True,
})

The trick is, that you also need to fill in the start and stop fields, as you can see above. The correct code i just took from Meeting code in Odoo. Generally said, when ever a simple create fails because of mising fields, check for on_change handlers in the code, as in Python and with the API you need to do extra work here.

With the Python code above, i created an automated action, which creates a Meeting from a crm.lead field when i move the lead from New to Quallified.

Using Caddy Webserver as HTTPS-Proxy for Plone

2020-03-04T00:00:00+02:00

Caddy supports configuration free HTTPS powered by Let's encrypt certificates. This example show's how to setup a virtual host for Plone.

The following Caddy vhost configuration applies to "derico.de" and "www.derico.de". And does a redirect for the non-www domain to the www-version.

Caddy does automatically an redirect from HTTP to HTTPS, so there is nothing to configure.

The rewrite rule should look familiar and does the same VirtualHostRoot rewriting you would do in Nginx or Apache too. It includes the Plone-site-id, which in this case is "Plone".

derico.de, www.derico.de {
    redir 301 {
        if {host} not_starts_with www
        / https://www.{hostonly}{uri}
    }
    rewrite {
        r ^/(.*)$
        to /VirtualHostBase/https/{hostonly}:443/Plone/VirtualHostRoot/{1}
    }
    proxy / http://localhost:9000 {
        transparent
        header_upstream X-Forwarded-Host {host}
    }
    gzip
    log /var/log/caddy/derico.de.access.log
    errors /var/log/caddy/derico.de.error.log

}

That's all you need for a HTTPS vhost for Plone. After restarting the Webserver, Caddy will make sure you'll get a valid Let's encrypt certificate and configure it for the domain. To get the certificate. the domain has to have a valid DNS setup already.

Ansible: Add an empty line before a blockinfile

2020-01-28T00:00:00+02:00

By default Ansible blockinfile inserts the block without a leading empty line:

127.0.0.1   localhost
xxx.xxx.xxx.xxx derico.de
### BEGIN ANSIBLE MANAGED BLOCK ###

xxx.xxx.xxx.xxx     mail.lan

### END ANSIBLE MANAGED BLOCK ###

Like other people on Reddit, i don't like it this. To make it more readable, we would like to add an empty line before that block:

- name: update /etc/hosts file with a list of lan-hosts
  become: true
  blockinfile:
    path: /etc/hosts
    block: "{{ lookup('template', 'templates/etc/lan-hosts.j2') }}"
    state: present
    marker: "### {mark} ANSIBLE MANAGED BLOCK ###"
    backup: yes

- name: insert an empty line before the marker line
  become: true
  replace:
    path: /etc/hosts
    regexp: "(?<=.\n)### BEGIN ANSIBLE MANAGED BLOCK ###$"
    replace: "\n### BEGIN ANSIBLE MANAGED BLOCK ###"

The regex matches the marker line, when there is no empty line right before it and replaces it with a marker which has a leading empty line:

127.0.0.1   localhost
xxx.xxx.xxx.xxx derico.de

### BEGIN ANSIBLE MANAGED BLOCK ###

xxx.xxx.xxx.xxx     mail.lan

### END ANSIBLE MANAGED BLOCK ###

Transmogrifier: skip existing items

2019-06-18T00:00:00+03:00

To skip items, we can use the collective.transmogrifier.sections.condition section. The following example shows how to use this section, together with a catalog query.

[only_nonexisting_items]
blueprint = collective.transmogrifier.sections.condition
condition = python: len(modules['plone'].api.content.find(import_id=item['import_id'])) == 0

With this section in place, we skip all items, where we already have objects with the same import_id in the catalog.

The new generation of bobtemplates.plone / plonecli

2019-03-08T00:00:00+02:00

bobtemplates.plone is ready for Python 3!

The Plone package generator templates for mrbob and plonecli, are now available in the 4th generation. During the after conference Sprint at the Plone-Tagung in Munich, the work was started and continuing a full week after the sprint. Our main goal was it to make bobtemplates.plone and the plonecli ready to support the development on Python 3 and Python 2.7. At the end we also fixed some existing issues in several templates and tests.

Python 3 and Python 2.7 support

It is now possible to create packages which support Plone from 4.3 until 5.2. Under Plone 5.2, the packages can also run under Python 3. New generated packages contain now a Tox Tox setup, which allows the developer to easily test the package in multiple Plone and Python versions.

$ tox -p auto
______________________ summary ________________________
ERROR:   py27-lint: parallel child exit code 1
  37-lint: commands succeeded
ERROR:   py27-Plone43: parallel child exit code 1
  py27-Plone51: commands succeeded
  py27-Plone52: commands succeeded
  py37-Plone52: commands succeeded
  build_instance: commands succeeded

Available Templates

Available mr.bob templates:
- addon
- behavior
- content_type
- portlet
- restapi_service
- theme
- theme_barceloneta
- view
- viewlet
- vocabulary
- buildout
- theme_package [deprecated] >> Please use the theme_barceloneta sub-template!

Write your own custom templates for plonecli

You can create your own custom package, analog to bobtemplates.plone and register your templates for plonecli. This could be used for example for your agency or client specific code structures. If you need help by creating such custom bobtemplates and plonecli integration's, give us a sign on Gitter: https://gitter.im/plone/plonecli or contact me here: https://derico.de.

Useful stylesheets for layouts done with Plone's Mosaic Editor

2019-01-17T00:00:00+02:00

Mosaic is a nice way of creating more complex content layouts in Plone. But the default styling might not always fit your needs. For example some of the styles of the Plone default theme are only effect elements inside of #content-core, which does not exists in a mosaic layout.

Some useful stylesheets for Mosaic layouts

/* usefull in content listing tile */
.tileItem .summary-image img {
    float:left;
    width: 128px;
}

/* always usefull to fix some layout issues when using Mosaic */
.mosaic-tile-content {
    img{
        max-width: 100%;
    }
    :first-child {
        margin-top: 0;
    }
}

/* usefull when using collective.tiles.collection */
.collectionTile {
    ul {
        padding-left: 0.5em;
        list-style-type: none;
    }
    li {
        margin-bottom: 0.5em;
        img {
            margin-right: 0.5em;
        }
    }
}

Writing a custom service for Plone REST API

2018-08-08T00:00:00+03:00

Plone REST API expand

Plone REST API services allow you to use the Expansion functionionality, to reduce the request on the client side. This way you can include additional informations, you want to show together with your main content in one single response. The Plone REST API already provides some useful services like the Breadcrumb service. Together with the Expansion flag, you can easily expand specific service informations into the main response.

For details about the Expension function see here: https://plonerestapi.readthedocs.io/en/latest/expansion.html

Implementation

We create the following structure in our Plone package:

services/
├── configure.zcml
├── __init__.py
└── related_articles
    ├── configure.zcml
    ├── get.py
    ├── __init__.py

In the services folder, we have this configure.zcml

<configure xmlns="http://namespaces.zope.org/zope">

  <include package=".related_articles" />

</configure>

also add this line to the parent configure.zcml:

<include package=".services" />

to register the actual service, we need the following zcml config inside the related_articles folder:

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

  <adapter factory=".get.RelatedArticles" name="related-articles"/>

  <plone:service
    method="GET"
    for="zope.interface.Interface"
    factory=".get.RelatedArticlesGet"
    name="@related-articles"
    permission="zope2.View"
    />

</configure>

The service code looks as follow:

get.py

# -*- coding: utf-8 -*-
from plone import api
from plone.restapi.interfaces import IExpandableElement
from plone.restapi.services import Service
from zope.component import adapter
from zope.interface import Interface
from zope.interface import implementer


@implementer(IExpandableElement)
@adapter(Interface, Interface)
class RelatedArticles(object):

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

    def __call__(self, expand=False):
        result = {
            'related-articles': {
                '@id': '{}/@related-articles'.format(
                    self.context.absolute_url(),
                ),
            },
        }
        if not expand:
            return result

        solution_categories = [c for c in self.context.solution_category]
        article_brains = api.content.find(
            portal_type="Chapter",
            solution_category={
                'query': solution_categories,
                'operator': 'and',
            }
        )
        items = []
        for article in article_brains:
            items.append({
                'title': article.Title,
                '@id': article.getURL(),
            })

        result['related-articles']['items'] = items
        return result


class RelatedArticlesGet(Service):

    def reply(self):
        related_articles = RelatedArticles(self.context, self.request)
        return related_articles(expand=True)['related-articles']

The service is using the plone.api to find all related objects of the portal_type Chapter and createds a list of dicts with the @id and title of each Chapter. Together with the Expansion flag, the client can expand this as follow:

http://localhost:7080/Plone/some-content?expand=related-articles

You will find the expanded service info inside of the @component section:

"@components": {
    "actions": {
        "@id": "http://localhost:7080/Plone/some-content/@actions"
    },
    "breadcrumbs": {
        "@id": "http://localhost:7080/Plone/some-content/@breadcrumbs"
    },
    "navigation": {
        "@id": "http://localhost:7080/Plone/some-content/@navigation"
    },
    "related-articles": {
        "@id": "http://localhost:7080/Plone/some-content/@related-articles",
        "items": [{
            "@id": "http://localhost:7080/Plone/articles/harvesting",
            "title": "Harvesting"
        }]
    },
    "workflow": {
        "@id": "http://localhost:7080/Plone/some-content/@workflow"
    }
},

Writing a custom serializer for Plone REST API

2018-08-06T00:00:00+03:00

The following code shows two custom FieldSerializer adapters which handle the values of Choice and MultiChoice (Collection) fields. For doing this, we register one adapter for the IChoice interface and one adapter for ICollection interface. Both also support vocabularies provided by collective.taxonomy.

By default the Plone REST API would give us just the plain tokens back, because that's what is actually stored when you use a Selection or Multiselection field. But on the client side we want the token and also the title, so that we can easily show it. Therefor we want something like this as the value for a Choice field.

Expected response

IChoice field

"solution_category": {
    "title": "A nice title",
    "token": "a-nice-title"
},

ICollection field

"solution_category": [
    {
        "title": "A nice title",
        "token": "a-nice-title"
    },
    {
        "title": "An awesome title",
        "token": "an-awesome-title"
    },
]

Implementation

restapi.py

from plone.dexterity.interfaces import IDexterityContent
from plone.restapi.interfaces import IFieldSerializer
from plone.restapi.serializer.converters import json_compatible
from zope.component import adapter
from zope.component import getUtility
from zope.interface import implementer
from zope.interface import Interface
from zope.schema.interfaces import IChoice
from zope.schema.interfaces import ICollection
from zope.schema.interfaces import IVocabularyFactory


def _get_vocab_term(context, field, value):
    """ Get vocab term dict
        returns: {'token': token, 'title': title}
    """
    vocab_term = {
        'token': None,
        'title': None,
    }
    vocab_term['token'] = value
    factory = getUtility(IVocabularyFactory, field)
    if not factory:
        return vocab_term

    # collective.taxonomy support:
    if hasattr(factory, 'translate'):
        vocab_term['title'] = _get_taxonomy_vocab_title(
            context,
            factory,
            value,
        )
    elif IVocabularyFactory.providedBy(factory):
        vocab_term['title'] = _get_vocab_title(
            context,
            factory,
            value,
        )
    return vocab_term


def _get_taxonomy_vocab_title(context, factory, value):
        vocab_title = factory.translate(
            value,
            context=context,
        )
        return vocab_title


def _get_vocab_title(context, factory, value):
    vocab = factory(context)
    vocab_title = vocab.getTermByToken(value).title
    return vocab_title


class BaseFieldSerializer(object):

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

    def __call__(self):
        return json_compatible(self.get_value())


@adapter(IChoice, IDexterityContent, Interface)
@implementer(IFieldSerializer)
class ChoiceFieldSerializer(BaseFieldSerializer):
    """
    """
    def get_value(self, default=None):
        value = getattr(
            self.field.interface(self.context),
            self.field.__name__,
            default,
        )
        if not value:
            return

        term = _get_vocab_term(
            self.context,
            self.field.vocabularyName,
            value,
        )
        return term


@adapter(ICollection, IDexterityContent, Interface)
@implementer(IFieldSerializer)
class CollectionFieldSerializer(BaseFieldSerializer):
    """
    """
    def get_value(self, default=None):
        terms = []
        values = getattr(
            self.field.interface(self.context),
            self.field.__name__,
            default,
        )
        if not values:
            return
        if not IChoice.providedBy(self.field.value_type):
            return

        for value in values:
            term = _get_vocab_term(
                self.context,
                self.field.value_type.vocabularyName,
                value,
            )
            terms.append(term)
        return terms

Registration

To activate this, we need to register the two adapters:

configure.zcml

<adapter factory=".restapi.ChoiceFieldSerializer" />
<adapter factory=".restapi.CollectionFieldSerializer" />

Iterating over Plone Dexterity fields

2018-05-30T00:00:00+03:00

To get all related schemas for your object, you can use the iterSchemata function provided by plone.dexterity.utils. From the list of schematas you can get the fields by using the getFields function provided by zope.schema.

from plone.dexterity.utils import iterSchemata
from zope.schema import getFields

fields = {}
schemes = iterSchemata(context)
for schema in schemes:
    fields.update(getFields(schema))

for name, field in fields.items():
    print("Field: {0}, value: {1}".format(name, field))

Setting pattern_options in a Plone relation field widget

2018-04-30T00:00:00+03:00

To use the full power of the RelationWidget in Plone 5, you can set some of the pattern_options, which are described in the link Mockup docs.

If you use a ReleationField, you usually want to browse thru all objects in the database, but only allow to select specific portal_types.

The pattern relateditems which is used by the RelatedItemsFieldWidget, has options to configure this by setting the selectableTypes list (array).

You can pass the patter_options argument to the widget configuration, with plone.autoform.directives like this:

directives.widget(
    'location',
    RelatedItemsFieldWidget,
    pattern_options={'selectableTypes': ['location']},
)
locations = RelationList(
    title=_(u'Locations'),
    value_type=RelationChoice(
        title=_(u'Related'),
        source=CatalogSource(),
    ),
    required=False,
)

This will update the pattern_options with your provided config.

The same way you can add more confgiuration settings for the pattern, like the basePath for example.

Dynamic screen definitions in i3wm

2017-12-31T00:00:00+02:00

Below we will generate a custom screens definition config file for i3 and using update-conf.py to generate the i3 config from a config.d directory.

Installing requirements

To generate a config file from a config.d, we are using the Python package update-conf.py, so lets install it.

sudo pip install update-conf.py

Separating i3 config files

Now let's create the config.d directory and put our config files into the directory.

mkdir ~/.i3/config.d
cp ~/.i3/config ~/.i3/config.d/99-main

For the screen definitions we want a separate config file the following:

set $mainscreen DP-1
set $sidescreen eDP-1

Creating the gen-screen-config.sh script

This file will change if, we use a different settings of monitors or plug a monitor into a different port on the computer. To update this file we will use the following script.

#!/bin/bash

xrandr --listactivemonitors | awk '$1 ~ /^0/ {print "set $mainscreen " $4}'
xrandr --listactivemonitors | awk '$1 ~ /^1/ {print "set $sidescreen " $4}'

Generating the screen config file for i3

You can use the script like this:

./gen-screens-conf.sh > ~/.i3/config.d/10-screens

Generating the i3 config from config.d files

To generate the i3 config file from the config.d directory, we use the update-conf.py:

update-conf.py -f /home/maik/.i3/config

This will concatenate all files in config.d directory into the i3 config file.

Optimizing the process

To make it easier to switch between setups, we can integrate the calls into i3 restart binding.

To not mess up the i3 config and to make sure the screens config config is generated when we regenerate the i3 config, we create enother script called refresh-screensettings.sh.

#!/bin/bash

~/.i3/scripts/gen-screens-conf.sh > ~/.i3/config.d/10-screens
update-conf.py -f ~/.i3/config

With this script in place we can use it in the restart binding as follow:

bindsym $mod+Shift+r  exec /home/john/.i3/scripts/refresh-screensettings.sh; restart

Now, every time we change the setup, we just need to restart i3. Make sure you have set the primary screen before restarting i3. You can do that for example with the ARandR program.

Plone command line interface - plonecli

2017-10-30T00:00:00+02:00

PloneConf after conference sprint report on plonecli and bobtemplates.plone.

During the after conference sprints in Barcelona, we (MrTango, tmassman and Gomez) created a command line client for developing Plone packages. The plonecli is mainly a wrapper around mr.bob and bobtemplates.plone, but can also used with other bobtemplates. The plonecli adds to the previous work on refactoring and modulizing the bobtemplates.plone templates, a simple and easy to use command line frontend.

Features

allow bobtemplates to be registered for plonecli
list available bobtemplates for the current context
standalone and subtemplates
auto completion of commands and available templates
command chaining

Usage

Create a Plone Addon packages

To create a Plone Addon with the plonecli, you can just use the create command:

$ plonecli create addon src/collective.todos

If you want to know what templates are available, you can either use the -l/--list-templates option or just press TAB-Key twice.

$ plonecli --list-templates
Available mr.bob templates:
 - buildout
 - addon
  - vocabulary
  - theme
  - content_type
 - theme_package

Example

Create addon with plonecli

Add a content_type to your Plone Addon

To add a content_type to an existing Plone Addon package, you can just use the add command inside the package:

$ cd src/collective.todos
$ plonecli add content_type

The -l/--list-templates and auto completion works also for subtemplates (the add command).

$ plonecli add
content_type  theme         vocabulary

Add a content_type to your package

Add a vocabulary to your Plone Addon

To add a Plone vocabulary, you can use the add command with the vocabulary subtemplate:

$ plonecli add vocabulary

Example

Add a vacobulary to your package

Build a Plone Addon

You can use the plonecli also to build the package:

$ plonecli build

This will run:

$ virtualenv .
$ ./bin/pip install -r requirements.txt --upgrade
$ ./bin/buildout

in your target directory. You can always run the 3 steps explicit by using the commands virtualenv,``requirements``, buildout instead of build. If you want to reset your build use the --clean option on build. This will clear your virtualenv before installing the requirements and also running buildout with -n to get the newest versions.

Example

Build your package with plonecli

Serve the development Plone site of the package

The plonecli also provides a serve command which will start the Plone instance in foreground and provide a link to open it in the browser:

$ plonecli serve
RUN: ./bin/instance fg

INFO: Open this in a Web Browser: http://localhost:8080
INFO: You can stop it by pressing CTRL + c

2017-10-30 14:21:01 INFO ZServer HTTP server started at Mon Oct 30 14:21:01 2017
    Hostname: 0.0.0.0
    Port: 8080
...

Combine (chain) commands

You can combine commands like create, build and serve:

$ plonecli build serve

This will first run all the build steps and then serve the Plone site

Example

Serve your package with plonecli

Kindle Voyage vs. Tolino Vision HD3

2016-05-26T00:00:00+03:00

Meine Erfahrungen aus dem Alltag mit Kindle Voyage und dem Tolino Vision HD 3.

Tolino Vision HD3

Pro

Design und Form, liegt angenehmer in der Hand
Schalter zum an und ausschalten der Hintergrundbeleuchtung
Sensortaste für Hauptmenü
etwas günstiger als Kindle Voyage
Android mit etwas Handarbeit erweiterbar
Umblättern mit Doppel-Tab auf Rückseite (Tab2Flip)

Kontra

Keine optimierten Ränder bei PDF-Dateien
kein Kontextmenü (Wörterbuch, Übersetzungsfunktion) bei PDF-Dateien
Querformat für PDF-Dateien nur umständlich verwendbar (Es muss gescrollt werden, Tab springt zur nächsten Seite und nicht zum Rest der Seite)
Kein Zoomen von Textblöcken per Doppel-Tap, wie man es von Tablets kennt
Fehlerhafte Darstellung von Code-Blöcken in eBooks, Text wird zu groß dargestellt und ist teilweise nicht sichtbar
Eigene Bücher lassen sich nur per USB auf den Tolino übertragen, keine Übertragung per E-Mail
Um Bücher in die Tolino-Cloud zu laden, müssen diese vorher per USB auf das Gerät geladen werden und anschließend manueller Upload in die Cloud
keine automatische Konvertierung von PDF in ePub

Kindle Voyage

Pro

Sensortasten zum vor und zurück blättern auf jeder Seite
Kontextmenü (Wörterbuch, Übersetzungsfunktion) funktioniert auch für PDF-Dateien
Optimierte Ränder bei PDF-Dateien, keine händische Bearbeitung um Vorfeld nötig
Lesen von PDF-Dateien im Querformat gut verwendbar, Tab zeigt nächsten Bereich an und blättert bei Bedarf zur nächsten Seite
Zoomen von Textblöcken per Doppel-Tab möglich, ähnlich wie auf Tablets
Übertragen von eigenen Büchern per USB und E-Mail möglich
Automatische Konvertierung von PDF zu MOBI bei Übertragung per E-Mail (optional)
Konvertierung von PDF zu MOBI ist qualitativ recht gut, oft besser als Programme wie Calibre
Automatische Anpassung der Hintergrundbeleuchtung (funktioniert aber nicht immer perfekt)

Kontra

Gerät liegt etwas schlechter in der Hand als der Tolino, hier gefallen mir die Runden Ecken vom Tolino deutlich besser
Sensortasten zum weiter blättern für mich in der Praxis nicht sinnvoll nutzbar, daher deaktiviert
Keine Taste zum an und ausschalten der Hintergrundbeleuchtung
Keine Taste für das Hauptmenü