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)