def login(self, forward_url=None, previous_url=None, *args, **kw):
if not identity.current.anonymous \
and identity.was_login_attempted() \
and not identity.get_identity_errors():
raise controllers.redirect(forward_url)
forward_url=None
previous_url= request.path
if identity.was_login_attempted():
msg=_("The credentials you supplied were not correct or "
"did not grant access to this resource.")
elif identity.get_identity_errors():
msg=_("You must provide your credentials before accessing "
"this resource.")
else:
msg=_("Please log in.")
site=get_current_site()
forward_url= request.headers.get("Referer", "/%s" % (site.name))
response.status=403
return dict(message=msg, previous_url=previous_url, logging_in=True,
original_parameters=request.params,
forward_url=forward_url)
def create_page(self, name, title, body):
page_name = name.replace(' ', '_')
site = get_current_site()
page = Pages(name=page_name,
title=title,
body=body,
site=site)
raise controllers.redirect(page_name)
def update_page(self, page_id, name, title, body):
page_name = name.replace(' ', '_')
page = Pages.get(page_id)
page.set(name=page_name,
title=title,
body=body)
raise controllers.redirect(page_name)
def default(self, name, *args, **kwargs):
site=get_current_site()
page = Pages.find_by_name(name=name,
site=site)
if page == None:
raise controllers.redirect('/new_page?name=' + name)
return dict(page=page,
site=site,
archive_posts= Posts.find_archive_count(site=site),
archives_widget=widgets.archives_widget,
tags_widget=widgets.tags_widget,
pages_widget=widgets.pages_widget,
pages=Pages.find_all(site=site),
tags=Tags.find_all(site=site),
admin_widget=widgets.admin_widget,
badge_widget=widgets.badge_widget,
recent_comments=Comments.find_recent(),
recent_comments_widget=widgets.recent_comments_widget)
def post(self, year, month, day, title):
permalink = '/'.join((year, month, day, title))
site=get_current_site()
try:
post = Posts.find_by_permalink(permalink=permalink, site=site)
except SQLObjectNotFound:
flash("Sorry, post could not be found!")
raise controllers.redirect('/')
return dict(post=post,
site=site,
comment_widget=widgets.comment_widget,
archive_posts= Posts.find_archive_count(site=site),
archives_widget=widgets.archives_widget,
tags_widget=widgets.tags_widget,
pages_widget=widgets.pages_widget,
pages=Pages.find_all(site=site),
tags=Tags.find_all(site=site),
admin_widget=widgets.admin_widget,
badge_widget=widgets.badge_widget,
recent_comments=Comments.find_recent(),
recent_comments_widget=widgets.recent_comments_widget)
def decorated(func, *args, **kw):
def kwpop(name, default=None):
return kw.pop(var_name + '_tgp_' + name,
kw.pop('tg_paginate_' + name, default))
page = kwpop('no')
if page is None:
page = 1
elif page == 'last':
page = None
else:
try:
page = int(page)
if page < 1:
raise ValueError
except (TypeError, ValueError):
page = 1
if get('paginate.redirect_on_out_of_range'):
cherrypy.request.params[var_name + '_tgp_no'] = page
redirect(cherrypy.request.path_info,
cherrypy.request.params)
try:
limit_ = int(kwpop('limit'))
if max_limit is not None and not (allow_limit_override
and max_limit == 0):
if max_limit <= 0:
raise ValueError
limit_ = min(limit_, max_limit)
except (TypeError, ValueError):
limit_ = limit
order = kwpop('order')
ordering = kwpop('ordering')
log.debug("paginate params: page=%s, limit=%s, order=%s", page,
limit_, order)
# get the output from the decorated function
output = func(*args, **kw)
if not isinstance(output, dict):
return output
try:
var_data = output[var_name]
except KeyError:
raise KeyError("paginate: var_name"
" (%s) not found in output dict" % var_name)
if not hasattr(var_data, '__getitem__') and callable(var_data):
# e.g. SQLAlchemy query class
var_data = var_data()
if not hasattr(var_data, '__getitem__'):
raise TypeError('Paginate variable is not a sequence')
if dynamic_limit:
try:
dyn_limit = output[dynamic_limit]
except KeyError:
raise KeyError("paginate: dynamic_limit"
" (%s) not found in output dict" %
dynamic_limit)
limit_ = dyn_limit
if ordering:
ordering = str(ordering).split(',')
else:
ordering = default_order or []
if isinstance(ordering, basestring):
# adapt old style default_order to new style
if default_reversed:
ordering = "-" + ordering
ordering = [ordering]
elif default_reversed:
raise ValueError(
"paginate: default_reversed (deprecated)"
" only allowed when default_order is a basestring")
if order:
order = str(order)
log.debug('paginate: ordering was %s, sort is %s', ordering,
order)
sort_ordering(ordering, order)
log.debug('paginate: ordering is %s', ordering)
try:
row_count = len(var_data)
except TypeError:
try: # SQL query
row_count = var_data.count() or 0
except AttributeError: # other iterator
var_data = list(var_data)
row_count = len(var_data)
if ordering:
var_data = sort_data(
var_data, ordering, max_sort is None
or 0 < row_count <= max_sort)
# If limit is zero then return all our rows
if not limit_:
limit_ = row_count or 1
page_count = int(ceil(float(row_count) / limit_))
if page is None:
page = max(page_count, 1)
if get('paginate.redirect_on_last_page'):
cherrypy.request.params[var_name + '_tgp_no'] = page
redirect(cherrypy.request.path_info,
cherrypy.request.params)
elif page > page_count:
page = max(page_count, 1)
if get('paginate.redirect_on_out_of_range'):
cherrypy.request.params[var_name + '_tgp_no'] = page
redirect(cherrypy.request.path_info,
cherrypy.request.params)
offset = (page - 1) * limit_
pages_to_show = _select_pages_to_show(page, page_count, max_pages)
# remove pagination parameters from request
input_values = variable_encode(cherrypy.request.params.copy())
input_values.pop('self', None)
for input_key in input_values.keys():
if (input_key.startswith(var_name + '_tgp_')
or input_key.startswith('tg_paginate_')):
del input_values[input_key]
paginate_instance = Paginate(current_page=page,
limit=limit_,
pages=pages_to_show,
page_count=page_count,
input_values=input_values,
order=order,
ordering=ordering,
row_count=row_count,
var_name=var_name)
cherrypy.request.paginate = paginate_instance
if not hasattr(cherrypy.request, 'paginates'):
cherrypy.request.paginates = dict()
cherrypy.request.paginates[var_name] = paginate_instance
# we replace the var with the sliced one
endpoint = offset + limit_
log.debug("paginate: slicing data between %d and %d", offset,
endpoint)
global _simulate_offset
if _simulate_offset is None:
_simulate_offset = get('paginate.simulate_offset', None)
if _simulate_offset is None:
_simulate_offset = False
so_db = get('sqlobject.dburi', 'NOMATCH:').split(':', 1)[0]
sa_db = get('sqlalchemy.dburi', 'NOMATCH:').split(':',
1)[0]
if so_db in _so_no_offset or sa_db in _sa_no_offset:
_simulate_offset = True
log.warning(
"paginate: simulating OFFSET,"
" paginate may be slow"
" (disable with paginate.simulate_offset=False)")
if _simulate_offset:
var_data = iter(var_data[:endpoint])
# skip over the number of records specified by offset
for i in xrange(offset):
var_data.next()
# return the records that remain
output[var_name] = list(var_data)
else:
try:
output[var_name] = var_data[offset:endpoint]
except TypeError:
for i in xrange(offset):
var_data.next()
output[var_name] = [
var_data.next() for i in xrange(offset, endpoint)
]
return output
def decorated(func, *args, **kw):
def kwpop(name, default=None):
return kw.pop(var_name + '_tgp_' + name,
kw.pop('tg_paginate_' + name, default))
page = kwpop('no')
if page is None:
page = 1
elif page == 'last':
page = None
else:
try:
page = int(page)
if page < 1:
raise ValueError
except (TypeError, ValueError):
page = 1
if get('paginate.redirect_on_out_of_range'):
cherrypy.request.params[var_name + '_tgp_no'] = page
redirect(cherrypy.request.path_info, cherrypy.request.params)
try:
limit_ = int(kwpop('limit'))
if max_limit is not None and not (
allow_limit_override and max_limit == 0):
if max_limit <= 0:
raise ValueError
limit_ = min(limit_, max_limit)
except (TypeError, ValueError):
limit_ = limit
order = kwpop('order')
ordering = kwpop('ordering')
log.debug("paginate params: page=%s, limit=%s, order=%s",
page, limit_, order)
# get the output from the decorated function
output = func(*args, **kw)
if not isinstance(output, dict):
return output
try:
var_data = output[var_name]
except KeyError:
raise KeyError("paginate: var_name"
" (%s) not found in output dict" % var_name)
if not hasattr(var_data, '__getitem__') and callable(var_data):
# e.g. SQLAlchemy query class
var_data = var_data()
if not hasattr(var_data, '__getitem__'):
raise TypeError('Paginate variable is not a sequence')
if dynamic_limit:
try:
dyn_limit = output[dynamic_limit]
except KeyError:
raise KeyError("paginate: dynamic_limit"
" (%s) not found in output dict" % dynamic_limit)
limit_ = dyn_limit
if ordering:
ordering = str(ordering).split(',')
else:
ordering = default_order or []
if isinstance(ordering, basestring):
# adapt old style default_order to new style
if default_reversed:
ordering = "-" + ordering
ordering = [ordering]
elif default_reversed:
raise ValueError("paginate: default_reversed (deprecated)"
" only allowed when default_order is a basestring")
if order:
order = str(order)
log.debug('paginate: ordering was %s, sort is %s',
ordering, order)
sort_ordering(ordering, order)
log.debug('paginate: ordering is %s', ordering)
try:
row_count = len(var_data)
except TypeError:
try: # SQL query
row_count = var_data.count() or 0
except AttributeError: # other iterator
var_data = list(var_data)
row_count = len(var_data)
if ordering:
var_data = sort_data(var_data, ordering,
max_sort is None or 0 < row_count <= max_sort)
# If limit is zero then return all our rows
if not limit_:
limit_ = row_count or 1
page_count = int(ceil(float(row_count)/limit_))
if page is None:
page = max(page_count, 1)
if get('paginate.redirect_on_last_page'):
cherrypy.request.params[var_name + '_tgp_no'] = page
redirect(cherrypy.request.path_info, cherrypy.request.params)
elif page > page_count:
page = max(page_count, 1)
if get('paginate.redirect_on_out_of_range'):
cherrypy.request.params[var_name + '_tgp_no'] = page
redirect(cherrypy.request.path_info, cherrypy.request.params)
offset = (page-1) * limit_
pages_to_show = _select_pages_to_show(page, page_count, max_pages)
# remove pagination parameters from request
input_values = variable_encode(cherrypy.request.params.copy())
input_values.pop('self', None)
for input_key in input_values.keys():
if (input_key.startswith(var_name + '_tgp_') or
input_key.startswith('tg_paginate_')):
del input_values[input_key]
paginate_instance = Paginate(
current_page=page,
limit=limit_,
pages=pages_to_show,
page_count=page_count,
input_values=input_values,
order=order,
ordering=ordering,
row_count=row_count,
var_name=var_name)
cherrypy.request.paginate = paginate_instance
if not hasattr(cherrypy.request, 'paginates'):
cherrypy.request.paginates = dict()
cherrypy.request.paginates[var_name] = paginate_instance
# we replace the var with the sliced one
endpoint = offset + limit_
log.debug("paginate: slicing data between %d and %d",
offset, endpoint)
global _simulate_offset
if _simulate_offset is None:
_simulate_offset = get('paginate.simulate_offset', None)
if _simulate_offset is None:
_simulate_offset = False
so_db = get('sqlobject.dburi', 'NOMATCH:').split(':', 1)[0]
sa_db = get('sqlalchemy.dburi', 'NOMATCH:').split(':', 1)[0]
if so_db in _so_no_offset or sa_db in _sa_no_offset:
_simulate_offset = True
log.warning("paginate: simulating OFFSET,"
" paginate may be slow"
" (disable with paginate.simulate_offset=False)")
if _simulate_offset:
var_data = iter(var_data[:endpoint])
# skip over the number of records specified by offset
for i in xrange(offset):
var_data.next()
# return the records that remain
output[var_name] = list(var_data)
else:
try:
output[var_name] = var_data[offset:endpoint]
except TypeError:
for i in xrange(offset):
var_data.next()
output[var_name] = [var_data.next()
for i in xrange(offset, endpoint)]
return output
def index(self, *args, **kw):
raise controllers.redirect(config.get('calabro.default_site'))
def redirect_to_users():
site = get_current_site()
raise controllers.redirect("/%s/users" % (site.name))
def redirect_to_site(site_name):
raise controllers.redirect("../../%s" % (site_name))
