annotation tools

First set of fixes from the pull request

This does not include some of the testing files. The textannotation and
videoannotation test files are not ready. waiting for an answer on the
issue.

Deleted token line in api.py and added test for token generator

Added notes_spec.coffee

remove spec file

fixed minor error with the test

fixes some quality errors

fixed unit test

fixed unit test

added advanced module

Added notes_spec.coffee

remove spec file

Quality and  Testing Coverage

1. in test_textannotation.py I already check for line 75 as it states
in the diff in line 43, same with test_videoanntotation
2. Like you said, exceptions cannot be checked for
firebase_token_generator.py. The version of python that is active on
the edx server is 2.7 or higher, but the code is there for correctness.
Error checking works the same way.
3. I added a test for student/views/.py within tests and deleted the
unused secret assignment.
4. test_token_generator.py is now its own file

Added Secret Token data input

fixed token generator

Annotation Tools in Place

The purpose of this pull request is to install two major modules: (1) a
module to annotate text and (2) a module to annotate video. In either
case an instructor can declare them in advanced settings under
advanced_modules and input content (HTML in text, mp4 or YouTube videos
for video). Students will be able to highlight portions and add their
comments as well as reply to each other. There needs to be a storage
server set up per course as well as a secret token to talk with said
storage.

Changes:
1. Added test to check for the creation of a token in tests.py (along
with the rest of the tests for student/view.py)
2. Removed items in cms pertaining to annotation as this will only be
possible in the lms
3. Added more comments to firebase_token_generator.py, the test files,
students/views.py
4. Added some internationalization stuff to textannotation.html and
videoannotation.html. I need some help with doing it in javascript, but
the html is covered.

incorporated lib for traslate

fixed quality errors

fixed my notes with catch token

Text and Video Annotation Modules - First Iteration

The following code-change is the first iteration of the modules for
text and video annotation.

Installing Modules:
1. Under “Advanced Settings”, add “textannotation” and
“videoannotation” to the list of advanced_modules.
2. Add link to an external storage for annotations under
“annotation_storage_url”
3. Add the secret token for talking with said storage under
“annotation_token_secret”

Using Modules
1. When creating  new unit, you can find Text and Video annotation
modules under “Advanced” component
2. Make sure you have either Text or Video in one unit, but not both.
3. Annotations are only allowed on Live/Public version and not Studio.

Added missing templates and fixed more of the quality errors

Fixed annotator not existing issue in cmd and tried to find the get_html() from the annotation module class to the descriptor

Added a space after # in comments

Fixed issue with an empty Module and token links

Added licenses and fixed vis naming scheme and location.

common/djangoapps/student/firebase_token_generator.py

@@ -0,0 +1,99 @@
+'''
+    Firebase - library to generate a token
+    License: https://github.com/firebase/firebase-token-generator-python/blob/master/LICENSE
+    Tweaked and Edited by @danielcebrianr and @lduarte1991
+
+    This library will take either objects or strings and use python's built-in encoding
+    system as specified by RFC 3548. Thanks to the firebase team for their open-source
+    library. This was made specifically for speaking with the annotation_storage_url and
+    can be used and expanded, but not modified by anyone else needing such a process.
+'''
+from base64 import urlsafe_b64encode
+import hashlib
+import hmac
+import sys
+try:
+    import json
+except ImportError:
+    import simplejson as json
+
+__all__ = ['create_token']
+
+TOKEN_SEP = '.'
+
+
+def create_token(secret, data):
+    '''
+    Simply takes in the secret key and the data and
+    passes it to the local function _encode_token
+    '''
+    return _encode_token(secret, data)
+
+
+if sys.version_info < (2, 7):
+    def _encode(bytes_data):
+        '''
+        Takes a json object, string, or binary and
+        uses python's urlsafe_b64encode to encode data
+        and make it safe pass along in a url.
+        To make sure it does not conflict with variables
+        we make sure equal signs are removed.
+        More info: docs.python.org/2/library/base64.html
+        '''
+        encoded = urlsafe_b64encode(bytes(bytes_data))
+        return encoded.decode('utf-8').replace('=', '')
+else:
+    def _encode(bytes_info):
+        '''
+        Same as above function but for Python 2.7 or later
+        '''
+        encoded = urlsafe_b64encode(bytes_info)
+        return encoded.decode('utf-8').replace('=', '')
+
+
+def _encode_json(obj):
+    '''
+    Before a python dict object can be properly encoded,
+    it must be transformed into a jason object and then
+    transformed into bytes to be encoded using the function
+    defined above.
+    '''
+    return _encode(bytearray(json.dumps(obj), 'utf-8'))
+
+
+def _sign(secret, to_sign):
+    '''
+    This function creates a sign that goes at the end of the
+    message that is specific to the secret and not the actual
+    content of the encoded body.
+    More info on hashing: http://docs.python.org/2/library/hmac.html
+    The function creates a hashed values of the secret and to_sign
+    and returns the digested values based the secure hash
+    algorithm, 256
+    '''
+    def portable_bytes(string):
+        '''
+        Simply transforms a string into a bytes object,
+        which is a series of immutable integers 0<=x<=256.
+        Always try to encode as utf-8, unless it is not
+        compliant.
+        '''
+        try:
+            return bytes(string, 'utf-8')
+        except TypeError:
+            return bytes(string)
+    return _encode(hmac.new(portable_bytes(secret), portable_bytes(to_sign), hashlib.sha256).digest())  # pylint: disable=E1101
+
+
+def _encode_token(secret, claims):
+    '''
+    This is the main function that takes the secret token and
+    the data to be transmitted. There is a header created for decoding
+    purposes. Token_SEP means that a period/full stop separates the
+    header, data object/message, and signatures.
+    '''
+    encoded_header = _encode_json({'typ': 'JWT', 'alg': 'HS256'})
+    encoded_claims = _encode_json(claims)
+    secure_bits = '%s%s%s' % (encoded_header, TOKEN_SEP, encoded_claims)
+    sig = _sign(secret, secure_bits)
+    return '%s%s%s' % (secure_bits, TOKEN_SEP, sig)

common/djangoapps/student/tests/test_token_generator.py

@@ -0,0 +1,43 @@
+"""
+This test will run for firebase_token_generator.py.
+"""
+
+from django.test import TestCase
+
+from student.firebase_token_generator import _encode, _encode_json, _encode_token, create_token
+
+
+class TokenGenerator(TestCase):
+    """
+    Tests for the file firebase_token_generator.py
+    """
+    def test_encode(self):
+        """
+        This tests makes sure that no matter what version of python
+        you have, the _encode function still returns the appropriate result
+        for a string.
+        """
+        expected = "dGVzdDE"
+        result = _encode("test1")
+        self.assertEqual(expected, result)
+
+    def test_encode_json(self):
+        """
+        Same as above, but this one focuses on a python dict type
+        transformed into a json object and then encoded.
+        """
+        expected = "eyJ0d28iOiAidGVzdDIiLCAib25lIjogInRlc3QxIn0"
+        result = _encode_json({'one': 'test1', 'two': 'test2'})
+        self.assertEqual(expected, result)
+
+    def test_create_token(self):
+        """
+        Unlike its counterpart in student/views.py, this function
+        just checks for the encoding of a token. The other function
+        will test depending on time and user.
+        """
+        expected = "eyJhbGciOiAiSFMyNTYiLCAidHlwIjogIkpXVCJ9.eyJ1c2VySWQiOiAidXNlcm5hbWUiLCAidHRsIjogODY0MDB9.-p1sr7uwCapidTQ0qB7DdU2dbF-hViKpPNN_5vD10t8"
+        result1 = _encode_token('4c7f4d1c-8ac4-4e9f-84c8-b271c57fcac4', {"userId": "username", "ttl": 86400})
+        result2 = create_token('4c7f4d1c-8ac4-4e9f-84c8-b271c57fcac4', {"userId": "username", "ttl": 86400})
+        self.assertEqual(expected, result1)
+        self.assertEqual(expected, result2)

common/djangoapps/student/tests/tests.py

@@ -20,6 +20,7 @@ from django.contrib.auth.hashers import UNUSABLE_PASSWORD
 from django.contrib.auth.tokens import default_token_generator
 from django.utils.http import int_to_base36
 from django.core.urlresolvers import reverse
+from django.http import HttpResponse
 
 from xmodule.modulestore.tests.factories import CourseFactory
 from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
@@ -30,7 +31,7 @@ from textwrap import dedent
 
 from student.models import anonymous_id_for_user, user_by_anonymous_id, CourseEnrollment, unique_id_for_user
 from student.views import (process_survey_link, _cert_info, password_reset, password_reset_confirm_wrapper,
-                           change_enrollment, complete_course_mode_info)
+                           change_enrollment, complete_course_mode_info, token, course_from_id)
 from student.tests.factories import UserFactory, CourseModeFactory
 from student.tests.test_email import mock_render_to_string
 
@@ -556,3 +557,26 @@ class AnonymousLookupTable(TestCase):
         anonymous_id = anonymous_id_for_user(self.user, self.course.id)
         real_user = user_by_anonymous_id(anonymous_id)
         self.assertEqual(self.user, real_user)
+
+
+@override_settings(MODULESTORE=TEST_DATA_MIXED_MODULESTORE)
+class Token(ModuleStoreTestCase):
+    """
+    Test for the token generator. This creates a random course and passes it through the token file which generates the
+    token that will be passed in to the annotation_storage_url.
+    """
+    request_factory = RequestFactory()
+    COURSE_SLUG = "100"
+    COURSE_NAME = "test_course"
+    COURSE_ORG = "edx"
+
+    def setUp(self):
+        self.course = CourseFactory.create(org=self.COURSE_ORG, display_name=self.COURSE_NAME, number=self.COURSE_SLUG)
+        self.user = User.objects.create(username="username", email="username")
+        self.req = self.request_factory.post('/token?course_id=edx/100/test_course', {'user': self.user})
+        self.req.user = self.user
+
+    def test_token(self):
+        expected = HttpResponse("eyJhbGciOiAiSFMyNTYiLCAidHlwIjogIkpXVCJ9.eyJpc3N1ZWRBdCI6ICIyMDE0LTAxLTIzVDE5OjM1OjE3LjUyMjEwNC01OjAwIiwgImNvbnN1bWVyS2V5IjogInh4eHh4eHh4LXh4eHgteHh4eC14eHh4LXh4eHh4eHh4eHh4eCIsICJ1c2VySWQiOiAidXNlcm5hbWUiLCAidHRsIjogODY0MDB9.OjWz9mzqJnYuzX-f3uCBllqJUa8PVWJjcDy_McfxLvc", mimetype="text/plain")
+        response = token(self.req)
+        self.assertEqual(expected.content.split('.')[0], response.content.split('.')[0])

common/djangoapps/student/views.py

@@ -1443,3 +1443,28 @@ def change_email_settings(request):
         track.views.server_track(request, "change-email-settings", {"receive_emails": "no", "course": course_id}, page='dashboard')
 
     return HttpResponse(json.dumps({'success': True}))
+
+from student.firebase_token_generator import create_token
+
+
+@login_required
+def token(request):
+    '''
+    Return a token for the backend of annotations.
+    It uses the course id to retrieve a variable that contains the secret
+    token found in inheritance.py. It also contains information of when
+    the token was issued. This will be stored with the user along with
+    the id for identification purposes in the backend.
+    '''
+    course_id = request.GET.get("course_id")
+    course = course_from_id(course_id)
+    dtnow = datetime.datetime.now()
+    dtutcnow = datetime.datetime.utcnow()
+    delta = dtnow - dtutcnow
+    newhour, newmin = divmod((delta.days * 24 * 60 * 60 + delta.seconds + 30) // 60, 60)
+    newtime = "%s%+02d:%02d" % (dtnow.isoformat(), newhour, newmin)
+    secret = course.annotation_token_secret
+    custom_data = {"issuedAt": newtime, "consumerKey": secret, "userId": request.user.email, "ttl": 86400}
+    newtoken = create_token(secret, custom_data)
+    response = HttpResponse(newtoken, mimetype="text/plain")
+    return response