Perform merge from master, including renumbering of migrations in…

Perform merge from master, including renumbering of migrations in common/djangoapps/student/migrations

cms/.coveragerc

@@ -2,11 +2,13 @@
 [run]
 data_file = reports/cms/.coverage
 source = cms
+omit = cms/envs/*, cms/manage.py
 
 [report]
 ignore_errors = True
 
 [html]
+title = CMS Python Test Coverage Report
 directory = reports/cms/cover
 
 [xml]

common/djangoapps/student/admin.py

@@ -12,6 +12,8 @@ admin.site.register(UserTestGroup)
 
 admin.site.register(CourseEnrollment)
 
+admin.site.register(CourseEnrollmentAllowed)
+
 admin.site.register(Registration)
 
 admin.site.register(PendingNameChange)

common/djangoapps/student/migrations/0022_add_more_fields_to_test_center_user.py → common/djangoapps/student/migrations/0023_add_test_center_registration.py

@@ -21,28 +21,41 @@ class Migration(SchemaMigration):
             ('eligibility_appointment_date_first', self.gf('django.db.models.fields.DateField')(db_index=True)),
             ('eligibility_appointment_date_last', self.gf('django.db.models.fields.DateField')(db_index=True)),
             ('accommodation_code', self.gf('django.db.models.fields.CharField')(max_length=64, blank=True)),
-            ('accommodation_request', self.gf('django.db.models.fields.CharField')(max_length=1024, blank=True)),
-            ('upload_status', self.gf('django.db.models.fields.CharField')(max_length=20, blank=True)),
+            ('accommodation_request', self.gf('django.db.models.fields.CharField')(db_index=True, max_length=1024, blank=True)),
             ('uploaded_at', self.gf('django.db.models.fields.DateTimeField')(null=True, db_index=True)),
+            ('processed_at', self.gf('django.db.models.fields.DateTimeField')(null=True, db_index=True)),
+            ('upload_status', self.gf('django.db.models.fields.CharField')(db_index=True, max_length=20, blank=True)),
             ('upload_error_message', self.gf('django.db.models.fields.CharField')(max_length=512, blank=True)),
+            ('authorization_id', self.gf('django.db.models.fields.IntegerField')(null=True, db_index=True)),
+            ('confirmed_at', self.gf('django.db.models.fields.DateTimeField')(null=True, db_index=True)),
         ))
         db.send_create_signal('student', ['TestCenterRegistration'])
 
-        # Adding field 'TestCenterUser.upload_status'
-        db.add_column('student_testcenteruser', 'upload_status',
-                      self.gf('django.db.models.fields.CharField')(db_index=True, default='', max_length=20, blank=True),
-                      keep_default=False)
-
         # Adding field 'TestCenterUser.uploaded_at'
         db.add_column('student_testcenteruser', 'uploaded_at',
                       self.gf('django.db.models.fields.DateTimeField')(db_index=True, null=True, blank=True),
                       keep_default=False)
 
+        # Adding field 'TestCenterUser.processed_at'
+        db.add_column('student_testcenteruser', 'processed_at',
+                      self.gf('django.db.models.fields.DateTimeField')(null=True, db_index=True),
+                      keep_default=False)
+
+        # Adding field 'TestCenterUser.upload_status'
+        db.add_column('student_testcenteruser', 'upload_status',
+                      self.gf('django.db.models.fields.CharField')(db_index=True, default='', max_length=20, blank=True),
+                      keep_default=False)
+
         # Adding field 'TestCenterUser.upload_error_message'
         db.add_column('student_testcenteruser', 'upload_error_message',
                       self.gf('django.db.models.fields.CharField')(default='', max_length=512, blank=True),
                       keep_default=False)
 
+        # Adding field 'TestCenterUser.confirmed_at'
+        db.add_column('student_testcenteruser', 'confirmed_at',
+                      self.gf('django.db.models.fields.DateTimeField')(null=True, db_index=True),
+                      keep_default=False)
+
         # Adding index on 'TestCenterUser', fields ['company_name']
         db.create_index('student_testcenteruser', ['company_name'])
 
@@ -60,15 +73,21 @@ class Migration(SchemaMigration):
         # Deleting model 'TestCenterRegistration'
         db.delete_table('student_testcenterregistration')
 
-        # Deleting field 'TestCenterUser.upload_status'
-        db.delete_column('student_testcenteruser', 'upload_status')
-
         # Deleting field 'TestCenterUser.uploaded_at'
         db.delete_column('student_testcenteruser', 'uploaded_at')
 
+        # Deleting field 'TestCenterUser.processed_at'
+        db.delete_column('student_testcenteruser', 'processed_at')
+
+        # Deleting field 'TestCenterUser.upload_status'
+        db.delete_column('student_testcenteruser', 'upload_status')
+
         # Deleting field 'TestCenterUser.upload_error_message'
         db.delete_column('student_testcenteruser', 'upload_error_message')
 
+        # Deleting field 'TestCenterUser.confirmed_at'
+        db.delete_column('student_testcenteruser', 'confirmed_at')
+
 
     models = {
         'auth.group': {
@@ -114,6 +133,13 @@ class Migration(SchemaMigration):
             'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
             'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']"})
         },
+        'student.courseenrollmentallowed': {
+            'Meta': {'unique_together': "(('email', 'course_id'),)", 'object_name': 'CourseEnrollmentAllowed'},
+            'course_id': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'}),
+            'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'null': 'True', 'db_index': 'True', 'blank': 'True'}),
+            'email': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
+        },
         'student.pendingemailchange': {
             'Meta': {'object_name': 'PendingEmailChange'},
             'activation_key': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '32', 'db_index': 'True'}),
@@ -137,18 +163,21 @@ class Migration(SchemaMigration):
         'student.testcenterregistration': {
             'Meta': {'object_name': 'TestCenterRegistration'},
             'accommodation_code': ('django.db.models.fields.CharField', [], {'max_length': '64', 'blank': 'True'}),
-            'accommodation_request': ('django.db.models.fields.CharField', [], {'max_length': '1024', 'blank': 'True'}),
+            'accommodation_request': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '1024', 'blank': 'True'}),
+            'authorization_id': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'db_index': 'True'}),
             'client_authorization_id': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '20', 'db_index': 'True'}),
+            'confirmed_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'db_index': 'True'}),
             'course_id': ('django.db.models.fields.CharField', [], {'max_length': '128', 'db_index': 'True'}),
             'created_at': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'db_index': 'True', 'blank': 'True'}),
             'eligibility_appointment_date_first': ('django.db.models.fields.DateField', [], {'db_index': 'True'}),
             'eligibility_appointment_date_last': ('django.db.models.fields.DateField', [], {'db_index': 'True'}),
             'exam_series_code': ('django.db.models.fields.CharField', [], {'max_length': '15', 'db_index': 'True'}),
             'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'processed_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'db_index': 'True'}),
             'testcenter_user': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['student.TestCenterUser']"}),
             'updated_at': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'db_index': 'True', 'blank': 'True'}),
             'upload_error_message': ('django.db.models.fields.CharField', [], {'max_length': '512', 'blank': 'True'}),
-            'upload_status': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
+            'upload_status': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '20', 'blank': 'True'}),
             'uploaded_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'db_index': 'True'}),
             'user_updated_at': ('django.db.models.fields.DateTimeField', [], {'db_index': 'True'})
         },
@@ -161,6 +190,7 @@ class Migration(SchemaMigration):
             'city': ('django.db.models.fields.CharField', [], {'max_length': '32', 'db_index': 'True'}),
             'client_candidate_id': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '50', 'db_index': 'True'}),
             'company_name': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '50', 'blank': 'True'}),
+            'confirmed_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'db_index': 'True'}),
             'country': ('django.db.models.fields.CharField', [], {'max_length': '3', 'db_index': 'True'}),
             'created_at': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'db_index': 'True', 'blank': 'True'}),
             'extension': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '8', 'blank': 'True'}),
@@ -173,6 +203,7 @@ class Migration(SchemaMigration):
             'phone': ('django.db.models.fields.CharField', [], {'max_length': '35'}),
             'phone_country_code': ('django.db.models.fields.CharField', [], {'max_length': '3', 'db_index': 'True'}),
             'postal_code': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '16', 'blank': 'True'}),
+            'processed_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'db_index': 'True'}),
             'salutation': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
             'state': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '20', 'blank': 'True'}),
             'suffix': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),

common/djangoapps/student/models.py

@@ -52,7 +52,6 @@ from django.dispatch import receiver
 from django.forms import ModelForm, forms
 
 import comment_client as cc
-from django_comment_client.models import Role
 
 log = logging.getLogger(__name__)
 
@@ -615,15 +614,22 @@ class CourseEnrollment(models.Model):
         return "[CourseEnrollment] %s: %s (%s)" % (self.user, self.course_id, self.created)
 
 
-@receiver(post_save, sender=CourseEnrollment)
-def assign_default_role(sender, instance, **kwargs):
-    if instance.user.is_staff:
-        role = Role.objects.get_or_create(course_id=instance.course_id, name="Moderator")[0]
-    else:
-        role = Role.objects.get_or_create(course_id=instance.course_id, name="Student")[0]
+class CourseEnrollmentAllowed(models.Model):
+    """
+    Table of users (specified by email address strings) who are allowed to enroll in a specified course.
+    The user may or may not (yet) exist.  Enrollment by users listed in this table is allowed
+    even if the enrollment time window is past.
+    """
+    email = models.CharField(max_length=255, db_index=True)
+    course_id = models.CharField(max_length=255, db_index=True)
+
+    created = models.DateTimeField(auto_now_add=True, null=True, db_index=True)
+
+    class Meta:
+        unique_together = (('email', 'course_id'), )
 
-    logging.info("assign_default_role: adding %s as %s" % (instance.user, role))
-    instance.user.roles.add(role)
+    def __unicode__(self):
+        return "[CourseEnrollmentAllowed] %s: %s (%s)" % (self.email, self.course_id, self.created)
 
 #cache_relation(User.profile)
 

common/djangoapps/student/views.py

@@ -42,7 +42,7 @@ from xmodule.modulestore.django import modulestore
 #from datetime import date
 from collections import namedtuple
 
-from courseware.courses import get_courses_by_university
+from courseware.courses import get_courses
 from courseware.access import has_access
 
 from statsd import statsd
@@ -76,16 +76,21 @@ def index(request, extra_context={}, user=None):
     domain = settings.MITX_FEATURES.get('FORCE_UNIVERSITY_DOMAIN')	# normally False
     if domain==False:				# do explicit check, because domain=None is valid
         domain = request.META.get('HTTP_HOST')
-    universities = get_courses_by_university(None,
-                                             domain=domain)
+
+    courses = get_courses(None, domain=domain)
+
+    # Sort courses by how far are they from they start day
+    key = lambda course: course.days_until_start
+    courses = sorted(courses, key=key, reverse=True)
 
     # Get the 3 most recent news
     top_news = _get_news(top=3)
 
-    context = {'universities': universities, 'news': top_news}
+    context = {'courses': courses, 'news': top_news}
     context.update(extra_context)
     return render_to_response('index.html', context)
 
+
 def course_from_id(course_id):
     """Return the CourseDescriptor corresponding to this course_id"""
     course_loc = CourseDescriptor.id_to_location(course_id)
@@ -338,6 +343,14 @@ def change_enrollment(request):
     return {'success': False, 'error': 'We weren\'t able to unenroll you. Please try again.'}
 
 
+@ensure_csrf_cookie
+def accounts_login(request, error=""):
+
+
+    return render_to_response('accounts_login.html', { 'error': error })
+
+
+
 # Need different levels of logging
 @ensure_csrf_cookie
 def login_user(request, error=""):

common/djangoapps/track/migrations/0001_initial.py

+# -*- coding: utf-8 -*-
+import datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Adding model 'TrackingLog'
+        db.create_table('track_trackinglog', (
+            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
+            ('dtcreated', self.gf('django.db.models.fields.DateTimeField')(auto_now_add=True, blank=True)),
+            ('username', self.gf('django.db.models.fields.CharField')(max_length=32, blank=True)),
+            ('ip', self.gf('django.db.models.fields.CharField')(max_length=32, blank=True)),
+            ('event_source', self.gf('django.db.models.fields.CharField')(max_length=32)),
+            ('event_type', self.gf('django.db.models.fields.CharField')(max_length=32, blank=True)),
+            ('event', self.gf('django.db.models.fields.TextField')(blank=True)),
+            ('agent', self.gf('django.db.models.fields.CharField')(max_length=256, blank=True)),
+            ('page', self.gf('django.db.models.fields.CharField')(max_length=32, null=True, blank=True)),
+            ('time', self.gf('django.db.models.fields.DateTimeField')()),
+        ))
+        db.send_create_signal('track', ['TrackingLog'])
+
+
+    def backwards(self, orm):
+        # Deleting model 'TrackingLog'
+        db.delete_table('track_trackinglog')
+
+
+    models = {
+        'track.trackinglog': {
+            'Meta': {'object_name': 'TrackingLog'},
+            'agent': ('django.db.models.fields.CharField', [], {'max_length': '256', 'blank': 'True'}),
+            'dtcreated': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
+            'event': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            'event_source': ('django.db.models.fields.CharField', [], {'max_length': '32'}),
+            'event_type': ('django.db.models.fields.CharField', [], {'max_length': '32', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'ip': ('django.db.models.fields.CharField', [], {'max_length': '32', 'blank': 'True'}),
+            'page': ('django.db.models.fields.CharField', [], {'max_length': '32', 'null': 'True', 'blank': 'True'}),
+            'time': ('django.db.models.fields.DateTimeField', [], {}),
+            'username': ('django.db.models.fields.CharField', [], {'max_length': '32', 'blank': 'True'})
+        }
+    }
+
+    complete_apps = ['track']
\ No newline at end of file

common/djangoapps/track/migrations/0002_auto__add_field_trackinglog_host__chg_field_trackinglog_event_type__ch.py

+# -*- coding: utf-8 -*-
+import datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Adding field 'TrackingLog.host'
+        db.add_column('track_trackinglog', 'host',
+                      self.gf('django.db.models.fields.CharField')(default='', max_length=64, blank=True),
+                      keep_default=False)
+
+
+        # Changing field 'TrackingLog.event_type'
+        db.alter_column('track_trackinglog', 'event_type', self.gf('django.db.models.fields.CharField')(max_length=512))
+
+        # Changing field 'TrackingLog.page'
+        db.alter_column('track_trackinglog', 'page', self.gf('django.db.models.fields.CharField')(max_length=512, null=True))
+
+    def backwards(self, orm):
+        # Deleting field 'TrackingLog.host'
+        db.delete_column('track_trackinglog', 'host')
+
+
+        # Changing field 'TrackingLog.event_type'
+        db.alter_column('track_trackinglog', 'event_type', self.gf('django.db.models.fields.CharField')(max_length=32))
+
+        # Changing field 'TrackingLog.page'
+        db.alter_column('track_trackinglog', 'page', self.gf('django.db.models.fields.CharField')(max_length=32, null=True))
+
+    models = {
+        'track.trackinglog': {
+            'Meta': {'object_name': 'TrackingLog'},
+            'agent': ('django.db.models.fields.CharField', [], {'max_length': '256', 'blank': 'True'}),
+            'dtcreated': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
+            'event': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            'event_source': ('django.db.models.fields.CharField', [], {'max_length': '32'}),
+            'event_type': ('django.db.models.fields.CharField', [], {'max_length': '512', 'blank': 'True'}),
+            'host': ('django.db.models.fields.CharField', [], {'max_length': '64', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'ip': ('django.db.models.fields.CharField', [], {'max_length': '32', 'blank': 'True'}),
+            'page': ('django.db.models.fields.CharField', [], {'max_length': '512', 'null': 'True', 'blank': 'True'}),
+            'time': ('django.db.models.fields.DateTimeField', [], {}),
+            'username': ('django.db.models.fields.CharField', [], {'max_length': '32', 'blank': 'True'})
+        }
+    }
+
+    complete_apps = ['track']
\ No newline at end of file

common/djangoapps/track/models.py

@@ -7,11 +7,12 @@ class TrackingLog(models.Model):
     username = models.CharField(max_length=32,blank=True)
     ip = models.CharField(max_length=32,blank=True)
     event_source = models.CharField(max_length=32)
-    event_type = models.CharField(max_length=32,blank=True)
+    event_type = models.CharField(max_length=512,blank=True)
     event = models.TextField(blank=True)
     agent = models.CharField(max_length=256,blank=True)
-    page = models.CharField(max_length=32,blank=True,null=True)
+    page = models.CharField(max_length=512,blank=True,null=True)
     time = models.DateTimeField('event time')
+    host = models.CharField(max_length=64,blank=True)
 
     def __unicode__(self):
         s = "[%s] %s@%s: %s | %s | %s | %s" % (self.time, self.username, self.ip, self.event_source,

common/djangoapps/track/views.py

@@ -17,7 +17,7 @@ from track.models import TrackingLog
 
 log = logging.getLogger("tracking")
 
-LOGFIELDS = ['username','ip','event_source','event_type','event','agent','page','time']
+LOGFIELDS = ['username','ip','event_source','event_type','event','agent','page','time','host']
 
 def log_event(event):
     event_str = json.dumps(event)
@@ -58,6 +58,7 @@ def user_track(request):
         "agent": agent,
         "page": request.GET['page'],
         "time": datetime.datetime.utcnow().isoformat(),
+        "host": request.META['SERVER_NAME'],
         }
     log_event(event)
     return HttpResponse('success')
@@ -83,6 +84,7 @@ def server_track(request, event_type, event, page=None):
         "agent": agent,
         "page": page,
         "time": datetime.datetime.utcnow().isoformat(),
+        "host": request.META['SERVER_NAME'],
         }
 
     if event_type.startswith("/event_logs") and request.user.is_staff:	# don't log

common/lib/capa/.coveragerc

@@ -7,6 +7,7 @@ source = common/lib/capa
 ignore_errors = True
 
 [html]
+title = Capa Python Test Coverage Report
 directory = reports/common/lib/capa/cover
 
 [xml]

common/lib/capa/capa/inputtypes.py

@@ -735,51 +735,3 @@ class ChemicalEquationInput(InputTypeBase):
 registry.register(ChemicalEquationInput)
 
 #-----------------------------------------------------------------------------
-
-class OpenEndedInput(InputTypeBase):
-    """
-    A text area input for code--uses codemirror, does syntax highlighting, special tab handling,
-    etc.
-    """
-
-    template = "openendedinput.html"
-    tags = ['openendedinput']
-
-    # pulled out for testing
-    submitted_msg = ("Feedback not yet available.  Reload to check again. "
-                     "Once the problem is graded, this message will be "
-                     "replaced with the grader's feedback")
-
-    @classmethod
-    def get_attributes(cls):
-        """
-        Convert options to a convenient format.
-        """
-        return [Attribute('rows', '30'),
-                Attribute('cols', '80'),
-                Attribute('hidden', ''),
-                ]
-
-    def setup(self):
-        """
-        Implement special logic: handle queueing state, and default input.
-        """
-        # if no student input yet, then use the default input given by the problem
-        if not self.value:
-            self.value = self.xml.text
-
-        # Check if problem has been queued
-        self.queue_len = 0
-        # Flag indicating that the problem has been queued, 'msg' is length of queue
-        if self.status == 'incomplete':
-            self.status = 'queued'
-            self.queue_len = self.msg
-            self.msg = self.submitted_msg
-
-    def _extra_context(self):
-        """Defined queue_len, add it """
-        return {'queue_len': self.queue_len,}
-
-registry.register(OpenEndedInput)
-
-#-----------------------------------------------------------------------------

common/lib/capa/capa/templates/openendedinput.html

-<section id="openended_${id}" class="openended">
-  <textarea rows="${rows}" cols="${cols}" name="input_${id}" class="short-form-response" id="input_${id}"
-       % if hidden:
-      	    style="display:none;"
-       % endif
-  >${value|h}</textarea>
-
-  <div class="grader-status">
-    % if status == 'unsubmitted':
-      <span class="unanswered" style="display:inline-block;" id="status_${id}">Unanswered</span>
-    % elif status == 'correct':
-      <span class="correct" id="status_${id}">Correct</span>
-    % elif status == 'incorrect':
-      <span class="incorrect" id="status_${id}">Incorrect</span>
-    % elif status == 'queued':
-      <span class="grading" id="status_${id}">Submitted for grading</span>
-    % endif
-
-    % if hidden:
-      <div style="display:none;" name="${hidden}" inputid="input_${id}" />
-    % endif
-  </div>
-
-  <span id="answer_${id}"></span>
-
-    % if status == 'queued':
-    <input name="reload" class="reload" type="button" value="Recheck for Feedback" onclick="document.location.reload(true);" />
-    % endif
-  <div class="external-grader-message">
-    ${msg|n}
-  </div>
-</section>

common/lib/xmodule/.coveragerc

@@ -7,6 +7,7 @@ source = common/lib/xmodule
 ignore_errors = True
 
 [html]
+title = XModule Python Test Coverage Report
 directory = reports/common/lib/xmodule/cover
 
 [xml]

common/lib/xmodule/setup.py

@@ -19,6 +19,7 @@ setup(
             "abtest = xmodule.abtest_module:ABTestDescriptor",
             "book = xmodule.backcompat_module:TranslateCustomTagDescriptor",
             "chapter = xmodule.seq_module:SequenceDescriptor",
+            "combinedopenended = xmodule.combined_open_ended_module:CombinedOpenEndedDescriptor",
             "course = xmodule.course_module:CourseDescriptor",
             "customtag = xmodule.template_module:CustomTagDescriptor",
             "discuss = xmodule.backcompat_module:TranslateCustomTagDescriptor",
@@ -28,7 +29,6 @@ setup(
             "problem = xmodule.capa_module:CapaDescriptor",
             "problemset = xmodule.seq_module:SequenceDescriptor",
             "section = xmodule.backcompat_module:SemanticSectionDescriptor",
-            "selfassessment = xmodule.self_assessment_module:SelfAssessmentDescriptor",
             "sequential = xmodule.seq_module:SequenceDescriptor",
             "slides = xmodule.backcompat_module:TranslateCustomTagDescriptor",
             "vertical = xmodule.vertical_module:VerticalDescriptor",
@@ -36,6 +36,7 @@ setup(
             "videodev = xmodule.backcompat_module:TranslateCustomTagDescriptor",
             "videosequence = xmodule.seq_module:SequenceDescriptor",
             "discussion = xmodule.discussion_module:DiscussionDescriptor",
+            "graphical_slider_tool = xmodule.gst_module:GraphicalSliderToolDescriptor",
         ]
     }
 )

common/lib/xmodule/xmodule/capa_module.py

@@ -430,6 +430,7 @@ class CapaModule(XModule):
 
         return False
 
+
     def update_score(self, get):
         """
         Delivers grading response (e.g. from asynchronous code checking) to

common/lib/xmodule/xmodule/combined_open_ended_rubric.py

+from mitxmako.shortcuts import render_to_string
+import logging
+from lxml import etree
+
+log=logging.getLogger(__name__)
+
+class CombinedOpenEndedRubric:
+
+    @staticmethod
+    def render_rubric(rubric_xml):
+        try:
+            rubric_categories = CombinedOpenEndedRubric.extract_rubric_categories(rubric_xml)
+            html = render_to_string('open_ended_rubric.html', {'rubric_categories'  : rubric_categories})
+        except:
+            log.exception("Could not parse the rubric.")
+            html = rubric_xml
+        return html
+
+    @staticmethod
+    def extract_rubric_categories(element):
+        '''
+        Contstruct a list of categories such that the structure looks like:
+        [ { category: "Category 1 Name",
+            options: [{text: "Option 1 Name", points: 0}, {text:"Option 2 Name", points: 5}]
+            },
+           { category: "Category 2 Name",
+             options: [{text: "Option 1 Name", points: 0},
+                         {text: "Option 2 Name", points: 1},
+                         {text: "Option 3 Name", points: 2]}]
+
+        '''
+        element = etree.fromstring(element)
+        categories = []
+        for category in element:
+            if category.tag != 'category':
+                raise Exception("[capa.inputtypes.extract_categories] Expected a <category> tag: got {0} instead".format(category.tag))
+            else:
+                categories.append(CombinedOpenEndedRubric.extract_category(category))
+        return categories
+
+    @staticmethod
+    def extract_category(category):
+        '''
+        construct an individual category
+        {category: "Category 1 Name",
+         options: [{text: "Option 1 text", points: 1},
+                   {text: "Option 2 text", points: 2}]}
+
+        all sorting and auto-point generation occurs in this function
+        '''
+
+        has_score=False
+        descriptionxml = category[0]
+        scorexml = category[1]
+        if scorexml.tag == "option":
+            optionsxml = category[1:]
+        else:
+            optionsxml = category[2:]
+            has_score=True
+
+        # parse description
+        if descriptionxml.tag != 'description':
+            raise Exception("[extract_category]: expected description tag, got {0} instead".format(descriptionxml.tag))
+
+        if has_score:
+            if scorexml.tag != 'score':
+                raise Exception("[extract_category]: expected score tag, got {0} instead".format(scorexml.tag))
+
+        for option in optionsxml:
+            if option.tag != "option":
+                raise Exception("[extract_category]: expected option tag, got {0} instead".format(option.tag))
+
+        description = descriptionxml.text
+
+        if has_score:
+            score = int(scorexml.text)
+        else:
+            score = 0
+
+        cur_points = 0
+        options = []
+        autonumbering = True
+        # parse options
+        for option in optionsxml:
+            if option.tag != 'option':
+                raise Exception("[extract_category]: expected option tag, got {0} instead".format(option.tag))
+            else:
+                pointstr = option.get("points")
+                if pointstr:
+                    autonumbering = False
+                    # try to parse this into an int
+                    try:
+                        points = int(pointstr)
+                    except ValueError:
+                        raise Exception("[extract_category]: expected points to have int, got {0} instead".format(pointstr))
+                elif autonumbering:
+                    # use the generated one if we're in the right mode
+                    points = cur_points
+                    cur_points = cur_points + 1
+                else:
+                    raise Exception("[extract_category]: missing points attribute. Cannot continue to auto-create points values after a points value is explicitly dfined.")
+                optiontext = option.text
+                selected = False
+                if has_score:
+                    if points == score:
+                        selected = True
+                options.append({'text': option.text, 'points': points, 'selected' : selected})
+
+        # sort and check for duplicates
+        options = sorted(options, key=lambda option: option['points'])
+        CombinedOpenEndedRubric.validate_options(options)
+
+        return {'description': description, 'options': options, 'score' : score, 'has_score' : has_score}
+
+    @staticmethod
+    def validate_options(options):
+        '''
+        Validates a set of options. This can and should be extended to filter out other bad edge cases
+        '''
+        if len(options) == 0:
+            raise Exception("[extract_category]: no options associated with this category")
+        if len(options) == 1:
+            return
+        prev = options[0]['points']
+        for option in options[1:]:
+            if prev == option['points']:
+                raise Exception("[extract_category]: found duplicate point values between two different options")
+            else:
+                prev = option['points']
\ No newline at end of file

common/lib/xmodule/xmodule/course_module.py

-from fs.errors import ResourceNotFoundError
 import logging
 from lxml import etree
-from path import path # NOTE (THK): Only used for detecting presence of syllabus
+from path import path  # NOTE (THK): Only used for detecting presence of syllabus
 import requests
 import time
+from datetime import datetime
 
 from xmodule.util.decorators import lazyproperty
 from xmodule.graders import load_grading_policy
@@ -13,6 +13,7 @@ from xmodule.timeparse import parse_time, stringify_time
 
 log = logging.getLogger(__name__)
 
+
 class CourseDescriptor(SequenceDescriptor):
     module_class = SequenceModule
 
@@ -115,7 +116,8 @@ class CourseDescriptor(SequenceDescriptor):
         """Parse the policy specified in policy_str, and save it"""
         try:
             self._grading_policy = load_grading_policy(policy_str)
-        except:
+        except Exception, err:
+            log.exception('Failed to load grading policy:')
             self.system.error_tracker("Failed to load grading policy")
             # Setting this to an empty dictionary will lead to errors when
             # grading needs to happen, but should allow course staff to see
@@ -179,6 +181,38 @@ class CourseDescriptor(SequenceDescriptor):
     def show_calculator(self):
         return self.metadata.get("show_calculator", None) == "Yes"
 
+    @property
+    def is_new(self):
+        # The course is "new" if either if the metadata flag is_new is
+        # true or if the course has not started yet
+        flag = self.metadata.get('is_new', None)
+        if flag is None:
+            return self.days_until_start > 1
+        elif isinstance(flag, basestring):
+            return flag.lower() in ['true', 'yes', 'y']
+        else:
+            return bool(flag)
+
+    @property
+    def days_until_start(self):
+        def convert_to_datetime(timestamp):
+            return datetime.fromtimestamp(time.mktime(timestamp))
+
+        start_date = convert_to_datetime(self.start)
+
+        #  Try to use course advertised date if we can parse it
+        advertised_start = self.metadata.get('advertised_start', None)
+        if advertised_start:
+            try:
+                start_date = datetime.strptime(advertised_start,
+                                               "%Y-%m-%dT%H:%M")
+            except ValueError:
+                pass  # Invalid date, keep using 'start''
+
+        now = convert_to_datetime(time.gmtime())
+        days_until_start = (start_date - now).days
+        return days_until_start
+
     @lazyproperty
     def grading_context(self):
         """
@@ -258,7 +292,6 @@ class CourseDescriptor(SequenceDescriptor):
             raise ValueError("{0} is not a course location".format(loc))
         return "/".join([loc.org, loc.course, loc.name])
 
-
     @property
     def id(self):
         """Return the course_id for this course"""
@@ -266,7 +299,20 @@ class CourseDescriptor(SequenceDescriptor):
 
     @property
     def start_date_text(self):
-        displayed_start = self._try_parse_time('advertised_start') or self.start
+        parsed_advertised_start = self._try_parse_time('advertised_start')
+
+        # If the advertised start isn't a real date string, we assume it's free
+        # form text...
+        if parsed_advertised_start is None and \
+           ('advertised_start' in self.metadata):
+            return self.metadata['advertised_start']
+
+        displayed_start = parsed_advertised_start or self.start
+
+        # If we have neither an advertised start or a real start, just return TBD
+        if not displayed_start:
+            return "TBD"
+
         return time.strftime("%b %d, %Y", displayed_start)
 
     @property
@@ -424,4 +470,3 @@ class CourseDescriptor(SequenceDescriptor):
     @property
     def org(self):
         return self.location.org
-

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

@@ -297,6 +297,51 @@ section.problem {
           float: left;
         }
       }
+
+    }
+    .evaluation {
+        p {
+            margin-bottom: 4px;
+        }
+    }
+
+
+    .feedback-on-feedback {
+        height: 100px;
+        margin-right: 20px;
+    }
+
+    .evaluation-response {
+        header {
+            text-align: right;
+            a {
+                font-size: .85em;
+            }
+        }
+    }
+
+    .evaluation-scoring {
+        .scoring-list {
+            list-style-type: none;
+            margin-left: 3px;
+
+            li {
+                &:first-child {
+                    margin-left: 0px;
+                }
+                display:inline;
+                margin-left: 50px;
+
+                label {
+                    font-size: .9em;
+                }
+
+            }
+        }
+
+    }
+    .submit-message-container {
+        margin: 10px 0px ;
     }
   }
 
@@ -634,6 +679,10 @@ section.problem {
       color: #2C2C2C;
       font-family: monospace;
       font-size: 1em;
+      padding-top: 10px;
+      header {
+          font-size: 1.4em;
+      }
 
       .shortform {
         font-weight: bold;

common/lib/xmodule/xmodule/graders.py

@@ -316,7 +316,7 @@ class AssignmentFormatGrader(CourseGrader):
     min_count = 2 would produce the labels "Assignment 3", "Assignment 4"
 
     """
-    def __init__(self, type, min_count, drop_count, category=None, section_type=None, short_label=None, show_only_average=False, starting_index=1):
+    def __init__(self, type, min_count, drop_count, category=None, section_type=None, short_label=None, show_only_average=False, hide_average=False, starting_index=1):
         self.type = type
         self.min_count = min_count
         self.drop_count = drop_count
@@ -325,6 +325,7 @@ class AssignmentFormatGrader(CourseGrader):
         self.short_label = short_label or self.type
         self.show_only_average = show_only_average
         self.starting_index = starting_index
+        self.hide_average = hide_average
 
     def grade(self, grade_sheet, generate_random_scores=False):
         def totalWithDrops(breakdown, drop_count):
@@ -385,7 +386,8 @@ class AssignmentFormatGrader(CourseGrader):
         if self.show_only_average:
             breakdown = []
         
-        breakdown.append({'percent': total_percent, 'label': total_label, 'detail': total_detail, 'category': self.category, 'prominent': True})
+        if not self.hide_average:
+            breakdown.append({'percent': total_percent, 'label': total_label, 'detail': total_detail, 'category': self.category, 'prominent': True})
         
         return {'percent': total_percent,
                 'section_breakdown': breakdown,

common/lib/xmodule/xmodule/gst_module.py

+"""
+Graphical slider tool module is ungraded xmodule used by students to
+understand functional dependencies.
+"""
+
+import json
+import logging
+from lxml import etree
+from lxml import html
+import xmltodict
+
+from xmodule.mako_module import MakoModuleDescriptor
+from xmodule.xml_module import XmlDescriptor
+from xmodule.x_module import XModule
+from xmodule.stringify import stringify_children
+from pkg_resources import resource_string
+
+
+log = logging.getLogger(__name__)
+
+
+class GraphicalSliderToolModule(XModule):
+    ''' Graphical-Slider-Tool Module
+    '''
+
+    js = {
+      'js': [
+        # 3rd party libraries used by graphic slider tool.
+        # TODO - where to store them - outside xmodule?
+        resource_string(__name__, 'js/src/graphical_slider_tool/jstat-1.0.0.min.js'),
+
+        resource_string(__name__, 'js/src/graphical_slider_tool/gst_main.js'),
+        resource_string(__name__, 'js/src/graphical_slider_tool/state.js'),
+        resource_string(__name__, 'js/src/graphical_slider_tool/logme.js'),
+        resource_string(__name__, 'js/src/graphical_slider_tool/general_methods.js'),
+        resource_string(__name__, 'js/src/graphical_slider_tool/sliders.js'),
+        resource_string(__name__, 'js/src/graphical_slider_tool/inputs.js'),
+        resource_string(__name__, 'js/src/graphical_slider_tool/graph.js'),
+        resource_string(__name__, 'js/src/graphical_slider_tool/el_output.js'),
+        resource_string(__name__, 'js/src/graphical_slider_tool/g_label_el_output.js'),
+
+        resource_string(__name__, 'js/src/graphical_slider_tool/gst.js')
+      ]
+    }
+    js_module_name = "GraphicalSliderTool"
+
+    def __init__(self, system, location, definition, descriptor, instance_state=None,
+                 shared_state=None, **kwargs):
+        """
+        For XML file format please look at documentation. TODO - receive
+        information where to store XML documentation.
+        """
+        XModule.__init__(self, system, location, definition, descriptor,
+                         instance_state, shared_state, **kwargs)
+
+    def get_html(self):
+        """ Renders parameters to template. """
+
+        # these 3 will be used in class methods
+        self.html_id = self.location.html_id()
+        self.html_class = self.location.category
+        self.configuration_json = self.build_configuration_json()
+        params = {
+                  'gst_html': self.substitute_controls(self.definition['render']),
+                  'element_id': self.html_id,
+                  'element_class': self.html_class,
+                  'configuration_json': self.configuration_json
+                  }
+        self.content = self.system.render_template(
+                        'graphical_slider_tool.html', params)
+        return self.content
+
+    def substitute_controls(self, html_string):
+        """ Substitutes control elements (slider, textbox and plot) in
+        html_string with their divs. Html_string is content of <render> tag
+        inside <graphical_slider_tool> tag. Documentation on how information in
+        <render> tag is organized and processed is located in:
+        mitx/docs/build/html/graphical_slider_tool.html.
+
+        Args:
+            html_string: content of <render> tag, with controls as xml tags,
+                         e.g. <slider var="a"/>.
+
+        Returns:
+                html_string with control tags replaced by proper divs
+                (<slider var="a"/> -> <div class="....slider" > </div>)
+        """
+
+        xml = html.fromstring(html_string)
+
+        #substitute plot, if presented
+        plot_div = '<div class="{element_class}_plot" id="{element_id}_plot" \
+                    style="{style}"></div>'
+        plot_el = xml.xpath('//plot')
+        if plot_el:
+            plot_el = plot_el[0]
+            plot_el.getparent().replace(plot_el, html.fromstring(
+                                plot_div.format(element_class=self.html_class,
+                                               element_id=self.html_id,
+                                               style=plot_el.get('style', ""))))
+
+        #substitute sliders
+        slider_div = '<div class="{element_class}_slider" \
+                                   id="{element_id}_slider_{var}" \
+                                   data-var="{var}" \
+                                   style="{style}">\
+                     </div>'
+        slider_els = xml.xpath('//slider')
+        for slider_el in slider_els:
+            slider_el.getparent().replace(slider_el, html.fromstring(
+                                slider_div.format(element_class=self.html_class,
+                                    element_id=self.html_id,
+                                    var=slider_el.get('var', ""),
+                                    style=slider_el.get('style', ""))))
+
+        # substitute inputs aka textboxes
+        input_div = '<input class="{element_class}_input" \
+                                  id="{element_id}_input_{var}_{input_index}" \
+                                   data-var="{var}" style="{style}"/>'
+        input_els = xml.xpath('//textbox')
+        for input_index, input_el in enumerate(input_els):
+            input_el.getparent().replace(input_el, html.fromstring(
+                                input_div.format(element_class=self.html_class,
+                                        element_id=self.html_id,
+                                        var=input_el.get('var', ""),
+                                        style=input_el.get('style', ""),
+                                        input_index=input_index)))
+
+        return html.tostring(xml)
+
+    def build_configuration_json(self):
+        """Creates json element from xml element (with aim to transfer later
+         directly to javascript via hidden field in template). Steps:
+
+            1. Convert xml tree to python dict.
+
+            2. Dump dict to json.
+
+        """
+        # <root> added for interface compatibility with xmltodict.parse
+        # class added for javascript's part purposes
+        return json.dumps(xmltodict.parse('<root class="' + self.html_class +
+                '">' + self.definition['configuration'] + '</root>'))
+
+
+class GraphicalSliderToolDescriptor(MakoModuleDescriptor, XmlDescriptor):
+    module_class = GraphicalSliderToolModule
+    template_dir_name = 'graphical_slider_tool'
+
+    @classmethod
+    def definition_from_xml(cls, xml_object, system):
+        """
+        Pull out the data into dictionary.
+
+        Args:
+            xml_object: xml from file.
+
+        Returns:
+            dict
+        """
+        # check for presense of required tags in xml
+        expected_children_level_0 = ['render', 'configuration']
+        for child in expected_children_level_0:
+            if len(xml_object.xpath(child)) != 1:
+                raise ValueError("Graphical Slider Tool definition must include \
+                    exactly one '{0}' tag".format(child))
+
+        expected_children_level_1 = ['functions']
+        for child in expected_children_level_1:
+            if len(xml_object.xpath('configuration')[0].xpath(child)) != 1:
+                raise ValueError("Graphical Slider Tool definition must include \
+                    exactly one '{0}' tag".format(child))
+        # finished
+
+        def parse(k):
+            """Assumes that xml_object has child k"""
+            return stringify_children(xml_object.xpath(k)[0])
+        return {
+                    'render': parse('render'),
+                    'configuration': parse('configuration')
+                }
+
+    def definition_to_xml(self, resource_fs):
+        '''Return an xml element representing this definition.'''
+        xml_object = etree.Element('graphical_slider_tool')
+
+        def add_child(k):
+            child_str = '<{tag}>{body}</{tag}>'.format(tag=k, body=self.definition[k])
+            child_node = etree.fromstring(child_str)
+            xml_object.append(child_node)
+
+        for child in ['render', 'configuration']:
+            add_child(child)
+
+        return xml_object

common/lib/xmodule/xmodule/js/src/collapsible.coffee

@@ -22,7 +22,7 @@ class @Collapsible
     if $(event.target).text() == 'See full output'
       new_text = 'Hide output'
     else
-      new_text = 'See full ouput'
+      new_text = 'See full output'
     $(event.target).text(new_text)
 
   @toggleHint: (event) =>

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

+class @CombinedOpenEnded
+  constructor: (element) ->
+    @element=element
+    @reinitialize(element)
+
+  reinitialize: (element) ->
+    @wrapper=$(element).find('section.xmodule_CombinedOpenEndedModule')
+    @el = $(element).find('section.combined-open-ended')
+    @combined_open_ended=$(element).find('section.combined-open-ended')
+    @id = @el.data('id')
+    @ajax_url = @el.data('ajax-url')
+    @state = @el.data('state')
+    @task_count = @el.data('task-count')
+    @task_number = @el.data('task-number')
+
+    @allow_reset = @el.data('allow_reset')
+    @reset_button = @$('.reset-button')
+    @reset_button.click @reset
+    @next_problem_button = @$('.next-step-button')
+    @next_problem_button.click @next_problem
+
+    @show_results_button=@$('.show-results-button')
+    @show_results_button.click @show_results
+
+    # valid states: 'initial', 'assessing', 'post_assessment', 'done'
+    Collapsible.setCollapsibles(@el)
+    @submit_evaluation_button = $('.submit-evaluation-button')
+    @submit_evaluation_button.click @message_post
+
+    @results_container = $('.result-container')
+
+    # Where to put the rubric once we load it
+    @el = $(element).find('section.open-ended-child')
+    @errors_area = @$('.error')
+    @answer_area = @$('textarea.answer')
+
+    @rubric_wrapper = @$('.rubric-wrapper')
+    @hint_wrapper = @$('.hint-wrapper')
+    @message_wrapper = @$('.message-wrapper')
+    @submit_button = @$('.submit-button')
+    @child_state = @el.data('state')
+    @child_type = @el.data('child-type')
+    if @child_type=="openended"
+      @skip_button = @$('.skip-button')
+      @skip_button.click @skip_post_assessment
+
+    @open_ended_child= @$('.open-ended-child')
+
+    @find_assessment_elements()
+    @find_hint_elements()
+
+    @rebind()
+
+  # locally scoped jquery.
+  $: (selector) ->
+    $(selector, @el)
+
+  show_results: (event) =>
+    status_item = $(event.target).parent().parent()
+    status_number = status_item.data('status-number')
+    data = {'task_number' : status_number}
+    $.postWithPrefix "#{@ajax_url}/get_results", data, (response) =>
+      if response.success
+        @results_container.after(response.html).remove()
+        @results_container = $('div.result-container')
+        @submit_evaluation_button = $('.submit-evaluation-button')
+        @submit_evaluation_button.click @message_post
+        Collapsible.setCollapsibles(@results_container)
+      else
+        @errors_area.html(response.error)
+
+  message_post: (event)=>
+    Logger.log 'message_post', @answers
+    external_grader_message=$(event.target).parent().parent().parent()
+    evaluation_scoring = $(event.target).parent()
+
+    fd = new FormData()
+    feedback = evaluation_scoring.find('textarea.feedback-on-feedback')[0].value
+    submission_id = external_grader_message.find('input.submission_id')[0].value
+    grader_id = external_grader_message.find('input.grader_id')[0].value
+    score = evaluation_scoring.find("input:radio[name='evaluation-score']:checked").val()
+
+    fd.append('feedback', feedback)
+    fd.append('submission_id', submission_id)
+    fd.append('grader_id', grader_id)
+    if(!score)
+      @gentle_alert "You need to pick a rating before you can submit."
+      return
+    else
+      fd.append('score', score)
+
+    settings =
+      type: "POST"
+      data: fd
+      processData: false
+      contentType: false
+      success: (response) =>
+        @gentle_alert response.msg
+        $('section.evaluation').slideToggle()
+        @message_wrapper.html(response.message_html)
+
+    $.ajaxWithPrefix("#{@ajax_url}/save_post_assessment", settings)
+
+
+  rebind: () =>
+    # rebind to the appropriate function for the current state
+    @submit_button.unbind('click')
+    @submit_button.show()
+    @reset_button.hide()
+    @next_problem_button.hide()
+    @hint_area.attr('disabled', false)
+
+    if @child_type=="openended"
+      @skip_button.hide()
+    if @allow_reset=="True"
+      @reset_button.show()
+      @submit_button.hide()
+      @answer_area.attr("disabled", true)
+      @hint_area.attr('disabled', true)
+    else if @child_state == 'initial'
+      @answer_area.attr("disabled", false)
+      @submit_button.prop('value', 'Submit')
+      @submit_button.click @save_answer
+    else if @child_state == 'assessing'
+      @answer_area.attr("disabled", true)
+      @submit_button.prop('value', 'Submit assessment')
+      @submit_button.click @save_assessment
+      if @child_type == "openended"
+        @submit_button.hide()
+        @queueing()
+    else if @child_state == 'post_assessment'
+      if @child_type=="openended"
+        @skip_button.show()
+        @skip_post_assessment()
+      @answer_area.attr("disabled", true)
+      @submit_button.prop('value', 'Submit post-assessment')
+      if @child_type=="selfassessment"
+         @submit_button.click @save_hint
+      else
+        @submit_button.click @message_post
+    else if @child_state == 'done'
+      @answer_area.attr("disabled", true)
+      @hint_area.attr('disabled', true)
+      @submit_button.hide()
+      if @child_type=="openended"
+        @skip_button.hide()
+      if @task_number<@task_count
+        @next_problem()
+      else
+        @reset_button.show()
+
+
+  find_assessment_elements: ->
+    @assessment = @$('select.assessment')
+
+  find_hint_elements: ->
+    @hint_area = @$('textarea.post_assessment')
+
+  save_answer: (event) =>
+    event.preventDefault()
+    if @child_state == 'initial'
+      data = {'student_answer' : @answer_area.val()}
+      $.postWithPrefix "#{@ajax_url}/save_answer", data, (response) =>
+        if response.success
+          @rubric_wrapper.html(response.rubric_html)
+          @child_state = 'assessing'
+          @find_assessment_elements()
+          @rebind()
+        else
+          @errors_area.html(response.error)
+    else
+      @errors_area.html('Problem state got out of sync.  Try reloading the page.')
+
+  save_assessment: (event) =>
+    event.preventDefault()
+    if @child_state == 'assessing'
+      data = {'assessment' : @assessment.find(':selected').text()}
+      $.postWithPrefix "#{@ajax_url}/save_assessment", data, (response) =>
+        if response.success
+          @child_state = response.state
+
+          if @child_state == 'post_assessment'
+            @hint_wrapper.html(response.hint_html)
+            @find_hint_elements()
+          else if @child_state == 'done'
+            @message_wrapper.html(response.message_html)
+
+          @rebind()
+        else
+          @errors_area.html(response.error)
+    else
+      @errors_area.html('Problem state got out of sync.  Try reloading the page.')
+
+  save_hint:  (event) =>
+    event.preventDefault()
+    if @child_state == 'post_assessment'
+      data = {'hint' : @hint_area.val()}
+
+      $.postWithPrefix "#{@ajax_url}/save_post_assessment", data, (response) =>
+        if response.success
+          @message_wrapper.html(response.message_html)
+          @child_state = 'done'
+          @rebind()
+        else
+          @errors_area.html(response.error)
+    else
+      @errors_area.html('Problem state got out of sync.  Try reloading the page.')
+
+  skip_post_assessment: =>
+    if @child_state == 'post_assessment'
+
+      $.postWithPrefix "#{@ajax_url}/skip_post_assessment", {}, (response) =>
+        if response.success
+          @child_state = 'done'
+          @rebind()
+        else
+          @errors_area.html(response.error)
+    else
+      @errors_area.html('Problem state got out of sync.  Try reloading the page.')
+
+  reset: (event) =>
+    event.preventDefault()
+    if @child_state == 'done' or @allow_reset=="True"
+      $.postWithPrefix "#{@ajax_url}/reset", {}, (response) =>
+        if response.success
+          @answer_area.val('')
+          @rubric_wrapper.html('')
+          @hint_wrapper.html('')
+          @message_wrapper.html('')
+          @child_state = 'initial'
+          @combined_open_ended.after(response.html).remove()
+          @allow_reset="False"
+          @reinitialize(@element)
+          @rebind()
+          @reset_button.hide()
+        else
+          @errors_area.html(response.error)
+    else
+      @errors_area.html('Problem state got out of sync.  Try reloading the page.')
+
+  next_problem: =>
+    if @child_state == 'done'
+      $.postWithPrefix "#{@ajax_url}/next_problem", {}, (response) =>
+        if response.success
+          @answer_area.val('')
+          @rubric_wrapper.html('')
+          @hint_wrapper.html('')
+          @message_wrapper.html('')
+          @child_state = 'initial'
+          @combined_open_ended.after(response.html).remove()
+          @reinitialize(@element)
+          @rebind()
+          @next_problem_button.hide()
+          if !response.allow_reset
+            @gentle_alert "Moved to next step."
+          else
+            @gentle_alert "Your score did not meet the criteria to move to the next step."
+        else
+          @errors_area.html(response.error)
+    else
+      @errors_area.html('Problem state got out of sync.  Try reloading the page.')
+
+  gentle_alert: (msg) =>
+    if @el.find('.open-ended-alert').length
+      @el.find('.open-ended-alert').remove()
+    alert_elem = "<div class='open-ended-alert'>" + msg + "</div>"
+    @el.find('.open-ended-action').after(alert_elem)
+    @el.find('.open-ended-alert').css(opacity: 0).animate(opacity: 1, 700)
+
+  queueing: =>
+    if @child_state=="assessing" and @child_type=="openended"
+      if window.queuePollerID # Only one poller 'thread' per Problem
+        window.clearTimeout(window.queuePollerID)
+      window.queuePollerID = window.setTimeout(@poll, 10000)
+
+  poll: =>
+    $.postWithPrefix "#{@ajax_url}/check_for_score", (response) =>
+      if response.state == "done" or response.state=="post_assessment"
+        delete window.queuePollerID
+        location.reload()
+      else
+        window.queuePollerID = window.setTimeout(@poll, 10000)
\ No newline at end of file

common/lib/xmodule/xmodule/js/src/graphical_slider_tool/el_output.js

+// Wrapper for RequireJS. It will make the standard requirejs(), require(), and
+// define() functions from Require JS available inside the anonymous function.
+(function (requirejs, require, define) {
+
+define('ElOutput', ['logme'], function (logme) {
+
+    return ElOutput;
+
+    function ElOutput(config, state) {
+
+        if ($.isPlainObject(config.functions.function)) {
+            processFuncObj(config.functions.function);
+        } else if ($.isArray(config.functions.function)) {
+            (function (c1) {
+                while (c1 < config.functions.function.length) {
+                    if ($.isPlainObject(config.functions.function[c1])) {
+                        processFuncObj(config.functions.function[c1]);
+                    }
+
+                    c1 += 1;
+                }
+            }(0));
+        }
+
+        return;
+
+        function processFuncObj(obj) {
+            var paramNames, funcString, func, el, disableAutoReturn, updateOnEvent;
+
+            // We are only interested in functions that are meant for output to an
+            // element.
+            if (
+                (typeof obj['@output'] !== 'string') ||
+                ((obj['@output'].toLowerCase() !== 'element') && (obj['@output'].toLowerCase() !== 'none'))
+            ) {
+                return;
+            }
+
+            if (typeof obj['@el_id'] !== 'string') {
+                logme('ERROR: You specified "output" as "element", but did not spify "el_id".');
+
+                return;
+            }
+
+            if (typeof obj['#text'] !== 'string') {
+                logme('ERROR: Function body is not defined.');
+
+                return;
+            }
+
+            updateOnEvent = 'slide';
+            if (
+                (obj.hasOwnProperty('@update_on') === true) &&
+                (typeof obj['@update_on'] === 'string') &&
+                ((obj['@update_on'].toLowerCase() === 'slide') || (obj['@update_on'].toLowerCase() === 'change'))
+            ) {
+                updateOnEvent = obj['@update_on'].toLowerCase();
+            }
+
+            disableAutoReturn = obj['@disable_auto_return'];
+
+            funcString = obj['#text'];
+
+            if (
+                (disableAutoReturn === undefined) ||
+                    (
+                        (typeof disableAutoReturn === 'string') &&
+                        (disableAutoReturn.toLowerCase() !== 'true')
+                    )
+            ) {
+                if (funcString.search(/return/i) === -1) {
+                    funcString = 'return ' + funcString;
+                }
+            } else {
+                if (funcString.search(/return/i) === -1) {
+                    logme(
+                        'ERROR: You have specified a JavaScript ' +
+                        'function without a "return" statemnt. Your ' +
+                        'function will return "undefined" by default.'
+                    );
+                }
+            }
+
+            // Make sure that all HTML entities are converted to their proper
+            // ASCII text equivalents.
+            funcString = $('<div>').html(funcString).text();
+
+            paramNames = state.getAllParameterNames();
+            paramNames.push(funcString);
+
+            try {
+                func = Function.apply(null, paramNames);
+            } catch (err) {
+                logme(
+                    'ERROR: The function body "' +
+                        funcString +
+                        '" was not converted by the Function constructor.'
+                );
+                logme('Error message: "' + err.message + '".');
+
+                $('#' + gstId).html('<div style="color: red;">' + 'ERROR IN XML: Could not create a function from string "' + funcString + '".' + '</div>');
+                $('#' + gstId).append('<div style="color: red;">' + 'Error message: "' + err.message + '".' + '</div>');
+
+                paramNames.pop();
+
+                return;
+            }
+
+            paramNames.pop();
+
+            if (obj['@output'].toLowerCase() !== 'none') {
+                el = $('#' + obj['@el_id']);
+
+                if (el.length !== 1) {
+                    logme(
+                        'ERROR: DOM element with ID "' + obj['@el_id'] + '" ' +
+                        'not found. Dynamic element not created.'
+                    );
+
+                    return;
+                }
+
+                el.html(func.apply(window, state.getAllParameterValues()));
+            } else {
+                el = null;
+                func.apply(window, state.getAllParameterValues());
+            }
+
+            state.addDynamicEl(el, func, obj['@el_id'], updateOnEvent);
+        }
+
+    }
+});
+
+// End of wrapper for RequireJS. As you can see, we are passing
+// namespaced Require JS variables to an anonymous function. Within
+// it, you can use the standard requirejs(), require(), and define()
+// functions as if they were in the global namespace.
+}(RequireJS.requirejs, RequireJS.require, RequireJS.define)); // End-of: (function (requirejs, require, define)

common/lib/xmodule/xmodule/js/src/graphical_slider_tool/g_label_el_output.js

+// Wrapper for RequireJS. It will make the standard requirejs(), require(), and
+// define() functions from Require JS available inside the anonymous function.
+(function (requirejs, require, define) {
+
+define('GLabelElOutput', ['logme'], function (logme) {
+    return GLabelElOutput;
+
+    function GLabelElOutput(config, state) {
+        if ($.isPlainObject(config.functions.function)) {
+            processFuncObj(config.functions.function);
+        } else if ($.isArray(config.functions.function)) {
+            (function (c1) {
+                while (c1 < config.functions.function.length) {
+                    if ($.isPlainObject(config.functions.function[c1])) {
+                        processFuncObj(config.functions.function[c1]);
+                    }
+
+                    c1 += 1;
+                }
+            }(0));
+        }
+
+        return;
+
+        function processFuncObj(obj) {
+            var paramNames, funcString, func, disableAutoReturn;
+
+            // We are only interested in functions that are meant for output to an
+            // element.
+            if (
+                (typeof obj['@output'] !== 'string') ||
+                (obj['@output'].toLowerCase() !== 'plot_label')
+            ) {
+                return;
+            }
+
+            if (typeof obj['@el_id'] !== 'string') {
+                logme('ERROR: You specified "output" as "plot_label", but did not spify "el_id".');
+
+                return;
+            }
+
+            if (typeof obj['#text'] !== 'string') {
+                logme('ERROR: Function body is not defined.');
+
+                return;
+            }
+
+            disableAutoReturn = obj['@disable_auto_return'];
+
+            funcString = obj['#text'];
+
+            if (
+                (disableAutoReturn === undefined) ||
+                    (
+                        (typeof disableAutoReturn === 'string') &&
+                        (disableAutoReturn.toLowerCase() !== 'true')
+                    )
+            ) {
+                if (funcString.search(/return/i) === -1) {
+                    funcString = 'return ' + funcString;
+                }
+            } else {
+                if (funcString.search(/return/i) === -1) {
+                    logme(
+                        'ERROR: You have specified a JavaScript ' +
+                        'function without a "return" statemnt. Your ' +
+                        'function will return "undefined" by default.'
+                    );
+                }
+            }
+
+            // Make sure that all HTML entities are converted to their proper
+            // ASCII text equivalents.
+            funcString = $('<div>').html(funcString).text();
+
+            paramNames = state.getAllParameterNames();
+            paramNames.push(funcString);
+
+            try {
+                func = Function.apply(null, paramNames);
+            } catch (err) {
+                logme(
+                    'ERROR: The function body "' +
+                        funcString +
+                        '" was not converted by the Function constructor.'
+                );
+                logme('Error message: "' + err.message + '".');
+
+                $('#' + gstId).html('<div style="color: red;">' + 'ERROR IN XML: Could not create a function from string "' + funcString + '".' + '</div>');
+                $('#' + gstId).append('<div style="color: red;">' + 'Error message: "' + err.message + '".' + '</div>');
+
+                paramNames.pop();
+
+                return;
+            }
+
+            paramNames.pop();
+
+            state.plde.push({
+                'elId': obj['@el_id'],
+                'func': func
+            });
+        }
+
+    }
+});
+
+// End of wrapper for RequireJS. As you can see, we are passing
+// namespaced Require JS variables to an anonymous function. Within
+// it, you can use the standard requirejs(), require(), and define()
+// functions as if they were in the global namespace.
+}(RequireJS.requirejs, RequireJS.require, RequireJS.define)); // End-of: (function (requirejs, require, define)

common/lib/xmodule/xmodule/js/src/graphical_slider_tool/general_methods.js

+// Wrapper for RequireJS. It will make the standard requirejs(), require(), and
+// define() functions from Require JS available inside the anonymous function.
+(function (requirejs, require, define) {
+
+define('GeneralMethods', [], function () {
+    if (!String.prototype.trim) {
+        // http://blog.stevenlevithan.com/archives/faster-trim-javascript
+        String.prototype.trim = function trim(str) {
+            return str.replace(/^\s\s*/, '').replace(/\s\s*$/, '');
+        };
+    }
+
+    return {
+        'module_name': 'GeneralMethods',
+        'module_status': 'OK'
+    };
+});
+
+// End of wrapper for RequireJS. As you can see, we are passing
+// namespaced Require JS variables to an anonymous function. Within
+// it, you can use the standard requirejs(), require(), and define()
+// functions as if they were in the global namespace.
+}(RequireJS.requirejs, RequireJS.require, RequireJS.define)); // End-of: (function (requirejs, require, define)

common/lib/xmodule/xmodule/js/src/graphical_slider_tool/gst.js

+/*
+ * We will add a function that will be called for all GraphicalSliderTool
+ * xmodule module instances. It must be available globally by design of
+ * xmodule.
+ */
+window.GraphicalSliderTool = function (el) {
+    // All the work will be performed by the GstMain module. We will get access
+    // to it, and all it's dependencies, via Require JS. Currently Require JS
+    // is namespaced and is available via a global object RequireJS.
+    RequireJS.require(['GstMain'], function (GstMain) {
+        // The GstMain module expects the DOM ID of a Graphical Slider Tool
+        // element. Since we are given a <section> element which might in
+        // theory contain multiple graphical_slider_tool <div> elements (each
+        // with a unique DOM ID), we will iterate over all children, and for
+        // each match, we will call GstMain module.
+        $(el).children('.graphical_slider_tool').each(function (index, value) {
+            GstMain($(value).attr('id'));
+        });
+    });
+};

common/lib/xmodule/xmodule/js/src/graphical_slider_tool/gst_main.js

+// Wrapper for RequireJS. It will make the standard requirejs(), require(), and
+// define() functions from Require JS available inside the anonymous function.
+(function (requirejs, require, define) {
+
+define(
+    'GstMain',
+
+    // Even though it is not explicitly in this module, we have to specify
+    // 'GeneralMethods' as a dependency. It expands some of the core JS objects
+    // with additional useful methods that are used in other modules.
+    ['State', 'GeneralMethods', 'Sliders', 'Inputs', 'Graph', 'ElOutput', 'GLabelElOutput', 'logme'],
+    function (State, GeneralMethods, Sliders, Inputs, Graph, ElOutput, GLabelElOutput, logme) {
+
+    return GstMain;
+
+    function GstMain(gstId) {
+        var config, gstClass, state;
+
+        if ($('#' + gstId).attr('data-processed') !== 'processed') {
+            $('#' + gstId).attr('data-processed', 'processed');
+        } else {
+            logme('MESSAGE: Already processed GST with ID ' + gstId + '. Skipping.');
+
+            return;
+        }
+
+        // Get the JSON configuration, parse it, and store as an object.
+        try {
+            config = JSON.parse($('#' + gstId + '_json').html()).root;
+        } catch (err) {
+            logme('ERROR: could not parse config JSON.');
+            logme('$("#" + gstId + "_json").html() = ', $('#' + gstId + '_json').html());
+            logme('JSON.parse(...) = ', JSON.parse($('#' + gstId + '_json').html()));
+            logme('config = ', config);
+
+            return;
+        }
+
+        // Get the class name of the GST. All elements are assigned a class
+        // name that is based on the class name of the GST. For example, inputs
+        // are assigned a class name '{GST class name}_input'.
+        if (typeof config['@class'] !== 'string') {
+            logme('ERROR: Could not get the class name of GST.');
+            logme('config["@class"] = ', config['@class']);
+
+            return;
+        }
+        gstClass = config['@class'];
+
+        // Parse the configuration settings for parameters, and store them in a
+        // state object.
+        state = State(gstId, config);
+
+        // It is possible that something goes wrong while extracting parameters
+        // from the JSON config object. In this case, we will not continue.
+        if (state === undefined) {
+            logme('ERROR: The state object was not initialized properly.');
+
+            return;
+        }
+
+        // Create the sliders and the text inputs, attaching them to
+        // appropriate parameters.
+        Sliders(gstId, state);
+        Inputs(gstId, gstClass, state);
+
+        // Configure functions that output to an element instead of the graph.
+        ElOutput(config, state);
+
+        // Configure functions that output to an element instead of the graph
+        // label.
+        GLabelElOutput(config, state);
+
+        // Configure and display the graph. Attach event for the graph to be
+        // updated on any change of a slider or a text input.
+        Graph(gstId, config, state);
+    }
+});
+
+// End of wrapper for RequireJS. As you can see, we are passing
+// namespaced Require JS variables to an anonymous function. Within
+// it, you can use the standard requirejs(), require(), and define()
+// functions as if they were in the global namespace.
+}(RequireJS.requirejs, RequireJS.require, RequireJS.define)); // End-of: (function (requirejs, require, define)

common/lib/xmodule/xmodule/js/src/graphical_slider_tool/inputs.js

+// Wrapper for RequireJS. It will make the standard requirejs(), require(), and
+// define() functions from Require JS available inside the anonymous function.
+(function (requirejs, require, define) {
+
+define('Inputs', ['logme'], function (logme) {
+    return Inputs;
+
+    function Inputs(gstId, gstClass, state) {
+        var c1, paramName, allParamNames;
+
+        allParamNames = state.getAllParameterNames();
+
+        for (c1 = 0; c1 < allParamNames.length; c1 += 1) {
+            $('#' + gstId).find('.' + gstClass + '_input').each(function (index, value) {
+                var inputDiv, paramName;
+
+                paramName = allParamNames[c1];
+                inputDiv = $(value);
+
+                if (paramName === inputDiv.data('var')) {
+                    createInput(inputDiv, paramName);
+                }
+            });
+        }
+
+        return;
+
+        function createInput(inputDiv, paramName) {
+            var paramObj;
+
+            paramObj = state.getParamObj(paramName);
+
+            // Check that the retrieval went OK.
+            if (paramObj === undefined) {
+                logme('ERROR: Could not get a paramObj for parameter "' + paramName + '".');
+
+                return;
+            }
+
+            // Bind a function to the 'change' event. Whenever the user changes
+            // the value of this text input, and presses 'enter' (or clicks
+            // somewhere else on the page), this event will be triggered, and
+            // our callback will be called.
+            inputDiv.bind('change', inputOnChange);
+
+            inputDiv.val(paramObj.value);
+
+            // Lets style the input element nicely. We will use the button()
+            // widget for this since there is no native widget for the text
+            // input.
+            inputDiv.button().css({
+                'font': 'inherit',
+                'color': 'inherit',
+                'text-align': 'left',
+                'outline': 'none',
+                'cursor': 'text',
+                'height': '15px'
+            });
+
+            // Tell the parameter object from state that we are attaching a
+            // text input to it. Next time the parameter will be updated with
+            // a new value, tis input will also be updated.
+            paramObj.inputDivs.push(inputDiv);
+
+            return;
+
+            // Update the 'state' - i.e. set the value of the parameter this
+            // input is attached to to a new value.
+            //
+            // This will cause the plot to be redrawn each time after the user
+            // changes the value in the input. Note that he has to either press
+            // 'Enter', or click somewhere else on the page in order for the
+            // 'change' event to be tiggered.
+            function inputOnChange(event) {
+                var inputDiv;
+
+                inputDiv = $(this);
+                state.setParameterValue(paramName, inputDiv.val(), inputDiv);
+            }
+        }
+    }
+});
+
+// End of wrapper for RequireJS. As you can see, we are passing
+// namespaced Require JS variables to an anonymous function. Within
+// it, you can use the standard requirejs(), require(), and define()
+// functions as if they were in the global namespace.
+}(RequireJS.requirejs, RequireJS.require, RequireJS.define)); // End-of: (function (requirejs, require, define)

common/lib/xmodule/xmodule/js/src/graphical_slider_tool/logme.js

+// Wrapper for RequireJS. It will make the standard requirejs(), require(), and
+// define() functions from Require JS available inside the anonymous function.
+(function (requirejs, require, define) {
+
+define('logme', [], function () {
+    var debugMode;
+
+    // debugMode can be one of the following:
+    //
+    //     true - All messages passed to logme will be written to the internal
+    //            browser console.
+    //     false - Suppress all output to the internal browser console.
+    //
+    // Obviously, if anywhere there is a direct console.log() call, we can't do
+    // anything about it. That's why use logme() - it will allow to turn off
+    // the output of debug information with a single change to a variable.
+    debugMode = true;
+
+    return logme;
+
+    /*
+     * function: logme
+     *
+     * A helper function that provides logging facilities. We don't want
+     * to call console.log() directly, because sometimes it is not supported
+     * by the browser. Also when everything is routed through this function.
+     * the logging output can be easily turned off.
+     *
+     * logme() supports multiple parameters. Each parameter will be passed to
+     * console.log() function separately.
+     *
+     */
+    function logme() {
+        var i;
+
+        if (
+            (typeof debugMode === 'undefined') ||
+            (debugMode !== true) ||
+            (typeof window.console === 'undefined')
+        ) {
+            return;
+        }
+
+        for (i = 0; i < arguments.length; i++) {
+            window.console.log(arguments[i]);
+        }
+    } // End-of: function logme
+});
+
+// End of wrapper for RequireJS. As you can see, we are passing
+// namespaced Require JS variables to an anonymous function. Within
+// it, you can use the standard requirejs(), require(), and define()
+// functions as if they were in the global namespace.
+}(RequireJS.requirejs, RequireJS.require, RequireJS.define)); // End-of: (function (requirejs, require, define)

common/lib/xmodule/xmodule/js/src/graphical_slider_tool/sliders.js

+// Wrapper for RequireJS. It will make the standard requirejs(), require(), and
+// define() functions from Require JS available inside the anonymous function.
+(function (requirejs, require, define) {
+
+define('Sliders', ['logme'], function (logme) {
+    return Sliders;
+
+    function Sliders(gstId, state) {
+        var c1, paramName, allParamNames, sliderDiv;
+
+        allParamNames = state.getAllParameterNames();
+
+        for (c1 = 0; c1 < allParamNames.length; c1 += 1) {
+            paramName = allParamNames[c1];
+
+            sliderDiv = $('#' + gstId + '_slider_' + paramName);
+
+            if (sliderDiv.length === 1) {
+                createSlider(sliderDiv, paramName);
+            } else if (sliderDiv.length > 1) {
+                logme('ERROR: Found more than one slider for the parameter "' + paramName + '".');
+                logme('sliderDiv.length = ', sliderDiv.length);
+            } else {
+                logme('MESSAGE: Did not find a slider for the parameter "' + paramName + '".');
+            }
+        }
+
+        function createSlider(sliderDiv, paramName) {
+            var paramObj;
+
+            paramObj = state.getParamObj(paramName);
+
+            // Check that the retrieval went OK.
+            if (paramObj === undefined) {
+                logme('ERROR: Could not get a paramObj for parameter "' + paramName + '".');
+
+                return;
+            }
+
+            // Create a jQuery UI slider from the slider DIV. We will set
+            // starting parameters, and will also attach a handler to update
+            // the 'state' on the 'slide' event.
+            sliderDiv.slider({
+                'min': paramObj.min,
+                'max': paramObj.max,
+                'value': paramObj.value,
+                'step': paramObj.step
+            });
+
+            // Tell the parameter object stored in state that we have a slider
+            // that is attached to it. Next time when the parameter changes, it
+            // will also update the value of this slider.
+            paramObj.sliderDiv = sliderDiv;
+
+            // Atach callbacks to update the slider's parameter.
+            paramObj.sliderDiv.on('slide', sliderOnSlide);
+            paramObj.sliderDiv.on('slidechange', sliderOnChange);
+
+            return;
+
+            // Update the 'state' - i.e. set the value of the parameter this
+            // slider is attached to to a new value.
+            //
+            // This will cause the plot to be redrawn each time after the user
+            // drags the slider handle and releases it.
+            function sliderOnSlide(event, ui) {
+                // Last parameter passed to setParameterValue() will be 'true'
+                // so that the function knows we are a slider, and it can
+                // change the our value back in the case when the new value is
+                // invalid for some reason.
+                if (state.setParameterValue(paramName, ui.value, sliderDiv, true, 'slide') === undefined) {
+                    logme('ERROR: Could not update the parameter named "' + paramName + '" with the value "' + ui.value + '".');
+                }
+            }
+
+            function sliderOnChange(event, ui) {
+                if (state.setParameterValue(paramName, ui.value, sliderDiv, true, 'change') === undefined) {
+                    logme('ERROR: Could not update the parameter named "' + paramName + '" with the value "' + ui.value + '".');
+                }
+            }
+        }
+    }
+});
+
+// End of wrapper for RequireJS. As you can see, we are passing
+// namespaced Require JS variables to an anonymous function. Within
+// it, you can use the standard requirejs(), require(), and define()
+// functions as if they were in the global namespace.
+}(RequireJS.requirejs, RequireJS.require, RequireJS.define)); // End-of: (function (requirejs, require, define)

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

-class @SelfAssessment
-  constructor: (element) ->
-    @el = $(element).find('section.self-assessment')
-    @id = @el.data('id')
-    @ajax_url = @el.data('ajax-url')
-    @state = @el.data('state')
-    @allow_reset = @el.data('allow_reset')
-    # valid states: 'initial', 'assessing', 'request_hint', 'done'
-
-    # Where to put the rubric once we load it
-    @errors_area = @$('.error')
-    @answer_area = @$('textarea.answer')
-
-    @rubric_wrapper = @$('.rubric-wrapper')
-    @hint_wrapper = @$('.hint-wrapper')
-    @message_wrapper = @$('.message-wrapper')
-    @submit_button = @$('.submit-button')
-    @reset_button = @$('.reset-button')
-    @reset_button.click @reset
-
-    @find_assessment_elements()
-    @find_hint_elements()
-
-    @rebind()
-
-  # locally scoped jquery.
-  $: (selector) ->
-    $(selector, @el)
-
-  rebind: () =>
-    # rebind to the appropriate function for the current state
-    @submit_button.unbind('click')
-    @submit_button.show()
-    @reset_button.hide()
-    @hint_area.attr('disabled', false)
-    if @state == 'initial'
-      @answer_area.attr("disabled", false)
-      @submit_button.prop('value', 'Submit')
-      @submit_button.click @save_answer
-    else if @state == 'assessing'
-      @answer_area.attr("disabled", true)
-      @submit_button.prop('value', 'Submit assessment')
-      @submit_button.click @save_assessment
-    else if @state == 'request_hint'
-      @answer_area.attr("disabled", true)
-      @submit_button.prop('value', 'Submit hint')
-      @submit_button.click @save_hint
-    else if @state == 'done'
-      @answer_area.attr("disabled", true)
-      @hint_area.attr('disabled', true)
-      @submit_button.hide()
-      if @allow_reset
-        @reset_button.show()
-      else
-        @reset_button.hide()
-
-
-  find_assessment_elements: ->
-    @assessment = @$('select.assessment')
-
-  find_hint_elements: ->
-    @hint_area = @$('textarea.hint')
-
-  save_answer: (event) =>
-    event.preventDefault()
-    if @state == 'initial'
-      data = {'student_answer' : @answer_area.val()}
-      $.postWithPrefix "#{@ajax_url}/save_answer", data, (response) =>
-        if response.success
-          @rubric_wrapper.html(response.rubric_html)
-          @state = 'assessing'
-          @find_assessment_elements()
-          @rebind()
-        else
-          @errors_area.html(response.error)
-    else
-      @errors_area.html('Problem state got out of sync.  Try reloading the page.')
-
-  save_assessment: (event) =>
-    event.preventDefault()
-    if @state == 'assessing'
-      data = {'assessment' : @assessment.find(':selected').text()}
-      $.postWithPrefix "#{@ajax_url}/save_assessment", data, (response) =>
-        if response.success
-          @state = response.state
-
-          if @state == 'request_hint'
-            @hint_wrapper.html(response.hint_html)
-            @find_hint_elements()
-          else if @state == 'done'
-            @message_wrapper.html(response.message_html)
-            @allow_reset = response.allow_reset
-
-          @rebind()
-        else
-          @errors_area.html(response.error)
-    else
-      @errors_area.html('Problem state got out of sync.  Try reloading the page.')
-    
-
-  save_hint:  (event) =>
-    event.preventDefault()
-    if @state == 'request_hint'
-      data = {'hint' : @hint_area.val()}
-      
-      $.postWithPrefix "#{@ajax_url}/save_hint", data, (response) =>
-        if response.success
-          @message_wrapper.html(response.message_html)
-          @state = 'done'
-          @allow_reset = response.allow_reset
-          @rebind()
-        else
-          @errors_area.html(response.error)
-    else
-      @errors_area.html('Problem state got out of sync.  Try reloading the page.')
-      
-
-  reset: (event) =>
-    event.preventDefault()
-    if @state == 'done'
-      $.postWithPrefix "#{@ajax_url}/reset", {}, (response) =>
-        if response.success
-          @answer_area.val('')
-          @rubric_wrapper.html('')
-          @hint_wrapper.html('')
-          @message_wrapper.html('')
-          @state = 'initial'
-          @rebind()
-          @reset_button.hide()
-        else
-          @errors_area.html(response.error)
-    else
-      @errors_area.html('Problem state got out of sync.  Try reloading the page.')

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

@@ -2,6 +2,8 @@ class @Video
   constructor: (element) ->
     @el = $(element).find('.video')
     @id = @el.attr('id').replace(/video_/, '')
+    @start = @el.data('start')
+    @end = @el.data('end')
     @caption_data_dir = @el.data('caption-data-dir')
     @show_captions = @el.data('show-captions') == "true"
     window.player = null

common/lib/xmodule/xmodule/js/src/video/display/video_player.coffee

@@ -36,14 +36,21 @@ class @VideoPlayer extends Subview
       @volumeControl = new VideoVolumeControl el: @$('.secondary-controls')
     @speedControl = new VideoSpeedControl el: @$('.secondary-controls'), speeds: @video.speeds, currentSpeed: @currentSpeed()
     @progressSlider = new VideoProgressSlider el: @$('.slider')
+    @playerVars =
+      controls: 0
+      wmode: 'transparent'
+      rel: 0
+      showinfo: 0
+      enablejsapi: 1
+      modestbranding: 1
+    if @video.start
+      @playerVars.start = @video.start
+    if @video.end
+      # work in AS3, not HMLT5. but iframe use AS3
+      @playerVars.end = @video.end
+
     @player = new YT.Player @video.id,
-      playerVars:
-        controls: 0
-        wmode: 'transparent'
-        rel: 0
-        showinfo: 0
-        enablejsapi: 1
-        modestbranding: 1
+      playerVars: @playerVars
       videoId: @video.youtubeId()
       events:
         onReady: @onReady

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

@@ -345,9 +345,9 @@ class ModuleStore(object):
         '''
         raise NotImplementedError
 
-    def get_parent_locations(self, location):
-        '''Find all locations that are the parents of this location.  Needed
-        for path_to_location().
+    def get_parent_locations(self, location, course_id):
+        '''Find all locations that are the parents of this location in this 
+        course.  Needed for path_to_location().
 
         returns an iterable of things that can be passed to Location.
         '''

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

@@ -309,9 +309,9 @@ class MongoModuleStore(ModuleStoreBase):
 
         self._update_single_item(location, {'metadata': metadata})
 
-    def get_parent_locations(self, location):
-        '''Find all locations that are the parents of this location.  Needed
-        for path_to_location().
+    def get_parent_locations(self, location, course_id):
+        '''Find all locations that are the parents of this location in this 
+        course.  Needed for path_to_location().
 
         If there is no data at location in this modulestore, raise
             ItemNotFoundError.

common/lib/xmodule/xmodule/modulestore/search.py

@@ -64,7 +64,7 @@ def path_to_location(modulestore, course_id, location):
             # isn't found so we don't have to do it explicitly.  Call this
             # first to make sure the location is there (even if it's a course, and
             # we would otherwise immediately exit).
-            parents = modulestore.get_parent_locations(loc)
+            parents = modulestore.get_parent_locations(loc, course_id)
 
             # print 'Processing loc={0}, path={1}'.format(loc, path)
             if loc.category == "course":

common/lib/xmodule/xmodule/modulestore/tests/test_modulestore.py

@@ -23,12 +23,3 @@ def check_path_to_location(modulestore):
     for location in not_found:
         assert_raises(ItemNotFoundError, path_to_location, modulestore, course_id, location)
 
-    # Since our test files are valid, there shouldn't be any
-    # elements with no path to them.  But we can look for them in
-    # another course.
-    no_path = (
-        "i4x://edX/simple/video/Lost_Video",
-        )
-    for location in no_path:
-        assert_raises(NoPathToItem, path_to_location, modulestore, course_id, location)
-

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

@@ -275,14 +275,16 @@ class XMLModuleStore(ModuleStoreBase):
             class_ = getattr(import_module(module_path), class_name)
             self.default_class = class_
 
-        self.parent_tracker = ParentTracker()
+        self.parent_trackers = defaultdict(ParentTracker)
 
         # If we are specifically asked for missing courses, that should
         # be an error.  If we are asked for "all" courses, find the ones
-        # that have a course.xml
+        # that have a course.xml. We sort the dirs in alpha order so we always
+        # read things in the same order (OS differences in load order have
+        # bitten us in the past.)
         if course_dirs is None:
-            course_dirs = [d for d in os.listdir(self.data_dir) if
-                           os.path.exists(self.data_dir / d / "course.xml")]
+            course_dirs = sorted([d for d in os.listdir(self.data_dir) if
+                                  os.path.exists(self.data_dir / d / "course.xml")])
 
         for course_dir in course_dirs:
             self.try_load_course(course_dir)
@@ -307,7 +309,7 @@ class XMLModuleStore(ModuleStoreBase):
         if course_descriptor is not None:
             self.courses[course_dir] = course_descriptor
             self._location_errors[course_descriptor.location] = errorlog
-            self.parent_tracker.make_known(course_descriptor.location)
+            self.parent_trackers[course_descriptor.id].make_known(course_descriptor.location)
         else:
             # Didn't load course.  Instead, save the errors elsewhere.
             self.errored_courses[course_dir] = errorlog
@@ -432,7 +434,7 @@ class XMLModuleStore(ModuleStoreBase):
                 course_dir,
                 policy,
                 tracker,
-                self.parent_tracker,
+                self.parent_trackers[course_id],
                 self.load_error_modules,
             )
 
@@ -541,9 +543,9 @@ class XMLModuleStore(ModuleStoreBase):
         """
         raise NotImplementedError("XMLModuleStores are read-only")
 
-    def get_parent_locations(self, location):
-        '''Find all locations that are the parents of this location.  Needed
-        for path_to_location().
+    def get_parent_locations(self, location, course_id):
+        '''Find all locations that are the parents of this location in this 
+        course.  Needed for path_to_location().
 
         If there is no data at location in this modulestore, raise
             ItemNotFoundError.
@@ -552,7 +554,7 @@ class XMLModuleStore(ModuleStoreBase):
         be empty if there are no parents.
         '''
         location = Location.ensure_fully_specified(location)
-        if not self.parent_tracker.is_known(location):
-            raise ItemNotFoundError(location)
+        if not self.parent_trackers[course_id].is_known(location):
+            raise ItemNotFoundError("{0} not in {1}".format(location, course_id))
 
-        return self.parent_tracker.parents(location)
+        return self.parent_trackers[course_id].parents(location)

common/lib/xmodule/xmodule/openendedchild.py

+import copy
+from fs.errors import ResourceNotFoundError
+import itertools
+import json
+import logging
+from lxml import etree
+from lxml.html import rewrite_links
+from path import path
+import os
+import sys
+import hashlib
+import capa.xqueue_interface as xqueue_interface
+
+from pkg_resources import resource_string
+
+from .capa_module import only_one, ComplexEncoder
+from .editing_module import EditingDescriptor
+from .html_checker import check_html
+from progress import Progress
+from .stringify import stringify_children
+from .xml_module import XmlDescriptor
+from xmodule.modulestore import Location
+from capa.util import *
+
+from datetime import datetime
+
+log = logging.getLogger("mitx.courseware")
+
+# Set the default number of max attempts.  Should be 1 for production
+# Set higher for debugging/testing
+# attempts specified in xml definition overrides this.
+MAX_ATTEMPTS = 1
+
+# Set maximum available number of points.
+# Overriden by max_score specified in xml.
+MAX_SCORE = 1
+
+class OpenEndedChild():
+    """
+    States:
+
+    initial (prompt, textbox shown)
+         |
+    assessing (read-only textbox, rubric + assessment input shown for self assessment, response queued for open ended)
+         |
+    post_assessment (read-only textbox, read-only rubric and assessment, hint input box shown)
+         |
+    done (submitted msg, green checkmark, everything else read-only.  If attempts < max, shows
+         a reset button that goes back to initial state.  Saves previous
+         submissions too.)
+    """
+
+    DEFAULT_QUEUE = 'open-ended'
+    DEFAULT_MESSAGE_QUEUE = 'open-ended-message'
+    max_inputfields = 1
+
+    STATE_VERSION = 1
+
+    # states
+    INITIAL = 'initial'
+    ASSESSING = 'assessing'
+    POST_ASSESSMENT = 'post_assessment'
+    DONE = 'done'
+
+    #This is used to tell students where they are at in the module
+    HUMAN_NAMES = {
+        'initial': 'Started',
+        'assessing': 'Being scored',
+        'post_assessment': 'Scoring finished',
+        'done': 'Problem complete',
+    }
+
+    def __init__(self, system, location, definition, descriptor, static_data,
+                 instance_state=None, shared_state=None, **kwargs):
+        # Load instance state
+        if instance_state is not None:
+            instance_state = json.loads(instance_state)
+        else:
+            instance_state = {}
+
+        # History is a list of tuples of (answer, score, hint), where hint may be
+        # None for any element, and score and hint can be None for the last (current)
+        # element.
+        # Scores are on scale from 0 to max_score
+        self.history = instance_state.get('history', [])
+
+        self.state = instance_state.get('state', self.INITIAL)
+
+        self.created = instance_state.get('created', False)
+
+        self.attempts = instance_state.get('attempts', 0)
+        self.max_attempts = static_data['max_attempts']
+
+        self.prompt = static_data['prompt']
+        self.rubric = static_data['rubric']
+
+        # Used for progress / grading.  Currently get credit just for
+        # completion (doesn't matter if you self-assessed correct/incorrect).
+        self._max_score = static_data['max_score']
+
+        self.setup_response(system, location, definition, descriptor)
+
+    def setup_response(self, system, location, definition, descriptor):
+        """
+        Needs to be implemented by the inheritors of this module.  Sets up additional fields used by the child modules.
+        @param system: Modulesystem
+        @param location: Module location
+        @param definition: XML definition
+        @param descriptor: Descriptor of the module
+        @return: None
+        """
+        pass
+
+    def latest_answer(self):
+        """None if not available"""
+        if not self.history:
+            return ""
+        return self.history[-1].get('answer', "")
+
+    def latest_score(self):
+        """None if not available"""
+        if not self.history:
+            return None
+        return self.history[-1].get('score')
+
+    def latest_post_assessment(self):
+        """None if not available"""
+        if not self.history:
+            return ""
+        return self.history[-1].get('post_assessment', "")
+
+    def new_history_entry(self, answer):
+        """
+        Adds a new entry to the history dictionary
+        @param answer: The student supplied answer
+        @return: None
+        """
+        self.history.append({'answer': answer})
+
+    def record_latest_score(self, score):
+        """Assumes that state is right, so we're adding a score to the latest
+        history element"""
+        self.history[-1]['score'] = score
+
+    def record_latest_post_assessment(self, post_assessment):
+        """Assumes that state is right, so we're adding a score to the latest
+        history element"""
+        self.history[-1]['post_assessment'] = post_assessment
+
+    def change_state(self, new_state):
+        """
+        A centralized place for state changes--allows for hooks.  If the
+        current state matches the old state, don't run any hooks.
+        """
+        if self.state == new_state:
+            return
+
+        self.state = new_state
+
+        if self.state == self.DONE:
+            self.attempts += 1
+
+    def get_instance_state(self):
+        """
+        Get the current score and state
+        """
+
+        state = {
+            'version': self.STATE_VERSION,
+            'history': self.history,
+            'state': self.state,
+            'max_score': self._max_score,
+            'attempts': self.attempts,
+            'created': False,
+        }
+        return json.dumps(state)
+
+    def _allow_reset(self):
+        """Can the module be reset?"""
+        return (self.state == self.DONE and self.attempts < self.max_attempts)
+
+    def max_score(self):
+        """
+        Return max_score
+        """
+        return self._max_score
+
+    def get_score(self):
+        """
+        Returns the last score in the list
+        """
+        score = self.latest_score()
+        return {'score': score if score is not None else 0,
+                'total': self._max_score}
+
+    def reset(self, system):
+        """
+        If resetting is allowed, reset the state.
+
+        Returns {'success': bool, 'error': msg}
+        (error only present if not success)
+        """
+        self.change_state(self.INITIAL)
+        return {'success': True}
+
+    def get_progress(self):
+        '''
+        For now, just return last score / max_score
+        '''
+        if self._max_score > 0:
+            try:
+                return Progress(self.get_score()['score'], self._max_score)
+            except Exception as err:
+                log.exception("Got bad progress")
+                return None
+        return None
+
+    def out_of_sync_error(self, get, msg=''):
+        """
+        return dict out-of-sync error message, and also log.
+        """
+        log.warning("Assessment module state out sync. state: %r, get: %r. %s",
+            self.state, get, msg)
+        return {'success': False,
+                'error': 'The problem state got out-of-sync'}
+
+    def get_html(self):
+        """
+         Needs to be implemented by inheritors.  Renders the HTML that students see.
+        @return:
+        """
+        pass
+
+    def handle_ajax(self):
+        """
+        Needs to be implemented by child modules.  Handles AJAX events.
+        @return:
+        """
+        pass
+
+    def is_submission_correct(self, score):
+        """
+        Checks to see if a given score makes the answer correct.  Very naive right now (>66% is correct)
+        @param score: Numeric score.
+        @return: Boolean correct.
+        """
+        correct = False
+        if(isinstance(score, (int, long, float, complex))):
+            score_ratio = int(score) / float(self.max_score())
+            correct = (score_ratio >= 0.66)
+        return correct
+
+    def is_last_response_correct(self):
+        """
+        Checks to see if the last response in the module is correct.
+        @return: 'correct' if correct, otherwise 'incorrect'
+        """
+        score = self.get_score()['score']
+        correctness = 'correct' if self.is_submission_correct(score) else 'incorrect'
+        return correctness
+
+
+

common/lib/xmodule/xmodule/tests/test_course_module.py

+import unittest
+from time import strptime, gmtime
+from fs.memoryfs import MemoryFS
+
+from mock import Mock, patch
+
+from xmodule.modulestore.xml import ImportSystem, XMLModuleStore
+
+
+ORG = 'test_org'
+COURSE = 'test_course'
+
+NOW = strptime('2013-01-01T01:00:00', '%Y-%m-%dT%H:%M:00')
+
+
+class DummySystem(ImportSystem):
+    @patch('xmodule.modulestore.xml.OSFS', lambda dir: MemoryFS())
+    def __init__(self, load_error_modules):
+
+        xmlstore = XMLModuleStore("data_dir", course_dirs=[],
+                                  load_error_modules=load_error_modules)
+        course_id = "/".join([ORG, COURSE, 'test_run'])
+        course_dir = "test_dir"
+        policy = {}
+        error_tracker = Mock()
+        parent_tracker = Mock()
+
+        super(DummySystem, self).__init__(
+            xmlstore,
+            course_id,
+            course_dir,
+            policy,
+            error_tracker,
+            parent_tracker,
+            load_error_modules=load_error_modules,
+        )
+
+
+class IsNewCourseTestCase(unittest.TestCase):
+    """Make sure the property is_new works on courses"""
+    @staticmethod
+    def get_dummy_course(start, is_new=None, load_error_modules=True):
+        """Get a dummy course"""
+
+        system = DummySystem(load_error_modules)
+        is_new = '' if is_new is None else 'is_new="{0}"'.format(is_new).lower()
+
+        start_xml = '''
+         <course org="{org}" course="{course}"
+                graceperiod="1 day" url_name="test"
+                start="{start}"
+                {is_new}>
+            <chapter url="hi" url_name="ch" display_name="CH">
+                <html url_name="h" display_name="H">Two houses, ...</html>
+            </chapter>
+         </course>
+         '''.format(org=ORG, course=COURSE, start=start, is_new=is_new)
+
+        return system.process_xml(start_xml)
+
+    @patch('xmodule.course_module.time.gmtime')
+    def test_non_started_yet(self, gmtime_mock):
+        descriptor = self.get_dummy_course(start='2013-01-05T12:00')
+        gmtime_mock.return_value = NOW
+        assert(descriptor.is_new == True)
+        assert(descriptor.days_until_start == 4)
+
+    @patch('xmodule.course_module.time.gmtime')
+    def test_already_started(self, gmtime_mock):
+        gmtime_mock.return_value = NOW
+
+        descriptor = self.get_dummy_course(start='2012-12-02T12:00')
+        assert(descriptor.is_new == False)
+        assert(descriptor.days_until_start < 0)
+
+    @patch('xmodule.course_module.time.gmtime')
+    def test_is_new_set(self, gmtime_mock):
+        gmtime_mock.return_value = NOW
+
+        descriptor = self.get_dummy_course(start='2012-12-02T12:00', is_new=True)
+        assert(descriptor.is_new == True)
+        assert(descriptor.days_until_start < 0)
+
+        descriptor = self.get_dummy_course(start='2013-02-02T12:00', is_new=False)
+        assert(descriptor.is_new == False)
+        assert(descriptor.days_until_start > 0)
+
+        descriptor = self.get_dummy_course(start='2013-02-02T12:00', is_new=True)
+        assert(descriptor.is_new == True)
+        assert(descriptor.days_until_start > 0)

common/lib/xmodule/xmodule/tests/test_export.py

@@ -39,9 +39,12 @@ def strip_filenames(descriptor):
 
 
 class RoundTripTestCase(unittest.TestCase):
-    '''Check that our test courses roundtrip properly'''
+    ''' Check that our test courses roundtrip properly.
+        Same course imported , than exported, then imported again.
+        And we compare original import with second import (after export).
+        Thus we make sure that export and import work properly.
+    '''
     def check_export_roundtrip(self, data_dir, course_dir):
-
         root_dir = path(mkdtemp())
         print "Copying test course to temp dir {0}".format(root_dir)
 
@@ -117,3 +120,7 @@ class RoundTripTestCase(unittest.TestCase):
     def test_selfassessment_roundtrip(self):
         #Test selfassessment xmodule to see if it exports correctly
         self.check_export_roundtrip(DATA_DIR,"self_assessment")
+
+    def test_graphicslidertool_roundtrip(self):
+        #Test graphicslidertool xmodule to see if it exports correctly
+        self.check_export_roundtrip(DATA_DIR,"graphic_slider_tool")

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

@@ -352,3 +352,19 @@ class ImportTestCase(unittest.TestCase):
         sa_sample = modulestore.get_instance(sa_id, location)
         #10 attempts is hard coded into SampleQuestion, which is the url_name of a selfassessment xml tag
         self.assertEqual(sa_sample.metadata['attempts'], '10')
+
+    def test_graphicslidertool_import(self):
+        '''
+        Check to see if definition_from_xml in gst_module.py
+        works properly.  Pulls data from the graphic_slider_tool directory
+        in the test data directory.
+        '''
+        modulestore = XMLModuleStore(DATA_DIR, course_dirs=['graphic_slider_tool'])
+
+        sa_id = "edX/gst_test/2012_Fall"
+        location = Location(["i4x", "edX", "gst_test", "graphical_slider_tool", "sample_gst"])
+        gst_sample = modulestore.get_instance(sa_id, location)
+        render_string_from_sample_gst_xml = """
+        <slider var="a" style="width:400px;float:left;"/>\
+<plot style="margin-top:15px;margin-bottom:15px;"/>""".strip()
+        self.assertEqual(gst_sample.definition['render'], render_string_from_sample_gst_xml)

common/lib/xmodule/xmodule/video_module.py

@@ -7,6 +7,9 @@ from pkg_resources import resource_string, resource_listdir
 from xmodule.x_module import XModule
 from xmodule.raw_module import RawDescriptor
 
+import datetime
+import time
+
 log = logging.getLogger(__name__)
 
 
@@ -33,6 +36,7 @@ class VideoModule(XModule):
         self.show_captions = xmltree.get('show_captions', 'true')
         self.source = self._get_source(xmltree)
         self.track = self._get_track(xmltree)
+        self.start_time, self.end_time = self._get_timeframe(xmltree)
 
         if instance_state is not None:
             state = json.loads(instance_state)
@@ -42,11 +46,11 @@ class VideoModule(XModule):
     def _get_source(self, xmltree):
         # find the first valid source
         return self._get_first_external(xmltree, 'source')
-        
+
     def _get_track(self, xmltree):
         # find the first valid track
         return self._get_first_external(xmltree, 'track')
-        
+
     def _get_first_external(self, xmltree, tag):
         """
         Will return the first valid element
@@ -61,6 +65,23 @@ class VideoModule(XModule):
                 break
         return result
 
+    def _get_timeframe(self, xmltree):
+        """ Converts 'from' and 'to' parameters in video tag to seconds.
+        If there are no parameters, returns empty string. """
+
+        def parse_time(s):
+            """Converts s in '12:34:45' format to seconds. If s is
+            None, returns empty string"""
+            if s is None:
+                return ''
+            else:
+                x = time.strptime(s, '%H:%M:%S')
+                return datetime.timedelta(hours=x.tm_hour,
+                                      minutes=x.tm_min,
+                                      seconds=x.tm_sec).total_seconds()
+
+        return parse_time(xmltree.get('from')), parse_time(xmltree.get('to'))
+
     def handle_ajax(self, dispatch, get):
         '''
         Handle ajax calls to this video.
@@ -98,11 +119,13 @@ class VideoModule(XModule):
             'id': self.location.html_id(),
             'position': self.position,
             'source': self.source,
-            'track' : self.track,
+            'track': self.track,
             'display_name': self.display_name,
             # TODO (cpennington): This won't work when we move to data that isn't on the filesystem
             'data_dir': self.metadata['data_dir'],
-            'show_captions': self.show_captions
+            'show_captions': self.show_captions,
+            'start': self.start_time,
+            'end': self.end_time
         })
 
 

common/test/data/graphic_slider_tool/README.md

+This is a very very simple course, useful for debugging graphical slider tool
+code.

common/test/data/graphic_slider_tool/course.xml

+roots/2012_Fall.xml
\ No newline at end of file

common/test/data/graphic_slider_tool/course/2012_Fall.xml

+<course>
+  <chapter url_name="Overview">
+    <graphical_slider_tool url_name="sample_gst"/>
+  </chapter>
+</course>

common/test/data/graphic_slider_tool/graphical_slider_tool/sample_gst.xml

+
+    <graphical_slider_tool>
+      <render>
+<slider var='a' style="width:400px;float:left;"/><plot style="margin-top:15px;margin-bottom:15px;"/>
+      </render>
+      <configuration>
+        <parameters>
+            <param var="a" min="5" max="25" step="0.5" initial="12.5" />
+        </parameters>
+        <functions>
+          <function color="red">return Math.sqrt(a * a - x * x);</function>
+          <function color="red">return -Math.sqrt(a * a - x * x);</function>
+        </functions>
+        <plot>
+          <xrange>
+            <!-- dynamic range -->
+              <min>
+                  return -a;
+              </min>
+              <max>
+                  return a;
+              </max>
+          </xrange>
+          <num_points>1000</num_points>
+          <xticks>-30, 6, 30</xticks>
+          <yticks>-30, 6, 30</yticks>
+        </plot>
+      </configuration>
+    </graphical_slider_tool>
+

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

+{
+    "course/2012_Fall": {
+        "graceperiod": "2 days 5 hours 59 minutes 59 seconds",
+        "start": "2015-07-17T12:00",
+        "display_name": "GST Test",
+        "graded": "false"
+    },
+    "chapter/Overview": {
+        "display_name": "Overview"
+    },
+    "graphical_slider_tool/sample_gst": {
+        "display_name": "Sample GST",
+    },
+}

common/test/data/graphic_slider_tool/roots/2012_Fall.xml

+<course org="edX" course="gst_test" url_name="2012_Fall"/>

common/test/data/self_assessment/course.xml

+<course org="edX" course="sa_test" url_name="2012_Fall"/>

common/test/data/self_assessment/course.xml

-roots/2012_Fall.xml
\ No newline at end of file

doc/course_grading.md

@@ -35,6 +35,43 @@ weights of 30, 10, 10, and 10 to the 4 problems, respectively.
 Note that the default weight of a problem **is not 1.** The default weight of a
 problem is the module's max_grade.
 
+If weighting is set, each problem is worth the number of points assigned, regardless of the number of responses it contains.
+
+Consider a Homework section that contains two problems.
+
+    <problem display_name=”Problem 1”>
+      <numericalresponse> ... </numericalreponse>
+    </problem>
+
+and
+
+    <problem display_name=”Problem 2”>
+      <numericalresponse> ... </numericalreponse>
+      <numericalresponse> ... </numericalreponse>
+      <numericalresponse> ... </numericalreponse>
+    </problem>
+
+
+
+
+
+Without weighting, Problem 1 is worth 25% of the assignment, and Problem 2 is worth 75% of the assignment.
+
+Weighting for the problems can be set in the policy.json file.
+
+    "problem/problem1": {
+       "weight": 2
+       },
+    "problem/problem2": {
+       "weight": 2
+        },
+
+With the above weighting, Problems 1 and 2 are each worth 50% of the assignment.
+
+Please note: When problems have weight, the point value is automatically included in the display name *except* when “weight”: 1.When “weight”: 1, no visual change occurs in the display name, leaving the point value open to interpretation to the student.
+
+
+
 ## Section Weighting
 
 Once each section has a percentage score, we must total those sections into a

doc/development.md

@@ -19,6 +19,11 @@ Use the MacPorts package `mongodb` or the Homebrew formula `mongodb`
 
 ## Initializing Mongodb
 
+First start up the mongo daemon. E.g. to start it up in the background
+using a config file:
+
+    mongod --config /usr/local/etc/mongod.conf &
+
 Check out the course data directories that you want to work with into the
 `GITHUB_REPO_ROOT` (by default, `../data`). Then run the following command:
 
@@ -37,8 +42,12 @@ This runs all the tests (long, uses collectstatic):
 
 If if you aren't changing static files, can run `rake test` once, then run
 
-    rake fasttest_{lms,cms}
+    rake fasttest_lms
+
+or
 
+    rake fasttest_cms
+    
 xmodule can be tested independently, with this:
 
     rake test_common/lib/xmodule

doc/remote_gradebook.md

+Grades can be pushed to a remote gradebook, and course enrollment membership can be pulled from a remote gradebook.  This file documents how to setup such a remote gradebook, and what the API should be for writing new remote gradebook "xservers".
+
+1. Definitions
+
+An "xserver" is a web-based server that is part of the MITx eco system.  There are a number of "xserver" programs, including one which does python code grading, an xqueue server, and graders for other coding languages.
+
+"Stellar" is the MIT on-campus gradebook system.
+
+2. Setup
+
+The remote gradebook xserver should be specified in the lms.envs configuration using
+
+    MITX_FEATURES[REMOTE_GRADEBOOK_URL]
+
+Each course, in addition, should define the name of the gradebook being used.  A class "section" may also be specified.  This goes in the policy.json file, eg:
+
+    "remote_gradebook": {                                                                                                          
+       "name" : "STELLAR:/project/mitxdemosite",                                                                                  
+       "section" : "r01"                                                                                                          
+        },     
+
+3. The API for the remote gradebook xserver is an almost RESTful service model, which only employs POSTs, to the xserver url, with form data for the fields:
+
+ - submit: get-assignments, get-membership, post-grades, or get-sections
+ - gradebook: name of gradebook
+ - user: username of staff person initiating the request (for logging)
+ - section: (optional) name of section
+
+The return body content should be a JSON string, of the format {'msg': message, 'data': data}.  The message is displayed in the instructor dashboard.  
+
+The data is a list of dicts (associative arrays).  Each dict should be key:value.
+
+## For submit=post-grades:
+
+A file is also posted, with the field name "datafile".  This file is CSV format, with two columns, one being "External email" and the other being the name of the assignment (that column contains the grades for the assignment).  
+
+## For submit=get-assignments
+
+data keys = "AssignmentName"
+
+## For submit=get-membership
+
+data keys = "email", "name", "section"
+
+## For submit=get-sections
+
+data keys = "SectionName"

doc/testing.md

 # Testing
 
-Testing is good.  Here is some useful info about how we set up tests--
+Testing is good.  Here is some useful info about how we set up tests.
+More info is [on the wiki](https://edx-wiki.atlassian.net/wiki/display/ENG/Test+Engineering)
 
-### Backend code:
+## Backend code
 
-- TODO
+- The python unit tests can be run via rake tasks. 
+See development.md for more info on how to do this.
 
-### Frontend code:
+## Frontend code
 
-We're using Jasmine to unit-testing the JavaScript files. All the specs are
-written in CoffeeScript for the consistency. To access the test cases, start the
-server in debug mode, navigate to `http://127.0.0.1:[port number]/_jasmine` to
-see the test result.
+### Jasmine
+
+We're using Jasmine to unit/integration test the JavaScript files. 
+More info [on the wiki](https://edx-wiki.atlassian.net/wiki/display/ENG/Jasmine)
+
+All the specs are written in CoffeeScript to be consistent with the code.
+To access the test cases, start the server using the settings file **jasmine.py** using this command:
+    `rake django-admin[runserver,lms,jasmine,12345]`
+
+Then navigate to `http://localhost:12345/_jasmine/` to see the test results.
 
 All the JavaScript codes must have test coverage. Both CMS and LMS
 has its own test directory in `{cms,lms}/static/coffee/spec`  If you haven't
@@ -30,3 +38,31 @@ If you're finishing a feature that contains JavaScript code snippets and do not
 sure how to test, please feel free to open up a pull request and asking people
 for help. (However, the best way to do it would be writing your test first, then
 implement your feature - Test Driven Development.)
+
+### BDD style acceptance tests with Lettuce
+
+We're using Lettuce for end user acceptance testing of features.
+More info [on the wiki](https://edx-wiki.atlassian.net/wiki/display/ENG/Lettuce+Acceptance+Testing)
+
+Lettuce is a port of Cucumber. We're using it to drive Splinter, which is a python wrapper to Selenium.
+To execute the automated test scripts, you'll need to start up the django server separately, then launch the tests.
+Do both use the settings file named **acceptance.py**.
+
+What this will do is to use a sqllite database named mitx_all/db/test_mitx.db. 
+That way it can be flushed etc. without messing up your dev db.
+Note that this also means that you need to syncdb and migrate the db first before starting the server to initialize it if it does not yet exist.
+
+1. Set up the test database (only needs to be done once):
+    rm ../db/test_mitx.db
+    rake django-admin[syncdb,lms,acceptance,--noinput]
+    rake django-admin[migrate,lms,acceptance,--noinput]
+
+2. Start up the django server separately in a shell
+    rake lms[acceptance]
+
+3. Then in another shell, run the tests in different ways as below. Lettuce comes with a new django-admin command called _harvest_. See the [lettuce django docs](http://lettuce.it/recipes/django-lxml.html) for more details.
+* All tests in a specified feature folder: `django-admin.py harvest --no-server --settings=lms.envs.acceptance --pythonpath=. lms/djangoapps/portal/features/`
+* Only the specified feature's scenarios: `django-admin.py harvest --no-server --settings=lms.envs.acceptance --pythonpath=. lms/djangoapps/courseware/features/high-level-tabs.feature`
+
+4. Troubleshooting
+* If you get an error msg that says something about harvest not being a command, you probably are missing a requirement. Pip install (test-requirements.txt) and/or brew install as needed.
\ No newline at end of file

docs/source/gst_example_bars.xml

+<vertical>
+    <graphical_slider_tool>
+      <render>
+        <h2>Graphic slider tool: Bar graph example.</h2>
+
+        <p>We can request the API to plot us a bar graph.</p>
+        <div style="clear:both">
+          <p style="width:60px;float:left;">a</p>
+          <slider var='a' style="width:400px;float:left;"/>
+          <textbox var='a' style="width:50px;float:left;margin-left:15px;"/>
+          <br /><br /><br />
+          <p style="width:60px;float:left;">b</p>
+          <slider var='b' style="width:400px;float:left;"/>
+          <textbox var='b' style="width:50px;float:left;margin-left:15px;"/>
+        </div>
+          <plot style="clear:left;"/>
+      </render>
+      <configuration>
+        <parameters>
+            <param var="a" min="-100" max="100" step="5" initial="25" />
+            <param var="b" min="-100" max="100" step="5" initial="50" />
+        </parameters>
+        <functions>
+          <function bar="true" color="blue" label="Men">
+            <![CDATA[if (((x>0.9) && (x<1.1)) || ((x>4.9) && (x<5.1))) { return Math.sin(a * 0.01 * Math.PI + 2.952 * x); }
+            else {return undefined;}]]>
+          </function>
+          <function bar="true" color="red" label="Women">
+            <![CDATA[if (((x>1.9) && (x<2.1)) || ((x>3.9) && (x<4.1))) { return Math.cos(b * 0.01 * Math.PI + 3.432 * x); }
+            else {return undefined;}]]>
+          </function>
+          <function bar="true" color="green" label="Other 1">
+            <![CDATA[if (((x>1.9) && (x<2.1)) || ((x>3.9) && (x<4.1))) { return Math.cos((b - 10 * a) * 0.01 * Math.PI + 3.432 * x); }
+            else {return undefined;}]]>
+          </function>
+          <function bar="true" color="yellow" label="Other 2">
+            <![CDATA[if (((x>1.9) && (x<2.1)) || ((x>3.9) && (x<4.1))) { return Math.cos((b + 7 * a) * 0.01 * Math.PI + 3.432 * x); }
+            else {return undefined;}]]>
+          </function>
+        </functions>
+        <plot>
+          <xrange><min>1</min><max>5</max></xrange>
+          <num_points>5</num_points>
+          <xticks>0, 0.5, 6</xticks>
+          <yticks>-1.5, 0.1, 1.5</yticks>
+          <xticks_names>
+          <![CDATA[
+              {
+                  "1.5": "Single", "4.5": "Married"
+              }
+          ]]>
+          </xticks_names>
+          <yticks_names>
+          <![CDATA[
+              {
+                  "-1.0": "-100%", "-0.5": "-50%", "0.0": "0%", "0.5": "50%", "1.0": "100%"
+              }
+          ]]>
+          </yticks_names>
+          <bar_width>0.4</bar_width>
+        </plot>
+      </configuration>
+    </graphical_slider_tool>
+</vertical>

docs/source/gst_example_dynamic_labels.xml

+<vertical>
+ <graphical_slider_tool>
+      <render>
+        <h1>Graphic slider tool: Dynamic labels.</h1>
+        <p>There are two kinds of dynamic lables.
+        1) Dynamic changing values in graph legends.
+        2) Dynamic labels, which coordinates depend on parameters </p>
+         <p>a: <slider var="a"/></p>
+          <br/>
+          <p>b: <slider var="b"/></p>
+          <br/><br/>
+          <plot style="width:400px; height:400px;"/>
+      </render>
+
+      <configuration>
+        <parameters>
+            <param var="a" min="-10" max="10" step="1" initial="0" />
+            <param var="b" min="0" max="10" step="0.5" initial="5" />
+        </parameters>
+        <functions>
+          <function label="Value of a is: dyn_val_1">a * x + b</function>
+         <!-- dynamic values in legend -->
+         <function output="plot_label" el_id="dyn_val_1">a</function>
+        </functions>
+        <plot>
+          <xrange><min>0</min><max>30</max></xrange>
+          <num_points>10</num_points>
+          <xticks>0, 6, 30</xticks>
+          <yticks>-9, 1, 9</yticks>
+          <!-- custom labels with coordinates as any function of parameter -->
+          <moving_label text="Dynam_lbl 1" weight="bold">
+          <![CDATA[  {'x': 10, 'y': a};]]>
+          </moving_label>
+          <moving_label text="Dynam lbl 2" weight="bold">
+          <![CDATA[  {'x': -6, 'y': b};]]>
+          </moving_label>
+        </plot>
+      </configuration>
+    </graphical_slider_tool>
+</vertical>
\ No newline at end of file

docs/source/gst_example_dynamic_range.xml

+<vertical>
+    <graphical_slider_tool>
+      <render>
+        <h2>Graphic slider tool: Dynamic range and implicit functions.</h2>
+
+        <p>You can make x range (not ticks of x axis) of functions to depend on
+          parameter value. This can be useful when function domain depends
+          on parameter.</p>
+        <p>Also implicit functons like circle can be plotted as 2 separate
+            functions of same color.</p>
+         <div style="height:50px;">
+         <slider var='a' style="width:400px;float:left;"/>
+         <textbox var='a' style="float:left;width:60px;margin-left:15px;"/>
+       </div>
+        <plot style="margin-top:15px;margin-bottom:15px;"/>
+      </render>
+      <configuration>
+        <parameters>
+            <param var="a" min="5" max="25" step="0.5" initial="12.5" />
+        </parameters>
+        <functions>
+          <function color="red">Math.sqrt(a * a - x * x)</function>
+          <function color="red">-Math.sqrt(a * a - x * x)</function>
+        </functions>
+        <plot>
+          <xrange>
+            <!-- dynamic range -->
+              <min>-a</min>
+              <max>a</max>
+          </xrange>
+          <num_points>1000</num_points>
+          <xticks>-30, 6, 30</xticks>
+          <yticks>-30, 6, 30</yticks>
+        </plot>
+      </configuration>
+    </graphical_slider_tool>
+</vertical>

docs/source/gst_example_html_element_output.xml

+<vertical>
+    <graphical_slider_tool>
+        <render>
+            <h2>Graphic slider tool: Output to DOM element.</h2>
+
+            <p>a + b = <span id="answer_span_1"></span></p>
+
+            <div style="clear:both">
+                <p style="float:left;margin-right:10px;">a</p>
+                <slider var='a' style="width:400px;float:left;"/>
+                <textbox var='a' style="width:50px;float:left;margin-left:15px;"/>
+            </div>
+
+            <div style="clear:both">
+                <p style="float:left;margin-right:10px;">b</p>
+                <slider var='b' style="width:400px;float:left;"/>
+                <textbox var='b' style="width:50px;float:left;margin-left:15px;"/>
+            </div>
+            <br/><br/><br/>
+            <plot/>
+        </render>
+        <configuration>
+            <parameters>
+                <param var="a" min="-10.0" max="10.0" step="0.1" initial="0" />
+                <param var="b" min="-10.0" max="10.0" step="0.1" initial="0" />
+            </parameters>
+
+            <functions>
+                <function output="element" el_id="answer_span_1">
+                    function add(a, b, precision) {
+                        var x = Math.pow(10, precision || 2);
+                        return (Math.round(a * x) + Math.round(b * x)) / x;
+                    }
+
+                    return add(a, b, 5);
+                </function>
+            </functions>
+        </configuration>
+    </graphical_slider_tool>
+</vertical>

docs/source/gst_example_with_documentation.xml

+<vertical>
+    <graphical_slider_tool>
+      <render>
+
+          <h2>Graphic slider tool: full example.</h2>
+            <p>
+                A simple equation
+                    \(
+                        y_1 = 10 \times b \times \frac{sin(a \times x) \times sin(b \times x)}{cos(b \times x) + 10}
+                    \)
+                can be plotted.
+            </p>
+
+            <!-- make text and input or slider at the same line -->
+            <div>
+              <p style="float:left;"> Currently \(a\) is</p>
+              <!-- readonly input for a -->
+              <span id="a_readonly" style="width:50px; float:left; margin-left:10px;"/>
+            </div>
+            <!-- clear:left will make next text to begin from new line -->
+            <p style="clear:left">   This one
+                  \(
+                      y_2 = sin(a \times x)
+                  \)
+              will be overlayed on top.
+            </p>
+            <div>
+              <p style="float:left;">Currently \(b\) is </p>
+              <textbox var="b" style="width:50px; float:left; margin-left:10px;"/>
+            </div>
+            <div style="clear:left;">
+              <p style="float:left;">To change \(a\) use:</p>
+              <slider var="a" style="width:400px;float:left;margin-left:10px;"/>
+            </div>
+            <div style="clear:left;">
+              <p style="float:left;">To change \(b\) use:</p>
+              <slider var="b" style="width:400px;float:left;margin-left:10px;"/>
+            </div>
+            <plot style='clear:left;width:600px;padding-top:15px;padding-bottom:20px;'/>
+            <div style="clear:left;height:50px;">
+             <p style="float:left;">Second input for b:</p>
+             <!-- editable input for b -->
+              <textbox var="b" style="color:red;width:60px;float:left;margin-left:10px;"/>
+            </div >
+      </render>
+
+      <configuration>
+
+        <parameters>
+            <param var="a" min="90" max="120" step="10" initial="100" />
+            <param var="b" min="120" max="200" step="2.3" initial="120" />
+        </parameters>
+
+        <functions>
+
+          <function color="#0000FF" line="false" dot="true" label="\(y_1\)">
+            return 10.0 * b * Math.sin(a * x) * Math.sin(b * x) / (Math.cos(b * x) + 10);
+          </function>
+          <function color="red" line="true" dot="false" label="\(y_2\)">
+            <!-- works w/o return, if function is single line -->
+            Math.sin(a * x);
+          </function>
+          <function color="#FFFF00" line="false" dot="false" label="unknown">
+            function helperFunc(c1) {
+              return c1 * c1 - a;
+            }
+
+            return helperFunc(x + 10 * a * b) + Math.sin(a - x);
+          </function>
+          <function output="element" el_id="a_readonly">a</function>
+        </functions>
+
+        <plot>
+
+          <xrange>
+              <min>return 0;</min>
+              <!-- works w/o return -->
+              <max>30</max>
+          </xrange>
+
+          <num_points>120</num_points>
+
+          <xticks>0, 3, 30</xticks>
+          <yticks>-1.5, 1.5, 13.5</yticks>
+
+          <xunits>\(cm\)</xunits>
+          <yunits>\(m\)</yunits>
+        </plot>
+      </configuration>
+    </graphical_slider_tool>
+</vertical>

docs/source/index.rst

@@ -14,7 +14,7 @@ Contents:
    overview.rst
    common-lib.rst
    djangoapps.rst
-
+   xml_formats.rst
 
 Indices and tables
 ==================

docs/source/xml_formats.rst

+XML formats of Inputtypes and Xmodule
+=====================================
+Contents:
+
+.. toctree::
+   :maxdepth: 2
+
+   graphical_slider_tool.rst
\ No newline at end of file

jenkins/quality.sh

@@ -3,6 +3,8 @@
 set -e
 set -x
 
+git remote prune origin
+
 # Reset the submodule, in case it changed
 git submodule foreach 'git reset --hard HEAD'
 

jenkins/test.sh

@@ -15,6 +15,8 @@ function github_mark_failed_on_exit {
     trap '[ $? == "0" ] || github_status state:failure "failed"' EXIT
 }
 
+git remote prune origin
+
 github_mark_failed_on_exit
 github_status state:pending "is running"
 
@@ -26,6 +28,12 @@ export PYTHONIOENCODING=UTF-8
 
 GIT_BRANCH=${GIT_BRANCH/HEAD/master}
 
+# Temporary workaround for pip/numpy bug. (Jenkin's is unable to pip install numpy successfully, scipy fails to install afterwards.
+# We tried pip 1.1, 1.2, all sorts of varieties but it's apparently a pip bug of some kind.
+wget -O /tmp/numpy.tar.gz http://pypi.python.org/packages/source/n/numpy/numpy-1.6.2.tar.gz#md5=95ed6c9dcc94af1fc1642ea2a33c1bba
+tar -zxvf /tmp/numpy.tar.gz -C /tmp/
+python /tmp/numpy-1.6.2/setup.py install
+
 pip install -q -r pre-requirements.txt
 pip install -q -r test-requirements.txt
 yes w | pip install -q -r requirements.txt

lms/.coveragerc

@@ -2,11 +2,13 @@
 [run]
 data_file = reports/lms/.coverage
 source = lms
+omit = lms/envs/*
 
 [report]
 ignore_errors = True
 
 [html]
+title = LMS Python Test Coverage Report
 directory = reports/lms/cover
 
 [xml]

lms/djangoapps/courseware/access.py

@@ -13,6 +13,8 @@ from xmodule.modulestore import Location
 from xmodule.timeparse import parse_time
 from xmodule.x_module import XModule, XModuleDescriptor
 
+from student.models import CourseEnrollmentAllowed
+
 DEBUG_ACCESS = False
 
 log = logging.getLogger(__name__)
@@ -124,6 +126,11 @@ def _has_access_course_desc(user, course, action):
             debug("Allow: in enrollment period")
             return True
 
+        # if user is in CourseEnrollmentAllowed with right course_id then can also enroll
+        if user is not None and CourseEnrollmentAllowed:
+            if CourseEnrollmentAllowed.objects.filter(email=user.email, course_id=course.id):
+                return True
+
         # otherwise, need staff access
         return _has_staff_access_to_descriptor(user, course)
 
@@ -159,13 +166,19 @@ def _has_access_course_desc(user, course, action):
 
     return _dispatch(checkers, action, user, course)
 
+
 def _get_access_group_name_course_desc(course, action):
     '''
-    Return name of group which gives staff access to course.  Only understands action = 'staff'
+    Return name of group which gives staff access to course.  Only understands action = 'staff' and 'instructor'
     '''
-    if not action=='staff':
-        return []
-    return _course_staff_group_name(course.location)
+    if action=='staff':
+        return _course_staff_group_name(course.location)
+    elif action=='instructor':
+        return _course_instructor_group_name(course.location)
+
+    return []
+
+
 
 def _has_access_error_desc(user, descriptor, action):
     """

lms/djangoapps/courseware/admin.py

@@ -7,3 +7,8 @@ from django.contrib import admin
 from django.contrib.auth.models import User
 
 admin.site.register(StudentModule)
+
+admin.site.register(OfflineComputedGrade)
+
+admin.site.register(OfflineComputedGradeLog)
+

lms/djangoapps/courseware/courses.py

@@ -217,11 +217,21 @@ def get_courses_by_university(user, domain=None):
     '''
     # TODO: Clean up how 'error' is done.
     # filter out any courses that errored.
-    visible_courses = branding.get_visible_courses(domain)
+    visible_courses = get_courses(user, domain)
 
     universities = defaultdict(list)
     for course in visible_courses:
-        if not has_access(user, course, 'see_exists'):
-            continue
         universities[course.org].append(course)
+
     return universities
+
+
+def get_courses(user, domain=None):
+    '''
+    Returns a list of courses available, sorted by course.number
+    '''
+    courses = branding.get_visible_courses(domain)
+    courses = [c for c in courses if has_access(user, c, 'see_exists')]
+
+    courses = sorted(courses, key=lambda course:course.number)
+    return courses

lms/djangoapps/courseware/features/courseware.feature

+Feature: View the Courseware Tab
+  As a student in an edX course
+  In order to work on the course
+  I want to view the info on the courseware tab
+
+    Scenario: I can get to the courseware tab when logged in
+    Given I am registered for a course
+    And I log in
+    And I click on View Courseware
+    When I click on the "Courseware" tab
+    Then the "Courseware" tab is active
+
+    # TODO: fix this one? Not sure whether you should get a 404.
+    # Scenario: I cannot get to the courseware tab when not logged in
+    # Given I am not logged in
+    # And I visit the homepage
+    # When I visit the courseware URL    
+    # Then the login dialog is visible

lms/djangoapps/courseware/features/courseware.py

+from lettuce import world, step
+from lettuce.django import django_url
+
+@step('I visit the courseware URL$')
+def i_visit_the_course_info_url(step):
+    url = django_url('/courses/MITx/6.002x/2012_Fall/courseware')
+    world.browser.visit(url)
\ No newline at end of file

lms/djangoapps/courseware/features/courseware_common.py

+from lettuce import world, step
+from lettuce.django import django_url
+
+@step('I click on View Courseware')
+def i_click_on_view_courseware(step):
+    css = 'p.enter-course'
+    world.browser.find_by_css(css).first.click()
+
+@step('I click on the "([^"]*)" tab$')
+def i_click_on_the_tab(step, tab):
+    world.browser.find_link_by_text(tab).first.click()
+    world.save_the_html()
+
+@step('I visit the courseware URL$')
+def i_visit_the_course_info_url(step):
+    url = django_url('/courses/MITx/6.002x/2012_Fall/courseware')
+    world.browser.visit(url)
+
+@step(u'I do not see "([^"]*)" anywhere on the page')
+def i_do_not_see_text_anywhere_on_the_page(step, text):
+    assert world.browser.is_text_not_present(text)    
+
+@step(u'I am on the dashboard page$')
+def i_am_on_the_dashboard_page(step):
+    assert world.browser.is_element_present_by_css('section.courses')
+    assert world.browser.url == django_url('/dashboard')
+
+@step('the "([^"]*)" tab is active$')
+def the_tab_is_active(step, tab):
+    css = '.course-tabs a.active'
+    active_tab = world.browser.find_by_css(css)
+    assert (active_tab.text == tab)
+
+@step('the login dialog is visible$')
+def login_dialog_visible(step):
+    css = 'form#login_form.login_form'
+    assert world.browser.find_by_css(css).visible

lms/djangoapps/courseware/features/high-level-tabs.feature

+Feature: All the high level tabs should work
+  In order to preview the courseware
+  As a student
+  I want to navigate through the high level tabs
+
+# Note this didn't work as a scenario outline because
+# before each scenario was not flushing the database
+# TODO: break this apart so that if one fails the others
+# will still run
+  Scenario: A student can see all tabs of the course
+    Given I am registered for a course
+    And I log in
+    And I click on View Courseware
+    When I click on the "Courseware" tab
+    Then the page title should be "6.002x Courseware"
+    When I click on the "Course Info" tab
+    Then the page title should be "6.002x Course Info"
+    When I click on the "Textbook" tab
+    Then the page title should be "6.002x Textbook"
+    When I click on the "Wiki" tab
+    Then the page title should be "6.002x | edX Wiki"
+    When I click on the "Progress" tab
+    Then the page title should be "6.002x Progress"

lms/djangoapps/courseware/features/openended.feature

+Feature: Open ended grading
+  As a student in an edX course
+  In order to complete the courseware questions
+  I want the machine learning grading to be functional
+
+    Scenario: An answer that is too short is rejected
+    Given I navigate to an openended question
+    And I enter the answer "z"
+    When I press the "Check" button
+    And I wait for "8" seconds
+    And I see the grader status "Submitted for grading"
+    And I press the "Recheck for Feedback" button
+    Then I see the red X
+    And I see the grader score "0"
+
+    Scenario: An answer with too many spelling errors is rejected
+    Given I navigate to an openended question
+    And I enter the answer "az"
+    When I press the "Check" button
+    And I wait for "8" seconds
+    And I see the grader status "Submitted for grading"
+    And I press the "Recheck for Feedback" button
+    Then I see the red X
+    And I see the grader score "0"
+    When I click the link for full output
+    Then I see the spelling grading message "More spelling errors than average."
+
+    Scenario: An answer makes its way to the instructor dashboard
+    Given I navigate to an openended question as staff
+    When I submit the answer "I love Chemistry."
+    And I wait for "8" seconds
+    And I visit the staff grading page
+    Then my answer is queued for instructor grading
\ No newline at end of file

lms/djangoapps/courseware/features/openended.py

+from lettuce import world, step
+from lettuce.django import django_url
+from nose.tools import assert_equals, assert_in
+from logging import getLogger
+logger = getLogger(__name__)
+
+@step('I navigate to an openended question$')
+def navigate_to_an_openended_question(step):
+    world.register_by_course_id('MITx/3.091x/2012_Fall')
+    world.log_in('robot@edx.org','test')
+    problem = '/courses/MITx/3.091x/2012_Fall/courseware/Week_10/Polymer_Synthesis/'
+    world.browser.visit(django_url(problem))
+    tab_css = 'ol#sequence-list > li > a[data-element="5"]'
+    world.browser.find_by_css(tab_css).click()
+
+@step('I navigate to an openended question as staff$')
+def navigate_to_an_openended_question_as_staff(step):
+    world.register_by_course_id('MITx/3.091x/2012_Fall', True)
+    world.log_in('robot@edx.org','test')
+    problem = '/courses/MITx/3.091x/2012_Fall/courseware/Week_10/Polymer_Synthesis/'
+    world.browser.visit(django_url(problem))
+    tab_css = 'ol#sequence-list > li > a[data-element="5"]'
+    world.browser.find_by_css(tab_css).click()
+
+@step(u'I enter the answer "([^"]*)"$')
+def enter_the_answer_text(step, text):
+    textarea_css = 'textarea'
+    world.browser.find_by_css(textarea_css).first.fill(text)
+
+@step(u'I submit the answer "([^"]*)"$')
+def i_submit_the_answer_text(step, text):
+    textarea_css = 'textarea'
+    world.browser.find_by_css(textarea_css).first.fill(text)
+    check_css = 'input.check'
+    world.browser.find_by_css(check_css).click()
+
+@step('I click the link for full output$')
+def click_full_output_link(step):
+    link_css = 'a.full'
+    world.browser.find_by_css(link_css).first.click()
+
+@step(u'I visit the staff grading page$')
+def i_visit_the_staff_grading_page(step):
+    # course_u = '/courses/MITx/3.091x/2012_Fall'
+    # sg_url = '%s/staff_grading' % course_u
+    world.browser.click_link_by_text('Instructor')
+    world.browser.click_link_by_text('Staff grading')    
+    # world.browser.visit(django_url(sg_url))
+
+@step(u'I see the grader message "([^"]*)"$')
+def see_grader_message(step, msg):
+    message_css = 'div.external-grader-message'
+    grader_msg = world.browser.find_by_css(message_css).text
+    assert_in(msg, grader_msg)
+
+@step(u'I see the grader status "([^"]*)"$')
+def see_the_grader_status(step, status):
+    status_css = 'div.grader-status'
+    grader_status = world.browser.find_by_css(status_css).text
+    assert_equals(status, grader_status)
+
+@step('I see the red X$')
+def see_the_red_x(step):
+    x_css = 'div.grader-status > span.incorrect'
+    assert world.browser.find_by_css(x_css)
+
+@step(u'I see the grader score "([^"]*)"$')
+def see_the_grader_score(step, score):
+    score_css = 'div.result-output > p'
+    score_text = world.browser.find_by_css(score_css).text
+    assert_equals(score_text, 'Score: %s' % score)
+
+@step('I see the link for full output$')
+def see_full_output_link(step):
+    link_css = 'a.full'
+    assert world.browser.find_by_css(link_css)
+
+@step('I see the spelling grading message "([^"]*)"$')
+def see_spelling_msg(step, msg):
+    spelling_css = 'div.spelling'
+    spelling_msg = world.browser.find_by_css(spelling_css).text    
+    assert_equals('Spelling: %s' % msg, spelling_msg)
+
+@step(u'my answer is queued for instructor grading$')
+def answer_is_queued_for_instructor_grading(step):
+    list_css = 'ul.problem-list > li > a'
+    actual_msg = world.browser.find_by_css(list_css).text
+    expected_msg = "(0 graded, 1 pending)"
+    assert_in(expected_msg, actual_msg)

lms/djangoapps/courseware/features/smart-accordion.feature

+# Here are all the courses for Fall 2012
+#  MITx/3.091x/2012_Fall
+#  MITx/6.002x/2012_Fall
+#  MITx/6.00x/2012_Fall
+#  HarvardX/CS50x/2012 (we will not be testing this, as it is anomolistic)
+#  HarvardX/PH207x/2012_Fall
+#  BerkeleyX/CS169.1x/2012_Fall
+#  BerkeleyX/CS169.2x/2012_Fall
+#  BerkeleyX/CS184.1x/2012_Fall
+
+#You can load the courses into your data directory with these cmds:
+#  git clone https://github.com/MITx/3.091x.git
+#  git clone https://github.com/MITx/6.00x.git
+#  git clone https://github.com/MITx/content-mit-6002x.git
+#  git clone https://github.com/MITx/content-mit-6002x.git
+#  git clone https://github.com/MITx/content-harvard-id270x.git
+#  git clone https://github.com/MITx/content-berkeley-cs169x.git
+#  git clone https://github.com/MITx/content-berkeley-cs169.2x.git
+#  git clone https://github.com/MITx/content-berkeley-cs184x.git
+
+Feature: There are courses on the homepage
+  In order to compared rendered content to the database
+  As an acceptance test
+  I want to count all the chapters, sections, and tabs for each course
+
+  Scenario: Navigate through course MITx/3.091x/2012_Fall
+    Given I am registered for course "MITx/3.091x/2012_Fall"
+    And I log in
+    Then I verify all the content of each course
+
+  Scenario: Navigate through course MITx/6.002x/2012_Fall
+    Given I am registered for course "MITx/6.002x/2012_Fall"
+    And I log in
+    Then I verify all the content of each course
+
+  Scenario: Navigate through course MITx/6.00x/2012_Fall
+    Given I am registered for course "MITx/6.00x/2012_Fall"
+    And I log in
+    Then I verify all the content of each course
+
+  Scenario: Navigate through course HarvardX/PH207x/2012_Fall
+    Given I am registered for course "HarvardX/PH207x/2012_Fall"
+    And I log in
+    Then I verify all the content of each course
+
+  Scenario: Navigate through course BerkeleyX/CS169.1x/2012_Fall
+    Given I am registered for course "BerkeleyX/CS169.1x/2012_Fall"
+    And I log in
+    Then I verify all the content of each course
+
+  Scenario: Navigate through course BerkeleyX/CS169.2x/2012_Fall
+    Given I am registered for course "BerkeleyX/CS169.2x/2012_Fall"
+    And I log in
+    Then I verify all the content of each course
+
+  Scenario: Navigate through course BerkeleyX/CS184.1x/2012_Fall
+    Given I am registered for course "BerkeleyX/CS184.1x/2012_Fall"
+    And I log in
+    Then I verify all the content of each course
\ No newline at end of file

lms/djangoapps/courseware/features/smart-accordion.py

+from lettuce import world, step
+from re import sub
+from nose.tools import assert_equals
+from xmodule.modulestore.django import modulestore
+from courses import *
+
+from logging import getLogger
+logger = getLogger(__name__)
+
+def check_for_errors():
+    e = world.browser.find_by_css('.outside-app')
+    if len(e) > 0:
+        assert False, 'there was a server error at %s' % (world.browser.url)
+    else:
+        assert True
+
+@step(u'I verify all the content of each course')
+def i_verify_all_the_content_of_each_course(step):
+    all_possible_courses = get_courses()
+    logger.debug('Courses found:')
+    for c in all_possible_courses:
+        logger.debug(c.id)
+    ids = [c.id for c in all_possible_courses]
+
+    # Get a list of all the registered courses
+    registered_courses = world.browser.find_by_css('article.my-course')
+    if len(all_possible_courses) < len(registered_courses):
+        assert False, "user is registered for more courses than are uniquely posssible"
+    else:
+        pass
+
+    for test_course in registered_courses:
+        test_course.find_by_css('a').click()
+        check_for_errors()
+
+        # Get the course. E.g. 'MITx/6.002x/2012_Fall'
+        current_course = sub('/info','', sub('.*/courses/', '', world.browser.url))
+        validate_course(current_course,ids)
+
+        world.browser.find_link_by_text('Courseware').click()
+        assert world.browser.is_element_present_by_id('accordion',wait_time=2)
+        check_for_errors()
+        browse_course(current_course)
+
+        # clicking the user link gets you back to the user's home page
+        world.browser.find_by_css('.user-link').click()
+        check_for_errors()
+
+def browse_course(course_id):
+
+    ## count chapters from xml and page and compare
+    chapters = get_courseware_with_tabs(course_id)
+    num_chapters = len(chapters)
+
+    rendered_chapters = world.browser.find_by_css('#accordion > nav > div')
+    num_rendered_chapters = len(rendered_chapters)
+
+    msg = '%d chapters expected, %d chapters found on page for %s' % (num_chapters, num_rendered_chapters, course_id)
+    #logger.debug(msg)
+    assert num_chapters == num_rendered_chapters, msg
+
+    chapter_it = 0
+
+    ## Iterate the chapters
+    while chapter_it < num_chapters:
+
+        ## click into a chapter
+        world.browser.find_by_css('#accordion > nav > div')[chapter_it].find_by_tag('h3').click()
+
+        ## look for the "there was a server error" div
+        check_for_errors()
+
+        ## count sections from xml and page and compare
+        sections = chapters[chapter_it]['sections']
+        num_sections = len(sections)
+
+        rendered_sections = world.browser.find_by_css('#accordion > nav > div')[chapter_it].find_by_tag('li')
+        num_rendered_sections = len(rendered_sections)
+
+        msg = ('%d sections expected, %d sections found on page, %s - %d - %s' %
+                (num_sections, num_rendered_sections, course_id, chapter_it, chapters[chapter_it]['chapter_name']))
+        #logger.debug(msg)
+        assert num_sections == num_rendered_sections, msg
+
+        section_it = 0
+
+        ## Iterate the sections
+        while section_it < num_sections:
+
+            ## click on a section
+            world.browser.find_by_css('#accordion > nav > div')[chapter_it].find_by_tag('li')[section_it].find_by_tag('a').click()
+
+            ## sometimes the course-content takes a long time to load
+            assert world.browser.is_element_present_by_css('.course-content',wait_time=5)
+
+            ## look for server error div
+            check_for_errors()
+
+            ## count tabs from xml and page and compare
+
+            ## count the number of tabs. If number of tabs is 0, there won't be anything rendered
+            ## so we explicitly set rendered_tabs because otherwise find_elements returns a None object with no length
+            num_tabs = sections[section_it]['clickable_tab_count']
+            if num_tabs != 0:
+                rendered_tabs = world.browser.find_by_css('ol#sequence-list > li')
+                num_rendered_tabs = len(rendered_tabs)
+            else:
+                rendered_tabs = 0
+                num_rendered_tabs = 0
+
+            msg = ('%d tabs expected, %d tabs found, %s - %d - %s' % 
+                        (num_tabs, num_rendered_tabs, course_id, section_it, sections[section_it]['section_name']))
+            #logger.debug(msg)
+
+            # Save the HTML to a file for later comparison
+            world.save_the_course_content('/tmp/%s' % course_id)
+
+            assert num_tabs == num_rendered_tabs, msg
+
+            tabs = sections[section_it]['tabs']
+            tab_it = 0
+
+            ## Iterate the tabs
+            while tab_it < num_tabs:
+
+                rendered_tabs[tab_it].find_by_tag('a').click()
+
+                ## do something with the tab sections[section_it]
+                # e = world.browser.find_by_css('section.course-content section')
+                # process_section(e)
+                tab_children = tabs[tab_it]['children_count']
+                tab_class = tabs[tab_it]['class']
+                if tab_children != 0:
+                    rendered_items = world.browser.find_by_css('div#seq_content > section > ol > li > section')
+                    num_rendered_items = len(rendered_items)              
+                    msg = ('%d items expected, %d items found, %s - %d - %s - tab %d' %
+                        (tab_children, num_rendered_items, course_id, section_it, sections[section_it]['section_name'], tab_it))
+                    #logger.debug(msg)
+                    assert tab_children == num_rendered_items, msg
+
+                tab_it += 1
+
+            section_it += 1
+
+        chapter_it += 1
+
+
+def validate_course(current_course, ids):
+    try:
+        ids.index(current_course)
+    except:
+        assert False, "invalid course id %s" % current_course

lms/djangoapps/courseware/migrations/0005_auto__add_offlinecomputedgrade__add_unique_offlinecomputedgrade_user_c.py

+# -*- coding: utf-8 -*-
+import datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Adding model 'OfflineComputedGrade'
+        db.create_table('courseware_offlinecomputedgrade', (
+            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
+            ('user', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['auth.User'])),
+            ('course_id', self.gf('django.db.models.fields.CharField')(max_length=255, db_index=True)),
+            ('created', self.gf('django.db.models.fields.DateTimeField')(auto_now_add=True, null=True, db_index=True, blank=True)),
+            ('updated', self.gf('django.db.models.fields.DateTimeField')(auto_now=True, db_index=True, blank=True)),
+            ('gradeset', self.gf('django.db.models.fields.TextField')(null=True, blank=True)),
+        ))
+        db.send_create_signal('courseware', ['OfflineComputedGrade'])
+
+        # Adding unique constraint on 'OfflineComputedGrade', fields ['user', 'course_id']
+        db.create_unique('courseware_offlinecomputedgrade', ['user_id', 'course_id'])
+
+        # Adding model 'OfflineComputedGradeLog'
+        db.create_table('courseware_offlinecomputedgradelog', (
+            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
+            ('course_id', self.gf('django.db.models.fields.CharField')(max_length=255, db_index=True)),
+            ('created', self.gf('django.db.models.fields.DateTimeField')(auto_now_add=True, null=True, db_index=True, blank=True)),
+            ('seconds', self.gf('django.db.models.fields.IntegerField')(default=0)),
+            ('nstudents', self.gf('django.db.models.fields.IntegerField')(default=0)),
+        ))
+        db.send_create_signal('courseware', ['OfflineComputedGradeLog'])
+
+
+    def backwards(self, orm):
+        # Removing unique constraint on 'OfflineComputedGrade', fields ['user', 'course_id']
+        db.delete_unique('courseware_offlinecomputedgrade', ['user_id', 'course_id'])
+
+        # Deleting model 'OfflineComputedGrade'
+        db.delete_table('courseware_offlinecomputedgrade')
+
+        # Deleting model 'OfflineComputedGradeLog'
+        db.delete_table('courseware_offlinecomputedgradelog')
+
+
+    models = {
+        'auth.group': {
+            'Meta': {'object_name': 'Group'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
+            'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
+        },
+        'auth.permission': {
+            'Meta': {'ordering': "('content_type__app_label', 'content_type__model', 'codename')", 'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'},
+            'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
+        },
+        'auth.user': {
+            'Meta': {'object_name': 'User'},
+            'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
+            'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
+            'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
+            'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
+        },
+        'contenttypes.contenttype': {
+            'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
+            'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
+        },
+        'courseware.offlinecomputedgrade': {
+            'Meta': {'unique_together': "(('user', 'course_id'),)", 'object_name': 'OfflineComputedGrade'},
+            'course_id': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'}),
+            'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'null': 'True', 'db_index': 'True', 'blank': 'True'}),
+            'gradeset': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'updated': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'db_index': 'True', 'blank': 'True'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']"})
+        },
+        'courseware.offlinecomputedgradelog': {
+            'Meta': {'object_name': 'OfflineComputedGradeLog'},
+            'course_id': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'}),
+            'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'null': 'True', 'db_index': 'True', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'nstudents': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'seconds': ('django.db.models.fields.IntegerField', [], {'default': '0'})
+        },
+        'courseware.studentmodule': {
+            'Meta': {'unique_together': "(('student', 'module_state_key', 'course_id'),)", 'object_name': 'StudentModule'},
+            'course_id': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'}),
+            'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'db_index': 'True', 'blank': 'True'}),
+            'done': ('django.db.models.fields.CharField', [], {'default': "'na'", 'max_length': '8', 'db_index': 'True'}),
+            'grade': ('django.db.models.fields.FloatField', [], {'db_index': 'True', 'null': 'True', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'max_grade': ('django.db.models.fields.FloatField', [], {'null': 'True', 'blank': 'True'}),
+            'modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'db_index': 'True', 'blank': 'True'}),
+            'module_state_key': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_column': "'module_id'", 'db_index': 'True'}),
+            'module_type': ('django.db.models.fields.CharField', [], {'default': "'problem'", 'max_length': '32', 'db_index': 'True'}),
+            'state': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
+            'student': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']"})
+        }
+    }
+
+    complete_apps = ['courseware']
\ No newline at end of file

lms/djangoapps/courseware/models.py

@@ -177,3 +177,40 @@ class StudentModuleCache(object):
 
     def append(self, student_module):
         self.cache.append(student_module)
+
+
+class OfflineComputedGrade(models.Model):
+    """
+    Table of grades computed offline for a given user and course.
+    """
+    user = models.ForeignKey(User, db_index=True)
+    course_id = models.CharField(max_length=255, db_index=True)
+
+    created = models.DateTimeField(auto_now_add=True, null=True, db_index=True)
+    updated = models.DateTimeField(auto_now=True, db_index=True)
+
+    gradeset = models.TextField(null=True, blank=True)		# grades, stored as JSON
+
+    class Meta:
+        unique_together = (('user', 'course_id'), )
+
+    def __unicode__(self):
+        return "[OfflineComputedGrade] %s: %s (%s) = %s" % (self.user, self.course_id, self.created, self.gradeset)
+
+
+class OfflineComputedGradeLog(models.Model):
+    """
+    Log of when offline grades are computed.
+    Use this to be able to show instructor when the last computed grades were done.
+    """
+    class Meta:
+        ordering = ["-created"]
+        get_latest_by = "created"
+
+    course_id = models.CharField(max_length=255, db_index=True)
+    created = models.DateTimeField(auto_now_add=True, null=True, db_index=True)
+    seconds = models.IntegerField(default=0)	# seconds elapsed for computation
+    nstudents = models.IntegerField(default=0)
+
+    def __unicode__(self):
+        return "[OCGLog] %s: %s" % (self.course_id, self.created)

lms/djangoapps/courseware/views.py

@@ -17,7 +17,7 @@ from django.views.decorators.cache import cache_control
 
 from courseware import grades
 from courseware.access import has_access
-from courseware.courses import (get_course_with_access, get_courses_by_university)
+from courseware.courses import (get_courses, get_course_with_access, get_courses_by_university)
 import courseware.tabs as tabs
 from courseware.models import StudentModuleCache
 from module_render import toc_for_course, get_module, get_instance_module
@@ -61,16 +61,19 @@ def user_groups(user):
     return group_names
 
 
-
 @ensure_csrf_cookie
 @cache_if_anonymous
 def courses(request):
     '''
     Render "find courses" page.  The course selection work is done in courseware.courses.
     '''
-    universities = get_courses_by_university(request.user,
-                                             domain=request.META.get('HTTP_HOST'))
-    return render_to_response("courseware/courses.html", {'universities': universities})
+    courses = get_courses(request.user, domain=request.META.get('HTTP_HOST'))
+
+    # Sort courses by how far are they from they start day
+    key = lambda course: course.days_until_start
+    courses = sorted(courses, key=key, reverse=True)
+
+    return render_to_response("courseware/courses.html", {'courses': courses})
 
 
 def render_accordion(request, course, chapter, section):
@@ -317,7 +320,7 @@ def jump_to(request, course_id, location):
     except NoPathToItem:
         raise Http404("This location is not in any class: {0}".format(location))
 
-    # choose the appropriate view (and provide the necessary args) based on the 
+    # choose the appropriate view (and provide the necessary args) based on the
     # args provided by the redirect.
     # Rely on index to do all error handling and access control.
     if chapter is None:
@@ -328,7 +331,7 @@ def jump_to(request, course_id, location):
         return redirect('courseware_section', course_id=course_id, chapter=chapter, section=section)
     else:
         return redirect('courseware_position', course_id=course_id, chapter=chapter, section=section, position=position)
-        
+
 @ensure_csrf_cookie
 def course_info(request, course_id):
     """
@@ -435,6 +438,11 @@ def university_profile(request, org_id):
     # Only grab courses for this org...
     courses = get_courses_by_university(request.user,
                                         domain=request.META.get('HTTP_HOST'))[org_id]
+
+    # Sort courses by how far are they from they start day
+    key = lambda course: course.days_until_start
+    courses = sorted(courses, key=key, reverse=True)
+
     context = dict(courses=courses, org_id=org_id)
     template_file = "university_profile/{0}.html".format(org_id).lower()
 

lms/djangoapps/django_comment_client/models.py

@@ -2,6 +2,10 @@ import logging
 
 from django.db import models
 from django.contrib.auth.models import User
+from django.dispatch import receiver
+from django.db.models.signals import post_save
+
+from student.models import CourseEnrollment
 
 from courseware.courses import get_course_by_id
 
@@ -45,3 +49,14 @@ class Permission(models.Model):
 
     def __unicode__(self):
         return self.name
+
+
+@receiver(post_save, sender=CourseEnrollment)
+def assign_default_role(sender, instance, **kwargs):
+    if instance.user.is_staff:
+        role = Role.objects.get_or_create(course_id=instance.course_id, name="Moderator")[0]
+    else:
+        role = Role.objects.get_or_create(course_id=instance.course_id, name="Student")[0]
+
+    logging.info("assign_default_role: adding %s as %s" % (instance.user, role))
+    instance.user.roles.add(role)

lms/djangoapps/instructor/management/commands/compute_grades.py

+#!/usr/bin/python
+#
+# django management command: dump grades to csv files
+# for use by batch processes
+
+import os, sys, string
+import datetime
+import json
+
+#import student.models
+from instructor.offline_gradecalc import *
+from courseware.courses import get_course_by_id
+from xmodule.modulestore.django import modulestore
+
+from django.conf import settings
+from django.core.management.base import BaseCommand
+
+class Command(BaseCommand):
+    help = "Compute grades for all students in a course, and store result in DB.\n"
+    help += "Usage: compute_grades course_id_or_dir \n"
+    help += "   course_id_or_dir: either course_id or course_dir\n"
+    help += 'Example course_id: MITx/8.01rq_MW/Classical_Mechanics_Reading_Questions_Fall_2012_MW_Section'
+
+    def handle(self, *args, **options):
+
+        print "args = ", args
+
+        if len(args)>0:
+            course_id = args[0]
+        else:
+            print self.help
+            return
+
+        try:
+            course = get_course_by_id(course_id)
+        except Exception as err:
+            if course_id in modulestore().courses:
+                course = modulestore().courses[course_id]
+            else:
+                print "-----------------------------------------------------------------------------"
+                print "Sorry, cannot find course %s" % course_id
+                print "Please provide a course ID or course data directory name, eg content-mit-801rq"
+                return
+
+        print "-----------------------------------------------------------------------------"
+        print "Computing grades for %s" % (course.id)
+
+        offline_grade_calculation(course.id)
+
+
+    
+        

lms/djangoapps/instructor/offline_gradecalc.py

+# ======== Offline calculation of grades =============================================================================
+#
+# Computing grades of a large number of students can take a long time.  These routines allow grades to
+# be computed offline, by a batch process (eg cronjob).
+#
+# The grades are stored in the OfflineComputedGrade table of the courseware model.
+
+import json
+import logging
+import time
+
+import courseware.models
+
+from collections import namedtuple
+from json import JSONEncoder
+from courseware import grades, models
+from courseware.courses import get_course_by_id
+from django.contrib.auth.models import User, Group
+
+
+class MyEncoder(JSONEncoder):
+
+    def _iterencode(self, obj, markers=None):
+        if isinstance(obj, tuple) and hasattr(obj, '_asdict'):
+            gen = self._iterencode_dict(obj._asdict(), markers)
+        else:
+            gen = JSONEncoder._iterencode(self, obj, markers)
+        for chunk in gen:
+            yield chunk
+
+
+def offline_grade_calculation(course_id):
+    '''
+    Compute grades for all students for a specified course, and save results to the DB.  
+    '''
+
+    tstart = time.time()
+    enrolled_students = User.objects.filter(courseenrollment__course_id=course_id).prefetch_related("groups").order_by('username')
+
+    enc = MyEncoder()
+
+    class DummyRequest(object):
+        META = {}
+        def __init__(self):
+            return
+        def get_host(self):
+            return 'edx.mit.edu'
+        def is_secure(self):
+            return False
+
+    request = DummyRequest()
+
+    print "%d enrolled students" % len(enrolled_students)
+    course = get_course_by_id(course_id)
+
+    for student in enrolled_students:
+        gradeset = grades.grade(student, request, course, keep_raw_scores=True)
+        gs = enc.encode(gradeset)
+        ocg, created = models.OfflineComputedGrade.objects.get_or_create(user=student, course_id=course_id)
+        ocg.gradeset = gs
+        ocg.save()
+        print "%s done" % student	# print statement used because this is run by a management command
+
+    tend = time.time()
+    dt = tend - tstart
+    
+    ocgl = models.OfflineComputedGradeLog(course_id=course_id, seconds=dt, nstudents=len(enrolled_students))
+    ocgl.save()
+    print ocgl
+    print "All Done!"
+    
+
+def offline_grades_available(course_id):
+    '''
+    Returns False if no offline grades available for specified course.
+    Otherwise returns latest log field entry about the available pre-computed grades.
+    '''
+    ocgl = models.OfflineComputedGradeLog.objects.filter(course_id=course_id)
+    if not ocgl:
+        return False
+    return ocgl.latest('created')
+
+    
+def student_grades(student, request, course, keep_raw_scores=False, use_offline=False):
+    '''
+    This is the main interface to get grades.  It has the same parameters as grades.grade, as well
+    as use_offline.  If use_offline is True then this will look for an offline computed gradeset in the DB.
+    '''
+
+    if not use_offline:
+        return grades.grade(student, request, course, keep_raw_scores=keep_raw_scores)
+    
+    try:
+        ocg = models.OfflineComputedGrade.objects.get(user=student, course_id=course.id)
+    except models.OfflineComputedGrade.DoesNotExist:
+        return dict(raw_scores=[], section_breakdown=[], 
+                    msg='Error: no offline gradeset available for %s, %s' % (student, course.id))
+    
+    return json.loads(ocg.gradeset)
+
+
+        
+

lms/djangoapps/instructor/tests.py

@@ -25,7 +25,6 @@ from django_comment_client.models import Role, FORUM_ROLE_ADMINISTRATOR, \
     FORUM_ROLE_MODERATOR, FORUM_ROLE_COMMUNITY_TA, FORUM_ROLE_STUDENT
 from django_comment_client.utils import has_forum_access
 
-from instructor import staff_grading_service
 from courseware.access import _course_staff_group_name
 import courseware.tests.tests as ct
 from xmodule.modulestore.django import modulestore
@@ -100,7 +99,6 @@ def action_name(operation, rolename):
         return '{0} forum {1}'.format(operation, FORUM_ADMIN_ACTION_SUFFIX[rolename])
 
 
-_mock_service = staff_grading_service.MockStaffGradingService()
 
 @override_settings(MODULESTORE=ct.TEST_DATA_XML_MODULESTORE)
 class TestInstructorDashboardForumAdmin(ct.PageLoader):
@@ -223,94 +221,3 @@ class TestInstructorDashboardForumAdmin(ct.PageLoader):
             self.assertTrue(response.content.find('<td>{0}</td>'.format(roles))>=0, 'not finding roles "{0}"'.format(roles))
 
 
-@override_settings(MODULESTORE=ct.TEST_DATA_XML_MODULESTORE)
-class TestStaffGradingService(ct.PageLoader):
-    '''
-    Check that staff grading service proxy works.  Basically just checking the
-    access control and error handling logic -- all the actual work is on the
-    backend.
-    '''
-    def setUp(self):
-        xmodule.modulestore.django._MODULESTORES = {}
-
-        self.student = 'view@test.com'
-        self.instructor = 'view2@test.com'
-        self.password = 'foo'
-        self.location = 'TestLocation'
-        self.create_account('u1', self.student, self.password)
-        self.create_account('u2', self.instructor, self.password)
-        self.activate_user(self.student)
-        self.activate_user(self.instructor)
-        
-        self.course_id = "edX/toy/2012_Fall"
-        self.toy = modulestore().get_course(self.course_id)
-        def make_instructor(course):
-            group_name = _course_staff_group_name(course.location)
-            g = Group.objects.create(name=group_name)
-            g.user_set.add(ct.user(self.instructor))
-
-        make_instructor(self.toy)
-
-        self.mock_service = staff_grading_service.grading_service()
-
-        self.logout()
-
-    def test_access(self):
-        """
-        Make sure only staff have access.
-        """
-        self.login(self.student, self.password)
-
-        # both get and post should return 404
-        for view_name in ('staff_grading_get_next', 'staff_grading_save_grade'):
-            url = reverse(view_name, kwargs={'course_id': self.course_id})
-            self.check_for_get_code(404, url)
-            self.check_for_post_code(404, url)
-
-
-    def test_get_next(self):
-        self.login(self.instructor, self.password)
-
-        url = reverse('staff_grading_get_next', kwargs={'course_id': self.course_id})
-        data = {'location': self.location}
-
-        r = self.check_for_post_code(200, url, data)
-        d = json.loads(r.content)
-        self.assertTrue(d['success'])
-        self.assertEquals(d['submission_id'], self.mock_service.cnt)
-        self.assertIsNotNone(d['submission'])
-        self.assertIsNotNone(d['num_graded'])
-        self.assertIsNotNone(d['min_for_ml'])
-        self.assertIsNotNone(d['num_pending'])
-        self.assertIsNotNone(d['prompt'])
-        self.assertIsNotNone(d['ml_error_info'])
-        self.assertIsNotNone(d['max_score'])
-        self.assertIsNotNone(d['rubric'])
-
-
-    def test_save_grade(self):
-        self.login(self.instructor, self.password)
-
-        url = reverse('staff_grading_save_grade', kwargs={'course_id': self.course_id})
-
-        data = {'score': '12',
-                'feedback': 'great!',
-                'submission_id': '123',
-                'location': self.location}
-        r = self.check_for_post_code(200, url, data)
-        d = json.loads(r.content)
-        self.assertTrue(d['success'], str(d))
-        self.assertEquals(d['submission_id'], self.mock_service.cnt)
-
-    def test_get_problem_list(self):
-        self.login(self.instructor, self.password)
-
-        url = reverse('staff_grading_get_problem_list', kwargs={'course_id': self.course_id})
-        data = {}
-
-        r = self.check_for_post_code(200, url, data)
-        d = json.loads(r.content)
-        self.assertTrue(d['success'], str(d))
-        self.assertIsNotNone(d['problem_list'])
-
-

lms/djangoapps/open_ended_grading/grading_service.py

+# This class gives a common interface for logging into the grading controller
+import json
+import logging
+import requests
+from requests.exceptions import RequestException, ConnectionError, HTTPError
+import sys
+
+from django.conf import settings
+from django.http import HttpResponse, Http404
+
+from courseware.access import has_access
+from util.json_request import expect_json
+from xmodule.course_module import CourseDescriptor
+
+log = logging.getLogger(__name__)
+
+class GradingServiceError(Exception):
+    pass
+
+class GradingService(object):
+    """
+    Interface to staff grading backend.
+    """
+    def __init__(self, config):
+        self.username = config['username']
+        self.password = config['password']
+        self.url = config['url']
+        self.login_url = self.url + '/login/'
+        self.session = requests.session()
+
+    def _login(self):
+        """
+        Log into the staff grading service.
+
+        Raises requests.exceptions.HTTPError if something goes wrong.
+
+        Returns the decoded json dict of the response.
+        """
+        response = self.session.post(self.login_url,
+                                     {'username': self.username,
+                                      'password': self.password,})
+
+        response.raise_for_status()
+
+        return response.json
+
+    def post(self, url, data, allow_redirects=False): 
+        """
+        Make a post request to the grading controller
+        """
+        try:
+            op = lambda: self.session.post(url, data=data,
+                                           allow_redirects=allow_redirects)
+            r = self._try_with_login(op)
+        except (RequestException, ConnectionError, HTTPError) as err:
+            # reraise as promised GradingServiceError, but preserve stacktrace.
+            raise GradingServiceError, str(err), sys.exc_info()[2]
+
+        return r.text
+
+    def get(self, url, params, allow_redirects=False):
+        """
+        Make a get request to the grading controller
+        """
+        log.debug(params)
+        op = lambda: self.session.get(url,
+                                      allow_redirects=allow_redirects,
+                                      params=params)
+        try:
+            r = self._try_with_login(op)
+        except (RequestException, ConnectionError, HTTPError) as err:
+            # reraise as promised GradingServiceError, but preserve stacktrace.
+            raise GradingServiceError, str(err), sys.exc_info()[2]
+
+        return r.text
+        
+
+    def _try_with_login(self, operation):
+        """
+        Call operation(), which should return a requests response object.  If
+        the request fails with a 'login_required' error, call _login() and try
+        the operation again.
+
+        Returns the result of operation().  Does not catch exceptions.
+        """
+        response = operation()
+        if (response.json
+            and response.json.get('success') == False
+            and response.json.get('error') == 'login_required'):
+            # apparrently we aren't logged in.  Try to fix that.
+            r = self._login()
+            if r and not r.get('success'):
+                log.warning("Couldn't log into staff_grading backend. Response: %s",
+                            r)
+            # try again
+            response = operation()
+            response.raise_for_status()
+
+        return response
+