Merge pull request #1463 from MITx/feature/brian/pearson-exam

Feature/brian/pearson exam

common/lib/xmodule/setup.py

@@ -34,6 +34,7 @@ setup(
             "section = xmodule.backcompat_module:SemanticSectionDescriptor",
             "sequential = xmodule.seq_module:SequenceDescriptor",
             "slides = xmodule.backcompat_module:TranslateCustomTagDescriptor",
+            "timelimit = xmodule.timelimit_module:TimeLimitDescriptor",
             "vertical = xmodule.vertical_module:VerticalDescriptor",
             "video = xmodule.video_module:VideoDescriptor",
             "videodev = xmodule.backcompat_module:TranslateCustomTagDescriptor",

common/lib/xmodule/xmodule/course_module.py

@@ -648,7 +648,7 @@ class CourseDescriptor(SequenceDescriptor):
                 raise ValueError("First appointment date must be before last appointment date")
             if self.registration_end_date > self.last_eligible_appointment_date:
                 raise ValueError("Registration end date must be before last appointment date")
-
+            self.exam_url = exam_info.get('Exam_URL')
 
         def _try_parse_time(self, key):
             """
@@ -704,6 +704,10 @@ class CourseDescriptor(SequenceDescriptor):
         else:
             return None
 
+    def get_test_center_exam(self, exam_series_code):
+        exams = [exam for exam in self.test_center_exams if exam.exam_series_code == exam_series_code]
+        return exams[0] if len(exams) == 1 else None
+        
     @property
     def title(self):
         return self.display_name

common/lib/xmodule/xmodule/modulestore/xml.py

@@ -73,7 +73,7 @@ class ImportSystem(XMLParsingSystem, MakoDescriptorSystem):
                 # VS[compat]. Take this out once course conversion is done (perhaps leave the uniqueness check)
 
                 # tags that really need unique names--they store (or should store) state.
-                need_uniq_names = ('problem', 'sequential', 'video', 'course', 'chapter', 'videosequence')
+                need_uniq_names = ('problem', 'sequential', 'video', 'course', 'chapter', 'videosequence', 'timelimit')
 
                 attr = xml_data.attrib
                 tag = xml_data.tag

common/lib/xmodule/xmodule/timelimit_module.py

+import json
+import logging
+
+from lxml import etree
+from time import time
+
+from xmodule.editing_module import XMLEditingDescriptor
+from xmodule.xml_module import XmlDescriptor
+from xmodule.x_module import XModule
+from xmodule.progress import Progress
+from xmodule.exceptions import NotFoundError
+
+
+log = logging.getLogger(__name__)
+
+class TimeLimitModule(XModule):
+    ''' 
+    Wrapper module which imposes a time constraint for the completion of its child.
+    '''
+
+    def __init__(self, system, location, definition, descriptor, instance_state=None,
+                 shared_state=None, **kwargs):
+        XModule.__init__(self, system, location, definition, descriptor,
+                         instance_state, shared_state, **kwargs)
+
+        self.rendered = False
+        self.beginning_at = None
+        self.ending_at = None
+        self.accommodation_code = None
+        
+        if instance_state is not None:
+            state = json.loads(instance_state)
+
+            if 'beginning_at' in state:
+                self.beginning_at = state['beginning_at']
+            if 'ending_at' in state:
+                self.ending_at = state['ending_at']
+            if 'accommodation_code' in state:
+                self.accommodation_code = state['accommodation_code']
+                
+    # For a timed activity, we are only interested here
+    # in time-related accommodations, and these should be disjoint.
+    # (For proctored exams, it is possible to have multiple accommodations
+    # apply to an exam, so they require accommodating a multi-choice.)
+    TIME_ACCOMMODATION_CODES = (('NONE', 'No Time Accommodation'),
+                      ('ADDHALFTIME', 'Extra Time - 1 1/2 Time'),
+                      ('ADD30MIN', 'Extra Time - 30 Minutes'),
+                      ('DOUBLE', 'Extra Time - Double Time'),
+                      ('TESTING', 'Extra Time -- Large amount for testing purposes')
+                    )
+
+    def _get_accommodated_duration(self, duration):
+        ''' 
+        Get duration for activity, as adjusted for accommodations.
+        Input and output are expressed in seconds.
+        '''
+        if self.accommodation_code is None or self.accommodation_code == 'NONE':
+            return duration
+        elif self.accommodation_code == 'ADDHALFTIME':
+            # TODO:  determine what type to return
+            return int(duration * 1.5)
+        elif self.accommodation_code == 'ADD30MIN':
+            return (duration + (30 * 60))
+        elif self.accommodation_code == 'DOUBLE':
+            return (duration * 2)
+        elif self.accommodation_code == 'TESTING':
+            # when testing, set timer to run for a week at a time.
+            return 3600 * 24 * 7
+
+    @property
+    def has_begun(self):
+        return self.beginning_at is not None
+    
+    @property    
+    def has_ended(self):
+        if not self.ending_at:
+            return False
+        return self.ending_at < time()
+        
+    def begin(self, duration):
+        ''' 
+        Sets the starting time and ending time for the activity,
+        based on the duration provided (in seconds).
+        '''
+        self.beginning_at = time()
+        modified_duration = self._get_accommodated_duration(duration)
+        self.ending_at = self.beginning_at + modified_duration
+        
+    def get_end_time_in_ms(self):
+        return int(self.ending_at * 1000)
+
+    def get_instance_state(self):
+        state = {}
+        if self.beginning_at:
+            state['beginning_at'] = self.beginning_at
+        if self.ending_at:
+            state['ending_at'] = self.ending_at
+        if self.accommodation_code:
+            state['accommodation_code'] = self.accommodation_code
+        return json.dumps(state)
+
+    def get_html(self):
+        self.render()
+        return self.content
+
+    def get_progress(self):
+        ''' Return the total progress, adding total done and total available.
+        (assumes that each submodule uses the same "units" for progress.)
+        '''
+        # TODO: Cache progress or children array?
+        children = self.get_children()
+        progresses = [child.get_progress() for child in children]
+        progress = reduce(Progress.add_counts, progresses)
+        return progress
+
+    def handle_ajax(self, dispatch, get):
+        raise NotFoundError('Unexpected dispatch type')
+
+    def render(self):
+        if self.rendered:
+            return
+        # assumes there is one and only one child, so it only renders the first child
+        children = self.get_display_items()
+        if children:
+            child = children[0]
+            self.content = child.get_html()
+        self.rendered = True
+
+    def get_icon_class(self):
+        children = self.get_children()
+        if children:
+            return children[0].get_icon_class()
+        else:
+            return "other"
+
+class TimeLimitDescriptor(XMLEditingDescriptor, XmlDescriptor):
+
+    module_class = TimeLimitModule
+
+    # For remembering when a student started, and when they should end
+    stores_state = True 
+
+    @classmethod
+    def definition_from_xml(cls, xml_object, system):
+        children = []
+        for child in xml_object:
+            try:
+                children.append(system.process_xml(etree.tostring(child, encoding='unicode')).location.url())
+            except Exception as e:
+                log.exception("Unable to load child when parsing TimeLimit wrapper. Continuing...")
+                if system.error_tracker is not None:
+                    system.error_tracker("ERROR: " + str(e))
+                continue
+        return {'children': children}
+
+    def definition_to_xml(self, resource_fs):
+        xml_object = etree.Element('timelimit')
+        for child in self.get_children():
+            xml_object.append(
+                etree.fromstring(child.export_to_xml(resource_fs)))
+        return xml_object
+

lms/djangoapps/courseware/models.py

@@ -13,14 +13,8 @@ ASSUMPTIONS: modules have unique IDs, even across different module_types
 
 """
 from django.db import models
-#from django.core.cache import cache
 from django.contrib.auth.models import User
 
-#from cache_toolbox import cache_model, cache_relation
-
-#CACHE_TIMEOUT = 60 * 60 * 4 # Set the cache timeout to be four hours
-
-
 class StudentModule(models.Model):
     """
     Keeps student state for a particular module in a particular course.
@@ -30,6 +24,7 @@ class StudentModule(models.Model):
     MODULE_TYPES = (('problem', 'problem'),
                     ('video', 'video'),
                     ('html', 'html'),
+                    ('timelimit', 'timelimit'),
                     )
     ## These three are the key for the object
     module_type = models.CharField(max_length=32, choices=MODULE_TYPES, default='problem', db_index=True)

lms/djangoapps/courseware/views.py

@@ -8,7 +8,7 @@ from django.core.context_processors import csrf
 from django.core.urlresolvers import reverse
 from django.contrib.auth.models import User
 from django.contrib.auth.decorators import login_required
-from django.http import Http404
+from django.http import Http404, HttpResponseRedirect
 from django.shortcuts import redirect
 from mitxmako.shortcuts import render_to_response, render_to_string
 #from django.views.decorators.csrf import ensure_csrf_cookie
@@ -20,7 +20,7 @@ from courseware.access import has_access
 from courseware.courses import (get_courses, get_course_with_access,
                                 get_courses_by_university, sort_by_announcement)
 import courseware.tabs as tabs
-from courseware.models import StudentModuleCache
+from courseware.models import StudentModule, StudentModuleCache
 from module_render import toc_for_course, get_module, get_instance_module, get_module_for_descriptor
 
 from django_comment_client.utils import get_discussion_title
@@ -153,6 +153,76 @@ def save_child_position(seq_module, child_name, instance_module):
                 instance_module.state = seq_module.get_instance_state()
                 instance_module.save()
 
+def check_for_active_timelimit_module(request, course_id, course):
+    '''
+    Looks for a timing module for the given user and course that is currently active.
+    If found, returns a context dict with timer-related values to enable display of time remaining.
+    ''' 
+    context = {}
+    timelimit_student_modules = StudentModule.objects.filter(student=request.user, course_id=course_id, module_type='timelimit')
+    if timelimit_student_modules:
+        for timelimit_student_module in timelimit_student_modules: 
+            # get the corresponding section_descriptor for the given StudentModel entry:
+            module_state_key = timelimit_student_module.module_state_key
+            timelimit_descriptor = modulestore().get_instance(course_id, Location(module_state_key))
+            timelimit_module_cache = StudentModuleCache.cache_for_descriptor_descendents(course.id, request.user, 
+                                                                                     timelimit_descriptor, depth=None)
+            timelimit_module = get_module_for_descriptor(request.user, request, timelimit_descriptor, 
+                                                     timelimit_module_cache, course.id, position=None)
+            if timelimit_module is not None and timelimit_module.category == 'timelimit' and \
+                    timelimit_module.has_begun and not timelimit_module.has_ended:
+                location = timelimit_module.location
+                # determine where to go when the timer expires:
+                if 'time_expired_redirect_url' not in timelimit_descriptor.metadata:
+                    raise Http404("No {0} metadata at this location: {1} ".format('time_expired_redirect_url', location))
+                time_expired_redirect_url = timelimit_descriptor.metadata.get('time_expired_redirect_url')
+                context['time_expired_redirect_url'] = time_expired_redirect_url
+                # Fetch the end time (in GMT) as stored in the module when it was started.
+                # This value should be UTC time as number of milliseconds since epoch.
+                end_date = timelimit_module.get_end_time_in_ms()
+                context['timer_expiration_datetime'] = end_date
+                if 'suppress_toplevel_navigation' in timelimit_descriptor.metadata:
+                    context['suppress_toplevel_navigation'] = timelimit_descriptor.metadata['suppress_toplevel_navigation']
+                return_url = reverse('jump_to', kwargs={'course_id':course_id, 'location':location})
+                context['timer_navigation_return_url'] = return_url
+    return context
+
+def update_timelimit_module(user, course_id, student_module_cache, timelimit_descriptor, timelimit_module):
+    '''
+    Updates the state of the provided timing module, starting it if it hasn't begun.
+    Returns dict with timer-related values to enable display of time remaining.
+    Returns 'timer_expiration_datetime' in dict if timer is still active, and not if timer has expired.
+    ''' 
+    context = {}
+    # determine where to go when the exam ends:
+    if 'time_expired_redirect_url' not in timelimit_descriptor.metadata: 
+        raise Http404("No {0} metadata at this location: {1} ".format('time_expired_redirect_url', timelimit_module.location))
+    time_expired_redirect_url = timelimit_descriptor.metadata.get('time_expired_redirect_url')
+    context['time_expired_redirect_url'] = time_expired_redirect_url
+
+    if not timelimit_module.has_ended:
+        if not timelimit_module.has_begun:
+            # user has not started the exam, so start it now.
+            if 'duration' not in timelimit_descriptor.metadata:
+                raise Http404("No {0} metadata at this location: {1} ".format('duration', timelimit_module.location))
+            # The user may have an accommodation that has been granted to them.
+            # This accommodation information should already be stored in the module's state.
+            duration = int(timelimit_descriptor.metadata.get('duration'))
+            timelimit_module.begin(duration)
+            # we have changed state, so we need to persist the change:
+            instance_module = get_instance_module(course_id, user, timelimit_module, student_module_cache)
+            instance_module.state = timelimit_module.get_instance_state()
+            instance_module.save()
+            
+        # the exam has been started, either because the student is returning to the
+        # exam page, or because they have just visited it.  Fetch the end time (in GMT) as stored
+        # in the module when it was started.
+        # This value should be UTC time as number of milliseconds since epoch.
+        context['timer_expiration_datetime'] = timelimit_module.get_end_time_in_ms()
+        # also use the timed module to determine whether top-level navigation is visible:
+        if 'suppress_toplevel_navigation' in timelimit_descriptor.metadata:
+            context['suppress_toplevel_navigation'] = timelimit_descriptor.metadata['suppress_toplevel_navigation']
+    return context
 
 @login_required
 @ensure_csrf_cookie
@@ -222,7 +292,7 @@ def index(request, course_id, chapter=None, section=None,
             instance_module = get_instance_module(course_id, request.user, course_module, student_module_cache)
             save_child_position(course_module, chapter, instance_module)
         else:
-            raise Http404
+            raise Http404('No chapter descriptor found with name {}'.format(chapter))
 
         chapter_module = course_module.get_child_by(lambda m: m.url_name == chapter)
         if chapter_module is None:
@@ -251,7 +321,20 @@ def index(request, course_id, chapter=None, section=None,
             instance_module = get_instance_module(course_id, request.user, chapter_module, student_module_cache)
             save_child_position(chapter_module, section, instance_module)
 
-
+            # check here if this section *is* a timed module.  
+            if section_module.category == 'timelimit':
+                timer_context = update_timelimit_module(request.user, course_id, student_module_cache, 
+                                                        section_descriptor, section_module)
+                if 'timer_expiration_datetime' in timer_context:
+                    context.update(timer_context)
+                else:
+                    # if there is no expiration defined, then we know the timer has expired:
+                    return HttpResponseRedirect(timer_context['time_expired_redirect_url'])
+            else:
+                # check here if this page is within a course that has an active timed module running.  If so, then 
+                # add in the appropriate timer information to the rendering context:
+                context.update(check_for_active_timelimit_module(request, course_id, course))
+                
             context['content'] = section_module.get_html()
         else:
             # section is none, so display a message

lms/static/sass/course.scss

@@ -22,7 +22,7 @@
 @import 'course/courseware/sidebar';
 @import 'course/courseware/amplifier';
 @import 'course/layout/calculator';
-
+@import 'course/layout/timer';
 
 // course-specific courseware (all styles in these files should be gated by a
 // course-specific class). This should be replaced with a better way of

lms/static/sass/course/layout/_timer.scss

+div.timer-main {
+  position: fixed;
+  z-index: 99;
+  top: 0;
+  right: 0;
+  width: 100%;
+  border-top: 2px solid #000;
+
+  div#timer_wrapper {
+    position: absolute;
+    top: -3px;
+    right: 10px;
+    background: #000;
+    color: #fff;
+    padding: 10px 20px;
+    border-radius: 3px;
+  }
+
+  .timer_return_url {
+    display: block;
+    margin-bottom: 5px;
+    border-bottom: 1px solid tint(#000, 20%);
+    padding-bottom: 5px;
+    font-size: 13px;
+  }
+
+  .timer_label {
+    color: #b0b0b0;
+    font-size: 13px;
+    margin-bottom: 3px;
+  }
+
+  #exam_timer {
+    font-weight: bold;
+    font-size: 15px;
+    letter-spacing: 1px;
+  }
+}

lms/templates/courseware/courseware.html

@@ -59,12 +59,75 @@
         });
       });
   </script>
+
+% if timer_expiration_datetime:
+  <script type="text/javascript">  
+    var timer = {
+      timer_inst : null,   
+      get_remaining_secs : function() {
+        // set the end time when the template is rendered.
+        // This value should be UTC time as number of milliseconds since epoch.
+        var endTime = new Date(${timer_expiration_datetime});
+        var currentTime = new Date();
+        var remaining_secs = Math.floor((endTime - currentTime)/1000);
+        return remaining_secs;
+      },
+      get_time_string : function() {
+        function pretty_time_string(num) {
+          return ( num < 10 ? "0" : "" ) + num;
+        }
+        // count down in terms of hours, minutes, and seconds:
+        var hours = pretty_time_string(Math.floor(remaining_secs / 3600));
+        remaining_secs = remaining_secs % 3600;
+        var minutes = pretty_time_string(Math.floor(remaining_secs / 60));
+        remaining_secs = remaining_secs % 60;
+        var seconds = pretty_time_string(Math.floor(remaining_secs));      
+       
+        var remainingTimeString = hours + ":" + minutes + ":" + seconds;
+        return remainingTimeString;
+      },
+      update_time : function(self) {
+        remaining_secs = self.get_remaining_secs();
+        if (remaining_secs <= 0) {
+          self.end(self);
+        }
+        $('#exam_timer').text(self.get_time_string(remaining_secs));
+      },
+      start : function() { var that = this;
+        this.timer_inst = setInterval(function(){ that.update_time(that); }, 1000);
+      },
+      end : function(self) {
+        clearInterval(self.timer_inst);
+        // redirect to specified URL:
+        window.location = "${time_expired_redirect_url}"; 
+      }
+    }  
+    // start timer right away: 
+    timer.start(); 
+  </script>
+% endif
+
 </%block>
 
-<%include file="/courseware/course_navigation.html" args="active_page='courseware'" />
+% if timer_expiration_datetime:
+<div class="timer-main">
+  <div id="timer_wrapper">
+    % if timer_navigation_return_url:
+    <a href="${timer_navigation_return_url}" class="timer_return_url">Return to Exam</a>
+    % endif
+    <div class="timer_label">Time Remaining:</div> <div id="exam_timer" class="timer_value">&nbsp;</div>
+  </div>
+</div>
+% endif
+
+% if accordion:
+ <%include file="/courseware/course_navigation.html" args="active_page='courseware'" />
+% endif
 
 <section class="container">
   <div class="course-wrapper">
+
+% if accordion:
     <section aria-label="Course Navigation" class="course-index">
       <header id="open_close_accordion">
         <a href="#">close</a>
@@ -76,6 +139,7 @@
         </nav>
       </div>
     </section>
+% endif
 
     <section class="course-content">
       ${content}

lms/templates/main.html

@@ -29,13 +29,18 @@
 
 <body class="<%block name='bodyclass'/>">
 
+% if not suppress_toplevel_navigation:
   <%include file="navigation.html" />
+% endif
+
   <section class="content-wrapper">
     ${self.body()}
     <%block name="bodyextra"/>
   </section>
 
+% if not suppress_toplevel_navigation:
   <%include file="footer.html" />
+% endif
 
   <%static:js group='application'/>
   <%static:js group='module-js'/>