annotation tools

AUTHORS

@@ -107,3 +107,25 @@ Matt Drayer <mattdrayer@edx.org>
 Cristian Salamea <cristian.salamea@iaen.edu.ec>
 Graham Lowe <graham.lowe@gmail.com>
 Matt Bachmann <bachmann.matt@gmail.com>
+Dave St.Germain <dstgermain@edx.org>
+Usman Khalid <symbolist@users.noreply.github.com>
+John Kern <kern3020@gmail.com>
+John Orr <jorr@google.com>
+Mark Hoeber <hoeber@edx.org>
+Waheed Ahmed <waheed.ahmed@arbisoft.com>
+Javier Orts Peñarrocha <jorts@upv.es>
+Stephen Sanchez <steve@edx.org>
+Jim Abramson <jsa@edx.org>
+Chris Rossi <chris@archimedeanco.com>
+Carson Gee <x@carsongee.com>
+Oleg Marshev <oleh.marshev@gmail.com>
+Sylvia Pearce <spearce@edx.org>
+Olga Stroilova <olga@edx.org>
+Paul-Olivier Dehaye <pdehaye@gmail.com>
+Feanil Patel <feanil@edx.org>
+Zubair Afzal <zubair.afzal@arbisoft.com>
+Juho Kim <juhokim@edx.org>
+Alison Hodges <ahodges@edx.org>
+Jane Manning <jmanning@gmail.com>
+Toddi Norum <toddi@edx.org>
+Xavier Antoviaque <xavier@antoviaque.org>

cms/envs/aws.py

@@ -150,6 +150,9 @@
 
 COURSES_WITH_UNSAFE_CODE = ENV_TOKENS.get("COURSES_WITH_UNSAFE_CODE", [])
 
+# Theme overrides
+THEME_NAME = ENV_TOKENS.get('THEME_NAME', None)
+
 #Timezone overrides
 TIME_ZONE = ENV_TOKENS.get('TIME_ZONE', TIME_ZONE)
 

cms/envs/common.py

@@ -281,6 +281,16 @@
             'css/vendor/jquery.qtip.min.css',
             'js/vendor/markitup/skins/simple/style.css',
             'js/vendor/markitup/sets/wiki/style.css',
+            'css/vendor/ova/edx-annotator.css',
+            'css/vendor/ova/annotator.css',
+            'css/vendor/ova/video-js.min.css',
+            'css/vendor/ova/rangeslider.css',
+            'css/vendor/ova/share-annotator.css',
+            'css/vendor/ova/richText-annotator.css',
+            'css/vendor/ova/tags-annotator.css',
+            'css/vendor/ova/flagging-annotator.css',
+            'css/vendor/ova/ova.css',
+            'js/vendor/ova/catch/css/main.css'
         ],
         'output_filename': 'css/cms-style-vendor.css',
     },
@@ -316,6 +326,25 @@
         'output_filename': 'js/cms-modules.js',
         'test_order': 1
     },
+    'main_vendor': {
+        'source_filenames': [
+            'js/vendor/ova/annotator-full.js',
+            'js/vendor/ova/video.dev.js',
+            'js/vendor/ova/vjs.youtube.js',
+            'js/vendor/ova/rangeslider.js',
+            'js/vendor/ova/share-annotator.js',
+            'js/vendor/ova/tinymce.min.js',
+            'js/vendor/ova/richText-annotator.js',
+            'js/vendor/ova/reply-annotator.js',
+            'js/vendor/ova/tags-annotator.js',
+            'js/vendor/ova/flagging-annotator.js',
+            'js/vendor/ova/jquery-Watch.js',
+            'js/vendor/ova/ova.js',
+            'js/vendor/ova/catch/js/catch.js',
+            'js/vendor/ova/catch/js/handlebars-1.1.2.js'
+        ],
+        'output_filename': 'js/cms-main_vendor.js',
+    },
 }
 
 PIPELINE_COMPILERS = (

cms/static/js/spec/transcripts/message_manager_spec.js

@@ -65,7 +65,8 @@ function ($, _, Utils, MessageManager, FileUploader, sinon) {
             });
         });
 
-        describe('Render', function () {
+        // Disabled 2/6/14 after intermittent failure in master
+        xdescribe('Render', function () {
 
             beforeEach(function () {
                 spyOn(_,'template').andCallThrough();

cms/urls.py

@@ -48,6 +48,9 @@
     # ajax view that actually does the work
     url(r'^login_post$', 'student.views.login_user', name='login_post'),
     url(r'^logout$', 'student.views.logout_user', name='logout'),
+
+    #added token
+    url(r'^token/', 'student.views.token', name="token"),
 )
 
 # restful api

common/djangoapps/student/firebase_token_generator.py

@@ -30,25 +30,17 @@ def create_token(secret, data):
     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(bytes_info):
+    '''
+    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_info)
+    return encoded.decode('utf-8').replace('=', '')
 
 
 def _encode_json(obj):

common/djangoapps/student/tests/tests.py

@@ -34,6 +34,7 @@
                            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
+from firebase_token_generator import _encode, _encode_json, _sign, _encode_token, create_token
 
 import shoppingcart
 

common/lib/xmodule/xmodule/tests/test_textannotation.py

@@ -9,66 +9,46 @@
 from xblock.fields import ScopeIds
 
 from xmodule.textannotation_module import TextAnnotationModule
+from xmodule.modulestore import Location
 
 from . import get_test_system
 
-
 class TextAnnotationModuleTestCase(unittest.TestCase):
-    ''' text Annotation Module Test Case '''
     sample_xml = '''
         <annotatable>
             <instructions><p>Test Instructions.</p></instructions>
             <p>
                 One Fish. Two Fish.
                 Red Fish. Blue Fish.
-
+                
                 Oh the places you'll go!
             </p>
         </annotatable>
     '''
-
     def setUp(self):
-        """
-            Makes sure that the Module is declared and mocked with the sample xml above.
-        """
         self.mod = TextAnnotationModule(
             Mock(),
             get_test_system(),
-            DictFieldData({'data': self.sample_xml}),
+            DictFieldData({'data':self.sample_xml}),
             ScopeIds(None, None, None, None)
         )
 
-    def test_render_content(self):
-        """
-        Tests to make sure the sample xml is rendered and that it forms a valid xmltree
-        that does not contain a display_name.
-        """
-        content = self.mod._render_content()  # pylint: disable=W0212
-        self.assertIsNotNone(content)
-        element = etree.fromstring(content)
-        self.assertIsNotNone(element)
-        self.assertFalse('display_name' in element.attrib, "Display Name should have been deleted from Content")
-
     def test_extract_instructions(self):
-        """
-        Tests to make sure that the instructions are correctly pulled from the sample xml above.
-        It also makes sure that if no instructions exist, that it does in fact return nothing.
-        """
         xmltree = etree.fromstring(self.sample_xml)
 
         expected_xml = u"<div><p>Test Instructions.</p></div>"
-        actual_xml = self.mod._extract_instructions(xmltree)  # pylint: disable=W0212
+        actual_xml = self.mod._extract_instructions(xmltree)
         self.assertIsNotNone(actual_xml)
         self.assertEqual(expected_xml.strip(), actual_xml.strip())
 
         xmltree = etree.fromstring('<annotatable>foo</annotatable>')
-        actual = self.mod._extract_instructions(xmltree)  # pylint: disable=W0212
+        actual = self.mod._extract_instructions(xmltree)
         self.assertIsNone(actual)
-
+    
     def test_get_html(self):
         """
         Tests the function that passes in all the information in the context that will be used in templates/textannotation.html
         """
-        context = self.mod.get_html()
+        context = self.mod.get_html()  # pylint: disable=W0212
         for key in ['display_name', 'tag', 'source', 'instructions_html', 'content_html', 'annotation_storage']:
             self.assertIn(key, context)

common/lib/xmodule/xmodule/tests/test_videoannotation.py

@@ -8,158 +8,53 @@
 from xblock.field_data import DictFieldData
 from xblock.fields import ScopeIds
 
-from xmodule.videoannotation_module import VideoAnnotationModule
+from xmodule.textannotation_module import VideoAnnotationModule
+from xmodule.modulestore import Location
 
 from . import get_test_system
 
-
 class VideoAnnotationModuleTestCase(unittest.TestCase):
-    ''' Video Annotation Module Test Case '''
     sample_xml = '''
         <annotatable>
             <instructions><p>Video Test Instructions.</p></instructions>
         </annotatable>
     '''
-    sample_sourceurl = "http://video-js.zencoder.com/oceans-clip.mp4"
-    sample_youtubeurl = "http://www.youtube.com/watch?v=yxLIu-scR9Y"
-
+    sample_sourceURL = "http://video-js.zencoder.com/oceans-clip.mp4"
+    sample_youtubeURL = "http://www.youtube.com/watch?v=yxLIu-scR9Y"
+    
     def setUp(self):
-        """
-        Makes sure that the Video Annotation Module is created.
-        """
         self.mod = VideoAnnotationModule(
             Mock(),
             get_test_system(),
-            DictFieldData({'data': self.sample_xml, 'sourceUrl': self.sample_sourceurl}),
+            DictFieldData({'data':self.sample_xml, 'sourceUrl':sample_sourceURL}),
             ScopeIds(None, None, None, None)
         )
 
-    def test_annotation_class_attr_default(self):
-        """
-        Makes sure that it can detect annotation values in text-form if user
-        decides to add text to the area below video, video functionality is completely
-        found in javascript.
-        """
-        xml = '<annotation title="x" body="y" problem="0">test</annotation>'
-        element = etree.fromstring(xml)
-
-        expected_attr = {'class': {'value': 'annotatable-span highlight'}}
-        actual_attr = self.mod._get_annotation_class_attr(element)  # pylint: disable=W0212
-
-        self.assertIsInstance(actual_attr, dict)
-        self.assertDictEqual(expected_attr, actual_attr)
-
-    def test_annotation_class_attr_with_valid_highlight(self):
-        """
-        Same as above but more specific to an area that is highlightable in the appropriate
-        color designated.
-        """
-        xml = '<annotation title="x" body="y" problem="0" highlight="{highlight}">test</annotation>'
-
-        for color in self.mod.highlight_colors:
-            element = etree.fromstring(xml.format(highlight=color))
-            value = 'annotatable-span highlight highlight-{highlight}'.format(highlight=color)
-
-            expected_attr = {'class': {
-                'value': value,
-                '_delete': 'highlight'}
-            }
-            actual_attr = self.mod._get_annotation_class_attr(element)  # pylint: disable=W0212
-
-            self.assertIsInstance(actual_attr, dict)
-            self.assertDictEqual(expected_attr, actual_attr)
-
-    def test_annotation_class_attr_with_invalid_highlight(self):
-        """
-        Same as above, but checked with invalid colors.
-        """
-        xml = '<annotation title="x" body="y" problem="0" highlight="{highlight}">test</annotation>'
-
-        for invalid_color in ['rainbow', 'blink', 'invisible', '', None]:
-            element = etree.fromstring(xml.format(highlight=invalid_color))
-            expected_attr = {'class': {
-                'value': 'annotatable-span highlight',
-                '_delete': 'highlight'}
-            }
-            actual_attr = self.mod._get_annotation_class_attr(element)  # pylint: disable=W0212
-
-            self.assertIsInstance(actual_attr, dict)
-            self.assertDictEqual(expected_attr, actual_attr)
-
-    def test_annotation_data_attr(self):
-        """
-        Test that each highlight contains the data information from the annotation itself.
-        """
-        element = etree.fromstring('<annotation title="bar" body="foo" problem="0">test</annotation>')
-
-        expected_attr = {
-            'data-comment-body': {'value': 'foo', '_delete': 'body'},
-            'data-comment-title': {'value': 'bar', '_delete': 'title'},
-            'data-problem-id': {'value': '0', '_delete': 'problem'}
-        }
-
-        actual_attr = self.mod._get_annotation_data_attr(element)  # pylint: disable=W0212
-
-        self.assertIsInstance(actual_attr, dict)
-        self.assertDictEqual(expected_attr, actual_attr)
-
-    def test_render_annotation(self):
-        """
-        Tests to make sure that the spans designating annotations acutally visually render as annotations.
-        """
-        expected_html = '<span class="annotatable-span highlight highlight-yellow" data-comment-title="x" data-comment-body="y" data-problem-id="0">z</span>'
-        expected_el = etree.fromstring(expected_html)
-
-        actual_el = etree.fromstring('<annotation title="x" body="y" problem="0" highlight="yellow">z</annotation>')
-        self.mod._render_annotation(actual_el)  # pylint: disable=W0212
-
-        self.assertEqual(expected_el.tag, actual_el.tag)
-        self.assertEqual(expected_el.text, actual_el.text)
-        self.assertDictEqual(dict(expected_el.attrib), dict(actual_el.attrib))
-
-    def test_render_content(self):
-        """
-        Like above, but using the entire text, it makes sure that display_name is removed and that there is only one
-        div encompassing the annotatable area.
-        """
-        content = self.mod._render_content()  # pylint: disable=W0212
-        element = etree.fromstring(content)
-        self.assertIsNotNone(element)
-        self.assertEqual('div', element.tag, 'root tag is a div')
-        self.assertFalse('display_name' in element.attrib, "Display Name should have been deleted from Content")
-
     def test_extract_instructions(self):
-        """
-        This test ensures that if an instruction exists it is pulled and
-        formatted from the <instructions> tags. Otherwise, it should return nothing.
-        """
         xmltree = etree.fromstring(self.sample_xml)
 
         expected_xml = u"<div><p>Video Test Instructions.</p></div>"
         actual_xml = self.mod._extract_instructions(xmltree)  # pylint: disable=W0212
+
         self.assertIsNotNone(actual_xml)
         self.assertEqual(expected_xml.strip(), actual_xml.strip())
 
         xmltree = etree.fromstring('<annotatable>foo</annotatable>')
-        actual = self.mod._extract_instructions(xmltree)  # pylint: disable=W0212
+        actual = self.mod._extract_instructions(xmltree)
         self.assertIsNone(actual)
-
+    
     def test_get_extension(self):
-        """
-        Tests the function that returns the appropriate extension depending on whether it is
-        a video from youtube, or one uploaded to the EdX server.
-        """
-        expectedyoutube = 'video/youtube'
-        expectednotyoutube = 'video/mp4'
-        result1 = self.mod._get_extension(self.sample_sourceurl)  # pylint: disable=W0212
-        result2 = self.mod._get_extension(self.sample_youtubeurl)  # pylint: disable=W0212
-        self.assertEqual(expectedyoutube, result2)
-        self.assertEqual(expectednotyoutube, result1)
-
+        expectedYoutube = 'video/youtube'
+        expectedNotYoutube = 'video/mp4'
+        result1 = self.mod._get_extension(sample_sourceURL)
+        result2 = self.mod._get_extension(sample_youtubeURL)
+        self.assertEqual(expectedYoutube, result2)
+        self.assertEqual(expectedNotYoutube, result1)
+
     def test_get_html(self):
         """
         Tests to make sure variables passed in truly exist within the html once it is all rendered.
         """
-        context = self.mod.get_html()
-        for key in ['display_name', 'content_html', 'instructions_html', 'sourceUrl', 'typeSource', 'poster', 'alert', 'annotation_storage']:
+        context = self.mod.get_html()  # pylint: disable=W0212
+        for key in ['display_name', 'instructions_html', 'sourceUrl', 'typeSource', 'poster', 'annotation_storage']:
             self.assertIn(key, context)