def get_all_filters(self, require=INewsItemFilter):
catalog = getUtility(ICatalogService)
query = {
'meta_type': {
'operator': 'or',
'query': meta_types_for_interface(require)}}
return (brain.getObject() for brain in catalog(query))
def GET(self):
self.update()
meta_types = meta_types_for_interface(IContainer)
children = []
for child in self.context.get_ordered_publishables(IContainer):
children.append(self.get_node_info(child, meta_types))
return self.json_response(children)
def get_ordered_publishables(self, interface=IPublishable):
assert interface.isOrExtends(IPublishable), "Invalid interface"
result = [
content for content in self.objectValues(
meta_types_for_interface(interface))
if not content.is_default()
]
result.sort(key=IOrderManager(self).get_position)
return result
def _get_package(self, description=None):
package_name = self.request['name']
package_version = self.request['version']
if package_name.startswith('Products.'):
package_name = package_name[9:]
# By default the release uploaded is the last version of the package
is_last_version = True
#catalog = component.getUtility(ICatalogService)
catalog = self.context.service_catalog
query = {
'meta_type': 'Silva Software Package',
'id': package_name,
'path': '/'.join(self.context.getPhysicalPath())
}
package_brains = catalog(query)
if len(package_brains) == 1:
package = package_brains[0].getObject()
# Check if it is really the last version we know of
last_packages_version = package.objectIds(
meta_types_for_interface(IFile))
if last_packages_version:
last_packages_version = map(parse_version,
last_packages_version)
last_packages_version.sort()
if parse_version(package_version) < last_packages_version[-1]:
is_last_version = False
else:
logger.debug(u'Create package %s' % package_name)
factory = self.context.manage_addProduct['SilvaSoftwarePackage']
factory.manage_addSilvaSoftwarePackage(package_name, package_name)
package = getattr(self.context, package_name)
if (description is not None and is_last_version and
not interfaces.ISilvaNoAutomaticUpdate.providedBy(package)):
description = rst_utils.get_description(description)
index = package.index
if index.get_editable() is None:
IPublicationWorkflow(index).new_version()
version = index.get_editable()
version.body.save(version, self.request, description.as_html(True))
binding = self._get_metadata(version)
binding.setValues('silva-content', {'maintitle': package_name})
notify(ObjectModifiedEvent(version))
IPublicationWorkflow(index).publish()
return (package, package_name, package_version)
def _get_package(self, description=None):
package_name = self.request['name']
package_version = self.request['version']
if package_name.startswith('Products.'):
package_name = package_name[9:]
# By default the release uploaded is the last version of the package
is_last_version = True
#catalog = component.getUtility(ICatalogService)
catalog = self.context.service_catalog
query = {'meta_type': 'Silva Software Package',
'id': package_name,
'path': '/'.join(self.context.getPhysicalPath())}
package_brains = catalog(query)
if len(package_brains) == 1:
package = package_brains[0].getObject()
# Check if it is really the last version we know of
last_packages_version = package.objectIds(meta_types_for_interface(IFile))
if last_packages_version:
last_packages_version = map(
parse_version, last_packages_version)
last_packages_version.sort()
if parse_version(package_version) < last_packages_version[-1]:
is_last_version = False
else:
logger.debug(u'Create package %s' % package_name)
factory = self.context.manage_addProduct['SilvaSoftwarePackage']
factory.manage_addSilvaSoftwarePackage(package_name, package_name)
package = getattr(self.context, package_name)
if (description is not None and is_last_version and
not interfaces.ISilvaNoAutomaticUpdate.providedBy(package)):
description = rst_utils.get_description(description)
index = package.index
if index.get_editable() is None:
IPublicationWorkflow(index).new_version()
version = index.get_editable()
version.body.save(version, self.request, description.as_html(True))
binding = self._get_metadata(version)
binding.setValues('silva-content', {'maintitle': package_name})
notify(ObjectModifiedEvent(version))
IPublicationWorkflow(index).publish()
return (package, package_name, package_version)
def sax_contents(self):
options = self.getOptions()
self.startElement('content')
if not options.only_container:
default = self.context.get_default()
if default is not None:
self.startElement('default')
self.subsax(default)
self.endElement('default')
for content in self.context.get_ordered_publishables():
if (IPublication.providedBy(content) and
not options.include_publications):
continue
self.subsax(content)
for content in self.context.get_non_publishables():
self.subsax(content)
if options.other_contents:
meta_types = meta_types_for_interface(
ISilvaXMLExportable,
excepts=[IPublishable, INonPublishable])
for content in self.context.objectValues(meta_types):
self.subsax(content)
self.endElement('content')
def list(cls, container):
return sorted(
container.objectValues(meta_types_for_interface(cls.interface)),
key=lambda content: content.getId())
def GET(self):
self.update()
interfaces = meta_types_for_interface(IContainer)
root_info = self.get_node_info(self.context, interfaces)
return self.json_response(root_info)
def get_non_publishables(self, interface=INonPublishable):
assert interface.isOrExtends(INonPublishable), "Invalid interface"
result = self.objectValues(meta_types_for_interface(interface))
result.sort(key=lambda o: o.getId())
return result
