Mit dem Inhaltstyp anfangen

Da Sie nun eine Vorstellung vom Inhaltstyp haben, den Sie in diesem Kapitel erstellen werden, können Sie anfangen, ihn zu erstellen, indem Sie Python-Code im Dateisystem schreiben. Dieser Inhaltstyp ist also auch ein Produkt, d.h., Sie erstellen ein neues Verzeichnis in Ihrem Produktverzeichnis. Der Name des zu erzeugenden Verzeichnisses ist der Name des Produkts, das Zope importieren wird. Treffen Sie also eine kluge Wahl für Ihren Namen. Ich habe mir spaßeshalber überlegt, das Produkt SourceCode oder PloneSourceCode zu nennen, fand diese Namen aber zu verwirrend, (man könnte denken, dass das Produkt der eigentliche Quellcode von Plone wäre). Aber PloneSilverCity schien ein netter Produktname zu sein, der auf seinen Ursprung hinweist und hinreichend obskur ist, dass ihn keiner mit etwas anderem verwechseln könnte.

Nachdem das Verzeichnis erstellt ist, füge ich normalerweise ein paar Dateien und Verzeichnisse hinzu, die ich benötige. Jedes Paket benötigt eine Datei namens __init__.py darin. Dieser Dateiname wird von Python so verlangt und bedeutet, dass dieses Verzeichnis ein Python-Paket ist, d.h., dass es importiert werden kann. Wenn das Paket importiert wird, führt Zope diese Datei aus. In dieser Datei fügen Sie den Code zur Registrierung des Produkts in Zope hinzu.

Da Sie benutzerfreundlich sein möchten, können Sie auch ein paar Textdateien wie readme.txt, install.txt usw. hinzufügen. Eine andere nützliche Textdatei ist refresh.txt. Damit können Sie sich in das Refresh-Modul von Zope einklinken und das Produkt dynamisch neu laden, während Sie es schreiben. Das ist gerade bei Ihren ersten Schritten unglaublich hilfreich, wenn Sie eine Klasse schreiben, und ich werde ihnen später zeigen, wie Sie das in Zope konfigurieren.

Im Moment haben Sie ein Verzeichnis namens PloneSilverCity im Produktverzeichnis, das folgende leere Dateien enthält: readme.txt, refresh.txt, install.txt und __init__.py. Das stellt nun ein gültiges Python-Paket dar, das absolut nichts tut (aber nicht mehr lange).

Integration von SilverCity

Bevor Sie sich zu tief in den Zope-Code verstricken, könnte es sinnvoll sein herauszufinden, wie man SilverCity benutzt. Bei jeder Softwareentwicklung ist ein schichtweises Vorgehen, das das Testen einzelner Schichten erlaubt, von größter Bedeutung. Aus diesem Grund sollten Sie damit anfangen, dass Sie sicherstellen, SilverCity direkt aus einem Python-Modul heraus benutzen zu können. Wenn das funktioniert, müssen Sie nur noch die Zope-Schicht hinzufügen.

Schauen Sie sich SilverCity also einmal an. Zuerst müssen Sie es installieren. Glücklicherweise folgt dieses Modul den in Kapitel 10 skizzierten Installationsanweisungen für Python-Module. Für eine Installation unter Windows laden Sie die Datei SilverCity-0.9.5.win32-py2.3.exe von http://silvercity.sf.net herunter und starten das grafische Installationsprogramm. Für Linux laden Sie die Datei SilverCity-0.9.5.tar.gz von der gleichen Website herunter und speichern sie auf der Platte. Dann packen Sie sie aus und starten das Programm setup.py. Beispiel:

$ tar -zxf SilverCity-0.9.2.tgz
$ cd SilverCity-0.9.2
$ python setup.py install
...

Danach können Sie unter dem Python-Prompt in Windows oder Linux schnell sehen, ob es funktioniert:

$ python
Python 2.3.2 (#1, Oct  6 2003, 10:07:16)
[GCC 3.2.2 20030222 (Red Hat Linux 3.2.2-5)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import SilverCity
>>>

Das bedeutet, dass SilverCity erfolgreich installiert worden ist. Falls Sie kein ähnliches Ergebnis erhalten und SilverCity nicht importieren können, unterbrechen Sie an dieser Stelle und lösen zuerst das Problem, denn sonst funktioniert überhaupt nichts.

Nun müssen Sie die API (Application Programming Interface) dieses Moduls herausfinden. Weil ich faul bin, habe ich mir ein Beispielskript in PySilverCity/Scripts namens source2html.py angeschaut. Dieses Skript tut genau, was Sie wollen: Es spuckt HTML zu einem gegebenen Stück Code aus. Eine wirklich freche Art, es in Aktion zu sehen, besteht darin, dieses Skript wie folgt auf sich selbst loszulassen:

$python source2html.py source2html.py --generator=python
 
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <title>source2html.py</title>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  <link
    rel="stylesheet"
    href="default.css" />
</head>
...

Das heißt, Sie müssen sich nur diese API anschauen und sie leicht abändern. Fügen Sie ein Modul namens source.py im Verzeichnis PloneSilverCity hinzu. Dort schreiben Sie den Code, der die Schnittstelle zur Bibliothek enthält. Dieses neue Modul enthält momentan keinen Zope- oder Plone-spezifischen Code. Es hat drei Hauptbestandteile: Es nennt Ihnen alle möglichen Sprachen, die Sie benutzen können, es nimmt einen Text an, und es gibt den korrekten Parser zurück, und schließlich führt es die eigentliche Umwandlung aus.

Fügen Sie zuerst die folgende Funktion create_generator hinzu, mit der Sie den korrekten Parser erhalten:

from SilverCity import LanguageInfo
from StringIO import StringIO
 
def create_generator(source_file_name=None, generator_name=None):
    """ Make a generator from the given information
    about the object, such as its source and type """
    if generator_name:
        return LanguageInfo.find_generator_by_name(generator_name)()
    else:
        if source_file_name:
            h = LanguageInfo.guess_language_for_file(source_file_name)
            return h.get_default_html_generator()()
        else:
            raise ValueError, "Unknown file type, cannot create lexer"

Zweitens, wenn Sie in Plone sind, müssen Sie genau herausfinden, welche Sprachen verfügbar sind, damit Sie diese den Benutzern anzeigen können. Schreiben Sie die folgende Funktion namens list_generators, die diese Liste zurückgibt:

def list_generators():
    """ This returns a list of generators, a generator
    is a valid language, so these are things like perl,
    python, xml etc..."""
    lexers = LanguageInfo.get_generator_names()
    return lexers

Die Funktion generate_html nimmt schließlich eine Quelldatei als String an, einen optionalen Generator und einen optionalen Dateinamen. SilverCity benötigt eine Datei, z.B. buffer, um den Inhalt irgendwohin zu schreiben, d.h., Sie können das Python-Modul StringIO zu diesem Zweck verwenden. Die Funktion generate_html lautet wie folgt:

def generate_html(source_file, generator=None, source_file_name=None):
    """ From the source make a generator
    and then make the html """
 
    # SilverCity requires a file like object
    target_file = StringIO()
    generator = create_generator(source_file_name, generator)
    generator.generate_html(target_file, source_file)
 
    # return the html back
    return target_file.getvalue(), generator.name

Sie werden bemerken, dass sie die Funktion create_generator aufruft, die Sie zuvor geschrieben haben, um den richtigen Generator für diese Sprache zu finden. Das ist der ganze Code, den Sie benötigen, um zu einer Datei das entsprechende HTML zu generieren. Ich bin nicht auf irgendwelche Besonderheiten des eigentlichen Lexens des Quellcodes oder der Erzeugung des HTML-Codes eingegangen. Die SilverCity-Bibliothek erledigt das alles für Sie. Um den vorigen Punkt zu wiederholen: In diesem Modul haben Sie keine Referenz auf Zope oder Plone, d.h., dieses Modul ist völlig selbstständig. Die eigentlichen Details dieses Moduls müssen Sie nicht kennen, solange Sie wissen, dass Sie eine Bibliothek von dritter Seite importieren.

In Pyhon-Skripten gibt es die Tradition, mindestens einen Test in den Code einzubauen. Sie könnten auch eine vollständige Unittest-Suite erstellen, aber das geht über das aktuelle Thema hinaus. Stattdessen werden Sie ein wenig Code hinzufügen, um zwei Dinge zu testen, nämlich zum einen, dass es funktioniert, und zum anderen, dass die Sprachen verfügbar sind:

if __name__ == "__main__":
    import sys
    myself = sys.argv[0]
    file = open(myself, 'r').read()
    print generate_html(file, generator="python")
    print list_generators()

Wenn Sie dieses Skript ausführen, öffnet es sich selbst und übergibt seinen Code an den Teil, der die HTML-Syntax hervorhebt. Dann wird eine Menge HTML-Code ausgespuckt. Das könnten Sie einfach ins Zope-spezifische Modul setzen, das Sie gleich schreiben werden. Wenn sich allerdings alles in getrennten Skripten befindet, wird es später einfacher zu testen und zu ändern.

Die Klasse schreiben

Ein Inhaltstyp in Plone ist lediglich ein Objekt, das einige bestimmte Attribute und einige bestimmte Basisklassen hat. Sie müssen sich nicht einmal um das Lesen und Schreiben in der Datenbank kümmern, das machen alles die Persistencebase-Klassen. Erstellen Sie nun ein Modul namens PloneSilverCity.py im Paket.

Importieren Sie zuerst das Modul source.py, das Sie vor wenigen Augenblicken geschrieben haben. Das geht mit einer einfachen Zeile, da sich das Modul im gleichen Paket befindet. Die Zeile, die die Funktion importiert, lautet wie folgt:

from source import generate_html, list_generators

Als Zweites benötigen Sie eine Klasse PloneSilverCity, in der Sie die benötigte Funktionalität kapseln können. Bei dieser Klasse müssen Sie auf die folgenden vier Attribute aufpassen:

• id: Speichert die eindeutige ID dieser Instanz der Klasse PloneSilverCity.
• _raw: Speichert den rohen Quellcode in der Klasse.
• _raw_as_html: Speichert den Quellcode, nachdem er in HTML gelext wurde.
• _raw_language: Speichert die Sprache dieses Quellcodes.

Für jedes dieser Attribute werden Sie einen Accessor schreiben, d.h. eine Methode, die den Wert dieses Attributs zurückgibt, damit Sie nicht das Attribut, sondern die Zugriffsmethode aufrufen. Ein Beispiel für eine Accessor-Methode ist getLanguage, die den Wert des language-Attributs zurückgibt. Einen Accessor zu schreiben ist normalerweise eine gute Idee, besonders deswegen, weil Sie später Sicherheitsmechanismen auf diese Accessor-Methoden anwenden werden. In Zope stehen alle Methoden oder Attribute, die mit einem Unterstrich beginnen, nicht für webbasierte Methoden wie Page Templates oder Script (Python)-Objekte zur Verfügung. Ein gute Vorgehensweise besteht darin, am Anfang für all Ihre Attribute einen Unterstrich zu verwenden und dann die Sicherheitsmechanismen auf die Zugriffsmethoden anzuwenden.

Listing 12.1 zeigt die Basisklasse.

Listing 12.1. Die Basisklasse in Python

class PloneSilverCity:
    def __init__(self, id):
        self.id = id
        self._raw = ""
        self._raw_as_html = ""
        self._raw_language = None
 
    def getLanguage(self):
        """ Returns the language this code has been lexed with """
        return self._raw_language
 
    def getRawCode(self):
        """ Returns the raw code """
        return self._raw
 
    def getHTMLCode(self):
        """ Returns the html code """
        return self._raw_as_html
 
    def getLanguages(self):
        """ Returns the list of languages available """
        langs = []
        for name, description in list_generators():
            langs.append( {'name':lang, 'value':language} )
        langs.sort()
        return langs

Eine weitere Methode müssen Sie noch hinzufügen, nämlich eine edit-Methode, mit der Sie eine Datei oder einen String hochladen können. Diese Methode liest die Datei und prüft, ob irgendetwas in der Datei steht. Wenn ja, wird sie gelesen und ein Dateiname wird bestimmt. Dann werden der Code, die Sprache und der Dateiname an die Erzeugungsfunktion übergeben. All das speichern Sie in den zuvor genannten Attributen, wie Sie in Listing 12.2 sehen können.

Listing 12.2. Die Methode zur Behandlung von Bearbeitungsschritten

def edit(self, language, raw_code, file=""):
    """ The edit function, that sets
    all our parameters, and turns the code
    into pretty HTML """
    filename = ""
    if file:
        file_code = file.read()

        # if there is a file and it's not blank...
        if file_code:
            raw_code = file_code
            if hasattr(file, "name"):
                filename = file.name
            else:
                filename = file.filename
            # set the language to None so set by SilverCity
            language = None

    self._raw = raw_code

    # our function, generate_html does the hard work here
    html, language = generate_html(raw_code, language, filename)
    self._raw_as_html = html
    self._raw_language = language

Nun haben Sie also eine Python-Klasse, die das Objekt kapselt. An dieser Stelle sollten Sie die Klasse unter einem Python-Prompt sehr leicht ausführen können, um zu testen, ob sie das macht, was Sie wünschen. Beispiel:

$ python
Python 2.3.2 (#1, Oct  6 2003, 10:07:16)
[GCC 3.2.2 20030222 (Red Hat Linux 3.2.2-5)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> from PloneSilverCity import PloneSilverCity
>>> p = PloneSilverCity("test.py")
>>> p.edit("python", "print 'hello world'")
>>> p.getRawCode()
"print 'hello world'"
>>> p.getHTMLCode()
'<span class="p_word">print</span>
<span class="p_default">nbsp;</span>
<span class="p_character">\'hellonbsp;world\'</span>'
>>> p.getLanguage()
'python'

Aus einem Paket ein Produkt machen

Nun haben Sie ein einfaches Paket, aber das ist noch kein Plone-Produkt. Sie müssen es mit Plone initialisieren. Das heißt,Sie müssen zusätzliche Informationen zum Modul PloneSilverCity.py hinzufügen. Insbesondere müssen Sie eine Factory-Funktion hinzufügen. Die Verwendung einer Factory ist ein wohlbekanntes Muster im objektorientierten Design. Sie definiert, wie ein Objekt erzeugt wird. Fügen Sie im Modul PloneSilverCity.py den folgenden Konstruktor hinzu:

def addPloneSilverCity(self, id, REQUEST=None):
    """ This is our factory function and creates
    an empty PloneSilverCity object """
    obj = PloneSilverCity(id)
    self._setObject(id, obj)

Die Funktion addPloneSilverCity gehört nicht zur Klasse PloneSilverCity. Als Konstruktor für die Klasse wird sie in das Modul außerhalb der Klasse gesetzt. Diese Funktion ist die erste Plone-spezifische Funktion. Der Methode werden drei Parameter übergeben: das Objekt self, der ID-String für das Objekt und REQUEST. Das Objekt self ist eigentlich der context, den Sie zuvor schon gesehen haben, wenn auch unter einem anderen Namen. Da die Objekte immer innerhalb eines Ordners erzeugt werden, zeigt self auf den Ordner, in dem dieses Objekt erzeugt wird. Diese Funktion erzeugt eine Instanz von PloneSilverCity namens obj und übergibt sie an die Methode _setObject des Ordners. Die Methode _setObject ist in Zope etwas Besonderes: Sie instanziiert das Objekt in der Datenbank und registriert das Objekt im umgebenden Ordner.

Als Nächstes fügen Sie die Factory-Typinformation hinzu, die in Kapitel 11 behandelt wurde (das ist Ihre erste Chance, sie selbst zu erzeugen). Die Factory-Typinformation enthält in einem Dictionary alle Informationen über den Inhaltstyp. Diese Angaben werden in portal_types geladen, wenn das Produkt in Ihrer Plone-Instanz installiert wird. Sie stellen jene Information dar, die Sie vorher gesehen haben, als Sie die Factory-Typinformation über das Web geändert haben.

Bevor ich die Factory-Information erstelle, erstelle ich normalerweise eine Konfigurationsdatei, die alle wiederholten Variablen zu dem Produkt enthält. Diese Datei heißt config.py, und darin schreiben Sie wie folgt den Namen des Produkts, den Namen seiner Ebenen in den Skins und den Namen, den der Benutzer dafür sieht:

product_name = "PloneSilverCity"
plone_product_name = "Source Code"
layer_name = "silvercity"
layer_location = "PloneSilverCity/skins"

Dann können Sie die Factory-Typ-Information erstellen und diese Strings verwenden. Die ID z.B. wird Source Code sein, da das den Benutzern in Plone angezeigt wird. Der Aktionsabschnitt der Typinformation ist ein Tupel von Dictionaries aller Aktionen, die auf diesem Objekt vorkommen können. Wenn diese Factory in Plone geladen wird, wird der Actions-Reiter im Werkzeug portal_types mit diesem Inhalt gefüllt. All diese Aktionen haben eine entsprechende Methode, ein Template oder Skript, das aufgerufen wird. Die meisten davon haben eine direkte Entsprechung zu Page Templates, was ich später in diesem Abschnitt noch erörtern werde.

Wie Sie nun wissen, ist eine Aktion etwas, das Benutzer mit einem Element in der Plone-Datenbank machen können. Mit Blick auf diese Beispielanwendung können die Benutzer zwei offensichtliche Dinge mit dem Quellcode anstellen. Sie können ihn anzeigen und den hübsch hervorgehobenen Code sehen, und sie können das Element bearbeiten und einen Quellcode hochladen. Tatsächlich verlangt Plone, dass es eine Aktion namens view und eine Aktion namens edit gibt, d.h., diese beiden passen hier gut ins Konzept. Sie werden auch eine dritte Aktion haben wollen: Es ist nett, den Quellcode in seiner ursprünglichen Form herunterladen zu können. In Sprachen wie Python, in denen die Formatierung ein wesentliches Element ist, ist das wirklich nützlich. Diese Aktion zeigt direkt auf getRawCode, was die Methode für den Zugriff auf den rohen Code ist.

Jede Aktion hat ein zugehöriges Recht, wie in Listing 12.3 gezeigt wird (wo es genau herkommt, werde ich im weiteren Verlauf dieses Abschnitts zeigen).

Listing 12.3. Die Factory-Typinformationen und Aktionen

factory_type_information = {
     'id': plone_product_name,
     'meta_type': product_name,
     'description': ('Provides syntax highlighted HTML of source code.'),
     'product': product_name,
     'factory': 'addPloneSilverCity',
     'content_icon': 'silvercity.gif',
     'immediate_view': 'view',
     'actions': (
                 {'id': 'view',
                  'name': 'View',
                  'action': 'silvercity_view_form',
                  'permissions': (view_permission,)},
                 {'id': 'edit',
                  'name': 'Edit',
                  'action': 'silvercity_edit_form',
                  'permissions': (edit_permission,)},
                 {'id': 'source',
                  'name': 'Source',
                  'action': 'getRawCode',
                  'permissions': (view_permission,)},
                 ),
     }

from Products.CMFCore import CMFCorePermissions
 
add_permission = CMFCorePermissions.AddPortalContent
edit_permission = CMFCorePermissions.ModifyPortalContent
view_permission = CMFCorePermissions.View

add_permission = "Add Source Code"

import PloneSilverCity
 
from Products.CMFCore import utils
from Products.CMFCore.DirectoryView import registerDirectory
 
from config import product_name, add_permission
 
contentConstructors = (PloneSilverCity.addPloneSilverCity,)
contentClasses = (PloneSilverCity.PloneSilverCity,)
contentFTI = (PloneSilverCity.factory_type_information,)
 
registerDirectory('skins', globals())
 
def initialize(context):
    product = utils.ContentInit(product_name,
        content_types = contentClasses,
        permission = add_permission,
        extra_constructors = contentConstructors,
        fti = contentFTI)
    product.initialize(context)

Produkt-Module ändern

Nun können Sie zum Modul PloneSilverCity.py und zu der Aufgabe zurückkehren, es in ein Plone-Produkt zu verwandeln. Am Anfang des Moduls werden Sie die import-Anweisungen erstellen. Diese holen wie folgt aus unterschiedlichen Orten verschiedene Dinge, die für die Plone-Initialisierung notwendig sind:

from Globals import InitializeClass
from AccessControl import ClassSecurityInfo
from Products.CMFDefault.DublinCore import DefaultDublinCoreImpl
from Products.CMFCore.PortalContent import PortalContent

Diese Import-Anweisungen stellen die Grundfunktionalität für das Produkt bereit und kommen bei den meisten Inhaltstypen vor. Die importierten Definitionen lauten wie folgt:

• InitializeClass: Diese Funktion initialisiert die Klasse und wendet alle Sicherheitsdeklarationen an, die diese haben wird. Diese Sicherheitsdeklarationen geben Sie durch die Verwendung der Klasse ClassSecurityInfo an.
• ClassSecurityInfo: Diese Klasse bietet eine Reihe von Sicherheitsmethoden, mit denen Sie den Zugriff auf die Methoden des Inhaltstyps beschränken können.
• DefaultDublinCoreImpl: Diese Klasse enthält eine Implementation von Dublin Core-Metadaten. Der Dublin Core wurde in Kapitel 11 behandelt. Sie verleiht einem Objekt alle Dublin Core-Attribute und -Methoden für den Zugriff darauf, wie Title, Description, Creator usw.
• PortalContent: Dies ist die Basisklasse für alle Inhalte in einer Plone-Site und einige der darin benötigten Schlüsselattribute. Durch die Verwendung dieser Basisklasse erhält das Objekt eine ganze Menge an Funktionalität, z.B. zur persistenten Speicherung des Objekts in der Datenbank, der Katalogisierung des Objekts für die Suche mit dem Objekt portal_catalog und seiner Registrierbarkeit mit dem Werkzeug portal_types.

Außerdem müssen Sie die Konfigurationsvariablen und Rechte importieren. Das erfolgt mit den beiden folgenden Zeilen:

from config import plone_product_name, product_name
from config import add_permission, edit_permission, view_permission

In der Klasse wiederum müssen Sie zwei Basisklassen hinzufügen, um sie vollständig Plone-kompatibel zu machen: PortalContent und DefaultDublinCoreImpl. Weiterhin müssen Sie der Klasse einen meta_type geben. In Zope hat jedes Produkt einen eindeutigen meta_type:

class PloneSilverCity(PortalContent, DefaultDublinCoreImpl):
    meta_type = product_name

Plone muss wissen, welche Basisklassen der Inhaltstyp implementiert. Andere Teile der Anwendung müssen wissen, welche Klassen implementiert werden. Geben Sie daher wie folgt explizit an, welche Klassen der Inhaltstyp implementiert:

__implements__ = (
    PortalContent.__implements__,
    DefaultDublinCoreImpl.__implements__
    )

security = ClassSecurityInfo()

security.declareProtected(edit_permission, "edit")

InitializeClass(PloneSilverCity)

security.declareProtected(view_permission, "SearchableText")
def SearchableText(self):
    """ Used by the catalog for basic full text indexing """
    return "%s %s %s" % ( self.Title()
                        , self.Description()
                        , self._raw
                        )

from Globals import InitializeClass
from AccessControl import ClassSecurityInfo
from Products.CMFDefault.DublinCore import DefaultDublinCoreImpl
from Products.CMFCore.PortalContent import PortalContent

from config import meta_type, product_name
from config import add_permission, edit_permission, view_permission
from source import generate_html, list_generators

factory_type_information = {
     'id': plone_product_name,
     'meta_type': product_name,
     'description': ('Provides syntax highlighted HTML of source code.'),
     'product': product_name,
     'factory': 'addPloneSilverCity',
     'content_icon': 'silvercity.gif',
     'immediate_view': 'view',
     'actions': (
                 {'id': 'view',
                  'name': 'View',
                  'action': 'silvercity_view_form',
                  'permissions': (view_permission,)},
                 {'id': 'source',
                  'name': 'View source',
                  'action': 'getRawCode',
                  'permissions': (view_permission,)},
                 {'id': 'edit',
                  'name': 'Edit',
                  'action': 'silvercity_edit_form',
                  'permissions': (edit_permission,)},
                 ),

     }

def addPloneSilverCity(self, id, REQUEST=None):
    """ This is our factory function and creates
    an empty PloneSilverCity object inside our Plone
    site """
    obj = PloneSilverCity(id)
    self._setObject(id, obj)

class PloneSilverCity(PortalContent, DefaultDublinCoreImpl):

    meta_type = product_name

    __implements__ = (
        PortalContent.__implements__,
        DefaultDublinCoreImpl.__implements__
        )

    security = ClassSecurityInfo()
    def __init__(self, id):
        DefaultDublinCoreImpl.__init__(self)
        self.id = id
        self._raw = ""
        self._raw_as_html = ""
        self._raw_language = None

    security.declareProtected(edit_permission, "edit")
    def edit(self, language, raw_code, file=""):
        """ The edit function, that sets
        all our parameters, and turns the code
        into pretty HTML """
        filename = ""
        if file:
            file_code = file.read()
 
            # if there is a file and its not blank...
            if file_code:
                raw_code = file_code
                if hasattr(file, "name"):
                    filename = file.name
                else:
                    filename = file.filename
                # set the language to None so set by SilverCity
                language = None
 
        self._raw = raw_code
 
        # our function, generate_html does the hard work here
        html, language = generate_html(raw_code, language, filename)
        self._raw_as_html = html
        self._raw_language = language

    security.declareProtected(view_permission, "getLanguage")
    def getLanguage(self):
        """ Returns the language that code has been lexed with """
        return self._raw_language

    security.declareProtected(view_permission, "getLanguages")
    def getLanguages(self):
        """ Returns the list of languages available """
        langs = []
 
        for name, description in list_generators():
            # these names are normally in uppercase
            langs.append( {'name':lang, 'value':language } )
 
        langs.sort()
        return langs

    security.declareProtected(view_permission, "getRawCode")
    def getRawCode(self):
        """ Returns the raw code """
        return self._raw

    security.declareProtected(view_permission, "getHTMLCode")
    def getHTMLCode(self):
        """ Returns the html code """
        return self._raw_as_html

    security.declareProtected(view_permission, "SearchableText")
    def SearchableText(self):

        """ Used by the catalog for basic full text indexing """

        return "%s %s %s" % ( self.Title()
                            , self.Description()
                            , self._raw
                            )

InitializeClass(PloneSilverCity)

Skins hinzufügen

Nun, da Sie den Hauptcode haben, bleiben noch zwei Dinge für Sie zu tun: die Skins und eine Installationsmethode erstellen. Die Skins gehören zu den einfacheren Teilen, weil ein Großteil der notwendigen Arbeit bereits vom Plone-Framework erledigt wird. Skins habe ich detailliert in vorangegangenen Kapiteln behandelt, in denen ich erörtert habe, wie man im Dateisystem eine Skin für eine Plone-Site erstellt. Jedes Produkt, das eine eigene Benutzerschnittstelle haben muss (UI, User Interface), macht das mit einem eigenen FSDV (File System Directory View), d.h., hier werdn Sie erneut das Gleiche machen.

Skins kommen in das Verzeichnis skins des Produkts. Dieser Verzeichnisname wird in der Datei __init__.py definiert, wo Sie das Verzeichnis mit der Funktion registerDirectory registrieren. Wenn Sie diesen Namen ändern möchten, sollten Sie ihn auf jeden Fall registrieren. Sie können so viele Verzeichnisse registrieren, wie Sie wollen, aber das ist rekursiv und dabei wird auch alles in und unter diesem registrierten Verzeichnis registriert.

Die einfachste all Ihrer Aufgaben bei diesem Produkt besteht darin, ein Icon für das Objekt hinzuzufügen, das in Plone erscheint. Der Name dieses Icons wird bereits in der Factory-Typinformation mit der Zeile 'content_icon': 'silvercity.gif' definiert, d.h., Sie müssen lediglich ein Icon namens silvercity.gif im Verzeichnis skins hinzufügen. Dieses Icon wird immer dann angezeigt, wenn Sie das Objekt in der Benutzerschnittstelle von Plone anzeigen. Wenn SilverCity eine Datei lext, gibt es HTML aus, in dem CSS-Tags benutzt werden, d.h., Sie müssen sicherstellen, dass die entsprechende CSS-Datei auch verfügbar ist. Bei diesem Produkt kopieren Sie einfach das CSS aus dem SilverCity-Produkt und setzen es in das Verzeichnis skins.

Diese zwei Dinge sind nun erledigt. Nun müssen Sie als Nächstes wirklich die Seiten zum Anzeigen und Bearbeiten der Seiten schreiben. Ich habe zuvor die Ähnlichkeit zu einem Dokument beschrieben, wenn Sie also nach Seiten zum Anzeigen und Bearbeiten suchen, dann sind die Seiten zu einem Dokument der beste Platz dafür. Dies sind document_view.pt und document_edit_form.cpt, die sich im Verzeichnis CMFPlone/skins/plone_content befinden.

<metal:cssslot fill-slot="css_slot">
 
<link
   rel="stylesheet"
   href=""
   tal:attributes="href string:$portal_url/silvercity.css" />
</metal:cssslot>

<div id="bodyContent">
    <div tal:replace="structure here/getHTMLCode" />
</div>

<div class="field">
  <label
   for="language"
   i18n:translate="label_silvercity_language">
Language</label>
 
    <div class="formHelp" i18n:translate="help_silvercity_language">
        Select the name of the language that you are adding
    </div>
    <select name="text_format"
            tal:define="l here/getLanguage">
        <option tal:repeat="item here/getLanguages"
            tal:content="item/name"
            tal:attributes="value item/value;
                            selected python:test(item['value'] == l, 1, 0)" />
    </select>
</div>

[validators]
validators..Save = validate_id,validate_title
validators..Cancel =

##parameters=text_format, text, file='', SafteyBelt='', 
  title='', description='', id=''
##title=Edit a document
 
filename=getattr(file,'filename', '')
if file and filename:
    # if there is no id, use the filename as the id
    if not id:
        id = filename[max( filename.rfind('/')
                       , filename.rfind('\\')
                       , filename.rfind(':') )+1:]
    file.seek(0)
 
# if there is no id specified, keep the current one
if not id:
    id = context.getId()
 
new_context = context.portal_factory.doCreate(context, id)
new_context.edit( text_format
                , text
                , file
                , safety_belt=SafetyBelt )
 
from Products.CMFPlone import transaction_note
transaction_note('Edited source code %s at %s' % 
  (new_context.title_or_id(), new_context.absolute_url()) 
  )
 
new_context.plone_utils.contentEdit( new_context
                                   , id=id
                                   , title=title
                                   , description=description )
 
return state.set(context=new_context,
  portal_status_message='Source code changes saved.')

Installation des Produkts in Plone

Es gibt eine standardisierte Art, ein Produkt in Plone zu installieren: Sie gehen ins Plone-Control Panel und klicken auf das Produkt, um es zu installieren. Dieses Skript benutzt das Werkzeug portal_quickinstaller für die Installation. Damit dieses Produkt funktioniert, müssen Sie eine gewisse Funktionalität offen legen, die das Werkzeug lesen kann. Schließlich wollen Sie, dass so viele Leute wie möglich Ihr Produkt benutzen. Wenn Sie etwas nur für den internen Gebrauch schreiben und Sie es nicht an andere Leute verteilen, können Sie diesen Schritt auslassen. Aber Sie müssen diese Schritte sowieso von Hand ausführen, und es ist immer besser, man hat ein Skript für die Installation.

Für eine Integration mit dem Quick Installer müssen Sie ein spezielles Modul namens Install.py im Verzeichnis Extensions erstellen. Dieses Modul muss eine Funktion namens install enthalten. Das Quick Installer-Werkzeug führt die Funktion install aus, und die Ausgabe landet in einer Datei auf dem Server. Da die Methode install das Produkt in den Portal-Typen installieren muss, fügen Sie nun ein FSDV hinzu, das auf das Verzeichnis skins zeigt, und fügen dieses neue Verzeichnis zu den Skin-Ebenen hinzu.

Importieren Sie nun die Funktionen, und richten Sie die Variablen wie üblich ein. Die factory_type_information müssen Sie aus dem Produkt installieren, damit Sie es im Skript verwenden können, wie in Listing 12.8 zu sehen ist.

Listing 12.8. Der Anfang der Installationsfunktion

from Products.CMFCore.TypesTool import ContentFactoryMetadata
from Products.CMFCore.DirectoryView import createDirectoryView
from Products.CMFCore.utils import getToolByName
from Products.PloneSilverCity.PloneSilverCity import factory_type_information
 
from Products.PloneSilverCity.config import plone_product_name, product_name
from Products.PloneSilverCity.config import layer_name, layer_location
 
def install(self):
    """ Install this product """

Danach ist alles generisch und könnte auf jedem Produkt laufen, außer dann natürlich, wenn Sie möchten, dass es bei der Installation irgendwas Spezielles tut. Um Ihr Produkt zum Werkzeug portal_types hinzuzufügen, überprüfen Sie zuerst, ob Ihr Produkt schon registriert ist. Es könnte sein, dass ein anderer schon ein anderes Produkt mit dem gleichen Namen installiert hat. Dazu rufen Sie die Methode manage_addTypeInformation auf, wie in Listing 12.9 angegeben.

Listing 12-9. Rest der Installationsfunktion

out = []
typesTool = getToolByName(self, 'portal_types')
skinsTool = getToolByName(self, 'portal_skins')

if id not in typesTool.objectIds():
   typesTool.manage_addTypeInformation(
       add_meta_type =  factory_type_information['meta_type']
       id = factory_type_information['id']
       )
   out.append('Registered with the types tool')
else:
   out.append('Object "%s" already existed in the types tool' % (id))

Als Nächstes müssen Sie ein FSDV im skins-Verzeichnis hinzufügen. Wieder müssen Sie als Erstes prüfen, ob Sie nicht schon eines haben. Dann fügen Sie die Verzeichnisansicht wie folgt hinzu:

if skinname not in skinsTool.objectIds():
    createDirectoryView(skinsTool, skinlocation, skinname)
    out.append('Added "%s" directory view to portal_skins' % skinname)

Und schließlich iterieren Sie über alle Skins und fügen Ihr neues FSDV zu allen Skins hinzu. Dies ist eine generische Funktion. Jede Skin wird als String aufgeführt, in dem alle Ebenen mit Kommata voneinander getrennt sind. Nun müssen Sie den String nur noch aufteilen und Ihre neue Skin nach der Ebene namens custom einfügen wie in Listing 12.10 zu sehen ist.

Listing 12-10. Die Skin in der Installationsmethode setzen

skins = skinsTool.getSkinSelections()
for skin in skins:
    path = skinsTool.getSkinPath(skin)
    path = [ p.strip() for p in p.split(',') ]
    if skinname not in path:
        path.insert(path.index('custom')+1, skinname)

        path = ", ".join(path)
        skinsTool.addSkinSelection(skin, path)
        out.append('Added "%s" to "%s" skins' % (skinname, skin))
    else:
        out.append('Skipping "%s" skin' % skin)
return "\n".join(out)

Das wars. Nun ist Ihr Produkt bereit, ausgeführt zu werden.

Das Produkt testen

Um das Produkt zu testen, starten Sie Ihre Plone-Instanz neu, damit sie das Produktverzeichnis einliest. Wenn Sie Ihr Produkt noch nicht im entsprechenden Produktverzeichnis entwickelt haben, dann kopieren Sie es jetzt dorthin, damit es Teil Ihres normalen Installationsprozesses wird. Wenn es mit Ihrem Produkt irgendwelche Probleme gibt, dann startet Zope eventuell noch, aber das Produkt wird dann unter Umständen im Control Panel als defekt angezeigt.

Dann installieren Sie es in Plone mit Hilfe der Seite Produkte hinzufügen/löschen im Plone-Control Panel. Nun sollten Sie zu einem Ordner gehen und ein Quellcode-Objekt hinzufügen können. Das Icon wird Ihr Icon in der Skin sein, und der Name ist jener, den Sie im Dateisystem definiert haben. Danach erhalten Sie die Bearbeiten-Seite. Beachten Sie, dass die URL nun mit silvercity_edit_form endet und das passend geänderte Bearbeiten-Formular anzeigt.

Sie könnten weiteren Code hinzufügen, eine Sprache auswählen und auf Speichern klicken, oder Sie könnten eine Datei von Ihrem Computer hochladen. Nach einem Klick auf Speichern gelangen Sie zu der Anzeigefunktion zurück, und es wird hoffentlich der Code mit der hervorgehobenen Syntax angezeigt.

Dieses Produkt ist ein kleines Beispiel dafür, wie einfach man ein Produkt in Plone schreiben kann. Auch wenn es viele Seiten waren, wurden auf den meisten die Infrastruktur und die Skins eingerichtet. Es läge jetzt nahe, das mit anderen Web-Skriptsprachen wie PHP zu vergleichen. Aber Sie müssen daran denken, dass Sie dadurch, dass Ihr Code in Plone ist, eine ganze Menge Dinge erreicht haben, ohne dafür etwas neu schreiben zu müssen. Insbesondere haben Sie Folgendes erreicht:

• Volltext-Suche im Inhalt
• Integration mit dem Workflow
• Integration mit Portal-Mitgliedschaft und -Authentifikation
• Persistenz dank der Plone-Datenbank, ohne SQL schreiben oder andere Arbeit verrichten zu müssen

Außerdem kann später dadurch Ihr ganzes Produkt wirklich besser skalieren. Wenn Sie z.B. ein Bug-Tracking-System benötigen, nehmen Sie das Collector-Produkt hinzu, und wenn Sie ein Produkt zur Bilderverwaltung benötigen, nehmen Sie CMFPhoto. Indem Sie das Framework verwenden, verleihen Sie Ihrer ganzen Site eine Menge an Flexibilität und Skalierbarkeit.

Auch wenn dieses Produkt insofern ein wenig mogelt, als dass es eine Menge an vorhandenem Code wiederverwendet, so demonstriert es doch eine ganze Reihe von Schlüsselfunktionen beim Schreiben eines Produkts in Plone.

Fehlersuche bei der Entwicklung

Wenn Sie Ihr eigenes Produkt entwickeln, werden Sie früher oder später zwei Dinge feststellen (es sei denn, Sie verfügen über so viel Zen, dass Sie eigentlich am Code des Zope-Kerns mitschreiben sollten): Ihr Produkt versagt, und Sie müssen den Fehler finden.

Während der Entwicklung möchten Sie eventuell versuchen, das Produkt vom Python-Prompt aus zu importieren, um zu sehen, wie es funktioniert. Leider werden Sie dabei sehr wahrscheinlich einen Fehler bekommen. Das liegt daran, dass Sie bei diesem Import eine Lawine an Zope-bezogenen Imports auslösen. Mit einigen davon können Sie fertig werden, aber nicht mit allen. Eines der häufigen Probleme besteht darin, dass Sie den folgenden Fehler bekommen:

Traceback (most recent call last):
  File "<stdin>", line 1, in ?
  File "PloneSilverCity/__init__.py", line 1, in ?
    import PloneSilverCity
  File "PloneSilverCity/PloneSilverCity.py", line 4, in ?
    from Globals import InitializeClass
  File "/opt/Zope-2.7/lib/python/Globals.py", line 23, in ?
    import Acquisition, ComputedAttribute, App.PersistentExtra, os
  File "/opt/Zope-2.7/lib/python/App/PersistentExtra.py", line 15, in ?
    from Persistence import Persistent
ImportError: cannot import name Persistent

Das können Sie lösen, indem Sie sicherstellen, dass Sie vor dem Import von PloneSilverCity erst Zope importieren und die Startup-Methode ausführen. Um Zope importieren zu können, muss das Verzeichnis, das Zope enthält, in Ihrem Pfad enthalten sein. Auf meinem Computer ist das /opt/Zope-2.7/lib/python. Allerdings werden Sie dann beim Versuch, CMFCore zu importieren, Fehler erhalten, falls Sie Zope mit der Option "Instance Home" konfiguriert haben, was vermutlich der Fall ist.

Am leichtesten kann man PloneSilverCity importieren, indem man Zope mit zopectl von der Kommandozeile im Debug-Modus ausführt. Dabei wird ein Python-Prompt aufgemacht, unter dem Sie von Python direkt auf die Zope-Datenbank zugreifen können. Kapitel 14 behandelt das etwas detaillierter, aber Sie können es auch leicht jetzt tun (vorausgesetzt, dass Ihr Zope gerade nicht läuft). Das Skript zopectl finden Sie im Verzeichnis bin Ihrer Zope-Instanz. Auf meinem Computer z.B. ist das /var/zope/bin. Listing 12.11 zeigt ein Beispiel eines laufenden zopectl mit PloneSilverCity.

Listing 12.11. Fehlersuche im Produkt mittels Zope

$ cd /var/zope/bin
$ ./zopectl debug
Starting debugger (the name "app" is bound to the top-level Zope object)
>>> from PloneSilverCity.PloneSilverCity import PloneSilverCity
>>> p = PloneSilverCity("test")
>>> p.edit("python", "import test")
>>> p.getRawCode()
'import test'
>>> p
<PloneSilverCity at test>

Falls Ihr Produkt defekt ist, bekommen Sie einen Traceback zu einer von zwei Stellen, entweder zur Fehlerprotokollseite oder zu einem der Ereignisprotokolle. Und wenn Sie es wirklich vermasselt haben, dann startet Plone erst gar nicht. Das passiert normalerweise, wenn ein Import fehlschlägt. Wenn das der Fall ist, startet Plone gar nicht erst. Ich empfehle dann, Plone von der Kommandozeile aus zu starten, egal ob unter Windows oder Linux. Mit der Ausgabe des Fehlers in der Konsole haben Sie eine sofortige Fehlermeldung. Listing 12.12 z.B. zeigt, was passiert, wenn Sie versuchen, Plone mit SilverCity zu starten, falls dabei ein beliebiger Import-Fehler auftritt.

Listing 12.12. Ein Beispielfehler beim Hochfahren

$ bin/runzope
------
2003-12-19T17:44:05 INFO(0) ZServer HTTP server started at Fri Dec 19 17:44:05 2003
        Hostname: laptop
        Port: 8080
------
2003-12-19T17:44:05 INFO(0) ZServer FTP server started at Fri Dec 19 17:44:05
2003
        Hostname: basil.agmweb.ca
        Port: 8021
------
2003-12-19T17:44:16 ERROR(200) Zope Could not import Products.PloneSilverCity
Traceback (most recent call last):
  File "/opt/Zope-2.7/lib/python/OFS/Application.py", line 533, in import_product
    product=__import__(pname, global_dict, global_dict, silly)
  File "/var/zope.zeo/Products/PloneSilverCity/__init__.py", line 1, in ?
    import PloneSilverCity
  File "/var/zope.zeo/Products/PloneSilverCity/PloneSilverCity.py", line 1
     import ThisModuleDoesNotExist
                                  ^
 ImportError: No module named ThismoduleDoesNotExist

An diesem Punkt stoppt Zope, und Sie müssen diesen Import reparieren, bevor Sie es erneut starten können. Wahrscheinlich ist das der am leichtesten zu reparierende Fehler. Er kommt aber wahrscheinlich nur dann vor, wenn Sie das neueste hippige Produkt aus dem Internet installieren, um festzustellen, dass es von einem Dutzend anderen Modulen abhängt.

Die nächste Art möglicher Fehler ist die von Fehlern innerhalb des Programms oder der Programmlogik. Angenommen, Ihr Produkt addiert zwei Zahlen, von denen eine aber ein String ist (was in Python ein Fehler ist). Es wird eine Fehlerausnahme aufgelöst, die Plone mit dem Fehlerwert und -typ an die Benutzerschnittstelle weitergibt. An dieser Stelle sollten Sie auf Plone-Konfiguration und Fehlerprotokoll klicken, um den Traceback anzuschauen, den Fehler zu finden und das Problem zu lösen.

Wenn Sie etwas im Produkt ändern, wird diese Änderung in Python nicht sofort umgesetzt. Um das zu erzwingen, müssen Sie ein Produkt namens Refresh verwenden. Das ist ein unglaublich nützliches Werkzeug für neue Entwickler, das Sie dadurch aktivieren, dass Sie eine Datei namens refresh.txt in Ihrem Verzeichnis Products haben. Sie werden bemerken, dass PloneSilverCity eine solche hat. Dann wählen Sie im ZMI das Control Panel, dann Products, gefolgt von PloneSilverCity (oder dem Namen Ihres Produkts), und klicken anschließend auf den Refresh-Reiter. Falls Ihr Produkt eine Datei namens refresh.txt enthält, können Sie auf den Refresh-Button klicken. Plone wird Ihr Produkt dann dynamisch mitsamt dem ganzen neuen Code neu laden. Falls Sie Zope im Debug-Modus betreiben, können Sie das Produkt so einstellen, dass es diese Überprüfung bei jedem Lauf dynamisch vornimmt, so dass Sie nicht jedes Mal zu diesem Bildschirm zurückkehren müssen.

Leider gibt es hierbei nicht nur Vorteile. Hinter den Kulissen passieren nämlich einige recht "interessante" Dinge mit Python, damit das funktioniert. Tatsächlich kann das Refresh-Produkt zu unerwarteten Ergebnissen in Ihrem Produkt führen, wenn auch zu nichts, was nicht durch einen Neustart von Zope zu reparieren wäre. Relativ einfache Produkte, die lediglich Manipulationen an Daten vornehmen, werden keine Probleme haben, andere hingegen schon. Zu Beginn werden Ihre Produkte jedoch eher einfacher Natur sein, und die Chancen stehen gut, dass Sie an dieser Stelle keine Probleme haben werden.

Und wenn schließlich doch etwas schief geht und Sie nicht herausfinden können, was es ist, dann müssen Sie zu einem Debugger greifen. Sie haben derart viele Möglichkeiten bei der Fehlersuche mit Zope, dass ich hier nur die eine beschreiben möchte, die ich selbst am meisten benutze, den Python-Debugger. Diesen Python-Debugger rufen Sie auf, indem Sie die folgende Zeile zu einem Stück Code hinzufügen:

import pdb; pdb.set_trace()

Das bewirkt, dass ein Breakpoint in der Ausführung des Codes gesetzt wird, an dem Zope die Abarbeitung anhält und den Debugger aufruft. Das ist der Grund, warum man während der Entwicklung Plone wirklich besser von einer Konsole startet. Mit einem Dienst oder Daemon funktioniert das nicht, weil es keine Konsole gibt, mit der eine Verbindung möglich wäre. Wenn Sie Ihr Problem nun reproduzieren, gelangen Sie zum Python-Debugger, mit dem Sie den Fehler in Ihrem Produkt suchen können. In meinem nun reparierten und korrekt importierenden PloneSilverCity habe ich z.B. die folgende pdb-Trace-Funktion in die Methode getLanguages gesetzt:

def getLanguages(self):
     """ Returns the list of languages available """
     import pdb; pdb.set_trace()
     langs = []
     ...

Wenn Sie Zope nun starten und sich mit der Skin verbinden (was Sie bald hinzufügen werden), wird diese Funktion aufgerufen, und in der Konsole, in der Sie Zope gestartet haben, werden Sie Folgendes sehen können:

--Return--
> /var/tmp/python2.3-2.3.2-root/usr/lib/python2.3/pdb.py(992)set_trace()->None
-> Pdb().set_trace()
(Pdb)

Um eine Liste von Hilfestellungen zu erhalten, können Sie help eingeben. Die zwei wesentlichen Optionen sind n für nächstes und s für einen Schritt in ein Element hinein. Beispiel:

(Pdb) n
> /var/zope.zeo/Products/PloneSilverCity/PloneSilverCity.py(97)getLanguages()
-> langs = []
(Pdb) n
> /var/zope.zeo/Products/PloneSilverCity/PloneSilverCity.py(99)getLanguages()
-> for value, description in list_generators():
(Pdb) langs
[]

Für weitere Informationen zum Debugger empfehle ich die Online-Dokumentation auf der Python-Website (http://python.org/doc/current/lib/module-pdb.html). Sie haben auch andere Möglichkeiten, Fehler mit Zope zu suchen, z.B. können Sie ZEO verwenden, um einen Interpreter zu bekommen. ZEO wird in Kapitel 14 behandelt. Mit integrierten Entwicklerumgebungen wie Wing (http://wingide.com/wingide) oder Komodo (http://www.activestate.com/Products/Komodo) können Sie Fehler in Zope-Instanzen auch auf entfernten Rechnern suchen und haben dabei noch eine nette grafische Benutzerschnittstelle.

Das Werkzeug starten

Das Werkzeug sollten Sie auf die gleiche Weise in ein Produktverzeichnis setzen, wie Sie es beim Inhaltstyp gemacht haben, d.h., indem Sie ein Verzeichnis innerhalb des Produktverzeichnisses der Instanz erstellen. In diesen Ordner fügen Sie die Dateien refresh.txt, install.txt, readme.txt und __init__.py hinzu.

In diesem Verzeichnis lautet der Name des Hauptmoduls stats.py. Es enthält den gesamten Code zur Erstellung der Statistiken. Auch hier behandle ich das Aussehen des Moduls, ohne zusätzlichen Zope-Code zu betrachten. Da Sie es aber direkt mit den anderen Plone-Werkzeugen koppeln, macht es allerdings wenig Sinn, es außerhalb von Zope zu benutzen.

Listing 12.13 zeigt den Anfang des Werkzeugs. Dies ist eine einfache Version, die über zwei Methoden verfügt: eine, die die Anzahl der Inhaltstypen nach Typ und Workflow-Zustand zurückgibt, und eine andere für Benutzer, die die Gesamtzahl der Benutzer der Site zurückgibt.

Listing 12.13. Das grundlegende Statistik-Objekt

class Stats:
    def getContentTypes(self):
        """ Returns the number of documents by type """
        pc = getToolByName(self, "portal_catalog")
        # call the catalog and loop through the records
        results = pc()
        numbers = {"total":len(results),"bytype":{},"bystate":{}}
        for result in results:
            # set the number for the type
            ctype = str(result.Type)
            num = numbers["bytype"].get(ctype, 0)
            num += 1
            numbers["bytype"][ctype] = num
 
            # set the number for the state
            state = str(result.review_state)
            num = numbers["bystate"].get(state, 0)
            num += 1
            numbers["bystate"][state] = num
        return numbers
 
    def getUserCount(self):
        """ The number of users """
        pm = getToolByName(self, "portal_membership")
        count = len(pm.listMemberIds())
        return count

Das Paket in ein Werkzeug umwandeln

Um das Paket in ein Werkzeug umzuwandeln, müssen Sie den gleichen Prozess wie beim Inhaltstyp durchmachen. Mit anderen Worten, Sie müssen das Werkzeug im Modul __init__.py registrieren. Genau wie beim Beispiel mit dem Inhaltstyp erstellen Sie eine Datei namens config.py, die alle Konfigurationen enthält. Diese Datei sieht wie folgt aus:

from Products.CMFCore import CMFCorePermissions
 
view_permission = CMFCorePermissions.ManagePortal
 
product_name = "PloneStats"
unique_id = "plone_stats"

Die Sicherheit bei diesem Produkt ist einfacher, was daran liegt, dass das Produkt selbst recht einfach ist. Es interagiert lediglich mit anderen Werkzeugen und produziert einige Statistiken. Es gibt nichts, was Benutzer hinzufügen, bearbeiten oder löschen könnten, oder etwas, mit dem sie sonstwie interagieren könnten. Das heißt, Sie haben es nur mit einem einzigen Recht, ManagePortal, zu tun, dem Recht nämlich, die Konfiguration von Plone zu verwalten, das normalerweise nur an Manager vergeben wird. Also können nur Manager ins ZMI gehen und die Information sehen, die das Werkzeug bietet. Wenn Sie wollten, könnten Sie recht einfach eine hübsch ausschauende Skin für das Plone-Control Panel oder ein Portlet hinzufügen, das diese Information in Ihrer Site darstellt.

Was __init__.py anbelangt, fügen Sie nun den Initialisierungscode für das Werkzeug hinzu. Es gibt ein besonderes Initialisierungsskript für Werkzeuge namens ToolInit. In diesem Werkzeug sieht die Datei __init__.py wie folgt aus:

from Products.CMFCore import utils
from stats import Stats
from config import product_name
 
tools = (stats.Stats,)
 
def initialize(context):
    init = utils.ToolInit( product_name,
                    tools = tools,
                    product_name = product_name,
                    icon='tool.gif'
                    )
init.initialize(context)

Die Funktion ToolInit kann mehrere Werkzeuge annehmen. In diesem Fall haben Sie es aber nur mit einem zu tun. Bei mehreren Werkzugen können Sie nur einen Produktnamen und ein Produkt-Icon haben, das im ZMI angezeigt wird. Das ist alles, was man braucht, um das Werkzeug zu registrieren. Nun müssen Sie das Hauptmodul vervollständigen, um es in ein echtes Werkzeugobjekt zu verwandeln.

Den Werkzeug-Code ändern

Als Nächstes fügen Sie den Code zu der Klasse hinzu, um ihn in ein Werkzeug umzuwandeln. Wie beim Inhaltstyp besteht dieser Schritt nur aus dem Hinzufügen der Sicherheit durch Ableitung von den korrekten Basisklassen, z.B. so:

from Globals import InitializeClass
from OFS.SimpleItem import SimpleItem
from AccessControl import ClassSecurityInfo
 
from Products.CMFCore.utils import UniqueObject, getToolByName

Die Klasse SimpleItem ist die vorgegebene Basisklasse für ein einfaches Objekt in Zope (nicht für einen Ordner). Tatsächlich erben alle Inhaltstypen von einer Klasse, die irgendwo in der Klassenhierarchie von SimpleItem erbt. Es ist nur so, dass Sie die ganzen zusätzlichen Attribute dieser anderen Klassen nicht benötigen. UniqueObject garantiert, dass es genau eine Instanz dieses Objekts in Ihrer Plone-Site gibt und dass sie nicht umbenannt oder verschoben werden kann. Das heißt, Ihr Objekt wird immer verfügbar sein.

Als Nächstes importieren Sie wie üblich die Variablen aus der Konfigurationsdatei. Durch die Zuweisung an die ID Ihres Objekts garantieren Sie, dass das Werkzeug die ID dessen haben wird, was immer unique_id in der Konfigurationsdatei ist - in diesem Fall plone_stats. Die zwei Basisklassen für das Werkzeug sind UniqueObject und SimpleItem, die das Minimum dessen darstellen, was es benötigt. Beispiel:

from config import view_permission, product_name, unique_id
 
class Stats(UniqueObject,  SimpleItem):
    """ Prints out statistics for a Plone site """
    meta_type = product_name
    id = unique_id

Dann müssen Sie die Sicherheit einrichten, wobei Sie wiederum die Klasse ClassSecurityInfo benutzen werden, um explizit Rechte an den Methoden zu setzen. Beispiel:

security = ClassSecurityInfo()
security.declareProtected(view_permission, 'getContentTypes')
def getContentTypes(self):
    ...

Das Werkzeug testen

Nun ist das Werkzeug fertig, d.h., Sie können testen, ob es funktioniert. Zuerst starten Sie Ihre Plone-Instanz neu, damit sie das Produktverzeichnis einliest und Ihr neues Werkzeug registriert. Als Zweites gehen Sie ins ZMI und dort in die obere rechte Ecke zum Dropdown-Menü namens Add. Sie werden feststellen, dass in der Liste nun PloneStats aufgeführt ist. Wählen Sie diese Option, und klicken Sie auf Add. Das nächste Formular listet die verfügbaren Werkzeuge im Produkt PloneStats auf, in diesem Fall erscheint nur eines, wie in Abbildung 12.3 zu sehen ist.

Abbildung 12.3. Hinzufügen des Werkzeugs

Wählen Sie das Werkzeug, und klicken Sie auf Add. Klicken Sie dann auf das Werkzeug, um zu testen, ob es funktioniert. Sie sollten eine Reihe von Statistiken sehen, wie Sie sie zuvor für ZopeZen gesehen haben.

Dieses Werkzeug ist einfach, weil ich nicht wirklich weiß, welche Art von Darstellung die Leute gerne hätten. Wenn ich ein standardisiertes Berichtwerkzeug erstelle, dann können Sie es benutzen, wie Sie wollen. Einige Ideen, die einem dafür einfallen, sind z.B. eine Seite im Control Panel, ein kleiner Portlet-Kasten, eine PDF-Datei (Portable Document Format) mit hübschen Grafiken, die via E-Mail an einen Manager verschickt wird, oder eine API, damit externe Berichtswerkzeuge wie Crystal Reports mein Werkzeug benutzen können. An dieser Stelle warte ich ab und beobachte, was in der Zukunft alles passiert.