root/cpsskins/branches/paris-sprint-2006/thememanager.py

##############################################################################
#
# Copyright (c) 2005-2006 Nuxeo and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""

$Id$
"""
__docformat__ = "reStructuredText"

import logging

from zope.app.container.btree import BTreeContainer
from zope.app.container.interfaces import INameChooser
from zope.component import getUtility
from zope.component.persistentregistry import PersistentComponents
from zope.interface import implements, Interface
from zope.i18nmessageid import MessageFactory
from zope.traversing.api import getName, getParent

from cpsskins.caching import ImageCache, IImageCache
from cpsskins.elements.interfaces import IFormattable
from cpsskins.elements.interfaces import ITheme, IThemePage, IThemeContainer
from cpsskins.ontology import isDefault, hasFormat
from cpsskins.perspectives import Perspective
from cpsskins.perspectives.interfaces import IPerspective
from cpsskins.relations import MonadicRelation
from cpsskins.setup.interfaces import IResourceManager, IResource
from cpsskins.setup.presets import Presets, IPresets
from cpsskins.storage.formats import FormatStorage, IFormatStorage
from cpsskins.storage.locations import LocationStorage, ILocationStorage
from cpsskins.storage.portlets import PortletStorage, IPortletStorage
from cpsskins.storage.relations import RelationStorage, IRelationStorage
from cpsskins.storage.snapshots import ISnapshotStorage, SnapshotStorage
from cpsskins.uids import IUids, Uids

logger = logging.getLogger("cpsskins")

_ = MessageFactory("cpsskins")

def added(object, event):
    object.registerUtilities()

class IThemeManagementFolder(Interface):
    """Interface for theme management.

    The methods may be moved to other classes.
    """

    def registerUtilities():
        """Register the various components."""

    def getIdRegistry():
        """Return the unique id registry."""

    def getImageCache():
        """Return the image cache."""

    def getRelationStorage():
        """Return the relation storage."""

    def getFormatStorage():
        """Return the format storage."""

    def getPortletStorage():
        """Return the portlet storage."""

    def getLocationStorage():
        """Return the location storage."""

    def getSnapshotStorage():
        """Return the snapshot storage."""

    def getPresets():
        """Return the presets."""

    def registerElement(element):
        """Add an element to the unique id registry."""

    def unregisterElement(element):
        """Remove an element from the unique id registry."""

    def getElementById(id):
        """Return an element by its unique id. """

    def addTheme(theme, name):
        """Add a theme."""

    def addPage(theme, page, name):
        """Add a page."""

    def getThemes():
        """Return the list of available themes."""

    def getPages(theme):
        """Return the list of available pages in a theme."""

    def deleteTheme(name):
        """Delete a theme."""

    def deleteAllThemes():
        """Delete all themes."""

    def getThemeByName(name):
        """Return a theme by its name."""

    def getPageByName(name):
        """Return a page by its name."""

    def isDefault(object):
        """Return true if the object is used by default."""

    def setAsDefault(object):
        """Set the object as a default object."""

    def getDefaultTheme():
        """Return the default theme."""

    def getDefaultPage(theme):
        """Return the default page of a theme."""

    def removeFormats(object):
        """Remove the formats of an element"""

    def listPerspectives():
        """Return the list of perspectives."""

    def addPerspective(perspective, id):
        """Add a perspective to the storage"""

    def getLocation(context):
        """Return the location in a given context"""

class ThemeManagementFolder(BTreeContainer, PersistentComponents):
    """A theme management utility that can contain multiple .
    themes

    >>> from zope.interface.verify import verifyClass
    >>> verifyClass(IThemeManagementFolder, ThemeManagementFolder)
    True

    """
    implements(IThemeManagementFolder, IThemeContainer)

    def __init__(self):
        BTreeContainer.__init__(self)
        PersistentComponents.__init__(self)
        # registries, storages, etc.
        self[u'uids'] = Uids()
        self[u'imagecache'] = ImageCache()
        self[u'presets'] = Presets()
        self[u'relations'] = RelationStorage()
        self[u'portlets'] = PortletStorage()
        self[u'formats'] = FormatStorage()
        self[u'locations'] = LocationStorage()
        # snapshots
        self[u'snapshots'] = SnapshotStorage()

    ###################################################################
    # Local utilities
    ###################################################################

    def registerUtilities(self):
        self.registerUtility(self[u'uids'], IUids)
        self.registerUtility(self[u'snapshots'], ISnapshotStorage)
        self.registerUtility(self[u'imagecache'], IImageCache)
        self.registerUtility(self[u'presets'], IPresets)
        self.registerUtility(self[u'relations'], IRelationStorage)
        self.registerUtility(self[u'portlets'], IPortletStorage)
        self.registerUtility(self[u'formats'], IFormatStorage)
        self.registerUtility(self[u'locations'], ILocationStorage)

    def getIdRegistry(self):
        return self.getUtility(IUids)

    def getImageCache(self):
        return self.getUtility(IImageCache)

    def getRelationStorage(self):
        return self.getUtility(IRelationStorage)

    def getFormatStorage(self):
        return self.getUtility(IFormatStorage)

    def getPortletStorage(self):
        return self.getUtility(IPortletStorage)

    def getLocationStorage(self):
        return self.getUtility(ILocationStorage)

    def getSnapshotStorage(self):
        return self.getUtility(ISnapshotStorage)

    def getPresets(self):
        return self.getUtility(IPresets)

    ###################################################################
    # Unique id registry
    ###################################################################

    def registerElement(self, element):
        intids = self.getIdRegistry()
        id = intids.queryId(element)
        if id is None:
            id = intids.register(element)
            # store the element's id in the element itself.
            element.identifier = id
        else:
            logger.debug("The element %s is already registered. "
                         "No need to register it again.", repr(element))
        return id

    def unregisterElement(self, element):
        try:
            self.getIdRegistry().unregister(element)
        except KeyError:
            logger.debug("The element %s is not registered", repr(element))

    def getElementById(self, id):
        return self.getIdRegistry().getObject(int(id))

    ###################################################################
    # Themes and pages
    ###################################################################

    def addTheme(self, theme, name=u''):
        if not ITheme.providedBy(theme):
            raise("Must specify a theme.")

        name = INameChooser(self).chooseName(name, theme)
        self[name] = theme
        return name

    def addPage(self, theme, page, name=u''):
        if not IThemePage.providedBy(page):
            raise("Must specify a theme page.")

        name = INameChooser(theme).chooseName(name, page)
        theme[name] = page
        return name

    def getThemes(self):
        return [theme for name, theme in self.getUtilitiesFor(ITheme)]

    def getPages(self, theme):
        return [page for name, page in theme.getUtilitiesFor(IThemePage)]

    def deleteTheme(self, name):
        for k, v in self.getUtilitiesFor(ITheme):
            if k == name:
                del self[getName(v)]
                return

        raise KeyError("No such theme: %s." % name)

    def deleteAllThemes(self):
        for k, v in self.getUtilitiesFor(ITheme):
            del self[getName(v)]

    def getThemeByName(self, name):
        for k, v in self.getUtilitiesFor(ITheme):
            if k == name:
                return v
        return None

    def getPageByName(self, name):
        theme_name, page_name = name.split(u':')
        theme = self.getThemeByName(theme_name)
        if theme is None:
            return None
        for k, v in theme.getUtilitiesFor(IThemePage):
            if k == page_name:
                return v
        return None

    def isDefault(self, object):
        relations = self.getRelationStorage()
        res = relations.search(predicate=isDefault, first=object)
        return bool(res)

    def setAsDefault(self, object):
        relations = self.getRelationStorage()
        relations.add(MonadicRelation(isDefault, object))
        defaults = []
        for o in object.getSiblings():
            defaults.extend(relations.search(predicate=isDefault, first=o))
        relations.remove(defaults)

    def getDefaultTheme(self):
        for theme in self.getThemes():
            if theme.isDefault():
                return theme
        return None

    def getDefaultPage(self, theme):
        for page in theme.getPages():
            if page.isDefault():
                return page
        return None

    ###################################################################
    # Formats
    ###################################################################

    def removeFormats(self, object):

        # Physically remove the formats
        formats = self.getFormatStorage()
        formats.remove([getName(f) for f 
                        in IFormattable(object).getFormats(resolve=False)])

        # Remove the relation
        relations = self.getRelationStorage()
        format_relations = relations.search(first=object, predicate=hasFormat)
        relations.remove(format_relations)

    ###################################################################
    # Perspectives
    ###################################################################

    def listPerspectives(self):
        resources = getUtility(IResourceManager)
        return [IResource(r).getResource() for r in
                resources.list(type=IPerspective, context=self)]

    def addPerspective(self, name, title):
        perspective = Perspective(name)
        resources = getUtility(IResourceManager)
        resources.register(name=name, resource=perspective, context=self)

    ###################################################################
    # Locations
    ###################################################################

    def getLocation(self, path, root=u''):
        locations = self.getLocationStorage()
        return locations.find(path, root)