def setupContext(self, field_name, mode, widget, instance, field, \
accessor, **kwargs):
# look for the context in the stack
frame = sys._getframe()
context = _marker
while context is _marker and frame is not None:
context = frame.f_locals.get('econtext', _marker)
frame = frame.f_back
if context is _marker:
raise RuntimeError, 'Context not found'
# for editing of multiple AT-based content at once we might want to
# prefix the field-name.
if 'fieldprefix' in kwargs:
field_name = '%s%s' % (kwargs['fieldprefix'], field_name)
widget = ImplicitAcquisitionWrapper(widget, instance)
field = ImplicitAcquisitionWrapper(field, instance)
context.setLocal('here', instance)
context.setLocal('fieldName', field_name)
context.setLocal('accessor', accessor)
context.setLocal('widget', widget)
context.setLocal('field', field)
context.setLocal('mode', mode)
context.setLocal('UID', instance.UID())
if kwargs:
for k, v in kwargs.items():
context.setLocal(k, v)
del frame
return context
def __call__(self, context):
settings = IFeedSettings(context)
wrapped = ImplicitAcquisitionWrapper(self, settings)
generator = wrapped.get_terms()
terms = tuple(generator)
return SimpleVocabulary(terms)
def __of__(self, parent):
'''
Sneakily sets up the portal skin then returns the wrapper
that Acquisition.Implicit.__of__() would return.
'''
w_self = ImplicitAcquisitionWrapper(aq_base(self), parent)
w_self.setupCurrentSkin()
return w_self
def __of__(self, parent):
'''
Sneakily sets up the portal skin then returns the wrapper
that Acquisition.Implicit.__of__() would return.
'''
w_self = ImplicitAcquisitionWrapper(aq_base(self), parent)
w_self.setupCurrentSkin()
return w_self
def __of__(self, parent):
'''
Sneakily sets up the portal skin then returns the wrapper
that Acquisition.Implicit.__of__() would return.
'''
w_self = ImplicitAcquisitionWrapper(self, parent)
try:
w_self.setupCurrentSkin()
except ConflictError:
raise
except:
# This shouldn't happen, even if the requested skin
# does not exist.
logger.exception("Unable to setupCurrentSkin()")
return w_self
def __of__(self, parent):
'''
Sneakily sets up the portal skin then returns the wrapper
that Acquisition.Implicit.__of__() would return.
'''
w_self = ImplicitAcquisitionWrapper(self, parent)
try:
w_self.setupCurrentSkin()
except ConflictError:
raise
except:
# This shouldn't happen, even if the requested skin
# does not exist.
logger.exception("Unable to setupCurrentSkin()")
return w_self
def __of__(self, parent):
# Accesses the database, returning an acquisition
# wrapper around the connected object rather than around self.
try:
return self._getOrOpenObject(parent)
except:
return ImplicitAcquisitionWrapper(self, parent)
def __of__(self, parent):
'''
Sneakily sets up the portal skin then returns the wrapper
that Acquisition.Implicit.__of__() would return.
'''
w_self = ImplicitAcquisitionWrapper(self, parent)
try:
w_self.setupCurrentSkin()
except:
# This shouldn't happen, even if the requested skin
# does not exist.
import sys
from zLOG import LOG, ERROR
LOG('CMFCore', ERROR, 'Unable to setupCurrentSkin()',
error=sys.exc_info())
return w_self
def __of__(self, parent):
try:
self = ImplicitAcquisitionWrapper(self, parent)
self._updateFromFS()
return self
except:
logger.exception("Error during __of__")
raise
def __of__(self, parent):
try:
self = ImplicitAcquisitionWrapper(self, parent)
self._updateFromFS()
return self
except:
logging.exception('FS Z SQL Method', 'Error during __of__')
raise
def wrapped_context(self):
""""We need to wrap the context to be able to acquire the root
of the site to get tools, as done in plone.app.textfield"""
context = self.context
content = closest_content(context)
if context.__class__ == dict:
context = UserDict(self.context)
return ImplicitAcquisitionWrapper(context, content)
def getHistoryMetadata(self, obj):
"""Returns the versioning metadata history.
"""
self._assertAuthorized(obj, AccessPreviousVersions,
'getHistoryMetadata')
portal_archivist = getToolByName(self, 'portal_archivist')
hist = portal_archivist.getHistoryMetadata(obj)
if hist:
return ImplicitAcquisitionWrapper(hist, obj)
return hist
def __call__(self, context):
try:
utility = getUtility(IApiUtility, context=context)
except ComponentLookupError:
site = getSite()
utility = getUtility(IApiUtility, context=site)
else:
utility = utility.__of__(context)
wrapped = ImplicitAcquisitionWrapper(self, utility)
generator = wrapped.get_terms()
terms = tuple(generator)
try:
return SimpleVocabulary(terms)
except ValueError as e:
logger.info(e.message)
return SimpleVocabulary([])
def __call__(self, context):
try:
utility = getUtility(IApiUtility, context=context)
except ComponentLookupError:
site = getSite()
utility = getUtility(IApiUtility, context=site)
else:
utility = utility.__of__(context)
wrapped = ImplicitAcquisitionWrapper(self, utility)
generator = wrapped.get_terms()
terms = tuple(generator)
try:
return SimpleVocabulary(terms)
except ValueError as e:
logger.info(e.message)
return SimpleVocabulary([])
def __of__(self, parent):
try:
self = ImplicitAcquisitionWrapper(self, parent)
self._updateFromFS()
return self
except:
import sys
LOG('FS Z SQL Method',
ERROR,
'Error during __of__',
error=sys.exc_info())
raise
def wrapped_context(self):
context = self.context
content = closest_content(context)
# We'll wrap context in the current site *if* it's not already
# wrapped. This allows the template to acquire tools with
# ``context/portal_this`` if context is not wrapped already.
# Any attempts to satisfy the Kupu template in a less idiotic
# way failed. Also we turn dicts into UserDicts to avoid
# short-circuiting path traversal. :-s
if context.__class__ == dict:
context = UserDict(self.context)
return ImplicitAcquisitionWrapper(context, content)
def lookupType(self, package, type):
types = self.listRegisteredTypes()
for t in types:
if t['package'] != package:
continue
if t['meta_type'] == type:
# We have to return the schema wrapped into the acquisition of
# something to allow access. Otherwise we will end up with:
# Your user account is defined outside the context of the object
# being accessed.
t['schema'] = ImplicitAcquisitionWrapper(t['schema'], self)
return t
return None
def delegate(self, method, obj, data=None, file=None, **kw):
if file is not None:
kw['file'] = file
__traceback_info__ = (method, obj, kw)
context = getContext(obj, kw.get('REQUEST'))
if context is not obj:
# If the object is being created by means of a PUT
# then it has no context, and some of the stuff
# we are doing here may require a context.
# Wrapping it in an ImplicitAcquisitionWrapper should
# be safe as long as nothing tries to persist
# a reference to the wrapped object.
obj = ImplicitAcquisitionWrapper(obj, context)
tool = getToolByName(obj, TOOL_ID, None)
components = None
if tool is not None:
info = kw.copy()
info['data'] = data
info['mode'] = method
components = tool.getMarshallersFor(obj, **info)
else:
# Couldn't find a context to get
# hold of the tool or the tool is not installed.
logger.log(
logging.DEBUG, 'Could not find the marshaller tool. '
'It might not be installed or you might not '
'be providing enough context to find it.')
# We just use the first component, if one is returned.
if components:
marshaller = getComponent(components[0])
else:
# If no default marshaller was provided then we complain.
if self.fallback is None:
raise MarshallingException(
"Couldn't get a marshaller for %r, %r" % (obj, kw))
# Otherwise, use the default marshaller provided. Note it
# must be an instance, not a factory.
marshaller = self.fallback
__traceback_info__ = (marshaller, method, obj, kw)
args = (obj, )
if method == 'demarshall':
args += (data, )
method = getattr(marshaller, method)
return mapply(method, *args, **kw)
def manage_main(self, REQUEST, *a, **kw):
"""
Wrap Folder's manage_main to render international characters
"""
# ugh, API cruft
if REQUEST is self and a:
REQUEST = a[0]
a = a[1:]
# wrap the special dtml method Folder.manage_main into a valid
# acquisition context. Required for Zope 2.8+.
try:
r = Folder.manage_main(self, self, REQUEST, *a, **kw)
except AttributeError:
manage_main = ImplicitAcquisitionWrapper(Folder.manage_main, self)
r = manage_main(self, self, REQUEST, *a, **kw)
if isinstance(r, unicode):
r = r.encode('utf-8')
REQUEST.RESPONSE.setHeader('Content-type', 'text/html; charset=utf-8')
return r
def __init__(self, kw, context):
self.context = ImplicitAcquisitionWrapper(self, context)
self.url = kw['path']
self.title = kw['title']
self.description = u''
tzname = "Europe/Brussels"
zone = timezone(tzname)
self.start = isotime2dt(kw['start_date'], zone)
self.end = isotime2dt(kw['end_date'], zone)
self.timezone = tzname
self.location = kw.get('City', '')
self.attendees = kw['number_of_attendees'] # not used anyway
self.contact_name = kw['agency_initial_contact']
self.contact_email = kw['agency_contact_reply']
self.contact_phone = ""
self.event_url = kw['website_of_event']
self.subjects = ", ".join(kw['category'].split("\\n"))
self.text = kw['body']
self.organiser = kw['organization']
self.attachment = False
def __of__(self, parent):
w, m, p = self._ugh
return m.__of__(ImplicitAcquisitionWrapper(w, parent))
def __call__(self, *args, **kw):
w, m, parent = self._ugh
self = m.__of__(ImplicitAcquisitionWrapper(w, parent))
return self(*args, **kw)
def __call__(self, form, request):
template = self.template
if IAcquirer.providedBy(template):
return ImplicitAcquisitionWrapper(template, form)
else:
return template
def getContent(self):
content = super(ControlPanelEditForm, self).getContent()
return ImplicitAcquisitionWrapper(content, self.context)
def create(self, data):
container = aq_inner(self.context)
content = self.ti.factory(**data)
content.__parent__ = container
content = ImplicitAcquisitionWrapper(content, container)
return content
def Schema(self):
schema = self.getAndPrepareSchema()
return ImplicitAcquisitionWrapper(schema, self)
class ListSubscribeForm(SubscribeForm):
# See Products.PloneHotfix20160830==1.3
allow_prefill_from_GET_request = True
@property
def fields(self):
fields = field.Fields()
settings = IFeedSettings(self.context)
# Javascript-widget
if settings.enable_select_all:
fields += field.Fields(
SelectAllGroupsJavascript(schema.Field(__name__="js",
required=False),
mode="hidden"))
# Include form fields, but change the order around.
fields += field.Fields(ISubscription).select('interests')
fields['interests'].widgetFactory = InterestsWidget.factory
if settings.show_name:
fields += field.Fields(
schema.TextLine(
__name__="name",
title=_(u"Name"),
required=False,
))
fields += field.Fields(ISubscription).select('email')
# Add mailinglist as hidden field
fields += field.Fields(schema.ASCII(__name__="list_id", required=True),
mode="hidden")
context = self.getContent()
api = getUtility(IApiUtility, context=self.context)
result = api.list_merge_vars(context.mailinglist)
for entry in result:
name = entry['tag'].lower()
if name in fields:
continue
if not entry['show']:
continue
# Skip all-uppercase:
if entry['name'] == entry['name'].upper():
continue
field_type = entry['field_type']
required = entry['req']
if field_type == 'text':
factory = schema.TextLine
options = {}
elif field_type == 'dropdown':
factory = schema.Choice
choices = list(entry['choices'])
if not required:
choices.append(u"")
required = True
options = {
'vocabulary':
SimpleVocabulary([
SimpleTerm(value=value,
token=value.encode('ascii',
'xmlcharrefreplace'),
title=value or _(u"None"))
for value in choices
])
}
else:
continue
fields += field.Fields(
factory(__name__=name.encode('utf-8'),
default=entry['default'],
required=required,
title=_(entry['name']),
**options))
return fields
# Remove prefix; we want to be able to provide defaults using a
# simple format.
prefix = ""
@property
def description(self):
context = self.context.aq_base
if self.request.get('success'):
return u''
elif not IPloneSiteRoot.providedBy(context) \
and context.Description():
return context.Description()
else:
return _(u"Select subscription options and submit form.")
@property
def label(self):
if self.request.get('success'):
return _(u"Request processed")
name = self.getContent().name
return _(u"Subscribe to: ${name}", mapping={'name': name})
@view.memoize
def getContent(self):
if ISubscriptionFormSettings.providedBy(self.context):
return self.context
settings = IFeedSettings(self.context)
try:
context = SubscribeContext(self.request)
except KeyError, exc:
raise BadRequest(u"Missing parameter: %s." % exc)
return context.__of__(
ImplicitAcquisitionWrapper(settings, self.context))
def Schema(self):
"""Return a (wrapped) schema instance for this object instance.
"""
return ImplicitAcquisitionWrapper(ISchema(self), self)
def __of__(self, parent):
self = ImplicitAcquisitionWrapper(self, parent)
self._updateFromFS()
return self
def _wrap_schema(self, schema):
return ImplicitAcquisitionWrapper(schema, self)
def wrapObject(self, object, sql_catalog_id=None, **kw):
"""
Return a wrapped object for reindexing.
"""
catalog = self.getSQLCatalog(sql_catalog_id)
if catalog is None:
# Nothing to do.
LOG('wrapObject', 0, 'Warning: catalog is not available')
return (None, None)
document_object = aq_inner(object)
w = IndexableObjectWrapper(document_object)
wf = getToolByName(self, 'portal_workflow')
if wf is not None:
w.__dict__.update(wf.getCatalogVariablesFor(object))
# Find the parent definition for security
is_acquired = 0
while getattr(document_object, 'isRADContent', 0):
# This condition tells which object should acquire
# from their parent.
# XXX Hardcode _View_Permission for a performance point of view
if getattr(aq_base(document_object), '_View_Permission', ACQUIRE_PERMISSION_VALUE) == ACQUIRE_PERMISSION_VALUE\
and document_object._getAcquireLocalRoles():
document_object = document_object.aq_parent
is_acquired = 1
else:
break
if is_acquired:
document_w = IndexableObjectWrapper(document_object)
else:
document_w = w
(security_uid_dict, optimised_roles_and_users) = \
catalog.getSecurityUidDict(document_w)
w.optimised_roles_and_users = optimised_roles_and_users
catalog_security_uid_groups_columns_dict = \
catalog.getSQLCatalogSecurityUidGroupsColumnsDict()
default_security_uid_column = catalog_security_uid_groups_columns_dict[
'']
for local_roles_group_id, security_uid in security_uid_dict.items():
catalog_column = catalog_security_uid_groups_columns_dict.get(
local_roles_group_id, default_security_uid_column)
setattr(w, catalog_column, security_uid)
# XXX we should build vars begore building the wrapper
predicate_property_dict = catalog.getPredicatePropertyDict(object)
if predicate_property_dict is not None:
w.predicate_property_dict = predicate_property_dict
else:
w.predicate_property_dict = {}
(subject_set_uid,
optimised_subject_list) = catalog.getSubjectSetUid(document_w)
w.optimised_subject_list = optimised_subject_list
w.subject_set_uid = subject_set_uid
return ImplicitAcquisitionWrapper(w, aq_parent(document_object))
def getContent(self):
return ImplicitAcquisitionWrapper(ControlPanelAdapter(self.context),
self.context)
def vocabulary(self):
settings = IFeedSettings(self.context)
return ImplicitAcquisitionWrapper(interest_groups_factory, settings)
def __getattr__(self, name):
w, m, parent = self._ugh
self = m.__of__(ImplicitAcquisitionWrapper(w, parent))
return getattr(self, name)
