def get_assertion(request, uid):
"""
Handle badge assertion requests.
"""
award = get_object_or_404(Award, pk=uid)
if award.ob_state=='REVOKED':
return HttpResponseGone('{"revoked": true}', mimetype="application/json")
badge = award.badge
recipient_email = get_user(award.user_uri)['email']
image = get_image(badge.image_uri)
assertion = create_assertion_from_template(
uid = uid,
recipient_email = recipient_email,
image = image['url'],
evidence = award.evidence_url,
issued_on = award.date_awarded,
badge_id = badge.pk,
)
json_assertion = json.dumps(assertion)
print json_assertion
return HttpResponse(json_assertion, mimetype="application/json")
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'])
for fb in feedback:
if fb.get('expert_uri'):
fb['expert'] = p2pu_user_api.get_user(fb['expert_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 fetch_resources(project, feedback_list=None):
project['image'] = get_image(project['image_uri'])
project['author'] = get_user(project['author_uri'])
project['badge'] = get_badge(project['badge_uri'])
fetch_badge_resources(project['badge'])
if feedback_list:
add_feedback_to_project(feedback_list, project)
return project
def edit(request, badge_id):
user_uri = request.session['user']['uri']
user = p2pu_user_api.get_user(user_uri)
user_partner = user['partner']
badge = badge_api.get_badge(badge_api.id2uri(badge_id))
if not user_uri == badge['author_uri']:
messages.error(request, _('You cannot edit someone elses badge!'))
return http.HttpResponseRedirect(reverse(
'badge_preview', args=(badge_id,)
))
if request.method == 'POST':
form = BadgeForm(request.POST, request.FILES, user_uri=user_uri, editing=True, published=badge['published'])
else:
form = BadgeForm(badge, user_uri=user_uri, editing=True, published=badge['published'])
if request.method == 'POST' and form.is_valid():
try:
updated = {}
if 'image_uri' in request.FILES:
image = media_api.upload_image(
request.FILES['image_uri'],
request.session['user']['uri'],
media_root=settings.MEDIA_ROOT,
)
updated['image_uri'] = image['uri']
for attr in ['title', 'description', 'requirements']:
if not badge[attr] == form.cleaned_data[attr]:
updated[attr] = form.cleaned_data[attr]
badge = badge_api.update_badge(badge['uri'], **updated)
if badge['published']:
return http.HttpResponseRedirect(
reverse('badge_view', args=(badge_api.uri2id(badge['uri']),))
)
return http.HttpResponseRedirect(
reverse('badge_preview', args=(badge_api.uri2id(badge['uri']),))
)
except badge_api.DuplicateTitleError:
form.errors['title'] = [_('Badge title needs to be unique'), ]
return render_to_response(
'badge/badge_info/edit.html', {
'badge': badge,
'form': form,
'user_is_partner': user_partner,
'existing_img': media_api.get_image(badge['image_uri']),
},
context_instance=RequestContext(request))
def _feedback2dict(feedback):
json = {
'expert_uri': feedback.expert_uri,
'expert': p2pu_user_api.get_user(feedback.expert_uri),
'good': feedback.good,
'bad': feedback.bad,
'ugly': feedback.ugly,
'date_created': feedback.date_created,
'badge_awarded': feedback.badge_awarded,
}
return json
def profile_feedback(request, username):
user = user_api.get_user(user_api.username2uri(username))
user = check_if_owner(request.session.get('user', default=None), username, user)
projects = list_projects_that_user_gave_feedback(user['uri'])
return render_to_response(
'dashboard/dashboard_feedback.html', {
'user': user,
'projects': projects,
},
context_instance=RequestContext(request)
)
def profile(request, username ):
context = {}
user_uri = u'/uri/user/{0}'.format(username)
context['draft_badges'] = badge_api.get_user_draft_badges(user_uri)
context['earned_badges'] = badge_api.get_user_earned_badges(user_uri)
context['created_badges'] = badge_api.get_user_created_badges(user_uri)
context['awarded_badges'] = badge_api.get_user_awarded_badges(user_uri)
map(fetch_badge_resources, context['draft_badges'])
map(fetch_badge_resources, context['earned_badges'])
map(fetch_badge_resources, context['created_badges'])
map(fetch_badge_resources, context['awarded_badges'])
context['feedback_your_projects'] = project_api.search_projects(author_uri=user_uri)
map(fetch_resources, context['feedback_your_projects'])
peer_projects = []
feedback_latest = []
for badge in context['earned_badges']:
feedback_latest += project_api.get_projects_ready_for_feedback(badge['uri'])
peer_projects += project_api.search_projects(badge_uri=badge['uri'])
filter_func = lambda project: not project['author_uri'] == user_uri
peer_projects = filter(filter_func, peer_projects)
badges_under_revision = []
context['badges_under_revision'] = None
for project in context['feedback_your_projects']:
badge_uri = project_api.get_badge_uri_from_project_under_revision(project['uri'])
if badge_uri:
badge = badge_api.get_badge(badge_uri)
fetch_badge_resources(badge)
badges_under_revision.append(badge)
if badges_under_revision:
context['badges_under_revision'] = badges_under_revision
context['feedback_peer_projects'] = map(fetch_resources, peer_projects)
context['feedback_latest'] = map(fetch_resources, feedback_latest)
context['user'] = user_api.get_user(user_api.username2uri(username))
context['can_delete'] = False
if 'user' in request.session:
if context['user']['username'] == request.session.get('user')['username']:
context['can_delete'] = True
return render_to_response(
'dashboard/dashboard.html',
context,
context_instance=RequestContext(request)
)
def profile_badges(request, username):
user = user_api.get_user(user_api.username2uri(username))
user = check_if_owner(request.session.get('user', default=None), username, user)
badges = map(fetch_badge_resources, badge_api.get_user_earned_badges(user['uri']))
draft_badges = map(fetch_badge_resources, badge_api.get_user_draft_badges(user['uri']))
projects = list_projects_by_user(user['uri'])
return render_to_response(
'dashboard/dashboard_badges.html', {
'user': user,
'projects': projects,
'badges': badges,
'draft_badges': draft_badges,
},
context_instance=RequestContext(request)
)
def create(request):
user_uri = request.session['user']['uri']
user = p2pu_user_api.get_user(user_uri)
user_partner = user['partner']
form = BadgeForm(user_uri=user_uri)
if request.method == 'POST':
form = BadgeForm(request.POST, request.FILES, user_uri=user_uri)
if form.is_valid():
try:
if request.FILES['image_uri'].size > (256 * 1024):
raise media_api.UploadImageError('Image size too large.')
image = media_api.upload_image(
request.FILES['image_uri'],
user_uri,
media_root=settings.MEDIA_ROOT,
delete_original=True)
badge = badge_api.create_badge(
form.cleaned_data['title'],
image['uri'],
form.cleaned_data['description'],
form.cleaned_data['requirements'],
user_uri,
partner_name=form.cleaned_data['partner']
)
return http.HttpResponseRedirect(
reverse('badge_publish', args=(badge_api.uri2id(badge['uri']),))
)
except badge_api.DuplicateTitleError:
form.errors['title'] = [_('Badge title needs to be unique'), ]
except media_api.UploadImageError:
form.errors['title'] = [_('Badge image cannot be uploaded. Possible reasons: format not supported'
'(png, jpeg, jpg, gif), file size too large (up to 256kb).'), ]
return render_to_response(
'badge/badge_info/create.html', {
'form': form,
'user_is_partner': user_partner,
},
context_instance=RequestContext(request))
def profile_dashboard(request, username):
user = user_api.get_user(user_api.username2uri(username))
user = check_if_owner(request.session.get('user', default=None), username, user)
if not user.get('is_owner'):
return redirect(to=reverse('profile_badges', args=[username]))
badges = map(fetch_badge_resources, badge_api.get_user_earned_badges(user['uri']))
projects = list_projects_ready_for_feedback(badges)
return render_to_response(
'dashboard/dashboard.html', {
'user': user,
'projects': projects,
'badges': badges,
},
context_instance=RequestContext(request)
)
def send_notification(receiver_uri, subject, text, html=None, sender=None, callback=None):
"""
Send a notification to a single receiver via the Django-mandrill to a user
receiver - uri of user to send the notification to
sender - name to use in from part of email
"""
receiver = get_user(receiver_uri)
msg = EmailMultiAlternatives(
subject=subject,
body=text,
from_email=settings.DEFAULT_FROM_EMAIL,
to=[receiver['email']],
)
if html:
msg.attach_alternative(html, "text/html")
try:
msg.send()
except:
log.error(u'Could not send email notification to {0}'.format(receiver['email']))
def test_get_user(self):
user = user_api.save_user('testuser', '/media/images/test.png')
user2 = user_api.get_user(user['uri'])
self.assertEqual(user, user2)
def fetch_badge_resources( badge ):
badge['image'] = media_api.get_image(badge['image_uri'])
badge['author'] = p2pu_user_api.get_user(badge['author_uri'])
return badge
def fetch_resources( project ):
project['image'] = media_api.get_image(project['image_uri'])
project['author'] = p2pu_user_api.get_user(project['author_uri'])
return project
def fetch_badge_resources( badge ):
badge['image'] = media_api.get_image(badge['image_uri'])
badge['author'] = p2pu_user_api.get_user(badge['author_uri'])
badge['url'] = settings.ORGANISATION_URL + reverse('badge_view', args=(badge['id'],))
return badge
