def create_project(badge_uri, author_uri, title, image_uri, work_url, description, reflection, tags):
if Project.objects.filter(author_uri=author_uri, badge_uri=badge_uri, date_deleted__isnull=True).exists():
raise MultipleProjectError('A user can only submit 1 project for a badge')
badge = badge_api.get_badge(badge_uri)
if author_uri in badge_api.get_badge_experts(badge_uri):
raise Exception(u'Badge {0} already awarded to user'.format(badge_uri))
if isinstance(tags, list):
tags = ','.join(tags)
project_db = Project(
title=title,
image_uri=image_uri,
work_url=work_url,
description=description,
reflection=reflection,
tags=tags,
badge_uri=badge_uri,
author_uri=author_uri,
date_created=datetime.utcnow(),
date_updated=datetime.utcnow()
)
project_db.save()
project = get_project(id2uri(project_db.id))
send_project_creation_notification(project)
experts = badge_api.get_badge_experts(project['badge_uri'])
send_project_creation_expert_notification(project, badge, experts)
return project
def test_award_badge(self):
badge = badge_api.create_badge(*self.badge_values)
self.assertNotIn(badge['author_uri'], badge_api.get_badge_experts(badge['uri']))
badge_api.publish_badge(badge['uri'])
kwargs = {
'badge_uri': badge['uri'],
'user_uri': badge['author_uri'],
'expert_uri': badge['author_uri'],
'evidence_url': 'http://some.evi/dence'
}
# test that the author have the badge
with self.assertRaisesRegexp(Exception, 'already awarded'):
badge_api.award_badge(**kwargs)
# test that non expert cannot award badge
kwargs['user_uri'] = '/uri/user/iwantbadge'
kwargs['expert_uri'] = '/uri/user/igivebadge'
with self.assertRaisesRegexp(Exception, 'Cannot award'):
badge_api.award_badge(**kwargs)
# test that expert can award badge
kwargs['expert_uri'] = badge['author_uri']
badge_api.award_badge(**kwargs)
self.assertIn(kwargs['user_uri'], badge_api.get_badge_experts(badge['uri']))
# test that badge awards triggers notifications
kwargs['user_uri'] = '/uri/user/ialsowantbadge'
with patch('notifications.models.send_notification') as send:
badge_api.award_badge(**kwargs)
self.assertTrue(send.called)
def submit_feedback(project_uri, expert_uri, good, bad, ugly):
project=Project.objects.get(id=uri2id(project_uri))
if not expert_uri in badge_api.get_badge_experts(project.badge_uri):
raise Exception('Only experts can submit feedback on projects.')
if not ready_for_feedback(project_uri):
raise Exception('No revision submitted since last feedback.')
feedback = Feedback(
project=project,
expert_uri=expert_uri,
good=good,
bad=bad,
ugly=ugly,
date_created=datetime.utcnow()
)
last_revision = None
if project.revision_set.count() > 0:
last_revision = project.revision_set.latest('date_created')
if last_revision:
feedback.revision = last_revision
feedback.save()
send_feedback_notification(get_project(project_uri))
def view( request, project_id ):
project = project_api.get_project(project_api.id2uri(project_id))
project = fetch_resources(project)
badge = badge_api.get_badge(project['badge_uri'])
badge = fetch_badge_resources(badge)
feedback = project_api.get_project_feedback(project['uri'])
can_revise = False
can_give_feedback = False
if request.session.get('user'):
user_uri = request.session['user']['uri']
if user_uri == project['author_uri']:
can_revise = project_api.can_revise_project(project['uri'])
can_give_feedback = project_api.ready_for_feedback(project['uri'])
can_give_feedback &= user_uri in badge_api.get_badge_experts(badge['uri'])
context = {
'project': project,
'badge': badge,
'feedback': feedback,
'can_revise': can_revise,
'can_give_feedback': can_give_feedback
}
return render_to_response(
'project/view.html',
context,
context_instance=RequestContext(request)
)
def view( request, badge_id ):
badge = badge_api.get_badge(badge_api.id2uri(badge_id))
fetch_badge_resources(badge)
context = {
'badge': badge
}
context['projects'] = map(fetch_resources, project_api.search_projects(badge_uri=badge['uri']))
context['experts'] = badge_api.get_badge_experts(badge['uri'])
return render_to_response(
'badge/view.html',
context,
context_instance=RequestContext(request)
)
def submit_feedback(project_uri, expert_uri, good, bad, ugly, award_badge=False):
"""
Checks if badge can be awarded and creates feedback
"""
project = Project.objects.get(id=uri2id(project_uri))
badge = get_badge(project.badge_uri)
result = submit_feedback_result.NOT_AWARDED
if not expert_uri in get_badge_experts(project.badge_uri):
raise Exception('Only experts can submit feedback on projects.')
if not ready_for_feedback(project_uri):
raise Exception('Badge has already been awarded to project.')
feedback = Feedback(
project=project,
expert_uri=expert_uri,
good=good,
bad=bad,
ugly=ugly,
date_created=datetime.utcnow(),
badge_awarded=False
)
if award_badge and can_badge_be_awarded(badge, expert_uri):
result = submit_feedback_result.AWARDED
feedback.badge_awarded = True
elif award_badge: #and badge requires approval by partner
result = submit_feedback_result.REQUIRES_APPROVAL
send_badge_needs_partner_feedback_notification(badge, _project2dict(project))
last_revision = None
if project.revision_set.count() > 0:
last_revision = project.revision_set.latest('date_created')
if last_revision:
feedback.revision = last_revision
feedback.save()
send_feedback_notification(get_project(project_uri))
#return _feedback2dict(feedback)
return result
def view( request, badge_id ):
badge = badge_api.get_badge(badge_api.id2uri(badge_id))
fetch_badge_resources(badge)
context = {
'badge': badge
}
context['projects'] = map(fetch_resources, project_api.search_projects(badge_uri=badge['uri']))
expert_uris = badge_api.get_badge_experts(badge['uri'])
if request.session.get('user'):
context['user_is_expert'] = request.session['user']['uri'] in expert_uris
context['experts'] = map(p2pu_user_api.get_user, expert_uris)
return render_to_response(
'badge/view.html',
context,
context_instance=RequestContext(request)
)
def view(request, badge_id):
badge = badge_api.get_badge(badge_api.id2uri(badge_id))
fetch_badge_resources(badge)
projects = project_api.search_projects_awarded_badges(badge_uri=badge['uri'])
for project in projects:
fetch_resources(project, feedback_list=project_api.get_project_feedback(project['uri']))
expert_uris = badge_api.get_badge_experts(badge['uri'])
user = request.session.get('user')
if user:
user['is_expert'] = user['uri'] in expert_uris
user['is_author'] = _user_is_author(badge, user)
if user['is_author']:
user['can_delete_badge'] = badge_api.is_allowed_to_remove(badge['uri'])
if user['is_expert']:
user['added_to_backpack'] = badge_api.pushed_to_backpack(badge, user['uri'])
projects_ready_for_feedback = project_api.get_projects_ready_for_feedback(badge['uri'])
for project in projects_ready_for_feedback:
feedback_list = project_api.get_project_feedback(project['uri'])
fetch_resources(project, feedback_list=feedback_list)
experts = map(p2pu_user_api.get_user, expert_uris)
iframe = '//%s%s?rendering=normal' % (settings.ORGANISATION_URL,
reverse('badge_view_embedded', args=[badge_id]))
return render_to_response(
'badge/badge_info/view.html', {
'user': user,
'badge': badge,
'projects': projects,
'projects_ready_for_feedback': projects_ready_for_feedback,
'experts': experts,
'iframe': iframe,
'organisation_url': settings.ORGANISATION_URL,
},
context_instance=RequestContext(request)
)
def view(request, badge_id):
badge = badge_api.get_badge(badge_api.id2uri(badge_id))
fetch_badge_resources(badge)
context = {'badge': badge}
context['projects'] = map(fetch_resources, project_api.search_projects_awarded_badges(badge_uri=badge['uri']))
expert_uris = badge_api.get_badge_experts(badge['uri'])
if request.session.get('user'):
context['user_is_expert'] = request.session['user']['uri'] in expert_uris
context['experts'] = map(p2pu_user_api.get_user, expert_uris)
context['iframe'] = 'http://%s%s?rendering=normal' % (settings.ORGANISATION_URL,
reverse('badge_view_embedded', args=[badge_id]))
return render_to_response(
'badge/view.html',
context,
context_instance=RequestContext(request)
)
def test_badge_awarded_from_nonpartner_expert(self):
#create a partner
partner = p2pu_user_api.create_partner('Test parnter')
# create partner badge
new_badge_values = self.badge_values.copy()
new_badge_values['partner_name'] = partner['name']
# create a parnter badge
badge = badge_api.create_badge(**new_badge_values)
badge_api.publish_badge(badge['uri'])
# submit a project for a badge
project_values = self.project_values.copy()
project_values['badge_uri'] = badge['uri']
project = project_api.create_project(**project_values)
# award badge as a partner
feedback = project_api.submit_feedback(
project['uri'],
badge['author_uri'],
'Good',
'Bad',
'Ugly',
award_badge=True
)
self.assertEquals(feedback, project_api.submit_feedback_result.AWARDED)
# award badge
# HACK - needs well revision on how to refactor in order to test cycle properly
if project_api.submit_feedback_result.AWARDED:
with patch('badge.models.send_badge_awarded_notification') as mock_notification:
badge_api.award_badge(badge['uri'], project_values['author_uri'], badge['author_uri'], 'http://project.org/url')
self.assertIn(project_values['author_uri'], badge_api.get_badge_experts(badge['uri']))
# submit another project for a badge
another_project_values = {
'badge_uri': badge['uri'],
'author_uri': '/uri/user/anotheruser',
'title': 'Test Second Title',
'image_uri': '/uri/image/2',
'work_url': 'http://project.org/url',
'description': 'Did the test second time',
'reflection': 'Will not do it earlier and more next time',
'tags': ['test', 'tdd', 'bdd'],
}
project = project_api.create_project(**another_project_values)
# award badge as a non partner
feedback = project_api.submit_feedback(
project['uri'],
'/uri/user/testuser',
'Good',
'Bad',
'Ugly',
award_badge=True
)
self.assertEquals(feedback, project_api.submit_feedback_result.REQUIRES_APPROVAL)
# award badge as partner
feedback = project_api.submit_feedback(
project['uri'],
badge['author_uri'],
'Good',
'Bad',
'Ugly',
award_badge=True
)
self.assertEquals(feedback, project_api.submit_feedback_result.AWARDED)
# test that feedback can not be given anymore
with self.assertRaises(Exception):
project_api.submit_feedback(
project['uri'],
badge['author_uri'],
'Good',
'Bad',
'Ugly',
award_badge=True
)
# test that revision can not be given any longer either
with self.assertRaises(Exception):
project_api.revise_project(project['uri'], 'Some improvement')
