def initialize(context):
from Products.Extropy import content
content_types, constructors, ftis = process_types(listTypes(config.PROJECTNAME), config.PROJECTNAME)
ContentInit(
config.PROJECTNAME + " Content",
content_types=content_types,
permission=config.ADD_CONTENT_PERMISSION,
extra_constructors=constructors,
).initialize(context)
TOOLS = (tools.ExtropyTimeTrackerTool.ExtropyTimeTrackerTool, tools.ExtropyTrackingTool.ExtropyTrackingTool)
ToolInit(config.PROJECTNAME + " Tool", tools=TOOLS, icon="tool.gif").initialize(context)
import patches
allow_module("Products.Extropy.odict")
from Products.Extropy.odict import OrderedDict
allow_class(OrderedDict)
from Products.CMFPlone import i18nl10n
i18nl10n.setDefaultDateFormat(("en",), u"yyyy-MM-dd")
i18nl10n.setDefaultTimeFormat(("en",), u"HH:mm:ss")
def initialize(context):
"""Initializer called when used as a Zope 2 product."""
import ubify.recyclebin.content
from Products.ATContentTypes.permission import permissions
content_types, constructors, ftis = process_types(
listTypes(PROJECTNAME), PROJECTNAME)
allTypes = zip(content_types, constructors)
for atype, constructor in allTypes:
kind = "%s: %s" % (PROJECTNAME, atype.archetype_name)
if atype.portal_type not in TYPES_NEW:
ContentInit(
kind,
content_types = (atype,),
permission = permissions[atype.portal_type],
extra_constructors = (constructor,),
).initialize(context)
else:
ContentInit(
kind,
content_types = (atype,),
permission = DEFAULT_ADD_CONTENT_PERMISSION,
extra_constructors = (constructor,),
).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):
import MoneyField
import FixedPointField
import MoneyWidget
# As time goes by, more things will move from Python into the
# profile.
profile_desc = "Extra setup stuff for FinanceFields."
profile_registry.registerProfile('default',
'FinanceFields',
profile_desc,
'profiles/default',
'FinanceFields',
EXTENSION,
for_=IPloneSiteRoot,
)
content_types, constructors, ftis = process_types(
listTypes(PROJECTNAME),
PROJECTNAME)
ContentInit(
PROJECTNAME + ' Content',
content_types = content_types,
permission = ADD_CONTENT_PERMISSION,
extra_constructors = constructors,
fti = ftis,
).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):
# 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):
import Products.PloneSurvey.content
ADD_CONTENT_PERMISSIONS = {}
types = listTypes(PROJECTNAME)
for aType in types:
if aType['portal_type'] in [
'Survey',
]:
ADD_CONTENT_PERMISSIONS[aType['portal_type']] = addSurvey
else:
ADD_CONTENT_PERMISSIONS[aType['portal_type']] = AddPortalContent
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),
PROJECTNAME)
allTypes = zip(content_types, constructors)
for aType, constructor in allTypes:
kind = "%s: %s" % (PROJECTNAME, aType.portal_type)
ContentInit(
kind,
content_types=(aType, ),
permission=ADD_CONTENT_PERMISSIONS[aType.portal_type],
extra_constructors=(constructor, ),
fti=ftis,
).initialize(context)
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):
# Importing the content types allows for their registration
# with the Archetypes runtime
from Products.sampleremember import content
# Ask Archetypes to handback all the type information needed
# to make the CMF happy.
types = atapi.listTypes(config.PROJECT_NAME)
content_types, constructors, ftis = \
atapi.process_types(types, config.PROJECT_NAME)
# We register each type with an add permission that is set
# in permissions.py. By default, each content type has its
# own permission, but this behavior can be easily overridden.
permissions = initialize_permissions()
allTypes = zip(content_types, constructors)
for atype, constructor in allTypes:
kind = "%s: %s" % (config.PROJECT_NAME, atype.archetype_name)
cmf_utils.ContentInit(
kind,
content_types = (atype,),
permission = permissions[atype.portal_type],
extra_constructors = (constructor,),
fti = ftis,
).initialize(context)
profile_registry.registerProfile(
'default',
'sampleremember',
"Installs sampleremember.",
'profiles/default',
'sampleremember',
EXTENSION,
for_=IPloneSiteRoot,)
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:
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):
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 Warenkorb
import SimpleProduct
import DefaultProduct
# Register skin directory
DirectoryView.registerDirectory("skins", globals())
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME), PROJECTNAME)
utils.ContentInit(
PROJECTNAME + " Warenkorb",
content_types=content_types,
permission=ADD_CONTENT_PERMISSION,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
utils.ContentInit(
PROJECTNAME + " Simple Product",
content_types=content_types,
permission=ADD_CONTENT_PERMISSION,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
utils.ContentInit(
PROJECTNAME + " Default Product",
content_types=content_types,
permission=ADD_CONTENT_PERMISSION,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
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 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':
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('SalesforcePFGAdapterMessageFactory')
ModuleSecurityInfo('Products.PloneFormGen').declarePublic('HAS_PLONE25')
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':
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(
'SalesforcePFGAdapterMessageFactory')
ModuleSecurityInfo('Products.PloneFormGen').declarePublic('HAS_PLONE25')
def gen_class(klass, schema=None):
"""generats and registers the klass
"""
if schema is not None:
klass.schema = schema.copy()
registerType(klass, 'AttachmentFieldTest')
content_types, constructors, ftis = process_types(listTypes(), PKG_NAME)
def initialize(context):
"""Initializer called when used as a Zope 2 product."""
import ubify.recyclebin.content
from Products.ATContentTypes.permission import permissions
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),
PROJECTNAME)
allTypes = zip(content_types, constructors)
for atype, constructor in allTypes:
kind = "%s: %s" % (PROJECTNAME, atype.archetype_name)
if atype.portal_type not in TYPES_NEW:
ContentInit(
kind,
content_types=(atype, ),
permission=permissions[atype.portal_type],
extra_constructors=(constructor, ),
).initialize(context)
else:
ContentInit(
kind,
content_types=(atype, ),
permission=DEFAULT_ADD_CONTENT_PERMISSION,
extra_constructors=(constructor, ),
).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 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):
install_types = DEBUG or \
os.environ.get(INSTALL_EXAMPLE_TYPES_ENVIRONMENT_VARIABLE)
if install_types:
# Import example types
from Products.FileSystemStorage.examples import FSSItem
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),
PROJECTNAME)
ContentInit('%s Content' % PROJECTNAME,
content_types = content_types,
permission = CMFCorePermissions.AddPortalContent,
extra_constructors = constructors,
fti = ftis,
).initialize(context)
# Import tool
from Products.FileSystemStorage.FSSTool import FSSTool
ToolInit(
'%s Tool' % PROJECTNAME,
tools=(FSSTool,),
product_name=PROJECTNAME,
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):
"""initialization method
"""
# generate the content types, constructors, and FTIs
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),
PROJECTNAME)
# instatiates an object of the type ContentInit (from the CMFCore) and register the types in the CMF
# or permission = DEFAULT_ADD_CONTENT_PERMISSION,
utils.ContentInit(
PROJECTNAME + ' Content',
content_types=content_types,
permission=ADD_CONTENT_PERMISSION,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
if HAS_GENERICSETUP:
profile_registry.registerProfile(PROJECTNAME,
PROJECTNAME,
'Extension profile for default setup',
'profiles/default',
PROJECTNAME,
EXTENSION,
for_=IPloneSiteRoot)
def initialize(context):
import ubify.coretypes.content
from Products.ATContentTypes.permission import permissions
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),
PROJECTNAME)
allTypes = zip(content_types, constructors)
for atype, constructor in allTypes:
kind = "%s: %s" % (PROJECTNAME, atype.archetype_name)
if atype.portal_type not in TYPES_NEW:
ContentInit(
kind,
content_types=(atype, ),
permission=permissions[atype.portal_type],
extra_constructors=(constructor, ),
).initialize(context)
else:
ContentInit(
kind,
content_types=(atype, ),
permission=DEFAULT_ADD_CONTENT_PERMISSION,
extra_constructors=(constructor, ),
).initialize(context)
ModuleSecurityInfo("ubify.coretypes").declarePublic("get_action_mapped")
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):
"""load up content types"""
from Products.CMFCore import utils as cmf_utils
#app = context._ProductContext__app
#patch_listDefaultTypeInformation(app)
from ironicwiki import IronicWiki
try:
from wickeddoc import WickedDoc
except ImportError: # no ATCT
pass
types = atapi.listTypes(PROJECTNAME)
content_types, constructors, ftis = atapi.process_types( types,
PROJECTNAME)
permissions = {}
types = atapi.listTypes(PROJECTNAME)
for atype in types:
permission = "%s: Add %s" % (PROJECTNAME, atype['portal_type'])
permissions[atype['portal_type']] = permission
# Assign default roles
setDefaultRoles(permission, ('Manager', 'Owner'))
allTypes = zip(content_types, constructors)
for atype, constructor in allTypes:
kind = "%s: %s" % (PROJECTNAME, atype.archetype_name)
cmf_utils.ContentInit(
kind,
content_types = (atype,),
permission = permissions[atype.portal_type],
extra_constructors = (constructor,),
fti = ftis,
).initialize(context)
def initialize(context):
import ubify.coretypes.content
from Products.ATContentTypes.permission import permissions
content_types, constructors, ftis = process_types(
listTypes(PROJECTNAME), PROJECTNAME)
allTypes = zip(content_types, constructors)
for atype, constructor in allTypes:
kind = "%s: %s" % (PROJECTNAME, atype.archetype_name)
if atype.portal_type not in TYPES_NEW:
ContentInit(
kind,
content_types = (atype,),
permission = permissions[atype.portal_type],
extra_constructors = (constructor,),
).initialize(context)
else:
ContentInit(
kind,
content_types = (atype,),
permission = DEFAULT_ADD_CONTENT_PERMISSION,
extra_constructors = (constructor,),
).initialize(context)
ModuleSecurityInfo("ubify.coretypes").declarePublic("get_action_mapped")
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):
##Import Types here to register them
from content import Portlet
from content import TopicPortlet
if HAS_CMFSIN:
from content import CMFSinPortlet
content_types, constructors, ftis = process_types(
listTypes(PROJECTNAME),
PROJECTNAME)
utils.ContentInit(
PROJECTNAME + ' Content',
content_types = content_types,
permission = ADD_CONTENTS_PERMISSION,
extra_constructors = constructors,
fti = ftis,
).initialize(context)
from SimplePortletTool import SimplePortletTool
utils.ToolInit(
'SimplePortlet tool',
tools=(SimplePortletTool,),
icon='tool.gif', ).initialize(context)
def initialize(context):
import Products.PloneSurvey.content
ADD_CONTENT_PERMISSIONS = {}
types = listTypes(PROJECTNAME)
for aType in types:
if aType['portal_type'] in ['Survey',]:
ADD_CONTENT_PERMISSIONS[aType['portal_type']] = addSurvey
else:
ADD_CONTENT_PERMISSIONS[aType['portal_type']] = AddPortalContent
content_types, constructors, ftis = process_types(
listTypes(PROJECTNAME),
PROJECTNAME)
allTypes = zip(content_types, constructors)
for aType, constructor in allTypes:
kind = "%s: %s" % (PROJECTNAME, aType.portal_type)
ContentInit(
kind,
content_types = (aType,),
permission = ADD_CONTENT_PERMISSIONS[aType.portal_type],
extra_constructors = (constructor,),
fti = ftis,
).initialize(context)
def initialize(context):
import content
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)
permission = ADD_CONTENT_PERMISSION
utils.ContentInit(
kind,
content_types = (atype,),
permission = permission,
extra_constructors = (constructor,),
fti = ftis,
).initialize(context)
def initialize(context):
""" The 'initialize' function of this Product.
It is called when Zope is restarted with these files in the Products
directory. (I'm not sure what it does or if it is neccessary
at all. Best leave it alone.)
"""
log('Start: "initialize()"\n')
try:
content_types, constructors, ftis = process_types(
listTypes(PROJECTNAME),
PROJECTNAME)
utils.ContentInit(
PROJECTNAME + ' Content',
content_types = content_types,
permission = PERMISSION_ADD_MCTEST,
extra_constructors = constructors,
fti = ftis,
).initialize(context)
log('\tWorked: "ContentInit()"\n')
# Add permissions to allow control on a per-class basis
for i in range(0, len(content_types)):
content_type = content_types[i].__name__
if ADD_CONTENT_PERMISSIONS.has_key(content_type):
context.registerClass(meta_type = ftis[i]['meta_type'],
constructors = (constructors[i],),
permission = ADD_CONTENT_PERMISSIONS[content_type])
from ECQTool import ECQTool
utils.ToolInit(
ECQTool.meta_type,
tools = (ECQTool,),
product_name = PROJECTNAME,
icon = 'ECQTool.png',
).initialize(context)
if profile_registry is not None:
profile_registry.registerProfile('default',
'ECQuiz',
'Extension profile for ECQuiz',
'profiles/default',
'ECQuiz',
EXTENSION,
for_=IPloneSiteRoot)
#~ parsers.initialize(context)
#~ renderers.initialize(context)
log('Worked: "initialize()"\n')
except Exception, e:
# Log any errors that occurred in 'initialize()'
log('Failed: "initialize()": ' + str(e) + '\n')
def initialize(context):
## archetypes initialization
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),PROJECTNAME)
utils.ContentInit(
"InraProjectsManager Content",
content_types = content_types,
permission = ManagePortal,
extra_constructors = constructors,
fti = ftis,).initialize(context)
context.registerClass(
meta_type = content.ProjectViewModelsManager.ProjectViewModelsManager.archetype_name,
constructors = (content.ProjectViewModelsManager.addProjectViewModelsManager,),
permission = ADD_MANAGER_PERMISSION,
)
context.registerClass(
meta_type = content.InraProjects.InraProject.archetype_name,
constructors = (content.InraProjects.addInraProject,),
permission = ADD_CONTENT_PERMISSION,
)
context.registerClass(
meta_type = content.InraProjectsManager.InraProjectsManager.archetype_name,
constructors = (content.InraProjectsManager.addInraProjectsManager,),
permission = ADD_MANAGER_PERMISSION,
)
context.registerClass(
meta_type = content.ProjectViewModels.ProjectViewModel.archetype_name,
constructors = (content.ProjectViewModels.addProjectViewModel,),
permission = ADD_MANAGER_PERMISSION,
)
context.registerClass(
meta_type = content.ProjectViewModels.ProjectViewModel.archetype_name,
constructors = (content.ProjectViewModels.addProjectViewModel,),
permission = ADD_MANAGER_PERMISSION,
)
context.registerClass(
meta_type = content.PublicProjectForm.PublicProjectForm.archetype_name,
constructors = (content.PublicProjectForm.addPublicProjectForm,),
permission = ADD_MANAGER_PERMISSION,
)
context.registerClass(
meta_type = content.ProjectReports.ProjectReport.archetype_name,
constructors = (content.ProjectReports.addProjectReport,),
permission = ADD_MANAGER_PERMISSION,
)
pass
def initialize(context):
from content import Map, Marker, Overlay
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME), PROJECTNAME)
utils.ContentInit(PROJECTNAME + ' Content',
content_types = content_types,
permission = DEFAULT_ADD_CONTENT_PERMISSION,
extra_constructors = constructors,
fti = ftis).initialize(context)
def initialize(context):
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),
PROJECTNAME)
utils.ContentInit(
PROJECTNAME + ' Content',
content_types=content_types,
permission=ADD_CONTENT_PERMISSION,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
def initialize(context):
"""Initializer called when used as a Zope 2 product."""
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),
PROJECTNAME)
utils.ContentInit(
PROJECTNAME + ' Content',
content_types=content_types,
permission=ADD_CONTENT_PERMISSION,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
def initialize(context):
content_types, constructors, ftis = process_types(
listTypes(PROJECTNAME),
PROJECTNAME)
utils.ContentInit(
PROJECTNAME + ' Content',
content_types = content_types,
permission = ADD_CONTENT_PERMISSION,
extra_constructors = constructors,
fti = ftis,
).initialize(context)
def initialize(context):
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),
PROJECTNAME)
utils.ContentInit(
'%s Content' % PROJECTNAME,
content_types=content_types,
permission=ADD_CONTENT_PERMISSIONS['UnifiedFile'],
extra_constructors=constructors,
fti=ftis,
).initialize(context)
def initialize(context):
"""Initializer called when used as a Zope 2 product."""
# import types from this project to register them.
import leocornus.bookkeeping.content
# get content type list, content constructor list, and file type
# information (fti) list.
content_types, constructors, ftis = process_types(
listTypes(PROJECTNAME),
PROJECTNAME)
# initializing permissions.
permissions = initialize_permissions()
# make 'content type' and 'consturctor' tuples list to use easly
# at next process.
allTypes = zip(content_types, constructors)
# Registration per content type.
for atype, constructor in allTypes:
kind = "%s: %s" % (PROJECTNAME, atype.archetype_name)
# Call CMFCore.utils.ContentInit to register content types.
ContentInit(
# Name that display in ADD drop-down menu on ZMI is
# specified. This is used as meta_type in internal. However,
# there is no relation to meta_type set in each contents type
# implementation class.
kind,
# The tupple of the contents type implementation class object
# that can be added with kind(meta_type) is specified. The
# menu panel to select it is displayed to add the object of
# which contents type with ZMI when the plural is specified
# when the addition is executed.
content_types = (atype,),
# Permission information on the contents type that tries to
# be registered now is specified among information acquired
# with initialize_permissions().
permission = permissions[atype.portal_type],
# The constructor executed when the object is added is
# specified. Constructors of the same number as the number of
# elements set to the content_types argument are necessary.
extra_constructors = (constructor,),
# FileTypeInformation is specified.
#fti = ftis,
# The initialization execution function of ContentInit is
# called. After necessary processing is done as CMFCore, the
# product registration function to Zope is called.
).initialize(context)
def initialize(context):
"""Initializer called when used as a Zope 2 product."""
# import types from this project to register them.
import leocornus.bookkeeping.content
# get content type list, content constructor list, and file type
# information (fti) list.
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),
PROJECTNAME)
# initializing permissions.
permissions = initialize_permissions()
# make 'content type' and 'consturctor' tuples list to use easly
# at next process.
allTypes = zip(content_types, constructors)
# Registration per content type.
for atype, constructor in allTypes:
kind = "%s: %s" % (PROJECTNAME, atype.archetype_name)
# Call CMFCore.utils.ContentInit to register content types.
ContentInit(
# Name that display in ADD drop-down menu on ZMI is
# specified. This is used as meta_type in internal. However,
# there is no relation to meta_type set in each contents type
# implementation class.
kind,
# The tupple of the contents type implementation class object
# that can be added with kind(meta_type) is specified. The
# menu panel to select it is displayed to add the object of
# which contents type with ZMI when the plural is specified
# when the addition is executed.
content_types=(atype, ),
# Permission information on the contents type that tries to
# be registered now is specified among information acquired
# with initialize_permissions().
permission=permissions[atype.portal_type],
# The constructor executed when the object is added is
# specified. Constructors of the same number as the number of
# elements set to the content_types argument are necessary.
extra_constructors=(constructor, ),
# FileTypeInformation is specified.
#fti = ftis,
# The initialization execution function of ContentInit is
# called. After necessary processing is done as CMFCore, the
# product registration function to Zope is called.
).initialize(context)
def initialize(context):
from Products.CMFCore.utils import ContentInit
import category, container
from Products.Archetypes.public import process_types, listTypes
content_types, constructors, ftis = process_types(
listTypes('marsapp.categories'), 'marsapp.categories')
ContentInit('marsapp.categories Content',
content_types = content_types,
permission = ADD_CONTENT_PERMISSION,
extra_constructors = constructors,
fti = ftis,
).initialize( context )
def initialize(context):
import MultiEvent
content_types, constructors, ftis = public.process_types(public.listTypes(config.PROJECTNAME), config.PROJECTNAME)
utils.ContentInit(
config.PROJECTNAME + " Content",
content_types=content_types,
permission=config.ADD_CONTENT_PERMISSION,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
def initialize(context):
# Import Types here to register them
content_types, constructors, ftis = process_types(
listTypes(PROJECTNAME), PROJECTNAME)
# Add permissions to allow control on a per-class basis
for i in range(0, len(content_types)):
content_type = content_types[i].__name__
if content_type in ADD_CONTENT_PERMISSIONS:
context.registerClass(meta_type = ftis[i]['meta_type'],
constructors = (constructors[i],),
permission = ADD_CONTENT_PERMISSIONS[content_type])
def initialize(context):
"""Initializer called when used as a Zope 2 product."""
content_types, constructors, ftis = process_types(
listTypes(PROJECTNAME),
PROJECTNAME)
utils.ContentInit(
PROJECTNAME + ' Content',
content_types = content_types,
permission = ADD_CONTENT_PERMISSION,
extra_constructors = constructors,
fti = ftis,
).initialize(context)
def initialize(context):
content_types, constructors, ftis = process_types(
listTypes(PROJECTNAME),
PROJECTNAME)
utils.ContentInit(
'%s Content' % PROJECTNAME,
content_types = content_types,
permission = ADD_CONTENT_PERMISSIONS['UnifiedFile'],
extra_constructors = constructors,
fti = ftis,
).initialize(context)
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)
def initialize(context):
content_types, constructors, ftis = process_types(
listTypes(config.PROJECTNAME), config.PROJECTNAME)
utils.ContentInit(
config.PROJECTNAME + ' Content',
content_types=content_types,
permission=AddPortalContent,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
def initialize_content(context):
from gocept.alphaflow import instance
import gocept.alphaflow.activities
content_types, constructors, ftis = process_types(
listTypes(config.PROJECTNAME), config.PROJECTNAME)
cmfcoreutils.ContentInit(
config.PROJECTNAME + ' Content',
content_types=content_types,
permission=config.ADD_CONTENT_PERMISSION,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
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):
from Products.CMFCore.utils import ContentInit
import category, container
from Products.Archetypes.public import process_types, listTypes
content_types, constructors, ftis = process_types(
listTypes('marsapp.categories'), 'marsapp.categories')
ContentInit(
'marsapp.categories Content',
content_types=content_types,
permission=ADD_CONTENT_PERMISSION,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
def initialize(context):
from Products.ImageRepository import content
content_types, constructors, ftis = process_types(
listTypes(config.PROJECTNAME), config.PROJECTNAME)
ContentInit(
config.PROJECTNAME + ' Content',
content_types=content_types,
permission=permissions.AddImageRepositoryContent,
extra_constructors=constructors,
).initialize(context)
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)
def initialize_content(context):
from Products.Procurement import request
types = atapi.listTypes(config.PROJECTNAME)
content_types, constructors, ftis = atapi.process_types(
types, config.PROJECTNAME)
cmfcoreutils.ContentInit(
config.PROJECTNAME + "Content",
content_types = content_types,
permission = config.ADD_CONTENT_PERMISSION,
extra_constructors = constructors,
fti = ftis,
).initialize(context)
def initialize(context):
from cirb.relex import content
content # pyflakes
content_types, constructors, ftis = process_types(listTypes('cirb.relex'),
'cirb.relex')
ContentInit(
'cirb.relex Content',
content_types=content_types,
permission='cirb.relex: Add Project',
extra_constructors=constructors,
fti=ftis,
).initialize(context)
def initialize(context):
"""
Create content types
"""
content_types, constructors, ftis = process_types(
listTypes(config.PROJECTNAME),
config.PROJECTNAME
)
ContentInit(config.PROJECTNAME + ' Content',
content_types=content_types,
permission=config.ADD_CONTENT_PERMISSION,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
def initialize(context):
import NewsletterReference
import NewsletterRichReference
import NewsletterBTree
ContentInit('Plone Gazette Newsletter Theme',
content_types=(NewsletterTheme.NewsletterTheme, ),
permission=AddNewsletterTheme,
extra_constructors=(NewsletterTheme.addNewsletterTheme, ),
fti=NewsletterTheme.NewsletterTheme.factory_type_information
).initialize(context)
ContentInit(
'Plone Gazette Newsletter Section',
content_types=(Section.Section, ),
permission=ChangeNewsletter,
extra_constructors=(Section.addSection, ),
fti=Section.Section.factory_type_information).initialize(context)
ContentInit('Plone Gazette resources',
content_types=contentClasses,
permission=permissions.AddPortalContent,
extra_constructors=contentConstructors,
fti=factoryTypes).initialize(context)
registerIcon(NewsletterTheme.NewsletterTheme,
'skins/PloneGazette/NewsletterTheme.gif', globals())
registerIcon(Newsletter.Newsletter, 'skins/PloneGazette/Newsletter.gif',
globals())
registerIcon(Subscriber.Subscriber, 'skins/PloneGazette/Subscriber.gif',
globals())
registerIcon(Section.Section, 'skins/PloneGazette/Section.gif', globals())
registerIcon(NewsletterTopic.NewsletterTopic,
'skins/PloneGazette/NewsletterTopic.gif', globals())
# Archetypes init
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),
PROJECTNAME)
ContentInit(
PROJECTNAME + ' Content',
content_types=content_types,
permission=permissions.AddPortalContent,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
return
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):
##Import Types here to register them
import types.FeatureArticle
import types.UserFeedback
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),
PROJECTNAME)
utils.ContentInit(
PROJECTNAME + ' Content',
content_types=content_types,
permission=ADD_CONTENT_PERMISSION,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
