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)
context.registerClass(Portal.CMFSite,
constructors=(factory.addConfiguredSiteForm,
factory.addConfiguredSite),
icon='images/portal.gif')
registerIcon(DefaultWorkflow.DefaultWorkflowDefinition,
'images/workflow.gif', globals())
# make registerHelp work with 2 directories
help = context.getProductHelp()
lastRegistered = help.lastRegistered
context.registerHelp(directory='help', clear=1)
context.registerHelp(directory='interfaces', clear=1)
if help.lastRegistered != lastRegistered:
help.lastRegistered = None
context.registerHelp(directory='help', clear=1)
help.lastRegistered = None
context.registerHelp(directory='interfaces', clear=0)
context.registerHelpTitle('CMF Default Help')
def initialize( context ):
ToolInit( meta_type='CMF Action Icons Tool'
, tools=( ActionIconsTool, )
, product_name='CMFActionIcons'
, icon="tool.gif"
).initialize( context )
def initialize(context):
##Import Types here to register them
from Products.PloneTemplates.content import Template
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),
PROJECTNAME)
from Products.PloneTemplates.Permissions import permissions
allTypes = zip(content_types, constructors)
wireAddPermissions()
for atype, constructor in allTypes:
kind = "%s: %s" % (PROJECTNAME, atype.archetype_name)
ContentInit(
kind,
content_types=(atype, ),
permission=permissions[atype.portal_type],
extra_constructors=(constructor, ),
fti=ftis,
).initialize(context)
from Products.PloneTemplates.TemplateTool import PloneTemplatesTool
ToolInit(
'PloneTemplates tool',
tools=(PloneTemplatesTool, ),
icon='tool.gif',
).initialize(context)
# patch types
import Products.PloneTemplates.PatchSchemas
def initialize(context):
listOfTypes = listTypes(PROJECTNAME)
content_types, constructors, ftis = process_types(listOfTypes, PROJECTNAME)
ContentInit(
PROJECTNAME + ' Content',
content_types=content_types,
permission=PlonePopoll_addPermission,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
ToolInit(
'%s Tool' % PROJECTNAME,
tools=(PlonePopollTool, ),
icon='tool.gif',
).initialize(context)
# This has to be improved so that only PlonePopollManager objects can hold PlonePopollBackends
# and PlonePopollBackends can be derived.
context.registerClass(
PlonePopollZODBBackend,
permission=view_management_screens,
constructors=(manage_addPlonePopollZODBBackend, ),
visibility=None,
icon='www/PlonePopollBackend.gif',
)
context.registerClass(
PlonePopollZSQLBackend,
permission=view_management_screens,
constructors=(manage_addPlonePopollZSQLBackend, ),
visibility=None,
icon='www/PlonePopollBackend.gif',
)
def initialize(context):
# import at initialize: this let a chance to 3rd party products to change
# config before deciding to patch
from Products.PloneGlossary import patches
patches # pyflakes
from Products.PloneGlossary.permissions import add_permissions
# used by test framework
if 'ZOPETESTCASE' in os.environ:
from . import examples
examples # pyflakes
# Import types
listOfTypes = listTypes(PROJECTNAME)
content_types, constructors, ftis = process_types(listOfTypes, PROJECTNAME)
for content_type, constructor in zip(content_types, constructors):
kind = "%s: %s" % (PROJECTNAME, content_type.__name__)
ContentInit(
kind,
content_types=(content_type, ),
permission=add_permissions[content_type.__name__],
extra_constructors=(constructor, ),
fti=ftis,
).initialize(context)
# Import tool
ToolInit('%s Tool' % PROJECTNAME,
tools=(PloneGlossaryTool, ),
icon='tool.gif').initialize(context)
def initialize(context):
# import at initialize: this let a chance to 3rd party products to change
# config before deciding to patch
import patches
# used by test framework
if config.INSTALL_EXAMPLES:
import examples
# Import types
listOfTypes = listTypes(PROJECTNAME)
content_types, constructors, ftis = process_types(listOfTypes, PROJECTNAME)
ContentInit(
'%s Content' % PROJECTNAME,
content_types=content_types,
permission=CMFCorePermissions.AddPortalContent,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
# Import tool
ToolInit('%s Tool' % PROJECTNAME,
tools=(PloneGlossaryTool, ),
icon='tool.gif').initialize(context)
def initialize(context):
tools = (FormController.FormController, )
ToolInit(
'Form Controller Tool',
tools=tools,
icon='tool.gif',
).initialize(context)
context.registerClass(
ControllerPageTemplate.ControllerPageTemplate,
constructors=(
ControllerPageTemplate.manage_addControllerPageTemplateForm,
ControllerPageTemplate.manage_addControllerPageTemplate),
icon='www/cpt.gif',
)
context.registerClass(
ControllerPythonScript.ControllerPythonScript,
constructors=(
ControllerPythonScript.manage_addControllerPythonScriptForm,
ControllerPythonScript.manage_addControllerPythonScript),
icon='www/cpy.gif',
)
context.registerClass(
ControllerValidator.ControllerValidator,
constructors=(ControllerValidator.manage_addControllerValidatorForm,
ControllerValidator.manage_addControllerValidator),
icon='www/vpy.gif',
)
registerIcon(FSControllerPageTemplate.FSControllerPageTemplate,
'www/cpt.gif', globals())
registerIcon(FSControllerPythonScript.FSControllerPythonScript,
'www/cpy.gif', globals())
registerIcon(FSControllerValidator.FSControllerValidator, 'www/vpy.gif',
globals())
def initialize(context):
from Products.CMFCore.utils import ContentInit
from Products.CMFCore.utils import ToolInit
import Event
import CalendarTool
from permissions import AddPortalContent
# Make sure security is initialized
import utils
ToolInit( 'CMF Calendar Tool'
, tools=(CalendarTool.CalendarTool,)
, icon='tool.gif'
).initialize( context )
# BBB: register oldstyle constructors
ContentInit( 'CMF Calendar Content'
, content_types=()
, permission=AddPortalContent
, extra_constructors=(Event.addEvent,)
, visibility=None
).initialize( context )
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,
permission=AddPortalContent,
extra_constructors=contentConstructors,
fti=Portal.factory_type_information).initialize(context)
context.registerClass(Portal.CMFSite,
constructors=(Portal.manage_addCMFSiteForm,
Portal.manage_addCMFSite),
icon='portal.gif')
registerIcon(DefaultWorkflow.DefaultWorkflowDefinition,
'images/workflow.gif', globals())
# make registerHelp work with 2 directories
help = context.getProductHelp()
lastRegistered = help.lastRegistered
context.registerHelp(directory='help', clear=1)
context.registerHelp(directory='interfaces', clear=1)
if help.lastRegistered != lastRegistered:
help.lastRegistered = None
context.registerHelp(directory='help', clear=1)
help.lastRegistered = None
context.registerHelp(directory='interfaces', clear=0)
context.registerHelpTitle('CMF Default Help')
def initialize(context):
# process our custom types
if HAS_LINGUA_PLONE:
from Products.LinguaPlone.public import process_types
from Products.LinguaPlone.public import listTypes
else:
from Products.Archetypes.atapi import process_types
from Products.Archetypes.atapi import listTypes
ToolInit(
'ATContentTypes tool',
tools=(ATCTTool,),
icon='tool.gif', ).initialize(context)
listOfTypes = listTypes(PROJECTNAME)
content_types, constructors, ftis = process_types(
listOfTypes,
PROJECTNAME)
# Assign an own permission to all content types
# Heavily based on Bricolite's code from Ben Saller
from Products.ATContentTypes.permission import permissions
allTypes = zip(content_types, constructors)
for atype, constructor in allTypes:
kind = "%s: %s" % (PROJECTNAME, atype.archetype_name)
ContentInit(
kind,
content_types=(atype,),
permission=permissions[atype.portal_type],
extra_constructors=(constructor,),
).initialize(context)
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 initialize(context):
""" initialize function called when used as a zope2 product """
ToolInit(
'plone.app.customerize',
tools=(ViewTemplateContainer, ),
icon='tool.gif',
).initialize(context)
def initialize(context):
""" initialize function called when used as a zope2 product """
ToolInit(
'eea.faceted.tool',
tools=(FacetedTool, ),
icon='tool.gif',
).initialize(context)
def initialize(context):
""" initialize function called when used as a zope2 product """
ToolInit(
'eea.google',
tools=(GoogleTool, ),
icon='icon.gif',
).initialize(context)
def initialize(context):
"""
initialize the tool here.
"""
ToolInit('Plone Cryptography Tool',
tools = (PloneCryptoTool,),
icon = 'tool.gif').initialize(context)
def initialize(context):
from Products.CMFCore.utils import ToolInit
import ActionIconsTool
ToolInit(meta_type='CMF Action Icons Tool',
tools=(ActionIconsTool.ActionIconsTool, ),
icon="tool.gif").initialize(context)
def initialize(context):
"""
Initializer called when used as a Zope 2 product.
"""
# register tool.
from Products.CMFCore.utils import ToolInit
ToolInit('iScorpio Plonelab Tool', tools=(PlonelabTool, ),
icon='tool.gif').initialize(context)
def initialize(context):
from Products.CMFQuickInstallerTool.QuickInstallerTool import QuickInstallerTool # noqa
from Products.CMFQuickInstallerTool.QuickInstallerTool import addQuickInstallerTool # noqa
ToolInit('CMF QuickInstaller Tool',
tools=(QuickInstallerTool, ),
icon='tool.gif').initialize(context)
context.registerClass(QuickInstallerTool,
meta_type="CMFQuickInstallerTool",
constructors=(addQuickInstallerTool, ),
icon='tool.gif')
def initialize( context ):
initializeBasesPhase2( z_bases, context )
initializeBasesPhase2( z_tool_bases, context )
ToolInit( 'CMF Default Tool'
, tools=tools
, icon='tool.gif'
).initialize( context )
ContentInit( 'CMF Default Content'
, content_types=contentClasses
, permission=AddPortalContent
, extra_constructors=contentConstructors
, fti=Portal.factory_type_information
).initialize( context )
profile_registry.registerProfile('default',
'CMFDefault Site',
'Profile for a default CMFSite.',
'profiles/default',
'CMFDefault',
BASE)
profile_registry.registerProfile('sample_content',
'Sample CMFDefault Content',
'Content for a sample CMFSite.',
'profiles/sample_content',
'CMFDefault',
EXTENSION)
context.registerClass( Portal.CMFSite
, constructors=(factory.addConfiguredSiteForm,
factory.addConfiguredSite,
Portal.manage_addCMFSite)
, icon='images/portal.gif'
)
registerIcon( DefaultWorkflow.DefaultWorkflowDefinition
, 'images/workflow.gif'
, globals()
)
# make registerHelp work with 2 directories
help = context.getProductHelp()
lastRegistered = help.lastRegistered
context.registerHelp(directory='help', clear=1)
context.registerHelp(directory='interfaces', clear=1)
if help.lastRegistered != lastRegistered:
help.lastRegistered = None
context.registerHelp(directory='help', clear=1)
help.lastRegistered = None
context.registerHelp(directory='interfaces', clear=0)
context.registerHelpTitle('CMF Default Help')
def initialize(context):
ToolInit('CMF Calendar Tool',
tools=(CalendarTool.CalendarTool, ),
icon='tool.gif').initialize(context)
# BBB: register oldstyle constructors
ContentInit('CMF Calendar Content',
content_types=(),
permission=AddPortalContent,
extra_constructors=(Event.addEvent, )).initialize(context)
def initialize(context):
ToolInit(meta_type='CMF Action Icons Tool',
tools=(ActionIconsTool.ActionIconsTool, ),
icon="tool.gif").initialize(context)
if has_profile_registry:
profile_registry.registerProfile('actionicons', 'CMFActionIcons',
'Adds action icon tool / settings.',
'profiles/actionicons',
'CMFActionIcons', EXTENSION)
def initialize(self, context):
# Wrap the CMFCore Tool Init method.
CMFCoreToolInit.initialize(self, context)
for tool in self.tools:
# Get the icon path from the tool
path = getattr(tool, 'toolicon', None)
if path is not None:
pc = self.getProductContext(context)
if pc is not None:
pid = pc.id
name = split(path)[1]
icon = self.getIcon(context, path)
if icon is None:
# Icon was not found
return
icon.__roles__ = None
tool.icon = 'misc_/%s/%s' % (self.product_name, name)
misc = OFS.misc_.misc_
Misc = OFS.misc_.Misc_
if not hasattr(misc, pid):
setattr(misc, pid, Misc(pid, {}))
getattr(misc, pid)[name] = icon
def initialize(self, context):
""" Wrap the CMFCore Tool Init method """
CMFCoreToolInit.initialize(self, context)
for tool in self.tools:
# Get the icon path from the tool
path = getattr(tool, 'toolicon', None)
if path is not None:
pc = self.getProductContext(context)
if pc is not None:
pid = pc.id
name = split(path)[1]
icon = self.getIcon(context, path)
if icon is None:
# Icon was not found
return
icon.__roles__ = None
tool.icon = 'misc_/%s/%s' % (self.product_name, name)
misc = OFS.misc_.misc_
Misc = OFS.misc_.Misc_
if not hasattr(misc, pid):
setattr(misc, pid, Misc(pid, {}))
getattr(misc, pid)[name] = icon
def initialize(context):
TOOLS = (
CSSRegistry.CSSRegistryTool,
KSSRegistry.KSSRegistryTool,
JSRegistry.JSRegistryTool,
)
ToolInit(
config.PROJECTNAME + ' Tool',
tools=TOOLS,
icon='tool.gif',
).initialize(context)
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 initialize(context):
# inicializa a instalacao e estrutura do SAGL-OpenLegis
ModuleSecurityInfo('socket.socket').declarePublic('fileno')
ModuleSecurityInfo('tempfile.NamedTemporaryFile').declarePublic('flush')
allow_module('zlib')
allow_module('urllib')
allow_module('urllib2')
allow_module('sys')
allow_module('os')
allow_module('lacunarestpki')
allow_module('Acquisition')
allow_module('ExtensionClass')
allow_module('App.FindHomes')
allow_module('trml2pdf')
allow_module('cStringIO.StringIO')
allow_module('time')
allow_module('_strptime')
allow_module('csv')
allow_module('pdb')
allow_module('simplejson')
allow_module('tempfile.NamedTemporaryFile')
allow_module('collections')
allow_module('base64')
allow_module('socket')
allow_module('fcntl')
allow_module('struct')
allow_module('array')
allow_module('datetime')
allow_module('datetime.datetime.timetuple')
allow_module('PyPDF2')
allow_module('StringIO')
allow_module('PIL')
tools = (SAPLTool.SAPLTool, )
ToolInit('SAPL Tool', tools=tools, icon='tool.gif').initialize(context)
context.registerClass(Portal.SAPL,
constructors=(
Portal.manage_addSAPLForm,
Portal.manage_addSAPL,
),
icon='interlegisIcon.gif')
context.registerClass(lexml.SAPLOAIServer.SAPLOAIServer,
constructors=(
SAPLOAIServer.manage_addSAPLOAIServerForm,
SAPLOAIServer.manage_addSAPLOAIServer,
),
icon='oai_service.png')
def initialize(context):
context.registerClass(
usermanager.MembraneUserManager,
permission=add_user_folders,
constructors=(usermanager.manage_addMembraneUserManagerForm,
usermanager.addMembraneUserManager),
visibility=None
)
context.registerClass(
groupmanager.MembraneGroupManager,
permission=add_user_folders,
constructors=(groupmanager.manage_addMembraneGroupManagerForm,
groupmanager.addMembraneGroupManager),
visibility=None
)
context.registerClass(
propertymanager.MembranePropertyManager,
permission=add_user_folders,
constructors=(propertymanager.manage_addMembranePropertyManagerForm,
propertymanager.addMembranePropertyManager),
visibility=None
)
context.registerClass(
rolemanager.MembraneRoleManager,
permission=add_user_folders,
constructors=(rolemanager.manage_addMembraneRoleManagerForm,
rolemanager.addMembraneRoleManager),
visibility=None
)
context.registerClass(
userfactory.MembraneUserFactory,
permission=add_user_folders,
constructors=(userfactory.manage_addMembraneUserFactoryForm,
userfactory.addMembraneUserFactory),
visibility=None
)
from Products.membrane.tools import membrane
ToolInit(PROJECTNAME + ' Tool',
tools=(membrane.MembraneTool, ),
icon='tool.gif'
).initialize(context)
def initialize(context):
context.registerClass(CollaborationFolder.CollaborationFolder,
constructors=(CollaborationFolder.manage_addCollaborationFolderForm,
CollaborationFolder.manage_addCollaborationFolder),
icon="www/collabfolder.gif")
context.registerClass(CollaborationFolder.CollabRequest,
permission="CollaborationFolder: Add Collaboration",
constructors=(CollaborationFolder.manage_addCollabRequestForm,
CollaborationFolder.manage_addCollabRequest),
icon="www/collabrequest.gif")
ToolInit( meta_type='Collaboration Tool'
, tools=( CollaborationTool, )
, icon="tool.gif"
).initialize( context )
def initialize(context):
# inicializa a instalacao e estrutura do SAPL
tools = [SAPLTool]
ToolInit('SAPL Tool', tools=tools, icon='tool.gif').initialize(context)
context.registerClass(Portal.SAPL,
constructors=(Portal.manage_addSAPLForm,
Portal.manage_addSAPL),
icon='interlegisIcon.gif')
context.registerClass(lexml.SAPLOAIServer.SAPLOAIServer,
constructors=(
SAPLOAIServer.manage_addSAPLOAIServerForm,
SAPLOAIServer.manage_addSAPLOAIServer,
),
icon='oai_service.png')
def initialize(context):
# Setup migrations
migration.executeMigrations()
migration.registerMigrations()
# optional demo content
if config.INSTALL_EXAMPLES:
import examples
# register the fti
context.registerClass(PloneArticleFactoryTypeInformation,
permission=ManagePortal,
constructors=(manage_addPAFTIForm, ),
visibility=None)
context.registerClass(DynamicAllowedContentFTI,
permission=ManagePortal,
constructors=(manage_addDVTFTIForm, ),
visibility=None)
# initialize the content, including types and add permissions
content_types, constructors, ftis = process_types(
listTypes(config.PROJECTNAME), config.PROJECTNAME)
permissions = {
'PloneArticle': 'PloneArticle: Add PloneArticle',
'PloneArticleMultiPage': "PloneArticle: Add PloneArticleMultiPage",
}
for atype, constructor, fti in zip(content_types, constructors, ftis):
permission = permissions.get(atype.portal_type,
'PloneArticle: Add PloneArticle')
ContentInit(
config.PROJECTNAME + ' Content',
content_types=(atype, ),
permission=permission,
extra_constructors=(constructor, ),
fti=(fti, ),
).initialize(context)
# Initialize the tool
ToolInit(config.PROJECTNAME + ' Tool',
tools=(tool.PloneArticleTool, ),
icon='tool.gif').initialize(context)
def initialize(context):
from Products.CMFCore.utils import ToolInit
from Products.GenericSetup import EXTENSION
from Products.GenericSetup import profile_registry
import UniqueIdAnnotationTool
import UniqueIdGeneratorTool
import UniqueIdHandlerTool
tools = (UniqueIdAnnotationTool.UniqueIdAnnotationTool,
UniqueIdGeneratorTool.UniqueIdGeneratorTool,
UniqueIdHandlerTool.UniqueIdHandlerTool)
ToolInit('CMF Unique Id Tool', tools=tools,
icon='tool.gif').initialize(context)
profile_registry.registerProfile('default', 'CMFUid', 'Adds UID support.',
'profiles/default', 'CMFUid', EXTENSION)
def initialize(context):
init = ToolInit(PKG_NAME, tools = tools, product_name = PKG_NAME,
icon='tool.gif')
init.initialize(context)
def initialize(context):
new_tool = ToolInit(
config.TOOL_NAME, tools=(tool.PloneKeywordManager, ), icon='tool.gif')
new_tool.initialize(context)
