Merge conflicts

CHANGELOG.rst

@@ -79,6 +79,9 @@ key in course settings. (BLD-426)
 
 Blades: Fix bug when the speed can only be changed when the video is playing.
 
+LMS: The dialogs on the wiki "changes" page are now accessible to screen
+readers.  Now all wiki pages have been made accessible. (LMS-1337)
+
 LMS: Change bulk email implementation to use less memory, and to better handle
 duplicate tasks in celery.
 
@@ -95,8 +98,8 @@ client error are correctly passed through to the client.
 LMS: Improve performance of page load and thread list load for
 discussion tab
 
-LMS: The wiki markup cheatsheet dialog is now accessible to people with
-disabilites.  (LMS-1303)
+LMS: The wiki markup cheatsheet dialog is now accessible to screen readers.
+(LMS-1303)
 
 Common: Add skip links for accessibility to CMS and LMS. (LMS-1311)
 

cms/djangoapps/contentstore/features/video.feature

@@ -53,30 +53,33 @@ Feature: CMS.Video Component
     Then Captions become "invisible"
 
   # 8
-  Scenario: Open captions never become invisible
-    Given I have created a Video component with subtitles
-    And Make sure captions are open
-    Then Captions are "visible"
-    And I hover over button "CC"
-    Then Captions are "visible"
-    And I hover over button "volume"
-    Then Captions are "visible"
+  # Disabled 11/26 due to flakiness in master
+  #Scenario: Open captions never become invisible
+  #  Given I have created a Video component with subtitles
+  #  And Make sure captions are open
+  #  Then Captions are "visible"
+  #  And I hover over button "CC"
+  #  Then Captions are "visible"
+  #  And I hover over button "volume"
+  #  Then Captions are "visible"
 
   # 9
-  Scenario: Closed captions are invisible when mouse doesn't hover on CC button
-    Given I have created a Video component with subtitles
-    And Make sure captions are closed
-    Then Captions become "invisible"
-    And I hover over button "volume"
-    Then Captions are "invisible"
+  # Disabled 11/26 due to flakiness in master
+  #Scenario: Closed captions are invisible when mouse doesn't hover on CC button
+  #  Given I have created a Video component with subtitles
+  #  And Make sure captions are closed
+  #  Then Captions become "invisible"
+  #  And I hover over button "volume"
+  #  Then Captions are "invisible"
 
   # 10
-  Scenario: When enter key is pressed on a caption shows an outline around it
-    Given I have created a Video component with subtitles
-    And Make sure captions are opened
-    Then I focus on caption line with data-index "0"
-    Then I press "enter" button on caption line with data-index "0"
-    And I see caption line with data-index "0" has class "focused"
+  # Disabled 11/26 due to flakiness in master
+  #Scenario: When enter key is pressed on a caption shows an outline around it
+  #  Given I have created a Video component with subtitles
+  #  And Make sure captions are opened
+  #  Then I focus on caption line with data-index "0"
+  #  Then I press "enter" button on caption line with data-index "0"
+  #  And I see caption line with data-index "0" has class "focused"
 
   # 11
   Scenario: When start end end times are specified, a range on slider is shown

cms/djangoapps/contentstore/tests/test_contentstore.py

@@ -1660,15 +1660,7 @@ class ContentStoreTest(ModuleStoreTestCase):
         test_get_html('tabs')
         test_get_html('settings/details')
         test_get_html('settings/grading')
-
-        # advanced settings
-        resp = self.client.get_html(reverse('course_advanced_settings',
-                                            kwargs={'org': loc.org,
-                                                    'course': loc.course,
-                                                    'name': loc.name}))
-        self.assertEqual(resp.status_code, 200)
-        # TODO: uncomment when advanced settings not using old locations.
-        # _test_no_locations(self, resp)
+        test_get_html('settings/advanced')
 
         # textbook index
         resp = self.client.get_html(reverse('textbook_index',

cms/djangoapps/contentstore/tests/test_course_settings.py

@@ -9,10 +9,9 @@ import mock
 from django.utils.timezone import UTC
 from django.test.utils import override_settings
 
-from xmodule.modulestore import Location
 from models.settings.course_details import (CourseDetails, CourseSettingsEncoder)
 from models.settings.course_grading import CourseGradingModel
-from contentstore.utils import get_modulestore
+from contentstore.utils import get_modulestore, EXTRA_TAB_PANELS
 from xmodule.modulestore.tests.factories import CourseFactory
 
 
@@ -20,7 +19,8 @@ from models.settings.course_metadata import CourseMetadata
 from xmodule.fields import Date
 
 from .utils import CourseTestCase
-from xmodule.modulestore.django import loc_mapper
+from xmodule.modulestore.django import loc_mapper, modulestore
+from contentstore.views.component import ADVANCED_COMPONENT_POLICY_KEY
 
 
 class CourseDetailsTestCase(CourseTestCase):
@@ -418,15 +418,19 @@ class CourseMetadataEditingTest(CourseTestCase):
     """
     def setUp(self):
         CourseTestCase.setUp(self)
-        CourseFactory.create(org='edX', course='999', display_name='Robot Super Course')
-        self.fullcourse_location = Location(['i4x', 'edX', '999', 'course', 'Robot_Super_Course', None])
+        self.fullcourse = CourseFactory.create(org='edX', course='999', display_name='Robot Super Course')
+        self.course_setting_url = self.course_locator.url_reverse('settings/advanced')
+        self.fullcourse_setting_url = loc_mapper().translate_location(
+            self.fullcourse.location.course_id,
+            self.fullcourse.location, False, True
+        ).url_reverse('settings/advanced')
 
     def test_fetch_initial_fields(self):
-        test_model = CourseMetadata.fetch(self.course.location)
+        test_model = CourseMetadata.fetch(self.course)
         self.assertIn('display_name', test_model, 'Missing editable metadata field')
         self.assertEqual(test_model['display_name'], 'Robot Super Course', "not expected value")
 
-        test_model = CourseMetadata.fetch(self.fullcourse_location)
+        test_model = CourseMetadata.fetch(self.fullcourse)
         self.assertNotIn('graceperiod', test_model, 'blacklisted field leaked in')
         self.assertIn('display_name', test_model, 'full missing editable metadata field')
         self.assertEqual(test_model['display_name'], 'Robot Super Course', "not expected value")
@@ -435,17 +439,17 @@ class CourseMetadataEditingTest(CourseTestCase):
         self.assertIn('xqa_key', test_model, 'xqa_key field ')
 
     def test_update_from_json(self):
-        test_model = CourseMetadata.update_from_json(self.course.location, {
+        test_model = CourseMetadata.update_from_json(self.course, {
             "advertised_start": "start A",
-            "testcenter_info": {"c": "test"},
             "days_early_for_beta": 2
         })
         self.update_check(test_model)
         # try fresh fetch to ensure persistence
-        test_model = CourseMetadata.fetch(self.course.location)
+        fresh = modulestore().get_item(self.course_location)
+        test_model = CourseMetadata.fetch(fresh)
         self.update_check(test_model)
         # now change some of the existing metadata
-        test_model = CourseMetadata.update_from_json(self.course.location, {
+        test_model = CourseMetadata.update_from_json(fresh, {
             "advertised_start": "start B",
             "display_name": "jolly roger"}
         )
@@ -459,13 +463,15 @@ class CourseMetadataEditingTest(CourseTestCase):
         self.assertEqual(test_model['display_name'], 'Robot Super Course', "not expected value")
         self.assertIn('advertised_start', test_model, 'Missing new advertised_start metadata field')
         self.assertEqual(test_model['advertised_start'], 'start A', "advertised_start not expected value")
-        self.assertIn('testcenter_info', test_model, 'Missing testcenter_info metadata field')
-        self.assertDictEqual(test_model['testcenter_info'], {"c": "test"}, "testcenter_info not expected value")
         self.assertIn('days_early_for_beta', test_model, 'Missing days_early_for_beta metadata field')
         self.assertEqual(test_model['days_early_for_beta'], 2, "days_early_for_beta not expected value")
 
     def test_delete_key(self):
-        test_model = CourseMetadata.delete_key(self.fullcourse_location, {'deleteKeys': ['doesnt_exist', 'showanswer', 'xqa_key']})
+        test_model = CourseMetadata.update_from_json(
+            self.fullcourse, {
+                "unsetKeys": ['showanswer', 'xqa_key']
+            }
+        )
         # ensure no harm
         self.assertNotIn('graceperiod', test_model, 'blacklisted field leaked in')
         self.assertIn('display_name', test_model, 'full missing editable metadata field')
@@ -475,6 +481,65 @@ class CourseMetadataEditingTest(CourseTestCase):
         self.assertEqual('finished', test_model['showanswer'], 'showanswer field still in')
         self.assertEqual(None, test_model['xqa_key'], 'xqa_key field still in')
 
+    def test_http_fetch_initial_fields(self):
+        response = self.client.get_json(self.course_setting_url)
+        test_model = json.loads(response.content)
+        self.assertIn('display_name', test_model, 'Missing editable metadata field')
+        self.assertEqual(test_model['display_name'], 'Robot Super Course', "not expected value")
+
+        response = self.client.get_json(self.fullcourse_setting_url)
+        test_model = json.loads(response.content)
+        self.assertNotIn('graceperiod', test_model, 'blacklisted field leaked in')
+        self.assertIn('display_name', test_model, 'full missing editable metadata field')
+        self.assertEqual(test_model['display_name'], 'Robot Super Course', "not expected value")
+        self.assertIn('rerandomize', test_model, 'Missing rerandomize metadata field')
+        self.assertIn('showanswer', test_model, 'showanswer field ')
+        self.assertIn('xqa_key', test_model, 'xqa_key field ')
+
+    def test_http_update_from_json(self):
+        response = self.client.ajax_post(self.course_setting_url, {
+            "advertised_start": "start A",
+            "testcenter_info": {"c": "test"},
+            "days_early_for_beta": 2,
+            "unsetKeys": ['showanswer', 'xqa_key'],
+        })
+        test_model = json.loads(response.content)
+        self.update_check(test_model)
+        self.assertEqual('finished', test_model['showanswer'], 'showanswer field still in')
+        self.assertEqual(None, test_model['xqa_key'], 'xqa_key field still in')
+
+        response = self.client.get_json(self.course_setting_url)
+        test_model = json.loads(response.content)
+        self.update_check(test_model)
+        # now change some of the existing metadata
+        response = self.client.ajax_post(self.course_setting_url, {
+            "advertised_start": "start B",
+            "display_name": "jolly roger"
+        })
+        test_model = json.loads(response.content)
+        self.assertIn('display_name', test_model, 'Missing editable metadata field')
+        self.assertEqual(test_model['display_name'], 'jolly roger', "not expected value")
+        self.assertIn('advertised_start', test_model, 'Missing revised advertised_start metadata field')
+        self.assertEqual(test_model['advertised_start'], 'start B', "advertised_start not expected value")
+
+    def test_advanced_components_munge_tabs(self):
+        """
+        Test that adding and removing specific advanced components adds and removes tabs.
+        """
+        self.assertNotIn(EXTRA_TAB_PANELS.get("open_ended"), self.course.tabs)
+        self.assertNotIn(EXTRA_TAB_PANELS.get("notes"), self.course.tabs)
+        self.client.ajax_post(self.course_setting_url, {
+            ADVANCED_COMPONENT_POLICY_KEY: ["combinedopenended"]
+        })
+        course = modulestore().get_item(self.course_location)
+        self.assertIn(EXTRA_TAB_PANELS.get("open_ended"), course.tabs)
+        self.assertNotIn(EXTRA_TAB_PANELS.get("notes"), course.tabs)
+        self.client.ajax_post(self.course_setting_url, {
+            ADVANCED_COMPONENT_POLICY_KEY: []
+        })
+        course = modulestore().get_item(self.course_location)
+        self.assertNotIn(EXTRA_TAB_PANELS.get("open_ended"), course.tabs)
+
 
 class CourseGraderUpdatesTest(CourseTestCase):
     """

cms/djangoapps/models/settings/course_details.py

@@ -32,11 +32,11 @@ class CourseDetails(object):
         self.course_image_asset_path = ""  # URL of the course image
 
     @classmethod
-    def fetch(cls, course_location):
+    def fetch(cls, course_locator):
         """
         Fetch the course details for the given course from persistence and return a CourseDetails model.
         """
-        course_old_location = loc_mapper().translate_locator_to_location(course_location)
+        course_old_location = loc_mapper().translate_locator_to_location(course_locator)
         descriptor = get_modulestore(course_old_location).get_item(course_old_location)
         course = cls(course_old_location.org, course_old_location.course, course_old_location.name)
 
@@ -75,11 +75,11 @@ class CourseDetails(object):
         return course
 
     @classmethod
-    def update_from_json(cls, course_location, jsondict):
+    def update_from_json(cls, course_locator, jsondict):
         """
         Decode the json into CourseDetails and save any changed attrs to the db
         """
-        course_old_location = loc_mapper().translate_locator_to_location(course_location)
+        course_old_location = loc_mapper().translate_locator_to_location(course_locator)
         descriptor = get_modulestore(course_old_location).get_item(course_old_location)
 
         dirty = False
@@ -153,7 +153,7 @@ class CourseDetails(object):
 
         # Could just return jsondict w/o doing any db reads, but I put the reads in as a means to confirm
         # it persisted correctly
-        return CourseDetails.fetch(course_location)
+        return CourseDetails.fetch(course_locator)
 
     @staticmethod
     def parse_video_tag(raw_video):

cms/djangoapps/models/settings/course_grading.py

@@ -18,11 +18,11 @@ class CourseGradingModel(object):
         self.grace_period = CourseGradingModel.convert_set_grace_period(course_descriptor)
 
     @classmethod
-    def fetch(cls, course_location):
+    def fetch(cls, course_locator):
         """
         Fetch the course grading policy for the given course from persistence and return a CourseGradingModel.
         """
-        course_old_location = loc_mapper().translate_locator_to_location(course_location)
+        course_old_location = loc_mapper().translate_locator_to_location(course_locator)
         descriptor = get_modulestore(course_old_location).get_item(course_old_location)
 
         model = cls(descriptor)
@@ -52,12 +52,12 @@ class CourseGradingModel(object):
                     }
 
     @staticmethod
-    def update_from_json(course_location, jsondict):
+    def update_from_json(course_locator, jsondict):
         """
         Decode the json into CourseGradingModel and save any changes. Returns the modified model.
         Probably not the usual path for updates as it's too coarse grained.
         """
-        course_old_location = loc_mapper().translate_locator_to_location(course_location)
+        course_old_location = loc_mapper().translate_locator_to_location(course_locator)
         descriptor = get_modulestore(course_old_location).get_item(course_old_location)
 
         graders_parsed = [CourseGradingModel.parse_grader(jsonele) for jsonele in jsondict['graders']]
@@ -69,9 +69,9 @@ class CourseGradingModel(object):
             course_old_location, descriptor.get_explicitly_set_fields_by_scope(Scope.content)
         )
 
-        CourseGradingModel.update_grace_period_from_json(course_location, jsondict['grace_period'])
+        CourseGradingModel.update_grace_period_from_json(course_locator, jsondict['grace_period'])
 
-        return CourseGradingModel.fetch(course_location)
+        return CourseGradingModel.fetch(course_locator)
 
     @staticmethod
     def update_grader_from_json(course_location, grader):

cms/djangoapps/models/settings/course_metadata.py

-from xmodule.modulestore import Location
+from xblock.fields import Scope
+
 from contentstore.utils import get_modulestore
 from xmodule.modulestore.inheritance import own_metadata
-from xblock.fields import Scope
 from cms.xmodule_namespace import CmsBlockMixin
 
 
@@ -20,21 +20,18 @@ class CourseMetadata(object):
                      'tabs',
                      'graceperiod',
                      'checklists',
-                     'show_timezone'
+                     'show_timezone',
+                     'format',
+                     'graded',
     ]
 
     @classmethod
-    def fetch(cls, course_location):
+    def fetch(cls, descriptor):
         """
         Fetch the key:value editable course details for the given course from
         persistence and return a CourseMetadata model.
         """
-        if not isinstance(course_location, Location):
-            course_location = Location(course_location)
-
-        course = {}
-
-        descriptor = get_modulestore(course_location).get_item(course_location)
+        result = {}
 
         for field in descriptor.fields.values():
             if field.name in CmsBlockMixin.fields:
@@ -46,19 +43,17 @@ class CourseMetadata(object):
             if field.name in cls.FILTERED_LIST:
                 continue
 
-            course[field.name] = field.read_json(descriptor)
+            result[field.name] = field.read_json(descriptor)
 
-        return course
+        return result
 
     @classmethod
-    def update_from_json(cls, course_location, jsondict, filter_tabs=True):
+    def update_from_json(cls, descriptor, jsondict, filter_tabs=True):
         """
         Decode the json into CourseMetadata and save any changed attrs to the db.
 
         Ensures none of the fields are in the blacklist.
         """
-        descriptor = get_modulestore(course_location).get_item(course_location)
-
         dirty = False
 
         # Copy the filtered list to avoid permanently changing the class attribute.
@@ -72,39 +67,17 @@ class CourseMetadata(object):
             if key in filtered_list:
                 continue
 
+            if key == "unsetKeys":
+                dirty = True
+                for unset in val:
+                    descriptor.fields[unset].delete_from(descriptor)
+
             if hasattr(descriptor, key) and getattr(descriptor, key) != val:
                 dirty = True
                 value = descriptor.fields[key].from_json(val)
                 setattr(descriptor, key, value)
 
         if dirty:
-            # Save the data that we've just changed to the underlying
-            # MongoKeyValueStore before we update the mongo datastore.
-            descriptor.save()
-            get_modulestore(course_location).update_metadata(course_location,
-                                                             own_metadata(descriptor))
-
-        # Could just generate and return a course obj w/o doing any db reads,
-        # but I put the reads in as a means to confirm it persisted correctly
-        return cls.fetch(course_location)
-
-    @classmethod
-    def delete_key(cls, course_location, payload):
-        '''
-        Remove the given metadata key(s) from the course. payload can be a
-        single key or [key..]
-        '''
-        descriptor = get_modulestore(course_location).get_item(course_location)
-
-        for key in payload['deleteKeys']:
-            if hasattr(descriptor, key):
-                delattr(descriptor, key)
-
-        # Save the data that we've just changed to the underlying
-        # MongoKeyValueStore before we update the mongo datastore.
-        descriptor.save()
-
-        get_modulestore(course_location).update_metadata(course_location,
-                                                         own_metadata(descriptor))
+            get_modulestore(descriptor.location).update_metadata(descriptor.location, own_metadata(descriptor))
 
-        return cls.fetch(course_location)
+        return cls.fetch(descriptor)

cms/static/sass/contexts/_ie.scss

@@ -10,6 +10,10 @@
     &.is-shown {
       bottom: 0;
     }
+
+    &.is-hiding {
+      bottom: -($ui-notification-height);
+    }
   }
 }
 

cms/static/sass/elements/_xmodules.scss

-// studio - elements - xmodules
+// studio - elements - xmodules & xblocks
+// ====================
+
+// general - display mode (xblock-student_view or xmodule_display)
+.xmodule_display, .xblock-student_view {
+
+  // font styling
+  i, em {
+    font-style: italic;
+  }
+}
+
 // ====================
 
 // Video Alpha

cms/templates/settings.html

@@ -6,7 +6,6 @@
 <%!
   from django.utils.translation import ugettext as _
   from xmodule.modulestore.django import loc_mapper
-  from django.core.urlresolvers import reverse
 %>
 
 <%block name="jsextra">
@@ -293,14 +292,14 @@ require(["domReady!", "jquery", "js/models/settings/course_details", "js/views/s
           <%
             course_team_url = course_locator.url_reverse('course_team/', '')
             grading_config_url = course_locator.url_reverse('settings/grading/')
-            ctx_loc = context_course.location
+            advanced_config_url = course_locator.url_reverse('settings/advanced/')
           %>
         <h3 class="title-3">${_("Other Course Settings")}</h3>
         <nav class="nav-related">
           <ul>
             <li class="nav-item"><a href="${grading_config_url}">${_("Grading")}</a></li>
             <li class="nav-item"><a href="${course_team_url}">${_("Course Team")}</a></li>
-            <li class="nav-item"><a href="${reverse('course_advanced_settings', kwargs={'org' : ctx_loc.org, 'course' : ctx_loc.course, 'name': ctx_loc.name})}">${_("Advanced Settings")}</a></li>
+            <li class="nav-item"><a href="${advanced_config_url}">${_("Advanced Settings")}</a></li>
           </ul>
         </nav>
      % endif

cms/templates/settings_advanced.html

 <%inherit file="base.html" />
 <%namespace name='static' file='static_content.html'/>
 <%!
-  from django.core.urlresolvers import reverse
   from django.utils.translation import ugettext as _
   from contentstore import utils
   from xmodule.modulestore.django import loc_mapper
-  from django.core.urlresolvers import reverse
 %>
 <%block name="title">${_("Advanced Settings")}</%block>
 <%block name="bodyclass">is-signedin course advanced view-settings</%block>
@@ -28,7 +26,7 @@ require(["domReady!", "jquery", "js/models/settings/advanced", "js/views/setting
 
   // proactively populate advanced b/c it has the filtered list and doesn't really follow the model pattern
   var advancedModel = new AdvancedSettingsModel(${advanced_dict | n}, {parse: true});
-  advancedModel.url = "${reverse('course_advanced_settings_updates', kwargs=dict(org=context_course.location.org, course=context_course.location.course, name=context_course.location.name))}";
+  advancedModel.url = "${advanced_settings_url}";
 
   var editor = new AdvancedSettingsView({
     el: $('.settings-advanced'),
@@ -91,13 +89,15 @@ require(["domReady!", "jquery", "js/models/settings/advanced", "js/views/setting
         <%
           ctx_loc = context_course.location
           location = loc_mapper().translate_location(ctx_loc.course_id, ctx_loc, False, True)
+          details_url = location.url_reverse('settings/details/')
+          grading_url = location.url_reverse('settings/grading/')
           course_team_url = location.url_reverse('course_team/', '')
         %>
       <h3 class="title-3">${_("Other Course Settings")}</h3>
         <nav class="nav-related">
           <ul>
-            <li class="nav-item"><a href="${course_locator.url_reverse('settings/details/')}">${_("Details &amp; Schedule")}</a></li>
-            <li class="nav-item"><a href="${course_locator.url_reverse('settings/grading/')}">${_("Grading")}</a></li>
+            <li class="nav-item"><a href="${details_url}">${_("Details &amp; Schedule")}</a></li>
+            <li class="nav-item"><a href="${grading_url}">${_("Grading")}</a></li>
             <li class="nav-item"><a href="${course_team_url}">${_("Course Team")}</a></li>
           </ul>
         </nav>

cms/templates/settings_graders.html

@@ -7,7 +7,6 @@
   from contentstore import utils
   from django.utils.translation import ugettext as _
   from xmodule.modulestore.django import loc_mapper
-  from django.core.urlresolvers import reverse
 %>
 
 <%block name="header_extras">
@@ -139,15 +138,16 @@ require(["domReady!", "jquery", "js/views/settings/grading", "js/models/settings
       <div class="bit">
       % if context_course:
         <%
-          ctx_loc = context_course.location
           course_team_url = course_locator.url_reverse('course_team/')
+          advanced_settings_url = course_locator.url_reverse('settings/advanced/')
+          detailed_settings_url = course_locator.url_reverse('settings/details/')
         %>
         <h3 class="title-3">${_("Other Course Settings")}</h3>
         <nav class="nav-related">
           <ul>
-            <li class="nav-item"><a href="${course_locator.url_reverse('settings/details/')}">${_("Details &amp; Schedule")}</a></li>
+            <li class="nav-item"><a href="${detailed_settings_url}">${_("Details &amp; Schedule")}</a></li>
             <li class="nav-item"><a href="${course_team_url}">${_("Course Team")}</a></li>
-            <li class="nav-item"><a href="${reverse('course_advanced_settings', kwargs={'org' : ctx_loc.org, 'course' : ctx_loc.course, 'name': ctx_loc.name})}">${_("Advanced Settings")}</a></li>
+            <li class="nav-item"><a href="${advanced_settings_url}">${_("Advanced Settings")}</a></li>
           </ul>
         </nav>
       % endif

cms/templates/unit.html

@@ -182,7 +182,7 @@ require(["domReady!", "jquery", "js/models/module_info", "coffee/src/views/unit"
             <div class="row wrapper-unit-id">
               <p class="unit-id">
                 <span class="label">${_("Unit Identifier:")}</span>
-                <input type="text" class="url value" value="${unit.location.name}" disabled />
+                <input type="text" class="url value" value="${unit.location.name}" readonly />
               </p>
             </div>
             <ol>

cms/templates/widgets/header.html

@@ -25,6 +25,7 @@
             export_url = location.url_reverse('export')
             settings_url = location.url_reverse('settings/details/')
             grading_url = location.url_reverse('settings/grading/')
+            advanced_settings_url = location.url_reverse('settings/advanced/')
             tabs_url = location.url_reverse('tabs')
       %>
       <h2 class="info-course">
@@ -80,7 +81,7 @@
                     <a href="${course_team_url}">${_("Course Team")}</a>
                   </li>
                   <li class="nav-item nav-course-settings-advanced">
-                    <a href="${reverse('course_advanced_settings', kwargs={'org' : ctx_loc.org, 'course' : ctx_loc.course, 'name': ctx_loc.name})}">${_("Advanced Settings")}</a>
+                    <a href="${advanced_settings_url}">${_("Advanced Settings")}</a>
                   </li>
                 </ul>
               </div>

cms/templates/widgets/problem-edit.html

@@ -39,7 +39,7 @@
             <div class="row">
                 <h6>${_("Heading 1")}</h6>
                 <div class="col sample heading-1">
-                    <img src="${static.url("/img/header-example.png")}" />
+                    <img src="${static.url("img/header-example.png")}" />
                 </div>
                 <div class="col">
 <pre><code>H1

cms/urls.py

@@ -23,13 +23,6 @@ urlpatterns = patterns('',  # nopep8
     url(r'^preview/xblock/(?P<usage_id>.*?)/handler/(?P<handler>[^/]*)(?:/(?P<suffix>[^/]*))?$',
         'contentstore.views.preview_handler', name='preview_handler'),
 
-    # This is the URL to initially render the course advanced settings.
-    url(r'^(?P<org>[^/]+)/(?P<course>[^/]+)/settings-advanced/(?P<name>[^/]+)$',
-        'contentstore.views.course_config_advanced_page', name='course_advanced_settings'),
-    # This is the URL used by BackBone for updating and re-fetching the model.
-    url(r'^(?P<org>[^/]+)/(?P<course>[^/]+)/settings-advanced/(?P<name>[^/]+)/update.*$',
-        'contentstore.views.course_advanced_updates', name='course_advanced_settings_updates'),
-
     url(r'^(?P<org>[^/]+)/(?P<course>[^/]+)/textbooks/(?P<name>[^/]+)$',
         'contentstore.views.textbook_index', name='textbook_index'),
     url(r'^(?P<org>[^/]+)/(?P<course>[^/]+)/textbooks/(?P<name>[^/]+)/new$',
@@ -95,6 +88,7 @@ urlpatterns += patterns(
     url(r'(?ix)^tabs/{}$'.format(parsers.URL_RE_SOURCE), 'tabs_handler'),
     url(r'(?ix)^settings/details/{}$'.format(parsers.URL_RE_SOURCE), 'settings_handler'),
     url(r'(?ix)^settings/grading/{}(/)?(?P<grader_index>\d+)?$'.format(parsers.URL_RE_SOURCE), 'grading_handler'),
+    url(r'(?ix)^settings/advanced/{}$'.format(parsers.URL_RE_SOURCE), 'advanced_settings_handler'),
 )
 
 js_info_dict = {

common/djangoapps/external_auth/views.py

@@ -21,7 +21,7 @@ from django.core.exceptions import ValidationError
 if settings.MITX_FEATURES.get('AUTH_USE_CAS'):
     from django_cas.views import login as django_cas_login
 
-from student.models import UserProfile, TestCenterUser, TestCenterRegistration
+from student.models import UserProfile
 
 from django.http import HttpResponse, HttpResponseRedirect, HttpRequest, HttpResponseForbidden
 from django.utils.http import urlquote, is_safe_url
@@ -880,146 +880,7 @@ def provider_xrds(request):
     return response
 
 
-#-------------------
-# Pearson
-#-------------------
 def course_from_id(course_id):
     """Return the CourseDescriptor corresponding to this course_id"""
     course_loc = CourseDescriptor.id_to_location(course_id)
     return modulestore().get_instance(course_id, course_loc)
-
-
-@csrf_exempt
-def test_center_login(request):
-    ''' Log in students taking exams via Pearson
-
-    Takes a POST request that contains the following keys:
-        - code - a security code provided by Pearson
-        - clientCandidateID
-        - registrationID
-        - exitURL - the url that we redirect to once we're done
-        - vueExamSeriesCode - a code that indicates the exam that we're using
-    '''
-    # Imports from lms/djangoapps/courseware -- these should not be
-    # in a common djangoapps.
-    from courseware.views import get_module_for_descriptor, jump_to
-    from courseware.model_data import FieldDataCache
-
-    # errors are returned by navigating to the error_url, adding a query parameter named "code"
-    # which contains the error code describing the exceptional condition.
-    def makeErrorURL(error_url, error_code):
-        log.error("generating error URL with error code {}".format(error_code))
-        return "{}?code={}".format(error_url, error_code)
-
-    # get provided error URL, which will be used as a known prefix for returning error messages to the
-    # Pearson shell.
-    error_url = request.POST.get("errorURL")
-
-    # TODO: check that the parameters have not been tampered with, by comparing the code provided by Pearson
-    # with the code we calculate for the same parameters.
-    if 'code' not in request.POST:
-        return HttpResponseRedirect(makeErrorURL(error_url, "missingSecurityCode"))
-    code = request.POST.get("code")
-
-    # calculate SHA for query string
-    # TODO: figure out how to get the original query string, so we can hash it and compare.
-
-    if 'clientCandidateID' not in request.POST:
-        return HttpResponseRedirect(makeErrorURL(error_url, "missingClientCandidateID"))
-    client_candidate_id = request.POST.get("clientCandidateID")
-
-    # TODO: check remaining parameters, and maybe at least log if they're not matching
-    # expected values....
-    # registration_id = request.POST.get("registrationID")
-    # exit_url = request.POST.get("exitURL")
-
-    # find testcenter_user that matches the provided ID:
-    try:
-        testcenteruser = TestCenterUser.objects.get(client_candidate_id=client_candidate_id)
-    except TestCenterUser.DoesNotExist:
-        AUDIT_LOG.error("not able to find demographics for cand ID {}".format(client_candidate_id))
-        return HttpResponseRedirect(makeErrorURL(error_url, "invalidClientCandidateID"))
-
-    AUDIT_LOG.info("Attempting to log in test-center user '{}' for test of cand {}".format(testcenteruser.user.username, client_candidate_id))
-
-    # find testcenter_registration that matches the provided exam code:
-    # Note that we could rely in future on either the registrationId or the exam code,
-    # or possibly both.  But for now we know what to do with an ExamSeriesCode,
-    # while we currently have no record of RegistrationID values at all.
-    if 'vueExamSeriesCode' not in request.POST:
-        # we are not allowed to make up a new error code, according to Pearson,
-        # so instead of "missingExamSeriesCode", we use a valid one that is
-        # inaccurate but at least distinct.  (Sigh.)
-        AUDIT_LOG.error("missing exam series code for cand ID {}".format(client_candidate_id))
-        return HttpResponseRedirect(makeErrorURL(error_url, "missingPartnerID"))
-    exam_series_code = request.POST.get('vueExamSeriesCode')
-
-    registrations = TestCenterRegistration.objects.filter(testcenter_user=testcenteruser, exam_series_code=exam_series_code)
-    if not registrations:
-        AUDIT_LOG.error("not able to find exam registration for exam {} and cand ID {}".format(exam_series_code, client_candidate_id))
-        return HttpResponseRedirect(makeErrorURL(error_url, "noTestsAssigned"))
-
-    # TODO: figure out what to do if there are more than one registrations....
-    # for now, just take the first...
-    registration = registrations[0]
-
-    course_id = registration.course_id
-    course = course_from_id(course_id)  # assume it will be found....
-    if not course:
-        AUDIT_LOG.error("not able to find course from ID {} for cand ID {}".format(course_id, client_candidate_id))
-        return HttpResponseRedirect(makeErrorURL(error_url, "incorrectCandidateTests"))
-    exam = course.get_test_center_exam(exam_series_code)
-    if not exam:
-        AUDIT_LOG.error("not able to find exam {} for course ID {} and cand ID {}".format(exam_series_code, course_id, client_candidate_id))
-        return HttpResponseRedirect(makeErrorURL(error_url, "incorrectCandidateTests"))
-    location = exam.exam_url
-    log.info("Proceeding with test of cand {} on exam {} for course {}: URL = {}".format(client_candidate_id, exam_series_code, course_id, location))
-
-    # check if the test has already been taken
-    timelimit_descriptor = modulestore().get_instance(course_id, Location(location))
-    if not timelimit_descriptor:
-        log.error("cand {} on exam {} for course {}: descriptor not found for location {}".format(client_candidate_id, exam_series_code, course_id, location))
-        return HttpResponseRedirect(makeErrorURL(error_url, "missingClientProgram"))
-
-    timelimit_module_cache = FieldDataCache.cache_for_descriptor_descendents(course_id, testcenteruser.user,
-                                                                             timelimit_descriptor, depth=None)
-    timelimit_module = get_module_for_descriptor(request.user, request, timelimit_descriptor,
-                                                 timelimit_module_cache, course_id, position=None)
-    if not timelimit_module.category == 'timelimit':
-        log.error("cand {} on exam {} for course {}: non-timelimit module at location {}".format(client_candidate_id, exam_series_code, course_id, location))
-        return HttpResponseRedirect(makeErrorURL(error_url, "missingClientProgram"))
-
-    if timelimit_module and timelimit_module.has_ended:
-        AUDIT_LOG.warning("cand {} on exam {} for course {}: test already over at {}".format(client_candidate_id, exam_series_code, course_id, timelimit_module.ending_at))
-        return HttpResponseRedirect(makeErrorURL(error_url, "allTestsTaken"))
-
-    # check if we need to provide an accommodation:
-    time_accommodation_mapping = {'ET12ET': 'ADDHALFTIME',
-                                  'ET30MN': 'ADD30MIN',
-                                  'ETDBTM': 'ADDDOUBLE', }
-
-    time_accommodation_code = None
-    for code in registration.get_accommodation_codes():
-        if code in time_accommodation_mapping:
-            time_accommodation_code = time_accommodation_mapping[code]
-
-    if time_accommodation_code:
-        timelimit_module.accommodation_code = time_accommodation_code
-        AUDIT_LOG.info("cand {} on exam {} for course {}: receiving accommodation {}".format(client_candidate_id, exam_series_code, course_id, time_accommodation_code))
-
-    # UGLY HACK!!!
-    # Login assumes that authentication has occurred, and that there is a
-    # backend annotation on the user object, indicating which backend
-    # against which the user was authenticated.  We're authenticating here
-    # against the registration entry, and assuming that the request given
-    # this information is correct, we allow the user to be logged in
-    # without a password.  This could all be formalized in a backend object
-    # that does the above checking.
-    # TODO: (brian) create a backend class to do this.
-    # testcenteruser.user.backend = "%s.%s" % (backend.__module__, backend.__class__.__name__)
-    testcenteruser.user.backend = "%s.%s" % ("TestcenterAuthenticationModule", "TestcenterAuthenticationClass")
-    login(request, testcenteruser.user)
-    AUDIT_LOG.info("Logged in user '{}' for test of cand {} on exam {} for course {}: URL = {}".format(testcenteruser.user.username, client_candidate_id, exam_series_code, course_id, location))
-
-    # And start the test:
-    return jump_to(request, course_id, location)

common/djangoapps/student/management/commands/pearson_dump.py

-from optparse import make_option
-from json import dump
-from datetime import datetime
-
-from django.core.management.base import BaseCommand
-
-from student.models import TestCenterRegistration
-
-
-class Command(BaseCommand):
-
-    args = '<output JSON file>'
-    help = """
-    Dump information as JSON from TestCenterRegistration tables, including username and status.
-    """
-
-    option_list = BaseCommand.option_list + (
-        make_option('--course_id',
-                    action='store',
-                    dest='course_id',
-                    help='Specify a particular course.'),
-        make_option('--exam_series_code',
-                    action='store',
-                    dest='exam_series_code',
-                    default=None,
-                    help='Specify a particular exam, using the Pearson code'),
-        make_option('--accommodation_pending',
-                    action='store_true',
-                    dest='accommodation_pending',
-                    default=False,
-                    ),
-    )
-
-    def handle(self, *args, **options):
-        if len(args) < 1:
-            outputfile = datetime.utcnow().strftime("pearson-dump-%Y%m%d-%H%M%S.json")
-        else:
-            outputfile = args[0]
-
-        # construct the query object to dump:
-        registrations = TestCenterRegistration.objects.all()
-        if 'course_id' in options and options['course_id']:
-            registrations = registrations.filter(course_id=options['course_id'])
-        if 'exam_series_code' in options and options['exam_series_code']:
-            registrations = registrations.filter(exam_series_code=options['exam_series_code'])
-
-        # collect output:
-        output = []
-        for registration in registrations:
-            if 'accommodation_pending' in options and options['accommodation_pending'] and not registration.accommodation_is_pending:
-                continue
-            record = {'username': registration.testcenter_user.user.username,
-                      'email': registration.testcenter_user.email,
-                      'first_name': registration.testcenter_user.first_name,
-                      'last_name': registration.testcenter_user.last_name,
-                      'client_candidate_id': registration.client_candidate_id,
-                      'client_authorization_id': registration.client_authorization_id,
-                      'course_id': registration.course_id,
-                      'exam_series_code': registration.exam_series_code,
-                      'accommodation_request': registration.accommodation_request,
-                      'accommodation_code': registration.accommodation_code,
-                      'registration_status': registration.registration_status(),
-                      'demographics_status': registration.demographics_status(),
-                      'accommodation_status': registration.accommodation_status(),
-                      }
-            if len(registration.upload_error_message) > 0:
-                record['registration_error'] = registration.upload_error_message
-            if len(registration.testcenter_user.upload_error_message) > 0:
-                record['demographics_error'] = registration.testcenter_user.upload_error_message
-            if registration.needs_uploading:
-                record['needs_uploading'] = True
-
-            output.append(record)
-
-        # dump output:
-        with open(outputfile, 'w') as outfile:
-            dump(output, outfile, indent=2)

common/djangoapps/student/management/commands/pearson_export_cdd.py

-import csv
-import os
-from collections import OrderedDict
-from datetime import datetime
-from optparse import make_option
-
-from django.conf import settings
-from django.core.management.base import BaseCommand, CommandError
-
-from student.models import TestCenterUser
-from pytz import UTC
-
-
-class Command(BaseCommand):
-
-    CSV_TO_MODEL_FIELDS = OrderedDict([
-        # Skipping optional field CandidateID
-        ("ClientCandidateID", "client_candidate_id"),
-        ("FirstName", "first_name"),
-        ("LastName", "last_name"),
-        ("MiddleName", "middle_name"),
-        ("Suffix", "suffix"),
-        ("Salutation", "salutation"),
-        ("Email", "email"),
-        # Skipping optional fields Username and Password
-        ("Address1", "address_1"),
-        ("Address2", "address_2"),
-        ("Address3", "address_3"),
-        ("City", "city"),
-        ("State", "state"),
-        ("PostalCode", "postal_code"),
-        ("Country", "country"),
-        ("Phone", "phone"),
-        ("Extension", "extension"),
-        ("PhoneCountryCode", "phone_country_code"),
-        ("FAX", "fax"),
-        ("FAXCountryCode", "fax_country_code"),
-        ("CompanyName", "company_name"),
-        # Skipping optional field CustomQuestion
-        ("LastUpdate", "user_updated_at"),  # in UTC, so same as what we store
-    ])
-
-    # define defaults, even thought 'store_true' shouldn't need them.
-    # (call_command will set None as default value for all options that don't have one,
-    # so one cannot rely on presence/absence of flags in that world.)
-    option_list = BaseCommand.option_list + (
-        make_option('--dest-from-settings',
-                    action='store_true',
-                    dest='dest-from-settings',
-                    default=False,
-                    help='Retrieve the destination to export to from django.'),
-        make_option('--destination',
-                    action='store',
-                    dest='destination',
-                    default=None,
-                    help='Where to store the exported files')
-    )
-
-    def handle(self, **options):
-        # update time should use UTC in order to be comparable to the user_updated_at
-        # field
-        uploaded_at = datetime.now(UTC)
-
-        # if specified destination is an existing directory, then
-        # create a filename for it automatically.  If it doesn't exist,
-        # then we will create the directory.
-        # Name will use timestamp -- this is UTC, so it will look funny,
-        # but it should at least be consistent with the other timestamps
-        # used in the system.
-        if 'dest-from-settings' in options and options['dest-from-settings']:
-            if 'LOCAL_EXPORT' in settings.PEARSON:
-                dest = settings.PEARSON['LOCAL_EXPORT']
-            else:
-                raise CommandError('--dest-from-settings was enabled but the'
-                                   'PEARSON[LOCAL_EXPORT] setting was not set.')
-        elif 'destination' in options and options['destination']:
-            dest = options['destination']
-        else:
-            raise CommandError('--destination or --dest-from-settings must be used')
-
-        if not os.path.isdir(dest):
-            os.makedirs(dest)
-
-        destfile = os.path.join(dest, uploaded_at.strftime("cdd-%Y%m%d-%H%M%S.dat"))
-
-        # strings must be in latin-1 format.  CSV parser will
-        # otherwise convert unicode objects to ascii.
-        def ensure_encoding(value):
-            if isinstance(value, unicode):
-                return value.encode('iso-8859-1')
-            else:
-                return value
-
-#        dump_all = options['dump_all']
-
-        with open(destfile, "wb") as outfile:
-            writer = csv.DictWriter(outfile,
-                                    Command.CSV_TO_MODEL_FIELDS,
-                                    delimiter="\t",
-                                    quoting=csv.QUOTE_MINIMAL,
-                                    extrasaction='ignore')
-            writer.writeheader()
-            for tcu in TestCenterUser.objects.order_by('id'):
-                if tcu.needs_uploading:  # or dump_all
-                    record = dict((csv_field, ensure_encoding(getattr(tcu, model_field)))
-                                  for csv_field, model_field
-                                  in Command.CSV_TO_MODEL_FIELDS.items())
-                    record["LastUpdate"] = record["LastUpdate"].strftime("%Y/%m/%d %H:%M:%S")
-                    writer.writerow(record)
-                    tcu.uploaded_at = uploaded_at
-                    tcu.save()

common/djangoapps/student/management/commands/pearson_export_ead.py

-import csv
-import os
-from collections import OrderedDict
-from datetime import datetime
-from optparse import make_option
-
-from django.conf import settings
-from django.core.management.base import BaseCommand, CommandError
-
-from student.models import TestCenterRegistration, ACCOMMODATION_REJECTED_CODE
-from pytz import UTC
-
-
-class Command(BaseCommand):
-
-    CSV_TO_MODEL_FIELDS = OrderedDict([
-        ('AuthorizationTransactionType', 'authorization_transaction_type'),
-        ('AuthorizationID', 'authorization_id'),
-        ('ClientAuthorizationID', 'client_authorization_id'),
-        ('ClientCandidateID', 'client_candidate_id'),
-        ('ExamAuthorizationCount', 'exam_authorization_count'),
-        ('ExamSeriesCode', 'exam_series_code'),
-        ('Accommodations', 'accommodation_code'),
-        ('EligibilityApptDateFirst', 'eligibility_appointment_date_first'),
-        ('EligibilityApptDateLast', 'eligibility_appointment_date_last'),
-        ("LastUpdate", "user_updated_at"),  # in UTC, so same as what we store
-    ])
-
-    option_list = BaseCommand.option_list + (
-        make_option('--dest-from-settings',
-                    action='store_true',
-                    dest='dest-from-settings',
-                    default=False,
-                    help='Retrieve the destination to export to from django.'),
-        make_option('--destination',
-                    action='store',
-                    dest='destination',
-                    default=None,
-                    help='Where to store the exported files'),
-        make_option('--dump_all',
-                    action='store_true',
-                    dest='dump_all',
-                    default=False,
-                    ),
-        make_option('--force_add',
-                    action='store_true',
-                    dest='force_add',
-                    default=False,
-                    ),
-    )
-
-    def handle(self, **options):
-        # update time should use UTC in order to be comparable to the user_updated_at
-        # field
-        uploaded_at = datetime.now(UTC)
-
-        # if specified destination is an existing directory, then
-        # create a filename for it automatically.  If it doesn't exist,
-        # then we will create the directory.
-        # Name will use timestamp -- this is UTC, so it will look funny,
-        # but it should at least be consistent with the other timestamps
-        # used in the system.
-        if 'dest-from-settings' in options and options['dest-from-settings']:
-            if 'LOCAL_EXPORT' in settings.PEARSON:
-                dest = settings.PEARSON['LOCAL_EXPORT']
-            else:
-                raise CommandError('--dest-from-settings was enabled but the'
-                                   'PEARSON[LOCAL_EXPORT] setting was not set.')
-        elif 'destination' in options and options['destination']:
-            dest = options['destination']
-        else:
-            raise CommandError('--destination or --dest-from-settings must be used')
-
-        if not os.path.isdir(dest):
-            os.makedirs(dest)
-
-        destfile = os.path.join(dest, uploaded_at.strftime("ead-%Y%m%d-%H%M%S.dat"))
-
-        dump_all = options['dump_all']
-
-        with open(destfile, "wb") as outfile:
-            writer = csv.DictWriter(outfile,
-                                    Command.CSV_TO_MODEL_FIELDS,
-                                    delimiter="\t",
-                                    quoting=csv.QUOTE_MINIMAL,
-                                    extrasaction='ignore')
-            writer.writeheader()
-            for tcr in TestCenterRegistration.objects.order_by('id'):
-                if dump_all or tcr.needs_uploading:
-                    record = dict((csv_field, getattr(tcr, model_field))
-                                  for csv_field, model_field
-                                  in Command.CSV_TO_MODEL_FIELDS.items())
-                    record["LastUpdate"] = record["LastUpdate"].strftime("%Y/%m/%d %H:%M:%S")
-                    record["EligibilityApptDateFirst"] = record["EligibilityApptDateFirst"].strftime("%Y/%m/%d")
-                    record["EligibilityApptDateLast"] = record["EligibilityApptDateLast"].strftime("%Y/%m/%d")
-                    if record["Accommodations"] == ACCOMMODATION_REJECTED_CODE:
-                        record["Accommodations"] = ""
-                    if options['force_add']:
-                        record['AuthorizationTransactionType'] = 'Add'
-
-                    writer.writerow(record)
-                    tcr.uploaded_at = uploaded_at
-                    tcr.save()

common/djangoapps/student/management/commands/pearson_import_conf_zip.py

-import csv
-from time import strptime, strftime
-from datetime import datetime
-from zipfile import ZipFile, is_zipfile
-
-from dogapi import dog_http_api
-from pytz import UTC
-
-from django.core.management.base import BaseCommand, CommandError
-from django.conf import settings
-
-import django_startup
-
-from student.models import TestCenterUser, TestCenterRegistration
-
-
-django_startup.autostartup()
-
-
-class Command(BaseCommand):
-
-    args = '<input zip file>'
-    help = """
-    Import Pearson confirmation files and update TestCenterUser
-    and TestCenterRegistration tables with status.
-    """
-
-    @staticmethod
-    def datadog_error(string, tags):
-        dog_http_api.event("Pearson Import", string, alert_type='error', tags=[tags])
-
-    def handle(self, *args, **kwargs):
-        if len(args) < 1:
-            print Command.help
-            return
-
-        source_zip = args[0]
-        if not is_zipfile(source_zip):
-            error = "Input file is not a zipfile: \"{}\"".format(source_zip)
-            Command.datadog_error(error, source_zip)
-            raise CommandError(error)
-
-        # loop through all files in zip, and process them based on filename prefix:
-        with ZipFile(source_zip, 'r') as zipfile:
-            for fileinfo in zipfile.infolist():
-                with zipfile.open(fileinfo) as zipentry:
-                    if fileinfo.filename.startswith("eac-"):
-                        self.process_eac(zipentry)
-                    elif fileinfo.filename.startswith("vcdc-"):
-                        self.process_vcdc(zipentry)
-                    else:
-                        error = "Unrecognized confirmation file type\"{}\" in confirmation zip file \"{}\"".format(fileinfo.filename, zipfile)
-                        Command.datadog_error(error, source_zip)
-                        raise CommandError(error)
-
-    def process_eac(self, eacfile):
-        print "processing eac"
-        reader = csv.DictReader(eacfile, delimiter="\t")
-        for row in reader:
-            client_authorization_id = row['ClientAuthorizationID']
-            if not client_authorization_id:
-                if row['Status'] == 'Error':
-                    Command.datadog_error("Error in EAD file processing ({}): {}".format(row['Date'], row['Message']), eacfile.name)
-                else:
-                    Command.datadog_error("Encountered bad record: {}".format(row), eacfile.name)
-            else:
-                try:
-                    registration = TestCenterRegistration.objects.get(client_authorization_id=client_authorization_id)
-                    Command.datadog_error("Found authorization record for user {}".format(registration.testcenter_user.user.username), eacfile.name)
-                    # now update the record:
-                    registration.upload_status = row['Status']
-                    registration.upload_error_message = row['Message']
-                    try:
-                        registration.processed_at = strftime('%Y-%m-%d %H:%M:%S', strptime(row['Date'], '%Y/%m/%d %H:%M:%S'))
-                    except ValueError as ve:
-                        Command.datadog_error("Bad Date value found for {}: message {}".format(client_authorization_id, ve), eacfile.name)
-                    # store the authorization Id if one is provided.  (For debugging)
-                    if row['AuthorizationID']:
-                        try:
-                            registration.authorization_id = int(row['AuthorizationID'])
-                        except ValueError as ve:
-                            Command.datadog_error("Bad AuthorizationID value found for {}: message {}".format(client_authorization_id, ve), eacfile.name)
-
-                    registration.confirmed_at = datetime.now(UTC)
-                    registration.save()
-                except TestCenterRegistration.DoesNotExist:
-                    Command.datadog_error("Failed to find record for client_auth_id {}".format(client_authorization_id), eacfile.name)
-
-    def process_vcdc(self, vcdcfile):
-        print "processing vcdc"
-        reader = csv.DictReader(vcdcfile, delimiter="\t")
-        for row in reader:
-            client_candidate_id = row['ClientCandidateID']
-            if not client_candidate_id:
-                if row['Status'] == 'Error':
-                    Command.datadog_error("Error in CDD file processing ({}): {}".format(row['Date'], row['Message']), vcdcfile.name)
-                else:
-                    Command.datadog_error("Encountered bad record: {}".format(row), vcdcfile.name)
-            else:
-                try:
-                    tcuser = TestCenterUser.objects.get(client_candidate_id=client_candidate_id)
-                    Command.datadog_error("Found demographics record for user {}".format(tcuser.user.username), vcdcfile.name)
-                    # now update the record:
-                    tcuser.upload_status = row['Status']
-                    tcuser.upload_error_message = row['Message']
-                    try:
-                        tcuser.processed_at = strftime('%Y-%m-%d %H:%M:%S', strptime(row['Date'], '%Y/%m/%d %H:%M:%S'))
-                    except ValueError as ve:
-                        Command.datadog_error("Bad Date value found for {}: message {}".format(client_candidate_id, ve), vcdcfile.name)
-                    # store the candidate Id if one is provided.  (For debugging)
-                    if row['CandidateID']:
-                        try:
-                            tcuser.candidate_id = int(row['CandidateID'])
-                        except ValueError as ve:
-                            Command.datadog_error("Bad CandidateID value found for {}: message {}".format(client_candidate_id, ve), vcdcfile.name)
-                    tcuser.confirmed_at = datetime.utcnow()
-                    tcuser.save()
-                except TestCenterUser.DoesNotExist:
-                    Command.datadog_error(" Failed to find record for client_candidate_id {}".format(client_candidate_id), vcdcfile.name)

common/djangoapps/student/management/commands/pearson_make_tc_registration.py

-from optparse import make_option
-
-from django.contrib.auth.models import User
-from django.core.management.base import BaseCommand, CommandError
-
-from student.models import TestCenterUser, TestCenterRegistration, TestCenterRegistrationForm, get_testcenter_registration
-from student.views import course_from_id
-from xmodule.course_module import CourseDescriptor
-from xmodule.modulestore.exceptions import ItemNotFoundError
-
-
-class Command(BaseCommand):
-    option_list = BaseCommand.option_list + (
-        # registration info:
-        make_option(
-            '--accommodation_request',
-            action='store',
-            dest='accommodation_request',
-        ),
-        make_option(
-            '--accommodation_code',
-            action='store',
-            dest='accommodation_code',
-        ),
-        make_option(
-            '--client_authorization_id',
-            action='store',
-            dest='client_authorization_id',
-        ),
-        # exam info:
-        make_option(
-            '--exam_series_code',
-            action='store',
-            dest='exam_series_code',
-        ),
-        make_option(
-            '--eligibility_appointment_date_first',
-            action='store',
-            dest='eligibility_appointment_date_first',
-            help='use YYYY-MM-DD format if overriding existing course values, or YYYY-MM-DDTHH:MM if not using an existing course.'
-        ),
-        make_option(
-            '--eligibility_appointment_date_last',
-            action='store',
-            dest='eligibility_appointment_date_last',
-            help='use YYYY-MM-DD format if overriding existing course values, or YYYY-MM-DDTHH:MM if not using an existing course.'
-        ),
-        # internal values:
-        make_option(
-            '--authorization_id',
-            action='store',
-            dest='authorization_id',
-            help='ID we receive from Pearson for a particular authorization'
-        ),
-        make_option(
-            '--upload_status',
-            action='store',
-            dest='upload_status',
-            help='status value assigned by Pearson'
-        ),
-        make_option(
-            '--upload_error_message',
-            action='store',
-            dest='upload_error_message',
-            help='error message provided by Pearson on a failure.'
-        ),
-        # control values:
-        make_option(
-            '--ignore_registration_dates',
-            action='store_true',
-            dest='ignore_registration_dates',
-            help='find exam info for course based on exam_series_code, even if the exam is not active.'
-        ),
-        make_option(
-            '--create_dummy_exam',
-            action='store_true',
-            dest='create_dummy_exam',
-            help='create dummy exam info for course, even if course exists'
-        ),
-    )
-    args = "<student_username course_id>"
-    help = "Create or modify a TestCenterRegistration entry for a given Student"
-
-    @staticmethod
-    def is_valid_option(option_name):
-        base_options = set(option.dest for option in BaseCommand.option_list)
-        return option_name not in base_options
-
-
-    def handle(self, *args, **options):
-        username = args[0]
-        course_id = args[1]
-        print username, course_id
-
-        our_options = dict((k, v) for k, v in options.items()
-                           if Command.is_valid_option(k) and v is not None)
-        try:
-            student = User.objects.get(username=username)
-        except User.DoesNotExist:
-            raise CommandError("User \"{}\" does not exist".format(username))
-
-        try:
-            testcenter_user = TestCenterUser.objects.get(user=student)
-        except TestCenterUser.DoesNotExist:
-            raise CommandError("User \"{}\" does not have an existing demographics record".format(username))
-
-        # get an "exam" object.  Check to see if a course_id was specified, and use information from that:
-        exam = None
-        create_dummy_exam = 'create_dummy_exam' in our_options and our_options['create_dummy_exam']
-        if not create_dummy_exam:
-            try:
-                course = course_from_id(course_id)
-                if 'ignore_registration_dates' in our_options:
-                    examlist = [exam for exam in course.test_center_exams if exam.exam_series_code == our_options.get('exam_series_code')]
-                    exam = examlist[0] if len(examlist) > 0 else None
-                else:
-                    exam = course.current_test_center_exam
-            except ItemNotFoundError:
-                pass
-        else:
-            # otherwise use explicit values (so we don't have to define a course):
-            exam_name = "Dummy Placeholder Name"
-            exam_info = {'Exam_Series_Code': our_options['exam_series_code'],
-                          'First_Eligible_Appointment_Date': our_options['eligibility_appointment_date_first'],
-                          'Last_Eligible_Appointment_Date': our_options['eligibility_appointment_date_last'],
-                          }
-            exam = CourseDescriptor.TestCenterExam(course_id, exam_name, exam_info)
-            # update option values for date_first and date_last to use YYYY-MM-DD format
-            # instead of YYYY-MM-DDTHH:MM
-            our_options['eligibility_appointment_date_first'] = exam.first_eligible_appointment_date.strftime("%Y-%m-%d")
-            our_options['eligibility_appointment_date_last'] = exam.last_eligible_appointment_date.strftime("%Y-%m-%d")
-
-        if exam is None:
-            raise CommandError("Exam for course_id {} does not exist".format(course_id))
-
-        exam_code = exam.exam_series_code
-
-        UPDATE_FIELDS = ('accommodation_request',
-                          'accommodation_code',
-                          'client_authorization_id',
-                          'exam_series_code',
-                          'eligibility_appointment_date_first',
-                          'eligibility_appointment_date_last',
-                          )
-
-        # create and save the registration:
-        needs_updating = False
-        registrations = get_testcenter_registration(student, course_id, exam_code)
-        if len(registrations) > 0:
-            registration = registrations[0]
-            for fieldname in UPDATE_FIELDS:
-                if fieldname in our_options and registration.__getattribute__(fieldname) != our_options[fieldname]:
-                    needs_updating = True;
-        else:
-            accommodation_request = our_options.get('accommodation_request', '')
-            registration = TestCenterRegistration.create(testcenter_user, exam, accommodation_request)
-            needs_updating = True
-
-
-        if needs_updating:
-            # first update the record with the new values, if any:
-            for fieldname in UPDATE_FIELDS:
-                if fieldname in our_options and fieldname not in TestCenterRegistrationForm.Meta.fields:
-                    registration.__setattr__(fieldname, our_options[fieldname])
-
-            # the registration form normally populates the data dict with
-            # the accommodation request (if any).  But here we want to
-            # specify only those values that might change, so update the dict with existing
-            # values.
-            form_options = dict(our_options)
-            for propname in TestCenterRegistrationForm.Meta.fields:
-                if propname not in form_options:
-                    form_options[propname] = registration.__getattribute__(propname)
-            form = TestCenterRegistrationForm(instance=registration, data=form_options)
-            if form.is_valid():
-                form.update_and_save()
-                print "Updated registration information for user's registration: username \"{}\" course \"{}\", examcode \"{}\"".format(student.username, course_id, exam_code)
-            else:
-                if (len(form.errors) > 0):
-                    print "Field Form errors encountered:"
-                for fielderror in form.errors:
-                    for msg in form.errors[fielderror]:
-                        print "Field Form Error:  {} -- {}".format(fielderror, msg)
-                    if (len(form.non_field_errors()) > 0):
-                        print "Non-field Form errors encountered:"
-                        for nonfielderror in form.non_field_errors:
-                            print "Non-field Form Error:  %s" % nonfielderror
-
-        else:
-            print "No changes necessary to make to existing user's registration."
-
-        # override internal values:
-        change_internal = False
-        if 'exam_series_code' in our_options:
-            exam_code = our_options['exam_series_code']
-        registration = get_testcenter_registration(student, course_id, exam_code)[0]
-        for internal_field in ['upload_error_message', 'upload_status', 'authorization_id']:
-            if internal_field in our_options:
-                registration.__setattr__(internal_field, our_options[internal_field])
-                change_internal = True
-
-        if change_internal:
-            print "Updated  confirmation information in existing user's registration."
-            registration.save()
-        else:
-            print "No changes necessary to make to confirmation information in existing user's registration."

common/djangoapps/student/management/commands/pearson_make_tc_user.py

-from optparse import make_option
-
-from django.contrib.auth.models import User
-from django.core.management.base import BaseCommand, CommandError
-
-from student.models import TestCenterUser, TestCenterUserForm
-
-
-class Command(BaseCommand):
-    option_list = BaseCommand.option_list + (
-        # demographics:
-        make_option(
-            '--first_name',
-            action='store',
-            dest='first_name',
-        ),
-        make_option(
-            '--middle_name',
-            action='store',
-            dest='middle_name',
-        ),
-        make_option(
-            '--last_name',
-            action='store',
-            dest='last_name',
-        ),
-        make_option(
-            '--suffix',
-            action='store',
-            dest='suffix',
-        ),
-        make_option(
-            '--salutation',
-            action='store',
-            dest='salutation',
-        ),
-        make_option(
-            '--address_1',
-            action='store',
-            dest='address_1',
-        ),
-        make_option(
-            '--address_2',
-            action='store',
-            dest='address_2',
-        ),
-        make_option(
-            '--address_3',
-            action='store',
-            dest='address_3',
-        ),
-        make_option(
-            '--city',
-            action='store',
-            dest='city',
-        ),
-        make_option(
-            '--state',
-            action='store',
-            dest='state',
-            help='Two letter code (e.g. MA)'
-        ),
-        make_option(
-            '--postal_code',
-            action='store',
-            dest='postal_code',
-        ),
-        make_option(
-            '--country',
-            action='store',
-            dest='country',
-            help='Three letter country code (ISO 3166-1 alpha-3), like USA'
-        ),
-        make_option(
-            '--phone',
-            action='store',
-            dest='phone',
-            help='Pretty free-form (parens, spaces, dashes), but no country code'
-        ),
-        make_option(
-            '--extension',
-            action='store',
-            dest='extension',
-        ),
-        make_option(
-            '--phone_country_code',
-            action='store',
-            dest='phone_country_code',
-            help='Phone country code, just "1" for the USA'
-        ),
-        make_option(
-            '--fax',
-            action='store',
-            dest='fax',
-            help='Pretty free-form (parens, spaces, dashes), but no country code'
-        ),
-        make_option(
-            '--fax_country_code',
-            action='store',
-            dest='fax_country_code',
-            help='Fax country code, just "1" for the USA'
-        ),
-        make_option(
-            '--company_name',
-            action='store',
-            dest='company_name',
-        ),
-        # internal values:
-        make_option(
-            '--client_candidate_id',
-            action='store',
-            dest='client_candidate_id',
-            help='ID we assign a user to identify them to Pearson'
-        ),
-        make_option(
-            '--upload_status',
-            action='store',
-            dest='upload_status',
-            help='status value assigned by Pearson'
-        ),
-        make_option(
-            '--upload_error_message',
-            action='store',
-            dest='upload_error_message',
-            help='error message provided by Pearson on a failure.'
-        ),
-    )
-    args = "<student_username>"
-    help = "Create or modify a TestCenterUser entry for a given Student"
-
-    @staticmethod
-    def is_valid_option(option_name):
-        base_options = set(option.dest for option in BaseCommand.option_list)
-        return option_name not in base_options
-
-
-    def handle(self, *args, **options):
-        username = args[0]
-        print username
-
-        our_options = dict((k, v) for k, v in options.items()
-                           if Command.is_valid_option(k) and v is not None)
-        student = User.objects.get(username=username)
-        try:
-            testcenter_user = TestCenterUser.objects.get(user=student)
-            needs_updating = testcenter_user.needs_update(our_options)
-        except TestCenterUser.DoesNotExist:
-            # do additional initialization here:
-            testcenter_user = TestCenterUser.create(student)
-            needs_updating = True
-
-        if needs_updating:
-            # the registration form normally populates the data dict with
-            # all values from the testcenter_user.  But here we only want to
-            # specify those values that change, so update the dict with existing
-            # values.
-            form_options = dict(our_options)
-            for propname in TestCenterUser.user_provided_fields():
-                if propname not in form_options:
-                    form_options[propname] = testcenter_user.__getattribute__(propname)
-            form = TestCenterUserForm(instance=testcenter_user, data=form_options)
-            if form.is_valid():
-                form.update_and_save()
-            else:
-                errorlist = []
-                if (len(form.errors) > 0):
-                    errorlist.append("Field Form errors encountered:")
-                    for fielderror in form.errors:
-                        errorlist.append("Field Form Error:  {}".format(fielderror))
-                if (len(form.non_field_errors()) > 0):
-                    errorlist.append("Non-field Form errors encountered:")
-                    for nonfielderror in form.non_field_errors:
-                        errorlist.append("Non-field Form Error:  {}".format(nonfielderror))
-                raise CommandError("\n".join(errorlist))
-        else:
-            print "No changes necessary to make to existing user's demographics."
-
-        # override internal values:
-        change_internal = False
-        testcenter_user = TestCenterUser.objects.get(user=student)
-        for internal_field in ['upload_error_message', 'upload_status', 'client_candidate_id']:
-            if internal_field in our_options:
-                testcenter_user.__setattr__(internal_field, our_options[internal_field])
-                change_internal = True
-
-        if change_internal:
-            testcenter_user.save()
-            print "Updated  confirmation information in existing user's demographics."
-        else:
-            print "No changes necessary to make to confirmation information in existing user's demographics."

common/djangoapps/student/management/commands/pearson_transfer.py

-from optparse import make_option
-import os
-from stat import S_ISDIR
-
-import boto
-from dogapi import dog_http_api, dog_stats_api
-import paramiko
-
-from django.conf import settings
-from django.core.management import call_command
-from django.core.management.base import BaseCommand, CommandError
-
-import django_startup
-
-
-django_startup.autostartup()
-
-
-class Command(BaseCommand):
-    help = """
-    This command handles the importing and exporting of student records for
-    Pearson.  It uses some other Django commands to export and import the
-    files and then uploads over SFTP to Pearson and stuffs the entry in an
-    S3 bucket for archive purposes.
-
-    Usage: ./manage.py pearson-transfer --mode [import|export|both]
-    """
-
-    option_list = BaseCommand.option_list + (
-        make_option('--mode',
-                    action='store',
-                    dest='mode',
-                    default='both',
-                    choices=('import', 'export', 'both'),
-                    help='mode is import, export, or both'),
-    )
-
-    def handle(self, **options):
-
-        if not hasattr(settings, 'PEARSON'):
-            raise CommandError('No PEARSON entries in auth/env.json.')
-
-        # check settings needed for either import or export:
-        for value in ['SFTP_HOSTNAME', 'SFTP_USERNAME', 'SFTP_PASSWORD', 'S3_BUCKET']:
-            if value not in settings.PEARSON:
-                raise CommandError('No entry in the PEARSON settings'
-                                   '(env/auth.json) for {0}'.format(value))
-
-        for value in ['AWS_ACCESS_KEY_ID', 'AWS_SECRET_ACCESS_KEY']:
-            if not hasattr(settings, value):
-                raise CommandError('No entry in the AWS settings'
-                                   '(env/auth.json) for {0}'.format(value))
-
-        # check additional required settings for import and export:
-        if options['mode'] in ('export', 'both'):
-            for value in ['LOCAL_EXPORT', 'SFTP_EXPORT']:
-                if value not in settings.PEARSON:
-                    raise CommandError('No entry in the PEARSON settings'
-                                       '(env/auth.json) for {0}'.format(value))
-            # make sure that the import directory exists or can be created:
-            source_dir = settings.PEARSON['LOCAL_EXPORT']
-            if not os.path.isdir(source_dir):
-                os.makedirs(source_dir)
-
-        if options['mode'] in ('import', 'both'):
-            for value in ['LOCAL_IMPORT', 'SFTP_IMPORT']:
-                if value not in settings.PEARSON:
-                    raise CommandError('No entry in the PEARSON settings'
-                                       '(env/auth.json) for {0}'.format(value))
-            # make sure that the import directory exists or can be created:
-            dest_dir = settings.PEARSON['LOCAL_IMPORT']
-            if not os.path.isdir(dest_dir):
-                os.makedirs(dest_dir)
-
-
-        def sftp(files_from, files_to, mode, deleteAfterCopy=False):
-            with dog_stats_api.timer('pearson.{0}'.format(mode), tags='sftp'):
-                try:
-                    t = paramiko.Transport((settings.PEARSON['SFTP_HOSTNAME'], 22))
-                    t.connect(username=settings.PEARSON['SFTP_USERNAME'],
-                              password=settings.PEARSON['SFTP_PASSWORD'])
-                    sftp = paramiko.SFTPClient.from_transport(t)
-
-                    if mode == 'export':
-                        try:
-                            sftp.chdir(files_to)
-                        except IOError:
-                            raise CommandError('SFTP destination path does not exist: {}'.format(files_to))
-                        for filename in os.listdir(files_from):
-                            sftp.put(files_from + '/' + filename, filename)
-                            if deleteAfterCopy:
-                                os.remove(os.path.join(files_from, filename))
-                    else:
-                        try:
-                            sftp.chdir(files_from)
-                        except IOError:
-                            raise CommandError('SFTP source path does not exist: {}'.format(files_from))
-                        for filename in sftp.listdir('.'):
-                            # skip subdirectories
-                            if not S_ISDIR(sftp.stat(filename).st_mode):
-                                sftp.get(filename, files_to + '/' + filename)
-                                # delete files from sftp server once they are successfully pulled off:
-                                if deleteAfterCopy:
-                                    sftp.remove(filename)
-                except:
-                    dog_http_api.event('pearson {0}'.format(mode),
-                                       'sftp uploading failed',
-                                       alert_type='error')
-                    raise
-                finally:
-                    sftp.close()
-                    t.close()
-
-        def s3(files_from, bucket, mode, deleteAfterCopy=False):
-            with dog_stats_api.timer('pearson.{0}'.format(mode), tags='s3'):
-                try:
-                    for filename in os.listdir(files_from):
-                        source_file = os.path.join(files_from, filename)
-                        # use mode as name of directory into which to write files
-                        dest_file = os.path.join(mode, filename)
-                        upload_file_to_s3(bucket, source_file, dest_file)
-                        if deleteAfterCopy:
-                            os.remove(files_from + '/' + filename)
-                except:
-                    dog_http_api.event('pearson {0}'.format(mode),
-                                       's3 archiving failed')
-                    raise
-
-        def upload_file_to_s3(bucket, source_file, dest_file):
-            """
-            Upload file to S3
-            """
-            s3 = boto.connect_s3(settings.AWS_ACCESS_KEY_ID,
-                                 settings.AWS_SECRET_ACCESS_KEY)
-            from boto.s3.key import Key
-            b = s3.get_bucket(bucket)
-            k = Key(b)
-            k.key = "{filename}".format(filename=dest_file)
-            k.set_contents_from_filename(source_file)
-
-        def export_pearson():
-            options = {'dest-from-settings': True}
-            call_command('pearson_export_cdd', **options)
-            call_command('pearson_export_ead', **options)
-            mode = 'export'
-            sftp(settings.PEARSON['LOCAL_EXPORT'], settings.PEARSON['SFTP_EXPORT'], mode, deleteAfterCopy=False)
-            s3(settings.PEARSON['LOCAL_EXPORT'], settings.PEARSON['S3_BUCKET'], mode, deleteAfterCopy=True)
-
-        def import_pearson():
-            mode = 'import'
-            try:
-                sftp(settings.PEARSON['SFTP_IMPORT'], settings.PEARSON['LOCAL_IMPORT'], mode, deleteAfterCopy=True)
-                s3(settings.PEARSON['LOCAL_IMPORT'], settings.PEARSON['S3_BUCKET'], mode, deleteAfterCopy=False)
-            except Exception as e:
-                dog_http_api.event('Pearson Import failure', str(e))
-                raise e
-            else:
-                for filename in os.listdir(settings.PEARSON['LOCAL_IMPORT']):
-                    filepath = os.path.join(settings.PEARSON['LOCAL_IMPORT'], filename)
-                    call_command('pearson_import_conf_zip', filepath)
-                    os.remove(filepath)
-
-        # actually do the work!
-        if options['mode'] in ('export', 'both'):
-            export_pearson()
-        if options['mode'] in ('import', 'both'):
-            import_pearson()

common/djangoapps/student/tests/tests.py

@@ -342,6 +342,14 @@ class EnrollInCourseTest(TestCase):
         )
         self.assertFalse(enrollment_record.is_active)
 
+        # Make sure mode is updated properly if user unenrolls & re-enrolls
+        enrollment = CourseEnrollment.enroll(user, course_id, "verified")
+        self.assertEquals(enrollment.mode, "verified")
+        CourseEnrollment.unenroll(user, course_id)
+        enrollment = CourseEnrollment.enroll(user, course_id, "audit")
+        self.assertTrue(CourseEnrollment.is_enrolled(user, course_id))
+        self.assertEquals(enrollment.mode, "audit")
+
     def assert_no_events_were_emitted(self):
         """Ensures no events were emitted since the last event related assertion"""
         self.assertFalse(self.mock_server_track.called)

common/djangoapps/student/views.py

@@ -39,10 +39,9 @@ from mitxmako.shortcuts import render_to_response, render_to_string
 
 from course_modes.models import CourseMode
 from student.models import (
-    Registration, UserProfile, TestCenterUser, TestCenterUserForm,
-    TestCenterRegistration, TestCenterRegistrationForm, PendingNameChange,
+    Registration, UserProfile, PendingNameChange,
     PendingEmailChange, CourseEnrollment, unique_id_for_user,
-    get_testcenter_registration, CourseEnrollmentAllowed, UserStanding,
+    CourseEnrollmentAllowed, UserStanding,
 )
 from student.forms import PasswordResetFormNoActive
 
@@ -966,172 +965,6 @@ def create_account(request, post_override=None):
     return response
 
 
-def exam_registration_info(user, course):
-    """ Returns a Registration object if the user is currently registered for a current
-    exam of the course.  Returns None if the user is not registered, or if there is no
-    current exam for the course.
-    """
-    exam_info = course.current_test_center_exam
-    if exam_info is None:
-        return None
-
-    exam_code = exam_info.exam_series_code
-    registrations = get_testcenter_registration(user, course.id, exam_code)
-    if registrations:
-        registration = registrations[0]
-    else:
-        registration = None
-    return registration
-
-
-@login_required
-@ensure_csrf_cookie
-def begin_exam_registration(request, course_id):
-    """ Handles request to register the user for the current
-    test center exam of the specified course.  Called by form
-    in dashboard.html.
-    """
-    user = request.user
-
-    try:
-        course = course_from_id(course_id)
-    except ItemNotFoundError:
-        log.error("User {0} enrolled in non-existent course {1}".format(user.username, course_id))
-        raise Http404
-
-    # get the exam to be registered for:
-    # (For now, we just assume there is one at most.)
-    # if there is no exam now (because someone bookmarked this stupid page),
-    # then return a 404:
-    exam_info = course.current_test_center_exam
-    if exam_info is None:
-        raise Http404
-
-    # determine if the user is registered for this course:
-    registration = exam_registration_info(user, course)
-
-    # we want to populate the registration page with the relevant information,
-    # if it already exists.  Create an empty object otherwise.
-    try:
-        testcenteruser = TestCenterUser.objects.get(user=user)
-    except TestCenterUser.DoesNotExist:
-        testcenteruser = TestCenterUser()
-        testcenteruser.user = user
-
-    context = {'course': course,
-               'user': user,
-               'testcenteruser': testcenteruser,
-               'registration': registration,
-               'exam_info': exam_info,
-               }
-
-    return render_to_response('test_center_register.html', context)
-
-
-@ensure_csrf_cookie
-def create_exam_registration(request, post_override=None):
-    """
-    JSON call to create a test center exam registration.
-    Called by form in test_center_register.html
-    """
-    post_vars = post_override if post_override else request.POST
-
-    # first determine if we need to create a new TestCenterUser, or if we are making any update
-    # to an existing TestCenterUser.
-    username = post_vars['username']
-    user = User.objects.get(username=username)
-    course_id = post_vars['course_id']
-    course = course_from_id(course_id)  # assume it will be found....
-
-    # make sure that any demographic data values received from the page have been stripped.
-    # Whitespace is not an acceptable response for any of these values
-    demographic_data = {}
-    for fieldname in TestCenterUser.user_provided_fields():
-        if fieldname in post_vars:
-            demographic_data[fieldname] = (post_vars[fieldname]).strip()
-    try:
-        testcenter_user = TestCenterUser.objects.get(user=user)
-        needs_updating = testcenter_user.needs_update(demographic_data)
-        log.info("User {0} enrolled in course {1} {2}updating demographic info for exam registration".format(user.username, course_id, "" if needs_updating else "not "))
-    except TestCenterUser.DoesNotExist:
-        # do additional initialization here:
-        testcenter_user = TestCenterUser.create(user)
-        needs_updating = True
-        log.info("User {0} enrolled in course {1} creating demographic info for exam registration".format(user.username, course_id))
-
-    # perform validation:
-    if needs_updating:
-        # first perform validation on the user information
-        # using a Django Form.
-        form = TestCenterUserForm(instance=testcenter_user, data=demographic_data)
-        if form.is_valid():
-            form.update_and_save()
-        else:
-            response_data = {'success': False}
-            # return a list of errors...
-            response_data['field_errors'] = form.errors
-            response_data['non_field_errors'] = form.non_field_errors()
-            return HttpResponse(json.dumps(response_data), mimetype="application/json")
-
-    # create and save the registration:
-    needs_saving = False
-    exam = course.current_test_center_exam
-    exam_code = exam.exam_series_code
-    registrations = get_testcenter_registration(user, course_id, exam_code)
-    if registrations:
-        registration = registrations[0]
-        # NOTE: we do not bother to check here to see if the registration has changed,
-        # because at the moment there is no way for a user to change anything about their
-        # registration.  They only provide an optional accommodation request once, and
-        # cannot make changes to it thereafter.
-        # It is possible that the exam_info content has been changed, such as the
-        # scheduled exam dates, but those kinds of changes should not be handled through
-        # this registration screen.
-
-    else:
-        accommodation_request = post_vars.get('accommodation_request', '')
-        registration = TestCenterRegistration.create(testcenter_user, exam, accommodation_request)
-        needs_saving = True
-        log.info("User {0} enrolled in course {1} creating new exam registration".format(user.username, course_id))
-
-    if needs_saving:
-        # do validation of registration.  (Mainly whether an accommodation request is too long.)
-        form = TestCenterRegistrationForm(instance=registration, data=post_vars)
-        if form.is_valid():
-            form.update_and_save()
-        else:
-            response_data = {'success': False}
-            # return a list of errors...
-            response_data['field_errors'] = form.errors
-            response_data['non_field_errors'] = form.non_field_errors()
-            return HttpResponse(json.dumps(response_data), mimetype="application/json")
-
-    # only do the following if there is accommodation text to send,
-    # and a destination to which to send it.
-    # TODO: still need to create the accommodation email templates
-#    if 'accommodation_request' in post_vars and 'TESTCENTER_ACCOMMODATION_REQUEST_EMAIL' in settings:
-#        d = {'accommodation_request': post_vars['accommodation_request'] }
-#
-#        # composes accommodation email
-#        subject = render_to_string('emails/accommodation_email_subject.txt', d)
-#        # Email subject *must not* contain newlines
-#        subject = ''.join(subject.splitlines())
-#        message = render_to_string('emails/accommodation_email.txt', d)
-#
-#        try:
-#            dest_addr = settings['TESTCENTER_ACCOMMODATION_REQUEST_EMAIL']
-#            from_addr = user.email
-#            send_mail(subject, message, from_addr, [dest_addr], fail_silently=False)
-#        except:
-#            log.exception(sys.exc_info())
-#            response_data = {'success': False}
-#            response_data['non_field_errors'] =  [ 'Could not send accommodation e-mail.', ]
-#            return HttpResponse(json.dumps(response_data), mimetype="application/json")
-
-    js = {'success': True}
-    return HttpResponse(json.dumps(js), mimetype="application/json")
-
-
 def auto_auth(request):
     """
     Automatically logs the user in with a generated random credentials

common/djangoapps/util/json_request.py

 from functools import wraps
-import copy
 import json
 from django.core.serializers import serialize
 from django.core.serializers.json import DjangoJSONEncoder

common/lib/xmodule/setup.py

@@ -20,7 +20,6 @@ XMODULES = [
     "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",
     "videoalpha = xmodule.video_module:VideoDescriptor",

common/lib/xmodule/xmodule/course_module.py

@@ -213,7 +213,6 @@ class CourseFields(object):
     discussion_blackouts = List(help="List of pairs of start/end dates for discussion blackouts", scope=Scope.settings)
     discussion_topics = Dict(help="Map of topics names to ids", scope=Scope.settings)
     discussion_sort_alpha = Boolean(scope=Scope.settings, default=False, help="Sort forum categories and subcategories alphabetically.")
-    testcenter_info = Dict(help="Dictionary of Test Center info", scope=Scope.settings)
     announcement = Date(help="Date this course is announced", scope=Scope.settings)
     cohort_config = Dict(help="Dictionary defining cohort configuration", scope=Scope.settings)
     is_new = Boolean(help="Whether this course should be flagged as new", scope=Scope.settings)
@@ -426,20 +425,6 @@ class CourseDescriptor(CourseFields, SequenceDescriptor):
         if self.discussion_topics == {}:
             self.discussion_topics = {'General': {'id': self.location.html_id()}}
 
-        self.test_center_exams = []
-        test_center_info = self.testcenter_info
-        if test_center_info is not None:
-            for exam_name in test_center_info:
-                try:
-                    exam_info = test_center_info[exam_name]
-                    self.test_center_exams.append(self.TestCenterExam(self.id, exam_name, exam_info))
-                except Exception as err:
-                    # If we can't parse the test center exam info, don't break
-                    # the rest of the courseware.
-                    msg = 'Error %s: Unable to load test-center exam info for exam "%s" of course "%s"' % (err, exam_name, self.id)
-                    log.error(msg)
-                    continue
-
         # TODO check that this is still needed here and can't be by defaults.
         if not self.tabs:
             # When calling the various _tab methods, can omit the 'type':'blah' from the
@@ -876,93 +861,6 @@ class CourseDescriptor(CourseFields, SequenceDescriptor):
 
         return True
 
-    class TestCenterExam(object):
-        def __init__(self, course_id, exam_name, exam_info):
-            self.course_id = course_id
-            self.exam_name = exam_name
-            self.exam_info = exam_info
-            self.exam_series_code = exam_info.get('Exam_Series_Code') or exam_name
-            self.display_name = exam_info.get('Exam_Display_Name') or self.exam_series_code
-            self.first_eligible_appointment_date = self._try_parse_time('First_Eligible_Appointment_Date')
-            if self.first_eligible_appointment_date is None:
-                raise ValueError("First appointment date must be specified")
-            # TODO: If defaulting the last appointment date, it should be the
-            # *end* of the same day, not the same time.  It's going to be used as the
-            # end of the exam overall, so we don't want the exam to disappear too soon.
-            # It's also used optionally as the registration end date, so time matters there too.
-            self.last_eligible_appointment_date = self._try_parse_time('Last_Eligible_Appointment_Date')  # or self.first_eligible_appointment_date
-            if self.last_eligible_appointment_date is None:
-                raise ValueError("Last appointment date must be specified")
-            self.registration_start_date = (self._try_parse_time('Registration_Start_Date') or
-                datetime.fromtimestamp(0, UTC()))
-            self.registration_end_date = self._try_parse_time('Registration_End_Date') or self.last_eligible_appointment_date
-            # do validation within the exam info:
-            if self.registration_start_date > self.registration_end_date:
-                raise ValueError("Registration start date must be before registration end date")
-            if self.first_eligible_appointment_date > self.last_eligible_appointment_date:
-                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):
-            """
-            Parse an optional metadata key containing a time: if present, complain
-            if it doesn't parse.
-            Return None if not present or invalid.
-            """
-            if key in self.exam_info:
-                try:
-                    return Date().from_json(self.exam_info[key])
-                except ValueError as e:
-                    msg = "Exam {0} in course {1} loaded with a bad exam_info key '{2}': '{3}'".format(self.exam_name, self.course_id, self.exam_info[key], e)
-                    log.warning(msg)
-                return None
-
-        def has_started(self):
-            return datetime.now(UTC()) > self.first_eligible_appointment_date
-
-        def has_ended(self):
-            return datetime.now(UTC()) > self.last_eligible_appointment_date
-
-        def has_started_registration(self):
-            return datetime.now(UTC()) > self.registration_start_date
-
-        def has_ended_registration(self):
-            return datetime.now(UTC()) > self.registration_end_date
-
-        def is_registering(self):
-            now = datetime.now(UTC())
-            return now >= self.registration_start_date and now <= self.registration_end_date
-
-        @property
-        def first_eligible_appointment_date_text(self):
-            return self.first_eligible_appointment_date.strftime("%b %d, %Y")
-
-        @property
-        def last_eligible_appointment_date_text(self):
-            return self.last_eligible_appointment_date.strftime("%b %d, %Y")
-
-        @property
-        def registration_end_date_text(self):
-            return date_utils.get_default_time_display(self.registration_end_date)
-
-    @property
-    def current_test_center_exam(self):
-        exams = [exam for exam in self.test_center_exams if exam.has_started_registration() and not exam.has_ended()]
-        if len(exams) > 1:
-            # TODO: output some kind of warning.  This should already be
-            # caught if we decide to do validation at load time.
-            return exams[0]
-        elif len(exams) == 1:
-            return exams[0]
-        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 number(self):
         return self.location.course

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

@@ -79,7 +79,7 @@ class ImportSystem(XMLParsingSystem, MakoDescriptorSystem):
 
                 # tags that really need unique names--they store (or should store) state.
                 need_uniq_names = ('problem', 'sequential', 'video', 'course', 'chapter',
-                                   'videosequence', 'poll_question', 'timelimit')
+                                   'videosequence', 'poll_question', 'vertical')
 
                 attr = xml_data.attrib
                 tag = xml_data.tag

common/lib/xmodule/xmodule/tests/rendering/__init__.py

 import core
-import xmodule_asserts
\ No newline at end of file

common/lib/xmodule/xmodule/tests/rendering/xmodule_asserts.py

-"""
-View assertion functions for XModules
-"""
-
-from __future__ import absolute_import
-
-from nose.tools import assert_equals, assert_not_equals  # pylint: disable=no-name-in-module
-
-from xmodule.timelimit_module import TimeLimitModule, TimeLimitDescriptor
-
-from xmodule.tests.rendering.core import assert_student_view_valid_html, assert_student_view_invalid_html
-
-
-@assert_student_view_valid_html.register(TimeLimitModule)
-@assert_student_view_valid_html.register(TimeLimitDescriptor)
-def _(block, html):
-    """
-    Assert that a TimeLimitModule renders student_view html correctly
-    """
-    assert_not_equals(0, block.get_display_items())
-    assert_student_view_valid_html(block.get_children()[0], html)
-
-
-@assert_student_view_invalid_html.register(TimeLimitModule)
-@assert_student_view_invalid_html.register(TimeLimitDescriptor)
-def _(block, html):
-    """
-    Assert that a TimeLimitModule renders student_view html correctly
-    """
-    assert_equals(0, len(block.get_display_items()))
-    assert_equals(u"", html)

common/lib/xmodule/xmodule/tests/test_import.py

@@ -92,6 +92,16 @@ class ImportTestCase(BaseCourseTestCase):
 
         self.assertNotEqual(descriptor1.location, descriptor2.location)
 
+        # Check that each vertical gets its very own url_name
+        bad_xml = '''<vertical display_name="abc"><problem url_name="exam1:2013_Spring:abc"/></vertical>'''
+        bad_xml2 = '''<vertical display_name="abc"><problem url_name="exam2:2013_Spring:abc"/></vertical>'''
+
+        descriptor1 = system.process_xml(bad_xml)
+        descriptor2 = system.process_xml(bad_xml2)
+
+        self.assertNotEqual(descriptor1.location, descriptor2.location)
+
+
     def test_reimport(self):
         '''Make sure an already-exported error xml tag loads properly'''
 

common/lib/xmodule/xmodule/timelimit_module.py

-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
-from xblock.fields import Float, String, Boolean, Scope
-from xblock.fragment import Fragment
-
-
-log = logging.getLogger(__name__)
-
-
-class TimeLimitFields(object):
-    has_children = True
-
-    beginning_at = Float(help="The time this timer was started", scope=Scope.user_state)
-    ending_at = Float(help="The time this timer will end", scope=Scope.user_state)
-    accomodation_code = String(help="A code indicating accommodations to be given the student", scope=Scope.user_state)
-    time_expired_redirect_url = String(help="Url to redirect users to after the timelimit has expired", scope=Scope.settings)
-    duration = Float(help="The length of this timer", scope=Scope.settings)
-    suppress_toplevel_navigation = Boolean(help="Whether the toplevel navigation should be suppressed when viewing this module", scope=Scope.settings)
-
-
-class TimeLimitModule(TimeLimitFields, XModule):
-    '''
-    Wrapper module which imposes a time constraint for the completion of its child.
-    '''
-
-    # 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_remaining_time_in_ms(self):
-        return int((self.ending_at - time()) * 1000)
-
-    def student_view(self, context):
-        # 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]
-            return child.render('student_view', context)
-        else:
-            return Fragment()
-
-    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, _data):
-        raise NotFoundError('Unexpected dispatch type')
-
-    def get_icon_class(self):
-        children = self.get_children()
-        if children:
-            return children[0].get_icon_class()
-        else:
-            return "other"
-
-class TimeLimitDescriptor(TimeLimitFields, XMLEditingDescriptor, XmlDescriptor):
-
-    module_class = TimeLimitModule
-
-    @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
-
-    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

common/lib/xmodule/xmodule/xml_module.py

@@ -3,7 +3,6 @@ import copy
 import logging
 import os
 import sys
-from collections import namedtuple
 from lxml import etree
 
 from xblock.fields import Dict, Scope, ScopeIds
@@ -133,15 +132,12 @@ class XmlDescriptor(XModuleDescriptor):
                            'ispublic',  # if True, then course is listed for all users; see
                            'xqa_key',  # for xqaa server access
                            'giturl',  # url of git server for origin of file
-                           # information about testcenter exams is a dict (of dicts), not a string,
-                           # so it cannot be easily exportable as a course element's attribute.
-                           'testcenter_info',
                            # VS[compat] Remove once unused.
                            'name', 'slug')
 
     metadata_to_strip = ('data_dir',
                          'tabs', 'grading_policy', 'published_by', 'published_date',
-                         'discussion_blackouts', 'testcenter_info',
+                         'discussion_blackouts',
                          # VS[compat] -- remove the below attrs once everything is in the CMS
                          'course', 'org', 'url_name', 'filename',
                          # Used for storing xml attributes between import and export, for roundtrips

common/test/data/test_exam_registration/policies/2012_Fall.json

@@ -3,21 +3,6 @@
         "graceperiod": "2 days 5 hours 59 minutes 59 seconds",
         "start": "2011-07-17T12:00",
         "display_name": "Toy Course",
-	"testcenter_info": {
-            "Midterm_Exam": {
-                "Exam_Series_Code": "Midterm_Exam",
-                "First_Eligible_Appointment_Date": "2012-11-09T00:00",
-                "Last_Eligible_Appointment_Date": "2012-11-09T23:59"
-            },
-            "Final_Exam": {
-                 "Exam_Series_Code": "mit6002xfall12a",
-                 "Exam_Display_Name": "Final Exam",
-                 "First_Eligible_Appointment_Date": "2013-01-25T00:00",
-                 "Last_Eligible_Appointment_Date": "2013-01-25T23:59",
-                 "Registration_Start_Date": "2013-01-01T00:00",
-                 "Registration_End_Date": "2013-01-21T23:59"
-            }
-	}
     },
     "chapter/Overview": {
         "display_name": "Overview"

docs/data/source/internal_data_formats/sql_schema.rst

@@ -19,7 +19,7 @@ All of our tables will be described below, first in summary form with field type
   .. list-table::
      :widths: 10 80
      :header-rows: 1
-  
+
      * - Value
        - Meaning
      * - `int`
@@ -36,13 +36,13 @@ All of our tables will be described below, first in summary form with field type
        - Date
      * - `datetime`
        - Datetime in UTC, precision in seconds.
-  
+
 `Null`
 
   .. list-table::
      :widths: 10 80
      :header-rows: 1
-  
+
      * - Value
        - Meaning
      * - `YES`
@@ -57,7 +57,7 @@ All of our tables will be described below, first in summary form with field type
   .. list-table::
      :widths: 10 80
      :header-rows: 1
-  
+
      * - Value
        - Meaning
      * - `PRI`
@@ -252,19 +252,19 @@ There is an important split in demographic data gathered for the students who si
 
   `old_names`
     A list of the previous names this user had, and the timestamps at which they submitted a request to change those names. These name change request submissions used to require a staff member to approve it before the name change took effect. This is no longer the case, though we still record their previous names.
-  
+
     Note that the value stored for each entry is the name they had, not the name they requested to get changed to. People often changed their names as the time for certificate generation approached, to replace nicknames with their actual names or correct spelling/punctuation errors.
-  
+
     The timestamps are UTC, like all datetimes stored in our system.
-  
+
   `old_emails`
     A list of previous emails this user had, with timestamps of when they changed them, in a format similar to `old_names`. There was never an approval process for this.
-  
+
     The timestamps are UTC, like all datetimes stored in our system.
-  
+
   `6002x_exit_response`
     Answers to a survey that was sent to students after the prototype 6.002x course in the Spring of 2012. The questions and number of questions were randomly selected to measure how much survey length affected response rate. Only students from this course have this field.
-  
+
 
 `courseware`
 ------------
@@ -277,7 +277,7 @@ There is an important split in demographic data gathered for the students who si
   .. list-table::
      :widths: 10 80
      :header-rows: 1
-  
+
      * - Value
        - Meaning
      * - `NULL`
@@ -306,10 +306,10 @@ There is an important split in demographic data gathered for the students who si
   .. list-table::
      :widths: 10 80
      :header-rows: 1
-  
+
      * - Value
        - Meaning
-     * - `NULL` 
+     * - `NULL`
        - This student signed up before this information was collected
      * - `''` (blank)
        - User did not specify level of education.
@@ -335,7 +335,7 @@ There is an important split in demographic data gathered for the students who si
        - None
      * - `'other'`
        - Other
-     
+
 `goals`
 -------
   Text field collected during student signup in response to the prompt, "Goals in signing up for edX". We only started collecting this information after the transition from MITx to edX, so prototype course students will have `NULL` for this field. Students who elected not to enter anything will have a blank string.
@@ -382,7 +382,7 @@ Any piece of content in the courseware can store state and score in the `coursew
 
 .. warning::
    **Modules might not be what you expect!**
-   
+
    It's important to understand what "modules" are in the context of our system, as the terminology can be confusing. For the conventions of this table and many parts of our code, a "module" is a content piece that appears in the courseware. This can be nearly anything that appears when users are in the courseware tab: a video, a piece of HTML, a problem, etc. Modules can also be collections of other modules, such as sequences, verticals (modules stacked together on the same page), weeks, chapters, etc. In fact, the course itself is a top level module that contains all the other contents of the course as children. You can imagine the entire course as a tree with modules at every node.
 
    Modules can store state, but whether and how they do so is up to the implemenation for that particular kind of module. When a user loads page, we look up all the modules they need to render in order to display it, and then we ask the database to look up state for those modules for that user. If there is corresponding entry for that user for a given module, we create a new row and set the state to an empty JSON dictionary.
@@ -420,7 +420,7 @@ The `courseware_studentmodule` table holds all courseware state for a given user
   .. list-table::
      :widths: 10 80
      :header-rows: 0
-  
+
      * - `chapter`
        - The top level categories for a course. Each of these is usually labeled as a Week in the courseware, but this is just convention.
      * - `combinedopenended`
@@ -437,8 +437,6 @@ The `courseware_studentmodule` table holds all courseware state for a given user
        - Self assessment problems. An early test of the open ended grading system that is not in widespread use yet. Recently deprecated in favor of `combinedopenended`.
      * - `sequential`
        - A collection of videos, problems, and other materials, rendered as a horizontal icon bar in the courseware.
-     * - `timelimit`
-       - A special module that records the time you start working on a piece of courseware and enforces time limits, used for Pearson exams. This hasn't been completely generalized yet, so is not available for widespread use.
      * - `videosequence`
        - A collection of videos, exercise problems, and other materials, rendered as a horizontal icon bar in the courseware. Use is inconsistent, and some courses use a `sequential` instead.
 
@@ -451,20 +449,20 @@ The `courseware_studentmodule` table holds all courseware state for a given user
   .. list-table:: Breakdown of example `module_id`: `i4x://MITx/3.091x/problemset/Sample_Problems`
      :widths: 10 20 70
      :header-rows: 1
-     
+
      * - Part
        - Example
        - Definition
      * - `i4x://`
-       - 
+       -
        - Just a convention we ran with. We had plans for the domain `i4x.org` at one point.
      * - `org`
        - `MITx`
        - The organization part of the ID, indicating what organization created this piece of content.
-     * - `course_num` 
+     * - `course_num`
        - `3.091x`
        - The course number this content was created for. Note that there is no run information here, so you can't know what runs of the course this content is being used for from the `module_id` alone; you have to look at the `courseware_studentmodule.course_id` field.
-     * - `module_type` 
+     * - `module_type`
        - `problemset`
        - The module type, same value as what's in the `courseware_studentmodule.module_type` field.
      * - `module_name`
@@ -501,33 +499,6 @@ The `courseware_studentmodule` table holds all courseware state for a given user
   `selfassessment`
     TODO: More details to come.
 
-  `timelimit`
-    This very uncommon type was only used in one Pearson exam for one course, and the format may change significantly in the future. It is currently a JSON dictionary with fields:
-
-    .. list-table::
-       :widths: 10 20 70
-       :header-rows: 1
-
-       * - JSON field
-         - Example
-         - Definition
-       * - `beginning_at`
-         - `1360590255.488154`
-         - UTC time as measured in seconds since UNIX epoch representing when the exam was started.
-       * - `ending_at`
-         - `1360596632.559758`
-         - UTC time as measured in seconds since UNIX epoch representing the time the exam will close.
-       * - `accomodation_codes`
-         - `DOUBLE`
-         - (optional) Sometimes students are given more time for accessibility reasons. Possible values are:
-         
-           * `NONE`: no time accommodation
-           * `ADDHALFTIME`: 1.5X normal time allowance
-           * `ADD30MIN`: normal time allowance + 30 minutes
-           * `DOUBLE`: 2X normal time allowance
-           * `TESTING`: extra long period (for testing/debugging)
-
-
 `grade`
 -------
   Floating point value indicating the total unweighted grade for this problem that the student has scored. Basically how many responses they got right within the problem.
@@ -608,13 +579,13 @@ The generatedcertificate table tracks certificate state for students who have be
   * `notpassing`
   * `restricted`
   * `error`
-  
+
   After a course has been graded and certificates have been issued status will be one of:
-  
+
   * `downloadable`
   * `notpassing`
   * `restricted`
-  
+
   If the status is `downloadable` then the student passed the course and there will be a certificate available for download.
 
 `download_url`

lms/djangoapps/course_wiki/editors.py

@@ -60,5 +60,4 @@ class CodeMirror(BaseEditor):
               "js/vendor/CodeMirror/mitx_markdown.js",
               "js/wiki/accessible.js",
               "js/wiki/CodeMirror.init.js",
-              "js/wiki/cheatsheet.js",
               )

lms/djangoapps/courseware/models.py

@@ -27,7 +27,6 @@ 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/tests/test_timelimit_module.py

-"""
-Tests of the TimeLimitModule
-
-TODO: This should be a test in common/lib/xmodule. However,
-actually rendering HTML templates for XModules at this point requires
-Django (which is storing the templates), so the test can't run in isolation
-"""
-from xmodule.modulestore.tests.factories import ItemFactory
-from xmodule.tests.rendering.core import assert_student_view
-
-from . import XModuleRenderingTestBase
-
-
-class TestTimeLimitModuleRendering(XModuleRenderingTestBase):
-    """
-    Tests of TimeLimitModule html rendering
-    """
-    def test_with_children(self):
-        block = ItemFactory.create(category='timelimit')
-        block.xmodule_runtime = self.new_module_runtime()
-        ItemFactory.create(category='html', data='<html>This is just text</html>', parent=block)
-
-        assert_student_view(block, block.render('student_view'))
-
-    def test_without_children(self):
-        block = ItemFactory.create(category='timelimit')
-        block.xmodule_runtime = self.new_module_runtime()
-
-        assert_student_view(block, block.render('student_view'))

lms/djangoapps/courseware/views.py

@@ -172,71 +172,6 @@ def save_child_position(seq_module, child_name):
     seq_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 = {}
-
-    # TODO (cpennington): Once we can query the course structure, replace this with such a query
-    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 = FieldDataCache.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 timelimit_descriptor.time_expired_redirect_url is None:
-                    raise Http404("no time_expired_redirect_url specified at this location: {} ".format(timelimit_module.location))
-                context['time_expired_redirect_url'] = timelimit_descriptor.time_expired_redirect_url
-                # Fetch the remaining time relative to the end time as stored in the module when it was started.
-                # This value should be in milliseconds.
-                remaining_time = timelimit_module.get_remaining_time_in_ms()
-                context['timer_expiration_duration'] = remaining_time
-                context['suppress_toplevel_navigation'] = timelimit_descriptor.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, field_data_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_duration' in dict if timer is still active, and not if timer has expired.
-    """
-    context = {}
-    # determine where to go when the exam ends:
-    if timelimit_descriptor.time_expired_redirect_url is None:
-        raise Http404("No time_expired_redirect_url specified at this location: {} ".format(timelimit_module.location))
-    context['time_expired_redirect_url'] = timelimit_descriptor.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 timelimit_descriptor.duration is None:
-                raise Http404("No duration specified at this location: {} ".format(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.
-            timelimit_module.begin(timelimit_descriptor.duration)
-
-        # the exam has been started, either because the student is returning to the
-        # exam page, or because they have just visited it.  Fetch the remaining time relative to the
-        # end time as stored in the module when it was started.
-        context['timer_expiration_duration'] = timelimit_module.get_remaining_time_in_ms()
-        # also use the timed module to determine whether top-level navigation is visible:
-        context['suppress_toplevel_navigation'] = timelimit_descriptor.suppress_toplevel_navigation
-    return context
-
-
 def chat_settings(course, user):
     """
     Returns a dict containing the settings required to connect to a
@@ -390,22 +325,8 @@ def index(request, course_id, chapter=None, section=None,
 
             # Save where we are in the chapter
             save_child_position(chapter_module, section)
-
-            # check here if this section *is* a timed module.
-            if section_module.category == 'timelimit':
-                timer_context = update_timelimit_module(user, course_id, section_field_data_cache,
-                                                        section_descriptor, section_module)
-                if 'timer_expiration_duration' 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['fragment'] = section_module.render('student_view')
+
         else:
             # section is none, so display a message
             prev_section = get_current_child(chapter_module)

lms/djangoapps/shoppingcart/admin.py

+"""
+Allows django admin site to add PaidCourseRegistrationAnnotations
+"""
+from ratelimitbackend import admin
+from shoppingcart.models import PaidCourseRegistrationAnnotation
+
+admin.site.register(PaidCourseRegistrationAnnotation)

lms/djangoapps/shoppingcart/migrations/0005_auto__add_paidcourseregistrationannotation__add_field_orderitem_report.py

+# -*- coding: utf-8 -*-
+import datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Adding model 'PaidCourseRegistrationAnnotation'
+        db.create_table('shoppingcart_paidcourseregistrationannotation', (
+            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
+            ('course_id', self.gf('django.db.models.fields.CharField')(unique=True, max_length=128, db_index=True)),
+            ('annotation', self.gf('django.db.models.fields.TextField')(null=True)),
+        ))
+        db.send_create_signal('shoppingcart', ['PaidCourseRegistrationAnnotation'])
+
+        # Adding field 'OrderItem.report_comments'
+        db.add_column('shoppingcart_orderitem', 'report_comments',
+                      self.gf('django.db.models.fields.TextField')(default=''),
+                      keep_default=False)
+
+
+    def backwards(self, orm):
+        # Deleting model 'PaidCourseRegistrationAnnotation'
+        db.delete_table('shoppingcart_paidcourseregistrationannotation')
+
+        # Deleting field 'OrderItem.report_comments'
+        db.delete_column('shoppingcart_orderitem', 'report_comments')
+
+
+    models = {
+        'auth.group': {
+            'Meta': {'object_name': 'Group'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
+            'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
+        },
+        'auth.permission': {
+            'Meta': {'ordering': "('content_type__app_label', 'content_type__model', 'codename')", 'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'},
+            'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
+        },
+        'auth.user': {
+            'Meta': {'object_name': 'User'},
+            'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
+            'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
+            'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
+            'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
+        },
+        'contenttypes.contenttype': {
+            'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
+            'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
+        },
+        'shoppingcart.certificateitem': {
+            'Meta': {'object_name': 'CertificateItem', '_ormbases': ['shoppingcart.OrderItem']},
+            'course_enrollment': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['student.CourseEnrollment']"}),
+            'course_id': ('django.db.models.fields.CharField', [], {'max_length': '128', 'db_index': 'True'}),
+            'mode': ('django.db.models.fields.SlugField', [], {'max_length': '50'}),
+            'orderitem_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['shoppingcart.OrderItem']", 'unique': 'True', 'primary_key': 'True'})
+        },
+        'shoppingcart.order': {
+            'Meta': {'object_name': 'Order'},
+            'bill_to_cardtype': ('django.db.models.fields.CharField', [], {'max_length': '32', 'blank': 'True'}),
+            'bill_to_ccnum': ('django.db.models.fields.CharField', [], {'max_length': '8', 'blank': 'True'}),
+            'bill_to_city': ('django.db.models.fields.CharField', [], {'max_length': '64', 'blank': 'True'}),
+            'bill_to_country': ('django.db.models.fields.CharField', [], {'max_length': '64', 'blank': 'True'}),
+            'bill_to_first': ('django.db.models.fields.CharField', [], {'max_length': '64', 'blank': 'True'}),
+            'bill_to_last': ('django.db.models.fields.CharField', [], {'max_length': '64', 'blank': 'True'}),
+            'bill_to_postalcode': ('django.db.models.fields.CharField', [], {'max_length': '16', 'blank': 'True'}),
+            'bill_to_state': ('django.db.models.fields.CharField', [], {'max_length': '8', 'blank': 'True'}),
+            'bill_to_street1': ('django.db.models.fields.CharField', [], {'max_length': '128', 'blank': 'True'}),
+            'bill_to_street2': ('django.db.models.fields.CharField', [], {'max_length': '128', 'blank': 'True'}),
+            'currency': ('django.db.models.fields.CharField', [], {'default': "'usd'", 'max_length': '8'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'processor_reply_dump': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            'purchase_time': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
+            'status': ('django.db.models.fields.CharField', [], {'default': "'cart'", 'max_length': '32'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']"})
+        },
+        'shoppingcart.orderitem': {
+            'Meta': {'object_name': 'OrderItem'},
+            'currency': ('django.db.models.fields.CharField', [], {'default': "'usd'", 'max_length': '8'}),
+            'fulfilled_time': ('django.db.models.fields.DateTimeField', [], {'null': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'line_desc': ('django.db.models.fields.CharField', [], {'default': "'Misc. Item'", 'max_length': '1024'}),
+            'order': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['shoppingcart.Order']"}),
+            'qty': ('django.db.models.fields.IntegerField', [], {'default': '1'}),
+            'report_comments': ('django.db.models.fields.TextField', [], {'default': "''"}),
+            'status': ('django.db.models.fields.CharField', [], {'default': "'cart'", 'max_length': '32'}),
+            'unit_cost': ('django.db.models.fields.DecimalField', [], {'default': '0.0', 'max_digits': '30', 'decimal_places': '2'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']"})
+        },
+        'shoppingcart.paidcourseregistration': {
+            'Meta': {'object_name': 'PaidCourseRegistration', '_ormbases': ['shoppingcart.OrderItem']},
+            'course_id': ('django.db.models.fields.CharField', [], {'max_length': '128', 'db_index': 'True'}),
+            'mode': ('django.db.models.fields.SlugField', [], {'default': "'honor'", 'max_length': '50'}),
+            'orderitem_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['shoppingcart.OrderItem']", 'unique': 'True', 'primary_key': 'True'})
+        },
+        'shoppingcart.paidcourseregistrationannotation': {
+            'Meta': {'object_name': 'PaidCourseRegistrationAnnotation'},
+            'annotation': ('django.db.models.fields.TextField', [], {'null': 'True'}),
+            'course_id': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '128', 'db_index': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
+        },
+        'student.courseenrollment': {
+            'Meta': {'ordering': "('user', 'course_id')", 'unique_together': "(('user', 'course_id'),)", 'object_name': 'CourseEnrollment'},
+            'course_id': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'}),
+            'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'null': 'True', 'db_index': 'True', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'mode': ('django.db.models.fields.CharField', [], {'default': "'honor'", 'max_length': '100'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']"})
+        }
+    }
+
+    complete_apps = ['shoppingcart']
\ No newline at end of file

lms/djangoapps/shoppingcart/models.py

@@ -2,6 +2,7 @@ from datetime import datetime
 import pytz
 import logging
 import smtplib
+import unicodecsv
 
 from model_utils.managers import InheritanceManager
 from collections import namedtuple
@@ -209,6 +210,8 @@ class OrderItem(models.Model):
     currency = models.CharField(default="usd", max_length=8)  # lower case ISO currency codes
     fulfilled_time = models.DateTimeField(null=True)
     refund_requested_time = models.DateTimeField(null=True)
+    # general purpose field, not user-visible.  Used for reporting
+    report_comments = models.TextField(default="")
 
     @property
     def line_cost(self):
@@ -256,6 +259,66 @@ class OrderItem(models.Model):
         """
         return self.pk_with_subclass, set([])
 
+    @classmethod
+    def purchased_items_btw_dates(cls, start_date, end_date):
+        """
+        Returns a QuerySet of the purchased items between start_date and end_date inclusive.
+        """
+        return cls.objects.filter(
+            status="purchased",
+            fulfilled_time__gte=start_date,
+            fulfilled_time__lt=end_date,
+        )
+
+    @classmethod
+    def csv_purchase_report_btw_dates(cls, filelike, start_date, end_date):
+        """
+        Outputs a CSV report into "filelike" (a file-like python object, such as an actual file, an HttpRequest,
+        or sys.stdout) of purchased items between start_date and end_date inclusive.
+        Opening and closing filelike (if applicable) should be taken care of by the caller
+        """
+        items = cls.purchased_items_btw_dates(start_date, end_date).order_by("fulfilled_time")
+
+        writer = unicodecsv.writer(filelike, encoding="utf-8")
+        writer.writerow(OrderItem.csv_report_header_row())
+
+        for item in items:
+            writer.writerow(item.csv_report_row)
+
+    @classmethod
+    def csv_report_header_row(cls):
+        """
+        Returns the "header" row for a csv report of purchases
+        """
+        return [
+            "Purchase Time",
+            "Order ID",
+            "Status",
+            "Quantity",
+            "Unit Cost",
+            "Total Cost",
+            "Currency",
+            "Description",
+            "Comments"
+        ]
+
+    @property
+    def csv_report_row(self):
+        """
+        Returns an array which can be fed into csv.writer to write out one csv row
+        """
+        return [
+            self.fulfilled_time,
+            self.order_id,  # pylint: disable=no-member
+            self.status,
+            self.qty,
+            self.unit_cost,
+            self.line_cost,
+            self.currency,
+            self.line_desc,
+            self.report_comments,
+        ]
+
     @property
     def pk_with_subclass(self):
         """
@@ -347,13 +410,13 @@ class PaidCourseRegistration(OrderItem):
 
         item, created = cls.objects.get_or_create(order=order, user=order.user, course_id=course_id)
         item.status = order.status
-
         item.mode = course_mode.slug
         item.qty = 1
         item.unit_cost = cost
         item.line_desc = 'Registration for Course: {0}'.format(course.display_name_with_default)
         item.currency = currency
         order.currency = currency
+        item.report_comments = item.csv_report_comments
         order.save()
         item.save()
         log.info("User {} added course registration {} to cart: order {}"
@@ -393,6 +456,31 @@ class PaidCourseRegistration(OrderItem):
 
         return self.pk_with_subclass, set([notification])
 
+    @property
+    def csv_report_comments(self):
+        """
+        Tries to fetch an annotation associated with the course_id from the database.  If not found, returns u"".
+        Otherwise returns the annotation
+        """
+        try:
+            return PaidCourseRegistrationAnnotation.objects.get(course_id=self.course_id).annotation
+        except PaidCourseRegistrationAnnotation.DoesNotExist:
+            return u""
+
+
+class PaidCourseRegistrationAnnotation(models.Model):
+    """
+    A model that maps course_id to an additional annotation.  This is specifically needed because when Stanford
+    generates report for the paid courses, each report item must contain the payment account associated with a course.
+    And unfortunately we didn't have the concept of a "SKU" or stock item where we could keep this association,
+    so this is to retrofit it.
+    """
+    course_id = models.CharField(unique=True, max_length=128, db_index=True)
+    annotation = models.TextField(null=True)
+
+    def __unicode__(self):
+        return u"{} : {}".format(self.course_id, self.annotation)
+
 
 class CertificateItem(OrderItem):
     """

lms/djangoapps/shoppingcart/tests/test_models.py

@@ -2,6 +2,8 @@
 Tests for the Shopping Cart Models
 """
 import smtplib
+import StringIO
+from textwrap import dedent
 from boto.exception import BotoServerError  # this is a super-class of SESError and catches connection errors
 
 from mock import patch, MagicMock
@@ -15,7 +17,7 @@ from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory
 from courseware.tests.tests import TEST_DATA_MONGO_MODULESTORE
 from shoppingcart.models import (Order, OrderItem, CertificateItem, InvalidCartItem, PaidCourseRegistration,
-                                 OrderItemSubclassPK)
+                                 OrderItemSubclassPK, PaidCourseRegistrationAnnotation)
 from student.tests.factories import UserFactory
 from student.models import CourseEnrollment
 from course_modes.models import CourseMode
@@ -322,6 +324,87 @@ class PaidCourseRegistrationTest(ModuleStoreTestCase):
 
 
 @override_settings(MODULESTORE=TEST_DATA_MONGO_MODULESTORE)
+class PurchaseReportTest(ModuleStoreTestCase):
+
+    FIVE_MINS = datetime.timedelta(minutes=5)
+    TEST_ANNOTATION = u'Ba\xfc\u5305'
+
+    def setUp(self):
+        self.user = UserFactory.create()
+        self.course_id = "MITx/999/Robot_Super_Course"
+        self.cost = 40
+        self.course = CourseFactory.create(org='MITx', number='999', display_name=u'Robot Super Course')
+        course_mode = CourseMode(course_id=self.course_id,
+                                 mode_slug="honor",
+                                 mode_display_name="honor cert",
+                                 min_price=self.cost)
+        course_mode.save()
+        course_mode2 = CourseMode(course_id=self.course_id,
+                                  mode_slug="verified",
+                                  mode_display_name="verified cert",
+                                  min_price=self.cost)
+        course_mode2.save()
+        self.annotation = PaidCourseRegistrationAnnotation(course_id=self.course_id, annotation=self.TEST_ANNOTATION)
+        self.annotation.save()
+        self.cart = Order.get_cart_for_user(self.user)
+        self.reg = PaidCourseRegistration.add_to_order(self.cart, self.course_id)
+        self.cert_item = CertificateItem.add_to_order(self.cart, self.course_id, self.cost, 'verified')
+        self.cart.purchase()
+        self.now = datetime.datetime.now(pytz.UTC)
+
+    def test_purchased_items_btw_dates(self):
+        purchases = OrderItem.purchased_items_btw_dates(self.now - self.FIVE_MINS, self.now + self.FIVE_MINS)
+        self.assertEqual(len(purchases), 2)
+        self.assertIn(self.reg.orderitem_ptr, purchases)
+        self.assertIn(self.cert_item.orderitem_ptr, purchases)
+        no_purchases = OrderItem.purchased_items_btw_dates(self.now + self.FIVE_MINS,
+                                                           self.now + self.FIVE_MINS + self.FIVE_MINS)
+        self.assertFalse(no_purchases)
+
+    test_time = datetime.datetime.now(pytz.UTC)
+
+    CORRECT_CSV = dedent("""
+        Purchase Time,Order ID,Status,Quantity,Unit Cost,Total Cost,Currency,Description,Comments
+        {time_str},1,purchased,1,40,40,usd,Registration for Course: Robot Super Course,Ba\xc3\xbc\xe5\x8c\x85
+        {time_str},1,purchased,1,40,40,usd,"Certificate of Achievement, verified cert for course Robot Super Course",
+        """.format(time_str=str(test_time)))
+
+    def test_purchased_csv(self):
+        """
+        Tests that a generated purchase report CSV is as we expect
+        """
+        # coerce the purchase times to self.test_time so that the test can match.
+        # It's pretty hard to patch datetime.datetime b/c it's a python built-in, which is immutable, so we
+        # make the times match this way
+        for item in OrderItem.purchased_items_btw_dates(self.now - self.FIVE_MINS, self.now + self.FIVE_MINS):
+            item.fulfilled_time = self.test_time
+            item.save()
+
+        # add annotation to the
+        csv_file = StringIO.StringIO()
+        OrderItem.csv_purchase_report_btw_dates(csv_file, self.now - self.FIVE_MINS, self.now + self.FIVE_MINS)
+        csv = csv_file.getvalue()
+        csv_file.close()
+        # Using excel mode csv, which automatically ends lines with \r\n, so need to convert to \n
+        self.assertEqual(csv.replace('\r\n', '\n').strip(), self.CORRECT_CSV.strip())
+
+    def test_csv_report_no_annotation(self):
+        """
+        Fill in gap in test coverage.  csv_report_comments for PaidCourseRegistration instance with no
+        matching annotation
+        """
+        # delete the matching annotation
+        self.annotation.delete()
+        self.assertEqual(u"", self.reg.csv_report_comments)
+
+    def test_paidcourseregistrationannotation_unicode(self):
+        """
+        Fill in gap in test coverage.  __unicode__ method of PaidCourseRegistrationAnnotation
+        """
+        self.assertEqual(unicode(self.annotation), u'{} : {}'.format(self.course_id, self.TEST_ANNOTATION))
+
+
+@override_settings(MODULESTORE=TEST_DATA_MONGO_MODULESTORE)
 class CertificateItemTest(ModuleStoreTestCase):
     """
     Tests for verifying specific CertificateItem functionality

lms/djangoapps/shoppingcart/tests/test_views.py

@@ -3,23 +3,23 @@ Tests for Shopping Cart views
 """
 from urlparse import urlparse
 
+from django.conf import settings
 from django.test import TestCase
 from django.test.utils import override_settings
 from django.core.urlresolvers import reverse
 from django.utils.translation import ugettext as _
+from django.contrib.auth.models import Group
 
 from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory
-from xmodule.modulestore.exceptions import ItemNotFoundError
 from courseware.tests.tests import TEST_DATA_MONGO_MODULESTORE
-from shoppingcart.views import add_course_to_cart
-from shoppingcart.models import Order, OrderItem, CertificateItem, InvalidCartItem, PaidCourseRegistration
+from shoppingcart.views import _can_download_report, _get_date_from_str
+from shoppingcart.models import Order, CertificateItem, PaidCourseRegistration, OrderItem
 from student.tests.factories import UserFactory
 from student.models import CourseEnrollment
 from course_modes.models import CourseMode
-from ..exceptions import PurchasedCallbackException
 from mitxmako.shortcuts import render_to_response
-from shoppingcart.processors import render_purchase_form_html, process_postpay_callback
+from shoppingcart.processors import render_purchase_form_html
 from mock import patch, Mock
 
 
@@ -232,3 +232,143 @@ class ShoppingCartViewsTests(ModuleStoreTestCase):
         self.assertEqual(resp.status_code, 200)
         ((template, _context), _tmp) = render_mock.call_args
         self.assertEqual(template, cert_item.single_item_receipt_template)
+
+
+@override_settings(MODULESTORE=TEST_DATA_MONGO_MODULESTORE)
+class CSVReportViewsTest(ModuleStoreTestCase):
+    """
+    Test suite for CSV Purchase Reporting
+    """
+    def setUp(self):
+        self.user = UserFactory.create()
+        self.user.set_password('password')
+        self.user.save()
+        self.course_id = "MITx/999/Robot_Super_Course"
+        self.cost = 40
+        self.course = CourseFactory.create(org='MITx', number='999', display_name='Robot Super Course')
+        self.course_mode = CourseMode(course_id=self.course_id,
+                                      mode_slug="honor",
+                                      mode_display_name="honor cert",
+                                      min_price=self.cost)
+        self.course_mode.save()
+        self.verified_course_id = 'org/test/Test_Course'
+        CourseFactory.create(org='org', number='test', run='course1', display_name='Test Course')
+        self.cart = Order.get_cart_for_user(self.user)
+        self.dl_grp = Group(name=settings.PAYMENT_REPORT_GENERATOR_GROUP)
+        self.dl_grp.save()
+
+    def login_user(self):
+        """
+        Helper fn to login self.user
+        """
+        self.client.login(username=self.user.username, password="password")
+
+    def add_to_download_group(self, user):
+        """
+        Helper fn to add self.user to group that's allowed to download report CSV
+        """
+        user.groups.add(self.dl_grp)
+
+    def test_report_csv_no_access(self):
+        self.login_user()
+        response = self.client.get(reverse('payment_csv_report'))
+        self.assertEqual(response.status_code, 403)
+
+    def test_report_csv_bad_method(self):
+        self.login_user()
+        self.add_to_download_group(self.user)
+        response = self.client.put(reverse('payment_csv_report'))
+        self.assertEqual(response.status_code, 400)
+
+    @patch('shoppingcart.views.render_to_response', render_mock)
+    def test_report_csv_get(self):
+        self.login_user()
+        self.add_to_download_group(self.user)
+        response = self.client.get(reverse('payment_csv_report'))
+
+        ((template, context), unused_kwargs) = render_mock.call_args
+        self.assertEqual(template, 'shoppingcart/download_report.html')
+        self.assertFalse(context['total_count_error'])
+        self.assertFalse(context['date_fmt_error'])
+        self.assertIn(_("Download Purchase Report"), response.content)
+
+    @patch('shoppingcart.views.render_to_response', render_mock)
+    def test_report_csv_bad_date(self):
+        self.login_user()
+        self.add_to_download_group(self.user)
+        response = self.client.post(reverse('payment_csv_report'), {'start_date': 'BAD', 'end_date': 'BAD'})
+
+        ((template, context), unused_kwargs) = render_mock.call_args
+        self.assertEqual(template, 'shoppingcart/download_report.html')
+        self.assertFalse(context['total_count_error'])
+        self.assertTrue(context['date_fmt_error'])
+        self.assertIn(_("There was an error in your date input.  It should be formatted as YYYY-MM-DD"),
+                      response.content)
+
+    @patch('shoppingcart.views.render_to_response', render_mock)
+    @override_settings(PAYMENT_REPORT_MAX_ITEMS=0)
+    def test_report_csv_too_long(self):
+        PaidCourseRegistration.add_to_order(self.cart, self.course_id)
+        self.cart.purchase()
+        self.login_user()
+        self.add_to_download_group(self.user)
+        response = self.client.post(reverse('payment_csv_report'), {'start_date': '1970-01-01',
+                                                                    'end_date': '2100-01-01'})
+
+        ((template, context), unused_kwargs) = render_mock.call_args
+        self.assertEqual(template, 'shoppingcart/download_report.html')
+        self.assertTrue(context['total_count_error'])
+        self.assertFalse(context['date_fmt_error'])
+        self.assertIn(_("There are too many results in your report.") + " (>0)", response.content)
+
+    # just going to ignored the date in this test, since we already deal with date testing
+    # in test_models.py
+    CORRECT_CSV_NO_DATE = ",1,purchased,1,40,40,usd,Registration for Course: Robot Super Course,"
+
+    def test_report_csv(self):
+        PaidCourseRegistration.add_to_order(self.cart, self.course_id)
+        self.cart.purchase()
+        self.login_user()
+        self.add_to_download_group(self.user)
+        response = self.client.post(reverse('payment_csv_report'), {'start_date': '1970-01-01',
+                                                                    'end_date': '2100-01-01'})
+        self.assertEqual(response['Content-Type'], 'text/csv')
+        self.assertIn(",".join(OrderItem.csv_report_header_row()), response.content)
+        self.assertIn(self.CORRECT_CSV_NO_DATE, response.content)
+
+
+class UtilFnsTest(TestCase):
+    """
+    Tests for utility functions in views.py
+    """
+    def setUp(self):
+        self.user = UserFactory.create()
+
+    def test_can_download_report_no_group(self):
+        """
+        Group controlling perms is not present
+        """
+        self.assertFalse(_can_download_report(self.user))
+
+    def test_can_download_report_not_member(self):
+        """
+        User is not part of group controlling perms
+        """
+        Group(name=settings.PAYMENT_REPORT_GENERATOR_GROUP).save()
+        self.assertFalse(_can_download_report(self.user))
+
+    def test_can_download_report(self):
+        """
+        User is part of group controlling perms
+        """
+        grp = Group(name=settings.PAYMENT_REPORT_GENERATOR_GROUP)
+        grp.save()
+        self.user.groups.add(grp)
+        self.assertTrue(_can_download_report(self.user))
+
+    def test_get_date_from_str(self):
+        test_str = "2013-10-01"
+        date = _get_date_from_str(test_str)
+        self.assertEqual(2013, date.year)
+        self.assertEqual(10, date.month)
+        self.assertEqual(1, date.day)

lms/djangoapps/shoppingcart/urls.py

@@ -12,6 +12,7 @@ if settings.MITX_FEATURES['ENABLE_SHOPPING_CART']:
         url(r'^clear/$', 'clear_cart'),
         url(r'^remove_item/$', 'remove_item'),
         url(r'^add/course/(?P<course_id>[^/]+/[^/]+/[^/]+)/$', 'add_course_to_cart', name='add_course_to_cart'),
+        url(r'^csv_report/$', 'csv_report', name='payment_csv_report'),
     )
 
 if settings.MITX_FEATURES.get('ENABLE_PAYMENT_FAKE'):

lms/djangoapps/shoppingcart/views.py

 import logging
+import datetime
+import pytz
+from django.conf import settings
+from django.contrib.auth.models import Group
 from django.http import (HttpResponse, HttpResponseRedirect, HttpResponseNotFound,
     HttpResponseBadRequest, HttpResponseForbidden, Http404)
 from django.utils.translation import ugettext as _
@@ -121,3 +125,73 @@ def show_receipt(request, ordernum):
         context.update(order_items[0].single_item_receipt_context)
 
     return render_to_response(receipt_template, context)
+
+
+def _can_download_report(user):
+    """
+    Tests if the user can download the payments report, based on membership in a group whose name is determined
+     in settings.  If the group does not exist, denies all access
+    """
+    try:
+        access_group = Group.objects.get(name=settings.PAYMENT_REPORT_GENERATOR_GROUP)
+    except Group.DoesNotExist:
+        return False
+    return access_group in user.groups.all()
+
+
+def _get_date_from_str(date_input):
+    """
+    Gets date from the date input string.  Lets the ValueError raised by invalid strings be processed by the caller
+    """
+    return datetime.datetime.strptime(date_input.strip(), "%Y-%m-%d").replace(tzinfo=pytz.UTC)
+
+
+def _render_report_form(start_str, end_str, total_count_error=False, date_fmt_error=False):
+    """
+    Helper function that renders the purchase form.  Reduces repetition
+    """
+    context = {
+        'total_count_error': total_count_error,
+        'date_fmt_error': date_fmt_error,
+        'start_date': start_str,
+        'end_date': end_str,
+    }
+    return render_to_response('shoppingcart/download_report.html', context)
+
+
+@login_required
+def csv_report(request):
+    """
+    Downloads csv reporting of orderitems
+    """
+    if not _can_download_report(request.user):
+        return HttpResponseForbidden(_('You do not have permission to view this page.'))
+
+    if request.method == 'POST':
+        start_str = request.POST.get('start_date', '')
+        end_str = request.POST.get('end_date', '')
+        try:
+            start_date = _get_date_from_str(start_str)
+            end_date = _get_date_from_str(end_str) + datetime.timedelta(days=1)
+        except ValueError:
+            # Error case: there was a badly formatted user-input date string
+            return _render_report_form(start_str, end_str, date_fmt_error=True)
+
+        items = OrderItem.purchased_items_btw_dates(start_date, end_date)
+        if items.count() > settings.PAYMENT_REPORT_MAX_ITEMS:
+            # Error case: too many items would be generated in the report and we're at risk of timeout
+            return _render_report_form(start_str, end_str, total_count_error=True)
+
+        response = HttpResponse(mimetype='text/csv')
+        filename = "purchases_report_{}.csv".format(datetime.datetime.now(pytz.UTC).strftime("%Y-%m-%d-%H-%M-%S"))
+        response['Content-Disposition'] = 'attachment; filename="{}"'.format(filename)
+        OrderItem.csv_purchase_report_btw_dates(response, start_date, end_date)
+        return response
+
+    elif request.method == 'GET':
+        end_date = datetime.datetime.now(pytz.UTC)
+        start_date = end_date - datetime.timedelta(days=30)
+        return _render_report_form(start_date.strftime("%Y-%m-%d"), end_date.strftime("%Y-%m-%d"))
+
+    else:
+        return HttpResponseBadRequest("HTTP Method Not Supported")

lms/envs/aws.py

@@ -166,6 +166,10 @@ PAYMENT_SUPPORT_EMAIL = ENV_TOKENS.get('PAYMENT_SUPPORT_EMAIL', PAYMENT_SUPPORT_
 PAID_COURSE_REGISTRATION_CURRENCY = ENV_TOKENS.get('PAID_COURSE_REGISTRATION_CURRENCY',
                                                    PAID_COURSE_REGISTRATION_CURRENCY)
 
+# Payment Report Settings
+PAYMENT_REPORT_GENERATOR_GROUP = ENV_TOKENS.get('PAYMENT_REPORT_GENERATOR_GROUP', PAYMENT_REPORT_GENERATOR_GROUP)
+PAYMENT_REPORT_MAX_ITEMS = ENV_TOKENS.get('PAYMENT_REPORT_MAX_ITEMS', PAYMENT_REPORT_MAX_ITEMS)
+
 # Bulk Email overrides
 BULK_EMAIL_DEFAULT_FROM_EMAIL = ENV_TOKENS.get('BULK_EMAIL_DEFAULT_FROM_EMAIL', BULK_EMAIL_DEFAULT_FROM_EMAIL)
 BULK_EMAIL_EMAILS_PER_TASK = ENV_TOKENS.get('BULK_EMAIL_EMAILS_PER_TASK', BULK_EMAIL_EMAILS_PER_TASK)
@@ -286,12 +290,6 @@ OPEN_ENDED_GRADING_INTERFACE = AUTH_TOKENS.get('OPEN_ENDED_GRADING_INTERFACE',
 EMAIL_HOST_USER = AUTH_TOKENS.get('EMAIL_HOST_USER', '')  # django default is ''
 EMAIL_HOST_PASSWORD = AUTH_TOKENS.get('EMAIL_HOST_PASSWORD', '')  # django default is ''
 
-PEARSON_TEST_USER = "pearsontest"
-PEARSON_TEST_PASSWORD = AUTH_TOKENS.get("PEARSON_TEST_PASSWORD")
-
-# Pearson hash for import/export
-PEARSON = AUTH_TOKENS.get("PEARSON")
-
 # Datadog for events!
 DATADOG = AUTH_TOKENS.get("DATADOG", {})
 DATADOG.update(ENV_TOKENS.get("DATADOG", {}))

lms/envs/common.py

@@ -523,11 +523,6 @@ WIKI_USE_BOOTSTRAP_SELECT_WIDGET = False
 WIKI_LINK_LIVE_LOOKUPS = False
 WIKI_LINK_DEFAULT_LEVEL = 2
 
-################################# Pearson TestCenter config  ################
-
-PEARSONVUE_SIGNINPAGE_URL = "https://www1.pearsonvue.com/testtaker/signin/SignInPage/EDX"
-# TESTCENTER_ACCOMMODATION_REQUEST_EMAIL = "exam-help@example.com"
-
 ##### Feedback submission mechanism #####
 FEEDBACK_SUBMISSION_EMAIL = None
 
@@ -550,6 +545,12 @@ CC_PROCESSOR = {
 }
 # Setting for PAID_COURSE_REGISTRATION, DOES NOT AFFECT VERIFIED STUDENTS
 PAID_COURSE_REGISTRATION_CURRENCY = ['usd', '$']
+
+# Members of this group are allowed to generate payment reports
+PAYMENT_REPORT_GENERATOR_GROUP = 'shoppingcart_report_access'
+# Maximum number of rows the report can contain
+PAYMENT_REPORT_MAX_ITEMS = 10000
+
 ################################# open ended grading config  #####################
 
 #By setting up the default settings with an incorrect user name and password,
@@ -909,6 +910,8 @@ BULK_EMAIL_LOG_SENT_EMAILS = False
 # parallel, and what the SES rate is.
 BULK_EMAIL_RETRY_DELAY_BETWEEN_SENDS = 0.02
 
+
+
 ################################### APPS ######################################
 INSTALLED_APPS = (
     # Standard ones that are always installed...

lms/envs/dev.py

@@ -254,9 +254,6 @@ MITX_FEATURES['RESTRICT_ENROLL_BY_REG_METHOD'] = True
 
 PIPELINE_SASS_ARGUMENTS = '--debug-info --require {proj_dir}/static/sass/bourbon/lib/bourbon.rb'.format(proj_dir=PROJECT_ROOT)
 
-########################## PEARSON TESTING ###########################
-MITX_FEATURES['ENABLE_PEARSON_LOGIN'] = False
-
 ########################## ANALYTICS TESTING ########################
 
 ANALYTICS_SERVER_URL = "http://127.0.0.1:9000/"

lms/static/js/toggle_login_modal.js

 (function($){
   $.fn.extend({
+    /*
+     * leanModal prepares an element to be a modal dialog.  Call it once on the
+     * element that launches the dialog, when the page is ready.  This function
+     * will add a .click() handler that properly opens the dialog.
+     *
+     * The launching element must:
+     *   - be an <a> element, not a button,
+     *   - have an href= attribute identifying the id of the dialog element,
+     *   - have rel='leanModal'.
+     */
     leanModal: function(options) {
       var defaults = {
         top: 100,
@@ -13,7 +23,7 @@
         $("body").append(overlay);
       }
 
-      options =  $.extend(defaults, options);
+      options = $.extend(defaults, options);
 
       return this.each(function() {
         var o = options;
@@ -23,7 +33,7 @@
           $(".modal").hide();
 
           var modal_id = $(this).attr("href");
-          
+
           if ($(modal_id).hasClass("video-modal")) {
             //Video modals need to be cloned before being presented as a modal
             //This is because actions on the video get recorded in the history.
@@ -34,13 +44,12 @@
             modal_id = '#modal_clone';
           }
 
-
-          $("#lean_overlay").click(function() {
-             close_modal(modal_id);
+          $("#lean_overlay").click(function(e) {
+            close_modal(modal_id, e);
           });
 
-          $(o.closeButton).click(function() {
-             close_modal(modal_id);
+          $(o.closeButton).click(function(e) {
+            close_modal(modal_id, e);
           });
 
           var modal_height = $(modal_id).outerHeight();
@@ -72,34 +81,30 @@
           }
           window.scrollTo(0, 0);
           e.preventDefault();
-
         });
       });
 
-      function close_modal(modal_id){
+      function close_modal(modal_id, e) {
         $("#lean_overlay").fadeOut(200);
         $('iframe', modal_id).attr('src', '');
         $(modal_id).css({ 'display' : 'none' });
         if (modal_id == '#modal_clone') {
           $(modal_id).remove();
         }
+        e.preventDefault();
       }
     }
   });
 
-  $(document).ready(function($) {
-      $("a[rel*=leanModal]").each(function(){
-        $(this).leanModal({ top : 120, overlay: 1, closeButton: ".close-modal", position: 'absolute' });
-        embed = $($(this).attr('href')).find('iframe')
-        if(embed.length > 0) {
-          if(embed.attr('src').indexOf("?") > 0) {
-              embed.data('src', embed.attr('src') + '&autoplay=1&rel=0');
-              embed.attr('src', '');
-          } else {
-              embed.data('src', embed.attr('src') + '?autoplay=1&rel=0');
-              embed.attr('src', '');
-          }
-        }
-      });
+  $(document).ready(function ($) {
+    $("a[rel*=leanModal]").each(function () {
+      $(this).leanModal({ top : 120, overlay: 1, closeButton: ".close-modal", position: 'absolute' });
+      embed = $($(this).attr('href')).find('iframe')
+      if (embed.length > 0 && embed.attr('src')) {
+        var sep = (embed.attr('src').indexOf("?") > 0) ? '&' : '?';
+        embed.data('src', embed.attr('src') + sep + 'autoplay=1&rel=0');
+        embed.attr('src', '');
+      }
+    });
   });
 })(jQuery);

lms/static/js/wiki/cheatsheet.js

-$(document).ready(function () {
-    $('#cheatsheetLink').click(function() {
-        $('#cheatsheetModal').leanModal();
-    });
-    accessible_modal("#cheatsheetLink", "#cheatsheetModal .close-modal", "#cheatsheetModal", ".content-wrapper");
-});

lms/static/sass/application-extend1.scss.mako

@@ -46,7 +46,6 @@
 @import 'multicourse/home';
 @import 'multicourse/dashboard';
 @import 'multicourse/account';
-@import 'multicourse/testcenter-register';
 @import 'multicourse/courses';
 @import 'multicourse/course_about';
 @import 'multicourse/jobs';

lms/static/sass/course/wiki/_wiki.scss

@@ -536,8 +536,12 @@ section.wiki {
     }
 
     .modal-header {
+      border: 1px solid $danger-red;
+      padding: ($baseline/2) ($baseline/2) 0 ($baseline/2);
+      margin-bottom: ($baseline/2);
+
       h1, p {
-        color: #fff;
+        color: $base-font-color;
       }
 
       h1 {

lms/static/sass/multicourse/_dashboard.scss

@@ -523,7 +523,7 @@
       .message-copy,
       .message-copy .copy {
         @extend %t-copy-sub1;
-        margin: 0;
+        margin: 2px 0 0 0;
       }
 
       // CASE: expandable
@@ -532,15 +532,18 @@
         .wrapper-tip {
 
           .message-title, .message-copy {
-            @include transition(color 0.25s ease-in-out 0);
             margin-bottom: 0;
           }
 
+          .message-title .value, .message-copy {
+            @include transition(color 0.25s ease-in-out 0s);
+          }
+
           // STATE: hover
           &:hover {
             cursor: pointer;
 
-            .message-title, .message-copy {
+            .message-title .value, .message-copy, .ui-toggle-expansion {
               color: $link-color;
             }
           }
@@ -555,6 +558,11 @@
         // STATE: is expanded
         &.is-expanded {
 
+          .ui-toggle-expansion {
+            @include transform(rotate(0));
+            @include transform-origin(50% 50%);
+          }
+
           .wrapper-extended {
             display: block;
             opacity: 1.0;
@@ -573,6 +581,16 @@
           float: left;
         }
 
+        .ui-toggle-expansion {
+          @include transition(all 0.25s ease-in-out 0s);
+          @include transform(rotate(-90deg));
+          @include transform-origin(50% 50%);
+          @include font-size(21);
+          display: inline-block;
+          vertical-align: middle;
+          margin-right: ($baseline/4);
+        }
+
         .message-copy {
           float: right;
         }

lms/static/sass/shared/_modal.scss

@@ -59,7 +59,7 @@
     overflow: hidden;
     padding-left: 10px;
     padding-right: 10px;
-    padding-bottom: 30px;
+    padding-bottom: 10px;
     position: relative;
     z-index: 2;
 
@@ -136,7 +136,7 @@
 
     form {
       margin-bottom: 12px;
-      padding: 0px 40px;
+      padding: 0px 40px 20px;
       position: relative;
       z-index: 2;
 

lms/static/sass/views/_shoppingcart.scss

@@ -5,6 +5,14 @@
   padding: 30px 30px 0 30px;
 }
 
+.error_msg {
+  margin: 20px;
+  padding: 5px;
+  color: $red;
+  border: 1px solid $red;
+
+}
+
 .cart-list {
   padding: 30px;
   margin-top: 40px;

lms/templates/courseware/course_navigation.html

@@ -25,7 +25,7 @@ def url_class(is_active):
           <li>
         % endif
              <a href="${tab.link | h}" class="${url_class(tab.is_active)}">
-                 ${tab.name | h}
+                 ${_(tab.name) | h}
                  % if tab.is_active == True:
                    <span class="sr">, current location</span>
                  %endif

lms/templates/dashboard/_dashboard_course_listing.html

@@ -65,7 +65,10 @@
         <div class="message message-upsell has-actions is-expandable is-shown">
 
             <div class="wrapper-tip">
-              <h4 class="message-title">${_("Challenge Yourself!")}</h4>
+              <h4 class="message-title">
+                <i class="icon-caret-down ui-toggle-expansion"></i>
+                <span class="value">${_("Challenge Yourself!")}</span>
+              </h4>
               <p class="message-copy">${_("Take this course as an ID-verified student.")}</p>
             </div>
 

lms/templates/shoppingcart/download_report.html

+<%! from django.utils.translation import ugettext as _ %>
+<%! from django.core.urlresolvers import reverse %>
+<%inherit file="../main.html" />
+
+<%block name="title"><title>${_("Download Purchase Report")}</title></%block>
+
+
+<section class="container">
+  <h2>${_("Download CSV of purchase data")}</h2>
+  % if date_fmt_error:
+    <section class="error_msg">
+      ${_("There was an error in your date input.  It should be formatted as YYYY-MM-DD")}
+    </section>
+  % endif
+  % if total_count_error:
+    <section class="error_msg">
+      ${_("There are too many results in your report.")} (>${settings.PAYMENT_REPORT_MAX_ITEMS}).
+      ${_("Try making the date range smaller.")}
+    </section>
+  % endif
+  <form method="post">
+    <label for="start_date">${_("Start Date: ")}</label>
+    <input id="start_date" type="text" value="${start_date}" name="start_date"/>
+    <label for="end_date">${_("End Date: ")}</label>
+    <input id="end_date" type="text" value="${end_date}" name="end_date"/>
+    <input type="hidden" name="csrfmiddlewaretoken" value="${csrf_token}" />
+    <input type="submit" />
+  </form>
+</section>

lms/templates/wiki/edit.html

 {% extends "wiki/article.html" %}
-{% load wiki_tags i18n %}
+{% load wiki_tags i18n sekizai_tags %}
 {% load url from future %}
 
 {% block pagetitle %}{% trans "Edit" %}: {{ article.current_revision.title }}{% endblock %}
 
 {% block wiki_contents_tab %}
 
-<form method="POST" class="form-horizontal" id="article_edit_form" enctype="multipart/form-data">
+{% addtoblock "js" %}
+<script type="text/javascript">
+  $(document).ready(
+    function ($) {
+      accessible_modal("#cheatsheetLink", "#cheatsheetModal .close-modal", "#cheatsheetModal", ".content-wrapper");
+      accessible_modal("#previewButton", "#previewModal .close-modal", "#previewModal", ".content-wrapper");
+      $("#previewModalBackToEditor").click(function (e) {
+        $("#previewModal .close-modal").click();
+        e.preventDefault();
+      });
+    }
+  );
+</script>
+{% endaddtoblock %}
+
+<form method="POST" class="form-horizontal" id="article_edit_form" name="article_edit_form" enctype="multipart/form-data">
   {% include "wiki/includes/editor.html" %}
   <div class="form-actions">
       <button type="submit" name="save" value="1" class="btn btn-large btn-primary" onclick="this.form.target=''; this.form.action='{% url 'wiki:edit' path=urlpath.path article_id=article.id %}'">
         <span class="icon-ok"></span>
         {% trans "Save changes" %}
       </button>
-      <button type="submit" name="preview" value="1" class="btn btn-large" onclick="$('#previewModal').modal('show'); this.form.target = 'previewWindow'; this.form.action = '{% url 'wiki:preview' path=urlpath.path article_id=article.id %}';">
+      <a class="btn btn-large" id="previewButton" href="#previewModal" rel="leanModal"
+        onclick="
+          document.article_edit_form.target='previewWindow';
+          document.article_edit_form.action='{% url 'wiki:preview' path=urlpath.path article_id=article.id %}';
+          document.article_edit_form.submit();">
         <span class="icon-eye-open"></span>
         {% trans "Preview" %}
-      </button>
-      
+      </a>
+
       <a href="{% url 'wiki:delete' path=urlpath.path article_id=article.id %}" class="pull-right btn btn-danger">
         <span class="icon-trash"></span>
         {% trans "Delete article" %}
       </a>
-      
+
   </div>
-  <div class="modal hide fade" id="previewModal">
+  <section id="previewModal" class="modal" aria-hidden="true">
+    <div class="inner-wrapper" role="dialog" aria-labelledby="preview-title">
+      <button class="close-modal">&#10005; <span class="sr">{% trans 'Close Modal' %}</span></button>
+
+      <header>
+        <h2 id="preview-title">{% trans "Wiki Preview" %}<span class="sr">, {% trans "modal open" %}</span></h2>
+        <hr/>
+      </header>
+
     <div class="modal-body">
       <iframe name="previewWindow" frameborder="0"></iframe>
     </div>
@@ -34,16 +61,13 @@
         {% trans "Save changes" %}
       </button>
 
-      <a href="#" class="btn btn-large" data-dismiss="modal">
+      <a id="previewModalBackToEditor" href="#" class="btn btn-large">
         <span class="icon-circle-arrow-left"></span>
         {% trans "Back to editor" %}
       </a>
     </div>
-  </div>
+  </section>
   {% include "wiki/includes/cheatsheet.html" %}
 </form>
 
 {% endblock %}
-
-
-

lms/templates/wiki/includes/cheatsheet.html

@@ -59,7 +59,7 @@
 1. {% trans "Ordered" %}
 2. {% trans "List" %}</pre>
               <pre>
-> {% trans "Quotes" %}</pre>
+&gt; {% trans "Quotes" %}</pre>
           </section>
       </div>
 

lms/urls.py

@@ -41,9 +41,6 @@ urlpatterns = ('',  # nopep8
     url(r'^create_account$', 'student.views.create_account', name='create_account'),
     url(r'^activate/(?P<key>[^/]*)$', 'student.views.activate_account', name="activate"),
 
-    url(r'^begin_exam_registration/(?P<course_id>[^/]+/[^/]+/[^/]+)$', 'student.views.begin_exam_registration', name="begin_exam_registration"),
-    url(r'^create_exam_registration$', 'student.views.create_exam_registration'),
-
     url(r'^password_reset/$', 'student.views.password_reset', name='password_reset'),
     ## Obsolete Django views for password resets
     ## TODO: Replace with Mako-ized views
@@ -402,9 +399,6 @@ if settings.MITX_FEATURES.get('AUTH_USE_OPENID_PROVIDER'):
         url(r'^openid/provider/xrds/$', 'external_auth.views.provider_xrds', name='openid-provider-xrds')
     )
 
-if settings.MITX_FEATURES.get('ENABLE_PEARSON_LOGIN', False):
-    urlpatterns += url(r'^testcenter/login$', 'external_auth.views.test_center_login'),
-
 if settings.MITX_FEATURES.get('ENABLE_LMS_MIGRATION'):
     urlpatterns += (
         url(r'^migrate/modules$', 'lms_migration.migrate.manage_modulestores'),

requirements/edx/base.txt

@@ -70,6 +70,7 @@ South==0.7.6
 sympy==0.7.1
 xmltodict==0.4.1
 django-ratelimit-backend==0.6
+unicodecsv==0.9.4
 
 # Used for debugging
 ipython==0.13.1
@@ -89,7 +90,7 @@ Babel==1.3
 transifex-client==0.9.1
 
 # Used for testing
-coverage==3.6
+coverage==3.7
 ddt==0.4.0
 factory_boy==2.0.2
 mock==1.0.1