def _to_python(self, value, state):
from adhocracy.model import Group
group = Group.by_code(value)
if not group:
raise formencode.Invalid(
_("No group with ID '%s' exists") % value, value, state)
return group
def setUp(self):
super(TestInteractionOfDelegationOnDifferentLevels, self).setUp()
voter_group = Group.by_code(Group.CODE_VOTER)
self.me = tt_make_user(instance_group=voter_group)
self.first = tt_make_user(instance_group=voter_group)
self.second = tt_make_user(instance_group=voter_group)
self.proposal = tt_make_proposal(voting=True)
def setUp(self):
super(TestInteractionOfDelegationOnDifferentLevels, self).setUp()
voter_group = Group.by_code(Group.CODE_VOTER)
self.me = tt_make_user(instance_group=voter_group)
self.first = tt_make_user(instance_group=voter_group)
self.second = tt_make_user(instance_group=voter_group)
self.proposal = tt_make_proposal(voting=True)
def _to_python(self, value, state):
from adhocracy.model import Group
group = Group.by_code(value)
if not group:
raise formencode.Invalid(
_("No group with ID '%s' exists") % value,
value, state)
return group
def test_delete_user_deletes_watches(self):
from adhocracy.model import Watch
voter_group = Group.by_code(Group.CODE_VOTER)
user = tt_make_user(instance_group=voter_group)
instance = tt_get_instance()
watch = Watch.create(user, instance)
self.assertFalse(watch.is_deleted())
user.delete()
self.assertTrue(watch.is_deleted())
def test_delete_user_deletes_watches(self):
from adhocracy.model import Watch
voter_group = Group.by_code(Group.CODE_VOTER)
user = tt_make_user(instance_group=voter_group)
instance = tt_get_instance()
watch = Watch.create(user, instance)
self.assertFalse(watch.is_deleted())
user.delete()
self.assertTrue(watch.is_deleted())
def test_can_delegate_via_forward_on_user(self):
proposal = tt_make_proposal(voting=True)
voter_group = Group.by_code(Group.CODE_VOTER)
me = tt_make_user(instance_group=voter_group)
delegate = tt_make_user(instance_group=voter_group)
Delegation.create(me, delegate, proposal)
self.assertEqual(delegate.number_of_votes_in_scope(proposal), 2)
def test_can_delegate_via_forward_on_user(self):
proposal = tt_make_proposal(voting=True)
voter_group = Group.by_code(Group.CODE_VOTER)
me = tt_make_user(instance_group=voter_group)
delegate = tt_make_user(instance_group=voter_group)
Delegation.create(me, delegate, proposal)
self.assertEqual(delegate.number_of_votes_in_scope(proposal), 2)
def _to_python(self, value, state):
from adhocracy.model import Group
group = Group.by_code(value)
if not group:
raise formencode.Invalid(
_("No group with ID '%s' exists") % value, value, state)
if not group.is_instance_group():
raise formencode.Invalid(
_("Group '%s' is no instance group") % group.code, value,
state)
return group
def _to_python(self, value, state):
from adhocracy.model import Group
group = Group.by_code(value)
if not group:
raise formencode.Invalid(
_("No group with ID '%s' exists") % value,
value, state)
if not group.is_instance_group():
raise formencode.Invalid(
_("Group '%s' is no instance group") % group.code,
value, state)
return group
def prepare_app(self, anonymous=False, group_code=None, instance=True):
self.app.extra_environ = dict()
self.user = None
if not anonymous:
group = None
if group_code:
group = Group.by_code(group_code)
self.user = tt_make_user(instance_group=group)
self.app.extra_environ['REMOTE_USER'] = str(self.user.user_name)
if instance:
self.app.extra_environ['HTTP_HOST'] = "test.test.lan"
else:
self.app.extra_environ['HTTP_HOST'] = "test.lan"
def prepare_app(self, anonymous=False, group_code=None, instance=True):
self.app.extra_environ = dict()
self.user = None
if not anonymous:
group = None
if group_code:
group = Group.by_code(group_code)
self.user = tt_make_user(instance_group=group)
self.app.extra_environ['REMOTE_USER'] = str(self.user.user_name)
if instance:
self.app.extra_environ['HTTP_HOST'] = "test.test.lan"
else:
self.app.extra_environ['HTTP_HOST'] = "test.lan"
def test_members(self):
from adhocracy.model import Instance, Group
test_instance = Instance.find('test')
members = test_instance.members()
self.assertEqual(len(members), 1)
self.assertEqual(members[0].user_name, u'admin')
voters = Group.find(u'Voter')
tt_make_user(u'second', voters)
members = test_instance.members()
self.assertEqual(len(members), 2)
self.assertEqual(sorted([member.user_name for member in
test_instance.members()]),
['admin', 'second'])
def test_members(self):
from adhocracy.model import Instance, Group
test_instance = Instance.find('test')
members = test_instance.members()
self.assertEqual(len(members), 1)
self.assertEqual(members[0].user_name, u'admin')
voters = Group.find(u'Voter')
tt_make_user(u'second', voters)
members = test_instance.members()
self.assertEqual(len(members), 2)
self.assertEqual(
sorted([member.user_name for member in test_instance.members()]),
['admin', 'second'])
def main():
parser = create_parser(description=__doc__, use_instance=False)
parser.add_argument(
"username",
help=("The name of the user who should become a global admin"))
args = parser.parse_args()
load_from_args(args)
user = User.find(args.username)
if user is None:
print 'Cannot find user %s\n' % args.username
parser.exit()
global_membership = [membership for membership in user.memberships if
membership.instance is None][0]
admin_group = Group.by_code(Group.CODE_ADMIN)
global_membership.group = admin_group
meta.Session.commit()
def edit(self, id, errors=None, format=u'html'):
badge = self._get_badge_or_redirect(id)
data = {
'badge_type': self._get_badge_type(badge),
'badge_thumbnail': (
h.badge_helper.generate_thumbnail_tag(badge)
if getattr(badge, "thumbnail", None)
else None
),
'form_type': 'update',
'return_url': self.base_url,
'sorting_orders': PROPOSAL_SORTS,
}
self._set_parent_categories(exclude=badge)
# Plug in current values
instance_default = badge.instance.key if badge.instance else ''
defaults = dict(
title=badge.title,
description=badge.description,
color=badge.color,
visible=badge.visible,
display_group=badge.display_group,
impact=badge.impact,
instance=instance_default,
behavior_proposal_sort_order=badge.behavior_proposal_sort_order)
if isinstance(badge, UserBadge):
c.groups = Group.all_instance()
defaults['group'] = badge.group and badge.group.code or ''
if isinstance(badge, CategoryBadge):
defaults['parent'] = badge.parent and badge.parent.id or ''
defaults['select_child_description'] =\
badge.select_child_description
return htmlfill.render(render(self.form_template, data,
overlay=format == u'overlay'),
errors=errors,
defaults=defaults,
force_defaults=False)
def add(self, badge_type=None, errors=None, format=u''):
data = {
'form_type': 'add',
'groups': Group.all_instance(),
'sorting_orders': PROPOSAL_SORTS,
}
if badge_type is not None:
data['badge_type'] = badge_type
defaults = {'visible': True,
'select_child_description': '',
'impact': 0,
}
defaults.update(dict(request.params))
self._set_parent_categories()
html = render(self.form_template, data, overlay=format == u'overlay')
return htmlfill.render(html,
defaults=defaults,
errors=errors,
force_defaults=False)
def setUp(self):
voter_group = Group.by_code(Group.CODE_VOTER)
self.me = tt_make_user(instance_group=voter_group)
self.first = tt_make_user(instance_group=voter_group)
self.second = tt_make_user(instance_group=voter_group)
self.proposal = tt_make_proposal(voting=True)
def setUp(self):
voter_group = Group.by_code(Group.CODE_VOTER)
self.me = tt_make_user(instance_group=voter_group)
self.first = tt_make_user(instance_group=voter_group)
self.second = tt_make_user(instance_group=voter_group)
self.proposal = tt_make_proposal(voting=True)
