def filter(self, components, manager=None):
""" Returns a filtered list of components
"""
order = []
# temporary provide all interfaces of the registered components
notprovided = []
for name, comp in components:
if not comp.interface.providedBy(self.context):
notprovided.append(comp.interface)
interface.alsoProvides(self.context, comp.interface)
view = component.getMultiAdapter((self.context, self.request), name=u'view')
if manager is not None:
manager = component.getMultiAdapter((self.context, self.request, view), VIEWLET_MANAGER_MAP.get(manager, object()), name=manager)
viewlets = component.getAdapters((self.context, self.request, view, manager), IViewlet)
viewlets = manager.filter(viewlets)
viewlets = manager.sort(viewlets)
for name, viewlet in viewlets:
order.append(name)
else:
for name, iface in ORDERED_VIEWLET_MANAGERS:
manager = component.getMultiAdapter((self.context, self.request, view), iface, name=name)
viewlets = component.getAdapters((self.context, self.request, view, manager), IViewlet)
viewlets = manager.filter(viewlets)
viewlets = manager.sort(viewlets)
for name, viewlet in viewlets:
order.append(name)
# no longer provide the interfaces previously set
for iface in notprovided:
interface.noLongerProvides(self.context, iface)
components = [(name, comp) for name, comp in components if comp.viewlet in order]
components.sort(lambda x, y: cmp(order.index(x[1].viewlet), order.index(y[1].viewlet)))
return components
def test_membership_adapter_registration(self):
class Source(TestAdapter):
def memberships(self, person=None):
pass
with self.custom_source(Source):
folder = self.new_temporary_folder()
adapters = [
name for name, source in
getAdapters((folder, ), IMembershipSource)
]
self.assertEqual(
adapters, ['zodb-membership-source', 'custom-source']
)
adapters = [
name for name, source in
getAdapters((folder, ), IMembershipSource)
]
self.assertEqual(adapters, ['zodb-membership-source'])
def __init__(self, context):
perms = []
# first get object permissionsmap
supp = IObjectPermissionsMaps(context, None)
if supp is not None:
perms.extend(supp.get())
for name, permissions in getAdapters((context,), IPermissionsMap):
# then get adapted permissionsmap
perms.append(permissions)
self.perms = perms
# collect parents permissionsmaps
parent_perms = []
if hasattr(context, '__parent__'):
parent_context = context.__parent__
else:
parent_context = None
while ILocation.providedBy(parent_context) and parent_context is not None:
for name, permissions in getAdapters((parent_context,), IPermissionsMap):
if permissions not in parent_perms:
parent_perms.append(permissions)
parent_context = parent_context.__parent__
self.parent_perms = parent_perms #tuple(reversed(parent_perms)) # Permissions are propagated in 'child -> parent' direction
def instanceSchemaFactory(context):
"""Default schema adapter factory.
In BaseObject, the Schema() method will do 'schema = ISchema(self)'. This
adapter factory is a replacement of the default one in
Archetypes.Schema.factory. It allows you to register named adapter
to extend the schema. The advantage is that now several packages can do
additions to the schema without conflicts.
"""
extenders = list(getAdapters((context, ), ISchemaExtender))
modifiers = list(getAdapters((context, ), ISchemaModifier))
if len(extenders) == 0 and len(modifiers) == 0:
return context.schema
# as long as the schema is only extended, we can reuse all fields
# if it's modified later, then we need a full copy, see modifiers below
# however, using the __add__ function will needlessly validate all fields
# again (in `addField`). instead we first create an empty schema of the
# same class, which is then populated using (shallow) copies of the
# internal data structures. this shouldn't be too risky considering
# that they've last changed about 6 years ago...
schema = context.schema.__class__()
schema._names = list(context.schema._names)
schema._fields = context.schema._fields.copy()
schema._props = context.schema._props.copy()
schema._layers = context.schema._layers.copy()
# loop through all schema extenders
order = None
for name, extender in extenders:
if IBrowserLayerAwareExtender.providedBy(extender) and \
(not has_plone_browserlayer or \
extender.layer not in registered_layers()):
continue
for field in extender.getFields():
schema.addField(field)
if order is not None:
if not field.schemata in order.keys():
order[field.schemata] = list()
order[field.schemata].append(field.getName())
if IOrderableSchemaExtender.providedBy(extender):
if order is None:
# we need to get the current order first
order = get_schema_order(schema)
order = extender.getOrder(order)
if DevelopmentMode:
validate_schema_order(schema, order)
if order is not None:
set_schema_order(schema, order)
if len(modifiers) > 0:
for name, modifier in modifiers:
if IBrowserLayerAwareExtender.providedBy(modifier) and \
(not has_plone_browserlayer or \
modifier.layer not in registered_layers()):
continue
modifier.fiddle(schema)
return schema
def extenders(self):
extenders = [x for x in getAdapters((self.base_context, ), ISchemaExtender)]
modifiers = [x for x in getAdapters((self.base_context, ), ISchemaModifier)]
extenders.extend(modifiers)
return extenders
def vocab(context):
request = context.REQUEST
view = getMultiAdapter((context, context.REQUEST), Interface, 'plone')
values = []
for manager_name, manager in getAdapters((context, request, view), IViewletManager):
if manager_name not in MANAGER_BLACKLIST:
for viewlet_name, viewlet in getAdapters((context, request, view, manager), IViewlet):
if viewlet_name not in VIEWLET_BLACKLIST:
values.append(' '.join((manager_name, viewlet_name)))
return SimpleVocabulary.fromValues(values)
def vocab(context):
request = context.REQUEST
view = BrowserView(context, request)
alsoProvides(view, IViewView)
values = []
for manager_name, manager in getAdapters((context, request, view), IViewletManager):
if manager_name not in MANAGER_BLACKLIST:
for viewlet_name, viewlet in getAdapters((context, request, view, manager), IViewlet):
if viewlet_name not in VIEWLET_BLACKLIST:
values.append(' '.join((manager_name, viewlet_name)))
return SimpleVocabulary.fromValues(values)
def addRefreshViewletCommands(event):
view = event.view
context = view.context
request = view.request
annotations = IAnnotations(request)
viewletByClass = annotations.get('viewletByClass', [])
if viewletByClass:
for name, manager in getAdapters(
(context, request, view, ), IViewletManager):
for name, viewlet in getAdapters(
(context, request, view, manager), IViewlet):
maybeRenderViewlet(viewlet, viewletByClass)
def SetDefaults(object, event):
""" Sets the default components defined by the registered adapters providing IDefaultComponents
"""
for name, provider in component.getAdapters((object,),
interfaces.IDefaultComponents):
for comp in provider.getComponents():
interface.alsoProvides(object, comp.interface)
for name, provider in component.getAdapters((object,),
interfaces.INamedDefaultComponent):
comp = component.queryAdapter(object,
interface=interfaces.IComponent,
name=name)
if comp is not None:
interface.alsoProvides(object, comp.interface)
object.reindexObject(idxs=['object_provides'])
def _get_sorted_post_upgrade_adapters(self):
"""Returns a list of post upgrade adapters, sorted by
profile dependencies.
Assumes that the names of the adapters are profile names
(e.g. "ftw.upgrade:default").
"""
profile_order = get_sorted_profile_ids(self.portal_setup)
portal_url = getToolByName(self.portal_setup, 'portal_url')
portal = portal_url.getPortalObject()
adapters = list(getAdapters((portal, portal.REQUEST), IPostUpgrade))
def _sorter(a, b):
name_a = a[0]
name_b = b[0]
if name_a not in profile_order and name_b not in profile_order:
return 0
elif name_a not in profile_order:
return -1
elif name_b not in profile_order:
return 1
else:
return cmp(profile_order.index(name_a),
profile_order.index(name_b))
adapters.sort(_sorter)
return [adapter for name, adapter in adapters]
def __call__(self, result=None, **kwargs):
translate = self.context.translate
path = '++resource++bika.lims.images'
alerts = {}
# We look for IResultOutOfRange adapters for this object
for name, adapter in getAdapters((self.context, ), IResultOutOfRange):
ret = adapter(result)
if not ret:
continue
spec = ret["spec_values"]
rngstr = "{0} {1}, {2} {3}".format(
t(_("min")), str(spec.get('min','')),
t(_("max")), str(spec.get('max','')))
if ret["out_of_range"]:
if ret["acceptable"]:
message = "{0} ({1})".format(
t(_('Result in shoulder range')),
rngstr
)
icon = path + '/warning.png'
else:
message = "{0} ({1})".format(
t(_('Result out of range')),
rngstr
)
icon = path + '/exclamation.png'
alerts[self.context.UID()] = [
{
'icon': icon,
'msg': message,
'field': 'Result',
},
]
break
return alerts
def additionalSchemata(self):
schema_context = self.context.aq_parent
adapters = getAdapters(
(schema_context, self.field),
IEasyFormActionsEditorExtender
)
return [v for k, v in adapters]
def update(self):
"""See zope.contentprovider.interfaces.IContentProvider"""
OTHER_MANAGER_KEYS = ["form.buttons.scale_button", "form.buttons.slots_button",
"form.buttons.lead_button","form.buttons.text_button_questions",
"form.buttons.text_button_answers","form.buttons.quiz_pages"]
for key in OTHER_MANAGER_KEYS:
no_need_update = self.request.get(key, default=False)
if no_need_update:
self.viewlets = []
return
self.__updated = True
# Find all content providers for the region
viewlets = getAdapters(
(self.context, self.request, self.__parent__, self),IViewlet)
viewlets = self.filter(viewlets)
viewlets = self.sort(viewlets)
# Just use the viewlets from now on
self.viewlets = [viewlet for name, viewlet in viewlets]
self.names = [name for name,viewlet in viewlets]
# Update all viewlets and Handle Delete action
for viewlet in self.viewlets:
viewlet.update()
if self.context.__name__ is None:
#handle case when the first lead viewlet must be updated
if IQuestionsForConstructor.providedBy(self.__parent__):
if ILeadedLayer.providedBy(self.request):
self.__parent__.question_was_removed = True
self.viewlets = []
break
def getPathsToPurge(context, request):
"""Given the current request and an object, look up paths to purge for
the object and yield them one by one. An IPurgePathRewriter adapter may
be used to rewrite the paths.
"""
rewriter = IPurgePathRewriter(request, None)
for name, pathProvider in getAdapters((context,), IPurgePaths):
# add relative paths, which are rewritten
relativePaths = pathProvider.getRelativePaths()
if relativePaths:
for relativePath in relativePaths:
if rewriter is None:
yield relativePath
else:
rewrittenPaths = rewriter(relativePath) or [] # None -> []
for rewrittenPath in rewrittenPaths:
yield rewrittenPath
# add absoute paths, which are not
absolutePaths = pathProvider.getAbsolutePaths()
if absolutePaths:
for absolutePath in absolutePaths:
yield absolutePath
def update(self):
"""Return the first component find that is valid for this context.
If none are found use a dummy ressource"""
if self.resource is None:
url = self.url
#to optimize performance those are hardcoded
if check_facebook(url):
self.resource = FacebookLink(self.context)
elif check_picasaweb(url):
self.resource = PicasawebLink(self.context)
elif check_flickr(url):
self.resource = FlickrLink(self.context)
if self.resource is None:
resources = component.getAdapters((self.context,),
interfaces.IGallery)
for name, r in resources:
#every adapters should have a validate method
if r.validate():
self.resource = r
break
if self.resource:
self.resource.width = self.width
self.resource.height = self.height
else:
msg = i18n.message_no_backend_for_link
self.addmessage(msg, type=u"error")
def syncDraft(draft, target):
"""Look up all (named) IDraftSyncer adapters from (draft, target) and
call each one in turn.
"""
for name, syncer in getAdapters((draft, target), IDraftSyncer):
syncer()
def _process_devices(self):
stats = {'Device Count': 0,
'Decommissioned Devices': 0,
'CPU Cores':0}
LINKED_DEVICES = "Linked Devices"
if LINKED_DEVICES not in stats:
stats[LINKED_DEVICES] = 0
for device in self._dmd.Devices.getSubDevicesGen_recursive():
stats['Device Count'] += 1
if device.productionState < 0:
stats["Decommissioned Devices"] += 1
cpuCount = IDeviceCpuCount(device).cpuCount()
log.debug("Devices %s has %s cpu cores", device, cpuCount)
stats['CPU Cores'] += cpuCount
for adapter in subscribers([device], IDeviceResource):
adapter.processDevice(stats)
found_linked = False
for name, adapter in getAdapters((device,), IDeviceLink):
if adapter.linkedDevice():
key = "%s - %s" % (LINKED_DEVICES, name)
if key not in stats:
stats[key] = 0
stats[key] += 1
if not found_linked:
stats[LINKED_DEVICES] += 1
found_linked = True
return stats
def __call__(self, *args, **kw):
workspaces = []
space = self.context
default = space.defaultWorkspace
factory = queryAdapter(space, IWorkspaceFactory, default)
if factory is not None:
if space.isEnabled(factory):
if IOverviewWorkspaceFactory.providedBy(factory):
return getMultiAdapter(
(space, self.request), name='overview')()
self.request.response.redirect('./%s/'%default)
return
for name, factory in getAdapters((space,), IWorkspaceFactory):
if space.isEnabled(factory) and \
checkPermission('zope.View', factory.get()):
workspaces.append((factory.weight, factory.title, name))
if workspaces:
workspaces.sort()
self.request.response.redirect('./%s/'%workspaces[0][2])
else:
self.request.response.redirect('./listing.html')
def testUpgradeTinyMCE(self):
# skip test in new Plones that don't install tinymce to begin with
if 'portal_tinymce' not in self.portal:
return
alphas.upgradeTinyMCE(self.portal.portal_setup)
jstool = getToolByName(self.portal, 'portal_javascripts')
jsresourceids = jstool.getResourceIds()
self.assertTrue('jquery.tinymce.js' in jsresourceids)
for ne in ['tiny_mce.js', 'tiny_mce_init.js']:
self.assertFalse(ne in jsresourceids)
ksstool = getToolByName(self.portal, 'portal_kss', None)
if ksstool is not None:
kssresourceids = ksstool.getResourceIds()
self.assertFalse(
'++resource++tinymce.kss/tinymce.kss' in kssresourceids)
request = self.app.REQUEST
plone_view = queryMultiAdapter((self.portal, request), name="plone")
manager = queryMultiAdapter(
(self.portal, request, plone_view), IContentProvider, 'plone.htmlhead')
viewlets = getAdapters(
(manager.context, manager.request, manager.__parent__, manager), IViewlet)
self.assertFalse(u'tinymce.configuration' in dict(viewlets))
def _subscribes():
log.msg('bit.bot.http.request: Subscribes.load._subscribes: ',
sessionid)
if len(args.strip().split(' ')) > 1:
subscribe_name = args.strip().split(' ')[1]
subscribe = queryAdapter(
self.request, ISubscribe, subscribe_name)
if subscribe:
self.request.speak("%s:" % subscribe_name)
self.request.speak(
subscribe.__doc__ or '...is currently undocumented')
else:
self.request.speak(
'unrecognized subscribe: %s' % subscribe_name)
self.request.speak(
'type ~ or ~help for a list of subscribes')
return
_subscribes = ['list of subscribes:']
subscribes = getAdapters((self.request, ), ISubscribe)
for subscribe, adapter in subscribes:
if not subscribe:
continue
_subscribes.append(subscribe)
self.request.speak('\n'.join(_subscribes))
def resources(self, request):
resources = []
for name, resource in getAdapters((request, self), IPackageResource):
resources.append((resource.order, resource))
resources.sort()
return [r for o, r in resources]
def addition_init_code(self):
code = u""
providers = component.getAdapters(self, IFacebookInitCodeProvider)
for provider in providers:
if provider.available():
code += provider.get_code()
return code
def renameAfterCreation(obj):
"""Rename the content after it was created/added
"""
# Check if the _bika_id was already set
bika_id = getattr(obj, "_bika_id", None)
if bika_id is not None:
return bika_id
# Can't rename without a subtransaction commit when using portal_factory
transaction.savepoint(optimistic=True)
# The id returned should be normalized already
new_id = None
# Checking if an adapter exists for this content type. If yes, we will
# get new_id from adapter.
for name, adapter in getAdapters((obj, ), IIdServer):
if new_id:
logger.warn(('More than one ID Generator Adapter found for'
'content type -> %s') % obj.portal_type)
new_id = adapter.generate_id(obj.portal_type)
if not new_id:
new_id = generateUniqueId(obj)
# TODO: This is a naive check just in current folder
# -> this should check globally for duplicate objects with same prefix
# N.B. a check like `search_by_prefix` each time would probably slow things
# down too much!
# -> A solution could be to store all IDs with a certain prefix in a storage
parent = api.get_parent(obj)
if new_id in parent.objectIds():
# XXX We could do the check in a `while` loop and generate a new one.
raise KeyError("The ID {} is already taken in the path {}".format(
new_id, api.get_path(parent)))
# rename the object to the new id
parent.manage_renameObject(obj.id, new_id)
return new_id
def default(self):
adapters = getAdapters((self.context,), IShipping)
for name, shipping in adapters:
if shipping.default:
return name
if adapters:
return adapters[0][0]
def test_criteria_adapter(self):
setRoles(self.portal, TEST_USER_ID, ('Manager',))
self.portal.invokeFactory('LibrarySearch', 'library', title=u"Library")
library_obj = self.portal['library']
provideAdapter(get_extra_criteria,
adapts=[IExtendedLibrarySearch],
provides=library.ISearchCriteriaProvider,
name="more-criteria")
alsoProvides(library_obj, IExtendedLibrarySearch)
adapters = getAdapters((library_obj, ),
provided=library.ISearchCriteriaProvider)
criteria = {}
for name, value in adapters:
criteria.update(value)
expected = {}
expected.update(library.get_basic_criteria(library_obj))
expected.update(get_extra_criteria(library_obj))
self.maxDiff = None
self.assertEqual(criteria, expected)
def testUpgradeTinyMCE(self):
alphas.upgradeTinyMCE(self.portal.portal_setup)
jstool = getToolByName(self.portal, 'portal_javascripts')
jsresourceids = jstool.getResourceIds()
self.assertIn('jquery.tinymce.js', jsresourceids)
for ne in ['tiny_mce.js', 'tiny_mce_init.js']:
self.assertNotIn(ne, jsresourceids, ne)
ksstool = getToolByName(self.portal, 'portal_kss', None)
if ksstool is not None:
kssresourceids = ksstool.getResourceIds()
self.assertNotIn('++resource++tinymce.kss/tinymce.kss',
kssresourceids)
request = self.app.REQUEST
plone_view = queryMultiAdapter((self.portal, request), name="plone")
manager = queryMultiAdapter(
(self.portal, request, plone_view), IContentProvider, 'plone.htmlhead')
viewlets = getAdapters(
(manager.context, manager.request, manager.__parent__, manager), IViewlet)
self.assertIn(u'tinymce.configuration', dict(viewlets))
storage = getUtility(IViewletSettingsStorage)
skinname = self.portal.getCurrentSkinName()
order_by_name = storage.getOrder('plone.htmlhead', skinname)
self.assertEqual(order_by_name[-1], u'tinymce.configuration')
def update(self):
"""See zope.contentprovider.interfaces.IContentProvider"""
self.__updated = True
# Find all content providers for the region
viewlets = component.getAdapters(
(self.context, self.request, self.__parent__, self),
IViewlet)
# update the setting viewlet first, as that determines
# which viewlets we end up filtering
viewlets = list( viewlets )
setting_viewlet = [v for n,v in viewlets if n == 'settings'][0]
setting_viewlet.update()
viewlets = self.filter(viewlets)
viewlets = self.sort(viewlets)
# Just use the viewlets from now on
self.viewlets = [viewlet for name, viewlet in viewlets]
# Update all viewlets
for viewlet in self.viewlets:
if viewlet == setting_viewlet:
continue
viewlet.update()
def __init__(self, context):
terms = []
site = component.getSiteManager()
books = list(component.getAdapters((site,), IAddressBook))
for name, book in books:
terms.append(SimpleTerm(name, name, unicode(name)))
super(AddressBooks, self).__init__(terms)
def containers(self):
"""Get a list of potential containers
"""
context = aq_inner(self.context)
for name, locator in getAdapters((context,), IWCContainerLocator):
if locator.available:
yield dict(name=name, locator=locator)
def __call__(self):
portal_state = getMultiAdapter(
(self.context, self.request),
name=u'plone_portal_state'
)
context_state = getMultiAdapter(
(self.context, self.request),
name='plone_context_state'
)
# do not use getSite because it's possible it could be different
# than the actual portal url
portal_url = portal_state.portal_url()
result = {
'data-base-url': self.context.absolute_url(),
'data-view-url': context_state.view_url(),
'data-portal-url': portal_url,
'data-i18ncatalogurl': portal_url + '/plonejsi18n'
}
# first, check for any adapters that need pattern data defined
adapters = getAdapters(
(self.context, self.request, None),
IPatternsSettings
)
[result.update(x[1]()) for x in adapters]
# Resources Registered UI patterns can override adapters
registry = getUtility(IRegistry)
pattern_options = registry.get('plone.patternoptions', {})
for key, value in pattern_options.items():
result['data-pat-' + key] = value
return result
def __call__(self):
self.icon = self.portal_url + "/++resource++bika.lims.images/chevron_big.png"
bika_setup = getToolByName(self.context, "bika_setup")
login_url = '{}/{}'.format(self.portal_url, 'login')
landingpage = bika_setup.getLandingPage()
# Anonymous Users get either redirected to the std. bika-frontpage or
# to the custom landing page, which is set in bika_setup. If no landing
# page setup, then redirect to login page.
if self.is_anonymous_user():
# Redirect to the selected Landing Page
if landingpage:
return self.request.response.redirect(landingpage.absolute_url())
# Redirect to login page
return self.request.response.redirect(login_url)
# Authenticated Users get either the Dashboard, the std. login page
# or the custom landing page. Furthermore, they can switch between the
# Dashboard and the landing page.
# Add-ons can have an adapter for front-page-url as well.
for name, adapter in getAdapters((self.context,), IFrontPageAdapter):
redirect_to = adapter.get_front_page_url()
if redirect_to:
return self.request.response.redirect(self.portal_url + redirect_to)
# First precedence: Request parameter `redirect_to`
redirect_to = self.request.form.get("redirect_to", None)
if redirect_to == "dashboard":
return self.request.response.redirect(self.portal_url + "/bika-dashboard")
if redirect_to == "frontpage":
if landingpage:
return self.request.response.redirect(landingpage.absolute_url())
return self.template()
# Second precedence: Dashboard enabled
if self.is_dashboard_enabled():
roles = self.get_user_roles()
allowed = ['Manager', 'LabManager', 'LabClerk']
if set(roles).intersection(allowed):
return self.request.response.redirect(
self.portal_url + "/bika-dashboard")
if 'Sampler' in roles or 'SampleCoordinator' in roles:
return self.request.response.redirect(self.portal_url + "/samples?samples_review_state=to_be_sampled")
# Third precedence: Custom Landing Page
if landingpage:
return self.request.response.redirect(landingpage.absolute_url())
# Last precedence: Front Page
return self.template()
def __call__(self, context):
container = aq_parent(context)
if context.isTemporary() and isinstance(container, TempFolder):
container = aq_parent(aq_parent(container))
if not interfaces.IArticle.providedBy(container):
return []
components = [(name, comp) for name, comp in component.getAdapters((context,), interfaces.IComponentSelection)]
view = component.getMultiAdapter((container, context.REQUEST), name=u'components')
sorter = component.getMultiAdapter((container, context.REQUEST, view), interfaces.IComponentFilter)
components = sorter.filter(components)
items = []
for name, comp in components:
items.append(SimpleTerm(name, None, comp.title))
return items
def transform(self, result, encoding):
context = getContext(self.published)
manager = queryMultiAdapter((context, self.request, self.published),
IViewletManager,
name='plone.httpheaders')
if manager is not None:
headers = map(str.lower, self.request.response.headers)
for name, viewlet in getAdapters(
(context, self.request, self.published, manager), IViewlet):
viewlet.update()
for key, value in viewlet.getHeaders():
if key.lower() not in headers:
self.request.response.setHeader(key, value)
return None
def __call__(self):
self.selection_macros = SelectionMacrosView(self.context, self.request)
self.icon = self.portal_url + "/++resource++bika.lims.images/report_big.png"
self.getAnalysts = getUsers(self.context,
['Manager', 'LabManager', 'Analyst'])
self.additional_reports = []
adapters = getAdapters((self.context, ), IProductivityReport)
for name, adapter in adapters:
report_dict = adapter(self.context, self.request)
report_dict['id'] = name
self.additional_reports.append(report_dict)
return self.template()
def get_digest_adapter(self, group):
'''Get the digest adaptor for a group
:param object group: The group to get a digest-adaptor for.
:returns: The "best" digest adaptor for the group, or ``None``.
:rtype: :class:`.interfaces.ITopicsDigestNotifier`'''
adapters = [
a[1]
for a in getAdapters((group, self.request), ITopicsDigestNotifier)
if a[1].canSend
]
adapters.sort(key=lambda a: a.weight)
retval = adapters[0] if adapters else None
return retval
def getArg(self, controller_state):
url = _getArg(self, controller_state)
if controller_state.id not in ['atct_edit', 'update_version_on_edit']:
return url
context = controller_state.getContext()
adapters = getAdapters((context, ), IRedirector)
for name, adapter in adapters:
if adapter.can_handle():
return adapter.get_url()
return url
def extract(self):
data = {}
data[BASEDATA_KEY] = {
'id': self.obj.getId(),
'title': self.obj.Title(),
'portal_type': self.obj.portal_type
}
# collect data
collectors = getAdapters((self.obj, ), IDataCollector)
for name, collector in collectors:
data[name] = collector.extract()
return decode_for_json(data)
def extended_testPasswordValidity(self, password, confirm=None, data=None):
"""
Patching the standard Plone's testPasswordValidity method to
enable registering a custom password validator.
"""
original = original_testPasswordValidity(self, password, confirm)
if original:
return original
else:
validators = getAdapters((self,), ICustomPasswordValidator)
for name, validator in validators:
result = validator.validate(password, data)
if result:
return result
return None
def getAbsolutePaths(self):
root = self._getRoot()
if root is None:
return
request = getRequest()
if request is None:
return
for name, pathProvider in getAdapters((root, ), IPurgePaths):
# add absoute paths, which are not
absolutePaths = pathProvider.getAbsolutePaths()
if absolutePaths:
for absolutePath in absolutePaths:
yield absolutePath
def _create_object(self, container, data):
""" Creates the object with the data
"""
portal_type = data[BASEDATA_KEY]['portal_type']
# base data
creator = self._get_object_creator(portal_type)
obj = creator.create(container, data[BASEDATA_KEY])
# insert data from collectors
collectors = getAdapters((obj, ), IDataCollector)
for name, collector in collectors:
collector.insert(data[name])
# let the object reindex by creating a modified event, which also
# runs stuff like globalindex, if needed.
notify(ObjectModifiedEvent(obj))
return obj
def getMenuItemByAction(self, obj, request, action):
# Normalize actions; strip view prefix
if action.startswith('@@'):
action = action[2:]
if action.startswith('++view++'):
action = action[8:]
for name, item in getAdapters((obj, request), self.getMenuItemType()):
item_action = item.action
# Normalize menu item action; never uses ++view++
if item_action.startswith('@@'):
item_action = item_action[2:]
if item_action == action:
return item
def RendererVocabulary(context):
"""
Vocabulary which list out all renderers
"""
adapters = getAdapters((None, ), ICollectionMultiViewRenderer)
terms = []
for name, adapted in adapters:
if hasattr(adapted, 'title'):
title = adapted.title
elif hasattr(adapted, '__name__'): # backward compatibility with 1.x
title = adapted.__name__
else:
title = name
terms.append(SimpleVocabulary.createTerm(name, name, title))
return SimpleVocabulary(terms)
def test_annotation_saved_on_checkin(self):
# First we get and save a custom annotation to the existing object
obj_annotations = IAnnotations(self.s1)
self.assertEqual(obj_annotations, {})
obj_annotations['key1'] = u'value1'
obj_annotations = IAnnotations(self.s1)
self.assertEqual(obj_annotations, {'key1': u'value1'})
# Now, let's get a working copy for it.
locators = getAdapters((self.s1,), IWCContainerLocator)
location = u'plone.app.iterate.parent'
locator = [c[1] for c in locators if c[0] == location][0]
policy = ICheckinCheckoutPolicy(self.s1)
wc = policy.checkout(locator())
# Annotations should be the same
new_annotations = IAnnotations(wc)
self.assertEqual(new_annotations['key1'], u'value1')
# Now, let's modify the existing one, and create a new one
new_annotations['key1'] = u'value2'
new_annotations['key2'] = u'value1'
# Check that annotations were stored correctly and original ones were
# not overriten
new_annotations = IAnnotations(wc)
self.assertEqual(new_annotations['key1'], u'value2')
self.assertEqual(new_annotations['key2'], u'value1')
obj_annotations = IAnnotations(self.s1)
self.assertEqual(obj_annotations['key1'], u'value1')
self.assertFalse('key2' in obj_annotations)
# Now, we do a checkin
policy = ICheckinCheckoutPolicy(wc)
policy.checkin(u'Commit message')
# And finally check that the old object has the same annotations as
# its working copy
obj_annotations = IAnnotations(self.s1)
self.assertTrue('key1' in obj_annotations)
self.assertTrue('key2' in obj_annotations)
self.assertEqual(obj_annotations['key1'], u'value2')
self.assertEqual(obj_annotations['key2'], u'value1')
def getMenuItems(self, object, request):
"""Return menu item entries in a TAL-friendly form."""
result = []
for _name, item in getAdapters((object, request),
self.getMenuItemType()):
if item.available():
result.append(item)
# Now order the result. This is not as easy as it seems.
#
# (1) Look at the interfaces and put the more specific menu entries
# to the front.
# (2) Sort unambigious entries by order and then by title.
ifaces = list(providedBy(removeSecurityProxy(object)).__iro__)
max_key = len(ifaces)
def iface_index(item):
iface = item._for or Interface
if IInterface.providedBy(iface):
return ifaces.index(iface)
if isinstance(removeSecurityProxy(object), item._for):
# directly specified for class, this goes first.
return -1
# no idea. This goes last.
return max_key # pragma: no cover
result = [(iface_index(item), item.order, item.title, item)
for item in result]
result.sort()
result = [{
'title':
title,
'description':
item.description,
'action':
item.action,
'selected': (item.selected() and u'selected') or u'',
'icon':
item.icon,
'extra':
item.extra,
'submenu': (IBrowserSubMenuItem.providedBy(item)
and getMenu(item.submenuId, object, request)) or None
} for index, order, title, item in result]
return result
def getAvailableViews(self, excepts=[]):
generic_views = {}
views = {}
adapters = component.getAdapters(
(self.context, self.request),
interface.Interface)
for k, v in adapters:
if k not in excepts and IGrokView.providedBy(v):
adapts = grok.context.bind().get(v)
if adapts is interface.Interface:
generic_views[k] = v
else:
views[k] = v
return generic_views, views
def test_all_data_collectors_extract_json_compatible_data(self):
self.login(self.regular_user)
self.task.set_reminder(ReminderOnDate({'date': date(2019, 12, 30)}))
objects_to_test = [self.task]
for obj in objects_to_test:
adapters = getAdapters((self.task,), IDataCollector)
for name, adapter in adapters:
data = adapter.extract()
try:
json.dumps(data)
except TypeError:
self.fail("Extracted data from IDataCollector adapter "
"%r (%r) is not JSON serializable: "
"%r" % (name, adapter, data))
def switch_subscription(self, subscriber, folder, storage_key):
catalog = queryUtility(ISubscriptionCatalog)
if IPloneSiteRoot.providedBy(folder):
uid = 'plonesite'
else:
uid = IUIDStrategy(folder)()
site = getToolByName(folder, 'portal_url').getPortalObject()
storages = getAdapters((site,), IDigestStorage)
for name, storage in storages:
key = "%s-digest" % name
if key == storage_key:
catalog.index(subscriber, uid, key)
else:
storage.purge_user(subscriber)
catalog.unindex(subscriber, uid, key)
def get_all_portlets(self):
output = []
names = set()
for portlet_id in self.getPortletsIds():
output.append(self.getPortletById(portlet_id))
names.add(portlet_id)
site = self.getSite()
for portlet_id, portlet in component.getAdapters((site, ), INyPortlet):
if portlet_id not in names:
output.append(LegacyPortletWrapper(portlet, portlet_id))
names.add(portlet_id)
output.sort(key=lambda portlet: force_to_unicode(portlet.title_or_id().
lower()))
return output
def groupby(self):
if self._groupby is not None:
# The groupby criteria are used at each IBeforeTraverseEvent - so
# on each request. This has to be fast, so exit early.
return self._groupby
self._groupby = {}
cat = plone.api.portal.get_tool('portal_catalog')
# get catalog metadata schema, but filter out items which cannot be
# used for grouping
metadata = [it for it in cat.schema() if it not in GROUPBY_BLACKLIST]
for it in metadata:
index_modifier = None
display_modifier = translate_value # Allow to translate in this package domain per default. # noqa
idx = cat._catalog.indexes.get(it)
if six.PY2 and getattr(idx, 'meta_type', None) == 'KeywordIndex':
# in Py2 KeywordIndex accepts only utf-8 encoded values.
index_modifier = safe_encode
if getattr(idx, 'meta_type', None) == 'BooleanIndex':
index_modifier = make_bool
display_modifier = get_yes_no_title
# for portal_type or Type we have some special sauce as we need to translate via fti.i18n_domain. # noqa
if it == 'portal_type':
display_modifier = translate_portal_type
elif it == 'Type':
display_modifier = translate_messagefactory
self._groupby[it] = {
'index': it,
'metadata': it,
'display_modifier': display_modifier,
'css_modifier': None,
'index_modifier': index_modifier,
'value_blacklist': None,
'sort_key_function': lambda it: it['title'].lower(
), # sort key function. defaults to a lower-cased title. # noqa
}
modifiers = getAdapters((self, ), IGroupByModifier)
for name, modifier in sorted(modifiers, key=lambda it: it[0]):
modifier()
return self._groupby
def update(self):
if self.request.method != 'POST':
self.defaults = {
'sendaspdf-recipients':'',
'sendaspdf-subject': '',
'sendaspdf-message': ''
}
return
recipients = self.request.get('sendaspdf-recipients', '').strip()
subject = self.request.get('sendaspdf-subject', '').strip()
message = self.request.get('sendaspdf-message', '').strip()
self.defaults = {
'sendaspdf-recipients': recipients,
'sendaspdf-subject': subject,
'sendaspdf-message': message
}
statusmessages = IStatusMessage(self.request)
if not subject:
statusmessages.add('Subject is required', type='error')
if not recipients:
statusmessages.add('Recipients is required', type='error')
if not message:
statusmessages.add('Message is required', type='error')
if not (subject and recipients and message):
return
expanded_recipients = []
adapters = getAdapters((self.context,), IPDFEmailSource)
for recipient in recipients.splitlines():
expanded = False
for name, adapter in adapters:
if adapter.can_expand(recipient):
expanded_recipients += adapter.expand_value(recipient)
expanded = True
break
if not expanded:
expanded_recipients.append(recipient)
self.send_email(
recipients=list(set(expanded_recipients)),
subject=subject,
message=message
)
statusmessages.add('Emails sent')
self.request.response.redirect(self.context.absolute_url())
def render_content_core(self):
try:
layout = getLayout(self.context)
except TypeError:
return super(LayoutAwareItem, self).render_content_core()
req = getRequest()
filters = [f for _, f in getAdapters((self.context, req), IFilter)]
layout = apply_filters(filters, layout)
dom = getHTMLSerializer(layout)
tiles.renderTiles(req, dom.tree,
self.context.absolute_url() + '/layout_view')
gridsystem.merge(req, dom.tree)
content = contentpanel_xpath(dom.tree)
if len(content) > 0:
return tostring(content[0])
return ''
def getHistory(self, checkMayViewEvent=True, checkMayViewComment=True):
"""Get the history for current object.
Merge workflow history with content history and sort by time."""
history = []
history_adapters = getAdapters((self.context,), IImioHistory)
for adapter_name, adapter in history_adapters:
# for now, specifically limit display to u'revision' and u'workflow'
if adapter_name in self.histories_to_handle:
history.extend(adapter.getHistory(
checkMayViewEvent=checkMayViewEvent,
checkMayViewComment=checkMayViewComment))
if not history:
return []
history.sort(key=lambda x: x["time"], reverse=True)
return history
def EnabledPaymentProcessors(context):
"""Returns a vocabulary of the PaymentProcessors that have been enabled
in the shop configuration.
"""
# context is the portal config options, whose context is the portal
registry = getUtility(IRegistry)
shop_config = registry.forInterface(IShopConfiguration)
request = getSite().REQUEST
payment_processors = getAdapters((context, request, context),
IPaymentProcessor)
terms = create_terms_from_adapters(payment_processors)
for term in terms:
if term.value not in shop_config.enabled_payment_processors:
terms.remove(term)
directlyProvides(EnabledPaymentProcessors, IVocabularyFactory)
return vocabulary.SimpleVocabulary(terms)
def _setHeaders(self):
if self.published is None or \
not self.request.get('plone.app.blocks.enabled', False):
return None
context = aq_parent(aq_base(self.published)) or api.portal.get()
manager = queryMultiAdapter((context, self.request, self.published),
IViewletManager,
name='plone.httpheaders')
if manager is not None:
headers = map(str.lower, self.request.response.headers)
for name, viewlet in getAdapters(
(context, self.request, self.published, manager), IViewlet):
viewlet.update()
for key, value in viewlet.getHeaders():
if key.lower() not in headers:
self.request.response.setHeader(key, value)
def update(self):
context = self.context
self.iscalendarlayout = context.unrestrictedTraverse(
'iscalendarlayout')()
if self.iscalendarlayout:
self.sources = [
source
for name, source in getAdapters((self.context,
self.request), IEventSource)
]
else:
catalog = getToolByName(context, 'portal_catalog')
if 'object_provides' in catalog.indexes():
query = {'object_provides': IEvent.__identifier__}
else:
query = {'portal_type': 'Event'}
self.events = context.queryCatalog(**query)
def _folder_item_fieldicons(self, analysis_brain):
"""Resolves if field-specific icons must be displayed for the object
passed in.
:param analysis_brain: Brain that represents an analysis
"""
full_obj = self.get_object(analysis_brain)
uid = api.get_uid(full_obj)
for name, adapter in getAdapters((full_obj, ), IFieldIcons):
alerts = adapter()
if not alerts or uid not in alerts:
continue
alerts = alerts[uid]
if uid not in self.field_icons:
self.field_icons[uid] = alerts
continue
self.field_icons[uid].extend(alerts)
def update(self):
"""See zope.contentprovider.interfaces.IContentProvider"""
self.__updated = True
# Find all content providers for the region
viewlets = component.getAdapters(
(self.context, self.request, self.__parent__, self), IViewlet)
viewlets = self.filter(viewlets)
viewlets = self.sort(viewlets)
self.viewlets_map = dict(viewlets)
# Just use the viewlets from now on
self.viewlets = [viewlet for name, viewlet in viewlets]
# Update all viewlets
[viewlet.update() for viewlet in self.viewlets]
def transform_html(html, request):
portal = api.portal.get()
charset = portal.portal_properties.site_properties.getProperty(
'default_charset', 'utf-8')
new_html = None
published = request.get('PUBLISHED', None)
handlers = [v[1] for v in getAdapters((published, request,), ITransform)]
handlers.sort(sort_key)
if handlers:
# The first handler is the diazo transform, the others are caching
theme_handler = handlers[0]
new_html = theme_handler.transformIterable([html], charset)
# If the theme is not enabled, transform returns None
if new_html is not None:
new_html = etree.tostring(new_html.tree)
else:
new_html = html
return new_html
def getResources(self):
"""Get all the registered resource data, uncooked.
For management screens.
"""
result = []
for name, provider in getAdapters((self, ), IResourceProvider):
for item in provider.getResources():
if isinstance(item, dict):
# BBB we used dicts before
item = item.copy()
item_id = item['id']
del item['id']
obj = self.resource_class(item_id, **item)
result.append(obj)
else:
result.append(item)
return tuple(result)
def __call__(self, result=None, **kwargs):
workflow = getToolByName(self.context, 'portal_workflow')
items = self.context.getAnalyses()
field_icons = {}
for obj in items:
obj = obj.getObject() if hasattr(obj, 'getObject') else obj
uid = obj.UID()
astate = workflow.getInfoFor(obj, 'review_state')
if astate == 'retracted':
continue
adapters = getAdapters((obj, ), IFieldIcons)
for name, adapter in adapters:
alerts = adapter(obj)
if alerts:
if uid in field_icons:
field_icons[uid].extend(alerts[uid])
else:
field_icons[uid] = alerts[uid]
return field_icons
