def initialize( context ):
from Products.CMFCore.utils import ContentInit
from Products.CMFCore.utils import ToolInit
from Products.CMFCore.DirectoryView import registerDirectory
from Products.GenericSetup import EXTENSION
from Products.GenericSetup import profile_registry
import Event
import CalendarTool
from permissions import AddPortalContent
tools = ( CalendarTool.CalendarTool, )
ToolInit( 'CMF Calendar Tool'
, tools=tools, icon='tool.gif'
).initialize( context )
contentConstructors = (Event.addEvent,)
contentClasses = (Event.Event,)
ContentInit( 'CMF Event'
, content_types = contentClasses
, permission = AddPortalContent
, extra_constructors = contentConstructors
).initialize( context )
profile_registry.registerProfile('default',
'CMFCalendar',
'Adds calendar support.',
'profiles/default',
'CMFCalendar',
EXTENSION)
registerDirectory('skins', cmfcalendar_globals)
context.registerHelpTitle('CMF Calendar Help')
context.registerHelp(directory='help')
def install_subskin(self, out, skin_name, globals=types_globals):
homedir = package_home(globals)
log("Skins are in the %s subdirectory of %s" % (skin_name, homedir))
skinstool = getToolByName(self, "portal_skins")
if skin_name not in skinstool.objectIds():
registerDirectory(skin_name, homedir)
try:
addDirectoryViews(skinstool, skin_name, homedir)
except:
log("Error adding directory views for " + skin_name)
for skinName in skinstool.getSkinSelections():
path = skinstool.getSkinPath(skinName)
path = [i.strip() for i in path.split(",")]
# Delete it if it already exists, so it only exists once.
for skin_dir in SKIN_DIRS:
if skin_dir in path:
path.remove(skin_dir)
try:
if skin_dir not in path:
path.insert(path.index("custom") + 1, skin_dir)
except ValueError:
if skin_dir not in path:
path.append(skin_dir)
path = ",".join(path)
skinstool.addSkinSelection(skinName, path)
def _registerDirectory(self,object=None):
from Products.CMFCore.DirectoryView import registerDirectory
from Products.CMFCore.DirectoryView import addDirectoryViews
registerDirectory(self._skinname, self.tempname)
if object is not None:
ob = self.ob = DummyFolder()
addDirectoryViews(ob, self._skinname, self.tempname)
def initialize( context ):
from Products.CMFCore.utils import ContentInit
from Products.CMFCore.DirectoryView import registerDirectory
from Products.GenericSetup import EXTENSION
from Products.GenericSetup import profile_registry
import Topic
import SimpleStringCriterion
import SimpleIntCriterion
import ListCriterion
import DateCriteria
import SortCriterion
from permissions import AddTopics
context.registerHelpTitle( 'CMF Topic Help' )
context.registerHelp( directory='help' )
# CMF Initializers
ContentInit( 'CMF Topic Objects'
, content_types = (Topic.Topic,)
, permission = AddTopics
, extra_constructors = (Topic.addTopic,)
).initialize( context )
registerDirectory( 'skins', cmftopic_globals )
profile_registry.registerProfile('default',
'CMFTopic',
'Adds topic portal type.',
'profiles/default',
'CMFTopic',
EXTENSION)
def initialize(context):
registerDirectory(SKINS_DIR, GLOBALS)
ToolInit("{0} Tool".format(PKG_NAME),
tools = (HumaineMailmanTool,),
icon = ICON
).initialize(context)
def initialize(context):
# register directory views
registerDirectory(SKINS_DIR, GLOBALS)
# Register kss extension to allow it used from fs skins
registerFileExtension('kss', FSFile)
def setUp(self):
self._trap_warning_output()
from Products.CMFCore.DirectoryView import registerDirectory
from Products.CMFCore.DirectoryView import addDirectoryViews
registerDirectory('fake_skins', _prefix)
self.ob = DummyFolder()
addDirectoryViews(self.ob, 'fake_skins', _prefix)
def initialize( context ):
from Products.CMFCore.DirectoryView import registerDirectory
from Products.CMFCore.utils import ToolInit
try:
from Products.CMFSetup import EXTENSION
from Products.CMFSetup import profile_registry
has_profile_registry = True
except ImportError:
has_profile_registry = False
import ActionIconsTool
ToolInit( meta_type='CMF Action Icons Tool'
, tools=( ActionIconsTool.ActionIconsTool, )
, icon="tool.gif"
).initialize( context )
registerDirectory('skins', cmfactionicons_globals)
if has_profile_registry:
profile_registry.registerProfile('actionicons',
'CMFActionIcons',
'Adds action icon tool / settings.',
'profiles/actionicons',
'CMFActionIcons',
EXTENSION)
def createDocumentationDirectoryViews(self, product):
""""""
try:
registerDirectory(DOCUMENTATION_DIR, GLOBALS)
except OSError, ex:
if ex.errno == 2: # No such file or directory
return
raise
def initialize(context):
registerDirectory('skins', tinymce_globals)
from Products.CMFCore import utils
utils.ToolInit("%s Tool" % PROJECTNAME,
tools=tools,
icon="browser/images/tinymce_icon.gif",
).initialize(context)
def _registerDirectory(self, object=None, ignore=None):
self._trap_warning_output()
from Products.CMFCore.DirectoryView import registerDirectory
from Products.CMFCore.DirectoryView import addDirectoryViews
if ignore is None:
from Products.CMFCore.DirectoryView import ignore
registerDirectory(self._skinname, self.tempname, ignore=ignore)
if object is not None:
ob = self.ob = DummyFolder()
addDirectoryViews(ob, self._skinname, self.tempname)
def addTestLayer(self):
# Install test_captcha skin layer
registerDirectory("tests", GLOBALS)
skins = self.portal.portal_skins
addDirectoryViews(skins, "tests", GLOBALS)
skinName = skins.getDefaultSkin()
paths = map(string.strip, skins.getSkinPath(skinName).split(","))
paths.insert(paths.index("custom") + 1, "test_captcha")
skins.addSkinSelection(skinName, ",".join(paths))
self._refreshSkinData()
def initialize(context):
"""Initialize the ZWiki product for use in CMF.
"""
registerDirectory('skins', globals())
# XXX I don't want this in the zmi add menu, how can I hide it ?
Products.CMFCore.utils.ContentInit(
'Wiki Content',
content_types = (ZWikiPage, ),
permission = Permissions.Add,
extra_constructors = (addWikiPage, ),
fti = factory_type_information,
).initialize(context)
def createDocumentationDirectoryViews(self, product):
"""
create file system directory views for generated documentation
Parameters:
- product: product that is documented
"""
try:
registerDirectory(DOCUMENTATION_DIR, GLOBALS)
except OSError, ex:
if ex.errno == 2: # No such file or directory
return
raise
def install_subskin(self, out, globals=types_globals, product_skins_dir='skins'):
skinstool = getToolByName(self, 'portal_skins')
product = getPackageName(globals)
registry_key = "%s:%s" % (product, product_skins_dir)
registered_directories = manage_listAvailableDirectories()
if registry_key not in registered_directories:
try:
registerDirectory(product_skins_dir, globals)
except OSError, ex:
if ex.errno == 2: # No such file or directory
return
raise
def initialize(context):
try:
registerDirectory('skins', groupuserfolder_globals)
except:
# No registerdir available => we ignore
pass
context.registerClass(
GroupUserFolder.GroupUserFolder,
permission='Add GroupUserFolders',
constructors=(GroupUserFolder.manage_addGroupUserFolder,),
icon='www/GroupUserFolder.gif',
)
if hasLDAP:
context.registerClass(
LDAPGroupFolder.LDAPGroupFolder,
permission='Add GroupUserFolders',
constructors=(LDAPGroupFolder.addLDAPGroupFolderForm, LDAPGroupFolder.manage_addLDAPGroupFolder,),
icon='www/LDAPGroupFolder.gif',
)
context.registerClass(
GRUFFolder.GRUFUsers,
permission='Add GroupUserFolder',
constructors=(GRUFFolder.manage_addGRUFUsers,),
visibility=None,
icon='www/GRUFUsers.gif',
)
context.registerClass(
GRUFFolder.GRUFGroups,
permission='Add GroupUserFolder',
constructors=(GRUFFolder.manage_addGRUFGroups,),
visibility=None,
icon='www/GRUFGroups.gif',
)
try:
from Products.CMFCore.utils import ToolInit, ContentInit
from GroupsTool import GroupsTool
from GroupDataTool import GroupDataTool
ToolInit( meta_type='CMF Groups Tool'
, tools=( GroupsTool, GroupDataTool, )
, icon="tool.gif"
).initialize( context )
except ImportError:
Log(LOG_NOTICE, "Unable to import GroupsTool and/or GroupDataTool. \
This won't disable GRUF but if you use CMF/Plone you won't get benefit of its special features.")
def test_registerDirectory_in_egg(self):
from pkg_resources import require
require('rotten')
from Products.CMFCore.DirectoryView import registerDirectory
from Products.CMFCore.DirectoryView import _dirreg
before = _dirreg._directories.copy()
registerDirectory('skins', {'__name__': 'Products.Rotten'})
after = _dirreg._directories.copy()
added = [x for x in after.keys() if x not in before]
self.assertEqual(len(added), 2)
self.failUnless('Products/Rotten/skins' in added)
self.failUnless('Products/Rotten/skins/rotten' in added)
def initialize(context):
context.registerClass(
ZSyncer.ZSyncer,
constructors = (ZSyncer.manage_addZSyncerForm,
ZSyncer.manage_addZSyncer),
icon='zsyncer_icon.gif')
context.registerHelp()
if CMF:
from Products.CMFCore.DirectoryView import registerDirectory
registerDirectory('skins', zs_globals)
from ZSyncerTool import ZSyncerTool
ToolInit(ZSyncerTool.meta_type,
tools=(ZSyncerTool, ),
product_name='ZSyncer', # NOT meta_type!
icon='zsyncer_icon.gif', # Must be in this dir.
).initialize( context )
def initialize(context):
# register directory views
registerDirectory('skins', GLOBALS)
if INSTALL_DEMO_TYPES:
import examples
# content initialization
content_types, constructors, ftis = process_types(listTypes(PKG_NAME), PKG_NAME,)
ContentInit(
'%s Content' % PKG_NAME,
content_types = content_types,
permission = AddPortalContent,
extra_constructors = constructors,
fti = ftis,
).initialize(context)
def initialize(context):
# register directory views
registerDirectory(SKINS_DIR, GLOBALS)
# Register kss extension to allow it used from fs skins
registerFileExtension('kss', FSFile)
# content initialization
content_types, constructors, ftis = process_types(
listTypes(PROJECTNAME),
PROJECTNAME)
utils.ContentInit(
PROJECTNAME + ' Content',
content_types = content_types,
permission = ADD_CONTENT_PERM,
extra_constructors = constructors,
).initialize(context)
def initialize(context):
from Products.customsearch import customsearch
# register directory views
registerDirectory("skins", GLOBALS)
# initialize portal content
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME), PROJECTNAME)
cmfutils.ContentInit(
PROJECTNAME + " Content",
content_types=content_types,
permission=ADD_CUSTOM_SEARCH_PERMISSON,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
# yay! let the world know about us
LOG.info("CustomSearch initialized")
def setUp( self ):
# initialise skins
registerDirectory('fake_skins', _prefix)
ob = self.ob = DummyFolder()
addDirectoryViews(ob, 'fake_skins', _prefix)
# add a method to the fake skin folder
f = open(test2path,'w')
f.write("return 'test2'")
f.close()
# edit the test1 method
copy2(test1path,test1path+'.bak')
f = open(test1path,'w')
f.write("return 'new test1'")
f.close()
# add a new folder
mkdir(test3path)
def install_skins(self, out, globals=GLOBALS, product_skins_dir=SKINS_DIR):
logger.info('Installing Skin Product')
out.write('PloneSlideShow Installation on %s\n' % self.id)
out.write('======================\n\n')
# Setup the skins
skinstool=getToolByName(self, 'portal_skins')
fullProductSkinsPath = join(package_home(globals), product_skins_dir)
productSkinsPath = minimalpath(fullProductSkinsPath)
registered_directories = manage_listAvailableDirectories()
if productSkinsPath+'/SlideShow' not in registered_directories:
registerDirectory(product_skins_dir+'/SlideShow', globals)
try:
addDirectoryViews(skinstool, product_skins_dir, globals)
out.write("Added %s directory view to portal_skins\n" % skinname)
except BadRequestException, e:
pass # directory view has already been added
out.write("%s directory view already existed in portal_skins\n" % skinname)
def initialize(context):
"""Initialize the LoginLockout plugin.
Register skin directory.
"""
registerMultiPlugin(LoginLockout.meta_type)
context.registerClass(LoginLockout,
permission=add_user_folders,
constructors=(manage_addLoginLockoutForm,
manage_addLoginLockout),
icon='www/tool.gif',
visibility=None,
)
# register the custom skins directory
GLOBALS = globals()
registerDirectory('skins', GLOBALS)
# register the tool
tools = ( LoginLockoutTool, )
utils.ToolInit(
PROJECTNAME,
icon='www/tool.gif',
tools=tools).initialize(context)
"""
from Products.Archetypes.atapi import listTypes
from Products.Archetypes.atapi import process_types
from Products.CMFCore import utils
from Products.CMFCore.DirectoryView import registerDirectory
from Products.CompositePage import tool as base_tool
from Products.CompositePack import config
from Products.CompositePack import design
from Products.CompositePack import tool
tools = (tool.CompositeTool, )
registerDirectory('skins', config.GLOBALS)
base_tool.registerUI('plone', design.PloneUI())
def initialize(context):
from Products.CompositePack import viewlet
from Products.CompositePack.composite import archetype
from Products.CompositePack.composite import fragments
from Products.CompositePack.composite import navigationpage
from Products.CompositePack.composite import portlets
from Products.CompositePack.composite import titles
from Products.CompositePack.viewlet import container
if config.INSTALL_DEMO_TYPES:
from Products.CompositePack.demo import ATCompositeDocument
HAVE_43 = True
except ImportError:
HAVE_43 = False
from Products.Archetypes.public import process_types, listTypes
from Products.CMFCore import utils
from Products.CMFCore.DirectoryView import registerDirectory
from AccessControl import ModuleSecurityInfo
from Products.PloneFormGen.config import PROJECTNAME, \
ADD_CONTENT_PERMISSION, CSA_ADD_CONTENT_PERMISSION, \
MA_ADD_CONTENT_PERMISSION, SDA_ADD_CONTENT_PERMISSION, \
SFA_ADD_CONTENT_PERMISSION, SKINS_DIR, GLOBALS
registerDirectory(SKINS_DIR + '/PloneFormGen', GLOBALS)
def initialize(context):
import content, validators, tools, widgets
# side-effect import
import patches
# Add our tools
utils.ToolInit('PloneFormGen Tool',
tools=( tools.formGenTool.FormGenTool, ),
icon='Form.gif',
).initialize(context)
def initialize(context):
registerDirectory(config.SKINS_DIR, config.GLOBALS)
initialize_content(context)
def setUp(self):
from Products.CMFCore.DirectoryView import registerDirectory
from Products.CMFCore.DirectoryView import addDirectoryViews
registerDirectory('fake_skins', _prefix)
self.ob = DummyFolder()
addDirectoryViews(self.ob, 'fake_skins', _prefix)
from AccessControl import ModuleSecurityInfo
from Products.Archetypes.public import process_types, listTypes
from Products.CMFCore import utils
from Products.CMFCore.DirectoryView import registerDirectory
from Products.salesforcepfgadapter.config import PROJECTNAME, GLOBALS, \
SFA_ADD_CONTENT_PERMISSION
from Products.PloneFormGen.config import ADD_CONTENT_PERMISSION, SKINS_DIR
registerDirectory(SKINS_DIR + '/salesforcepfgadapter_images', GLOBALS)
def initialize(context):
import content
##########
# Add our content types
# A little different from the average Archetype product
# due to the need to individualize some add permissions.
#
# This approach borrowed from ATContentTypes
#
listOfTypes = listTypes(PROJECTNAME)
content_types, constructors, ftis = process_types(listOfTypes, PROJECTNAME)
allTypes = zip(content_types, constructors)
for atype, constructor in allTypes:
kind = "%s: %s" % (PROJECTNAME, atype.archetype_name)
if atype.portal_type == 'SalesforcePFGAdapter':
""" from Globals import package_home from Products.Archetypes.public import process_types, listTypes from Products.CMFCore import utils from Products.CMFCore.DirectoryView import registerDirectory from Products.CMFPlone.interfaces.siteroot import IPloneSiteRoot from config import SKINS_DIR, GLOBALS, PROJECTNAME from config import ADD_CONTENT_PERMISSION, ADD_LENS_SELECTED_CONTENT_PERMISSION import monkeypatch #import indexesMonkeypatch registerDirectory(SKINS_DIR, GLOBALS) import BooleanWorkflow import LensTool tools = (LensTool.LensTool, ) # register fields/widgets/validators/etc import VersionField import SimpleHtmlValidator #permissions import LensPermissions def initialize(context):
from zope.i18nmessageid import MessageFactory
from Products.PythonScripts.Utility import allow_module
from Products.CMFCore.DirectoryView import registerDirectory
allow_module('agsci.common')
allow_module('agsci.common.utilities')
allow_module('Products.CMFPlone.utils')
allow_module('plone.app.textfield.value')
AgsciMessageFactory = MessageFactory('agsci.common')
GLOBALS = globals()
registerDirectory('skins/agsci_common', GLOBALS)
# Register indexers
from . import indexer
def initialize(context):
pass
# Returns an object with the keyword arguments as properties
def object_factory(**kwargs):
# https://stackoverflow.com/questions/1305532/convert-python-dict-to-object
class _(object):
def __init__(self, **kwargs):
self.__dict__.update(kwargs)
# Provide placeholder for empty text
def setUp(self):
registerDirectory('fake_skins', _prefix)
ob = self.ob = DummyFolder()
addDirectoryViews(ob, 'fake_skins', _prefix)
"""
$Id: __init__.py 53403 2007-11-08 09:54:35Z wichert $
"""
from Products.Archetypes.public import process_types, listTypes
from Products.CMFCore.DirectoryView import registerDirectory
from Products.Ploneboard.PloneboardTool import PloneboardTool
import sys
from Products.Ploneboard.config import SKINS_DIR, GLOBALS, PROJECTNAME
import Products.Ploneboard.catalog
registerDirectory(SKINS_DIR, GLOBALS)
this_module = sys.modules[ __name__ ]
def initialize(context):
##Import Types here to register them
import Products.Ploneboard.content
# If we put this import line to the top of module then
# utils will magically point to Ploneboard.utils
from Products.CMFCore import utils
utils.ToolInit('Ploneboard Tool',
tools=(PloneboardTool,),
icon='tool.gif'
).initialize(context)
content_types, constructors, ftis = process_types(
listTypes(PROJECTNAME),
def testCleanUpSkinsTool(self):
# This removes no longer existing layers from the skins tool and the
# skin selections.
from Products.CMFCore.DirectoryView import DirectoryView
from Products.CMFCore.DirectoryView import registerDirectory
self.setRoles(['Manager'])
skins = getToolByName(self.portal, 'portal_skins')
existing = skins.keys()
selection = 'Plone Default'
def layers_in_selection(selection_name):
return skins.getSkinPath(selection_name).split(',')
existing_layers_in_selection = layers_in_selection(selection)
# An initial cleanup should do nothing.
utils.cleanUpSkinsTool(self.portal)
difference = set(existing) ^ set(skins)
self.assertEqual(len(skins.keys()),
len(existing),
msg='Skink difference is: {}'.format(
list(difference)))
difference = set(
layers_in_selection(selection)) ^ set(existing_layers_in_selection)
self.assertEqual(len(layers_in_selection(selection)),
len(existing_layers_in_selection),
msg='Layer difference is: {}'.format(
list(difference)))
# A second cleanup should also do nothing. We used to rename
# plone_styles to classic_styles on the first run, which would get
# removed on a second run because in these tests the class_styles layer
# is not available.
utils.cleanUpSkinsTool(self.portal)
self.assertEqual(len(skins.keys()), len(existing))
self.assertEqual(len(layers_in_selection(selection)),
len(existing_layers_in_selection))
# Register some test skins layers. Note: the current module name is
# taken from globals()['__name__'], which is how registerDirectory
# knows where to find the directory. Also note that you should not try
# to register any layer that is outside of the current directory or in
# a 'skins' sub directory. There is just too much crazyness in the
# api. Better try to load some zcml in that case.
skin_name = 'skin_test'
# Make it available for Zope. This is what you would do in zcml.
registerDirectory(skin_name, globals(), subdirs=1)
# Add the DirectoryView object to portal_skins.
directory_info = DirectoryView(skin_name,
reg_key='plone.app.upgrade.tests:%s' %
skin_name)
skins._setObject(skin_name, directory_info)
# Add its sub skins to a skin selection.
self.addSkinLayer('skin_test/sub1', skin=selection)
self.addSkinLayer('skin_test/sub1/subsub1', skin=selection)
self.addSkinLayer('skin_test/sub2', skin=selection)
# Did that work?
self.assertEqual(len(skins.keys()), len(existing) + 1)
self.assertEqual(len(layers_in_selection(selection)),
len(existing_layers_in_selection) + 3)
# Clean it up again. Nothing should be removed.
utils.cleanUpSkinsTool(self.portal)
self.assertEqual(len(skins.keys()), len(existing) + 1)
self.assertEqual(len(layers_in_selection(selection)),
len(existing_layers_in_selection) + 3)
from Products.validation import validation
from Products.Reflecto.validators import isValidFilesystemPath
from Products.CMFCore.utils import ContentInit
from Products.CMFCore.DirectoryView import registerDirectory
from Products.Archetypes.public import process_types, listTypes
from Products.Reflecto.permissions import AddReflectorFolder
from Products.Reflecto.config import PROJECTNAME
registerDirectory("skins", globals())
validation.register(isValidFilesystemPath())
def initialize(context):
import Products.Reflecto.content
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),
PROJECTNAME)
ContentInit(
PROJECTNAME + ' Content',
content_types=content_types,
permission=AddReflectorFolder,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
# Cocommpyright (c) 2003-2005 Kupu Contributors. All rights reserved.
#
# This software is distributed under the terms of the Kupu
# License. See LICENSE.txt for license text. For a list of Kupu
# Contributors see CREDITS.txt.
#
##############################################################################
"""Kupu Plone integration
This package is a python package and contains a filesystem-based skin
layer containing the necessary UI customization to integrate Kupu as a
wysiwyg editor in Plone.
$Id: __init__.py 14546 2005-07-12 14:35:55Z duncan $
"""
from App.Common import package_home
from Products.CMFCore.DirectoryView import registerDirectory
from Products.CMFCore import utils
from Products.kupu.plone.plonelibrarytool import PloneKupuLibraryTool
from Products.kupu import kupu_globals
kupu_package_dir = package_home(kupu_globals)
registerDirectory('plone/kupu_plone_layer', kupu_package_dir)
def initialize(context):
utils.ToolInit("kupu Library Tool",
tools=(PloneKupuLibraryTool,),
product_name='kupu',
icon="kupu_icon.gif",
).initialize(context)
# Make MergeError available to TTW code
from AccessControl import ModuleSecurityInfo, allow_class
from BaseDiff import MergeError
ModuleSecurityInfo('Products.CMFDiffTool').declarePublic('MergeError')
allow_class(MergeError)
this_module = sys.modules[ __name__ ]
product_globals = globals()
tools = ( CMFDiffTool.CMFDiffTool,)
contentConstructors = (ChangeSet.manage_addChangeSet,)
contentClasses = (ChangeSet.ChangeSet,)
z_bases = utils.initializeBasesPhase1(contentClasses, this_module)
# Make the skins available as DirectoryViews
registerDirectory('skins', globals())
registerDirectory('skins/ChangeSet', globals())
CMFDiffTool.registerDiffType(BinaryDiff.BinaryDiff)
CMFDiffTool.registerDiffType(FieldDiff.FieldDiff)
CMFDiffTool.registerDiffType(ListDiff.ListDiff)
CMFDiffTool.registerDiffType(TextDiff.TextDiff)
CMFDiffTool.registerDiffType(XmlDiff.XmlDiff)
def initialize(context):
utils.ToolInit('CMF Diff Tool',
tools = tools,
icon='tool.gif'
).initialize( context )
utils.initializeBasesPhase2( z_bases, context )
# test for FileSystemSite
try:
import Products.FileSystemSite
have_fss = 1
except ImportError:
have_fss = 0
# do the minimal stuff for skin registering
# note that CMF/Plone users will still have to run the
# Extensions/Install.py script
if have_cmf:
# Need to do this in case Archetypes isn't present.
from Products.CMFCore.FSFile import FSFile
from Products.CMFCore.DirectoryView import registerFileExtension, registerDirectory
registerFileExtension('xsl', FSFile)
registerDirectory('common', globals())
if have_plone:
from Products.kupu.plone import initialize
elif have_zope2 and have_fss:
import zope2
initialize = zope2.initialize
if have_zope2:
# in Zope 2, make all modules in the 'python' lib available
def __allow_access_to_unprotected_subobjects__(name, value=None):
return name in ('python')
from AccessControl import allow_module
allow_module('Products.kupu.python.nationalizer')
#
# 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.
#
##############################################################################
""" Product: CMFActionIcons
Define tool for mapping CMF actions onto icons.
$Id$
"""
from Products.CMFCore.DirectoryView import registerDirectory
from Products.CMFCore.utils import ToolInit
from ActionIconsTool import ActionIconsTool
actionicons_globals = globals()
registerDirectory('skins', actionicons_globals)
def initialize(context):
ToolInit(meta_type='CMF Action Icons Tool',
tools=(ActionIconsTool, ),
icon="tool.gif").initialize(context)
def test_registerDirectory(self):
""" Test registerDirectory """
registerDirectory('fake_skins', _prefix)
from ZClasses import createZClassForBase
bases = (Topic.Topic, )
import sys
this_module = sys.modules[__name__]
for base in bases:
createZClassForBase(base, this_module)
# This is used by a script (external method) that can be run
# to set up Topics in an existing CMF Site instance.
topic_globals = globals()
# Make the skins available as DirectoryViews
registerDirectory('skins', globals())
registerDirectory('skins/topic', globals())
def initialize(context):
context.registerHelpTitle('CMF Topic Help')
context.registerHelp(directory='help')
# CMF Initializers
ContentInit('CMF Topic Objects',
content_types=(Topic.Topic, ),
permission=TopicPermissions.AddTopics,
extra_constructors=(Topic.addTopic, ),
fti=Topic.factory_type_information).initialize(context)
},
),
}, )))
contentClasses = (Collector.Collector, CollectorIssue.CollectorIssue,
Collector.CollectorCatalog, CollectorSubset.CollectorSubset)
contentConstructors = (Collector.addCollector,
CollectorIssue.addCollectorIssue,
CollectorSubset.addCollectorSubset)
z_bases = utils.initializeBasesPhase1(contentClasses, this_module)
# This is used by a script (external method) that can be run
# to set up collector in an existing CMF Site instance.
collector_globals = globals()
# Make the skins available as DirectoryViews
registerDirectory('skins', globals())
registerDirectory('skins/collector', globals())
def initialize(context):
utils.initializeBasesPhase2(z_bases, context)
context.registerHelp(directory='help')
context.registerHelpTitle('CMF Collector Help')
context.registerClass(Collector.Collector,
constructors=(Collector.addCollector, ),
permission=CMFCorePermissions.AddPortalContent)
context.registerClass(CollectorIssue.CollectorIssue,
constructors=(CollectorIssue.addCollectorIssue, ),
permission=CollectorPermissions.AddCollectorIssue)
DiscussionItem.DiscussionItem) + contentClasses)
tools = (DiscussionTool.DiscussionTool, MembershipTool.MembershipTool,
RegistrationTool.RegistrationTool, PropertiesTool.PropertiesTool,
MetadataTool.MetadataTool, SyndicationTool.SyndicationTool)
import sys
this_module = sys.modules[__name__]
z_bases = initializeBasesPhase1(bases, this_module)
z_tool_bases = initializeBasesPhase1(tools, this_module)
cmfdefault_globals = globals()
# Make the skins available as DirectoryViews.
registerDirectory('skins', globals())
registerDirectory('help', globals())
def initialize(context):
initializeBasesPhase2(z_bases, context)
initializeBasesPhase2(z_tool_bases, context)
ToolInit('CMFDefault Tool',
tools=tools,
product_name='CMFDefault',
icon='tool.gif').initialize(context)
ContentInit('CMFDefault Content',
content_types=contentClasses,
#
# This program is part of the PrinterToner Zenpack for Zenoss.
# Copyright (C) 2009 Tonino Greco & Zenoss Inc.
#
# This program can be used under the GNU General Public License version 2
# You can find full information here: http://www.zenoss.com/oss
#
################################################################################
import Globals
import os
from Products.CMFCore.DirectoryView import registerDirectory
from Products.ZenModel.ZenPack import ZenPackBase
skinsDir = os.path.join(os.path.dirname(__file__), 'skins')
if os.path.isdir(skinsDir):
registerDirectory(skinsDir, globals())
class ZenPack(ZenPackBase):
# Zepack addition of printerTonerMap on install and remove on de-install
# generic installer - just set the 2 variables below
new_plugin = "community.snmp.PrinterTonerMap"
#object = app.zport.dmd.Devices.Printer.Laser
# install the zpython class for the printertoner tab to be displayed
def install(self, app):
ZenPackBase.install(self, app)
dc = app.zport.dmd.Devices.getOrganizer('Devices/Printer/Laser')
dc._setProperty('zPythonClass',
'ZenPacks.community.PrinterToner.PrinterTonerDevice')
# Register our skins directory - this makes it available via portal_skins.
from Products.CMFCore.DirectoryView import registerDirectory
GLOBALS = globals()
registerDirectory('skins', GLOBALS)
"""Main product initializer
"""
from Products.Archetypes import atapi
from Products.CMFCore import utils
from Products.CMFCore.DirectoryView import registerDirectory
from ftw.blog import config
from zope.i18nmessageid import MessageFactory
_ = MessageFactory('ftw.blog')
registerDirectory('skins', config.product_globals)
def initialize(context):
"""Initializer called when used as a Zope 2 product.
This is referenced from configure.zcml. Regstrations as a "Zope 2 product"
is necessary for GenericSetup profiles to work, for example.
Here, we call the Archetypes machinery to register our content types
with Zope and the CMF.
"""
content_types, constructors, _ftis = atapi.process_types(
atapi.listTypes(config.PROJECTNAME), config.PROJECTNAME)
for atype, constructor in zip(content_types, constructors):
utils.ContentInit(
'%s: %s' % (config.PROJECTNAME, atype.portal_type),
content_types=(atype, ),
permission=config.ADD_PERMISSIONS[atype.portal_type],
import re
import os
from Products.CMFCore.utils import ContentInit
from Products.CMFCore.DirectoryView import registerDirectory
from config import PROJECTNAME, GLOBALS
import content
import permissions
import Products.listen.i18n
# Add builtin mailboxer skin
from Products.MailBoxer.config import SKINS_DIR as MB_SKINS_DIR
from Products.MailBoxer.config import GLOBALS as MB_GLOBALS
registerDirectory(MB_SKINS_DIR, MB_GLOBALS)
# Add local skin
registerDirectory('skins', GLOBALS)
def initialize(context):
ContentInit(
PROJECTNAME + ' Content',
content_types=(content.MailingList, ),
permission=permissions.AddMailingList,
extra_constructors=(content.addMailingList, ),
).initialize(context)
try:
fiveVersion = context._ProductContext__app.Control_Panel.Products.Five.version
from Products.CMFCore import permissions as cmf_permissions
from Products.CMFCore.DirectoryView import registerDirectory
from Products.CMFCore.utils import ContentInit
from Products.validation import validation
from zope.i18nmessageid import MessageFactory
from Products.PloneSoftwareCenter import config
from Products.PloneSoftwareCenter import permissions as psc_permissions
from Products.PloneSoftwareCenter import validators
PSCMessageFactory = MessageFactory('plonesoftwarecenter')
validation.register(validators.ProjectIdValidator('isNonConflictingProjectId'))
validation.register(validators.ProjectContactValidator('isValidContact'))
registerDirectory(config.SKINS_DIR, config.GLOBALS)
def initialize(context):
# Kick content registration and sys.modules mangling
from Products.PloneSoftwareCenter import content
content # pyflakes
allTypes = listTypes(config.PROJECTNAME)
# Register Archetypes content with the machinery
content_types, constructors, ftis = process_types(
allTypes, config.PROJECTNAME)
center_content_types = []
center_constructors = []
from Products.CMFCore import utils, CMFCorePermissions
from Products.CMFCore.DirectoryView import registerDirectory
from Products.CMFCore.CMFCorePermissions import setDefaultRoles
import sys
this_module = sys.modules[ __name__ ]
product_globals = globals()
# Make the skins available as DirectoryViews
registerDirectory('skins', product_globals)
def initialize(context):
pass
def initialize(context):
try:
from Products.CMFCore.interfaces import ISiteRoot
except ImportError:
ISiteRoot = None
else:
from Products.GenericSetup import EXTENSION
from Products.GenericSetup import profile_registry
from Products.CMFCore.DirectoryView import registerDirectory
import Collector
import CollectorIssue
import WebTextDocument
import CollectorSubset
from permissions import View
from permissions import AddPortalContent
from permissions import AddCollectorIssue
from permissions import EditCollectorIssue
from permissions import AddCollectorIssueFollowup
global factory_type_information # allow quickinstaller access
factory_type_information = ((
Collector.factory_type_information +
CollectorIssue.factory_type_information +
Collector.catalog_factory_type_information +
CollectorSubset.factory_type_information + (
{
'id':
'Collector Issue Transcript',
# 'content_icon': 'event_icon.gif',
'meta_type':
'WebText Document',
'description':
('A transcript of issue activity, including comments,'
' state changes, and so forth.'),
'product':
'CMFCollector',
'factory':
None, # So not included in 'New' add form
'allowed_content_types':
None,
'immediate_view':
'collector_transcript_view',
'actions': (
{
'id': 'view',
'name': 'View',
'action': 'string:${object_url}/../',
'permissions': (View, )
},
{
'id': 'addcomment',
'name': 'Add Comment',
'action':
'string:${object_url}/collector_transcript_comment_form',
'permissions': (AddCollectorIssueFollowup, )
},
{
'id': 'edittranscript',
'name': 'Edit Transcript',
'action':
'string:${object_url}/collector_transcript_edit_form',
'permissions': (EditCollectorIssue, )
},
),
}, )))
contentClasses = (Collector.Collector, CollectorIssue.CollectorIssue,
Collector.CollectorCatalog,
CollectorSubset.CollectorSubset)
contentConstructors = (Collector.addCollector,
CollectorIssue.addCollectorIssue,
CollectorSubset.addCollectorSubset)
context.registerHelp(directory='help')
context.registerHelpTitle('CMF Collector Help')
context.registerClass(Collector.Collector,
constructors=(Collector.addCollector, ),
permission=AddPortalContent)
context.registerClass(CollectorIssue.CollectorIssue,
constructors=(CollectorIssue.addCollectorIssue, ),
permission=AddCollectorIssue)
context.registerClass(CollectorSubset.CollectorSubset,
constructors=(CollectorSubset.addCollectorSubset, ),
permission=AddPortalContent)
registerDirectory('skins', globals())
registerDirectory('skins/collector', globals())
if ISiteRoot is not None:
profile_registry.registerProfile(
'CMFCollector',
'CMF Collector',
'Types, skins, workflow for collector.',
'profiles/collector',
'CMFCollector',
EXTENSION,
for_=ISiteRoot)
import logging
log = logging.getLogger('zen.DeviceSearch')
import os
import Globals
from Products.CMFCore.DirectoryView import registerDirectory
skinsDir = os.path.join(os.path.dirname(__file__), 'skins')
if os.path.isdir(skinsDir):
registerDirectory(skinsDir, globals())
from Products.ZenModel.ZenPack import ZenPack as ZenPackBase
class ZenPack(ZenPackBase):
def install(self, dmd):
super(ZenPack, self).install(dmd)
def remove(self, dmd, leaveObjects=False):
super(ZenPack, self).remove(dmd, leaveObjects)
from Products.ZenUtils.Utils import monkeypatch
try:
from Products.Zuul.catalog.global_catalog import DeviceWrapper, IpInterfaceWrapper
@monkeypatch('Products.Zuul.catalog.global_catalog.DeviceWrapper')
def searchKeywords(self):
device = self._context.primaryAq()
return super(DeviceWrapper, self).searchKeywords() + (device.zSnmpCommunity,)
# ^ Add other indexable properties (cProp, zProp, Attr) here as context device
$Id$
"""
from App.Common import package_home
from Products.CMFCore.DirectoryView import registerDirectory
from Products.CMFCore import utils
from Products.kupu.plone.plonelibrarytool import PloneKupuLibraryTool
from Products.kupu import kupu_globals
try:
from Products.GenericSetup import profile_registry
from Products.GenericSetup import BASE, EXTENSION
from Products.CMFPlone.interfaces import IPloneSiteRoot
except ImportError:
profile_registry = None
registerDirectory('plone/kupu_plone_layer', kupu_globals)
registerDirectory('plone/kupu_references', kupu_globals)
registerDirectory('tests', kupu_globals)
def initialize(context):
try:
init = utils.ToolInit(
"kupu Library Tool",
tools=(PloneKupuLibraryTool, ),
icon="kupu_icon.gif",
)
except TypeError:
# Try backward compatible form of the initialisation call
init = utils.ToolInit(
"kupu Library Tool",
# test for FileSystemSite
try:
import Products.FileSystemSite
have_fss = 1
except ImportError:
have_fss = 0
# do the minimal stuff for skin registering
# note that CMF/Plone users will still have to run the
# Extensions/Install.py script
if have_cmf:
# Need to do this in case Archetypes isn't present.
from Products.CMFCore.FSFile import FSFile
from Products.CMFCore.DirectoryView import registerFileExtension, registerDirectory
registerFileExtension('xsl', FSFile)
registerDirectory('common', globals())
if have_plone:
from Products.kupu.plone import initialize
elif have_zope2 and have_fss:
import zope2
initialize = zope2.initialize
if have_zope2:
# in Zope 2, make all modules in the 'python' lib available
def __allow_access_to_unprotected_subobjects__(name, value=None):
return name in ('python')
from AccessControl import allow_module
allow_module('Products.kupu.python.nationalizer')
from zope.component import getUtilitiesFor
from zopyx.txng3.core.interfaces import IParser
return [x[0] for x in getUtilitiesFor(IParser)]
def get_ranking_methods(self):
""" return all available parsers"""
from zope.component import getUtilitiesFor
from zopyx.txng3.core.interfaces import IRanking
return [x[0] for x in getUtilitiesFor(IRanking)]
# some monkey patching (necessary since we have no context object
# during the factory phase where we could use browser views)
from Products.ZCatalog.ZCatalog import ZCatalog
ZCatalog.get_storages = get_storages
ZCatalog.get_lexicons = get_lexicons
ZCatalog.get_splitters = get_splitters
ZCatalog.get_parsers = get_parsers
ZCatalog.get_ranking_methods = get_ranking_methods
# Plone
textindexng_globals = globals()
try:
from Products.CMFCore.DirectoryView import registerDirectory
registerDirectory('skins', textindexng_globals)
except ImportError:
pass
, Link.addLink
, Favorite.addFavorite
, NewsItem.addNewsItem
, SkinnedFolder.addSkinnedFolder
)
tools = ( DiscussionTool.DiscussionTool
, MembershipTool.MembershipTool
, RegistrationTool.RegistrationTool
, PropertiesTool.PropertiesTool
, MetadataTool.MetadataTool
, SyndicationTool.SyndicationTool
)
# Make the skins available as DirectoryViews.
registerDirectory('skins', globals())
registerDirectory('help', globals())
def initialize(context):
ToolInit( 'CMF Default Tool'
, tools=tools
, icon='tool.gif'
).initialize( context )
# BBB: register oldstyle constructors
ContentInit( 'CMF Default Content'
, content_types=()
, permission=AddPortalContent
, extra_constructors=contentConstructors
).initialize( context )
##############################################################################
#
# Copyright (C) Zenoss, Inc. 2007, all rights reserved.
#
# This content is made available according to terms specified in
# License.zenoss under the directory where your Zenoss product is installed.
#
##############################################################################
from Products.CMFCore.DirectoryView import registerDirectory
registerDirectory('js', globals())
# import any monkey patches that may be necessary
from patches import pasmonkey
from patches import dirviewmonkey
from patches import advancedquerymonkey
from Products.ZenUtils.Utils import unused
unused(pasmonkey, dirviewmonkey, advancedquerymonkey)
from Products.ZenUtils.MultiPathIndex import MultiPathIndex , \
manage_addMultiPathIndex, \
manage_addMultiPathIndexForm
def initialize(context):
context.registerClass(
MultiPathIndex,
permission='Add Pluggable Index',
constructors=(manage_addMultiPathIndexForm, manage_addMultiPathIndex),
#icon="www/index.gif",
visibility=None)
from Products.DataGridField.RadioColumn import RadioColumn
from Products.DataGridField.FixedColumn import FixedColumn
from Products.DataGridField.LinkColumn import LinkColumn
from Products.DataGridField.HelpColumn import HelpColumn
from Products.DataGridField.CheckboxColumn import CheckboxColumn
from Products.DataGridField.LinesColumn import LinesColumn
from Products.DataGridField import validators
from Products.DataGridField.config import PKG_NAME, GLOBALS
# Import "MessageFactory" to create messages in the DataGridField domain
DGFMessageFactory = MessageFactory('datagridfield')
# Import "MessageFactory" to create messages in the plone domain
PloneMessageFactory = MessageFactory('plone')
registerDirectory('skins', GLOBALS)
def initialize(context):
# Example content type initialization
import Products.DataGridField.examples
content_types, constructors, ftis = process_types(
listTypes(PKG_NAME), PKG_NAME, )
ContentInit(
'%s Content' % PKG_NAME,
content_types=content_types,
permission=AddPortalContent,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
from Products.CMFCore.DirectoryView import registerDirectory
import EventPermissions
import sys
this_module = sys.modules[ __name__ ]
contentConstructors = (Event.addEvent,)
contentClasses = (Event.Event,)
z_bases = utils.initializeBasesPhase1( contentClasses, this_module )
# This is used by a script (external method) that can be run
# to set up Events in an existing CMF Site instance.
event_globals=globals()
# Make the skins available as DirectoryViews
registerDirectory('skins', globals())
registerDirectory('skins/calendar', globals())
def initialize( context ):
utils.initializeBasesPhase2( z_bases, context )
context.registerHelpTitle('CMF Calendar Help')
context.registerHelp(directory='help')
utils.ContentInit( 'CMF Event'
, content_types = contentClasses
, permission = CMFCorePermissions.AddPortalContent
, extra_constructors = contentConstructors
, fti = Event.factory_type_information
).initialize( context )
def initialize(context):
try:
from Products.CMFCore.interfaces import ISiteRoot
except ImportError:
ISiteRoot = None
else:
from Products.GenericSetup import EXTENSION
from Products.GenericSetup import profile_registry
from Products.CMFCore.DirectoryView import registerDirectory
import Collector
import CollectorIssue
import WebTextDocument
import CollectorSubset
from permissions import View
from permissions import AddPortalContent
from permissions import AddCollectorIssue
from permissions import EditCollectorIssue
from permissions import AddCollectorIssueFollowup
global factory_type_information # allow quickinstaller access
factory_type_information = (
(Collector.factory_type_information
+ CollectorIssue.factory_type_information
+ Collector.catalog_factory_type_information
+ CollectorSubset.factory_type_information
+ ({'id': 'Collector Issue Transcript',
# 'content_icon': 'event_icon.gif',
'meta_type': 'WebText Document',
'description': (
'A transcript of issue activity, including comments,'
' state changes, and so forth.'),
'product': 'CMFCollector',
'factory': None, # So not included in 'New' add form
'allowed_content_types': None,
'immediate_view': 'collector_transcript_view',
'actions': (
{ 'id': 'view',
'name': 'View',
'action': 'string:${object_url}/../',
'permissions': (View,) },
{ 'id': 'addcomment',
'name': 'Add Comment',
'action':
'string:${object_url}/collector_transcript_comment_form',
'permissions':
(AddCollectorIssueFollowup,) },
{ 'id': 'edittranscript',
'name': 'Edit Transcript',
'action':
'string:${object_url}/collector_transcript_edit_form',
'permissions': (EditCollectorIssue,) },
),
},
)
)
)
contentClasses = (Collector.Collector, CollectorIssue.CollectorIssue,
Collector.CollectorCatalog, CollectorSubset.CollectorSubset)
contentConstructors = (Collector.addCollector,
CollectorIssue.addCollectorIssue,
CollectorSubset.addCollectorSubset)
context.registerHelp(directory='help')
context.registerHelpTitle('CMF Collector Help')
context.registerClass(Collector.Collector,
constructors = (Collector.addCollector,),
permission = AddPortalContent)
context.registerClass(CollectorIssue.CollectorIssue,
constructors = (CollectorIssue.addCollectorIssue,),
permission = AddCollectorIssue)
context.registerClass(CollectorSubset.CollectorSubset,
constructors = (CollectorSubset.addCollectorSubset,),
permission = AddPortalContent)
registerDirectory('skins', globals())
registerDirectory('skins/collector', globals())
if ISiteRoot is not None:
profile_registry.registerProfile('CMFCollector',
'CMF Collector',
'Types, skins, workflow for collector.',
'profiles/collector',
'CMFCollector',
EXTENSION,
for_=ISiteRoot)
CNXML_UPGRADE_XSL = os.path.join(package_home(globals()), 'www/cnxmlupgrade.xsl')
ModuleSecurityInfo('Products.CNXMLDocument').declarePublic('CNXML_UPGRADE_XSL')
CNXML_SEARCHABLE_XSL = os.path.join(package_home(globals()), 'www/baretext.xsl')
ModuleSecurityInfo('Products.CNXMLDocument').declarePublic('CNXML_SEARCHABLE_XSL')
CNXML_RENDER_XSL = 'http://cnx.rice.edu/technology/cnxml/stylesheet/cnxml_render.xsl'
ModuleSecurityInfo('Products.CNXMLDocument').declarePublic('CNXML_RENDER_XSL')
contentConstructors = (PortalCNXMLFile.addCNXMLFile,)
contentClasses = (PortalCNXMLFile.PortalCNXMLFile,)
product_globals = globals()
z_bases = utils.initializeBasesPhase1(contentClasses, this_module)
# Make the skins available as DirectoryViews
registerDirectory('skins', globals())
registerDirectory('skins/CNXMLFile', globals())
# Allow access to XMLService (until it's a tool)
from AccessControl import allow_module, allow_class
from Products.CNXMLDocument import XMLService
allow_module('Products.CNXMLDocument.XMLService')
def initialize(context):
"""
Register base classes
"""
utils.initializeBasesPhase2( z_bases, context )
utils.ContentInit(PortalCNXMLFile.PortalCNXMLFile.meta_type,
content_types = contentClasses,
