def _available_badges(self):
'''
Return the badges that are editable by a user.
'''
c.groups = [{'permission': 'global.admin',
'label': _('In all instances'),
'show_label': True}]
if c.instance:
c.groups.append(
{'permission': 'instance.admin',
'label': _('In instance "%s"') % c.instance.label,
'show_label': h.has_permission('global.admin')})
badges = {}
if has('global.admin'):
badges['global.admin'] = {
'instance': InstanceBadge.all(instance=None),
'user': UserBadge.all(instance=None),
'delegateable': DelegateableBadge.all(instance=None),
'category': CategoryBadge.all(instance=None),
'thumbnail': ThumbnailBadge.all(instance=None)}
if has('instance.admin') and c.instance is not None:
badges['instance.admin'] = {
'instance': InstanceBadge.all(instance=c.instance),
'user': UserBadge.all(instance=c.instance),
'delegateable': DelegateableBadge.all(instance=c.instance),
'category': CategoryBadge.all(instance=c.instance),
'thumbnail': ThumbnailBadge.all(instance=c.instance)}
return badges
def test_valid_badge(self):
from adhocracy.forms import ValidBadge
from adhocracy.model import Badge, UserBadge
creator = tt_make_user('creator')
badged_user = tt_make_user('badged_user')
badge = Badge.create('testbadge', '#ccc', 'description')
UserBadge.create(badged_user, badge, creator)
value = ValidBadge.to_python(badge.id, None)
self.assertEqual(value, badge)
def _make_one(self):
"""Returns creator, badged user and badge"""
from adhocracy.model import Badge, UserBadge
creator = tt_make_user('creator')
badged_user = tt_make_user('badged_user')
badge = Badge.create(u'testbadge', u'#ccc', u'description')
UserBadge.create(badged_user, badge, creator)
return creator, badged_user, badge
def valid_userbadge(title, instance=None):
invited_badge = UserBadge.find_by_instance(title, instance)
if invited_badge is None:
invited_badge = UserBadge.create(title,
u'#000000',
False,
u'This user has been invited',
instance=instance)
print(u"Badge %r created" % invited_badge)
return invited_badge
def test_valid_badge(self):
from adhocracy.forms import ValidBadge
from adhocracy.model import Badge, UserBadge
creator = tt_make_user('creator')
badged_user = tt_make_user('badged_user')
badge = Badge.create('testbadge', '#ccc', 'description')
UserBadge.create(badged_user, badge, creator)
value = ValidBadge.to_python(badge.id, None)
self.assertEqual(value, badge)
def _make_one(self):
"""Returns creator, badged user and badge"""
from adhocracy.model import Badge, UserBadge
creator = tt_make_user("creator")
badged_user = tt_make_user("badged_user")
badge = Badge.create(u"testbadge", u"#ccc", u"description")
UserBadge.create(badged_user, badge, creator)
return creator, badged_user, badge
def test_invalid_badge(self):
from formencode import Invalid
from adhocracy.forms import ValidBadge
from adhocracy.model import Badge, UserBadge
creator = tt_make_user('creator')
badged_user = tt_make_user('badged_user')
badge = Badge.create('testbadge', '#ccc', 'description')
UserBadge.create(badged_user, badge, creator)
self.assertRaises(Invalid, ValidBadge.to_python,
badge.id + 1, state=None)
def test_invalid_badge(self):
from formencode import Invalid
from adhocracy.forms import ValidBadge
from adhocracy.model import Badge, UserBadge
creator = tt_make_user('creator')
badged_user = tt_make_user('badged_user')
badge = Badge.create('testbadge', '#ccc', 'description')
UserBadge.create(badged_user, badge, creator)
self.assertRaises(Invalid,
ValidBadge.to_python,
badge.id + 1,
state=None)
def create_user_badge(self):
try:
self.form_result = UserBadgeForm().to_python(request.params)
except Invalid as i:
return self.add('user', i.unpack_errors())
title, color, visible, description, impact, instance =\
self._get_common_fields(self.form_result)
group = self.form_result.get('group')
display_group = self.form_result.get('display_group')
UserBadge.create(title, color, visible, description, group,
display_group, impact, instance)
# commit cause redirect() raises an exception
meta.Session.commit()
redirect(self.base_url)
def test_valid_user_badge(self):
from adhocracy.forms import ValidUserBadge
from adhocracy.model import UserBadge
badge = UserBadge.create(u'testbadge', u'#ccc', True, u'description')
value = ValidUserBadge.to_python(badge.id, None)
self.assertEqual(value, badge)
def test_valid_user_badge(self):
from adhocracy.forms import ValidUserBadge
from adhocracy.model import UserBadge
badge = UserBadge.create(u'testbadge', u'#ccc', True, u'description')
value = ValidUserBadge.to_python(badge.id, None)
self.assertEqual(value, badge)
def _to_python(self, value, state):
from adhocracy.model import UserBadge
badge = UserBadge.by_id(value, instance_filter=False)
if badge is None or badge.instance not in [None, c.instance]:
raise formencode.Invalid(
_("No Badge ID '%s' exists") % value, value, state)
return badge
def test_get_parent_badges_no_hierarchy(self):
from adhocracy.model import UserBadge
from adhocracy.lib.helpers.badge_helper import get_parent_badges
badge = UserBadge.create(u'testbadge', u'#ccc', True, u'description')
result = [b.title for b in get_parent_badges(badge)]
shouldbe = []
self.assertEqual(result, shouldbe)
def test_get_parent_badges_no_hierarchy(self):
from adhocracy.model import UserBadge
from adhocracy.lib.helpers.badge_helper import get_parent_badges
badge = UserBadge.create(u'testbadge', u'#ccc', True, u'description')
result = [b.title for b in get_parent_badges(badge)]
shouldbe = []
self.assertEqual(result, shouldbe)
def test_valid_user_badge(self):
from adhocracy.forms import ValidUserBadge
from adhocracy.model import UserBadge
badge = UserBadge.create("testbadge", "#ccc", "description")
value = ValidUserBadge.to_python(badge.id, None)
self.assertEqual(value, badge)
def test_invalid_user_badge(self):
from formencode import Invalid
from adhocracy.forms import ValidUserBadge
from adhocracy.model import UserBadge
badge = UserBadge.create("testbadge", "#ccc", "description")
self.assertRaises(Invalid, ValidUserBadge.to_python, badge.id + 1, state=None)
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 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 _to_python(self, value, state):
from adhocracy.model import UserBadge
badge = UserBadge.by_id(value)
if not badge:
raise formencode.Invalid(
_("No Badge ID '%s' exists") % value, value, state)
return badge
def _to_python(self, value, state):
from adhocracy.model import UserBadge
if value is None or value == '':
return []
labels = [l.strip() for l in value.split(',')]
if len(labels) != len(set(labels)):
raise formencode.Invalid(
_("Duplicates in input set of user badge labels"),
value, state)
badges = set()
missing = set()
for label in labels:
badge = UserBadge.find(label, instance_filter=self.instance_filter)
if badge is None:
missing.add(label)
else:
badges.add(badge)
if missing:
raise formencode.Invalid(
_("Could not find badges %s") % ','.join(missing),
value, state)
else:
return badges
def _to_python(self, value, state):
from adhocracy.model import UserBadge
if value is None:
if self.not_empty:
raise formencode.Invalid(_('No badges selected'), value, state)
return []
if isinstance(value, (str, unicode)):
value = [value]
if len(value) != len(set(value)):
raise formencode.Invalid(
_("Duplicates in input set of user badge IDs"),
value, state)
if self.not_empty and not value:
raise formencode.Invalid(_('No badges selected'), value, state)
badges = UserBadge.findall_by_ids(value)
if len(badges) != len(value):
missing = set(value).difference(b.id for b in badges)
raise formencode.Invalid(
_("Could not find badges %s") % ','.join(map(str, missing)),
value, state)
return badges
def test_entity_to_solr_token_no_hierachy(self):
from adhocracy.model import UserBadge
from adhocracy.lib.pager import entity_to_solr_token
badge = UserBadge.create('testbadge', '#ccc', True, 'description')
result = entity_to_solr_token(badge)
shouldbe = u"%s" % str(badge.id)
self.assertEqual(result, shouldbe)
def test_we_already_have_two_userbadges(self):
"""
Due to the setup code in `adhocracy.lib.install` and the definition
of example user badges in `test.ini` for the Shibboleth tests, we
already have two badges from the beginning.
"""
from adhocracy.model import UserBadge
self.assertEqual(len(UserBadge.all()), 2)
def _to_python(self, value, state):
from adhocracy.model import UserBadge
badge = UserBadge.by_id(value)
if not badge:
raise formencode.Invalid(
_("No Badge ID '%s' exists") % value,
value, state)
return badge
def _to_python(self, value, state):
from adhocracy.model import UserBadge
badge = UserBadge.by_id(value, instance_filter=False)
if badge is None or badge.instance not in [None, c.instance]:
raise formencode.Invalid(
_("No Badge ID '%s' exists") % value,
value, state)
return badge
def test_assignment(self):
b = UserBadge.create(u'all users - ' + tt_make_str(), u'', False, u'')
t = Treatment.create(tt_make_str(), source_badges=[b], variant_count=2)
sb, assignments, unassigned = get_assignments_by_source_badge(t)[0]
assert sb == b
ass1, ass2 = assignments
assert len(ass1) == 0
assert len(ass2) == 0
assert len(unassigned) == 0
first_users = [tt_make_user() for _ in range(5)]
for u in first_users:
b.assign(u, u)
# sanity check
assert set(u.id for u in b.users) == set(u.id for u in first_users)
sb, assignments, unassigned = get_assignments_by_source_badge(t)[0]
assert sb == b
ass1, ass2 = assignments
assert len(ass1) == 0
assert len(ass2) == 0
assert len(unassigned) == len(first_users)
assert assign_users(t)
sb, assignments, unassigned = get_assignments_by_source_badge(t)[0]
assert sb == b
ass1, ass2 = assignments
assert len(ass1) + len(ass2) == len(first_users)
assert (len(ass1) == len(ass2) - 1) or (len(ass1) == len(ass2) + 1)
assert len(unassigned) == 0
assert not assign_users(t)
new_users = [tt_make_user() for _ in range(5)]
for u in new_users:
b.assign(u, u)
sb, assignments, unassigned = get_assignments_by_source_badge(t)[0]
assert sb == b
ass1, ass2 = assignments
assert len(ass1) + len(ass2) == len(first_users)
assert (len(ass1) == len(ass2) - 1) or (len(ass1) == len(ass2) + 1)
assert len(unassigned) == len(new_users)
assert assign_users(t)
sb, assignments, unassigned = get_assignments_by_source_badge(t)[0]
assert sb == b
ass1, ass2 = assignments
assert len(ass1) + len(ass2) == len(first_users) + len(new_users)
# The following assert is disabled as it fails non-deterministically
# (see #601). It can be reenabled once this issue is fixed.
#assert len(ass1) == len(ass2)
assert len(unassigned) == 0
assert not assign_users(t)
def test_invalid_user_badge(self):
from formencode import Invalid
from adhocracy.forms import ValidUserBadge
from adhocracy.model import UserBadge
badge = UserBadge.create(u'testbadge', u'#ccc', True, u'description')
self.assertRaises(Invalid,
ValidUserBadge.to_python,
badge.id + 1,
state=None)
def test_get_all_badgets(self):
#setup
from adhocracy.model import Badge, CategoryBadge, DelegateableBadge, \
InstanceBadge
from adhocracy.model import UserBadge, Instance
instance = Instance.find(u'test')
# create for each type a global scope and an instance scope badge
InstanceBadge.create(u'badge ü', u'#ccc', u'description ü')
InstanceBadge.create(u'badge ü', u'#ccc', u'description ü',
instance=instance)
UserBadge.create(u'badge ü', u'#ccc', u'description ü')
UserBadge.create(u'ü', u'#ccc', u'ü', instance=instance)
DelegateableBadge.create(u'badge ü', u'#ccc', u'description ü')
DelegateableBadge.create(u'badge ü', u'#ccc', u'description ü',
instance=instance)
CategoryBadge.create(u'badge ü', u'#ccc', u"desc")
CategoryBadge.create(u'badge ü', u'#ccc', u"desc", instance=instance)
# all instance badges
self.assert_(len(InstanceBadge.all()) == 1)
self.assert_(len(InstanceBadge.all(instance=instance)) == 1)
# all delegateable badges
self.assert_(len(DelegateableBadge.all()) == 1)
self.assert_(len(DelegateableBadge.all(instance=instance)) == 1)
# all delegateable category badges
self.assert_(len(CategoryBadge.all()) == 1)
self.assert_(len(CategoryBadge.all(instance=instance)) == 1)
# all user badgets
self.assert_(len(UserBadge.all()) == 1)
self.assert_(len(UserBadge.all(instance=instance)) == 1)
# We can get all Badges by using `Badge`
self.assert_(len(Badge.all()) == 4)
self.assert_(len(Badge.all(instance=instance)) == 4)
self.assert_(len(Badge.all_q().all()) == 8)
def test_get_all_badges(self):
# setup
from adhocracy.model import Badge, CategoryBadge, DelegateableBadge, \
InstanceBadge, ThumbnailBadge
from adhocracy.model import UserBadge, Instance
instance = Instance.find(u'test')
# create for each type a global scope and an instance scope badge
InstanceBadge.create(u'badge ü', u'#ccc', True, u'description ü')
InstanceBadge.create(u'badge ü', u'#ccc', True, u'description ü',
instance=instance)
UserBadge.create(u'badge ü', u'#ccc', True, u'description ü')
UserBadge.create(u'ü', u'#ccc', True, u'ü', instance=instance)
DelegateableBadge.create(u'badge ü', u'#ccc', True, u'description ü')
DelegateableBadge.create(u'badge ü', u'#ccc', True, u'description ü',
instance=instance)
CategoryBadge.create(u'badge ü', u'#ccc', True, u"desc")
CategoryBadge.create(u'badge ü', u'#ccc', True, u"desc",
instance=instance)
ThumbnailBadge.create(u'badge ü', u'#ccc', True, u"desc",
thumbnail=b'binary')
ThumbnailBadge.create(u'badge ü', u'#ccc', True, u"desc",
thumbnail=b'binary', instance=instance)
# all instance badges
self.assertEqual(len(InstanceBadge.all()), 1)
self.assertEqual(len(InstanceBadge.all(instance=instance)), 1)
# all delegateable badges
self.assertEqual(len(DelegateableBadge.all()), 1)
self.assertEqual(len(DelegateableBadge.all(instance=instance)), 1)
# all delegateable category badges
self.assertEqual(len(CategoryBadge.all()), 1)
self.assertEqual(len(CategoryBadge.all(instance=instance)), 1)
# all delegateable thumbnail badges
self.assertEqual(len(ThumbnailBadge.all()), 1)
self.assertEqual(len(ThumbnailBadge.all(instance=instance)), 1)
# all user badges
self.assertEqual(len(UserBadge.all()), 3)
self.assertEqual(len(UserBadge.all(instance=instance)), 1)
# We can get all Badges by using `Badge`
self.assertEqual(len(Badge.all()), 7)
self.assertEqual(len(Badge.all(instance=instance)), 5)
self.assertEqual(len(Badge.all_q().all()), 12)
def new(self, id=None, errors={}):
if id is None:
require.perm('global.message')
template = '/massmessage/new.html'
else:
c.page_instance = InstanceController._get_current_instance(id)
require.message.create(c.page_instance)
c.settings_menu = InstanceController.settings_menu(c.page_instance,
'massmessage')
template = '/instance/settings_massmessage.html'
defaults = dict(request.params)
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),
defaults=defaults, errors=errors,
force_defaults=False)
def test_get_all_badgets(self):
#setup
from adhocracy.model import Badge, CategoryBadge, DelegateableBadge, \
InstanceBadge
from adhocracy.model import UserBadge, Instance
instance = Instance.find(u'test')
# create for each type a global scope and an instance scope badge
InstanceBadge.create(u'badge ü', u'#ccc', u'description ü')
InstanceBadge.create(u'badge ü',
u'#ccc',
u'description ü',
instance=instance)
UserBadge.create(u'badge ü', u'#ccc', u'description ü')
UserBadge.create(u'ü', u'#ccc', u'ü', instance=instance)
DelegateableBadge.create(u'badge ü', u'#ccc', u'description ü')
DelegateableBadge.create(u'badge ü',
u'#ccc',
u'description ü',
instance=instance)
CategoryBadge.create(u'badge ü', u'#ccc', u"desc")
CategoryBadge.create(u'badge ü', u'#ccc', u"desc", instance=instance)
# all instance badges
self.assert_(len(InstanceBadge.all()) == 1)
self.assert_(len(InstanceBadge.all(instance=instance)) == 1)
# all delegateable badges
self.assert_(len(DelegateableBadge.all()) == 1)
self.assert_(len(DelegateableBadge.all(instance=instance)) == 1)
# all delegateable category badges
self.assert_(len(CategoryBadge.all()) == 1)
self.assert_(len(CategoryBadge.all(instance=instance)) == 1)
# all user badgets
self.assert_(len(UserBadge.all()) == 1)
self.assert_(len(UserBadge.all(instance=instance)) == 1)
# We can get all Badges by using `Badge`
self.assert_(len(Badge.all()) == 4)
self.assert_(len(Badge.all(instance=instance)) == 4)
self.assert_(len(Badge.all_q().all()) == 8)
def valid_userbadge(title, instance=None):
invited_badge = UserBadge.find_by_instance(title, instance)
if invited_badge is None:
invited_badge = UserBadge.create(title, u"#000000", False, u"This user has been invited", instance=instance)
print (u"Badge %r created" % invited_badge)
return invited_badge
