def content(self):
records = []
for record in self.get_and_clear():
msg = record.getMessage()
if isinstance(msg, bytes):
msg = msg.decode('utf-8', 'ignore')
records.append({
'message':
msg,
'time':
datetime.datetime.fromtimestamp(record.created),
'level':
record.levelname,
'file':
format_fname(record.pathname),
'file_long':
record.pathname,
'line':
record.lineno,
})
records = reversed(records)
return unicode_text(
render(dict(records=records), tg.config['debugbar.engine'],
'tgext.debugbar.sections.templates.logging!html').split(
'\n', 1)[-1])
def content(self):
vars = odict()
request = tg.request._current_obj()
response = tg.response._current_obj()
attr_dict = request.environ.get("webob.adhoc_attrs", {}).copy()
attr_dict["response"] = repr(response.__dict__)
for entry in list(attr_dict.keys()):
if entry.startswith("tgdb_"):
del attr_dict[entry]
vars["GET"] = [(k, request.GET.getall(k)) for k in request.GET]
vars["POST"] = [(k, [saferepr(p) for p in request.POST.getall(k)]) for k in request.POST]
vars["Cookies"] = [(k, request.cookies.get(k)) for k in request.cookies]
vars["Headers"] = [
(k, saferepr(v)) for k, v in request.environ.items() if k.startswith("HTTP_") or k in request_header_filter
]
vars["Request Attributes"] = [(k, saferepr(v)) for k, v in attr_dict.items() if not callable(v)]
vars["Environ"] = [(k, saferepr(v)) for k, v in request.environ.items()]
return unicode_text(
render(
dict(vars=vars), tg.config["debugbar.engine"], "tgext.debugbar.sections.templates.request!html"
).split("\n", 1)[-1]
)
def content(self):
controllers = odict()
map_controllers('', get_root_controller(), controllers)
return unicode_text(
render(dict(controllers=controllers), tg.config['debugbar.engine'],
'tgext.debugbar.sections.templates.controllers!html').split(
'\n', 1)[-1])
def render_bars(self, response):
page = response.get('response')
if (not page or not isinstance(page, unicode_text)
or 'text/html' not in response['content_type'] or
request.headers.get('X-Requested-With') == 'XMLHttpRequest'):
if tg.config.get('debugbar.enable_logs', False):
for section in __sections__:
if hasattr(section, 'log_content'):
section.log_content()
return
pos_head = page.find('</head>')
if pos_head > 0:
pos_body = page.find('</body>', pos_head + 7)
if pos_body > 0:
response['response'] = ''.join([
page[:pos_head],
Markup(self.css_link % url(self.css_path)),
page[pos_head:pos_body],
Markup(
render(
dict(sections=__sections__),
tg.config['debugbar.engine'],
self.template,
).split('\n', 1)[-1]), page[pos_body:]
])
def content(self):
controllers = odict()
map_controllers('', get_root_controller(), controllers)
return unicode(render(
dict(controllers=controllers),
'genshi', 'tgext.debugbar.sections.templates.controllers'
).split('\n', 1)[-1])
def render_bars(self, response):
page = response.get('response')
if (not page or not isinstance(page, unicode_text)
or 'text/html' not in response['content_type']
or request.headers.get(
'X-Requested-With') == 'XMLHttpRequest'):
if config.get('debugbar.enable_logs', False):
for section in __sections__:
if hasattr(section, 'log_content'):
section.log_content()
return
pos_head = page.find('</head>')
if pos_head > 0:
pos_body = page.find('</body>', pos_head + 7)
if pos_body > 0:
response['response'] = ''.join(
[page[:pos_head],
Markup(self.css_link % url(self.css_path)),
page[pos_head:pos_body],
Markup(render(dict(sections=__sections__),
config['debugbar.engine'], self.template,).split('\n', 1)[-1]),
page[pos_body:]])
def content(self):
vars = odict()
request = tg.request._current_obj()
response = tg.response._current_obj()
attr_dict = request.environ['webob.adhoc_attrs'].copy()
attr_dict['response'] = repr(response.__dict__)
for entry in attr_dict.keys():
if entry.startswith('tgdb_'):
del attr_dict[entry]
vars['GET'] = [(k, request.GET.getall(k)) for k in request.GET]
vars['POST'] = [(k, [saferepr(p)
for p in request.POST.getall(k)]) for k in request.POST]
vars['Cookies'] = [(k, request.cookies.get(k))
for k in request.cookies]
vars['Headers'] = [(k, saferepr(v))
for k, v in request.environ.iteritems()
if k.startswith('HTTP_') or k in request_header_filter]
vars['Request Attributes'] = [(k, saferepr(v))
for k, v in attr_dict.iteritems() if not callable(v)]
vars['Environ'] = [(k, saferepr(v))
for k, v in request.environ.iteritems()]
return unicode(render(
dict(vars=vars),
'genshi', 'tgext.debugbar.sections.templates.request'
).split('\n', 1)[-1])
def content(self):
data = self._gather_queries()
if not data:
return 'No queries in executed by the controller.'
return unicode(render(dict(queries=data, tg=tg),
'genshi', 'tgext.debugbar.sections.templates.sqla').split('\n', 1)[-1])
def content(self):
vars = odict()
request = tg.request._current_obj()
response = tg.response._current_obj()
attr_dict = request.environ.get('webob.adhoc_attrs', {}).copy()
attr_dict['response'] = repr(response.__dict__)
for entry in list(attr_dict.keys()):
if entry.startswith('tgdb_'):
del attr_dict[entry]
vars['GET'] = [(k, request.GET.getall(k)) for k in request.GET]
vars['POST'] = [(k, [saferepr(p) for p in request.POST.getall(k)])
for k in request.POST]
vars['Cookies'] = [(k, request.cookies.get(k))
for k in request.cookies]
vars['Headers'] = [
(k, saferepr(v)) for k, v in request.environ.items()
if k.startswith('HTTP_') or k in request_header_filter
]
vars['Request Attributes'] = [(k, saferepr(v))
for k, v in attr_dict.items()
if not callable(v)]
vars['Environ'] = [(k, saferepr(v))
for k, v in request.environ.items()]
return unicode_text(
render(dict(vars=vars), tg.config['debugbar.engine'],
'tgext.debugbar.sections.templates.request!html').split(
'\n', 1)[-1])
def content(self):
queries = getattr(request, 'tgdb_sqla_queries', [])
if not queries:
return 'No queries in executed by the controller.'
data = []
for query in queries:
is_select = query['statement'].strip().lower().startswith('select')
params = ''
try:
params = json.dumps(query['parameters'])
except TypeError:
return 'Unable to serialize parameters of the query'
data.append({
'engine_id': query['engine_id'],
'duration': query['duration'],
'sql': format_sql(query['statement']),
'raw_sql': query['statement'],
'params': params,
'is_select': is_select,
'context': query['context'],
})
delattr(request, 'tgdb_sqla_queries')
return unicode(render(
dict(queries=data, tg=tg),
'genshi', 'tgext.debugbar.sections.templates.sqla'
).split('\n', 1)[-1])
def content(self):
controllers = odict()
map_controllers("", get_root_controller(), controllers)
return unicode_text(
render(
dict(controllers=controllers),
tg.config["debugbar.engine"],
"tgext.debugbar.sections.templates.controllers!html",
).split("\n", 1)[-1]
)
def vcard(self, uid=None):
user = get_user_or_default_user(uid)
enc = Encoder()
vcf = render.render({'user':user}, template_engine='vcard', template_name='hiringpond.templates.vcard')
data = enc.encode(vcf, {'ec_level': 3})
#data = pyqrcode.MakeQRImage()
buff = StringIO()
data.save(buff, 'png')
img = buff.getvalue()
buff.close()
return img
def content(self):
data = self._gather_queries()
if not data:
return 'No queries in executed by the controller.'
if isinstance(data, str):
return data
return unicode_text(render(dict(queries=data, tg=tg),
config['debugbar.engine'],
'tgext.debugbar.sections.templates.sqla!html').split('\n', 1)[-1])
def content(self):
inventing_enabled = asbool(config.get('debugbar.inventing', 'false'))
inventing_enabled = getattr(tmpl_context, 'debugbar_inventing', inventing_enabled)
result = u''
result += Markup(self.js_reloadscript)
if inventing_enabled:
result += Markup('<script>tgext_debugbar_init_inventing()</script>')
result += render(dict(enabled=inventing_enabled),
'genshi', 'tgext.debugbar.sections.templates.inventing')
return result
def content(self):
data = self._gather_queries()
if not data:
return 'No queries in executed by the controller.'
if isinstance(data, str):
return data
return unicode_text(
render(dict(queries=data, tg=tg), config['debugbar.engine'],
'tgext.debugbar.sections.templates.sqla!html').split(
'\n', 1)[-1])
def render_widget(mount_point, widget_name):
app = c.project.app_instance(mount_point)
method = getattr(app.widget(app), widget_name)
with push_config(c, app=app):
result = method()
if isinstance(result, dict):
deco = Decoration.get_decoration(method)
content_type, engine, template, exclude_names = \
deco.lookup_template_engine(request)
template_vars = dict((k,v) for k,v in result.iteritems()
if k not in exclude_names)
return render(template_vars, engine, template)
return result
def vcard(self, uid=None):
user = get_user_or_default_user(uid)
enc = Encoder()
vcf = render.render({'user': user},
template_engine='vcard',
template_name='hiringpond.templates.vcard')
data = enc.encode(vcf, {'ec_level': 3})
#data = pyqrcode.MakeQRImage()
buff = StringIO()
data.save(buff, 'png')
img = buff.getvalue()
buff.close()
return img
def content(self):
inventing_enabled = asbool(config.get('debugbar.inventing', 'false'))
inventing_enabled = getattr(tmpl_context, 'debugbar_inventing', inventing_enabled)
result = u''
result += render(dict(), config['debugbar.engine'],
'tgext.debugbar.sections.templates.inventing!html')
result += Markup(self.js_reloadscript)
if inventing_enabled:
result += Markup('<script>tgext_debugbar_inventing.init(true)</script>')
else:
result += Markup('<script>tgext_debugbar_inventing.init(false)</script>')
return result
def content(self):
records = []
for record in self.get_and_clear():
records.append({
'message': record.getMessage().decode('utf-8', 'ignore'),
'time': datetime.datetime.fromtimestamp(record.created),
'level': record.levelname,
'file': format_fname(record.pathname),
'file_long': record.pathname,
'line': record.lineno,
})
records = reversed(records)
return unicode(render(
dict(records=records),
'genshi', 'tgext.debugbar.sections.templates.logging'
).split('\n', 1)[-1])
def render_bars(self, response):
page = response.get('response')
if (not page or not isinstance(page, unicode)
or 'text/html' not in response['content_type']
or request.headers.get(
'X-Requested-With') == 'XMLHttpRequest'):
return
pos_head = page.find('</head>')
if pos_head > 0:
pos_body = page.find('</body>', pos_head + 7)
if pos_body > 0:
response['response'] = ''.join(
[page[:pos_head],
literal(self.css_link % url(self.css_path)),
page[pos_head:pos_body],
literal(render(dict(sections=__sections__),
'genshi', self.template,).split('\n', 1)[-1]),
page[pos_body:]])
def render_invalid_integrity_chosen_path(invalid_label: str) -> str:
"""
Return html page code of error about invalid label choice.
:param invalid_label: the invalid label
:return: html page code
"""
user = tmpl_context.current_user
fake_api_content = DictLikeClass(current_user=user, )
fake_api = Context(CTX.USER).toDict(fake_api_content)
return render(
template_vars=dict(
invalid_label=invalid_label,
fake_api=fake_api,
),
template_engine='mako',
template_name='tracim.templates.errors.label_invalid_path',
)
def content(self):
inventing_enabled = asbool(config.get('debugbar.inventing', 'false'))
inventing_enabled = getattr(tmpl_context, 'debugbar_inventing',
inventing_enabled)
result = u''
result += render(dict(), config['debugbar.engine'],
'tgext.debugbar.sections.templates.inventing!html')
result += Markup(self.js_reloadscript)
if inventing_enabled:
result += Markup(
'<script>tgext_debugbar_inventing.init(true)</script>')
else:
result += Markup(
'<script>tgext_debugbar_inventing.init(false)</script>')
return result
def reconfirm_auth(func, *args, **kwargs):
'''
A decorator to require the user to reconfirm their login. Useful for sensitive pages.
'''
from allura.lib.plugin import AuthenticationProvider
if request.POST.get('password'):
if AuthenticationProvider.get(request).validate_password(c.user, request.POST['password']):
session['auth-reconfirmed'] = datetime.utcnow()
session.save()
kwargs.pop('password', None)
else:
c.form_errors['password'] = '******'
allowed_timedelta = timedelta(seconds=asint(config.get('auth.reconfirm.seconds', 60)))
last_reconfirm = session.get('auth-reconfirmed', datetime.min)
if datetime.utcnow() - last_reconfirm <= allowed_timedelta:
return func(*args, **kwargs)
else:
return render({}, 'jinja', "allura:templates/reconfirm_auth.html")
def content(self):
records = []
for record in self.get_and_clear():
msg = record.getMessage()
if isinstance(msg, bytes):
msg = msg.decode('utf-8', 'ignore')
records.append({
'message': msg,
'time': datetime.datetime.fromtimestamp(record.created),
'level': record.levelname,
'file': format_fname(record.pathname),
'file_long': record.pathname,
'line': record.lineno,
})
records = reversed(records)
return unicode_text(render(
dict(records=records),
tg.config['debugbar.engine'], 'tgext.debugbar.sections.templates.logging!html'
).split('\n', 1)[-1])
def reconfirm_auth(func, *args, **kwargs):
'''
A decorator to require the user to reconfirm their login. Useful for sensitive pages.
'''
from allura.lib.plugin import AuthenticationProvider
if request.POST.get('password'):
if AuthenticationProvider.get(request).validate_password(c.user, request.POST['password']):
session['auth-reconfirmed'] = datetime.utcnow()
session.save()
kwargs.pop('password', None)
else:
c.form_errors['password'] = '******'
allowed_timedelta = timedelta(seconds=asint(config.get('auth.reconfirm.seconds', 60)))
last_reconfirm = session.get('auth-reconfirmed', datetime.min)
if datetime.utcnow() - last_reconfirm <= allowed_timedelta:
return func(*args, **kwargs)
else:
return render({}, 'jinja', "allura:templates/reconfirm_auth.html")
def render_invalid_integrity_chosen_path(invalid_label: str) -> str:
"""
Return html page code of error about invalid label choice.
:param invalid_label: the invalid label
:return: html page code
"""
user = tmpl_context.current_user
fake_api_content = DictLikeClass(
current_user=user,
)
fake_api = Context(CTX.USER).toDict(fake_api_content)
return render(
template_vars=dict(
invalid_label=invalid_label,
fake_api=fake_api,
),
template_engine='mako',
template_name='tracim.templates.errors.label_invalid_path',
)
def content(self):
queries = getattr(request, 'tgdb_ming_cursors', [])
if not queries:
return 'No queries in executed by the controller.'
data = []
for query in queries.values():
params = json.dumps(query['params'], default=json_util.default)
data.append({
'duration': query['duration'],
'command': query['command'],
'collection': query['collection'],
'filter': format_json(params),
'params': params
})
delattr(request, 'tgdb_ming_cursors')
return unicode_text(render(
dict(queries=data, tg=tg),
config['debugbar.engine'], 'tgext.debugbar.sections.templates.ming!html'
).split('\n', 1)[-1])
def content(self):
queries = getattr(request, 'tgdb_ming_cursors', [])
if not queries:
return 'No queries in executed by the controller.'
data = []
for query in queries.values():
params = json.dumps(query['params'], default=json_util.default)
data.append({
'duration': query['duration'],
'command': query['command'],
'collection': query['collection'],
'filter': format_json(params),
'params': params
})
delattr(request, 'tgdb_ming_cursors')
return unicode_text(
render(dict(queries=data, tg=tg), config['debugbar.engine'],
'tgext.debugbar.sections.templates.ming!html').split(
'\n', 1)[-1])
def content(self):
try:
return unicode_text(render(dict(
render_info=request.tgdb_render_info,
stats=request.tgdb_profiling_stats,
function_calls=request.tgdb_profiling_function_calls,
render_calls=request.tgdb_render_calls,
vars={'Total Time': request.tgdb_total_time,
'Controller Time': request.tgdb_call_time,
'Render Time': request.tgdb_render_time}),
config['debugbar.engine'], 'tgext.debugbar.sections.templates.timing!html'
).split('\n', 1)[-1])
finally:
delattr(request, 'tgdb_render_info')
delattr(request, 'tgdb_call_start_time')
delattr(request, 'tgdb_call_time')
delattr(request, 'tgdb_render_start_time')
delattr(request, 'tgdb_render_call_start_time')
delattr(request, 'tgdb_render_calls')
delattr(request, 'tgdb_total_time')
delattr(request, 'tgdb_render_time')
delattr(request, 'tgdb_profiling_stats')
delattr(request, 'tgdb_profiling_function_calls')
def content(self):
try:
return unicode(render(dict(
render_info=request.tgdb_render_info,
stats=request.tgdb_profiling_stats,
function_calls=request.tgdb_profiling_function_calls,
render_calls=request.tgdb_render_calls,
vars={'Total Time': request.tgdb_total_time,
'Controller Time': request.tgdb_call_time,
'Render Time': request.tgdb_render_time}),
'genshi', 'tgext.debugbar.sections.templates.timing'
).split('\n', 1)[-1])
finally:
delattr(request, 'tgdb_render_info')
delattr(request, 'tgdb_call_start_time')
delattr(request, 'tgdb_call_time')
delattr(request, 'tgdb_render_start_time')
delattr(request, 'tgdb_render_call_start_time')
delattr(request, 'tgdb_render_calls')
delattr(request, 'tgdb_total_time')
delattr(request, 'tgdb_render_time')
delattr(request, 'tgdb_profiling_stats')
delattr(request, 'tgdb_profiling_function_calls')
def test_render_missing_renderer():
render({}, 'gensh')
def test_render_missing_renderer():
render({}, 'gensh')
def jinja2_manual_rendering(self, frompylons=False):
if frompylons:
from pylons.templating import render_jinja2
return render_jinja2('jinja_inherits.html')
else:
return render({}, 'jinja', 'jinja_inherits.html')
def send_template(self, to=None, subject=None, template=None, **kwargs):
self.send(to=to, subject=subject, body=render(kwargs, template_name=template))
def genshi_manual_rendering_with_doctype(self, doctype=None):
response.content_type = 'text/html'
response.charset = 'utf-8'
return render({}, 'genshi', 'genshi_doctype.html', doctype=doctype)
