def get_view(name=None, context=None, request=None):
"""Get a BrowserView object.
:param name: [required] Name of the view.
:type name: string
:param context: [required] Context on which to get view.
:type context: context object
:param request: [required] Request on which to get view.
:type request: request object
:raises:
:class:`~plone.api.exc.MissingParameterError`,
:class:`~plone.api.exc.InvalidParameterError`
:Example: :ref:`content_get_view_example`
"""
try:
return getMultiAdapter((context, request), name=name)
except:
# get a list of all views so we can display their names in the error
# msg
sm = getSiteManager()
views = sm.adapters.lookupAll(
required=(providedBy(context), providedBy(request)),
provided=Interface,
)
views_names = [view[0] for view in views]
raise InvalidParameterError(
"Cannot find a view with name '{0}'.\n"
"Available views are:\n"
"{1}".format(name, '\n'.join(sorted(views_names)))
)
def test_marker_interface(self):
"""Test that Folder and Collection provides IVirtualGalleryEnabled
marker interface.
"""
from hexagonit.virtualgallery.browser.interfaces import IVirtualgalleryEnabled
self.assertTrue(IVirtualgalleryEnabled in providedBy(self.portal.folder))
self.assertTrue(IVirtualgalleryEnabled in providedBy(self.portal.collection))
def test_backward_compat(self):
class C1(object): __implemented__ = I1
class C2(C1): __implemented__ = I2, I5
class C3(C2): __implemented__ = I3, C2.__implemented__
self.assert_(C3.__implemented__.__class__ is tuple)
self.assertEqual(
[i.getName() for i in providedBy(C3())],
['I3', 'I2', 'I5'],
)
class C4(C3):
implements(I4)
self.assertEqual(
[i.getName() for i in providedBy(C4())],
['I4', 'I3', 'I2', 'I5'],
)
self.assertEqual(
[i.getName() for i in C4.__implemented__],
['I4', 'I3', 'I2', 'I5'],
)
# Note that C3.__implemented__ should now be a sequence of interfaces
self.assertEqual(
[i.getName() for i in C3.__implemented__],
['I3', 'I2', 'I5'],
)
self.failIf(C3.__implemented__.__class__ is tuple)
def get_tree(self, node):
'''Get the tree below of the node
ARGUMENTS
A node in the tree.
RETURNS
A 2-tuple of (node, (children\ldots)). The node supports
the IGSContentManagerFolderMarker interface.
SIDE EFFECTS
None
'''
assert IGSContentManagerFolderMarker in providedBy(node)
objectValueTypes = ('Folder (Ordered)', 'Folder')
childFolders = node.objectValues(objectValueTypes)
children = [self.get_tree(c) for c in childFolders
if(IGSContentManagerFolderMarker in providedBy(c))]
retval = (node, tuple(children))
assert len(retval) == 2
assert retval[0] == node
assert IGSContentManagerFolderMarker in providedBy(retval[0])
return retval
def get_root(self, node):
'''Get the root of the page-tree
The root node is a node that provides the
IGSContentManagerFolderMarker interface but does not have a
parent that provides the IGSContentManagerFolderMarker
interface.
ARGUMENTS
node A node in the tree to start searching from.
RETURNS
The root node of the tree.
SIDE EFFECTS
None
'''
parent = node.aq_parent
if (IGSContentManagerFolderMarker in providedBy(parent)):
retval = self.get_root(parent)
else:
retval = node
assert retval
assert IGSContentManagerFolderMarker in providedBy(retval)
return retval
def update(self):
request = self.request
context = self.context
self.view_name = view_name = request.GET.get('view', '')
adapters = request.registry.adapters
view_callable = adapters.lookup(
(IViewClassifier, providedBy(request), providedBy(context)),
IView, name=view_name, default=None)
if not isinstance(view_callable, PyramidView):
raise HTTPNotFound()
view_renderer = None
layout_renderer = None
for r in view_callable.renderers:
if isinstance(r, view.LayoutRenderer):
layout_renderer = r
if isinstance(r, view.ViewRenderer):
view_renderer = r
if layout_renderer is not None:
self.layout = view.query_layout_chain(
context, request, layout_renderer.layout)
self.view = view_renderer
self.action = view_callable.__config_action__
self.info = view_callable.__config_action__.info
if self.layout is None:
raise HTTPNotFound()
def test_directlyProvides(self):
class IA1(Interface): pass
class IA2(Interface): pass
class IB(Interface): pass
class IC(Interface): pass
class A(Odd):
pass
classImplements(A, IA1, IA2)
class B(Odd):
pass
classImplements(B, IB)
class C(A, B):
pass
classImplements(C, IC)
ob = C()
directlyProvides(ob, I1, I2)
self.assertTrue(I1 in providedBy(ob))
self.assertTrue(I2 in providedBy(ob))
self.assertTrue(IA1 in providedBy(ob))
self.assertTrue(IA2 in providedBy(ob))
self.assertTrue(IB in providedBy(ob))
self.assertTrue(IC in providedBy(ob))
directlyProvides(ob, directlyProvidedBy(ob)-I2)
self.assertTrue(I1 in providedBy(ob))
self.assertFalse(I2 in providedBy(ob))
self.assertFalse(I2 in providedBy(ob))
directlyProvides(ob, directlyProvidedBy(ob), I2)
self.assertTrue(I2 in providedBy(ob))
def test_directlyProvides(self):
class IA1(Interface): pass
class IA2(Interface): pass
class IB(Interface): pass
class IC(Interface): pass
class A(Odd):
implements(IA1, IA2)
class B(Odd):
implements(IB)
class C(A, B):
implements(IC)
ob = C()
directlyProvides(ob, I1, I2)
self.assert_(I1 in providedBy(ob))
self.assert_(I2 in providedBy(ob))
self.assert_(IA1 in providedBy(ob))
self.assert_(IA2 in providedBy(ob))
self.assert_(IB in providedBy(ob))
self.assert_(IC in providedBy(ob))
directlyProvides(ob, directlyProvidedBy(ob)-I2)
self.assert_(I1 in providedBy(ob))
self.failIf(I2 in providedBy(ob))
self.failIf(I2 in providedBy(ob))
directlyProvides(ob, directlyProvidedBy(ob), I2)
self.assert_(I2 in providedBy(ob))
def get_view(name=None, context=None, request=None):
"""Get a BrowserView object.
:param name: [required] Name of the view.
:type name: string
:param context: [required] Context on which to get view.
:type context: context object
:param request: [required] Request on which to get view.
:type request: request object
:raises:
:class:`~plone.api.exc.MissingParameterError`,
:class:`~plone.api.exc.InvalidParameterError`
:Example: :ref:`content_get_view_example`
"""
# It happens sometimes that ACTUAL_URL is not set in tests. To be nice
# and not throw strange errors, we set it to be the same as URL.
# TODO: if/when we have api.env.test_mode() boolean in the future, use that
config = getConfiguration()
if config.dbtab.__module__ == "plone.testing.z2":
request["ACTUAL_URL"] = request["URL"]
try:
return getMultiAdapter((context, request), name=name)
except:
# get a list of all views so we can display their names in the error
# msg
sm = getSiteManager()
views = sm.adapters.lookupAll(required=(providedBy(context), providedBy(request)), provided=Interface)
views_names = [view[0] for view in views]
raise InvalidParameterError(
"Cannot find a view with name '{0}'.\n"
"Available views are:\n"
"{1}".format(name, "\n".join(sorted(views_names)))
)
def getAvailableLayouts(self):
# Get the layouts registered for this object from its FTI.
fti = self.getTypeInfo()
if fti is None:
return ()
result = []
method_ids = fti.getAvailableViewMethods(self)
spec = (providedBy(self), providedBy(self.REQUEST))
gsm = getSiteManager()
for mid in method_ids:
if not isinstance(mid, six.string_types):
mid = mid.decode()
factory = gsm.adapters.lookup(spec, Interface, mid)
if factory is not None:
menu = getUtility(
IBrowserMenu,
'plone_displayviews'
)
item = menu.getMenuItemByAction(self, self.REQUEST, mid)
title = item and item.title or mid
result.append((mid, title))
else:
method = getattr(self, mid, None)
if method is not None:
# a method might be a template, script or method
try:
title = method.aq_inner.aq_explicit.title_or_id()
except AttributeError:
title = mid
result.append((mid, title))
return result
def execute(self, clear=True):
for event in self._events:
handler = None
if event.origin is not None:
# 1. Lookup customization with the original field
required = (providedBy(event.origin), event.interface)
# 1.a Original field and name
handler = self._origin.lookup(
required, Interface, event.field.identifier)
if handler is None:
# 1.b Original field without name
handler = self._origin.lookup(required, Interface)
if handler is not None:
handler(event.field)
if handler is None:
# 2. No customization found, lookup with the zeam.form field
required = (providedBy(event.field), event.interface)
# 2.a zeam.form field and name
handler = self._field.lookup(
required, Interface, event.field.identifier)
if handler is None:
# 2.b zeam.form field without name
handler = self._field.lookup(required, Interface)
if handler is not None:
handler(event.field)
if clear:
del self._events[:]
self._scheduled = False
def getLayouts(self):
context = self.context
request = context.REQUEST
if ICollageAlias.providedBy(self.context):
target = self.context.get_target()
if target is not None:
context = target
ifaces = mark_request(context, request)
sm = getSiteManager()
layouts = sm.adapters.lookupAll(
required=(providedBy(context), providedBy(request)),
provided=Interface
)
directlyProvides(request, *ifaces)
layouts = [(name, getattr(layout, 'title', name))
for (name, layout) in layouts
if isinstance(layout, type) and
issubclass(layout, BrowserView) and
not getattr(layout, 'hide', False)]
layouts.sort(lambda a, b: cmp(a[1], b[1]))
return layouts
def checkObject(container, name, object):
"""Check containement constraints for an object and container
"""
# check __setitem__ precondition
containerProvided = providedBy(container)
__setitem__ = containerProvided.get("__setitem__")
if __setitem__ is not None:
precondition = __setitem__.queryTaggedValue("precondition")
if precondition is not None:
precondition(container, name, object)
# check the constraint on __parent__
__parent__ = providedBy(object).get("__parent__")
if __parent__ is not None:
try:
validate = __parent__.validate
except AttributeError:
pass
else:
validate(container)
if not containerProvided.extends(IContainer):
# If it doesn't implement IContainer, it can't contain stuff.
raise TypeError(_("Container is not a valid Zope container."))
def __call__(self, *args):
if len(args) == 1:
ast=args[0]
processer = p
else:
processer, ast = args
# raise Exception()
continuation = processer.continuation
continuation['initialCallDepth'] += 1
continuation['targetCallDepth'] = processer.callDepth
callback = callccCallback(continuation, self)
# processer.popStack([ast[0], callback])
# processer.stackPointer-=1
if Procedure in providedBy(ast[0]):
processer.pushStack([[ast[0], callback]])
r = processer.process([[ast[0], callback]], processer.cenv)
# processer.popStack(r)
elif Macro in providedBy(ast[0]):
r = ast[0](processer, [callback])
processer.pushStack(r)
r = processer.process(r, processer.cenv)
processer.popStack(r)
else:
r = ast[0](callback)
return r
def setUp(self):
super(self.__class__, self).setUp()
# load file content
filedata = get_file_content('example.zip')
# create an ATFile w/ the content
self.loginAsPortalOwner()
# self.portal.invokeFactory("File", 'archive')
_createObjectByType("File", self.portal, id='archive')
self.archive = archive = self.portal.archive
# we should not have IArchiveFile
self.assertTrue(IArchiveFile not in providedBy(archive))
archive.setFile(filedata)
# trigger modified event since we have a subscriber for that
event = ObjectModifiedEvent(archive)
notify(event)
# now we must have IArchiveFile
self.assertTrue(IArchiveFile in providedBy(archive))
# look for a zip reader
zipreader = component.queryAdapter(archive, IArchiveReader,
name=archive.getContentType())
self.failIf(zipreader is None)
self.logout()
def diff(source, target, *interfaces):
"""Get a list of (field, changed, result) 3-tuples, for "diff-able" fields.
"""
if not len(interfaces):
interfaces = interface.providedBy(source)
results = []
for iface in interfaces:
# the order is locked on the order returned by of interface.names()
for name in iface.names():
#!+VERSIONS(miano, 2 may 2012) something changed in the last couple
# of weeks that makes removeSecurityPolicy below required yet
# it wasn't before.
field = removeSecurityProxy(iface[name])
# only consider for diffing fields of this type
#!+VERSIONS(miano, 2 May 2012) This was an isinstance check before.
# switched it to check on interfaces.
if set((schema.interfaces.IText, schema.interfaces.ITextLine,
schema.interfaces.ISet)).isdisjoint(
set(interface.providedBy(field))):
continue
bound = field.bind(source)
source_value = bound.query(source, field.default)
target_value = bound.query(target, field.default)
if source_value is None or target_value is None:
continue
hresult = htmldiff(source_value, target_value)
results.append((field, bool(hresult!=source_value), hresult))
return results
def get_view(name=None, context=None, request=None):
"""Get a BrowserView object.
:param name: [required] Name of the view.
:type name: string
:param context: [required] Context on which to get view.
:type context: context object
:param request: [required] Request on which to get view.
:type request: request object
:raises:
:class:`~plone.api.exc.MissingParameterError`,
:class:`~plone.api.exc.InvalidParameterError`
:Example: :ref:`content_get_view_example`
"""
# We do not use exceptionhandling to detect if the requested view is
# available, because the __init__ of said view will contain
# errors in client code.
# Get all available views...
sm = getSiteManager()
available_views = sm.adapters.lookupAll(
required=(providedBy(context), providedBy(request)),
provided=Interface,
)
# and get their names.
available_view_names = [view[0] for view in available_views]
# Raise an error if the requested view is not available.
if name not in available_view_names:
raise InvalidParameterError(
"Cannot find a view with name '{0}'.\n"
"Available views are:\n"
"{1}".format(name, '\n'.join(sorted(available_view_names)))
)
return getMultiAdapter((context, request), name=name)
def _fixup_zope_interface():
# Make sure the provided and implementedBy objects
# can be iterated.
# Note that we DO NOT use the _iteratorChecker, but instead
# we use NoProxy to be sure that the results (of iteration or not) are not
# proxied. On Python 2, these objects are builtin and don't go through the
# checking process at all, much like BTrees, so NoProxy is necessary for
# compatibility. On Python 3, prior to this, iteration was simply not allowed.
from zope.interface import providedBy
from zope.interface import alsoProvides
class I1(Interface):
pass
class I2(Interface):
pass
@implementer(I1)
class O(object):
pass
o = O()
# This will be athe zope.interface.implementedBy from the class
# a zope.interface.declarations.Implements
_default_checkers[type(providedBy(o))] = NoProxy
alsoProvides(o, I2)
# This will be the zope.interface.Provides from the instance
_default_checkers[type(providedBy(o))] = NoProxy
def test_builtins(self):
# Setup
intspec = implementedBy(int)
olddeclared = intspec.declared
classImplements(int, I1)
class myint(int):
implements(I2)
x = 42
self.assertEqual([i.getName() for i in providedBy(x)],
['I1'])
x = myint(42)
directlyProvides(x, I3)
self.assertEqual([i.getName() for i in providedBy(x)],
['I3', 'I2', 'I1'])
# cleanup
intspec.declared = olddeclared
classImplements(int)
x = 42
self.assertEqual([i.getName() for i in providedBy(x)],
[])
def __eq__(self, other):
if other is self:
return True
if not isinstance(other, SimpleVocabulary):
return False
return self._terms == other._terms and providedBy(self) == providedBy(other)
def render_view(name, context, request):
adapters = config.registry.adapters
view_callable = adapters.lookup(
(IViewClassifier, providedBy(request), providedBy(context)),
IView, name=name, default=None)
return view_callable(context, request)
def _view(self, name, context, request):
adapters = self.registry.adapters
view_callable = adapters.lookup(
(IViewClassifier,
interface.providedBy(request),
interface.providedBy(context)),
IView, name=name, default=None)
return view_callable(context, request)
def test_module(self):
from zope.interface.tests import m1, m2
#import zope.interface.tests.m2
directlyProvides(m2,
m1.I1,
m1.I2,
)
self.assertEqual(list(providedBy(m1)),
list(providedBy(m2)),
)
def __init__(self, context, request):
super(CroppableImagesView, self).__init__(context, request)
image_fields = [field
for field in self.context.Schema().fields()
if IBlobImageField in providedBy(field).interfaces()
or IImageField in providedBy(field).interfaces()]
image_fields = [f
for f in image_fields
if f.get_size(self.context) > 0]
self.image_fields = image_fields
def test_wrapped_instance(self):
from zope.interface import Interface
from zope.interface import implementer
from zope.interface import providedBy
class IFoo(Interface):
pass
@implementer(IFoo)
class Foo(object):
pass
foo = Foo()
proxy = self._makeOne(foo)
self.assertEqual(list(providedBy(proxy)), list(providedBy(foo)))
def test___provides___w_field_w_provides(self):
from zope.interface import implementedBy
from zope.interface import providedBy
from guillotina.schema import Text
field = Text()
field_provides = list(providedBy(field))
wrapped = self._makeOne(field)
wrapped_provides = list(providedBy(wrapped))
self.assertEqual(wrapped_provides[:len(field_provides)],
list(providedBy(field)))
for iface in list(implementedBy(self._getTargetClass())):
self.assertTrue(iface in wrapped_provides)
def test_snippet_register(self):
def TestSnippet(request):
return 'test snippet'
view.register_snippet('test', Context, TestSnippet)
self.init_ptah()
res = self.registry.adapters.lookup(
(providedBy(Context()), providedBy(self.request)),
view.ISnippet, 'test')
self.assertEqual(res(Context(), self.request), 'test snippet')
def testUtil(self):
self.assert_(IC in implementedBy(C))
self.assert_(I1 in implementedBy(A))
self.assert_(not I1 in implementedBy(C))
self.assert_(I2 in implementedBy(B))
self.assert_(not I2 in implementedBy(C))
self.assert_(IC in providedBy(C()))
self.assert_(I1 in providedBy(A()))
self.assert_(not I1 in providedBy(C()))
self.assert_(I2 in providedBy(B()))
self.assert_(not I2 in providedBy(C()))
def test_proxy_delegates___provided_by__(self):
from zope.interface import Interface
from zope.interface import implementer
from zope.interface import providedBy
class IFoo(Interface):
pass
@implementer(IFoo)
class Foo(object):
pass
foo = Foo()
proxy = self._makeOne(foo)
self.assertEqual(providedBy(proxy), providedBy(foo))
def render_view_to_response(context, request, name='', secure=True):
""" Call the :term:`view callable` configured with a :term:`view
configuration` that matches the :term:`view name` ``name``
registered against the specified ``context`` and ``request`` and
return a :term:`response` object. This function will return
``None`` if a corresponding :term:`view callable` cannot be found
(when no :term:`view configuration` matches the combination of
``name`` / ``context`` / and ``request``).
If `secure`` is ``True``, and the :term:`view callable` found is
protected by a permission, the permission will be checked before calling
the view function. If the permission check disallows view execution
(based on the current :term:`authorization policy`), a
:exc:`pyramid.httpexceptions.HTTPForbidden` exception will be raised.
The exception's ``args`` attribute explains why the view access was
disallowed.
If ``secure`` is ``False``, no permission checking is done."""
registry = getattr(request, 'registry', None)
if registry is None:
registry = get_current_registry()
context_iface = providedBy(context)
# We explicitly pass in the interfaces provided by the request as
# request_iface to _call_view; we don't want _call_view to use
# request.request_iface, because render_view_to_response and friends are
# pretty much limited to finding views that are not views associated with
# routes, and the only thing request.request_iface is used for is to find
# route-based views. The render_view_to_response API is (and always has
# been) a stepchild API reserved for use of those who actually use
# traversal. Doing this fixes an infinite recursion bug introduced in
# Pyramid 1.6a1, and causes the render_view* APIs to behave as they did in
# 1.5 and previous. We should probably provide some sort of different API
# that would allow people to find views for routes. See
# https://github.com/Pylons/pyramid/issues/1643 for more info.
request_iface = providedBy(request)
response = _call_view(
registry,
request,
context,
context_iface,
name,
secure=secure,
request_iface=request_iface,
)
return response # NB: might be None
def updateImportance(self, remote_importance, malone_importance):
"""See `IBugWatch`."""
if self.remote_importance != remote_importance:
self.remote_importance = remote_importance
self.lastchanged = UTC_NOW
# Sync the object in order to convert the UTC_NOW sql
# constant to a datetime value.
self.sync()
for linked_bugtask in self.bugtasks_to_update:
old_bugtask = Snapshot(linked_bugtask,
providing=providedBy(linked_bugtask))
linked_bugtask.transitionToImportance(
malone_importance,
getUtility(ILaunchpadCelebrities).bug_watch_updater)
if linked_bugtask.importance != old_bugtask.importance:
event = ObjectModifiedEvent(
linked_bugtask,
old_bugtask, ['importance'],
user=getUtility(ILaunchpadCelebrities).bug_watch_updater)
notify(event)
def test_handler_step_provides_interfaces_implemented_by_upgrade_step_class(
self):
code = '\n'.join((
'from ftw.upgrade import UpgradeStep',
'from ftw.upgrade.tests.test_directory_meta_directive import IFoo',
'from zope.interface import implementer', '', '@implementer(IFoo)',
'class Foo(UpgradeStep):', ' pass'))
self.profile.with_upgrade(
Builder('ftw upgrade step').to(datetime(2011, 1, 1,
1)).with_code(code))
with self.package_created():
portal_setup = getToolByName(self.portal, 'portal_setup')
steps = listUpgradeSteps(portal_setup, 'the.package:default',
'10000000000000')
self.assertEquals(1, len(steps))
self.assertItemsEqual((IRecordableHandler, IUpgradeStep, IFoo),
tuple(providedBy(steps[0]['step'].handler)))
self.assertTrue(steps[0]['step'].handler.handler)
def test_register_class_as_content_type(self):
from repoze.workflow.interfaces import IWorkflowList
from zope.component import getSiteManager
from zope.interface import providedBy
from zope.interface import Interface
class Foo:
pass
class IBar(Interface):
pass
workflow = object()
self._callFUT(workflow, 'security', Foo)
sm = getSiteManager()
pb = providedBy(Foo)
wf_list = sm.adapters.lookup((pb, ), IWorkflowList, name='security')
self.assertEqual(wf_list, [{'elector': None, 'workflow': workflow}])
other = sm.adapters.lookup((IBar, ), IWorkflowList, name='security')
self.assertEqual(other, None)
def register_workflow(workflow, type, content_type, elector, info=None):
if content_type is None:
content_type = IDefaultWorkflow
if not IInterface.providedBy(content_type):
content_type = providedBy(content_type)
sm = getSiteManager()
wf_list = sm.adapters.lookup((content_type, ),
IWorkflowList,
name=type,
default=None)
if wf_list is None:
wf_list = []
sm.registerAdapter(wf_list, (content_type, ), IWorkflowList, type,
info)
wf_list.append({'workflow': workflow, 'elector': elector})
def test_workitems_deleted_notification_message(self):
""" Test that we get a notification for deleting a work item."""
stub.test_emails = []
wi = self.factory.makeSpecificationWorkItem()
spec = wi.specification
old_spec = Snapshot(spec, providing=providedBy(spec))
login_person(spec.owner)
spec.updateWorkItems([])
# In production this notification is fired by lazr.restful, but we
# need to do it ourselves in this test.
notify(ObjectModifiedEvent(
spec, old_spec, edited_fields=['workitems_text']))
transaction.commit()
self.assertEqual(1, len(stub.test_emails))
rationale = '- %s: %s' % (wi.title, wi.status.name)
[email] = stub.test_emails
# Actual message is part 2 of the e-mail.
msg = email[2]
self.assertIn(rationale, msg)
def requestAvatarId(self, credentials):
"""
Part of the L{ICredentialsChecker} interface. Called by a portal with
some credentials to check if they'll authenticate a user. We check the
interfaces that the credentials provide against our list of acceptable
checkers. If one of them matches, we ask that checker to verify the
credentials. If they're valid, we call our L{_cbGoodAuthentication}
method to continue.
@param credentials: the credentials the L{Portal} wants us to verify
"""
ifac = providedBy(credentials)
for i in ifac:
c = self.checkers.get(i)
if c is not None:
d = defer.maybeDeferred(c.requestAvatarId, credentials)
return d.addCallback(self._cbGoodAuthentication,
credentials)
return defer.fail(UnhandledCredentials("No checker for %s" % \
', '.join(map(reflect.qual, ifac))))
def utility(_context,
provides=None,
component=None,
factory=None,
permission=None,
name=''):
if factory and component:
raise TypeError("Can't specify factory and component.")
if provides is None:
if factory:
provides = list(implementedBy(factory))
else:
provides = list(providedBy(component))
if len(provides) == 1:
provides = provides[0]
else:
raise TypeError("Missing 'provides' attribute")
if name == '':
if factory:
name = getName(factory)
else:
name = getName(component)
if permission is not None:
component = proxify(component,
provides=provides,
permission=permission)
_context.action(
discriminator=('utility', provides, name),
callable=handler,
args=('registerUtility', component, provides, name, _context.info),
kw=dict(factory=factory),
)
_context.action(
discriminator=None,
callable=provideInterface,
args=('', provides),
)
def get_portlets(self):
portlets_schemata = {
iface: name
for name, iface in getUtilitiesFor(IPortletTypeInterface)
}
portlets = {}
for manager_name, manager in getUtilitiesFor(IPortletManager):
mapping = queryMultiAdapter(
(self.context, manager), IPortletAssignmentMapping
)
if mapping is None:
continue
mapping = mapping.__of__(self.context)
for name, assignment in mapping.items():
type_ = None
schema = None
for schema in providedBy(assignment).flattened():
type_ = portlets_schemata.get(schema, None)
if type_ is not None:
break
if type_ is None:
continue
assignment = assignment.__of__(mapping)
settings = IPortletAssignmentSettings(assignment)
if manager_name not in portlets:
portlets[manager_name] = []
title = getattr(assignment, "title", "") or getattr(
assignment, "header", ""
)
portlets[manager_name].append(
{
"type": type_,
"title": title,
"visible": settings.get("visible", True),
"assignment": {
name: getattr(assignment, name, None)
for name in schema.names()
},
}
)
self["portlets"] = portlets
def beforeTraversal(self, request):
notify(StartRequestEvent(request))
request._traversalticks_start = tickcount.tickcount()
threadid = thread.get_ident()
threadrequestfile = open_for_writing(
'logs/thread-%s.request' % threadid, 'w')
try:
request_txt = unicode(request).encode('UTF-8')
except Exception:
request_txt = 'Exception converting request to string\n\n'
try:
request_txt += traceback.format_exc()
except:
request_txt += 'Unable to render traceback!'
threadrequestfile.write(request_txt)
threadrequestfile.close()
# Tell our custom database adapter that the request has started.
da.set_request_started()
newInteraction(request)
transaction.begin()
# Now we are logged in, install the correct IDatabasePolicy for
# this request.
db_policy = IDatabasePolicy(request)
getUtility(IStoreSelector).push(db_policy)
getUtility(IOpenLaunchBag).clear()
# Set the default layer.
adapters = getGlobalSiteManager().adapters
layer = adapters.lookup((providedBy(request), ), IDefaultSkin, '')
if layer is not None:
layers.setAdditionalLayer(request, layer)
principal = self.getPrincipal(request)
request.setPrincipal(principal)
self.maybeRestrictToTeam(request)
maybe_block_offsite_form_post(request)
def makeConnection(self, transport):
directlyProvides(self, providedBy(transport))
Protocol.makeConnection(self, transport)
if not self.method in self.allowedMethods:
self.sendHeaders({
'status': '405 Method Not Supported',
'allow': ', '.join(self.allowedMethods)
})
self.transport.write("\r\n")
self.transport.loseConnection()
return
elif self.method == 'OPTIONS':
self.sendHeaders()
self.transport.write("")
self.transport.loseConnection()
return
if not self.writeOnly:
if self.session in self.factory.sessions:
self.wrappedProtocol = self.factory.sessions[self.session]
else:
self.wrappedProtocol = RelayProtocol(
self.factory,
self.factory.wrappedFactory.buildProtocol(
self.transport.addr), self.session)
if self.wrappedProtocol.attached:
self.wrappedProtocol = None
self.failConnect()
else:
if not self.prepConnection():
self.disconnecting = False
self.wrappedProtocol.makeConnection(self)
else:
if self.session in self.factory.sessions:
self.wrappedProtocol = self.factory.sessions[self.session]
else:
self.sendHeaders({'status': '404 Not Found'})
self.transport.write("\r\n")
self.transport.loseConnection()
def test__find_view_no_match_multiview_registered(self):
from zope.interface import implements
from zope.interface import providedBy
from pyramid.interfaces import IRequest
from pyramid.interfaces import IViewClassifier
from pyramid.interfaces import IMultiView
from pyramid.traversal import DefaultRootFactory
from pyramid.registry import Registry
registry = Registry()
class View1(object):
implements(IMultiView)
request = DummyRequest({'PATH_INFO':'/a'})
root = DefaultRootFactory(request)
root_iface = providedBy(root)
registry.registerAdapter(View1(),
(IViewClassifier, IRequest, root_iface),
IMultiView)
self._register_mapper(registry, [])
command = self._makeOne(registry=registry)
result = command._find_view('/x', registry)
self.assertEqual(result, None)
def excview_tween(request):
attrs = request.__dict__
try:
response = handler(request)
except Exception, exc:
# WARNING: do not assign the result of sys.exc_info() to a
# local var here, doing so will cause a leak
attrs['exc_info'] = sys.exc_info()
attrs['exception'] = exc
# clear old generated request.response, if any; it may
# have been mutated by the view, and its state is not
# sane (e.g. caching headers)
if 'response' in attrs:
del attrs['response']
request_iface = attrs['request_iface']
provides = providedBy(exc)
for_ = (IExceptionViewClassifier, request_iface.combined, provides)
view_callable = adapters.lookup(for_, IView, default=None)
if view_callable is None:
raise
response = view_callable(exc, request)
def _updateContent(self, notification, data=None):
try:
util = getUtility(IAction, notification.action)
except ComponentLookupError:
raise InvalidTriggerActionType(
"Invalid action type specified: %s" % notification.action
)
fields = {}
for iface in providedBy(util.getInfo(notification)):
f = getFields(iface)
if f:
fields.update(f)
data = util.getDefaultData(self._dmd)
for k, v in fields.iteritems():
if k not in data:
data[k] = v.default
util.updateContent(notification.content, data)
def annotate_add(context):
if IPloneSiteRoot in providedBy(context):
return
try:
annotate_action(
context.REQUEST,
context.absolute_url(),
"add",
context.getContentType(),
get_metadata(context),
)
except AttributeError:
#dexterity content
annotate_action(
context.REQUEST,
context.absolute_url(),
"add",
context.content_type(),
get_metadata(context),
)
def diff(source, target, *interfaces):
"""Get a list of (field, changed, result) 3-tuples, for "diff-able" fields.
"""
if not len(interfaces):
interfaces = interface.providedBy(source)
results = []
for iface in interfaces:
# the order is locked on the order returned by of interface.names()
for name in iface.names():
field = iface[name]
# only consider for diffing fields of this type
if not isinstance(field, (schema.Text, schema.TextLine, schema.Set)):
continue
bound = field.bind(source)
source_value = bound.query(source, field.default)
target_value = bound.query(target, field.default)
if source_value is None or target_value is None:
continue
hresult = textDiff(source_value, target_value)
results.append((field, bool(hresult!=source_value), hresult))
return results
def render_panel(context, request, name='', *args, **kw):
"""Render a panel.
TODO: Clean this up
Renders the named panel, returning a `unicode` object that is the
rendered HTML for the panel. The panel is looked up using the current
context (or the context given as keyword argument, to override the
context in which the panel is called) and an optional given name
(which defaults to an empty string).
The panel is called passing in the current
context, request and any additional parameters passed into the
`render_panel` call. In case a panel isn't found, `None` is returned.
"""
if "controls" not in kw:
kw["controls"] = True
adapters = request.registry.adapters
panel = adapters.lookup((providedBy(context), ), IPanel, name=name)
assert panel, "Could not find panel {name}".format(name=name)
return Markup(panel(context, request, *args, **kw))
def getExportImportHandler(self, field):
"""Returns an IWidgetExportImportHandler suitable for this widget."""
widgetName = self.getWidgetFactoryName()
if widgetName is None:
# Find default widget factory for this field.
# We use lookup instead of getAdapter b/c we don't want to
# instantiate the widget.
sm = getSiteManager()
widgetFactory = sm.adapters.lookup((providedBy(field), IFormLayer),
IFieldWidget)
if widgetFactory is not None:
widgetName = '{0}.{1}'.format(widgetFactory.__module__,
widgetFactory.__name__)
else:
widgetName = u''
widgetHandler = queryUtility(IWidgetExportImportHandler,
name=widgetName)
if widgetHandler is None:
widgetHandler = WidgetExportImportHandler(IHTMLFormElement)
return widgetHandler
def list_uiactions(content, request=None, registry=None, category=''):
""" List ui actions for specific content """
if request is not None:
registry = request.registry
url = request.resource_url(content)
else:
url = ''
actions = []
for name, action in registry.adapters.lookupAll((providedBy(content), ),
IAction):
if (action.category == category) and action.check(content, request):
actions.append((action.sort_weight, {
'id': action.id,
'url': action.url(content, request, url),
'title': action.title,
'description': action.description,
'data': action.data
}))
return [ac for _w, ac in sorted(actions, key=lambda action: action[0])]
def _makeFolder(id, site_folder=False):
from zope.interface import directlyProvides
from zope.interface import providedBy
from Products.CMFCore.PortalFolder import PortalFolder
from Products.CMFCore.interfaces import ISiteRoot
from Products.CMFCore.TypesTool import TypesTool
from Products.CMFCore.tests.base.dummy import DummyType
class _TypeInfo(DummyType):
def _getId(self):
return self._id
def constructInstance(self, container, id, *args, **kw):
portal_type = self._getId()
if portal_type == TEST_FOLDER:
content = PortalFolder(id)
elif portal_type == TEST_CONTENT:
content = _makeItem()
content._setId(id)
elif portal_type == TEST_INI_AWARE:
content = _makeINIAware(id)
elif portal_type == TEST_CSV_AWARE:
content = _makeCSVAware(id)
else:
raise ValueError, 'Ugh'
content.portal_type = portal_type
container._setObject(id, content)
return container._getOb(id)
folder = PortalFolder(id)
folder.portal_type = TEST_FOLDER
if site_folder:
directlyProvides(folder, ISiteRoot + providedBy(folder))
tool = folder.portal_types = TypesTool()
tool._setObject(TEST_CSV_AWARE, _TypeInfo(TEST_CSV_AWARE))
tool._setObject(TEST_INI_AWARE, _TypeInfo(TEST_INI_AWARE))
tool._setObject(TEST_CONTENT, _TypeInfo(TEST_CONTENT))
tool._setObject(TEST_FOLDER, _TypeInfo(TEST_FOLDER))
return folder
def event(obj, event=None):
if event is None:
# some events don't include object
event = obj
obj = None
iface = providedBy(event).declared[0]
if iface in _registered:
try:
registry = getUtility(IRegistry)
except ComponentLookupError:
return
if not registry.get(
'collective.elasticsearch.interfaces.IElasticSettings.enabled',
False): # noqa
return
if obj is not None and ITrashed.providedBy(obj):
# special handling for ITrashed...
# we don't want to record transition events for trashing
# and we want a special psuedo trash event
# then, we still want an event when it gets deleted for good
if iface not in (IAfterTransitionEvent, IObjectRemovedEvent):
# dive out if not IAfterTransitionEvent or object removed event
return
if iface == IObjectRemovedEvent:
audit_data = _registered[iface]
else:
audit_data = _registered[ITrashed]
else:
audit_data = _registered[iface]
recorder = audit_data.get_recorder(event, obj)
site_path = '/'.join(api.portal.get().getPhysicalPath())
transaction.get().addAfterCommitHook(
record,
args=(recorder, site_path, ESConnectionFactoryFactory(registry)))
else:
pass
def doCustomizeTemplate(self, viewname):
# find the nearest site
site = findSite(self.context, IObjectManagerSite)
if site is None:
raise TypeError("No site found") # TODO find right exception
# we're using the original filename of the template, not the
# view name to avoid potential conflicts and/or confusion in
# URLs
template = self.templateFromViewName(viewname)
zpt_id = basename(template.filename)
template_file = self.templateCodeFromViewName(viewname)
viewclass = self.viewClassFromViewName(viewname)
permission = self.permissionFromViewName(viewname)
viewzpt = TTWViewTemplate(zpt_id,
template_file,
view=viewclass,
permission=permission)
container = queryUtility(IViewTemplateContainer)
if container is not None:
viewzpt = container.addTemplate(zpt_id, viewzpt)
else:
site._setObject(zpt_id,
viewzpt) #XXXthere could be a naming conflict
viewzpt = getattr(site, zpt_id)
# find out the view registration object so we can get at the
# provided and required interfaces
for reg in getViews(providedBy(self.context), IBrowserRequest):
if reg.name == viewname:
break
components = site.getSiteManager()
components.registerAdapter(viewzpt,
required=reg.required,
provided=reg.provided,
name=viewname) #XXX info?
return viewzpt
def update(self):
need("yui-dragdrop")
need("yui-container")
sitting = self._parent._parent.context
scheduled_item_ids = [item.item_id for item in sitting.item_schedule]
# add location to items
gsm = component.getSiteManager()
adapter = gsm.adapters.lookup(
(interface.implementedBy(self.model), interface.providedBy(self)),
ILocation
)
date_formatter = self.get_date_formatter("date", "medium")
items = [ adapter(item, None) for item in self._query_items() ]
# for each item, format dictionary for use in template
self.items = [{
"title": properties.title,
"name": item.__class__.__name__,
"description": properties.description,
#"date": _(u"$F", mapping={"F":
# datetimedict.fromdatetime(item.changes[-1].date)}),
#"date":item.changes[-1].date,
# not every item has a auditlog (headings)
# use last status change instead.
"date": date_formatter.format(self._item_date(item)),
"state": IWorkflow(item).get_state(item.status).title,
"id": item.parliamentary_item_id,
"class": (
(item.parliamentary_item_id in scheduled_item_ids and
"dd-disable") or
""),
"url": self._item_url(item),
"type": item.type
} for item, properties in [
(item, (IDCDescriptiveProperties.providedBy(item) and item or
IDCDescriptiveProperties(item)))
for item in items ]
]
def testDefaultSkin(self):
request = TestRequest()
self.assertEqual(
component.queryMultiAdapter((ob, request), name='test'), None)
XMLConfig('meta.zcml', zope.app.component)()
xmlconfig(
StringIO(template % ('''
<interface
interface="
zope.app.publisher.browser.tests.test_directives.ITestSkin"
type="zope.publisher.interfaces.browser.IBrowserSkinType"
name="Test Skin"
/>
<browser:defaultSkin name="Test Skin" />
<browser:page
name="test"
class="zope.app.component.tests.views.VZMI"
layer="
zope.app.publisher.browser.tests.test_directives.ITestLayer"
for="zope.app.component.tests.views.IC"
permission="zope.Public"
attribute="index"
/>
<browser:page name="test"
class="zope.app.component.tests.views.V1"
for="zope.app.component.tests.views.IC"
permission="zope.Public"
attribute="index"
/>
''')))
# Simulate Zope Publication behavior in beforeTraversal()
adapters = component.getSiteManager().adapters
skin = adapters.lookup((providedBy(request), ), IDefaultSkin, '')
directlyProvides(request, skin)
v = component.queryMultiAdapter((ob, request), name='test')
self.assert_(issubclass(v.__class__, VZMI))
def test_no_adapts(self):
from zope.interface import Interface
from zope.interface import implementer
from zope.interface import providedBy
from zope.component.globalregistry import getGlobalSiteManager
from zope.component._api import adapter
class IFoo(Interface):
pass
@implementer(IFoo)
class Foo(object):
pass
@adapter(IFoo)
def _handler(context):
assert 0, "DON'T GO HERE"
self._callFUT(_handler)
gsm = getGlobalSiteManager()
regs = list(gsm.registeredHandlers())
self.assertEqual(len(regs), 1)
hr = regs[0]
self.assertEqual(list(hr.required), list(providedBy(Foo())))
self.assertEqual(hr.name, '')
self.assertTrue(hr.factory is _handler)
def share_with_principal(self, principal_id, role):
""" Setup proper share role for this principal
"""
logger.info("Setting up proper %s role for %s", role, principal_id)
print "Sharing", principal_id, role
contexts = [self.context]
wc = self.get_wc(self.context)
if wc:
contexts.append(wc)
site = getSite()
for location in PLONE_LOCATIONS:
if self.context.aq_parent.id != 'countries':
continue
obj = site.unrestrictedTraverse(location + self.context.id)
if obj:
contexts.append(obj)
for folder in contexts:
self.assign_role_to_principal(folder, role, principal_id)
if ICountryPage not in list(providedBy(folder)):
mark(folder, ICountryPage)
def updateStatus(self, remote_status, malone_status):
"""See `IBugWatch`."""
if self.remotestatus != remote_status:
self.remotestatus = remote_status
self.lastchanged = UTC_NOW
# Sync the object in order to convert the UTC_NOW sql
# constant to a datetime value.
self.sync()
for linked_bugtask in self.bugtasks_to_update:
old_bugtask = Snapshot(linked_bugtask,
providing=providedBy(linked_bugtask))
linked_bugtask.transitionToStatus(
malone_status,
getUtility(ILaunchpadCelebrities).bug_watch_updater)
# We don't yet support updating the assignee of bug watches.
linked_bugtask.transitionToAssignee(None)
if linked_bugtask.status != old_bugtask.status:
event = ObjectModifiedEvent(
linked_bugtask,
old_bugtask, ['status'],
user=getUtility(ILaunchpadCelebrities).bug_watch_updater)
notify(event)
def find_service(request, iface=Interface, context=_marker, name=''):
if context is _marker:
context = getattr(request, 'context', None)
context_iface = providedBy(context)
svc_types = (IServiceClassifier, context_iface)
cache = request.service_cache
svc = cache.lookup(svc_types, iface, name=name, default=None)
if svc is None:
adapters = request.registry.adapters
info = adapters.lookup(svc_types, iface, name=name)
if info is None:
raise ValueError('could not find registered service')
svc = info.factory(context, request)
cache.register(
(IServiceClassifier, info.context_iface),
iface,
name,
svc,
)
return svc
def getBindingNames(self, context):
## Todo: remove this getattr
ifs = providedBy(getattr(self, 'boundTo', self))
ifs = [
x for x in ifs if x is not IConfigurable and x is not TypedInterface
]
bindingNames = []
self.bindingDict = bindingDict = {}
for interface in ifs:
## TypedInterfaces have a __spec__ attribute which is a list of all Typed properties and
## autocallable methods
for binding in getattr(interface, '__spec__', []):
bindingDict[binding.name] = binding
if binding.name not in bindingNames:
bindingNames.append(binding.name)
if IActionableType.providedBy(binding.typedValue):
acts = binding.typedValue.actions
if acts is None:
acts = []
for action in acts:
bindingDict[action.name] = action
return bindingNames
def test_getAdditionalSchemata(self):
from plone.dexterity.interfaces import IDexterityFTI
from plone.behavior.interfaces import IBehavior
from plone.autoform.interfaces import IFormFieldProvider
from zope.interface import Interface
from zope.interface import providedBy
class IBehaviorInterface(Interface):
pass
class IBehaviorSchema(Interface):
pass
behavior_mock = Mock()
fti_mock = DexterityFTI(u'testtype')
portal_type = 'prefix_0_type_0_schema'
behavior_name = 'behavior_0'
fti_mock.behaviors = (behavior_name,)
behavior_mock.interface = IBehaviorInterface
provider_mock = Mock(return_value=IBehaviorSchema)
self.mock_utility(behavior_mock, IBehavior, behavior_name)
self.mock_utility(fti_mock, IDexterityFTI, portal_type)
self.mock_adapter(
provider_mock,
IFormFieldProvider,
(providedBy(IBehaviorInterface), )
)
generator = utils.getAdditionalSchemata(None, portal_type)
schematas = tuple(generator)
self.assertEqual(len(schematas), 1)
schemata = schematas[0]
self.assertTrue(schemata is IBehaviorSchema)
def makeConnection(self, transport):
"""
Connect this wrapper to the given transport and initialize the
necessary L{OpenSSL.SSL.Connection} with a memory BIO.
"""
tlsContext = self.factory._contextFactory.getContext()
self._tlsConnection = Connection(tlsContext, None)
if self.factory._isClient:
self._tlsConnection.set_connect_state()
else:
self._tlsConnection.set_accept_state()
self._appSendBuffer = []
# Add interfaces provided by the transport we are wrapping:
for interface in providedBy(transport):
directlyProvides(self, interface)
# Intentionally skip ProtocolWrapper.makeConnection - it might call
# wrappedProtocol.makeConnection, which we want to make conditional.
Protocol.makeConnection(self, transport)
self.factory.registerProtocol(self)
if self._connectWrapped:
# Now that the TLS layer is initialized, notify the application of
# the connection.
ProtocolWrapper.makeConnection(self, transport)
# Now that we ourselves have a transport (initialized by the
# ProtocolWrapper.makeConnection call above), kick off the TLS
# handshake.
try:
self._tlsConnection.do_handshake()
except WantReadError:
# This is the expected case - there's no data in the connection's
# input buffer yet, so it won't be able to complete the whole
# handshake now. If this is the speak-first side of the
# connection, then some bytes will be in the send buffer now; flush
# them.
self._flushSendBIO()
