Merge branch 'master' into feature/jkarni/genex

.gitignore

@@ -27,4 +27,5 @@ lms/lib/comment_client/python
 nosetests.xml
 cover_html/
 .idea/
+.redcar/
 chromedriver.log
\ No newline at end of file

cms/djangoapps/contentstore/__init__.py

-from xmodule.templates import update_templates
 
-update_templates()

cms/djangoapps/contentstore/features/advanced-settings.feature

+Feature: Advanced (manual) course policy
+  In order to specify course policy settings for which no custom user interface exists
+  I want to be able to manually enter JSON key/value pairs
+
+  Scenario: A course author sees only display_name on a newly created course
+    Given I have opened a new course in Studio
+    When I select the Advanced Settings
+    Then I see only the display name
+
+  Scenario: Test if there are no policy settings without existing UI controls
+    Given I am on the Advanced Course Settings page in Studio
+    When I delete the display name
+    Then there are no advanced policy settings
+    And I reload the page
+    Then there are no advanced policy settings
+
+  Scenario: Test cancel editing key name
+    Given I am on the Advanced Course Settings page in Studio
+    When I edit the name of a policy key
+    And I press the "Cancel" notification button
+    Then the policy key name is unchanged
+
+  Scenario: Test editing key name
+    Given I am on the Advanced Course Settings page in Studio
+    When I edit the name of a policy key
+    And I press the "Save" notification button
+    Then the policy key name is changed
+
+  Scenario: Test cancel editing key value
+    Given I am on the Advanced Course Settings page in Studio
+    When I edit the value of a policy key
+    And I press the "Cancel" notification button
+    Then the policy key value is unchanged
+
+  Scenario: Test editing key value
+    Given I am on the Advanced Course Settings page in Studio
+    When I edit the value of a policy key
+    And I press the "Save" notification button
+    Then the policy key value is changed
+
+  Scenario: Add new entries, and they appear alphabetically after save
+    Given I am on the Advanced Course Settings page in Studio
+    When I create New Entries
+    Then they are alphabetized
+    And I reload the page
+    Then they are alphabetized
+
+  Scenario: Test how multi-line input appears
+    Given I am on the Advanced Course Settings page in Studio
+    When I create a JSON object
+    Then it is displayed as formatted

cms/djangoapps/contentstore/features/advanced-settings.py

+from lettuce import world, step
+from common import *
+import time
+
+from nose.tools import assert_equal
+from nose.tools import assert_true
+
+"""
+http://selenium.googlecode.com/svn/trunk/docs/api/py/webdriver/selenium.webdriver.common.keys.html
+"""
+from selenium.webdriver.common.keys import Keys
+
+
+############### ACTIONS ####################
+@step('I select the Advanced Settings$')
+def i_select_advanced_settings(step):
+    expand_icon_css = 'li.nav-course-settings i.icon-expand'
+    if world.browser.is_element_present_by_css(expand_icon_css):
+        css_click(expand_icon_css)
+    link_css = 'li.nav-course-settings-advanced a'
+    css_click(link_css)
+
+
+@step('I am on the Advanced Course Settings page in Studio$')
+def i_am_on_advanced_course_settings(step):
+    step.given('I have opened a new course in Studio')
+    step.given('I select the Advanced Settings')
+
+
+# TODO: this is copied from terrain's step.py. Need to figure out how to share that code.
+@step('I reload the page$')
+def reload_the_page(step):
+    world.browser.reload()
+
+
+@step(u'I edit the name of a policy key$')
+def edit_the_name_of_a_policy_key(step):
+    policy_key_css = 'input.policy-key'
+    e = css_find(policy_key_css).first
+    e.fill('new')
+
+
+@step(u'I press the "([^"]*)" notification button$')
+def press_the_notification_button(step, name):
+    world.browser.click_link_by_text(name)
+
+
+@step(u'I edit the value of a policy key$')
+def edit_the_value_of_a_policy_key(step):
+    """
+    It is hard to figure out how to get into the CodeMirror
+    area, so cheat and do it from the policy key field :)
+    """
+    policy_key_css = 'input.policy-key'
+    e = css_find(policy_key_css).first
+    e._element.send_keys(Keys.TAB, Keys.END, Keys.ARROW_LEFT, ' ', 'X')
+
+
+@step('I delete the display name$')
+def delete_the_display_name(step):
+    delete_entry(0)
+    click_save()
+
+
+@step('create New Entries$')
+def create_new_entries(step):
+    create_entry("z", "apple")
+    create_entry("a", "zebra")
+    click_save()
+
+
+@step('I create a JSON object$')
+def create_JSON_object(step):
+    create_entry("json", '{"key": "value", "key_2": "value_2"}')
+    click_save()
+
+
+############### RESULTS ####################
+@step('I see only the display name$')
+def i_see_only_display_name(step):
+    assert_policy_entries(["display_name"], ['"Robot Super Course"'])
+
+
+@step('there are no advanced policy settings$')
+def no_policy_settings(step):
+    assert_policy_entries([], [])
+
+
+@step('they are alphabetized$')
+def they_are_alphabetized(step):
+    assert_policy_entries(["a", "display_name", "z"], ['"zebra"', '"Robot Super Course"', '"apple"'])
+
+
+@step('it is displayed as formatted$')
+def it_is_formatted(step):
+    assert_policy_entries(["display_name", "json"], ['"Robot Super Course"', '{\n    "key": "value",\n    "key_2": "value_2"\n}'])
+
+
+@step(u'the policy key name is unchanged$')
+def the_policy_key_name_is_unchanged(step):
+    policy_key_css = 'input.policy-key'
+    e = css_find(policy_key_css).first
+    assert_equal(e.value, 'display_name')
+
+
+@step(u'the policy key name is changed$')
+def the_policy_key_name_is_changed(step):
+    policy_key_css = 'input.policy-key'
+    e = css_find(policy_key_css).first
+    assert_equal(e.value, 'new')
+
+
+@step(u'the policy key value is unchanged$')
+def the_policy_key_value_is_unchanged(step):
+    policy_value_css = 'li.course-advanced-policy-list-item div.value textarea'
+    e = css_find(policy_value_css).first
+    assert_equal(e.value, '"Robot Super Course"')
+
+
+@step(u'the policy key value is changed$')
+def the_policy_key_value_is_unchanged(step):
+    policy_value_css = 'li.course-advanced-policy-list-item div.value textarea'
+    e = css_find(policy_value_css).first
+    assert_equal(e.value, '"Robot Super Course X"')
+
+
+############# HELPERS ###############
+def create_entry(key, value):
+    # Scroll down the page so the button is visible
+    world.scroll_to_bottom()
+    css_click_at('a.new-advanced-policy-item', 10, 10)
+    new_key_css = 'div#__new_advanced_key__ input'
+    new_key_element = css_find(new_key_css).first
+    new_key_element.fill(key)
+#   For some reason have to get the instance for each command (get error that it is no longer attached to the DOM)
+#   Have to do all this because Selenium has a bug that fill does not remove existing text
+    new_value_css = 'div.CodeMirror textarea'
+    css_find(new_value_css).last.fill("")
+    css_find(new_value_css).last._element.send_keys(Keys.DELETE, Keys.DELETE)
+    css_find(new_value_css).last.fill(value)
+
+
+def delete_entry(index):
+    """ 
+    Delete the nth entry where index is 0-based
+    """
+    css = '.delete-button'
+    assert_true(world.browser.is_element_present_by_css(css, 5))
+    delete_buttons = css_find(css)
+    assert_true(len(delete_buttons) > index, "no delete button exists for entry " + str(index))
+    delete_buttons[index].click()
+
+
+def assert_policy_entries(expected_keys, expected_values):
+    assert_entries('.key input', expected_keys)
+    assert_entries('.json', expected_values)
+
+
+def assert_entries(css, expected_values):
+    webElements = css_find(css)
+    assert_equal(len(expected_values), len(webElements))
+#   Sometimes get stale reference if I hold on to the array of elements
+    for counter in range(len(expected_values)):
+        assert_equal(expected_values[counter], css_find(css)[counter].value)
+
+
+def click_save():
+    css = ".save-button"
+
+    def is_shown(driver):
+        visible = css_find(css).first.visible
+        if visible:
+            # Even when waiting for visible, this fails sporadically. Adding in a small wait.
+            time.sleep(float(1))
+        return visible
+    wait_for(is_shown)
+    css_click(css)
+
+
+def fill_last_field(value):
+    newValue = css_find('#__new_advanced_key__ input').first
+    newValue.fill(value)

cms/djangoapps/contentstore/features/common.py

 from lettuce import world, step
-from factories import *
-from django.core.management import call_command
 from lettuce.django import django_url
-from django.conf import settings
-from django.core.management import call_command
 from nose.tools import assert_true
 from nose.tools import assert_equal
+from selenium.webdriver.support.ui import WebDriverWait
+
+from terrain.factories import UserFactory, RegistrationFactory, UserProfileFactory
+from terrain.factories import CourseFactory, GroupFactory
 import xmodule.modulestore.django
+from auth.authz import get_user_by_email
 
 from logging import getLogger
 logger = getLogger(__name__)
@@ -44,6 +45,13 @@ def i_press_the_category_delete_icon(step, category):
         assert False, 'Invalid category: %s' % category
     css_click(css)
 
+
+@step('I have opened a new course in Studio$')
+def i_have_opened_a_new_course(step):
+    clear_courses()
+    log_into_studio()
+    create_a_course()
+
 ####### HELPER FUNCTIONS ##############
 
 
@@ -86,13 +94,38 @@ def assert_css_with_text(css, text):
 
 
 def css_click(css):
+    assert_true(world.browser.is_element_present_by_css(css, 5))
     world.browser.find_by_css(css).first.click()
 
 
+def css_click_at(css, x=10, y=10):
+    '''
+    A method to click at x,y coordinates of the element
+    rather than in the center of the element
+    '''
+    assert_true(world.browser.is_element_present_by_css(css, 5))
+    e = world.browser.find_by_css(css).first
+    e.action_chains.move_to_element_with_offset(e._element, x, y)
+    e.action_chains.click()
+    e.action_chains.perform()
+
+
 def css_fill(css, value):
     world.browser.find_by_css(css).first.fill(value)
 
 
+def css_find(css):
+    return world.browser.find_by_css(css)
+
+
+def wait_for(func):
+    WebDriverWait(world.browser.driver, 10).until(func)
+
+
+def id_find(id):
+    return world.browser.find_by_id(id)
+
+
 def clear_courses():
     flush_xmodule_store()
 
@@ -129,9 +162,18 @@ def log_into_studio(
 
 
 def create_a_course():
-    css_click('a.new-course-button')
-    fill_in_course_info()
-    css_click('input.new-course-save')
+    c = CourseFactory.create(org='MITx', course='999', display_name='Robot Super Course')
+
+    # Add the user to the instructor group of the course
+    # so they will have the permissions to see it in studio
+    g = GroupFactory.create(name='instructor_MITx/999/Robot_Super_Course')
+    u = get_user_by_email('robot+studio@edx.org')
+    u.groups.add(g)
+    u.save()
+    world.browser.reload()
+
+    course_link_css = 'span.class-name'
+    css_click(course_link_css)
     course_title_css = 'span.course-title'
     assert_true(world.browser.is_element_present_by_css(course_title_css, 5))
 

cms/djangoapps/contentstore/features/section.feature

@@ -11,6 +11,14 @@ Feature: Create Section
     And I see a release date for my section
     And I see a link to create a new subsection
 
+  Scenario: Add a new section (with a quote in the name) to a course (bug #216)
+    Given I have opened a new course in Studio
+    When I click the New Section link
+    And I enter a section name with a quote and click save
+    Then I see my section name with a quote on the Courseware page
+    And I click to edit the section name
+    Then I see the complete section name with a quote in the editor
+
   Scenario: Edit section release date
     Given I have opened a new course in Studio
     And I have added a new section

cms/djangoapps/contentstore/features/section.py

 from lettuce import world, step
 from common import *
+from nose.tools import assert_equal
 
 ############### ACTIONS ####################
 
 
-@step('I have opened a new course in Studio$')
-def i_have_opened_a_new_course(step):
-    clear_courses()
-    log_into_studio()
-    create_a_course()
-
-
 @step('I click the new section link$')
 def i_click_new_section_link(step):
     link_css = 'a.new-courseware-section-button'
@@ -19,10 +13,12 @@ def i_click_new_section_link(step):
 
 @step('I enter the section name and click save$')
 def i_save_section_name(step):
-    name_css = '.new-section-name'
-    save_css = '.new-section-name-save'
-    css_fill(name_css, 'My Section')
-    css_click(save_css)
+    save_section_name('My Section')
+
+
+@step('I enter a section name with a quote and click save$')
+def i_save_section_name_with_quote(step):
+    save_section_name('Section with "Quote"')
 
 
 @step('I have added a new section$')
@@ -46,13 +42,30 @@ def i_save_a_new_section_release_date(step):
     css_fill(time_css, '12:00am')
     css_click('a.save-button')
 
+
 ############ ASSERTIONS ###################
 
 
 @step('I see my section on the Courseware page$')
 def i_see_my_section_on_the_courseware_page(step):
-    section_css = 'span.section-name-span'
-    assert_css_with_text(section_css, 'My Section')
+    see_my_section_on_the_courseware_page('My Section')
+
+
+@step('I see my section name with a quote on the Courseware page$')
+def i_see_my_section_name_with_quote_on_the_courseware_page(step):
+    see_my_section_on_the_courseware_page('Section with "Quote"')
+
+
+@step('I click to edit the section name$')
+def i_click_to_edit_section_name(step):
+    css_click('span.section-name-span')
+
+
+@step('I see the complete section name with a quote in the editor$')
+def i_see_complete_section_name_with_quote_in_editor(step):
+    css = '.edit-section-name'
+    assert world.browser.is_element_present_by_css(css, 5)
+    assert_equal(world.browser.find_by_css(css).value, 'Section with "Quote"')
 
 
 @step('the section does not exist$')
@@ -94,3 +107,17 @@ def the_section_release_date_is_updated(step):
     css = 'span.published-status'
     status_text = world.browser.find_by_css(css).text
     assert status_text == 'Will Release: 12/25/2013 at 12:00am'
+
+
+############ HELPER METHODS ###################
+
+def save_section_name(name):
+    name_css = '.new-section-name'
+    save_css = '.new-section-name-save'
+    css_fill(name_css, name)
+    css_click(save_css)
+
+
+def see_my_section_on_the_courseware_page(name):
+    section_css = 'span.section-name-span'
+    assert_css_with_text(section_css, name)
\ No newline at end of file

cms/djangoapps/contentstore/features/subsection.feature

@@ -9,6 +9,14 @@ Feature: Create Subsection
     And I enter the subsection name and click save
     Then I see my subsection on the Courseware page
 
+    Scenario: Add a new subsection (with a name containing a quote) to a section (bug #216)
+    Given I have opened a new course section in Studio
+    When I click the New Subsection link
+    And I enter a subsection name with a quote and click save
+    Then I see my subsection name with a quote on the Courseware page
+    And I click to edit the subsection name
+    Then I see the complete subsection name with a quote in the editor
+
     Scenario: Delete a subsection
     Given I have opened a new course section in Studio
     And I have added a new subsection

cms/djangoapps/contentstore/features/subsection.py

 from lettuce import world, step
 from common import *
+from nose.tools import assert_equal
 
 ############### ACTIONS ####################
 
@@ -20,28 +21,60 @@ def i_click_the_new_subsection_link(step):
 
 @step('I enter the subsection name and click save$')
 def i_save_subsection_name(step):
-    name_css = 'input.new-subsection-name-input'
-    save_css = 'input.new-subsection-name-save'
-    css_fill(name_css, 'Subsection One')
-    css_click(save_css)
+    save_subsection_name('Subsection One')
+
+
+@step('I enter a subsection name with a quote and click save$')
+def i_save_subsection_name_with_quote(step):
+    save_subsection_name('Subsection With "Quote"')
+
+
+@step('I click to edit the subsection name$')
+def i_click_to_edit_subsection_name(step):
+    css_click('span.subsection-name-value')
+
+
+@step('I see the complete subsection name with a quote in the editor$')
+def i_see_complete_subsection_name_with_quote_in_editor(step):
+    css = '.subsection-display-name-input'
+    assert world.browser.is_element_present_by_css(css, 5)
+    assert_equal(world.browser.find_by_css(css).value, 'Subsection With "Quote"')
 
 
 @step('I have added a new subsection$')
 def i_have_added_a_new_subsection(step):
     add_subsection()
 
+
 ############ ASSERTIONS ###################
 
 
 @step('I see my subsection on the Courseware page$')
 def i_see_my_subsection_on_the_courseware_page(step):
-    css = 'span.subsection-name'
-    assert world.browser.is_element_present_by_css(css)
-    css = 'span.subsection-name-value'
-    assert_css_with_text(css, 'Subsection One')
+    see_subsection_name('Subsection One')
+
+
+@step('I see my subsection name with a quote on the Courseware page$')
+def i_see_my_subsection_name_with_quote_on_the_courseware_page(step):
+    see_subsection_name('Subsection With "Quote"')
 
 
 @step('the subsection does not exist$')
 def the_subsection_does_not_exist(step):
     css = 'span.subsection-name'
     assert world.browser.is_element_not_present_by_css(css)
+
+
+############ HELPER METHODS ###################
+
+def save_subsection_name(name):
+    name_css = 'input.new-subsection-name-input'
+    save_css = 'input.new-subsection-name-save'
+    css_fill(name_css, name)
+    css_click(save_css)
+
+def see_subsection_name(name):
+    css = 'span.subsection-name'
+    assert world.browser.is_element_present_by_css(css)
+    css = 'span.subsection-name-value'
+    assert_css_with_text(css, name)

cms/djangoapps/contentstore/management/commands/delete_course.py

@@ -17,22 +17,29 @@ from auth.authz import _delete_course_group
 
 
 class Command(BaseCommand):
-    help = \
-'''Delete a MongoDB backed course'''
+    help = '''Delete a MongoDB backed course'''
 
     def handle(self, *args, **options):
-        if len(args) != 1:
-            raise CommandError("delete_course requires one argument: <location>")
+        if len(args) != 1 and len(args) != 2:
+            raise CommandError("delete_course requires one or more arguments: <location> |commit|")
 
         loc_str = args[0]
 
+        commit = False
+        if len(args) == 2:
+            commit = args[1] == 'commit'
+
+        if commit:
+            print 'Actually going to delete the course from DB....'
+
         ms = modulestore('direct')
         cs = contentstore()
 
         if query_yes_no("Deleting course {0}. Confirm?".format(loc_str), default="no"):
-          if query_yes_no("Are you sure. This action cannot be undone!", default="no"):
-            loc = CourseDescriptor.id_to_location(loc_str)
-            if delete_course(ms, cs, loc) == True:
-              print 'removing User permissions from course....'
-              # in the django layer, we need to remove all the user permissions groups associated with this course
-              _delete_course_group(loc)            
+            if query_yes_no("Are you sure. This action cannot be undone!", default="no"):
+                loc = CourseDescriptor.id_to_location(loc_str)
+                if delete_course(ms, cs, loc, commit) == True:
+                    print 'removing User permissions from course....'
+                    # in the django layer, we need to remove all the user permissions groups associated with this course
+                    if commit:
+                        _delete_course_group(loc)

cms/djangoapps/contentstore/management/commands/prompt.py

@@ -13,7 +13,7 @@ def query_yes_no(question, default="yes"):
     """
     valid = {"yes":True,   "y":True,  "ye":True,
              "no":False,     "n":False}
-    if default == None:
+    if default is None:
         prompt = " [y/n] "
     elif default == "yes":
         prompt = " [Y/n] "

cms/djangoapps/contentstore/management/commands/update_templates.py

+from xmodule.templates import update_templates
+from django.core.management.base import BaseCommand
+
+class Command(BaseCommand):
+    help = \
+'''Imports and updates the Studio component templates from the code pack and put in the DB'''
+
+    def handle(self, *args, **options):
+        update_templates()
\ No newline at end of file

cms/djangoapps/contentstore/tests/factories.py

-from factory import Factory
-from datetime import datetime
-from uuid import uuid4
-from student.models import (User, UserProfile, Registration,
-                            CourseEnrollmentAllowed)
-from django.contrib.auth.models import Group
-
-
-class UserProfileFactory(Factory):
-    FACTORY_FOR = UserProfile
-
-    user = None
-    name = 'Robot Studio'
-    courseware = 'course.xml'
-
-
-class RegistrationFactory(Factory):
-    FACTORY_FOR = Registration
-
-    user = None
-    activation_key = uuid4().hex
-
-
-class UserFactory(Factory):
-    FACTORY_FOR = User
-
-    username = 'robot'
-    email = 'robot@edx.org'
-    password = 'test'
-    first_name = 'Robot'
-    last_name = 'Tester'
-    is_staff = False
-    is_active = True
-    is_superuser = False
-    last_login = datetime.now()
-    date_joined = datetime.now()
-
-
-class GroupFactory(Factory):
-    FACTORY_FOR = Group
-
-    name = 'test_group'
-
-
-class CourseEnrollmentAllowedFactory(Factory):
-    FACTORY_FOR = CourseEnrollmentAllowed
-
-    email = 'test@edx.org'
-    course_id = 'edX/test/2012_Fall'

cms/djangoapps/contentstore/tests/test_contentstore.py

@@ -171,7 +171,7 @@ class ContentStoreToyCourseTest(ModuleStoreTestCase):
 
         location = CourseDescriptor.id_to_location('edX/full/6.002_Spring_2012')
 
-        delete_course(ms, cs, location)
+        delete_course(ms, cs, location, commit=True)
 
         items = ms.get_items(Location(['i4x', 'edX', 'full', 'vertical', None]))
         self.assertEqual(len(items), 0)
@@ -465,7 +465,9 @@ class ContentStoreTest(ModuleStoreTestCase):
         # check for grace period definition which should be defined at the course level
         self.assertIn('graceperiod', new_module.metadata)
 
-        self.assertEqual(course.metadata['graceperiod'], new_module.metadata['graceperiod'])
+        self.assertEqual(parent.metadata['graceperiod'], new_module.metadata['graceperiod'])
+
+        self.assertEqual(course.metadata['xqa_key'], new_module.metadata['xqa_key'])
 
         #
         # now let's define an override at the leaf node level

cms/djangoapps/contentstore/tests/test_course_settings.py

 import datetime
-import time
 import json
-import calendar
 import copy
 from util import converters
 from util.converters import jsdate_to_time
@@ -11,7 +9,6 @@ from django.test.client import Client
 from django.core.urlresolvers import reverse
 from django.utils.timezone import UTC
 
-import xmodule
 from xmodule.modulestore import Location
 from cms.djangoapps.models.settings.course_details import (CourseDetails,
                                                     CourseSettingsEncoder)
@@ -22,6 +19,10 @@ from django.test import TestCase
 from utils import ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory
 
+from cms.djangoapps.models.settings.course_metadata import CourseMetadata
+from xmodule.modulestore.xml_importer import import_from_xml
+from xmodule.modulestore.django import modulestore
+
 
 # YYYY-MM-DDThh:mm:ss.s+/-HH:MM
 class ConvertersTestCase(TestCase):
@@ -261,3 +262,64 @@ class CourseGradingTest(CourseTestCase):
         test_grader.graders[1]['drop_count'] = test_grader.graders[1].get('drop_count') + 1
         altered_grader = CourseGradingModel.update_grader_from_json(test_grader.course_location, test_grader.graders[1])
         self.assertDictEqual(test_grader.graders[1], altered_grader, "drop_count[1] + 2")
+
+class CourseMetadataEditingTest(CourseTestCase):
+    def setUp(self):
+        CourseTestCase.setUp(self)
+        # add in the full class too
+        import_from_xml(modulestore(), 'common/test/data/', ['full'])
+        self.fullcourse_location = Location(['i4x','edX','full','course','6.002_Spring_2012', None])
+
+
+    def test_fetch_initial_fields(self):
+        test_model = CourseMetadata.fetch(self.course_location)
+        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)
+        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'], 'Testing', "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_update_from_json(self):
+        test_model = CourseMetadata.update_from_json(self.course_location,
+            { "a" : 1,
+              "b_a_c_h" : { "c" : "test" },
+              "test_text" : "a text string"})
+        self.update_check(test_model)
+        # try fresh fetch to ensure persistence
+        test_model = CourseMetadata.fetch(self.course_location)
+        self.update_check(test_model)
+        # now change some of the existing metadata
+        test_model = CourseMetadata.update_from_json(self.course_location,
+            { "a" : 2,
+              "display_name" : "jolly roger"})
+        self.assertIn('display_name', test_model, 'Missing editable metadata field')
+        self.assertEqual(test_model['display_name'], 'jolly roger', "not expected value")
+        self.assertIn('a', test_model, 'Missing revised a metadata field')
+        self.assertEqual(test_model['a'], 2, "a not expected value")
+
+    def update_check(self, test_model):
+        self.assertIn('display_name', test_model, 'Missing editable metadata field')
+        self.assertEqual(test_model['display_name'], 'Robot Super Course', "not expected value")
+        self.assertIn('a', test_model, 'Missing new a metadata field')
+        self.assertEqual(test_model['a'], 1, "a not expected value")
+        self.assertIn('b_a_c_h', test_model, 'Missing b_a_c_h metadata field')
+        self.assertDictEqual(test_model['b_a_c_h'], { "c" : "test" }, "b_a_c_h not expected value")
+        self.assertIn('test_text', test_model, 'Missing test_text metadata field')
+        self.assertEqual(test_model['test_text'], "a text string", "test_text not expected value")
+
+
+    def test_delete_key(self):
+        test_model = CourseMetadata.delete_key(self.fullcourse_location, { 'deleteKeys' : ['doesnt_exist', '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')
+        self.assertEqual(test_model['display_name'], 'Testing', "not expected value")
+        self.assertIn('rerandomize', test_model, 'Missing rerandomize metadata field')
+        # check for deletion effectiveness
+        self.assertNotIn('showanswer', test_model, 'showanswer field still in')
+        self.assertNotIn('xqa_key', test_model, 'xqa_key field still in')
\ No newline at end of file

cms/djangoapps/contentstore/utils.py

@@ -75,12 +75,20 @@ def get_course_for_item(location):
     return courses[0]
 
 
-def get_lms_link_for_item(location, preview=False):
+def get_lms_link_for_item(location, preview=False, course_id=None):
+    if course_id is None:
+        course_id = get_course_id(location)
+
     if settings.LMS_BASE is not None:
-        lms_link = "//{preview}{lms_base}/courses/{course_id}/jump_to/{location}".format(
-            preview='preview.' if preview else '',
-            lms_base=settings.LMS_BASE,
-            course_id=get_course_id(location),
+        if preview:
+            lms_base = settings.MITX_FEATURES.get('PREVIEW_LMS_BASE',
+                'preview.' + settings.LMS_BASE)
+        else:
+            lms_base = settings.LMS_BASE
+     
+        lms_link = "//{lms_base}/courses/{course_id}/jump_to/{location}".format(
+            lms_base=lms_base,
+            course_id=course_id,
             location=Location(location)
         )
     else:

cms/djangoapps/models/settings/course_metadata.py

+from xmodule.modulestore import Location
+from contentstore.utils import get_modulestore
+from xmodule.x_module import XModuleDescriptor
+
+
+class CourseMetadata(object):
+    '''
+    For CRUD operations on metadata fields which do not have specific editors on the other pages including any user generated ones.
+    The objects have no predefined attrs but instead are obj encodings of the editable metadata.
+    '''
+    # __new_advanced_key__ is used by client not server; so, could argue against it being here
+    FILTERED_LIST = XModuleDescriptor.system_metadata_fields + ['start', 'end', 'enrollment_start', 'enrollment_end', 'tabs', 'graceperiod', '__new_advanced_key__']
+    
+    @classmethod
+    def fetch(cls, course_location):
+        """
+        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)
+        
+        for k, v in descriptor.metadata.iteritems():
+            if k not in cls.FILTERED_LIST:
+                course[k] = v
+                
+        return course
+        
+    @classmethod
+    def update_from_json(cls, course_location, jsondict):
+        """
+        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
+
+        for k, v in jsondict.iteritems():
+            # should it be an error if one of the filtered list items is in the payload?
+            if k not in cls.FILTERED_LIST and (k not in descriptor.metadata or descriptor.metadata[k] != v):
+                dirty = True
+                descriptor.metadata[k] = v
+            
+        if dirty:
+            get_modulestore(course_location).update_metadata(course_location, descriptor.metadata)
+            
+        # 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 key in descriptor.metadata:
+                del descriptor.metadata[key]
+    
+        get_modulestore(course_location).update_metadata(course_location, descriptor.metadata)
+        
+        return cls.fetch(course_location)
+        
\ No newline at end of file

cms/envs/common.py

@@ -172,6 +172,9 @@ LANGUAGE_CODE = 'en'            # http://www.i18nguy.com/unicode/language-identi
 USE_I18N = True
 USE_L10N = True
 
+# Tracking
+TRACK_MAX_EVENT = 10000
+
 # Messages
 MESSAGE_STORAGE = 'django.contrib.messages.storage.session.SessionStorage'
 
@@ -275,6 +278,10 @@ INSTALLED_APPS = (
     'auth',
     'student',  # misleading name due to sharing with lms
     'course_groups',  # not used in cms (yet), but tests run
+
+    # tracking
+    'track',
+
     # For asset pipelining
     'pipeline',
     'staticfiles',

cms/envs/test.py

@@ -27,6 +27,9 @@ STATIC_ROOT = TEST_ROOT / "staticfiles"
 GITHUB_REPO_ROOT = TEST_ROOT / "data"
 COMMON_TEST_DATA_ROOT = COMMON_ROOT / "test" / "data"
 
+# Makes the tests run much faster...
+SOUTH_TESTS_MIGRATE = False # To disable migrations and use syncdb instead
+
 # TODO (cpennington): We need to figure out how envs/test.py can inject things into common.py so that we don't have to repeat this sort of thing
 STATICFILES_DIRS = [
     COMMON_ROOT / "static",

cms/static/client_templates/advanced_entry.html

+<li class="field-group course-advanced-policy-list-item">
+	<div class="field text key" id="<%= (_.isEmpty(key) ? '__new_advanced_key__' : key) %>">
+		<label for="<%= keyUniqueId %>">Policy Key:</label>
+		<input type="text" class="short policy-key" id="<%= keyUniqueId %>" value="<%= key %>" />
+		<span class="tip tip-stacked">Keys are case	sensitive and cannot contain spaces or start with a number</span>
+  </div>
+  
+  <div class="field text value">
+    <label for="<%= valueUniqueId %>">Policy Value:</label>
+    <textarea class="json text" id="<%= valueUniqueId %>"><%= value %></textarea>
+  </div>
+	
+	<div class="actions">
+		<a href="#" class="button delete-button standard remove-item remove-grading-data"><span class="delete-icon"></span>Delete</a>
+	</div>
+</li>
\ No newline at end of file

cms/static/js/models/settings/advanced.js

+if (!CMS.Models['Settings']) CMS.Models.Settings = {};
+
+CMS.Models.Settings.Advanced = Backbone.Model.extend({
+    // the key for a newly added policy-- before the user has entered a key value
+    new_key : "__new_advanced_key__",
+
+    defaults: {
+        // the properties are whatever the user types in (in addition to whatever comes originally from the server)
+    },
+    // which keys to send as the deleted keys on next save
+    deleteKeys : [],
+    blacklistKeys : [], // an array which the controller should populate directly for now [static not instance based]
+
+    validate: function (attrs) {
+        var errors = {};
+        for (var key in attrs) {
+            if (key === this.new_key || _.isEmpty(key)) {
+                errors[key] = "A key must be entered.";
+            }
+            else if (_.contains(this.blacklistKeys, key)) {
+                errors[key] = key + " is a reserved keyword or can be edited on another screen";
+            }
+        }
+        if (!_.isEmpty(errors)) return errors;
+    },
+    
+    save : function (attrs, options) {
+        // wraps the save call w/ the deletion of the removed keys after we know the saved ones worked
+        options = options ? _.clone(options) : {};
+        // add saveSuccess to the success
+        var success = options.success;
+        options.success = function(model, resp, options) {
+          model.afterSave(model);
+          if (success) success(model, resp, options);
+        };
+        Backbone.Model.prototype.save.call(this, attrs, options);
+    },
+    
+    afterSave : function(self) {
+        // remove deleted attrs
+        if (!_.isEmpty(self.deleteKeys)) {
+            // remove the to be deleted keys from the returned model
+            _.each(self.deleteKeys, function(key) { self.unset(key); });
+            // not able to do via backbone since we're not destroying the model
+            $.ajax({
+                url : self.url,
+                // json to and fro
+                contentType : "application/json",
+                dataType : "json",
+                // delete
+                type : 'DELETE',
+                // data
+                data : JSON.stringify({ deleteKeys : self.deleteKeys})
+            })
+            .fail(function(hdr, status, error) { CMS.ServerError(self, "Deleting keys:" + status); })
+            .done(function(data, status, error) {
+                // clear deleteKeys on success
+                self.deleteKeys = [];
+            });
+        }
+    }
+});

cms/static/js/models/settings/course_details.js

@@ -59,19 +59,14 @@ CMS.Models.Settings.CourseDetails = Backbone.Model.extend({
         // NOTE don't return empty errors as that will be interpreted as an error state
     },
 
-    url: function() {
-        var location = this.get('location');
-        return '/' + location.get('org') + "/" + location.get('course') + '/settings-details/' + location.get('name') + '/section/details';
-    },
-
     _videokey_illegal_chars : /[^a-zA-Z0-9_-]/g,
     save_videosource: function(newsource) {
         // newsource either is <video youtube="speed:key, *"/> or just the "speed:key, *" string
         // returns the videosource for the preview which iss the key whose speed is closest to 1
-        if (_.isEmpty(newsource) && !_.isEmpty(this.get('intro_video'))) this.set({'intro_video': null}); 
+        if (_.isEmpty(newsource) && !_.isEmpty(this.get('intro_video'))) this.save({'intro_video': null}); 
         // TODO remove all whitespace w/in string
         else {
-            if (this.get('intro_video') !== newsource) this.set('intro_video', newsource);
+            if (this.get('intro_video') !== newsource) this.save('intro_video', newsource);
         }
 
         return this.videosourceSample();

cms/static/js/models/settings/course_settings.js

-if (!CMS.Models['Settings']) CMS.Models.Settings = new Object();
-CMS.Models.Settings.CourseSettings = Backbone.Model.extend({
-    // a container for the models representing the n possible tabbed states
-    defaults: {
-        courseLocation: null,
-        details: null,
-        faculty: null,
-        grading: null,
-        problems: null,
-        discussions: null
-    },
-
-    retrieve: function(submodel, callback) {
-        if (this.get(submodel)) callback();
-        else {
-            var cachethis = this;
-            switch (submodel) {
-            case 'details':
-                var details = new CMS.Models.Settings.CourseDetails({location: this.get('courseLocation')});
-                details.fetch( {
-                    success : function(model) {
-                        cachethis.set('details', model);
-                        callback(model);
-                    }
-                });
-                break;
-            case 'grading':
-                var grading = new CMS.Models.Settings.CourseGradingPolicy({course_location: this.get('courseLocation')});
-                grading.fetch( {
-                    success : function(model) {
-                        cachethis.set('grading', model);
-                        callback(model);
-                    }
-                });
-                break;
-
-            default:
-                break;
-            }
-        }
-    }
-})
\ No newline at end of file

cms/static/js/template_loader.js

@@ -5,7 +5,7 @@
 	if (typeof window.templateLoader == 'function') return;
 	
     var templateLoader = {
-      templateVersion: "0.0.12",
+      templateVersion: "0.0.15",
       templates: {},
       loadRemoteTemplate: function(templateName, filename, callback) {
         if (!this.templates[templateName]) {

cms/static/js/views/course_info_edit.js

@@ -44,6 +44,8 @@ CMS.Views.ClassInfoUpdateView = Backbone.View.extend({
         		self.render();           
             }
         );
+        // when the client refetches the updates as a whole, re-render them
+        this.listenTo(this.collection, 'reset', this.render);
     },
         
     render: function () {
@@ -53,8 +55,12 @@ CMS.Views.ClassInfoUpdateView = Backbone.View.extend({
           $(updateEle).empty();
           var self = this;
           this.collection.each(function (update) {
-        	  var newEle = self.template({ updateModel : update });
-              $(updateEle).append(newEle);
+              try {
+                  var newEle = self.template({ updateModel : update });
+                  $(updateEle).append(newEle);
+            } catch (e) {
+                // ignore
+            }
           });
           this.$el.find(".new-update-form").hide();
           this.$el.find('.date').datepicker({ 'dateFormat': 'MM d, yy' });
@@ -150,7 +156,7 @@ CMS.Views.ClassInfoUpdateView = Backbone.View.extend({
     },
 
     closeEditor: function(self, removePost) {
-        var targetModel = self.collection.getByCid(self.$currentPost.attr('name'));
+        var targetModel = self.collection.get(self.$currentPost.attr('name'));
 
         if(removePost) {
             self.$currentPost.remove();
@@ -160,8 +166,13 @@ CMS.Views.ClassInfoUpdateView = Backbone.View.extend({
         self.$currentPost.removeClass('editing');
         self.$currentPost.find('.date-display').html(targetModel.get('date'));
         self.$currentPost.find('.date').val(targetModel.get('date'));
-        self.$currentPost.find('.update-contents').html(targetModel.get('content'));
-        self.$currentPost.find('.new-update-content').val(targetModel.get('content'));
+        try {
+            // just in case the content causes an error (embedded js errors)
+            self.$currentPost.find('.update-contents').html(targetModel.get('content'));
+            self.$currentPost.find('.new-update-content').val(targetModel.get('content'));
+        } catch (e) {
+            // ignore but handle rest of page
+        }
         self.$currentPost.find('form').hide();
         window.$modalCover.unbind('click');
         window.$modalCover.hide();
@@ -172,7 +183,7 @@ CMS.Views.ClassInfoUpdateView = Backbone.View.extend({
     // Dereferencing from events to screen elements    
     eventModel: function(event) {
         // not sure if it should be currentTarget or delegateTarget
-        return this.collection.getByCid($(event.currentTarget).attr("name"));
+        return this.collection.get($(event.currentTarget).attr("name"));
     },
         
     modelDom: function(event) {

cms/static/js/views/settings/main_settings_view.js

-if (!CMS.Views['Settings']) CMS.Views.Settings = {}; // ensure the pseudo pkg exists
+if (!CMS.Views['Settings']) CMS.Views.Settings = {};
 
 CMS.Views.Settings.Details = CMS.Views.ValidatingView.extend({
     // Model class is CMS.Models.Settings.CourseDetails
     events : {
-        "blur input" : "updateModel",
-        "blur textarea" : "updateModel",
+        "change input" : "updateModel",
+        "change textarea" : "updateModel",
         'click .remove-course-syllabus' : "removeSyllabus",
         'click .new-course-syllabus' : 'assetSyllabus',
         'click .remove-course-introduction-video' : "removeVideo",
@@ -97,7 +97,7 @@ CMS.Views.Settings.Details = CMS.Views.ValidatingView.extend({
                 }
                 var newVal = new Date(date.getTime() + time * 1000);
                 if (!cacheModel.has(fieldName) || cacheModel.get(fieldName).getTime() !== newVal.getTime()) {
-                    cacheModel.save(fieldName, newVal, { error: CMS.ServerError});
+                    cacheModel.save(fieldName, newVal);
                 }
             }
         };

cms/static/js/views/settings/settings_grading_view.js

@@ -3,9 +3,9 @@ if (!CMS.Views['Settings']) CMS.Views.Settings = {}; // ensure the pseudo pkg ex
 CMS.Views.Settings.Grading = CMS.Views.ValidatingView.extend({
     // Model class is CMS.Models.Settings.CourseGradingPolicy
     events : {
-        "blur input" : "updateModel",
-        "blur textarea" : "updateModel",
-        "blur span[contenteditable=true]" : "updateDesignation",
+        "change input" : "updateModel",
+        "change textarea" : "updateModel",
+        "change span[contenteditable=true]" : "updateDesignation",
         "click .settings-extra header" : "showSettingsExtras",
         "click .new-grade-button" : "addNewGrade",
         "click .remove-button" : "removeGrade",
@@ -90,8 +90,7 @@ CMS.Views.Settings.Grading = CMS.Views.ValidatingView.extend({
     setGracePeriod : function(event) {
         event.data.clearValidationErrors();
         var newVal = event.data.model.dateToGracePeriod($(event.currentTarget).timepicker('getTime'));
-        if (event.data.model.get('grace_period') != newVal) event.data.model.save('grace_period', newVal,
-                { error : CMS.ServerError});
+        if (event.data.model.get('grace_period') != newVal) event.data.model.save('grace_period', newVal);
     },
     updateModel : function(event) {
         if (!this.selectorToField[event.currentTarget.id]) return;
@@ -227,8 +226,7 @@ CMS.Views.Settings.Grading = CMS.Views.ValidatingView.extend({
                     object[cutoff['designation']] = cutoff['cutoff'] / 100.0;
                     return object;
                 }, 
-                {}),
-                { error : CMS.ServerError});
+                {}));
     },
 
     addNewGrade: function(e) {
@@ -310,8 +308,8 @@ CMS.Views.Settings.Grading = CMS.Views.ValidatingView.extend({
 CMS.Views.Settings.GraderView = CMS.Views.ValidatingView.extend({
     // Model class is CMS.Models.Settings.CourseGrader
     events : {
-        "blur input" : "updateModel",
-        "blur textarea" : "updateModel",
+        "change input" : "updateModel",
+        "change textarea" : "updateModel",
         "click .remove-grading-data" : "deleteModel",
         // would love to move to a general superclass, but event hashes don't inherit in backbone :-(
         'focus :input' : "inputFocus",

cms/static/js/views/validating_view.js

@@ -10,8 +10,8 @@ CMS.Views.ValidatingView = Backbone.View.extend({
     errorTemplate : _.template('<span class="message-error"><%= message %></span>'),
 
     events : {
-        "blur input" : "clearValidationErrors",
-        "blur textarea" : "clearValidationErrors"
+        "change input" : "clearValidationErrors",
+        "change textarea" : "clearValidationErrors"
     },
     fieldToSelectorMap : {
         // Your subclass must populate this w/ all of the model keys and dom selectors 

cms/static/sass/_alerts.scss

+// notifications
+.wrapper-notification {
+	@include clearfix();
+	@include box-sizing(border-box);
+	@include transition (bottom 2.0s ease-in-out 5s);
+	@include box-shadow(0 -1px 2px rgba(0,0,0,0.1));
+	position: fixed;
+	bottom: -100px;
+	z-index: 1000;
+	width: 100%;
+	overflow: hidden;
+	opacity: 0;
+	border-top: 1px solid $darkGrey;
+	padding: 20px 40px;
+
+	&.is-shown {
+		bottom: 0;
+		opacity: 1.0;
+	}
+
+	&.wrapper-notification-warning {
+		border-color: shade($yellow, 25%);
+		background: tint($yellow, 25%);
+	}
+
+	&.wrapper-notification-error {
+		border-color: shade($red, 50%);
+		background: tint($red, 20%);
+		color: $white;
+	}
+
+	&.wrapper-notification-confirm {
+		border-color: shade($green, 30%);
+		background: tint($green, 40%);
+		color: shade($green, 30%);
+	}
+}
+
+.notification {
+	@include box-sizing(border-box);
+	margin: 0 auto;
+	width: flex-grid(12);
+	max-width: $fg-max-width;
+	min-width: $fg-min-width;
+
+	.copy {
+		float: left;
+		width: flex-grid(9, 12);
+		margin-right: flex-gutter();
+		margin-top: 5px;
+		font-size: 14px;
+
+		.icon {
+			display: inline-block;
+			vertical-align: top;
+			margin-right: 5px;
+			font-size: 20px;
+		}
+
+		p {
+			width: flex-grid(8, 9);
+			display: inline-block;
+			vertical-align: top;
+		}
+	}
+
+	.actions {
+		float: right;
+		width: flex-grid(3, 12);
+		margin-top: ($baseline/2);
+		text-align: right;
+
+		li {
+			display: inline-block;
+			vertical-align: middle;
+			margin-right: 10px;
+
+			&:last-child {
+				margin-right: 0;
+			}
+		}
+
+		.save-button {
+			@include blue-button;
+		}
+
+		.cancel-button {
+		  @include white-button;
+		}
+	}
+
+	strong {
+		font-weight: 700;
+	}
+}
+
+// adopted alerts
 .alert {
 	padding: 15px 20px;
 	margin-bottom: 30px;

cms/static/sass/_graphics.scss

@@ -254,6 +254,30 @@
 	background: url(../img/html-icon.png) center no-repeat;
 }
 
+.large-openended-icon {
+	display: inline-block;
+	width: 100px;
+	height: 60px;
+	margin-right: 5px;
+	background: url(../img/large-openended-icon.png) center no-repeat;
+}
+
+.large-annotations-icon {
+	display: inline-block;
+	width: 100px;
+	height: 60px;
+	margin-right: 5px;
+	background: url(../img/large-annotations-icon.png) center no-repeat;
+}
+
+.large-advanced-icon {
+	display: inline-block;
+	width: 100px;
+	height: 60px;
+	margin-right: 5px;
+	background: url(../img/large-advanced-icon.png) center no-repeat;
+}
+
 .large-textbook-icon {
 	display: inline-block;
 	width: 100px;

cms/static/sass/_settings.scss

@@ -14,6 +14,44 @@ body.course.settings {
     padding: $baseline ($baseline*1.5);
   }
 
+  // messages - should be synced up with global messages in the future
+  .message {
+    display: block;
+    font-size: 14px;
+  }
+
+  .message-status {
+    display: none;
+    @include border-top-radius(2px);
+    @include box-sizing(border-box);
+    border-bottom: 2px solid $yellow;
+    margin: 0 0 20px 0;
+    padding: 10px 20px;
+    font-weight: 500;
+    background: $paleYellow;
+
+    .text {
+      display: inline-block;
+    }
+
+    &.error {
+      border-color: shade($red, 50%);
+      background: tint($red, 20%);
+      color: $white;
+    }
+
+    &.confirm {
+      border-color: shade($green, 50%);
+      background: tint($green, 20%);
+      color: $white;
+    }
+
+    &.is-shown {
+      display: block;
+    }
+  }
+
+  // in form - elements
   .group-settings {
     margin: 0 0 ($baseline*2) 0;
 
@@ -45,7 +83,12 @@ body.course.settings {
 
     }
 
-    // UI hints/tips/messages
+    // in form  -UI hints/tips/messages
+    .instructions {
+      @include font-size(14);
+      margin: 0 0 $baseline 0;
+    }
+
     .tip {
       @include transition(color, 0.15s, ease-in-out);
       @include font-size(13);
@@ -576,6 +619,119 @@ body.course.settings {
         }
       }
     }
+
+    // specific fields - advanced settings
+    &.advanced-policies {
+
+      .field-group {
+        margin-bottom: ($baseline*1.5);
+
+        &:last-child {
+          border: none;
+          padding-bottom: 0;
+        }
+      }
+
+      .course-advanced-policy-list-item {
+        @include clearfix();
+        position: relative;
+
+        .field {
+
+          input {
+            width: 100%;
+          }
+
+          .tip {
+            @include transition (opacity 0.5s ease-in-out 0s);
+            opacity: 0;
+            position: absolute;
+            bottom: ($baseline*1.25);
+          }
+
+          input:focus {
+
+            & + .tip {
+              opacity: 1.0;
+            }
+          }
+
+          input.error {
+
+            & + .tip {
+              opacity: 0;
+            }
+          }
+        }
+
+        .key, .value {
+          float: left;
+          margin: 0 0 ($baseline/2) 0;
+        }
+
+       .key {
+         width: flex-grid(3, 9);
+         margin-right: flex-gutter();
+        }
+
+        .value {
+          width: flex-grid(6, 9);
+        }
+
+        .actions {
+          float: left;
+          width: flex-grid(9, 9);
+
+          .delete-button {
+            margin: 0;
+          }
+        }
+      }
+
+      .message-error {
+        position: absolute;
+        bottom: ($baseline*0.75);
+      }
+
+      // specific to code mirror instance in JSON policy editing, need to sync up with other similar code mirror UIs
+      .CodeMirror {
+        @include font-size(16);
+        @include box-sizing(border-box);
+        @include box-shadow(0 1px 2px rgba(0, 0, 0, .1) inset);
+        @include linear-gradient($lightGrey, tint($lightGrey, 90%));
+        padding: 5px 8px;
+        border: 1px solid $mediumGrey;
+        border-radius: 2px;
+        background-color: $lightGrey;
+        font-family: 'Open Sans', sans-serif;
+        color: $baseFontColor;
+        outline: 0;
+
+        &.CodeMirror-focused {
+          @include linear-gradient($paleYellow, tint($paleYellow, 90%));
+          outline: 0;
+        }
+
+        .CodeMirror-scroll {
+          overflow: hidden;
+          height: auto;
+          min-height: ($baseline*1.5);
+          max-height: ($baseline*10);
+        }
+
+        // editor color changes just for JSON
+        .CodeMirror-lines {
+
+          .cm-string {
+            color: #cb9c40;
+          }
+
+          pre {
+            line-height: 2.0rem;
+          }
+        }
+      }
+    }
   }
 
   .content-supplementary {

cms/templates/course_info.html

@@ -20,8 +20,8 @@
   <script type="text/javascript" charset="utf-8">
   $(document).ready(function(){
     var course_updates = new CMS.Models.CourseUpdateCollection();
-    course_updates.reset(${course_updates|n});
     course_updates.urlbase = '${url_base}';
+    course_updates.fetch();
 
     var course_handouts = new CMS.Models.ModuleInfo({
         id: '${handouts_location}'

cms/templates/edit_subsection.html

@@ -22,7 +22,7 @@
       <article class="subsection-body window" data-id="${subsection.location}">
         <div class="subsection-name-input">
           <label>Display Name:</label>
-          <input type="text" value="${subsection.display_name}" class="subsection-display-name-input" data-metadata-name="display_name"/>
+          <input type="text" value="${subsection.display_name | h}" class="subsection-display-name-input" data-metadata-name="display_name"/>
         </div>
         <div class="sortable-unit-list">
           <label>Units:</label>

cms/templates/import.html

@@ -19,7 +19,6 @@
   <div class="inner-wrapper">
     <article class="import-overview">
       <div class="description">
-        <h2>Please <a href="https://edge.edx.org/courses/edX/edx101/edX_Studio_Reference/about" target="_blank">read the documentation</a> before attempting an import!</h2>
         <p><strong>Importing a new course will delete all content currently associated with your course
         and replace it with the contents of the uploaded file.</strong></p>
         <p>File uploads must be gzipped tar files (.tar.gz or .tgz) containing, at a minimum, a <code>course.xml</code> file.</p>

cms/templates/overview.html

@@ -156,7 +156,7 @@
               <h3 class="section-name">
                 <span data-tooltip="Edit this section's name" class="section-name-span">${section.display_name}</span>
                 <form class="section-name-edit" style="display:none">
-                  <input type="text" value="${section.display_name}" class="edit-section-name" autocomplete="off"/>
+                  <input type="text" value="${section.display_name | h}" class="edit-section-name" autocomplete="off"/>
                   <input type="submit" class="save-button edit-section-name-save" value="Save" />
                   <input type="button" class="cancel-button edit-section-name-cancel" value="Cancel" />
                 </form>

cms/templates/settings.html

@@ -23,19 +23,25 @@ from contentstore import utils
   
   <script type="text/javascript">
     $(document).ready(function(){
-    
+      
+      // hilighting labels when fields are focused in
       $("form :input").focus(function() {
         $("label[for='" + this.id + "']").addClass("is-focused");
       }).blur(function() {
         $("label").removeClass("is-focused");
         });
-        
-      var editor = new CMS.Views.Settings.Details({
-          el: $('.settings-details'),
-          model: new CMS.Models.Settings.CourseDetails(${course_details|n},{parse:true})
-        });
-        
-        editor.render();
+      var model = new CMS.Models.Settings.CourseDetails();
+      model.urlRoot = '${details_url}';
+      model.fetch({success : 
+          function(model) {
+              var editor = new CMS.Views.Settings.Details({
+                  el: $('.settings-details'),
+                  model: model
+                });
+                
+              editor.render();
+          }
+      });
     });
       
   </script>
@@ -205,7 +211,7 @@ from contentstore import utils
 
     <aside class="content-supplementary" role="complimentary">
      <div class="bit">
-        <h3 class="title-3">How will these settings be used</h3>
+        <h3 class="title-3">How will these settings be used?</h3>
         <p>Your course's schedule settings determine when students can enroll in and begin a course as well as when the course.</p>
 
         <p>Additionally, details provided on this page are also used in edX's catalog of courses, which new and returning students use to choose new courses to study.</p>
@@ -220,6 +226,7 @@ from contentstore import utils
           <ul>
             <li class="nav-item"><a href="${reverse('contentstore.views.course_config_graders_page', kwargs={'org' : ctx_loc.org, 'course' : ctx_loc.course, 'name': ctx_loc.name})}">Grading</a></li>
             <li class="nav-item"><a href="${reverse('manage_users', kwargs=dict(location=ctx_loc))}">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>
           </ul>
         </nav>
       % endif

cms/templates/settings_advanced.html

+<%inherit file="base.html" />
+<%! from django.core.urlresolvers import reverse %>
+<%block name="title">Advanced Settings</%block>
+<%block name="bodyclass">is-signedin course advanced settings</%block>
+
+<%namespace name='static' file='static_content.html'/>
+<%!
+from contentstore import utils
+%>
+
+<%block name="jsextra">
+
+<script type="text/javascript" src="${static.url('js/template_loader.js')}"></script>
+<script type="text/javascript" src="${static.url('js/views/server_error.js')}"></script>
+<script type="text/javascript" src="${static.url('js/views/validating_view.js')}"></script>
+<script type="text/javascript" src="${static.url('js/models/settings/advanced.js')}"></script>
+<script type="text/javascript" src="${static.url('js/views/settings/advanced_view.js')}"></script>
+
+<script type="text/javascript">
+$(document).ready(function () {
+
+    // proactively populate advanced b/c it has the filtered list and doesn't really follow the model pattern
+    var advancedModel = new CMS.Models.Settings.Advanced(${advanced_dict | n}, {parse: true});
+    advancedModel.blacklistKeys = ${advanced_blacklist | n};
+    advancedModel.url = "${reverse('course_advanced_settings_updates', kwargs=dict(org=context_course.location.org, course=context_course.location.course, name=context_course.location.name))}";
+
+    var editor = new CMS.Views.Settings.Advanced({
+      el: $('.settings-advanced'),
+      model: advancedModel
+      });
+
+editor.render();
+
+});
+
+</script>
+</%block>
+
+<%block name="content">
+<div class="wrapper-content wrapper">
+  <section class="content">
+    <header class="page">
+      <span class="title-sub">Settings</span>
+      <h1 class="title-1">Advanced Settings</h1>
+    </header>
+
+    <article class="content-primary" role="main">
+      <form id="settings_advanced" class="settings-advanced" method="post" action="">
+
+        <div class="message message-status confirm">
+          Your policy changes have been saved.
+        </div>
+
+        <div class="message message-status error">
+          There was an error saving your information. Please see below.
+        </div>
+
+        <section class="group-settings advanced-policies">
+          <header>
+            <h2 class="title-2">Manual Policy Definition</h2>
+            <span class="tip">Manually Edit Course Policy Values (JSON Key / Value pairs)</span>
+          </header>
+
+          <p class="instructions"><strong>Warning</strong>: Add only manual policy data that you are familiar
+          with.</p>
+
+          <ul class="list-input course-advanced-policy-list enum">
+              
+          </ul>
+
+          <div class="actions">
+            <a href="#" class="button new-button new-advanced-policy-item add-policy-data">
+              <span class="plus-icon white"></span>New Manual Policy
+            </a>            
+          </div>
+        </section>
+      </form>
+    </article>
+
+    <aside class="content-supplementary" role="complimentary">
+      <div class="bit">
+        <h3 class="title-3">How will these settings be used?</h3>
+        <p>Manual policies are JSON-based key and value pairs that allow you add additional settings which edX Studio will use when generating your course.</p>
+
+        <p>Any policies you define here will override any other information you've defined elsewhere in Studio. With this in mind, please be very careful and do not add policies that you are unfamiliar with (both their purpose and their syntax).</p>
+      </div>
+
+      <div class="bit">
+      % if context_course:
+      <% ctx_loc = context_course.location %>
+      <%! from django.core.urlresolvers import reverse %>
+        <h3 class="title-3">Other Course Settings</h3>
+        <nav class="nav-related">
+          <ul>
+            <li class="nav-item"><a href="${reverse('contentstore.views.get_course_settings', kwargs=dict(org=ctx_loc.org, course=ctx_loc.course, name=ctx_loc.name))}">Details &amp; Schedule</a></li>
+            <li class="nav-item"><a href="${reverse('contentstore.views.course_config_graders_page', kwargs={'org' : ctx_loc.org, 'course' : ctx_loc.course, 'name': ctx_loc.name})}">Grading</a></li>
+            <li class="nav-item"><a href="${reverse('manage_users', kwargs=dict(location=ctx_loc))}">Course Team</a></li>
+          </ul>
+        </nav>
+      % endif
+      </div>
+    </aside>
+  </section>
+</div>
+
+<!-- notification: change has been made and a save is needed -->
+<div class="wrapper wrapper-notification wrapper-notification-warning">
+  <div class="notification warning">
+    <div class="copy">
+      <i class="ss-icon ss-symbolicons-block icon icon-warning">&#x26A0;</i>
+
+      <p><strong>Note: </strong>Your changes will not take effect until you <strong>save your
+      progress</strong>. Take care with key and value formatting, as validation is <strong>not implemented</strong>.</p>
+    </div>
+
+    <div class="actions">
+      <ul>
+        <li><a href="#" class="save-button">Save</a></li>
+        <li><a href="#" class="cancel-button">Cancel</a></li>
+      </ul>
+    </div>
+  </div>
+</div>
+</%block>
\ No newline at end of file

cms/templates/settings_graders.html

@@ -126,7 +126,7 @@ from contentstore import utils
 
     <aside class="content-supplementary" role="complimentary">
       <div class="bit">
-        <h3 class="title-3">How will these settings be used</h3>
+        <h3 class="title-3">How will these settings be used?</h3>
         <p>Your grading settings will be used to calculate students grades and performance.</p>
 
         <p>Overall grade range will be used in students' final grades, which are calculated by the weighting you determine for each custom assignment type.</p>
@@ -141,6 +141,7 @@ from contentstore import utils
           <ul>
             <li class="nav-item"><a href="${reverse('contentstore.views.get_course_settings', kwargs=dict(org=ctx_loc.org, course=ctx_loc.course, name=ctx_loc.name))}">Details &amp; Schedule</a></li>
             <li class="nav-item"><a href="${reverse('manage_users', kwargs=dict(location=ctx_loc))}">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>
           </ul>
         </nav>
       % endif

cms/templates/unit.html

@@ -44,7 +44,7 @@
       </div>
       <div class="main-column">
         <article class="unit-body window">
-          <p class="unit-name-input"><label>Display Name:</label><input type="text" value="${unit.display_name}" class="unit-display-name-input" /></p>
+          <p class="unit-name-input"><label>Display Name:</label><input type="text" value="${unit.display_name | h}" class="unit-display-name-input" /></p>
           <ol class="components">
             % for id in components:
             <li class="component" data-id="${id}"/>

cms/templates/widgets/header.html

@@ -44,7 +44,7 @@
                   <li class="nav-item nav-course-settings-schedule"><a href="${reverse('contentstore.views.get_course_settings', kwargs=dict(org=ctx_loc.org, course=ctx_loc.course, name=ctx_loc.name))}">Schedule &amp; Details</a></li>
                   <li class="nav-item nav-course-settings-grading"><a href="${reverse('contentstore.views.course_config_graders_page', kwargs={'org' : ctx_loc.org, 'course' : ctx_loc.course, 'name': ctx_loc.name})}">Grading</a></li>
                   <li class="nav-item nav-course-settings-team"><a href="${reverse('manage_users', kwargs=dict(location=ctx_loc))}">Course Team</a></li>
-                  <!-- <li class="nav-item nav-course-settings-advanced"><a href="${reverse('course_settings', kwargs={'org' : ctx_loc.org, 'course' : ctx_loc.course, 'name': ctx_loc.name})}">Advanced Settings</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></li>
                 </ul>
               </div>
             </div>            

cms/templates/widgets/source-edit.html

@@ -10,7 +10,7 @@
       <h2>High Level Source Editing</h2>
     </header>
 
-    <form id="hls-form">
+    <form id="hls-form" enctype="multipart/form-data">
       <section class="source-edit">
           <textarea name="" data-metadata-name="source_code" class="source-edit-box hls-data" rows="8" cols="40">${metadata['source_code']|h}</textarea>
       </section>
@@ -18,6 +18,9 @@
         <button type="reset" class="hls-compile">Save &amp; Compile to edX XML</button>
         <button type="reset" class="hls-save">Save</button>
         <button type="reset" class="hls-refresh">Refresh</button>
+	<div style="display:none" id="hls-finput"></div>
+        <span id="message"></span>
+        <button type="reset" class="hls-upload" style="float:right">Upload</button>
       </div>
     </form>
 
@@ -25,88 +28,148 @@
   </section>
     
   <script type="text/javascript" src="/static/js/vendor/CodeMirror/stex.js"></script>
-  <script type="text/javascript">
-     $('#hls-trig-${hlskey}').leanModal({ top:40, overlay:0.8, closeButton: ".close-button"});
-
-     $('#hls-modal-${hlskey}').data('editor',CodeMirror.fromTextArea($('#hls-modal-${hlskey}').find('.hls-data')[0], {lineNumbers: true, mode: 'stex'}));
-
-     $('#hls-trig-${hlskey}').click(function(){slow_refresh_hls($('#hls-modal-${hlskey}'))})
-
-     // refresh button
-
-     $('#hls-modal-${hlskey}').find('.hls-refresh').click(function(){refresh_hls($('#hls-modal-${hlskey}'))});
-
-     function refresh_hls(el){
-	 el.data('editor').refresh();
-      }
-
-     function slow_refresh_hls(el){
-         el.delay(200).queue(function(){ 
-	       refresh_hls(el);
-	       $(this).dequeue(); 
-	   });
-	 // resize the codemirror box
-	 h = el.height();
-	 el.find('.CodeMirror-scroll').height(h-100);
-     }
-
-     // compile & save button
-
-     $('#hls-modal-${hlskey}').find('.hls-compile').click(compile_hls_${hlskey});
-     
-     function compile_hls_${hlskey}(){
-
-          editor = $('#hls-modal-${hlskey}').data('editor')
-          var myquery = { latexin: editor.getValue() };
-
-          $.ajax({
-              url: '${metadata.get('source_processor_url','https://qisx.mit.edu:5443/latex2edx')}',
-              type: 'GET',
-              contentType: 'application/json',
-              data: escape(JSON.stringify(myquery)),
-              crossDomain: true,
-              dataType: 'jsonp',
-              jsonpCallback: 'process_return_${hlskey}',
-              beforeSend: function (xhr) { xhr.setRequestHeader ("Authorization", "Basic eHFhOmFnYXJ3YWw="); },
-              timeout : 7000,
-              success: function(result) {
-		  console.log(result);
-              },
-              error: function() {
-                  alert('Error: cannot connect to latex2edx server');
-                  console.log('error!');
+  <script type = "text/javascript">
+  hlstrig = $('#hls-trig-${hlskey}');
+  hlsmodal = $('#hls-modal-${hlskey}');
+
+  hlstrig.leanModal({
+      top: 40,
+      overlay: 0.8,
+      closeButton: ".close-button"
+  });
+
+  hlsmodal.data('editor', CodeMirror.fromTextArea(hlsmodal.find('.hls-data')[0], {
+      lineNumbers: true,
+      mode: 'stex'
+  }));
+
+  $('#hls-trig-${hlskey}').click(function() {
+
+      ## this ought to be done using css instead
+      hlsmodal.attr('style', function(i,s) { return s + ' margin-left:0px !important; left:5%' });
+
+      ## setup file input
+      ## need to insert this only after hls triggered, because otherwise it
+      ## causes other <form> elements to become multipart/form-data, 
+      ## thus breaking multiple-choice input forms, for example.
+      $('#hls-finput').append('<input type="file" name="hlsfile" id="hlsfile" />');
+
+      var el = $('#hls-modal-${hlskey}');
+      setup_autoupload(el);
+      slow_refresh_hls(el);
+  });
+
+  // file upload button
+  hlsmodal.find('.hls-upload').click(function() {
+      $('#hls-modal-${hlskey}').find('#hlsfile').trigger('click');
+  });
+
+  // auto-upload after file is chosen
+  function setup_autoupload(el){
+      el.find('#hlsfile').change(function() {
+          var file = el.find('#hlsfile')[0].files[0];
+    
+          var reader = new FileReader();
+          reader.onload = function(event) {
+              var contents = event.target.result;
+	      el.data('editor').setValue(contents);
+	      // trigger compile & save
+	      el.find('.hls-compile').trigger('click');
+          };
+          reader.readAsText(file);
+      });
+  }
+
+  // refresh button
+  hlsmodal.find('.hls-refresh').click(function() {
+      refresh_hls(hlsmodal);
+  });
+
+  function refresh_hls(el) {
+      el.data('editor').refresh();
+      $('#lean_overlay').hide();	      // hide gray overlay
+  }
+
+  function slow_refresh_hls(el) {
+      el.delay(200).queue(function() {
+          refresh_hls(el);
+          $(this).dequeue();
+      });
+      // resize the codemirror box
+      var h = el.height();
+      el.find('.CodeMirror-scroll').height(h - 100);
+  }
+
+  // compile & save button
+  hlsmodal.find('.hls-compile').click(function() {
+      var el = $('#hls-modal-${hlskey}');
+      compile_hls(el);
+  });
+
+  // connect to server using POST (requires cross-domain-access)
+
+  function compile_hls(el) {
+      var editor = el.data('editor')
+      var hlsdata = editor.getValue();
+
+      $.ajax({
+          url: "https://studio-input-filter.mitx.mit.edu/latex2edx?raw=1",
+          type: "POST",
+          data: "" + hlsdata,
+          crossDomain: true,
+          processData: false,
+          success: function(data) {
+              xml = data.xml;
+              if (xml.length == 0) {
+                  alert('Conversion failed!  error:' + data.message);
+              } else {
+                  el.closest('.component').find('.CodeMirror-wrap')[0].CodeMirror.setValue(xml);
+                  save_hls(el);
               }
-          });
-	  // $('#hls-modal-${hlskey}').hide();
-     }
-
-     function process_return_${hlskey}(datadict){
-          // datadict is json of array with "xml" and "message"
-          // if "xml" value is '' then the conversion failed
-          xml = datadict.xml;
-          console.log('xml:');
-          console.log(xml);
-          if (xml.length==0){
-              alert('Conversion failed!  error:'+ datadict.message);
-          }else{
-              set_raw_edit_box(xml,'${hlskey}');
-              save_hls($('#hls-modal-${hlskey}'));
+          },
+          error: function() {
+              alert('Error: cannot connect to latex2edx server');
           }
-     }
-
-     function set_raw_edit_box(data,key){
-         // get the codemirror editor for the raw-edit-box
-         // it's a CodeMirror-wrap class element
-          $('#hls-modal-'+key).closest('.component').find('.CodeMirror-wrap')[0].CodeMirror.setValue(data);
-     }
-
-     // save button
-
-     $('#hls-modal-${hlskey}').find('.hls-save').click(function(){save_hls($('#hls-modal-${hlskey}'))});
-     
-     function save_hls(el){
-          el.find('.hls-data').val(el.data('editor').getValue());
-          el.closest('.component').find('.save-button').click();
-     }
+      });
+  }
+  
+  function process_return_${hlskey}(datadict) {
+      // datadict is json of array with "xml" and "message"
+      // if "xml" value is '' then the conversion failed
+      var xml = datadict.xml;
+      if (xml.length == 0) {
+          alert('Conversion failed!  error:' + datadict.message);
+      } else {
+          set_raw_edit_box(xml, '${hlskey}');
+          save_hls($('#hls-modal-${hlskey}'));
+      }
+  }
+
+
+  function set_raw_edit_box(data, key) {
+      // get the codemirror editor for the raw-edit-box
+      // it's a CodeMirror-wrap class element
+      $('#hls-modal-' + key).closest('.component').find('.CodeMirror-wrap')[0].CodeMirror.setValue(data);
+  }
+
+  // save button
+
+  hlsmodal.find('.hls-save').click(function() {
+      save_hls(hlsmodal);
+  });
+
+  function save_hls(el) {
+      el.find('.hls-data').val(el.data('editor').getValue());
+      el.closest('.component').find('.save-button').click();
+  }
+
+  ## add upload and download links / buttons to component edit box
+  hlsmodal.closest('.component').find('.component-actions').append('<div id="link-${hlskey}" style="float:right;"></div>');
+  $('#link-${hlskey}').html('<a class="upload-button standard" id="upload-${hlskey}">upload</a>');
+  $('#upload-${hlskey}').click(function() {
+      hlsmodal.closest('.component').find('.edit-button').trigger('click'); // open up editor window
+      $('#hls-trig-${hlskey}').trigger('click'); // open up HLS editor window
+      hlsmodal.find('#hlsfile').trigger('click');
+  });
 
   </script>

cms/urls.py

@@ -47,6 +47,10 @@ urlpatterns = ('',
     url(r'^(?P<org>[^/]+)/(?P<course>[^/]+)/settings-grading/(?P<name>[^/]+)$', 'contentstore.views.course_config_graders_page', name='course_settings'),
     url(r'^(?P<org>[^/]+)/(?P<course>[^/]+)/settings-details/(?P<name>[^/]+)/section/(?P<section>[^/]+).*$', 'contentstore.views.course_settings_updates', name='course_settings'),
     url(r'^(?P<org>[^/]+)/(?P<course>[^/]+)/settings-grading/(?P<name>[^/]+)/(?P<grader_index>.*)$', 'contentstore.views.course_grader_updates', name='course_settings'),
+    # 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>[^/]+)/(?P<category>[^/]+)/(?P<name>[^/]+)/gradeas.*$', 'contentstore.views.assignment_type_update', name='assignment_type_update'),
 

common/djangoapps/course_groups/cohorts.py

@@ -6,6 +6,7 @@ forums, and to the cohort admin views.
 from django.contrib.auth.models import User
 from django.http import Http404
 import logging
+import random
 
 from courseware import courses
 from student.models import get_user_by_username_or_email
@@ -64,7 +65,23 @@ def is_commentable_cohorted(course_id, commentable_id):
                                                                ans))
     return ans
 
+    
+def get_cohorted_commentables(course_id):
+    """
+    Given a course_id return a list of strings representing cohorted commentables
+    """
+
+    course = courses.get_course_by_id(course_id)
+    
+    if not course.is_cohorted:
+        # this is the easy case :)
+        ans = []
+    else: 
+        ans = course.cohorted_discussions
 
+    return ans
+    
+    
 def get_cohort(user, course_id):
     """
     Given a django User and a course_id, return the user's cohort in that
@@ -96,9 +113,30 @@ def get_cohort(user, course_id):
                                             group_type=CourseUserGroup.COHORT,
                                             users__id=user.id)
     except CourseUserGroup.DoesNotExist:
-        # TODO: add auto-cohorting logic here once we know what that will be.
+        # Didn't find the group.  We'll go on to create one if needed.
+        pass
+
+    if not course.auto_cohort:
         return None
 
+    choices = course.auto_cohort_groups
+    if len(choices) == 0:
+        # Nowhere to put user
+        log.warning("Course %s is auto-cohorted, but there are no"
+                    " auto_cohort_groups specified",
+                    course_id)
+        return None
+
+    # Put user in a random group, creating it if needed
+    group_name = random.choice(choices)
+    group, created = CourseUserGroup.objects.get_or_create(
+        course_id=course_id,
+        group_type=CourseUserGroup.COHORT,
+        name=group_name)
+    
+    user.course_groups.add(group)
+    return group
+
 
 def get_course_cohorts(course_id):
     """

common/djangoapps/course_groups/tests/tests.py

@@ -47,7 +47,10 @@ class TestCohorts(django.test.TestCase):
 
     @staticmethod
     def config_course_cohorts(course, discussions,
-                              cohorted, cohorted_discussions=None):
+                              cohorted,
+                              cohorted_discussions=None,
+                              auto_cohort=None,
+                              auto_cohort_groups=None):
         """
         Given a course with no discussion set up, add the discussions and set
         the cohort config appropriately.
@@ -59,6 +62,9 @@ class TestCohorts(django.test.TestCase):
             cohorted: bool.
             cohorted_discussions: optional list of topic names.  If specified,
                 converts them to use the same ids as topic names.
+            auto_cohort: optional bool.
+            auto_cohort_groups: optional list of strings
+                      (names of groups to put students into).
 
         Returns:
             Nothing -- modifies course in place.
@@ -76,6 +82,12 @@ class TestCohorts(django.test.TestCase):
         if cohorted_discussions is not None:
             d["cohorted_discussions"] = [to_id(name)
                                          for name in cohorted_discussions]
+
+        if auto_cohort is not None:
+            d["auto_cohort"] = auto_cohort
+        if auto_cohort_groups is not None:
+            d["auto_cohort_groups"] = auto_cohort_groups
+
         course.metadata["cohort_config"] = d
 
 
@@ -89,12 +101,9 @@ class TestCohorts(django.test.TestCase):
 
 
     def test_get_cohort(self):
-        # Need to fix this, but after we're testing on staging.  (Looks like
-        # problem is that when get_cohort internally tries to look up the
-        # course.id, it fails, even though we loaded it through the modulestore.
-
-        # Proper fix: give all tests a standard modulestore that uses the test
-        # dir.
+        """
+        Make sure get_cohort() does the right thing when the course is cohorted
+        """
         course = modulestore().get_course("edX/toy/2012_Fall")
         self.assertEqual(course.id, "edX/toy/2012_Fall")
         self.assertFalse(course.is_cohorted)
@@ -122,6 +131,54 @@ class TestCohorts(django.test.TestCase):
         self.assertEquals(get_cohort(other_user, course.id), None,
                           "other_user shouldn't have a cohort")
 
+    def test_auto_cohorting(self):
+        """
+        Make sure get_cohort() does the right thing when the course is auto_cohorted
+        """
+        course = modulestore().get_course("edX/toy/2012_Fall")
+        self.assertEqual(course.id, "edX/toy/2012_Fall")
+        self.assertFalse(course.is_cohorted)
+
+        user1 = User.objects.create(username="test", email="a@b.com")
+        user2 = User.objects.create(username="test2", email="a2@b.com")
+        user3 = User.objects.create(username="test3", email="a3@b.com")
+
+        cohort = CourseUserGroup.objects.create(name="TestCohort",
+                                                course_id=course.id,
+                               group_type=CourseUserGroup.COHORT)
+
+        # user1 manually added to a cohort
+        cohort.users.add(user1)
+
+        # Make the course auto cohorted...
+        self.config_course_cohorts(course, [], cohorted=True,
+                                   auto_cohort=True,
+                                   auto_cohort_groups=["AutoGroup"])
+
+        self.assertEquals(get_cohort(user1, course.id).id, cohort.id,
+                          "user1 should stay put")
+
+        self.assertEquals(get_cohort(user2, course.id).name, "AutoGroup",
+                          "user2 should be auto-cohorted")
+
+        # Now make the group list empty
+        self.config_course_cohorts(course, [], cohorted=True,
+                                   auto_cohort=True,
+                                   auto_cohort_groups=[])
+
+        self.assertEquals(get_cohort(user3, course.id), None,
+                          "No groups->no auto-cohorting")
+        
+        # Now make it different
+        self.config_course_cohorts(course, [], cohorted=True,
+                                   auto_cohort=True,
+                                   auto_cohort_groups=["OtherGroup"])
+
+        self.assertEquals(get_cohort(user3, course.id).name, "OtherGroup",
+                          "New list->new group")
+        self.assertEquals(get_cohort(user2, course.id).name, "AutoGroup",
+                          "user2 should still be in originally placed cohort")
+
 
     def test_get_course_cohorts(self):
         course1_id = 'a/b/c'

common/djangoapps/student/views.py

@@ -115,7 +115,7 @@ def get_date_for_press(publish_date):
 
 def press(request):
     json_articles = cache.get("student_press_json_articles")
-    if json_articles == None:
+    if json_articles is None:
         if hasattr(settings, 'RSS_URL'):
             content = urllib.urlopen(settings.PRESS_URL).read()
             json_articles = json.loads(content)
@@ -301,7 +301,7 @@ def change_enrollment(request):
     action = request.POST.get("enrollment_action", "")
 
     course_id = request.POST.get("course_id", None)
-    if course_id == None:
+    if course_id is None:
         return HttpResponse(json.dumps({'success': False,
                                         'error': 'There was an error receiving the course id.'}))
 
@@ -385,7 +385,7 @@ def login_user(request, error=""):
         try:
             login(request, user)
             if request.POST.get('remember') == 'true':
-                request.session.set_expiry(None)  # or change to 604800 for 7 days
+                request.session.set_expiry(604800)
                 log.debug("Setting user session to never expire")
             else:
                 request.session.set_expiry(0)
@@ -554,7 +554,7 @@ def create_account(request, post_override=None):
     try:
         validate_slug(post_vars['username'])
     except ValidationError:
-        js['value'] = "Username should only consist of A-Z and 0-9.".format(field=a)
+        js['value'] = "Username should only consist of A-Z and 0-9, with no spaces.".format(field=a)
         js['field'] = 'username'
         return HttpResponse(json.dumps(js))
 
@@ -1203,7 +1203,7 @@ def _get_news(top=None):
     "Return the n top news items on settings.RSS_URL"
 
     feed_data = cache.get("students_index_rss_feed_data")
-    if feed_data == None:
+    if feed_data is None:
         if hasattr(settings, 'RSS_URL'):
             feed_data = urllib.urlopen(settings.RSS_URL).read()
         else:

common/djangoapps/terrain/factories.py

 from student.models import User, UserProfile, Registration
+from django.contrib.auth.models import Group
 from datetime import datetime
 from factory import Factory
 from xmodule.modulestore import Location
@@ -8,6 +9,12 @@ from uuid import uuid4
 from xmodule.timeparse import stringify_time
 
 
+class GroupFactory(Factory):
+    FACTORY_FOR = Group
+
+    name = 'staff_MITx/999/Robot_Super_Course'
+    
+
 class UserProfileFactory(Factory):
     FACTORY_FOR = UserProfile
 

common/djangoapps/terrain/steps.py

 from lettuce import world, step
 from factories import *
-from django.core.management import call_command
 from lettuce.django import django_url
-from django.conf import settings
 from django.contrib.auth.models import User
 from student.models import CourseEnrollment
 from urllib import quote_plus
@@ -21,6 +19,11 @@ def wait(step, seconds):
     time.sleep(float(seconds))
 
 
+@step('I reload the page$')
+def reload_the_page(step):
+    world.browser.reload()
+
+
 @step('I (?:visit|access|open) the homepage$')
 def i_visit_the_homepage(step):
     world.browser.visit(django_url('/'))
@@ -105,6 +108,11 @@ def i_am_an_edx_user(step):
 
 #### helper functions
 
+@world.absorb
+def scroll_to_bottom():
+    # Maximize the browser
+    world.browser.execute_script("window.scrollTo(0, screen.height);")
+
 
 @world.absorb
 def create_user(uname):

common/lib/capa/capa/capa_problem.py

@@ -510,7 +510,9 @@ class LoncapaProblem(object):
 
         # let each Response render itself
         if problemtree in self.responders:
-            return self.responders[problemtree].render_html(self._extract_html)
+            overall_msg = self.correct_map.get_overall_message()
+            return self.responders[problemtree].render_html(self._extract_html,
+                                                response_msg=overall_msg)
 
         # let each custom renderer render itself:
         if problemtree.tag in customrender.registry.registered_tags():

common/lib/capa/capa/correctmap.py

@@ -27,6 +27,7 @@ class CorrectMap(object):
         self.cmap = dict()
         self.items = self.cmap.items
         self.keys = self.cmap.keys
+        self.overall_message = ""
         self.set(*args, **kwargs)
 
     def __getitem__(self, *args, **kwargs):
@@ -104,16 +105,21 @@ class CorrectMap(object):
         return self.is_queued(answer_id) and self.cmap[answer_id]['queuestate']['key'] == test_key
 
     def get_queuetime_str(self, answer_id):
-        return self.cmap[answer_id]['queuestate']['time']
+        if self.cmap[answer_id]['queuestate']:
+            return self.cmap[answer_id]['queuestate']['time']
+        else:
+            return None
 
     def get_npoints(self, answer_id):
-        npoints = self.get_property(answer_id, 'npoints')
-        if npoints is not None:
-            return npoints
-        elif self.is_correct(answer_id):
-            return 1
-         # if not correct and no points have been assigned, return 0
-        return 0
+        """ Return the number of points for an answer:
+            If the answer is correct, return the assigned
+            number of points (default: 1 point)
+            Otherwise, return 0 points """
+        if self.is_correct(answer_id):
+            npoints = self.get_property(answer_id, 'npoints')
+            return npoints if npoints is not None else 1
+        else:
+            return 0
 
     def set_property(self, answer_id, property, value):
         if answer_id in self.cmap:
@@ -153,3 +159,15 @@ class CorrectMap(object):
         if not isinstance(other_cmap, CorrectMap):
             raise Exception('CorrectMap.update called with invalid argument %s' % other_cmap)
         self.cmap.update(other_cmap.get_dict())
+        self.set_overall_message(other_cmap.get_overall_message())
+
+
+    def set_overall_message(self, message_str):
+        """ Set a message that applies to the question as a whole,
+            rather than to individual inputs. """
+        self.overall_message = str(message_str) if message_str else ""
+
+    def get_overall_message(self):
+        """ Retrieve a message that applies to the question as a whole.
+        If no message is available, returns the empty string """
+        return self.overall_message

common/lib/capa/capa/responsetypes.py

@@ -174,13 +174,14 @@ class LoncapaResponse(object):
         '''
         return sum(self.maxpoints.values())
 
-    def render_html(self, renderer):
+    def render_html(self, renderer, response_msg=''):
         '''
         Return XHTML Element tree representation of this Response.
 
         Arguments:
 
           - renderer : procedure which produces HTML given an ElementTree
+          - response_msg: a message displayed at the end of the Response
         '''
         # render ourself as a <span> + our content
         tree = etree.Element('span')
@@ -195,6 +196,11 @@ class LoncapaResponse(object):
             if item_xhtml is not None:
                 tree.append(item_xhtml)
         tree.tail = self.xml.tail
+
+        # Add a <div> for the message at the end of the response
+        if response_msg:
+            tree.append(self._render_response_msg_html(response_msg))
+
         return tree
 
     def evaluate_answers(self, student_answers, old_cmap):
@@ -319,6 +325,29 @@ class LoncapaResponse(object):
     def __unicode__(self):
         return u'LoncapaProblem Response %s' % self.xml.tag
 
+    def _render_response_msg_html(self, response_msg):
+        """ Render a <div> for a message that applies to the entire response.
+
+        *response_msg* is a string, which may contain XHTML markup
+        
+        Returns an etree element representing the response message <div> """
+        # First try wrapping the text in a <div> and parsing
+        # it as an XHTML tree
+        try:
+            response_msg_div = etree.XML('<div>%s</div>' % str(response_msg))
+
+        # If we can't do that, create the <div> and set the message
+        # as the text of the <div>
+        except:
+            response_msg_div = etree.Element('div')
+            response_msg_div.text = str(response_msg)
+
+
+        # Set the css class of the message <div>
+        response_msg_div.set("class", "response_message")
+
+        return response_msg_div
+
 
 #-----------------------------------------------------------------------------
 
@@ -965,6 +994,7 @@ def sympy_check2():
         # not expecting 'unknown's
         correct = ['unknown'] * len(idset)
         messages = [''] * len(idset)
+        overall_message = ""
 
         # put these in the context of the check function evaluator
         # note that this doesn't help the "cfn" version - only the exec version
@@ -996,6 +1026,10 @@ def sympy_check2():
             # the list of messages to be filled in by the check function
             'messages': messages,
 
+            # a message that applies to the entire response
+            # instead of a particular input
+            'overall_message': overall_message,
+
             # any options to be passed to the cfn
             'options': self.xml.get('options'),
             'testdat': 'hello world',
@@ -1010,6 +1044,7 @@ def sympy_check2():
                 exec self.code in self.context['global_context'], self.context
                 correct = self.context['correct']
                 messages = self.context['messages']
+                overall_message = self.context['overall_message']
             except Exception as err:
                 print "oops in customresponse (code) error %s" % err
                 print "context = ", self.context
@@ -1044,34 +1079,100 @@ def sympy_check2():
                 log.error(traceback.format_exc())
                 raise Exception("oops in customresponse (cfn) error %s" % err)
             log.debug("[courseware.capa.responsetypes.customresponse.get_score] ret = %s" % ret)
+
             if type(ret) == dict:
-                correct = ['correct'] * len(idset) if ret['ok'] else ['incorrect'] * len(idset)
-                msg = ret['msg']
-
-                if 1:
-                    # try to clean up message html
-                    msg = '<html>' + msg + '</html>'
-                    msg = msg.replace('&#60;', '&lt;')
-                    #msg = msg.replace('&lt;','<')
-                    msg = etree.tostring(fromstring_bs(msg, convertEntities=None),
-                                         pretty_print=True)
-                    #msg = etree.tostring(fromstring_bs(msg),pretty_print=True)
-                    msg = msg.replace('&#13;', '')
-                    #msg = re.sub('<html>(.*)</html>','\\1',msg,flags=re.M|re.DOTALL)   # python 2.7
-                    msg = re.sub('(?ms)<html>(.*)</html>', '\\1', msg)
-
-                messages[0] = msg
+
+                # One kind of dictionary the check function can return has the
+                # form {'ok': BOOLEAN, 'msg': STRING}
+                # If there are multiple inputs, they all get marked
+                # to the same correct/incorrect value
+                if 'ok' in ret:
+                    correct = ['correct'] * len(idset) if ret['ok'] else ['incorrect'] * len(idset)
+                    msg = ret.get('msg', None)
+                    msg = self.clean_message_html(msg)
+
+                    # If there is only one input, apply the message to that input
+                    # Otherwise, apply the message to the whole problem
+                    if len(idset) > 1:
+                        overall_message = msg
+                    else:
+                        messages[0] = msg
+
+
+                # Another kind of dictionary the check function can return has
+                # the form:
+                # {'overall_message': STRING,
+                #  'input_list': [{ 'ok': BOOLEAN, 'msg': STRING }, ...] }
+                # 
+                # This allows the function to return an 'overall message'
+                # that applies to the entire problem, as well as correct/incorrect
+                # status and messages for individual inputs
+                elif 'input_list' in ret:
+                    overall_message = ret.get('overall_message', '')
+                    input_list = ret['input_list']
+
+                    correct = []
+                    messages = []
+                    for input_dict in input_list:
+                        correct.append('correct' if input_dict['ok'] else 'incorrect')
+                        msg = self.clean_message_html(input_dict['msg']) if 'msg' in input_dict else None
+                        messages.append(msg)
+
+                # Otherwise, we do not recognize the dictionary
+                # Raise an exception
+                else:
+                    log.error(traceback.format_exc())
+                    raise Exception("CustomResponse: check function returned an invalid dict")
+
+            # The check function can return a boolean value,
+            # indicating whether all inputs should be marked
+            # correct or incorrect
             else:
                 correct = ['correct'] * len(idset) if ret else ['incorrect'] * len(idset)
 
         # build map giving "correct"ness of the answer(s)
         correct_map = CorrectMap()
+
+        overall_message = self.clean_message_html(overall_message)
+        correct_map.set_overall_message(overall_message)
+
         for k in range(len(idset)):
             npoints = self.maxpoints[idset[k]] if correct[k] == 'correct' else 0
             correct_map.set(idset[k], correct[k], msg=messages[k],
                             npoints=npoints)
         return correct_map
 
+    def clean_message_html(self, msg):
+
+        # If *msg* is an empty string, then the code below
+        # will return "</html>".  To avoid this, we first check
+        # that *msg* is a non-empty string.
+        if msg:
+
+            # When we parse *msg* using etree, there needs to be a root
+            # element, so we wrap the *msg* text in <html> tags
+            msg = '<html>' + msg + '</html>'
+
+            # Replace < characters
+            msg = msg.replace('&#60;', '&lt;')
+
+            # Use etree to prettify the HTML
+            msg = etree.tostring(fromstring_bs(msg, convertEntities=None),
+                                 pretty_print=True)
+
+            msg = msg.replace('&#13;', '')
+
+            # Remove the <html> tags we introduced earlier, so we're
+            # left with just the prettified message markup
+            msg = re.sub('(?ms)<html>(.*)</html>', '\\1', msg)
+
+            # Strip leading and trailing whitespace
+            return msg.strip()
+
+        # If we start with an empty string, then return an empty string
+        else:
+            return ""
+
     def get_answers(self):
         '''
         Give correct answer expected for this response.

common/lib/capa/capa/templates/choicegroup.html

 <form class="choicegroup capa_inputtype" id="inputtype_${id}">
-  <div class="indicator_container">
-    % if status == 'unsubmitted':
-    <span class="unanswered" style="display:inline-block;" id="status_${id}"></span>
-    % elif status == 'correct': 
-    <span class="correct" id="status_${id}"></span>
-    % elif status == 'incorrect':
-    <span class="incorrect" id="status_${id}"></span>
-    % elif status == 'incomplete':
-    <span class="incorrect" id="status_${id}"></span>
-    % endif
-  </div>
 
   <fieldset>
     % for choice_id, choice_description in choices:
-    <label for="input_${id}_${choice_id}">  <input type="${input_type}" name="input_${id}${name_array_suffix}" id="input_${id}_${choice_id}" value="${choice_id}"
+    <label for="input_${id}_${choice_id}">          
+
+        % if choice_id in value:
+        <span class="indicator_container">
+            % if status == 'unsubmitted':
+            <span class="unanswered" style="display:inline-block;" id="status_${id}"></span>
+            % elif status == 'correct': 
+            <span class="correct" id="status_${id}"></span>
+            % elif status == 'incorrect':
+            <span class="incorrect" id="status_${id}"></span>
+            % elif status == 'incomplete':
+            <span class="incorrect" id="status_${id}"></span>
+            % endif
+        </span>
+        % else:
+        <span class="indicator_container">&#160;</span>
+        % endif
+        
+        <input type="${input_type}" name="input_${id}${name_array_suffix}" id="input_${id}_${choice_id}" value="${choice_id}"
     % if choice_id in value:
     checked="true"
     % endif
-    /> ${choice_description} </label>
+    />
+    
+    ${choice_description}
+
+    </label>
+
     % endfor
     <span id="answer_${id}"></span>
   </fieldset>

common/lib/capa/capa/tests/test_correctmap.py

+import unittest
+from capa.correctmap import CorrectMap
+import datetime
+
+class CorrectMapTest(unittest.TestCase):
+
+    def setUp(self):
+        self.cmap = CorrectMap()
+
+    def test_set_input_properties(self):
+
+        # Set the correctmap properties for two inputs
+        self.cmap.set(answer_id='1_2_1',
+                    correctness='correct',
+                    npoints=5,
+                    msg='Test message',
+                    hint='Test hint',
+                    hintmode='always',
+                    queuestate={'key':'secretstring',
+                                'time':'20130228100026'})
+
+        self.cmap.set(answer_id='2_2_1',
+                    correctness='incorrect',
+                    npoints=None,
+                    msg=None,
+                    hint=None,
+                    hintmode=None,
+                    queuestate=None)
+
+        # Assert that each input has the expected properties
+        self.assertTrue(self.cmap.is_correct('1_2_1'))
+        self.assertFalse(self.cmap.is_correct('2_2_1'))
+
+        self.assertEqual(self.cmap.get_correctness('1_2_1'), 'correct')
+        self.assertEqual(self.cmap.get_correctness('2_2_1'), 'incorrect')
+
+        self.assertEqual(self.cmap.get_npoints('1_2_1'), 5)
+        self.assertEqual(self.cmap.get_npoints('2_2_1'), 0)
+
+        self.assertEqual(self.cmap.get_msg('1_2_1'), 'Test message')
+        self.assertEqual(self.cmap.get_msg('2_2_1'), None)
+
+        self.assertEqual(self.cmap.get_hint('1_2_1'), 'Test hint')
+        self.assertEqual(self.cmap.get_hint('2_2_1'), None)
+
+        self.assertEqual(self.cmap.get_hintmode('1_2_1'), 'always')
+        self.assertEqual(self.cmap.get_hintmode('2_2_1'), None)
+
+        self.assertTrue(self.cmap.is_queued('1_2_1'))
+        self.assertFalse(self.cmap.is_queued('2_2_1'))
+
+        self.assertEqual(self.cmap.get_queuetime_str('1_2_1'), '20130228100026')
+        self.assertEqual(self.cmap.get_queuetime_str('2_2_1'), None)
+
+        self.assertTrue(self.cmap.is_right_queuekey('1_2_1', 'secretstring'))
+        self.assertFalse(self.cmap.is_right_queuekey('1_2_1', 'invalidstr'))
+        self.assertFalse(self.cmap.is_right_queuekey('1_2_1', ''))
+        self.assertFalse(self.cmap.is_right_queuekey('1_2_1', None))
+
+        self.assertFalse(self.cmap.is_right_queuekey('2_2_1', 'secretstring'))
+        self.assertFalse(self.cmap.is_right_queuekey('2_2_1', 'invalidstr'))
+        self.assertFalse(self.cmap.is_right_queuekey('2_2_1', ''))
+        self.assertFalse(self.cmap.is_right_queuekey('2_2_1', None))
+
+
+    def test_get_npoints(self):
+        # Set the correctmap properties for 4 inputs
+        # 1) correct, 5 points
+        # 2) correct, None points
+        # 3) incorrect, 5 points
+        # 4) incorrect, None points
+        # 5) correct, 0 points
+        self.cmap.set(answer_id='1_2_1',
+                    correctness='correct',
+                    npoints=5)
+
+        self.cmap.set(answer_id='2_2_1',
+                    correctness='correct',
+                    npoints=None)
+
+        self.cmap.set(answer_id='3_2_1',
+                    correctness='incorrect',
+                    npoints=5)
+
+        self.cmap.set(answer_id='4_2_1',
+                    correctness='incorrect',
+                    npoints=None)
+
+        self.cmap.set(answer_id='5_2_1',
+                    correctness='correct',
+                    npoints=0)
+
+        # Assert that we get the expected points
+        # If points assigned and correct --> npoints
+        # If no points assigned and correct --> 1 point
+        # Otherwise --> 0 points
+        self.assertEqual(self.cmap.get_npoints('1_2_1'), 5)
+        self.assertEqual(self.cmap.get_npoints('2_2_1'), 1)
+        self.assertEqual(self.cmap.get_npoints('3_2_1'), 0)
+        self.assertEqual(self.cmap.get_npoints('4_2_1'), 0)
+        self.assertEqual(self.cmap.get_npoints('5_2_1'), 0)
+
+
+    def test_set_overall_message(self):
+
+        # Default is an empty string string
+        self.assertEqual(self.cmap.get_overall_message(), "")
+
+        # Set a message that applies to the whole question
+        self.cmap.set_overall_message("Test message")
+
+        # Retrieve the message
+        self.assertEqual(self.cmap.get_overall_message(), "Test message")
+
+        # Setting the message to None --> empty string
+        self.cmap.set_overall_message(None)
+        self.assertEqual(self.cmap.get_overall_message(), "")
+
+    def test_update_from_correctmap(self):
+        # Initialize a CorrectMap with some properties
+        self.cmap.set(answer_id='1_2_1',
+                    correctness='correct',
+                    npoints=5,
+                    msg='Test message',
+                    hint='Test hint',
+                    hintmode='always',
+                    queuestate={'key':'secretstring',
+                                'time':'20130228100026'})
+
+        self.cmap.set_overall_message("Test message")
+
+        # Create a second cmap, then update it to have the same properties
+        # as the first cmap
+        other_cmap = CorrectMap()
+        other_cmap.update(self.cmap)
+        
+        # Assert that it has all the same properties
+        self.assertEqual(other_cmap.get_overall_message(),
+                        self.cmap.get_overall_message())
+
+        self.assertEqual(other_cmap.get_dict(),
+                        self.cmap.get_dict())
+
+
+    def test_update_from_invalid(self):
+        # Should get an exception if we try to update() a CorrectMap
+        # with a non-CorrectMap value
+        invalid_list = [None, "string", 5, datetime.datetime.today()]
+
+        for invalid in invalid_list:
+            with self.assertRaises(Exception):
+                self.cmap.update(invalid)

common/lib/capa/capa/tests/test_files/choiceresponse_checkbox.xml

-<problem>
-<choiceresponse>
-  <checkboxgroup>
-    <choice correct="false">
-      <startouttext />This is foil One.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Two.<endouttext />
-    </choice>
-    <choice correct="true">
-      <startouttext />This is foil Three.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Four.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Five.<endouttext />
-    </choice>
-  </checkboxgroup>
-</choiceresponse>
-<choiceresponse>
-  <checkboxgroup>
-    <choice correct="false">
-      <startouttext />This is foil One.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Two.<endouttext />
-    </choice>
-    <choice correct="true">
-      <startouttext />This is foil Three.<endouttext />
-    </choice>
-    <choice correct="true">
-      <startouttext />This is foil Four.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Five.<endouttext />
-    </choice>
-  </checkboxgroup>
-</choiceresponse>
-<choiceresponse>
-  <checkboxgroup>
-    <choice correct="false">
-      <startouttext />This is foil One.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Two.<endouttext />
-    </choice>
-    <choice correct="true">
-      <startouttext />This is foil Three.<endouttext />
-    </choice>
-    <choice correct="true">
-      <startouttext />This is foil Four.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Five.<endouttext />
-    </choice>
-  </checkboxgroup>
-</choiceresponse>
-</problem>

common/lib/capa/capa/tests/test_files/choiceresponse_radio.xml

-<problem>
-<choiceresponse>
-  <radiogroup>
-    <choice correct="false">
-      <startouttext />This is foil One.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Two.<endouttext />
-    </choice>
-    <choice correct="true">
-      <startouttext />This is foil Three.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Four.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Five.<endouttext />
-    </choice>
-  </radiogroup>
-</choiceresponse>
-<choiceresponse>
-  <radiogroup>
-    <choice correct="false">
-      <startouttext />This is foil One.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Two.<endouttext />
-    </choice>
-    <choice correct="true">
-      <startouttext />This is foil Three.<endouttext />
-    </choice>
-    <choice correct="true">
-      <startouttext />This is foil Four.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Five.<endouttext />
-    </choice>
-  </radiogroup>
-</choiceresponse>
-</problem>

common/lib/capa/capa/tests/test_files/coderesponse.xml

-<problem>
-<text>
-<h2>Code response</h2>
-
-<p>
-</p>
-
-<text>
-Write a program to compute the square of a number
-  <coderesponse tests="repeat:2,generate">
-    <textbox rows="10" cols="70"  mode="python"/>
-    <codeparam>
-      <initial_display>def square(x):</initial_display>
-      <answer_display>answer</answer_display>
-      <grader_payload>grader stuff</grader_payload>
-    </codeparam>
-  </coderesponse>
-</text>
-
-<text>
-Write a program to compute the square of a number
-  <coderesponse tests="repeat:2,generate">
-    <textbox rows="10" cols="70"  mode="python"/>
-    <codeparam>
-      <initial_display>def square(x):</initial_display>
-      <answer_display>answer</answer_display>
-      <grader_payload>grader stuff</grader_payload>
-    </codeparam>
-  </coderesponse>
-</text>
-
-</text>
-</problem>

common/lib/capa/capa/tests/test_files/coderesponse_externalresponseformat.xml

-<problem>
-<text>
-<h2>Code response</h2>
-
-<p>
-</p>
-
-<text>
-Write a program to compute the square of a number
-  <coderesponse tests="repeat:2,generate">
-    <textbox rows="10" cols="70"  mode="python"/>
-    <answer><![CDATA[
-initial_display = """
-def square(n):
-"""
-
-answer = """
-def square(n):
-    return n**2    
-"""
-
-preamble = """ 
-import sys, time
-"""
-
-test_program = """
-import random
-import operator
-
-def testSquare(n = None):
-    if n is None:
-       n = random.randint(2, 20)
-    print 'Test is: square(%d)'%n
-    return str(square(n))
-
-def main():
-   f = os.fdopen(3,'w')
-   test = int(sys.argv[1])
-   rndlist = map(int,os.getenv('rndlist').split(','))
-   random.seed(rndlist[0])
-   if test == 1: f.write(testSquare(0))
-   elif test == 2: f.write(testSquare(1))
-   else:  f.write(testSquare())
-   f.close()
-
-main()
-sys.exit(0)
-"""
-]]>
-    </answer>
-  </coderesponse>
-</text>
-
-<text>
-Write a program to compute the cube of a number
-  <coderesponse tests="repeat:2,generate">
-    <textbox rows="10" cols="70"  mode="python"/>
-    <answer><![CDATA[
-initial_display = """
-def cube(n):
-"""
-
-answer = """
-def cube(n):
-    return n**3    
-"""
-
-preamble = """ 
-import sys, time
-"""
-
-test_program = """
-import random
-import operator
-
-def testCube(n = None):
-    if n is None:
-       n = random.randint(2, 20)
-    print 'Test is: cube(%d)'%n
-    return str(cube(n))
-
-def main():
-   f = os.fdopen(3,'w')
-   test = int(sys.argv[1])
-   rndlist = map(int,os.getenv('rndlist').split(','))
-   random.seed(rndlist[0])
-   if test == 1: f.write(testCube(0))
-   elif test == 2: f.write(testCube(1))
-   else:  f.write(testCube())
-   f.close()
-
-main()
-sys.exit(0)
-"""
-]]>
-    </answer>
-  </coderesponse>
-</text>
-
-</text>
-</problem>

common/lib/capa/capa/tests/test_files/filename_convert_test.txt

+This file is used to test converting file handles to filenames in the capa utility module

common/lib/capa/capa/tests/test_files/formularesponse_with_hint.xml

-<problem>
-<script type="loncapa/python">
-# from loncapa import *
-x1 = 4 # lc_random(2,4,1)
-y1 = 5 # lc_random(3,7,1)
-
-x2 = 10 # lc_random(x1+1,9,1)
-y2 = 20 # lc_random(y1+1,15,1)
-
-m = (y2-y1)/(x2-x1)
-b = y1 - m*x1
-answer = "%s*x+%s" % (m,b)
-answer = answer.replace('+-','-')
-
-inverted_m = (x2-x1)/(y2-y1)
-inverted_b = b
-wrongans = "%s*x+%s" % (inverted_m,inverted_b)
-wrongans = wrongans.replace('+-','-')
-</script>
-
-<text>
-<p>Hints can be provided to students, based on the last response given, as well as the history of responses given.  Here is an example of a hint produced by a Formula Response problem.</p>
-
-<p>
-What is the equation of the line which passess through ($x1,$y1) and
-($x2,$y2)?</p>
-
-<p>The correct answer is <tt>$answer</tt>. A common error is to invert the equation for the slope.  Enter <tt>
-$wrongans</tt> to see a hint.</p>
-
-</text>
-
-<formularesponse samples="x@-5:5#11" id="11" answer="$answer">
- <responseparam description="Numerical Tolerance" type="tolerance" default="0.001" name="tol" /> 
- <text>y = <textline size="25" /></text>
-  <hintgroup>
-   <formulahint samples="x@-5:5#11" answer="$wrongans" name="inversegrad">
-   </formulahint>
-   <hintpart on="inversegrad">
-    <text>You have inverted the slope in the question.</text>
-   </hintpart>
-  </hintgroup>     
-</formularesponse>
-</problem>
-

common/lib/capa/capa/tests/test_files/imageresponse.xml

-<problem>
-<text><p>
-Two skiers are on frictionless black diamond ski slopes.
-Hello</p></text>
-
-<imageresponse max="1" loncapaid="11">
-<imageinput src="/static/Physics801/Figures/Skier-conservation of energy.jpg" width="560" height="388" rectangle="(490,11)-(556,98)"/>
-<text>Click on the image where the top skier will stop momentarily if the top skier starts from rest.</text>
-<imageinput src="/static/Physics801/Figures/Skier-conservation of energy.jpg" width="560" height="388" rectangle="(242,202)-(296,276)"/>
-<text>Click on the image where the lower skier will stop momentarily if the lower skier starts from rest.</text>
-<imageinput src="/static/Physics801/Figures/Skier-conservation of energy.jpg" width="560" height="388" rectangle="(490,11)-(556,98);(242,202)-(296,276)"/>
-<text>Click on either of the two positions as discussed previously.</text>
-<imageinput src="/static/Physics801/Figures/Skier-conservation of energy.jpg" width="560" height="388" rectangle="(490,11)-(556,98);(242,202)-(296,276)"/>
-<text>Click on either of the two positions as discussed previously.</text>
-<imageinput src="/static/Physics801/Figures/Skier-conservation of energy.jpg" width="560" height="388" rectangle="(490,11)-(556,98);(242,202)-(296,276)"/>
-<text>Click on either of the two positions as discussed previously.</text>
-<hintgroup showoncorrect="no">
-<text><p>Use conservation of energy.</p></text>
-</hintgroup>
-</imageresponse>
-
-
-<imageresponse max="1" loncapaid="12">
-<imageinput src="/static/Physics801/Figures/Skier-conservation of energy.jpg" width="560" height="388" rectangle="(490,11)-(556,98)" regions="[[[10,10], [20,10], [20, 30]], [[100,100], [120,100], [120,150]]]"/>
-<imageinput src="/static/Physics801/Figures/Skier-conservation of energy.jpg" width="560" height="388" rectangle="(490,11)-(556,98)" regions='[[[10,10], [20,10], [20, 30]], [[100,100], [120,100], [120,150]]]'/>
-<imageinput src="/static/Physics801/Figures/Skier-conservation of energy.jpg" width="560" height="388" regions="[[[10,10], [20,10], [20, 30]], [[100,100], [120,100], [120,150]]]"/>
-<imageinput src="/static/Physics801/Figures/Skier-conservation of energy.jpg" width="560" height="388" regions="[[[10,10], [20,10], [20, 30]], [[100,100], [120,100], [120,150]]]"/>
-<text>Click on either of the two positions as discussed previously.</text>
-<imageinput src="/static/Physics801/Figures/Skier-conservation of energy.jpg" width="560" height="388" regions="[[[10,10], [20,10], [20, 30]]]"/>
-<text>Click on either of the two positions as discussed previously.</text>
-<imageinput src="/static/Physics801/Figures/Skier-conservation of energy.jpg" width="560" height="388" regions="[[10,10], [30,30], [15, 15]]"/>
-<imageinput src="/static/Physics801/Figures/Skier-conservation of energy.jpg" width="560" height="388" regions="[[10,10], [30,30], [10, 30], [30, 10]]"/>
-<text>Click on either of the two positions as discussed previously.</text>
-<hintgroup showoncorrect="no">
-<text><p>Use conservation of energy.</p></text>
-</hintgroup>
-</imageresponse>
-
-
-</problem>

common/lib/capa/capa/tests/test_files/javascriptresponse.xml

-<problem>
-
-<javascriptresponse>
-  <generator src="test_problem_generator.js"/>
-  <grader src="test_problem_grader.js"/>
-  <display class="TestProblemDisplay" src="test_problem_display.js"/>
-  <responseparam name="value" value="4"/>
-  <javascriptinput>
-  </javascriptinput>
-</javascriptresponse>
-
-</problem>
-

common/lib/capa/capa/tests/test_files/js/compiled/c9a9cd4242d84c924fe5f8324e9ae79d.js

-// Generated by CoffeeScript 1.3.3
-(function() {
-  var MinimaxProblemDisplay, root,
-    __hasProp = {}.hasOwnProperty,
-    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
-
-  MinimaxProblemDisplay = (function(_super) {
-
-    __extends(MinimaxProblemDisplay, _super);
-
-    function MinimaxProblemDisplay(state, submission, evaluation, container, submissionField, parameters) {
-      this.state = state;
-      this.submission = submission;
-      this.evaluation = evaluation;
-      this.container = container;
-      this.submissionField = submissionField;
-      this.parameters = parameters != null ? parameters : {};
-      MinimaxProblemDisplay.__super__.constructor.call(this, this.state, this.submission, this.evaluation, this.container, this.submissionField, this.parameters);
-    }
-
-    MinimaxProblemDisplay.prototype.render = function() {};
-
-    MinimaxProblemDisplay.prototype.createSubmission = function() {
-      var id, value, _ref, _results;
-      this.newSubmission = {};
-      if (this.submission != null) {
-        _ref = this.submission;
-        _results = [];
-        for (id in _ref) {
-          value = _ref[id];
-          _results.push(this.newSubmission[id] = value);
-        }
-        return _results;
-      }
-    };
-
-    MinimaxProblemDisplay.prototype.getCurrentSubmission = function() {
-      return this.newSubmission;
-    };
-
-    return MinimaxProblemDisplay;
-
-  })(XProblemDisplay);
-
-  root = typeof exports !== "undefined" && exports !== null ? exports : this;
-
-  root.TestProblemDisplay = TestProblemDisplay;
-
-}).call(this);
-;

common/lib/capa/capa/tests/test_files/js/compiled/javascriptresponse.js

-// Generated by CoffeeScript 1.3.3
-(function() {
-  var MinimaxProblemDisplay, root,
-    __hasProp = {}.hasOwnProperty,
-    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
-
-  MinimaxProblemDisplay = (function(_super) {
-
-    __extends(MinimaxProblemDisplay, _super);
-
-    function MinimaxProblemDisplay(state, submission, evaluation, container, submissionField, parameters) {
-      this.state = state;
-      this.submission = submission;
-      this.evaluation = evaluation;
-      this.container = container;
-      this.submissionField = submissionField;
-      this.parameters = parameters != null ? parameters : {};
-      MinimaxProblemDisplay.__super__.constructor.call(this, this.state, this.submission, this.evaluation, this.container, this.submissionField, this.parameters);
-    }
-
-    MinimaxProblemDisplay.prototype.render = function() {};
-
-    MinimaxProblemDisplay.prototype.createSubmission = function() {
-      var id, value, _ref, _results;
-      this.newSubmission = {};
-      if (this.submission != null) {
-        _ref = this.submission;
-        _results = [];
-        for (id in _ref) {
-          value = _ref[id];
-          _results.push(this.newSubmission[id] = value);
-        }
-        return _results;
-      }
-    };
-
-    MinimaxProblemDisplay.prototype.getCurrentSubmission = function() {
-      return this.newSubmission;
-    };
-
-    return MinimaxProblemDisplay;
-
-  })(XProblemDisplay);
-
-  root = typeof exports !== "undefined" && exports !== null ? exports : this;
-
-  root.TestProblemDisplay = TestProblemDisplay;
-
-}).call(this);
-;

common/lib/capa/capa/tests/test_files/multi_bare.xml

-<problem>
-<multiplechoiceresponse>
-  <choicegroup>
-    <choice correct="false" >
-      <startouttext />This is foil One.<endouttext />
-    </choice>
-    <choice correct="false" >
-      <startouttext />This is foil Two.<endouttext />
-    </choice>
-    <choice correct="true" >
-      <startouttext />This is foil Three.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Four.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Five.<endouttext />
-    </choice>
-  </choicegroup>
-</multiplechoiceresponse>
-</problem>

common/lib/capa/capa/tests/test_files/multichoice.xml

-<problem>
-<multiplechoiceresponse>
-  <choicegroup>
-    <choice correct="false" name="foil1">
-      <startouttext />This is foil One.<endouttext />
-    </choice>
-    <choice correct="false" name="foil2">
-      <startouttext />This is foil Two.<endouttext />
-    </choice>
-    <choice correct="true" name="foil3">
-      <startouttext />This is foil Three.<endouttext />
-    </choice>
-    <choice correct="false" name="foil4">
-      <startouttext />This is foil Four.<endouttext />
-    </choice>
-    <choice correct="false" name="foil5">
-      <startouttext />This is foil Five.<endouttext />
-    </choice>
-  </choicegroup>
-</multiplechoiceresponse>
-</problem>

common/lib/capa/capa/tests/test_files/optionresponse.xml

-  <problem>
-    <text>
-      <p>
-Why do bicycles benefit from having larger wheels when going up a bump as shown in the picture? <br/>
-Assume that for both bicycles:<br/>
-1.)	The tires have equal air pressure.<br/>
-2.)	The bicycles never leave the contact with the bump.<br/>
-3.)	The bicycles have the same mass. The bicycle tires (regardless of size) have the same mass.<br/>
-</p>
-    </text>
-    <optionresponse texlayout="horizontal" max="10" randomize="yes">
-      <ul>
-        <li>
-          <text>
-            <p>The bicycles with larger wheels have more time to go over the bump. This decreases the magnitude of the force needed to lift the bicycle.</p>
-          </text>
-          <optioninput name="Foil1" location="random" options="('True','False')" correct="True">
-</optioninput>
-        </li>
-        <li>
-          <text>
-            <p>The bicycles with larger wheels always have a smaller vertical displacement regardless of speed.</p>
-          </text>
-          <optioninput name="Foil2" location="random" options="('True','False')" correct="False">
-</optioninput>
-        </li>
-        <li>
-          <text>
-            <p>The bicycles with larger wheels experience a force backward with less magnitude for the same amount of time.</p>
-          </text>
-          <optioninput name="Foil3" location="random" options="('True','False')" correct="False">
-</optioninput>
-        </li>
-        <li>
-          <text>
-            <p>The bicycles with larger wheels experience a force backward with less magnitude for a greater amount of time.</p>
-          </text>
-          <optioninput name="Foil4" location="random" options="('True','False')" correct="True">
-</optioninput>
-        </li>
-        <li>
-          <text>
-            <p>The bicycles with larger wheels have more kinetic energy turned into gravitational potential energy.</p>
-          </text>
-          <optioninput name="Foil5" location="random" options="('True','False')" correct="False">
-</optioninput>
-        </li>
-        <li>
-          <text>
-            <p>The bicycles with larger wheels have more rotational kinetic energy, so the horizontal velocity of the biker changes less.</p>
-          </text>
-          <optioninput name="Foil6" location="random" options="('True','False')" correct="False">
-</optioninput>
-        </li>
-      </ul>
-      <hintgroup showoncorrect="no">
-        <text>
-          <br/>
-          <br/>
-        </text>
-      </hintgroup>
-    </optionresponse>
-  </problem>

common/lib/capa/capa/tests/test_files/stringresponse_with_hint.xml

-<problem >
- <text><h2>Example: String Response Problem</h2>
- <br/>
- </text>
- 
- <text>Which US state has Lansing as its capital?</text>
-  <stringresponse answer="Michigan" type="ci">
-  <textline size="20" />
-  <hintgroup>
-   <stringhint answer="wisconsin" type="cs" name="wisc">
-   </stringhint>
-   <stringhint answer="minnesota" type="cs" name="minn">
-   </stringhint>
-   <hintpart on="wisc">
-    <text>The state capital of Wisconsin is Madison.</text>
-   </hintpart>
-   <hintpart on="minn">
-    <text>The state capital of Minnesota is St. Paul.</text>
-   </hintpart>
-   <hintpart on="default">
-    <text>The state you are looking for is also known as the 'Great Lakes State'</text>
-   </hintpart>     
-  </hintgroup>
- </stringresponse>
-</problem>

common/lib/capa/capa/tests/test_files/symbolicresponse.xml

-<problem>
-<text>
-<h2>Example: Symbolic Math Response Problem</h2>
-
-<p>
-A symbolic math response problem presents one or more symbolic math
-input fields for input.  Correctness of input is evaluated based on
-the symbolic properties of the expression entered.  The student enters
-text, but sees a proper symbolic rendition of the entered formula, in
-real time, next to the input box.
-</p>
-
-<p>This is a correct answer which may be entered below: </p>
-<p><tt>cos(theta)*[[1,0],[0,1]] + i*sin(theta)*[[0,1],[1,0]]</tt></p>
-
-<script>
-from symmath import *
-</script>
-  <text>Compute [mathjax] U = \exp\left( i \theta \left[ \begin{matrix} 0 &amp; 1 \\ 1 &amp; 0 \end{matrix} \right] \right) [/mathjax]
-      and give the resulting \(2 \times 2\) matrix. <br/>
-      Your input should be typed in as a list of lists, eg <tt>[[1,2],[3,4]]</tt>. <br/>
-       [mathjax]U=[/mathjax] <symbolicresponse cfn="symmath_check" answer="[[cos(theta),I*sin(theta)],[I*sin(theta),cos(theta)]]" options="matrix,imaginaryi" id="filenamedogi0VpEBOWedxsymmathresponse_1" state="unsubmitted">
-          <textline size="80" math="1" response_id="2" answer_id="1" id="filenamedogi0VpEBOWedxsymmathresponse_2_1"/>
-        </symbolicresponse>
-      <br/>
-  </text>
-
-</text>
-</problem>

common/lib/capa/capa/tests/test_files/truefalse.xml

-<problem>
-  <truefalseresponse max="10" randomize="yes">
-  <choicegroup>
-    <choice location="random" correct="true" name="foil1">
-      <startouttext />This is foil One.<endouttext />
-    </choice>
-    <choice location="random" correct="true" name="foil2">
-      <startouttext />This is foil Two.<endouttext />
-    </choice>
-    <choice location="random" correct="false" name="foil3">
-      <startouttext />This is foil Three.<endouttext />
-    </choice>
-    <choice location="random" correct="false" name="foil4">
-      <startouttext />This is foil Four.<endouttext />
-    </choice>
-    <choice location="random" correct="false" name="foil5">
-            <startouttext />This is foil Five.<endouttext />
-    </choice>
-  </choicegroup>
-</truefalseresponse>
-</problem>

common/lib/capa/capa/tests/test_html_render.py

+import unittest
+from lxml import etree
+import os
+import textwrap
+import json
+import mock
+
+from capa.capa_problem import LoncapaProblem
+from response_xml_factory import StringResponseXMLFactory, CustomResponseXMLFactory
+from . import test_system
+
+class CapaHtmlRenderTest(unittest.TestCase):
+
+    def test_include_html(self):
+        # Create a test file to include
+        self._create_test_file('test_include.xml',
+                                '<test>Test include</test>')
+
+        # Generate some XML with an <include>
+        xml_str = textwrap.dedent("""
+            <problem>
+                <include file="test_include.xml"/>
+            </problem>
+        """)
+
+        # Create the problem
+        problem = LoncapaProblem(xml_str, '1', system=test_system)
+    
+        # Render the HTML
+        rendered_html = etree.XML(problem.get_html())
+
+        # Expect that the include file was embedded in the problem
+        test_element = rendered_html.find("test")
+        self.assertEqual(test_element.tag, "test")
+        self.assertEqual(test_element.text, "Test include")
+
+
+    def test_process_outtext(self):
+        # Generate some XML with <startouttext /> and <endouttext />
+        xml_str = textwrap.dedent("""
+            <problem>
+            <startouttext/>Test text<endouttext/>
+            </problem>
+        """)
+
+        # Create the problem
+        problem = LoncapaProblem(xml_str, '1', system=test_system)
+    
+        # Render the HTML
+        rendered_html = etree.XML(problem.get_html())
+
+        # Expect that the <startouttext /> and <endouttext />
+        # were converted to <span></span> tags
+        span_element = rendered_html.find('span')
+        self.assertEqual(span_element.text, 'Test text')
+
+    def test_render_script(self):
+        # Generate some XML with a <script> tag
+        xml_str = textwrap.dedent("""
+            <problem>
+                <script>test=True</script>
+            </problem>
+        """)
+
+        # Create the problem
+        problem = LoncapaProblem(xml_str, '1', system=test_system)
+    
+        # Render the HTML
+        rendered_html = etree.XML(problem.get_html())
+
+        # Expect that the script element has been removed from the rendered HTML
+        script_element = rendered_html.find('script')
+        self.assertEqual(None, script_element)
+
+    def test_render_response_xml(self):
+        # Generate some XML for a string response
+        kwargs = {'question_text': "Test question",
+                    'explanation_text': "Test explanation",
+                    'answer': 'Test answer',
+                    'hints': [('test prompt', 'test_hint', 'test hint text')]}
+        xml_str = StringResponseXMLFactory().build_xml(**kwargs)
+
+        # Mock out the template renderer
+        test_system.render_template = mock.Mock()
+        test_system.render_template.return_value = "<div>Input Template Render</div>"
+
+        # Create the problem and render the HTML
+        problem = LoncapaProblem(xml_str, '1', system=test_system)
+        rendered_html = etree.XML(problem.get_html())
+
+        # Expect problem has been turned into a <div>
+        self.assertEqual(rendered_html.tag, "div")
+
+        # Expect question text is in a <p> child
+        question_element = rendered_html.find("p")
+        self.assertEqual(question_element.text, "Test question")
+
+        # Expect that the response has been turned into a <span>
+        response_element = rendered_html.find("span")
+        self.assertEqual(response_element.tag, "span")
+
+        # Expect that the response <span> 
+        # that contains a <div> for the textline
+        textline_element = response_element.find("div")
+        self.assertEqual(textline_element.text, 'Input Template Render')
+        
+        # Expect a child <div> for the solution
+        # with the rendered template
+        solution_element = rendered_html.find("div")
+        self.assertEqual(solution_element.text, 'Input Template Render')
+
+        # Expect that the template renderer was called with the correct
+        # arguments, once for the textline input and once for
+        # the solution
+        expected_textline_context = {'status': 'unsubmitted', 
+                                        'value': '', 
+                                        'preprocessor': None, 
+                                        'msg': '', 
+                                        'inline': False, 
+                                        'hidden': False, 
+                                        'do_math': False, 
+                                        'id': '1_2_1', 
+                                        'size': None}
+
+        expected_solution_context = {'id': '1_solution_1'}
+
+        expected_calls = [mock.call('textline.html', expected_textline_context),
+                mock.call('solutionspan.html', expected_solution_context)]
+
+        self.assertEqual(test_system.render_template.call_args_list,
+                            expected_calls)
+
+
+    def test_render_response_with_overall_msg(self):
+        # CustomResponse script that sets an overall_message
+        script=textwrap.dedent("""
+            def check_func(*args):
+                msg = '<p>Test message 1<br /></p><p>Test message 2</p>'
+                return {'overall_message': msg,
+                        'input_list': [ {'ok': True, 'msg': '' } ] }
+        """)
+
+        # Generate some XML for a CustomResponse
+        kwargs = {'script':script, 'cfn': 'check_func'}
+        xml_str = CustomResponseXMLFactory().build_xml(**kwargs)
+
+        # Create the problem and render the html
+        problem = LoncapaProblem(xml_str, '1', system=test_system)
+        
+        # Grade the problem
+        correctmap = problem.grade_answers({'1_2_1': 'test'})
+
+        # Render the html
+        rendered_html = etree.XML(problem.get_html())
+
+
+        # Expect that there is a <div> within the response <div>
+        # with css class response_message
+        msg_div_element = rendered_html.find(".//div[@class='response_message']")
+        self.assertEqual(msg_div_element.tag, "div")
+        self.assertEqual(msg_div_element.get('class'), "response_message")
+
+        # Expect that the <div> contains our message (as part of the XML tree)
+        msg_p_elements = msg_div_element.findall('p')
+        self.assertEqual(msg_p_elements[0].tag, "p")
+        self.assertEqual(msg_p_elements[0].text, "Test message 1")
+
+        self.assertEqual(msg_p_elements[1].tag, "p")
+        self.assertEqual(msg_p_elements[1].text, "Test message 2")
+
+
+    def test_substitute_python_vars(self):
+        # Generate some XML with Python variables defined in a script
+        # and used later as attributes
+        xml_str = textwrap.dedent("""
+            <problem>
+                <script>test="TEST"</script>
+                <span attr="$test"></span>
+            </problem>
+        """)
+
+        # Create the problem and render the HTML
+        problem = LoncapaProblem(xml_str, '1', system=test_system)
+        rendered_html = etree.XML(problem.get_html())
+
+        # Expect that the variable $test has been replaced with its value
+        span_element = rendered_html.find('span')
+        self.assertEqual(span_element.get('attr'), "TEST")
+
+    def _create_test_file(self, path, content_str):
+        test_fp = test_system.filestore.open(path, "w")
+        test_fp.write(content_str)
+        test_fp.close()
+
+        self.addCleanup(lambda: os.remove(test_fp.name))

common/lib/capa/capa/verifiers/draganddrop.py

@@ -111,7 +111,7 @@ class DragAndDrop(object):
         Returns: bool.
         '''
         for draggable in self.excess_draggables:
-            if not self.excess_draggables[draggable]:
+            if self.excess_draggables[draggable]:
                 return False  # user answer has more draggables than correct answer
 
         # Number of draggables in user_groups may be differ that in
@@ -304,8 +304,13 @@ class DragAndDrop(object):
 
         user_answer = json.loads(user_answer)
 
-        # check if we have draggables that are not in correct answer:
-        self.excess_draggables = {}
+        # This dictionary will hold a key for each draggable the user placed on
+        # the image.  The value is True if that draggable is not mentioned in any
+        # correct_answer entries.  If the draggable is mentioned in at least one
+        # correct_answer entry, the value is False.
+        # default to consider every user answer excess until proven otherwise.
+        self.excess_draggables = dict((users_draggable.keys()[0],True) 
+            for users_draggable in user_answer['draggables'])
 
         # create identical data structures from user answer and correct answer
         for i in xrange(0, len(correct_answer)):
@@ -322,11 +327,8 @@ class DragAndDrop(object):
                     self.user_groups[groupname].append(draggable_name)
                     self.user_positions[groupname]['user'].append(
                                             draggable_dict[draggable_name])
-                    self.excess_draggables[draggable_name] = True
-                else:
-                    self.excess_draggables[draggable_name] = \
-                    self.excess_draggables.get(draggable_name, False)
-
+                    # proved that this is not excess
+                    self.excess_draggables[draggable_name] = False
 
 def grade(user_input, correct_answer):
     """ Creates DragAndDrop instance from user_input and correct_answer and

common/lib/capa/capa/verifiers/tests_draganddrop.py

@@ -46,6 +46,18 @@ class Test_DragAndDrop_Grade(unittest.TestCase):
         correct_answer = {'1':              't1', 'name_with_icon': 't2'}
         self.assertTrue(draganddrop.grade(user_input, correct_answer))
 
+    def test_expect_no_actions_wrong(self):
+        user_input = '{"draggables": [{"1": "t1"}, \
+         {"name_with_icon": "t2"}]}'
+        correct_answer = []
+        self.assertFalse(draganddrop.grade(user_input, correct_answer))
+
+    def test_expect_no_actions_right(self):
+        user_input = '{"draggables": []}'
+        correct_answer = []
+        self.assertTrue(draganddrop.grade(user_input, correct_answer))
+
+
     def test_targets_false(self):
         user_input = '{"draggables": [{"1": "t1"}, \
         {"name_with_icon": "t2"}]}'

common/lib/capa/setup.py

@@ -4,5 +4,5 @@ setup(
     name="capa",
     version="0.1",
     packages=find_packages(exclude=["tests"]),
-    install_requires=['distribute', 'pyparsing'],
+    install_requires=['distribute==0.6.34', 'pyparsing==1.5.6'],
 )

common/lib/xmodule/xmodule/combined_open_ended_module.py

@@ -4,9 +4,8 @@ from lxml import etree
 
 from pkg_resources import resource_string
 
-from .editing_module import EditingDescriptor
+from xmodule.raw_module import RawDescriptor
 from .x_module import XModule
-from .xml_module import XmlDescriptor
 from xmodule.open_ended_grading_classes.combined_open_ended_modulev1 import CombinedOpenEndedV1Module, CombinedOpenEndedV1Descriptor
 
 log = logging.getLogger("mitx.courseware")
@@ -134,7 +133,7 @@ class CombinedOpenEndedModule(XModule):
         }
 
         self.child_descriptor = descriptors[version_index](self.system)
-        self.child_definition = descriptors[version_index].definition_from_xml(etree.fromstring(definition['xml_string']), self.system)
+        self.child_definition = descriptors[version_index].definition_from_xml(etree.fromstring(definition['data']), self.system)
         self.child_module = modules[version_index](self.system, location, self.child_definition, self.child_descriptor,
             instance_state = json.dumps(instance_state), metadata = self.metadata, static_data= static_data)
 
@@ -165,11 +164,11 @@ class CombinedOpenEndedModule(XModule):
         return self.child_module.display_name
 
 
-class CombinedOpenEndedDescriptor(XmlDescriptor, EditingDescriptor):
+class CombinedOpenEndedDescriptor(RawDescriptor):
     """
     Module for adding combined open ended questions
     """
-    mako_template = "widgets/html-edit.html"
+    mako_template = "widgets/raw-edit.html"
     module_class = CombinedOpenEndedModule
     filename_extension = "xml"
 
@@ -177,35 +176,3 @@ class CombinedOpenEndedDescriptor(XmlDescriptor, EditingDescriptor):
     has_score = True
     template_dir_name = "combinedopenended"
 
-    js = {'coffee': [resource_string(__name__, 'js/src/html/edit.coffee')]}
-    js_module_name = "HTMLEditingDescriptor"
-
-    @classmethod
-    def definition_from_xml(cls, xml_object, system):
-        """
-        Pull out the individual tasks, the rubric, and the prompt, and parse
-
-        Returns:
-        {
-        'rubric': 'some-html',
-        'prompt': 'some-html',
-        'task_xml': dictionary of xml strings,
-        }
-        """
-
-        return {'xml_string' : etree.tostring(xml_object), 'metadata' : xml_object.attrib}
-
-
-    def definition_to_xml(self, resource_fs):
-        '''Return an xml element representing this definition.'''
-        elt = etree.Element('combinedopenended')
-
-        def add_child(k):
-            child_str = '<{tag}>{body}</{tag}>'.format(tag=k, body=self.definition[k])
-            child_node = etree.fromstring(child_str)
-            elt.append(child_node)
-
-        for child in ['task']:
-            add_child(child)
-
-        return elt

common/lib/xmodule/xmodule/contentstore/content.py

@@ -35,7 +35,8 @@ class StaticContent(object):
     @staticmethod
     def compute_location(org, course, name, revision=None, is_thumbnail=False):
         name = name.replace('/', '_')
-        return Location([XASSET_LOCATION_TAG, org, course, 'asset' if not is_thumbnail else 'thumbnail', Location.clean(name), revision])
+        return Location([XASSET_LOCATION_TAG, org, course, 'asset' if not is_thumbnail else 'thumbnail',
+                         Location.clean_keeping_underscores(name), revision])
 
     def get_id(self):
         return StaticContent.get_id_from_location(self.location)

common/lib/xmodule/xmodule/course_module.py

@@ -127,6 +127,7 @@ class CourseDescriptor(SequenceDescriptor):
         # NOTE (THK): This is a last-minute addition for Fall 2012 launch to dynamically
         #   disable the syllabus content for courses that do not provide a syllabus
         self.syllabus_present = self.system.resources_fs.exists(path('syllabus'))
+        self._grading_policy = {}
         self.set_grading_policy(self.definition['data'].get('grading_policy', None))
 
         self.test_center_exams = []
@@ -196,11 +197,9 @@ class CourseDescriptor(SequenceDescriptor):
         grading_policy.update(course_policy)
 
         # Here is where we should parse any configurations, so that we can fail early
-        grading_policy['RAW_GRADER'] = grading_policy['GRADER']  # used for cms access
-        grading_policy['GRADER'] = grader_from_conf(grading_policy['GRADER'])
-        self._grading_policy = grading_policy
-
-
+        # Use setters so that side effecting to .definitions works
+        self.raw_grader = grading_policy['GRADER']  # used for cms access
+        self.grade_cutoffs = grading_policy['GRADE_CUTOFFS']
 
     @classmethod
     def read_grading_policy(cls, paths, system):
@@ -319,7 +318,7 @@ class CourseDescriptor(SequenceDescriptor):
 
     @property
     def grader(self):
-        return self._grading_policy['GRADER']
+        return grader_from_conf(self.raw_grader)
 
     @property
     def raw_grader(self):
@@ -379,6 +378,28 @@ class CourseDescriptor(SequenceDescriptor):
         return bool(config.get("cohorted"))
 
     @property
+    def auto_cohort(self):
+        """
+        Return whether the course is auto-cohorted.
+        """
+        if not self.is_cohorted:
+            return False
+
+        return bool(self.metadata.get("cohort_config", {}).get(
+            "auto_cohort", False))
+
+    @property
+    def auto_cohort_groups(self):
+        """
+        Return the list of groups to put students into.  Returns [] if not
+        specified. Returns specified list even if is_cohorted and/or auto_cohort are
+        false.
+        """
+        return self.metadata.get("cohort_config", {}).get(
+            "auto_cohort_groups", [])
+
+    
+    @property
     def top_level_discussion_topic_ids(self):
         """
         Return list of topic ids defined in course policy.
@@ -714,7 +735,7 @@ class CourseDescriptor(SequenceDescriptor):
     def get_test_center_exam(self, exam_series_code):
         exams = [exam for exam in self.test_center_exams if exam.exam_series_code == exam_series_code]
         return exams[0] if len(exams) == 1 else None
-        
+
     @property
     def title(self):
         return self.display_name

common/lib/xmodule/xmodule/css/capa/display.scss

@@ -40,7 +40,7 @@ section.problem {
     @include clearfix;
 
     label.choicegroup_correct{
-      text:after{
+      &:after{
         content: url('../images/correct-icon.png');
       }
     }
@@ -227,7 +227,7 @@ section.problem {
         background: url('../images/correct-icon.png') center center no-repeat;
         height: 20px;
         position: relative;
-        top: 6px;
+        top: 3px;
         width: 25px;
       }
 
@@ -237,7 +237,7 @@ section.problem {
         height: 20px;
         width: 20px;
         position: relative;
-        top: 6px;
+        top: 3px;
       }
     }
 

common/lib/xmodule/xmodule/css/foldit/leaderboard.scss

+$leaderboard: #F4F4F4;
+
+section.foldit {
+    div.folditchallenge {
+        table {
+            border: 1px solid lighten($leaderboard, 10%);
+            border-collapse: collapse;
+            margin-top: 20px;
+        }
+        th {
+            background: $leaderboard;
+            color: darken($leaderboard, 25%);
+        }
+        td {
+            background: lighten($leaderboard, 3%);
+            border-bottom: 1px solid  #fff;
+            padding: 8px;
+        }
+    }
+}

common/lib/xmodule/xmodule/foldit_module.py

@@ -11,14 +11,27 @@ from xmodule.xml_module import XmlDescriptor
 log = logging.getLogger(__name__)
 
 class FolditModule(XModule):
+
+    css = {'scss': [resource_string(__name__, 'css/foldit/leaderboard.scss')]}
+
     def __init__(self, system, location, definition, descriptor,
                  instance_state=None, shared_state=None, **kwargs):
         XModule.__init__(self, system, location, definition, descriptor,
                          instance_state, shared_state, **kwargs)
-        # ooh look--I'm lazy, so hardcoding the 7.00x required level.
-        # If we need it generalized, can pull from the xml later
-        self.required_level = 4
-        self.required_sublevel = 5
+        """
+
+        Example:
+         <foldit show_basic_score="true"
+            required_level="4"
+            required_sublevel="3"
+            show_leaderboard="false"/>
+        """
+        req_level = self.metadata.get("required_level")
+        req_sublevel = self.metadata.get("required_sublevel")
+
+        # default to what Spring_7012x uses
+        self.required_level = req_level if req_level else 4
+        self.required_sublevel = req_sublevel if req_sublevel else 5
 
         def parse_due_date():
             """
@@ -66,6 +79,14 @@ class FolditModule(XModule):
             PuzzleComplete.completed_puzzles(self.system.anonymous_student_id),
             key=lambda d: (d['set'], d['subset']))
 
+    def puzzle_leaders(self, n=10):
+        """
+        Returns a list of n pairs (user, score) corresponding to the top
+        scores; the pairs are in descending order of score.
+        """
+        from foldit.models import Score
+
+        return [(e['username'], e['score']) for e in Score.get_tops_n(10)]
 
     def get_html(self):
         """
@@ -75,15 +96,47 @@ class FolditModule(XModule):
             self.required_level,
             self.required_sublevel)
 
+        showbasic = (self.metadata.get("show_basic_score").lower() == "true")
+        showleader = (self.metadata.get("show_leaderboard").lower() == "true")
         context = {
             'due': self.due_str,
             'success': self.is_complete(),
             'goal_level': goal_level,
             'completed': self.completed_puzzles(),
+            'top_scores': self.puzzle_leaders(),
+            'show_basic': showbasic,
+            'show_leader': showleader,
+            'folditbasic': self.get_basicpuzzles_html(),
+            'folditchallenge': self.get_challenge_html()
             }
 
         return self.system.render_template('foldit.html', context)
 
+    def get_basicpuzzles_html(self):
+        """
+        Render html for the basic puzzle section.
+        """
+        goal_level = '{0}-{1}'.format(
+            self.required_level,
+            self.required_sublevel)
+
+        context = {
+            'due': self.due_str,
+            'success': self.is_complete(),
+            'goal_level': goal_level,
+            'completed': self.completed_puzzles(),
+            }
+        return self.system.render_template('folditbasic.html', context)
+
+    def get_challenge_html(self):
+        """
+        Render html for challenge (i.e., the leaderboard)
+        """
+
+        context = {
+            'top_scores': self.puzzle_leaders()}
+
+        return self.system.render_template('folditchallenge.html', context)
 
     def get_score(self):
         """
@@ -97,9 +150,10 @@ class FolditModule(XModule):
         return 1
 
 
+
 class FolditDescriptor(XmlDescriptor, EditingDescriptor):
     """
-    Module for adding open ended response questions to courses
+    Module for adding Foldit problems to courses
     """
     mako_template = "widgets/html-edit.html"
     module_class = FolditModule
@@ -119,6 +173,6 @@ class FolditDescriptor(XmlDescriptor, EditingDescriptor):
     @classmethod
     def definition_from_xml(cls, xml_object, system):
         """
-        For now, don't need anything from the xml
+        Get the xml_object's attributes.
         """
-        return {}
+        return {'metadata': xml_object.attrib}

common/lib/xmodule/xmodule/js/spec/problem/edit_spec.coffee

@@ -119,13 +119,13 @@ describe 'MarkdownEditingDescriptor', ->
         <p>The answer is correct if it is within a specified numerical tolerance of the expected answer.</p>
         
         <p>Enter the numerical value of Pi:</p>
-        <numericalresponse answer="3.14159 ">
+        <numericalresponse answer="3.14159">
           <responseparam type="tolerance" default=".02" />
           <textline />
         </numericalresponse>
         
         <p>Enter the approximate value of 502*9:</p>
-        <numericalresponse answer="4518 ">
+        <numericalresponse answer="4518">
           <responseparam type="tolerance" default="15%" />
           <textline />
         </numericalresponse>
@@ -148,6 +148,20 @@ describe 'MarkdownEditingDescriptor', ->
         </div>
         </solution>
         </problem>""")
+    it 'will convert 0 as a numerical response (instead of string response)', ->
+      data =  MarkdownEditingDescriptor.markdownToXml("""
+        Enter 0 with a tolerance:
+        = 0 +- .02
+        """)
+      expect(data).toEqual("""<problem>
+        <p>Enter 0 with a tolerance:</p>
+        <numericalresponse answer="0">
+          <responseparam type="tolerance" default=".02" />
+          <textline />
+        </numericalresponse>
+
+
+        </problem>""")
     it 'converts multiple choice to xml', ->
       data = MarkdownEditingDescriptor.markdownToXml("""A multiple choice problem presents radio buttons for student input. Students can only select a single option presented. Multiple Choice questions have been the subject of many areas of research due to the early invention and adoption of bubble sheets.
         

common/lib/xmodule/xmodule/js/src/capa/display.coffee

@@ -262,9 +262,8 @@ class @Problem
   save: =>
     Logger.log 'problem_save', @answers
     $.postWithPrefix "#{@url}/problem_save", @answers, (response) =>
-      if response.success
-        saveMessage = "Your answers have been saved but not graded. Hit 'Check' to grade them."
-        @gentle_alert saveMessage
+      saveMessage = response.msg
+      @gentle_alert saveMessage
       @updateProgress response
 
   refreshMath: (event, element) =>

common/lib/xmodule/xmodule/js/src/combinedopenended/display.coffee

@@ -4,7 +4,47 @@ class @Rubric
   @initialize: (location) ->
     $('.rubric').data("location", location) 
     $('input[class="score-selection"]').change @tracking_callback
+    # set up the hotkeys
+    $(window).unbind('keydown', @keypress_callback)
+    $(window).keydown @keypress_callback
+    # display the 'current' carat
+    @categories = $('.rubric-category')
+    @category = $(@categories.first())
+    @category.prepend('> ')
+    @category_index = 0
+    
+    
+  @keypress_callback: (event) =>
+    # don't try to do this when user is typing in a text input
+    if $(event.target).is('input, textarea')
+      return
+    # for when we select via top row
+    if event.which >= 48 and event.which <= 57
+      selected = event.which - 48
+    # for when we select via numpad
+    else if event.which >= 96 and event.which <= 105
+      selected = event.which - 96
+    # we don't want to do anything since we haven't pressed a number
+    else
+      return
 
+    # if we actually have a current category (not past the end)
+    if(@category_index <= @categories.length)
+      # find the valid selections for this category
+      inputs = $("input[name='score-selection-#{@category_index}']")
+      max_score = inputs.length - 1
+
+      if selected > max_score or selected < 0
+        return
+      inputs.filter("input[value=#{selected}]").click()
+
+      # move to the next category
+      old_category_text = @category.html().substring(5)
+      @category.html(old_category_text)
+      @category_index++
+      @category = $(@categories[@category_index])
+      @category.prepend('> ')
+    
   @tracking_callback: (event) ->
     target_selection = $(event.target).val()
     # chop off the beginning of the name so that we can get the number of the category
@@ -49,6 +89,7 @@ class @CombinedOpenEnded
   constructor: (element) ->
     @element=element
     @reinitialize(element)
+    $(window).keydown @keydown_handler
 
   reinitialize: (element) ->
     @wrapper=$(element).find('section.xmodule_CombinedOpenEndedModule')
@@ -306,6 +347,7 @@ class @CombinedOpenEnded
           if response.success
             @rubric_wrapper.html(response.rubric_html)
             @rubric_wrapper.show()
+            Rubric.initialize(@location)
             @answer_area.html(response.student_response)
             @child_state = 'assessing'
             @find_assessment_elements()
@@ -318,6 +360,11 @@ class @CombinedOpenEnded
     else
       @errors_area.html(@out_of_sync_message)
 
+  keydown_handler: (e) =>
+    # only do anything when the key pressed is the 'enter' key
+    if e.which == 13 && @child_state == 'assessing' && Rubric.check_complete()
+      @save_assessment(e)
+
   save_assessment: (event) =>
     event.preventDefault()
     if @child_state == 'assessing' && Rubric.check_complete()

common/lib/xmodule/xmodule/js/src/peergrading/peer_grading_problem.coffee

@@ -210,6 +210,9 @@ class @PeerGradingProblem
     @calibration_interstitial_page_button = $('.calibration-interstitial-page-button')
     @flag_student_checkbox = $('.flag-checkbox')
     @answer_unknown_checkbox = $('.answer-unknown-checkbox')
+
+    $(window).keydown @keydown_handler
+
     @collapse_question()
 
     Collapsible.setCollapsibles(@content_panel)
@@ -251,9 +254,6 @@ class @PeerGradingProblem
   fetch_submission_essay: () =>
     @backend.post('get_next_submission', {location: @location}, @render_submission)
 
-  gentle_alert: (msg) =>
-    @grading_message.fadeIn()
-    @grading_message.html("<p>" + msg + "</p>")
 
   construct_data: () ->
     data =
@@ -337,6 +337,14 @@ class @PeerGradingProblem
       @show_submit_button()
       @grade = Rubric.get_total_score()
 
+  keydown_handler: (event) =>
+    if event.which == 13 && @submit_button.is(':visible')
+      if @calibration
+        @submit_calibration_essay()
+      else
+        @submit_grade()
+
+
 
 
   ##########
@@ -473,6 +481,10 @@ class @PeerGradingProblem
     # And now hook up an event handler again
     $("input[class='score-selection']").change @graded_callback
 
+  gentle_alert: (msg) =>
+    @grading_message.fadeIn()
+    @grading_message.html("<p>" + msg + "</p>")
+
   collapse_question: () =>
     @prompt_container.slideToggle()
     @prompt_container.toggleClass('open')

common/lib/xmodule/xmodule/js/src/problem/edit.coffee

@@ -231,13 +231,14 @@ class @MarkdownEditingDescriptor extends XModule.Descriptor
       // replace string and numerical
       xml = xml.replace(/^\=\s*(.*?$)/gm, function(match, p) {
         var string;
-        var params = /(.*?)\+\-\s*(.*?$)/.exec(p);
-        if(parseFloat(p)) {
+        var floatValue = parseFloat(p);
+        if(!isNaN(floatValue)) {
+          var params = /(.*?)\+\-\s*(.*?$)/.exec(p);
           if(params) {
-            string = '<numericalresponse answer="' + params[1] + '">\n';
+            string = '<numericalresponse answer="' + floatValue + '">\n';
             string += '  <responseparam type="tolerance" default="' + params[2] + '" />\n';
           } else {
-            string = '<numericalresponse answer="' + p + '">\n';
+            string = '<numericalresponse answer="' + floatValue + '">\n';
           }
           string += '  <textline />\n';
           string += '</numericalresponse>\n\n';

common/lib/xmodule/xmodule/modulestore/__init__.py

@@ -23,6 +23,15 @@ URL_RE = re.compile("""
     (@(?P<revision>[^/]+))?
     """, re.VERBOSE)
 
+MISSING_SLASH_URL_RE = re.compile("""
+    (?P<tag>[^:]+):/
+    (?P<org>[^/]+)/
+    (?P<course>[^/]+)/
+    (?P<category>[^/]+)/
+    (?P<name>[^@]+)
+    (@(?P<revision>[^/]+))?
+    """, re.VERBOSE)
+
 # TODO (cpennington): We should decide whether we want to expand the
 # list of valid characters in a location
 INVALID_CHARS = re.compile(r"[^\w.-]")
@@ -62,6 +71,17 @@ class Location(_LocationBase):
         """
         return Location._clean(value, INVALID_CHARS)
 
+
+    @staticmethod
+    def clean_keeping_underscores(value):
+        """
+        Return value, replacing INVALID_CHARS, but not collapsing multiple '_' chars.
+        This for cleaning asset names, as the YouTube ID's may have underscores in them, and we need the
+        transcript asset name to match. In the future we may want to change the behavior of _clean.
+        """
+        return INVALID_CHARS.sub('_', value)
+
+
     @staticmethod
     def clean_for_url_name(value):
         """
@@ -164,12 +184,16 @@ class Location(_LocationBase):
         if isinstance(location, basestring):
             match = URL_RE.match(location)
             if match is None:
-                log.debug('location is instance of %s but no URL match' % basestring)
-                raise InvalidLocationError(location)
-            else:
-                groups = match.groupdict()
-                check_dict(groups)
-                return _LocationBase.__new__(_cls, **groups)
+                # cdodge:
+                # check for a dropped slash near the i4x:// element of the location string. This can happen with some
+                # redirects (e.g. edx.org -> www.edx.org which I think happens in Nginx)
+                match = MISSING_SLASH_URL_RE.match(location)
+                if match is None:
+                    log.debug('location is instance of %s but no URL match' % basestring)
+                    raise InvalidLocationError(location)    
+            groups = match.groupdict()
+            check_dict(groups)
+            return _LocationBase.__new__(_cls, **groups)
         elif isinstance(location, (list, tuple)):
             if len(location) not in (5, 6):
                 log.debug('location has wrong length')

common/lib/xmodule/xmodule/modulestore/mongo.py

@@ -64,7 +64,11 @@ class CachingDescriptorSystem(MakoDescriptorSystem):
         location = Location(location)
         json_data = self.module_data.get(location)
         if json_data is None:
-            return self.modulestore.get_item(location)
+            module = self.modulestore.get_item(location)
+            if module is not None:
+                # update our own cache after going to the DB to get cache miss
+                self.module_data.update(module.system.module_data)
+            return module
         else:
             # load the module and apply the inherited metadata
             try:
@@ -157,10 +161,15 @@ class MongoModuleStore(ModuleStoreBase):
         '''
         
         # get all collections in the course, this query should not return any leaf nodes
-        query = { '_id.org' : location.org,
-                '_id.course' : location.course,
-                '_id.revision' : None,
-                'definition.children':{'$ne': []}
+        query = { 
+                    '_id.org': location.org,
+                    '_id.course': location.course,
+                    '$or': [ 
+                    {"_id.category":"course"}, 
+                    {"_id.category":"chapter"},    
+                    {"_id.category":"sequential"},    
+                    {"_id.category":"vertical"}   
+                ]
                 }
         # we just want the Location, children, and metadata
         record_filter = {'_id':1,'definition.children':1,'metadata':1}
@@ -279,6 +288,13 @@ class MongoModuleStore(ModuleStoreBase):
 
         resource_fs = OSFS(root)
 
+        metadata_inheritance_tree = None
+
+        # if we are loading a course object, there is no parent to inherit the metadata from
+        # so don't bother getting it
+        if item['location']['category'] != 'course':
+            metadata_inheritance_tree = self.get_cached_metadata_inheritance_tree(Location(item['location']), 300)
+
         # TODO (cdodge): When the 'split module store' work has been completed, we should remove
         # the 'metadata_inheritance_tree' parameter
         system = CachingDescriptorSystem(
@@ -288,7 +304,7 @@ class MongoModuleStore(ModuleStoreBase):
             resource_fs,
             self.error_tracker,
             self.render_template,
-            metadata_inheritance_tree = self.get_cached_metadata_inheritance_tree(Location(item['location']), 60)
+            metadata_inheritance_tree = metadata_inheritance_tree
         )
         return system.load_item(item['location'])
 

common/lib/xmodule/xmodule/modulestore/xml_exporter.py

@@ -7,47 +7,47 @@ from json import dumps
 
 def export_to_xml(modulestore, contentstore, course_location, root_dir, course_dir):
 
-  course = modulestore.get_item(course_location)
+    course = modulestore.get_item(course_location)
 
-  fs = OSFS(root_dir)
-  export_fs = fs.makeopendir(course_dir)
+    fs = OSFS(root_dir)
+    export_fs = fs.makeopendir(course_dir)
 
-  xml = course.export_to_xml(export_fs)
-  with export_fs.open('course.xml', 'w') as course_xml:
-      course_xml.write(xml)
+    xml = course.export_to_xml(export_fs)
+    with export_fs.open('course.xml', 'w') as course_xml:
+        course_xml.write(xml)
 
-  # export the static assets
-  contentstore.export_all_for_course(course_location, root_dir + '/' + course_dir + '/static/')
+    # export the static assets
+    contentstore.export_all_for_course(course_location, root_dir + '/' + course_dir + '/static/')
 
-  # export the static tabs
-  export_extra_content(export_fs, modulestore, course_location, 'static_tab', 'tabs', '.html')
+    # export the static tabs
+    export_extra_content(export_fs, modulestore, course_location, 'static_tab', 'tabs', '.html')
 
-  # export the custom tags
-  export_extra_content(export_fs, modulestore, course_location, 'custom_tag_template', 'custom_tags')
+    # export the custom tags
+    export_extra_content(export_fs, modulestore, course_location, 'custom_tag_template', 'custom_tags')
 
-  # export the course updates
-  export_extra_content(export_fs, modulestore, course_location, 'course_info', 'info', '.html')
+    # export the course updates
+    export_extra_content(export_fs, modulestore, course_location, 'course_info', 'info', '.html')
 
-  # export the grading policy
-  policies_dir = export_fs.makeopendir('policies')
-  course_run_policy_dir = policies_dir.makeopendir(course.location.name)
-  if 'grading_policy' in course.definition['data']:
-    with course_run_policy_dir.open('grading_policy.json', 'w') as grading_policy:
-      grading_policy.write(dumps(course.definition['data']['grading_policy']))
+    # export the grading policy
+    policies_dir = export_fs.makeopendir('policies')
+    course_run_policy_dir = policies_dir.makeopendir(course.location.name)
+    if 'grading_policy' in course.definition['data']:
+        with course_run_policy_dir.open('grading_policy.json', 'w') as grading_policy:
+            grading_policy.write(dumps(course.definition['data']['grading_policy']))
 
-  # export all of the course metadata in policy.json
-  with course_run_policy_dir.open('policy.json', 'w') as course_policy:
-    policy = {}
-    policy = {'course/' + course.location.name: course.metadata}
-    course_policy.write(dumps(policy)) 
+    # export all of the course metadata in policy.json
+    with course_run_policy_dir.open('policy.json', 'w') as course_policy:
+        policy = {}
+        policy = {'course/' + course.location.name: course.metadata}
+        course_policy.write(dumps(policy))
 
 
 def export_extra_content(export_fs, modulestore, course_location, category_type, dirname, file_suffix=''):
-  query_loc = Location('i4x', course_location.org, course_location.course, category_type, None)
-  items = modulestore.get_items(query_loc)
-
-  if len(items) > 0:
-    item_dir = export_fs.makeopendir(dirname)
-    for item in items:
-      with item_dir.open(item.location.name + file_suffix, 'w') as item_file:
-        item_file.write(item.definition['data'].encode('utf8'))
+    query_loc = Location('i4x', course_location.org, course_location.course, category_type, None)
+    items = modulestore.get_items(query_loc)
+
+    if len(items) > 0:
+        item_dir = export_fs.makeopendir(dirname)
+        for item in items:
+            with item_dir.open(item.location.name + file_suffix, 'w') as item_file:
+                item_file.write(item.definition['data'].encode('utf8'))

common/lib/xmodule/xmodule/open_ended_grading_classes/combined_open_ended_modulev1.py

@@ -79,6 +79,9 @@ class CombinedOpenEndedV1Module():
     INTERMEDIATE_DONE = 'intermediate_done'
     DONE = 'done'
 
+    #Where the templates live for this problem
+    TEMPLATE_DIR = "combinedopenended"
+
     def __init__(self, system, location, definition, descriptor,
                  instance_state=None, shared_state=None, metadata = None, static_data = None, **kwargs):
 
@@ -343,7 +346,7 @@ class CombinedOpenEndedV1Module():
         Output: rendered html
         """
         context = self.get_context()
-        html = self.system.render_template('combined_open_ended.html', context)
+        html = self.system.render_template('{0}/combined_open_ended.html'.format(self.TEMPLATE_DIR), context)
         return html
 
     def get_html_nonsystem(self):
@@ -354,7 +357,7 @@ class CombinedOpenEndedV1Module():
         Output: HTML rendered directly via Mako
         """
         context = self.get_context()
-        html = self.system.render_template('combined_open_ended.html', context)
+        html = self.system.render_template('{0}/combined_open_ended.html'.format(self.TEMPLATE_DIR), context)
         return html
 
     def get_html_base(self):
@@ -531,7 +534,7 @@ class CombinedOpenEndedV1Module():
             'task_name' : 'Scored Rubric',
             'class_name' : 'combined-rubric-container'
         }
-        html = self.system.render_template('combined_open_ended_results.html', context)
+        html = self.system.render_template('{0}/combined_open_ended_results.html'.format(self.TEMPLATE_DIR), context)
         return {'html': html, 'success': True}
 
     def get_legend(self, get):
@@ -543,7 +546,7 @@ class CombinedOpenEndedV1Module():
         context = {
             'legend_list' : LEGEND_LIST,
             }
-        html = self.system.render_template('combined_open_ended_legend.html', context)
+        html = self.system.render_template('{0}/combined_open_ended_legend.html'.format(self.TEMPLATE_DIR), context)
         return {'html': html, 'success': True}
 
     def get_results(self, get):
@@ -574,7 +577,7 @@ class CombinedOpenEndedV1Module():
                     'submission_id' : ri['submission_ids'][i],
                 }
                 context_list.append(context)
-        feedback_table = self.system.render_template('open_ended_result_table.html', {
+        feedback_table = self.system.render_template('{0}/open_ended_result_table.html'.format(self.TEMPLATE_DIR), {
             'context_list' : context_list,
             'grader_type_image_dict' : GRADER_TYPE_IMAGE_DICT,
             'human_grader_types' : HUMAN_GRADER_TYPE,
@@ -586,7 +589,7 @@ class CombinedOpenEndedV1Module():
             'task_name' : "Feedback",
             'class_name' : "result-container",
             }
-        html = self.system.render_template('combined_open_ended_results.html', context)
+        html = self.system.render_template('{0}/combined_open_ended_results.html'.format(self.TEMPLATE_DIR), context)
         return {'html': html, 'success': True}
 
     def get_status_ajax(self, get):
@@ -700,7 +703,7 @@ class CombinedOpenEndedV1Module():
             'legend_list' : LEGEND_LIST,
             'render_via_ajax' : render_via_ajax,
         }
-        status_html = self.system.render_template("combined_open_ended_status.html", context)
+        status_html = self.system.render_template("{0}/combined_open_ended_status.html".format(self.TEMPLATE_DIR), context)
 
         return status_html
 

common/lib/xmodule/xmodule/open_ended_grading_classes/combined_open_ended_rubric.py

@@ -30,6 +30,8 @@ class RubricParsingError(Exception):
 
 class CombinedOpenEndedRubric(object):
 
+    TEMPLATE_DIR = "combinedopenended/openended"
+
     def __init__ (self, system, view_only = False):
         self.has_score = False
         self.view_only = view_only
@@ -57,9 +59,9 @@ class CombinedOpenEndedRubric(object):
             rubric_scores = [cat['score'] for cat in rubric_categories]
             max_scores = map((lambda cat: cat['options'][-1]['points']), rubric_categories)
             max_score = max(max_scores)
-            rubric_template = 'open_ended_rubric.html'
+            rubric_template = '{0}/open_ended_rubric.html'.format(self.TEMPLATE_DIR)
             if self.view_only:
-                rubric_template = 'open_ended_view_only_rubric.html'
+                rubric_template = '{0}/open_ended_view_only_rubric.html'.format(self.TEMPLATE_DIR)
             html = self.system.render_template(rubric_template,
                     {'categories': rubric_categories,
                      'has_score': self.has_score,
@@ -207,7 +209,7 @@ class CombinedOpenEndedRubric(object):
                         for grader_type in tuple[3]:
                             rubric_categories[i]['options'][j]['grader_types'].append(grader_type)
 
-        html = self.system.render_template('open_ended_combined_rubric.html',
+        html = self.system.render_template('{0}/open_ended_combined_rubric.html'.format(self.TEMPLATE_DIR),
             {'categories': rubric_categories,
              'has_score': True,
              'view_only': True,

common/lib/xmodule/xmodule/open_ended_grading_classes/open_ended_module.py

@@ -40,6 +40,8 @@ class OpenEndedModule(openendedchild.OpenEndedChild):
     </openended>
     """
 
+    TEMPLATE_DIR = "combinedopenended/openended"
+
     def setup_response(self, system, location, definition, descriptor):
         """
         Sets up the response type.
@@ -397,10 +399,10 @@ class OpenEndedModule(openendedchild.OpenEndedChild):
             rubric_scores = rubric_dict['rubric_scores']
 
         if not response_items['success']:
-            return system.render_template("open_ended_error.html",
+            return system.render_template("{0}/open_ended_error.html".format(self.TEMPLATE_DIR),
                 {'errors': feedback})
 
-        feedback_template = system.render_template("open_ended_feedback.html", {
+        feedback_template = system.render_template("{0}/open_ended_feedback.html".format(self.TEMPLATE_DIR), {
             'grader_type': response_items['grader_type'],
             'score': "{0} / {1}".format(response_items['score'], self.max_score()),
             'feedback': feedback,
@@ -558,7 +560,7 @@ class OpenEndedModule(openendedchild.OpenEndedChild):
         @return: Rendered html
         """
         context = {'msg': feedback, 'id': "1", 'rows': 50, 'cols': 50}
-        html = system.render_template('open_ended_evaluation.html', context)
+        html = system.render_template('{0}/open_ended_evaluation.html'.format(self.TEMPLATE_DIR), context)
         return html
 
     def handle_ajax(self, dispatch, get, system):
@@ -692,7 +694,7 @@ class OpenEndedModule(openendedchild.OpenEndedChild):
             'accept_file_upload': self.accept_file_upload,
             'eta_message' : eta_string,
         }
-        html = system.render_template('open_ended.html', context)
+        html = system.render_template('{0}/open_ended.html'.format(self.TEMPLATE_DIR), context)
         return html
 
 

common/lib/xmodule/xmodule/open_ended_grading_classes/openendedchild.py

@@ -22,7 +22,7 @@ from xmodule.stringify import stringify_children
 from xmodule.xml_module import XmlDescriptor
 from xmodule.modulestore import Location
 from capa.util import *
-from peer_grading_service import PeerGradingService
+from peer_grading_service import PeerGradingService, MockPeerGradingService
 import controller_query_service
 
 from datetime import datetime
@@ -106,8 +106,14 @@ class OpenEndedChild(object):
         # Used for progress / grading.  Currently get credit just for
         # completion (doesn't matter if you self-assessed correct/incorrect).
         self._max_score = static_data['max_score']
-        self.peer_gs = PeerGradingService(system.open_ended_grading_interface, system)
-        self.controller_qs = controller_query_service.ControllerQueryService(system.open_ended_grading_interface,system)
+        if system.open_ended_grading_interface:
+            self.peer_gs = PeerGradingService(system.open_ended_grading_interface, system)
+            self.controller_qs = controller_query_service.ControllerQueryService(system.open_ended_grading_interface,system)
+        else:
+            self.peer_gs = MockPeerGradingService()
+            self.controller_qs = None 
+
+
 
         self.system = system
         
@@ -461,11 +467,14 @@ class OpenEndedChild(object):
             return success, allowed_to_submit, error_message
 
     def get_eta(self):
-        response = self.controller_qs.check_for_eta(self.location_string)
-        try:
-            response = json.loads(response)
-        except:
-            pass
+        if self.controller_qs:
+            response = self.controller_qs.check_for_eta(self.location_string)
+            try:
+                response = json.loads(response)
+            except:
+                pass
+        else:
+            return ""
 
         success = response['success']
         if isinstance(success, basestring):

common/lib/xmodule/xmodule/open_ended_grading_classes/self_assessment_module.py

@@ -32,6 +32,8 @@ class SelfAssessmentModule(openendedchild.OpenEndedChild):
     </selfassessment>
     """
 
+    TEMPLATE_DIR = "combinedopenended/selfassessment"
+
     def setup_response(self, system, location, definition, descriptor):
         """
         Sets up the module
@@ -68,7 +70,7 @@ class SelfAssessmentModule(openendedchild.OpenEndedChild):
             'accept_file_upload': self.accept_file_upload,
         }
 
-        html = system.render_template('self_assessment_prompt.html', context)
+        html = system.render_template('{0}/self_assessment_prompt.html'.format(self.TEMPLATE_DIR), context)
         return html
 
 
@@ -129,7 +131,7 @@ class SelfAssessmentModule(openendedchild.OpenEndedChild):
             #This is a dev_facing_error
             raise ValueError("Self assessment module is in an illegal state '{0}'".format(self.state))
 
-        return system.render_template('self_assessment_rubric.html', context)
+        return system.render_template('{0}/self_assessment_rubric.html'.format(self.TEMPLATE_DIR), context)
 
     def get_hint_html(self, system):
         """
@@ -155,7 +157,7 @@ class SelfAssessmentModule(openendedchild.OpenEndedChild):
             #This is a dev_facing_error
             raise ValueError("Self Assessment module is in an illegal state '{0}'".format(self.state))
 
-        return system.render_template('self_assessment_hint.html', context)
+        return system.render_template('{0}/self_assessment_hint.html'.format(self.TEMPLATE_DIR), context)
 
 
     def save_answer(self, get, system):