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):
"""Initializer called when used as a Zope 2 product."""
from content.shipment import Shipment
from content.shipments import Shipments
from content.kittemplate import KitTemplate
from content.biospectype import BiospecType
from content.biospecimen import Biospecimen
from content.multimage import Multimage
from content.storagetype import StorageType
from content.kit import Kit
from content.kits import Kits
from content.project import Project
from content.projects import Projects
from content.biospecimens import Biospecimens
from content.inventoryorder import InventoryOrder
from content.inventoryorderfolder import InventoryOrderFolder
from content.product import Product
from content.stockitem import StockItem
from content.storageunit import StorageUnit
from content.storageunits import StorageUnits
from content.managedstorage import ManagedStorage
from content.unmanagedstorage import UnmanagedStorage
from content.storageposition import StoragePosition
from content.donor import SampleDonor
from content.donors import SampleDonors
from content.disease_ontology import DiseaseOntology
from content.disease_ontologies import DiseaseOntologies
from content.sampleshipment import SampleShipment
from content.sampleshipments import SampleShipments
from content.samplebatch import SampleBatch
from content.samplebatches import SampleBatches
from controlpanel.bika_kittemplates import KitTemplates
from controlpanel.bika_biospectypes import BiospecTypes
from controlpanel.bika_storagetypes import StorageTypes
from controlpanel.bika_products import Products
from controlpanel.bika_stockitems import StockItems
content_types, constructors, ftis = process_types(
listTypes(PROJECTNAME),
PROJECTNAME)
# Register each type with it's own Add permission
# use ADD_CONTENT_PERMISSION as default
allTypes = zip(content_types, constructors)
for atype, constructor in allTypes:
kind = "%s: Add %s" % (PROJECTNAME, atype.portal_type)
perm = ADD_CONTENT_PERMISSIONS.get(atype.portal_type,
ADD_CONTENT_PERMISSION)
ContentInit(kind,
content_types = (atype,),
permission = perm,
extra_constructors = (constructor,),
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 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):
context.registerHelpTitle('CMF Topic Help')
context.registerHelp(directory='help')
# BBB: register oldstyle constructors
ContentInit('CMF Topic Content',
content_types=(),
permission=AddTopics,
extra_constructors=(Topic.addTopic, )).initialize(context)
def initialize(context):
import NewsletterReference
import NewsletterRichReference
import NewsletterBTree
ContentInit(
'Plone Gazette Newsletter Theme',
content_types=(NewsletterTheme.NewsletterTheme, ),
permission=PNLPermissions.AddNewsletterTheme,
extra_constructors=(NewsletterTheme.addNewsletterTheme, ),
fti=NewsletterTheme.NewsletterTheme.factory_type_information).initialize(context)
ContentInit(
'Plone Gazette Newsletter Section',
content_types=(Section.Section,),
permission=PNLPermissions.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)
def initialize( context ):
initializeBasesPhase2( z_bases, context )
initializeBasesPhase2( z_tool_bases, context )
ToolInit( 'CMF Default Tool'
, tools=tools
, icon='tool.gif'
).initialize( context )
ContentInit( 'CMF Default Content'
, content_types=contentClasses
, permission=AddPortalContent
, extra_constructors=contentConstructors
, fti=Portal.factory_type_information
).initialize( context )
profile_registry.registerProfile('default',
'CMFDefault Site',
'Profile for a default CMFSite.',
'profiles/default',
'CMFDefault',
BASE)
profile_registry.registerProfile('sample_content',
'Sample CMFDefault Content',
'Content for a sample CMFSite.',
'profiles/sample_content',
'CMFDefault',
EXTENSION)
context.registerClass( Portal.CMFSite
, constructors=(factory.addConfiguredSiteForm,
factory.addConfiguredSite,
Portal.manage_addCMFSite)
, icon='images/portal.gif'
)
registerIcon( DefaultWorkflow.DefaultWorkflowDefinition
, 'images/workflow.gif'
, globals()
)
# make registerHelp work with 2 directories
help = context.getProductHelp()
lastRegistered = help.lastRegistered
context.registerHelp(directory='help', clear=1)
context.registerHelp(directory='interfaces', clear=1)
if help.lastRegistered != lastRegistered:
help.lastRegistered = None
context.registerHelp(directory='help', clear=1)
help.lastRegistered = None
context.registerHelp(directory='interfaces', clear=0)
context.registerHelpTitle('CMF Default Help')
def initialize(context):
content_types, constructors, ftis = atapi.process_types(
atapi.listTypes(config.PROJECTNAME), config.PROJECTNAME)
for atype, constructor in zip(content_types, constructors):
ContentInit(
'%s: %s' % (config.PROJECTNAME, atype.portal_type),
content_types=(atype, ),
permission=config.ADD_PERMISSIONS[atype.portal_type],
extra_constructors=(constructor, ),
).initialize(context)
def initialize(context):
ToolInit('CMF Calendar Tool',
tools=(CalendarTool.CalendarTool, ),
icon='tool.gif').initialize(context)
# BBB: register oldstyle constructors
ContentInit('CMF Calendar Content',
content_types=(),
permission=AddPortalContent,
extra_constructors=(Event.addEvent, )).initialize(context)
def initialize(context):
context.registerHelpTitle('CMF Topic Help')
context.registerHelp(directory='help')
# CMF Initializers
ContentInit('CMF Topic Objects',
content_types=(Topic.Topic, ),
permission=TopicPermissions.AddTopics,
extra_constructors=(Topic.addTopic, ),
fti=Topic.factory_type_information).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):
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):
import demo
demo # pyflakes
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),
PROJECTNAME)
ContentInit(
PROJECTNAME + ' Content',
content_types=content_types,
permission=AddPortalContent,
extra_constructors=constructors,
).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):
# Example content type initialization
import Products.DataGridField.examples
content_types, constructors, ftis = process_types(
listTypes(PKG_NAME), PKG_NAME, )
ContentInit(
'%s Content' % PKG_NAME,
content_types=content_types,
permission=AddPortalContent,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
def initialize(context):
"""Inicializador chamado quando usado como um produto Zope 2."""
content_types, constructors, ftis = atapi.process_types(
atapi.listTypes(config.PROJECTNAME), config.PROJECTNAME)
for atype, constructor in zip(content_types, constructors):
ContentInit(
'%s: %s' % (config.PROJECTNAME, atype.portal_type),
content_types=(atype, ),
permission=config.ADD_PERMISSIONS[atype.portal_type],
extra_constructors=(constructor, ),
).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):
"""
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):
context.registerHelpTitle('CMF Topic Help')
context.registerHelp(directory='help')
# CMF Initializers
ContentInit('CMF Topic Objects',
content_types=(Topic.Topic, ),
permission=AddTopics,
extra_constructors=(Topic.addTopic, )).initialize(context)
profile_registry.registerProfile('default', 'CMFTopic',
'Adds topic portal type.',
'profiles/default', 'CMFTopic', EXTENSION)
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):
"""Initializer called when used as a Zope 2 product."""
##Import Types here to register them
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),
PROJECTNAME)
ContentInit(
PROJECTNAME + ' Content',
content_types=content_types,
permission=AddPortalContent,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
def initialize_archetypes_testing(context):
"""Initializer called when initializing with testing.zcml."""
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)
ContentInit(
kind,
content_types=(atype,),
permission=add_documents_images_and_files,
extra_constructors=(constructor,),
).initialize(context)
def initialize(context):
from Products.Maps import content
content # pyflakes
content_types, constructors, ftis = process_types(
listTypes(config.PROJECTNAME), config.PROJECTNAME)
ContentInit(
config.PROJECTNAME + ' Content',
content_types = content_types,
permission = 'Maps: Add GeoLocation',
extra_constructors = constructors,
fti = ftis,
).initialize(context)
def initialize(context):
import EntiCriteria
listOfTypes = listTypes(PROJECTNAME)
content_types, constructors, ftis = process_types(listOfTypes, PROJECTNAME)
from redturtle.entiterritoriali.config import default_permission
allTypes = zip(content_types, constructors)
for atype, constructor in allTypes:
kind = "%s: %s" % (PROJECTNAME, atype.archetype_name)
ContentInit(
kind,
content_types=(atype, ),
permission=default_permission,
extra_constructors=(constructor, ),
).initialize(context)
def initialize(context):
"""Initializer called when used as a Zope 2 product."""
# Example content type initialization
import collective.referencedatagridfield.examples
import collective.referencedatagridfield.columns
content_types, constructors, ftis = process_types(
listTypes(PKG_NAME),
PKG_NAME,
)
ContentInit(
'%s Content' % PKG_NAME,
content_types=content_types,
permission=AddPortalContent,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
def initialize(context):
"""Register content types through Archetypes with Zope and the CMF.
"""
from Products.CMFCore.utils import ContentInit
from Products.CMFCore.permissions import AddPortalContent
from plone.formwidget.recurrence.tests.at_example import content # noqa
content_types, constructors, ftis = atapi.process_types(
atapi.listTypes(packageName), packageName)
for atype, constructor, fti in zip(content_types, constructors, ftis):
ContentInit(
"%s: %s" % (packageName, atype.portal_type),
content_types=(atype,),
permission = AddPortalContent,
extra_constructors = (constructor,),
fti = (fti,),
).initialize(context)
def initialize(context):
"""Initializer called when used as a Zope 2 product."""
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),
PROJECTNAME)
allTypes = zip(content_types, constructors, ftis)
for atype, constructor, fti in allTypes:
kind = "%s: Add %s" % (PROJECTNAME, atype.portal_type)
perm = ADD_CONTENT_PERMISSIONS.get(atype.portal_type,
ADD_CONTENT_PERMISSION)
ContentInit(
kind,
content_types=(atype, ),
permission=perm,
extra_constructors=(constructor, ),
fti=fti,
).initialize(context)
def initialize(context):
# Setup migrations
migration.executeMigrations()
migration.registerMigrations()
# optional demo content
if config.INSTALL_EXAMPLES:
import examples
# register the fti
context.registerClass(PloneArticleFactoryTypeInformation,
permission=ManagePortal,
constructors=(manage_addPAFTIForm, ),
visibility=None)
context.registerClass(DynamicAllowedContentFTI,
permission=ManagePortal,
constructors=(manage_addDVTFTIForm, ),
visibility=None)
# initialize the content, including types and add permissions
content_types, constructors, ftis = process_types(
listTypes(config.PROJECTNAME), config.PROJECTNAME)
permissions = {
'PloneArticle': 'PloneArticle: Add PloneArticle',
'PloneArticleMultiPage': "PloneArticle: Add PloneArticleMultiPage",
}
for atype, constructor, fti in zip(content_types, constructors, ftis):
permission = permissions.get(atype.portal_type,
'PloneArticle: Add PloneArticle')
ContentInit(
config.PROJECTNAME + ' Content',
content_types=(atype, ),
permission=permission,
extra_constructors=(constructor, ),
fti=(fti, ),
).initialize(context)
# Initialize the tool
ToolInit(config.PROJECTNAME + ' Tool',
tools=(tool.PloneArticleTool, ),
icon='tool.gif').initialize(context)
def initialize(context):
from iw.fss.config import PROJECTNAME
from iw.fss.customconfig import (ZOPETESTCASE,
INSTALL_EXAMPLE_TYPES_ENVIRONMENT_VARIABLE)
if ZOPETESTCASE or os.environ.get(INSTALL_EXAMPLE_TYPES_ENVIRONMENT_VARIABLE):
# Import example types
from iw.fss import examples
dummy = examples # No pyflakes warning
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),
PROJECTNAME)
ContentInit('%s Content' % PROJECTNAME,
content_types = content_types,
permission = CCP.AddPortalContent,
extra_constructors = constructors,
fti = ftis,
).initialize(context)
# Register modifier
context.registerClass(
ConditionalTalesModifier,
MODIFIER_ID,
permission=CCP.ManagePortal,
constructors = (modifierAddForm, manage_addModifier),
icon='modifier.gif',
)
# Setup module aliases to bind all Zope2 products
import modulealiases
dummy = modulealiases # No pyflakes warning
# Provides 'plone' domain translations
if not ZOPETESTCASE:
try:
i18n_dir = os.path.join(os.path.dirname(__file__), 'i18n')
context._ProductContext__app.Control_Panel.TranslationService._load_i18n_dir(i18n_dir)
except AttributeError, e:
# No translation service obj
# FIXME: we should find an alternate solution to push 'plone' domain translations
import logging
logger = logging.getLogger(PROJECTNAME)
logger.warning("'plone' domain translations could'nt be enabled")
def initialize(context):
"""Register content types through Archetypes with Zope and the CMF.
"""
from Products.CMFCore.utils import ContentInit
from plone.app.event.at import content # nopep8
content_types, constructors, ftis = atapi.process_types(
atapi.listTypes(packageName), packageName)
assert len(content_types) == 1, 'only one new event, please!'
for atype, constructor, fti in zip(content_types, constructors, ftis):
ContentInit(
"%s: %s" % (packageName, atype.portal_type),
content_types=(atype,),
permission=ADD_PERMISSION,
extra_constructors=(constructor,),
fti=(fti,),
).initialize(context)
