def map(self, student):
self.log.append('######### Student %s ##########' % student.key().name())
part_report = PartReport.on(student, course=self.course, part=self.part,
force_re_run=self.re_run)
completion = part_report.completion()
base_badge_version = choose_badge_version(part_report.slug, completion)
if not base_badge_version:
self.log.append(' Skipping, since not complete.')
return ([], [])
self.log.append(' Part is complete, considering units.')
unit_reports = part_report.unit_reports
promotions = 0
for ur in unit_reports:
promotions += ur.promotions
best_so_far = self.best_by_group[student.group_id][1]
if promotions > best_so_far:
self.best_by_group[student.group_id] = ([student.key().name()], promotions)
self.log.append(' They have current best for group %s, with %d.' % (
student.group_id, promotions))
elif promotions == best_so_far:
self.best_by_group[student.group_id][0].append(student.key().name())
self.log.append(' They ARE TIED FOR CURRENT BEST for group %s, with %d.' % (
student.group_id, promotions))
return ([], [])
def finish(self):
if self.really:
leader_badges = dict((key, Badge.get_by_key_name(key)) for key in self.leader_badge_keys)
for group_id, (emails, count) in self.best_by_group.iteritems():
self.log.append('Considering group %s, best score is %d' % (
str(group_id), count))
if count < 1:
self.log.append('... Best score is too low, skipping.')
continue
if self.really:
for email in emails:
report = PartReport.on(
db.Key.from_path(Student.kind(), email),
course=self.course, part=self.part,
force_re_run=self.re_run)
base_badge_version = choose_badge_version(report.slug, report.completion())
leader_badge_version = combine_badge_slug_parts(base_badge_version, 'leader')
leader_badge = leader_badges[leader_badge_version]
assert leader_badge, "Should be a badge called %s" % leader_badge_version
b = Badge.issue(leader_badge,
db.Key.from_path(Student.kind(), email), put=False)
b.evidence = self.host_url + '/badges/evidence?id=%d' % report.key().id()
b.put()
self.log.append('... ISSUED leader badge %s to %s, id=%d' % (
leader_badge_version, email, b.key().id()))
else:
self.log.append('... WOULD ISSUE leader badge to %s' % ' '.join(emails))
self._batch_write()
def map(self, student):
self.log.append('########## Student %s ##########' % student.key().name())
report = PartReport.on(student, course=self.course, part=self.part,
force_re_run=self.re_run, put=self.really)
completion = report.completion()
self.log.append(' Passed? %s.' % str(completion))
badge_version = choose_badge_version(report.slug, completion)
if badge_version:
badge = Badge.get_by_key_name(badge_version)
if not badge:
self.log.append(' There is no badge with key_name %s (so I cannot issue a badge)' % badge_version)
self.num_issued += 1
if self.really and badge:
b = Badge.issue(badge, student, put=False) # need to include evidence URL here somehow
b.evidence = self.host_url + '/badges/evidence?id=%d' % report.key().id()
b.put()
self.log.append(' Issued badge, name=%s, assertion id=%d' % (
badge_version, b.key().id()))
return ([b], [])
else:
self.log.append(' WOULD issue badge.')
else:
self.log.append('Not issuing because at least one of: %s' % (', '.join(report.incomplete_reasons)))
##TODO: this is not comprehensive: they could still have .expertise or .leader versions.
#if self.really and badge:
#Badge.ensure_not_issued(badge, student)
return ([], [])
def post(self):
if not users.is_current_user_admin():
self.abort(403)
if not XsrfTokenManager.is_xsrf_token_valid(self.request.POST.get('xsrf_token', ''), 'post'):
self.abort(403, 'XSRF token failed.')
form = self.Form(self.request.POST)
if not form.validate():
self.response.write('<br>'.join(form.errors))
return
student = Student.get_by_key_name(form.email.data)
report = PartReport.on(student, course=self.get_course(),
part=form.part.data,
force_re_run=form.re_run.data,
put=form.really_save.data)
badge_version = choose_badge_version(part_config[form.part.data]['slug'], report.completion())
if badge_version:
badge = Badge.get_by_key_name(badge_version)
if not badge:
self.response.write(' There is no badge with key_name %s (so I cannot issue a badge)' % badge_version)
if form.really_save.data and badge:
b = Badge.issue(badge, student, put=False)
b.evidence = self.request.host_url + '/badges/evidence?id=%d' % report.key().id()
b.put()
self.response.write('Issued badge %s!' % badge_version)
else:
self.response.write('Would have issued badge %s!' % badge_version)
else:
self.response.write('Not issuing because at least one of: %s' % (', '.join(report.incomplete_reasons)))
def head(self):
try:
report = PartReport.get_by_id(int(self.request.GET.get('id', -1)))
except ValueError:
report = None
if not report:
self.abort(404)
self.abort(200)
def post_save_settings(self):
user = self.personalize_page_and_get_enrolled()
if not user:
return
form = self.SettingsForm(self.request.POST)
try:
report = PartReport.get_by_id(int(form.report_id.data))
except ValueError:
report = None
if not report:
self.abort(404, "That evidence report was not found.")
if not self.can_edit(user, report):
self.abort(403, "You can't edit that user's report.")
if report.assessment_scores:
display_field_params = exam_display_choices(
report.assessment_scores[0])
form.exam_display.choices = display_field_params['choices']
form.exam_display.default = display_field_params['default']
else:
del form.exam_display
if not form.validate():
self.redirect('/')
return
report.units_are_public = form.units_are_public.data
report.review_is_public = form.review_is_public.data
if report.assessment_scores:
report.exam_display = form.exam_display.data
report.put()
EventEntity.record(
'set-evidence-settings',
users.get_current_user(),
transforms.dumps({
'part': report.part,
'slug': report.slug,
'review_is_public': report.review_is_public,
'public': report.units_are_public,
'exam_display': report.exam_display,
'email': user.key().name()
}))
self.template_value['navbar'] = {}
self.template_value['content'] = '''<div class="gcb-aside">OK, saved settings.<br>
<a href="/student/home">Back to your account page...</a></div>'''
self.render('bare.html')
def get_settings(self):
user = self.personalize_page_and_get_enrolled()
if not user:
return
try:
report = PartReport.get_by_id(int(self.request.GET.get('id', -1)))
except ValueError:
report = None
if not report:
self.abort(404, "That evidence report was not found.")
if not self.can_edit(user, report):
self.abort(403)
form = self.SettingsForm(
report_id=report.key().id(),
units_are_public=report.units_are_public,
exam_display=report.exam_display,
review_is_public=report.review_is_public)
#if report.part != 4:
#del form.review_is_public
display_field_params = {
'choices': [('blank', '(Blank)')],
'default': 'blank'
}
if report.assessment_scores:
if len(report.assessment_scores) > 1:
logging.warning("Evidence page settings assuming there's just one exam per part, but there is more than one")
display_field_params = exam_display_choices(
report.assessment_scores[0])
form.exam_display.choices = display_field_params['choices']
form.exam_display.default = display_field_params['default']
self.template_value['report'] = report
self.template_value['form'] = form
self.template_value['xsrf_token'] = XsrfTokenManager.create_xsrf_token('save_settings')
self.template_value['navbar'] = {}
self.template_value['action_url'] = '/badges/evidence?action=save_settings'
self.template_value['badge_name'] = report._config['name']
self.render('wf_evidence_settings.html')
def get_view(self):
try:
report = PartReport.get_by_id(int(self.request.GET.get('id', -1)))
except ValueError:
report = None
if not report:
self.abort(404)
if not report.exam_display:
if report.assessment_scores:
display_info = exam_display_choices(report.assessment_scores[0])
report.exam_display = display_info['default']
else:
report.exam_display = 'blank'
self.report = report
self.template_value['inline_save'] = lambda: ''
self.template_value['navbar'] = {}
self.template_value['author'] = self.report.student
self.template_value['review_is_public'] = self.report.review_is_public
if report.units_are_public:
self.template_value['unit_link'] = self._unit_link
else:
self.template_value['unit_link'] = None
self.template_value['no_unit_links'] = True
self.template_value['unit_title'] = self._unit_title
self.unit_num = None
try:
if report.units_are_public:
self.unit_num = int(self.request.GET.get('unit', ''))
except ValueError:
self.unit_num = None
if self.unit_num:
self.unit = self.report.get_unit(self.unit_num)
if self.unit:
self.render_unit()
return
else:
logging.warning('Could not find the right unit %d for PartReport %s',
self.unit_num, self.report.key())
self.render_top()
