def initialize(context): # Import the type, which results in registerType() being called from content import PressRoom, PressRelease, PressClip, PressContact # initialize the content, including types and add permissions content_types, constructors, ftis = process_types( listTypes(PROJECTNAME), PROJECTNAME) for content_type, constructor, fti in zip(content_types, constructors, ftis): utils.ContentInit( PROJECTNAME + ' Content', content_types = (content_type,), permission = PERMISSIONS[content_type.portal_type], extra_constructors = (constructor,), fti = (fti,), ).initialize(context) # Register the extension profile profile_registry.registerProfile('default', 'PressRoom', 'pressroom', 'profiles/default', 'PressRoom', EXTENSION, IPloneSiteRoot)
def initialize(context): ##code-section custom-init-top #fill in your manual code here ##/code-section custom-init-top # imports packages and types for registration import LookAndFeel # Initialize portal content content_types, constructors, ftis = process_types( listTypes(PROJECTNAME), PROJECTNAME) cmfutils.ContentInit( PROJECTNAME + ' Content', content_types = content_types, permission = DEFAULT_ADD_CONTENT_PERMISSION, extra_constructors = constructors, fti = ftis, ).initialize(context) # Apply customization-policy, if theres any if CustomizationPolicy and hasattr(CustomizationPolicy, 'register'): CustomizationPolicy.register(context) print 'Customization policy for BungeniSkinPanafrica installed'
def initialize(context): """Initializer called when used as a Zope 2 product.""" import TT_NewsletterFolder, TT_Subscriber content_types, constructors, ftis = process_types( listTypes(config.PROJECTNAME), config.PROJECTNAME ) permissions = p.initialize() 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 = constructors, fti = ftis, ).initialize(context) # utils.ContentInit( # config.PROJECTNAME + ' Content', # content_types = content_types, # permission = p.ADD_CONTENT_PERMISSION, # extra_constructors = constructors, # fti = ftis, # ).initialize(context) print '>>> initialize TT_NewsletterFolder success.'
def initialize(context): """ Zope 2 """ # 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 klassname not in ADD_CONTENT_PERMISSIONS: continue context.registerClass(meta_type=all_ftis[i]['meta_type'], constructors=(all_constructors[i], ), permission=ADD_CONTENT_PERMISSIONS[klassname]) setupSchemas()
def initialize(context): ##code-section custom-init-top #fill in your manual code here ##/code-section custom-init-top # imports packages and types for registration import content content # pyflakes import WindowZTool # Initialize portal tools ToolInit(PROJECTNAME +' Tools', tools = (WindowZTool.WindowZTool,), icon='tool.gif' ).initialize(context) # 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 = ADD_CONTENT_PERMISSION, extra_constructors = all_constructors, fti = all_ftis, ).initialize(context)
def initialize(context): enable_log() if os.environ.get('ZOPETESTCASE') is None: pwManager = getUtility(IPasswordManager, 'pg') dbHostname = os.environ.get('PG_HOSTNAME', 'localhost') connString = 'postgres://%s@%s/gites_wallons' % \ (pwManager.getLoginPassWithSeparator(':'), dbHostname) createSAWrapper(connString, forZope=True, echo=False, session_options={'query_cls': query_callable(regions)}, engine_options={'convert_unicode': True, 'encoding': 'utf-8'}, encoding='utf-8', name='gites_wallons', model='GitesMappings') content_types, constructors, ftis = process_types( listTypes(PROJECTNAME), PROJECTNAME) cmfutils.ContentInit( PROJECTNAME + ' Content', content_types=content_types, permission=DEFAULT_ADD_CONTENT_PERMISSION, extra_constructors=constructors, fti=ftis).initialize(context)
def initialize(context): """initialize product (called by zope)""" # imports packages and types for registration from . import content content # pyflakes # 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])
def initialize(context): # imports packages and types for registration from . import content from . import interfaces # Initialize portal content all_content_types, all_constructors, all_ftis = process_types( listTypes('eXtremeManagement'), 'eXtremeManagement') cmfutils.ContentInit( 'eXtremeManagement 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(context): """initialize product (called by zope)""" import 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) 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])
def initialize(context): # imports packages and types for registration import interfaces import psc import content interfaces, psc, content # pyflakes # 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])
def initialize(context): """initialize product (called by zope)""" ##code-section custom-init-top #fill in your manual code here ##/code-section custom-init-top # imports packages and types for registration import csvreplicataTool # Initialize portal tools tools = [csvreplicataTool.csvreplicataTool] ToolInit(PROJECTNAME + ' Tools', tools=tools, icon='tool.gif').initialize(context) # Initialize portal content content_types, constructors, ftis = process_types(listTypes(PROJECTNAME), PROJECTNAME) cmfutils.ContentInit( PROJECTNAME + ' Content', content_types=content_types, permission=DEFAULT_ADD_CONTENT_PERMISSION, extra_constructors=constructors, fti=ftis, ).initialize(context)
def initialize(context): ##code-section custom-init-top #fill in your manual code here ##/code-section custom-init-top # imports packages and types for registration import content # Initialize portal content content_types, constructors, ftis = process_types( listTypes(PROJECTNAME), PROJECTNAME) cmfutils.ContentInit( PROJECTNAME + ' Content', content_types = content_types, permission = DEFAULT_ADD_CONTENT_PERMISSION, extra_constructors = constructors, fti = ftis, ).initialize(context) profile_registry.registerProfile( name='default', title=PROJECTNAME, description='Profile for flickrgallery', path='profiles/default', product='flickrgallery', profile_type=EXTENSION, for_=Products.CMFPlone.interfaces.IPloneSiteRoot)
def initialize(context): ##code-section custom-init-top #fill in your manual code here ##/code-section custom-init-top # imports packages and types for registration from . import CalendarXFolder # Initialize portal content content_types, constructors, ftis = process_types(listTypes(PROJECTNAME), PROJECTNAME) cmfutils.ContentInit( PROJECTNAME + ' Content', content_types=content_types, permission=DEFAULT_ADD_CONTENT_PERMISSION, extra_constructors=constructors, fti=ftis, ).initialize(context) profile_registry.registerProfile( name='default', title=PROJECTNAME, description='Profile for CalendarX', path='profiles/default', product='CalendarX', profile_type=EXTENSION, for_=Products.CMFPlone.interfaces.IPloneSiteRoot) ##code-section custom-init-bottom #fill in your manual code here ##/code-section custom-init-bottom return
def afterSetUp(self): PloneTestCase.PloneTestCase.afterSetUp(self) registerType(Dummy, 'AttachmentFieldTest') content_types, constructors, ftis = process_types(listTypes(), PKG_NAME) gen_dummy() self.makeDummy() self.fakeUpload()
def initialize(context): ##code-section custom-init-top #fill in your manual code here ##/code-section custom-init-top # imports packages and types for registration import content import interfaces # Initialize portal content content_types, constructors, ftis = process_types(listTypes(PROJECTNAME), PROJECTNAME) cmfutils.ContentInit( PROJECTNAME + ' Content', content_types=content_types, permission=DEFAULT_ADD_CONTENT_PERMISSION, extra_constructors=constructors, fti=ftis, ).initialize(context) profile_registry.registerProfile('bungenihelpcenter', 'BungeniHelpCenter', 'BungeniHelpCenter', 'profiles/default', 'BungeniHelpCenter', EXTENSION, for_=IPloneSiteRoot)
def initialize(context): """ Zope 2 """ # 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 klassname not in ADD_CONTENT_PERMISSIONS: continue context.registerClass(meta_type=all_ftis[i]['meta_type'], constructors=(all_constructors[i],), permission=ADD_CONTENT_PERMISSIONS[klassname]) setupSchemas()
def initialize(context): # imports packages and types for registration from Products.validation import validation validation.register(validators.ReferenceValidator('ReferenceValidator')) validation.register(validators.isValidYearValidator('isValidYearValidator')) validation.register(validators.isDifficultToWalkValidator('isDifficultToWalkValidator')) validation.register(validators.orientationSession2hoursValidator('orientationSession2hoursValidator')) validation.register(validators.orientationSession2DateValidator('orientationSession2DateValidator')) validation.register(validators.orientationConflictDateValidator('orientationConflictDateValidator')) validation.register(validators.financialAidValidator('financialAidValidator')) import content # initialize portal content 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) # apply customization-policy, if theres any if CustomizationPolicy and hasattr(CustomizationPolicy, 'register'): CustomizationPolicy.register(context) print 'Customization policy for UWOshOIE installed'
def initialize(context): ##code-section custom-init-top #fill in your manual code here ##/code-section custom-init-top # imports packages and types for registration import LookAndFeel # Initialize portal content content_types, constructors, ftis = process_types( listTypes(PROJECTNAME), PROJECTNAME) cmfutils.ContentInit( PROJECTNAME + ' Content', content_types = content_types, permission = DEFAULT_ADD_CONTENT_PERMISSION, extra_constructors = constructors, fti = ftis, ).initialize(context) # Apply customization-policy, if theres any if CustomizationPolicy and hasattr(CustomizationPolicy, 'register'): CustomizationPolicy.register(context) print 'Customization policy for BungeniSkin installed'
def initialize(context): """initialize product (called by zope)""" ##code-section custom-init-top #fill in your manual code here ##/code-section custom-init-top # imports packages and types for registration import SubSkinsTool # Initialize portal tools tools = [SubSkinsTool.SubSkinsTool] ToolInit( PROJECTNAME +' Tools', tools = tools, icon='tool.gif' ).initialize( context ) # Initialize portal content content_types, constructors, ftis = process_types( listTypes(PROJECTNAME), PROJECTNAME) cmfutils.ContentInit( PROJECTNAME + ' Content', content_types = content_types, permission = DEFAULT_ADD_CONTENT_PERMISSION, extra_constructors = constructors, fti = ftis, ).initialize(context)
def initialize(context): ##code-section custom-init-top #fill in your manual code here ##/code-section custom-init-top # imports packages and types for registration import tools # Initialize portal tools tools = [tools.password_tool.password_tool] ToolInit( PROJECTNAME +' Tools', tools = tools, icon='tool.gif' ).initialize( context ) # Initialize portal content content_types, constructors, ftis = process_types( listTypes(PROJECTNAME), PROJECTNAME) cmfutils.ContentInit( PROJECTNAME + ' Content', content_types = content_types, permission = DEFAULT_ADD_CONTENT_PERMISSION, extra_constructors = constructors, fti = ftis, ).initialize(context) # Apply customization-policy, if theres any if CustomizationPolicy and hasattr(CustomizationPolicy, 'register'): CustomizationPolicy.register(context) print 'Customization policy for SERPROSenha installed'
def initialize(context): """initialize product (called by zope)""" # imports packages and types for registration import content # Initialize portal content all_content_types, all_constructors, all_ftis = process_types( listTypes('upfront.versioning'), 'upfront.versioning') cmfutils.ContentInit( 'upfront.versioning' + ' 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])
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(context): """Initializer called when used as a Zope 2 product. """ import easymall.mall.content import easymall.catalog.content import easymall.shop.content # 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])
def initialize(context): """initialize product (called by zope)""" ##code-section custom-init-top #fill in your manual code here ##/code-section custom-init-top import content # 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])
def initialize(context): """Initializer called when used as a Zope 2 product. """ import easymall.mall.content import easymall.catalog.content import easymall.shop.content # 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])
def initialize(context): ##code-section custom-init-top #fill in your manual code here ##/code-section custom-init-top # imports packages and types for registration import Custodian import Harvester import Log import Metadata import MetadataManager import Standard import Logs # import MetadataCollection import LogContainer import Archive # Initialize portal content content_types, constructors, ftis = process_types( listTypes(PROJECTNAME), PROJECTNAME) cmfutils.ContentInit( PROJECTNAME + ' Content', content_types = content_types, permission = DEFAULT_ADD_CONTENT_PERMISSION, extra_constructors = constructors, fti = ftis, ).initialize(context) # Apply customization-policy, if theres any if CustomizationPolicy and hasattr(CustomizationPolicy, 'register'): CustomizationPolicy.register(context) print 'Customization policy for ZMetadata installed'
def initialize(context): """Initializer called when used as a Zope 2 product.""" ##code-section custom-init-top #fill in your manual code here ##/code-section custom-init-top # imports packages and types for registration import content import admin content_types, constructors, ftis = process_types( listTypes(PROJECTNAME), PROJECTNAME) cmfutils.ContentInit( PROJECTNAME + ' Content', content_types = content_types, permission = DEFAULT_ADD_CONTENT_PERMISSION, extra_constructors = constructors, fti = ftis, ).initialize(context) tools = [admin.AdsAdmin.AdsAdmin] ToolInit("%s Tool" % PROJECTNAME, tools=tools, icon="browser/images/adminicon.gif", ).initialize(context) # Apply customization-policy, if theres any if CustomizationPolicy and hasattr(CustomizationPolicy, 'register'): CustomizationPolicy.register(context) print 'Customization policy for Ads installed'
def initialize(context): """Initializer called when used as a Zope 2 product. """ import easyshop.nochex.content # 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) # register profile profile_registry.registerProfile( name = 'default', title = 'easyshop.nochex', description = 'Nochex payment processing for EasyShop', path = 'profiles/default', product = 'easyshop.nochex', profile_type = EXTENSION, for_ = IPloneSiteRoot)
def initialize(context): # Import the type, which results in registerType() being called from content import signupsheet, registrant # initialize the content, including types and add permissions 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) # Give it some extra permissions to control them on a per class limit for i in range(0,len(content_types)): klassname=content_types[i].__name__ if not klassname in ADD_CONTENT_PERMISSIONS: continue context.registerClass(meta_type = ftis[i]['meta_type'], constructors= (constructors[i],), permission = ADD_CONTENT_PERMISSIONS[klassname])
def initialize(context): ##code-section custom-init-top #fill in your manual code here ##/code-section custom-init-top # imports packages and types for registration import content import tools import interfaces # Initialize portal tools tools = [tools.Annotations.Annotations] ToolInit( PROJECTNAME +' Tools', tools = tools, icon='tool.gif' ).initialize( context ) # Initialize portal content content_types, constructors, ftis = process_types( listTypes(PROJECTNAME), PROJECTNAME) cmfutils.ContentInit( PROJECTNAME + ' Content', content_types = content_types, permission = DEFAULT_ADD_CONTENT_PERMISSION, extra_constructors = constructors, fti = ftis, ).initialize(context)
def initialize(context): """initialize product (called by zope)""" ##code-section custom-init-top #fill in your manual code here ##/code-section custom-init-top # imports packages and types for registration import content # 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])
def initialize(context): # imports packages and types for registration import content import interfaces import utilities import contenthandler # Make pyflakes happy content interfaces utilities contenthandler # Initialize portal content content_types, constructors, ftis = process_types( listTypes(PROJECTNAME), PROJECTNAME) cmfutils.ContentInit( PROJECTNAME + ' Content', content_types = content_types, permission = DEFAULT_ADD_CONTENT_PERMISSION, extra_constructors = constructors, fti = ftis, ).initialize(context)
def initialize(context): ##code-section custom-init-top #fill in your manual code here ##/code-section custom-init-top # imports packages and types for registration import content import interfaces # Initialize portal content content_types, constructors, ftis = process_types( listTypes(PROJECTNAME), PROJECTNAME) cmfutils.ContentInit( PROJECTNAME + ' Content', content_types = content_types, permission = DEFAULT_ADD_CONTENT_PERMISSION, extra_constructors = constructors, fti = ftis, ).initialize(context) profile_registry.registerProfile('bungenihelpcenter', 'BungeniHelpCenter', 'BungeniHelpCenter', 'profiles/default', 'BungeniHelpCenter', EXTENSION, for_=IPloneSiteRoot)
def initialize(context): """Initializer called when used as a Zope 2 product.""" # imports packages and types for registration import content content # pyflakes permissions = dict( Project='minaraad.projects: Add Project', Meeting='minaraad.projects: Add Meeting', DigiBib='minaraad.projects: Add DigiBib', AgendaItemProject='minaraad.projects: Add AgendaItemProject', Organisation='minaraad.projects: Add Organisation', ProjectContainer='minaraad.projects: Add ProjectContainer', MeetingContainer='minaraad.projects: Add MeetingContainer', OrganisationContainer='minaraad.projects: Add OrganisationContainer', ) # Initialize portal content content_types, constructors, ftis = atapi.process_types( listTypes(config.PROJECTNAME), config.PROJECTNAME) allTypes = zip(content_types, constructors) for atype, constructor in allTypes: kind = "%s: %s" % (config.PROJECTNAME, atype.archetype_name) cmfutils.ContentInit( kind, content_types=(atype, ), permission=permissions[atype.portal_type], extra_constructors=(constructor, ), ).initialize(context)
def getRegisteredArchePortalTypes(self): meta_portal = self.getMapMetatypesPortalTypes() arche_data = listTypes() result = [] for arche_type in arche_data: result.extend(meta_portal.get(arche_type['meta_type'], [])) return result
def getRegisteredArchePortalTypes(self): meta_portal = self.getMapMetatypesPortalTypes() arche_data = listTypes() result = [] for arche_type in arche_data: result.extend(meta_portal.get(arche_type["meta_type"], [])) return result
def initialize(context): """ Initialize product (standard Zope hook) """ ##code-section custom-init-top #fill in your manual code here registerPermissions([(ADD_DESIGN_PERMISSION, []), (ADD_CONTENT_PERMISSION, []), (READ_PERMISSION, []), (EDIT_PERMISSION, []), (CREATE_PERMISSION, []), (REMOVE_PERMISSION, []), (DESIGN_PERMISSION, []), (ACL_PERMISSION, [])]) ##/code-section custom-init-top # imports packages and types for registration import PlominoDatabase import PlominoAction import PlominoForm import PlominoField import PlominoView import PlominoColumn import PlominoDocument import PlominoHidewhen import PlominoAgent import PlominoCache from PlominoDocument import addPlominoDocument # Initialize portal content all_content_types, all_constructors, all_ftis = process_types( listTypes(PROJECTNAME), PROJECTNAME) all_content_types += (PlominoDocument.PlominoDocument, ) all_constructors += (addPlominoDocument, ) all_ftis += ({ 'meta_type': 'PlominoDocument', 'allowed_content_types': [], 'allow_discussion': 0, 'immediate_view': 'checkBeforeOpenDocument', 'global_allow': 0, 'filter_content_types': 1, }, ) #EXAMPLE: {'factory': 'addPlominoAction', 'product': 'CMFPlomino', 'immediate_view': 'base_edit', 'content_icon': 'document_icon.gif', 'global_allow': True, 'filter_content_types': False, 'actions': ({'action': <Products.CMFCore.Expression.Expression object at 0x6bee8c0>, 'title': 'View', 'id': 'view', 'permissions': ('View',)}, {'action': <Products.CMFCore.Expression.Expression object at 0x6bee758>, 'title': 'Edit', 'id': 'edit', 'condition': <Products.CMFCore.Expression.Expression object at 0x6e247d0>, 'permissions': ('Modify portal content',)}, {'action': <Products.CMFCore.Expression.Expression object at 0x6d9dd70>, 'title': 'Properties', 'id': 'metadata', 'permissions': ('Modify portal content',)}), 'fti_meta_type': 'Factory-based Type Information with dynamic views', 'default_view': 'base_view', 'meta_type': 'PlominoAction', 'allow_discussion': False, 'view_methods': ('base_view',), 'aliases': {'sharing': 'folder_localrole_form', 'gethtml': '', '(Default)': '(dynamic view)', 'edit': 'base_edit', 'mkdir': '', 'properties': 'base_metadata', 'view': '(selected layout)'}, 'id': 'PlominoAction', 'description': '\n '} 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])
def uninstall(self): out = StringIO() classes = listTypes(PROJECTNAME) #unregister folderish classes in use_folder_contents props = getToolByName(self, 'portal_properties').site_properties use_folder_tabs = list(props.use_folder_tabs) print >> out, 'removing classes from use_folder_tabs:' for cl in classes: print >> out, 'type:', cl['klass'].portal_type if cl['klass'].isPrincipiaFolderish and not cl[ 'klass'].portal_type in []: if cl['klass'].portal_type in use_folder_tabs: use_folder_tabs.remove(cl['klass'].portal_type) props.use_folder_tabs = tuple(use_folder_tabs) #autouninstall tools for t in []: # undo: tools are not content. dont list it in navtree try: self.portal_properties.navtree_properties.metaTypesNotToList = list( self.portal_properties.navtree_properties.metaTypesNotToList) self.portal_properties.navtree_properties.metaTypesNotToList.remove( t) except ValueError: pass except: raise # unregister tool in control panel try: portal_control_panel = getToolByName(self, 'portal_control_panel_actions') except AttributeError: #portal_control_panel has been renamed in RC1 (grumpf) portal_control_panel = getToolByName(self, 'portal_controlpanel', None) #auto build #try to call a custom uninstall method #in 'AppInstall.py' method 'uninstall' try: uninstall = ExternalMethod('temp', 'temp', PROJECTNAME + '.AppInstall', 'uninstall') except: uninstall = None if uninstall: print >> out, 'Custom Uninstall:' res = uninstall(self) if res: print >> out, res else: print >> out, 'no output' else: print >> out, 'no custom uninstall' return out.getvalue()
def getRegisteredCompositePortalTypes(self): meta_portal = self.getMapMetatypesPortalTypes() arche_data = listTypes() result = [] for arche_type in arche_data: if hasattr(arche_type["klass"], "cp_view"): result.extend(meta_portal.get(arche_type["meta_type"], [])) return result
def getRegisteredCompositePortalTypes(self): meta_portal = self.getMapMetatypesPortalTypes() arche_data = listTypes() result = [] for arche_type in arche_data: if hasattr(arche_type['klass'], 'cp_view'): result.extend(meta_portal.get(arche_type['meta_type'], [])) return result
def install(self): out = StringIO() classes = listTypes(PROJECTNAME) installTypes(self, out, classes, PROJECTNAME) install_subskin(self, out, GLOBALS) print >> out, 'Successfully installed %s' % PROJECTNAME return out.getvalue()
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 uninstall(self): out = StringIO() classes=listTypes(PROJECTNAME) #unregister folderish classes in use_folder_contents props=getToolByName(self,'portal_properties').site_properties use_folder_tabs=list(props.use_folder_tabs) print >> out, 'removing classes from use_folder_tabs:' for cl in classes: print >> out, 'type:', cl['klass'].portal_type if cl['klass'].isPrincipiaFolderish and not cl['klass'].portal_type in []: if cl['klass'].portal_type in use_folder_tabs: use_folder_tabs.remove(cl['klass'].portal_type) props.use_folder_tabs=tuple(use_folder_tabs) #autouninstall tools for t in []: # undo: tools are not content. dont list it in navtree try: self.portal_properties.navtree_properties.metaTypesNotToList=list(self.portal_properties.navtree_properties.metaTypesNotToList) self.portal_properties.navtree_properties.metaTypesNotToList.remove(t) except ValueError: pass except: raise # unregister tool in control panel try: portal_control_panel=getToolByName(self,'portal_control_panel_actions') except AttributeError: #portal_control_panel has been renamed in RC1 (grumpf) portal_control_panel=getToolByName(self, 'portal_controlpanel', None) #auto build #try to call a custom uninstall method #in 'AppInstall.py' method 'uninstall' try: uninstall = ExternalMethod('temp','temp',PROJECTNAME+'.AppInstall', 'uninstall') except: uninstall=None if uninstall: print >>out,'Custom Uninstall:' res=uninstall(self) if res: print >>out,res else: print >>out,'no output' else: print >>out,'no custom uninstall' return out.getvalue()
def initialize(context): ##code-section custom-init-top #fill in your manual code here ##/code-section custom-init-top # imports packages and types for registration import membership import interfaces import content import events import bills import debaterecord import groups import votes import geoinfo import workspaces # Initialize portal tools tools = [membership.BungeniMembershipTool.BungeniMembershipTool, debaterecord.RotaTool.RotaTool] ToolInit( PROJECTNAME +' Tools', tools = tools, icon='tool.gif' ).initialize( context ) # 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]) profile_registry.registerProfile( name='default', title=PROJECTNAME, description='Profile for Bungeni', path='profiles/default', product='Bungeni', profile_type=EXTENSION, for_=Products.CMFPlone.interfaces.IPloneSiteRoot)
def initialize(context): ##code-section custom-init-top #fill in your manual code here ##/code-section custom-init-top # imports packages and types for registration import membership import interfaces import content import events import bills import debaterecord import groups import geoinfo import workspaces import government # Initialize portal tools tools = [membership.BungeniMembershipTool.BungeniMembershipTool, debaterecord.RotaTool.RotaTool] ToolInit( PROJECTNAME +' Tools', tools = tools, icon='tool.gif' ).initialize( context ) # 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]) profile_registry.registerProfile( name='default', title=PROJECTNAME, description='Profile for Bungeni', path='profiles/default', product='Bungeni', profile_type=EXTENSION, for_=Products.CMFPlone.interfaces.IPloneSiteRoot)
def getPortalTypes(self): # cargoed from ArchetypeTool.listPortalTypesWithInterfaces because # portal_factory is given a FauxArchetypeTool without this method pt = getToolByName(self, 'portal_types') value = [] for data in listTypes(): klass = data['klass'] for iface in [IHaveIdentifiers]: if iface.implementedBy(klass): ti = pt.getTypeInfo(data['portal_type']) if ti is not None: value.append(ti) return [v.Title() for v in value]
def install(self): portal=getToolByName(self,'portal_url').getPortalObject() out = StringIO() classes=listTypes(PROJECTNAME) installTypes(self, out, classes, PROJECTNAME) print >> out, "Successfully installed %s." % PROJECTNAME sr = PloneSkinRegistrar('skins', product_globals) print >> out,sr.install(self) print >> out,sr.install(self,position='custom',mode='after',layerName=PROJECTNAME+'_public') return out.getvalue()
def initialize(context): """initialize product (called by zope)""" # Initialize portal content content_types, constructors, ftis = process_types(listTypes(PROJECTNAME), PROJECTNAME) cmfutils.ContentInit( PROJECTNAME + ' Content', content_types=content_types, permission=DEFAULT_ADD_CONTENT_PERMISSION, extra_constructors=constructors, fti=ftis, ).initialize(context)
def install(self): portal = getToolByName(self, 'portal_url').getPortalObject() out = StringIO() classes = listTypes(PROJECTNAME) installTypes(self, out, classes, PROJECTNAME) print >> out, "Successfully installed %s." % PROJECTNAME sr = PloneSkinRegistrar('skins', product_globals) print >> out, sr.install(self) #sr = PloneSkinRegistrar('skins', product_globals) print >> out, sr.install(self, position='custom', mode='after', layerName=PROJECTNAME + '_public') #register folderish classes in use_folder_contents props = getToolByName(self, 'portal_properties').site_properties use_folder_tabs = list(props.use_folder_tabs) print >> out, 'adding classes to use_folder_tabs:' for cl in classes: print >> out, 'type:', cl['klass'].portal_type if cl['klass'].isPrincipiaFolderish and not cl[ 'klass'].portal_type in []: use_folder_tabs.append(cl['klass'].portal_type) props.use_folder_tabs = tuple(use_folder_tabs) #autoinstall tools for t in []: try: portal.manage_addProduct[PROJECTNAME].manage_addTool(t) # tools are not content. dont list it in navtree except: #heuristics for testing if an instance with the same name already exists #only this error will be swallowed. #Zope raises in an unelegant manner a 'Bad Request' error e = sys.exc_info() if e[0] != 'Bad Request': raise #hide tools in the navigation for t in []: try: if t not in self.portal_properties.navtree_properties.metaTypesNotToList: self.portal_properties.navtree_properties.metaTypesNotToList= \ list(self.portal_properties.navtree_properties.metaTypesNotToList) + \ [t] except TypeError, e: print 'Attention: could not set the navtree properties:', e
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): 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): """Initializer called when used as a Zope 2 product.""" import Products.OrderableReferenceField.examples content_types, constructors, ftis = process_types(listTypes(PROJECTNAME), PROJECTNAME) cmfutils.ContentInit( PROJECTNAME + ' Content', content_types=content_types, permission=permissions.AddPortalContent, extra_constructors=constructors, fti=ftis, ).initialize(context)
def initialize(context): ##Import Types here to register them (were removed by pyflake check!) import FAQ import FAQQuestion 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): """initialize product (called by zope)""" import archetype # Initialize portal content content_types, constructors, ftis = process_types( listTypes('collective.dynatree.example'), 'collective.dynatree.example') ci = ContentInit( 'collective.dynatree.example content', content_types=content_types, permission="Add portal content", extra_constructors=constructors, fti=ftis, ) ci.initialize(context)
def initialize(context): # Initialize portal content content_types, constructors, ftis = process_types(listTypes(PROJECTNAME), PROJECTNAME) cmfutils.ContentInit( PROJECTNAME + ' Content', content_types=content_types, permission=DEFAULT_ADD_CONTENT_PERMISSION, extra_constructors=constructors, fti=ftis, ).initialize(context) # Apply customization-policy, if theres any if CustomizationPolicy and hasattr(CustomizationPolicy, 'register'): CustomizationPolicy.register(context) print 'Customization policy for ZipFileTransport installed'
def uninstall(self): out = StringIO() classes=listTypes(PROJECTNAME) #unregister folderish classes in use_folder_contents props=getToolByName(self,'portal_properties').site_properties use_folder_tabs=list(props.use_folder_tabs) print >> out, 'removing classes from use_folder_tabs:' for cl in classes: print >> out, 'type:', cl['klass'].portal_type if cl['klass'].isPrincipiaFolderish and not cl['klass'].portal_type in []: if cl['klass'].portal_type in use_folder_tabs: use_folder_tabs.remove(cl['klass'].portal_type) props.use_folder_tabs=tuple(use_folder_tabs) return out.getvalue()