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()
