root/trunk/__init__.py

# Copyright 2006 by the LeMill Team (see AUTHORS)
#
# This file is part of LeMill.
#
# LeMill is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# LeMill is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with LeMill; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

from config import *
import config

# CMF imports
from Products.CMFCore import utils 
from Products.CMFCore.DirectoryView import registerDirectory, registerFileExtension
from Products.CMFPlone import MigrationTool

# BEGIN: PLONE 2.1 portion
from Products.CMFPlone.Portal import addPolicy
from Products.CMFPlone.interfaces.CustomizationPolicy import ICustomizationPolicy
from Products.CMFPlone.CustomizationPolicy import DefaultCustomizationPolicy
# END: PLONE 2.1 portion

if PLONE25:
    from Products.CMFPlone.interfaces import IPloneSiteRoot
    from Products.GenericSetup import profile_registry, BASE, EXTENSION

# Zope's HTTPResponse uses iso-8859-15 as its default encoding
# This is not normally used if the HTTPResponse knows which encoding
# has been requested. However, for status messages the headers are
# not set, so we need to hack the default to utf-8.
from ZPublisher import HTTPResponse
HTTPResponse.default_encoding='utf-8'

#XXX KALA

from Products.CMFCore.FSFile import FSFile
registerFileExtension ('ttf', FSFile)
registerFileExtension ('xml', FSFile)

# Import "LeMillMessageFactory as _" to create message ids in the plone domain
# Zope 3.1-style messagefactory module
# BBB: Zope 2.8 / Zope X3.0
try:
    from zope.i18nmessageid import MessageFactory
except ImportError:
    from messagefactory_ import LeMillMessageFactory
else:
    LeMillMessageFactory = MessageFactory('lemill')

from messagefactory_ import i18nme

# Provide backward compatibility for products relying on this import location
# BBB: Remove in Plone 3.0
import transaction


# Archetypes imports
from Products.Archetypes.public import process_types, listTypes

# Our own content types
import Piece, Material, LargeSectionFolder, Activity, Tool, Collection, MemberFolder, GroupBlog, BlogPost
import PresentationMaterial, MultimediaMaterial, ExerciseMaterial, LessonPlan, SchoolProjectMaterial
import CommonMixIn, Resource, LearningResource, Discussable
import LeMillReference, PILOTMaterial, LeMillPrintResource
from CommonMixIn import Redirector

# Our own portal tools
import LeMillSearchTool, LeMillTool, LeMillUserTool, LatexTool, LeMillFactoryTool, LeMillCatalogTool, MaintenanceTool
# Make a list of portal tools
tools = (LeMillTool.LeMillTool, LeMillSearchTool.LeMillSearchTool, LeMillUserTool.LeMillUserTool, LatexTool.LatexTool, LeMillFactoryTool.FactoryTool, LeMillCatalogTool.CatalogTool, MaintenanceTool.MaintenanceTool)

# Our own configuration stuff
from ConfigurationMethods import LeMillSetup

# HOOK: Anything executed here will be executed any time the product is refreshed
# or Zope is restarted.

# Add the skins folder to the registry of viewable folders
registerDirectory(SKINS_DIR,GLOBALS)

def initialize(context):
    """This method is called when this product is initialized upon Zope startup."""

    # Add our setup widgets into MigrationTool
    MigrationTool.registerSetupWidget(LeMillSetup)

    # making config accessible from python scripts.
    from AccessControl import allow_module, ModuleSecurityInfo
    #ModuleSecurityInfo('config').declarePublic()
    #allow_module('Products.LeMill.config')
    allow_module('Products.LeMill.Validators')

    # Register our extension profile / customization policy
    if PLONE25:
        try:
            profile_registry.registerProfile(name='LeMill',
                                             title='LeMill Site',
                                             description="LeMill is a heavily customized Plone for special use, and can't be converted to a normal Plone very easily.",
                                             path='profiles/legacy',
                                             product='LeMill',
                                             profile_type=EXTENSION,
                                             for_=IPloneSiteRoot)
        except KeyError:
            # Already done - ignore
            pass
                                         
    addPolicy('LeMill Site',LeMillCustomizationPolicy())

    # Register our set of portal tools
    utils.ToolInit(PROJECTNAME + ' Tools', tools=tools, 
        icon='skins/lemill/tool.gif',).initialize(context)

    # Process all imported content types into nice lists
    content_types, constructors, ftis = process_types(
        listTypes(PROJECTNAME),
        PROJECTNAME)

    # Register our set of content types
    utils.ContentInit(
        PROJECTNAME + ' Content',
        content_types      = content_types,
        permission         = ADD_CONTENT_PERMISSION,
        extra_constructors = constructors,
        fti                = ftis,
        ).initialize(context)


class LeMillCustomizationPolicy(DefaultCustomizationPolicy):
    """Customization policy for the LeMill site."""
    __implements__ = ICustomizationPolicy

    # Yes, this can be used when creating a new Plone instance
    availableAtConstruction=True

    def customize(self,portal):
        """This method is called when a Plone portal is created with this
        customization policy."""
        
        # Call super class, just in case they do something intelligent
        DefaultCustomizationPolicy.customize(self,portal)
        
        # Locate our migration widget
        widget = portal.portal_migration._getWidget('LeMill Setup')
        
        # Add and execute all configuration methods that it lists as being available
        widget.addItems(widget.available())