def update(self, id, format='html'):
c.comment = get_entity_or_abort(model.Comment, id)
require.comment.edit(c.comment)
rev = c.comment.create_revision(
self.form_result.get('text'),
c.user,
sentiment=self.form_result.get('sentiment'))
model.meta.Session.commit()
if can.user.vote():
decision = democracy.Decision(c.user, c.comment.poll)
if not decision.result == model.Vote.YES:
decision.make(model.Vote.YES)
model.meta.Session.commit()
# do not modify watch state as comments are always watched
event.emit(event.T_COMMENT_EDIT,
c.user,
instance=c.instance,
topics=[c.comment.topic],
comment=c.comment,
topic=c.comment.topic,
rev=rev)
if len(request.params.get('ret_url', '')):
redirect(request.params.get('ret_url') + "#c" + str(c.comment.id))
if format != 'html':
return ret_success(entity=c.comment, format=format)
else:
return ret_success(entity=c.comment, format='fwd')
def update(self, id, format='html'):
c.comment = get_entity_or_abort(model.Comment, id)
require.comment.edit(c.comment)
rev = c.comment.create_revision(
self.form_result.get('text'),
c.user,
sentiment=self.form_result.get('sentiment'))
model.meta.Session.commit()
if can.user.vote():
decision = democracy.Decision(c.user, c.comment.poll)
if not decision.result == model.Vote.YES:
decision.make(model.Vote.YES)
model.meta.Session.commit()
# do not modify watch state as comments are always watched
event.emit(event.T_COMMENT_EDIT, c.user, instance=c.instance,
topics=[c.comment.topic], comment=c.comment,
topic=c.comment.topic, rev=rev)
if c.came_from != u'':
redirect(c.came_from + "#c" + str(c.comment.id))
if format != 'html':
return ret_success(entity=c.comment, format=format)
else:
return ret_success(entity=c.comment, format='fwd')
def resend(self, id):
c.page_user = get_entity_or_abort(model.User, id,
instance_filter=False)
require.user.edit(c.page_user)
libmail.send_activation_link(c.page_user)
path = request.params.get('came_from', None)
ret_success(
message=_("The activation link has been re-sent to your email "
"address."), category='success',
entity=c.page_user, member='edit', force_path=path)
def leave(self, id, format='html'):
c.page_instance = self._get_current_instance(id)
if not c.page_instance in c.user.instances:
return ret_abort(
entity=c.page_instance, format=format,
message=_("You're not a member of %(instance)s.") % {
'instance': c.page_instance.label})
elif c.user == c.page_instance.creator:
return ret_abort(
entity=c.page_instance, format=format,
message=_("You're the founder of %s, cannot leave.") % {
'instance': c.page_instance.label})
require.instance.leave(c.page_instance)
for membership in c.user.memberships:
if membership.is_expired():
continue
if membership.instance == c.page_instance:
membership.expire()
model.meta.Session.add(membership)
c.user.revoke_delegations(c.page_instance)
event.emit(event.T_INSTANCE_LEAVE, c.user,
instance=c.page_instance)
model.meta.Session.commit()
return ret_success(entity=c.page_instance, format=format,
message=_("You've left %(instance)s.") % {
'instance': c.page_instance.label})
def leave(self, id, format='html'):
c.page_instance = self._get_current_instance(id)
if not c.page_instance in c.user.instances:
return ret_abort(
entity=c.page_instance, format=format,
message=_("You're not a member of %(instance)s.") % {
'instance': c.page_instance.label})
elif c.user == c.page_instance.creator:
return ret_abort(
entity=c.page_instance, format=format,
message=_("You're the founder of %s, cannot leave.") % {
'instance': c.page_instance.label})
require.instance.leave(c.page_instance)
for membership in c.user.memberships:
if membership.is_expired():
continue
if membership.instance == c.page_instance:
membership.expire()
model.meta.Session.add(membership)
c.user.revoke_delegations(c.page_instance)
event.emit(event.T_INSTANCE_LEAVE, c.user,
instance=c.page_instance)
model.meta.Session.commit()
return ret_success(entity=c.page_instance, format=format,
message=_("You've left %(instance)s.") % {
'instance': c.page_instance.label})
def delete(self, id, format="html"):
c.page_instance = self._get_current_instance(id)
require.instance.delete(c.page_instance)
c.page_instance.delete()
model.meta.Session.commit()
event.emit(event.T_INSTANCE_DELETE, c.user, instance=c.instance, topics=[])
return ret_success(format=format, message=_("The instance %s has been deleted.") % c.page_instance.label)
def create(self, format='html'):
c.scope = self.form_result.get('scope')
require.delegation.create(c.scope)
agents = filter(lambda f: f is not None, self.form_result.get('agent'))
if not len(agents) or agents[0] == c.user:
h.flash(_("Invalid delegation recipient"), 'error')
return self.new()
existing = model.Delegation.find_by_agent_principal_scope(agents[0],
c.user,
c.scope)
if existing is not None:
h.flash(_("You have already delegated voting to %s in %s") %
(agents[0].name, c.scope.label),
'notice')
return self.new()
delegation = model.Delegation.create(
c.user, agents[0], c.scope,
replay=self.form_result.get('replay') == 1)
model.meta.Session.commit()
event.emit(event.T_DELEGATION_CREATE, c.user,
instance=c.instance,
topics=[c.scope], scope=c.scope,
agent=agents[0], delegation=delegation)
return ret_success(entity=delegation.scope, format=format)
def create(self, format='html'):
c.scope = self.form_result.get('scope')
require.delegation.create(c.scope)
agents = filter(lambda f: f is not None, self.form_result.get('agent'))
if not len(agents) or agents[0] == c.user:
h.flash(_("Invalid delegation recipient"), 'error')
return self.new()
existing = model.Delegation.find_by_agent_principal_scope(
agents[0], c.user, c.scope)
if existing is not None:
h.flash(
_("You have already delegated voting to %s in %s") %
(agents[0].name, c.scope.label), 'notice')
return self.new()
delegation = model.Delegation.create(
c.user,
agents[0],
c.scope,
replay=self.form_result.get('replay') == 1)
model.meta.Session.commit()
event.emit(event.T_DELEGATION_CREATE,
c.user,
instance=c.instance,
topics=[c.scope],
scope=c.scope,
agent=agents[0],
delegation=delegation)
return ret_success(entity=delegation.scope, format=format)
def delete(self, id, format):
c.poll = self._get_open_poll(id)
require.poll.delete(c.poll)
c.poll.end()
model.meta.Session.commit()
event.emit(event.T_PROPOSAL_STATE_REDRAFT, c.user, instance=c.instance,
topics=[c.poll.scope], proposal=c.poll.scope, poll=c.poll)
return ret_success(message=_("The poll has ended."),
entity=c.poll.subject)
def create(self, format='html'):
require.instance.create()
instance = model.Instance.create(
self.form_result.get('key'), self.form_result.get('label'),
c.user, description=self.form_result.get('description'),
locale=c.locale)
model.meta.Session.commit()
event.emit(event.T_INSTANCE_CREATE, c.user, instance=instance)
return ret_success(entity=instance, format=format)
def create(self, sender_email, sender_name, subject, body, recipients,
include_footer):
message = Message.create(subject, body, c.user, sender_email,
sender_name, include_footer)
for count, user in enumerate(recipients, start=1):
MessageRecipient.create(message, user, notify=True)
return ret_success(message=_("Message sent to %d users.") % count)
def create(self, format='html'):
require.instance.create()
instance = model.Instance.create(
self.form_result.get('key'), self.form_result.get('label'),
c.user, description=self.form_result.get('description'),
locale=c.locale)
model.meta.Session.commit()
event.emit(event.T_INSTANCE_CREATE, c.user, instance=instance)
return ret_success(entity=instance, format=format)
def create(self, subject, body, recipients, sender_email, sender_name,
instance, include_footer):
send_message(subject, body, c.user, recipients,
sender_email=sender_email,
sender_name=sender_name,
instance=instance,
include_footer=include_footer)
return ret_success(
message=_("Message sent to %d users.") % len(recipients))
def delete(self, id, format):
c.poll = self._get_open_poll(id)
require.poll.delete(c.poll)
c.poll.end()
model.meta.Session.commit()
event.emit(event.T_PROPOSAL_STATE_REDRAFT, c.user, instance=c.instance,
topics=[c.poll.scope], proposal=c.poll.scope, poll=c.poll)
return ret_success(message=_("The poll has ended."),
entity=c.poll.subject)
def delete(self, id, format='html'):
c.page_instance = self._get_current_instance(id)
require.instance.delete(c.page_instance)
c.page_instance.delete()
model.meta.Session.commit()
event.emit(event.T_INSTANCE_DELETE, c.user, instance=c.instance,
topics=[])
return ret_success(format=format,
message=_("The instance %s has been deleted.") %
c.page_instance.label)
def create(self, sender, subject, body, recipients):
message = Message.create(subject,
body,
c.user,
sender)
for count, user in enumerate(recipients, start=1):
MessageRecipient.create(message, user, notify=True)
return ret_success(message=_("Message sent to %d users.") % count)
def create(self, format='html'):
instance = model.Instance.create(
self.form_result.get('key'), self.form_result.get('label'),
c.user, description=self.form_result.get('description'),
locale=c.locale)
model.meta.Session.commit()
event.emit(event.T_INSTANCE_CREATE, c.user, instance=instance)
return ret_success(
message=_('Instance created successfully. You can now configure it'
' as you like.'), category='success',
entity=instance, member='settings', format=None)
def create(self, format='html'):
require.instance.create()
instance = model.Instance.create(
self.form_result.get('key'), self.form_result.get('label'),
c.user, description=self.form_result.get('description'),
locale=c.locale)
model.meta.Session.commit()
event.emit(event.T_INSTANCE_CREATE, c.user, instance=instance)
return ret_success(
message=_('Instance created successfully. You can now configure it'
' as you like.'), category='success',
entity=instance, member='settings', format=None)
def create(self, subject, body, recipients, sender_email, sender_name,
instance, include_footer):
send_message(subject,
body,
c.user,
recipients,
sender_email=sender_email,
sender_name=sender_name,
instance=instance,
include_footer=include_footer)
return ret_success(message=_("Message sent to %d users.") %
len(recipients))
def delete(self, id, format='html'):
c.comment = get_entity_or_abort(model.Comment, id)
require.comment.delete(c.comment)
c.comment.delete()
model.meta.Session.commit()
event.emit(event.T_COMMENT_DELETE, c.user, instance=c.instance,
topics=[c.comment.topic], comment=c.comment,
topic=c.comment.topic)
return ret_success(message=_("The comment has been deleted."),
entity=c.comment.topic,
format=format)
def delete(self, id):
c.delegation = get_entity_or_abort(model.Delegation, id)
require.delegation.delete(c.delegation)
if not c.delegation.principal == c.user:
return ret_abort(_("Cannot access delegation %(id)s") %
{'id': id}, code=403)
c.delegation.revoke()
model.meta.Session.commit()
event.emit(event.T_DELEGATION_REVOKE, c.user,
topics=[c.delegation.scope],
scope=c.delegation.scope, instance=c.instance,
agent=c.delegation.agent)
return ret_success(message=_("The delegation is now revoked."),
entity=c.delegation.scope)
def purge_history(self, id, format='html'):
c.comment = get_entity_or_abort(model.Comment, id)
require.comment.revert(c.comment)
revision = self.form_result.get('rev')
if revision.comment != c.comment:
return ret_abort(_("You're trying to purge a revision which "
"is not part of this comment's history"),
code=400, format=format)
model.meta.Session.delete(revision)
model.meta.Session.commit()
return ret_success(message=_("The comment revision has been deleted."),
entity=c.comment, format=format)
def update(self, id, format='html'):
c.comment = get_entity_or_abort(model.Comment, id)
require.comment.edit(c.comment)
rev = c.comment.create_revision(
self.form_result.get('text'),
c.user,
sentiment=self.form_result.get('sentiment'))
model.meta.Session.commit()
if can.user.vote():
decision = democracy.Decision(c.user, c.comment.poll)
if not decision.result == model.Vote.YES:
decision.make(model.Vote.YES)
model.meta.Session.commit()
watchlist.check_watch(c.comment)
#watch = model.Watch.create(c.user, c.comment)
event.emit(event.T_COMMENT_EDIT, c.user, instance=c.instance,
topics=[c.comment.topic], comment=c.comment,
topic=c.comment.topic, rev=rev)
if len(request.params.get('ret_url', '')):
redirect(request.params.get('ret_url') + "#c" + str(c.comment.id))
if format != 'html':
return ret_success(entity=c.comment, format=format)
return ret_success(entity=c.comment, format='fwd')
def join(self, id, format='html'):
c.page_instance = self._get_current_instance(id)
require.instance.join(c.page_instance)
membership = model.Membership(c.user, c.page_instance,
c.page_instance.default_group)
model.meta.Session.expunge(membership)
model.meta.Session.add(membership)
model.meta.Session.commit()
event.emit(event.T_INSTANCE_JOIN, c.user, instance=c.page_instance)
return ret_success(entity=c.page_instance,
format=format,
message=_("Welcome to %(instance)s") %
{'instance': c.page_instance.label})
def join(self, id, format='html'):
c.page_instance = self._get_current_instance(id)
require.instance.join(c.page_instance)
membership = model.Membership(c.user, c.page_instance,
c.page_instance.default_group)
model.meta.Session.expunge(membership)
model.meta.Session.add(membership)
model.meta.Session.commit()
event.emit(event.T_INSTANCE_JOIN, c.user,
instance=c.page_instance)
return ret_success(entity=c.page_instance, format=format,
message=_("Welcome to %(instance)s") % {
'instance': c.page_instance.label})
def untag_all(self, format='html'):
# HACK create a proper permission
require.instance.edit(c.instance)
delegateable = self.form_result.get('delegateable')
tag = self.form_result.get('tag')
for tagging in delegateable.taggings:
if tagging.tag == tag:
tagging.delete()
update_entity(delegateable, model.UPDATE)
model.meta.Session.commit()
return ret_success(
message=_('Tag "%s" has been removed from %s "%s".') %
(tag.name, _(delegateable.type), delegateable.label),
category='success',
entity=delegateable,
format=format)
def purge_history(self, id, format='html'):
c.comment = get_entity_or_abort(model.Comment, id)
require.comment.revert(c.comment)
revision = self.form_result.get('rev')
if revision.comment != c.comment:
return ret_abort(_("You're trying to purge a revision which "
"is not part of this comment's history"),
code=400,
format=format)
model.meta.Session.delete(revision)
model.meta.Session.commit()
return ret_success(message=_("The comment revision has been deleted."),
entity=c.comment,
format=format)
def delete(self, id):
c.delegation = get_entity_or_abort(model.Delegation, id)
require.delegation.delete(c.delegation)
if not c.delegation.principal == c.user:
return ret_abort(_("Cannot access delegation %(id)s") % {'id': id},
code=403)
c.delegation.revoke()
model.meta.Session.commit()
event.emit(event.T_DELEGATION_REVOKE,
c.user,
topics=[c.delegation.scope],
scope=c.delegation.scope,
instance=c.instance,
agent=c.delegation.agent)
return ret_success(message=_("The delegation is now revoked."),
entity=c.delegation.scope)
def revert(self, id, format='html'):
c.comment = get_entity_or_abort(model.Comment, id)
require.comment.revert(c.comment)
revision = self.form_result.get('to')
if revision.comment != c.comment:
return ret_abort(_("You're trying to revert to a revision which "
"is not partri of this comments history"),
code=400, format=format)
rev = c.comment.create_revision(revision.text,
c.user,
sentiment=revision.sentiment)
model.meta.Session.commit()
event.emit(event.T_COMMENT_EDIT, c.user, instance=c.instance,
topics=[c.comment.topic], comment=c.comment,
topic=c.comment.topic, rev=rev)
return ret_success(message=_("The comment has been reverted."),
entity=c.comment, format=format)
def untag_all(self, format='html'):
# HACK create a proper permission
require.instance.edit(c.instance)
delegateable = self.form_result.get('delegateable')
tag = self.form_result.get('tag')
for tagging in delegateable.taggings:
if tagging.tag == tag:
tagging.delete()
update_entity(delegateable, model.UPDATE)
model.meta.Session.commit()
return ret_success(
message=_('Tag "%s" has been removed from %s "%s".') % (
tag.name,
_(delegateable.type),
delegateable.label),
category='success',
entity=delegateable,
format=format)
class InstanceController(BaseController):
def index(self, format='html'):
require.instance.index()
h.add_meta(
"description",
_("An index of instances run at this site. "
"Select which ones you would like to join "
"and participate!"))
instances = model.Instance.all()
if format == 'json':
return render_json(instances)
c.instances_pager = pager.instances(instances)
return render("/instance/index.html")
def new(self):
require.instance.create()
return render("/instance/new.html")
@csrf.RequireInternalRequest(methods=['POST'])
@validate(schema=InstanceCreateForm(), form="new", post_only=True)
def create(self, format='html'):
require.instance.create()
instance = model.Instance.create(
self.form_result.get('key'),
self.form_result.get('label'),
c.user,
description=self.form_result.get('description'),
locale=c.locale)
model.meta.Session.commit()
event.emit(event.T_INSTANCE_CREATE, c.user, instance=instance)
return ret_success(entity=instance, format=format)
#@RequireInstance
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")
@RequireInstance
def activity(self, id, format='html'):
c.page_instance = get_entity_or_abort(model.Instance, id)
require.instance.show(c.page_instance)
if format == 'sline':
sline = event.sparkline_samples(instance_activity, c.page_instance)
return render_json(dict(activity=sline))
events = model.Event.find_by_instance(c.page_instance)
if format == 'rss':
return event.rss_feed(events, _('%s News' % c.page_instance.label),
h.base_url(c.page_instance),
_("News from %s") % c.page_instance.label)
c.tile = tiles.instance.InstanceTile(c.page_instance)
c.events_pager = pager.events(events)
return render("/instance/activity.html")
@RequireInstance
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
})
@RequireInstance
@csrf.RequireInternalRequest(methods=['POST'])
@validate(schema=InstanceEditForm(), form="edit", post_only=True)
def update(self, id, format='html'):
c.page_instance = self._get_current_instance(id)
require.instance.edit(c.page_instance)
c.page_instance.description = self.form_result.get('description')
c.page_instance.label = self.form_result.get('label')
c.page_instance.required_majority = self.form_result.get(
'required_majority')
c.page_instance.activation_delay = self.form_result.get(
'activation_delay')
c.page_instance.allow_adopt = self.form_result.get('allow_adopt')
c.page_instance.allow_delegate = self.form_result.get('allow_delegate')
c.page_instance.allow_propose = self.form_result.get('allow_propose')
c.page_instance.allow_index = self.form_result.get('allow_index')
c.page_instance.hidden = self.form_result.get('hidden')
c.page_instance.frozen = self.form_result.get('frozen')
c.page_instance.milestones = self.form_result.get('milestones')
c.page_instance.css = self.form_result.get('css')
c.page_instance.use_norms = self.form_result.get('use_norms')
locale = Locale(self.form_result.get("locale"))
if locale and locale in i18n.LOCALES:
c.page_instance.locale = locale
if (self.form_result.get('default_group').code
in model.Group.INSTANCE_GROUPS):
c.page_instance.default_group = self.form_result.get(
'default_group')
try:
if ('logo' in request.POST
and hasattr(request.POST.get('logo'), 'file')
and request.POST.get('logo').file):
logo.store(c.page_instance, request.POST.get('logo').file)
except Exception, e:
h.flash(unicode(e), 'error')
log.debug(e)
model.meta.Session.commit()
event.emit(event.T_INSTANCE_EDIT, c.user, instance=c.page_instance)
return ret_success(entity=c.page_instance, format=format)
class CommentController(BaseController):
@RequireInstance
def index(self, format='html'):
require.comment.index()
comments = model.Comment.all()
c.comments_pager = NamedPager(
'comments', comments, tiles.comment.row, count=10,
sorts={_("oldest"): sorting.entity_oldest,
_("newest"): sorting.entity_newest},
default_sort=sorting.entity_newest)
if format == 'json':
return render_json(c.comments_pager)
return self.not_implemented(format=format)
@RequireInstance
@validate(schema=CommentNewForm(), form="bad_request",
post_only=False, on_get=True)
def new(self, errors=None):
c.topic = self.form_result.get('topic')
c.reply = self.form_result.get('reply')
c.wiki = self.form_result.get('wiki')
c.variant = self.form_result.get('variant')
defaults = dict(request.params)
if c.reply:
require.comment.reply(c.reply)
else:
require.comment.create_on(c.topic)
return htmlfill.render(render('/comment/new.html'), defaults=defaults,
errors=errors, force_defaults=False)
@RequireInstance
@csrf.RequireInternalRequest(methods=['POST'])
def create(self, format='html'):
require.comment.create()
try:
self.form_result = CommentCreateForm().to_python(request.params)
except Invalid, i:
return self.new(errors=i.unpack_errors())
topic = self.form_result.get('topic')
reply = self.form_result.get('reply')
if reply:
require.comment.reply(reply)
else:
require.comment.create_on(topic)
variant = self.form_result.get('variant')
if hasattr(topic, 'variants') and not variant in topic.variants:
return ret_abort(_("Comment topic has no variant %s") % variant,
code=400)
comment = model.Comment.create(
self.form_result.get('text'),
c.user, topic,
reply=reply,
wiki=self.form_result.get('wiki'),
variant=variant,
sentiment=self.form_result.get('sentiment'),
with_vote=can.user.vote())
# watch comments by default!
model.Watch.create(c.user, comment)
model.meta.Session.commit()
#watchlist.check_watch(comment)
event.emit(event.T_COMMENT_CREATE, c.user, instance=c.instance,
topics=[topic], comment=comment, topic=topic,
rev=comment.latest)
if len(request.params.get('ret_url', '')):
redirect(request.params.get('ret_url') + "#c" + str(comment.id))
if format != 'html':
return ret_success(entity=comment, format=format)
return ret_success(entity=comment, format='fwd')
