fix mega merge conflicts

.gitignore

@@ -28,3 +28,6 @@ nosetests.xml
 cover_html/
 .idea/
 .redcar/
+chromedriver.log
+/nbproject
+ghostdriver.log

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "common/test/phantom-jasmine"]
+  path = common/test/phantom-jasmine    
+  url = https://github.com/jcarver989/phantom-jasmine.git

.pep8

@@ -0,0 +1,2 @@
+[pep8]
+ignore=E501

.pylintrc

@@ -12,7 +12,7 @@ profile=no
 
 # Add files or directories to the blacklist. They should be base names, not
 # paths.
-ignore=CVS
+ignore=CVS, migrations
 
 # Pickle collected data for later comparisons.
 persistent=yes
@@ -33,7 +33,16 @@ load-plugins=
 # can either give multiple identifier separated by comma (,) or put this option
 # multiple time (only on the command line, not in the configuration file where
 # it should appear only once).
-disable=E1102,W0142
+disable=
+# W0141: Used builtin function 'map'
+# W0142: Used * or ** magic
+# R0201: Method could be a function
+# R0901: Too many ancestors
+# R0902: Too many instance attributes
+# R0903: Too few public methods (1/2)
+# R0904: Too many public methods
+# R0913: Too many arguments
+    W0141,W0142,R0201,R0901,R0902,R0903,R0904,R0913
 
 
 [REPORTS]
@@ -43,7 +52,7 @@ disable=E1102,W0142
 output-format=text
 
 # Include message's id in output
-include-ids=no
+include-ids=yes
 
 # Put messages in a separate file for each module / package specified on the
 # command line instead of printing them on stdout. Reports (if any) will be
@@ -97,7 +106,7 @@ bad-functions=map,filter,apply,input
 module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
 
 # Regular expression which should only match correct module level names
-const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__))$
+const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__)|log|urlpatterns)$
 
 # Regular expression which should only match correct class names
 class-rgx=[A-Z_][a-zA-Z0-9]+$
@@ -106,7 +115,7 @@ class-rgx=[A-Z_][a-zA-Z0-9]+$
 function-rgx=[a-z_][a-z0-9_]{2,30}$
 
 # Regular expression which should only match correct method names
-method-rgx=[a-z_][a-z0-9_]{2,30}$
+method-rgx=([a-z_][a-z0-9_]{2,60}|setUp|set[Uu]pClass|tearDown|tear[Dd]ownClass|assert[A-Z]\w*)$
 
 # Regular expression which should only match correct instance attribute names
 attr-rgx=[a-z_][a-z0-9_]{2,30}$
@@ -129,7 +138,7 @@ bad-names=foo,bar,baz,toto,tutu,tata
 
 # Regular expression which should only match functions or classes name which do
 # not require a docstring
-no-docstring-rgx=__.*__
+no-docstring-rgx=(__.*__|test_.*)
 
 
 [MISCELLANEOUS]

.ruby-version

@@ -0,0 +1 @@
+1.9.3-p374

Gemfile

@@ -1,5 +1,6 @@
-source :rubygems
-ruby "1.9.3"
-gem 'rake'
+source 'https://rubygems.org'
+gem 'rake', '~> 10.0.3'
 gem 'sass', '3.1.15'
 gem 'bourbon', '~> 1.3.6'
+gem 'colorize', '~> 0.5.8'
+gem 'launchy', '~> 2.1.2'

apt-packages.txt

@@ -9,6 +9,7 @@ gfortran
 liblapack-dev
 libfreetype6-dev
 libpng12-dev
+libjpeg-dev
 libxml2-dev
 libxslt-dev
 yui-compressor

cms/.coveragerc

@@ -1,12 +1,14 @@
 # .coveragerc for cms
 [run]
 data_file = reports/cms/.coverage
-source = cms
+source = cms,common/djangoapps
+omit = cms/envs/*, cms/manage.py, common/djangoapps/terrain/*, common/djangoapps/*/migrations/*
 
 [report]
 ignore_errors = True
 
 [html]
+title = CMS Python Test Coverage Report
 directory = reports/cms/cover
 
 [xml]

cms/CHANGELOG.md

@@ -0,0 +1,21 @@
+Instructions
+============
+For each pull request, add one or more lines to the bottom of the change list. When
+code is released to production, change the `Upcoming` entry to todays date, and add
+a new block at the bottom of the file.
+
+    Upcoming
+    --------
+
+Change log entries should be targeted at end users. A good place to start is the
+user story that instigated the pull request.
+
+
+Changes
+=======
+
+Upcoming
+--------
+* Fix: Deleting last component in a unit does not work
+* Fix: Unit name is editable when a unit is public
+* Fix: Visual feedback inconsistent when saving a unit name change

cms/__init__.py

@@ -1 +0,0 @@
-

cms/djangoapps/auth/authz.py

@@ -6,35 +6,52 @@ from django.core.exceptions import PermissionDenied
 
 from xmodule.modulestore import Location
 
+'''
+This code is somewhat duplicative of access.py in the LMS. We will unify the code as a separate story
+but this implementation should be data compatible with the LMS implementation
+'''
+
 # define a couple of simple roles, we just need ADMIN and EDITOR now for our purposes
-ADMIN_ROLE_NAME = 'admin'
-EDITOR_ROLE_NAME = 'editor'
+INSTRUCTOR_ROLE_NAME = 'instructor'
+STAFF_ROLE_NAME = 'staff'
 
 # we're just making a Django group for each location/role combo
 # to do this we're just creating a Group name which is a formatted string
 # of those two variables
+
+
 def get_course_groupname_for_role(location, role):
     loc = Location(location)
-    groupname = loc.course_id  + ':' + role
+    # hack: check for existence of a group name in the legacy LMS format <role>_<course>
+    # if it exists, then use that one, otherwise use a <role>_<course_id> which contains
+    # more information
+    groupname = '{0}_{1}'.format(role, loc.course)
+
+    if len(Group.objects.filter(name=groupname)) == 0:
+        groupname = '{0}_{1}'.format(role, loc.course_id)
+
     return groupname
 
+
 def get_users_in_course_group_by_role(location, role):
     groupname = get_course_groupname_for_role(location, role)
-    group = Group.objects.get(name=groupname)
+    (group, created) = Group.objects.get_or_create(name=groupname)
     return group.user_set.all()
 
 
 '''
 Create all permission groups for a new course and subscribe the caller into those roles
 '''
+
+
 def create_all_course_groups(creator, location):
-    create_new_course_group(creator, location, ADMIN_GROUP_NAME)
-    create_new_course_group(creator, location, EDITOR_GROUP_NAME)
+    create_new_course_group(creator, location, INSTRUCTOR_ROLE_NAME)
+    create_new_course_group(creator, location, STAFF_ROLE_NAME)
 
 
 def create_new_course_group(creator, location, role):
     groupname = get_course_groupname_for_role(location, role)
-    (group, created) =Group.get_or_create(name=groupname)
+    (group, created) = Group.objects.get_or_create(name=groupname)
     if created:
         group.save()
 
@@ -43,10 +60,47 @@ def create_new_course_group(creator, location, role):
 
     return
 
+'''
+This is to be called only by either a command line code path or through a app which has already
+asserted permissions
+'''
+
+
+def _delete_course_group(location):
+    # remove all memberships
+    instructors = Group.objects.get(name=get_course_groupname_for_role(location, INSTRUCTOR_ROLE_NAME))
+    for user in instructors.user_set.all():
+        user.groups.remove(instructors)
+        user.save()
+
+    staff = Group.objects.get(name=get_course_groupname_for_role(location, STAFF_ROLE_NAME))
+    for user in staff.user_set.all():
+        user.groups.remove(staff)
+        user.save()
+
+'''
+This is to be called only by either a command line code path or through an app which has already
+asserted permissions to do this action
+'''
+
+
+def _copy_course_group(source, dest):
+    instructors = Group.objects.get(name=get_course_groupname_for_role(source, INSTRUCTOR_ROLE_NAME))
+    new_instructors_group = Group.objects.get(name=get_course_groupname_for_role(dest, INSTRUCTOR_ROLE_NAME))
+    for user in instructors.user_set.all():
+        user.groups.add(new_instructors_group)
+        user.save()
+
+    staff = Group.objects.get(name=get_course_groupname_for_role(source, STAFF_ROLE_NAME))
+    new_staff_group = Group.objects.get(name=get_course_groupname_for_role(dest, STAFF_ROLE_NAME))
+    for user in staff.user_set.all():
+        user.groups.add(new_staff_group)
+        user.save()
+
 
 def add_user_to_course_group(caller, user, location, role):
     # only admins can add/remove other users
-    if not is_user_in_course_group_role(caller, location, ADMIN_ROLE_NAME):
+    if not is_user_in_course_group_role(caller, location, INSTRUCTOR_ROLE_NAME):
         raise PermissionDenied
 
     if user.is_active and user.is_authenticated:
@@ -73,7 +127,7 @@ def get_user_by_email(email):
 
 def remove_user_from_course_group(caller, user, location, role):
     # only admins can add/remove other users
-    if not is_user_in_course_group_role(caller, location, ADMIN_ROLE_NAME):
+    if not is_user_in_course_group_role(caller, location, INSTRUCTOR_ROLE_NAME):
         raise PermissionDenied
 
     # see if the user is actually in that role, if not then we don't have to do anything
@@ -87,8 +141,7 @@ def remove_user_from_course_group(caller, user, location, role):
 
 def is_user_in_course_group_role(user, location, role):
     if user.is_active and user.is_authenticated:
-        return user.groups.filter(name=get_course_groupname_for_role(location,role)).count() > 0
+        # all "is_staff" flagged accounts belong to all groups
+        return user.is_staff or user.groups.filter(name=get_course_groupname_for_role(location, role)).count() > 0
 
     return False
-
-    

cms/djangoapps/contentstore/__init__.py

@@ -1,3 +1 @@
-from xmodule.templates import update_templates
 
-update_templates()

cms/djangoapps/contentstore/course_info_model.py

@@ -0,0 +1,152 @@
+from xmodule.modulestore.exceptions import ItemNotFoundError
+from xmodule.modulestore import Location
+from xmodule.modulestore.django import modulestore
+from lxml import html
+import re
+from django.http import HttpResponseBadRequest
+import logging
+import django.utils
+
+# # TODO store as array of { date, content } and override  course_info_module.definition_from_xml
+# # This should be in a class which inherits from XmlDescriptor
+log = logging.getLogger(__name__)
+
+
+def get_course_updates(location):
+    """
+    Retrieve the relevant course_info updates and unpack into the model which the client expects:
+    [{id : location.url() + idx to make unique, date : string, content : html string}]
+    """
+    try:
+        course_updates = modulestore('direct').get_item(location)
+    except ItemNotFoundError:
+        template = Location(['i4x', 'edx', "templates", 'course_info', "Empty"])
+        course_updates = modulestore('direct').clone_item(template, Location(location))
+
+    # current db rep: {"_id" : locationjson, "definition" : { "data" : "<ol>[<li><h2>date</h2>content</li>]</ol>"} "metadata" : ignored}
+    location_base = course_updates.location.url()
+
+    # purely to handle free formed updates not done via editor. Actually kills them, but at least doesn't break.
+    try:
+        course_html_parsed = html.fromstring(course_updates.data)
+    except:
+        log.error("Cannot parse: " + course_updates.data)
+        escaped = django.utils.html.escape(course_updates.data)
+        course_html_parsed = html.fromstring("<ol><li>" + escaped + "</li></ol>")
+
+    # Confirm that root is <ol>, iterate over <li>, pull out <h2> subs and then rest of val
+    course_upd_collection = []
+    if course_html_parsed.tag == 'ol':
+        # 0 is the newest
+        for idx, update in enumerate(course_html_parsed):
+            if (len(update) == 0):
+                continue
+            elif (len(update) == 1):
+                # could enforce that update[0].tag == 'h2'
+                content = update[0].tail
+            else:
+                content = "\n".join([html.tostring(ele) for ele in update[1:]])
+
+            # make the id on the client be 1..len w/ 1 being the oldest and len being the newest
+            course_upd_collection.append({"id": location_base + "/" + str(len(course_html_parsed) - idx),
+                                          "date": update.findtext("h2"),
+                                          "content": content})
+
+    return course_upd_collection
+
+
+def update_course_updates(location, update, passed_id=None):
+    """
+    Either add or update the given course update. It will add it if the passed_id is absent or None. It will update it if
+    it has an passed_id which has a valid value. Until updates have distinct values, the passed_id is the location url + an index
+    into the html structure.
+    """
+    try:
+        course_updates = modulestore('direct').get_item(location)
+    except ItemNotFoundError:
+        return HttpResponseBadRequest()
+
+    # purely to handle free formed updates not done via editor. Actually kills them, but at least doesn't break.
+    try:
+        course_html_parsed = html.fromstring(course_updates.data)
+    except:
+        log.error("Cannot parse: " + course_updates.data)
+        escaped = django.utils.html.escape(course_updates.data)
+        course_html_parsed = html.fromstring("<ol><li>" + escaped + "</li></ol>")
+
+    # No try/catch b/c failure generates an error back to client
+    new_html_parsed = html.fromstring('<li><h2>' + update['date'] + '</h2>' + update['content'] + '</li>')
+
+    # Confirm that root is <ol>, iterate over <li>, pull out <h2> subs and then rest of val
+    if course_html_parsed.tag == 'ol':
+        # ??? Should this use the id in the json or in the url or does it matter?
+        if passed_id is not None:
+            idx = get_idx(passed_id)
+            # idx is count from end of list
+            course_html_parsed[-idx] = new_html_parsed
+        else:
+            course_html_parsed.insert(0, new_html_parsed)
+
+            idx = len(course_html_parsed)
+            passed_id = course_updates.location.url() + "/" + str(idx)
+
+        # update db record
+        course_updates.data = html.tostring(course_html_parsed)
+        modulestore('direct').update_item(location, course_updates.data)
+
+        if (len(new_html_parsed) == 1):
+            content = new_html_parsed[0].tail
+        else:
+            content = "\n".join([html.tostring(ele)
+                for ele in new_html_parsed[1:]])
+
+        return {"id": passed_id,
+                "date": update['date'],
+                "content": content}
+
+
+def delete_course_update(location, update, passed_id):
+    """
+    Delete the given course_info update from the db.
+    Returns the resulting course_updates b/c their ids change.
+    """
+    if not passed_id:
+        return HttpResponseBadRequest()
+
+    try:
+        course_updates = modulestore('direct').get_item(location)
+    except ItemNotFoundError:
+        return HttpResponseBadRequest()
+
+    # TODO use delete_blank_text parser throughout and cache as a static var in a class
+    # purely to handle free formed updates not done via editor. Actually kills them, but at least doesn't break.
+    try:
+        course_html_parsed = html.fromstring(course_updates.data)
+    except:
+        log.error("Cannot parse: " + course_updates.data)
+        escaped = django.utils.html.escape(course_updates.data)
+        course_html_parsed = html.fromstring("<ol><li>" + escaped + "</li></ol>")
+
+    if course_html_parsed.tag == 'ol':
+        # ??? Should this use the id in the json or in the url or does it matter?
+        idx = get_idx(passed_id)
+        # idx is count from end of list
+        element_to_delete = course_html_parsed[-idx]
+        if element_to_delete is not None:
+            course_html_parsed.remove(element_to_delete)
+
+        # update db record
+        course_updates.data = html.tostring(course_html_parsed)
+        store = modulestore('direct')
+        store.update_item(location, course_updates.data)
+
+    return get_course_updates(location)
+
+
+def get_idx(passed_id):
+    """
+    From the url w/ idx appended, get the idx.
+    """
+    idx_matcher = re.search(r'.*?/?(\d+)$', passed_id)
+    if idx_matcher:
+        return int(idx_matcher.group(1))

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

@@ -0,0 +1,42 @@
+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 default advanced settings
+    Given I have opened a new course in Studio
+    When I select the Advanced Settings
+    Then I see default advanced settings
+
+  Scenario: Add new entries, and they appear alphabetically after save
+    Given I am on the Advanced Course Settings page in Studio
+    Then the settings are alphabetized
+
+  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
+    And I reload the page
+    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
+    And I reload the page
+    Then the policy key value is changed
+
+  Scenario: Test how multi-line input appears
+    Given I am on the Advanced Course Settings page in Studio
+    When I create a JSON object as a value
+    Then it is displayed as formatted
+    And I reload the page
+    Then it is displayed as formatted
+
+  Scenario: Test automatic quoting of non-JSON values
+    Given I am on the Advanced Course Settings page in Studio
+    When I create a non-JSON value not in quotes
+    Then it is displayed as a string
+    And I reload the page
+    Then it is displayed as a string

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

@@ -0,0 +1,146 @@
+from lettuce import world, step
+from common import *
+import time
+from terrain.steps import reload_the_page
+from selenium.common.exceptions import WebDriverException
+from selenium.webdriver.support import expected_conditions as EC
+
+from nose.tools import assert_true, assert_false, assert_equal
+
+"""
+http://selenium.googlecode.com/svn/trunk/docs/api/py/webdriver/selenium.webdriver.common.keys.html
+"""
+from selenium.webdriver.common.keys import Keys
+
+KEY_CSS = '.key input.policy-key'
+VALUE_CSS = 'textarea.json'
+DISPLAY_NAME_KEY = "display_name"
+DISPLAY_NAME_VALUE = '"Robot Super Course"'
+
+############### 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')
+
+
+@step(u'I press the "([^"]*)" notification button$')
+def press_the_notification_button(step, name):
+    def is_visible(driver):
+        return EC.visibility_of_element_located((By.CSS_SELECTOR, css,))
+
+    #    def is_invisible(driver):
+    #        return EC.invisibility_of_element_located((By.CSS_SELECTOR,css,))
+
+    css = 'a.%s-button' % name.lower()
+    wait_for(is_visible)
+    time.sleep(float(1))
+    css_click_at(css)
+
+#   is_invisible is not returning a boolean, not working
+#    try:
+#        css_click_at(css)
+#        wait_for(is_invisible)
+#    except WebDriverException, e:
+#        css_click_at(css)
+#        wait_for(is_invisible)
+
+
+@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 :)
+    """
+    e = css_find(KEY_CSS)[get_index_of(DISPLAY_NAME_KEY)]
+    e._element.send_keys(Keys.TAB, Keys.END, Keys.ARROW_LEFT, ' ', 'X')
+
+
+@step('I create a JSON object as a value$')
+def create_JSON_object(step):
+    change_display_name_value(step, '{"key": "value", "key_2": "value_2"}')
+
+
+@step('I create a non-JSON value not in quotes$')
+def create_value_not_in_quotes(step):
+    change_display_name_value(step, 'quote me')
+
+
+############### RESULTS ####################
+@step('I see default advanced settings$')
+def i_see_default_advanced_settings(step):
+    # Test only a few of the existing properties (there are around 34 of them)
+    assert_policy_entries(
+        ["advanced_modules", DISPLAY_NAME_KEY, "show_calculator"], ["[]", DISPLAY_NAME_VALUE, "false"])
+
+
+@step('the settings are alphabetized$')
+def they_are_alphabetized(step):
+    key_elements = css_find(KEY_CSS)
+    all_keys = []
+    for key in key_elements:
+        all_keys.append(key.value)
+
+    assert_equal(sorted(all_keys), all_keys, "policy keys were not sorted")
+
+
+@step('it is displayed as formatted$')
+def it_is_formatted(step):
+    assert_policy_entries([DISPLAY_NAME_KEY], ['{\n    "key": "value",\n    "key_2": "value_2"\n}'])
+
+
+@step('it is displayed as a string')
+def it_is_formatted(step):
+    assert_policy_entries([DISPLAY_NAME_KEY], ['"quote me"'])
+
+
+@step(u'the policy key value is unchanged$')
+def the_policy_key_value_is_unchanged(step):
+    assert_equal(get_display_name_value(), DISPLAY_NAME_VALUE)
+
+
+@step(u'the policy key value is changed$')
+def the_policy_key_value_is_changed(step):
+    assert_equal(get_display_name_value(), '"Robot Super Course X"')
+
+
+############# HELPERS ###############
+def assert_policy_entries(expected_keys, expected_values):
+    for counter in range(len(expected_keys)):
+        index = get_index_of(expected_keys[counter])
+        assert_false(index == -1, "Could not find key: " + expected_keys[counter])
+        assert_equal(expected_values[counter], css_find(VALUE_CSS)[index].value, "value is incorrect")
+
+
+def get_index_of(expected_key):
+    for counter in range(len(css_find(KEY_CSS))):
+        #   Sometimes get stale reference if I hold on to the array of elements
+        key = css_find(KEY_CSS)[counter].value
+        if key == expected_key:
+            return counter
+
+    return -1
+
+
+def get_display_name_value():
+    index = get_index_of(DISPLAY_NAME_KEY)
+    return css_find(VALUE_CSS)[index].value
+
+
+def change_display_name_value(step, new_value):
+    e = css_find(KEY_CSS)[get_index_of(DISPLAY_NAME_KEY)]
+    display_name = get_display_name_value()
+    for count in range(len(display_name)):
+        e._element.send_keys(Keys.TAB, Keys.END, Keys.BACK_SPACE)
+        # Must delete "" before typing the JSON value
+    e._element.send_keys(Keys.TAB, Keys.END, Keys.BACK_SPACE, Keys.BACK_SPACE, new_value)
+    press_the_notification_button(step, "Save")

cms/djangoapps/contentstore/features/checklists.feature

@@ -0,0 +1,24 @@
+Feature: Course checklists
+
+  Scenario: A course author sees checklists defined by edX
+    Given I have opened a new course in Studio
+    When I select Checklists from the Tools menu
+    Then I see the four default edX checklists
+
+  Scenario: A course author can mark tasks as complete
+    Given I have opened Checklists
+    Then I can check and uncheck tasks in a checklist
+    And They are correctly selected after I reload the page
+
+  Scenario: A task can link to a location within Studio
+    Given I have opened Checklists
+    When I select a link to the course outline
+    Then I am brought to the course outline page
+    And I press the browser back button
+    Then I am brought back to the course outline in the correct state
+
+  Scenario: A task can link to a location outside Studio
+    Given I have opened Checklists
+    When I select a link to help page
+    Then I am brought to the help page in a new window
+

cms/djangoapps/contentstore/features/checklists.py

@@ -0,0 +1,119 @@
+from lettuce import world, step
+from common import *
+from terrain.steps import reload_the_page
+
+############### ACTIONS ####################
+@step('I select Checklists from the Tools menu$')
+def i_select_checklists(step):
+    expand_icon_css = 'li.nav-course-tools i.icon-expand'
+    if world.browser.is_element_present_by_css(expand_icon_css):
+        css_click(expand_icon_css)
+    link_css = 'li.nav-course-tools-checklists a'
+    css_click(link_css)
+
+
+@step('I have opened Checklists$')
+def i_have_opened_checklists(step):
+    step.given('I have opened a new course in Studio')
+    step.given('I select Checklists from the Tools menu')
+
+
+@step('I see the four default edX checklists$')
+def i_see_default_checklists(step):
+    checklists = css_find('.checklist-title')
+    assert_equal(4, len(checklists))
+    assert_true(checklists[0].text.endswith('Getting Started With Studio'))
+    assert_true(checklists[1].text.endswith('Draft a Rough Course Outline'))
+    assert_true(checklists[2].text.endswith("Explore edX\'s Support Tools"))
+    assert_true(checklists[3].text.endswith('Draft Your Course About Page'))
+
+
+@step('I can check and uncheck tasks in a checklist$')
+def i_can_check_and_uncheck_tasks(step):
+    # Use the 2nd checklist as a reference
+    verifyChecklist2Status(0, 7, 0)
+    toggleTask(1, 0)
+    verifyChecklist2Status(1, 7, 14)
+    toggleTask(1, 3)
+    verifyChecklist2Status(2, 7, 29)
+    toggleTask(1, 6)
+    verifyChecklist2Status(3, 7, 43)
+    toggleTask(1, 3)
+    verifyChecklist2Status(2, 7, 29)
+
+
+@step('They are correctly selected after I reload the page$')
+def tasks_correctly_selected_after_reload(step):
+    reload_the_page(step)
+    verifyChecklist2Status(2, 7, 29)
+    # verify that task 7 is still selected by toggling its checkbox state and making sure that it deselects
+    toggleTask(1, 6)
+    verifyChecklist2Status(1, 7, 14)
+
+
+@step('I select a link to the course outline$')
+def i_select_a_link_to_the_course_outline(step):
+    clickActionLink(1, 0, 'Edit Course Outline')
+
+
+@step('I am brought to the course outline page$')
+def i_am_brought_to_course_outline(step):
+    assert_equal('Course Outline', css_find('.outline .title-1')[0].text)
+    assert_equal(1, len(world.browser.windows))
+
+
+@step('I am brought back to the course outline in the correct state$')
+def i_am_brought_back_to_course_outline(step):
+    step.given('I see the four default edX checklists')
+    # In a previous step, we selected (1, 0) in order to click the 'Edit Course Outline' link.
+    # Make sure the task is still showing as selected (there was a caching bug with the collection).
+    verifyChecklist2Status(1, 7, 14)
+
+
+@step('I select a link to help page$')
+def i_select_a_link_to_the_help_page(step):
+    clickActionLink(2, 0, 'Visit Studio Help')
+
+
+@step('I am brought to the help page in a new window$')
+def i_am_brought_to_help_page_in_new_window(step):
+    step.given('I see the four default edX checklists')
+    windows = world.browser.windows
+    assert_equal(2, len(windows))
+    world.browser.switch_to_window(windows[1])
+    assert_equal('http://help.edge.edx.org/', world.browser.url)
+
+
+
+
+############### HELPER METHODS ####################
+def verifyChecklist2Status(completed, total, percentage):
+    def verify_count(driver):
+        try:
+            statusCount = css_find('#course-checklist1 .status-count').first
+            return statusCount.text == str(completed)
+        except StaleElementReferenceException:
+            return False
+
+    wait_for(verify_count)
+    assert_equal(str(total), css_find('#course-checklist1 .status-amount').first.text)
+    # Would like to check the CSS width, but not sure how to do that.
+    assert_equal(str(percentage), css_find('#course-checklist1 .viz-checklist-status-value .int').first.text)
+
+
+def toggleTask(checklist, task):
+    css_click('#course-checklist' + str(checklist) +'-task' + str(task))
+
+
+def clickActionLink(checklist, task, actionText):
+    # toggle checklist item to make sure that the link button is showing
+    toggleTask(checklist, task)
+    action_link = css_find('#course-checklist' + str(checklist) + ' a')[task]
+
+    # text will be empty initially, wait for it to populate
+    def verify_action_link_text(driver):
+        return action_link.text == actionText
+
+    wait_for(verify_action_link_text)
+    action_link.click()
+

cms/djangoapps/contentstore/features/common.py

@@ -0,0 +1,209 @@
+from lettuce import world, step
+from lettuce.django import django_url
+from nose.tools import assert_true
+from nose.tools import assert_equal
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.common.exceptions import WebDriverException, StaleElementReferenceException
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.common.by import By
+
+from xmodule.modulestore.django import _MODULESTORES, modulestore
+from xmodule.templates import update_templates
+from auth.authz import get_user_by_email
+
+from logging import getLogger
+logger = getLogger(__name__)
+
+###########  STEP HELPERS ##############
+@step('I (?:visit|access|open) the Studio homepage$')
+def i_visit_the_studio_homepage(step):
+    # To make this go to port 8001, put
+    # LETTUCE_SERVER_PORT = 8001
+    # in your settings.py file.
+    world.browser.visit(django_url('/'))
+    signin_css = 'a.action-signin'
+    assert world.browser.is_element_present_by_css(signin_css, 10)
+
+
+@step('I am logged into Studio$')
+def i_am_logged_into_studio(step):
+    log_into_studio()
+
+
+@step('I confirm the alert$')
+def i_confirm_with_ok(step):
+    world.browser.get_alert().accept()
+
+
+@step(u'I press the "([^"]*)" delete icon$')
+def i_press_the_category_delete_icon(step, category):
+    if category == 'section':
+        css = 'a.delete-button.delete-section-button span.delete-icon'
+    elif category == 'subsection':
+        css = 'a.delete-button.delete-subsection-button  span.delete-icon'
+    else:
+        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 ##############
+def create_studio_user(
+        uname='robot',
+        email='robot+studio@edx.org',
+        password='test',
+        is_staff=False):
+    studio_user = world.UserFactory.build(
+        username=uname,
+        email=email,
+        password=password,
+        is_staff=is_staff)
+    studio_user.set_password(password)
+    studio_user.save()
+
+    registration = world.RegistrationFactory(user=studio_user)
+    registration.register(studio_user)
+    registration.activate()
+
+    user_profile = world.UserProfileFactory(user=studio_user)
+
+
+def flush_xmodule_store():
+    # Flush and initialize the module store
+    # It needs the templates because it creates new records
+    # by cloning from the template.
+    # Note that if your test module gets in some weird state
+    # (though it shouldn't), do this manually
+    # from the bash shell to drop it:
+    # $ mongo test_xmodule --eval "db.dropDatabase()"
+    _MODULESTORES = {}
+    modulestore().collection.drop()
+    update_templates()
+
+
+def assert_css_with_text(css, text):
+    assert_true(world.browser.is_element_present_by_css(css, 5))
+    assert_equal(world.browser.find_by_css(css).text, text)
+
+
+def css_click(css):
+    '''
+    First try to use the regular click method, 
+    but if clicking in the middle of an element
+    doesn't work it might be that it thinks some other
+    element is on top of it there so click in the upper left
+    '''
+    try:
+        css_find(css).first.click()
+    except WebDriverException, e:
+        css_click_at(css)
+
+
+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
+    '''
+    e = css_find(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):
+    def is_visible(driver):
+        return EC.visibility_of_element_located((By.CSS_SELECTOR,css,))
+
+    world.browser.is_element_present_by_css(css, 5)
+    wait_for(is_visible)
+    return world.browser.find_by_css(css)
+
+
+def wait_for(func):
+    WebDriverWait(world.browser.driver, 5).until(func)
+
+
+def id_find(id):
+    return world.browser.find_by_id(id)
+
+
+def clear_courses():
+    flush_xmodule_store()
+
+
+def fill_in_course_info(
+        name='Robot Super Course',
+        org='MITx',
+        num='101'):
+    css_fill('.new-course-name', name)
+    css_fill('.new-course-org', org)
+    css_fill('.new-course-number', num)
+
+
+def log_into_studio(
+        uname='robot',
+        email='robot+studio@edx.org',
+        password='test',
+        is_staff=False):
+    create_studio_user(uname=uname, email=email, is_staff=is_staff)
+    world.browser.cookies.delete()
+    world.browser.visit(django_url('/'))
+    signin_css = 'a.action-signin'
+    world.browser.is_element_present_by_css(signin_css, 10)
+
+    # click the signin button
+    css_click(signin_css)
+
+    login_form = world.browser.find_by_css('form#login_form')
+    login_form.find_by_name('email').fill(email)
+    login_form.find_by_name('password').fill(password)
+    login_form.find_by_name('submit').click()
+
+    assert_true(world.browser.is_element_present_by_css('.new-course-button', 5))
+
+
+def create_a_course():
+    c = world.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 = world.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))
+
+
+def add_section(name='My Section'):
+    link_css = 'a.new-courseware-section-button'
+    css_click(link_css)
+    name_css = 'input.new-section-name'
+    save_css = 'input.new-section-name-save'
+    css_fill(name_css, name)
+    css_click(save_css)
+    span_css = 'span.section-name-span'
+    assert_true(world.browser.is_element_present_by_css(span_css, 5))
+
+
+def add_subsection(name='Subsection One'):
+    css = 'a.new-subsection-item'
+    css_click(css)
+    name_css = 'input.new-subsection-name-input'
+    save_css = 'input.new-subsection-name-save'
+    css_fill(name_css, name)
+    css_click(save_css)

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

@@ -0,0 +1,25 @@
+Feature: Course Settings
+  As a course author, I want to be able to configure my course settings.
+
+  Scenario: User can set course dates
+    Given I have opened a new course in Studio
+    When I select Schedule and Details
+    And I set course dates
+    Then I see the set dates on refresh
+
+  Scenario: User can clear previously set course dates (except start date)
+    Given I have set course dates
+    And I clear all the dates except start
+    Then I see cleared dates on refresh
+
+  Scenario: User cannot clear the course start date
+    Given I have set course dates
+    And I clear the course start date
+    Then I receive a warning about course start date
+    And The previously set start date is shown on refresh
+
+  Scenario: User can correct the course start date warning
+    Given I have tried to clear the course start
+    And I have entered a new course start date
+    Then The warning about course start date goes away
+    And My new course start date is shown on refresh

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

@@ -0,0 +1,163 @@
+from lettuce import world, step
+from common import *
+from terrain.steps import reload_the_page
+from selenium.webdriver.common.keys import Keys
+import time
+
+from nose.tools import assert_true, assert_false, assert_equal
+
+COURSE_START_DATE_CSS = "#course-start-date"
+COURSE_END_DATE_CSS = "#course-end-date"
+ENROLLMENT_START_DATE_CSS = "#course-enrollment-start-date"
+ENROLLMENT_END_DATE_CSS = "#course-enrollment-end-date"
+
+COURSE_START_TIME_CSS = "#course-start-time"
+COURSE_END_TIME_CSS = "#course-end-time"
+ENROLLMENT_START_TIME_CSS = "#course-enrollment-start-time"
+ENROLLMENT_END_TIME_CSS = "#course-enrollment-end-time"
+
+DUMMY_TIME = "3:30pm"
+DEFAULT_TIME = "12:00am"
+
+
+############### ACTIONS ####################
+@step('I select Schedule and Details$')
+def test_i_select_schedule_and_details(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-schedule a'
+    css_click(link_css)
+
+
+@step('I have set course dates$')
+def test_i_have_set_course_dates(step):
+    step.given('I have opened a new course in Studio')
+    step.given('I select Schedule and Details')
+    step.given('And I set course dates')
+
+
+@step('And I set course dates$')
+def test_and_i_set_course_dates(step):
+    set_date_or_time(COURSE_START_DATE_CSS, '12/20/2013')
+    set_date_or_time(COURSE_END_DATE_CSS, '12/26/2013')
+    set_date_or_time(ENROLLMENT_START_DATE_CSS, '12/1/2013')
+    set_date_or_time(ENROLLMENT_END_DATE_CSS, '12/10/2013')
+
+    set_date_or_time(COURSE_START_TIME_CSS, DUMMY_TIME)
+    set_date_or_time(ENROLLMENT_END_TIME_CSS, DUMMY_TIME)
+
+    pause()
+
+
+@step('Then I see the set dates on refresh$')
+def test_then_i_see_the_set_dates_on_refresh(step):
+    reload_the_page(step)
+    verify_date_or_time(COURSE_START_DATE_CSS, '12/20/2013')
+    verify_date_or_time(COURSE_END_DATE_CSS, '12/26/2013')
+    verify_date_or_time(ENROLLMENT_START_DATE_CSS, '12/01/2013')
+    verify_date_or_time(ENROLLMENT_END_DATE_CSS, '12/10/2013')
+
+    verify_date_or_time(COURSE_START_TIME_CSS, DUMMY_TIME)
+    # Unset times get set to 12 AM once the corresponding date has been set.
+    verify_date_or_time(COURSE_END_TIME_CSS, DEFAULT_TIME)
+    verify_date_or_time(ENROLLMENT_START_TIME_CSS, DEFAULT_TIME)
+    verify_date_or_time(ENROLLMENT_END_TIME_CSS, DUMMY_TIME)
+
+
+@step('And I clear all the dates except start$')
+def test_and_i_clear_all_the_dates_except_start(step):
+    set_date_or_time(COURSE_END_DATE_CSS, '')
+    set_date_or_time(ENROLLMENT_START_DATE_CSS, '')
+    set_date_or_time(ENROLLMENT_END_DATE_CSS, '')
+
+    pause()
+
+
+@step('Then I see cleared dates on refresh$')
+def test_then_i_see_cleared_dates_on_refresh(step):
+    reload_the_page(step)
+    verify_date_or_time(COURSE_END_DATE_CSS, '')
+    verify_date_or_time(ENROLLMENT_START_DATE_CSS, '')
+    verify_date_or_time(ENROLLMENT_END_DATE_CSS, '')
+
+    verify_date_or_time(COURSE_END_TIME_CSS, '')
+    verify_date_or_time(ENROLLMENT_START_TIME_CSS, '')
+    verify_date_or_time(ENROLLMENT_END_TIME_CSS, '')
+
+    # Verify course start date (required) and time still there
+    verify_date_or_time(COURSE_START_DATE_CSS, '12/20/2013')
+    verify_date_or_time(COURSE_START_TIME_CSS, DUMMY_TIME)
+
+
+@step('I clear the course start date$')
+def test_i_clear_the_course_start_date(step):
+    set_date_or_time(COURSE_START_DATE_CSS, '')
+
+
+@step('I receive a warning about course start date$')
+def test_i_receive_a_warning_about_course_start_date(step):
+    assert_css_with_text('.message-error', 'The course must have an assigned start date.')
+    assert_true('error' in css_find(COURSE_START_DATE_CSS).first._element.get_attribute('class'))
+    assert_true('error' in css_find(COURSE_START_TIME_CSS).first._element.get_attribute('class'))
+
+
+@step('The previously set start date is shown on refresh$')
+def test_the_previously_set_start_date_is_shown_on_refresh(step):
+    reload_the_page(step)
+    verify_date_or_time(COURSE_START_DATE_CSS, '12/20/2013')
+    verify_date_or_time(COURSE_START_TIME_CSS, DUMMY_TIME)
+
+
+@step('Given I have tried to clear the course start$')
+def test_i_have_tried_to_clear_the_course_start(step):
+    step.given("I have set course dates")
+    step.given("I clear the course start date")
+    step.given("I receive a warning about course start date")
+
+
+@step('I have entered a new course start date$')
+def test_i_have_entered_a_new_course_start_date(step):
+    set_date_or_time(COURSE_START_DATE_CSS, '12/22/2013')
+    pause()
+
+
+@step('The warning about course start date goes away$')
+def test_the_warning_about_course_start_date_goes_away(step):
+    assert_equal(0, len(css_find('.message-error')))
+    assert_false('error' in css_find(COURSE_START_DATE_CSS).first._element.get_attribute('class'))
+    assert_false('error' in css_find(COURSE_START_TIME_CSS).first._element.get_attribute('class'))
+
+
+@step('My new course start date is shown on refresh$')
+def test_my_new_course_start_date_is_shown_on_refresh(step):
+    reload_the_page(step)
+    verify_date_or_time(COURSE_START_DATE_CSS, '12/22/2013')
+    # Time should have stayed from before attempt to clear date.
+    verify_date_or_time(COURSE_START_TIME_CSS, DUMMY_TIME)
+
+
+############### HELPER METHODS ####################
+def set_date_or_time(css, date_or_time):
+    """
+    Sets date or time field.
+    """
+    css_fill(css, date_or_time)
+    e = css_find(css).first
+    # hit Enter to apply the changes
+    e._element.send_keys(Keys.ENTER)
+
+
+def verify_date_or_time(css, date_or_time):
+    """
+    Verifies date or time field.
+    """
+    assert_equal(date_or_time, css_find(css).first.value)
+
+
+def pause():
+    """
+    Must sleep briefly to allow last time save to finish,
+    else refresh of browser will fail.
+    """
+    time.sleep(float(1))

cms/djangoapps/contentstore/features/courses.feature

@@ -0,0 +1,13 @@
+Feature: Create Course
+  In order offer a course on the edX platform
+  As a course author
+  I want to create courses
+
+  Scenario: Create a course
+    Given There are no courses
+    And I am logged into Studio
+    When I click the New Course button
+    And I fill in the new course information
+    And I press the "Save" button
+    Then the Courseware page has loaded in Studio
+    And I see a link for adding a new section

cms/djangoapps/contentstore/features/courses.py

@@ -0,0 +1,62 @@
+from lettuce import world, step
+from common import *
+
+############### ACTIONS ####################
+
+
+@step('There are no courses$')
+def no_courses(step):
+    clear_courses()
+
+
+@step('I click the New Course button$')
+def i_click_new_course(step):
+    css_click('.new-course-button')
+
+
+@step('I fill in the new course information$')
+def i_fill_in_a_new_course_information(step):
+    fill_in_course_info()
+
+
+@step('I create a new course$')
+def i_create_a_course(step):
+    create_a_course()
+
+
+@step('I click the course link in My Courses$')
+def i_click_the_course_link_in_my_courses(step):
+    course_css = 'span.class-name'
+    css_click(course_css)
+
+############ ASSERTIONS ###################
+
+
+@step('the Courseware page has loaded in Studio$')
+def courseware_page_has_loaded_in_studio(step):
+    course_title_css = 'span.course-title'
+    assert world.browser.is_element_present_by_css(course_title_css)
+
+
+@step('I see the course listed in My Courses$')
+def i_see_the_course_in_my_courses(step):
+    course_css = 'span.class-name'
+    assert_css_with_text(course_css, 'Robot Super Course')
+
+
+@step('the course is loaded$')
+def course_is_loaded(step):
+    class_css = 'a.class-name'
+    assert_css_with_text(class_css, 'Robot Super Course')
+
+
+@step('I am on the "([^"]*)" tab$')
+def i_am_on_tab(step, tab_name):
+    header_css = 'div.inner-wrapper h1'
+    assert_css_with_text(header_css, tab_name)
+
+
+@step('I see a link for adding a new section$')
+def i_see_new_section_link(step):
+    link_css = 'a.new-courseware-section-button'
+    assert_css_with_text(link_css, '+ New Section')

cms/djangoapps/contentstore/features/section.feature

@@ -0,0 +1,35 @@
+Feature: Create Section
+  In order offer a course on the edX platform
+  As a course author
+  I want to create and edit sections
+
+  Scenario: Add a new section to a course
+    Given I have opened a new course in Studio
+    When I click the New Section link
+    And I enter the section name and click save
+    Then I see my section on the Courseware page
+    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
+    When I click the Edit link for the release date
+    And I save a new section release date
+    Then the section release date is updated
+
+  @skip-phantom
+  Scenario: Delete section
+    Given I have opened a new course in Studio
+    And I have added a new section
+    When I press the "section" delete icon
+    And I confirm the alert
+    Then the section does not exist

cms/djangoapps/contentstore/features/section.py

@@ -0,0 +1,129 @@
+from lettuce import world, step
+from common import *
+from nose.tools import assert_equal
+from selenium.webdriver.common.keys import Keys
+import time
+
+############### ACTIONS ####################
+
+
+@step('I click the new section link$')
+def i_click_new_section_link(step):
+    link_css = 'a.new-courseware-section-button'
+    css_click(link_css)
+
+
+@step('I enter the section name and click save$')
+def i_save_section_name(step):
+    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$')
+def i_have_added_new_section(step):
+    add_section()
+
+
+@step('I click the Edit link for the release date$')
+def i_click_the_edit_link_for_the_release_date(step):
+    button_css = 'div.section-published-date a.edit-button'
+    css_click(button_css)
+
+
+@step('I save a new section release date$')
+def i_save_a_new_section_release_date(step):
+    date_css = 'input.start-date.date.hasDatepicker'
+    time_css = 'input.start-time.time.ui-timepicker-input'
+    css_fill(date_css, '12/25/2013')
+    # hit TAB to get to the time field
+    e = css_find(date_css).first
+    e._element.send_keys(Keys.TAB)
+    css_fill(time_css, '12:00am')
+    e = css_find(time_css).first
+    e._element.send_keys(Keys.TAB)
+    time.sleep(float(1))
+    world.browser.click_link_by_text('Save')
+
+
+############ ASSERTIONS ###################
+
+
+@step('I see my section on the Courseware page$')
+def i_see_my_section_on_the_courseware_page(step):
+    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$')
+def section_does_not_exist(step):
+    css = 'span.section-name-span'
+    assert world.browser.is_element_not_present_by_css(css)
+
+
+@step('I see a release date for my section$')
+def i_see_a_release_date_for_my_section(step):
+    import re
+
+    css = 'span.published-status'
+    assert world.browser.is_element_present_by_css(css)
+    status_text = world.browser.find_by_css(css).text
+
+    # e.g. 11/06/2012 at 16:25
+    msg = 'Will Release:'
+    date_regex = '[01][0-9]\/[0-3][0-9]\/[12][0-9][0-9][0-9]'
+    time_regex = '[0-2][0-9]:[0-5][0-9]'
+    match_string = '%s %s at %s' % (msg, date_regex, time_regex)
+    assert re.match(match_string, status_text)
+
+
+@step('I see a link to create a new subsection$')
+def i_see_a_link_to_create_a_new_subsection(step):
+    css = 'a.new-subsection-item'
+    assert world.browser.is_element_present_by_css(css)
+
+
+@step('the section release date picker is not visible$')
+def the_section_release_date_picker_not_visible(step):
+    css = 'div.edit-subsection-publish-settings'
+    assert False, world.browser.find_by_css(css).visible
+
+
+@step('the section release date is updated$')
+def the_section_release_date_is_updated(step):
+    css = 'span.published-status'
+    status_text = world.browser.find_by_css(css).text
+    assert_equal(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)

cms/djangoapps/contentstore/features/signup.feature

@@ -0,0 +1,12 @@
+Feature: Sign in
+  In order to use the edX content
+  As a new user
+  I want to signup for a student account
+
+  Scenario: Sign up from the homepage
+    Given I visit the Studio homepage
+    When I click the link with the text "Sign Up"
+    And I fill in the registration form
+    And I press the Create My Account button on the registration form
+    Then I should see be on the studio home page
+    And I should see the message "please click on the activation link in your email."

cms/djangoapps/contentstore/features/signup.py

@@ -0,0 +1,30 @@
+from lettuce import world, step
+from common import *
+
+
+@step('I fill in the registration form$')
+def i_fill_in_the_registration_form(step):
+    register_form = world.browser.find_by_css('form#register_form')
+    register_form.find_by_name('email').fill('robot+studio@edx.org')
+    register_form.find_by_name('password').fill('test')
+    register_form.find_by_name('username').fill('robot-studio')
+    register_form.find_by_name('name').fill('Robot Studio')
+    register_form.find_by_name('terms_of_service').check()
+
+
+@step('I press the Create My Account button on the registration form$')
+def i_press_the_button_on_the_registration_form(step):
+    submit_css = 'form#register_form button#submit'
+    # Workaround for click not working on ubuntu
+    # for some unknown reason.
+    e = css_find(submit_css)
+    e.type(' ')
+
+@step('I should see be on the studio home page$')
+def i_should_see_be_on_the_studio_home_page(step):
+    assert world.browser.find_by_css('div.inner-wrapper')
+
+
+@step(u'I should see the message "([^"]*)"$')
+def i_should_see_the_message(step, msg):
+    assert world.browser.is_text_present(msg, 5)

cms/djangoapps/contentstore/features/studio-overview-togglesection.feature

@@ -0,0 +1,60 @@
+Feature: Overview Toggle Section
+	In order to quickly view the details of a course's section or to scan the inventory of sections
+	As a course author
+	I want to toggle the visibility of each section's  subsection details in the overview listing
+
+	Scenario: The default layout for the overview page is to show sections in expanded view
+		Given I have a course with multiple sections
+		When I navigate to the course overview page
+		Then I see the "Collapse All Sections" link
+		And all sections are expanded
+
+	Scenario: Expand/collapse for a course with no sections
+		Given I have a course with no sections
+		When I navigate to the course overview page
+		Then I do not see the "Collapse All Sections" link
+
+	Scenario: Collapse link appears after creating first section of a course
+		Given I have a course with no sections
+		When I navigate to the course overview page
+		And I add a section
+		Then I see the "Collapse All Sections" link
+		And all sections are expanded
+
+	@skip-phantom
+	Scenario: Collapse link is not removed after last section of a course is deleted
+		Given I have a course with 1 section
+		And I navigate to the course overview page
+	    When I press the "section" delete icon
+	    And I confirm the alert
+		Then I see the "Collapse All Sections" link
+
+	Scenario: Collapsing all sections when all sections are expanded
+		Given I navigate to the courseware page of a course with multiple sections
+		And all sections are expanded
+		When I click the "Collapse All Sections" link
+		Then I see the "Expand All Sections" link
+		And all sections are collapsed
+
+	Scenario: Collapsing all sections when 1 or more sections are already collapsed
+		Given I navigate to the courseware page of a course with multiple sections
+		And all sections are expanded
+		When I collapse the first section
+		And I click the "Collapse All Sections" link
+		Then I see the "Expand All Sections" link
+		And all sections are collapsed
+
+	Scenario: Expanding all sections when all sections are collapsed
+		Given I navigate to the courseware page of a course with multiple sections
+		And I click the "Collapse All Sections" link
+		When I click the "Expand All Sections" link
+		Then I see the "Collapse All Sections" link
+		And all sections are expanded
+
+	Scenario: Expanding all sections when 1 or more sections are already expanded
+		Given I navigate to the courseware page of a course with multiple sections
+		And I click the "Collapse All Sections" link
+		When I expand the first section
+		And I click the "Expand All Sections" link
+		Then I see the "Collapse All Sections" link
+		And all sections are expanded

cms/djangoapps/contentstore/features/studio-overview-togglesection.py

@@ -0,0 +1,116 @@
+from lettuce import world, step
+from common import *
+from nose.tools import assert_true, assert_false, assert_equal
+
+from logging import getLogger
+logger = getLogger(__name__)
+
+
+@step(u'I have a course with no sections$')
+def have_a_course(step):
+    clear_courses()
+    course = world.CourseFactory.create()
+
+
+@step(u'I have a course with 1 section$')
+def have_a_course_with_1_section(step):
+    clear_courses()
+    course = world.CourseFactory.create()
+    section = world.ItemFactory.create(parent_location=course.location)
+    subsection1 = world.ItemFactory.create(
+        parent_location=section.location,
+        template='i4x://edx/templates/sequential/Empty',
+        display_name='Subsection One',)
+
+
+@step(u'I have a course with multiple sections$')
+def have_a_course_with_two_sections(step):
+    clear_courses()
+    course = world.CourseFactory.create()
+    section = world.ItemFactory.create(parent_location=course.location)
+    subsection1 = world.ItemFactory.create(
+        parent_location=section.location,
+        template='i4x://edx/templates/sequential/Empty',
+        display_name='Subsection One',)
+    section2 = world.ItemFactory.create(
+        parent_location=course.location,
+        display_name='Section Two',)
+    subsection2 = world.ItemFactory.create(
+        parent_location=section2.location,
+        template='i4x://edx/templates/sequential/Empty',
+        display_name='Subsection Alpha',)
+    subsection3 = world.ItemFactory.create(
+        parent_location=section2.location,
+        template='i4x://edx/templates/sequential/Empty',
+        display_name='Subsection Beta',)
+
+
+@step(u'I navigate to the course overview page$')
+def navigate_to_the_course_overview_page(step):
+    log_into_studio(is_staff=True)
+    course_locator = '.class-name'
+    css_click(course_locator)
+
+
+@step(u'I navigate to the courseware page of a course with multiple sections')
+def nav_to_the_courseware_page_of_a_course_with_multiple_sections(step):
+    step.given('I have a course with multiple sections')
+    step.given('I navigate to the course overview page')
+
+
+@step(u'I add a section')
+def i_add_a_section(step):
+    add_section(name='My New Section That I Just Added')
+
+
+@step(u'I click the "([^"]*)" link$')
+def i_click_the_text_span(step, text):
+    span_locator = '.toggle-button-sections span'
+    assert_true(world.browser.is_element_present_by_css(span_locator, 5))
+    # first make sure that the expand/collapse text is the one you expected
+    assert_equal(world.browser.find_by_css(span_locator).value, text)
+    css_click(span_locator)
+
+
+@step(u'I collapse the first section$')
+def i_collapse_a_section(step):
+    collapse_locator = 'section.courseware-section a.collapse'
+    css_click(collapse_locator)
+
+
+@step(u'I expand the first section$')
+def i_expand_a_section(step):
+    expand_locator = 'section.courseware-section a.expand'
+    css_click(expand_locator)
+
+
+@step(u'I see the "([^"]*)" link$')
+def i_see_the_span_with_text(step, text):
+    span_locator = '.toggle-button-sections span'
+    assert_true(world.browser.is_element_present_by_css(span_locator, 5))
+    assert_equal(world.browser.find_by_css(span_locator).value, text)
+    assert_true(world.browser.find_by_css(span_locator).visible)
+
+
+@step(u'I do not see the "([^"]*)" link$')
+def i_do_not_see_the_span_with_text(step, text):
+    # Note that the span will exist on the page but not be visible
+    span_locator = '.toggle-button-sections span'
+    assert_true(world.browser.is_element_present_by_css(span_locator))
+    assert_false(world.browser.find_by_css(span_locator).visible)
+
+
+@step(u'all sections are expanded$')
+def all_sections_are_expanded(step):
+    subsection_locator = 'div.subsection-list'
+    subsections = world.browser.find_by_css(subsection_locator)
+    for s in subsections:
+        assert_true(s.visible)
+
+
+@step(u'all sections are collapsed$')
+def all_sections_are_expanded(step):
+    subsection_locator = 'div.subsection-list'
+    subsections = world.browser.find_by_css(subsection_locator)
+    for s in subsections:
+        assert_false(s.visible)

cms/djangoapps/contentstore/features/subsection.feature

@@ -0,0 +1,27 @@
+Feature: Create Subsection
+  In order offer a course on the edX platform
+  As a course author
+  I want to create and edit subsections
+
+    Scenario: Add a new subsection to a section
+    Given I have opened a new course section in Studio
+    When I click the New Subsection link
+    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
+
+    @skip-phantom
+    Scenario: Delete a subsection
+    Given I have opened a new course section in Studio
+    And I have added a new subsection
+    And I see my subsection on the Courseware page
+    When I press the "subsection" delete icon
+    And I confirm the alert
+    Then the subsection does not exist

cms/djangoapps/contentstore/features/subsection.py

@@ -0,0 +1,80 @@
+from lettuce import world, step
+from common import *
+from nose.tools import assert_equal
+
+############### ACTIONS ####################
+
+
+@step('I have opened a new course section in Studio$')
+def i_have_opened_a_new_course_section(step):
+    clear_courses()
+    log_into_studio()
+    create_a_course()
+    add_section()
+
+
+@step('I click the New Subsection link')
+def i_click_the_new_subsection_link(step):
+    css = 'a.new-subsection-item'
+    css_click(css)
+
+
+@step('I enter the subsection name and click save$')
+def i_save_subsection_name(step):
+    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):
+    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/clone.py

@@ -0,0 +1,39 @@
+###
+### Script for cloning a course
+###
+from django.core.management.base import BaseCommand, CommandError
+from xmodule.modulestore.store_utilities import clone_course
+from xmodule.modulestore.django import modulestore
+from xmodule.contentstore.django import contentstore
+from xmodule.modulestore import Location
+from xmodule.course_module import CourseDescriptor
+
+from auth.authz import _copy_course_group
+
+#
+# To run from command line: rake cms:clone SOURCE_LOC=MITx/111/Foo1 DEST_LOC=MITx/135/Foo3
+#
+
+
+class Command(BaseCommand):
+    help = \
+'''Clone a MongoDB backed course to another location'''
+
+    def handle(self, *args, **options):
+        if len(args) != 2:
+            raise CommandError("clone requires two arguments: <source-location> <dest-location>")
+
+        source_location_str = args[0]
+        dest_location_str = args[1]
+
+        ms = modulestore('direct')
+        cs = contentstore()
+
+        print "Cloning course {0} to {1}".format(source_location_str, dest_location_str)
+
+        source_location = CourseDescriptor.id_to_location(source_location_str)
+        dest_location = CourseDescriptor.id_to_location(dest_location_str)
+
+        if clone_course(ms, cs, source_location, dest_location):
+            print "copying User permissions..."
+            _copy_course_group(source_location, dest_location)

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

@@ -0,0 +1,45 @@
+###
+### Script for cloning a course
+###
+from django.core.management.base import BaseCommand, CommandError
+from xmodule.modulestore.store_utilities import delete_course
+from xmodule.modulestore.django import modulestore
+from xmodule.contentstore.django import contentstore
+from xmodule.modulestore import Location
+from xmodule.course_module import CourseDescriptor
+from .prompt import query_yes_no
+
+from auth.authz import _delete_course_group
+
+#
+# To run from command line: rake cms:delete_course LOC=MITx/111/Foo1
+#
+
+
+class Command(BaseCommand):
+    help = '''Delete a MongoDB backed course'''
+
+    def handle(self, *args, **options):
+        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, 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/export.py

@@ -0,0 +1,35 @@
+###
+### Script for exporting courseware from Mongo to a tar.gz file
+###
+import os
+
+from django.core.management.base import BaseCommand, CommandError
+from xmodule.modulestore.xml_exporter import export_to_xml
+from xmodule.modulestore.django import modulestore
+from xmodule.contentstore.django import contentstore
+from xmodule.modulestore import Location
+from xmodule.course_module import CourseDescriptor
+
+
+unnamed_modules = 0
+
+
+class Command(BaseCommand):
+    help = \
+'''Import the specified data directory into the default ModuleStore'''
+
+    def handle(self, *args, **options):
+        if len(args) != 2:
+            raise CommandError("import requires two arguments: <course location> <output path>")
+
+        course_id = args[0]
+        output_path = args[1]
+
+        print "Exporting course id = {0} to {1}".format(course_id, output_path)
+
+        location = CourseDescriptor.id_to_location(course_id)
+
+        root_dir = os.path.dirname(output_path)
+        course_dir = os.path.splitext(os.path.basename(output_path))[0]
+
+        export_to_xml(modulestore('direct'), contentstore(), location, root_dir, course_dir)

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

@@ -5,6 +5,7 @@
 from django.core.management.base import BaseCommand, CommandError
 from xmodule.modulestore.xml_importer import import_from_xml
 from xmodule.modulestore.django import modulestore
+from xmodule.contentstore.django import contentstore
 
 
 unnamed_modules = 0
@@ -26,4 +27,5 @@ class Command(BaseCommand):
         print "Importing.  Data_dir={data}, course_dirs={courses}".format(
             data=data_dir,
             courses=course_dirs)
-        import_from_xml(modulestore(), data_dir, course_dirs, load_error_modules=False)
+        import_from_xml(modulestore('direct'), data_dir, course_dirs, load_error_modules=False,
+            static_content_store=contentstore(), verbose=True)

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

@@ -0,0 +1,34 @@
+import sys
+
+
+def query_yes_no(question, default="yes"):
+    """Ask a yes/no question via raw_input() and return their answer.
+
+    "question" is a string that is presented to the user.
+    "default" is the presumed answer if the user just hits <Enter>.
+        It must be "yes" (the default), "no" or None (meaning
+        an answer is required of the user).
+
+    The "answer" return value is one of "yes" or "no".
+    """
+    valid = {"yes":True,   "y":True,  "ye":True,
+             "no":False,     "n":False}
+    if default is None:
+        prompt = " [y/n] "
+    elif default == "yes":
+        prompt = " [Y/n] "
+    elif default == "no":
+        prompt = " [y/N] "
+    else:
+        raise ValueError("invalid default answer: '%s'" % default)
+
+    while True:
+        sys.stdout.write(question + prompt)
+        choice = raw_input().lower()
+        if default is not None and choice == '':
+            return valid[default]
+        elif choice in valid:
+            return valid[choice]
+        else:
+            sys.stdout.write("Please respond with 'yes' or 'no' "\
+                             "(or 'y' or 'n').\n")

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

@@ -0,0 +1,9 @@
+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()

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

@@ -0,0 +1,28 @@
+from django.core.management.base import BaseCommand, CommandError
+from xmodule.modulestore.xml_importer import perform_xlint
+from xmodule.modulestore.django import modulestore
+from xmodule.contentstore.django import contentstore
+
+
+unnamed_modules = 0
+
+
+class Command(BaseCommand):
+    help = \
+    '''
+    Verify the structure of courseware as to it's suitability for import
+    To run test: rake cms:xlint DATA_DIR=../data [COURSE_DIR=content-edx-101 (optional parameter)]
+    '''
+    def handle(self, *args, **options):
+        if len(args) == 0:
+            raise CommandError("import requires at least one argument: <data directory> [<course dir>...]")
+
+        data_dir = args[0]
+        if len(args) > 1:
+            course_dirs = args[1:]
+        else:
+            course_dirs = None
+        print "Importing.  Data_dir={data}, course_dirs={courses}".format(
+            data=data_dir,
+            courses=course_dirs)
+        perform_xlint(data_dir, course_dirs, load_error_modules=False)

cms/djangoapps/contentstore/module_info_model.py

@@ -0,0 +1,93 @@
+from static_replace import replace_static_urls
+from xmodule.modulestore.exceptions import ItemNotFoundError
+from xmodule.modulestore import Location
+from django.http import Http404
+
+
+def get_module_info(store, location, parent_location=None, rewrite_static_links=False):
+    try:
+        if location.revision is None:
+            module = store.get_item(location)
+        else:
+            module = store.get_item(location)
+    except ItemNotFoundError:
+        # create a new one
+        template_location = Location(['i4x', 'edx', 'templates', location.category, 'Empty'])
+        module = store.clone_item(template_location, location)
+
+    data = module.data
+    if rewrite_static_links:
+        data = replace_static_urls(
+            module.data,
+            None,
+            course_namespace=Location([
+                module.location.tag,
+                module.location.org,
+                module.location.course,
+                None,
+                None
+            ])
+        )
+
+    return {
+        'id': module.location.url(),
+        'data': data,
+        # TODO (cpennington): This really shouldn't have to do this much reaching in to get the metadata
+        'metadata': module._model_data._kvs._metadata
+    }
+
+
+def set_module_info(store, location, post_data):
+    module = None
+    try:
+        if location.revision is None:
+            module = store.get_item(location)
+        else:
+            module = store.get_item(location)
+    except:
+        pass
+
+    if module is None:
+        # new module at this location
+        # presume that we have an 'Empty' template
+        template_location = Location(['i4x', 'edx', 'templates', location.category, 'Empty'])
+        module = store.clone_item(template_location, location)
+
+    if post_data.get('data') is not None:
+        data = post_data['data']
+        store.update_item(location, data)
+
+    # cdodge: note calling request.POST.get('children') will return None if children is an empty array
+    # so it lead to a bug whereby the last component to be deleted in the UI was not actually
+    # deleting the children object from the children collection
+    if 'children' in post_data and post_data['children'] is not None:
+        children = post_data['children']
+        store.update_children(location, children)
+
+    # cdodge: also commit any metadata which might have been passed along in the
+    # POST from the client, if it is there
+    # NOTE, that the postback is not the complete metadata, as there's system metadata which is
+    # not presented to the end-user for editing. So let's fetch the original and
+    # 'apply' the submitted metadata, so we don't end up deleting system metadata
+    if post_data.get('metadata') is not None:
+        posted_metadata = post_data['metadata']
+
+        # update existing metadata with submitted metadata (which can be partial)
+        # IMPORTANT NOTE: if the client passed pack 'null' (None) for a piece of metadata that means 'remove it'
+        for metadata_key, value in posted_metadata.items():
+
+            # let's strip out any metadata fields from the postback which have been identified as system metadata
+            # and therefore should not be user-editable, so we should accept them back from the client
+            if metadata_key in module.system_metadata_fields:
+                del posted_metadata[metadata_key]
+            elif posted_metadata[metadata_key] is None:
+                # remove both from passed in collection as well as the collection read in from the modulestore
+                if metadata_key in module._model_data:
+                    del module._model_data[metadata_key]
+                del posted_metadata[metadata_key]
+            else:
+                module._model_data[metadata_key] = value
+
+        # commit to datastore
+        # TODO (cpennington): This really shouldn't have to do this much reaching in to get the metadata
+        store.update_metadata(location, module._model_data._kvs._metadata)

cms/djangoapps/contentstore/tests/test_checklists.py

@@ -0,0 +1,96 @@
+""" Unit tests for checklist methods in views.py. """
+from contentstore.utils import get_modulestore, get_url_reverse
+from contentstore.tests.test_course_settings import CourseTestCase
+from xmodule.modulestore.inheritance import own_metadata
+from xmodule.modulestore.tests.factories import CourseFactory
+from django.core.urlresolvers import reverse
+import json
+
+
+class ChecklistTestCase(CourseTestCase):
+    """ Test for checklist get and put methods. """
+    def setUp(self):
+        """ Creates the test course. """
+        super(ChecklistTestCase, self).setUp()
+        self.course = CourseFactory.create(org='mitX', number='333', display_name='Checklists Course')
+
+    def get_persisted_checklists(self):
+        """ Returns the checklists as persisted in the modulestore. """
+        modulestore = get_modulestore(self.course.location)
+        return modulestore.get_item(self.course.location).checklists
+
+    def test_get_checklists(self):
+        """ Tests the get checklists method. """
+        checklists_url = get_url_reverse('Checklists', self.course)
+        response = self.client.get(checklists_url)
+        self.assertContains(response, "Getting Started With Studio")
+        payload = response.content
+
+        # Now delete the checklists from the course and verify they get repopulated (for courses
+        # created before checklists were introduced).
+        self.course.checklists = None
+        modulestore = get_modulestore(self.course.location)
+        modulestore.update_metadata(self.course.location, own_metadata(self.course))
+        self.assertEquals(self.get_persisted_checklists(), None)
+        response = self.client.get(checklists_url)
+        self.assertEquals(payload, response.content)
+
+    def test_update_checklists_no_index(self):
+        """ No checklist index, should return all of them. """
+        update_url = reverse('checklists_updates', kwargs={
+            'org': self.course.location.org,
+            'course': self.course.location.course,
+            'name': self.course.location.name})
+
+        returned_checklists = json.loads(self.client.get(update_url).content)
+        self.assertListEqual(self.get_persisted_checklists(), returned_checklists)
+
+    def test_update_checklists_index_ignored_on_get(self):
+        """ Checklist index ignored on get. """
+        update_url = reverse('checklists_updates', kwargs={'org': self.course.location.org,
+                                                           'course': self.course.location.course,
+                                                           'name': self.course.location.name,
+                                                           'checklist_index': 1})
+
+        returned_checklists = json.loads(self.client.get(update_url).content)
+        self.assertListEqual(self.get_persisted_checklists(), returned_checklists)
+
+    def test_update_checklists_post_no_index(self):
+        """ No checklist index, will error on post. """
+        update_url = reverse('checklists_updates', kwargs={'org': self.course.location.org,
+                                                           'course': self.course.location.course,
+                                                           'name': self.course.location.name})
+        response = self.client.post(update_url)
+        self.assertContains(response, 'Could not save checklist', status_code=400)
+
+    def test_update_checklists_index_out_of_range(self):
+        """ Checklist index out of range, will error on post. """
+        update_url = reverse('checklists_updates', kwargs={'org': self.course.location.org,
+                                                           'course': self.course.location.course,
+                                                           'name': self.course.location.name,
+                                                           'checklist_index': 100})
+        response = self.client.post(update_url)
+        self.assertContains(response, 'Could not save checklist', status_code=400)
+
+    def test_update_checklists_index(self):
+        """ Check that an update of a particular checklist works. """
+        update_url = reverse('checklists_updates', kwargs={'org': self.course.location.org,
+                                                           'course': self.course.location.course,
+                                                           'name': self.course.location.name,
+                                                           'checklist_index': 2})
+        payload = self.course.checklists[2]
+        self.assertFalse(payload.get('is_checked'))
+        payload['is_checked'] = True
+
+        returned_checklist = json.loads(self.client.post(update_url, json.dumps(payload), "application/json").content)
+        self.assertTrue(returned_checklist.get('is_checked'))
+        self.assertEqual(self.get_persisted_checklists()[2], returned_checklist)
+
+    def test_update_checklists_delete_unsupported(self):
+        """ Delete operation is not supported. """
+        update_url = reverse('checklists_updates', kwargs={'org': self.course.location.org,
+                                                           'course': self.course.location.course,
+                                                           'name': self.course.location.name,
+                                                           'checklist_index': 100})
+        response = self.client.delete(update_url)
+        self.assertContains(response, 'Unsupported request', status_code=400)

cms/djangoapps/contentstore/tests/test_contentstore.py

@@ -0,0 +1,608 @@
+import json
+import shutil
+from django.test.client import Client
+from django.test.utils import override_settings
+from django.conf import settings
+from django.core.urlresolvers import reverse
+from path import path
+from tempdir import mkdtemp_clean
+from datetime import timedelta
+import json
+from fs.osfs import OSFS
+import copy
+from json import loads
+
+from django.contrib.auth.models import User
+from contentstore.utils import get_modulestore
+
+from .utils import ModuleStoreTestCase, parse_json
+from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
+
+from xmodule.modulestore import Location
+from xmodule.modulestore.store_utilities import clone_course
+from xmodule.modulestore.store_utilities import delete_course
+from xmodule.modulestore.django import modulestore
+from xmodule.contentstore.django import contentstore
+from xmodule.templates import update_templates
+from xmodule.modulestore.xml_exporter import export_to_xml
+from xmodule.modulestore.xml_importer import import_from_xml
+from xmodule.modulestore.inheritance import own_metadata
+
+from xmodule.capa_module import CapaDescriptor
+from xmodule.course_module import CourseDescriptor
+from xmodule.seq_module import SequenceDescriptor
+from xmodule.modulestore.exceptions import ItemNotFoundError
+
+TEST_DATA_MODULESTORE = copy.deepcopy(settings.MODULESTORE)
+TEST_DATA_MODULESTORE['default']['OPTIONS']['fs_root'] = path('common/test/data')
+TEST_DATA_MODULESTORE['direct']['OPTIONS']['fs_root'] = path('common/test/data')
+
+class MongoCollectionFindWrapper(object):
+    def __init__(self, original):
+        self.original = original
+        self.counter = 0
+
+    def find(self, query, *args, **kwargs):
+        self.counter = self.counter+1
+        return self.original(query, *args, **kwargs)
+
+@override_settings(MODULESTORE=TEST_DATA_MODULESTORE)
+class ContentStoreToyCourseTest(ModuleStoreTestCase):
+    """
+    Tests that rely on the toy courses.
+    TODO: refactor using CourseFactory so they do not.
+    """
+    def setUp(self):
+        uname = 'testuser'
+        email = 'test+courses@edx.org'
+        password = 'foo'
+
+        # Create the use so we can log them in.
+        self.user = User.objects.create_user(uname, email, password)
+
+        # Note that we do not actually need to do anything
+        # for registration if we directly mark them active.
+        self.user.is_active = True
+        # Staff has access to view all courses
+        self.user.is_staff = True
+        self.user.save()
+
+        self.client = Client()
+        self.client.login(username=uname, password=password)
+
+    def check_edit_unit(self, test_course_name):
+        import_from_xml(modulestore(), 'common/test/data/', [test_course_name])
+
+        for descriptor in modulestore().get_items(Location(None, None, 'vertical', None, None)):
+            print "Checking ", descriptor.location.url()
+            print descriptor.__class__, descriptor.location
+            resp = self.client.get(reverse('edit_unit', kwargs={'location': descriptor.location.url()}))
+            self.assertEqual(resp.status_code, 200)
+
+    def test_edit_unit_toy(self):
+        self.check_edit_unit('toy')
+
+    def test_edit_unit_full(self):
+        self.check_edit_unit('full')
+
+    def test_static_tab_reordering(self):
+        import_from_xml(modulestore(), 'common/test/data/', ['full'])
+
+        module_store = modulestore('direct')
+        course = module_store.get_item(Location(['i4x', 'edX', 'full', 'course', '6.002_Spring_2012', None]))
+
+        # reverse the ordering
+        reverse_tabs = []
+        for tab in course.tabs:
+            if tab['type'] == 'static_tab':
+                reverse_tabs.insert(0, 'i4x://edX/full/static_tab/{0}'.format(tab['url_slug']))
+
+        self.client.post(reverse('reorder_static_tabs'), json.dumps({'tabs': reverse_tabs}), "application/json")
+
+        course = module_store.get_item(Location(['i4x', 'edX', 'full', 'course', '6.002_Spring_2012', None]))
+
+        # compare to make sure that the tabs information is in the expected order after the server call
+        course_tabs = []
+        for tab in course.tabs:
+            if tab['type'] == 'static_tab':
+                course_tabs.append('i4x://edX/full/static_tab/{0}'.format(tab['url_slug']))
+
+        self.assertEqual(reverse_tabs, course_tabs)
+
+    def test_import_polls(self):
+        import_from_xml(modulestore(), 'common/test/data/', ['full'])
+
+        module_store = modulestore('direct')
+        found = False
+
+        item = None
+        items = module_store.get_items(['i4x', 'edX', 'full', 'poll_question', None, None])
+        found = len(items) > 0
+
+        self.assertTrue(found)
+        # check that there's actually content in the 'question' field
+        self.assertGreater(len(items[0].question),0)
+
+    def test_delete(self):
+        import_from_xml(modulestore(), 'common/test/data/', ['full'])
+
+        module_store = modulestore('direct')
+
+        sequential = module_store.get_item(Location(['i4x', 'edX', 'full', 'sequential', 'Administrivia_and_Circuit_Elements', None]))
+
+        chapter = module_store.get_item(Location(['i4x', 'edX', 'full', 'chapter','Week_1', None]))
+
+        # make sure the parent no longer points to the child object which was deleted
+        self.assertTrue(sequential.location.url() in chapter.children)
+
+        self.client.post(reverse('delete_item'),
+            json.dumps({'id': sequential.location.url(), 'delete_children': 'true', 'delete_all_versions': 'true'}),
+            "application/json")
+
+        found = False
+        try:
+            module_store.get_item(Location(['i4x', 'edX', 'full', 'sequential', 'Administrivia_and_Circuit_Elements', None]))
+            found = True
+        except ItemNotFoundError:
+            pass
+
+        self.assertFalse(found)
+
+        chapter = module_store.get_item(Location(['i4x', 'edX', 'full', 'chapter','Week_1', None]))
+
+        # make sure the parent no longer points to the child object which was deleted
+        self.assertFalse(sequential.location.url() in chapter.children)
+
+    def test_about_overrides(self):
+        '''
+        This test case verifies that a course can use specialized override for about data, e.g. /about/Fall_2012/effort.html
+        while there is a base definition in /about/effort.html
+        '''
+        import_from_xml(modulestore(), 'common/test/data/', ['full'])
+        module_store = modulestore('direct')
+        effort = module_store.get_item(Location(['i4x', 'edX', 'full', 'about', 'effort', None]))
+        self.assertEqual(effort.data, '6 hours')
+
+        # this one should be in a non-override folder
+        effort = module_store.get_item(Location(['i4x', 'edX', 'full', 'about', 'end_date', None]))
+        self.assertEqual(effort.data, 'TBD')
+
+    def test_remove_hide_progress_tab(self):
+        import_from_xml(modulestore(), 'common/test/data/', ['full'])
+
+        module_store = modulestore('direct')
+        content_store = contentstore()
+
+        source_location = CourseDescriptor.id_to_location('edX/full/6.002_Spring_2012')
+        course = module_store.get_item(source_location)
+        self.assertFalse(course.hide_progress_tab)
+
+    def test_clone_course(self):
+
+        course_data = {
+            'template': 'i4x://edx/templates/course/Empty',
+            'org': 'MITx',
+            'number': '999',
+            'display_name': 'Robot Super Course',
+            }
+
+        import_from_xml(modulestore(), 'common/test/data/', ['full'])
+
+        resp = self.client.post(reverse('create_new_course'), course_data)
+        self.assertEqual(resp.status_code, 200)
+        data = parse_json(resp)
+        self.assertEqual(data['id'], 'i4x://MITx/999/course/Robot_Super_Course')
+
+        module_store = modulestore('direct')
+        content_store = contentstore()
+
+        source_location = CourseDescriptor.id_to_location('edX/full/6.002_Spring_2012')
+        dest_location = CourseDescriptor.id_to_location('MITx/999/Robot_Super_Course')
+
+        clone_course(module_store, content_store, source_location, dest_location)
+
+        # now loop through all the units in the course and verify that the clone can render them, which
+        # means the objects are at least present
+        items = module_store.get_items(Location(['i4x', 'edX', 'full', 'vertical', None]))
+        self.assertGreater(len(items), 0)
+        clone_items = module_store.get_items(Location(['i4x', 'MITx', '999', 'vertical', None]))
+        self.assertGreater(len(clone_items), 0)
+        for descriptor in items:
+            new_loc = descriptor.location._replace(org='MITx', course='999')
+            print "Checking {0} should now also be at {1}".format(descriptor.location.url(), new_loc.url())
+            resp = self.client.get(reverse('edit_unit', kwargs={'location': new_loc.url()}))
+            self.assertEqual(resp.status_code, 200)
+
+    def test_bad_contentstore_request(self):
+        resp = self.client.get('http://localhost:8001/c4x/CDX/123123/asset/&images_circuits_Lab7Solution2.png')
+        self.assertEqual(resp.status_code, 400)
+
+    def test_delete_course(self):
+        import_from_xml(modulestore(), 'common/test/data/', ['full'])
+
+        module_store = modulestore('direct')
+        content_store = contentstore()
+
+        location = CourseDescriptor.id_to_location('edX/full/6.002_Spring_2012')
+
+        delete_course(module_store, content_store, location, commit=True)
+
+        items = module_store.get_items(Location(['i4x', 'edX', 'full', 'vertical', None]))
+        self.assertEqual(len(items), 0)
+
+    def verify_content_existence(self, modulestore, root_dir, location, dirname, category_name, filename_suffix=''):
+        fs = OSFS(root_dir / 'test_export')
+        self.assertTrue(fs.exists(dirname))
+
+        query_loc = Location('i4x', location.org, location.course, category_name, None)
+        items = modulestore.get_items(query_loc)
+
+        for item in items:
+            fs = OSFS(root_dir / ('test_export/' + dirname))
+            self.assertTrue(fs.exists(item.location.name + filename_suffix))
+
+    def test_export_course(self):
+        module_store = modulestore('direct')
+        content_store = contentstore()
+
+        import_from_xml(module_store, 'common/test/data/', ['full'])
+        location = CourseDescriptor.id_to_location('edX/full/6.002_Spring_2012')
+
+        root_dir = path(mkdtemp_clean())
+
+        print 'Exporting to tempdir = {0}'.format(root_dir)
+
+        # export out to a tempdir
+        export_to_xml(module_store, content_store, location, root_dir, 'test_export')
+
+        # check for static tabs
+        self.verify_content_existence(module_store, root_dir, location, 'tabs', 'static_tab', '.html')
+
+        # check for custom_tags
+        self.verify_content_existence(module_store, root_dir, location, 'info', 'course_info', '.html')
+
+        # check for custom_tags
+        self.verify_content_existence(module_store, root_dir, location, 'custom_tags', 'custom_tag_template')
+
+        # check for graiding_policy.json
+        fs = OSFS(root_dir / 'test_export/policies/6.002_Spring_2012')
+        self.assertTrue(fs.exists('grading_policy.json'))
+
+        course = module_store.get_item(location)
+        # compare what's on disk compared to what we have in our course
+        with fs.open('grading_policy.json', 'r') as grading_policy:
+            on_disk = loads(grading_policy.read())
+            self.assertEqual(on_disk, course.grading_policy)
+
+        #check for policy.json
+        self.assertTrue(fs.exists('policy.json'))
+
+        # compare what's on disk to what we have in the course module
+        with fs.open('policy.json', 'r') as course_policy:
+            on_disk = loads(course_policy.read())
+            self.assertIn('course/6.002_Spring_2012', on_disk)
+            self.assertEqual(on_disk['course/6.002_Spring_2012'], own_metadata(course))
+
+        # remove old course
+        delete_course(module_store, content_store, location)
+
+        # reimport
+        import_from_xml(module_store, root_dir, ['test_export'])
+
+        items = module_store.get_items(Location(['i4x', 'edX', 'full', 'vertical', None]))
+        self.assertGreater(len(items), 0)
+        for descriptor in items:
+            print "Checking {0}....".format(descriptor.location.url())
+            resp = self.client.get(reverse('edit_unit', kwargs={'location': descriptor.location.url()}))
+            self.assertEqual(resp.status_code, 200)
+
+        shutil.rmtree(root_dir)
+
+    def test_course_handouts_rewrites(self):
+        module_store = modulestore('direct')
+        content_store = contentstore()
+
+        # import a test course
+        import_from_xml(module_store, 'common/test/data/', ['full'])
+
+        handout_location = Location(['i4x', 'edX', 'full', 'course_info', 'handouts'])
+
+        # get module info
+        resp = self.client.get(reverse('module_info', kwargs={'module_location': handout_location}))
+
+        # make sure we got a successful response
+        self.assertEqual(resp.status_code, 200)
+
+        # check that /static/ has been converted to the full path
+        # note, we know the link it should be because that's what in the 'full' course in the test data
+        self.assertContains(resp, '/c4x/edX/full/asset/handouts_schematic_tutorial.pdf')
+
+    def test_prefetch_children(self):
+        import_from_xml(modulestore(), 'common/test/data/', ['full'])
+        module_store = modulestore('direct')
+        location = CourseDescriptor.id_to_location('edX/full/6.002_Spring_2012')
+
+        wrapper = MongoCollectionFindWrapper(module_store.collection.find)
+        module_store.collection.find = wrapper.find
+        course = module_store.get_item(location, depth=2)
+
+        # make sure we haven't done too many round trips to DB
+        # note we say 4 round trips here for 1) the course, 2 & 3) for the chapters and sequentials, and
+        # 4) because of the RT due to calculating the inherited metadata
+        self.assertEqual(wrapper.counter, 4)
+
+        # make sure we pre-fetched a known sequential which should be at depth=2
+        self.assertTrue(Location(['i4x', 'edX', 'full', 'sequential',
+            'Administrivia_and_Circuit_Elements', None]) in course.system.module_data)
+
+        # make sure we don't have a specific vertical which should be at depth=3
+        self.assertFalse(Location(['i4x', 'edX', 'full', 'vertical', 'vertical_58',
+            None]) in course.system.module_data)
+
+    def test_export_course_with_unknown_metadata(self):
+        module_store = modulestore('direct')
+        content_store = contentstore()
+
+        import_from_xml(module_store, 'common/test/data/', ['full'])
+        location = CourseDescriptor.id_to_location('edX/full/6.002_Spring_2012')
+
+        root_dir = path(mkdtemp_clean())
+
+        course = module_store.get_item(location)
+
+        metadata = own_metadata(course)
+        # add a bool piece of unknown metadata so we can verify we don't throw an exception
+        metadata['new_metadata'] = True
+
+        module_store.update_metadata(location, metadata)
+
+        print 'Exporting to tempdir = {0}'.format(root_dir)
+
+        # export out to a tempdir
+        exported = False
+        try:
+            export_to_xml(module_store, content_store, location, root_dir, 'test_export')
+            exported = True
+        except Exception:
+            pass
+
+        self.assertTrue(exported)
+
+class ContentStoreTest(ModuleStoreTestCase):
+    """
+    Tests for the CMS ContentStore application.
+    """
+    def setUp(self):
+        """
+        These tests need a user in the DB so that the django Test Client
+        can log them in.
+        They inherit from the ModuleStoreTestCase class so that the mongodb collection
+        will be cleared out before each test case execution and deleted
+        afterwards.
+        """
+        uname = 'testuser'
+        email = 'test+courses@edx.org'
+        password = 'foo'
+
+        # Create the use so we can log them in.
+        self.user = User.objects.create_user(uname, email, password)
+
+        # Note that we do not actually need to do anything
+        # for registration if we directly mark them active.
+        self.user.is_active = True
+        # Staff has access to view all courses
+        self.user.is_staff = True
+        self.user.save()
+
+        self.client = Client()
+        self.client.login(username=uname, password=password)
+
+        self.course_data = {
+            'template': 'i4x://edx/templates/course/Empty',
+            'org': 'MITx',
+            'number': '999',
+            'display_name': 'Robot Super Course',
+            }
+
+    def test_create_course(self):
+        """Test new course creation - happy path"""
+        resp = self.client.post(reverse('create_new_course'), self.course_data)
+        self.assertEqual(resp.status_code, 200)
+        data = parse_json(resp)
+        self.assertEqual(data['id'], 'i4x://MITx/999/course/Robot_Super_Course')
+
+    def test_create_course_duplicate_course(self):
+        """Test new course creation - error path"""
+        resp = self.client.post(reverse('create_new_course'), self.course_data)
+        resp = self.client.post(reverse('create_new_course'), self.course_data)
+        data = parse_json(resp)
+        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(data['ErrMsg'], 'There is already a course defined with this name.')
+
+    def test_create_course_duplicate_number(self):
+        """Test new course creation - error path"""
+        resp = self.client.post(reverse('create_new_course'), self.course_data)
+        self.course_data['display_name'] = 'Robot Super Course Two'
+
+        resp = self.client.post(reverse('create_new_course'), self.course_data)
+        data = parse_json(resp)
+
+        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(data['ErrMsg'],
+            'There is already a course defined with the same organization and course number.')
+
+    def test_create_course_with_bad_organization(self):
+        """Test new course creation - error path for bad organization name"""
+        self.course_data['org'] = 'University of California, Berkeley'
+        resp = self.client.post(reverse('create_new_course'), self.course_data)
+        data = parse_json(resp)
+
+        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(data['ErrMsg'],
+            "Unable to create course 'Robot Super Course'.\n\nInvalid characters in 'University of California, Berkeley'.")
+
+    def test_course_index_view_with_no_courses(self):
+        """Test viewing the index page with no courses"""
+        # Create a course so there is something to view
+        resp = self.client.get(reverse('index'))
+        self.assertContains(resp,
+            '<h1 class="title-1">My Courses</h1>',
+            status_code=200,
+            html=True)
+
+    def test_course_factory(self):
+        """Test that the course factory works correctly."""
+        course = CourseFactory.create()
+        self.assertIsInstance(course, CourseDescriptor)
+
+    def test_item_factory(self):
+        """Test that the item factory works correctly."""
+        course = CourseFactory.create()
+        item = ItemFactory.create(parent_location=course.location)
+        self.assertIsInstance(item, SequenceDescriptor)
+
+    def test_course_index_view_with_course(self):
+        """Test viewing the index page with an existing course"""
+        CourseFactory.create(display_name='Robot Super Educational Course')
+        resp = self.client.get(reverse('index'))
+        self.assertContains(resp,
+            '<span class="class-name">Robot Super Educational Course</span>',
+            status_code=200,
+            html=True)
+
+    def test_course_overview_view_with_course(self):
+        """Test viewing the course overview page with an existing course"""
+        CourseFactory.create(org='MITx', course='999', display_name='Robot Super Course')
+
+        data = {
+                'org': 'MITx',
+                'course': '999',
+                'name': Location.clean('Robot Super Course'),
+                }
+
+        resp = self.client.get(reverse('course_index', kwargs=data))
+        self.assertContains(resp,
+            '<article class="courseware-overview" data-course-id="i4x://MITx/999/course/Robot_Super_Course">',
+            status_code=200,
+            html=True)
+
+    def test_clone_item(self):
+        """Test cloning an item. E.g. creating a new section"""
+        CourseFactory.create(org='MITx', course='999', display_name='Robot Super Course')
+
+        section_data = {
+            'parent_location': 'i4x://MITx/999/course/Robot_Super_Course',
+            'template': 'i4x://edx/templates/chapter/Empty',
+            'display_name': 'Section One',
+            }
+
+        resp = self.client.post(reverse('clone_item'), section_data)
+
+        self.assertEqual(resp.status_code, 200)
+        data = parse_json(resp)
+        self.assertRegexpMatches(data['id'],
+            '^i4x:\/\/MITx\/999\/chapter\/([0-9]|[a-f]){32}$')
+
+    def test_capa_module(self):
+        """Test that a problem treats markdown specially."""
+        CourseFactory.create(org='MITx', course='999', display_name='Robot Super Course')
+
+        problem_data = {
+            'parent_location': 'i4x://MITx/999/course/Robot_Super_Course',
+            'template': 'i4x://edx/templates/problem/Blank_Common_Problem'
+            }
+
+        resp = self.client.post(reverse('clone_item'), problem_data)
+
+        self.assertEqual(resp.status_code, 200)
+        payload = parse_json(resp)
+        problem_loc = payload['id']
+        problem = get_modulestore(problem_loc).get_item(problem_loc)
+        # should be a CapaDescriptor
+        self.assertIsInstance(problem, CapaDescriptor, "New problem is not a CapaDescriptor")
+        context = problem.get_context()
+        self.assertIn('markdown', context, "markdown is missing from context")
+        self.assertNotIn('markdown', problem.editable_metadata_fields, "Markdown slipped into the editable metadata fields")
+
+    def test_import_metadata_with_attempts_empty_string(self):
+        import_from_xml(modulestore(), 'common/test/data/', ['simple'])
+        module_store = modulestore('direct')
+        did_load_item = False
+        try:
+            module_store.get_item(Location(['i4x', 'edX', 'simple', 'problem', 'ps01-simple', None]))
+            did_load_item = True
+        except ItemNotFoundError:
+            pass
+
+        # make sure we found the item (e.g. it didn't error while loading)
+        self.assertTrue(did_load_item)
+
+    def test_metadata_inheritance(self):
+        import_from_xml(modulestore(), 'common/test/data/', ['full'])
+
+        module_store = modulestore('direct')
+        course = module_store.get_item(Location(['i4x', 'edX', 'full', 'course', '6.002_Spring_2012', None]))
+
+        verticals = module_store.get_items(['i4x', 'edX', 'full', 'vertical', None, None])
+
+        # let's assert on the metadata_inheritance on an existing vertical
+        for vertical in verticals:
+            self.assertEqual(course.lms.xqa_key, vertical.lms.xqa_key)
+
+        self.assertGreater(len(verticals), 0)
+
+        new_component_location = Location('i4x', 'edX', 'full', 'html', 'new_component')
+        source_template_location = Location('i4x', 'edx', 'templates', 'html', 'Blank_HTML_Page')
+
+        # crate a new module and add it as a child to a vertical
+        module_store.clone_item(source_template_location, new_component_location)
+        parent = verticals[0]
+        module_store.update_children(parent.location, parent.children + [new_component_location.url()])
+
+        # flush the cache
+        module_store.refresh_cached_metadata_inheritance_tree(new_component_location)
+        new_module = module_store.get_item(new_component_location)
+
+        # check for grace period definition which should be defined at the course level
+        self.assertEqual(parent.lms.graceperiod, new_module.lms.graceperiod)
+
+        self.assertEqual(course.lms.xqa_key, new_module.lms.xqa_key)
+
+        #
+        # now let's define an override at the leaf node level
+        #
+        new_module.lms.graceperiod = timedelta(1)
+        module_store.update_metadata(new_module.location, own_metadata(new_module))
+
+        # flush the cache and refetch
+        module_store.refresh_cached_metadata_inheritance_tree(new_component_location)
+        new_module = module_store.get_item(new_component_location)
+
+        self.assertEqual(timedelta(1), new_module.lms.graceperiod)
+
+
+class TemplateTestCase(ModuleStoreTestCase):
+
+    def test_template_cleanup(self):
+        module_store = modulestore('direct')
+
+        # insert a bogus template in the store
+        bogus_template_location = Location('i4x', 'edx', 'templates', 'html', 'bogus')
+        source_template_location = Location('i4x', 'edx', 'templates', 'html', 'Blank_HTML_Page')
+
+        module_store.clone_item(source_template_location, bogus_template_location)
+
+        verify_create = module_store.get_item(bogus_template_location)
+        self.assertIsNotNone(verify_create)
+
+        # now run cleanup
+        update_templates()
+
+        # now try to find dangling template, it should not be in DB any longer
+        asserted = False
+        try:
+            verify_create = module_store.get_item(bogus_template_location)
+        except ItemNotFoundError:
+            asserted = True
+
+        self.assertTrue(asserted)

cms/djangoapps/contentstore/tests/test_core_caching.py

@@ -0,0 +1,36 @@
+from cache_toolbox.core import get_cached_content, set_cached_content, del_cached_content
+from xmodule.modulestore import Location
+from xmodule.contentstore.content import StaticContent
+from django.test import TestCase
+
+
+class Content:
+    def __init__(self, location, content):
+        self.location = location
+        self.content = content
+
+    def get_id(self):
+        return StaticContent.get_id_from_location(self.location)
+
+
+class CachingTestCase(TestCase):
+#   Tests for https://edx.lighthouseapp.com/projects/102637/tickets/112-updating-asset-does-not-refresh-the-cached-copy
+    unicodeLocation = Location(u'c4x', u'mitX', u'800', u'thumbnail', u'monsters.jpg')
+    # Note that some of the parts are strings instead of unicode strings
+    nonUnicodeLocation = Location('c4x', u'mitX', u'800', 'thumbnail', 'monsters.jpg')
+    mockAsset = Content(unicodeLocation, 'my content')
+
+    def test_put_and_get(self):
+        set_cached_content(self.mockAsset)
+        self.assertEqual(self.mockAsset.content, get_cached_content(self.unicodeLocation).content,
+            'should be stored in cache with unicodeLocation')
+        self.assertEqual(self.mockAsset.content, get_cached_content(self.nonUnicodeLocation).content,
+            'should be stored in cache with nonUnicodeLocation')
+
+    def test_delete(self):
+        set_cached_content(self.mockAsset)
+        del_cached_content(self.nonUnicodeLocation)
+        self.assertEqual(None, get_cached_content(self.unicodeLocation),
+            'should not be stored in cache with unicodeLocation')
+        self.assertEqual(None, get_cached_content(self.nonUnicodeLocation),
+            'should not be stored in cache with nonUnicodeLocation')

cms/djangoapps/contentstore/tests/test_course_settings.py

@@ -0,0 +1,311 @@
+import datetime
+import json
+import copy
+
+from django.contrib.auth.models import User
+from django.test.client import Client
+from django.core.urlresolvers import reverse
+from django.utils.timezone import UTC
+
+from xmodule.modulestore import Location
+from models.settings.course_details import (CourseDetails,
+                                                    CourseSettingsEncoder)
+from models.settings.course_grading import CourseGradingModel
+from contentstore.utils import get_modulestore
+
+from .utils import ModuleStoreTestCase
+from xmodule.modulestore.tests.factories import CourseFactory
+
+from models.settings.course_metadata import CourseMetadata
+from xmodule.modulestore.xml_importer import import_from_xml
+from xmodule.modulestore.django import modulestore
+from xmodule.fields import Date
+
+class CourseTestCase(ModuleStoreTestCase):
+    def setUp(self):
+        """
+        These tests need a user in the DB so that the django Test Client
+        can log them in.
+        They inherit from the ModuleStoreTestCase class so that the mongodb collection
+        will be cleared out before each test case execution and deleted
+        afterwards.
+        """
+        uname = 'testuser'
+        email = 'test+courses@edx.org'
+        password = 'foo'
+
+        # Create the use so we can log them in.
+        self.user = User.objects.create_user(uname, email, password)
+
+        # Note that we do not actually need to do anything
+        # for registration if we directly mark them active.
+        self.user.is_active = True
+        # Staff has access to view all courses
+        self.user.is_staff = True
+        self.user.save()
+
+        self.client = Client()
+        self.client.login(username=uname, password=password)
+
+        t = 'i4x://edx/templates/course/Empty'
+        o = 'MITx'
+        n = '999'
+        dn = 'Robot Super Course'
+        self.course_location = Location('i4x', o, n, 'course', 'Robot_Super_Course')
+        CourseFactory.create(template=t, org=o, number=n, display_name=dn)
+
+
+class CourseDetailsTestCase(CourseTestCase):
+    def test_virgin_fetch(self):
+        details = CourseDetails.fetch(self.course_location)
+        self.assertEqual(details.course_location, self.course_location, "Location not copied into")
+        self.assertIsNone(details.end_date, "end date somehow initialized " + str(details.end_date))
+        self.assertIsNone(details.enrollment_start, "enrollment_start date somehow initialized " + str(details.enrollment_start))
+        self.assertIsNone(details.enrollment_end, "enrollment_end date somehow initialized " + str(details.enrollment_end))
+        self.assertIsNone(details.syllabus, "syllabus somehow initialized" + str(details.syllabus))
+        self.assertEqual(details.overview, "", "overview somehow initialized" + details.overview)
+        self.assertIsNone(details.intro_video, "intro_video somehow initialized" + str(details.intro_video))
+        self.assertIsNone(details.effort, "effort somehow initialized" + str(details.effort))
+
+    def test_encoder(self):
+        details = CourseDetails.fetch(self.course_location)
+        jsondetails = json.dumps(details, cls=CourseSettingsEncoder)
+        jsondetails = json.loads(jsondetails)
+        self.assertTupleEqual(Location(jsondetails['course_location']), self.course_location, "Location !=")
+        # Note, start_date is being initialized someplace. I'm not sure why b/c the default will make no sense.
+        self.assertIsNone(jsondetails['end_date'], "end date somehow initialized ")
+        self.assertIsNone(jsondetails['enrollment_start'], "enrollment_start date somehow initialized ")
+        self.assertIsNone(jsondetails['enrollment_end'], "enrollment_end date somehow initialized ")
+        self.assertIsNone(jsondetails['syllabus'], "syllabus somehow initialized")
+        self.assertEqual(jsondetails['overview'], "", "overview somehow initialized")
+        self.assertIsNone(jsondetails['intro_video'], "intro_video somehow initialized")
+        self.assertIsNone(jsondetails['effort'], "effort somehow initialized")
+
+    def test_update_and_fetch(self):
+        # # NOTE: I couldn't figure out how to validly test time setting w/ all the conversions
+        jsondetails = CourseDetails.fetch(self.course_location)
+        jsondetails.syllabus = "<a href='foo'>bar</a>"
+        # encode - decode to convert date fields and other data which changes form
+        self.assertEqual(CourseDetails.update_from_json(jsondetails.__dict__).syllabus,
+                             jsondetails.syllabus, "After set syllabus")
+        jsondetails.overview = "Overview"
+        self.assertEqual(CourseDetails.update_from_json(jsondetails.__dict__).overview,
+                             jsondetails.overview, "After set overview")
+        jsondetails.intro_video = "intro_video"
+        self.assertEqual(CourseDetails.update_from_json(jsondetails.__dict__).intro_video,
+                             jsondetails.intro_video, "After set intro_video")
+        jsondetails.effort = "effort"
+        self.assertEqual(CourseDetails.update_from_json(jsondetails.__dict__).effort,
+                             jsondetails.effort, "After set effort")
+
+
+class CourseDetailsViewTest(CourseTestCase):
+    def alter_field(self, url, details, field, val):
+        setattr(details, field, val)
+        # Need to partially serialize payload b/c the mock doesn't handle it correctly
+        payload = copy.copy(details.__dict__)
+        payload['course_location'] = details.course_location.url()
+        payload['start_date'] = CourseDetailsViewTest.convert_datetime_to_iso(details.start_date)
+        payload['end_date'] = CourseDetailsViewTest.convert_datetime_to_iso(details.end_date)
+        payload['enrollment_start'] = CourseDetailsViewTest.convert_datetime_to_iso(details.enrollment_start)
+        payload['enrollment_end'] = CourseDetailsViewTest.convert_datetime_to_iso(details.enrollment_end)
+        resp = self.client.post(url, json.dumps(payload), "application/json")
+        self.compare_details_with_encoding(json.loads(resp.content), details.__dict__, field + str(val))
+
+    @staticmethod
+    def convert_datetime_to_iso(datetime):
+        if datetime is not None:
+            return datetime.isoformat("T")
+        else:
+            return None
+
+    def test_update_and_fetch(self):
+        details = CourseDetails.fetch(self.course_location)
+
+        # resp s/b json from here on
+        url = reverse('course_settings', kwargs={'org': self.course_location.org, 'course': self.course_location.course,
+                                                 'name': self.course_location.name, 'section': 'details'})
+        resp = self.client.get(url)
+        self.compare_details_with_encoding(json.loads(resp.content), details.__dict__, "virgin get")
+
+        utc = UTC()
+        self.alter_field(url, details, 'start_date', datetime.datetime(2012, 11, 12, 1, 30, tzinfo=utc))
+        self.alter_field(url, details, 'start_date', datetime.datetime(2012, 11, 1, 13, 30, tzinfo=utc))
+        self.alter_field(url, details, 'end_date', datetime.datetime(2013, 2, 12, 1, 30, tzinfo=utc))
+        self.alter_field(url, details, 'enrollment_start', datetime.datetime(2012, 10, 12, 1, 30, tzinfo=utc))
+
+        self.alter_field(url, details, 'enrollment_end', datetime.datetime(2012, 11, 15, 1, 30, tzinfo=utc))
+        self.alter_field(url, details, 'overview', "Overview")
+        self.alter_field(url, details, 'intro_video', "intro_video")
+        self.alter_field(url, details, 'effort', "effort")
+
+    def compare_details_with_encoding(self, encoded, details, context):
+        self.compare_date_fields(details, encoded, context, 'start_date')
+        self.compare_date_fields(details, encoded, context, 'end_date')
+        self.compare_date_fields(details, encoded, context, 'enrollment_start')
+        self.compare_date_fields(details, encoded, context, 'enrollment_end')
+        self.assertEqual(details['overview'], encoded['overview'], context + " overviews not ==")
+        self.assertEqual(details['intro_video'], encoded.get('intro_video', None), context + " intro_video not ==")
+        self.assertEqual(details['effort'], encoded['effort'], context + " efforts not ==")
+
+    @staticmethod
+    def struct_to_datetime(struct_time):
+        return datetime.datetime(struct_time.tm_year, struct_time.tm_mon,
+            struct_time.tm_mday, struct_time.tm_hour,
+            struct_time.tm_min, struct_time.tm_sec, tzinfo=UTC())
+
+    def compare_date_fields(self, details, encoded, context, field):
+        if details[field] is not None:
+            date = Date()
+            if field in encoded and encoded[field] is not None:
+                encoded_encoded = date.from_json(encoded[field])
+                dt1 = CourseDetailsViewTest.struct_to_datetime(encoded_encoded)
+
+                if isinstance(details[field], datetime.datetime):
+                    dt2 = details[field]
+                else:
+                    details_encoded = date.from_json(details[field])
+                    dt2 = CourseDetailsViewTest.struct_to_datetime(details_encoded)
+
+                expected_delta = datetime.timedelta(0)
+                self.assertEqual(dt1 - dt2, expected_delta, str(dt1) + "!=" + str(dt2) + " at " + context)
+            else:
+                self.fail(field + " missing from encoded but in details at " + context)
+        elif field in encoded and encoded[field] is not None:
+            self.fail(field + " included in encoding but missing from details at " + context)
+
+
+class CourseGradingTest(CourseTestCase):
+    def test_initial_grader(self):
+        descriptor = get_modulestore(self.course_location).get_item(self.course_location)
+        test_grader = CourseGradingModel(descriptor)
+        # ??? How much should this test bake in expectations about defaults and thus fail if defaults change?
+        self.assertEqual(self.course_location, test_grader.course_location, "Course locations")
+        self.assertIsNotNone(test_grader.graders, "No graders")
+        self.assertIsNotNone(test_grader.grade_cutoffs, "No cutoffs")
+
+    def test_fetch_grader(self):
+        test_grader = CourseGradingModel.fetch(self.course_location.url())
+        self.assertEqual(self.course_location, test_grader.course_location, "Course locations")
+        self.assertIsNotNone(test_grader.graders, "No graders")
+        self.assertIsNotNone(test_grader.grade_cutoffs, "No cutoffs")
+
+        test_grader = CourseGradingModel.fetch(self.course_location)
+        self.assertEqual(self.course_location, test_grader.course_location, "Course locations")
+        self.assertIsNotNone(test_grader.graders, "No graders")
+        self.assertIsNotNone(test_grader.grade_cutoffs, "No cutoffs")
+
+        for i, grader in enumerate(test_grader.graders):
+            subgrader = CourseGradingModel.fetch_grader(self.course_location, i)
+            self.assertDictEqual(grader, subgrader, str(i) + "th graders not equal")
+
+        subgrader = CourseGradingModel.fetch_grader(self.course_location.list(), 0)
+        self.assertDictEqual(test_grader.graders[0], subgrader, "failed with location as list")
+
+    def test_fetch_cutoffs(self):
+        test_grader = CourseGradingModel.fetch_cutoffs(self.course_location)
+        # ??? should this check that it's at least a dict? (expected is { "pass" : 0.5 } I think)
+        self.assertIsNotNone(test_grader, "No cutoffs via fetch")
+
+        test_grader = CourseGradingModel.fetch_cutoffs(self.course_location.url())
+        self.assertIsNotNone(test_grader, "No cutoffs via fetch with url")
+
+    def test_fetch_grace(self):
+        test_grader = CourseGradingModel.fetch_grace_period(self.course_location)
+        # almost a worthless test
+        self.assertIn('grace_period', test_grader, "No grace via fetch")
+
+        test_grader = CourseGradingModel.fetch_grace_period(self.course_location.url())
+        self.assertIn('grace_period', test_grader, "No cutoffs via fetch with url")
+
+    def test_update_from_json(self):
+        test_grader = CourseGradingModel.fetch(self.course_location)
+        altered_grader = CourseGradingModel.update_from_json(test_grader.__dict__)
+        self.assertDictEqual(test_grader.__dict__, altered_grader.__dict__, "Noop update")
+
+        test_grader.graders[0]['weight'] = test_grader.graders[0].get('weight') * 2
+        altered_grader = CourseGradingModel.update_from_json(test_grader.__dict__)
+        self.assertDictEqual(test_grader.__dict__, altered_grader.__dict__, "Weight[0] * 2")
+
+        test_grader.grade_cutoffs['D'] = 0.3
+        altered_grader = CourseGradingModel.update_from_json(test_grader.__dict__)
+        self.assertDictEqual(test_grader.__dict__, altered_grader.__dict__, "cutoff add D")
+
+        test_grader.grace_period = {'hours': 4, 'minutes': 5, 'seconds': 0}
+        altered_grader = CourseGradingModel.update_from_json(test_grader.__dict__)
+        print test_grader.grace_period, altered_grader.grace_period
+        self.assertDictEqual(test_grader.__dict__, altered_grader.__dict__, "4 hour grace period")
+
+    def test_update_grader_from_json(self):
+        test_grader = CourseGradingModel.fetch(self.course_location)
+        altered_grader = CourseGradingModel.update_grader_from_json(test_grader.course_location, test_grader.graders[1])
+        self.assertDictEqual(test_grader.graders[1], altered_grader, "Noop update")
+
+        test_grader.graders[1]['min_count'] = test_grader.graders[1].get('min_count') + 2
+        altered_grader = CourseGradingModel.update_grader_from_json(test_grader.course_location, test_grader.graders[1])
+        self.assertDictEqual(test_grader.graders[1], altered_grader, "min_count[1] + 2")
+
+        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,
+            { "advertised_start" : "start A",
+              "testcenter_info" : { "c" : "test" },
+              "days_early_for_beta" : 2})
+        self.update_check(test_model)
+        # try fresh fetch to ensure persistence
+        test_model = CourseMetadata.fetch(self.course_location)
+        self.update_check(test_model)
+        # now change some of the existing metadata
+        test_model = CourseMetadata.update_from_json(self.course_location,
+            { "advertised_start" : "start B",
+              "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('advertised_start', test_model, 'Missing revised advertised_start metadata field')
+        self.assertEqual(test_model['advertised_start'], 'start B', "advertised_start 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('advertised_start', test_model, 'Missing new advertised_start metadata field')
+        self.assertEqual(test_model['advertised_start'], 'start A', "advertised_start not expected value")
+        self.assertIn('testcenter_info', test_model, 'Missing testcenter_info metadata field')
+        self.assertDictEqual(test_model['testcenter_info'], { "c" : "test" }, "testcenter_info not expected value")
+        self.assertIn('days_early_for_beta', test_model, 'Missing days_early_for_beta metadata field')
+        self.assertEqual(test_model['days_early_for_beta'], 2, "days_early_for_beta not expected value")
+
+
+    def test_delete_key(self):
+        test_model = CourseMetadata.delete_key(self.fullcourse_location, { 'deleteKeys' : ['doesnt_exist', 'showanswer', 'xqa_key']})
+        # 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.assertEqual('closed', test_model['showanswer'], 'showanswer field still in')
+        self.assertEqual(None, test_model['xqa_key'], 'xqa_key field still in')

cms/djangoapps/contentstore/tests/test_course_updates.py

@@ -0,0 +1,145 @@
+'''unit tests for course_info views and models.'''
+from contentstore.tests.test_course_settings import CourseTestCase
+from django.core.urlresolvers import reverse
+import json
+
+
+class CourseUpdateTest(CourseTestCase):
+    '''The do all and end all of unit test cases.'''
+    def test_course_update(self):
+        '''Go through each interface and ensure it works.'''
+        # first get the update to force the creation
+        url = reverse('course_info',
+            kwargs={'org': self.course_location.org,
+                'course': self.course_location.course,
+                'name': self.course_location.name})
+        self.client.get(url)
+
+        init_content = '<iframe width="560" height="315" src="http://www.youtube.com/embed/RocY-Jd93XU" frameborder="0">'
+        content = init_content + '</iframe>'
+        payload = {'content': content,
+                   'date': 'January 8, 2013'}
+        url = reverse('course_info_json',
+            kwargs={'org': self.course_location.org,
+                'course': self.course_location.course,
+                'provided_id': ''})
+
+        resp = self.client.post(url, json.dumps(payload), "application/json")
+
+        payload = json.loads(resp.content)
+
+        self.assertHTMLEqual(payload['content'], content)
+
+        first_update_url = reverse('course_info_json',
+            kwargs={'org': self.course_location.org,
+                'course': self.course_location.course,
+                'provided_id': payload['id']})
+        content += '<div>div <p>p<br/></p></div>'
+        payload['content'] = content
+        resp = self.client.post(first_update_url, json.dumps(payload),
+            "application/json")
+
+        self.assertHTMLEqual(content, json.loads(resp.content)['content'],
+            "iframe w/ div")
+
+        # now put in an evil update
+        content = '<ol/>'
+        payload = {'content': content,
+                   'date': 'January 11, 2013'}
+        url = reverse('course_info_json',
+            kwargs={'org': self.course_location.org,
+                'course': self.course_location.course,
+                'provided_id': ''})
+
+        resp = self.client.post(url, json.dumps(payload), "application/json")
+
+        payload = json.loads(resp.content)
+
+        self.assertHTMLEqual(content, payload['content'], "self closing ol")
+
+        url = reverse('course_info_json',
+            kwargs={'org': self.course_location.org,
+                'course': self.course_location.course,
+                'provided_id': ''})
+        resp = self.client.get(url)
+        payload = json.loads(resp.content)
+        self.assertTrue(len(payload) == 2)
+
+        # can't test non-json paylod b/c expect_json throws error
+        # try json w/o required fields
+        self.assertContains(
+            self.client.post(url, json.dumps({'garbage': 1}),
+                "application/json"),
+            'Failed to save', status_code=400)
+
+        # now try to update a non-existent update
+        url = reverse('course_info_json',
+            kwargs={'org': self.course_location.org,
+                'course': self.course_location.course,
+                'provided_id': '9'})
+        content = 'blah blah'
+        payload = {'content': content,
+                   'date': 'January 21, 2013'}
+        self.assertContains(
+            self.client.post(url, json.dumps(payload), "application/json"),
+            'Failed to save', status_code=400)
+
+        # update w/ malformed html
+        content = '<garbage tag No closing brace to force <span>error</span>'
+        payload = {'content': content,
+                   'date': 'January 11, 2013'}
+        url = reverse('course_info_json', kwargs={'org': self.course_location.org,
+            'course': self.course_location.course,
+            'provided_id': ''})
+
+        self.assertContains(
+            self.client.post(url, json.dumps(payload), "application/json"),
+            '<garbage')
+
+        # set to valid html which would break an xml parser
+        content = "<p><br><br></p>"
+        payload = {'content': content,
+                   'date': 'January 11, 2013'}
+        url = reverse('course_info_json', kwargs={'org': self.course_location.org,
+            'course': self.course_location.course,
+            'provided_id': ''})
+
+        resp = self.client.post(url, json.dumps(payload), "application/json")
+        payload = json.loads(resp.content)
+        self.assertHTMLEqual(content, json.loads(resp.content)['content'])
+
+        # now try to delete a non-existent update
+        url = reverse('course_info_json', kwargs={'org': self.course_location.org,
+            'course': self.course_location.course,
+            'provided_id': '19'})
+        payload = {'content': content,
+                   'date': 'January 21, 2013'}
+        self.assertContains(self.client.delete(url), "delete", status_code=400)
+
+        # now delete a real update
+        content = 'blah blah'
+        payload = {'content': content,
+                   'date': 'January 28, 2013'}
+        url = reverse('course_info_json', kwargs={'org': self.course_location.org,
+            'course': self.course_location.course,
+            'provided_id': ''})
+        resp = self.client.post(url, json.dumps(payload), "application/json")
+        payload = json.loads(resp.content)
+        this_id = payload['id']
+        self.assertHTMLEqual(content, payload['content'], "single iframe")
+        # first count the entries
+        url = reverse('course_info_json',
+            kwargs={'org': self.course_location.org,
+                'course': self.course_location.course,
+                'provided_id': ''})
+        resp = self.client.get(url)
+        payload = json.loads(resp.content)
+        before_delete = len(payload)
+
+        url = reverse('course_info_json',
+            kwargs={'org': self.course_location.org,
+                'course': self.course_location.course,
+                'provided_id': this_id})
+        resp = self.client.delete(url)
+        payload = json.loads(resp.content)
+        self.assertTrue(len(payload) == before_delete - 1)

cms/djangoapps/contentstore/tests/test_utils.py

@@ -0,0 +1,72 @@
+""" Tests for utils. """
+from contentstore import utils
+import mock
+from django.test import TestCase
+from xmodule.modulestore.tests.factories import CourseFactory
+from .utils import ModuleStoreTestCase
+
+
+class LMSLinksTestCase(TestCase):
+    """ Tests for LMS links. """
+    def about_page_test(self):
+        """ Get URL for about page. """
+        location = 'i4x', 'mitX', '101', 'course', 'test'
+        utils.get_course_id = mock.Mock(return_value="mitX/101/test")
+        link = utils.get_lms_link_for_about_page(location)
+        self.assertEquals(link, "//localhost:8000/courses/mitX/101/test/about")
+
+    def lms_link_test(self):
+        """ Tests get_lms_link_for_item. """
+        location = 'i4x', 'mitX', '101', 'vertical', 'contacting_us'
+        utils.get_course_id = mock.Mock(return_value="mitX/101/test")
+        link = utils.get_lms_link_for_item(location, False)
+        self.assertEquals(link, "//localhost:8000/courses/mitX/101/test/jump_to/i4x://mitX/101/vertical/contacting_us")
+        link = utils.get_lms_link_for_item(location, True)
+        self.assertEquals(
+            link,
+            "//preview.localhost:8000/courses/mitX/101/test/jump_to/i4x://mitX/101/vertical/contacting_us"
+        )
+
+
+class UrlReverseTestCase(ModuleStoreTestCase):
+    """ Tests for get_url_reverse """
+    def test_CoursePageNames(self):
+        """ Test the defined course pages. """
+        course = CourseFactory.create(org='mitX', number='666', display_name='URL Reverse Course')
+
+        self.assertEquals(
+            '/manage_users/i4x://mitX/666/course/URL_Reverse_Course',
+            utils.get_url_reverse('ManageUsers', course)
+        )
+
+        self.assertEquals(
+            '/mitX/666/settings-details/URL_Reverse_Course',
+            utils.get_url_reverse('SettingsDetails', course)
+        )
+
+        self.assertEquals(
+            '/mitX/666/settings-grading/URL_Reverse_Course',
+            utils.get_url_reverse('SettingsGrading', course)
+        )
+
+        self.assertEquals(
+            '/mitX/666/course/URL_Reverse_Course',
+            utils.get_url_reverse('CourseOutline', course)
+        )
+
+        self.assertEquals(
+            '/mitX/666/checklists/URL_Reverse_Course',
+            utils.get_url_reverse('Checklists', course)
+        )
+
+    def test_unknown_passes_through(self):
+        """ Test that unknown values pass through. """
+        course = CourseFactory.create(org='mitX', number='666', display_name='URL Reverse Course')
+        self.assertEquals(
+            'foobar',
+            utils.get_url_reverse('foobar', course)
+        )
+        self.assertEquals(
+            'https://edge.edx.org/courses/edX/edX101/How_to_Create_an_edX_Course/about',
+            utils.get_url_reverse('https://edge.edx.org/courses/edX/edX101/How_to_Create_an_edX_Course/about', course)
+        )

cms/djangoapps/contentstore/tests/tests.py

@@ -1,54 +1,50 @@
 import json
-from django.test import TestCase
+import shutil
 from django.test.client import Client
-from mock import patch, Mock
-from override_settings import override_settings
 from django.conf import settings
 from django.core.urlresolvers import reverse
 from path import path
-
-from student.models import Registration
-from django.contrib.auth.models import User
-from xmodule.modulestore.django import modulestore
-import xmodule.modulestore.django
-from xmodule.modulestore import Location
-from xmodule.modulestore.xml_importer import import_from_xml
+import json
+from fs.osfs import OSFS
 import copy
 
+from contentstore.utils import get_modulestore
 
-def parse_json(response):
-    """Parse response, which is assumed to be json"""
-    return json.loads(response.content)
+from xmodule.modulestore import Location
+from xmodule.modulestore.store_utilities import clone_course
+from xmodule.modulestore.store_utilities import delete_course
+from xmodule.modulestore.django import modulestore, _MODULESTORES
+from xmodule.contentstore.django import contentstore
+from xmodule.templates import update_templates
+from xmodule.modulestore.xml_exporter import export_to_xml
+from xmodule.modulestore.xml_importer import import_from_xml
+
+from xmodule.capa_module import CapaDescriptor
+from xmodule.course_module import CourseDescriptor
+from xmodule.seq_module import SequenceDescriptor
+
+from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
+from .utils import ModuleStoreTestCase, parse_json, user, registration
 
 
-def user(email):
-    '''look up a user by email'''
-    return User.objects.get(email=email)
-
-
-def registration(email):
-    '''look up registration object by email'''
-    return Registration.objects.get(user__email=email)
-
-
-class ContentStoreTestCase(TestCase):
+class ContentStoreTestCase(ModuleStoreTestCase):
     def _login(self, email, pw):
-        '''Login.  View should always return 200.  The success/fail is in the
-        returned json'''
+        """Login.  View should always return 200.  The success/fail is in the
+        returned json"""
         resp = self.client.post(reverse('login_post'),
                                 {'email': email, 'password': pw})
         self.assertEqual(resp.status_code, 200)
         return resp
 
     def login(self, email, pw):
-        '''Login, check that it worked.'''
+        """Login, check that it worked."""
         resp = self._login(email, pw)
         data = parse_json(resp)
         self.assertTrue(data['success'])
         return resp
 
     def _create_account(self, username, email, pw):
-        '''Try to create an account.  No error checking'''
+        """Try to create an account.  No error checking"""
         resp = self.client.post('/create_account', {
             'username': username,
             'email': email,
@@ -62,7 +58,7 @@ class ContentStoreTestCase(TestCase):
         return resp
 
     def create_account(self, username, email, pw):
-        '''Create the account and check that it worked'''
+        """Create the account and check that it worked"""
         resp = self._create_account(username, email, pw)
         self.assertEqual(resp.status_code, 200)
         data = parse_json(resp)
@@ -74,8 +70,8 @@ class ContentStoreTestCase(TestCase):
         return resp
 
     def _activate_user(self, email):
-        '''Look up the activation key for the user, then hit the activate view.
-        No error checking'''
+        """Look up the activation key for the user, then hit the activate view.
+        No error checking"""
         activation_key = registration(email).activation_key
 
         # and now we try to activate
@@ -88,7 +84,6 @@ class ContentStoreTestCase(TestCase):
         # Now make sure that the user is now actually activated
         self.assertTrue(user(email).is_active)
 
-
 class AuthTestCase(ContentStoreTestCase):
     """Check that various permissions-related things work"""
 
@@ -141,8 +136,6 @@ class AuthTestCase(ContentStoreTestCase):
         """Make sure pages that do require login work."""
         auth_pages = (
             reverse('index'),
-            reverse('edit_item'),
-            reverse('save_item'),
             )
 
         # These are pages that should just load when the user is logged in
@@ -178,34 +171,3 @@ class AuthTestCase(ContentStoreTestCase):
         self.assertEqual(resp.status_code, 302)
 
         # Logged in should work.
-
-TEST_DATA_MODULESTORE = copy.deepcopy(settings.MODULESTORE)
-TEST_DATA_MODULESTORE['default']['OPTIONS']['fs_root'] = path('common/test/data')
-
-@override_settings(MODULESTORE=TEST_DATA_MODULESTORE)
-class EditTestCase(ContentStoreTestCase):
-    """Check that editing functionality works on example courses"""
-
-    def setUp(self):
-        email = 'edit@test.com'
-        password = 'foo'
-        self.create_account('edittest', email, password)
-        self.activate_user(email)
-        self.login(email, password)
-        xmodule.modulestore.django._MODULESTORES = {}
-        xmodule.modulestore.django.modulestore().collection.drop()
-
-    def check_edit_item(self, test_course_name):
-        import_from_xml(modulestore(), 'common/test/data/', [test_course_name])
-
-        for descriptor in modulestore().get_items(Location(None, None, None, None, None)):
-            print "Checking ", descriptor.location.url()
-            print descriptor.__class__, descriptor.location
-            resp = self.client.get(reverse('edit_item'), {'id': descriptor.location.url()})
-            self.assertEqual(resp.status_code, 200)
-
-    def test_edit_item_toy(self):
-        self.check_edit_item('toy')
-
-    def test_edit_item_full(self):
-        self.check_edit_item('full')

cms/djangoapps/contentstore/tests/utils.py

@@ -0,0 +1,65 @@
+import json
+import copy
+from uuid import uuid4
+from django.test import TestCase
+from django.conf import settings
+
+from student.models import Registration
+from django.contrib.auth.models import User
+
+import xmodule.modulestore.django
+from xmodule.templates import update_templates
+
+
+class ModuleStoreTestCase(TestCase):
+    """ Subclass for any test case that uses the mongodb
+    module store. This populates a uniquely named modulestore
+    collection with templates before running the TestCase
+    and drops it they are finished. """
+
+    def _pre_setup(self):
+        super(ModuleStoreTestCase, self)._pre_setup()
+
+        # Use a uuid to differentiate
+        # the mongo collections on jenkins.
+        self.orig_MODULESTORE = copy.deepcopy(settings.MODULESTORE)
+        self.test_MODULESTORE = self.orig_MODULESTORE
+        self.test_MODULESTORE['default']['OPTIONS']['collection'] = 'modulestore_%s' % uuid4().hex
+        self.test_MODULESTORE['direct']['OPTIONS']['collection'] = 'modulestore_%s' % uuid4().hex
+        settings.MODULESTORE = self.test_MODULESTORE
+
+        # Flush and initialize the module store
+        # It needs the templates because it creates new records
+        # by cloning from the template.
+        # Note that if your test module gets in some weird state
+        # (though it shouldn't), do this manually
+        # from the bash shell to drop it:
+        # $ mongo test_xmodule --eval "db.dropDatabase()"
+        xmodule.modulestore.django._MODULESTORES = {}
+        update_templates()
+
+    def _post_teardown(self):
+        # Make sure you flush out the modulestore.
+        # Drop the collection at the end of the test,
+        # otherwise there will be lingering collections leftover
+        # from executing the tests.
+        xmodule.modulestore.django._MODULESTORES = {}
+        xmodule.modulestore.django.modulestore().collection.drop()
+        settings.MODULESTORE = self.orig_MODULESTORE
+
+        super(ModuleStoreTestCase, self)._post_teardown()
+
+
+def parse_json(response):
+    """Parse response, which is assumed to be json"""
+    return json.loads(response.content)
+
+
+def user(email):
+    """look up a user by email"""
+    return User.objects.get(email=email)
+
+
+def registration(email):
+    """look up registration object by email"""
+    return Registration.objects.get(user__email=email)

cms/djangoapps/contentstore/utils.py

@@ -1,13 +1,32 @@
+from django.conf import settings
 from xmodule.modulestore import Location
 from xmodule.modulestore.django import modulestore
+from xmodule.modulestore.exceptions import ItemNotFoundError
+from django.core.urlresolvers import reverse
+
+DIRECT_ONLY_CATEGORIES = ['course', 'chapter', 'sequential', 'about', 'static_tab', 'course_info']
+
+
+def get_modulestore(location):
+    """
+    Returns the correct modulestore to use for modifying the specified location
+    """
+    if not isinstance(location, Location):
+        location = Location(location)
+
+    if location.category in DIRECT_ONLY_CATEGORIES:
+        return modulestore('direct')
+    else:
+        return modulestore()
+
 
-'''
-cdodge: for a given Xmodule, return the course that it belongs to
-NOTE: This makes a lot of assumptions about the format of the course location
-Also we have to assert that this module maps to only one course item - it'll throw an
-assert if not
-'''
 def get_course_location_for_item(location):
+    '''
+    cdodge: for a given Xmodule, return the course that it belongs to
+    NOTE: This makes a lot of assumptions about the format of the course location
+    Also we have to assert that this module maps to only one course item - it'll throw an
+    assert if not
+    '''
     item_loc = Location(location)
 
     # check to see if item is already a course, if so we can skip this
@@ -21,11 +40,154 @@ def get_course_location_for_item(location):
         # make sure we found exactly one match on this above course search
         found_cnt = len(courses)
         if found_cnt == 0:
-            raise BaseException('Could not find course at {0}'.format(course_search_location))
+            raise Exception('Could not find course at {0}'.format(course_search_location))
 
         if found_cnt > 1:
-            raise BaseException('Found more than one course at {0}. There should only be one!!!'.format(course_search_location))
+            raise Exception('Found more than one course at {0}. There should only be one!!! Dump = {1}'.format(course_search_location, courses))
 
         location = courses[0].location
 
     return location
+
+
+def get_course_for_item(location):
+    '''
+    cdodge: for a given Xmodule, return the course that it belongs to
+    NOTE: This makes a lot of assumptions about the format of the course location
+    Also we have to assert that this module maps to only one course item - it'll throw an
+    assert if not
+    '''
+    item_loc = Location(location)
+
+    # @hack! We need to find the course location however, we don't
+    # know the 'name' parameter in this context, so we have
+    # to assume there's only one item in this query even though we are not specifying a name
+    course_search_location = ['i4x', item_loc.org, item_loc.course, 'course', None]
+    courses = modulestore().get_items(course_search_location)
+
+    # make sure we found exactly one match on this above course search
+    found_cnt = len(courses)
+    if found_cnt == 0:
+        raise BaseException('Could not find course at {0}'.format(course_search_location))
+
+    if found_cnt > 1:
+        raise BaseException('Found more than one course at {0}. There should only be one!!! Dump = {1}'.format(course_search_location, courses))
+
+    return courses[0]
+
+
+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:
+        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:
+        lms_link = None
+
+    return lms_link
+
+
+def get_lms_link_for_about_page(location):
+    """
+    Returns the url to the course about page from the location tuple.
+    """
+    if settings.LMS_BASE is not None:
+        lms_link = "//{lms_base}/courses/{course_id}/about".format(
+            lms_base=settings.LMS_BASE,
+            course_id=get_course_id(location)
+        )
+    else:
+        lms_link = None
+
+    return lms_link
+
+
+def get_course_id(location):
+    """
+    Returns the course_id from a given the location tuple.
+    """
+    # TODO: These will need to be changed to point to the particular instance of this problem in the particular course
+    return modulestore().get_containing_courses(Location(location))[0].id
+
+
+class UnitState(object):
+    draft = 'draft'
+    private = 'private'
+    public = 'public'
+
+
+def compute_unit_state(unit):
+    """
+    Returns whether this unit is 'draft', 'public', or 'private'.
+
+    'draft' content is in the process of being edited, but still has a previous
+        version visible in the LMS
+    'public' content is locked and visible in the LMS
+    'private' content is editabled and not visible in the LMS
+    """
+
+    if unit.cms.is_draft:
+        try:
+            modulestore('direct').get_item(unit.location)
+            return UnitState.draft
+        except ItemNotFoundError:
+            return UnitState.private
+    else:
+        return UnitState.public
+
+
+def get_date_display(date):
+    return date.strftime("%d %B, %Y at %I:%M %p")
+
+
+def update_item(location, value):
+    """
+    If value is None, delete the db entry. Otherwise, update it using the correct modulestore.
+    """
+    if value is None:
+        get_modulestore(location).delete_item(location)
+    else:
+        get_modulestore(location).update_item(location, value)
+
+
+def get_url_reverse(course_page_name, course_module):
+    """
+    Returns the course URL link to the specified location. This value is suitable to use as an href link.
+
+    course_page_name should correspond to an attribute in CoursePageNames (for example, 'ManageUsers'
+    or 'SettingsDetails'), or else it will simply be returned. This method passes back unknown values of
+    course_page_names so that it can also be used for absolute (known) URLs.
+
+    course_module is used to obtain the location, org, course, and name properties for a course, if
+    course_page_name corresponds to an attribute in CoursePageNames.
+    """
+    url_name = getattr(CoursePageNames, course_page_name, None)
+    ctx_loc = course_module.location
+
+    if CoursePageNames.ManageUsers == url_name:
+        return reverse(url_name, kwargs={"location": ctx_loc})
+    elif url_name in [CoursePageNames.SettingsDetails, CoursePageNames.SettingsGrading,
+                      CoursePageNames.CourseOutline, CoursePageNames.Checklists]:
+        return reverse(url_name, kwargs={'org': ctx_loc.org, 'course': ctx_loc.course, 'name': ctx_loc.name})
+    else:
+        return course_page_name
+
+
+class CoursePageNames:
+    """ Constants for pages that are recognized by get_url_reverse method. """
+    ManageUsers = "manage_users"
+    SettingsDetails = "settings_details"
+    SettingsGrading = "settings_grading"
+    CourseOutline = "course_index"
+    Checklists = "checklists"

cms/djangoapps/contentstore/views.py

@@ -1,52 +1,86 @@
 from util.json_request import expect_json
 import json
-import os
 import logging
+import os
 import sys
-import mimetypes
-import StringIO
-import exceptions
+import time
+import tarfile
+import shutil
+from datetime import datetime
 from collections import defaultdict
+from uuid import uuid4
+from path import path
+from xmodule.modulestore.xml_exporter import export_to_xml
+from tempfile import mkdtemp
+from django.core.servers.basehttp import FileWrapper
+from django.core.files.temp import NamedTemporaryFile
 
 # to install PIL on MacOSX: 'easy_install http://dist.repoze.org/PIL-1.1.6.tar.gz'
 from PIL import Image
 
-from django.http import HttpResponse, Http404, HttpResponseBadRequest, HttpResponseForbidden
+from django.http import HttpResponse, Http404, HttpResponseBadRequest, HttpResponseForbidden, HttpResponseServerError
+from django.http import HttpResponseNotFound
 from django.contrib.auth.decorators import login_required
 from django.core.exceptions import PermissionDenied
 from django.core.context_processors import csrf
 from django_future.csrf import ensure_csrf_cookie
 from django.core.urlresolvers import reverse
 from django.conf import settings
-from django import forms
 
 from xmodule.modulestore import Location
+from xmodule.modulestore.exceptions import ItemNotFoundError, InvalidLocationError
+from xmodule.modulestore.inheritance import own_metadata
+from xblock.core import Scope
+from xblock.runtime import KeyValueStore, DbModel, InvalidScopeError
 from xmodule.x_module import ModuleSystem
 from xmodule.error_module import ErrorDescriptor
 from xmodule.errortracker import exc_info_to_str
-from github_sync import export_to_github
-from static_replace import replace_urls
+import static_replace
+from external_auth.views import ssl_login_shortcut
+from xmodule.modulestore.mongo import MongoUsage
 
 from mitxmako.shortcuts import render_to_response, render_to_string
 from xmodule.modulestore.django import modulestore
 from xmodule_modifiers import replace_static_urls, wrap_xmodule
 from xmodule.exceptions import NotFoundError
 from functools import partial
-from itertools import groupby
-from operator import attrgetter
 
 from xmodule.contentstore.django import contentstore
 from xmodule.contentstore.content import StaticContent
 
-from cache_toolbox.core import set_cached_content, get_cached_content, del_cached_content
 from auth.authz import is_user_in_course_group_role, get_users_in_course_group_by_role
 from auth.authz import get_user_by_email, add_user_to_course_group, remove_user_from_course_group
-from auth.authz import ADMIN_ROLE_NAME, EDITOR_ROLE_NAME
-from .utils import get_course_location_for_item
+from auth.authz import INSTRUCTOR_ROLE_NAME, STAFF_ROLE_NAME, create_all_course_groups
+from .utils import get_course_location_for_item, get_lms_link_for_item, compute_unit_state, \
+    get_date_display, UnitState, get_course_for_item, get_url_reverse
+
+from xmodule.modulestore.xml_importer import import_from_xml
+from contentstore.course_info_model import get_course_updates, \
+    update_course_updates, delete_course_update
+from cache_toolbox.core import del_cached_content
+from contentstore.module_info_model import get_module_info, set_module_info
+from models.settings.course_details import CourseDetails, \
+    CourseSettingsEncoder
+from models.settings.course_grading import CourseGradingModel
+from contentstore.utils import get_modulestore
+from django.shortcuts import redirect
+from models.settings.course_metadata import CourseMetadata
+
+# to install PIL on MacOSX: 'easy_install http://dist.repoze.org/PIL-1.1.6.tar.gz'
 
 log = logging.getLogger(__name__)
 
 
+COMPONENT_TYPES = ['customtag', 'discussion', 'html', 'problem', 'video']
+
+ADVANCED_COMPONENT_TYPES = ['annotatable', 'combinedopenended', 'peergrading']
+ADVANCED_COMPONENT_CATEGORY = 'advanced'
+ADVANCED_COMPONENT_POLICY_KEY = 'advanced_modules'
+
+# cdodge: these are categories which should not be parented, they are detached from the hierarchy
+DETACHED_CATEGORIES = ['about', 'static_tab', 'course_info']
+
+
 # ==== Public views ==================================================
 
 @ensure_csrf_cookie
@@ -58,44 +92,82 @@ def signup(request):
     return render_to_response('signup.html', {'csrf': csrf_token})
 
 
+def old_login_redirect(request):
+    '''
+    Redirect to the active login url.
+    '''
+    return redirect('login', permanent=True)
+
+
+@ssl_login_shortcut
 @ensure_csrf_cookie
 def login_page(request):
     """
     Display the login form.
     """
     csrf_token = csrf(request)['csrf_token']
-    return render_to_response('login.html', {'csrf': csrf_token})
+    return render_to_response('login.html', {
+        'csrf': csrf_token,
+        'forgot_password_link': "//{base}/#forgot-password-modal".format(base=settings.LMS_BASE),
+    })
 
 
+def howitworks(request):
+    if request.user.is_authenticated():
+        return index(request)
+    else:
+        return render_to_response('howitworks.html', {})
+
 # ==== Views for any logged-in user ==================================
 
+
 @login_required
 @ensure_csrf_cookie
 def index(request):
     """
     List all courses available to the logged in user
     """
-    courses = modulestore().get_items(['i4x', None, None, 'course', None])
+    courses = modulestore('direct').get_items(['i4x', None, None, 'course', None])
 
-    # filter out courses that we don't have access to
-    courses = filter(lambda course: has_access(request.user, course.location), courses)
+    # filter out courses that we don't have access too
+    def course_filter(course):
+        return (has_access(request.user, course.location)
+                and course.location.course != 'templates'
+                and course.location.org != ''
+                and course.location.course != ''
+                and course.location.name != '')
+    courses = filter(course_filter, courses)
 
     return render_to_response('index.html', {
-        'courses': [(course.metadata.get('display_name'),
-                    reverse('course_index', args=[
-                        course.location.org,
-                        course.location.course,
-                        course.location.name]))
-                    for course in courses]
+        'new_course_template': Location('i4x', 'edx', 'templates', 'course', 'Empty'),
+        'courses': [(course.display_name,
+                    get_url_reverse('CourseOutline', course),
+                    get_lms_link_for_item(course.location, course_id=course.location.course_id))
+                    for course in courses],
+        'user': request.user,
+        'disable_course_creation': settings.MITX_FEATURES.get('DISABLE_COURSE_CREATION', False) and not request.user.is_staff
     })
 
 
 # ==== Views with per-item permissions================================
 
-def has_access(user, location, role=EDITOR_ROLE_NAME):
-    '''Return True if user allowed to access this piece of data'''
-    '''Note that the CMS permissions model is with respect to courses'''
-    return is_user_in_course_group_role(user, get_course_location_for_item(location), role)
+
+def has_access(user, location, role=STAFF_ROLE_NAME):
+    '''
+    Return True if user allowed to access this piece of data
+    Note that the CMS permissions model is with respect to courses
+    There is a super-admin permissions if user.is_staff is set
+    Also, since we're unifying the user database between LMS and CAS,
+    I'm presuming that the course instructor (formally known as admin)
+    will not be in both INSTRUCTOR and STAFF groups, so we have to cascade our queries here as INSTRUCTOR
+    has all the rights that STAFF do
+    '''
+    course_location = get_course_location_for_item(location)
+    _has_access = is_user_in_course_group_role(user, course_location, role)
+    # if we're not in STAFF, perhaps we're in INSTRUCTOR groups
+    if not _has_access and role == STAFF_ROLE_NAME:
+        _has_access = is_user_in_course_group_role(user, course_location, INSTRUCTOR_ROLE_NAME)
+    return _has_access
 
 
 @login_required
@@ -106,37 +178,98 @@ def course_index(request, org, course, name):
 
     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()
+    location = get_location_and_verify_access(request, org, course, name)
 
-    # TODO (cpennington): These need to be read in from the active user
-    _course = modulestore().get_item(location)
-    weeks = _course.get_children()
+    lms_link = get_lms_link_for_item(location)
 
-    #upload_asset_callback_url = "/{org}/{course}/course/{name}/upload_asset".format(
-    #    org = org, 
-    #    course = course,
-    #    name = name
-    #    )
+    upload_asset_callback_url = reverse('upload_asset', kwargs={
+        'org': org,
+        'course': course,
+        'coursename': name
+    })
 
-    upload_asset_callback_url = reverse('upload_asset', kwargs = {
-            'org' : org,
-            'course' : course,
-            'coursename' : name
-            })
-    logging.debug(upload_asset_callback_url)
+    course = modulestore().get_item(location)
+    sections = course.get_children()
 
-    return render_to_response('course_index.html', {
-            'weeks': weeks, 
-            'upload_asset_callback_url': upload_asset_callback_url
-            })
+    return render_to_response('overview.html', {
+        'active_tab': 'courseware',
+        'context_course': course,
+        'lms_link': lms_link,
+        'sections': sections,
+        'course_graders': json.dumps(CourseGradingModel.fetch(course.location).graders),
+        'parent_location': course.location,
+        'new_section_template': Location('i4x', 'edx', 'templates', 'chapter', 'Empty'),
+        'new_subsection_template': Location('i4x', 'edx', 'templates', 'sequential', 'Empty'),  # for now they are the same, but the could be different at some point...
+        'upload_asset_callback_url': upload_asset_callback_url,
+        'create_new_unit_template': Location('i4x', 'edx', 'templates', 'vertical', 'Empty')
+    })
 
 
 @login_required
-def edit_item(request):
+def edit_subsection(request, location):
+    # check that we have permissions to edit this item
+    if not has_access(request.user, location):
+        raise PermissionDenied()
+
+    item = modulestore().get_item(location)
+
+    # TODO: we need a smarter way to figure out what course an item is in
+    for course in modulestore().get_courses():
+        if (course.location.org == item.location.org and
+            course.location.course == item.location.course):
+            break
+
+    lms_link = get_lms_link_for_item(location)
+    preview_link = get_lms_link_for_item(location, preview=True)
+
+    # make sure that location references a 'sequential', otherwise return BadRequest
+    if item.location.category != 'sequential':
+        return HttpResponseBadRequest()
+
+    parent_locs = modulestore().get_parent_locations(location, None)
+
+    # we're for now assuming a single parent
+    if len(parent_locs) != 1:
+        logging.error('Multiple (or none) parents have been found for {0}'.format(location))
+
+    # this should blow up if we don't find any parents, which would be erroneous
+    parent = modulestore().get_item(parent_locs[0])
+
+    # remove all metadata from the generic dictionary that is presented in a more normalized UI
+
+    policy_metadata = dict(
+        (field.name, field.read_from(item))
+        for field
+        in item.fields
+        if field.name not in ['display_name', 'start', 'due', 'format'] and
+            field.scope == Scope.settings
+    )
+
+    can_view_live = False
+    subsection_units = item.get_children()
+    for unit in subsection_units:
+        state = compute_unit_state(unit)
+        if state == UnitState.public or state == UnitState.draft:
+            can_view_live = True
+            break
+
+    return render_to_response('edit_subsection.html',
+        {'subsection': item,
+         'context_course': course,
+         'create_new_unit_template': Location('i4x', 'edx', 'templates', 'vertical', 'Empty'),
+         'lms_link': lms_link,
+         'preview_link': preview_link,
+         'course_graders': json.dumps(CourseGradingModel.fetch(course.location).graders),
+         'parent_location': course.location,
+         'parent_item': parent,
+         'policy_metadata': policy_metadata,
+         'subsection_units': subsection_units,
+         'can_view_live': can_view_live
+        })
+
+
+@login_required
+def edit_unit(request, location):
     """
     Display an editing page for the specified module.
 
@@ -144,66 +277,144 @@ def edit_item(request):
 
     id: A Location URL
     """
-    
-    item_location = request.GET['id']
-
     # check that we have permissions to edit this item
-    if not has_access(request.user, item_location):
+    if not has_access(request.user, location):
         raise PermissionDenied()
 
-    item = modulestore().get_item(item_location)
-    item.get_html = wrap_xmodule(item.get_html, item, "xmodule_edit.html")
+    item = modulestore().get_item(location)
 
-    if settings.LMS_BASE is not None:
-        lms_link = "{lms_base}/courses/{course_id}/jump_to/{location}".format(
-            lms_base=settings.LMS_BASE,
-            # TODO: These will need to be changed to point to the particular instance of this problem in the particular course
-            course_id= modulestore().get_containing_courses(item.location)[0].id,
-            location=item.location,
-        )
+    # TODO: we need a smarter way to figure out what course an item is in
+    for course in modulestore().get_courses():
+        if (course.location.org == item.location.org and
+            course.location.course == item.location.course):
+            break
+
+    lms_link = get_lms_link_for_item(item.location)
+
+    component_templates = defaultdict(list)
+
+    # Check if there are any advanced modules specified in the course policy. These modules
+    # should be specified as a list of strings, where the strings are the names of the modules
+    # in ADVANCED_COMPONENT_TYPES that should be enabled for the course.
+    course_advanced_keys = course.advanced_modules
+
+    # Set component types according to course policy file
+    component_types = list(COMPONENT_TYPES)
+    if isinstance(course_advanced_keys, list):
+        course_advanced_keys = [c for c in course_advanced_keys if c in ADVANCED_COMPONENT_TYPES]
+        if len(course_advanced_keys) > 0:
+            component_types.append(ADVANCED_COMPONENT_CATEGORY)
     else:
-        lms_link = None
+        log.error("Improper format for course advanced keys! {0}".format(course_advanced_keys))
+
+    templates = modulestore().get_items(Location('i4x', 'edx', 'templates'))
+    for template in templates:
+        category = template.location.category
+
+        if category in course_advanced_keys:
+            category = ADVANCED_COMPONENT_CATEGORY
+
+        if category in component_types:
+            # This is a hack to create categories for different xmodules
+            component_templates[category].append((
+                template.display_name_with_default,
+                template.location.url(),
+                hasattr(template, 'markdown') and template.markdown is not None,
+                template.cms.empty,
+            ))
+
+    components = [
+        component.location.url()
+        for component
+        in item.get_children()
+    ]
+
+    # TODO (cpennington): If we share units between courses,
+    # this will need to change to check permissions correctly so as
+    # to pick the correct parent subsection
+
+    containing_subsection_locs = modulestore().get_parent_locations(location, None)
+    containing_subsection = modulestore().get_item(containing_subsection_locs[0])
+
+    containing_section_locs = modulestore().get_parent_locations(containing_subsection.location, None)
+    containing_section = modulestore().get_item(containing_section_locs[0])
+
+    # cdodge hack. We're having trouble previewing drafts via jump_to redirect
+    # so let's generate the link url here
+
+    # need to figure out where this item is in the list of children as the preview will need this
+    index = 1
+    for child in containing_subsection.get_children():
+        if child.location == item.location:
+            break
+        index = index + 1
+
+    preview_lms_base = settings.MITX_FEATURES.get('PREVIEW_LMS_BASE',
+        'preview.' + settings.LMS_BASE)
+
+    preview_lms_link = '//{preview_lms_base}/courses/{org}/{course}/{course_name}/courseware/{section}/{subsection}/{index}'.format(
+            preview_lms_base=preview_lms_base,
+            lms_base=settings.LMS_BASE,
+            org=course.location.org,
+            course=course.location.course,
+            course_name=course.location.name,
+            section=containing_section.location.name,
+            subsection=containing_subsection.location.name,
+            index=index)
+
+    unit_state = compute_unit_state(item)
 
-    
     return render_to_response('unit.html', {
-        'contents': item.get_html(),
-        'js_module': item.js_module_name,
-        'category': item.category,
-        'url_name': item.url_name,
-        'previews': get_module_previews(request, item),
-        'metadata': item.metadata,
-        # TODO: It would be nice to able to use reverse here in some form, but we don't have the lms urls imported
-        'lms_link': lms_link,
+        'context_course': course,
+        'active_tab': 'courseware',
+        'unit': item,
+        'unit_location': location,
+        'components': components,
+        'component_templates': component_templates,
+        'draft_preview_link': preview_lms_link,
+        'published_preview_link': lms_link,
+        'subsection': containing_subsection,
+        'release_date': get_date_display(datetime.fromtimestamp(time.mktime(containing_subsection.lms.start))) if containing_subsection.lms.start is not None else None,
+        'section': containing_section,
+        'create_new_unit_template': Location('i4x', 'edx', 'templates', 'vertical', 'Empty'),
+        'unit_state': unit_state,
+        'published_date': item.cms.published_date.strftime('%B %d, %Y') if item.cms.published_date is not None else None,
     })
 
 
 @login_required
-def new_item(request):
-    """
-    Display a page where the user can create a new item from a template
+def preview_component(request, location):
+    # TODO (vshnayder): change name from id to location in coffee+html as well.
+    if not has_access(request.user, location):
+        raise HttpResponseForbidden()
 
-    Expects a GET request with the parameter 'parent_location', which is the element to add
-    the newly created item to as a child.
+    component = modulestore().get_item(location)
 
-    parent_location: A Location URL
-    """
-
-    parent_location = request.GET['parent_location']
-    if not has_access(request.user, parent_location):
-        raise Http404
-
-    parent = modulestore().get_item(parent_location)
-    templates = modulestore().get_items(Location('i4x', 'edx', 'templates'))
-
-    templates.sort(key=attrgetter('location.category', 'display_name'))
-
-    return render_to_response('new_item.html', {
-        'parent_name': parent.display_name,
-        'parent_location': parent.location.url(),
-        'templates': groupby(templates, attrgetter('location.category')),
+    return render_to_response('component.html', {
+        'preview': get_module_previews(request, component)[0],
+        'editor': wrap_xmodule(component.get_html, component, 'xmodule_edit.html')(),
     })
 
 
+@expect_json
+@login_required
+@ensure_csrf_cookie
+def assignment_type_update(request, org, course, category, name):
+    '''
+    CRUD operations on assignment types for sections and subsections and anything else gradable.
+    '''
+    location = Location(['i4x', org, course, category, name])
+    if not has_access(request.user, location):
+        raise HttpResponseForbidden()
+
+    if request.method == 'GET':
+        return HttpResponse(json.dumps(CourseGradingModel.get_section_grader_type(location)),
+                            mimetype="application/json")
+    elif request.method == 'POST':  # post or put, doesn't matter.
+        return HttpResponse(json.dumps(CourseGradingModel.update_section_grader_type(location, request.POST)),
+                            mimetype="application/json")
+
+
 def user_author_string(user):
     '''Get an author string for commits by this user.  Format:
     first last <email@email.com>.
@@ -232,9 +443,8 @@ def preview_dispatch(request, preview_id, location, dispatch=None):
     dispatch: The action to execute
     """
 
-    instance_state, shared_state = load_preview_state(request, preview_id, location)
     descriptor = modulestore().get_item(location)
-    instance = load_preview_module(request, preview_id, descriptor, instance_state, shared_state)
+    instance = load_preview_module(request, preview_id, descriptor)
     # Let the module handle the AJAX
     try:
         ajax_return = instance.handle_ajax(dispatch, request.POST)
@@ -245,42 +455,9 @@ def preview_dispatch(request, preview_id, location, dispatch=None):
         log.exception("error processing ajax call")
         raise
 
-    save_preview_state(request, preview_id, location, instance.get_instance_state(), instance.get_shared_state())
     return HttpResponse(ajax_return)
 
 
-def load_preview_state(request, preview_id, location):
-    """
-    Load the state of a preview module from the request
-
-    preview_id (str): An identifier specifying which preview this module is used for
-    location: The Location of the module to dispatch to
-    """
-    if 'preview_states' not in request.session:
-        request.session['preview_states'] = defaultdict(dict)
-
-    instance_state = request.session['preview_states'][preview_id, location].get('instance')
-    shared_state = request.session['preview_states'][preview_id, location].get('shared')
-
-    return instance_state, shared_state
-
-
-def save_preview_state(request, preview_id, location, instance_state, shared_state):
-    """
-    Save the state of a preview module to the request
-
-    preview_id (str): An identifier specifying which preview this module is used for
-    location: The Location of the module to dispatch to
-    instance_state: The instance state to save
-    shared_state: The shared state to save
-    """
-    if 'preview_states' not in request.session:
-        request.session['preview_states'] = defaultdict(dict)
-
-    request.session['preview_states'][preview_id, location]['instance'] = instance_state
-    request.session['preview_states'][preview_id, location]['shared'] = shared_state
-
-
 def render_from_lms(template_name, dictionary, context=None, namespace='main'):
     """
     Render a template using the LMS MAKO_TEMPLATES
@@ -288,6 +465,33 @@ def render_from_lms(template_name, dictionary, context=None, namespace='main'):
     return render_to_string(template_name, dictionary, context, namespace="lms." + namespace)
 
 
+class SessionKeyValueStore(KeyValueStore):
+    def __init__(self, request, model_data):
+        self._model_data = model_data
+        self._session = request.session
+
+    def get(self, key):
+        try:
+            return self._model_data[key.field_name]
+        except (KeyError, InvalidScopeError):
+            return self._session[tuple(key)]
+
+    def set(self, key, value):
+        try:
+            self._model_data[key.field_name] = value
+        except (KeyError, InvalidScopeError):
+            self._session[tuple(key)] = value
+
+    def delete(self, key):
+        try:
+            del self._model_data[key.field_name]
+        except (KeyError, InvalidScopeError):
+            del self._session[tuple(key)]
+
+    def has(self, key):
+        return key in self._model_data or key in self._session
+
+
 def preview_module_system(request, preview_id, descriptor):
     """
     Returns a ModuleSystem for the specified descriptor that is specialized for
@@ -297,6 +501,15 @@ def preview_module_system(request, preview_id, descriptor):
     preview_id (str): An identifier specifying which preview this module is used for
     descriptor: An XModuleDescriptor
     """
+
+    def preview_model_data(descriptor):
+        return DbModel(
+            SessionKeyValueStore(request, descriptor._model_data),
+            descriptor.module_class,
+            preview_id,
+            MongoUsage(preview_id, descriptor.location.url()),
+        )
+
     return ModuleSystem(
         ajax_url=reverse('preview_dispatch', args=[preview_id, descriptor.location.url(), '']).rstrip('/'),
         # TODO (cpennington): Do we want to track how instructors are using the preview problems?
@@ -305,12 +518,13 @@ def preview_module_system(request, preview_id, descriptor):
         get_module=partial(get_preview_module, request, preview_id),
         render_template=render_from_lms,
         debug=True,
-        replace_urls=replace_urls,
+        replace_urls=partial(static_replace.replace_static_urls, data_directory=None, course_namespace=descriptor.location),
         user=request.user,
+        xblock_model_data=preview_model_data,
     )
 
 
-def get_preview_module(request, preview_id, location):
+def get_preview_module(request, preview_id, descriptor):
     """
     Returns a preview XModule at the specified location. The preview_data is chosen arbitrarily
     from the set of preview data for the descriptor specified by Location
@@ -319,12 +533,11 @@ def get_preview_module(request, preview_id, location):
     preview_id (str): An identifier specifying which preview this module is used for
     location: A Location
     """
-    descriptor = modulestore().get_item(location)
-    instance_state, shared_state = descriptor.get_sample_state()[0]
-    return load_preview_module(request, preview_id, descriptor, instance_state, shared_state)
+
+    return load_preview_module(request, preview_id, descriptor)
 
 
-def load_preview_module(request, preview_id, descriptor, instance_state, shared_state):
+def load_preview_module(request, preview_id, descriptor):
     """
     Return a preview XModule instantiated from the supplied descriptor, instance_state, and shared_state
 
@@ -336,19 +549,33 @@ def load_preview_module(request, preview_id, descriptor, instance_state, shared_
     """
     system = preview_module_system(request, preview_id, descriptor)
     try:
-        module = descriptor.xmodule_constructor(system)(instance_state, shared_state)
+        module = descriptor.xmodule(system)
     except:
+        log.debug("Unable to load preview module", exc_info=True)
         module = ErrorDescriptor.from_descriptor(
             descriptor,
             error_msg=exc_info_to_str(sys.exc_info())
-        ).xmodule_constructor(system)(None, None)
+        ).xmodule(system)
+
+    # cdodge: Special case
+    if module.location.category == 'static_tab':
+        module.get_html = wrap_xmodule(
+            module.get_html,
+            module,
+            "xmodule_tab_display.html",
+        )
+    else:
+        module.get_html = wrap_xmodule(
+            module.get_html,
+            module,
+            "xmodule_display.html",
+        )
 
     module.get_html = replace_static_urls(
-        wrap_xmodule(module.get_html, module, "xmodule_display.html"),
-        module.metadata.get('data_dir', module.location.course)
+        module.get_html,
+        getattr(module, 'data_dir', module.location.course),
+        course_namespace=Location([module.location.tag, module.location.org, module.location.course, None, None])
     )
-    save_preview_state(request, preview_id, descriptor.location.url(),
-        module.get_instance_state(), module.get_shared_state())
 
     return module
 
@@ -362,11 +589,69 @@ def get_module_previews(request, descriptor):
     """
     preview_html = []
     for idx, (instance_state, shared_state) in enumerate(descriptor.get_sample_state()):
-        module = load_preview_module(request, str(idx), descriptor, instance_state, shared_state)
+        module = load_preview_module(request, str(idx), descriptor)
         preview_html.append(module.get_html())
     return preview_html
 
 
+def _xmodule_recurse(item, action):
+    for child in item.get_children():
+        _xmodule_recurse(child, action)
+
+    action(item)
+
+
+@login_required
+@expect_json
+def delete_item(request):
+    item_location = request.POST['id']
+    item_loc = Location(item_location)
+
+    # check permissions for this user within this course
+    if not has_access(request.user, item_location):
+        raise PermissionDenied()
+
+    # optional parameter to delete all children (default False)
+    delete_children = request.POST.get('delete_children', False)
+    delete_all_versions = request.POST.get('delete_all_versions', False)
+
+    item = modulestore().get_item(item_location)
+
+    store = get_modulestore(item_loc)
+
+
+    # @TODO: this probably leaves draft items dangling. My preferance would be for the semantic to be
+    # if item.location.revision=None, then delete both draft and published version
+    # if caller wants to only delete the draft than the caller should put item.location.revision='draft'
+
+    if delete_children:
+        _xmodule_recurse(item, lambda i: store.delete_item(i.location))
+    else:
+        store.delete_item(item.location)
+
+    # cdodge: this is a bit of a hack until I can talk with Cale about the
+    # semantics of delete_item whereby the store is draft aware. Right now calling
+    # delete_item on a vertical tries to delete the draft version leaving the
+    # requested delete to never occur
+    if item.location.revision is None and item.location.category == 'vertical' and delete_all_versions:
+        modulestore('direct').delete_item(item.location)
+
+    # cdodge: we need to remove our parent's pointer to us so that it is no longer dangling
+    if delete_all_versions:
+        parent_locs = modulestore('direct').get_parent_locations(item_loc, None)
+
+        for parent_loc in parent_locs:
+            parent = modulestore('direct').get_item(parent_loc)
+            item_url = item_loc.url()
+            if item_url in parent.children:
+                children = parent.children
+                children.remove(item_url)
+                parent.children = children
+                modulestore('direct').update_children(parent.location, parent.children)
+
+    return HttpResponse()
+
+
 @login_required
 @expect_json
 def save_item(request):
@@ -376,41 +661,96 @@ def save_item(request):
     if not has_access(request.user, item_location):
         raise PermissionDenied()
 
-    if request.POST['data']:
+    store = get_modulestore(Location(item_location));
+
+    if request.POST.get('data') is not None:
         data = request.POST['data']
-        modulestore().update_item(item_location, data)
-        
-    if request.POST['children']:
+        store.update_item(item_location, data)
+
+    # cdodge: note calling request.POST.get('children') will return None if children is an empty array
+    # so it lead to a bug whereby the last component to be deleted in the UI was not actually
+    # deleting the children object from the children collection
+    if 'children' in request.POST and request.POST['children'] is not None:
         children = request.POST['children']
-        modulestore().update_children(item_location, children)
+        store.update_children(item_location, children)
 
     # cdodge: also commit any metadata which might have been passed along in the
     # POST from the client, if it is there
-    # note, that the postback is not the complete metadata, as there's system metadata which is
+    # NOTE, that the postback is not the complete metadata, as there's system metadata which is
     # not presented to the end-user for editing. So let's fetch the original and
     # 'apply' the submitted metadata, so we don't end up deleting system metadata
-    if request.POST['metadata']:
+    if request.POST.get('metadata') is not None:
         posted_metadata = request.POST['metadata']
         # fetch original
         existing_item = modulestore().get_item(item_location)
+
         # update existing metadata with submitted metadata (which can be partial)
-        existing_item.metadata.update(posted_metadata)
-        modulestore().update_metadata(item_location, existing_item.metadata)
+        # IMPORTANT NOTE: if the client passed pack 'null' (None) for a piece of metadata that means 'remove it'
+        for metadata_key, value in posted_metadata.items():
 
-    # Export the course back to github
-    # This uses wildcarding to find the course, which requires handling
-    # multiple courses returned, but there should only ever be one
-    course_location = Location(item_location)._replace(
-        category='course', name=None)
-    courses = modulestore().get_items(course_location, depth=None)
-    for course in courses:
-        author_string = user_author_string(request.user)
-        export_to_github(course, "CMS Edit", author_string)
+            # let's strip out any metadata fields from the postback which have been identified as system metadata
+            # and therefore should not be user-editable, so we should accept them back from the client
+            if metadata_key in existing_item.system_metadata_fields:
+                del posted_metadata[metadata_key]
+            elif posted_metadata[metadata_key] is None:
+                # remove both from passed in collection as well as the collection read in from the modulestore
+                if metadata_key in existing_item._model_data:
+                    del existing_item._model_data[metadata_key]
+                del posted_metadata[metadata_key]
+            else:
+                existing_item._model_data[metadata_key] = value
 
-    descriptor = modulestore().get_item(item_location)
-    preview_html = get_module_previews(request, descriptor)
+        # commit to datastore
+        # TODO (cpennington): This really shouldn't have to do this much reaching in to get the metadata
+        store.update_metadata(item_location, own_metadata(existing_item))
 
-    return HttpResponse(json.dumps(preview_html))
+    return HttpResponse()
+
+
+@login_required
+@expect_json
+def create_draft(request):
+    location = request.POST['id']
+
+    # check permissions for this user within this course
+    if not has_access(request.user, location):
+        raise PermissionDenied()
+
+    # This clones the existing item location to a draft location (the draft is implicit,
+    # because modulestore is a Draft modulestore)
+    modulestore().clone_item(location, location)
+
+    return HttpResponse()
+
+
+@login_required
+@expect_json
+def publish_draft(request):
+    location = request.POST['id']
+
+    # check permissions for this user within this course
+    if not has_access(request.user, location):
+        raise PermissionDenied()
+
+    item = modulestore().get_item(location)
+    _xmodule_recurse(item, lambda i: modulestore().publish(i.location, request.user.id))
+
+    return HttpResponse()
+
+
+@login_required
+@expect_json
+def unpublish_unit(request):
+    location = request.POST['id']
+
+    # check permissions for this user within this course
+    if not has_access(request.user, location):
+        raise PermissionDenied()
+
+    item = modulestore().get_item(location)
+    _xmodule_recurse(item, lambda i: modulestore().unpublish(i.location))
+
+    return HttpResponse()
 
 
 @login_required
@@ -418,44 +758,43 @@ def save_item(request):
 def clone_item(request):
     parent_location = Location(request.POST['parent_location'])
     template = Location(request.POST['template'])
-    display_name = request.POST['name']
+
+    display_name = request.POST.get('display_name')
 
     if not has_access(request.user, parent_location):
         raise PermissionDenied()
 
-    parent = modulestore().get_item(parent_location)
-    dest_location = parent_location._replace(category=template.category, name=Location.clean_for_url_name(display_name))
+    parent = get_modulestore(template).get_item(parent_location)
+    dest_location = parent_location._replace(category=template.category, name=uuid4().hex)
 
-    new_item = modulestore().clone_item(template, dest_location)
-    new_item.metadata['display_name'] = display_name
+    new_item = get_modulestore(template).clone_item(template, dest_location)
 
-    # TODO: This needs to be deleted when we have proper storage for static content
-    new_item.metadata['data_dir'] = parent.metadata['data_dir']
+    # replace the display name with an optional parameter passed in from the caller
+    if display_name is not None:
+        new_item.display_name = display_name
 
-    modulestore().update_metadata(new_item.location.url(), new_item.own_metadata)
-    modulestore().update_children(parent_location, parent.definition.get('children', []) + [new_item.location.url()])
+    get_modulestore(template).update_metadata(new_item.location.url(), own_metadata(new_item))
+
+    if new_item.location.category not in DETACHED_CATEGORIES:
+        get_modulestore(parent.location).update_children(parent_location, parent.children + [new_item.location.url()])
+
+    return HttpResponse(json.dumps({'id': dest_location.url()}))
 
-    return HttpResponse()
 
-'''
-cdodge: this method allows for POST uploading of files into the course asset library, which will
-be supported by GridFS in MongoDB.
-'''
-#@login_required
-#@ensure_csrf_cookie
 def upload_asset(request, org, course, coursename):
-
+    '''
+    cdodge: this method allows for POST uploading of files into the course asset library, which will
+    be supported by GridFS in MongoDB.
+    '''
     if request.method != 'POST':
         # (cdodge) @todo: Is there a way to do a - say - 'raise Http400'?
         return HttpResponseBadRequest()
 
     # construct a location from the passed in path
-    location = ['i4x', org, course, 'course', coursename]
-    if not has_access(request.user, location):
-        return HttpResponseForbidden()
-    
-    # Does the course actually exist?!?
-    
+    location = get_location_and_verify_access(request, org, course, coursename)
+
+    # Does the course actually exist?!? Get anything from it to prove its existance
+
     try:
         item = modulestore().get_item(location)
     except:
@@ -467,111 +806,93 @@ def upload_asset(request, org, course, coursename):
     # nomenclature since we're using a FileSystem paradigm here. We're just imposing
     # the Location string formatting expectations to keep things a bit more consistent
 
-    name = request.FILES['file'].name
+    filename = request.FILES['file'].name
     mime_type = request.FILES['file'].content_type
     filedata = request.FILES['file'].read()
 
-    file_location = StaticContent.compute_location_filename(org, course, name)
+    content_loc = StaticContent.compute_location(org, course, filename)
+    content = StaticContent(content_loc, filename, mime_type, filedata)
 
-    content = StaticContent(file_location, name, mime_type, filedata)
+    # first let's see if a thumbnail can be created
+    (thumbnail_content, thumbnail_location) = contentstore().generate_thumbnail(content)
 
-    # first commit to the DB
+    # delete cached thumbnail even if one couldn't be created this time (else the old thumbnail will continue to show)
+    del_cached_content(thumbnail_location)
+    # now store thumbnail location only if we could create it
+    if thumbnail_content is not None:
+        content.thumbnail_location = thumbnail_location
+
+    # then commit the content
     contentstore().save(content)
+    del_cached_content(content.location)
 
-    # then remove the cache so we're not serving up stale content
-    # NOTE: we're not re-populating the cache here as the DB owns the last-modified timestamp
-    # which is used when serving up static content. This integrity is needed for
-    # browser-side caching support. We *could* re-fetch the saved content so that we have the
-    # timestamp populated, but we might as well wait for the first real request to come in
-    # to re-populate the cache.
-    del_cached_content(file_location)
+    # readback the saved content - we need the database timestamp
+    readback = contentstore().find(content.location)
 
-    # if we're uploading an image, then let's generate a thumbnail so that we can
-    # serve it up when needed without having to rescale on the fly
-    if mime_type.split('/')[0] == 'image':
-        try:
-            # not sure if this is necessary, but let's rewind the stream just in case
-            request.FILES['file'].seek(0)
+    response_payload = {'displayname': content.name,
+        'uploadDate': get_date_display(readback.last_modified_at),
+        'url': StaticContent.get_url_path_from_location(content.location),
+        'thumb_url': StaticContent.get_url_path_from_location(thumbnail_location) if thumbnail_content is not None else None,
+        'msg': 'Upload completed'
+        }
 
-            # use PIL to do the thumbnail generation (http://www.pythonware.com/products/pil/)
-            # My understanding is that PIL will maintain aspect ratios while restricting
-            # the max-height/width to be whatever you pass in as 'size'
-            # @todo: move the thumbnail size to a configuration setting?!?
-            im = Image.open(request.FILES['file'])
+    response = HttpResponse(json.dumps(response_payload))
+    response['asset_url'] = StaticContent.get_url_path_from_location(content.location)
+    return response
 
-            # I've seen some exceptions from the PIL library when trying to save palletted 
-            # PNG files to JPEG. Per the google-universe, they suggest converting to RGB first.
-            im = im.convert('RGB')
-            size = 128, 128
-            im.thumbnail(size, Image.ANTIALIAS)
-            thumbnail_file = StringIO.StringIO()
-            im.save(thumbnail_file, 'JPEG')
-            thumbnail_file.seek(0)
-        
-            # use a naming convention to associate originals with the thumbnail
-            #   <name_without_extention>.thumbnail.jpg
-            thumbnail_name = os.path.splitext(name)[0] + '.thumbnail.jpg'
-            # then just store this thumbnail as any other piece of content
-            thumbnail_file_location = StaticContent.compute_location_filename(org, course, 
-                                                                              thumbnail_name)
-            thumbnail_content = StaticContent(thumbnail_file_location, thumbnail_name, 
-                                              'image/jpeg', thumbnail_file)
-            contentstore().save(thumbnail_content)
-
-            # remove any cached content at this location, as thumbnails are treated just like any
-            # other bit of static content
-            del_cached_content(thumbnail_file_location)
-        except:
-            # catch, log, and continue as thumbnails are not a hard requirement
-            logging.error('Failed to generate thumbnail for {0}. Continuing...'.format(name))
-
-    return HttpResponse('Upload completed')
 
 '''
 This view will return all CMS users who are editors for the specified course
 '''
 @login_required
 @ensure_csrf_cookie
-def manage_users(request, org, course, name):
-    location = ['i4x', org, course, 'course', name]
-    
+def manage_users(request, location):
+
     # check that logged in user has permissions to this item
-    if not has_access(request.user, location, role=ADMIN_ROLE_NAME):
+    if not has_access(request.user, location, role=INSTRUCTOR_ROLE_NAME) and not has_access(request.user, location, role=STAFF_ROLE_NAME):
         raise PermissionDenied()
 
-    return render_to_response('manage_users.html', {
-        'editors': get_users_in_course_group_by_role(location, EDITOR_ROLE_NAME)
-    })
-    
+    course_module = modulestore().get_item(location)
 
-def create_json_response(errmsg = None):
+    return render_to_response('manage_users.html', {
+        'active_tab': 'users',
+        'context_course': course_module,
+        'staff': get_users_in_course_group_by_role(location, STAFF_ROLE_NAME),
+        'add_user_postback_url': reverse('add_user', args=[location]).rstrip('/'),
+        'remove_user_postback_url': reverse('remove_user', args=[location]).rstrip('/'),
+        'allow_actions': has_access(request.user, location, role=INSTRUCTOR_ROLE_NAME),
+        'request_user_id': request.user.id
+    })
+
+
+def create_json_response(errmsg=None):
     if errmsg is not None:
-        resp = HttpResponse(json.dumps({'Status': 'Failed', 'ErrMsg' : errmsg}))
+        resp = HttpResponse(json.dumps({'Status': 'Failed', 'ErrMsg': errmsg}))
     else:
         resp = HttpResponse(json.dumps({'Status': 'OK'}))
 
     return resp
 
+
 '''
 This POST-back view will add a user - specified by email - to the list of editors for
 the specified course
 '''
+@expect_json
 @login_required
 @ensure_csrf_cookie
-def add_user(request, org, course, name):
+def add_user(request, location):
     email = request.POST["email"]
 
-    if email=='':
+    if email == '':
         return create_json_response('Please specify an email address.')
 
-    location = ['i4x', org, course, 'course', name]
-    
     # check that logged in user has admin permissions to this course
-    if not has_access(request.user, location, role=ADMIN_ROLE_NAME):
+    if not has_access(request.user, location, role=INSTRUCTOR_ROLE_NAME):
         raise PermissionDenied()
-    
+
     user = get_user_by_email(email)
-    
+
     # user doesn't exist?!? Return error.
     if user is None:
         return create_json_response('Could not find user by email address \'{0}\'.'.format(email))
@@ -581,30 +902,759 @@ def add_user(request, org, course, name):
         return create_json_response('User {0} has registered but has not yet activated his/her account.'.format(email))
 
     # ok, we're cool to add to the course group
-    add_user_to_course_group(request.user, user, location, EDITOR_ROLE_NAME)
+    add_user_to_course_group(request.user, user, location, STAFF_ROLE_NAME)
 
     return create_json_response()
 
+
 '''
 This POST-back view will remove a user - specified by email - from the list of editors for
 the specified course
 '''
+@expect_json
 @login_required
 @ensure_csrf_cookie
-def remove_user(request, org, course, name):
+def remove_user(request, location):
     email = request.POST["email"]
 
-    location = ['i4x', org, course, 'course', name]
-    
     # check that logged in user has admin permissions on this course
-    if not has_access(request.user, location, role=ADMIN_ROLE_NAME):
+    if not has_access(request.user, location, role=INSTRUCTOR_ROLE_NAME):
         raise PermissionDenied()
 
     user = get_user_by_email(email)
     if user is None:
         return create_json_response('Could not find user by email address \'{0}\'.'.format(email))
 
-    remove_user_from_course_group(request.user, user, location, EDITOR_ROLE_NAME)
+    # make sure we're not removing ourselves
+    if user.id == request.user.id:
+        raise PermissionDenied()
+
+    remove_user_from_course_group(request.user, user, location, STAFF_ROLE_NAME)
 
     return create_json_response()
 
+
+# points to the temporary course landing page with log in and sign up
+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):
+
+    location = get_location_and_verify_access(request, org, course, coursename)
+
+    course = modulestore().get_item(location)
+
+    return render_to_response('static-pages.html', {
+        'active_tab': 'pages',
+        'context_course': course,
+    })
+
+
+def edit_static(request, org, course, coursename):
+    return render_to_response('edit-static-page.html', {})
+
+
+@login_required
+@expect_json
+def reorder_static_tabs(request):
+    tabs = request.POST['tabs']
+    course = get_course_for_item(tabs[0])
+
+    if not has_access(request.user, course.location):
+        raise PermissionDenied()
+
+    # get list of existing static tabs in course
+    # make sure they are the same lengths (i.e. the number of passed in tabs equals the number
+    # that we know about) otherwise we can drop some!
+
+    existing_static_tabs = [t for t in course.tabs if t['type'] == 'static_tab']
+    if len(existing_static_tabs) != len(tabs):
+        return HttpResponseBadRequest()
+
+    # load all reference tabs, return BadRequest if we can't find any of them
+    tab_items = []
+    for tab in tabs:
+        item = modulestore('direct').get_item(Location(tab))
+        if item is None:
+            return HttpResponseBadRequest()
+
+        tab_items.append(item)
+
+    # now just go through the existing course_tabs and re-order the static tabs
+    reordered_tabs = []
+    static_tab_idx = 0
+    for tab in course.tabs:
+        if tab['type'] == 'static_tab':
+            reordered_tabs.append({'type': 'static_tab',
+                'name': tab_items[static_tab_idx].display_name,
+                'url_slug': tab_items[static_tab_idx].location.name})
+            static_tab_idx += 1
+        else:
+            reordered_tabs.append(tab)
+
+
+    # OK, re-assemble the static tabs in the new order
+    course.tabs = reordered_tabs
+    modulestore('direct').update_metadata(course.location, own_metadata(course))
+    return HttpResponse()
+
+
+@login_required
+@ensure_csrf_cookie
+def edit_tabs(request, org, course, coursename):
+    location = ['i4x', org, course, 'course', coursename]
+    course_item = modulestore().get_item(location)
+    static_tabs_loc = Location('i4x', org, course, 'static_tab', None)
+
+    # check that logged in user has permissions to this item
+    if not has_access(request.user, location):
+        raise PermissionDenied()
+
+    # see tabs have been uninitialized (e.g. supporing courses created before tab support in studio)
+    if course_item.tabs is None or len(course_item.tabs) == 0:
+        initialize_course_tabs(course_item)
+
+    # first get all static tabs from the tabs list
+    # we do this because this is also the order in which items are displayed in the LMS
+    static_tabs_refs = [t for t in course_item.tabs if t['type'] == 'static_tab']
+
+    static_tabs = []
+    for static_tab_ref in static_tabs_refs:
+        static_tab_loc = Location(location)._replace(category='static_tab', name=static_tab_ref['url_slug'])
+        static_tabs.append(modulestore('direct').get_item(static_tab_loc))
+
+    components = [
+        static_tab.location.url()
+        for static_tab
+        in static_tabs
+    ]
+
+    return render_to_response('edit-tabs.html', {
+        'active_tab': 'pages',
+        'context_course': course_item,
+        'components': components
+        })
+
+
+def not_found(request):
+    return render_to_response('error.html', {'error': '404'})
+
+
+def server_error(request):
+    return render_to_response('error.html', {'error': '500'})
+
+
+@login_required
+@ensure_csrf_cookie
+def course_info(request, org, course, name, provided_id=None):
+    """
+    Send models and views as well as html for editing the course info to the client.
+
+    org, course, name: Attributes of the Location for the item to edit
+    """
+    location = get_location_and_verify_access(request, org, course, name)
+
+    course_module = modulestore().get_item(location)
+
+    # get current updates
+    location = ['i4x', org, course, 'course_info', "updates"]
+
+    return render_to_response('course_info.html', {
+        'active_tab': 'courseinfo-tab',
+        'context_course': course_module,
+        'url_base': "/" + org + "/" + course + "/",
+        'course_updates': json.dumps(get_course_updates(location)),
+        'handouts_location': Location(['i4x', org, course, 'course_info', 'handouts']).url()
+    })
+
+
+@expect_json
+@login_required
+@ensure_csrf_cookie
+def course_info_updates(request, org, course, provided_id=None):
+    """
+    restful CRUD operations on course_info updates.
+
+    org, course: Attributes of the Location for the item to edit
+    provided_id should be none if it's new (create) and a composite of the update db id + index otherwise.
+    """
+    # ??? No way to check for access permission afaik
+    # get current updates
+    location = ['i4x', org, course, 'course_info', "updates"]
+
+    # Hmmm, provided_id is coming as empty string on create whereas I believe it used to be None :-(
+    # Possibly due to my removing the seemingly redundant pattern in urls.py
+    if provided_id == '':
+        provided_id = None
+
+    # check that logged in user has permissions to this item
+    if not has_access(request.user, location):
+        raise PermissionDenied()
+
+    real_method = get_request_method(request)
+
+    if request.method == 'GET':
+        return HttpResponse(json.dumps(get_course_updates(location)),
+            mimetype="application/json")
+    elif real_method == 'DELETE':
+        try:
+            return HttpResponse(json.dumps(delete_course_update(location,
+                request.POST, provided_id)), mimetype="application/json")
+        except:
+            return HttpResponseBadRequest("Failed to delete",
+                content_type="text/plain")
+    elif request.method == 'POST':
+        try:
+            return HttpResponse(json.dumps(update_course_updates(location,
+                request.POST, provided_id)), mimetype="application/json")
+        except:
+            return HttpResponseBadRequest("Failed to save",
+                content_type="text/plain")
+
+
+@expect_json
+@login_required
+@ensure_csrf_cookie
+def module_info(request, module_location):
+    location = Location(module_location)
+
+    # check that logged in user has permissions to this item
+    if not has_access(request.user, location):
+        raise PermissionDenied()
+
+    real_method = get_request_method(request)
+
+    rewrite_static_links = request.GET.get('rewrite_url_links', 'True') in ['True', 'true']
+    logging.debug('rewrite_static_links = {0} {1}'.format(request.GET.get('rewrite_url_links', 'False'), rewrite_static_links))
+
+    # check that logged in user has permissions to this item
+    if not has_access(request.user, location):
+        raise PermissionDenied()
+
+    if real_method == 'GET':
+        return HttpResponse(json.dumps(get_module_info(get_modulestore(location), location, rewrite_static_links=rewrite_static_links)), mimetype="application/json")
+    elif real_method == 'POST' or real_method == 'PUT':
+        return HttpResponse(json.dumps(set_module_info(get_modulestore(location), location, request.POST)), mimetype="application/json")
+    else:
+        return HttpResponseBadRequest()
+
+
+@login_required
+@ensure_csrf_cookie
+def get_course_settings(request, org, course, name):
+    """
+    Send models and views as well as html for editing the course settings to the client.
+
+    org, course, name: Attributes of the Location for the item to edit
+    """
+    location = get_location_and_verify_access(request, org, course, name)
+
+    course_module = modulestore().get_item(location)
+
+    return render_to_response('settings.html', {
+        'context_course': course_module,
+        'course_location': location,
+        'details_url': reverse(course_settings_updates,
+                               kwargs={"org": org,
+                                       "course": course,
+                                       "name": name,
+                                       "section": "details"})
+    })
+
+
+@login_required
+@ensure_csrf_cookie
+def course_config_graders_page(request, org, course, name):
+    """
+    Send models and views as well as html for editing the course settings to the client.
+
+    org, course, name: Attributes of the Location for the item to edit
+    """
+    location = get_location_and_verify_access(request, org, course, name)
+
+    course_module = modulestore().get_item(location)
+    course_details = CourseGradingModel.fetch(location)
+
+    return render_to_response('settings_graders.html', {
+        'context_course': course_module,
+        'course_location' : location,
+        '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 = get_location_and_verify_access(request, org, course, name)
+
+    course_module = modulestore().get_item(location)
+
+    return render_to_response('settings_advanced.html', {
+        'context_course': course_module,
+        'course_location' : location,
+        'advanced_dict' : json.dumps(CourseMetadata.fetch(location)),
+    })
+
+
+@expect_json
+@login_required
+@ensure_csrf_cookie
+def course_settings_updates(request, org, course, name, section):
+    """
+    restful CRUD operations on course settings. This differs from get_course_settings by communicating purely
+    through json (not rendering any html) and handles section level operations rather than whole page.
+
+    org, course: Attributes of the Location for the item to edit
+    section: one of details, faculty, grading, problems, discussions
+    """
+    get_location_and_verify_access(request, org, course, name)
+
+    if section == 'details':
+        manager = CourseDetails
+    elif section == 'grading':
+        manager = CourseGradingModel
+    else: return
+
+    if request.method == 'GET':
+        # Cannot just do a get w/o knowing the course name :-(
+        return HttpResponse(json.dumps(manager.fetch(Location(['i4x', org, course, 'course', name])), cls=CourseSettingsEncoder),
+                            mimetype="application/json")
+    elif request.method == 'POST':  # post or put, doesn't matter.
+        return HttpResponse(json.dumps(manager.update_from_json(request.POST), cls=CourseSettingsEncoder),
+                            mimetype="application/json")
+
+
+@expect_json
+@login_required
+@ensure_csrf_cookie
+def course_grader_updates(request, org, course, name, grader_index=None):
+    """
+    restful CRUD operations on course_info updates. This differs from get_course_settings by communicating purely
+    through json (not rendering any html) and handles section level operations rather than whole page.
+
+    org, course: Attributes of the Location for the item to edit
+    """
+
+    location = get_location_and_verify_access(request, org, course, name)
+
+    real_method = get_request_method(request)
+
+    if real_method == 'GET':
+        # Cannot just do a get w/o knowing the course name :-(
+        return HttpResponse(json.dumps(CourseGradingModel.fetch_grader(Location(location), grader_index)),
+                            mimetype="application/json")
+    elif real_method == "DELETE":
+        # ??? Should this return anything? Perhaps success fail?
+        CourseGradingModel.delete_grader(Location(location), grader_index)
+        return HttpResponse()
+    elif request.method == 'POST':   # post or put, doesn't matter.
+        return HttpResponse(json.dumps(CourseGradingModel.update_grader_from_json(Location(location), 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 = get_location_and_verify_access(request, org, course, name)
+
+    real_method = get_request_method(request)
+        
+    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")
+
+
+@ensure_csrf_cookie
+@login_required
+def get_checklists(request, org, course, name):
+    """
+    Send models, views, and html for displaying the course checklists.
+
+    org, course, name: Attributes of the Location for the item to edit
+    """
+    location = get_location_and_verify_access(request, org, course, name)
+
+    modulestore = get_modulestore(location)
+    course_module = modulestore.get_item(location)
+    new_course_template = Location('i4x', 'edx', 'templates', 'course', 'Empty')
+    template_module = modulestore.get_item(new_course_template)
+
+    # If course was created before checklists were introduced, copy them over from the template.
+    copied = False
+    if not course_module.checklists:
+        course_module.checklists = template_module.checklists
+        copied = True
+
+    checklists, modified = expand_checklist_action_urls(course_module)
+    if copied or modified:
+        modulestore.update_metadata(location, own_metadata(course_module))
+    return render_to_response('checklists.html',
+        {
+            'context_course': course_module,
+            'checklists': checklists
+        })
+
+
+@ensure_csrf_cookie
+@login_required
+def update_checklist(request, org, course, name, checklist_index=None):
+    """
+    restful CRUD operations on course checklists. The payload is a json rep of
+    the modified checklist. For PUT or POST requests, the index of the
+    checklist being modified must be included; the returned payload will
+    be just that one checklist. For GET requests, the returned payload
+    is a json representation of the list of all checklists.
+
+    org, course, name: Attributes of the Location for the item to edit
+    """
+    location = get_location_and_verify_access(request, org, course, name)
+    modulestore = get_modulestore(location)
+    course_module = modulestore.get_item(location)
+
+    real_method = get_request_method(request)
+    if real_method == 'POST' or real_method == 'PUT':
+        if checklist_index is not None and 0 <= int(checklist_index) < len(course_module.checklists):
+            index = int(checklist_index)
+            course_module.checklists[index] = json.loads(request.body)
+            checklists, modified = expand_checklist_action_urls(course_module)
+            modulestore.update_metadata(location, own_metadata(course_module))
+            return HttpResponse(json.dumps(checklists[index]), mimetype="application/json")
+        else:
+            return HttpResponseBadRequest(
+                "Could not save checklist state because the checklist index was out of range or unspecified.",
+                content_type="text/plain")
+    elif request.method == 'GET':
+        # In the JavaScript view initialize method, we do a fetch to get all the checklists.
+        checklists, modified = expand_checklist_action_urls(course_module)
+        if modified:
+            modulestore.update_metadata(location, own_metadata(course_module))
+        return HttpResponse(json.dumps(checklists), mimetype="application/json")
+    else:
+        return HttpResponseBadRequest("Unsupported request.", content_type="text/plain")
+
+
+def expand_checklist_action_urls(course_module):
+    """
+    Gets the checklists out of the course module and expands their action urls
+    if they have not yet been expanded.
+
+    Returns the checklists with modified urls, as well as a boolean
+    indicating whether or not the checklists were modified.
+    """
+    checklists = course_module.checklists
+    modified = False
+    for checklist in checklists:
+        if not checklist.get('action_urls_expanded', False):
+            for item in checklist.get('items'):
+                item['action_url'] = get_url_reverse(item.get('action_url'), course_module)
+            checklist['action_urls_expanded'] = True
+            modified = True
+
+    return checklists, modified
+
+
+@login_required
+@ensure_csrf_cookie
+def asset_index(request, org, course, name):
+    """
+    Display an editable asset library
+
+    org, course, name: Attributes of the Location for the item to edit
+    """
+    location = get_location_and_verify_access(request, org, course, name)
+
+    upload_asset_callback_url = reverse('upload_asset', kwargs={
+        'org': org,
+        'course': course,
+        'coursename': name
+    })
+
+    course_module = modulestore().get_item(location)
+
+    course_reference = StaticContent.compute_location(org, course, name)
+    assets = contentstore().get_all_content_for_course(course_reference)
+
+    # sort in reverse upload date order
+    assets = sorted(assets, key=lambda asset: asset['uploadDate'], reverse=True)
+
+    thumbnails = contentstore().get_all_content_thumbnails_for_course(course_reference)
+    asset_display = []
+    for asset in assets:
+        id = asset['_id']
+        display_info = {}
+        display_info['displayname'] = asset['displayname']
+        display_info['uploadDate'] = get_date_display(asset['uploadDate'])
+
+        asset_location = StaticContent.compute_location(id['org'], id['course'], id['name'])
+        display_info['url'] = StaticContent.get_url_path_from_location(asset_location)
+
+        # note, due to the schema change we may not have a 'thumbnail_location' in the result set
+        _thumbnail_location = asset.get('thumbnail_location', None)
+        thumbnail_location = Location(_thumbnail_location) if _thumbnail_location is not None else None
+        display_info['thumb_url'] = StaticContent.get_url_path_from_location(thumbnail_location) if thumbnail_location is not None else None
+
+        asset_display.append(display_info)
+
+    return render_to_response('asset_index.html', {
+        'active_tab': 'assets',
+        'context_course': course_module,
+        'assets': asset_display,
+        'upload_asset_callback_url': upload_asset_callback_url
+    })
+
+
+# points to the temporary edge page
+def edge(request):
+    return render_to_response('university_profiles/edge.html', {})
+
+
+@login_required
+@expect_json
+def create_new_course(request):
+
+    if settings.MITX_FEATURES.get('DISABLE_COURSE_CREATION', False) and not request.user.is_staff:
+        raise PermissionDenied()
+
+    # This logic is repeated in xmodule/modulestore/tests/factories.py
+    # so if you change anything here, you need to also change it there.
+    # TODO: write a test that creates two courses, one with the factory and
+    # the other with this method, then compare them to make sure they are
+    # equivalent.
+    template = Location(request.POST['template'])
+    org = request.POST.get('org')
+    number = request.POST.get('number')
+    display_name = request.POST.get('display_name')
+
+    try:
+        dest_location = Location('i4x', org, number, 'course', Location.clean(display_name))
+    except InvalidLocationError as e:
+        return HttpResponse(json.dumps({'ErrMsg': "Unable to create course '" + display_name + "'.\n\n" + e.message}))
+
+    # see if the course already exists
+    existing_course = None
+    try:
+        existing_course = modulestore('direct').get_item(dest_location)
+    except ItemNotFoundError:
+        pass
+
+    if existing_course is not None:
+        return HttpResponse(json.dumps({'ErrMsg': 'There is already a course defined with this name.'}))
+
+    course_search_location = ['i4x', dest_location.org, dest_location.course, 'course', None]
+    courses = modulestore().get_items(course_search_location)
+
+    if len(courses) > 0:
+        return HttpResponse(json.dumps({'ErrMsg': 'There is already a course defined with the same organization and course number.'}))
+
+    new_course = modulestore('direct').clone_item(template, dest_location)
+
+    if display_name is not None:
+        new_course.display_name = display_name
+
+    # set a default start date to now
+    new_course.start = time.gmtime()
+
+    initialize_course_tabs(new_course)
+
+    create_all_course_groups(request.user, new_course.location)
+
+    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
+    # at least a list populated with the minimal times
+    # @TODO: I don't like the fact that the presentation tier is away of these data related constraints, let's find a better
+    # place for this. Also rather than using a simple list of dictionaries a nice class model would be helpful here
+
+    # This logic is repeated in xmodule/modulestore/tests/factories.py
+    # so if you change anything here, you need to also change it there.
+    course.tabs = [{"type": "courseware"},
+        {"type": "course_info", "name": "Course Info"},
+        {"type": "discussion", "name": "Discussion"},
+        {"type": "wiki", "name": "Wiki"},
+        {"type": "progress", "name": "Progress"}]
+
+    modulestore('direct').update_metadata(course.location.url(), own_metadata(course))
+
+
+@ensure_csrf_cookie
+@login_required
+def import_course(request, org, course, name):
+
+    location = get_location_and_verify_access(request, org, course, name)
+
+    if request.method == 'POST':
+        filename = request.FILES['course-data'].name
+
+        if not filename.endswith('.tar.gz'):
+            return HttpResponse(json.dumps({'ErrMsg': 'We only support uploading a .tar.gz file.'}))
+
+        data_root = path(settings.GITHUB_REPO_ROOT)
+
+        course_subdir = "{0}-{1}-{2}".format(org, course, name)
+        course_dir = data_root / course_subdir
+        if not course_dir.isdir():
+            os.mkdir(course_dir)
+
+        temp_filepath = course_dir / filename
+
+        logging.debug('importing course to {0}'.format(temp_filepath))
+
+        # stream out the uploaded files in chunks to disk
+        temp_file = open(temp_filepath, 'wb+')
+        for chunk in request.FILES['course-data'].chunks():
+            temp_file.write(chunk)
+        temp_file.close()
+
+        tf = tarfile.open(temp_filepath)
+        tf.extractall(course_dir + '/')
+
+        # find the 'course.xml' file
+
+        for r, d, f in os.walk(course_dir):
+            for files in f:
+                if files == 'course.xml':
+                    break
+            if files == 'course.xml':
+                break
+
+        if files != 'course.xml':
+            return HttpResponse(json.dumps({'ErrMsg': 'Could not find the course.xml file in the package.'}))
+
+        logging.debug('found course.xml at {0}'.format(r))
+
+        if r != course_dir:
+            for fname in os.listdir(r):
+                shutil.move(r / fname, course_dir)
+
+        module_store, course_items = import_from_xml(modulestore('direct'), settings.GITHUB_REPO_ROOT,
+            [course_subdir], load_error_modules=False, static_content_store=contentstore(), target_location_namespace=Location(location))
+
+        # we can blow this away when we're done importing.
+        shutil.rmtree(course_dir)
+
+        logging.debug('new course at {0}'.format(course_items[0].location))
+
+        create_all_course_groups(request.user, course_items[0].location)
+
+        return HttpResponse(json.dumps({'Status': 'OK'}))
+    else:
+        course_module = modulestore().get_item(location)
+
+        return render_to_response('import.html', {
+            'context_course': course_module,
+            'active_tab': 'import',
+            'successful_import_redirect_url': get_url_reverse('CourseOutline', course_module)
+        })
+
+
+@ensure_csrf_cookie
+@login_required
+def generate_export_course(request, org, course, name):
+    location = get_location_and_verify_access(request, org, course, name)
+
+    loc = Location(location)
+    export_file = NamedTemporaryFile(prefix=name + '.', suffix=".tar.gz")
+
+    root_dir = path(mkdtemp())
+
+    # export out to a tempdir
+
+    logging.debug('root = {0}'.format(root_dir))
+
+    export_to_xml(modulestore('direct'), contentstore(), loc, root_dir, name)
+    # filename = root_dir / name + '.tar.gz'
+
+    logging.debug('tar file being generated at {0}'.format(export_file.name))
+    tf = tarfile.open(name=export_file.name, mode='w:gz')
+    tf.add(root_dir / name, arcname=name)
+    tf.close()
+
+    # remove temp dir
+    shutil.rmtree(root_dir / name)
+
+    wrapper = FileWrapper(export_file)
+    response = HttpResponse(wrapper, content_type='application/x-tgz')
+    response['Content-Disposition'] = 'attachment; filename=%s' % os.path.basename(export_file.name)
+    response['Content-Length'] = os.path.getsize(export_file.name)
+    return response
+
+
+@ensure_csrf_cookie
+@login_required
+def export_course(request, org, course, name):
+
+    location = get_location_and_verify_access(request, org, course, name)
+
+    course_module = modulestore().get_item(location)
+
+    return render_to_response('export.html', {
+        'context_course': course_module,
+        'active_tab': 'export',
+        '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
+    console logs don't get distracted :-)
+    '''
+    return HttpResponse(True)
+
+
+def render_404(request):
+    return HttpResponseNotFound(render_to_string('404.html', {}))
+
+
+def render_500(request):
+    return HttpResponseServerError(render_to_string('500.html', {}))
+
+
+def get_location_and_verify_access(request, org, course, name):
+    """
+    Create the location tuple verify that the user has permissions
+    to view the location. Returns the location.
+    """
+    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()
+
+    return location
+
+
+def get_request_method(request):
+    """
+    Using HTTP_X_HTTP_METHOD_OVERRIDE, in the request metadata, determine
+    what type of request came from the client, and return it.
+    """
+    # 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
+
+    return real_method

cms/djangoapps/github_sync/__init__.py

@@ -1,125 +0,0 @@
-import logging
-import os
-
-from django.conf import settings
-from fs.osfs import OSFS
-from git import Repo, PushInfo
-
-from xmodule.modulestore.xml_importer import import_from_xml
-from xmodule.modulestore.django import modulestore
-from collections import namedtuple
-
-from .exceptions import GithubSyncError, InvalidRepo
-
-log = logging.getLogger(__name__)
-
-RepoSettings = namedtuple('RepoSettings', 'path branch origin')
-
-
-def sync_all_with_github():
-    """
-    Sync all defined repositories from github
-    """
-    for repo_name in settings.REPOS:
-        sync_with_github(load_repo_settings(repo_name))
-
-
-def sync_with_github(repo_settings):
-    """
-    Sync specified repository from github
-
-    repo_settings: A RepoSettings defining which repo to sync
-    """
-    revision, course = import_from_github(repo_settings)
-    export_to_github(course, "Changes from cms import of revision %s" % revision, "CMS <cms@edx.org>")
-
-
-def setup_repo(repo_settings):
-    """
-    Reset the local github repo specified by repo_settings
-
-    repo_settings (RepoSettings): The settings for the repo to reset
-    """
-    course_dir = repo_settings.path
-    repo_path = settings.GITHUB_REPO_ROOT / course_dir
-
-    if not os.path.isdir(repo_path):
-        Repo.clone_from(repo_settings.origin, repo_path)
-
-    git_repo = Repo(repo_path)
-    origin = git_repo.remotes.origin
-    origin.fetch()
-
-    # Do a hard reset to the remote branch so that we have a clean import
-    git_repo.git.checkout(repo_settings.branch)
-
-    return git_repo
-
-
-def load_repo_settings(course_dir):
-    """
-    Returns the repo_settings for the course stored in course_dir
-    """
-    if course_dir not in settings.REPOS:
-        raise InvalidRepo(course_dir)
-
-    return RepoSettings(course_dir, **settings.REPOS[course_dir])
-
-
-def import_from_github(repo_settings):
-    """
-    Imports data into the modulestore based on the XML stored on github
-    """
-    course_dir = repo_settings.path
-    git_repo = setup_repo(repo_settings)
-    git_repo.head.reset('origin/%s' % repo_settings.branch, index=True, working_tree=True)
-
-    module_store = import_from_xml(modulestore(),
-                                   settings.GITHUB_REPO_ROOT, course_dirs=[course_dir])
-    return git_repo.head.commit.hexsha, module_store.courses[course_dir]
-
-
-def export_to_github(course, commit_message, author_str=None):
-    '''
-    Commit any changes to the specified course with given commit message,
-    and push to github (if MITX_FEATURES['GITHUB_PUSH'] is True).
-    If author_str is specified, uses it in the commit.
-    '''
-    course_dir = course.metadata.get('data_dir', course.location.course)
-    try:
-        repo_settings = load_repo_settings(course_dir)
-    except InvalidRepo:
-        log.warning("Invalid repo {0}, not exporting data to xml".format(course_dir))
-        return
-
-    git_repo = setup_repo(repo_settings)
-
-    fs = OSFS(git_repo.working_dir)
-    xml = course.export_to_xml(fs)
-
-    with fs.open('course.xml', 'w') as course_xml:
-        course_xml.write(xml)
-
-    if git_repo.is_dirty():
-        git_repo.git.add(A=True)
-        if author_str is not None:
-            git_repo.git.commit(m=commit_message, author=author_str)
-        else:
-            git_repo.git.commit(m=commit_message)
-
-        origin = git_repo.remotes.origin
-        if settings.MITX_FEATURES['GITHUB_PUSH']:
-            push_infos = origin.push()
-            if len(push_infos) > 1:
-                log.error('Unexpectedly pushed multiple heads: {infos}'.format(
-                    infos="\n".join(str(info.summary) for info in push_infos)
-                ))
-
-            if push_infos[0].flags & PushInfo.ERROR:
-                log.error('Failed push: flags={p.flags}, local_ref={p.local_ref}, '
-                          'remote_ref_string={p.remote_ref_string}, '
-                          'remote_ref={p.remote_ref}, old_commit={p.old_commit}, '
-                          'summary={p.summary})'.format(p=push_infos[0]))
-                raise GithubSyncError('Failed to push: {info}'.format(
-                    info=str(push_infos[0].summary)
-                ))

cms/djangoapps/github_sync/exceptions.py

@@ -1,6 +0,0 @@
-class GithubSyncError(Exception):
-    pass
-
-
-class InvalidRepo(Exception):
-    pass

cms/djangoapps/github_sync/management/commands/sync_with_github.py

@@ -1,14 +0,0 @@
-###
-### Script for syncing CMS with defined github repos
-###
-
-from django.core.management.base import NoArgsCommand
-from github_sync import sync_all_with_github
-
-
-class Command(NoArgsCommand):
-    help = \
-'''Sync the CMS with the defined github repos'''
-
-    def handle_noargs(self, **options):
-        sync_all_with_github()

cms/djangoapps/github_sync/tests/__init__.py

@@ -1,108 +0,0 @@
-from django.test import TestCase
-from path import path
-import shutil
-from github_sync import (
-    import_from_github, export_to_github, load_repo_settings,
-    sync_all_with_github, sync_with_github
-)
-from git import Repo
-from django.conf import settings
-from xmodule.modulestore.django import modulestore
-from xmodule.modulestore import Location
-from override_settings import override_settings
-from github_sync.exceptions import GithubSyncError
-from mock import patch, Mock
-
-REPO_DIR = settings.GITHUB_REPO_ROOT / 'local_repo'
-WORKING_DIR = path(settings.TEST_ROOT)
-REMOTE_DIR = WORKING_DIR / 'remote_repo'
-
-
-@override_settings(REPOS={
-    'local_repo': {
-        'origin': REMOTE_DIR,
-        'branch': 'master',
-    }
-})
-class GithubSyncTestCase(TestCase):
-
-    def cleanup(self):
-        shutil.rmtree(REPO_DIR, ignore_errors=True)
-        shutil.rmtree(REMOTE_DIR, ignore_errors=True)
-        modulestore().collection.drop()
-
-    def setUp(self):
-        # make sure there's no stale data lying around
-        self.cleanup()
-
-        shutil.copytree('common/test/data/toy', REMOTE_DIR)
-
-        remote = Repo.init(REMOTE_DIR)
-        remote.git.add(A=True)
-        remote.git.commit(m='Initial commit')
-        remote.git.config("receive.denyCurrentBranch", "ignore")
-
-        self.import_revision, self.import_course = import_from_github(load_repo_settings('local_repo'))
-
-    def tearDown(self):
-        self.cleanup()
-
-    def test_initialize_repo(self):
-        """
-        Test that importing from github will create a repo if the repo doesn't already exist
-        """
-        self.assertEquals(1, len(Repo(REPO_DIR).head.reference.log()))
-
-    def test_import_contents(self):
-        """
-        Test that the import loads the correct course into the modulestore
-        """
-        self.assertEquals('Toy Course', self.import_course.metadata['display_name'])
-        self.assertIn(
-            Location('i4x://edX/toy/chapter/Overview'),
-            [child.location for child in self.import_course.get_children()])
-        self.assertEquals(2, len(self.import_course.get_children()))
-
-    @patch('github_sync.sync_with_github')
-    def test_sync_all_with_github(self, sync_with_github):
-        sync_all_with_github()
-        sync_with_github.assert_called_with(load_repo_settings('local_repo'))
-
-    def test_sync_with_github(self):
-        with patch('github_sync.import_from_github', Mock(return_value=(Mock(), Mock()))) as import_from_github:
-            with patch('github_sync.export_to_github') as export_to_github:
-                settings = load_repo_settings('local_repo')
-                sync_with_github(settings)
-                import_from_github.assert_called_with(settings)
-                export_to_github.assert_called
-
-    @override_settings(MITX_FEATURES={'GITHUB_PUSH': False})
-    def test_export_no_pash(self):
-        """
-        Test that with the GITHUB_PUSH feature disabled, no content is pushed to the remote
-        """
-        export_to_github(self.import_course, 'Test no-push')
-        self.assertEquals(1, Repo(REMOTE_DIR).head.commit.count())
-
-    @override_settings(MITX_FEATURES={'GITHUB_PUSH': True})
-    def test_export_push(self):
-        """
-        Test that with GITHUB_PUSH enabled, content is pushed to the remote
-        """
-        self.import_course.metadata['display_name'] = 'Changed display name'
-        export_to_github(self.import_course, 'Test push')
-        self.assertEquals(2, Repo(REMOTE_DIR).head.commit.count())
-
-    @override_settings(MITX_FEATURES={'GITHUB_PUSH': True})
-    def test_export_conflict(self):
-        """
-        Test that if there is a conflict when pushing to the remote repo, nothing is pushed and an exception is raised
-        """
-        self.import_course.metadata['display_name'] = 'Changed display name'
-
-        remote = Repo(REMOTE_DIR)
-        remote.git.commit(allow_empty=True, m="Testing conflict commit")
-
-        self.assertRaises(GithubSyncError, export_to_github, self.import_course, 'Test push')
-        self.assertEquals(2, remote.head.reference.commit.count())
-        self.assertEquals("Testing conflict commit\n", remote.head.reference.commit.message)

cms/djangoapps/github_sync/tests/test_views.py

@@ -1,43 +0,0 @@
-import json
-from django.test.client import Client
-from django.test import TestCase
-from mock import patch
-from override_settings import override_settings
-from github_sync import load_repo_settings
-
-
-@override_settings(REPOS={'repo': {'branch': 'branch', 'origin': 'origin'}})
-class PostReceiveTestCase(TestCase):
-    def setUp(self):
-        self.client = Client()
-
-    @patch('github_sync.views.import_from_github')
-    def test_non_branch(self, import_from_github):
-        self.client.post('/github_service_hook', {'payload': json.dumps({
-            'ref': 'refs/tags/foo'})
-        })
-        self.assertFalse(import_from_github.called)
-
-    @patch('github_sync.views.import_from_github')
-    def test_non_watched_repo(self, import_from_github):
-        self.client.post('/github_service_hook', {'payload': json.dumps({
-            'ref': 'refs/heads/branch',
-            'repository': {'name': 'bad_repo'}})
-        })
-        self.assertFalse(import_from_github.called)
-
-    @patch('github_sync.views.import_from_github')
-    def test_non_tracked_branch(self, import_from_github):
-        self.client.post('/github_service_hook', {'payload': json.dumps({
-            'ref': 'refs/heads/non_branch',
-            'repository': {'name': 'repo'}})
-        })
-        self.assertFalse(import_from_github.called)
-
-    @patch('github_sync.views.import_from_github')
-    def test_tracked_branch(self, import_from_github):
-        self.client.post('/github_service_hook', {'payload': json.dumps({
-            'ref': 'refs/heads/branch',
-            'repository': {'name': 'repo'}})
-        })
-        import_from_github.assert_called_with(load_repo_settings('repo'))

cms/djangoapps/github_sync/views.py

@@ -1,51 +0,0 @@
-import logging
-import json
-
-from django.http import HttpResponse
-from django.conf import settings
-from django_future.csrf import csrf_exempt
-
-from . import import_from_github, load_repo_settings
-
-log = logging.getLogger()
-
-
-@csrf_exempt
-def github_post_receive(request):
-    """
-    This view recieves post-receive requests from github whenever one of
-    the watched repositiories changes.
-
-    It is responsible for updating the relevant local git repo,
-    importing the new version of the course (if anything changed),
-    and then pushing back to github any changes that happened as part of the
-    import.
-
-    The github request format is described here: https://help.github.com/articles/post-receive-hooks
-    """
-
-    payload = json.loads(request.POST['payload'])
-
-    ref = payload['ref']
-
-    if not ref.startswith('refs/heads/'):
-        log.info('Ignore changes to non-branch ref %s' % ref)
-        return HttpResponse('Ignoring non-branch')
-
-    branch_name = ref.replace('refs/heads/', '', 1)
-
-    repo_name = payload['repository']['name']
-
-    if repo_name not in settings.REPOS:
-        log.info('No repository matching %s found' % repo_name)
-        return HttpResponse('No Repo Found')
-
-    repo = load_repo_settings(repo_name)
-
-    if repo.branch != branch_name:
-        log.info('Ignoring changes to non-tracked branch %s in repo %s' % (branch_name, repo_name))
-        return HttpResponse('Ignoring non-tracked branch')
-
-    import_from_github(repo)
-
-    return HttpResponse('Push received')

cms/djangoapps/models/settings/course_details.py

@@ -0,0 +1,188 @@
+from xmodule.modulestore import Location
+from xmodule.modulestore.exceptions import ItemNotFoundError
+from xmodule.modulestore.inheritance import own_metadata
+import json
+from json.encoder import JSONEncoder
+import time
+from contentstore.utils import get_modulestore
+from models.settings import course_grading
+from contentstore.utils import update_item
+from xmodule.fields import Date
+import re
+import logging
+
+
+class CourseDetails(object):
+    def __init__(self, location):
+        self.course_location = location    # a Location obj
+        self.start_date = None  # 'start'
+        self.end_date = None    # 'end'
+        self.enrollment_start = None
+        self.enrollment_end = None
+        self.syllabus = None    # a pdf file asset
+        self.overview = ""      # html to render as the overview
+        self.intro_video = None    # a video pointer
+        self.effort = None      # int hours/week
+
+    @classmethod
+    def fetch(cls, course_location):
+        """
+        Fetch the course details for the given course from persistence and return a CourseDetails model.
+        """
+        if not isinstance(course_location, Location):
+            course_location = Location(course_location)
+
+        course = cls(course_location)
+
+        descriptor = get_modulestore(course_location).get_item(course_location)
+
+        course.start_date = descriptor.start
+        course.end_date = descriptor.end
+        course.enrollment_start = descriptor.enrollment_start
+        course.enrollment_end = descriptor.enrollment_end
+
+        temploc = course_location._replace(category='about', name='syllabus')
+        try:
+            course.syllabus = get_modulestore(temploc).get_item(temploc).data
+        except ItemNotFoundError:
+            pass
+
+        temploc = temploc._replace(name='overview')
+        try:
+            course.overview = get_modulestore(temploc).get_item(temploc).data
+        except ItemNotFoundError:
+            pass
+
+        temploc = temploc._replace(name='effort')
+        try:
+            course.effort = get_modulestore(temploc).get_item(temploc).data
+        except ItemNotFoundError:
+            pass
+
+        temploc = temploc._replace(name='video')
+        try:
+            raw_video = get_modulestore(temploc).get_item(temploc).data
+            course.intro_video = CourseDetails.parse_video_tag(raw_video)
+        except ItemNotFoundError:
+            pass
+
+        return course
+
+    @classmethod
+    def update_from_json(cls, jsondict):
+        """
+        Decode the json into CourseDetails and save any changed attrs to the db
+        """
+        ## TODO make it an error for this to be undefined & for it to not be retrievable from modulestore
+        course_location = jsondict['course_location']
+        ## Will probably want to cache the inflight courses because every blur generates an update
+        descriptor = get_modulestore(course_location).get_item(course_location)
+
+        dirty = False
+
+        # In the descriptor's setter, the date is converted to JSON using Date's to_json method.
+        # Calling to_json on something that is already JSON doesn't work. Since reaching directly
+        # into the model is nasty, convert the JSON Date to a Python date, which is what the
+        # setter expects as input.
+        date = Date()
+
+        if 'start_date' in jsondict:
+            converted = date.from_json(jsondict['start_date'])
+        else:
+            converted = None
+        if converted != descriptor.start:
+            dirty = True
+            descriptor.start = converted
+
+        if 'end_date' in jsondict:
+            converted = date.from_json(jsondict['end_date'])
+        else:
+            converted = None
+
+        if converted != descriptor.end:
+            dirty = True
+            descriptor.end = converted
+
+        if 'enrollment_start' in jsondict:
+            converted = date.from_json(jsondict['enrollment_start'])
+        else:
+            converted = None
+
+        if converted != descriptor.enrollment_start:
+            dirty = True
+            descriptor.enrollment_start = converted
+
+        if 'enrollment_end' in jsondict:
+            converted = date.from_json(jsondict['enrollment_end'])
+        else:
+            converted = None
+
+        if converted != descriptor.enrollment_end:
+            dirty = True
+            descriptor.enrollment_end = converted
+
+        if dirty:
+            get_modulestore(course_location).update_metadata(course_location, own_metadata(descriptor))
+
+        # NOTE: below auto writes to the db w/o verifying that any of the fields actually changed
+        # to make faster, could compare against db or could have client send over a list of which fields changed.
+        temploc = Location(course_location)._replace(category='about', name='syllabus')
+        update_item(temploc, jsondict['syllabus'])
+
+        temploc = temploc._replace(name='overview')
+        update_item(temploc, jsondict['overview'])
+
+        temploc = temploc._replace(name='effort')
+        update_item(temploc, jsondict['effort'])
+
+        temploc = temploc._replace(name='video')
+        recomposed_video_tag = CourseDetails.recompose_video_tag(jsondict['intro_video'])
+        update_item(temploc, recomposed_video_tag)
+
+        # 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 CourseDetails.fetch(course_location)
+
+    @staticmethod
+    def parse_video_tag(raw_video):
+        """
+        Because the client really only wants the author to specify the youtube key, that's all we send to and get from the client.
+        The problem is that the db stores the html markup as well (which, of course, makes any sitewide changes to how we do videos
+        next to impossible.)
+        """
+        if not raw_video:
+            return None
+
+        keystring_matcher = re.search('(?<=embed/)[a-zA-Z0-9_-]+', raw_video)
+        if keystring_matcher is None:
+            keystring_matcher = re.search('<?=\d+:[a-zA-Z0-9_-]+', raw_video)
+
+        if keystring_matcher:
+            return keystring_matcher.group(0)
+        else:
+            logging.warn("ignoring the content because it doesn't not conform to expected pattern: " + raw_video)
+            return None
+
+    @staticmethod
+    def recompose_video_tag(video_key):
+        # TODO should this use a mako template? Of course, my hope is that this is a short-term workaround for the db not storing
+        # the right thing
+        result = None
+        if video_key:
+            result = '<iframe width="560" height="315" src="http://www.youtube.com/embed/' + \
+                video_key + '?autoplay=1&rel=0" frameborder="0" allowfullscreen=""></iframe>'
+        return result
+
+
+
+# TODO move to a more general util? Is there a better way to do the isinstance model check?
+class CourseSettingsEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, CourseDetails) or isinstance(obj, course_grading.CourseGradingModel):
+            return obj.__dict__
+        elif isinstance(obj, Location):
+            return obj.dict()
+        elif isinstance(obj, time.struct_time):
+            return Date().to_json(obj)
+        else:
+            return JSONEncoder.default(self, obj)

cms/djangoapps/models/settings/course_grading.py

@@ -0,0 +1,283 @@
+from xmodule.modulestore import Location
+from contentstore.utils import get_modulestore
+from datetime import timedelta
+
+
+class CourseGradingModel(object):
+    """
+    Basically a DAO and Model combo for CRUD operations pertaining to grading policy.
+    """
+    def __init__(self, course_descriptor):
+        self.course_location = course_descriptor.location
+        self.graders = [CourseGradingModel.jsonize_grader(i, grader) for i, grader in enumerate(course_descriptor.raw_grader)]   # weights transformed to ints [0..100]
+        self.grade_cutoffs = course_descriptor.grade_cutoffs
+        self.grace_period = CourseGradingModel.convert_set_grace_period(course_descriptor)
+
+    @classmethod
+    def fetch(cls, course_location):
+        """
+        Fetch the course details for the given course from persistence and return a CourseDetails model.
+        """
+        if not isinstance(course_location, Location):
+            course_location = Location(course_location)
+
+        descriptor = get_modulestore(course_location).get_item(course_location)
+
+        model = cls(descriptor)
+        return model
+
+    @staticmethod
+    def fetch_grader(course_location, index):
+        """
+        Fetch the course's nth grader
+        Returns an empty dict if there's no such grader.
+        """
+        if not isinstance(course_location, Location):
+            course_location = Location(course_location)
+
+        descriptor = get_modulestore(course_location).get_item(course_location)
+        # # ??? it would be good if these had the course_location in them so that they stand alone sufficiently
+        # # but that would require not using CourseDescriptor's field directly. Opinions?
+
+        index = int(index)
+        if len(descriptor.raw_grader) > index:
+            return CourseGradingModel.jsonize_grader(index, descriptor.raw_grader[index])
+
+        # return empty model
+        else:
+            return {
+                    "id": index,
+                    "type": "",
+                    "min_count": 0,
+                    "drop_count": 0,
+                    "short_label": None,
+                    "weight": 0
+                }
+
+    @staticmethod
+    def fetch_cutoffs(course_location):
+        """
+        Fetch the course's grade cutoffs.
+        """
+        if not isinstance(course_location, Location):
+            course_location = Location(course_location)
+
+        descriptor = get_modulestore(course_location).get_item(course_location)
+        return descriptor.grade_cutoffs
+
+    @staticmethod
+    def fetch_grace_period(course_location):
+        """
+        Fetch the course's default grace period.
+        """
+        if not isinstance(course_location, Location):
+            course_location = Location(course_location)
+
+        descriptor = get_modulestore(course_location).get_item(course_location)
+        return {'grace_period': CourseGradingModel.convert_set_grace_period(descriptor)}
+
+    @staticmethod
+    def update_from_json(jsondict):
+        """
+        Decode the json into CourseGradingModel and save any changes. Returns the modified model.
+        Probably not the usual path for updates as it's too coarse grained.
+        """
+        course_location = jsondict['course_location']
+        descriptor = get_modulestore(course_location).get_item(course_location)
+
+        graders_parsed = [CourseGradingModel.parse_grader(jsonele) for jsonele in jsondict['graders']]
+
+        descriptor.raw_grader = graders_parsed
+        descriptor.grade_cutoffs = jsondict['grade_cutoffs']
+
+        get_modulestore(course_location).update_item(course_location, descriptor._model_data._kvs._data)
+        CourseGradingModel.update_grace_period_from_json(course_location, jsondict['grace_period'])
+
+        return CourseGradingModel.fetch(course_location)
+
+
+    @staticmethod
+    def update_grader_from_json(course_location, grader):
+        """
+        Create or update the grader of the given type (string key) for the given course. Returns the modified
+        grader which is a full model on the client but not on the server (just a dict)
+        """
+        if not isinstance(course_location, Location):
+            course_location = Location(course_location)
+
+        descriptor = get_modulestore(course_location).get_item(course_location)
+        # # ??? it would be good if these had the course_location in them so that they stand alone sufficiently
+        # # but that would require not using CourseDescriptor's field directly. Opinions?
+
+        # parse removes the id; so, grab it before parse
+        index = int(grader.get('id', len(descriptor.raw_grader)))
+        grader = CourseGradingModel.parse_grader(grader)
+
+        if index < len(descriptor.raw_grader):
+            descriptor.raw_grader[index] = grader
+        else:
+            descriptor.raw_grader.append(grader)
+
+        get_modulestore(course_location).update_item(course_location, descriptor._model_data._kvs._data)
+
+        return CourseGradingModel.jsonize_grader(index, descriptor.raw_grader[index])
+
+    @staticmethod
+    def update_cutoffs_from_json(course_location, cutoffs):
+        """
+        Create or update the grade cutoffs for the given course. Returns sent in cutoffs (ie., no extra
+        db fetch).
+        """
+        if not isinstance(course_location, Location):
+            course_location = Location(course_location)
+
+        descriptor = get_modulestore(course_location).get_item(course_location)
+        descriptor.grade_cutoffs = cutoffs
+        get_modulestore(course_location).update_item(course_location, descriptor._model_data._kvs._data)
+
+        return cutoffs
+
+
+    @staticmethod
+    def update_grace_period_from_json(course_location, graceperiodjson):
+        """
+        Update the course's default grace period. Incoming dict is {hours: h, minutes: m} possibly as a
+        grace_period entry in an enclosing dict. It is also safe to call this method with a value of
+        None for graceperiodjson.
+        """
+        if not isinstance(course_location, Location):
+            course_location = Location(course_location)
+
+        # Before a graceperiod has ever been created, it will be None (once it has been
+        # created, it cannot be set back to None).
+        if graceperiodjson is not None:
+            if 'grace_period' in graceperiodjson:
+                graceperiodjson = graceperiodjson['grace_period']
+
+            # lms requires these to be in a fixed order
+            grace_timedelta = timedelta(**graceperiodjson)
+
+            descriptor = get_modulestore(course_location).get_item(course_location)
+            descriptor.lms.graceperiod = grace_timedelta
+            get_modulestore(course_location).update_metadata(course_location, descriptor._model_data._kvs._metadata)
+
+    @staticmethod
+    def delete_grader(course_location, index):
+        """
+        Delete the grader of the given type from the given course.
+        """
+        if not isinstance(course_location, Location):
+            course_location = Location(course_location)
+
+        descriptor = get_modulestore(course_location).get_item(course_location)
+        index = int(index)
+        if index < len(descriptor.raw_grader):
+            del descriptor.raw_grader[index]
+            # force propagation to definition
+            descriptor.raw_grader = descriptor.raw_grader
+            get_modulestore(course_location).update_item(course_location, descriptor._model_data._kvs._data)
+
+    # NOTE cannot delete cutoffs. May be useful to reset
+    @staticmethod
+    def delete_cutoffs(course_location, cutoffs):
+        """
+        Resets the cutoffs to the defaults
+        """
+        if not isinstance(course_location, Location):
+            course_location = Location(course_location)
+
+        descriptor = get_modulestore(course_location).get_item(course_location)
+        descriptor.grade_cutoffs = descriptor.defaut_grading_policy['GRADE_CUTOFFS']
+        get_modulestore(course_location).update_item(course_location, descriptor._model_data._kvs._data)
+
+        return descriptor.grade_cutoffs
+
+    @staticmethod
+    def delete_grace_period(course_location):
+        """
+        Delete the course's default grace period.
+        """
+        if not isinstance(course_location, Location):
+            course_location = Location(course_location)
+
+        descriptor = get_modulestore(course_location).get_item(course_location)
+        del descriptor.lms.graceperiod
+        get_modulestore(course_location).update_metadata(course_location, descriptor._model_data._kvs._metadata)
+
+    @staticmethod
+    def get_section_grader_type(location):
+        if not isinstance(location, Location):
+            location = Location(location)
+
+        descriptor = get_modulestore(location).get_item(location)
+        return {
+                "graderType": descriptor.lms.format if descriptor.lms.format is not None else 'Not Graded',
+                "location": location,
+                "id": 99   # just an arbitrary value to
+                }
+
+    @staticmethod
+    def update_section_grader_type(location, jsondict):
+        if not isinstance(location, Location):
+            location = Location(location)
+
+        descriptor = get_modulestore(location).get_item(location)
+        if 'graderType' in jsondict and jsondict['graderType'] != u"Not Graded":
+            descriptor.lms.format = jsondict.get('graderType')
+            descriptor.lms.graded = True
+        else:
+            del descriptor.lms.format
+            del descriptor.lms.graded
+
+        get_modulestore(location).update_metadata(location, descriptor._model_data._kvs._metadata)
+
+
+    @staticmethod
+    def convert_set_grace_period(descriptor):
+        # 5 hours 59 minutes 59 seconds => converted to iso format
+        rawgrace = descriptor.lms.graceperiod
+        if rawgrace:
+            hours_from_days = rawgrace.days*24
+            seconds = rawgrace.seconds
+            hours_from_seconds = int(seconds / 3600)
+            hours = hours_from_days + hours_from_seconds
+            seconds -= hours_from_seconds * 3600
+            minutes = int(seconds / 60)
+            seconds -= minutes * 60
+
+            graceperiod = {'hours': 0, 'minutes': 0, 'seconds': 0}
+            if hours > 0:
+                graceperiod['hours'] = hours
+
+            if minutes > 0:
+                graceperiod['minutes'] = minutes
+
+            if seconds > 0:
+                graceperiod['seconds'] = seconds
+
+            return graceperiod
+        else:
+            return None
+
+    @staticmethod
+    def parse_grader(json_grader):
+        # manual to clear out kruft
+        result = {
+                    "type": json_grader["type"],
+                    "min_count": int(json_grader.get('min_count', 0)),
+                    "drop_count": int(json_grader.get('drop_count', 0)),
+                    "short_label": json_grader.get('short_label', None),
+                    "weight": float(json_grader.get('weight', 0)) / 100.0
+                }
+
+        return result
+
+    @staticmethod
+    def jsonize_grader(i, grader):
+        grader['id'] = i
+        if grader['weight']:
+            grader['weight'] *= 100
+        if not 'short_label' in grader:
+            grader['short_label'] = ""
+
+        return grader

cms/djangoapps/models/settings/course_metadata.py

@@ -0,0 +1,91 @@
+from xmodule.modulestore import Location
+from contentstore.utils import get_modulestore
+from xmodule.x_module import XModuleDescriptor
+from xmodule.modulestore.inheritance import own_metadata
+from xblock.core import Scope
+from xmodule.course_module import CourseDescriptor
+
+
+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.
+    '''
+    FILTERED_LIST = XModuleDescriptor.system_metadata_fields + ['start', 'end',
+        'enrollment_start', 'enrollment_end', 'tabs', 'graceperiod', 'checklists']
+
+    @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 field in descriptor.fields + descriptor.lms.fields:
+            if field.scope != Scope.settings:
+                continue
+
+            if field.name not in cls.FILTERED_LIST:
+                course[field.name] = field.read_json(descriptor)
+
+        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 in cls.FILTERED_LIST:
+                continue
+
+            if hasattr(descriptor, k) and getattr(descriptor, k) != v:
+                dirty = True
+                value = getattr(CourseDescriptor, k).from_json(v)
+                setattr(descriptor, k, value)
+            elif hasattr(descriptor.lms, k) and getattr(descriptor.lms, k) != k:
+                dirty = True
+                value = getattr(CourseDescriptor.lms, k).from_json(v)
+                setattr(descriptor.lms, k, value)
+
+        if dirty:
+            get_modulestore(course_location).update_metadata(course_location,
+                own_metadata(descriptor))
+
+        # Could just generate and return a course obj w/o doing any db reads,
+        # but I put the reads in as a means to confirm it persisted correctly
+        return cls.fetch(course_location)
+
+    @classmethod
+    def delete_key(cls, course_location, payload):
+        '''
+        Remove the given metadata key(s) from the course. payload can be a
+        single key or [key..]
+        '''
+        descriptor = get_modulestore(course_location).get_item(course_location)
+
+        for key in payload['deleteKeys']:
+            if hasattr(descriptor, key):
+                delattr(descriptor, key)
+            elif hasattr(descriptor.lms, key):
+                delattr(descriptor.lms, key)
+
+        get_modulestore(course_location).update_metadata(course_location,
+            own_metadata(descriptor))
+
+        return cls.fetch(course_location)

cms/envs/acceptance.py

@@ -0,0 +1,38 @@
+"""
+This config file extends the test environment configuration
+so that we can run the lettuce acceptance tests.
+"""
+from .test import *
+
+# You need to start the server in debug mode,
+# otherwise the browser will not render the pages correctly
+DEBUG = True
+
+# Show the courses that are in the data directory
+COURSES_ROOT = ENV_ROOT / "data"
+DATA_DIR = COURSES_ROOT
+# MODULESTORE = {
+#     'default': {
+#         'ENGINE': 'xmodule.modulestore.xml.XMLModuleStore',
+#         'OPTIONS': {
+#             'data_dir': DATA_DIR,
+#             'default_class': 'xmodule.hidden_module.HiddenDescriptor',
+#         }
+#     }
+# }
+
+# Set this up so that rake lms[acceptance] and running the
+# harvest command both use the same (test) database
+# which they can flush without messing up your dev db
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.sqlite3',
+        'NAME': ENV_ROOT / "db" / "test_mitx.db",
+        'TEST_NAME': ENV_ROOT / "db" / "test_mitx.db",
+    }
+}
+
+# Include the lettuce app for acceptance testing, including the 'harvest' django-admin command
+INSTALLED_APPS += ('lettuce.django',)
+LETTUCE_APPS = ('contentstore',)
+LETTUCE_SERVER_PORT = 8001

cms/envs/aws.py

@@ -3,10 +3,24 @@ This is the default template for our main set of AWS servers.
 """
 import json
 
-from .logsettings import get_logger_config
 from .common import *
+from logsettings import get_logger_config
+import os
 
-############################### ALWAYS THE SAME ################################
+# specified as an environment variable.  Typically this is set
+# in the service's upstart script and corresponds exactly to the service name.
+# Service variants apply config differences via env and auth JSON files,
+# the names of which correspond to the variant.
+SERVICE_VARIANT = os.environ.get('SERVICE_VARIANT', None)
+
+# when not variant is specified we attempt to load an unvaried
+# config set.
+CONFIG_PREFIX = ""
+
+if SERVICE_VARIANT:
+    CONFIG_PREFIX = SERVICE_VARIANT + "."
+
+############### ALWAYS THE SAME ################################
 DEBUG = False
 TEMPLATE_DEBUG = False
 
@@ -14,9 +28,9 @@ EMAIL_BACKEND = 'django_ses.SESBackend'
 SESSION_ENGINE = 'django.contrib.sessions.backends.cache'
 DEFAULT_FILE_STORAGE = 'storages.backends.s3boto.S3BotoStorage'
 
-########################### NON-SECURE ENV CONFIG ##############################
+############# NON-SECURE ENV CONFIG ##############################
 # Things like server locations, ports, etc.
-with open(ENV_ROOT / "cms.env.json") as env_file:
+with open(ENV_ROOT / CONFIG_PREFIX + "env.json") as env_file:
     ENV_TOKENS = json.load(env_file)
 
 LMS_BASE = ENV_TOKENS.get('LMS_BASE')
@@ -27,24 +41,27 @@ LOG_DIR = ENV_TOKENS['LOG_DIR']
 
 CACHES = ENV_TOKENS['CACHES']
 
+SESSION_COOKIE_DOMAIN = ENV_TOKENS.get('SESSION_COOKIE_DOMAIN')
+
 for feature, value in ENV_TOKENS.get('MITX_FEATURES', {}).items():
     MITX_FEATURES[feature] = value
 
 LOGGING = get_logger_config(LOG_DIR,
                             logging_env=ENV_TOKENS['LOGGING_ENV'],
                             syslog_addr=(ENV_TOKENS['SYSLOG_SERVER'], 514),
-                            debug=False)
+                            debug=False,
+                            service_variant=SERVICE_VARIANT)
 
-with open(ENV_ROOT / "repos.json") as repos_file:
-    REPOS = json.load(repos_file)
-
-
-############################## SECURE AUTH ITEMS ###############################
+################ SECURE AUTH ITEMS ###############################
 # Secret things: passwords, access keys, etc.
-with open(ENV_ROOT / "cms.auth.json") as auth_file:
+with open(ENV_ROOT / CONFIG_PREFIX + "auth.json") as auth_file:
     AUTH_TOKENS = json.load(auth_file)
 
 AWS_ACCESS_KEY_ID = AUTH_TOKENS["AWS_ACCESS_KEY_ID"]
 AWS_SECRET_ACCESS_KEY = AUTH_TOKENS["AWS_SECRET_ACCESS_KEY"]
 DATABASES = AUTH_TOKENS['DATABASES']
 MODULESTORE = AUTH_TOKENS['MODULESTORE']
+CONTENTSTORE = AUTH_TOKENS['CONTENTSTORE']
+
+# Datadog for events!
+DATADOG_API = AUTH_TOKENS.get("DATADOG_API")

cms/envs/common.py

@@ -20,23 +20,22 @@ Longer TODO:
 """
 
 import sys
-import tempfile
 import os.path
 import os
-import errno
-import glob2
 import lms.envs.common
-import hashlib
-from collections import defaultdict
 from path import path
+from xmodule.static_content import write_descriptor_styles, write_descriptor_js, write_module_js, write_module_styles
 
 ############################ FEATURE CONFIGURATION #############################
 
 MITX_FEATURES = {
     'USE_DJANGO_PIPELINE': True,
     'GITHUB_PUSH': False,
-    'ENABLE_DISCUSSION_SERVICE': False
+    'ENABLE_DISCUSSION_SERVICE': False,
+    'AUTH_USE_MIT_CERTIFICATES': False,
+    'STUB_VIDEO_FOR_TESTING': False,   # do not display video when running automated acceptance tests
 }
+ENABLE_JASMINE = False
 
 # needed to use lms student app
 GENERATE_RANDOM_USER_CREDENTIALS = False
@@ -59,7 +58,8 @@ sys.path.append(COMMON_ROOT / 'lib')
 
 ############################# WEB CONFIGURATION #############################
 # This is where we stick our compiled template files.
-MAKO_MODULE_DIR = tempfile.mkdtemp('mako')
+from tempdir import mkdtemp_clean
+MAKO_MODULE_DIR = mkdtemp_clean('mako')
 MAKO_TEMPLATES = {}
 MAKO_TEMPLATES['main'] = [
     PROJECT_ROOT / 'templates',
@@ -70,14 +70,12 @@ MAKO_TEMPLATES['main'] = [
 for namespace, template_dirs in lms.envs.common.MAKO_TEMPLATES.iteritems():
     MAKO_TEMPLATES['lms.' + namespace] = template_dirs
 
-TEMPLATE_DIRS = (
-    PROJECT_ROOT / "templates",
-)
+TEMPLATE_DIRS = MAKO_TEMPLATES['main']
 
 MITX_ROOT_URL = ''
 
-LOGIN_REDIRECT_URL = MITX_ROOT_URL + '/login'
-LOGIN_URL = MITX_ROOT_URL + '/login'
+LOGIN_REDIRECT_URL = MITX_ROOT_URL + '/signin'
+LOGIN_URL = MITX_ROOT_URL + '/signin'
 
 
 TEMPLATE_CONTEXT_PROCESSORS = (
@@ -90,10 +88,6 @@ TEMPLATE_CONTEXT_PROCESSORS = (
 
 LMS_BASE = None
 
-################################# Jasmine ###################################
-JASMINE_TEST_DIRECTORY = PROJECT_ROOT + '/static/coffee'
-
-
 #################### CAPA External Code Evaluation #############################
 XQUEUE_INTERFACE = {
     'url': 'http://localhost:8888',
@@ -171,13 +165,6 @@ STATICFILES_DIRS = [
 # This is how you would use the textbook images locally
 #    ("book", ENV_ROOT / "book_images")
 ]
-if os.path.isdir(GITHUB_REPO_ROOT):
-    STATICFILES_DIRS += [
-        # TODO (cpennington): When courses aren't loaded from github, remove this
-        (course_dir, GITHUB_REPO_ROOT / course_dir)
-        for course_dir in os.listdir(GITHUB_REPO_ROOT)
-        if os.path.isdir(GITHUB_REPO_ROOT / course_dir)
-    ]
 
 # Locale/Internationalization
 TIME_ZONE = 'America/New_York'  # http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
@@ -185,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'
 
@@ -194,71 +184,36 @@ STATICFILES_STORAGE = 'pipeline.storage.PipelineCachedStorage'
 
 # Load javascript and css from all of the available descriptors, and
 # prep it for use in pipeline js
-from xmodule.x_module import XModuleDescriptor
 from xmodule.raw_module import RawDescriptor
 from xmodule.error_module import ErrorDescriptor
-js_file_dir = PROJECT_ROOT / "static" / "coffee" / "module"
-css_file_dir = PROJECT_ROOT / "static" / "sass" / "module"
-module_styles_path = css_file_dir / "_module-styles.scss"
+from rooted_paths import rooted_glob, remove_root
 
-for dir_ in (js_file_dir, css_file_dir):
-    try:
-        os.makedirs(dir_)
-    except OSError as exc:
-        if exc.errno == errno.EEXIST:
-            pass
-        else:
-            raise
+write_descriptor_styles(PROJECT_ROOT / "static/sass/descriptor", [RawDescriptor, ErrorDescriptor])
+write_module_styles(PROJECT_ROOT / "static/sass/module", [RawDescriptor, ErrorDescriptor])
 
-js_fragments = set()
-css_fragments = defaultdict(set)
-for _, descriptor in XModuleDescriptor.load_classes() + [(None, RawDescriptor), (None, ErrorDescriptor)]:
-    descriptor_js = descriptor.get_javascript()
-    module_js = descriptor.module_class.get_javascript()
-
-    for filetype in ('coffee', 'js'):
-        for idx, fragment in enumerate(descriptor_js.get(filetype, []) + module_js.get(filetype, [])):
-            js_fragments.add((idx, filetype, fragment))
-
-    for class_ in (descriptor, descriptor.module_class):
-        fragments = class_.get_css()
-        for filetype in ('sass', 'scss', 'css'):
-            for idx, fragment in enumerate(fragments.get(filetype, [])):
-                css_fragments[idx, filetype, fragment].add(class_.__name__)
-
-module_js_sources = []
-for idx, filetype, fragment in sorted(js_fragments):
-    path = js_file_dir / "{idx}-{hash}.{type}".format(
-        idx=idx,
-        hash=hashlib.md5(fragment).hexdigest(),
-        type=filetype)
-    with open(path, 'w') as js_file:
-        js_file.write(fragment)
-    module_js_sources.append(path.replace(PROJECT_ROOT / "static/", ""))
-
-css_imports = defaultdict(set)
-for (idx, filetype, fragment), classes in sorted(css_fragments.items()):
-    fragment_name = "{idx}-{hash}.{type}".format(
-        idx=idx,
-        hash=hashlib.md5(fragment).hexdigest(),
-        type=filetype)
-    # Prepend _ so that sass just includes the files into a single file
-    with open(css_file_dir / '_' + fragment_name, 'w') as js_file:
-        js_file.write(fragment)
-
-    for class_ in classes:
-        css_imports[class_].add(fragment_name)
-
-with open(module_styles_path, 'w') as module_styles:
-    for class_, fragment_names in css_imports.items():
-        imports = "\n".join('@import "{0}";'.format(name) for name in fragment_names)
-        module_styles.write(""".xmodule_{class_} {{ {imports} }}""".format(
-            class_=class_, imports=imports
-        ))
+descriptor_js = remove_root(
+    PROJECT_ROOT / 'static',
+    write_descriptor_js(
+        PROJECT_ROOT / "static/coffee/descriptor",
+        [RawDescriptor, ErrorDescriptor]
+    )
+)
+module_js = remove_root(
+    PROJECT_ROOT / 'static',
+    write_module_js(
+        PROJECT_ROOT / "static/coffee/module",
+        [RawDescriptor, ErrorDescriptor]
+    )
+)
 
 PIPELINE_CSS = {
     'base-style': {
-        'source_filenames': ['sass/base-style.scss'],
+        'source_filenames': [
+            'js/vendor/CodeMirror/codemirror.css',
+            'css/vendor/ui-lightness/jquery-ui-1.8.22.custom.css',
+            'css/vendor/jquery.qtip.min.css',
+            'sass/base-style.scss'
+        ],
         'output_filename': 'css/cms-base-style.css',
     },
 }
@@ -267,23 +222,18 @@ PIPELINE_ALWAYS_RECOMPILE = ['sass/base-style.scss']
 
 PIPELINE_JS = {
     'main': {
-        'source_filenames': [
-            pth.replace(COMMON_ROOT / 'static/', '')
-            for pth
-            in glob2.glob(COMMON_ROOT / 'static/coffee/src/**/*.coffee')
-        ] + [
-            pth.replace(PROJECT_ROOT / 'static/', '')
-            for pth
-            in glob2.glob(PROJECT_ROOT / 'static/coffee/src/**/*.coffee')
-        ],
+        'source_filenames': sorted(
+            rooted_glob(COMMON_ROOT / 'static/', 'coffee/src/**/*.coffee') +
+            rooted_glob(PROJECT_ROOT / 'static/', 'coffee/src/**/*.coffee')
+        ) + ['js/hesitate.js', 'js/base.js'],
         'output_filename': 'js/cms-application.js',
     },
     'module-js': {
-        'source_filenames': module_js_sources,
+        'source_filenames': descriptor_js + module_js,
         'output_filename': 'js/cms-modules.js',
     },
     'spec': {
-        'source_filenames': [pth.replace(PROJECT_ROOT / 'static/', '') for pth in glob2.glob(PROJECT_ROOT / 'static/coffee/spec/**/*.coffee')],
+        'source_filenames': sorted(rooted_glob(PROJECT_ROOT / 'static/', 'coffee/spec/**/*.coffee')),
         'output_filename': 'js/cms-spec.js'
     }
 }
@@ -326,13 +276,14 @@ INSTALLED_APPS = (
     # For CMS
     'contentstore',
     'auth',
-    'github_sync',
     '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',
-
-    # For testing
-    'django_jasmine',
+    'static_replace',
 )

cms/envs/dev.py

@@ -2,29 +2,33 @@
 This config file runs the simplest dev environment"""
 
 from .common import *
-from .logsettings import get_logger_config
-
-import logging
-import sys
+from logsettings import get_logger_config
 
 DEBUG = True
 TEMPLATE_DEBUG = DEBUG
 LOGGING = get_logger_config(ENV_ROOT / "log",
                             logging_env="dev",
                             tracking_filename="tracking.log",
+                            dev_env=True,
                             debug=True)
 
+modulestore_options = {
+    'default_class': 'xmodule.raw_module.RawDescriptor',
+    'host': 'localhost',
+    'db': 'xmodule',
+    'collection': 'modulestore',
+    'fs_root': GITHUB_REPO_ROOT,
+    'render_template': 'mitxmako.shortcuts.render_to_string',
+}
+
 MODULESTORE = {
     'default': {
+        'ENGINE': 'xmodule.modulestore.mongo.DraftMongoModuleStore',
+        'OPTIONS': modulestore_options
+    },
+    'direct': {
         'ENGINE': 'xmodule.modulestore.mongo.MongoModuleStore',
-        'OPTIONS': {
-            'default_class': 'xmodule.raw_module.RawDescriptor',
-            'host': 'localhost',
-            'db': 'xmodule',
-            'collection': 'modulestore',
-            'fs_root': GITHUB_REPO_ROOT,
-            'render_template': 'mitxmako.shortcuts.render_to_string',
-        }
+        'OPTIONS': modulestore_options
     }
 }
 
@@ -34,7 +38,7 @@ CONTENTSTORE = {
     'ENGINE': 'xmodule.contentstore.mongo.MongoContentStore',
     'OPTIONS': {
         'host': 'localhost',
-        'db' : 'xcontent',
+        'db': 'xcontent',
     }
 }
 
@@ -42,11 +46,11 @@ CONTENTSTORE = {
 DATABASES = {
     'default': {
         'ENGINE': 'django.db.backends.sqlite3',
-        'NAME': ENV_ROOT / "db" / "cms.db",
+        'NAME': ENV_ROOT / "db" / "mitx.db",
     }
 }
 
-LMS_BASE = "http://localhost:8000"
+LMS_BASE = "localhost:8000"
 
 REPOS = {
     'edx4edx': {
@@ -92,8 +96,50 @@ CACHES = {
         'KEY_PREFIX': 'general',
         'VERSION': 4,
         'KEY_FUNCTION': 'util.memcache.safe_key',
+    },
+
+    'mongo_metadata_inheritance': {
+        'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
+        'LOCATION': '/var/tmp/mongo_metadata_inheritance',
+        'TIMEOUT': 300,
+        'KEY_FUNCTION': 'util.memcache.safe_key',
     }
 }
 
 # Make the keyedcache startup warnings go away
 CACHE_TIMEOUT = 0
+
+# Dummy secret key for dev
+SECRET_KEY = '85920908f28904ed733fe576320db18cabd7b6cd'
+
+################################ DEBUG TOOLBAR #################################
+INSTALLED_APPS += ('debug_toolbar', 'debug_toolbar_mongo')
+MIDDLEWARE_CLASSES += ('django_comment_client.utils.QueryCountDebugMiddleware',
+                       'debug_toolbar.middleware.DebugToolbarMiddleware',)
+INTERNAL_IPS = ('127.0.0.1',)
+
+DEBUG_TOOLBAR_PANELS = (
+    'debug_toolbar.panels.version.VersionDebugPanel',
+    'debug_toolbar.panels.timer.TimerDebugPanel',
+    'debug_toolbar.panels.settings_vars.SettingsVarsDebugPanel',
+    'debug_toolbar.panels.headers.HeaderDebugPanel',
+    'debug_toolbar.panels.request_vars.RequestVarsDebugPanel',
+    'debug_toolbar.panels.sql.SQLDebugPanel',
+    'debug_toolbar.panels.signals.SignalDebugPanel',
+    'debug_toolbar.panels.logger.LoggingPanel',
+    'debug_toolbar_mongo.panel.MongoDebugPanel',
+
+    #  Enabling the profiler has a weird bug as of django-debug-toolbar==0.9.4 and
+    #  Django=1.3.1/1.4 where requests to views get duplicated (your method gets
+    #  hit twice). So you can uncomment when you need to diagnose performance
+    #  problems, but you shouldn't leave it on.
+    #  'debug_toolbar.panels.profiling.ProfilingDebugPanel',
+    )
+
+DEBUG_TOOLBAR_CONFIG = {
+    'INTERCEPT_REDIRECTS': False
+}
+
+# To see stacktraces for MongoDB queries, set this to True.
+# Stacktraces slow down page loads drastically (for pages with lots of queries).
+DEBUG_TOOLBAR_MONGO_STACKTRACES = False

cms/envs/dev_ike.py

@@ -0,0 +1,14 @@
+# dev environment for ichuang/mit
+
+# FORCE_SCRIPT_NAME = '/cms'
+
+from .common import *
+from logsettings import get_logger_config
+from .dev import *
+import socket
+
+MITX_FEATURES['AUTH_USE_MIT_CERTIFICATES'] = True
+
+MITX_FEATURES['USE_DJANGO_PIPELINE'] = False      # don't recompile scss
+
+SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTOCOL', 'https')  	# django 1.4 for nginx ssl proxy

cms/envs/jasmine.py

@@ -0,0 +1,38 @@
+"""
+This configuration is used for running jasmine tests
+"""
+
+from .test import *
+from logsettings import get_logger_config
+
+ENABLE_JASMINE = True
+DEBUG = True
+
+LOGGING = get_logger_config(TEST_ROOT / "log",
+                            logging_env="dev",
+                            tracking_filename="tracking.log",
+                            dev_env=True,
+                            debug=True,
+                            local_loglevel='ERROR',
+                            console_loglevel='ERROR')
+
+PIPELINE_JS['js-test-source'] = {
+    'source_filenames': sum([
+        pipeline_group['source_filenames']
+        for group_name, pipeline_group
+        in PIPELINE_JS.items()
+        if group_name != 'spec'
+    ], []),
+    'output_filename': 'js/cms-test-source.js'
+}
+
+PIPELINE_JS['spec'] = {
+    'source_filenames': sorted(rooted_glob(PROJECT_ROOT / 'static/', 'coffee/spec/**/*.coffee')),
+    'output_filename': 'js/cms-spec.js'
+}
+
+JASMINE_TEST_DIRECTORY = PROJECT_ROOT + '/static/coffee'
+
+STATICFILES_DIRS.append(COMMON_ROOT / 'test' / 'phantom-jasmine' / 'lib')
+
+INSTALLED_APPS += ('django_jasmine', )

cms/envs/logsettings.py

@@ -1,96 +0,0 @@
-import os
-import os.path
-import platform
-import sys
-
-def get_logger_config(log_dir,
-                      logging_env="no_env",
-                      tracking_filename=None,
-                      syslog_addr=None,
-                      debug=False):
-    """Return the appropriate logging config dictionary. You should assign the
-    result of this to the LOGGING var in your settings. The reason it's done
-    this way instead of registering directly is because I didn't want to worry
-    about resetting the logging state if this is called multiple times when
-    settings are extended."""
-
-    # If we're given an explicit place to put tracking logs, we do that (say for
-    # debugging). However, logging is not safe for multiple processes hitting
-    # the same file. So if it's left blank, we dynamically create the filename
-    # based on the PID of this worker process.
-    if tracking_filename:
-        tracking_file_loc = os.path.join(log_dir, tracking_filename)
-    else:
-        pid = os.getpid() # So we can log which process is creating the log
-        tracking_file_loc = os.path.join(log_dir, "tracking_{0}.log".format(pid))
-
-    hostname = platform.node().split(".")[0]
-    syslog_format = ("[%(name)s][env:{logging_env}] %(levelname)s [{hostname} " +
-                     " %(process)d] [%(filename)s:%(lineno)d] - %(message)s").format(
-                        logging_env=logging_env, hostname=hostname)
-
-    handlers = ['console'] if debug else ['console', 'syslogger', 'newrelic']
-
-    return {
-        'version': 1,
-        'disable_existing_loggers': False,
-        'formatters' : {
-            'standard' : {
-                'format' : '%(asctime)s %(levelname)s %(process)d [%(name)s] %(filename)s:%(lineno)d - %(message)s',
-            },
-            'syslog_format' : { 'format' : syslog_format },
-            'raw' : { 'format' : '%(message)s' },
-        },
-        'handlers' : {
-            'console' : {
-                'level' : 'DEBUG' if debug else 'INFO',
-                'class' : 'logging.StreamHandler',
-                'formatter' : 'standard',
-                'stream' : sys.stdout,
-            },
-            'syslogger' : {
-                'level' : 'INFO',
-                'class' : 'logging.handlers.SysLogHandler',
-                'address' : syslog_addr,
-                'formatter' : 'syslog_format',
-            },
-            'tracking' : {
-                'level' : 'DEBUG',
-                'class' : 'logging.handlers.WatchedFileHandler',
-                'filename' : tracking_file_loc,
-                'formatter' : 'raw',
-            },
-            'newrelic' : {
-                'level': 'ERROR',
-                'class': 'newrelic_logging.NewRelicHandler',
-                'formatter': 'raw',
-            }
-        },
-        'loggers' : {
-            'django' : {
-                'handlers' : handlers,
-                'propagate' : True,
-                'level' : 'INFO'
-            },
-            'tracking' : {
-                'handlers' : ['tracking'],
-                'level' : 'DEBUG',
-                'propagate' : False,
-            },
-            '' : {
-                'handlers' : handlers,
-                'level' : 'DEBUG',
-                'propagate' : False
-            },
-            'mitx' : {
-                'handlers' : handlers,
-                'level' : 'DEBUG',
-                'propagate' : False
-            },
-            'keyedcache' : {
-                'handlers' : handlers,
-                'level' : 'DEBUG',
-                'propagate' : False
-            },
-        }
-    }

cms/envs/test.py

@@ -11,7 +11,6 @@ from .common import *
 import os
 from path import path
 
-
 # Nose Test Runner
 INSTALLED_APPS += ('django_nose',)
 NOSE_ARGS = ['--with-xunit']
@@ -19,12 +18,18 @@ TEST_RUNNER = 'django_nose.NoseTestSuiteRunner'
 
 TEST_ROOT = path('test_root')
 
+# Makes the tests run much faster...
+SOUTH_TESTS_MIGRATE = False   # To disable migrations and use syncdb instead
+
 # Want static files in the same dir for running on jenkins.
 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",
@@ -36,17 +41,31 @@ STATICFILES_DIRS += [
     if os.path.isdir(COMMON_TEST_DATA_ROOT / course_dir)
 ]
 
+modulestore_options = {
+    'default_class': 'xmodule.raw_module.RawDescriptor',
+    'host': 'localhost',
+    'db': 'test_xmodule',
+    'collection': 'modulestore',
+    'fs_root': GITHUB_REPO_ROOT,
+    'render_template': 'mitxmako.shortcuts.render_to_string',
+}
+
 MODULESTORE = {
     'default': {
         'ENGINE': 'xmodule.modulestore.mongo.MongoModuleStore',
-        'OPTIONS': {
-            'default_class': 'xmodule.raw_module.RawDescriptor',
-            'host': 'localhost',
-            'db': 'test_xmodule',
-            'collection': 'modulestore',
-            'fs_root': GITHUB_REPO_ROOT,
-            'render_template': 'mitxmako.shortcuts.render_to_string',
-        }
+        'OPTIONS': modulestore_options
+    },
+    'direct': {
+        'ENGINE': 'xmodule.modulestore.mongo.MongoModuleStore',
+        'OPTIONS': modulestore_options
+    }
+}
+
+CONTENTSTORE = {
+    'ENGINE': 'xmodule.contentstore.mongo.MongoContentStore',
+    'OPTIONS': {
+        'host': 'localhost',
+        'db': 'xcontent',
     }
 }
 
@@ -55,21 +74,12 @@ DATABASES = {
         'ENGINE': 'django.db.backends.sqlite3',
         'NAME': ENV_ROOT / "db" / "cms.db",
     },
-
-    # The following are for testing purposes...
-    'edX/toy/2012_Fall': {
-        'ENGINE': 'django.db.backends.sqlite3',
-        'NAME': ENV_ROOT / "db" / "course1.db",
-    },
-    
-    'edx/full/6.002_Spring_2012': {
-        'ENGINE': 'django.db.backends.sqlite3',
-        'NAME': ENV_ROOT / "db" / "course2.db",
-    }
 }
 
+LMS_BASE = "localhost:8000"
+
 CACHES = {
-    # This is the cache used for most things. Askbot will not work without a 
+    # This is the cache used for most things. Askbot will not work without a
     # functioning cache -- it relies on caching to load its settings in places.
     # In staging/prod envs, the sessions also live here.
     'default': {
@@ -88,5 +98,19 @@ CACHES = {
         'KEY_PREFIX': 'general',
         'VERSION': 4,
         'KEY_FUNCTION': 'util.memcache.safe_key',
+    },
+
+    'mongo_metadata_inheritance': {
+        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
+        'LOCATION': '/var/tmp/mongo_metadata_inheritance',
+        'TIMEOUT': 300,
+        'KEY_FUNCTION': 'util.memcache.safe_key',
     }
 }
+
+################### Make tests faster
+#http://slacy.com/blog/2012/04/make-your-tests-faster-in-django-1-4/
+PASSWORD_HASHERS = (
+    'django.contrib.auth.hashers.SHA1PasswordHasher',
+    'django.contrib.auth.hashers.MD5PasswordHasher',
+)

cms/manage.py

@@ -2,7 +2,7 @@
 from django.core.management import execute_manager
 import imp
 try:
-    imp.find_module('settings') # Assumed to be in the same directory.
+    imp.find_module('settings')   # Assumed to be in the same directory.
 except ImportError:
     import sys
     sys.stderr.write("Error: Can't find the file 'settings.py' in the directory containing %r. "

cms/one_time_startup.py

@@ -0,0 +1,14 @@
+from dogapi import dog_http_api, dog_stats_api
+from django.conf import settings
+from xmodule.modulestore.django import modulestore
+
+from django.core.cache import get_cache, InvalidCacheBackendError
+
+cache = get_cache('mongo_metadata_inheritance')
+for store_name in settings.MODULESTORE:
+    store = modulestore(store_name)
+    store.metadata_inheritance_cache = cache
+
+if hasattr(settings, 'DATADOG_API'):
+    dog_http_api.api_key = settings.DATADOG_API
+    dog_stats_api.start(api_key=settings.DATADOG_API, statsd=True)

cms/static/client_templates/advanced_entry.html

@@ -0,0 +1,11 @@
+<li class="field-group course-advanced-policy-list-item">
+	<div class="field is-not-editable text key" id="<%= key %>">
+		<label for="<%= keyUniqueId %>">Policy Key:</label>
+		<input readonly title="This field is disabled: policy keys cannot be edited." type="text" class="short policy-key" id="<%= keyUniqueId %>" value="<%= key %>" />
+  </div>
+  
+  <div class="field text value">
+    <label for="<%= valueUniqueId %>">Policy Value:</label>
+    <textarea class="json text" id="<%= valueUniqueId %>"><%= value %></textarea>
+  </div>
+</li>

cms/static/client_templates/checklist.html

@@ -0,0 +1,61 @@
+<% var allChecked = itemsChecked == items.length; %>
+<section
+    <% if (allChecked) { %>
+    class="course-checklist is-completed"
+    <% } else { %>
+    class="course-checklist"
+    <% } %>
+    id="<%= 'course-checklist' + checklistIndex %>">
+    <% var widthPercentage = 'width:' + percentChecked + '%;'; %>
+    <span class="viz viz-checklist-status"><span class="viz value viz-checklist-status-value" style="<%= widthPercentage %>">
+        <span class="int"><%= percentChecked %></span>% of checklist completed</span></span>
+    <header>
+        <h3 class="checklist-title title-2 is-selectable" title="Collapse/Expand this Checklist">
+            <i class="ss-icon ss-symbolicons-standard icon-arrow ui-toggle-expansion">&#x25BE;</i>
+            <%= checklistShortDescription %></h3>
+              <span class="checklist-status status">
+                Tasks Completed: <span class="status-count"><%= itemsChecked %></span>/<span class="status-amount"><%= items.length %></span>
+                <i class="ss-icon ss-symbolicons-standard icon-confirm">&#x2713;</i>
+              </span>
+    </header>
+
+    <ul class="list list-tasks">
+        <% var taskIndex = 0; %>
+        <% _.each(items, function(item) { %>
+            <% var checked = item['is_checked']; %>
+            <li
+            <% if (checked) { %>
+            class="task is-completed"
+            <% } else { %>
+            class="task"
+            <% } %>
+            >
+                <% var taskId = 'course-checklist' + checklistIndex + '-task' + taskIndex; %>
+                <input type="checkbox" class="task-input" data-checklist="<%= checklistIndex %>" data-task="<%= taskIndex %>"
+                name="<%= taskId %>" id="<%= taskId %>"
+                <% if (checked) { %>
+                checked="checked"
+                <% } %>
+                >
+                <label class="task-details" for="<%= taskId %>">
+                    <h4 class="task-name title title-3"><%= item['short_description'] %></h4>
+                    <p class="task-description"><%= item['long_description'] %></p>
+                </label>
+
+                <% if (item['action_text'] !== '' && item['action_url'] !== '') { %>
+                <ul class="list-actions task-actions">
+                    <li>
+                        <a href="<%= item['action_url'] %>" class="action action-primary"
+                        <% if (item['action_external']) { %>
+                        rel="external" title="This link will open in a new browser window/tab"
+                        <% } %>
+                        ><%= item['action_text'] %></a>
+                    </li>
+                </ul>
+                <% } %>
+            </li>
+
+        <% taskIndex+=1; }) %>
+
+    </ul>
+</section>

cms/static/client_templates/course_grade_policy.html

@@ -0,0 +1,37 @@
+<li class="field-group course-grading-assignment-list-item">
+  <div class="field text" id="field-course-grading-assignment-name">
+  	<label for="course-grading-assignment-name">Assignment Type	Name</label>
+  	<input type="text" class="long" id="course-grading-assignment-name" value="<%= model.get('type') %>" /> 
+  	<span class="tip tip-stacked">e.g. Homework, Midterm Exams</span> 
+  </div>
+
+  <div class="field text" id="field-course-grading-assignment-shortname">
+    <label for="course-grading-assignment-shortname">Abbreviation:</label>
+    <input type="text" class="short" id="course-grading-assignment-shortname" value="<%= model.get('short_label') %>" /> 
+    <span class="tip tip-inline">e.g. HW, Midterm</span>
+  </div>
+  
+  <div class="field text" id="field-course-grading-assignment-gradeweight">
+    <label for="course-grading-assignment-gradeweight">Weight of Total Grade</label>
+    <input type="text" class="short" id="course-grading-assignment-gradeweight" value = "<%= model.get('weight') %>" /> 
+    <span class="tip tip-inline">e.g. 25%</span>
+  </div>
+  
+  <div class="field text" id="field-course-grading-assignment-totalassignments">
+    <label for="course-grading-assignment-totalassignments">Total
+			Number</label>
+    <input type="text" class="short" id="course-grading-assignment-totalassignments" value = "<%= model.get('min_count') %>" /> 
+    <span class="tip tip-inline">total exercises assigned</span>
+  </div>
+  
+  <div class="field text" id="field-course-grading-assignment-droppable">
+    <label for="course-grading-assignment-droppable">Number of
+			Droppable</label>
+    <input type="text" class="short" id="course-grading-assignment-droppable" value = "<%= model.get('drop_count') %>" />
+    <span class="tip tip-inline">total exercises that won't be graded</span>
+  </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>

cms/static/client_templates/course_info_handouts.html

@@ -0,0 +1,19 @@
+<a href="#" class="edit-button"><span class="edit-icon"></span>Edit</a>
+
+<h2>Course Handouts</h2>
+<%if (model.get('data') != null) { %>
+  <div class="handouts-content">
+    <%= model.get('data') %>
+  </div>
+<% } else {%>
+  <p>You have no handouts defined</p>
+<% } %>
+<form class="edit-handouts-form" style="display: block;">
+  <div class="row">
+    <textarea class="handouts-content-editor text-editor"></textarea>
+  </div>
+  <div class="row">
+    <a href="#" class="save-button">Save</a>
+    <a href="#" class="cancel-button">Cancel</a>
+  </div>
+</form>

cms/static/client_templates/course_info_update.html

@@ -0,0 +1,29 @@
+<li name="<%- updateModel.cid %>">
+	<!-- FIXME what style should we use for initially hidden? --> <!-- TODO decide whether this should use codemirror -->
+	<form class="new-update-form">
+		<div class="row">
+			<label class="inline-label">Date:</label>
+			<!-- TODO replace w/ date widget and actual date (problem is that persisted version is "Month day" not an actual date obj -->
+			<input type="text" class="date" value="<%= updateModel.get('date') %>">
+		</div>
+		<div class="row">
+			<textarea class="new-update-content text-editor"><%= updateModel.get('content') %></textarea>
+		</div>
+		<div class="row">
+			<!-- cid rather than id b/c new ones have cid's not id's -->
+			<a href="#" class="save-button" name="<%= updateModel.cid %>">Save</a>
+			<a href="#" class="cancel-button" name="<%= updateModel.cid %>">Cancel</a>
+		</div>
+	</form>
+	<div class="post-preview">
+		<div class="post-actions">
+			<a href="#" class="edit-button" name="<%- updateModel.cid %>"><span class="edit-icon"></span>Edit</a>
+			<a href="#" class="delete-button" name="<%- updateModel.cid %>"><span class="delete-icon"></span>Delete</a>
+		</div>
+		<h2>
+			<span class="calendar-icon"></span><span class="date-display"><%=
+				updateModel.get('date') %></span>
+		</h2>
+		<div class="update-contents"><%= updateModel.get('content') %></div>
+	</div>
+</li>

cms/static/client_templates/load_templates.html

@@ -0,0 +1,14 @@
+<!-- In order to enable better debugging of templates, put them in
+     the script tag section.
+     TODO add lazy load fn to load templates as needed (called
+        from backbone view initialize to set this.template of the view)
+-->
+
+<%block name="jsextra">
+ <script type="text/javascript" charset="utf-8">
+   // How do I load an html file server side so I can 
+   // Precompiling your templates can be a big help when debugging errors you can't reproduce. This is because precompiled templates can provide line numbers and a stack trace, something that is not possible when compiling templates on the client. The source property is available on the compiled template function for easy precompilation.
+   // <script>CMS.course_info_update = <%= _.template(jstText).source %>;</script>
+ 
+ </script>
+</%block>

cms/static/coffee/.gitignore

@@ -1,2 +1,3 @@
 *.js
+descriptor
 module

cms/static/coffee/files.json

@@ -1,8 +1,12 @@
 {
-  "js_files": [
-    "/static/js/vendor/jquery.min.js",
-    "/static/js/vendor/json2.js",
-    "/static/js/vendor/underscore-min.js",
-    "/static/js/vendor/backbone-min.js"
+  "static_files": [
+    "js/vendor/RequireJS.js",
+    "js/vendor/jquery.min.js",
+    "js/vendor/jquery-ui.min.js",
+    "js/vendor/jquery.ui.draggable.js",
+    "js/vendor/jquery.cookie.js",
+    "js/vendor/json2.js",
+    "js/vendor/underscore-min.js",
+    "js/vendor/backbone-min.js"
   ]
 }

cms/static/coffee/spec/main_spec.coffee

@@ -8,72 +8,6 @@ describe "CMS", ->
   it "should initialize Views", ->
     expect(CMS.Views).toBeDefined()
 
-  describe "start", ->
-    beforeEach ->
-      @element = $("<div>")
-      spyOn(CMS.Views, "Course").andReturn(jasmine.createSpyObj("Course", ["render"]))
-      CMS.start(@element)
-
-    it "create the Course", ->
-      expect(CMS.Views.Course).toHaveBeenCalledWith(el: @element)
-      expect(CMS.Views.Course().render).toHaveBeenCalled()
-
-  describe "view stack", ->
-    beforeEach ->
-      @currentView = jasmine.createSpy("currentView")
-      CMS.viewStack = [@currentView]
-
-    describe "replaceView", ->
-      beforeEach ->
-        @newView = jasmine.createSpy("newView")
-        CMS.on("content.show", (@expectedView) =>)
-        CMS.replaceView(@newView)
-
-      it "replace the views on the viewStack", ->
-        expect(CMS.viewStack).toEqual([@newView])
-
-      it "trigger content.show on CMS", ->
-        expect(@expectedView).toEqual(@newView)
-
-    describe "pushView", ->
-      beforeEach ->
-        @newView = jasmine.createSpy("newView")
-        CMS.on("content.show", (@expectedView) =>)
-        CMS.pushView(@newView)
-
-      it "push new view onto viewStack", ->
-        expect(CMS.viewStack).toEqual([@currentView, @newView])
-
-      it "trigger content.show on CMS", ->
-        expect(@expectedView).toEqual(@newView)
-
-    describe "popView", ->
-      it "remove the current view from the viewStack", ->
-        CMS.popView()
-        expect(CMS.viewStack).toEqual([])
-
-      describe "when there's no view on the viewStack", ->
-        beforeEach ->
-          CMS.viewStack = [@currentView]
-          CMS.on("content.hide", => @eventTriggered = true)
-          CMS.popView()
-
-        it "trigger content.hide on CMS", ->
-          expect(@eventTriggered).toBeTruthy
-
-      describe "when there's previous view on the viewStack", ->
-        beforeEach ->
-          @parentView = jasmine.createSpyObj("parentView", ["delegateEvents"])
-          CMS.viewStack = [@parentView, @currentView]
-          CMS.on("content.show", (@expectedView) =>)
-          CMS.popView()
-
-        it "trigger content.show with the previous view on CMS", ->
-          expect(@expectedView).toEqual @parentView
-
-        it "re-bind events on the view", ->
-          expect(@parentView.delegateEvents).toHaveBeenCalled()
-
 describe "main helper", ->
   beforeEach ->
     @previousAjaxSettings = $.extend(true, {}, $.ajaxSettings)

cms/static/coffee/spec/models/module_spec.coffee

@@ -3,75 +3,4 @@ describe "CMS.Models.Module", ->
     expect(new CMS.Models.Module().url).toEqual("/save_item")
 
   it "set the correct default", ->
-    expect(new CMS.Models.Module().defaults).toEqual({data: ""})
-
-  describe "loadModule", ->
-    describe "when the module exists", ->
-      beforeEach ->
-        @fakeModule = jasmine.createSpy("fakeModuleObject")
-        window.FakeModule = jasmine.createSpy("FakeModule").andReturn(@fakeModule)
-        @module = new CMS.Models.Module(type: "FakeModule")
-        @stubDiv = $('<div />')
-        @stubElement = $('<div class="xmodule_edit" />')
-        @stubElement.data('type', "FakeModule")
-
-        @stubDiv.append(@stubElement)
-        @module.loadModule(@stubDiv)
-
-      afterEach ->
-        window.FakeModule = undefined
-
-      it "initialize the module", ->
-        expect(window.FakeModule).toHaveBeenCalled()
-        # Need to compare underlying nodes, because jquery selectors
-        # aren't equal even when they point to the same node.
-        # http://stackoverflow.com/questions/9505437/how-to-test-jquery-with-jasmine-for-element-id-if-used-as-this
-        expectedNode = @stubElement[0]
-        actualNode = window.FakeModule.mostRecentCall.args[0][0]
-
-        expect(actualNode).toEqual(expectedNode)
-        expect(@module.module).toEqual(@fakeModule)
-
-    describe "when the module does not exists", ->
-      beforeEach ->
-        @previousConsole = window.console
-        window.console = jasmine.createSpyObj("fakeConsole", ["error"])
-        @module = new CMS.Models.Module(type: "HTML")
-        @module.loadModule($("<div>"))
-
-      afterEach ->
-        window.console = @previousConsole
-
-      it "print out error to log", ->
-        expect(window.console.error).toHaveBeenCalled()
-        expect(window.console.error.mostRecentCall.args[0]).toMatch("^Unable to load")
-
-
-  describe "editUrl", ->
-    it "construct the correct URL based on id", ->
-      expect(new CMS.Models.Module(id: "i4x://mit.edu/module/html_123").editUrl())
-        .toEqual("/edit_item?id=i4x%3A%2F%2Fmit.edu%2Fmodule%2Fhtml_123")
-
-  describe "save", ->
-    beforeEach ->
-      spyOn(Backbone.Model.prototype, "save")
-      @module = new CMS.Models.Module()
-
-    describe "when the module exists", ->
-      beforeEach ->
-        @module.module = jasmine.createSpyObj("FakeModule", ["save"])
-        @module.module.save.andReturn("module data")
-        @module.save()
-
-      it "set the data and call save on the module", ->
-        expect(@module.get("data")).toEqual("\"module data\"")
-
-      it "call save on the backbone model", ->
-        expect(Backbone.Model.prototype.save).toHaveBeenCalled()
-
-    describe "when the module does not exists", ->
-      beforeEach ->
-        @module.save()
-
-      it "call save on the backbone model", ->
-        expect(Backbone.Model.prototype.save).toHaveBeenCalled()
+    expect(new CMS.Models.Module().defaults).toEqual(undefined)

cms/static/coffee/spec/views/course_spec.coffee

@@ -1,85 +0,0 @@
-describe "CMS.Views.Course", ->
-  beforeEach ->
-    setFixtures """
-      <section id="main-section">
-        <section class="main-content"></section>
-        <ol id="weeks">
-          <li class="cal week-one" style="height: 50px"></li>
-          <li class="cal week-two" style="height: 100px"></li>
-        </ol>
-      </section>
-      """
-    CMS.unbind()
-
-  describe "render", ->
-    beforeEach ->
-      spyOn(CMS.Views, "Week").andReturn(jasmine.createSpyObj("Week", ["render"]))
-      new CMS.Views.Course(el: $("#main-section")).render()
-
-    it "create week view for each week",->
-      expect(CMS.Views.Week.calls[0].args[0])
-        .toEqual({ el: $(".week-one").get(0), height: 101 })
-      expect(CMS.Views.Week.calls[1].args[0])
-        .toEqual({ el: $(".week-two").get(0), height: 101 })
-
-  describe "on content.show", ->
-    beforeEach ->
-      @view = new CMS.Views.Course(el: $("#main-section"))
-      @subView = jasmine.createSpyObj("subView", ["render"])
-      @subView.render.andReturn(el: "Subview Content")
-      spyOn(@view, "contentHeight").andReturn(100)
-      CMS.trigger("content.show", @subView)
-
-    afterEach ->
-      $("body").removeClass("content")
-
-    it "add content class to body", ->
-      expect($("body").attr("class")).toEqual("content")
-
-    it "replace content in .main-content", ->
-      expect($(".main-content")).toHaveHtml("Subview Content")
-
-    it "set height on calendar", ->
-      expect($(".cal")).toHaveCss(height: "100px")
-
-    it "set minimum height on all sections", ->
-      expect($("#main-section>section")).toHaveCss(minHeight: "100px")
-
-  describe "on content.hide", ->
-    beforeEach ->
-      $("body").addClass("content")
-      @view = new CMS.Views.Course(el: $("#main-section"))
-      $(".cal").css(height: 100)
-      $("#main-section>section").css(minHeight: 100)
-      CMS.trigger("content.hide")
-
-    afterEach ->
-      $("body").removeClass("content")
-
-    it "remove content class from body", ->
-      expect($("body").attr("class")).toEqual("")
-
-    it "remove content from .main-content", ->
-      expect($(".main-content")).toHaveHtml("")
-
-    it "reset height on calendar", ->
-      expect($(".cal")).not.toHaveCss(height: "100px")
-
-    it "reset minimum height on all sections", ->
-      expect($("#main-section>section")).not.toHaveCss(minHeight: "100px")
-
-  describe "maxWeekHeight", ->
-    it "return maximum height of the week element", ->
-      @view = new CMS.Views.Course(el: $("#main-section"))
-      expect(@view.maxWeekHeight()).toEqual(101)
-
-  describe "contentHeight", ->
-    beforeEach ->
-      $("body").append($('<header id="test">').height(100).hide())
-
-    afterEach ->
-      $("body>header#test").remove()
-
-    it "return the window height minus the header bar", ->
-      @view = new CMS.Views.Course(el: $("#main-section"))
-      expect(@view.contentHeight()).toEqual($(window).height() - 100)

cms/static/coffee/spec/views/module_edit_spec.coffee

@@ -1,81 +1,74 @@
 describe "CMS.Views.ModuleEdit", ->
   beforeEach ->
-    @stubModule = jasmine.createSpyObj("Module", ["editUrl", "loadModule"])
-    spyOn($.fn, "load")
+    @stubModule = jasmine.createSpy("CMS.Models.Module")
+    @stubModule.id = 'stub-id'
+
+
     setFixtures """
-      <div id="module-edit">
-        <a href="#" class="save-update">save</a>
-        <a href="#" class="cancel">cancel</a>
-        <ol>
-          <li>
-            <a href="#" class="module-edit" data-id="i4x://mitx/course/html/module" data-type="html">submodule</a>
-          </li>
-        </ol>
+    <li class="component" id="stub-id">
+      <div class="component-editor">
+        <div class="module-editor">
+          ${editor}
+        </div>
+        <a href="#" class="save-button">Save</a>
+        <a href="#" class="cancel-button">Cancel</a>
       </div>
-      """ #"
+      <div class="component-actions">
+        <a href="#" class="edit-button"><span class="edit-icon white"></span>Edit</a>
+        <a href="#" class="delete-button"><span class="delete-icon white"></span>Delete</a>  
+      </div>
+      <a href="#" class="drag-handle"></a>
+      <section class="xmodule_display xmodule_stub" data-type="StubModule">
+        <div id="stub-module-content"/>
+      </section>
+    </li>
+    """
+    spyOn($.fn, 'load').andReturn(@moduleData)
+
+    @moduleEdit = new CMS.Views.ModuleEdit(
+      el: $(".component")
+      model: @stubModule
+      onDelete: jasmine.createSpy()
+    )
     CMS.unbind()
 
-  describe "defaults", ->
-    it "set the correct tagName", ->
-      expect(new CMS.Views.ModuleEdit(model: @stubModule).tagName).toEqual("section")
+  describe "class definition", ->
+    it "sets the correct tagName", ->
+      expect(@moduleEdit.tagName).toEqual("li")
 
-    it "set the correct className", ->
-      expect(new CMS.Views.ModuleEdit(model: @stubModule).className).toEqual("edit-pane")
+    it "sets the correct className", ->
+      expect(@moduleEdit.className).toEqual("component")
 
-  describe "view creation", ->
-    beforeEach ->
-      @stubModule.editUrl.andReturn("/edit_item?id=stub_module")
-      new CMS.Views.ModuleEdit(el: $("#module-edit"), model: @stubModule)
+  describe "methods", ->
+    describe "initialize", ->
+      beforeEach ->
+        spyOn(CMS.Views.ModuleEdit.prototype, 'render')
+        @moduleEdit = new CMS.Views.ModuleEdit(
+          el: $(".component")
+          model: @stubModule
+          onDelete: jasmine.createSpy()
+        )
 
-    it "load the edit via ajax and pass to the model", ->
-      expect($.fn.load).toHaveBeenCalledWith("/edit_item?id=stub_module", jasmine.any(Function))
-      if $.fn.load.mostRecentCall
-        $.fn.load.mostRecentCall.args[1]()
-        expect(@stubModule.loadModule).toHaveBeenCalledWith($("#module-edit").get(0))
+      it "renders the module editor", ->
+        expect(@moduleEdit.render).toHaveBeenCalled()
 
-  describe "save", ->
-    beforeEach ->
-      @stubJqXHR = jasmine.createSpy("stubJqXHR")
-      @stubJqXHR.success = jasmine.createSpy("stubJqXHR.success").andReturn(@stubJqXHR)
-      @stubJqXHR.error = jasmine.createSpy("stubJqXHR.error").andReturn(@stubJqXHR)
-      @stubModule.save = jasmine.createSpy("stubModule.save").andReturn(@stubJqXHR)
-      new CMS.Views.ModuleEdit(el: $(".module-edit"), model: @stubModule)
-      spyOn(window, "alert")
-      $(".save-update").click()
+    describe "render", ->
+      beforeEach ->
+        spyOn(@moduleEdit, 'loadDisplay')
+        spyOn(@moduleEdit, 'delegateEvents')
+        @moduleEdit.render()
 
-    it "call save on the model", ->
-      expect(@stubModule.save).toHaveBeenCalled()
+      it "loads the module preview and editor via ajax on the view element", ->
+        expect(@moduleEdit.$el.load).toHaveBeenCalledWith("/preview_component/#{@moduleEdit.model.id}", jasmine.any(Function))
+        @moduleEdit.$el.load.mostRecentCall.args[1]()
+        expect(@moduleEdit.loadDisplay).toHaveBeenCalled()
+        expect(@moduleEdit.delegateEvents).toHaveBeenCalled()
 
-    it "alert user on success", ->
-      @stubJqXHR.success.mostRecentCall.args[0]()
-      expect(window.alert).toHaveBeenCalledWith("Your changes have been saved.")
+    describe "loadDisplay", ->
+      beforeEach ->
+        spyOn(XModule, 'loadModule')
+        @moduleEdit.loadDisplay()
 
-    it "alert user on error", ->
-      @stubJqXHR.error.mostRecentCall.args[0]()
-      expect(window.alert).toHaveBeenCalledWith("There was an error saving your changes. Please try again.")
-
-  describe "cancel", ->
-    beforeEach ->
-      spyOn(CMS, "popView")
-      @view = new CMS.Views.ModuleEdit(el: $("#module-edit"), model: @stubModule)
-      $(".cancel").click()
-
-    it "pop current view from viewStack", ->
-      expect(CMS.popView).toHaveBeenCalled()
-
-  describe "editSubmodule", ->
-    beforeEach ->
-      @view = new CMS.Views.ModuleEdit(el: $("#module-edit"), model: @stubModule)
-      spyOn(CMS, "pushView")
-      spyOn(CMS.Views, "ModuleEdit")
-        .andReturn(@view = jasmine.createSpy("Views.ModuleEdit"))
-      spyOn(CMS.Models, "Module")
-        .andReturn(@model = jasmine.createSpy("Models.Module"))
-      $(".module-edit").click()
-
-    it "push another module editing view into viewStack", ->
-      expect(CMS.pushView).toHaveBeenCalledWith @view
-      expect(CMS.Views.ModuleEdit).toHaveBeenCalledWith model: @model
-      expect(CMS.Models.Module).toHaveBeenCalledWith
-        id: "i4x://mitx/course/html/module"
-        type: "html"
+      it "loads the .xmodule-display inside the module editor", ->
+        expect(XModule.loadModule).toHaveBeenCalled()
+        expect(XModule.loadModule.mostRecentCall.args[0]).toBe($('.xmodule_display'))

cms/static/coffee/spec/views/module_spec.coffee

@@ -1,24 +0,0 @@
-describe "CMS.Views.Module", ->
-  beforeEach ->
-    setFixtures """
-      <div id="module" data-id="i4x://mitx/course/html/module" data-type="html">
-        <a href="#" class="module-edit">edit</a>
-      </div>
-      """
-
-  describe "edit", ->
-    beforeEach ->
-      @view = new CMS.Views.Module(el: $("#module"))
-      spyOn(CMS, "replaceView")
-      spyOn(CMS.Views, "ModuleEdit")
-        .andReturn(@view = jasmine.createSpy("Views.ModuleEdit"))
-      spyOn(CMS.Models, "Module")
-        .andReturn(@model = jasmine.createSpy("Models.Module"))
-      $(".module-edit").click()
-
-    it "replace the main view with ModuleEdit view", ->
-      expect(CMS.replaceView).toHaveBeenCalledWith @view
-      expect(CMS.Views.ModuleEdit).toHaveBeenCalledWith model: @model
-      expect(CMS.Models.Module).toHaveBeenCalledWith
-        id: "i4x://mitx/course/html/module"
-        type: "html"

cms/static/coffee/spec/views/week_edit_spec.coffee

@@ -1,7 +0,0 @@
-describe "CMS.Views.WeekEdit", ->
-  describe "defaults", ->
-    it "set the correct tagName", ->
-      expect(new CMS.Views.WeekEdit().tagName).toEqual("section")
-
-    it "set the correct className", ->
-      expect(new CMS.Views.WeekEdit().className).toEqual("edit-pane")

cms/static/coffee/spec/views/week_spec.coffee

@@ -1,67 +0,0 @@
-describe "CMS.Views.Week", ->
-  beforeEach ->
-    setFixtures """
-      <div id="week" data-id="i4x://mitx/course/chapter/week">
-        <div class="editable"></div>
-        <textarea class="editable-textarea"></textarea>
-        <a href="#" class="week-edit" >edit</a>
-        <ul class="modules">
-          <li id="module-one" class="module"></li>
-          <li id="module-two" class="module"></li>
-        </ul>
-      </div>
-      """
-    CMS.unbind()
-
-  describe "render", ->
-    beforeEach ->
-      spyOn(CMS.Views, "Module").andReturn(jasmine.createSpyObj("Module", ["render"]))
-      $.fn.inlineEdit = jasmine.createSpy("$.fn.inlineEdit")
-      @view = new CMS.Views.Week(el: $("#week"), height: 100).render()
-
-    it "set the height of the element", ->
-      expect(@view.el).toHaveCss(height: "100px")
-
-    it "make .editable as inline editor", ->
-      expect($.fn.inlineEdit.calls[0].object.get(0))
-        .toEqual($(".editable").get(0))
-
-    it "make .editable-test as inline editor", ->
-      expect($.fn.inlineEdit.calls[1].object.get(0))
-        .toEqual($(".editable-textarea").get(0))
-
-    it "create module subview for each module", ->
-      expect(CMS.Views.Module.calls[0].args[0])
-        .toEqual({ el: $("#module-one").get(0) })
-      expect(CMS.Views.Module.calls[1].args[0])
-        .toEqual({ el: $("#module-two").get(0) })
-
-  describe "edit", ->
-    beforeEach ->
-      new CMS.Views.Week(el: $("#week"), height: 100).render()
-      spyOn(CMS, "replaceView")
-      spyOn(CMS.Views, "WeekEdit")
-        .andReturn(@view = jasmine.createSpy("Views.WeekEdit"))
-      $(".week-edit").click()
-
-    it "replace the content with edit week view", ->
-      expect(CMS.replaceView).toHaveBeenCalledWith @view
-      expect(CMS.Views.WeekEdit).toHaveBeenCalled()
-
-  describe "on content.show", ->
-    beforeEach ->
-      @view = new CMS.Views.Week(el: $("#week"), height: 100).render()
-      @view.$el.height("")
-      @view.setHeight()
-
-    it "set the correct height", ->
-      expect(@view.el).toHaveCss(height: "100px")
-
-  describe "on content.hide", ->
-    beforeEach ->
-      @view = new CMS.Views.Week(el: $("#week"), height: 100).render()
-      @view.$el.height("100px")
-      @view.resetHeight()
-
-    it "remove height from the element", ->
-      expect(@view.el).not.toHaveCss(height: "100px")

cms/static/coffee/src/main.coffee

@@ -6,28 +6,6 @@ AjaxPrefix.addAjaxPrefix(jQuery, -> CMS.prefix)
 
   prefix: $("meta[name='path_prefix']").attr('content')
 
-  viewStack: []
-
-  start: (el) ->
-    new CMS.Views.Course(el: el).render()
-
-  replaceView: (view) ->
-    @viewStack = [view]
-    CMS.trigger('content.show', view)
-
-  pushView: (view) ->
-    @viewStack.push(view)
-    CMS.trigger('content.show', view)
-
-  popView: ->
-    @viewStack.pop()
-    if _.isEmpty(@viewStack)
-      CMS.trigger('content.hide')
-    else
-      view = _.last(@viewStack)
-      CMS.trigger('content.show', view)
-      view.delegateEvents()
-
 _.extend CMS, Backbone.Events
 
 $ ->
@@ -41,7 +19,3 @@ $ ->
     navigator.userAgent.match /iPhone|iPod|iPad/i
 
   $('body').addClass 'touch-based-device' if onTouchBasedDevice()
-
-
-  CMS.start($('section.main-container'))
-

cms/static/coffee/src/models/module.coffee

@@ -1,28 +1,2 @@
 class CMS.Models.Module extends Backbone.Model
   url: '/save_item'
-  defaults:
-    data: ''
-    children: ''
-    metadata: {}
-
-  loadModule: (element) ->
-    elt = $(element).find('.xmodule_edit').first()
-    @module = XModule.loadModule(elt)
-    # find the metadata edit region which should be setup server side,
-    # so that we can wire up posting back those changes
-    @metadata_elt = $(element).find('.metadata_edit')
-
-  editUrl: ->
-    "/edit_item?#{$.param(id: @get('id'))}"
-
-  save: (args...) ->
-    @set(data: @module.save()) if @module
-    # cdodge: package up metadata which is separated into a number of input fields
-    # there's probably a better way to do this, but at least this lets me continue to move onwards
-    if @metadata_elt
-      _metadata = {}
-      # walk through the set of elments which have the 'xmetadata_name' attribute and
-      # build up a object to pass back to the server on the subsequent POST
-      _metadata[$(el).data("metadata-name")]=el.value for el in $('[data-metadata-name]', @metadata_elt)
-      @set(metadata: _metadata)
-    super(args...)

cms/static/coffee/src/models/new_module.coffee

@@ -1,5 +0,0 @@
-class CMS.Models.NewModule extends Backbone.Model
-  url: '/clone_item'
-
-  newUrl: ->
-    "/new_item?#{$.param(parent_location: @get('parent_location'))}"

cms/static/coffee/src/views/course.coffee

@@ -1,28 +0,0 @@
-class CMS.Views.Course extends Backbone.View
-  initialize: ->
-    CMS.on('content.show', @showContent)
-    CMS.on('content.hide', @hideContent)
-
-  render: ->
-    @$('#weeks > li').each (index, week) =>
-      new CMS.Views.Week(el: week, height: @maxWeekHeight()).render()
-    return @
-
-  showContent: (subview) =>
-    $('body').addClass('content')
-    @$('.main-content').html(subview.render().el)
-    @$('.cal').css height: @contentHeight()
-    @$('>section').css minHeight: @contentHeight()
-
-  hideContent: =>
-    $('body').removeClass('content')
-    @$('.main-content').empty()
-    @$('.cal').css height: ''
-    @$('>section').css minHeight: ''
-
-  maxWeekHeight: ->
-    weekElementBorderSize = 1
-    _.max($('#weeks > li').map -> $(this).height()) + weekElementBorderSize
-
-  contentHeight: ->
-    $(window).height() - $('body>header').outerHeight()

cms/static/coffee/src/views/module.coffee

@@ -1,14 +0,0 @@
-class CMS.Views.Module extends Backbone.View
-  events:
-    "click .module-edit": "edit"
-
-  edit: (event) =>
-    event.preventDefault()
-    previewType = @$el.data('preview-type')
-    moduleType = @$el.data('type')
-    CMS.replaceView new CMS.Views.ModuleEdit
-      model: new CMS.Models.Module
-        id: @$el.data('id')
-        type: if moduleType == 'None' then null else moduleType
-        previewType: if previewType == 'None' then null else previewType
-

cms/static/coffee/src/views/module_add.coffee

@@ -1,26 +0,0 @@
-class CMS.Views.ModuleAdd extends Backbone.View
-  tagName: 'section'
-  className: 'add-pane'
-
-  events:
-    'click .cancel': 'cancel'
-    'click .save': 'save'
-
-  initialize: ->
-    @$el.load @model.newUrl()
-
-  save: (event) ->
-    event.preventDefault()
-    @model.save({
-      name: @$el.find('.name').val()
-      template: $(event.target).data('template-id')
-    }, {
-      success: -> CMS.popView()
-      error: -> alert('Create failed')
-    })
-
-  cancel: (event) ->
-    event.preventDefault()
-    CMS.popView()
-
-

cms/static/coffee/src/views/module_edit.coffee

@@ -1,60 +1,84 @@
 class CMS.Views.ModuleEdit extends Backbone.View
-  tagName: 'section'
-  className: 'edit-pane'
+  tagName: 'li'
+  className: 'component'
 
   events:
-    'click .cancel': 'cancel'
-    'click .module-edit': 'editSubmodule'
-    'click .save-update': 'save'
+    "click .component-editor .cancel-button": 'clickCancelButton'
+    "click .component-editor .save-button": 'clickSaveButton'
+    "click .component-actions .edit-button": 'clickEditButton'
+    "click .component-actions .delete-button": 'onDelete'
 
   initialize: ->
-    @$el.load @model.editUrl(), =>
-      @model.loadModule(@el)
+    @onDelete = @options.onDelete
+    @render()
 
-      # Load preview modules
-      XModule.loadModules('display')
-      @$children = @$el.find('#sortable')
-      @enableDrag()
+  $component_editor: => @$el.find('.component-editor')
 
-  enableDrag: =>
-      # Enable dragging things in the #sortable div (if there is one)
-      if @$children.length > 0
-        @$children.sortable(
-          placeholder: "ui-state-highlight"
-          update: (event, ui) =>
-            @model.set(children: @$children.find('.module-edit').map(
-                (idx, el) -> $(el).data('id')
-            ).toArray())
-        )
-        @$children.disableSelection()
+  loadDisplay: ->
+       XModule.loadModule(@$el.find('.xmodule_display'))
 
-  save: (event) =>
-    event.preventDefault()
-    @model.save().done((previews) =>
-      alert("Your changes have been saved.")
-      previews_section = @$el.find('.previews').empty()
-      $.each(previews, (idx, preview) =>
-        preview_wrapper = $('<section/>', class: 'preview').append preview
-        previews_section.append preview_wrapper
-      )
+  loadEdit: ->
+    if not @module
+      @module = XModule.loadModule(@$el.find('.xmodule_edit'))
 
-      XModule.loadModules('display')
-    ).fail( ->
-      alert("There was an error saving your changes. Please try again.")
+  metadata: ->
+    # cdodge: package up metadata which is separated into a number of input fields
+    # there's probably a better way to do this, but at least this lets me continue to move onwards
+    _metadata = {}
+
+    $metadata = @$component_editor().find('.metadata_edit')
+
+    if $metadata
+      # walk through the set of elments which have the 'xmetadata_name' attribute and
+      # build up a object to pass back to the server on the subsequent POST
+      _metadata[$(el).data("metadata-name")] = el.value for el in $('[data-metadata-name]', $metadata)
+
+    return _metadata
+
+  cloneTemplate: (parent, template) ->
+    $.post("/clone_item", {
+      parent_location: parent
+      template: template
+    }, (data) => 
+      @model.set(id: data.id)
+      @$el.data('id', data.id)
+      @render()
     )
 
-  cancel: (event) ->
-    event.preventDefault()
-    CMS.popView()
-    @enableDrag()
+  render: ->
+    if @model.id
+      @$el.load("/preview_component/#{@model.id}", =>
+        @loadDisplay()
+        @delegateEvents()
+      )
 
-  editSubmodule: (event) ->
+  clickSaveButton: (event) =>
     event.preventDefault()
-    previewType = $(event.target).data('preview-type')
-    moduleType = $(event.target).data('type')
-    CMS.pushView new CMS.Views.ModuleEdit
-        model: new CMS.Models.Module
-            id: $(event.target).data('id')
-            type: if moduleType == 'None' then null else moduleType
-            previewType: if previewType == 'None' then null else previewType
-    @enableDrag()
+    data = @module.save()
+    data.metadata = _.extend(data.metadata || {}, @metadata())
+    @hideModal()
+    @model.save(data).done( =>
+    #   # showToastMessage("Your changes have been saved.", null, 3)
+      @module = null
+      @render()
+      @$el.removeClass('editing')
+    ).fail( ->
+      showToastMessage("There was an error saving your changes. Please try again.", null, 3)
+    )
+
+  clickCancelButton: (event) ->
+    event.preventDefault()
+    @$el.removeClass('editing')
+    @$component_editor().slideUp(150)
+    @hideModal()
+
+  hideModal: ->
+    $modalCover.hide()
+    $modalCover.removeClass('is-fixed')
+
+  clickEditButton: (event) ->
+    event.preventDefault()
+    @$el.addClass('editing')
+    $modalCover.show().addClass('is-fixed')
+    @$component_editor().slideDown(150)
+    @loadEdit()

cms/static/coffee/src/views/tabs.coffee

@@ -0,0 +1,71 @@
+class CMS.Views.TabsEdit extends Backbone.View
+
+  initialize: =>
+    @$('.component').each((idx, element) =>
+        new CMS.Views.ModuleEdit(
+            el: element,
+            onDelete: @deleteTab,
+            model: new CMS.Models.Module(
+                id: $(element).data('id'),
+            )
+        )
+    )
+
+    @options.mast.find('.new-tab').on('click', @addNewTab)
+    @$('.components').sortable(
+      handle: '.drag-handle'
+      update: @tabMoved
+      helper: 'clone'
+      opacity: '0.5'
+      placeholder: 'component-placeholder'
+      forcePlaceholderSize: true
+      axis: 'y'
+      items: '> .component'
+    )    
+
+  tabMoved: (event, ui) =>
+    tabs = []
+    @$('.component').each((idx, element) =>
+        tabs.push($(element).data('id'))
+    )
+    $.ajax({
+      type:'POST',
+      url: '/reorder_static_tabs', 
+      data: JSON.stringify({
+        tabs : tabs
+      }),
+      contentType: 'application/json'
+    })
+
+  addNewTab: (event) =>
+    event.preventDefault()
+
+    editor = new CMS.Views.ModuleEdit(
+      onDelete: @deleteTab
+      model: new CMS.Models.Module()
+    )
+
+    $('.new-component-item').before(editor.$el)
+    editor.$el.addClass('new')
+    setTimeout(=>
+      editor.$el.removeClass('new')
+    , 500)
+
+    editor.cloneTemplate(
+      @model.get('id'),
+      'i4x://edx/templates/static_tab/Empty'
+    )
+
+  deleteTab: (event) =>
+    if not confirm 'Are you sure you want to delete this component? This action cannot be undone.'
+      return
+    $component = $(event.currentTarget).parents('.component')
+    $.post('/delete_item', {
+      id: $component.data('id')
+    }, =>
+      $component.remove()
+    )
+
+
+
+

cms/static/coffee/src/views/unit.coffee

@@ -0,0 +1,210 @@
+class CMS.Views.UnitEdit extends Backbone.View
+  events:
+    'click .new-component .new-component-type a': 'showComponentTemplates'
+    'click .new-component .cancel-button': 'closeNewComponent'
+    'click .new-component-templates .new-component-template a': 'saveNewComponent'
+    'click .new-component-templates .cancel-button': 'closeNewComponent'
+    'click .delete-draft': 'deleteDraft'
+    'click .create-draft': 'createDraft'
+    'click .publish-draft': 'publishDraft'
+    'change .visibility-select': 'setVisibility'
+
+  initialize: =>
+    @visibilityView = new CMS.Views.UnitEdit.Visibility(
+      el: @$('.visibility-select')
+      model: @model
+    )
+
+    @locationView = new CMS.Views.UnitEdit.LocationState(
+      el: @$('.section-item.editing a')
+      model: @model
+    )
+
+    @nameView = new CMS.Views.UnitEdit.NameEdit(
+      el: @$('.unit-name-input')
+      model: @model
+    )
+
+    @model.on('change:state', @render)
+
+    @$newComponentItem = @$('.new-component-item')
+    @$newComponentTypePicker = @$('.new-component')
+    @$newComponentTemplatePickers = @$('.new-component-templates')
+    @$newComponentButton = @$('.new-component-button')
+
+    @$('.components').sortable(
+      handle: '.drag-handle'
+      update: (event, ui) =>
+        payload = children : @components()
+        options = success : => @model.unset('children')
+        @model.save(payload, options)
+      helper: 'clone'
+      opacity: '0.5'
+      placeholder: 'component-placeholder'
+      forcePlaceholderSize: true
+      axis: 'y'
+      items: '> .component'
+    )
+
+    @$('.component').each((idx, element) =>
+        new CMS.Views.ModuleEdit(
+            el: element,
+            onDelete: @deleteComponent,
+            model: new CMS.Models.Module(
+                id: $(element).data('id'),
+            )
+        )
+    )
+
+  showComponentTemplates: (event) =>
+    event.preventDefault()
+
+    type = $(event.currentTarget).data('type')
+    @$newComponentTypePicker.slideUp(250)
+    @$(".new-component-#{type}").slideDown(250)
+    $('html, body').animate({ 
+      scrollTop: @$(".new-component-#{type}").offset().top 
+    }, 500)
+
+  closeNewComponent: (event) =>
+    event.preventDefault()
+
+    @$newComponentTypePicker.slideDown(250)
+    @$newComponentTemplatePickers.slideUp(250)
+    @$newComponentItem.removeClass('adding')
+    @$newComponentItem.find('.rendered-component').remove()
+
+  saveNewComponent: (event) =>
+    event.preventDefault()
+
+    editor = new CMS.Views.ModuleEdit(
+      onDelete: @deleteComponent
+      model: new CMS.Models.Module()
+    )
+
+    @$newComponentItem.before(editor.$el)
+
+    editor.cloneTemplate(
+      @$el.data('id'),
+      $(event.currentTarget).data('location')
+    )
+
+    @closeNewComponent(event)
+
+  components: => @$('.component').map((idx, el) -> $(el).data('id')).get()
+
+  wait: (value) =>
+    @$('.unit-body').toggleClass("waiting", value)
+
+  render: =>
+    if @model.hasChanged('state')
+      @$el.toggleClass("edit-state-#{@model.previous('state')} edit-state-#{@model.get('state')}")
+      @wait(false)
+
+  saveDraft: =>
+    @model.save()
+
+  deleteComponent: (event) =>
+    if not confirm 'Are you sure you want to delete this component? This action cannot be undone.'
+      return
+    $component = $(event.currentTarget).parents('.component')
+    $.post('/delete_item', {
+      id: $component.data('id')
+    }, =>
+      $component.remove()
+      # b/c we don't vigilantly keep children up to date
+      # get rid of it before it hurts someone
+      # sorry for the js, i couldn't figure out the coffee equivalent
+      `_this.model.save({children: _this.components()},
+          {success: function(model) {
+              model.unset('children');
+          }}
+      );`
+    )
+
+  deleteDraft: (event) ->
+    @wait(true)
+
+    $.post('/delete_item', {
+      id: @$el.data('id')
+      delete_children: true
+    }, =>
+      window.location.reload()
+    )
+
+  createDraft: (event) ->
+    @wait(true)
+
+    $.post('/create_draft', {
+      id: @$el.data('id')
+    }, =>
+      @model.set('state', 'draft')
+    )
+
+  publishDraft: (event) ->
+    @wait(true)
+    @saveDraft()
+
+    $.post('/publish_draft', {
+      id: @$el.data('id')
+    }, =>
+      @model.set('state', 'public')
+    )
+
+  setVisibility: (event) ->
+    if @$('.visibility-select').val() == 'private'
+      target_url = '/unpublish_unit'
+    else
+      target_url = '/publish_draft'
+
+    @wait(true)
+
+    $.post(target_url, {
+      id: @$el.data('id')
+    }, =>
+      @model.set('state', @$('.visibility-select').val())
+    )
+
+class CMS.Views.UnitEdit.NameEdit extends Backbone.View
+  events:
+    'change .unit-display-name-input': 'saveName'
+
+  initialize: =>
+    @model.on('change:metadata', @render)
+    @model.on('change:state', @setEnabled)
+    @setEnabled()
+    @saveName
+    @$spinner = $('<span class="spinner-in-field-icon"></span>');
+
+  render: =>
+    @$('.unit-display-name-input').val(@model.get('metadata').display_name)
+
+  setEnabled: =>
+    disabled = @model.get('state') == 'public'
+    if disabled
+      @$('.unit-display-name-input').attr('disabled', true)
+    else
+      @$('.unit-display-name-input').removeAttr('disabled')
+
+  saveName: =>
+    # Treat the metadata dictionary as immutable
+    metadata = $.extend({}, @model.get('metadata'))
+    metadata.display_name = @$('.unit-display-name-input').val()
+    @model.save(metadata: metadata)
+    # Update name shown in the right-hand side location summary.
+    $('.unit-location .editing .unit-name').html(metadata.display_name)
+
+class CMS.Views.UnitEdit.LocationState extends Backbone.View
+  initialize: =>
+    @model.on('change:state', @render)
+  
+  render: =>
+    @$el.toggleClass("#{@model.previous('state')}-item #{@model.get('state')}-item")
+
+class CMS.Views.UnitEdit.Visibility extends Backbone.View
+  initialize: =>
+    @model.on('change:state', @render)
+    @render()
+
+  render: =>
+    @$el.val(@model.get('state'))

cms/static/coffee/src/views/week.coffee

@@ -1,32 +0,0 @@
-class CMS.Views.Week extends Backbone.View
-  events:
-    'click .week-edit': 'edit'
-    'click .new-module': 'new'
-
-  initialize: ->
-    CMS.on('content.show', @resetHeight)
-    CMS.on('content.hide', @setHeight)
-
-  render: ->
-    @setHeight()
-    @$('.editable').inlineEdit()
-    @$('.editable-textarea').inlineEdit(control: 'textarea')
-    @$('.modules .module').each ->
-      new CMS.Views.Module(el: this).render()
-    return @
-
-  edit: (event) ->
-    event.preventDefault()
-    CMS.replaceView(new CMS.Views.WeekEdit())
-
-  setHeight: =>
-    @$el.height(@options.height)
-
-  resetHeight: =>
-    @$el.height('')
-
-  new: (event) =>
-    event.preventDefault()
-    CMS.replaceView new CMS.Views.ModuleAdd
-      model: new CMS.Models.NewModule
-        parent_location: @$el.data('id')

cms/static/coffee/src/views/week_edit.coffee

@@ -1,3 +0,0 @@
-class CMS.Views.WeekEdit extends Backbone.View
-  tagName: 'section'
-  className: 'edit-pane'

cms/static/css/tiny-mce.css

@@ -0,0 +1,140 @@
+@font-face{font-family:'Open Sans';font-style:normal;font-weight:700;src:local("Open Sans Bold"),local("OpenSans-Bold"),url(http://themes.googleusercontent.com/static/fonts/opensans/v6/k3k702ZOKiLJc3WVjuplzKRDOzjiPcYnFooOUGCOsRk.woff) format("woff")}@font-face{font-family:'Open Sans';font-style:normal;font-weight:300;src:local("Open Sans Light"),local("OpenSans-Light"),url(http://themes.googleusercontent.com/static/fonts/opensans/v6/DXI1ORHCpsQm3Vp6mXoaTaRDOzjiPcYnFooOUGCOsRk.woff) format("woff")}@font-face{font-family:'Open Sans';font-style:italic;font-weight:700;src:local("Open Sans Bold Italic"),local("OpenSans-BoldItalic"),url(http://themes.googleusercontent.com/static/fonts/opensans/v6/PRmiXeptR36kaC0GEAetxhbnBKKEOwRKgsHDreGcocg.woff) format("woff")}@font-face{font-family:'Open Sans';font-style:italic;font-weight:300;src:local("Open Sans Light Italic"),local("OpenSansLight-Italic"),url(http://themes.googleusercontent.com/static/fonts/opensans/v6/PRmiXeptR36kaC0GEAetxvR_54zmj3SbGZQh3vCOwvY.woff) format("woff")}@font-face{font-family:'Open Sans';font-style:italic;font-weight:400;src:local("Open Sans Italic"),local("OpenSans-Italic"),url(http://themes.googleusercontent.com/static/fonts/opensans/v6/xjAJXh38I15wypJXxuGMBrrIa-7acMAeDBVuclsi6Gc.woff) format("woff")}@font-face{font-family:'Open Sans';font-style:normal;font-weight:400;src:local("Open Sans"),local("OpenSans"),url(http://themes.googleusercontent.com/static/fonts/opensans/v6/cJZKeOuBrn4kERxqtaUH3bO3LdcAZYWl9Si6vvxL-qU.woff) format("woff")}
+
+.mceContentBody {
+    padding: 10px;
+    background-color: #fff;
+    font-family: 'Open Sans', Verdana, Arial, Helvetica, sans-serif;
+    font-size: 16px;
+    line-height: 1.6;
+    color: #3c3c3c;
+    scrollbar-3dlight-color: #F0F0EE;
+    scrollbar-arrow-color: #676662;
+    scrollbar-base-color: #F0F0EE;
+    scrollbar-darkshadow-color: #DDDDDD;
+    scrollbar-face-color: #E0E0DD;
+    scrollbar-highlight-color: #F0F0EE;
+    scrollbar-shadow-color: #F0F0EE;
+    scrollbar-track-color: #F5F5F5;
+}
+
+h1 {
+    color: #3c3c3c;
+    font-weight: normal;
+    font-size: 2em;
+    line-height: 1.4em;
+    letter-spacing: 1px;
+    margin: 0 0 1.416em 0;
+}
+
+h2 {
+    color: #646464;
+    font-weight: normal;
+    font-size: 1.2em;
+    line-height: 1.2em;
+    letter-spacing: 1px;
+    margin-bottom: 15px;
+    text-transform: uppercase;
+    -webkit-font-smoothing: antialiased;
+}
+
+h3, h4, h5, h6 {
+    margin: 0 0 10px 0;
+    font-weight: 600;
+}
+
+h3 {
+    font-size: 1.2em;
+}
+
+h4 {
+    font-size: 1em;
+}
+
+h5 {
+    font-size: .83em;
+}
+
+h6 {
+    font-size: 0.75em;
+}
+
+p {
+    margin-bottom: 1.416em;
+    font-size: 1em;
+    line-height: 1.6em !important;
+    color: #3c3c3c;
+}
+
+em, i {
+    font-style: italic;
+}
+
+strong, b {
+    font-style: bold;
+}
+
+p + p, ul + p, ol + p {
+    margin-top: 20px;
+}
+
+ol, ul {
+    margin: 1em 0;
+    padding: 0 0 0 1em;
+    color: #3c3c3c;
+
+}
+
+ol li, ul li {
+    margin-bottom: 0.708em;
+}
+
+ol {
+    list-style: decimal outside none;
+}
+
+ul {
+    list-style: disc outside none;
+}
+
+a, a:link, a:visited, a:hover, a:active {
+    color: #1d9dd9;
+}
+
+img {
+    max-width: 100%;
+}
+
+pre {
+  margin: 1em 0;
+  color: #3c3c3c;
+  font-family: monospace, serif;
+  font-size: 1em;
+  white-space: pre-wrap;
+  word-wrap: break-word;
+}
+
+code {
+    font-family: monospace, serif;
+    background: none;
+    color: #3c3c3c;
+    padding: 0;
+}
+
+table {
+    width: 100%;
+    border-collapse: collapse;
+    font-size: 16px;
+}
+
+th {
+    background: #eee;
+    font-weight: bold;
+}
+
+table td, th {
+    margin: 20px 0;
+    padding: 10px;
+    border: 1px solid #ccc !important;
+    text-align: left;
+    font-size: 14px;
+}