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_get_parent_badges_with_hierarchy(self):
from adhocracy.model import CategoryBadge
from adhocracy.lib.helpers.badge_helper import get_parent_badges
badge0 = CategoryBadge.create('testbadge0', '#ccc', True, 'descr')
badge11 = CategoryBadge.create('testbadge11', '#ccc', True, 'descr')
badge12 = CategoryBadge.create('testbadge12', '#ccc', True, 'descr')
badge121 = CategoryBadge.create('testbadge121', '#ccc', True, 'descr')
badge11.parent = badge0
badge12.parent = badge0
badge121.parent = badge12
result = [b.title for b in get_parent_badges(badge121)]
shouldbe = ['testbadge12', 'testbadge0']
self.assertEqual(result, shouldbe)
def test_entity_to_solr_token_with_hierachy(self):
from adhocracy.model import CategoryBadge
from adhocracy.lib.pager import entity_to_solr_token
badge0 = CategoryBadge.create('testbadge0', '#ccc', True, 'descr')
badge11 = CategoryBadge.create('testbadge11', '#ccc', True, 'descr')
badge12 = CategoryBadge.create('testbadge12', '#ccc', True, 'descr')
badge121 = CategoryBadge.create('testbadge121', '#ccc', True, 'descr')
badge11.parent = badge0
badge12.parent = badge0
badge121.parent = badge12
result = entity_to_solr_token(badge121)
shouldbe = u"%s/%s/%s" % (str(badge0.id), str(badge12.id),
str(badge121.id))
self.assertEqual(result, shouldbe)
def test_get_parent_badges_with_hierarchy(self):
from adhocracy.model import CategoryBadge
from adhocracy.lib.helpers.badge_helper import get_parent_badges
badge0 = CategoryBadge.create(u'testbadge0', u'#ccc', True, u'descr')
badge11 = CategoryBadge.create(u'testbadge11', u'#ccc', True, u'descr')
badge12 = CategoryBadge.create(u'testbadge12', u'#ccc', True, u'descr')
badge121 = CategoryBadge.create(u'testbadge121', u'#ccc', True,
u'descr')
badge11.parent = badge0
badge12.parent = badge0
badge121.parent = badge12
result = [b.title for b in get_parent_badges(badge121)]
shouldbe = ['testbadge12', u'testbadge0']
self.assertEqual(result, shouldbe)
def test_solr_token_to_entity_no_hierachy(self):
from adhocracy.model import CategoryBadge
from adhocracy.lib.pager import solr_tokens_to_entities
badge = CategoryBadge.create('testbadge', '#ccc', True, 'description')
token = u"%s" % str(badge.id)
self.assertEqual(solr_tokens_to_entities([token], CategoryBadge), [badge])
wrongtoken = "1A"
self.assertEqual(solr_tokens_to_entities([wrongtoken], CategoryBadge), [])
def test_valid_category_badge(self):
from formencode import Invalid
from adhocracy.forms import ValidCategoryBadge
from adhocracy.model import CategoryBadge, instance_filter
# the currently set instance ist the test instance. CategoryBadges from
# the current instance are valid.
test_instance = tt_get_instance()
self.assertEqual(test_instance, instance_filter.get_instance())
test_category = CategoryBadge.create("test_category", "#ccc", "description", test_instance)
value = ValidCategoryBadge.to_python(str(test_category.id))
self.assertEqual(value, test_category)
# from other instances they are not valid
other_instance = tt_make_instance("other", "Other Instance")
other_category = CategoryBadge.create("other_category", "#ccc", "description", other_instance)
self.assertRaises(Invalid, ValidCategoryBadge.to_python, str(other_category.id))
def test_create_milestone_with_category(self):
from adhocracy.model import CategoryBadge
milestone, creator = _make_one(u'title', u'text')
category = CategoryBadge.create(u'Category', u'#ccc', True,
u'descripiton', milestone.instance)
milestone.category = category
self.assertEqual(milestone.category.id, category.id)
self.assertEqual(category.milestones, [milestone])
def test_create_milestone_with_category(self):
from adhocracy.model import CategoryBadge
milestone, creator = _make_one(u'title', u'text')
category = CategoryBadge.create(u'Category', u'#ccc', True,
u'descripiton', 0, milestone.instance)
milestone.category = category
self.assertEqual(milestone.category.id, category.id)
self.assertEqual(category.milestones, [milestone])
def test_solr_token_to_entity_with_hierachy(self):
from adhocracy.model import CategoryBadge
from adhocracy.lib.pager import solr_tokens_to_entities
badge = CategoryBadge.create(u'testbadge', u'#ccc', True,
u'description')
token = u"1/2/%s" % str(badge.id)
self.assertEqual(solr_tokens_to_entities([token], CategoryBadge),
[badge])
def test_create_milestone_with_category(self):
from adhocracy.model import CategoryBadge
milestone, creator = _make_one(u"title", u"text")
category = CategoryBadge.create(u"Category", u"#ccc", u"descripiton", milestone.instance)
milestone.category = category
self.assertEqual(milestone.category.id, category.id)
self.assertEqual(category.milestones, [milestone])
def create_category_badge(self):
try:
self.form_result = CategoryBadgeForm().to_python(request.params)
except Invalid as i:
return self.add('category', i.unpack_errors())
title, color, visible, description, impact, instance =\
self._get_common_fields(self.form_result)
child_descr = self.form_result.get("select_child_description")
child_descr = child_descr.replace("$badge_title", title)
parent = self.form_result.get("parent")
if parent and parent.id == id:
parent = None
CategoryBadge.create(title, color, visible, description, impact,
instance, parent=parent,
select_child_description=child_descr)
# commit cause redirect() raises an exception
meta.Session.commit()
redirect(self.base_url)
def _make_content(self):
"""Returns creator, delegateable and badge"""
from adhocracy.model import CategoryBadge, Proposal, Instance
instance = Instance.find(u'test')
creator = tt_make_user(u'creator')
delegateable = Proposal.create(instance, u"labeld", creator)
badge = CategoryBadge.create(u'testbadge', u'#ccc', True,
u'description')
return creator, delegateable, badge
def test_valid_category_badge(self):
from formencode import Invalid
from adhocracy.forms import ValidCategoryBadge
from adhocracy.model import CategoryBadge, instance_filter
# the currently set instance ist the test instance. CategoryBadges from
# the current instance are valid.
test_instance = tt_get_instance()
self.assertEqual(test_instance, instance_filter.get_instance())
test_category = CategoryBadge.create('test_category', '#ccc',
'description', test_instance)
value = ValidCategoryBadge.to_python(str(test_category.id))
self.assertEqual(value, test_category)
# from other instances they are not valid
other_instance = tt_make_instance('other', 'Other Instance')
other_category = CategoryBadge.create('other_category', '#ccc',
'description', other_instance)
self.assertRaises(Invalid, ValidCategoryBadge.to_python,
str(other_category.id))
def _set_parent_categories(self, exclude=None):
local_categories = CategoryBadge.all_q(instance=c.instance)
if exclude is not None:
local_categories = filter(lambda c: not(c.is_ancester(exclude)),
local_categories)
c.local_category_parents = sorted(
[(b.id, b.get_key()) for b in local_categories],
key=lambda x: x[1])
if h.has_permission('global.admin'):
global_categories = CategoryBadge.all_q(instance=None)
if exclude is not None:
global_categories = filter(
lambda c: not(c.is_ancester(exclude)), global_categories)
c.global_category_parents = sorted(
[(b.id, b.get_key()) for b in global_categories],
key=lambda x: x[1])
def _to_python(self, value, state):
from adhocracy.model import CategoryBadge
try:
value = int(value)
except:
pass
badge = CategoryBadge.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 _make_content(self):
"""Returns creator, delegateable and badge"""
from adhocracy.model import CategoryBadge, Proposal, Instance
instance = Instance.find('test')
creator = tt_make_user('creator')
delegateable = Proposal.create(instance, u"labeld", creator)
badge = CategoryBadge.create(u'testbadge', u'#ccc', True,
'description')
return creator, delegateable, badge
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_to_dict(self):
from adhocracy.model import CategoryBadge, Instance
instance = Instance.find('test')
badge = CategoryBadge.create(u'badge', u'#ccc', u'description',
instance=instance)
result = badge.to_dict()
result = sorted(result.items())
expected = {'title': u'badge',
'color': u'#ccc',
'description': u'description',
'id': 1,
'instance': instance.id}
expected = sorted(expected.items())
self.assertEqual(result, expected)
def test_categorybadges_hierarchy(self):
#setup
from adhocracy.model import CategoryBadge
creator, delegateable, badge = self._make_content()
badge_parent = CategoryBadge.create(u'badge parent', u'#ccc', True,
'description')
badge_parent.select_child_description = "choose child"
# create the delegateable badge
badge.assign(delegateable, creator)
# add parent badge
badge.parent = badge_parent
self.assertEqual(badge.parent, badge_parent)
self.assertTrue(badge in badge_parent.children)
self.assertEqual(badge_parent.select_child_description, "choose child")
self.assertTrue(badge_parent.parent is None)
def test_categorybadges_hierarchy(self):
# setup
from adhocracy.model import CategoryBadge
creator, delegateable, badge = self._make_content()
badge_parent = CategoryBadge.create(u'badge parent', u'#ccc', True,
u'description')
badge_parent.select_child_description = u"choose child"
# create the delegateable badge
badge.assign(delegateable, creator)
# add parent badge
badge.parent = badge_parent
self.assertEqual(badge.parent, badge_parent)
self.assertTrue(badge in badge_parent.children)
self.assertEqual(badge_parent.select_child_description,
u"choose child")
self.assertTrue(badge_parent.parent is None)
def test_to_dict(self):
from adhocracy.model import CategoryBadge, Instance
instance = Instance.find('test')
badge = CategoryBadge.create(u'badge',
u'#ccc',
u'description',
instance=instance)
result = badge.to_dict()
result = sorted(result.items())
expected = {
'title': u'badge',
'color': u'#ccc',
'description': u'description',
'id': 1,
'instance': instance.id
}
expected = sorted(expected.items())
self.assertEqual(result, expected)
def test_create_milestone_with_category_that_changes_instance(self):
from adhocracy.model import CategoryBadge, meta
milestone, creator = _make_one(u'title', u'text')
category = CategoryBadge.create(u'Category', u'#ccc', True,
u'descripiton', milestone.instance)
milestone.category = category
self.assertEqual(milestone.category.id, category.id)
self.assertEqual(category.milestones, [milestone])
# after we set another instance for the category (and refreshed
# the objects in the Session), the milestone no longer has a category.
other_instance = tt_make_instance(u'other', u'Other Label')
category.instance = other_instance
meta.Session.flush()
meta.Session.refresh(milestone)
meta.Session.refresh(category)
self.assertNotEqual(category.instance, milestone.instance)
self.assertEqual(milestone.category, None)
self.assertEqual(category.milestones, [])
def test_create_milestone_with_category_that_changes_instance(self):
from adhocracy.model import CategoryBadge, meta
milestone, creator = _make_one(u'title', u'text')
category = CategoryBadge.create(u'Category', u'#ccc', True,
u'descripiton', 0, milestone.instance)
milestone.category = category
self.assertEqual(milestone.category.id, category.id)
self.assertEqual(category.milestones, [milestone])
# after we set another instance for the category (and refreshed
# the objects in the Session), the milestone no longer has a category.
other_instance = tt_make_instance(u'other', u'Other Label')
category.instance = other_instance
meta.Session.flush()
meta.Session.refresh(milestone)
meta.Session.refresh(category)
self.assertNotEqual(category.instance, milestone.instance)
self.assertEqual(milestone.category, None)
self.assertEqual(category.milestones, [])
def _to_python(self, value, state):
from adhocracy.model import CategoryBadge
try:
value = int(value)
except:
pass
badge = CategoryBadge.by_id(value, instance_filter=False)
if badge is None:
raise formencode.Invalid(
_("No Badge ID '%s' exists") % value, value, state)
if badge.instance is None and c.instance is not None\
and c.instance.hide_global_categories:
raise formencode.Invalid(
_("Cannot use global category %s in this instance") % value,
value, state)
if badge.instance not in [None, c.instance]:
raise formencode.Invalid(
_("Badge with ID '%s' not valid in this instance") % value,
value, state)
return badge
def _to_python(self, value, state):
from adhocracy.model import CategoryBadge
try:
value = int(value)
except:
pass
badge = CategoryBadge.by_id(value, instance_filter=False)
if badge is None:
raise formencode.Invalid(
_("No Badge ID '%s' exists") % value,
value, state)
if badge.instance is None and c.instance.hide_global_categories:
raise formencode.Invalid(
_("Cannot use global category %s in this instance") % value,
value, state)
if badge.instance not in [None, c.instance]:
raise formencode.Invalid(
_("Badge with ID '%s' not valid in this instance") % value,
value, state)
return badge
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 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)
