コード例 #1
0
ファイル: assessments.py プロジェクト: ksh/gpitraining
    def update_assessment_transaction(
        self, email, assessment_type, new_answers, score):
        """Stores answer and updates user scores."""
        student = Student.get_by_email(email)

        # 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)

        assessment_type = store_score(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(), json.dumps({
                'type': 'assessment-%s' % assessment_type,
                'values': new_answers, 'location': 'AnswerHandler'}))

        return (student, assessment_type)
コード例 #2
0
    def post(self):
        """Handles POST requests."""
        user = self.personalize_page_and_get_user()
        if not user:
            self.redirect(users.create_login_url(self.request.uri))
            return

        if not self.assert_xsrf_token_or_fail(self.request, "register-post"):
            return

        can_register = self.app_context.get_environ()["reg_form"]["can_register"]
        if not can_register:
            self.template_value["course_status"] = "full"
        else:
            name = self.request.get("form01")

            # create new or re-enroll old student
            student = Student.get_by_email(user.email())
            if not student:
                student = Student(key_name=user.email())
                student.user_id = user.user_id()

            student.is_enrolled = True
            student.name = name
            student.put()

        # Render registration confirmation page
        self.template_value["navbar"] = {"registration": True}
        self.render("confirmation.html")
コード例 #3
0
    def get(self):
        """Get a students progress."""

        #teachers aren't course admins, so we probably shouldn't check for that
        # if not roles.Roles.is_course_admin(self.app_context):
        #     transforms.send_json_response(self, 401, 'Access denied.', {})
        #     return

        key = self.request.get('student')
        errors = []

        student = Student.get_by_email(key.strip())
        course = self.get_course()

        if student:
            units = teacher_parsers.StudentProgressTracker.get_detailed_progress(student, course)
        else:
            errors.append('An error occurred retrieving student data. Contact your course administrator.')
            self.validation_error('\n'.join(errors))
            return

        payload_dict = {
            'units': units,
            'student_name': student.name,
            'student_email': student.email
        }

        transforms.send_json_response(
            self, 200, '', payload_dict=payload_dict,
            xsrf_token=crypto.XsrfTokenManager.create_xsrf_token(
                self.XSRF_TOKEN))
コード例 #4
0
  def post(self):
    user = self.personalizePageAndGetUser()
    if not user:
      self.redirect(users.create_login_url(self.request.uri))
      return
    
    # Read in answers
    answer = json.dumps(self.request.POST.items())
    original_type = self.request.get('assessment_type')

    # Check for enrollment status
    student = Student.get_by_email(user.email())
    if student and student.is_enrolled:
      # Log answer submission
      logging.info(student.key().name() + ':' + answer)

      (student, assessment_type) = self.storeAssessmentTransaction(student.key().name(), original_type, answer)

      # Serve the confirmation page
      self.templateValue['navbar'] = {'course': True}
      self.templateValue['assessment'] = assessment_type
      self.templateValue['student_score'] = getScore(student, 'overall_score')
      self.render('test_confirmation.html')
    else:
      self.redirect('/register')
コード例 #5
0
ファイル: utils.py プロジェクト: supunkamburugamuve/mooc
    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')
コード例 #6
0
    def get(self):
        """Get activity scores."""
        request = transforms.loads(self.request.get('request'))
        payload = transforms.loads(request.get('payload'))
        errors = []

        students = payload['students']
        force_refresh = payload['forceRefresh']
        course = self.get_course()

        temp_students = []
        for student in students:
            if '@' in student:
                temp_students.append(Student.get_by_email(student).user_id)

        if len(temp_students) > 0:
            students = temp_students

        if len(students) > 0:
            scores = teacher_parsers.ActivityScoreParser.get_activity_scores(students, course, force_refresh)
        else:
            errors.append('An error occurred retrieving activity scores. Contact your course administrator.')
            self.validation_error('\n'.join(errors))
            return

        payload_dict = {
            'scores': scores['scores'],
            'dateCached': scores['date'].strftime("%B %d, %Y %H:%M:%S")
        }

        transforms.send_json_response(
            self, 200, '', payload_dict=payload_dict,
            xsrf_token=crypto.XsrfTokenManager.create_xsrf_token(
                self.XSRF_TOKEN))
コード例 #7
0
ファイル: utils.py プロジェクト: esacosta/u-mooc
 def get(self):
     student = Student.get_by_email(self.request.get("img_id"))
     if student.avatar:
         self.response.headers["Content-Type"] = "image/png"
         self.response.out.write(student.avatar)
     else:
         self.error(404)
コード例 #8
0
 def get(self):
     student = Student.get_by_email(self.request.get('img_id'))
     if student.avatar:
         self.response.headers['Content-Type'] = 'image/png'
         self.response.out.write(student.avatar)
     else:
         self.error(404)
コード例 #9
0
ファイル: utils.py プロジェクト: osushkov/greekcoursebuilder
    def post(self):
        """Handles POST requests."""
        user = self.personalize_page_and_get_user()
        if not user:
            self.redirect(users.create_login_url(self.request.uri))
            return

        if not self.assert_xsrf_token_or_fail(self.request, 'register-post'):
            return

        can_register = self.app_context.get_environ(
            )['reg_form']['can_register']
        if not can_register:
            self.template_value['course_status'] = 'full'
        else:
            name = self.request.get('form01')
            surname = self.request.get('form02')
            age = self.request.get('form03')

            # create new or re-enroll old student
            student = Student.get_by_email(user.email())
            if not student:
                student = Student(key_name=user.email())
                student.user_id = user.user_id()

            student.is_enrolled = False
            student.name = name
            student.surname = surname
            student.age = age
            student.put()

        # Render registration confirmation page
        self.template_value['navbar'] = {'registration': True}
        self.render('confirmation.html')
コード例 #10
0
    def update_assessment_transaction(self, email, assessment_type,
                                      new_answers, score):
        """Stores answer and updates user scores."""
        student = Student.get_by_email(email)

        # 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)

        assessment_type = store_score(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(),
            json.dumps({
                'type': 'assessment-%s' % assessment_type,
                'values': new_answers,
                'location': 'AnswerHandler'
            }))

        return (student, assessment_type)
コード例 #11
0
    def post(self):
        """Handles POST requests."""
        user = self.personalize_page_and_get_user()
        if not user:
            self.redirect(users.create_login_url(self.request.uri))
            return

        if not self.assert_xsrf_token_or_fail(self.request, 'register-post'):
            return

        can_register = self.app_context.get_environ(
        )['reg_form']['can_register']
        if not can_register:
            self.template_value['course_status'] = 'full'
        else:
            name = self.request.get('form01')

            # create new or re-enroll old student
            student = Student.get_by_email(user.email())
            if not student:
                student = Student(key_name=user.email())
                student.user_id = user.user_id()

            student.is_enrolled = True
            student.name = name
            student.put()

        # Render registration confirmation page
        self.template_value['navbar'] = {'registration': True}
        self.render('confirmation.html')
コード例 #12
0
ファイル: utils.py プロジェクト: maxwillzq/AllAboutPython
  def post(self):
    user = self.personalizePageAndGetUser()
    if not user:
      self.redirect(users.create_login_url(self.request.uri))
      return

    if (MAX_CLASS_SIZE and Student.all(keys_only=True).count() >= MAX_CLASS_SIZE):
      self.templateValue['course_status'] = 'full'
    else:
      # Create student record
      name = self.request.get('form01')

      # create new or re-enroll old student
      student = Student.get_by_email(user.email())
      if student:
        if not student.is_enrolled:
          student.is_enrolled = True
          student.name = name
      else:
        student = Student(key_name=user.email(), name=name, is_enrolled=True)
      student.put()

    # Render registration confirmation page
    self.templateValue['navbar'] = {'registration': True}
    self.render('confirmation.html')
コード例 #13
0
  def storeAssessmentTransaction(self, email, original_type, answer):
    student = Student.get_by_email(email)

    # TODO: considering storing as float for better precision
    score = int(round(float(self.request.get('score'))))
    assessment_type = storeAssessmentData(student, original_type, score, answer)
    student.put()
    return (student, assessment_type)
コード例 #14
0
ファイル: student_csv.py プロジェクト: twiffy/eabooc
 def name(self, email):
     name = self._names.get(email, None)
     if name:
         return name
     else:
         stud = Student.get_by_email(email)
         self._names[email] = stud.name
         return stud.name
コード例 #15
0
ファイル: student_csv.py プロジェクト: twiffy/eabooc
 def name(self, email):
     name = self._names.get(email, None)
     if name:
         return name
     else:
         stud = Student.get_by_email(email)
         self._names[email] = stud.name
         return stud.name
コード例 #16
0
ファイル: lessons.py プロジェクト: supunkamburugamuve/mooc2
    def get(self):
        """Handles GET requests."""
        if not self.personalize_page_and_get_enrolled():
            return

        user = self.personalize_page_and_get_user()
        student = Student.get_by_email(user.email())
        playlist = student.playlist
        
        # Extract incoming args
        unit_id, lesson_id = extract_unit_and_lesson_id(self)
        self.template_value['unit_id'] = unit_id
        self.template_value['lesson_id'] = lesson_id
        
        # Set template values for a unit and its lesson entities
        for unit in self.get_units():
            if unit.unit_id == str(unit_id):
                self.template_value['units'] = unit

        lessons = self.get_lessons(unit_id)
        self.template_value['lessons'] = lessons

        # Set template values for nav bar
        self.template_value['navbar'] = {'course': True}

        # Set template values for back and next nav buttons
        if lesson_id == 1:
            self.template_value['back_button_url'] = ''
        elif lessons[lesson_id - 2].activity:
            self.template_value['back_button_url'] = (
                'activity?unit=%s&lesson=%s' % (unit_id, lesson_id - 1))
        else:
            self.template_value['back_button_url'] = (
                'unit?unit=%s&lesson=%s' % (unit_id, lesson_id - 1))

        if lessons[lesson_id - 1].activity:
            self.template_value['playlist_button_url'] = (
                'activity?unit=%s&lessons=%s' % (unit_id, lesson_id))
        elif playlist[0] != (str(unit_id) + '.' + str(lesson_id)):
            self.template_value['playlist_button_url'] = ''
        else:
            self.template_value['playlist_button_url'] = (
                'unit?unit=%s&lesson=%s' % (unit_id, lesson_id + 1))

        if lessons[lesson_id - 1].activity:
            self.template_value['next_button_url'] = (
                'activity?unit=%s&lesson=%s' % (unit_id, lesson_id))
        elif lesson_id == len(lessons):
            self.template_value['next_button_url'] = ''
        else:
            self.template_value['next_button_url'] = (
                'unit?unit=%s&lesson=%s' % (unit_id, lesson_id + 1))

        self.response.out.write(unit_id)
        self.response.out.write(lesson_id)
コード例 #17
0
ファイル: custom_badge.py プロジェクト: twiffy/eabooc
    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))
コード例 #18
0
ファイル: utils.py プロジェクト: maxwillzq/AllAboutPython
  def post(self):
    user = self.personalizePageAndGetUser()
    if not user:
      self.redirect(users.create_login_url(self.request.uri))
      return

    # Update student record
    student = Student.get_by_email(user.email())
    if student and student.is_enrolled:
      student.is_enrolled = False
      student.put()
    self.templateValue['navbar'] = {'registration': True}
    self.render('unenroll_confirmation.html')
コード例 #19
0
    def get_student_dashboard(cls, dashboardHandler):
        """Renders Student Dashboard view.

           Also gets ALL students in ALL course sections for the registered user to
           build a jQuery autocomplete dropdown on the view.
        """

        student_email = dashboardHandler.request.get('student') or None #email will be in the request if opened from student list
                                                            # view, otherwise it will be None

        #need to go through every course section for the current user and get all unique students
        students = []
        course_sections = teacher_entity.CourseSectionEntity.get_course_sections_for_user()
        if course_sections and len(course_sections) > 0:
            for course_section in course_sections.values():
                if course_section.students and len(course_section.students) > 0:
                    for student_in_section in course_section.students.values():
                        if not any(x['user_id'] == student_in_section['user_id'] for x in students):
                            students.append(student_in_section)

        #check to see if we have a student and if we need to get detailed progress
        student = None
        if student_email:
            student = Student.get_by_email(student_email)

        if (student):
            course = dashboardHandler.get_course()
            units = teacher_parsers.StudentProgressTracker.get_detailed_progress(student, course)
            scores = teacher_parsers.ActivityScoreParser.get_activity_scores([student.user_id], course)
        else:
            units = None
            scores = None

        #render the template for the student dashboard view
        main_content = dashboardHandler.get_template(
            'student_detailed_progress.html', [TEMPLATES_DIR]).render(
                {
                    'units': units, #unit completion
                    'student': student, #course defined student object, need email and name
                    'students': students, #list of students, names and emails, from a course section student list
                    'scores': scores
                })

        #call DashboardHandler function to render the page
        dashboardHandler.render_page({
            'page_title': dashboardHandler.format_title('Student Dashboard'),
            'main_content': jinja2.utils.Markup(main_content)
        })
コード例 #20
0
ファイル: lessons.py プロジェクト: supunkamburugamuve/mooc2
    def get(self):
        """Handles GET requests."""
        if not self.personalize_page_and_get_enrolled():
            return
        
        user = self.personalize_page_and_get_user()
        student = Student.get_by_email(user.email())
        playlist = filter(lambda x: x != "", student.playlist)
        
        # Extract incoming args
        unit_id, lesson_id = extract_unit_and_lesson_id(self)
        self.template_value['unit_id'] = unit_id
        self.template_value['lesson_id'] = lesson_id

        # Set template values for a unit and its lesson entities
        for unit in self.get_units():
            if unit.unit_id == str(unit_id):
                self.template_value['units'] = unit

        lessons = self.get_lessons(unit_id)
        self.template_value['lessons'] = lessons

        # Set template values for nav bar
        self.template_value['navbar'] = {'course': True}

        # Set template values for back and next nav buttons
        self.template_value['back_button_url'] = (
            'unit?unit=%s&lesson=%s' % (unit_id, lesson_id))

        if str(unit_id) + '.' + str(lesson_id) in playlist:
            for i in range (len(playlist)):
                if playlist[i] == str(unit_id) + '.' + str(lesson_id) and i != len(playlist) - 1:
                    next_playlist = playlist[i + 1] #will go out of bounds if at last item in playlist
                    self.template_value['playlist_button_url'] = (
                        'unit?unit=%s&lesson=%s' % (next_playlist[0], next_playlist[2]))
                    break        

        if lesson_id == len(lessons):
            self.template_value['next_button_url'] = ''
        else:
            self.template_value['next_button_url'] = (
                'unit?unit=%s&lesson=%s' % (unit_id, lesson_id + 1))

        self.template_value['record_events'] = CAN_PERSIST_ACTIVITY_EVENTS.value
        self.template_value['event_xsrf_token'] = (
            XsrfTokenManager.create_xsrf_token('event-post'))

        self.render('activity.html')
コード例 #21
0
ファイル: utils.py プロジェクト: maxwillzq/AllAboutPython
  def post(self):
    user = self.personalizePageAndGetUser()
    if not user:
      self.redirect(users.create_login_url(self.request.uri))
      return

    # Update student record
    e = self.request.get('email')
    n = self.request.get('name')

    student = Student.get_by_email(e)
    if student:
      if (n != ''):
        student.name = n
      student.put()
    self.redirect('/student/editstudent?email='+e)
コード例 #22
0
    def add_new_teacher_for_user(cls, email, school, additional_fields, alerts):

        student_by_email = Student.get_by_email(email)

        if not student_by_email:
            alerts.append("This email is not registered as a student for this course")
            return None

        # assume a new teacher is active by default
        teacher = cls._add_new_teacher_for_user(
            student_by_email.user_id, email, student_by_email.name, school, True, additional_fields
        )

        if teacher:
            alerts.append("Teacher was successfully registered")

        return teacher
コード例 #23
0
ファイル: utils.py プロジェクト: supunkamburugamuve/mooc
 def post(self):
     """Handles POST requests"""
     user = self.personalize_page_and_get_user()
     student = Student.get_by_email(user.email())
     playlist = self.request.get_all('plist')
     playlist_urls = list(xrange(len(playlist)))        
     for i in range (0, len(playlist)):
         playlist_urls[i] = ('unit?unit=%s&lesson=%s' % (playlist[i][0], playlist[i][2]))        
         # for i in range (0, 22):
     #     plist = 'plist' + str(i)
     #     plist = self.request.get(plist)
     #     if (plist != ""):
     #         playlist.append(plist)
     student.playlist_urls = playlist_urls
     student.playlist = playlist
     student.put()
     self.redirect('/playlist')
コード例 #24
0
ファイル: utils.py プロジェクト: maxwillzq/AllAboutPython
  def get(self):
    user = self.personalizePageAndGetUser()
    if not user:
      self.redirect(users.create_login_url(self.request.uri))
      return

    self.templateValue['navbar'] = {}
    e = self.request.get('email')
    # Check for existing registration -> redirect to course page
    student = Student.get_by_email(e)
    if student == None:
      self.templateValue['student'] = None
      self.templateValue['errormsg'] = 'Error: Student with email ' + e + ' can not be found on the roster.'
    else:
      self.templateValue['student'] = student
      self.templateValue['scores'] = getAllScores(student)
    self.render('student_profile.html')
コード例 #25
0
def get_progress_for_course(user, course_prefix):
    """ DEPRECATED: Use get_total_progress_for_course instead!
      Returns a progess dict for the overall percentage of the course complete and an array of track
      percentages (in the order they appear in app.yaml) for the given course-prefix. """
    track_progress = []
    course_tasks_completed = 0
    total_course_tasks = 0
    all_course_app_contexts = controllers.sites.get_all_courses()
    for course_app_context in all_course_app_contexts:
        url_path = course_app_context.slug
        if not url_path.startswith("/" + course_prefix + "-"):
            continue
        namespace_manager.set_namespace(course_app_context.namespace)
        student = Student.get_by_email(user.email())
        course = CourseModel12.load(course_app_context)
        tracker = progress.UnitLessonCompletionTracker(course)
        if student:
            lesson_breakdown = tracker.get_task_progress(student)
            track_tasks_completed = 0
            total_track_tasks = 0
            for unit_tasks_completed, total_unit_tasks in lesson_breakdown.values(
            ):
                track_tasks_completed += unit_tasks_completed
                total_track_tasks += total_unit_tasks
            track_progress.append(track_tasks_completed /
                                  float(total_track_tasks))
            course_tasks_completed += track_tasks_completed
            total_course_tasks += total_track_tasks
            logging.info(
                "Lesson progress in %s:  %d of %d tasks completed" %
                (url_path, track_tasks_completed / 2, total_track_tasks / 2))
        else:
            track_progress.append(0)
            total_track_tasks = tracker.get_task_total()
            total_course_tasks += total_track_tasks
            logging.info("Student not enrolled in %s, which has %d tasks" %
                         (url_path, total_track_tasks / 2))
    namespace_manager.set_namespace("")
    return {
        "course": course_tasks_completed / float(total_course_tasks),
        "tracks": track_progress
    }
コード例 #26
0
    def post(self):
        """Handles POST requests."""
        user = self.personalize_page_and_get_user()
        if not user:
            self.redirect(users.create_login_url(self.request.uri),
                          normalize=False)
            return

        if not self.assert_xsrf_token_or_fail(self.request, 'register-post'):
            return

        can_register = self.app_context.get_environ(
        )['reg_form']['can_register']
        if not can_register:
            self.template_value['course_status'] = 'full'
        else:
            name = self.request.get('form01')
            additional_fields = transforms.dumps(self.request.POST.items())

            # create new or re-enroll old student
            student = Student.get_by_email(user.email())
            if not student:
                student = Student(key_name=user.email())
                student.user_id = user.user_id()

            student_by_uid = Student.get_student_by_user_id(user.user_id())
            is_valid_student = (student_by_uid is None
                                or student_by_uid.user_id == student.user_id)
            assert is_valid_student, (
                'Student\'s email and user id do not match.')

            student.user_id = user.user_id()
            student.is_enrolled = True
            student.name = name
            student.age = self.request.get('form02')
            student.additional_fields = additional_fields
            student.put()

        # Render registration confirmation page
        self.template_value['navbar'] = {'registration': True}
        self.render('confirmation.html')
コード例 #27
0
ファイル: lessons.py プロジェクト: supunkamburugamuve/mooc2
    def get(self):
        """Handles GET requests."""
        user = self.personalize_page_and_get_user()
        

        if not user:
            self.redirect('/preview')
            return None

        student = Student.get_by_email(user.email())
        playlist = student.playlist
        playlist_urls = student.playlist_urls

        if not self.personalize_page_and_get_enrolled():
            return

        self.template_value['units'] = self.get_units()
        self.template_value['playlist'] = playlist
        self.template_value['playlist_urls'] = playlist_urls
        self.template_value['navbar'] = {'course': True}
        self.render('course.html')
コード例 #28
0
ファイル: utils.py プロジェクト: osushkov/greekcoursebuilder
    def get(self):
        logging.error("c**k has occured")
        """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_by_email(user.email())
        if student and student.is_enrolled:
            self.redirect('/course')
            return

        self.template_value['navbar'] = {'registration': True}
        self.template_value['register_xsrf_token'] = (
            XsrfTokenManager.create_xsrf_token('register-post'))

        if student and not student.is_enrolled:
            self.render('application_pending.html')
        else:
            self.render('register.html')
コード例 #29
0
ファイル: utils.py プロジェクト: sesamesushi/satisrevude
    def create_or_enroll_student(self, user, name):
        # create new or re-enroll old student
        student = Student.get_by_email(user.email())
        if not student:
            student = Student(key_name=user.email())
            student.user_id = user.user_id()

            # Add to global student
            namespace = namespace_manager.get_namespace()
            try:
                namespace_manager.set_namespace("")
                global_student = Student(key_name=user.email())
                global_student.user_id = user.user_id()
                global_student.name = name
                global_student.put()
            finally:
                namespace_manager.set_namespace(namespace)

        student.is_enrolled = True
        student.name = name
        student.put()
コード例 #30
0
ファイル: utils.py プロジェクト: ksh/gpirecertification
    def post(self):
        """Handles POST requests."""
        user = self.personalize_page_and_get_user()
        if not user:
            self.redirect(
                users.create_login_url(self.request.uri), normalize=False)
            return

        if not self.assert_xsrf_token_or_fail(self.request, 'register-post'):
            return

        can_register = self.app_context.get_environ(
            )['reg_form']['can_register']
        if not can_register:
            self.template_value['course_status'] = 'full'
        else:
            name = self.request.get('form01')
            additional_fields = transforms.dumps(self.request.POST.items())

            # create new or re-enroll old student
            student = Student.get_by_email(user.email())
            if not student:
                student = Student(key_name=user.email())
                student.user_id = user.user_id()

            student_by_uid = Student.get_student_by_user_id(user.user_id())
            is_valid_student = (student_by_uid is None or
                                student_by_uid.user_id == student.user_id)
            assert is_valid_student, (
                'Student\'s email and user id do not match.')

            student.user_id = user.user_id()
            student.is_enrolled = True
            student.name = name
            student.additional_fields = additional_fields
            student.put()

        # Render registration confirmation page
        self.template_value['navbar'] = {'registration': True}
        self.render('confirmation.html')
コード例 #31
0
ファイル: utils.py プロジェクト: esacosta/u-mooc
    def post(self):
        """Handles POST requests."""
        user = self.personalize_page_and_get_user()
        if not user:
            self.redirect(users.create_login_url(self.request.uri), normalize=False)
            return

        if not self.assert_xsrf_token_or_fail(self.request, "register-post"):
            return

        can_register = self.app_context.get_environ()["reg_form"]["can_register"]
        if not can_register:
            self.template_value["course_status"] = "full"
        else:
            name = self.request.get("form01")
            additional_fields = transforms.dumps(self.request.POST.items())

            # create new or re-enroll old student
            student = Student.get_by_email(user.email())
            if not student:
                student = Student(key_name=user.email())
                student.user_id = user.user_id()

            student_by_uid = Student.get_student_by_user_id(user.user_id())
            is_valid_student = student_by_uid is None or student_by_uid.user_id == student.user_id
            assert is_valid_student, "Student's email and user id do not match."

            student.user_id = user.user_id()
            student.is_enrolled = True
            student.name = name
            student.age = self.request.get("formAge")
            student.additional_fields = additional_fields
            student.put()

        # Render registration confirmation page
        self.template_value["navbar"] = {"registration": True}
        self.render("confirmation.html")
コード例 #32
0
def get_progress_for_course(user, course_prefix):
    """ DEPRECATED: Use get_total_progress_for_course instead!
      Returns a progess dict for the overall percentage of the course complete and an array of track
      percentages (in the order they appear in app.yaml) for the given course-prefix. """
    track_progress = []
    course_tasks_completed = 0
    total_course_tasks = 0
    all_course_app_contexts = controllers.sites.get_all_courses()
    for course_app_context in all_course_app_contexts:
        url_path = course_app_context.slug
        if not url_path.startswith("/" + course_prefix + "-"):
            continue
        namespace_manager.set_namespace(course_app_context.namespace)
        student = Student.get_by_email(user.email())
        course = CourseModel12.load(course_app_context)
        tracker = progress.UnitLessonCompletionTracker(course)
        if student:
            lesson_breakdown = tracker.get_task_progress(student)
            track_tasks_completed = 0
            total_track_tasks = 0
            for unit_tasks_completed, total_unit_tasks in lesson_breakdown.values():
                track_tasks_completed += unit_tasks_completed
                total_track_tasks += total_unit_tasks
            track_progress.append(track_tasks_completed / float(total_track_tasks))
            course_tasks_completed += track_tasks_completed
            total_course_tasks += total_track_tasks
            logging.info(
                "Lesson progress in %s:  %d of %d tasks completed"
                % (url_path, track_tasks_completed / 2, total_track_tasks / 2)
            )
        else:
            track_progress.append(0)
            total_track_tasks = tracker.get_task_total()
            total_course_tasks += total_track_tasks
            logging.info("Student not enrolled in %s, which has %d tasks" % (url_path, total_track_tasks / 2))
    namespace_manager.set_namespace("")
    return {"course": course_tasks_completed / float(total_course_tasks), "tracks": track_progress}
コード例 #33
0
def get_total_progress_for_course(email,
                                  course_prefix,
                                  as_percent=True,
                                  get_total_tasks=False):
    """ Returns a progess dict for the overall percentage of the course complete and an array of track
      percentages, which is a dictionary of the total progress in the course and the progress of each
      unit, (in the order they appear in app.yaml) for the given course-prefix. 
      as_percent is used to specify if the unit's are expressed in percentage or as number of completed tasks
      with the 'get_total_tasks' flag each unit will have another entry called unitid-total that will be the number of total tasks in the unit """
    track_progress = []
    course_tasks_completed = 0
    total_course_tasks = 0
    all_course_app_contexts = controllers.sites.get_all_courses()
    for course_app_context in all_course_app_contexts:
        url_path = course_app_context.slug
        if not url_path.startswith("/" + course_prefix + "-"):
            continue
        namespace_manager.set_namespace(course_app_context.namespace)
        student = Student.get_by_email(email)
        course = CourseModel12.load(course_app_context)
        tracker = progress.UnitLessonCompletionTracker(course)
        if student:
            lesson_breakdown = tracker.get_task_progress_with_title(student)
            track_tasks_completed = 0
            total_track_tasks = 0
            units = {}
            for unit_title, unit in lesson_breakdown.items():
                track_tasks_completed += unit[0]
                total_track_tasks += unit[1]
                if as_percent:
                    units[unit_title] = unit[0] / float(unit[1])
                else:
                    units[unit_title] = unit[0] / 2
                if get_total_tasks:
                    units[unit_title + "-total"] = unit[1] / 2
            track_progress.append({
                'name':
                course_app_context.get_title(),
                'url':
                url_path,
                'track':
                track_tasks_completed / float(total_track_tasks),
                'units':
                units,
                'blurb':
                course_app_context.get_environ()['course']['blurb'].strip()
            })
            course_tasks_completed += track_tasks_completed
            total_course_tasks += total_track_tasks
            logging.info(
                "Lesson progress in %s:  %d of %d tasks completed" %
                (url_path, track_tasks_completed / 2, total_track_tasks / 2))
        else:
            track = {
                'name':
                course_app_context.get_title(),
                'track':
                0,
                'url':
                url_path,
                'units': {},
                'blurb':
                course_app_context.get_environ()['course']['blurb'].strip()
            }
            total_track_tasks = tracker.get_task_total()
            for unit in tracker.get_course_units():
                track['units'][unit.unit_id + ":" + unit.title] = 0
                if get_total_tasks:
                    unit_tasks = tracker.get_num_tasks_for_unit(unit)
                    track['units'][unit.unit_id + ":" + unit.title +
                                   "-total"] = unit_tasks
            total_course_tasks += total_track_tasks
            track_progress.append(track)
            logging.info("Student not enrolled in %s, which has %d tasks" %
                         (url_path, total_track_tasks / 2))
    namespace_manager.set_namespace("")
    if total_course_tasks == 0:
        logging.warn('WARNING: track %s has 0 total tasks' % url_path)
        total_course_tasks = 1
    return {
        "course": course_tasks_completed / float(total_course_tasks),
        "tracks": track_progress
    }
コード例 #34
0
ファイル: utils.py プロジェクト: twiffy/eabooc
    def post(self):
        """Handles POST requests."""
        user = self.personalize_page_and_get_user()
        if not user:
            self.redirect(
                users.create_login_url(self.request.uri), normalize=False)
            return

        if not self.assert_xsrf_token_or_fail(self.request, 'register-post'):
            return

        can_register = self.app_context.get_environ(
            )['reg_form']['can_register']
        if not can_register:
            self.template_value['course_status'] = 'full'
        else:
            missing = self.find_missing_fields(self.request.POST)
            if missing:
                self.template_value['navbar'] = {'registration': True}
                self.template_value['content'] = '''
                <div class="gcb-col-11 gcb-aside">
                <h2>Something is missing...</h2>
                <p>You didn't fill out all the required fields in the registration form.
                Please use your browser's BACK button, and complete the form before
                submitting.</p>

                <p>Missing: {0}</p>

                <p>Thanks!</p>
                </div>
                '''.format(", ".join(missing))
                self.render('bare.html')
                return

            # We accept the form.  Now populate the student model:

            # create new or re-enroll old student
            student = Student.get_by_email(user.email())
            if not student:
                student = Student(key_name=user.email())
                student.user_id = user.user_id()

            student_by_uid = Student.get_student_by_user_id(user.user_id())
            is_valid_student = (student_by_uid is None or
                                student_by_uid.user_id == student.user_id)
            assert is_valid_student, (
                'Student\'s email and user id do not match.')

            student.user_id = user.user_id()
            student.is_enrolled = True

            string_fields = ('name', 'location_city',
                    'location_state', 'location_country',
                    'education_level', 'role',
                    'other_role')

            for field in string_fields:
                setattr(student, field, self.request.POST.get(field, None))

            string_list_fields = ('grade_levels', 'title_and_setting',
                    'research_area', 'faculty_area', 'student_subject')

            for field in string_list_fields:
                raw = self.request.POST.get(field, '')
                if len(raw) > 0:
                    values = [s.strip() for s in raw.split(',')]
                    setattr(student, field, values)

            student.put()

            # now that we're in full registration, don't subscribe to pre-reg any more
            #mailchimp.subscribe('pre-reg', user.email(), student.name)

            self.redirect('confirm')
            return

        # Render registration confirmation page
        self.template_value['navbar'] = {'registration': True}
        self.render('confirmation.html')
コード例 #35
0
ファイル: mentor_list.py プロジェクト: thejeshgn/seek
    def add_mentors(cls, handler):
        template_values = {}
        template_values['page_title'] = handler.format_title('Added Mentors')
        mentor_email_lc_list = cls.parse_mentor_csv(
            handler.request.get('mentor_email_list'))

        added_mentors = []
        not_found_mentors = []

        for m in mentor_email_lc_list:
            if len(m) < 1:
                continue

            email = m[0].strip()
            if len(m) >= 2:
                college_id = m[1].strip()
            else:
                college_id = ''

            if not email:
                continue
            p = Student.get_by_email(email)
            if (p is None
                    or (college_id and local_chapter_model.LocalChapterDAO.
                        get_local_chapter_by_key(college_id) is None)):
                not_found_mentors.append(email)
            else:
                mentor = Mentor.get_or_create(user_id=p.user_id)
                if college_id:
                    mentor.local_chapter = True
                    mentor.college_id = college_id
                else:
                    mentor.local_chapter = False
                mentor.put()
                added_mentors.append(email)

        content = safe_dom.NodeList()
        if len(added_mentors) > 0:
            content.append(
                safe_dom.Element('h3').add_text('Successfully added Mentors'))
            l = safe_dom.Element('ol')
            for m in added_mentors:
                l.add_child(safe_dom.Element('li').add_text(m))
            content.append(l)

        if len(not_found_mentors) > 0:
            content.append(
                safe_dom.Element('h3').add_text('Mentor Addition Failed'))
            l = safe_dom.Element('ol')
            for m in not_found_mentors:
                l.add_child(safe_dom.Element('li').add_text(m))
            content.append(l)

        if len(not_found_mentors) == 0 and len(added_mentors) == 0:
            content.append(
                safe_dom.Element('h3').add_text(
                    'No Emails specified for adding to mentor list'))

        handler.render_page(
            {
                'page_title': handler.format_title(cls.NAME),
                'main_content': content
            },
            in_action=cls.DASHBOARD_NAV,
            in_tab=cls.DASHBOARD_SHOW_LIST_TAB)
コード例 #36
0
    def put(self):
        """Inserts or updates a course section."""
        request = transforms.loads(self.request.get('request'))
        key = request.get('key')

        if not self.assert_xsrf_token_or_fail(
                request, self.XSRF_TOKEN, {}):
            return

        payload = request.get('payload')
        json_dict = transforms.loads(payload)
        python_dict = transforms.json_to_dict(
            json_dict, self.get_schema().get_json_schema_dict(),
            permit_none_values=True)

        version = python_dict.get('version')
        if version not in self.SCHEMA_VERSIONS:
            self.validation_error('Version %s not supported.' % version)
            return

        errors = []

        teacher = teacher_entity.Teacher.get_by_email(users.get_current_user().email())

        if not teacher:
            errors.append('Unable to save changes. Teacher is not registered. Please contact a course admin.')
            self.validation_error('\n'.join(errors))
            return

        if not teacher.is_active:
            errors.append('Unable to save changes. Teacher account is inactive.')
            self.validation_error('\n'.join(errors))
            return

        if key:
            key_after_save = key
            new_course_section = teacher_entity.CourseSectionEntity.get_course_for_user(key)

            students = new_course_section.students or {}
            emails = ""
            if 'students' in python_dict and python_dict['students'] is not None:
                emails = python_dict['students']['emails'].split(',')
            for email in emails:
                clean_email = email.strip().replace('\n', '').replace('\r', '')
                student = Student.get_by_email(clean_email)
                if student:
                    if python_dict['students']['action'] == 'insert':
                        student_info = {}
                        student_info['email'] = clean_email
                        student_info['name'] = student.name
                        student_info['user_id'] = student.user_id
                        students[student.user_id] = student_info
                    else:
                        students.pop(student.user_id, None)
                else:
                    errors.append('Unable to find student with email: ' + clean_email)

            sorted_students = sorted(students.values(), key=lambda k: (k['name']))

            if python_dict.get('name') != None:
                new_course_section.section_name = python_dict.get('name')
            if python_dict.get('active') != None:
                new_course_section.is_active = python_dict.get('active')
            if python_dict.get('description') != None:
                new_course_section.section_description = python_dict.get('description')
            if python_dict.get('year') != None:
                new_course_section.section_year = python_dict.get('year')

            course_section = teacher_entity.CourseSectionDTO.build(
                new_course_section.section_name, new_course_section.section_description,
                new_course_section.is_active, students, new_course_section.section_year)
            teacher_entity.CourseSectionEntity.update_course_section(key, course_section, errors)
        else:
            course_section = teacher_entity.CourseSectionDTO.build(
                python_dict.get('name'), python_dict.get('description'), python_dict.get('active'), {},
                python_dict.get('year'))
            key_after_save = teacher_entity.CourseSectionEntity.add_new_course_section(key, course_section, errors)

        if errors:
            self.validation_error('\n'.join(errors), key=key_after_save)
            return

        section = teacher_entity.CourseSectionEntity.get_course_for_user(key_after_save)
        if section:
            section.students = sorted_students
            if section.students and len(section.students) > 0:
                for student in section.students:
                    student['unit_completion'] = teacher_parsers.StudentProgressTracker.get_unit_completion(
                        Student.get_by_email(
                        student[
                        'email']), self.get_course())
                    student['course_completion'] = teacher_parsers.StudentProgressTracker.get_overall_progress(
                        Student.get_by_email(
                        student[
                        'email']), self.get_course())
                    student['detailed_course_completion'] = \
                        teacher_parsers.StudentProgressTracker.get_detailed_progress(
                        Student.get_by_email(student['email']), self.get_course())

        course_sections = teacher_entity.CourseSectionEntity.get_course_sections_for_user()

        if course_sections is not None:
            sorted_course_sections = sorted(course_sections.values(), key=lambda k: (k.section_year,
                                                                                 k.section_name.lower()))
        else:
            sorted_course_sections = {}

        payload_dict = {
            'key': key_after_save,
            'section': section,
            'section_list': sorted_course_sections
        }

        transforms.send_json_response(
            self, 200, 'Saved.', payload_dict)
コード例 #37
0
ファイル: custom_badge.py プロジェクト: twiffy/eabooc
    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))
コード例 #38
0
ファイル: lessons.py プロジェクト: supunkamburugamuve/mooc2
    def get(self):
        """Handles GET requests."""
        if not self.personalize_page_and_get_enrolled():
            return

        user = self.personalize_page_and_get_user()
        student = Student.get_by_email(user.email())
        playlist = filter(lambda x: x != "", student.playlist)
        
        # Extract incoming args
        unit_id, lesson_id = extract_unit_and_lesson_id(self)
        self.template_value['unit_id'] = unit_id
        self.template_value['lesson_id'] = lesson_id

        # Set template values for a unit and its lesson entities
        for unit in self.get_units():
            if unit.unit_id == str(unit_id):
                self.template_value['units'] = unit

        lessons = self.get_lessons(unit_id)
        self.template_value['lessons'] = lessons

        # Set template values for nav bar
        self.template_value['navbar'] = {'course': True}

        # Set template values for back and next nav buttons
        if lesson_id == 1:
            self.template_value['back_button_url'] = ''
        elif lessons[lesson_id - 2].activity:
            self.template_value['back_button_url'] = (
                'activity?unit=%s&lesson=%s' % (unit_id, lesson_id - 1))
        else:
            self.template_value['back_button_url'] = (
                'unit?unit=%s&lesson=%s' % (unit_id, lesson_id - 1))

        if lessons[lesson_id - 1].activity:
            self.template_value['playlist_button_url'] = (
                'activity?unit=%s&lesson=%s' % (unit_id, lesson_id))
        elif str(unit_id) + '.' + str(lesson_id) in playlist:
            for i in range (len(playlist)):
                if playlist[i] == str(unit_id) + '.' + str(lesson_id):
                    if i != len(playlist) - 1:
                        next_playlist = playlist[i + 1] #will go out of bounds if at last item in playlist
                        self.template_value['playlist_button_url'] = (
                            'unit?unit=%s&lesson=%s' % (next_playlist[0], next_playlist[2]))
                        break        
            

        # if lessons[lesson_id - 1].activity:
        #     self.template_value['playlist_button_url'] = (
        #         'activity?unit=%s&lessons=%s' % (unit_id, lesson_id))
        # else:
        #     self.template_value['playlist_button_url'] = (
        #         'unit?unit=%s&lesson=%s' % (unit_id, lesson_id + 
        #                                    1))

        if lessons[lesson_id - 1].activity:
            self.template_value['next_button_url'] = (
                'activity?unit=%s&lesson=%s' % (unit_id, lesson_id))
        elif lesson_id == len(lessons):
            self.template_value['next_button_url'] = ''
        else:
            self.template_value['next_button_url'] = (
                'unit?unit=%s&lesson=%s' % (unit_id, lesson_id + 1))

        self.render('unit.html')
コード例 #39
0
ファイル: utils.py プロジェクト: ehiller/course-builder
 def get_student(self):
     """Get the current student."""
     user = self.get_user()
     if user is None:
         return None
     return Student.get_by_email(user.email())
コード例 #40
0
ファイル: utils.py プロジェクト: Rosebotics/RoseboticsWeb
 def get_student(self):
     """Get the current student."""
     user = self.get_user()
     if user is None:
         return None
     return Student.get_by_email(user.email())
コード例 #41
0
    def get_roster(cls, dashboardHandler):
        """Renders the Roster view. Displays all students in a single course section

           Also allows user to add students to a course section
        """

        template_values = {}
        template_values['add_student_xsrf_token'] = crypto.XsrfTokenManager.create_xsrf_token(
            teacher_rest_handlers.CourseSectionRestHandler.XSRF_TOKEN)

        #need list of units and lessons for select elements that determine which progress value to display
        #need a list of units, need the titles, unit ids, types
        units = dashboardHandler.get_course().get_units()
        units_filtered = filter(lambda x: x.type == 'U', units) #filter out assessments
        template_values['units'] = units_filtered

        #need to get lessons, but only for units that aren't assessments
        lessons = {}
        for unit in units_filtered:
            unit_lessons = dashboardHandler.get_course().get_lessons(unit.unit_id)
            unit_lessons_filtered = []
            for lesson in unit_lessons:
                unit_lessons_filtered.append({
                    'title': lesson.title,
                    'unit_id': lesson.unit_id,
                    'lesson_id': lesson.lesson_id
                })
            lessons[unit.unit_id] = unit_lessons_filtered
        template_values['lessons'] = transforms.dumps(lessons, {}) #passing in JSON to template so it can be used
                                                                    # in JavaScript

        course_section_id = dashboardHandler.request.get('section')

        course_section = teacher_entity.CourseSectionEntity.get_course_for_user(course_section_id)
        students = {}

        #need to get progress values for ALL students since we show completion for every student
        if course_section.students and len(course_section.students) > 0:
            #course_section.students = sorted(course_section.students.values(), key=lambda k: (k['name']))
            for student in course_section.students.values():
                temp_student = {}

                temp_student['unit_completion'] = teacher_parsers.StudentProgressTracker.get_unit_completion(
                    Student.get_by_email(
                    student[
                    'email']), dashboardHandler.get_course())
                temp_student['course_completion'] = teacher_parsers.StudentProgressTracker.get_overall_progress(Student.get_by_email(student[
                    'email']), dashboardHandler.get_course())
                temp_student['detailed_course_completion'] = teacher_parsers.StudentProgressTracker.get_detailed_progress(
                    Student.get_by_email(student['email']), dashboardHandler.get_course())
                temp_student['email'] = student['email']
                temp_student['name'] = student['name']

                students[student['email']] = temp_student

        course_section.students = students

        #passing in students as JSON so JavaScript can handle updating completion values easier
        template_values['students_json'] = transforms.dumps(course_section.students, {})
        template_values['namespace'] = dashboardHandler.get_course()._namespace.replace('ns_', '')

        if course_section:
            template_values['section'] = course_section

        #render student_list.html for Roster view
        main_content = dashboardHandler.get_template(
            'student_list.html', [TEMPLATES_DIR]).render(template_values)

        #DashboardHandler renders the page
        dashboardHandler.render_page({
            'page_title': dashboardHandler.format_title('Student List'),
            'main_content': jinja2.utils.Markup(main_content)})