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",
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,