Merge pull request #1263 from MITx/feature/ichuang/instructor-dashboard-upgrade3

Upgrade to instructor dashboard: enrollment, offline grades, remote gradebook

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

@@ -49,7 +49,6 @@ from django.db.models.signals import post_save
 from django.dispatch import receiver
 
 import comment_client as cc
-from django_comment_client.models import Role
 
 
 log = logging.getLogger(__name__)
@@ -262,15 +261,23 @@ 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'), )
+
+    def __unicode__(self):
+        return "[CourseEnrollmentAllowed] %s: %s (%s)" % (self.email, self.course_id, self.created)
 
-    logging.info("assign_default_role: adding %s as %s" % (instance.user, role))
-    instance.user.roles.add(role)
 
 #cache_relation(User.profile)
 

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"

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/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/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/envs/dev.py

@@ -102,6 +102,10 @@ SUBDOMAIN_BRANDING = {
 
 COMMENTS_SERVICE_KEY = "PUT_YOUR_API_KEY_HERE"
 
+################################# mitx revision string  #####################
+
+MITX_VERSION_STRING = os.popen('cd %s; git describe' % REPO_ROOT).read().strip()
+
 ################################# Staff grading config  #####################
 
 STAFF_GRADING_INTERFACE = {

lms/templates/courseware/instructor_dashboard.html

@@ -57,10 +57,13 @@ function goto( mode)
             <a href="#" onclick="goto('Psychometrics');" class="${modeflag.get('Psychometrics')}">Psychometrics</a> | 
           %endif
           <a href="#" onclick="goto('Admin');" class="${modeflag.get('Admin')}">Admin</a> |
-          <a href="#" onclick="goto('Forum Admin');" class="${modeflag.get('Forum Admin')}">Forum Admin</a> ]
+          <a href="#" onclick="goto('Forum Admin');" class="${modeflag.get('Forum Admin')}">Forum Admin</a> |
+          <a href="#" onclick="goto('Enrollment');" class="${modeflag.get('Enrollment')}">Enrollment</a>
+	 ]
     </h2>
 
-  <div style="text-align:right" id="djangopid">${djangopid}</div>
+  <div style="text-align:right"><span id="djangopid">${djangopid}</span>
+  | <span id="mitxver">${mitx_version}</span></div>
 
     <form name="idashform" method="POST">
     <input type="hidden" name="csrfmiddlewaretoken" value="${ csrf_token }">
@@ -68,6 +71,12 @@ function goto( mode)
 
 ##----------------------------------------------------------------------------- 
 %if modeflag.get('Grades'):
+
+    %if offline_grade_log:
+      <p><font color='orange'>Pre-computed grades ${offline_grade_log} available: Use?
+          <input type='checkbox' name='use_offline_grades' value='yes'></font> </p>
+    %endif
+
     <p>
     <a href="${reverse('gradebook', kwargs=dict(course_id=course.id))}">Gradebook</a>
     </p>
@@ -93,6 +102,42 @@ function goto( mode)
     <p>
     <input type="submit" name="action" value="Download CSV of answer distributions">
     </p>
+    <hr width="40%" style="align:left">
+
+  %if settings.MITX_FEATURES.get('REMOTE_GRADEBOOK_URL','') and instructor_access:
+  
+    <%
+        rg = course.metadata.get('remote_gradebook',{})
+    %>
+
+    <h3>Export grades to remote gradebook</h3>
+    <p>The assignments defined for this course should match the ones
+    stored in the gradebook, for this to work properly!</p>
+
+    <ul>
+    <li>Gradebook name: <font color="green">${rg.get('name','None defined!')}</font>
+    <br/>
+    <br/>
+    <input type="submit" name="action" value="List assignments available in remote gradebook">
+    <input type="submit" name="action" value="List enrolled students matching remote gradebook">
+    <br/>
+    <br/>
+    </li>
+    <li><input type="submit" name="action" value="List assignments available for this course">
+    <br/>
+    <br/>
+    </li>
+    <li>Assignment name: <input type="text" name="assignment_name" size=40 >
+    <br/>
+    <br/>
+    <input type="submit" name="action" value="Display grades for assignment">
+    <input type="submit" name="action" value="Export grades for assignment to remote gradebook">
+    <input type="submit" name="action" value="Export CSV file of grades for assignment">
+    </li>
+    </ul>
+
+  %endif
+
  %endif
 
 ##----------------------------------------------------------------------------- 
@@ -128,6 +173,16 @@ function goto( mode)
     <hr width="40%" style="align:left">
   %endif
 
+  %if admin_access:
+    <hr width="40%" style="align:left">
+    <p>
+    <input type="submit" name="action" value="List course instructors">
+    <p>
+    <input type="text" name="instructor"> <input type="submit" name="action" value="Remove instructor">
+    <input type="submit" name="action" value="Add instructor">
+    <hr width="40%" style="align:left">
+  %endif
+
   %if settings.MITX_FEATURES['ENABLE_MANUAL_GIT_RELOAD'] and admin_access:
     <p>
     <input type="submit" name="action" value="Reload course from XML files">
@@ -163,10 +218,52 @@ function goto( mode)
   %endif
 %endif
 
+##----------------------------------------------------------------------------- 
+%if modeflag.get('Enrollment'):
+
+    <hr width="40%" style="align:left">
+    <p>
+    <input type="submit" name="action" value="List enrolled students">
+    <input type="submit" name="action" value="List students who may enroll but may not have yet signed up">
+    <p>
+    Student Email: <input type="text" name="enstudent"> <input type="submit" name="action" value="Un-enroll student">
+    <input type="submit" name="action" value="Enroll student">
+    <input type="submit" name="action" value="Un-enroll ALL students">
+    <hr width="40%" style="align:left">
+
+  %if settings.MITX_FEATURES.get('REMOTE_GRADEBOOK_URL','') and instructor_access:
+  
+    <%
+        rg = course.metadata.get('remote_gradebook',{})
+    %>
+
+    <p>Pull enrollment from remote gradebook</p>
+    <ul>
+    <li>Gradebook name: <font color="green">${rg.get('name','None defined!')}</font>
+    <li>Section: <input type="text" name="gradebook_section" size=40 value="${rg.get('section','')}"></li>
+    </ul>
+    <input type="submit" name="action" value="List sections available in remote gradebook">
+    <input type="submit" name="action" value="List students in section in remote gradebook">
+    <input type="submit" name="action" value="Overload enrollment list using remote gradebook">
+    <input type="submit" name="action" value="Merge enrollment list with remote gradebook">
+    <hr width="40%" style="align:left">
+  
+  %endif
+
+  <p>Add students: enter emails, separated by returns or commas;</p>
+  <textarea rows="6" cols="70" name="enroll_multiple"></textarea>
+  <input type="submit" name="action" value="Enroll multiple students">
+
+%endif
+
+##----------------------------------------------------------------------------- 
+
     </form>
 
 ##----------------------------------------------------------------------------- 
-%if modeflag.get('Psychometrics') is None:
+##----------------------------------------------------------------------------- 
+
+%if datatable and modeflag.get('Psychometrics') is None:
 
     <br/>
     <br/>