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",
tools=(PloneKupuLibraryTool, ),
product_name='kupu',
icon="kupu_icon.gif",
)
init.initialize(context)
if profile_registry is not None:
profile_registry.registerProfile(
'default',
'Kupu',
'Kupu is a cross-browser visual editor.',
'plone/profiles/default',
'kupu',
EXTENSION,
for_=IPloneSiteRoot)
def initialize(context):
from Products.CMFCore import utils
utils.ToolInit(
'MimetypesRegistry Tool',
tools=(MimeTypesRegistry.MimeTypesRegistry, ),
icon='tool.gif',
).initialize(context)
def initialize(context):
""" Zope 2
"""
from Products.EEAEnquiry.tools import catalog
cmfutils.ToolInit('Enquiry Tool',
tools=(catalog.EnquiryCatalog, ),
icon='tool.gif').initialize(context)
from Products.EEAEnquiry import content
content.register_content()
# Initialize portal content
all_content_types, all_constructors, all_ftis = atapi.process_types(
listTypes(config.PROJECTNAME), config.PROJECTNAME)
cmfutils.ContentInit(
config.PROJECTNAME + ' Content',
content_types=all_content_types,
permission=config.DEFAULT_ADD_CONTENT_PERMISSION,
extra_constructors=all_constructors,
fti=all_ftis,
).initialize(context)
# Give it some extra permissions to control them on a per class limit
for i in range(0, len(all_content_types)):
klassname = all_content_types[i].__name__
if not klassname in config.ADD_CONTENT_PERMISSIONS:
continue
context.registerClass(
meta_type=all_ftis[i]['meta_type'],
constructors=(all_constructors[i], ),
permission=config.ADD_CONTENT_PERMISSIONS[klassname])
def initialize_tool(context):
from gocept.linkchecker import LinkCheckerTool
tools = (LinkCheckerTool.LinkCheckerTool, )
tool_init = CMFutils.ToolInit('Link checker tool',
tools=tools,
icon="tool.png")
tool_init.initialize(context)
def initialize(context):
from content import BlogEntry
from content import Blog
from content import BlogFolder
listOfTypes = listTypes(PROJECTNAME)
content_types, constructors, ftis = process_types(listOfTypes, PROJECTNAME)
from Products.SimpleBlog.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 SimpleBlogTool import SimpleBlogManager
utils.ToolInit(
'SimpleBlog manager',
tools=(SimpleBlogTool.SimpleBlogManager, ),
icon='tool.gif',
).initialize(context)
def initialize(context):
from Products.CMFCore import utils
utils.ToolInit(
"%s Tool" % PKG_NAME,
tools=tools,
icon="tool.gif",
).initialize(context)
def initialize(context):
utils.initializeBasesPhase2(z_bases, context)
utils.initializeBasesPhase2(z_tool_bases, context)
utils.ToolInit(
'CMFDefault Tool',
tools=tools,
product_name='CMFDefault',
icon='tool.gif',
).initialize(context)
utils.ContentInit('CMFDefault Content',
content_types=contentClasses,
permission=ADD_CONTENT_PERMISSION,
extra_constructors=contentConstructors,
fti=Portal.factory_type_information).initialize(context)
context.registerClass(Portal.CMFSite,
constructors=(
Portal.manage_addCMFSiteForm,
Portal.manage_addCMFSite,
),
icon='portal.gif')
utils.registerIcon(DefaultWorkflow.DefaultWorkflowDefinition,
'images/workflow.gif', globals())
context.registerHelp()
context.registerHelpTitle('CMF Default Help')
def initialize(context):
utils.initializeBasesPhase2(z_bases, context)
utils.initializeBasesPhase2(z_tool_bases, context)
utils.ToolInit(
'CMFDefault Tool',
tools=tools,
product_name='CMFDefault',
icon='tool.gif',
).initialize(context)
utils.ContentInit('CMFDefault Content',
content_types=contentClasses,
permission=ADD_CONTENT_PERMISSION,
extra_constructors=contentConstructors,
fti=Portal.factory_type_information).initialize(context)
context.registerClass(Portal.CMFSite,
constructors=(
Portal.manage_addCMFSiteForm,
Portal.manage_addCMFSite,
),
icon='portal.gif')
reg = Products.CMFCore.PortalFolder.addPortalTypeHandler
reg('text/html', Document.Document)
reg('text/plain', Document.Document)
reg('image/png', Image.Image)
reg('image/gif', Image.Image)
reg('image/jpeg', Image.Image)
reg('image/unknown', Image.Image)
def initialize(context):
##Import Types here to register them
from content import coreblog2
from content import coreblogstufffolder
from content import coreblogentry
from content import coreblogcategory
from content import coreblogcomment
from content import coreblogtrackback
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),
PROJECTNAME)
utils.ToolInit(
'COREBlog Tool',
tools=(COREBlogTool.COREBlog2Tool, ),
product_name=PROJECTNAME,
icon='tool.gif',
).initialize(context)
permissions = initialize_permissions()
allTypes = zip(content_types, constructors)
for atype, constructor in allTypes:
kind = "%s: %s" % (config.PROJECTNAME, atype.archetype_name)
utils.ContentInit(
kind,
content_types=(atype, ),
permission=permissions[atype.portal_type],
extra_constructors=(constructor, ),
fti=ftis,
).initialize(context)
def initialize(context):
from Products.CMFCore import utils
utils.ToolInit(
"%s Tool" % PKG_NAME,
tools=tools,
icon="tool.gif",
).initialize(context)
if REGISTER_DEMO_TYPES:
import Products.Archetypes.examples
content_types, constructors, ftis = process_types(
listTypes(PKG_NAME), PKG_NAME)
utils.ContentInit(
'%s Content' % PKG_NAME,
content_types=content_types,
permission=permissions.AddPortalContent,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
try:
from Products.CMFCore.FSFile import FSFile
from Products.CMFCore.DirectoryView import registerFileExtension
registerFileExtension('xsl', FSFile)
registerFileExtension('xul', FSFile)
except ImportError:
pass
def initialize(context):
"""Initializer called when used as a Zope 2 product."""
utils.ToolInit(
'Handle Client',
tools=tools,
icon='tool.gif',
).initialize(context)
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
content_types, constructors, ftis = process_types(
listTypes(config.PROJECTNAME), config.PROJECTNAME)
utils.ContentInit(
"%s Content" % config.PROJECTNAME,
content_types=content_types,
permission=config.ADD_CONTENT_PERMISSION,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
utils.ToolInit(
config.TOOL_NAME,
tools=tools,
icon=config.TOOL_ICON,
).initialize(context)
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),
PROJECTNAME)
# Assign an own permission to all content types
# Heavily based on Bricolite's code from Ben Saller
import permissions as perms
allTypes = zip(content_types, constructors)
for atype, constructor in allTypes:
kind = "%s: %s" % (PROJECTNAME, atype.archetype_name)
utils.ContentInit(
kind,
content_types=(atype, ),
# Add permissions look like perms.Add{meta_type}
permission=getattr(perms, 'Add%s' % atype.meta_type),
extra_constructors=(constructor, ),
fti=ftis,
).initialize(context)
from AccessControl import allow_class
from batch import Batch
allow_class(Batch)
this_module.Batch = Batch
def initialize(context):
import NotificationTool
tools = (NotificationTool.NotificationTool, )
CMFCoreUtils.ToolInit(NotificationTool.META_TYPE,
tools=tools,
icon='tool.gif').initialize(context)
def initialize(context):
## Register our tool
utils.ToolInit(
"%s's Tool" % config.PROJECTNAME,
tools=(AnalyticsTool.AnalyticsTool, ),
product_name=config.PROJECTNAME,
icon='analytics_icon.gif',
).initialize(context)
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 initialize(context):
utils.initializeBasesPhase2(z_tool_bases, context)
utils.ToolInit('CMF Unique Id Tool',
tools=tools,
product_name='CMFUid',
icon='tool.gif').initialize(context)
def initialize(context):
utils.ToolInit('LinkMap Tool', tools=tools,
icon='tool.gif').initialize(context)
context.registerClass(
LinkMapTool.ExtendedLink,
constructors=(LinkMapTool.manage_addLink, LinkMapTool.manage_addLink),
)
def initialize(context):
# Initialize the tool
utils.ToolInit(
config.PROJECTNAME + ' Tool',
tools=(MeteoTool.MeteoTool, ),
product_name=config.PROJECTNAME,
icon='tool.gif',
).initialize(context)
def initialize(context):
utils.initializeBasesPhase2(z_tool_bases, context)
utils.ToolInit(
'CMFStaging Tool',
tools=tools,
product_name='CMFStaging',
icon='tool.gif',
).initialize(context)
def initialize(context):
utils.initializeBasesPhase2(z_tool_bases, context)
utils.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):
utils.ToolInit('CMF Diff Tool',
tools = tools,
icon='tool.gif'
).initialize( context )
utils.initializeBasesPhase2( z_bases, context )
utils.ContentInit(ChangeSet.ChangeSet.meta_type,
content_types = contentClasses,
permission = CMFCorePermissions.AddPortalContent,
extra_constructors = contentConstructors,
fti = ChangeSet.factory_type_information).initialize(context)
def initialize_tools(context):
from gocept.alphaflow import processmanager, process
tool = cmfcoreutils.ToolInit('workflow_manager',
tools=(processmanager.ProcessManager, ),
icon='browser/resources/tool.gif')
tool.initialize(context)
context.registerClass(
process.ProcessVersion,
constructors=(process.manage_addProcess, ),
container_filter=ProcessManagerFilter,
)
def initialize(context):
# Content Types
import content.fedorahierarchie
import content.volume
import content.issue
import content.specialissue
import content.fedoraarticle
import content.fedoradocument
import content.fedoraxml
import content.fedoramultimedia
import SubmissionFolder
import Submission
import Manuscript
import Review
import Attachment
# Tools
import EditorialToolboxTool
import Fedora2DiPP3Tool
import BibTool
import Utils
import Deadlines
import SectionsTool
import PeerReviewTool
import DataCite
sys.modules['Products.DiPP.SpecialIssue'] = content.specialissue
sys.modules['Products.DiPP.FedoraHierarchie'] = content.fedorahierarchie
sys.modules['Products.DiPP.FedoraArticle'] = content.fedoraarticle
sys.modules['Products.DiPP.FedoraDocument'] = content.fedoradocument
sys.modules['Products.DiPP.FedoraMultimedia'] = content.fedoramultimedia
sys.modules['Products.DiPP.FedoraXML'] = content.fedoraxml
sys.modules['Products.DiPP.Volume'] = content.volume
sys.modules['Products.DiPP.Issue'] = content.issue
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),
PROJECTNAME)
tools = (Fedora2DiPP3Tool.Fedora, EditorialToolboxTool.toolbox,
BibTool.BibTool, Utils.Utils, DataCite.DataCite,
Deadlines.Deadlines, SectionsTool.SectionsTool,
PeerReviewTool.PeerReviewTool)
utils.ToolInit(PROJECTNAME + ' Tools', tools=tools,
icon='dipptool.gif').initialize(context)
utils.ContentInit(
PROJECTNAME + ' Content',
content_types=content_types,
permission=ADD_CONTENTS_PERMISSION,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
def initialize(context):
"""
Initializer called when used as a Zope 2 product.
"""
cmfutils.registerIcon(AnalyticsReport, 'browser/images/chart_bar.gif',
globals())
cmfutils.ToolInit(
'Google Analytics Tool',
tools=tools,
icon='browser/images/chart_curve.gif',
).initialize(context)
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)
##########
# 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 == 'FormCustomScriptAdapter':
permission = CSA_ADD_CONTENT_PERMISSION
elif atype.portal_type == 'FormMailerAdapter':
permission = MA_ADD_CONTENT_PERMISSION
elif atype.portal_type == 'FormSaveDataAdapter':
permission = SDA_ADD_CONTENT_PERMISSION
elif atype.portal_type == 'FormSubmissionFolderAdapter':
permission = SFA_ADD_CONTENT_PERMISSION
else:
permission = ADD_CONTENT_PERMISSION
utils.ContentInit(
kind,
content_types = (atype,),
permission = permission,
extra_constructors = (constructor,),
fti = ftis,
).initialize(context)
ModuleSecurityInfo('Products.PloneFormGen').declarePublic('PloneFormGenMessageFactory')
def initialize(context):
# imports packages and types for registration
import interfaces
import FacultyStaffDirectory
import Classification
import Person
import Course
import CommitteesFolder
import Committee
import Specialty
import SpecialtiesFolder
import PersonGrouping
import Department
import Lab
import LabMembership
import CommitteeMembership
import SpecialtyInformation
import DepartmentalMembership
# Initialize portal content
all_content_types, all_constructors, all_ftis = process_types(
listTypes(PROJECTNAME), PROJECTNAME)
cmfutils.ContentInit(
PROJECTNAME + ' Content',
content_types=all_content_types,
permission=DEFAULT_ADD_CONTENT_PERMISSION,
extra_constructors=all_constructors,
fti=all_ftis,
).initialize(context)
# Give it some extra permissions to control them on a per class limit
for i in range(0, len(all_content_types)):
klassname = all_content_types[i].__name__
if not klassname in ADD_CONTENT_PERMISSIONS:
continue
context.registerClass(meta_type=all_ftis[i]['meta_type'],
constructors=(all_constructors[i], ),
permission=ADD_CONTENT_PERMISSIONS[klassname])
# Register the FacultyStaffDirectory tool
cmfutils.ToolInit(
'Faculty/Staff Directory Tool',
product_name='FacultyStaffDirectory',
tools=(FacultyStaffDirectoryTool, ),
icon='skins/FacultyStaffDirectory/group.png').initialize(context)
def initialize(context):
"""Initializer called when used as a Zope 2 product."""
#context.registerClass (
# ScriptableMailHost,
# constructors=(manage_addScriptableMailHostForm, manage_addScriptableMailHost)
# )
context.registerClass(MultiMailHost.MultiMailHost,
constructors=(manage_addMultiMailHostForm,
manage_addMultiMailHost))
tools = (MultiMailHost, )
CMFCoreUtils.ToolInit(MultiMailHost.MultiMailHost.meta_type,
tools=tools).initialize(context)
def initialize(context):
cmf_utils.ToolInit('Salesforce Base Connector',
tools = tools,
icon='www/salesforce.png'
).initialize( context )
# initialize security for the QueryResult and QueryRecordSet classes from beatbox
beatbox.python_client.QueryRecord.security = security = ClassSecurityInfo()
beatbox.python_client.QueryRecord.__allow_access_to_unprotected_subobjects__ = 1
security.declareObjectPublic()
InitializeClass(beatbox.python_client.QueryRecord)
beatbox.python_client.QueryRecordSet.security = security = ClassSecurityInfo()
beatbox.python_client.QueryRecordSet.__allow_access_to_unprotected_subobjects__ = 1
security.declareObjectPublic()
InitializeClass(beatbox.python_client.QueryRecordSet)
def initialize(context):
utils.initializeBasesPhase2(z_tool_bases, context)
utils.ToolInit(
'CMFStaging Tool',
tools=tools,
product_name='CMFStaging',
icon='tool.gif',
).initialize(context)
context.registerClass(
WorkflowRepository.WorkflowRepository,
constructors=(WorkflowRepository.manage_addWorkflowRepositoryForm,
WorkflowRepository.manage_addWorkflowRepository),
icon='tool.gif',
)
