def getConfig(self):
"""get the config"""
registry = getUtility(IRegistry)
# First grab the base config, so we can use the operations
registryreader = IQuerystringRegistryReader(registry)
registryreader.prefix = "plone.app.querystring.operation"
op_config = registryreader.parseRegistry()
# Then combine our fields
registryreader = IQuerystringRegistryReader(registry)
registryreader.prefix = "bika.lims.analysisrequestquery"
config = registryreader.parseRegistry()
config = registryreader.getVocabularyValues(config)
config.update(op_config)
registryreader.mapOperations(config)
registryreader.mapSortableIndexes(config)
config = {
'indexes': config.get('bika.lims.analysisrequestquery.field'),
'sortable_indexes': config.get('sortable'),
}
# Group indices by "group", order alphabetically
groupedIndexes = {}
for indexName in config['indexes']:
index = config['indexes'][indexName]
if index['enabled']:
group = index['group']
if group not in groupedIndexes:
groupedIndexes[group] = []
groupedIndexes[group].append((index['title'], indexName))
# Sort each index list
[a.sort() for a in groupedIndexes.values()]
config['groupedIndexes'] = groupedIndexes
return config
def getConfig(self):
"""get the config"""
registry = getUtility(IRegistry)
# First grab the base config, so we can use the operations
registryreader = IQuerystringRegistryReader(registry)
registryreader.prefix = "plone.app.querystring.operation"
op_config = registryreader.parseRegistry()
# Then combine our fields
registryreader = IQuerystringRegistryReader(registry)
registryreader.prefix = "bika.lims.analysisrequestquery"
config = registryreader.parseRegistry()
config = registryreader.getVocabularyValues(config)
config.update(op_config)
registryreader.mapOperations(config)
registryreader.mapSortableIndexes(config)
config = {
"indexes": config.get("bika.lims.analysisrequestquery.field"),
"sortable_indexes": config.get("sortable"),
}
# Group indices by "group", order alphabetically
groupedIndexes = {}
for indexName in config["indexes"]:
index = config["indexes"][indexName]
if index["enabled"]:
group = index["group"]
if group not in groupedIndexes:
groupedIndexes[group] = []
groupedIndexes[group].append((index["title"], indexName))
# Sort each index list
[a.sort() for a in groupedIndexes.values()]
config["groupedIndexes"] = groupedIndexes
return config
def __call__(self):
"""Return the registry configuration in JSON format"""
registry = getUtility(IRegistry)
# First grab the base config, so we can use the operations
registryreader = IQuerystringRegistryReader(registry)
registryreader.prefix = "plone.app.querystring.operation"
op_config = registryreader.parseRegistry()
# Then combine our fields
registryreader = IQuerystringRegistryReader(registry)
registryreader.prefix = self.prefix
config = registryreader.parseRegistry()
config = registryreader.getVocabularyValues(config)
config.update(op_config)
registryreader.mapOperations(config)
registryreader.mapSortableIndexes(config)
config = {"indexes": config.get(self.prefix + ".field"), "sortable_indexes": config.get("sortable")}
return json.dumps(config)
def test_map_operations_missing(self):
"""tests if nonexisting referenced operations are properly skipped"""
registry = self.createRegistry(td.test_missing_operator_xml)
reader = IQuerystringRegistryReader(registry)
result = reader.parseRegistry()
result = reader.mapOperations(result)
operators = result.get("plone.app.querystring.field.created.operators").keys()
self.assertTrue("plone.app.querystring.operation.date.lessThan" in operators)
self.assertFalse("plone.app.querystring.operation.date.largerThan" in operators)
def test_map_operations_clean(self):
"""tests if mapOperations is getting all operators correctly"""
registry = self.createRegistry(td.minimal_correct_xml)
reader = IQuerystringRegistryReader(registry)
result = reader.parseRegistry()
result = reader.mapOperations(result)
operations = result.get("plone.app.querystring.field.created.operations")
operators = result.get("plone.app.querystring.field.created.operators")
for operation in operations:
self.assertTrue(operation in operators)
def __call__(self):
"""Return the registry configuration in JSON format"""
registry = getUtility(IRegistry)
# First grab the base config, so we can use the operations
registryreader = IQuerystringRegistryReader(registry)
registryreader.prefix = "plone.app.querystring.operation"
op_config = registryreader.parseRegistry()
# Then combine our fields
registryreader = IQuerystringRegistryReader(registry)
registryreader.prefix = self.prefix
config = registryreader.parseRegistry()
config = registryreader.getVocabularyValues(config)
config.update(op_config)
registryreader.mapOperations(config)
registryreader.mapSortableIndexes(config)
return {
'indexes': config.get(self.prefix + '.field'),
'sortable_indexes': config.get('sortable'),
}
def test_get_vocabularies(self):
"""tests if getVocabularyValues is returning the correct vocabulary
values in the correct format
"""
registry = self.createRegistry(td.test_vocabulary_xml)
reader = IQuerystringRegistryReader(registry)
result = reader.parseRegistry()
result = reader.getVocabularyValues(result)
vocabulary_result = result.get("plone.app.querystring.field.reviewState.values")
self.assertEqual(vocabulary_result, {"foo": {"title": u"bar"}})
def getConfig(self):
"""get the config"""
registry = getUtility(IRegistry)
prefix = self.registry_prefix
if prefix:
# First grab the base config's operations
registryreader = IQuerystringRegistryReader(registry)
registryreader.prefix = "plone.app.querystring.operation"
plone_config = registryreader.parseRegistry()
# then merge custom fields
registryreader = IQuerystringRegistryReader(registry)
registryreader.prefix = prefix
config = registryreader.parseRegistry()
config = registryreader.getVocabularyValues(config)
config.update(plone_config)
config = registryreader.mapOperations(config)
config = registryreader.mapSortableIndexes(config)
config = {
'indexes': config.get(prefix + '.field'),
'sortable_indexes': config.get('sortable'),
}
else:
# First grab the base config's operations
registryreader = IQuerystringRegistryReader(registry)
registryreader.prefix = "plone.app.querystring"
config = registryreader()
# Group indices by "group", order alphabetically
groupedIndexes = {}
for indexName in config['indexes']:
index = config['indexes'][indexName]
if index['enabled']:
group = index['group']
if group not in groupedIndexes:
groupedIndexes[group] = []
groupedIndexes[group].append((index['title'], indexName))
# Sort each index list
[a.sort() for a in groupedIndexes.values()]
config['groupedIndexes'] = groupedIndexes
return config
def getConfig(self):
"""get the config"""
registry = getUtility(IRegistry)
prefix = self.registry_prefix
if prefix is not None:
# First grab the base config's operations
registryreader = IQuerystringRegistryReader(registry)
registryreader.prefix = "plone.app.querystring.operation"
plone_config = registryreader.parseRegistry()
# then merge custom fields
registryreader = IQuerystringRegistryReader(registry)
registryreader.prefix = prefix
config = registryreader.parseRegistry()
config = registryreader.getVocabularyValues(config)
config.update(plone_config)
config = registryreader.mapOperations(config)
config = registryreader.mapSortableIndexes(config)
config = {
'indexes': config.get(prefix + '.field'),
'sortable_indexes': config.get('sortable'),
}
else:
# First grab the base config's operations
registryreader = IQuerystringRegistryReader(registry)
registryreader.prefix = "plone.app.querystring"
config = registryreader()
# Group indices by "group", order alphabetically
groupedIndexes = {}
for indexName in config['indexes']:
index = config['indexes'][indexName]
if index['enabled']:
group = index['group']
if group not in groupedIndexes:
groupedIndexes[group] = []
groupedIndexes[group].append((index['title'], indexName))
# Sort each index list
[a.sort() for a in groupedIndexes.values()]
config['groupedIndexes'] = groupedIndexes
return config
def test_map_operations_clean(self):
"""tests if mapOperations is getting all operators correctly"""
registry = self.createRegistry(td.minimal_correct_xml)
reader = IQuerystringRegistryReader(registry)
result = reader.parseRegistry()
result = reader.mapOperations(result)
operations = result.get(
'plone.app.querystring.field.created.operations')
operators = result.get('plone.app.querystring.field.created.operators')
for operation in operations:
self.assertTrue(operation in operators)
def test_get_vocabularies(self):
"""tests if getVocabularyValues is returning the correct vocabulary
values in the correct format
"""
registry = self.createRegistry(td.test_vocabulary_xml)
reader = IQuerystringRegistryReader(registry)
result = reader.parseRegistry()
result = reader.getVocabularyValues(result)
vocabulary_result = result.get(
'plone.app.querystring.field.reviewState.values')
self.assertEqual(vocabulary_result, {'foo': {'title': u'bar'}})
def listSortFields(self):
"""Return a list of available fields for sorting."""
registry = getUtility(IRegistry)
config = IQuerystringRegistryReader(registry)
indexes = config.parseRegistry()
sortable = config.mapSortableIndexes(indexes)['sortable']
for name, index in sortable.items():
title = index.get('title', name)
description = index.get('description', title)
yield (name, title, description)
def test_map_operations_missing(self):
"""tests if nonexisting referenced operations are properly skipped"""
registry = self.createRegistry(td.test_missing_operator_xml)
reader = IQuerystringRegistryReader(registry)
result = reader.parseRegistry()
result = reader.mapOperations(result)
operators = result.get(
'plone.app.querystring.field.created.operators').keys()
self.assertTrue(
'plone.app.querystring.operation.date.lessThan' in operators)
self.assertFalse(
'plone.app.querystring.operation.date.largerThan' in operators)
def test_sortable_indexes(self):
"""tests if sortable indexes from the registry will be available in
the parsed registry
"""
registry = self.createRegistry(td.minimal_correct_xml)
reader = IQuerystringRegistryReader(registry)
result = reader.parseRegistry()
result = reader.mapOperations(result)
result = reader.mapSortableIndexes(result)
sortables = result['sortable']
# there should be one sortable index
self.assertEqual(len(sortables), 1)
# confirm that every sortable really is sortable
for field in sortables.values():
self.assertEqual(field['sortable'], True)
def test_sortable_indexes(self):
"""tests if sortable indexes from the registry will be available in
the parsed registry
"""
registry = self.createRegistry(td.minimal_correct_xml)
reader = IQuerystringRegistryReader(registry)
result = reader.parseRegistry()
result = reader.mapOperations(result)
result = reader.mapSortableIndexes(result)
sortables = result['sortable']
# there should be one sortable index
self.assertEqual(len(sortables), 1)
# confirm that every sortable really is sortable
for field in sortables.values():
self.assertEqual(field['sortable'], True)
def migrate_topics(portal):
"""Migrate ATContentTypes Topics to plone.app.contenttypes Collections.
This could also be used as upgrade step.
"""
# Parse the registry to get allowed operations and pass it to the
# migrator.
reg = getUtility(IRegistry)
reader = IQuerystringRegistryReader(reg)
registry = reader.parseRegistry()
# select migrator based on the base-class of collections
fti = portal.portal_types['Collection']
if fti.content_meta_type == 'Dexterity Item':
migrator = TopicMigrator
elif fti.content_meta_type == 'Dexterity Container':
migrator = FolderishTopicMigrator
walker = CustomQueryWalker(portal, migrator)(registry=registry)
return walker
def migrate_topics(portal):
"""Migrate ATContentTypes Topics to plone.app.contenttypes Collections.
This could also be used as upgrade step.
"""
# Parse the registry to get allowed operations and pass it to the
# migrator.
reg = getUtility(IRegistry)
reader = IQuerystringRegistryReader(reg)
registry = reader.parseRegistry()
# select migrator based on the base-class of collections
fti = portal.portal_types['Collection']
if fti.content_meta_type == "Dexterity Item":
migrator = TopicMigrator
elif fti.content_meta_type == "Dexterity Container":
migrator = FolderishTopicMigrator
walker = CustomQueryWalker(portal, migrator)(registry=registry)
return walker
def __call__(self, old_topic):
"""Store the criteria of the old Topic.
Store the info on the migrator and restore the values in the
migrate_criteria method.
"""
reg = getUtility(IRegistry)
reader = IQuerystringRegistryReader(reg)
self.registry = reader.parseRegistry()
self.old = old_topic
self._collection_sort_reversed = None
self._collection_sort_on = None
self._collection_query = None
path = "/".join(self.old.getPhysicalPath())
# Get the old criteria.
# See also Products.ATContentTypes.content.topic.buildQuery
criteria = self.old.listCriteria()
logger.debug(
"Old criteria for %s: %r",
path,
[(crit, crit.getCriteriaItems()) for crit in criteria],
)
formquery = []
for criterion in criteria:
type_ = criterion.__class__.__name__
if type_ in ["ATSortCriterion", "FormSortCriterion"]:
# Sort order and direction are now stored in the Collection.
self._collection_sort_reversed = criterion.getReversed()
self._collection_sort_on = criterion.Field()
continue
converter = CONVERTERS.get(type_)
if converter is None:
msg = "[SKIPPED] - Unsupported criterion {0}".format(type_)
logger.warning(msg)
continue
converter(formquery, criterion, self.registry)
logger.debug("New query for %s: %r", path, formquery)
return formquery
def __call__(self, version=None, include_items=False):
topic_metadata = super(SerializeTopicToJson, self).__call__(version=version)
# migrate criteria
formquery = []
reg = getUtility(IRegistry)
reader = IQuerystringRegistryReader(reg)
self.registry = reader.parseRegistry()
criteria = self.context.listCriteria()
for criterion in criteria:
type_ = criterion.__class__.__name__
if type_ == "ATSortCriterion":
# Sort order and direction are now stored in the Collection.
self._collection_sort_reversed = criterion.getReversed()
self._collection_sort_on = criterion.Field()
logger.debug(
"Sort on %r, reverse: %s.",
self._collection_sort_on,
self._collection_sort_reversed,
)
continue
converter = CONVERTERS.get(type_)
if converter is None:
msg = "Unsupported criterion {0}".format(type_)
logger.error(msg)
raise ValueError(msg)
try:
converter(formquery, criterion, self.registry)
except Exception as e:
logger.info(e)
topic_metadata["query"] = json_compatible(formquery)
# migrate batch size
if self.context.itemCount:
topic_metadata["b_size"] = self.context.itemCount
return topic_metadata
def test_parse_registry(self):
"""tests if the parsed registry data is correct"""
registry = self.createRegistry(td.minimal_correct_xml)
reader = IQuerystringRegistryReader(registry)
result = reader.parseRegistry()
self.assertEqual(result, td.parsed_correct)
def test_parse_registry(self):
"""tests if the parsed registry data is correct"""
registry = self.createRegistry(td.minimal_correct_xml)
reader = IQuerystringRegistryReader(registry)
result = reader.parseRegistry()
self.assertEqual(result, td.parsed_correct)
