def votes(self, id, format='html'):
c.poll = get_entity_or_abort(model.Poll, id)
# cover over data inconsistency because of a bug where pages (norms)
# were deleted when a proposal was deleted.
# Fixes http://trac.adhocracy.de/ticket/262
if (c.poll.action == model.Poll.SELECT and
c.poll.selection is None):
logmsg = ('Poll: "%s" is a model.Poll.rate poll, which should '
'have a selection, but the selection is None. Subject '
'of the Poll is %s') % (c.poll, c.poll.subject)
log.error(logmsg)
raise abort(404)
require.poll.show(c.poll)
decisions = democracy.Decision.for_poll(c.poll)
if (hasattr(self, 'form_result') and
self.form_result.get('result') is not None):
result_form = self.form_result.get('result')
decisions = filter(lambda d: d.result == result_form, decisions)
c.decisions_pager = pager.scope_decisions(decisions)
if format == 'json':
return render_json(c.decisions_pager)
elif format == 'ajax':
return render_def('/pager.html', 'overlay_pager',
pager=c.decisions_pager,
render_facets=False)
elif format == 'overlay':
return render("/poll/votes.html", overlay=True)
else:
return render("/poll/votes.html")
def show(self, id, format='html'):
c.tag = get_entity_or_abort(model.Tag, id)
require.tag.show(c.tag)
require.proposal.index()
require.page.index()
if format == 'json':
return render_json(c.tag)
entities = libsearch.query.run(u'tag:' + c.tag.name,
instance=c.instance)
entities = [e for e in entities if (isinstance(e, model.Proposal) or
isinstance(e, model.Page))]
c.entities_pager = NamedPager(
'entities', entities, tiles.dispatch_row,
sorts={_("oldest"): sorting.entity_oldest,
_("newest"): sorting.entity_newest,
_("alphabetically"): sorting.delegateable_title,
_("relevance"): sorting.entity_stable},
default_sort=sorting.entity_stable,
q=c.query)
tags = model.Tag.similar_tags(c.tag, limit=50)
c.cloud_tags = sorted(h.tag.tag_cloud_normalize(tags),
key=lambda (k, c, v): k.name)
if format == 'overlay':
return render("/tag/show.html", overlay=True)
else:
return render("/tag/show.html")
def all(self, format="html"):
if c.instance is None:
require.perm("event.index_all")
events = (
model.Event.all_q(
instance=c.instance, include_hidden=False, event_filter=request.params.getall("event_filter")
)
.order_by(model.Event.time.desc())
.limit(min(int(request.params.get("count", 50)), 100))
.all()
)
if format == "rss":
return event.rss_feed(
events, _("%s News" % h.site.name()), h.base_url(instance=None), _("News from %s") % h.site.name()
)
elif format == "ajax":
query_params = request.params.copy()
while True:
try:
query_params.pop("count")
except KeyError:
break
more_url = h.base_url(instance=c.instance, member="event/all", query_params=query_params)
return render_def("/event/tiles.html", "carousel", events=events, more_url=more_url)
else:
c.event_pager = pager.events(events, count=50)
if format == "overlay":
return render("/event/all.html", overlay=True, overlay_size=OVERLAY_SMALL)
else:
return render("/event/all.html")
def all(self, format='html'):
events = model.Event.all_q(
include_hidden=False,
event_filter=request.params.getall('event_filter'))\
.order_by(model.Event.time.desc())\
.limit(min(int(request.params.get('count', 50)), 100)).all()
if format == 'rss':
return event.rss_feed(events,
_('%s News' % h.site.name()),
h.base_url(instance=None),
_("News from %s") % h.site.name())
elif format == 'ajax':
query_params = request.params.copy()
while True:
try:
query_params.pop('count')
except KeyError:
break
more_url = h.base_url(instance=None,
member='event/all',
query_params=query_params)
return render_def('/event/tiles.html', 'carousel',
events=events, more_url=more_url)
else:
c.event_pager = pager.events(events, count=50)
if format == 'overlay':
return render('/event/all.html', overlay=True,
overlay_size=OVERLAY_SMALL)
else:
return render('/event/all.html')
def show(self, id, format='html'):
c.delegation = get_entity_or_abort(model.Delegation, id)
require.delegation.show(c.delegation)
c.scope = c.delegation.scope
decisions = democracy.Decision.for_user(c.delegation.principal,
c.instance)
decisions = filter(lambda d: c.delegation in d.delegations, decisions)
decisions = filter(
lambda d: isinstance(d.poll.subject, model.Proposal), decisions)
c.decisions_pager = pager.NamedPager(
'decisions',
decisions,
tiles.decision.user_row,
sorts={
_("oldest"): sorting.entity_oldest,
_("newest"): sorting.entity_newest
},
default_sort=sorting.entity_newest)
if format == 'json':
return render_json((c.delegation, c.decisions_pager))
elif format == 'overlay':
return render("delegation/show.html", overlay=True)
else:
return render("delegation/show.html")
def details(self, proposal_id, selection_id, format='html'):
'''
'''
selection = get_entity_or_abort(model.Selection, selection_id)
proposal = get_entity_or_abort(model.Proposal, proposal_id)
if selection.proposal is not proposal:
ret_abort(_('Page not Found'), code=404)
c.page = selection.page
variant_polls = dict(selection.variant_polls)
variant_to_show = selection.selected
if not variant_to_show:
variant_to_show = model.Text.HEAD
variant_items = PageController.variant_items(c.page,
selection=selection)
get_score = lambda item: \
selection.variant_poll(item['variant']).tally.score
c.variant_items = PageController.insert_variant_score_and_sort(
variant_items, get_score)
c.variant_details = PageController.variant_details(
c.page, variant_to_show)
c.variant_details_json = json.dumps(c.variant_details, indent=4)
c.selection_details = PageController.selection_urls(selection)
c.selection_details_json = json.dumps(c.selection_details, indent=4)
c.current_variant_poll = variant_polls[variant_to_show]
c.selection = selection
if format == 'overlay':
return render('/proposal/details.html', overlay=True)
return render('/proposal/details.html')
def index(self, format='html'):
if c.instance:
redirect(h.entity_url(c.instance))
if format == 'rss':
return EventController().all(format='rss')
name = config.get('adhocracy.redirect_startpage_to_instance')
if name != u'':
# get_entity_or_abort does no work for instances
instance = model.Instance.find(name)
if instance is not None:
redirect(h.entity_url(instance))
data = {}
instances_in_root = config.get_int(
'adhocracy.startpage.instances.list_length')
if instances_in_root > 0:
data['instances'] = model.Instance.all(limit=instances_in_root)
elif instances_in_root == -1:
data['instances'] = model.Instance.all()
add_static_content(data, u'adhocracy.static_index_path')
c.body_css_classes += data.get('css_classes', [])
c.body_css_classes.append('added_static_content')
if data['title'] is None:
data['title'] = config.get('adhocracy.site.name')
proposals_number = config.get_int(
'adhocracy.startpage.proposals.list_length')
if proposals_number > 0:
proposals = model.Proposal.all_q()\
.join(model.Instance).filter(not_(
model.Instance.key.in_(model.Instance.SPECIAL_KEYS)))\
.order_by(model.Proposal.create_time.desc())
data['new_proposals_pager'] = pager.proposals(
proposals, size=proposals_number,
default_sort=sorting.entity_newest,
enable_pages=False,
enable_sorts=False)
else:
data['new_proposals_pager'] = None
if config.get_bool('adhocracy.show_stats_on_frontpage'):
data['stats_global'] = {
"members": model.User.all_q().count(),
"comments": model.Comment.all_q().count(),
"proposals": model.Proposal.all_q().count(),
"votes": model.Vote.all_q().count(),
}
if format == 'overlay':
return render('index.html', data, overlay=True)
else:
return render('index.html', data)
def index(self, format='html'):
tags = model.Tag.popular_tags(limit=500)
if format == 'json':
return render_json(tags)
c.tags = sorted(h.tag.tag_cloud_normalize(tags),
key=lambda (k, c, v): k.name.lower())
if format == 'overlay':
return render("/tag/index.html", overlay=True)
else:
return render("/tag/index.html")
def serve(self, page_name, format='html'):
begin_time = time()
c.static = StaticPage(page_name)
if not c.static.exists:
abort(404, _('The requested page was not found'))
if format == 'simple':
ret = render('/plain_doc.html')
else:
ret = render('/template_doc.html')
ms = (time() - begin_time) * 1000
log.debug("Rendering static %s took %sms" % (page_name, ms))
return ret
def serve(self, page_name, format='html'):
begin_time = time()
c.static = StaticPage(page_name)
if not c.static.exists:
abort(404, _('The requested page was not found'))
if format == 'simple':
ret = render('/plain_doc.html')
else:
ret = render('/template_doc.html')
ms = (time() - begin_time) * 1000
log.debug("Rendering static %s took %sms" % (page_name, ms))
return ret
def edit(self, id, format='html'):
c.comment = get_entity_or_abort(model.Comment, id)
require.comment.edit(c.comment)
extra_vars = {'comment': c.comment}
if c.came_from != u'':
extra_vars[u'came_from'] = c.came_from
if format == 'ajax':
return render_def('/comment/tiles.html', 'edit_form',
extra_vars=extra_vars)
elif format == 'overlay':
return render('/comment/edit.html', overlay=True)
else:
return render('/comment/edit.html')
def _failure(self, openid, message):
"""
Abort an OpenID authenication attempt and return to login page,
giving an error message at the openid field.
"""
log.info("OpenID: %s - Error: %s" % (openid, message))
if c.user:
h.flash(message, "error")
return redirect(h.entity_url(c.user, member="settings/login"))
else:
loginhtml = render("/user/login_tile.html")
form = formencode.htmlfill.render(loginhtml, defaults={"openid": openid}, errors={"openid": message})
return render("/user/login.html", {"login_form_code": form})
def serve(self, key, format='html'):
page = get_static_page(key)
if page is None:
return abort(404, _('The requested page was not found'))
data = {
'static': page,
'active_global_nav': key,
}
if format == 'simple':
ret = render('/plain_doc.html', data)
else:
ret = render('/template_doc.html', data)
return ret
def edit(self, id, format='html'):
c.comment = get_entity_or_abort(model.Comment, id)
require.comment.edit(c.comment)
extra_vars = {'comment': c.comment}
if c.came_from != u'':
extra_vars[u'came_from'] = c.came_from
if format == 'ajax':
return render_def('/comment/tiles.html',
'edit_form',
extra_vars=extra_vars)
elif format == 'overlay':
return render('/comment/edit.html', overlay=True)
else:
return render('/comment/edit.html')
def index(self, format="html"):
c.active_global_nav = 'instances'
include_hidden = h.has_permission('global.admin')
c.instance_pager = pager.solr_instance_pager(include_hidden)
if format == 'json':
return render_json(c.instance_pager)
c.tile = tiles.instance.InstanceTile(c.instance)
if format == 'overlay':
return render("/instance/index.html", overlay=True)
else:
return render("/instance/index.html")
def _failure(self, openid, message):
"""
Abort an OpenID authenication attempt and return to login page,
giving an error message at the openid field.
"""
log.info("OpenID: %s - Error: %s" % (openid, message))
if c.user:
h.flash(message, 'error')
return redirect(h.entity_url(c.user, member='settings/login'))
else:
loginhtml = render("/user/login_tile.html")
form = formencode.htmlfill.render(loginhtml,
defaults={'openid': openid},
errors={'openid': message})
return render('/user/login.html', {'login_form_code': form})
def settings_voting_form(self, id):
c.page_instance = self._get_current_instance(id)
c.settings_menu = self.settings_menu(c.page_instance, 'voting')
c.delay_options = []
for delay in ((0, _("No delay")), (1, _("1 Day")), (2, _("2 Days")),
(7, _("One Week")), (14, _("Two Weeks")),
(28, _("Four Weeks"))):
c.delay_options.append({
'value':
delay[0],
'label':
h.literal(delay[1]),
'selected':
c.page_instance.activation_delay == delay[0]
})
c.majority_options = []
for majority in ((0.5, _("A simple majority (½ of vote)")),
(0.66, _("A two-thirds majority"))):
c.majority_options.append({
'value':
majority[0],
'label':
h.literal(majority[1]),
'selected':
c.page_instance.required_majority == majority[0]
})
return render("/instance/settings_voting.html")
def user_import_form(self, errors=None, format="html"):
return formencode.htmlfill.render(
render("/admin/userimport_form.html", {}, overlay=format == "overlay"),
defaults=dict(request.params),
errors=errors,
force_defaults=False,
)
def settings_general_form(self, id):
c.page_instance = self._get_current_instance(id)
c.settings_menu = self.settings_menu(c.page_instance, 'general')
c.locales = []
for locale in i18n.LOCALES:
c.locales.append({
'value': str(locale),
'label': locale.display_name,
'selected': locale == c.page_instance.locale
})
c.default_group_options = []
c.default_group = (c.page_instance.default_group.code
if c.page_instance.default_group else
model.Group.INSTANCE_DEFAULT)
for groupname in model.Group.INSTANCE_GROUPS:
group = model.Group.by_code(groupname)
c.default_group_options.append({
'value':
group.code,
'label':
h.literal(_(group.group_name)),
'selected':
group.code == c.default_group
})
rendered = render("/instance/settings_general.html")
return rendered
def edit(self, id):
c.page_user = get_entity_or_abort(model.User, id,
instance_filter=False)
require.user.edit(c.page_user)
c.locales = i18n.LOCALES
c.tile = tiles.user.UserTile(c.page_user)
return render("/user/edit.html")
def add(self, errors=None):
c.form_title = c.save_button = _("Add Badge")
c.action_url = self.base_url + '/add'
c.groups = meta.Session.query(Group).order_by(Group.group_name).all()
return htmlfill.render(render("/badge/form.html"),
defaults=dict(request.params),
errors=errors)
def preview(self, subject, body, recipients, sender_email, sender_name,
instance, include_footer):
recipients_list = sorted(list(recipients), key=lambda r: r.name)
if recipients_list:
try:
rendered_body = render_body(body, recipients_list[0],
is_preview=True)
except (KeyError, ValueError) as e:
rendered_body = _('Could not render message: %s') % str(e)
else:
rendered_body = body
# wrap body, but leave long words (e.g. links) intact
rendered_body = u'\n'.join(textwrap.fill(line, break_long_words=False)
for line in rendered_body.split(u'\n'))
data = {
'sender_email': sender_email,
'sender_name': sender_name,
'subject': subject,
'body': rendered_body,
'recipients': recipients_list,
'recipients_count': len(recipients_list),
'params': request.params,
'include_footer': include_footer,
'instance': instance,
}
return render('/massmessage/preview.html', data)
def settings_general_form(self, id):
c.page_instance = self._get_current_instance(id)
c.settings_menu = self.settings_menu(c.page_instance, "general")
c.locales = []
for locale in i18n.LOCALES:
c.locales.append(
{"value": str(locale), "label": locale.display_name, "selected": locale == c.page_instance.locale}
)
c.default_group_options = []
c.default_group = (
c.page_instance.default_group.code if c.page_instance.default_group else model.Group.INSTANCE_DEFAULT
)
for groupname in model.Group.INSTANCE_GROUPS:
group = model.Group.by_code(groupname)
c.default_group_options.append(
{
"value": group.code,
"label": h.literal(_(group.group_name)),
"selected": group.code == c.default_group,
}
)
rendered = render("/instance/settings_general.html")
return rendered
def _settings_voting_form(self, id):
c.page_instance = self._get_current_instance(id)
c.settings_menu = settings_menu(c.page_instance, 'voting')
c.delay_options = []
for delay in ((0, _("No delay")),
(1, _("1 Day")),
(2, _("2 Days")),
(7, _("One Week")),
(14, _("Two Weeks")),
(28, _("Four Weeks"))):
c.delay_options.append(
{'value': delay[0],
'label': h.literal(delay[1]),
'selected': c.page_instance.activation_delay == delay[0]})
c.majority_options = []
for majority in ((0.5, _("A simple majority (½ of vote)")),
(0.66, _("A two-thirds majority"))):
c.majority_options.append(
{'value': majority[0],
'label': h.literal(majority[1]),
'selected': c.page_instance.required_majority == majority[0]})
if votedetail.is_enabled():
c.votedetail_all_userbadges = model.UserBadge.all(
instance=c.page_instance, include_global=True)
else:
c.votedetail_all_userbadges = None
return render("/instance/settings_voting.html")
def new(self, id=None, errors={}, format=u'html'):
if id is None:
require.perm('global.message')
template = '/massmessage/new.html'
c.preview_url = h.base_url('/message/preview')
else:
c.page_instance = InstanceController._get_current_instance(id)
require.instance.message(c.page_instance)
template = '/instance/message.html'
c.preview_url = h.base_url('/instance/%s/message/preview' % id)
defaults = dict(request.params)
defaults.setdefault('include_footer', 'on')
data = {
'instances': self._get_allowed_instances(c.user),
'sender_options': self._get_allowed_sender_options(c.user),
'userbadges': UserBadge.all(instance=c.instance,
include_global=True)
}
return htmlfill.render(render(template,
data,
overlay=format == u'overlay'),
defaults=defaults,
errors=errors,
force_defaults=False)
def edit(self, id, format='html'):
c.comment = get_entity_or_abort(model.Comment, id)
require.comment.edit(c.comment)
if format == 'ajax':
return render_def('/comment/tiles.html', 'edit_form',
{'comment': c.comment})
return render('/comment/edit.html')
def events(self, id, format=u'html'):
if not c.instance.display_category_pages:
abort(404)
category = get_entity_or_abort(model.CategoryBadge, id)
events = h.category.event_q(
category,
event_filter=request.params.getall('event_filter'),
count=min(int(request.params.get('count', 50)), 100),
).all()
enable_sorts = asbool(request.params.get('enable_sorts', 'true'))
enable_pages = asbool(request.params.get('enable_pages', 'true'))
row_type = request.params.get('row_type', 'row')
if row_type not in ['row', 'profile_row', 'sidebar_row', 'tiny_row']:
abort(400)
data = {
'event_pager': pager.events(events,
enable_sorts=enable_sorts,
enable_pages=enable_pages,
row_type=row_type),
}
return render('/category/events.html', data,
overlay=format == 'overlay',
overlay_size=OVERLAY_SMALL)
def watchlist(self, id, format='html'):
require.watch.index()
c.active_global_nav = 'watchlist'
c.page_user = get_entity_or_abort(model.User,
id,
instance_filter=False)
require.user.show(c.page_user)
watches = model.Watch.all_by_user(c.page_user)
entities = [w.entity for w in watches if (w.entity is not None) \
and (not isinstance(w.entity, unicode))]
c.entities_pager = NamedPager('watches',
entities,
tiles.dispatch_row_with_comments,
sorts={
_("oldest"): sorting.entity_oldest,
_("newest"): sorting.entity_newest
},
default_sort=sorting.entity_newest)
if format == 'json':
return render_json(c.entities_pager)
self._common_metadata(c.page_user, member='watchlist')
return render("/user/watchlist.html")
def document(self):
resp = request.environ.get('pylons.original_response')
if resp is None:
raise abort(404)
response.status = resp.status
if resp.content_type == 'text/javascript':
response.content_type == resp.content_type
return resp.body
# YOU DO NOT SEE THIS. IF YOU DO, ITS NOT WHAT IT LOOKS LIKE
# I DID NOT HAVE REGEX RELATIONS WITH THAT HTML PAGE
for match in BODY_RE.finditer(resp.body):
c.error_message = match.group(1)
c.error_code = cgi.escape(request.GET.get('code',
str(resp.status_int)))
if not c.error_message:
c.error_message = _("Error %s") % c.error_code
if asbool(config.get('adhocracy.interactive_debugging', 'false')):
c.trace_url = request.environ['pylons.original_response']\
.headers.get('X-Debug-URL', None)
if c.trace_url is not None:
# this may only happen in debug mode
assert (asbool(config.get('debug', 'false')))
else:
c.trace_url = None
return render("/error/http.html")
def explain(self):
if not config.get_bool("adhocracy.debug.sql"):
raise ValueError("Not in debugging mode")
statement = request.params.get("statement")
if not statement.lower().startswith("select"):
raise ValueError("We explain only select statements")
parameters = request.params.get("parameters")
c.parameters = json_loads(parameters)
# collect explain results
if engine.name.startswith("sqlite"):
explain_query = "EXPLAIN QUERY PLAN %s" % statement
else:
explain_query = "EXPLAIN %s" % statement
explain_result = engine.execute(explain_query, c.parameters)
data_result = engine.execute(statement, c.parameters)
c.results = []
for (title, result) in (("Explain", explain_result), ("Data", data_result)):
c.results.append({"title": title, "result": result.fetchall(), "headers": result.keys()})
# other data to display
c.statement = statement
c.duration = float(request.params["duration"])
return render("/debug/explain.html")
def index(self, format='html'):
require.proposal.index()
if c.instance:
redirect(h.entity_url(c.instance))
c.instances = model.Instance.all()[:5]
c.page = StaticPage('index')
#query = self.form_result.get('proposals_q')
#proposals = libsearch.query.run(query,
# entity_type=model.Proposal)[:10]
c.milestones = model.Milestone.all()
#c.proposals_pager = pager.proposals(proposals)
#c.proposals = c.proposals_pager.here()
c.stats_global = {
"members": model.User.all_q().count(),
"comments": model.Comment.all_q().count(),
"proposals": model.Proposal.all_q().count(),
"votes": model.Vote.all_q().count(),
}
if format == 'rss':
return EventController().all(format='rss')
return render('index.html')
def ask_delete(self, proposal_id, id):
c.proposal = get_entity_or_abort(model.Proposal, proposal_id)
c.selection = get_entity_or_abort(model.Selection, id)
require.selection.delete(c.selection)
c.proposal_tile = tiles.proposal.ProposalTile(c.proposal)
return render("/selection/ask_delete.html")
def new(self, id=None, errors={}, format=u'html'):
if id is None:
require.perm('global.message')
template = '/massmessage/new.html'
c.preview_url = h.base_url('/message/preview')
else:
c.page_instance = InstanceController._get_current_instance(id)
require.instance.message(c.page_instance)
template = '/instance/message.html'
c.preview_url = h.base_url(
'/instance/%s/message/preview' % id)
defaults = dict(request.params)
defaults.setdefault('include_footer', 'on')
data = {
'instances': self._get_allowed_instances(c.user),
'sender_options': self._get_allowed_sender_options(c.user),
'userbadges': UserBadge.all(instance=c.instance,
include_global=True)
}
return htmlfill.render(render(template, data,
overlay=format == u'overlay'),
defaults=defaults, errors=errors,
force_defaults=False)
def show(self, id, format='html'):
c.page_instance = get_entity_or_abort(model.Instance, id)
require.instance.show(c.page_instance)
if format == 'json':
return render_json(c.page_instance)
if format == 'rss':
return self.activity(id, format)
if c.page_instance != c.instance:
redirect(h.entity_url(c.page_instance))
c.tile = tiles.instance.InstanceTile(c.page_instance)
proposals = model.Proposal.all(instance=c.page_instance)
c.new_proposals_pager = pager.proposals(
proposals, size=7, enable_sorts=False,
enable_pages=False, default_sort=sorting.entity_newest)
#pages = model.Page.all(instance=c.page_instance,
# functions=[model.Page.NORM])
#c.top_pages_pager = pager.pages(
# pages, size=7, enable_sorts=False,
# enable_pages=False, default_sort=sorting.norm_selections)
#tags = model.Tag.popular_tags(limit=40)
#c.tags = sorted(text.tag_cloud_normalize(tags),
# key=lambda (k, c, v): k.name)
if c.page_instance.milestones:
c.milestones = model.Milestone.all(instance=c.page_instance)
c.stats = {
'comments': model.Comment.all_q().count(),
'proposals': model.Proposal.all_q(
instance=c.page_instance).count(),
'members': model.Membership.all_q().count()
}
return render("/instance/show.html")
def settings_voting_form(self, id):
c.page_instance = self._get_current_instance(id)
c.settings_menu = self.settings_menu(c.page_instance, "voting")
c.delay_options = []
for delay in (
(0, _("No delay")),
(1, _("1 Day")),
(2, _("2 Days")),
(7, _("One Week")),
(14, _("Two Weeks")),
(28, _("Four Weeks")),
):
c.delay_options.append(
{
"value": delay[0],
"label": h.literal(delay[1]),
"selected": c.page_instance.activation_delay == delay[0],
}
)
c.majority_options = []
for majority in ((0.5, _("A simple majority (½ of vote)")), (0.66, _("A two-thirds majority"))):
c.majority_options.append(
{
"value": majority[0],
"label": h.literal(majority[1]),
"selected": c.page_instance.required_majority == majority[0],
}
)
return render("/instance/settings_voting.html")
def show(self, id, format='html'):
c.page_instance = get_entity_or_abort(model.Instance, id)
require.instance.show(c.page_instance)
if format == 'json':
return render_json(c.page_instance)
if format == 'rss':
return self.activity(id, format)
if c.page_instance != c.instance:
redirect(h.entity_url(c.page_instance))
c.tile = tiles.instance.InstanceTile(c.page_instance)
proposals = model.Proposal.all(instance=c.page_instance)
c.new_proposals_pager = pager.proposals(
proposals, size=7, enable_sorts=False,
enable_pages=False, default_sort=sorting.entity_newest)
c.sidebar_delegations = (_('Delegations are enabled.') if
c.page_instance.allow_delegate else
_('Delegations are disabled.'))
#pages = model.Page.all(instance=c.page_instance,
# functions=[model.Page.NORM])
#c.top_pages_pager = pager.pages(
# pages, size=7, enable_sorts=False,
# enable_pages=False, default_sort=sorting.norm_selections)
#tags = model.Tag.popular_tags(limit=40)
#c.tags = sorted(text.tag_cloud_normalize(tags),
# key=lambda (k, c, v): k.name)
if asbool(config.get('adhocracy.show_instance_overview_milestones')) \
and c.page_instance.milestones:
number = asint(config.get(
'adhocracy.number_instance_overview_milestones', 3))
milestones = model.Milestone.all_future_q(
instance=c.page_instance).limit(number).all()
c.next_milestones_pager = pager.milestones(
milestones, size=number, enable_sorts=False,
enable_pages=False, default_sort=sorting.milestone_time)
events = model.Event.find_by_instance(c.page_instance, limit=3)
c.events_pager = pager.events(events,
enable_pages=False,
enable_sorts=False)
c.stats = {
'comments': model.Comment.all_q().count(),
'proposals': model.Proposal.all_q(
instance=c.page_instance).count(),
'members': model.Membership.all_q().count()
}
c.tutorial_intro = _('tutorial_instance_show_intro')
c.tutorial = 'instance_show'
return render("/instance/show.html")
def edit(self, id):
c.page_instance = self._get_current_instance(id)
require.instance.edit(c.page_instance)
c._Group = model.Group
c.locales = i18n.LOCALES
default_group = c.page_instance.default_group.code if \
c.page_instance.default_group else \
model.Group.INSTANCE_DEFAULT
return htmlfill.render(render("/instance/edit.html"),
defaults={
'_method': 'PUT',
'label': c.page_instance.label,
'description': c.page_instance.description,
'css': c.page_instance.css,
'required_majority':
c.page_instance.required_majority,
'activation_delay':
c.page_instance.activation_delay,
'allow_adopt': c.page_instance.allow_adopt,
'allow_delegate':
c.page_instance.allow_delegate,
'allow_propose':
c.page_instance.allow_propose,
'allow_index': c.page_instance.allow_index,
'hidden': c.page_instance.hidden,
'milestones': c.page_instance.milestones,
'frozen': c.page_instance.frozen,
'locale': c.page_instance.locale,
'use_norms': c.page_instance.use_norms,
'_tok': csrf.token_id(),
'default_group': default_group
})
def sitemap_xml(self):
if c.instance:
redirect(h.base_url(None, path="/sitemap.xml"))
c.delegateables = model.Delegateable.all()
c.change_time = datetime.utcnow()
response.content_type = "text/xml"
return render("sitemap.xml")
def show(self, id, format=u'html'):
if not c.instance.display_category_pages:
abort(404)
require.proposal.index()
query = self.form_result.get('proposals_q')
category = get_entity_or_abort(model.CategoryBadge, id)
pages = model.Page.all_q(instance=c.instance,
functions=model.Page.LISTED) \
.join(model.DelegateableBadges) \
.filter(model.DelegateableBadges.badge_id == category.id) \
.all()
pages = filter(lambda p: p.parent is None, pages)
pages_pager = pager.NamedPager('pages', pages, tiles.page.smallrow,
enable_pages=False, enable_sorts=False)
default_sorting = config.get(
'adhocracy.listings.instance_proposal.sorting')
proposals_pager = pager.solr_proposal_pager(
c.instance,
{'text': query},
default_sorting=default_sorting,
extra_filter={'facet.delegateable.badgecategory': category.id})
data = {
'category': category,
'pages_pager': pages_pager,
'proposals_pager': proposals_pager,
}
return render('/category/show.html', data,
overlay=format == u'overlay')
def user_import_form(self, errors=None, format='html'):
return formencode.htmlfill.render(render("/admin/userimport_form.html",
{},
overlay=format == 'overlay'),
defaults=dict(request.params),
errors=errors,
force_defaults=False)
def settings_members_import_save(self, id, format='html'):
c.page_instance = self._get_current_instance(id)
c.settings_menu = settings_menu(c.page_instance,
'members_import')
require.instance.edit(c.page_instance)
AdminController()._create_users(self.form_result)
return(render("/instance/settings_members_import_success.html"))
def index(self, format='html'):
require.proposal.index()
if c.instance:
redirect(h.entity_url(c.instance))
instances_in_root = asint(
config.get('adhocracy.startpage.instances.list_length', 0))
if instances_in_root > 0:
c.instances = model.Instance.all(limit=instances_in_root)
elif instances_in_root == -1:
c.instances = model.Instance.all()
c.page = StaticPage('index')
#query = self.form_result.get('proposals_q')
#proposals = libsearch.query.run(query,
# entity_type=model.Proposal)[:10]
c.milestones = model.Milestone.all()
#c.proposals_pager = pager.proposals(proposals)
#c.proposals = c.proposals_pager.here()
c.stats_global = {
"members": model.User.all_q().count(),
"comments": model.Comment.all_q().count(),
"proposals": model.Proposal.all_q().count(),
"votes": model.Vote.all_q().count(),
}
if format == 'rss':
return EventController().all(format='rss')
return render('index.html')
def preview(self, subject, body, recipients, sender_email, sender_name,
instance, include_footer):
recipients_list = sorted(list(recipients), key=lambda r: r.name)
if recipients_list:
try:
rendered_body = render_body(body,
recipients_list[0],
is_preview=True)
except (KeyError, ValueError) as e:
rendered_body = _('Could not render message: %s') % str(e)
else:
rendered_body = body
# wrap body, but leave long words (e.g. links) intact
rendered_body = u'\n'.join(
textwrap.fill(line, break_long_words=False)
for line in rendered_body.split(u'\n'))
data = {
'sender_email': sender_email,
'sender_name': sender_name,
'subject': subject,
'body': rendered_body,
'recipients': recipients_list,
'recipients_count': len(recipients_list),
'params': request.params,
'include_footer': include_footer,
'instance': instance,
}
return render('/massmessage/preview.html', data)
def edit(self, id, format='html'):
c.comment = get_entity_or_abort(model.Comment, id)
require.comment.edit(c.comment)
extra_vars = {'comment': c.comment}
ret_url = request.params.get(u'ret_url', u'')
if validate_ret_url(ret_url):
extra_vars[u'ret_url'] = ret_url
c.ret_url = ret_url
if format == 'ajax':
return render_def('/comment/tiles.html',
'edit_form',
extra_vars=extra_vars)
elif format == 'overlay':
return render('/comment/edit.html', overlay=True)
else:
return render('/comment/edit.html')
def edit(self, id):
c.page_instance = self._get_current_instance(id)
require.instance.edit(c.page_instance)
c._Group = model.Group
c.locales = i18n.LOCALES
default_group = c.page_instance.default_group.code if \
c.page_instance.default_group else \
model.Group.INSTANCE_DEFAULT
return htmlfill.render(
render("/instance/edit.html"),
defaults={
'_method': 'PUT',
'label': c.page_instance.label,
'description': c.page_instance.description,
'css': c.page_instance.css,
'required_majority': c.page_instance.required_majority,
'activation_delay': c.page_instance.activation_delay,
'allow_adopt': c.page_instance.allow_adopt,
'allow_delegate': c.page_instance.allow_delegate,
'allow_propose': c.page_instance.allow_propose,
'allow_index': c.page_instance.allow_index,
'hidden': c.page_instance.hidden,
'milestones': c.page_instance.milestones,
'frozen': c.page_instance.frozen,
'locale': c.page_instance.locale,
'use_norms': c.page_instance.use_norms,
'_tok': csrf.token_id(),
'default_group': default_group})
def add(self, errors=None):
c.form_title = c.save_button = _("Add Badge")
c.action_url = self.base_url + '/add'
c.groups = meta.Session.query(Group).order_by(Group.group_name).all()
return htmlfill.render(render("/badge/form.html"),
defaults=dict(request.params),
errors=errors)
def explain(self):
if not config.get('adhocracy.debug.sql'):
raise ValueError('Not in debugging mode')
statement = request.params.get('statement')
if not statement.lower().startswith('select'):
raise ValueError('We explain only select statements')
parameters = request.params.get('parameters')
c.parameters = json_loads(parameters)
# collect explain results
if engine.name.startswith('sqlite'):
explain_query = 'EXPLAIN QUERY PLAN %s' % statement
else:
explain_query = 'EXPLAIN %s' % statement
explain_result = engine.execute(explain_query, c.parameters)
data_result = engine.execute(statement, c.parameters)
c.results = []
for (title, result) in (('Explain', explain_result), ('Data',
data_result)):
c.results.append({
'title': title,
'result': result.fetchall(),
'headers': result.keys()
})
# other data to display
c.statement = statement
c.duration = float(request.params['duration'])
return render('/debug/explain.html')
def _new(self, proposal_id, template, errors):
c.proposal = get_entity_or_abort(model.Proposal, proposal_id)
require.selection.create(c.proposal)
defaults = dict(request.params)
c.proposal_tile = tiles.proposal.ProposalTile(c.proposal)
return htmlfill.render(render(template), defaults=defaults,
errors=errors, force_defaults=False)
def carousel(self, format=u"html"):
if c.instance is None:
require.perm("event.index_all")
data = {u"data_url": h.base_url("/event/all", query_params=request.params)}
return render("/event/carousel.html", data, overlay=format == u"overlay", overlay_size=OVERLAY_SMALL)
def ask_delete(self, proposal_id, id):
c.proposal = get_entity_or_abort(model.Proposal, proposal_id)
c.selection = get_entity_or_abort(model.Selection, id)
require.selection.delete(c.selection)
c.proposal_tile = tiles.proposal.ProposalTile(c.proposal)
return render("/selection/ask_delete.html")
class MessageController(BaseController):
def new(self, id, format='html', errors={}):
c.page_user = get_entity_or_abort(model.User, id)
require.user.message(c.page_user)
html = render("/message/new.html", overlay=format == u'overlay')
return htmlfill.render(html,
defaults=request.params,
errors=errors,
force_defaults=False)
def create(self, id, format='html'):
c.page_user = get_entity_or_abort(model.User, id)
require.user.message(c.page_user)
try:
self.form_result = MessageCreateForm().to_python(request.params)
except Invalid, i:
return self.new(id, errors=i.unpack_errors())
c.body = self.form_result.get('body')
c.subject = self.form_result.get('subject')
message = render("/message/body.txt")
headers = {}
if c.user.is_email_activated():
headers['Reply-To'] = c.user.email
from adhocracy.lib.mail import to_user
label = h.site.name() if c.instance is None else c.instance.label
subject = _("[%s] Message from %s: %s") % (label, c.user.name,
c.subject)
to_user(c.page_user, subject, message, headers=headers)
h.flash(_("Your message has been sent. Thanks."), 'success')
redirect(h.entity_url(c.page_user, instance=c.instance))
def post_login(self):
if c.user:
session['logged_in'] = True
session.save()
came_from = session.get('came_from', None)
if came_from is not None:
del session['came_from']
session.save()
redirect(came_from)
# redirect to the dashboard inside the instance exceptionally
# to be able to link to proposals and norms in the welcome
# message.
redirect(h.base_url(path='/user/%s/dashboard' % c.user.user_name))
else:
login_configuration = h.allowed_login_types()
error_message = _("Invalid login")
if 'username+password' in login_configuration:
if 'email+password' in login_configuration:
error_message = _("Invalid email / user name or password")
else:
error_message = _("Invalid user name or password")
else:
if 'email+password' in login_configuration:
error_message = _("Invalid email or password")
return formencode.htmlfill.render(
render("/user/login.html"),
errors={"login": error_message})
