def __call__(self, client=None, REQUEST={}, RESPONSE=None, **kw):
"""Render the document with the given client object.
o If supplied, use REQUEST mapping, Response, and key word arguments.
"""
if not self._cache_namespace_keys:
data = self.ZCacheable_get(default=_marker)
if data is not _marker:
# Return cached results.
return data
__traceback_supplement__ = (PathTracebackSupplement, self)
kw['document_id'] = self.getId()
kw['document_title'] = self.title
if hasattr(self, 'aq_explicit'):
bself = self.aq_explicit
else:
bself = self
security = getSecurityManager()
security.addContext(self)
try:
if client is None:
# Called as subtemplate, so don't need error propagation!
r = HTML.__call__(self, bself, REQUEST, **kw)
if RESPONSE is None:
result = r
else:
result = decapitate(r, RESPONSE)
if not self._cache_namespace_keys:
self.ZCacheable_set(result)
return result
r = HTML.__call__(self, (client, bself), REQUEST, **kw)
if RESPONSE is None or not isinstance(r, str):
if not self._cache_namespace_keys:
self.ZCacheable_set(r)
return r
finally:
security.removeContext(self)
have_key = RESPONSE.headers.__contains__
if not (have_key('content-type') or have_key('Content-Type')):
if 'content_type' in self.__dict__:
c = self.content_type
else:
encoding = getattr(self, 'encoding', default_encoding)
if six.PY2 and not isinstance(r, six.text_type):
# Prevent double-encoding edge cases under Python 2
r = r.decode(encoding)
c, e = guess_content_type(self.getId(), r.encode(encoding))
RESPONSE.setHeader('Content-Type', c)
result = decapitate(r, RESPONSE)
if not self._cache_namespace_keys:
self.ZCacheable_set(result)
return result
def __call__(self, client=None, REQUEST={}, RESPONSE=None, **kw):
"""Render the DTML given a client object, REQUEST mapping,
Response, and key word arguments."""
security=getSecurityManager()
security.addContext(self)
try:
return HTML.__call__(self, client, REQUEST, **kw)
finally: security.removeContext(self)
def __call__(self, client=None, REQUEST={}, RESPONSE=None, **kw):
"""Render the document given a client object, REQUEST mapping,
Response, and key word arguments."""
self._updateFromFS()
kw['document_id'] =self.getId()
kw['document_title']=self.title
if client is not None:
if _checkConditionalGET(self, kw):
return ''
if not self._cache_namespace_keys:
data = self.ZCacheable_get(default=_marker)
if data is not _marker:
# Return cached results.
return data
__traceback_info__ = self._filepath
security=getSecurityManager()
security.addContext(self)
try:
r = HTML.__call__(self, client, REQUEST, **kw)
if client is None:
# Called as subtemplate, so don't need error propagation!
if RESPONSE is None: result = r
else: result = decapitate(r, RESPONSE)
if not self._cache_namespace_keys:
self.ZCacheable_set(result)
return result
if not isinstance(r, basestring) or RESPONSE is None:
if not self._cache_namespace_keys:
self.ZCacheable_set(r)
return r
finally: security.removeContext(self)
have_key=RESPONSE.headers.has_key
if not (have_key('content-type') or have_key('Content-Type')):
if self.__dict__.has_key('content_type'):
c=self.content_type
else:
c, e=guess_content_type(self.getId(), r)
RESPONSE.setHeader('Content-Type', c)
if RESPONSE is not None:
# caching policy manager hook
_setCacheHeaders(self, {})
result = decapitate(r, RESPONSE)
if not self._cache_namespace_keys:
self.ZCacheable_set(result)
return result
def raise_standardErrorMessage(
self, client=None, REQUEST={},
error_type=None, error_value=None, tb=None,
error_tb=None, error_message='',
tagSearch=re.compile(r'[a-zA-Z]>').search,
error_log_url=''):
try:
if error_type is None: error_type =sys.exc_info()[0]
if error_value is None: error_value=sys.exc_info()[1]
# allow for a few different traceback options
if tb is None and error_tb is None:
tb=sys.exc_info()[2]
if type(tb) is not type('') and (error_tb is None):
error_tb = pretty_tb(error_type, error_value, tb)
elif type(tb) is type('') and not error_tb:
error_tb = tb
if hasattr(self, '_v_eek'):
# Stop if there is recursion.
raise error_type, error_value, tb
self._v_eek = 1
if hasattr(error_type, '__name__'):
error_name = error_type.__name__
else:
error_name = 'Unknown'
if not error_message:
try:
s = ustr(error_value)
except:
s = error_value
try:
match = tagSearch(s)
except TypeError:
match = None
if match is not None:
error_message=error_value
if client is None:
client = self
if not REQUEST:
REQUEST = aq_acquire(self, 'REQUEST')
try:
s = aq_acquire(client, 'standard_error_message')
# For backward compatibility, we pass 'error_name' as
# 'error_type' here as historically this has always
# been a string.
kwargs = {'error_type': error_name,
'error_value': error_value,
'error_tb': error_tb,
'error_traceback': error_tb,
'error_message': error_message,
'error_log_url': error_log_url}
if getattr(aq_base(s), 'isDocTemp', 0):
v = s(client, REQUEST, **kwargs)
elif callable(s):
v = s(**kwargs)
else:
v = HTML.__call__(s, client, REQUEST, **kwargs)
except:
logger.error(
'Exception while rendering an error message',
exc_info=True
)
try:
strv = repr(error_value) # quotes tainted strings
except:
strv = ('<unprintable %s object>' %
str(type(error_value).__name__))
v = strv + (
(" (Also, the following error occurred while attempting "
"to render the standard error message, please see the "
"event log for full details: %s)")%(
html_quote(sys.exc_info()[1]),
))
# If we've been asked to handle errors, just return the rendered
# exception and let the ZPublisher Exception Hook deal with it.
return error_type, v, tb
finally:
if hasattr(self, '_v_eek'): del self._v_eek
tb = None
