pyams/pyams_content: comparison src/pyams_content/generations/__init_

equal deleted inserted replaced

-:dcdb0ce828f8
+:30fcd0659601
 # import interfaces
 from pyams_catalog.interfaces import MINUTE_RESOLUTION, DATE_RESOLUTION
 from pyams_content.interfaces import IBaseContent
 from pyams_content.root.interfaces import ISiteRootToolsConfiguration
 from pyams_content.shared.common.interfaces import IWfSharedContent
+from pyams_content.shared.form.interfaces import IFormsManagerFactory
+from pyams_content.shared.imagemap.interfaces import IImageMapManagerFactory
+from pyams_content.shared.logo.interfaces import ILogosManagerFactory
+from pyams_content.shared.news.interfaces import INewsManagerFactory
+from pyams_content.shared.view.interfaces import IViewsManagerFactory
 from pyams_utils.interfaces.site import ISiteGenerations
 from pyams_utils.interfaces.traversing import IPathElements
 from pyams_workflow.interfaces import IWorkflowState, IWorkflowPublicationInfo
 from zope.dublincore.interfaces import IZopeDublinCore
 from pyams_catalog.nltk import NltkFullTextProcessor
 from pyams_catalog.site import check_required_indexes
 from pyams_content.reference import ReferencesManager
 from pyams_content.reference.pictograms import PictogramTable
 from pyams_content.shared.common.manager import SharedToolContainer
-from pyams_content.shared.form.manager import FormsManager
-from pyams_content.shared.imagemap.manager import ImageMapsManager
-from pyams_content.shared.logo.manager import LogosManager
-from pyams_content.shared.news.manager import NewsManager
-from pyams_content.shared.view.manager import ViewsManager
 from pyams_i18n.index import I18nTextIndexWithInterface
 from pyams_security.index import PrincipalsRoleIndex
 from pyams_utils.registry import utility_config, get_global_registry
 from pyams_utils.site import check_required_utilities
 from pyramid.path import DottedNameResolver
 def get_fulltext_lexicon(language):
 return Lexicon(NltkFullTextProcessor(language=language))
+RENAMED_CLASSES = {
+'pyams_content.shared.common.review ReviewComment': 'pyams_content.features.review ReviewComment',
+'pyams_content.shared.common.review ReviewCommentsContainer':
+'pyams_content.features.review ReviewCommentsContainer'
+}
 REQUIRED_UTILITIES = ()
 REQUIRED_TABLES = (
 ('pictograms_table_name', 'pictograms', PictogramTable),
 )
 REQUIRED_TOOLS = [
-('views', ViewsManager),
+('views', IViewsManagerFactory),
-('logos', LogosManager),
+('logos', ILogosManagerFactory),
-('imagemaps', ImageMapsManager),
+('imagemaps', IImageMapManagerFactory),
-('forms', FormsManager),
+('forms', IFormsManagerFactory),
-('news', NewsManager)
+('news', INewsManagerFactory)
 ]
 REQUIRED_INDEXES = [
 ('content_type', FieldIndexWithInterface, {'interface': IBaseContent,
 'discriminator': 'content_type'}),
 #
 # Checker for required shared tables
 #
 def check_required_tables(site, tables=REQUIRED_TABLES, registry=None):
-"""Check for required reference tables"""
+"""Check for required reference tables
+:param site: site root to check for tables
+:param tables: iterable of reference tables to check or create; each occurrence is a tuple of three elements
+containing configuration attribute name, default table name and table factory
+:param registry: optional registry object
+For each required table, the checking process is:
+- get table name from current site configuration, or from configuration settings using
+'pyams_content.config.{table_name}' parameter where 'table_name' is the attribute name given as first
+tuple argument
+- if table doesn't exists, create table using given factory and given table name, and store this name into
+current site configuration
+"""
 def get_tables_manager():
 # check references tables manager
 tables_name = tools_configuration.tables_name or \
 registry.settings.get('pyams_content.config.tables_name', 'references')
 if registry is None:
 registry = get_global_registry()
 tables_manager = get_tables_manager()
 for attr, name, factory in tables:
 table_name = getattr(tools_configuration, attr, None) or \
-registry.settings.get('pyams_config.config.{0}'.format(attr), name)
+registry.settings.get('pyams_content.config.{0}'.format(attr), name)
 if table_name not in tables_manager:
 table = factory()
 logger.info("Creating table {0!r}...".format(table))
 registry.notify(ObjectCreatedEvent(table))
 tables_manager[table_name] = table
 #
 # Checker for required shared tools
 #
 def check_required_tools(site, config_interface, tools):
-"""Check for required shared tools"""
+"""Check for required shared tools
+:param site: site root to check for tools
+:param config_interface: site configuration interface; configuration attributes are updated
+when tools are created
+:param tools: iterable of shared tools to check or create; each occurrence is a tuple of two elements
+containing the tool name and it's factory interface.
+For each required tool, the checking process is:
+- get factory name from settings; the settings parameter name is 'pyams_content.config.{name}_tool_factory',
+where 'name' is the first element of tool's tuple configuration
+- if factory name is set as 'None' or '--', tool checking and creation is skipped
+- otherwise, we look for requested tool
+- if there is no shared tool with given name, we look for factory: this can be given as dotted Python name in
+configuration settings, as a named adapter from site manager to given factory interface (with name set as
+requested tool name), as an anonymous adapter from site manager to given factory interface, or as a utility
+providing given factory interface
+- if factory is found, the shared tool is created and it's name is stored into current site configuration
+"""
 def get_tools_manager(site, config, registry=None):
 """Check for shared tools manager"""
 if registry is None:
 registry = get_global_registry()
 def get_required_tools(manager, config, tools=REQUIRED_TOOLS, registry=None):
 """Create required shared tools"""
 if registry is None:
 registry = get_global_registry()
-for name, default_factory in tools:
+for name, factory_interface in tools:
 factory = registry.settings.get('pyams_content.config.{name}_tool_factory'.format(name=name))
 if (factory is None) or (factory.upper() not in ('NONE', '--')):
 attr_name = '{name}_tool_name'.format(name=name)
 tool_name = getattr(config, attr_name, None) or \
 registry.settings.get('pyams_content.config.{name}'.format(name=attr_name), name)
 if tool_name not in manager:
 if factory is not None:
 factory = DottedNameResolver().resolve(factory)
-else:
+if factory is None:
-factory = default_factory
+factory = registry.queryAdapter(manager, factory_interface, name=name)
-tool = factory()
+if factory is None:
-registry.notify(ObjectCreatedEvent(tool))
+factory = registry.queryAdapter(manager, factory_interface)
-manager[tool_name] = tool
+if factory is None:
-setattr(config, attr_name, tool_name)
+factory = registry.queryUtility(factory_interface)
+if factory is not None:
+tool = factory()
+registry.notify(ObjectCreatedEvent(tool))
+manager[tool_name] = tool
+setattr(config, attr_name, tool_name)
 configuration = config_interface(site, None)
 if configuration is not None:
 # check shared tools manager
 manager = get_tools_manager(site, configuration)

changeset 490	30fcd0659601
parent 470	2b552177c142
child 603	eadaa6149824