def get(self):
"""Handles GET request."""
user = self.personalize_page_and_get_user()
if not user:
self.redirect(users.create_login_url(self.request.uri))
return
student = Student.get_enrolled_student_by_email(user.email())
if student:
self.redirect("/course")
return
# Check global student data
namespace = namespace_manager.get_namespace()
try:
namespace_manager.set_namespace("")
student = Student.get_enrolled_student_by_email(user.email())
finally:
namespace_manager.set_namespace(namespace)
if student:
create_or_enroll_student(user, student.name)
self.template_value["navbar"] = {"registration": True}
self.render("confirmation.html")
return
self.template_value["navbar"] = {"registration": True}
self.template_value["register_xsrf_token"] = XsrfTokenManager.create_xsrf_token("register-post")
self.render("register.html")
def get(self):
"""Handles GET request."""
user = self.personalize_page_and_get_user()
if not user:
self.redirect(
users.create_login_url(self.request.uri), normalize=False)
return
student = Student.get_enrolled_student_by_email(user.email())
if student:
self.redirect('/course')
return
can_register = self.app_context.get_environ(
)['reg_form']['can_register']
if not can_register:
self.redirect('/course#registration_closed')
return
# pre-fill nick name from the profile if available
self.template_value['current_name'] = ''
profile = StudentProfileDAO.get_profile_by_user_id(user.user_id())
if profile and profile.nick_name:
self.template_value['current_name'] = profile.nick_name
self.template_value['navbar'] = {}
self.template_value['transient_student'] = True
self.template_value['register_xsrf_token'] = (
XsrfTokenManager.create_xsrf_token('register-post'))
self.render('register.html')
def update_simassessment_transaction(self, email, assessment_type,
new_answers, score):
"""Stores answer and updates user scores.
Args:
email: the student's email address.
assessment_type: the title of the assessment.
new_answers: the latest set of answers supplied by the student.
score: the numerical assessment score.
Returns:
the student instance.
"""
student = Student.get_enrolled_student_by_email(email)
print student.is_transient
course = self.get_course()
# It may be that old Student entities don't have user_id set; fix it.
if not student.user_id:
student.user_id = self.get_user().user_id()
answers = StudentAnswersEntity.get_by_key_name(student.user_id)
if not answers:
answers = StudentAnswersEntity(key_name=student.user_id)
answers.updated_on = datetime.datetime.now()
utils.set_answer(answers, assessment_type, new_answers)
assessments.store_score(course, student, assessment_type, int(score))
student.put()
answers.put()
def post(self):
""" Handles a PayPal IPN post: https://developer.paypal.com/docs/classic/ipn/integration-guide/IPNIntro/ """
import urllib
from google.appengine.api import urlfetch
parameters = None
if self.request.POST:
parameters = self.request.POST.copy()
if self.request.GET:
parameters = self.request.GET.copy()
logging.debug('Received IPN message: ' + str(parameters))
# Check the IPN POST request came from real PayPal, not from a fraudster.
if not parameters:
return
parameters['cmd'] = '_notify-validate'
params = urllib.urlencode(parameters)
status = urlfetch.fetch(
url='https://www.sandbox.paypal.com/cgi-bin/webscr',
method=urlfetch.POST,
payload=params,
).content
logging.debug('Verification status is: ' + status)
if not status == "VERIFIED":
logging.warning("Could not verify request: " + str(parameters) +
". Fraud?")
#TODO: return an error message
# Check funds go into the correct account
if not parameters[
'receiver_email'] == '*****@*****.**' and not parameters[
'receiver_email'] == '*****@*****.**':
logging.warning("Incorrect receiver email: " +
parameters['receiver_email'])
return
if not parameters['mc_currency'] == 'CHF':
logging.warning("Incorrect currency: " + parameters['mc_currency'])
return
student_email = parameters['custom']
# [hack] this handler will only work for the ns_sample namespace
namespace_manager.set_namespace('ns_sample')
# Check payment is completed, not Pending or Failed.
if parameters['payment_status'] == 'Completed':
student = Student.get_enrolled_student_by_email(student_email)
#student = (
# models.StudentProfileDAO.get_enrolled_student_by_email_for(
# student_email, self.app_context))
if not student:
logging.warning('Could not process payment for student: ' +
student_email)
self.send_error_email(student_email)
return
logging.info(
'Student %s is now a full access student. Payment confirmed.' %
student_email)
student.has_paid = True
student.access_code = 'PayPal'
student.put()
def get_list(self):
"""Shows a list of announcements."""
user = self.personalize_page_and_get_user()
transient_student = False
if user is None:
transient_student = True
else:
student = Student.get_enrolled_student_by_email(user.email())
if not student:
transient_student = True
else:
# CGL-MOOC-Builder starts:
# Set template value for progress bar that shows on the top navigation(header.html)
total_progress = (self.get_progress_tracker().get_overall_progress_score(student))
self.template_value['progress_value'] = total_progress.get('progress_score', 0)
self.template_value['complete_value'] = total_progress.get('completed_score', 0)
self.template_value['percentage'] = total_progress.get('percentage', '')
# CGL-MOOC-Builder ends
self.template_value['transient_student'] = transient_student
items = AnnouncementEntity.get_announcements()
if not items and AnnouncementsRights.can_edit(self):
items = self.put_sample_announcements()
items = AnnouncementsRights.apply_rights(self, items)
self.template_value['announcements'] = self.format_items_for_template(
items)
self.template_value['navbar'] = {'announcements': True}
self.render('announcements.html')
def get_list(self):
"""Shows a list of announcements."""
student = None
user = self.personalize_page_and_get_user()
transient_student = False
if user is None:
transient_student = True
else:
student = Student.get_enrolled_student_by_email(user.email())
if not student:
transient_student = True
self.template_value['transient_student'] = transient_student
items = AnnouncementEntity.get_announcements()
if not items and AnnouncementsRights.can_edit(self):
items = self.put_sample_announcements()
items = AnnouncementsRights.apply_rights(self, items)
if not roles.Roles.is_course_admin(self.get_course().app_context):
items = models.LabelDAO.apply_course_track_labels_to_student_labels(
self.get_course(), student, items)
self.template_value['announcements'] = self.format_items_for_template(
items)
self._render()
def get(self):
"""Handles GET requests."""
user = users.get_current_user()
if not user:
self.template_value['loginUrl'] = (
users.create_login_url(self.request.uri))
# self.template_value['fedLoginUrl'] = (
# users.create_login_url(self.request.uri, None, 'http://dev-hidden.africanmanagers.org'))
else:
self.template_value['email'] = user.email()
self.template_value['logoutUrl'] = (
users.create_logout_url(self.request.uri))
self.template_value['navbar'] = {'course': True}
self.template_value['units'] = self.get_units()
if user and Student.get_enrolled_student_by_email(user.email()):
self.redirect('/course')
else:
self.template_value['enroll']=True;
self.render('preview.html')
def get(self):
param_map = {}
for k in self.request.arguments():
param_map[k] = self.request.get(k)
client_id = param_map.get('client_id', 0)
logging.debug("vanilla request: " + str(param_map))
user = users.get_current_user()
if Roles.is_course_admin(self.app_context):
role= "administrator"
else:
role="member"
logging.debug(str(user))
if user:
student = Student.get_enrolled_student_by_email(user.email())
user = {
"name": student.name,
"email": user.email(),
"uniqueid": user.user_id(),
"photourl": "",
}
course = self.app_context.get_environ()['course']
client_id = course['VANILLA_CLIENT_ID']
secret_key = course['VANILLA_SECRET_KEY']
jsconn_str = get_jsconnect_string(user, param_map, client_id, secret_key)
logging.debug("mooc-ed response: " + jsconn_str)
self.response.out.write(jsconn_str)
def get_list(self):
"""Shows a list of announcements."""
user = self.personalize_page_and_get_user()
transient_student = False
if user is None:
transient_student = True
else:
student = Student.get_enrolled_student_by_email(user.email())
if not student:
transient_student = True
else:
#progress bar
total_progress = (self.get_progress_tracker().
get_overall_progress_score(student))
self.template_value['progress_value'] = total_progress.get(
'progress_score', 0)
self.template_value['complete_value'] = total_progress.get(
'completed_score', 0)
self.template_value['percentage'] = total_progress.get(
'percentage', '')
self.template_value['transient_student'] = transient_student
items = AnnouncementEntity.get_announcements()
if not items and AnnouncementsRights.can_edit(self):
items = self.put_sample_announcements()
items = AnnouncementsRights.apply_rights(self, items)
self.template_value['announcements'] = self.format_items_for_template(
items)
self.template_value['navbar'] = {'announcements': True}
self.render('announcements.html')
def get(self):
"""Handles GET requests."""
user = self.personalize_page_and_get_user()
transient_student = False
if user is None:
transient_student = True
else:
student = Student.get_enrolled_student_by_email(user.email())
if not student:
transient_student = True
else:
#progress bar
total_progress = (self.get_progress_tracker().
get_overall_progress_score(student))
self.template_value['progress_value'] = total_progress.get(
'progress_score', 0)
self.template_value['complete_value'] = total_progress.get(
'completed_score', 0)
self.template_value['percentage'] = total_progress.get(
'percentage', '')
#student = self.personalize_page_and_get_enrolled(
# supports_transient_student=True)
self.template_value['transient_student'] = transient_student
self.template_value['navbar'] = {'team': True}
self.render('team.html')
def personalize_page_and_get_enrolled(
self, supports_transient_student=False):
"""If the user is enrolled, add personalized fields to the navbar."""
user = self.personalize_page_and_get_user()
if user is None:
student = TRANSIENT_STUDENT
else:
student = Student.get_enrolled_student_by_email(user.email())
if not student:
self.template_value['transient_student'] = True
student = TRANSIENT_STUDENT
if student.is_transient:
if supports_transient_student and (
self.app_context.get_environ()['course']['browsable']):
return TRANSIENT_STUDENT
elif user is None:
self.redirect(
users.create_login_url(self.request.uri), normalize=False
)
return None
else:
self.redirect('/preview')
return None
# Patch Student models which (for legacy reasons) do not have a user_id
# attribute set.
if not student.user_id:
student.user_id = user.user_id()
student.put()
return student
def get(self):
param_map = {}
for k in self.request.arguments():
param_map[k] = self.request.get(k)
client_id = param_map.get('client_id', 0)
logging.debug("vanilla request: " + str(param_map))
user = users.get_current_user()
logging.debug(str(user))
if user:
student = Student.get_enrolled_student_by_email(user.email())
user = {
"name": student.name,
"email": user.email(),
"uniqueid": user.user_id(),
"photourl": "",
}
course = self.app_context.get_environ()['course']
client_id = course['VANILLA_CLIENT_ID']
secret_key = course['VANILLA_SECRET_KEY']
jsconn_str = get_jsconnect_string(user, param_map, client_id,
secret_key)
logging.debug("mooc-ed response: " + jsconn_str)
self.response.out.write(jsconn_str)
def get(self):
"""Handles GET requests."""
user = self.personalize_page_and_get_user()
student = Student.get_by_email(user.email())
if not user:
self.template_value['loginUrl'] = users.create_login_url('/')
else:
self.template_value['playlist'] = student.playlist
self.template_value['playlist_urls'] = student.playlist_urls
self.template_value['email'] = user.email()
self.template_value['logoutUrl'] = users.create_logout_url('/')
if len(student.playlist) > 0:
#unit_id = str(student.playlist[0][0])
#lesson_id = str(student.playlist[0][2])
self.template_value['start_plist_url'] = str(student.playlist[0]) #('unit?unit=%s&lesson=%s' % (unit_id, lesson_id))
self.template_value['hasList'] = True
else:
self.template_value['hasList'] = False
self.template_value['navbar'] = {'course': True}
self.template_value['units'] = self.get_units()
if user and Student.get_enrolled_student_by_email(user.email()):
self.render('playlist.html')
else:
self.redirect('/preview')
def get(self):
"""Handles GET request."""
user = self.personalize_page_and_get_user()
if not user:
self.redirect(
users.create_login_url(self.request.uri), normalize=False)
return
student = Student.get_enrolled_student_by_email(user.email())
if student:
self.redirect('/course')
return
can_register = self.app_context.get_environ(
)['reg_form']['can_register']
if not can_register:
self.redirect('/course#registration_closed')
return
# pre-fill nick name from the profile if available
self.template_value['current_name'] = ''
profile = StudentProfileDAO.get_profile_by_user_id(user.user_id())
if profile and profile.nick_name:
self.template_value['current_name'] = profile.nick_name
self.template_value['navbar'] = {}
self.template_value['transient_student'] = True
self.template_value['register_xsrf_token'] = (
XsrfTokenManager.create_xsrf_token('register-post'))
self.render('register.html')
def get_list(self):
"""Shows a list of announcements."""
student = None
user = self.personalize_page_and_get_user()
transient_student = False
if user is None:
transient_student = True
else:
student = Student.get_enrolled_student_by_email(user.email())
if not student:
transient_student = True
self.template_value['transient_student'] = transient_student
items = AnnouncementEntity.get_announcements()
if not items and AnnouncementsRights.can_edit(self):
items = self.put_sample_announcements()
items = AnnouncementsRights.apply_rights(self, items)
if not roles.Roles.is_course_admin(self.get_course().app_context):
items = models.LabelDAO.apply_course_track_labels_to_student_labels(
self.get_course(), student, items)
self.template_value['announcements'] = self.format_items_for_template(
items)
self._render()
def personalize_page_and_get_enrolled(
self, supports_transient_student=False):
"""If the user is enrolled, add personalized fields to the navbar."""
user = self.personalize_page_and_get_user()
if user is None:
student = TRANSIENT_STUDENT
else:
student = Student.get_enrolled_student_by_email(user.email())
if not student:
self.template_value['transient_student'] = True
student = TRANSIENT_STUDENT
if student.is_transient:
if supports_transient_student and (
self.app_context.get_environ()['course']['browsable']):
return TRANSIENT_STUDENT
elif user is None:
self.redirect(
users.create_login_url(self.request.uri), normalize=False
)
return None
else:
self.redirect('/preview')
return None
# Patch Student models which (for legacy reasons) do not have a user_id
# attribute set.
if not student.user_id:
student.user_id = user.user_id()
student.put()
return student
def get_list(self):
"""Shows a list of announcements."""
student = None
user = self.personalize_page_and_get_user()
transient_student = False
if user is None:
transient_student = True
else:
student = Student.get_enrolled_student_by_email(user.email())
if not student:
transient_student = True
self.template_value['transient_student'] = transient_student
items = AnnouncementEntity.get_announcements()
items = AnnouncementsRights.apply_rights(self, items)
if not roles.Roles.is_course_admin(self.get_course().app_context):
items = models.LabelDAO.apply_course_track_labels_to_student_labels(
self.get_course(), student, items)
self.template_value['announcements'] = self.format_items_for_template(
items)
self.template_value['navbar'] = {'announcements': True}
if student and len(items) > 0:
additional_fields = transforms.nested_lists_as_string_to_dict(
student.additional_fields)
additional_fields[
'annoucements_last_viewed'] = datetime.datetime.now().strftime(
courses.ISO_8601_DATE_FORMAT)
student.additional_fields = transforms.dict_to_nested_lists_as_string(
additional_fields)
student.put()
self.template_value['force'] = self.request.get('force')
self.render('announcements.html')
def get(self):
"""Handles GET requests."""
user = self.personalize_page_and_get_user()
if user is None:
student = TRANSIENT_STUDENT
else:
student = Student.get_enrolled_student_by_email(user.email())
profile = StudentProfileDAO.get_profile_by_user_id(user.user_id())
self.template_value['has_global_profile'] = profile is not None
if not student:
student = TRANSIENT_STUDENT
if (student.is_transient and
not self.app_context.get_environ()['course']['browsable']):
self.redirect('/preview')
return
self.template_value['units'] = self.get_units()
self.template_value['show_registration_page'] = True
if student and not student.is_transient:
self.augment_assessment_units(student)
elif user:
profile = StudentProfileDAO.get_profile_by_user_id(user.user_id())
additional_registration_fields = self.app_context.get_environ(
)['reg_form']['additional_registration_fields']
if profile is not None and not additional_registration_fields:
self.template_value['show_registration_page'] = False
self.template_value['register_xsrf_token'] = (
XsrfTokenManager.create_xsrf_token('register-post'))
self.template_value['transient_student'] = student.is_transient
self.template_value['progress'] = (
self.get_progress_tracker().get_unit_progress(student))
#progress bar
total_progress = (self.get_progress_tracker().get_overall_progress_score(student))
self.template_value['progress_value'] = total_progress.get('progress_score', 0)
self.template_value['complete_value'] = total_progress.get('completed_score', 0)
self.template_value['percentage'] = total_progress.get('percentage', '')
self.template_value['progress'] = (self.get_progress_tracker().get_unit_progress(student))
course = self.app_context.get_environ()['course']
self.template_value['video_exists'] = bool(
'main_video' in course and
'url' in course['main_video'] and
course['main_video']['url'])
self.template_value['image_exists'] = bool(
'main_image' in course and
'url' in course['main_image'] and
course['main_image']['url'])
self.template_value['is_progress_recorded'] = (
CAN_PERSIST_ACTIVITY_EVENTS.value)
self.template_value['navbar'] = {'course': True}
self.render('home.html')
def get(self):
user = users.get_current_user()
if user:
if Student.get_enrolled_student_by_email(user.email()):
self.redirect('/course')
else:
page = self.getOrCreatePage('loggedin_preview_page', utils.CoursePreviewHandler())
self.serve(page, user.email())
else:
page = self.getOrCreatePage('anonymous_preview_page', utils.CoursePreviewHandler())
self.serve(page)
def post_save(self):
if not Roles.is_course_admin(self.app_context):
self.abort(403, 'You are not an admin :(')
user = self.personalize_page_and_get_enrolled()
student_email = self.request.GET.get('email', None)
if not student_email:
self.abort(404, 'email= parameter required')
student = Student.get_enrolled_student_by_email(student_email)
if not student:
self.abort(404, Markup('Could not find a student with email "%s"') % student_email)
badge_slug = custom_badge_name(student)
badge = Badge.get_or_insert(badge_slug)
badge_form = BadgeForm(self.request.POST, badge)
comments_form = CommentsForm(self.request.POST)
if not (badge_form.validate() and comments_form.validate()):
self.render_edit(badge_form, comments_form)
return
comments_form.validate()
reviewer = Student.get_by_email(comments_form.review_source.data)
if not reviewer:
comments_form.review_source.errors.append("Could not find a user with that e-mail address")
self.render_edit(badge_form, comments_form)
return
page = WikiPage.get_page(student, unit=UNIT_NUMBER)
if not page:
self.abort(404, Markup('Could not find unit %d wikifolio for student "%s"') % (UNIT_NUMBER, student_email))
old_reviews = Annotation.reviews(whose=student, unit=UNIT_NUMBER).run()
db.delete(old_reviews)
Annotation.review(page, who=reviewer, text=comments_form.public_comments.data)
if not Annotation.endorsements(what=page, who=user).count(limit=1):
Annotation.endorse(page, who=user, optional_done=True)
badge_form.populate_obj(badge)
badge.put()
report = PartReport.on(student, self.get_course(), 4, force_re_run=True, put=False)
for rep in report.unit_reports:
rep._run()
rep.put()
report.slug = badge_slug
report.put()
assertion = Badge.issue(badge, student, put=False)
assertion.evidence = urljoin(self.request.host_url, '/badges/evidence?id=%d' % report.key().id())
assertion.put()
self.response.write(
Markup("Issued badge %s to %s, evidence %s") % (
badge.key().name(), student_email, assertion.evidence))
def get(self):
user = self.personalizePageAndGetUser()
if not user:
self.redirect(users.create_login_url(self.request.uri))
return
student = Student.get_enrolled_student_by_email(user.email())
if student:
self.templateValue['student'] = student
self.templateValue['navbar'] = {'registration': True}
self.render('unenroll_confirmation_check.html')
def get(self):
"""Handles GET requests."""
user = self.personalize_page_and_get_user()
if user is None:
student = TRANSIENT_STUDENT
else:
student = Student.get_enrolled_student_by_email(user.email())
profile = StudentProfileDAO.get_profile_by_user_id(user.user_id())
self.template_value['has_global_profile'] = profile is not None
if not student:
student = TRANSIENT_STUDENT
if (student.is_transient and
not self.app_context.get_environ()['course']['browsable']):
self.redirect('/preview')
return
self.template_value['units'] = self.get_units()
self.template_value['show_registration_page'] = True
if student and not student.is_transient:
self.augment_assessment_units(student)
elif user:
profile = StudentProfileDAO.get_profile_by_user_id(user.user_id())
additional_registration_fields = self.app_context.get_environ(
)['reg_form']['additional_registration_fields']
if profile is not None and not additional_registration_fields:
self.template_value['show_registration_page'] = False
self.template_value['register_xsrf_token'] = (
XsrfTokenManager.create_xsrf_token('register-post'))
self.template_value['transient_student'] = student.is_transient
self.template_value['progress'] = (
self.get_progress_tracker().get_unit_progress(student))
course = self.app_context.get_environ()['course']
self.template_value['video_exists'] = bool(
'main_video' in course and
'url' in course['main_video'] and
course['main_video']['url'])
self.template_value['image_exists'] = bool(
'main_image' in course and
'url' in course['main_image'] and
course['main_image']['url'])
self.template_value['is_progress_recorded'] = (
CAN_PERSIST_ACTIVITY_EVENTS.value)
self.template_value['navbar'] = {'course': True}
self.template_value['units_progress'] = self.get_course().get_units_progress()
self.render('course.html')
def personalize_page_and_get_enrolled(self):
"""If the user is enrolled, add personalized fields to the navbar."""
user = self.personalize_page_and_get_user()
if not user:
self.redirect(users.create_login_url(self.request.uri))
return None
student = Student.get_enrolled_student_by_email(user.email())
if not student:
self.redirect('/preview')
return None
return student
def get(self):
user = self.personalizePageAndGetUser()
if not user:
self.redirect(users.create_login_url(self.request.uri))
return
self.templateValue['navbar'] = {'registration': True}
# Check for existing registration -> redirect to course page
student = Student.get_enrolled_student_by_email(user.email())
if student:
self.redirect('/course')
else:
self.render('register.html')
def get(self):
user = self.personalizePageAndGetUser()
if not user:
self.redirect(users.create_login_url(self.request.uri))
return
student = Student.get_enrolled_student_by_email(user.email())
if not student:
self.redirect('/preview')
return
self.templateValue['navbar'] = {'announcements': True}
self.render('announcements.html')
def personalize_page_and_get_enrolled(self):
"""If the user is enrolled, add personalized fields to the navbar."""
user = self.personalize_page_and_get_user()
if not user:
self.redirect(users.create_login_url(self.request.uri))
return None
student = Student.get_enrolled_student_by_email(user.email())
if not student:
self.redirect('/preview')
return None
return student
def get(self):
user = users.get_current_user()
if not user:
self.templateValue['loginUrl'] = users.create_login_url('/')
else:
self.templateValue['email'] = user.email()
self.templateValue['logoutUrl'] = users.create_logout_url("/")
self.templateValue['navbar'] = {'course': True}
self.templateValue['units'] = Unit.get_units()
if user and Student.get_enrolled_student_by_email(user.email()):
self.redirect('/course')
else:
self.render('preview.html')
def get(self):
"""Handles GET requests."""
user = self.personalize_page_and_get_user()
if user is None:
student = TRANSIENT_STUDENT
else:
student = Student.get_enrolled_student_by_email(user.email())
if not student:
student = TRANSIENT_STUDENT
# If the course is browsable, or the student is logged in and
# registered, redirect to the main course page.
if ((student and not student.is_transient) or
self.app_context.get_environ()['course']['browsable']):
self.redirect('/course')
return
units = self.get_units()
self.template_value['transient_student'] = True
self.template_value['can_register'] = self.app_context.get_environ(
)['reg_form']['can_register']
self.template_value['navbar'] = {'course': True}
self.template_value['units'] = units
self.template_value['show_registration_page'] = True
course = self.app_context.get_environ()['course']
self.template_value['video_exists'] = bool(
'main_video' in course and
'url' in course['main_video'] and
course['main_video']['url'])
self.template_value['image_exists'] = bool(
'main_image' in course and
'url' in course['main_image'] and
course['main_image']['url'])
#get all lessons info
all_lessons = {}
for u in units:
if u.type == 'U':
all_lessons[u.unit_id] = get_all_lesson(self, u.unit_id)
self.template_value['all_lessons'] = all_lessons
if user:
profile = StudentProfileDAO.get_profile_by_user_id(user.user_id())
additional_registration_fields = self.app_context.get_environ(
)['reg_form']['additional_registration_fields']
if profile is not None and not additional_registration_fields:
self.template_value['show_registration_page'] = False
self.template_value['register_xsrf_token'] = (
XsrfTokenManager.create_xsrf_token('register-post'))
self.render('preview.html')
def get(self):
"""Handles GET requests."""
user = users.get_current_user()
if not user:
self.template_value['loginUrl'] = users.create_login_url('/')
else:
self.template_value['email'] = user.email()
self.template_value['logoutUrl'] = users.create_logout_url('/')
self.template_value['navbar'] = {'course': True}
self.template_value['units'] = self.get_units()
if user and Student.get_enrolled_student_by_email(user.email()):
self.redirect('/course')
else:
self.render('preview.html')
def get(self):
"""Handles GET requests."""
user = users.get_current_user()
if not user:
self.template_value["loginUrl"] = users.create_login_url(self.request.uri)
else:
self.template_value["email"] = user.email()
self.template_value["logoutUrl"] = users.create_logout_url("/")
self.template_value["navbar"] = {"course": True}
self.template_value["units"] = self.get_units()
if user and Student.get_enrolled_student_by_email(user.email()):
self.redirect("/course")
else:
self.render("preview.html")
def get(self):
"""Handles GET request."""
user = self.personalize_page_and_get_user()
if not user:
self.redirect(users.create_login_url(self.request.uri))
return
student = Student.get_enrolled_student_by_email(user.email())
if student:
self.redirect("/course")
return
self.template_value["navbar"] = {"registration": True}
self.template_value["register_xsrf_token"] = XsrfTokenManager.create_xsrf_token("register-post")
self.render("register.html")
def get(self):
"""Handles GET requests."""
user = self.personalize_page_and_get_user()
if user is None:
student = TRANSIENT_STUDENT
else:
student = Student.get_enrolled_student_by_email(user.email())
if not student:
student = TRANSIENT_STUDENT
# If the course is browsable, or the student is logged in and
# registered, redirect to the main course page.
if ((student and not student.is_transient)
or self.app_context.get_environ()['course']['browsable']):
self.redirect('/course')
return
units = self.get_units()
self.template_value['transient_student'] = True
self.template_value['can_register'] = self.app_context.get_environ(
)['reg_form']['can_register']
self.template_value['navbar'] = {'course': True}
self.template_value['units'] = units
self.template_value['show_registration_page'] = True
course = self.app_context.get_environ()['course']
self.template_value['video_exists'] = bool(
'main_video' in course and 'url' in course['main_video']
and course['main_video']['url'])
self.template_value['image_exists'] = bool(
'main_image' in course and 'url' in course['main_image']
and course['main_image']['url'])
#get all lessons info
all_lessons = {}
for u in units:
if u.type == 'U':
all_lessons[u.unit_id] = get_all_lesson(self, u.unit_id)
self.template_value['all_lessons'] = all_lessons
if user:
profile = StudentProfileDAO.get_profile_by_user_id(user.user_id())
additional_registration_fields = self.app_context.get_environ(
)['reg_form']['additional_registration_fields']
if profile is not None and not additional_registration_fields:
self.template_value['show_registration_page'] = False
self.template_value['register_xsrf_token'] = (
XsrfTokenManager.create_xsrf_token('register-post'))
self.render('preview.html')
def get(self):
"""Handles GET request."""
user = self.personalize_page_and_get_user()
if not user:
self.redirect(users.create_login_url(self.request.uri))
return
student = Student.get_enrolled_student_by_email(user.email())
if student:
self.redirect('/course')
return
self.template_value['navbar'] = {'registration': True}
self.template_value['register_xsrf_token'] = (
XsrfTokenManager.create_xsrf_token('register-post'))
self.render('register.html')
def run(self):
# find the student's user_id..
student = Student.get_enrolled_student_by_email(self.student_email)
if not student:
raise ValueError('That student was not found!')
user_id = student.user_id
query = EventEntity.all()
query.filter('user_id', str(user_id))
query.filter('source', 'edit-wiki-page')
query.order('-recorded_on')
edits = query.run(limit=2000)
for edit in edits:
fields = transforms.loads(edit.data)
fields['recorded_on'] = edit.recorded_on
yield fields
def run(self):
# find the student's user_id..
student = Student.get_enrolled_student_by_email(self.student_email)
if not student:
raise ValueError('That student was not found!')
user_id = student.user_id
query = EventEntity.all()
query.filter('user_id', str(user_id))
query.filter('source', 'edit-wiki-page')
query.order('-recorded_on')
edits = query.run(limit=2000)
for edit in edits:
fields = transforms.loads(edit.data)
fields['recorded_on'] = edit.recorded_on
yield fields
def personalize_page_and_get_enrolled(self):
"""If the user is enrolled, add personalized fields to the navbar."""
user = self.personalize_page_and_get_user()
if not user:
self.redirect(users.create_login_url(self.request.uri))
return None
student = Student.get_enrolled_student_by_email(user.email())
if not student:
self.redirect('/preview')
return None
valid = ValidStudent.get_valid(user.email())
prof = Profile.get_by_key_name(valid.profile)
student.profile = eval(prof.auth)
return student
def get(self):
"""Handles GET request."""
user = self.personalize_page_and_get_user()
if not user:
self.redirect(users.create_login_url(self.request.uri))
return
student = Student.get_enrolled_student_by_email(user.email())
if student:
self.redirect('/course')
return
self.template_value['navbar'] = {'registration': True}
self.template_value['register_xsrf_token'] = (
XsrfTokenManager.create_xsrf_token('register-post'))
self.render('register.html')
def get(self):
user = self.personalizePageAndGetUser()
if not user:
self.redirect(users.create_login_url(self.request.uri))
return
#check for existing registration -> redirect to registration page
student = Student.get_enrolled_student_by_email(user.email())
if not student:
self.redirect('/preview')
return
self.templateValue['navbar'] = {}
self.templateValue['student'] = student
self.templateValue['scores'] = getAllScores(student)
self.render('student_profile.html')
def get(self):
"""Handles GET requests."""
user = users.get_current_user()
if not user:
self.template_value['loginUrl'] = users.create_login_url('/')
else:
self.template_value['email'] = user.email()
self.template_value['logoutUrl'] = users.create_logout_url('/')
self.template_value['navbar'] = {'course': True}
self.template_value['units'] = self.get_units()
if user and Student.get_enrolled_student_by_email(user.email()):
self.render('playlist.html')
else:
self.redirect('/preview')
def get(self):
"""Handles GET requests."""
user = self.personalize_page_and_get_user()
if user is None:
student = TRANSIENT_STUDENT
else:
student = Student.get_enrolled_student_by_email(user.email())
profile = StudentProfileDAO.get_profile_by_user_id(user.user_id())
self.template_value["has_global_profile"] = profile is not None
if not student:
student = TRANSIENT_STUDENT
if student.is_transient and not self.app_context.get_environ()["course"]["browsable"]:
self.redirect("/preview")
return
self.template_value["units"] = self.get_units()
self.template_value["show_registration_page"] = True
if student and not student.is_transient:
self.augment_assessment_units(student)
elif user:
profile = StudentProfileDAO.get_profile_by_user_id(user.user_id())
additional_registration_fields = self.app_context.get_environ()["reg_form"][
"additional_registration_fields"
]
if profile is not None and not additional_registration_fields:
self.template_value["show_registration_page"] = False
self.template_value["register_xsrf_token"] = XsrfTokenManager.create_xsrf_token("register-post")
self.template_value["transient_student"] = student.is_transient
self.template_value["progress"] = self.get_progress_tracker().get_unit_progress(student)
course = self.app_context.get_environ()["course"]
self.template_value["video_exists"] = bool(
"main_video" in course and "url" in course["main_video"] and course["main_video"]["url"]
)
self.template_value["image_exists"] = bool(
"main_image" in course and "url" in course["main_image"] and course["main_image"]["url"]
)
self.template_value["is_progress_recorded"] = CAN_PERSIST_ACTIVITY_EVENTS.value
self.template_value["navbar"] = {"course": True}
self.render("course.html")
def get(self):
user = self.personalize_page_and_get_user()
transient_student = False
if user is None:
transient_student = True
else:
student = Student.get_enrolled_student_by_email(user.email())
if not student:
transient_student = True
else:
#progress bar
total_progress = (self.get_progress_tracker().get_overall_progress_score(student))
self.template_value['progress_value'] = total_progress.get('progress_score', 0)
self.template_value['complete_value'] = total_progress.get('completed_score', 0)
self.template_value['percentage'] = total_progress.get('percentage', '')
self.template_value['transient_student'] = transient_student
self.template_value['navbar'] = {'faq': True}
self.render('faq.html')
def update_assessment_transaction(self, email, assessment_type,
new_answers, score):
"""Stores answer and updates user scores.
Args:
email: the student's email address.
assessment_type: the title of the assessment.
new_answers: the latest set of answers supplied by the student.
score: the numerical assessment score.
Returns:
the student instance.
"""
student = Student.get_enrolled_student_by_email(email)
course = self.get_course()
# It may be that old Student entities don't have user_id set; fix it.
if not student.user_id:
student.user_id = self.get_user().user_id()
answers = StudentAnswersEntity.get_by_key_name(student.user_id)
if not answers:
answers = StudentAnswersEntity(key_name=student.user_id)
answers.updated_on = datetime.datetime.now()
utils.set_answer(answers, assessment_type, new_answers)
store_score(course, student, assessment_type, score)
student.put()
answers.put()
# Also record the event, which is useful for tracking multiple
# submissions and history.
models.EventEntity.record(
'submit-assessment', self.get_user(),
transforms.dumps({
'type': 'assessment-%s' % assessment_type,
'values': new_answers,
'location': 'AnswerHandler'
}))
return student
def personalize_page_and_get_enrolled(self):
"""If the user is enrolled, add personalized fields to the navbar."""
user = self.personalize_page_and_get_user()
if not user:
self.redirect(users.create_login_url(self.request.uri), normalize=False)
return None
student = Student.get_enrolled_student_by_email(user.email())
if not student:
self.redirect("/preview")
return None
# Patch Student models which (for legacy reasons) do not have a user_id
# attribute set.
if not student.user_id:
student.user_id = user.user_id()
student.put()
return student
def personalize_page_and_get_user(self):
"""If the user exists, add personalized fields to the navbar."""
user = self.get_user()
PageInitializerService.get().initialize(self.template_value)
if hasattr(self, 'app_context'):
self.template_value['can_register'] = \
self.app_context.get_environ()['reg_form'
]['can_register']
if user:
self.template_value['email'] = user.email()
self.template_value['logoutUrl'] = \
users.create_logout_url(self.request.uri)
self.template_value['transient_student'] = False
# configure page events
self.template_value['record_tag_events'] = \
CAN_PERSIST_TAG_EVENTS.value
self.template_value['record_page_events'] = \
CAN_PERSIST_PAGE_EVENTS.value
self.template_value['record_events'] = \
CAN_PERSIST_ACTIVITY_EVENTS.value
self.template_value['event_xsrf_token'] = \
XsrfTokenManager.create_xsrf_token('event-post')
else:
self.template_value['loginUrl'] = \
users.create_login_url(self.request.uri)
self.template_value['transient_student'] = True
return None
if user is None: # No existe usuario
student = TRANSIENT_STUDENT
else:
if not Student.get_enrolled_student_by_email(user.email()): # loggeado pero no registrado
if not self.request.path == '/register':
self.redirect('/register');
#return None
return user
def update_assessment_transaction(self, email, assessment_type,
new_answers, score):
"""Stores answer and updates user scores.
Args:
email: the student's email address.
assessment_type: the type of the assessment (as stated in unit.csv).
new_answers: the latest set of answers supplied by the student.
score: the numerical assessment score.
Returns:
the result of the assessment, if appropriate.
"""
student = Student.get_enrolled_student_by_email(email)
course = self.get_course()
# It may be that old Student entities don't have user_id set; fix it.
if not student.user_id:
student.user_id = self.get_user().user_id()
answers = StudentAnswersEntity.get_by_key_name(student.user_id)
if not answers:
answers = StudentAnswersEntity(key_name=student.user_id)
answers.updated_on = datetime.datetime.now()
utils.set_answer(answers, assessment_type, new_answers)
result = store_score(course, student, assessment_type, score)
student.put()
answers.put()
# Also record the event, which is useful for tracking multiple
# submissions and history.
models.EventEntity.record(
'submit-assessment', self.get_user(),
transforms.dumps({
'type': 'assessment-%s' % assessment_type,
'values': new_answers,
'location': 'AnswerHandler'
}))
return student, result
def personalize_page_and_get_enrolled(self):
"""If the user is enrolled, add personalized fields to the navbar."""
user = self.personalize_page_and_get_user()
if not user:
self.redirect(users.create_login_url(self.request.uri),
normalize=False)
return None
student = Student.get_enrolled_student_by_email(user.email())
if not student:
self.redirect('/preview')
return None
# Patch Student models which (for legacy reasons) do not have a user_id
# attribute set.
if not student.user_id:
student.user_id = user.user_id()
student.put()
return student
def get(self):
"""Handles GET requests."""
user = self.personalize_page_and_get_user()
if not user:
self.redirect('/preview')
return None
student = self.personalize_page_and_get_enrolled()
if not student:
return
self.template_value['units'] = self.get_units()
self.template_value['progress'] = (
self.get_progress_tracker().get_unit_progress(student))
self.template_value['navbar'] = {'course': True}
if user and Student.get_enrolled_student_by_email(user.email()):
self.render('preview.html')
else:
self.redirect('/preview')
def get(self):
if self.request.POST:
parameters = self.request.POST.copy()
if self.request.GET:
parameters = self.request.GET.copy()
logging.debug('Received access code verification: ' + str(parameters))
student_email = parameters['student_email']
# Check payment is completed, not Pending or Failed.
access_code = parameters['access_code']
if access_code is not None and crypto.verify_access_code(access_code):
if len(Student.get_by_access_code(access_code)) == 0:
# [hack] this handler will only work for the ns_sample namespac
namespace_manager.set_namespace('ns_sample')
student = Student.get_enrolled_student_by_email(student_email)
#student = (
# models.StudentProfileDAO.get_enrolled_student_by_email_for(
# student_email, self.app_context))
if not student:
logging.warning('Could not process payment for student: ' +
student_email)
self.send_error_email(student_email)
return
logging.info(
'Student %s is now a full access student. Access code %s confirmed.'
% (student_email, access_code))
student.has_paid = True
student.access_code = access_code
student.put()
self.redirect("/sample?use_last_location=true")
else:
logging.warning(
'Student %s tried an already used access code: %s' %
(student_email, access_code))
self.redirect(
"/sample?use_last_location=true&invalid_access_code=true")
else:
logging.info('Student %s tried an invalid access code: %s' %
(student_email, access_code))
self.redirect(
"/sample?use_last_location=true&invalid_access_code=true")
def get_list(self):
"""Shows a list of announcements."""
user = self.personalize_page_and_get_user()
transient_student = False
if user is None:
transient_student = True
else:
student = Student.get_enrolled_student_by_email(user.email())
if not student:
transient_student = True
self.template_value['transient_student'] = transient_student
items = AnnouncementEntity.get_announcements()
if not items and AnnouncementsRights.can_edit(self):
items = self.put_sample_announcements()
items = AnnouncementsRights.apply_rights(self, items)
self.template_value['announcements'] = self.format_items_for_template(
items)
self.template_value['navbar'] = {'announcements': True}
self.render('announcements.html')
def get_edit(self):
if not Roles.is_course_admin(self.app_context):
self.abort(403, 'You are not an admin :(')
student_email = self.request.GET.get('email', None)
if not student_email:
self.abort(404, 'email= parameter required')
student = Student.get_enrolled_student_by_email(student_email)
if not student:
self.abort(
404,
Markup('Could not find a student with email "%s"') %
student_email)
badge = Badge.get_or_insert(custom_badge_name(student))
badge_form = BadgeForm(None, badge)
review = Annotation.reviews(whose=student, unit=UNIT_NUMBER).get()
comments_form = CommentsForm()
if review:
comments_form.public_comments.data = review.reason
comments_form.review_source.data = review.who.key().name()
self.render_edit(badge_form, comments_form)
def post_save(self):
if not Roles.is_course_admin(self.app_context):
self.abort(403, 'You are not an admin :(')
user = self.personalize_page_and_get_enrolled()
student_email = self.request.GET.get('email', None)
if not student_email:
self.abort(404, 'email= parameter required')
student = Student.get_enrolled_student_by_email(student_email)
if not student:
self.abort(
404,
Markup('Could not find a student with email "%s"') %
student_email)
badge_slug = custom_badge_name(student)
badge = Badge.get_or_insert(badge_slug)
badge_form = BadgeForm(self.request.POST, badge)
comments_form = CommentsForm(self.request.POST)
if not (badge_form.validate() and comments_form.validate()):
self.render_edit(badge_form, comments_form)
return
comments_form.validate()
reviewer = Student.get_by_email(comments_form.review_source.data)
if not reviewer:
comments_form.review_source.errors.append(
"Could not find a user with that e-mail address")
self.render_edit(badge_form, comments_form)
return
page = WikiPage.get_page(student, unit=UNIT_NUMBER)
if not page:
self.abort(
404,
Markup('Could not find unit %d wikifolio for student "%s"') %
(UNIT_NUMBER, student_email))
old_reviews = Annotation.reviews(whose=student, unit=UNIT_NUMBER).run()
db.delete(old_reviews)
Annotation.review(page,
who=reviewer,
text=comments_form.public_comments.data)
if not Annotation.endorsements(what=page, who=user).count(limit=1):
Annotation.endorse(page, who=user, optional_done=True)
badge_form.populate_obj(badge)
badge.put()
report = PartReport.on(student,
self.get_course(),
4,
force_re_run=True,
put=False)
for rep in report.unit_reports:
rep._run()
rep.put()
report.slug = badge_slug
report.put()
assertion = Badge.issue(badge, student, put=False)
assertion.evidence = urljoin(
self.request.host_url,
'/badges/evidence?id=%d' % report.key().id())
assertion.put()
self.response.write(
Markup("Issued badge %s to %s, evidence %s") %
(badge.key().name(), student_email, assertion.evidence))
def post(self, *args):
if not self.personalize_page_and_get_enrolled():
return
(forum, siteroot, tmpldir) = forum_siteroot_tmpldir_from_url(self.request.path_info)
if not forum or forum.is_disabled:
return self.redirect(FORUMS_ROOT + "/")
if self.request.get('Cancel'):
return self.redirect(siteroot)
ip = get_remote_ip()
if ip in BANNED_IPS:
return self.redirect(siteroot)
self.send_cookie()
vals = ['TopicId', 'Subject', 'Message', ]
(topic_id, subject, message) = req_get_vals(self.request, vals)
message = to_unicode(message)
tvals = {
'siteroot' : siteroot,
'forums' : db.GqlQuery("SELECT * FROM Forum where is_disabled = False").fetch(MAX_FORUMS),
'forum' : forum,
"prevSubject" : subject,
"prevMessage" : message,
"log_in_out" : get_log_in_out(siteroot + "post")
}
# validate captcha and other values
errclass = None
if not message: errclass = "message_class"
# first post must have subject
if not topic_id and not subject: errclass = "subject_class"
# sha.new() doesn't accept Unicode strings, so convert to utf8 first
message_utf8 = message.encode('UTF-8')
s = sha.new(message_utf8)
sha1_digest = s.hexdigest()
duppost = Post.gql("WHERE sha1_digest = :1", sha1_digest).get()
if duppost: errclass = "message_class"
if errclass:
tvals[errclass] = "error"
tmpl = os.path.join(tmpldir, "post.html")
return self.template_out(tmpl, tvals)
# get user either by google user id or cookie. Create user objects if don't
# already exist
existing_user = False
user_id = users.get_current_user()
if not user_id:
self.redirect("/")
return
user = Student.get_enrolled_student_by_email(user_id.email())
if not user:
self.redirect("/")
return
if not topic_id:
topic = Topic(forum=forum, subject=subject, created_by=user.name)
topic.put()
else:
topic = db.get(db.Key.from_path('Topic', int(topic_id)))
#assert forum.key() == topic.forum.key()
topic.ncomments += 1
topic.put()
notify_addr = '*****@*****.**'
if notify_addr:
mail.send_mail(sender=notify_addr,
to=notify_addr,
subject="[booc-iu] New forum post",
body=Markup("Topic: %s\n%s\n%s") % (
topic.subject,
self.request.host_url + siteroot + "topic?id=" + str(topic.key().id()),
message))
user_ip_str = get_remote_ip()
if user.wiki_id:
user_profile_link = '/wikiprofile?student=%d' % user.wiki_id
else:
user_profile_link = ''
p = Post(topic=topic, forum=forum, user=user, user_ip=0, user_ip_str=user_ip_str, message=message, sha1_digest=sha1_digest, user_name = user.name, user_email = user_id.email(), user_homepage = user_profile_link)
p.put()
memcache.delete(rss_memcache_key(forum))
clear_topics_memcache(forum)
if topic_id:
self.redirect(siteroot + "topic?id=" + str(topic_id))
else:
self.redirect(siteroot)
