Merge pull request #1526 from MITx/feature/cas/manual-policy-merged

Feature/cas/manual policy merged

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.py

@@ -4,13 +4,6 @@ from common import *
 ############### 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'
@@ -46,6 +39,7 @@ def i_save_a_new_section_release_date(step):
     css_fill(time_css, '12:00am')
     css_click('a.save-button')
 
+
 ############ ASSERTIONS ###################
 
 

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/views.py

@@ -58,8 +58,8 @@ from cms.djangoapps.models.settings.course_details import CourseDetails,\
     CourseSettingsEncoder
 from cms.djangoapps.models.settings.course_grading import CourseGradingModel
 from cms.djangoapps.contentstore.utils import get_modulestore
-from lxml import etree
 from django.shortcuts import redirect
+from cms.djangoapps.models.settings.course_metadata import CourseMetadata
 
 # to install PIL on MacOSX: 'easy_install http://dist.repoze.org/PIL-1.1.6.tar.gz'
 
@@ -365,7 +365,6 @@ def preview_component(request, location):
         'editor': wrap_xmodule(component.get_html, component, 'xmodule_edit.html')(),
     })
 
-
 @expect_json
 @login_required
 @ensure_csrf_cookie
@@ -682,7 +681,6 @@ def create_draft(request):
 
     return HttpResponse()
 
-
 @login_required
 @expect_json
 def publish_draft(request):
@@ -712,7 +710,6 @@ def unpublish_unit(request):
 
     return HttpResponse()
 
-
 @login_required
 @expect_json
 def clone_item(request):
@@ -901,7 +898,6 @@ def remove_user(request, location):
 def landing(request, org, course, coursename):
     return render_to_response('temp-course-landing.html', {})
 
-
 @login_required
 @ensure_csrf_cookie
 def static_pages(request, org, course, coursename):
@@ -1005,7 +1001,6 @@ def edit_tabs(request, org, course, coursename):
         'components': components
         })
 
-
 def not_found(request):
     return render_to_response('error.html', {'error': '404'})
 
@@ -1041,7 +1036,6 @@ def course_info(request, org, course, name, provided_id=None):
         'handouts_location': Location(['i4x', org, course, 'course_info', 'handouts']).url()
     })
 
-
 @expect_json
 @login_required
 @ensure_csrf_cookie
@@ -1112,7 +1106,6 @@ def module_info(request, module_location):
     else:
         return HttpResponseBadRequest()
 
-
 @login_required
 @ensure_csrf_cookie
 def get_course_settings(request, org, course, name):
@@ -1159,6 +1152,28 @@ def course_config_graders_page(request, org, course, name):
         'course_details': json.dumps(course_details, cls=CourseSettingsEncoder)
     })
 
+@login_required
+@ensure_csrf_cookie
+def course_config_advanced_page(request, org, course, name):
+    """
+    Send models and views as well as html for editing the advanced course settings to the client.
+
+    org, course, name: Attributes of the Location for the item to edit
+    """
+    location = ['i4x', org, course, 'course', name]
+
+    # check that logged in user has permissions to this item
+    if not has_access(request.user, location):
+        raise PermissionDenied()
+
+    course_module = modulestore().get_item(location)
+
+    return render_to_response('settings_advanced.html', {
+        'context_course': course_module,
+        'course_location' : location,
+        'advanced_blacklist' : json.dumps(CourseMetadata.FILTERED_LIST),
+        'advanced_dict' : json.dumps(CourseMetadata.fetch(location)),
+    })
 
 @expect_json
 @login_required
@@ -1191,7 +1206,6 @@ def course_settings_updates(request, org, course, name, section):
         return HttpResponse(json.dumps(manager.update_from_json(request.POST), cls=CourseSettingsEncoder),
                             mimetype="application/json")
 
-
 @expect_json
 @login_required
 @ensure_csrf_cookie
@@ -1226,6 +1240,37 @@ def course_grader_updates(request, org, course, name, grader_index=None):
         return HttpResponse(json.dumps(CourseGradingModel.update_grader_from_json(Location(['i4x', org, course, 'course', name]), request.POST)),
                             mimetype="application/json")
 
+        
+## NB: expect_json failed on ["key", "key2"] and json payload
+@login_required
+@ensure_csrf_cookie
+def course_advanced_updates(request, org, course, name):
+    """
+    restful CRUD operations on metadata. The payload is a json rep of the metadata dicts. For delete, otoh,
+    the payload is either a key or a list of keys to delete.
+
+    org, course: Attributes of the Location for the item to edit
+    """
+    location = ['i4x', org, course, 'course', name]
+    
+    # check that logged in user has permissions to this item
+    if not has_access(request.user, location):
+        raise PermissionDenied()
+
+    # NB: we're setting Backbone.emulateHTTP to true on the client so everything comes as a post!!!
+    if request.method == 'POST' and 'HTTP_X_HTTP_METHOD_OVERRIDE' in request.META:
+        real_method = request.META['HTTP_X_HTTP_METHOD_OVERRIDE']
+    else:
+        real_method = request.method
+        
+    if real_method == 'GET':
+        return HttpResponse(json.dumps(CourseMetadata.fetch(location)), mimetype="application/json")
+    elif real_method == 'DELETE':
+        return HttpResponse(json.dumps(CourseMetadata.delete_key(location, json.loads(request.body))), mimetype="application/json")
+    elif real_method == 'POST' or real_method == 'PUT':
+        # NOTE: request.POST is messed up because expect_json cloned_request.POST.copy() is creating a defective entry w/ the whole payload as the key
+        return HttpResponse(json.dumps(CourseMetadata.update_from_json(location, json.loads(request.body))), mimetype="application/json")
+
 
 @login_required
 @ensure_csrf_cookie
@@ -1286,7 +1331,6 @@ def asset_index(request, org, course, name):
 def edge(request):
     return render_to_response('university_profiles/edge.html', {})
 
-
 @login_required
 @expect_json
 def create_new_course(request):
@@ -1342,7 +1386,6 @@ def create_new_course(request):
 
     return HttpResponse(json.dumps({'id': new_course.location.url()}))
 
-
 def initialize_course_tabs(course):
     # set up the default tabs
     # I've added this because when we add static tabs, the LMS either expects a None for the tabs list or
@@ -1360,7 +1403,6 @@ def initialize_course_tabs(course):
 
     modulestore('direct').update_metadata(course.location.url(), course.own_metadata)
 
-
 @ensure_csrf_cookie
 @login_required
 def import_course(request, org, course, name):
@@ -1438,7 +1480,6 @@ def import_course(request, org, course, name):
                         course_module.location.name])
         })
 
-
 @ensure_csrf_cookie
 @login_required
 def generate_export_course(request, org, course, name):
@@ -1490,7 +1531,6 @@ def export_course(request, org, course, name):
         'successful_import_redirect_url': ''
     })
 
-
 def event(request):
     '''
     A noop to swallow the analytics call so that cms methods don't spook and poor developers looking at

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/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/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/settings/advanced_view.js

+if (!CMS.Views['Settings']) CMS.Views.Settings = {};
+
+CMS.Views.Settings.Advanced = CMS.Views.ValidatingView.extend({
+    error_saving : "error_saving",
+    successful_changes: "successful_changes",
+
+    // Model class is CMS.Models.Settings.Advanced
+    events : {
+        'click .delete-button' : "deleteEntry",
+        'click .new-button' : "addEntry",
+        // update model on changes
+        'change .policy-key' : "updateKey",
+        // keypress to catch alpha keys and backspace/delete on some browsers
+        'keypress .policy-key' : "showSaveCancelButtons",
+        // keyup to catch backspace/delete reliably
+        'keyup .policy-key' : "showSaveCancelButtons",
+        'focus :input' : "focusInput",
+        'blur :input' : "blurInput"
+        // TODO enable/disable save based on validation (currently enabled whenever there are changes)
+    },
+    initialize : function() {
+        var self = this;
+        // instantiates an editor template for each update in the collection
+        window.templateLoader.loadRemoteTemplate("advanced_entry",
+            "/static/client_templates/advanced_entry.html",
+            function (raw_template) {
+                self.template = _.template(raw_template);
+                self.render();
+            }
+        );
+        // because these are outside of this.$el, they can't be in the event hash
+        $('.save-button').on('click', this, this.saveView);
+        $('.cancel-button').on('click', this, this.revertView);
+        this.model.on('error', this.handleValidationError, this);
+    },
+    render: function() {
+        // catch potential outside call before template loaded
+        if (!this.template) return this;
+
+        var listEle$ = this.$el.find('.course-advanced-policy-list');
+        listEle$.empty();
+        
+        // b/c we've deleted all old fields, clear the map and repopulate
+        this.fieldToSelectorMap = {};
+        this.selectorToField = {};
+
+        // iterate through model and produce key : value editors for each property in model.get
+        var self = this;
+        _.each(_.sortBy(_.keys(this.model.attributes), _.identity),
+            function(key) {
+                listEle$.append(self.renderTemplate(key, self.model.get(key)));
+            });
+
+        var policyValues = listEle$.find('.json');
+        _.each(policyValues, this.attachJSONEditor, this);
+        this.showMessage();
+        return this;
+    },
+    attachJSONEditor : function (textarea) {
+        // Since we are allowing duplicate keys at the moment, it is possible that we will try to attach
+        // JSON Editor to a value that already has one. Therefore only attach if no CodeMirror peer exists.
+        if ( $(textarea).siblings().hasClass('CodeMirror')) {
+            return;
+        }
+
+        var self = this;
+        var oldValue = $(textarea).val();
+        CodeMirror.fromTextArea(textarea, {
+            mode: "application/json", lineNumbers: false, lineWrapping: false,
+            onChange: function(instance, changeobj) {
+                // this event's being called even when there's no change :-(
+                if (instance.getValue() !== oldValue) self.showSaveCancelButtons();
+            },
+            onFocus : function(mirror) {
+              $(textarea).parent().children('label').addClass("is-focused");
+            },
+            onBlur: function (mirror) {
+                $(textarea).parent().children('label').removeClass("is-focused");
+                var key = $(mirror.getWrapperElement()).closest('.field-group').children('.key').attr('id');
+                var stringValue = $.trim(mirror.getValue());
+                // update CodeMirror to show the trimmed value.
+                mirror.setValue(stringValue);
+                var JSONValue = undefined;
+                try {
+                    JSONValue = JSON.parse(stringValue);
+                } catch (e) {
+                    // If it didn't parse, try converting non-arrays/non-objects to a String.
+                    // But don't convert single-quote strings, which are most likely errors.
+                    var firstNonWhite = stringValue.substring(0, 1);
+                    if (firstNonWhite !== "{" && firstNonWhite !== "[" && firstNonWhite !== "'") {
+                        try {
+                            stringValue = '"'+stringValue +'"';
+                            JSONValue = JSON.parse(stringValue);
+                            mirror.setValue(stringValue);
+                        } catch(quotedE) {
+                            // TODO: validation error
+                            console.log("Error with JSON, even after converting to String.");
+                            console.log(quotedE);
+                            JSONValue = undefined;
+                        }
+                    }
+                    else {
+                        // TODO: validation error
+                        console.log("Error with JSON, but will not convert to String.");
+                        console.log(e);
+                    }
+                }
+                if (JSONValue !== undefined) {
+                    self.clearValidationErrors();
+                    self.model.set(key, JSONValue, {validate: true});
+                }
+            }
+        });
+    },
+
+    showMessage: function (type) {
+        this.$el.find(".message-status").removeClass("is-shown");
+        if (type) {
+            if (type === this.error_saving) {
+                this.$el.find(".message-status.error").addClass("is-shown");
+            }
+            else if (type === this.successful_changes) {
+                this.$el.find(".message-status.confirm").addClass("is-shown");
+                this.hideSaveCancelButtons();
+            }
+        }
+        else {
+            // This is the case of the page first rendering, or when Cancel is pressed.
+            this.hideSaveCancelButtons();
+            this.toggleNewButton(true);
+        }
+    },
+
+    showSaveCancelButtons: function(event) {
+        if (!this.buttonsVisible) {
+            if (event && (event.type === 'keypress' || event.type === 'keyup')) {
+                // check whether it's really an altering event: note, String.fromCharCode(keyCode) will 
+                // give positive values for control/command/option-letter combos; so, don't use it
+                if (!((event.charCode && String.fromCharCode(event.charCode) !== "") ||
+                        // 8 = backspace, 46 = delete
+                        event.keyCode === 8 || event.keyCode === 46)) return;
+            }
+            this.$el.find(".message-status").removeClass("is-shown");
+            $('.wrapper-notification').addClass('is-shown');
+            this.buttonsVisible = true;
+        }
+    },
+
+    hideSaveCancelButtons: function() {
+        $('.wrapper-notification').removeClass('is-shown');
+        this.buttonsVisible = false;
+    },
+
+    toggleNewButton: function (enable) {
+        var newButton = this.$el.find(".new-button");
+        if (enable) {
+            newButton.removeClass('disabled');
+        }
+        else {
+            newButton.addClass('disabled');
+        }
+    },
+
+    deleteEntry : function(event) {
+        event.preventDefault();
+        // find out which entry
+        var li$ = $(event.currentTarget).closest('li');
+        // Not data b/c the validation view uses it for a selector
+        var key = $('.key', li$).attr('id');
+
+        delete this.selectorToField[this.fieldToSelectorMap[key]];
+        delete this.fieldToSelectorMap[key];
+        if (key !== this.model.new_key) {
+            this.model.deleteKeys.push(key);
+            this.model.unset(key);
+        }
+        li$.remove();
+        this.showSaveCancelButtons();
+    },
+    saveView : function(event) {
+        // TODO one last verification scan:
+        //    call validateKey on each to ensure proper format
+        //    check for dupes
+        var self = event.data;
+        self.model.save({},
+            {
+            success : function() {
+                self.render();
+                self.showMessage(self.successful_changes);
+            },
+            error : CMS.ServerError
+        });
+    },
+    revertView : function(event) {
+        var self = event.data;
+        self.model.deleteKeys = [];
+        self.model.clear({silent : true});
+        self.model.fetch({
+            success : function() { self.render(); },
+            error : CMS.ServerError
+        });
+    },
+    addEntry : function() {
+        var listEle$ = this.$el.find('.course-advanced-policy-list');
+        var newEle = this.renderTemplate("", "");
+        listEle$.append(newEle);
+        // need to re-find b/c replaceWith seems to copy rather than use the specific ele instance
+        var policyValueDivs = this.$el.find('#' + this.model.new_key).closest('li').find('.json');
+        // only 1 but hey, let's take advantage of the context mechanism
+        _.each(policyValueDivs, this.attachJSONEditor, this);
+        this.toggleNewButton(false);
+    },
+    updateKey : function(event) {
+        var parentElement = $(event.currentTarget).closest('.key');
+        // old key: either the key as in the model or new_key.
+        // That is, it doesn't change as the val changes until val is accepted.
+        var oldKey = parentElement.attr('id');
+        // TODO: validation of keys with spaces. For now at least trim strings to remove initial and
+        // trailing whitespace
+        var newKey = $.trim($(event.currentTarget).val());
+        if (oldKey !== newKey) {
+            // TODO: is it OK to erase other validation messages?
+            this.clearValidationErrors();
+
+            if (!this.validateKey(oldKey, newKey)) return;
+
+            if (this.model.has(newKey)) {
+                var error = {};
+                error[oldKey] = 'You have already defined "' + newKey + '" in the manual policy definitions.';
+                error[newKey] = "You tried to enter a duplicate of this key.";
+                this.model.trigger("error", this.model, error);
+                return false;
+            }
+
+            // explicitly call validate to determine whether to proceed (relying on triggered error means putting continuation in the success
+            // method which is uglier I think?)
+            var newEntryModel = {};
+            // set the new key's value to the old one's
+            newEntryModel[newKey] = (oldKey === this.model.new_key ? '' : this.model.get(oldKey));
+
+            var validation = this.model.validate(newEntryModel);
+            if (validation) {
+                if (_.has(validation, newKey)) {
+                    // swap to the key which the map knows about
+                    validation[oldKey] = validation[newKey];
+                }
+                this.model.trigger("error", this.model, validation);
+                // abandon update
+                return;
+            }
+
+            // Now safe to actually do the update
+            this.model.set(newEntryModel);
+
+            // update maps
+            var selector = this.fieldToSelectorMap[oldKey];
+            this.selectorToField[selector] = newKey;
+            this.fieldToSelectorMap[newKey] = selector;
+            delete this.fieldToSelectorMap[oldKey];
+
+            if (oldKey !== this.model.new_key) {
+                // mark the old key for deletion and delete from field maps
+                this.model.deleteKeys.push(oldKey);
+                this.model.unset(oldKey) ;
+            }
+            else {
+                // id for the new entry will now be the key value. Enable new entry button.
+                this.toggleNewButton(true);
+            }
+            
+            // check for newkey being the name of one which was previously deleted in this session
+            var wasDeleting = this.model.deleteKeys.indexOf(newKey);
+            if (wasDeleting >= 0) {
+                this.model.deleteKeys.splice(wasDeleting, 1);
+            }
+
+            // Update the ID to the new value.
+            parentElement.attr('id', newKey);
+            
+        }
+    },
+    validateKey : function(oldKey, newKey) {
+        // model validation can't handle malformed keys nor notice if 2 fields have same key; so, need to add that chk here
+        // TODO ensure there's no spaces or illegal chars (note some checking for spaces currently done in model's
+        // validate method.
+        return true;
+    },
+
+    renderTemplate: function (key, value) {
+        var newKeyId = _.uniqueId('policy_key_'),
+        newEle = this.template({ key : key, value : JSON.stringify(value, null, 4),
+            keyUniqueId: newKeyId, valueUniqueId: _.uniqueId('policy_value_')});
+        
+        this.fieldToSelectorMap[(_.isEmpty(key) ? this.model.new_key : key)] = newKeyId;
+        this.selectorToField[newKeyId] = (_.isEmpty(key) ? this.model.new_key : key);
+        return newEle;
+    },
+    
+    focusInput : function(event) {
+        $(event.target).prev().addClass("is-focused");
+    },
+    blurInput : function(event) {
+        $(event.target).prev().removeClass("is-focused");
+    }
+});
\ No newline at end of file

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",

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",
@@ -310,8 +310,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/_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: 6px 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 {
+            margin-bottom: ($baseline/4);
+          }
+        }
+      }
+    }
   }
 
   .content-supplementary {

cms/templates/settings.html

@@ -23,7 +23,8 @@ 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() {
@@ -205,7 +206,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 +221,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/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/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/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/static/js/vendor/CodeMirror/codemirror.js

+// CodeMirror version 2.23 (with edits)
+//
 // All functions that need access to the editor's state live inside
 // the CodeMirror function. Below that, at the bottom of the file,
 // some utilities are defined.

common/static/js/vendor/CodeMirror/javascript.js

+CodeMirror.defineMode("javascript", function(config, parserConfig) {
+  var indentUnit = config.indentUnit;
+  var jsonMode = parserConfig.json;
+
+  // Tokenizer
+
+  var keywords = function(){
+    function kw(type) {return {type: type, style: "keyword"};}
+    var A = kw("keyword a"), B = kw("keyword b"), C = kw("keyword c");
+    var operator = kw("operator"), atom = {type: "atom", style: "atom"};
+    return {
+      "if": A, "while": A, "with": A, "else": B, "do": B, "try": B, "finally": B,
+      "return": C, "break": C, "continue": C, "new": C, "delete": C, "throw": C,
+      "var": kw("var"), "const": kw("var"), "let": kw("var"),
+      "function": kw("function"), "catch": kw("catch"),
+      "for": kw("for"), "switch": kw("switch"), "case": kw("case"), "default": kw("default"),
+      "in": operator, "typeof": operator, "instanceof": operator,
+      "true": atom, "false": atom, "null": atom, "undefined": atom, "NaN": atom, "Infinity": atom
+    };
+  }();
+
+  var isOperatorChar = /[+\-*&%=<>!?|]/;
+
+  function chain(stream, state, f) {
+    state.tokenize = f;
+    return f(stream, state);
+  }
+
+  function nextUntilUnescaped(stream, end) {
+    var escaped = false, next;
+    while ((next = stream.next()) != null) {
+      if (next == end && !escaped)
+        return false;
+      escaped = !escaped && next == "\\";
+    }
+    return escaped;
+  }
+
+  // Used as scratch variables to communicate multiple values without
+  // consing up tons of objects.
+  var type, content;
+  function ret(tp, style, cont) {
+    type = tp; content = cont;
+    return style;
+  }
+
+  function jsTokenBase(stream, state) {
+    var ch = stream.next();
+    if (ch == '"' || ch == "'")
+      return chain(stream, state, jsTokenString(ch));
+    else if (/[\[\]{}\(\),;\:\.]/.test(ch))
+      return ret(ch);
+    else if (ch == "0" && stream.eat(/x/i)) {
+      stream.eatWhile(/[\da-f]/i);
+      return ret("number", "number");
+    }      
+    else if (/\d/.test(ch)) {
+      stream.match(/^\d*(?:\.\d*)?(?:[eE][+\-]?\d+)?/);
+      return ret("number", "number");
+    }
+    else if (ch == "/") {
+      if (stream.eat("*")) {
+        return chain(stream, state, jsTokenComment);
+      }
+      else if (stream.eat("/")) {
+        stream.skipToEnd();
+        return ret("comment", "comment");
+      }
+      else if (state.reAllowed) {
+        nextUntilUnescaped(stream, "/");
+        stream.eatWhile(/[gimy]/); // 'y' is "sticky" option in Mozilla
+        return ret("regexp", "string-2");
+      }
+      else {
+        stream.eatWhile(isOperatorChar);
+        return ret("operator", null, stream.current());
+      }
+    }
+    else if (ch == "#") {
+        stream.skipToEnd();
+        return ret("error", "error");
+    }
+    else if (isOperatorChar.test(ch)) {
+      stream.eatWhile(isOperatorChar);
+      return ret("operator", null, stream.current());
+    }
+    else {
+      stream.eatWhile(/[\w\$_]/);
+      var word = stream.current(), known = keywords.propertyIsEnumerable(word) && keywords[word];
+      return (known && state.kwAllowed) ? ret(known.type, known.style, word) :
+                     ret("variable", "variable", word);
+    }
+  }
+
+  function jsTokenString(quote) {
+    return function(stream, state) {
+      if (!nextUntilUnescaped(stream, quote))
+        state.tokenize = jsTokenBase;
+      return ret("string", "string");
+    };
+  }
+
+  function jsTokenComment(stream, state) {
+    var maybeEnd = false, ch;
+    while (ch = stream.next()) {
+      if (ch == "/" && maybeEnd) {
+        state.tokenize = jsTokenBase;
+        break;
+      }
+      maybeEnd = (ch == "*");
+    }
+    return ret("comment", "comment");
+  }
+
+  // Parser
+
+  var atomicTypes = {"atom": true, "number": true, "variable": true, "string": true, "regexp": true};
+
+  function JSLexical(indented, column, type, align, prev, info) {
+    this.indented = indented;
+    this.column = column;
+    this.type = type;
+    this.prev = prev;
+    this.info = info;
+    if (align != null) this.align = align;
+  }
+
+  function inScope(state, varname) {
+    for (var v = state.localVars; v; v = v.next)
+      if (v.name == varname) return true;
+  }
+
+  function parseJS(state, style, type, content, stream) {
+    var cc = state.cc;
+    // Communicate our context to the combinators.
+    // (Less wasteful than consing up a hundred closures on every call.)
+    cx.state = state; cx.stream = stream; cx.marked = null, cx.cc = cc;
+  
+    if (!state.lexical.hasOwnProperty("align"))
+      state.lexical.align = true;
+
+    while(true) {
+      var combinator = cc.length ? cc.pop() : jsonMode ? expression : statement;
+      if (combinator(type, content)) {
+        while(cc.length && cc[cc.length - 1].lex)
+          cc.pop()();
+        if (cx.marked) return cx.marked;
+        if (type == "variable" && inScope(state, content)) return "variable-2";
+        return style;
+      }
+    }
+  }
+
+  // Combinator utils
+
+  var cx = {state: null, column: null, marked: null, cc: null};
+  function pass() {
+    for (var i = arguments.length - 1; i >= 0; i--) cx.cc.push(arguments[i]);
+  }
+  function cont() {
+    pass.apply(null, arguments);
+    return true;
+  }
+  function register(varname) {
+    var state = cx.state;
+    if (state.context) {
+      cx.marked = "def";
+      for (var v = state.localVars; v; v = v.next)
+        if (v.name == varname) return;
+      state.localVars = {name: varname, next: state.localVars};
+    }
+  }
+
+  // Combinators
+
+  var defaultVars = {name: "this", next: {name: "arguments"}};
+  function pushcontext() {
+    if (!cx.state.context) cx.state.localVars = defaultVars;
+    cx.state.context = {prev: cx.state.context, vars: cx.state.localVars};
+  }
+  function popcontext() {
+    cx.state.localVars = cx.state.context.vars;
+    cx.state.context = cx.state.context.prev;
+  }
+  function pushlex(type, info) {
+    var result = function() {
+      var state = cx.state;
+      state.lexical = new JSLexical(state.indented, cx.stream.column(), type, null, state.lexical, info)
+    };
+    result.lex = true;
+    return result;
+  }
+  function poplex() {
+    var state = cx.state;
+    if (state.lexical.prev) {
+      if (state.lexical.type == ")")
+        state.indented = state.lexical.indented;
+      state.lexical = state.lexical.prev;
+    }
+  }
+  poplex.lex = true;
+
+  function expect(wanted) {
+    return function expecting(type) {
+      if (type == wanted) return cont();
+      else if (wanted == ";") return pass();
+      else return cont(arguments.callee);
+    };
+  }
+
+  function statement(type) {
+    if (type == "var") return cont(pushlex("vardef"), vardef1, expect(";"), poplex);
+    if (type == "keyword a") return cont(pushlex("form"), expression, statement, poplex);
+    if (type == "keyword b") return cont(pushlex("form"), statement, poplex);
+    if (type == "{") return cont(pushlex("}"), block, poplex);
+    if (type == ";") return cont();
+    if (type == "function") return cont(functiondef);
+    if (type == "for") return cont(pushlex("form"), expect("("), pushlex(")"), forspec1, expect(")"),
+                                      poplex, statement, poplex);
+    if (type == "variable") return cont(pushlex("stat"), maybelabel);
+    if (type == "switch") return cont(pushlex("form"), expression, pushlex("}", "switch"), expect("{"),
+                                         block, poplex, poplex);
+    if (type == "case") return cont(expression, expect(":"));
+    if (type == "default") return cont(expect(":"));
+    if (type == "catch") return cont(pushlex("form"), pushcontext, expect("("), funarg, expect(")"),
+                                        statement, poplex, popcontext);
+    return pass(pushlex("stat"), expression, expect(";"), poplex);
+  }
+  function expression(type) {
+    if (atomicTypes.hasOwnProperty(type)) return cont(maybeoperator);
+    if (type == "function") return cont(functiondef);
+    if (type == "keyword c") return cont(maybeexpression);
+    if (type == "(") return cont(pushlex(")"), maybeexpression, expect(")"), poplex, maybeoperator);
+    if (type == "operator") return cont(expression);
+    if (type == "[") return cont(pushlex("]"), commasep(expression, "]"), poplex, maybeoperator);
+    if (type == "{") return cont(pushlex("}"), commasep(objprop, "}"), poplex, maybeoperator);
+    return cont();
+  }
+  function maybeexpression(type) {
+    if (type.match(/[;\}\)\],]/)) return pass();
+    return pass(expression);
+  }
+    
+  function maybeoperator(type, value) {
+    if (type == "operator" && /\+\+|--/.test(value)) return cont(maybeoperator);
+    if (type == "operator") return cont(expression);
+    if (type == ";") return;
+    if (type == "(") return cont(pushlex(")"), commasep(expression, ")"), poplex, maybeoperator);
+    if (type == ".") return cont(property, maybeoperator);
+    if (type == "[") return cont(pushlex("]"), expression, expect("]"), poplex, maybeoperator);
+  }
+  function maybelabel(type) {
+    if (type == ":") return cont(poplex, statement);
+    return pass(maybeoperator, expect(";"), poplex);
+  }
+  function property(type) {
+    if (type == "variable") {cx.marked = "property"; return cont();}
+  }
+  function objprop(type) {
+    if (type == "variable") cx.marked = "property";
+    if (atomicTypes.hasOwnProperty(type)) return cont(expect(":"), expression);
+  }
+  function commasep(what, end) {
+    function proceed(type) {
+      if (type == ",") return cont(what, proceed);
+      if (type == end) return cont();
+      return cont(expect(end));
+    }
+    return function commaSeparated(type) {
+      if (type == end) return cont();
+      else return pass(what, proceed);
+    };
+  }
+  function block(type) {
+    if (type == "}") return cont();
+    return pass(statement, block);
+  }
+  function vardef1(type, value) {
+    if (type == "variable"){register(value); return cont(vardef2);}
+    return cont();
+  }
+  function vardef2(type, value) {
+    if (value == "=") return cont(expression, vardef2);
+    if (type == ",") return cont(vardef1);
+  }
+  function forspec1(type) {
+    if (type == "var") return cont(vardef1, forspec2);
+    if (type == ";") return pass(forspec2);
+    if (type == "variable") return cont(formaybein);
+    return pass(forspec2);
+  }
+  function formaybein(type, value) {
+    if (value == "in") return cont(expression);
+    return cont(maybeoperator, forspec2);
+  }
+  function forspec2(type, value) {
+    if (type == ";") return cont(forspec3);
+    if (value == "in") return cont(expression);
+    return cont(expression, expect(";"), forspec3);
+  }
+  function forspec3(type) {
+    if (type != ")") cont(expression);
+  }
+  function functiondef(type, value) {
+    if (type == "variable") {register(value); return cont(functiondef);}
+    if (type == "(") return cont(pushlex(")"), pushcontext, commasep(funarg, ")"), poplex, statement, popcontext);
+  }
+  function funarg(type, value) {
+    if (type == "variable") {register(value); return cont();}
+  }
+
+  // Interface
+
+  return {
+    startState: function(basecolumn) {
+      return {
+        tokenize: jsTokenBase,
+        reAllowed: true,
+        kwAllowed: true,
+        cc: [],
+        lexical: new JSLexical((basecolumn || 0) - indentUnit, 0, "block", false),
+        localVars: parserConfig.localVars,
+        context: parserConfig.localVars && {vars: parserConfig.localVars},
+        indented: 0
+      };
+    },
+
+    token: function(stream, state) {
+      if (stream.sol()) {
+        if (!state.lexical.hasOwnProperty("align"))
+          state.lexical.align = false;
+        state.indented = stream.indentation();
+      }
+      if (stream.eatSpace()) return null;
+      var style = state.tokenize(stream, state);
+      if (type == "comment") return style;
+      state.reAllowed = !!(type == "operator" || type == "keyword c" || type.match(/^[\[{}\(,;:]$/));
+      state.kwAllowed = type != '.';
+      return parseJS(state, style, type, content, stream);
+    },
+
+    indent: function(state, textAfter) {
+      if (state.tokenize != jsTokenBase) return 0;
+      var firstChar = textAfter && textAfter.charAt(0), lexical = state.lexical,
+          type = lexical.type, closing = firstChar == type;
+      if (type == "vardef") return lexical.indented + 4;
+      else if (type == "form" && firstChar == "{") return lexical.indented;
+      else if (type == "stat" || type == "form") return lexical.indented + indentUnit;
+      else if (lexical.info == "switch" && !closing)
+        return lexical.indented + (/^(?:case|default)\b/.test(textAfter) ? indentUnit : 2 * indentUnit);
+      else if (lexical.align) return lexical.column + (closing ? 0 : 1);
+      else return lexical.indented + (closing ? 0 : indentUnit);
+    },
+
+    electricChars: ":{}"
+  };
+});
+
+CodeMirror.defineMIME("text/javascript", "javascript");
+CodeMirror.defineMIME("application/json", {name: "javascript", json: true});