Merge pull request #1990 from edx/feature/abarrett/lms-notes-app

LMS Notes Djangoapp

cms/djangoapps/contentstore/tests/test_utils.py

 """ Tests for utils. """
 from contentstore import utils
 import mock
+import collections
+import copy
 from django.test import TestCase
 from xmodule.modulestore.tests.factories import CourseFactory
 from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
@@ -70,3 +72,79 @@ class UrlReverseTestCase(ModuleStoreTestCase):
             'https://edge.edx.org/courses/edX/edX101/How_to_Create_an_edX_Course/about',
             utils.get_url_reverse('https://edge.edx.org/courses/edX/edX101/How_to_Create_an_edX_Course/about', course)
         )
+
+
+class ExtraPanelTabTestCase(TestCase):
+    """ Tests adding and removing extra course tabs. """
+
+    def get_tab_type_dicts(self, tab_types):
+        """ Returns an array of tab dictionaries. """
+        if tab_types:
+            return [{'tab_type': tab_type} for tab_type in tab_types.split(',')]
+        else:
+            return []
+
+    def get_course_with_tabs(self, tabs=[]):
+        """ Returns a mock course object with a tabs attribute. """
+        course = collections.namedtuple('MockCourse', ['tabs'])
+        if isinstance(tabs, basestring):
+            course.tabs = self.get_tab_type_dicts(tabs)
+        else:
+            course.tabs = tabs
+        return course
+
+    def test_add_extra_panel_tab(self):
+        """ Tests if a tab can be added to a course tab list. """
+        for tab_type in utils.EXTRA_TAB_PANELS.keys():
+            tab = utils.EXTRA_TAB_PANELS.get(tab_type)
+
+            # test adding with changed = True
+            for tab_setup in ['', 'x', 'x,y,z']:
+                course = self.get_course_with_tabs(tab_setup)
+                expected_tabs = copy.copy(course.tabs)
+                expected_tabs.append(tab)
+                changed, actual_tabs = utils.add_extra_panel_tab(tab_type, course)
+                self.assertTrue(changed)
+                self.assertEqual(actual_tabs, expected_tabs)
+
+            # test adding with changed = False
+            tab_test_setup = [
+                [tab],
+                [tab, self.get_tab_type_dicts('x,y,z')],
+                [self.get_tab_type_dicts('x,y'), tab, self.get_tab_type_dicts('z')],
+                [self.get_tab_type_dicts('x,y,z'), tab]]
+
+            for tab_setup in tab_test_setup:
+                course = self.get_course_with_tabs(tab_setup)
+                expected_tabs = copy.copy(course.tabs)
+                changed, actual_tabs = utils.add_extra_panel_tab(tab_type, course)
+                self.assertFalse(changed)
+                self.assertEqual(actual_tabs, expected_tabs)
+
+    def test_remove_extra_panel_tab(self):
+        """ Tests if a tab can be removed from a course tab list. """
+        for tab_type in utils.EXTRA_TAB_PANELS.keys():
+            tab = utils.EXTRA_TAB_PANELS.get(tab_type)
+
+            # test removing with changed = True
+            tab_test_setup = [
+                [tab],
+                [tab, self.get_tab_type_dicts('x,y,z')],
+                [self.get_tab_type_dicts('x,y'), tab, self.get_tab_type_dicts('z')],
+                [self.get_tab_type_dicts('x,y,z'), tab]]
+
+            for tab_setup in tab_test_setup:
+                course = self.get_course_with_tabs(tab_setup)
+                expected_tabs = [t for t in course.tabs if t != utils.EXTRA_TAB_PANELS.get(tab_type)]
+                changed, actual_tabs = utils.remove_extra_panel_tab(tab_type, course)
+                self.assertTrue(changed)
+                self.assertEqual(actual_tabs, expected_tabs)
+
+            # test removing with changed = False
+            for tab_setup in ['', 'x', 'x,y,z']:
+                course = self.get_course_with_tabs(tab_setup)
+                expected_tabs = copy.copy(course.tabs)
+                changed, actual_tabs = utils.remove_extra_panel_tab(tab_type, course)
+                self.assertFalse(changed)
+                self.assertEqual(actual_tabs, expected_tabs)
+

cms/djangoapps/contentstore/utils.py

@@ -9,6 +9,8 @@ DIRECT_ONLY_CATEGORIES = ['course', 'chapter', 'sequential', 'about', 'static_ta
 
 #In order to instantiate an open ended tab automatically, need to have this data
 OPEN_ENDED_PANEL = {"name": "Open Ended Panel", "type": "open_ended"}
+NOTES_PANEL = {"name": "My Notes", "type": "notes"}
+EXTRA_TAB_PANELS = dict([(p['type'], p) for p in [OPEN_ENDED_PANEL, NOTES_PANEL]])
 
 
 def get_modulestore(location):
@@ -192,9 +194,10 @@ class CoursePageNames:
     Checklists = "checklists"
 
 
-def add_open_ended_panel_tab(course):
+def add_extra_panel_tab(tab_type, course):
     """
-    Used to add the open ended panel tab to a course if it does not exist.
+    Used to add the panel tab to a course if it does not exist.
+    @param tab_type: A string representing the tab type.
     @param course: A course object from the modulestore.
     @return: Boolean indicating whether or not a tab was added and a list of tabs for the course.
     """
@@ -202,16 +205,19 @@ def add_open_ended_panel_tab(course):
     course_tabs = copy.copy(course.tabs)
     changed = False
     #Check to see if open ended panel is defined in the course
-    if OPEN_ENDED_PANEL not in course_tabs:
+    
+    tab_panel = EXTRA_TAB_PANELS.get(tab_type)
+    if tab_panel not in course_tabs:
         #Add panel to the tabs if it is not defined
-        course_tabs.append(OPEN_ENDED_PANEL)
+        course_tabs.append(tab_panel)
         changed = True
     return changed, course_tabs
 
 
-def remove_open_ended_panel_tab(course):
+def remove_extra_panel_tab(tab_type, course):
     """
-    Used to remove the open ended panel tab from a course if it exists.
+    Used to remove the panel tab from a course if it exists.
+    @param tab_type: A string representing the tab type.
     @param course: A course object from the modulestore.
     @return: Boolean indicating whether or not a tab was added and a list of tabs for the course.
     """
@@ -219,8 +225,10 @@ def remove_open_ended_panel_tab(course):
     course_tabs = copy.copy(course.tabs)
     changed = False
     #Check to see if open ended panel is defined in the course
-    if OPEN_ENDED_PANEL in course_tabs:
+
+    tab_panel = EXTRA_TAB_PANELS.get(tab_type)
+    if tab_panel in course_tabs:
         #Add panel to the tabs if it is not defined
-        course_tabs = [ct for ct in course_tabs if ct != OPEN_ENDED_PANEL]
+        course_tabs = [ct for ct in course_tabs if ct != tab_panel]
         changed = True
     return changed, course_tabs

cms/djangoapps/contentstore/views/component.py

@@ -41,7 +41,8 @@ log = logging.getLogger(__name__)
 COMPONENT_TYPES = ['customtag', 'discussion', 'html', 'problem', 'video']
 
 OPEN_ENDED_COMPONENT_TYPES = ["combinedopenended", "peergrading"]
-ADVANCED_COMPONENT_TYPES = ['annotatable', 'word_cloud'] + OPEN_ENDED_COMPONENT_TYPES
+NOTE_COMPONENT_TYPES = ['notes']
+ADVANCED_COMPONENT_TYPES = ['annotatable' + 'word_cloud'] + OPEN_ENDED_COMPONENT_TYPES + NOTE_COMPONENT_TYPES
 ADVANCED_COMPONENT_CATEGORY = 'advanced'
 ADVANCED_COMPONENT_POLICY_KEY = 'advanced_modules'
 

cms/djangoapps/contentstore/views/course.py

@@ -20,8 +20,8 @@ from xmodule.modulestore import Location
 from contentstore.course_info_model \
      import get_course_updates, update_course_updates, delete_course_update
 from contentstore.utils \
-     import get_lms_link_for_item, add_open_ended_panel_tab, \
-     remove_open_ended_panel_tab
+     import get_lms_link_for_item, add_extra_panel_tab, \
+     remove_extra_panel_tab
 from models.settings.course_details \
      import CourseDetails, CourseSettingsEncoder
 from models.settings.course_grading import CourseGradingModel
@@ -32,7 +32,8 @@ from util.json_request import expect_json
 from .access import has_access, get_location_and_verify_access
 from .requests import get_request_method
 from .tabs import initialize_course_tabs
-from .component import OPEN_ENDED_COMPONENT_TYPES, ADVANCED_COMPONENT_POLICY_KEY
+from .component import OPEN_ENDED_COMPONENT_TYPES, \
+     NOTE_COMPONENT_TYPES, ADVANCED_COMPONENT_POLICY_KEY
 
 __all__ = ['course_index', 'create_new_course', 'course_info',
            'course_info_updates', 'get_course_settings',
@@ -352,38 +353,52 @@ def course_advanced_updates(request, org, course, name):
         request_body = json.loads(request.body)
         # Whether or not to filter the tabs key out of the settings metadata
         filter_tabs = True
-        # Check to see if the user instantiated any advanced components.
-        # This is a hack to add the open ended panel tab
-        # to a course automatically if the user has indicated that they want
-        # to edit the combinedopenended or peergrading
-        # module, and to remove it if they have removed the open ended elements.
+
+        #Check to see if the user instantiated any advanced components. This is a hack
+        #that does the following : 
+        #   1) adds/removes the open ended panel tab to a course automatically if the user 
+        #   has indicated that they want to edit the combinedopendended or peergrading module
+        #   2) adds/removes the notes panel tab to a course automatically if the user has
+        #   indicated that they want the notes module enabled in their course
+        # TODO refactor the above into distinct advanced policy settings
         if ADVANCED_COMPONENT_POLICY_KEY in request_body:
-            # Check to see if the user instantiated any open ended components
-            found_oe_type = False
-            # Get the course so that we can scrape current tabs
+            #Get the course so that we can scrape current tabs
             course_module = modulestore().get_item(location)
-            for oe_type in OPEN_ENDED_COMPONENT_TYPES:
-                if oe_type in request_body[ADVANCED_COMPONENT_POLICY_KEY]:
-                    # Add an open ended tab to the course if needed
-                    changed, new_tabs = add_open_ended_panel_tab(course_module)
-                    # If a tab has been added to the course, then send the
-                    # metadata along to CourseMetadata.update_from_json
+
+            #Maps tab types to components 
+            tab_component_map = {
+                'open_ended': OPEN_ENDED_COMPONENT_TYPES, 
+                'notes': NOTE_COMPONENT_TYPES,
+            }
+
+            #Check to see if the user instantiated any notes or open ended components
+            for tab_type in tab_component_map.keys():
+                component_types = tab_component_map.get(tab_type)
+                found_ac_type = False
+                for ac_type in component_types:
+                    if ac_type in request_body[ADVANCED_COMPONENT_POLICY_KEY]:
+                        #Add tab to the course if needed
+                        changed, new_tabs = add_extra_panel_tab(tab_type, course_module)
+                        #If a tab has been added to the course, then send the metadata along to CourseMetadata.update_from_json
                         if changed:
+                            course_module.tabs = new_tabs
                             request_body.update({'tabs': new_tabs})
-                        # Indicate that tabs should not be filtered out of the metadata
+                            #Indicate that tabs should not be filtered out of the metadata
                             filter_tabs = False
-                    # Set this flag to avoid the open ended tab removal code below.
-                    found_oe_type = True
+                        #Set this flag to avoid the tab removal code below.
+                        found_ac_type = True
                         break
-            # If we did not find an open ended module type in the advanced settings,
-            # we may need to remove the open ended tab from the course.
-            if not found_oe_type:
-                # Remove open ended tab to the course if needed
-                changed, new_tabs = remove_open_ended_panel_tab(course_module)
+                #If we did not find a module type in the advanced settings,
+                # we may need to remove the tab from the course.
+                if not found_ac_type:
+                    #Remove tab from the course if needed
+                    changed, new_tabs = remove_extra_panel_tab(tab_type, course_module)
                     if changed:
+                        course_module.tabs = new_tabs
                         request_body.update({'tabs': new_tabs})
-                    # Indicate that tabs should not be filtered out of the metadata
+                        #Indicate that tabs should *not* be filtered out of the metadata
                         filter_tabs = False
+
         response_json = json.dumps(CourseMetadata.update_from_json(location,
                                                                    request_body,
                                                                    filter_tabs=filter_tabs))

common/static/js/vendor/annotator.store.js

+/*
+** Annotator 1.2.6-dev-dc18206
+** https://github.com/okfn/annotator/
+**
+** Copyright 2012 Aron Carroll, Rufus Pollock, and Nick Stenning.
+** Dual licensed under the MIT and GPLv3 licenses.
+** https://github.com/okfn/annotator/blob/master/LICENSE
+**
+** Built at: 2013-05-16 18:02:02Z
+*/
+
+
+(function() {
+  var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
+    __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
+
+  Annotator.Plugin.Store = (function(_super) {
+    __extends(Store, _super);
+
+    Store.prototype.events = {
+      'annotationCreated': 'annotationCreated',
+      'annotationDeleted': 'annotationDeleted',
+      'annotationUpdated': 'annotationUpdated'
+    };
+
+    Store.prototype.options = {
+      annotationData: {},
+      emulateHTTP: false,
+      loadFromSearch: false,
+      prefix: '/store',
+      urls: {
+        create: '/annotations',
+        read: '/annotations/:id',
+        update: '/annotations/:id',
+        destroy: '/annotations/:id',
+        search: '/search'
+      }
+    };
+
+    function Store(element, options) {
+      this._onError = __bind(this._onError, this);
+      this._onLoadAnnotationsFromSearch = __bind(this._onLoadAnnotationsFromSearch, this);
+      this._onLoadAnnotations = __bind(this._onLoadAnnotations, this);
+      this._getAnnotations = __bind(this._getAnnotations, this);      Store.__super__.constructor.apply(this, arguments);
+      this.annotations = [];
+    }
+
+    Store.prototype.pluginInit = function() {
+      if (!Annotator.supported()) {
+        return;
+      }
+      if (this.annotator.plugins.Auth) {
+        return this.annotator.plugins.Auth.withToken(this._getAnnotations);
+      } else {
+        return this._getAnnotations();
+      }
+    };
+
+    Store.prototype._getAnnotations = function() {
+      if (this.options.loadFromSearch) {
+        return this.loadAnnotationsFromSearch(this.options.loadFromSearch);
+      } else {
+        return this.loadAnnotations();
+      }
+    };
+
+    Store.prototype.annotationCreated = function(annotation) {
+      var _this = this;
+
+      if (__indexOf.call(this.annotations, annotation) < 0) {
+        this.registerAnnotation(annotation);
+        return this._apiRequest('create', annotation, function(data) {
+          if (data.id == null) {
+            console.warn(Annotator._t("Warning: No ID returned from server for annotation "), annotation);
+          }
+          return _this.updateAnnotation(annotation, data);
+        });
+      } else {
+        return this.updateAnnotation(annotation, {});
+      }
+    };
+
+    Store.prototype.annotationUpdated = function(annotation) {
+      var _this = this;
+
+      if (__indexOf.call(this.annotations, annotation) >= 0) {
+        return this._apiRequest('update', annotation, (function(data) {
+          return _this.updateAnnotation(annotation, data);
+        }));
+      }
+    };
+
+    Store.prototype.annotationDeleted = function(annotation) {
+      var _this = this;
+
+      if (__indexOf.call(this.annotations, annotation) >= 0) {
+        return this._apiRequest('destroy', annotation, (function() {
+          return _this.unregisterAnnotation(annotation);
+        }));
+      }
+    };
+
+    Store.prototype.registerAnnotation = function(annotation) {
+      return this.annotations.push(annotation);
+    };
+
+    Store.prototype.unregisterAnnotation = function(annotation) {
+      return this.annotations.splice(this.annotations.indexOf(annotation), 1);
+    };
+
+    Store.prototype.updateAnnotation = function(annotation, data) {
+      if (__indexOf.call(this.annotations, annotation) < 0) {
+        console.error(Annotator._t("Trying to update unregistered annotation!"));
+      } else {
+        $.extend(annotation, data);
+      }
+      return $(annotation.highlights).data('annotation', annotation);
+    };
+
+    Store.prototype.loadAnnotations = function() {
+      return this._apiRequest('read', null, this._onLoadAnnotations);
+    };
+
+    Store.prototype._onLoadAnnotations = function(data) {
+      if (data == null) {
+        data = [];
+      }
+      this.annotations = this.annotations.concat(data);
+      return this.annotator.loadAnnotations(data.slice());
+    };
+
+    Store.prototype.loadAnnotationsFromSearch = function(searchOptions) {
+      return this._apiRequest('search', searchOptions, this._onLoadAnnotationsFromSearch);
+    };
+
+    Store.prototype._onLoadAnnotationsFromSearch = function(data) {
+      if (data == null) {
+        data = {};
+      }
+      return this._onLoadAnnotations(data.rows || []);
+    };
+
+    Store.prototype.dumpAnnotations = function() {
+      var ann, _i, _len, _ref, _results;
+
+      _ref = this.annotations;
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        ann = _ref[_i];
+        _results.push(JSON.parse(this._dataFor(ann)));
+      }
+      return _results;
+    };
+
+    Store.prototype._apiRequest = function(action, obj, onSuccess) {
+      var id, options, request, url;
+
+      id = obj && obj.id;
+      url = this._urlFor(action, id);
+      options = this._apiRequestOptions(action, obj, onSuccess);
+      request = $.ajax(url, options);
+      request._id = id;
+      request._action = action;
+      return request;
+    };
+
+    Store.prototype._apiRequestOptions = function(action, obj, onSuccess) {
+      var data, method, opts;
+
+      method = this._methodFor(action);
+      opts = {
+        type: method,
+        headers: this.element.data('annotator:headers'),
+        dataType: "json",
+        success: onSuccess || function() {},
+        error: this._onError
+      };
+      if (this.options.emulateHTTP && (method === 'PUT' || method === 'DELETE')) {
+        opts.headers = $.extend(opts.headers, {
+          'X-HTTP-Method-Override': method
+        });
+        opts.type = 'POST';
+      }
+      if (action === "search") {
+        opts = $.extend(opts, {
+          data: obj
+        });
+        return opts;
+      }
+      data = obj && this._dataFor(obj);
+      if (this.options.emulateJSON) {
+        opts.data = {
+          json: data
+        };
+        if (this.options.emulateHTTP) {
+          opts.data._method = method;
+        }
+        return opts;
+      }
+      opts = $.extend(opts, {
+        data: data,
+        contentType: "application/json; charset=utf-8"
+      });
+      return opts;
+    };
+
+    Store.prototype._urlFor = function(action, id) {
+      var url;
+
+      url = this.options.prefix != null ? this.options.prefix : '';
+      url += this.options.urls[action];
+      url = url.replace(/\/:id/, id != null ? '/' + id : '');
+      url = url.replace(/:id/, id != null ? id : '');
+      return url;
+    };
+
+    Store.prototype._methodFor = function(action) {
+      var table;
+
+      table = {
+        'create': 'POST',
+        'read': 'GET',
+        'update': 'PUT',
+        'destroy': 'DELETE',
+        'search': 'GET'
+      };
+      return table[action];
+    };
+
+    Store.prototype._dataFor = function(annotation) {
+      var data, highlights;
+
+      highlights = annotation.highlights;
+      delete annotation.highlights;
+      $.extend(annotation, this.options.annotationData);
+      data = JSON.stringify(annotation);
+      if (highlights) {
+        annotation.highlights = highlights;
+      }
+      return data;
+    };
+
+    Store.prototype._onError = function(xhr) {
+      var action, message;
+
+      action = xhr._action;
+      message = Annotator._t("Sorry we could not ") + action + Annotator._t(" this annotation");
+      if (xhr._action === 'search') {
+        message = Annotator._t("Sorry we could not search the store for annotations");
+      } else if (xhr._action === 'read' && !xhr._id) {
+        message = Annotator._t("Sorry we could not ") + action + Annotator._t(" the annotations from the store");
+      }
+      switch (xhr.status) {
+        case 401:
+          message = Annotator._t("Sorry you are not allowed to ") + action + Annotator._t(" this annotation");
+          break;
+        case 404:
+          message = Annotator._t("Sorry we could not connect to the annotations store");
+          break;
+        case 500:
+          message = Annotator._t("Sorry something went wrong with the annotation store");
+      }
+      Annotator.showNotification(message, Annotator.Notification.ERROR);
+      return console.error(Annotator._t("API request failed:") + (" '" + xhr.status + "'"));
+    };
+
+    return Store;
+
+  })(Annotator.Plugin);
+
+}).call(this);

common/static/js/vendor/annotator.store.min.js

+(function(){var __bind=function(fn,me){return function(){return fn.apply(me,arguments)}},__hasProp={}.hasOwnProperty,__extends=function(child,parent){for(var key in parent){if(__hasProp.call(parent,key))child[key]=parent[key]}function ctor(){this.constructor=child}ctor.prototype=parent.prototype;child.prototype=new ctor;child.__super__=parent.prototype;return child},__indexOf=[].indexOf||function(item){for(var i=0,l=this.length;i<l;i++){if(i in this&&this[i]===item)return i}return-1};Annotator.Plugin.Store=function(_super){__extends(Store,_super);Store.prototype.events={annotationCreated:"annotationCreated",annotationDeleted:"annotationDeleted",annotationUpdated:"annotationUpdated"};Store.prototype.options={annotationData:{},emulateHTTP:false,loadFromSearch:false,prefix:"/store",urls:{create:"/annotations",read:"/annotations/:id",update:"/annotations/:id",destroy:"/annotations/:id",search:"/search"}};function Store(element,options){this._onError=__bind(this._onError,this);this._onLoadAnnotationsFromSearch=__bind(this._onLoadAnnotationsFromSearch,this);this._onLoadAnnotations=__bind(this._onLoadAnnotations,this);this._getAnnotations=__bind(this._getAnnotations,this);Store.__super__.constructor.apply(this,arguments);this.annotations=[]}Store.prototype.pluginInit=function(){if(!Annotator.supported()){return}if(this.annotator.plugins.Auth){return this.annotator.plugins.Auth.withToken(this._getAnnotations)}else{return this._getAnnotations()}};Store.prototype._getAnnotations=function(){if(this.options.loadFromSearch){return this.loadAnnotationsFromSearch(this.options.loadFromSearch)}else{return this.loadAnnotations()}};Store.prototype.annotationCreated=function(annotation){var _this=this;if(__indexOf.call(this.annotations,annotation)<0){this.registerAnnotation(annotation);return this._apiRequest("create",annotation,function(data){if(data.id==null){console.warn(Annotator._t("Warning: No ID returned from server for annotation "),annotation)}return _this.updateAnnotation(annotation,data)})}else{return this.updateAnnotation(annotation,{})}};Store.prototype.annotationUpdated=function(annotation){var _this=this;if(__indexOf.call(this.annotations,annotation)>=0){return this._apiRequest("update",annotation,function(data){return _this.updateAnnotation(annotation,data)})}};Store.prototype.annotationDeleted=function(annotation){var _this=this;if(__indexOf.call(this.annotations,annotation)>=0){return this._apiRequest("destroy",annotation,function(){return _this.unregisterAnnotation(annotation)})}};Store.prototype.registerAnnotation=function(annotation){return this.annotations.push(annotation)};Store.prototype.unregisterAnnotation=function(annotation){return this.annotations.splice(this.annotations.indexOf(annotation),1)};Store.prototype.updateAnnotation=function(annotation,data){if(__indexOf.call(this.annotations,annotation)<0){console.error(Annotator._t("Trying to update unregistered annotation!"))}else{$.extend(annotation,data)}return $(annotation.highlights).data("annotation",annotation)};Store.prototype.loadAnnotations=function(){return this._apiRequest("read",null,this._onLoadAnnotations)};Store.prototype._onLoadAnnotations=function(data){if(data==null){data=[]}this.annotations=this.annotations.concat(data);return this.annotator.loadAnnotations(data.slice())};Store.prototype.loadAnnotationsFromSearch=function(searchOptions){return this._apiRequest("search",searchOptions,this._onLoadAnnotationsFromSearch)};Store.prototype._onLoadAnnotationsFromSearch=function(data){if(data==null){data={}}return this._onLoadAnnotations(data.rows||[])};Store.prototype.dumpAnnotations=function(){var ann,_i,_len,_ref,_results;_ref=this.annotations;_results=[];for(_i=0,_len=_ref.length;_i<_len;_i++){ann=_ref[_i];_results.push(JSON.parse(this._dataFor(ann)))}return _results};Store.prototype._apiRequest=function(action,obj,onSuccess){var id,options,request,url;id=obj&&obj.id;url=this._urlFor(action,id);options=this._apiRequestOptions(action,obj,onSuccess);request=$.ajax(url,options);request._id=id;request._action=action;return request};Store.prototype._apiRequestOptions=function(action,obj,onSuccess){var data,method,opts;method=this._methodFor(action);opts={type:method,headers:this.element.data("annotator:headers"),dataType:"json",success:onSuccess||function(){},error:this._onError};if(this.options.emulateHTTP&&(method==="PUT"||method==="DELETE")){opts.headers=$.extend(opts.headers,{"X-HTTP-Method-Override":method});opts.type="POST"}if(action==="search"){opts=$.extend(opts,{data:obj});return opts}data=obj&&this._dataFor(obj);if(this.options.emulateJSON){opts.data={json:data};if(this.options.emulateHTTP){opts.data._method=method}return opts}opts=$.extend(opts,{data:data,contentType:"application/json; charset=utf-8"});return opts};Store.prototype._urlFor=function(action,id){var url;url=this.options.prefix!=null?this.options.prefix:"";url+=this.options.urls[action];url=url.replace(/\/:id/,id!=null?"/"+id:"");url=url.replace(/:id/,id!=null?id:"");return url};Store.prototype._methodFor=function(action){var table;table={create:"POST",read:"GET",update:"PUT",destroy:"DELETE",search:"GET"};return table[action]};Store.prototype._dataFor=function(annotation){var data,highlights;highlights=annotation.highlights;delete annotation.highlights;$.extend(annotation,this.options.annotationData);data=JSON.stringify(annotation);if(highlights){annotation.highlights=highlights}return data};Store.prototype._onError=function(xhr){var action,message;action=xhr._action;message=Annotator._t("Sorry we could not ")+action+Annotator._t(" this annotation");if(xhr._action==="search"){message=Annotator._t("Sorry we could not search the store for annotations")}else if(xhr._action==="read"&&!xhr._id){message=Annotator._t("Sorry we could not ")+action+Annotator._t(" the annotations from the store")}switch(xhr.status){case 401:message=Annotator._t("Sorry you are not allowed to ")+action+Annotator._t(" this annotation");break;case 404:message=Annotator._t("Sorry we could not connect to the annotations store");break;case 500:message=Annotator._t("Sorry something went wrong with the annotation store")}Annotator.showNotification(message,Annotator.Notification.ERROR);return console.error(Annotator._t("API request failed:")+(" '"+xhr.status+"'"))};return Store}(Annotator.Plugin)}).call(this);
\ No newline at end of file

common/static/js/vendor/annotator.tags.js

+/*
+** Annotator 1.2.6-dev-dc18206
+** https://github.com/okfn/annotator/
+**
+** Copyright 2012 Aron Carroll, Rufus Pollock, and Nick Stenning.
+** Dual licensed under the MIT and GPLv3 licenses.
+** https://github.com/okfn/annotator/blob/master/LICENSE
+**
+** Built at: 2013-05-16 18:02:02Z
+*/
+
+
+(function() {
+  var _ref,
+    __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
+    __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  Annotator.Plugin.Tags = (function(_super) {
+    __extends(Tags, _super);
+
+    function Tags() {
+      this.setAnnotationTags = __bind(this.setAnnotationTags, this);
+      this.updateField = __bind(this.updateField, this);      _ref = Tags.__super__.constructor.apply(this, arguments);
+      return _ref;
+    }
+
+    Tags.prototype.options = {
+      parseTags: function(string) {
+        var tags;
+
+        string = $.trim(string);
+        tags = [];
+        if (string) {
+          tags = string.split(/\s+/);
+        }
+        return tags;
+      },
+      stringifyTags: function(array) {
+        return array.join(" ");
+      }
+    };
+
+    Tags.prototype.field = null;
+
+    Tags.prototype.input = null;
+
+    Tags.prototype.pluginInit = function() {
+      if (!Annotator.supported()) {
+        return;
+      }
+      this.field = this.annotator.editor.addField({
+        label: Annotator._t('Add some tags here') + '\u2026',
+        load: this.updateField,
+        submit: this.setAnnotationTags
+      });
+      this.annotator.viewer.addField({
+        load: this.updateViewer
+      });
+      if (this.annotator.plugins.Filter) {
+        this.annotator.plugins.Filter.addFilter({
+          label: Annotator._t('Tag'),
+          property: 'tags',
+          isFiltered: Annotator.Plugin.Tags.filterCallback
+        });
+      }
+      return this.input = $(this.field).find(':input');
+    };
+
+    Tags.prototype.parseTags = function(string) {
+      return this.options.parseTags(string);
+    };
+
+    Tags.prototype.stringifyTags = function(array) {
+      return this.options.stringifyTags(array);
+    };
+
+    Tags.prototype.updateField = function(field, annotation) {
+      var value;
+
+      value = '';
+      if (annotation.tags) {
+        value = this.stringifyTags(annotation.tags);
+      }
+      return this.input.val(value);
+    };
+
+    Tags.prototype.setAnnotationTags = function(field, annotation) {
+      return annotation.tags = this.parseTags(this.input.val());
+    };
+
+    Tags.prototype.updateViewer = function(field, annotation) {
+      field = $(field);
+      if (annotation.tags && $.isArray(annotation.tags) && annotation.tags.length) {
+        return field.addClass('annotator-tags').html(function() {
+          var string;
+
+          return string = $.map(annotation.tags, function(tag) {
+            return '<span class="annotator-tag">' + Annotator.$.escape(tag) + '</span>';
+          }).join(' ');
+        });
+      } else {
+        return field.remove();
+      }
+    };
+
+    return Tags;
+
+  })(Annotator.Plugin);
+
+  Annotator.Plugin.Tags.filterCallback = function(input, tags) {
+    var keyword, keywords, matches, tag, _i, _j, _len, _len1;
+
+    if (tags == null) {
+      tags = [];
+    }
+    matches = 0;
+    keywords = [];
+    if (input) {
+      keywords = input.split(/\s+/g);
+      for (_i = 0, _len = keywords.length; _i < _len; _i++) {
+        keyword = keywords[_i];
+        if (tags.length) {
+          for (_j = 0, _len1 = tags.length; _j < _len1; _j++) {
+            tag = tags[_j];
+            if (tag.indexOf(keyword) !== -1) {
+              matches += 1;
+            }
+          }
+        }
+      }
+    }
+    return matches === keywords.length;
+  };
+
+}).call(this);

common/static/js/vendor/annotator.tags.min.js

+(function(){var _ref,__bind=function(fn,me){return function(){return fn.apply(me,arguments)}},__hasProp={}.hasOwnProperty,__extends=function(child,parent){for(var key in parent){if(__hasProp.call(parent,key))child[key]=parent[key]}function ctor(){this.constructor=child}ctor.prototype=parent.prototype;child.prototype=new ctor;child.__super__=parent.prototype;return child};Annotator.Plugin.Tags=function(_super){__extends(Tags,_super);function Tags(){this.setAnnotationTags=__bind(this.setAnnotationTags,this);this.updateField=__bind(this.updateField,this);_ref=Tags.__super__.constructor.apply(this,arguments);return _ref}Tags.prototype.options={parseTags:function(string){var tags;string=$.trim(string);tags=[];if(string){tags=string.split(/\s+/)}return tags},stringifyTags:function(array){return array.join(" ")}};Tags.prototype.field=null;Tags.prototype.input=null;Tags.prototype.pluginInit=function(){if(!Annotator.supported()){return}this.field=this.annotator.editor.addField({label:Annotator._t("Add some tags here")+"…",load:this.updateField,submit:this.setAnnotationTags});this.annotator.viewer.addField({load:this.updateViewer});if(this.annotator.plugins.Filter){this.annotator.plugins.Filter.addFilter({label:Annotator._t("Tag"),property:"tags",isFiltered:Annotator.Plugin.Tags.filterCallback})}return this.input=$(this.field).find(":input")};Tags.prototype.parseTags=function(string){return this.options.parseTags(string)};Tags.prototype.stringifyTags=function(array){return this.options.stringifyTags(array)};Tags.prototype.updateField=function(field,annotation){var value;value="";if(annotation.tags){value=this.stringifyTags(annotation.tags)}return this.input.val(value)};Tags.prototype.setAnnotationTags=function(field,annotation){return annotation.tags=this.parseTags(this.input.val())};Tags.prototype.updateViewer=function(field,annotation){field=$(field);if(annotation.tags&&$.isArray(annotation.tags)&&annotation.tags.length){return field.addClass("annotator-tags").html(function(){var string;return string=$.map(annotation.tags,function(tag){return'<span class="annotator-tag">'+Annotator.$.escape(tag)+"</span>"}).join(" ")})}else{return field.remove()}};return Tags}(Annotator.Plugin);Annotator.Plugin.Tags.filterCallback=function(input,tags){var keyword,keywords,matches,tag,_i,_j,_len,_len1;if(tags==null){tags=[]}matches=0;keywords=[];if(input){keywords=input.split(/\s+/g);for(_i=0,_len=keywords.length;_i<_len;_i++){keyword=keywords[_i];if(tags.length){for(_j=0,_len1=tags.length;_j<_len1;_j++){tag=tags[_j];if(tag.indexOf(keyword)!==-1){matches+=1}}}}}return matches===keywords.length}}).call(this);
\ No newline at end of file

lms/djangoapps/courseware/tabs.py

@@ -185,6 +185,11 @@ def _combined_open_ended_grading(tab, user, course, active_page):
         return tab
     return []
 
+def _notes_tab(tab, user, course, active_page):
+    if user.is_authenticated() and settings.MITX_FEATURES.get('ENABLE_STUDENT_NOTES'):
+        link = reverse('notes', args=[course.id])
+        return [CourseTab(tab['name'], link, active_page == 'notes')]
+    return []
 
 #### Validators
 
@@ -227,6 +232,7 @@ VALID_TAB_TYPES = {
     'peer_grading': TabImpl(null_validator, _peer_grading),
     'staff_grading': TabImpl(null_validator, _staff_grading),
     'open_ended': TabImpl(null_validator, _combined_open_ended_grading),
+    'notes': TabImpl(null_validator, _notes_tab)
     }
 
 

lms/djangoapps/notes/README.md

+Notes Django App
+================
+
+This is a django application that stores and displays notes that students make while reading static HTML book(s) in their courseware.  Note taking functionality in the static HTML book(s) is handled by a wrapper script around [annotator.js](http://okfnlabs.org/annotator/), which interfaces with the API provided by this application to store and retrieve notes.
+
+Usage
+-----
+
+To use this application, course staff must opt-in by doing the following:
+
+* Login to [Studio](http://studio.edx.org/).
+* Go to *Course Settings* -> *Advanced Settings*
+* Find the ```advanced_modules``` policy key and in the policy value field, add ```"notes"``` to the list. 
+* Save the course settings.
+
+The result of following these steps is that you should see a new tab appear in the courseware named *My Notes*. This will display a journal of notes that the student has created in the static HTML book(s). Second, when you highlight text in the static HTML book(s), a dialog will appear. You can enter some notes and tags and save it. The note will appear highlighted in the text and will also be saved to the journal. 
+
+To disable the *My Notes* tab and notes in the static HTML book(s), simply reverse the above steps (i.e. remove ```"notes"``` from the ```advanced_modules``` policy setting).
+
+### Caveats and Limitations
+
+* Notes are private to each student. 
+* Sharing and replying to notes is not supported.
+* The student *My Notes* interface is very limited. 
+* There is no instructor interface to view student notes.
+
+Developer Overview
+------------------
+
+### Quickstart
+
+```
+$ rake django-admin[syncdb]
+$ rake django-admin[migrate]
+```
+
+Then follow the steps above to enable the *My Notes* tab or manually add a tab to the policy tab configuration with ```{"type": "notes", "name": "My Notes"}```.
+
+### App Directory Structure:
+
+lms/djangoapps/notes:
+
+* api.py - API used by annotator.js on the frontend
+* models.py - Contains note model for storing notes
+* tests.py - Unit tests
+* views.py - View to display the journal of notes (i.e. *My Notes* tab)
+* urls.py - Maps the API and View routes.
+* utils.py - Contains method for checking if the course has this app enabled. Intended to be public to other modules.
+
+Also requires:
+
+*  lms/static/coffee/src/notes.coffee -- wrapper around annotator.js
+*  lms/templates/notes.html -- used by views.py to display the notes
+
+Interacts with:
+
+* lms/djangoapps/staticbook - the html static book checks to see if notes is enabled and has some logic to enable/disable accordingly

lms/djangoapps/notes/api.py

+from django.contrib.auth.decorators import login_required
+from django.http import HttpResponse, Http404
+from django.core.exceptions import ValidationError
+
+from notes.models import Note
+from notes.utils import notes_enabled_for_course
+from courseware.courses import get_course_with_access
+
+import json
+import logging
+import collections
+
+log = logging.getLogger(__name__)
+
+API_SETTINGS = {
+    'META': {'name': 'Notes API', 'version': 1},
+
+    # Maps resources to HTTP methods and actions
+    'RESOURCE_MAP': {
+        'root': {'GET': 'root'},
+        'notes': {'GET': 'index', 'POST': 'create'},
+        'note': {'GET': 'read', 'PUT': 'update', 'DELETE': 'delete'},
+        'search': {'GET': 'search'},
+    },
+
+    # Cap the number of notes that can be returned in one request
+    'MAX_NOTE_LIMIT': 1000,
+}
+
+# Wrapper class for HTTP response and data. All API actions are expected to return this.
+ApiResponse = collections.namedtuple('ApiResponse', ['http_response', 'data'])
+
+#----------------------------------------------------------------------#
+# API requests are routed through api_request() using the resource map.
+
+
+def api_enabled(request, course_id):
+    '''
+    Returns True if the api is enabled for the course, otherwise False.
+    '''
+    course = _get_course(request, course_id)
+    return notes_enabled_for_course(course)
+
+
+@login_required
+def api_request(request, course_id, **kwargs):
+    '''
+    Routes API requests to the appropriate action method and returns JSON.
+    Raises a 404 if the requested resource does not exist or notes are
+        disabled for the course.
+    '''
+
+    # Verify that the api should be accessible to this course
+    if not api_enabled(request, course_id):
+        log.debug('Notes are disabled for course: {0}'.format(course_id))
+        raise Http404
+
+    # Locate the requested resource
+    resource_map = API_SETTINGS.get('RESOURCE_MAP', {})
+    resource_name = kwargs.pop('resource')
+    resource_method = request.method
+    resource = resource_map.get(resource_name)
+
+    if resource is None:
+        log.debug('Resource "{0}" does not exist'.format(resource_name))
+        raise Http404
+
+    if resource_method not in resource.keys():
+        log.debug('Resource "{0}" does not support method "{1}"'.format(resource_name, resource_method))
+        raise Http404
+
+    # Execute the action associated with the resource
+    func = resource.get(resource_method)
+    module = globals()
+    if func not in module:
+        log.debug('Function "{0}" does not exist for request {1} {2}'.format(func, resource_method, resource_name))
+        raise Http404
+
+    log.debug('API request: {0} {1}'.format(resource_method, resource_name))
+
+    api_response = module[func](request, course_id, **kwargs)
+    http_response = api_format(api_response)
+
+    return http_response
+
+
+def api_format(api_response):
+    '''
+    Takes an ApiResponse and returns an HttpResponse.
+    '''
+    http_response = api_response.http_response
+    content_type = 'application/json'
+    content = ''
+
+    # not doing a strict boolean check on data becuase it could be an empty list
+    if api_response.data is not None and api_response.data != '':
+        content = json.dumps(api_response.data)
+
+    http_response['Content-type'] = content_type
+    http_response.content = content
+
+    log.debug('API response type: {0} content: {1}'.format(content_type, content))
+
+    return http_response
+
+
+def _get_course(request, course_id):
+    '''
+    Helper function to load and return a user's course.
+    '''
+    return get_course_with_access(request.user, course_id, 'load')
+
+#----------------------------------------------------------------------#
+# API actions exposed via the resource map.
+
+
+def index(request, course_id):
+    '''
+    Returns a list of annotation objects.
+    '''
+    MAX_LIMIT = API_SETTINGS.get('MAX_NOTE_LIMIT')
+
+    notes = Note.objects.order_by('id').filter(course_id=course_id,
+                                               user=request.user)[:MAX_LIMIT]
+
+    return ApiResponse(http_response=HttpResponse(), data=[note.as_dict() for note in notes])
+
+
+def create(request, course_id):
+    '''
+    Receives an annotation object to create and returns a 303 with the read location.
+    '''
+    note = Note(course_id=course_id, user=request.user)
+
+    try:
+        note.clean(request.body)
+    except ValidationError as e:
+        log.debug(e)
+        return ApiResponse(http_response=HttpResponse('', status=400), data=None)
+
+    note.save()
+    response = HttpResponse('', status=303)
+    response['Location'] = note.get_absolute_url()
+
+    return ApiResponse(http_response=response, data=None)
+
+
+def read(request, course_id, note_id):
+    '''
+    Returns a single annotation object.
+    '''
+    try:
+        note = Note.objects.get(id=note_id)
+    except Note.DoesNotExist:
+        return ApiResponse(http_response=HttpResponse('', status=404), data=None)
+
+    if note.user.id != request.user.id:
+        return ApiResponse(http_response=HttpResponse('', status=403), data=None)
+
+    return ApiResponse(http_response=HttpResponse(), data=note.as_dict())
+
+
+def update(request, course_id, note_id):
+    '''
+    Updates an annotation object and returns a 303 with the read location.
+    '''
+    try:
+        note = Note.objects.get(id=note_id)
+    except Note.DoesNotExist:
+        return ApiResponse(http_response=HttpResponse('', status=404), data=None)
+
+    if note.user.id != request.user.id:
+        return ApiResponse(http_response=HttpResponse('', status=403), data=None)
+
+    try:
+        note.clean(request.body)
+    except ValidationError as e:
+        log.debug(e)
+        return ApiResponse(http_response=HttpResponse('', status=400), data=None)
+
+    note.save()
+
+    response = HttpResponse('', status=303)
+    response['Location'] = note.get_absolute_url()
+
+    return ApiResponse(http_response=response, data=None)
+
+
+def delete(request, course_id, note_id):
+    '''
+    Deletes the annotation object and returns a 204 with no content.
+    '''
+    try:
+        note = Note.objects.get(id=note_id)
+    except Note.DoesNotExist:
+        return ApiResponse(http_response=HttpResponse('', status=404), data=None)
+
+    if note.user.id != request.user.id:
+        return ApiResponse(http_response=HttpResponse('', status=403), data=None)
+
+    note.delete()
+
+    return ApiResponse(http_response=HttpResponse('', status=204), data=None)
+
+
+def search(request, course_id):
+    '''
+    Returns a subset of  annotation objects based on a search query.
+    '''
+    MAX_LIMIT = API_SETTINGS.get('MAX_NOTE_LIMIT')
+
+    # search parameters
+    offset = request.GET.get('offset', '')
+    limit = request.GET.get('limit', '')
+    uri = request.GET.get('uri', '')
+
+    # validate search parameters
+    if offset.isdigit():
+        offset = int(offset)
+    else:
+        offset = 0
+
+    if limit.isdigit():
+        limit = int(limit)
+        if limit == 0 or limit > MAX_LIMIT:
+            limit = MAX_LIMIT
+    else:
+        limit = MAX_LIMIT
+
+    # set filters
+    filters = {'course_id': course_id, 'user': request.user}
+    if uri != '':
+        filters['uri'] = uri
+
+    # retrieve notes
+    notes = Note.objects.order_by('id').filter(**filters)
+    total = notes.count()
+    rows = notes[offset:offset + limit]
+    result = {
+        'total': total,
+        'rows': [note.as_dict() for note in rows]
+    }
+
+    return ApiResponse(http_response=HttpResponse(), data=result)
+
+
+def root(request, course_id):
+    '''
+    Returns version information about the API.
+    '''
+    return ApiResponse(http_response=HttpResponse(), data=API_SETTINGS.get('META'))

lms/djangoapps/notes/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 'Note'
+        db.create_table('notes_note', (
+            ('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)),
+            ('uri', self.gf('django.db.models.fields.CharField')(max_length=1024, db_index=True)),
+            ('text', self.gf('django.db.models.fields.TextField')(default='')),
+            ('quote', self.gf('django.db.models.fields.TextField')(default='')),
+            ('range_start', self.gf('django.db.models.fields.CharField')(max_length=2048)),
+            ('range_start_offset', self.gf('django.db.models.fields.IntegerField')()),
+            ('range_end', self.gf('django.db.models.fields.CharField')(max_length=2048)),
+            ('range_end_offset', self.gf('django.db.models.fields.IntegerField')()),
+            ('tags', self.gf('django.db.models.fields.TextField')(default='')),
+            ('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)),
+        ))
+        db.send_create_signal('notes', ['Note'])
+
+
+    def backwards(self, orm):
+        # Deleting model 'Note'
+        db.delete_table('notes_note')
+
+
+    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'})
+        },
+        'notes.note': {
+            'Meta': {'object_name': 'Note'},
+            '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'}),
+            'quote': ('django.db.models.fields.TextField', [], {'default': "''"}),
+            'range_end': ('django.db.models.fields.CharField', [], {'max_length': '2048'}),
+            'range_end_offset': ('django.db.models.fields.IntegerField', [], {}),
+            'range_start': ('django.db.models.fields.CharField', [], {'max_length': '2048'}),
+            'range_start_offset': ('django.db.models.fields.IntegerField', [], {}),
+            'tags': ('django.db.models.fields.TextField', [], {'default': "''"}),
+            'text': ('django.db.models.fields.TextField', [], {'default': "''"}),
+            'updated': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'db_index': 'True', 'blank': 'True'}),
+            'uri': ('django.db.models.fields.CharField', [], {'max_length': '1024', 'db_index': 'True'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']"})
+        }
+    }
+
+    complete_apps = ['notes']
\ No newline at end of file

lms/djangoapps/notes/models.py

+from django.db import models
+from django.contrib.auth.models import User
+from django.core.urlresolvers import reverse
+from django.core.exceptions import ValidationError
+from django.utils.html import strip_tags
+import json
+
+
+class Note(models.Model):
+    user = models.ForeignKey(User, db_index=True)
+    course_id = models.CharField(max_length=255, db_index=True)
+    uri = models.CharField(max_length=1024, db_index=True)
+    text = models.TextField(default="")
+    quote = models.TextField(default="")
+    range_start = models.CharField(max_length=2048)  # xpath string
+    range_start_offset = models.IntegerField()
+    range_end = models.CharField(max_length=2048)  # xpath string
+    range_end_offset = models.IntegerField()
+    tags = models.TextField(default="")  # comma-separated string
+    created = models.DateTimeField(auto_now_add=True, null=True, db_index=True)
+    updated = models.DateTimeField(auto_now=True, db_index=True)
+
+    def clean(self, json_body):
+        '''
+        Cleans the note object or raises a ValidationError.
+        '''
+        if json_body is None:
+            raise ValidationError('Note must have a body.')
+
+        body = json.loads(json_body)
+        if not type(body) is dict:
+            raise ValidationError('Note body must be a dictionary.')
+
+        # NOTE: all three of these fields should be considered user input
+        # and may be output back to the user, so we need to sanitize them.
+        # These fields should only contain _plain text_.
+        self.uri = strip_tags(body.get('uri', ''))
+        self.text = strip_tags(body.get('text', ''))
+        self.quote = strip_tags(body.get('quote', ''))
+
+        ranges = body.get('ranges')
+        if ranges is None or len(ranges) != 1:
+            raise ValidationError('Note must contain exactly one range.')
+
+        self.range_start = ranges[0]['start']
+        self.range_start_offset = ranges[0]['startOffset']
+        self.range_end = ranges[0]['end']
+        self.range_end_offset = ranges[0]['endOffset']
+
+        self.tags = ""
+        tags = [strip_tags(tag) for tag in body.get('tags', [])]
+        if len(tags) > 0:
+            self.tags = ",".join(tags)
+
+    def get_absolute_url(self):
+        '''
+        Returns the aboslute url for the note object.
+        '''
+        kwargs = {'course_id': self.course_id, 'note_id': str(self.pk)}
+        return reverse('notes_api_note', kwargs=kwargs)
+
+    def as_dict(self):
+        '''
+        Returns the note object as a dictionary.
+        '''
+        return {
+            'id': self.pk,
+            'user_id': self.user.pk,
+            'uri': self.uri,
+            'text': self.text,
+            'quote': self.quote,
+            'ranges': [{
+                'start': self.range_start,
+                'startOffset': self.range_start_offset,
+                'end': self.range_end,
+                'endOffset': self.range_end_offset
+            }],
+            'tags': self.tags.split(","),
+            'created': str(self.created),
+            'updated': str(self.updated)
+        }

lms/djangoapps/notes/urls.py

+from django.conf.urls import patterns, url
+
+
+id_regex = r"(?P<note_id>[0-9A-Fa-f]+)"
+urlpatterns = patterns('notes.api',
+                       url(r'^api$', 'api_request', {'resource': 'root'}, name='notes_api_root'),
+                       url(r'^api/annotations$', 'api_request', {'resource': 'notes'}, name='notes_api_notes'),
+                       url(r'^api/annotations/' + id_regex + r'$', 'api_request', {'resource': 'note'}, name='notes_api_note'),
+                       url(r'^api/search', 'api_request', {'resource': 'search'}, name='notes_api_search')
+                       )

lms/djangoapps/notes/utils.py

+from django.conf import settings
+
+
+def notes_enabled_for_course(course):
+
+    '''
+    Returns True if the notes app is enabled for the course, False otherwise.
+
+    In order for the app to be enabled it must be:
+        1) enabled globally via MITX_FEATURES.
+        2) present in the course tab configuration.
+    '''
+
+    tab_found = next((True for t in course.tabs if t['type'] == 'notes'), False)
+    feature_enabled = settings.MITX_FEATURES.get('ENABLE_STUDENT_NOTES')
+
+    return feature_enabled and tab_found

lms/djangoapps/notes/views.py

+from django.contrib.auth.decorators import login_required
+from django.http import Http404
+from mitxmako.shortcuts import render_to_response
+from courseware.courses import get_course_with_access
+from notes.models import Note
+from notes.utils import notes_enabled_for_course
+import json
+
+
+@login_required
+def notes(request, course_id):
+    ''' Displays the student's notes. '''
+
+    course = get_course_with_access(request.user, course_id, 'load')
+    if not notes_enabled_for_course(course):
+        raise Http404
+
+    notes = Note.objects.filter(course_id=course_id, user=request.user).order_by('-created', 'uri')
+    context = {
+        'course': course,
+        'notes': notes
+    }
+
+    return render_to_response('notes.html', context)

lms/djangoapps/staticbook/views.py

 from django.contrib.auth.decorators import login_required
 from django.http import Http404
+from django.core.urlresolvers import reverse
 from mitxmako.shortcuts import render_to_response
 
 from courseware.access import has_access
 from courseware.courses import get_course_with_access
+from notes.utils import notes_enabled_for_course
 from static_replace import replace_static_urls
 
 
@@ -23,7 +25,8 @@ def index(request, course_id, book_index, page=None):
 
     return render_to_response('staticbook.html',
                               {'book_index': book_index, 'page': int(page),
-                               'course': course, 'book_url': textbook.book_url,
+                               'course': course,
+                               'book_url': textbook.book_url,
                                'table_of_contents': table_of_contents,
                                'start_page': textbook.start_page,
                                'end_page': textbook.end_page,
@@ -100,6 +103,7 @@ def html_index(request, course_id, book_index, chapter=None):
     """
     course = get_course_with_access(request.user, course_id, 'load')
     staff_access = has_access(request.user, course, 'staff')
+    notes_enabled = notes_enabled_for_course(course)
 
     book_index = int(book_index)
     if book_index < 0 or book_index >= len(course.html_textbooks):
@@ -128,4 +132,5 @@ def html_index(request, course_id, book_index, chapter=None):
                                'course': course,
                                'textbook': textbook,
                                'chapter': chapter,
-                               'staff_access': staff_access})
+                               'staff_access': staff_access,
+                               'notes_enabled': notes_enabled})

lms/envs/common.py

@@ -92,6 +92,9 @@ MITX_FEATURES = {
     # Staff Debug tool.
     'ENABLE_STUDENT_HISTORY_VIEW': True,
 
+    # Enables the student notes API and UI.
+    'ENABLE_STUDENT_NOTES': True,
+
     # Provide a UI to allow users to submit feedback from the LMS
     'ENABLE_FEEDBACK_SUBMISSION': False,
 }
@@ -422,11 +425,15 @@ main_vendor_js = [
   'js/vendor/jquery.qtip.min.js',
   'js/vendor/swfobject/swfobject.js',
   'js/vendor/jquery.ba-bbq.min.js',
+  'js/vendor/annotator.min.js',
+  'js/vendor/annotator.store.min.js',
+  'js/vendor/annotator.tags.min.js'
 ]
 
 discussion_js = sorted(rooted_glob(PROJECT_ROOT / 'static', 'coffee/src/discussion/**/*.js'))
 staff_grading_js = sorted(rooted_glob(PROJECT_ROOT / 'static', 'coffee/src/staff_grading/**/*.js'))
 open_ended_js = sorted(rooted_glob(PROJECT_ROOT / 'static', 'coffee/src/open_ended/**/*.js'))
+notes_js = sorted(rooted_glob(PROJECT_ROOT / 'static', 'coffee/src/notes/**/*.coffee'))
 
 PIPELINE_CSS = {
     'application': {
@@ -439,6 +446,7 @@ PIPELINE_CSS = {
             'css/vendor/jquery.treeview.css',
             'css/vendor/ui-lightness/jquery-ui-1.8.22.custom.css',
             'css/vendor/jquery.qtip.min.css',
+            'css/vendor/annotator.min.css',
             'sass/course.css',
             'xmodule/modules.css',
         ],
@@ -460,7 +468,7 @@ PIPELINE_JS = {
         'source_filenames': sorted(
             set(rooted_glob(COMMON_ROOT / 'static', 'coffee/src/**/*.js') +
                 rooted_glob(PROJECT_ROOT / 'static', 'coffee/src/**/*.js')) -
-            set(courseware_js + discussion_js + staff_grading_js + open_ended_js)
+            set(courseware_js + discussion_js + staff_grading_js + open_ended_js + notes_js)
         ) + [
             'js/form.ext.js',
             'js/my_courses_dropdown.js',
@@ -501,7 +509,12 @@ PIPELINE_JS = {
         'source_filenames': open_ended_js,
         'output_filename': 'js/open_ended.js',
         'test_order': 6,
-    }
+    },
+    'notes': {
+        'source_filenames': notes_js,
+        'output_filename': 'js/notes.js',
+        'test_order': 7
+    },
 }
 
 PIPELINE_DISABLE_WRAPPER = True
@@ -591,5 +604,8 @@ INSTALLED_APPS = (
 
     # Discussion forums
     'django_comment_client',
+
+    # Student notes
+    'notes',
 )
 

lms/static/coffee/src/notes.coffee

+class StudentNotes
+    _debug: false
+
+    targets: [] # holds elements with annotator() instances
+
+    # Adds a listener for "notes" events that may bubble up from descendants.
+    constructor: ($, el) ->
+        console.log 'student notes init', arguments, this if @_debug
+
+        if not $(el).data('notes-instance')
+            events = 'notes:init': @onInitNotes
+            $(el).delegate('*', events)
+            $(el).data('notes-instance', @)
+
+    # Initializes annotations on a container element in response to an init event.
+    onInitNotes: (event, uri=null) =>
+        event.stopPropagation()
+
+        storeConfig = @getStoreConfig uri
+        found = @targets.some (target) -> target is event.target
+
+        if found
+            annotator = $(event.target).data('annotator')
+            if annotator
+                store = annotator.plugins['Store']
+                $.extend(store.options, storeConfig)
+                if uri
+                    store.loadAnnotationsFromSearch(storeConfig['loadFromSearch'])
+                else
+                    console.log 'URI is required to load annotations'
+            else
+                console.log 'No annotator() instance found for target: ', event.target
+        else
+            $(event.target).annotator()
+                .annotator('addPlugin', 'Tags')
+                .annotator('addPlugin', 'Store', storeConfig)
+            @targets.push(event.target)
+
+    # Returns a JSON config object that can be passed to the annotator Store plugin
+    getStoreConfig: (uri) ->
+        prefix = @getPrefix()
+        if uri is null
+            uri = @getURIPath()
+
+        storeConfig =
+            prefix: prefix
+            loadFromSearch:
+                uri: uri
+                limit: 0
+            annotationData:
+                uri: uri
+        storeConfig
+
+    # Returns the API endpoint for the annotation store
+    getPrefix: () ->
+        re = /^(\/courses\/[^/]+\/[^/]+\/[^/]+)/
+        match = re.exec(@getURIPath())
+        prefix = (if match then match[1] else '')
+        return "#{prefix}/notes/api"
+
+    # Returns the URI path of the current page for filtering annotations
+    getURIPath: () ->
+        window.location.href.toString().split(window.location.host)[1]
+
+
+# Enable notes by default on the document root.
+# To initialize annotations on a container element in the document:
+#
+#   $('#myElement').trigger('notes:init');
+#
+# Comment this line to disable notes.
+
+$(document).ready ($) -> new StudentNotes $, @

lms/templates/notes.html

+<%namespace name='static' file='static_content.html'/>
+<%inherit file="main.html" />
+<%!
+    from django.core.urlresolvers import reverse
+%>
+
+<%block name="headextra">
+    <%static:css group='course'/>
+    <%static:js group='courseware'/>
+<style type="text/css">
+    blockquote {
+        background:#f9f9f9;
+        border-left:10px solid #ccc;
+        margin:1.5em 10px;
+        padding:.5em 10px;
+    }
+    blockquote:before {
+        color:#ccc;
+        content:'“';
+        font-size:4em;
+        line-height:.1em;
+        margin-right:.25em;
+        vertical-align:-.4em;
+    }
+    blockquote p {
+        display:inline;
+    }
+    .notes-wrapper {
+        padding: 32px 40px;
+    }
+    .note {
+        border-bottom: 1px solid #ccc;
+        padding: 0 0 1em 0;
+    }
+    .note .text {
+        margin-bottom: 1em;
+    }
+    .note ul.meta {
+        margin: .5em 0;
+    }
+    .note ul.meta li {
+        font-size: .9em;
+        margin-bottom: .5em;
+    }
+</style>
+
+</%block>
+
+<%block name="js_extra">
+  <script type="text/javascript">
+  </script>
+</%block>
+
+<%include file="/courseware/course_navigation.html" args="active_page='notes'" />
+
+<section class="container">
+    <div class="notes-wrapper">
+        <h1>My Notes</h1>
+        % for note in notes:
+        <div class="note">
+            <blockquote>${note.quote|h}</blockquote>
+            <div class="text">${note.text.replace("\n", "<br />") | n,h}</div>
+            <ul class="meta">
+                % if note.tags:
+                    <li class="tags">Tags: ${note.tags|h}</li>
+                % endif
+                <li class="user">Author: ${note.user.username}</li>
+                <li class="time">Created: ${note.created.strftime('%m/%d/%Y %H:%m')}</li>
+                <li class="uri">Source: <a href="${note.uri}">${note.uri|h}</a></li>
+                </ul>
+        </div>
+        % endfor
+        % if notes is UNDEFINED or len(notes) == 0:
+            <p>You do not have any notes.</p>
+        % endif
+    </div>
+</section>
+
+
+
+

lms/templates/static_htmlbook.html

@@ -26,22 +26,41 @@
             // chapters, and it should be in-bounds.
             chapterToLoad = options.chapterNum;
         }
+        var anchorToLoad = null;
+        if (options.chapters) {
+            anchorToLoad = options.anchor_id;
+        }
+
+        var onComplete = function() {};
+        if(options.notesEnabled) {
+            onComplete = function(url) {
+                return function() {
+                    $('#viewerContainer').trigger('notes:init', [url]);
+                }
+            };
+        }
 
-        loadUrl = function htmlViewLoadUrl(url) {
+        loadUrl = function htmlViewLoadUrl(url, anchorId) {
             // clear out previous load, if any:
             parentElement = document.getElementById('bookpage');
             while (parentElement.hasChildNodes())
                 parentElement.removeChild(parentElement.lastChild);
 	    // load new URL in:
-            $('#bookpage').load(url);
+            $('#bookpage').load(url, null, onComplete(url));
+
+	    // if there is an anchor set, then go to that location:
+            if (anchorId != null) {
+		// TODO: add implementation....
+            } 
+
         }; 
 
-        loadChapterUrl = function htmlViewLoadChapterUrl(chapterNum) {
+        loadChapterUrl = function htmlViewLoadChapterUrl(chapterNum, anchorId) {
             if (chapterNum < 1 || chapterNum > chapterUrls.length) {
                 return;
             }
             var chapterUrl = chapterUrls[chapterNum-1];
-            loadUrl(chapterUrl);
+            loadUrl(chapterUrl, anchorId);
         };
 
         // define navigation links for chapters:  
@@ -59,9 +78,9 @@
 
         // finally, load the appropriate url/page
         if (urlToLoad != null) {
-            loadUrl(urlToLoad);
+            loadUrl(urlToLoad, anchorToLoad);
         } else {
-            loadChapterUrl(chapterToLoad);
+            loadChapterUrl(chapterToLoad, anchorToLoad);
         }       
 
     }
@@ -82,6 +101,14 @@
         %if chapter is not None:
             options.chapterNum = ${chapter};
         %endif
+        %if anchor_id is not UNDEFINED and anchor_id is not None:
+            options.anchor_id = ${anchor_id};
+        %endif
+
+        options.notesEnabled = false;
+        %if notes_enabled is not UNDEFINED and notes_enabled:
+            options.notesEnabled = true;
+        %endif
 
         $('#outerContainer').myHTMLViewer(options);
     });

lms/urls.py

@@ -283,6 +283,10 @@ if settings.COURSEWARE_ENABLED:
 
         url(r'^courses/(?P<course_id>[^/]+/[^/]+/[^/]+)/peer_grading$',
             'open_ended_grading.views.peer_grading', name='peer_grading'),
+
+        url(r'^courses/(?P<course_id>[^/]+/[^/]+/[^/]+)/notes$', 'notes.views.notes', name='notes'),
+        url(r'^courses/(?P<course_id>[^/]+/[^/]+/[^/]+)/notes/', include('notes.urls')),
+
     )
 
     # allow course staff to change to student view of courseware