Merge pull request #458 from MITx/feature/bk_forum_int

Berkeley Forum Merge

.gitignore

@@ -25,3 +25,4 @@ Gemfile.lock
 .env/
 lms/static/sass/*.css
 cms/static/sass/*.css
+lms/lib/comment_client/python

common/djangoapps/student/management/commands/sync_user_info.py

+##
+## One-off script to sync all user information to the discussion service (later info will be synced automatically)
+
+
+from django.core.management.base import BaseCommand
+from django.contrib.auth.models import User
+import comment_client as cc
+
+
+class Command(BaseCommand):
+    help = \
+'''
+Sync all user ids, usernames, and emails to the discussion
+service'''
+
+    def handle(self, *args, **options):
+        for user in User.objects.all().iterator():
+            cc_user = cc.User.from_django_user(user)
+            cc_user.save()

common/djangoapps/student/models.py

@@ -45,6 +45,15 @@ from django.db.models.signals import post_delete, post_save
 from django.dispatch import receiver
 from django_countries import CountryField
 
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+
+from functools import partial
+
+import comment_client as cc
+
+import logging
+
 from xmodule.modulestore.django import modulestore
 
 #from cache_toolbox import cache_model, cache_relation
@@ -254,8 +263,18 @@ def add_user_to_default_group(user, group):
     utg.users.add(User.objects.get(username=user))
     utg.save()
 
+# @receiver(post_save, sender=User)
+def update_user_information(sender, instance, created, **kwargs):
+    try:
+        cc_user = cc.User.from_django_user(instance)
+        cc_user.save()
+    except Exception as e:
+        log = logging.getLogger("mitx.discussion")
+        log.error(unicode(e))
+        log.error("update user info to discussion failed for user with id: " + str(instance.id))
+
 ########################## REPLICATION SIGNALS #################################
-@receiver(post_save, sender=User)
+# @receiver(post_save, sender=User)
 def replicate_user_save(sender, **kwargs):
     user_obj = kwargs['instance']
     if not should_replicate(user_obj):
@@ -263,7 +282,7 @@ def replicate_user_save(sender, **kwargs):
     for course_db_name in db_names_to_replicate_to(user_obj.id):
         replicate_user(user_obj, course_db_name)
 
-@receiver(post_save, sender=CourseEnrollment)
+# @receiver(post_save, sender=CourseEnrollment)
 def replicate_enrollment_save(sender, **kwargs):
     """This is called when a Student enrolls in a course. It has to do the 
     following:
@@ -289,12 +308,12 @@ def replicate_enrollment_save(sender, **kwargs):
     user_profile = UserProfile.objects.get(user_id=enrollment_obj.user_id)
     replicate_model(UserProfile.save, user_profile, enrollment_obj.user_id)
  
-@receiver(post_delete, sender=CourseEnrollment)
+# @receiver(post_delete, sender=CourseEnrollment)
 def replicate_enrollment_delete(sender, **kwargs):
     enrollment_obj = kwargs['instance']
     return replicate_model(CourseEnrollment.delete, enrollment_obj, enrollment_obj.user_id)
  
-@receiver(post_save, sender=UserProfile)
+# @receiver(post_save, sender=UserProfile)
 def replicate_userprofile_save(sender, **kwargs):
     """We just updated the UserProfile (say an update to the name), so push that
     change to all Course DBs that we're enrolled in."""
@@ -404,4 +423,3 @@ def should_replicate(instance):
                   .format(instance))
         return False
     return True
-

common/djangoapps/student/tests.py

@@ -8,6 +8,7 @@ import logging
 from datetime import datetime
 
 from django.test import TestCase
+from nose.plugins.skip import SkipTest
 
 from .models import User, UserProfile, CourseEnrollment, replicate_user, USER_FIELDS_TO_COPY
 
@@ -22,6 +23,7 @@ class ReplicationTest(TestCase):
 
     def test_user_replication(self):
         """Test basic user replication."""
+        raise SkipTest()
         portal_user = User.objects.create_user('rusty', 'rusty@edx.org', 'fakepass')
         portal_user.first_name='Rusty'
         portal_user.last_name='Skids'
@@ -80,6 +82,7 @@ class ReplicationTest(TestCase):
     def test_enrollment_for_existing_user_info(self):
         """Test the effect of Enrolling in a class if you've already got user
         data to be copied over."""
+        raise SkipTest()
         # Create our User
         portal_user = User.objects.create_user('jack', 'jack@edx.org', 'fakepass')
         portal_user.first_name = "Jack"
@@ -143,6 +146,8 @@ class ReplicationTest(TestCase):
 
     def test_enrollment_for_user_info_after_enrollment(self):
         """Test the effect of modifying User data after you've enrolled."""
+        raise SkipTest()
+
         # Create our User
         portal_user = User.objects.create_user('patty', 'patty@edx.org', 'fakepass')
         portal_user.first_name = "Patty"

common/lib/xmodule/setup.py

@@ -34,6 +34,7 @@ setup(
             "video = xmodule.video_module:VideoDescriptor",
             "videodev = xmodule.backcompat_module:TranslateCustomTagDescriptor",
             "videosequence = xmodule.seq_module:SequenceDescriptor",
+            "discussion = xmodule.discussion_module:DiscussionDescriptor",
         ]
     }
 )

common/lib/xmodule/xmodule/discussion_module.py

+from lxml import etree
+
+from xmodule.x_module import XModule
+from xmodule.raw_module import RawDescriptor
+
+import json
+
+class DiscussionModule(XModule):
+    def get_html(self):
+        context = {
+            'discussion_id': self.discussion_id,
+        }
+        return self.system.render_template('discussion/_discussion_module.html', context)
+
+    def __init__(self, system, location, definition, descriptor, instance_state=None, shared_state=None, **kwargs):
+        XModule.__init__(self, system, location, definition, descriptor, instance_state, shared_state, **kwargs)
+
+        if isinstance(instance_state, str):
+            instance_state = json.loads(instance_state)
+        xml_data = etree.fromstring(definition['data'])
+        self.discussion_id = xml_data.attrib['id']
+        self.title = xml_data.attrib['for']
+        self.discussion_category = xml_data.attrib['discussion_category']
+
+class DiscussionDescriptor(RawDescriptor):
+    module_class = DiscussionModule

doc/discussion.md

+# Running the discussion service
+
+## Instruction for Mac
+
+## Installing Mongodb
+
+If you haven't done so already:
+
+    brew install mongodb
+
+Make sure that you have mongodb running. You can simply open a new terminal tab and type:
+ 
+    mongod
+
+## Installing elasticsearch
+
+    brew install elasticsearch
+
+For debugging, it's often more convenient to have elasticsearch running in a terminal tab instead of in background. To do so, simply open a new terminal tab and then type:
+
+    elasticsearch -f
+
+## Setting up the discussion service
+
+First, make sure that you have access to the [github repository](https://github.com/rll/cs_comments_service). If this were not the case, send an email to dementrock@gmail.com.
+
+First go into the mitx_all directory. Then type
+
+    git clone git@github.com:rll/cs_comments_service.git
+    cd cs_comments_service/
+
+If you see a prompt asking "Do you wish to trust this .rvmrc file?", type "y"
+
+Now if you see this error "Gemset 'cs_comments_service' does not exist," run the following command to create the gemset and then use the rvm environment manually:
+
+    rvm gemset create 'cs_comments_service'
+    rvm use 1.9.3@cs_comments_service
+
+Now use the following command to install required packages:
+
+    bundle install
+
+The following command creates database indexes:
+
+    bundle exec rake db:init
+
+Now use the following command to generate seeds (basically some random comments in Latin):
+
+    bundle exec rake db:seed
+
+It's done! Launch the app now:
+
+    ruby app.rb
+
+## Running the delayed job worker
+
+In the discussion service, notifications are handled asynchronously using a third party gem called delayed_job. If you want to test this functionality, run the following command in a separate tab:
+
+    bundle exec rake jobs:work
+
+## Initialize roles and permissions
+
+To fully test the discussion forum, you might want to act as a moderator or an administrator. Currently, moderators can manage everything in the forum, and administrator can manage everything plus assigning and revoking moderator status of other users.
+
+First make sure that the database is up-to-date:
+
+    rake django-admin[syncdb]
+    rake django-admin[migrate]
+
+For convenience, add the following environment variables to the terminal (assuming that you're using configuration set lms.envs.dev):
+
+    export DJANGO_SETTINGS_MODULE=lms.envs.dev
+    export PYTHONPATH=.
+
+Now initialzie roles and permissions:
+
+    django-admin.py seed_permissions_roles
+
+To assign yourself as a moderator, use the following command (assuming your username is "test", and the course id is "MITx/6.002x/2012_Fall"):
+
+    django-admin.py assign_role test Moderator "MITx/6.002x/2012_Fall"
+
+To assign yourself as an administrator, use the following command
+
+    django-admin.py assign_role test Administrator "MITx/6.002x/2012_Fall"
+
+## Some other useful commands
+
+### generate seeds for a specific forum
+The seed generating command above assumes that you have the following discussion tags somewhere in the course data:
+
+    <discussion for="Welcome Video" id="video_1" discussion_category="Video"/>
+    <discussion for="Lab 0: Using the Tools" id="lab_1" discussion_category="Lab"/>
+    <discussion for="Lab Circuit Sandbox" id="lab_2" discussion_category="Lab"/>
+
+For example, you can insert them into overview section as following:
+
+    <chapter name="Overview">
+      <section format="Video" name="Welcome">
+        <vertical>
+          <video youtube="0.75:izygArpw-Qo,1.0:p2Q6BrNhdh8,1.25:1EeWXzPdhSA,1.50:rABDYkeK0x8"/>
+          <discussion for="Welcome Video" id="video_1" discussion_category="Video"/>
+        </vertical>
+      </section>
+      <section format="Lecture Sequence" name="System Usage Sequence">
+        <%include file="sections/introseq.xml"/>
+      </section>
+      <section format="Lab" name="Lab0: Using the tools">
+        <vertical>
+          <html> See the <a href="/section/labintro"> Lab Introduction </a> or <a href="/static/handouts/schematic_tutorial.pdf">Interactive Lab Usage Handout </a> for information on how to do the lab </html>
+          <problem name="Lab 0: Using the Tools" filename="Lab0" rerandomize="false"/>
+          <discussion for="Lab 0: Using the Tools" id="lab_1" discussion_category="Lab"/>
+        </vertical>
+      </section>
+      <section format="Lab" name="Circuit Sandbox">
+        <vertical>
+          <problem name="Circuit Sandbox" filename="Lab_sandbox" rerandomize="false"/>
+          <discussion for="Lab Circuit Sandbox" id="lab_2" discussion_category="Lab"/>
+        </vertical>
+      </section>
+    </chapter>
+
+Currently, only the attribute "id" is actually used, which identifies discussion forum. In the code for the data generator, the corresponding lines are:
+
+    generate_comments_for("video_1")
+    generate_comments_for("lab_1")
+    generate_comments_for("lab_2")
+
+We also have a command for generating comments within a forum with the specified id:
+
+    bundle exec rake db:generate_comments[type_the_discussion_id_here]
+
+For instance, if you want to generate comments for a new discussion tab named "lab_3", then use the following command
+
+    bundle exec rake db:generate_comments[lab_3]
+
+### Running tests for the service
+
+    bundle exec rspec
+
+Warning: the development and test environments share the same elasticsearch index. After running tests, search may not work in the development environment. You simply need to reindex:
+
+    bundle exec rake db:reindex_search
+
+### debugging the service
+
+You can use the following command to launch a console within the service environment:
+
+    bundle exec rake console
+
+### show user roles and permissions
+
+Use the following command to see the roles and permissions of a user in a given course (assuming, again, that the username is "test"):
+
+    django-admin.py show_permissions moderator
+
+You need to make sure that the environment variables are exported. Otherwise you would need to do
+
+    django-admin.py show_permissions moderator --settings=lms.envs.dev --pythonpath=.

install.txt

@@ -75,4 +75,3 @@ There is also a script "create-dev-env.sh" that automates these steps.
         $ django-admin.py migrate --settings=envs.dev --pythonpath=.
         $ django-admin.py runserver --settings=envs.dev --pythonpath=.   
 
-

lms/djangoapps/courseware/module_render.py

@@ -167,6 +167,7 @@ def get_module(user, request, location, student_module_cache, course_id, positio
             shared_module = student_module_cache.lookup(descriptor.category,
                                                         shared_state_key)
 
+
     instance_state = instance_module.state if instance_module is not None else None
     shared_state = shared_module.state if shared_module is not None else None
 

lms/djangoapps/courseware/views.py

@@ -3,6 +3,10 @@ import logging
 import urllib
 import itertools
 
+from functools import partial
+
+from functools import partial
+
 from django.conf import settings
 from django.core.context_processors import csrf
 from django.core.urlresolvers import reverse
@@ -21,6 +25,11 @@ from courseware.courses import (get_course_with_access, get_courses_by_universit
 from models import StudentModuleCache
 from module_render import toc_for_course, get_module, get_section
 from student.models import UserProfile
+
+from multicourse import multicourse_settings
+
+from django_comment_client.utils import get_discussion_title
+
 from student.models import UserTestGroup, CourseEnrollment
 from util.cache import cache, cache_if_anonymous
 from xmodule.course_module import CourseDescriptor
@@ -29,6 +38,11 @@ from xmodule.modulestore.django import modulestore
 from xmodule.modulestore.exceptions import InvalidLocationError, ItemNotFoundError, NoPathToItem
 from xmodule.modulestore.search import path_to_location
 
+import comment_client
+
+
+
+
 log = logging.getLogger("mitx.courseware")
 
 template_imports = {'urllib': urllib}
@@ -256,6 +270,26 @@ def university_profile(request, org_id):
 
     return render_to_response(template_file, context)
 
+def render_notifications(request, course, notifications):
+    context = {
+        'notifications': notifications,
+        'get_discussion_title': partial(get_discussion_title, request=request, course=course),
+        'course': course,
+    }
+    return render_to_string('notifications.html', context)
+
+@login_required
+def news(request, course_id):
+    course = get_course_with_access(request.user, course_id, 'load')
+
+    notifications = comment_client.get_notifications(request.user.id)
+
+    context = {
+        'course': course,
+        'content': render_notifications(request, course, notifications),
+    }
+
+    return render_to_response('news.html', context)
 
 @login_required
 @cache_control(no_cache=True, no_store=True, must_revalidate=True)
@@ -346,4 +380,3 @@ def instructor_dashboard(request, course_id):
     context = {'course': course,
                'staff_access': True,}
     return render_to_response('courseware/instructor_dashboard.html', context)
-

lms/djangoapps/django_comment_client/__init__.py

+# call some function from permissions so that the post_save hook is imported
+from permissions import assign_default_role

lms/djangoapps/django_comment_client/base/urls.py

+from django.conf.urls.defaults import url, patterns
+import django_comment_client.base.views
+
+urlpatterns = patterns('django_comment_client.base.views',
+
+    url(r'upload$', 'upload', name='upload'),
+    url(r'users/(?P<user_id>\w+)/update_moderator_status$', 'update_moderator_status', name='update_moderator_status'),
+    url(r'threads/tags/autocomplete$', 'tags_autocomplete', name='tags_autocomplete'),
+    url(r'threads/(?P<thread_id>[\w\-]+)/update$', 'update_thread', name='update_thread'),
+    url(r'threads/(?P<thread_id>[\w\-]+)/reply$', 'create_comment', name='create_comment'),
+    url(r'threads/(?P<thread_id>[\w\-]+)/delete', 'delete_thread', name='delete_thread'),
+    url(r'threads/(?P<thread_id>[\w\-]+)/upvote$', 'vote_for_thread', {'value': 'up'}, name='upvote_thread'),
+    url(r'threads/(?P<thread_id>[\w\-]+)/downvote$', 'vote_for_thread', {'value': 'down'}, name='downvote_thread'),
+    url(r'threads/(?P<thread_id>[\w\-]+)/unvote$', 'undo_vote_for_thread', name='undo_vote_for_thread'),
+    url(r'threads/(?P<thread_id>[\w\-]+)/follow$', 'follow_thread', name='follow_thread'),
+    url(r'threads/(?P<thread_id>[\w\-]+)/unfollow$', 'unfollow_thread', name='unfollow_thread'),
+    url(r'threads/(?P<thread_id>[\w\-]+)/close$', 'openclose_thread', name='openclose_thread'),
+
+    url(r'comments/(?P<comment_id>[\w\-]+)/update$', 'update_comment', name='update_comment'),
+    url(r'comments/(?P<comment_id>[\w\-]+)/endorse$', 'endorse_comment', name='endorse_comment'),
+    url(r'comments/(?P<comment_id>[\w\-]+)/reply$', 'create_sub_comment', name='create_sub_comment'),
+    url(r'comments/(?P<comment_id>[\w\-]+)/delete$', 'delete_comment', name='delete_comment'),
+    url(r'comments/(?P<comment_id>[\w\-]+)/upvote$', 'vote_for_comment', {'value': 'up'}, name='upvote_comment'),
+    url(r'comments/(?P<comment_id>[\w\-]+)/downvote$', 'vote_for_comment', {'value': 'down'}, name='downvote_comment'),
+    url(r'comments/(?P<comment_id>[\w\-]+)/unvote$', 'undo_vote_for_comment', name='undo_vote_for_comment'),
+    
+    url(r'(?P<commentable_id>[\w\-]+)/threads/create$', 'create_thread', name='create_thread'),
+    # TODO should we search within the board?
+    url(r'(?P<commentable_id>[\w\-]+)/threads/search_similar$', 'search_similar_threads', name='search_similar_threads'),
+    url(r'(?P<commentable_id>[\w\-]+)/follow$', 'follow_commentable', name='follow_commentable'),
+    url(r'(?P<commentable_id>[\w\-]+)/unfollow$', 'unfollow_commentable', name='unfollow_commentable'),
+)

lms/djangoapps/django_comment_client/forum/urls.py

+from django.conf.urls.defaults import url, patterns
+import django_comment_client.forum.views
+
+urlpatterns = patterns('django_comment_client.forum.views',
+    url(r'users/(?P<user_id>\w+)$', 'user_profile', name='user_profile'),
+    url(r'(?P<discussion_id>\w+)/threads/(?P<thread_id>\w+)$', 'single_thread', name='single_thread'),
+    url(r'(?P<discussion_id>\w+)/inline$', 'inline_discussion', name='inline_discussion'),
+    url(r'', 'forum_form_discussion', name='forum_form_discussion'),
+)

lms/djangoapps/django_comment_client/forum/views.py

+from django.contrib.auth.decorators import login_required
+from django.views.decorators.http import require_POST
+from django.http import HttpResponse
+from django.utils import simplejson
+from django.core.context_processors import csrf
+from django.core.urlresolvers import reverse
+from django.contrib.auth.models import User
+
+from mitxmako.shortcuts import render_to_response, render_to_string
+from courseware.courses import get_course_with_access
+
+from urllib import urlencode
+from django_comment_client.permissions import check_permissions_by_view
+from django_comment_client.utils import merge_dict, extract, strip_none
+
+import json
+import dateutil
+import django_comment_client.utils as utils
+import comment_client as cc
+
+
+THREADS_PER_PAGE = 5
+PAGES_NEARBY_DELTA = 2
+
+
+def _general_discussion_id(course_id):
+    return course_id.replace('/', '_').replace('.', '_')
+
+def _should_perform_search(request):
+    return bool(request.GET.get('text', False) or \
+            request.GET.get('tags', False))
+        
+
+def render_accordion(request, course, discussion_id):
+
+    discussion_info = utils.get_categorized_discussion_info(request, course)
+
+    context = {
+        'course': course,
+        'discussion_info': discussion_info,
+        'active': discussion_id,
+        'csrf': csrf(request)['csrf_token'],
+    }
+
+    return render_to_string('discussion/_accordion.html', context)
+
+def render_discussion(request, course_id, threads, *args, **kwargs):
+
+    discussion_id = kwargs.get('discussion_id')
+    user_id = kwargs.get('user_id')
+    discussion_type = kwargs.get('discussion_type', 'inline')
+    query_params = kwargs.get('query_params', {})
+
+    template = {
+        'inline': 'discussion/_inline.html',
+        'forum': 'discussion/_forum.html',
+        'user': 'discussion/_user_active_threads.html',
+    }[discussion_type]
+
+    base_url = {
+        'inline': (lambda: reverse('django_comment_client.forum.views.inline_discussion', args=[course_id, discussion_id])), 
+        'forum': (lambda: reverse('django_comment_client.forum.views.forum_form_discussion', args=[course_id])),
+        'user': (lambda: reverse('django_comment_client.forum.views.user_profile', args=[course_id, user_id])),
+    }[discussion_type]()
+
+    annotated_content_infos = map(lambda x: utils.get_annotated_content_infos(course_id, x, request.user), threads)
+    annotated_content_info = reduce(merge_dict, annotated_content_infos, {})
+
+    context = {
+        'threads': threads,
+        'discussion_id': discussion_id,
+        'user_id': user_id,
+        'user_info': json.dumps(cc.User.from_django_user(request.user).to_dict()),
+        'course_id': course_id,
+        'request': request,
+        'performed_search': _should_perform_search(request),
+        'pages_nearby_delta': PAGES_NEARBY_DELTA,
+        'discussion_type': discussion_type,
+        'base_url': base_url,
+        'query_params': strip_none(extract(query_params, ['page', 'sort_key', 'sort_order', 'tags', 'text'])),
+        'annotated_content_info': json.dumps(annotated_content_info),
+    }
+    context = dict(context.items() + query_params.items())
+    return render_to_string(template, context)
+
+def render_inline_discussion(*args, **kwargs):
+    return render_discussion(discussion_type='inline', *args, **kwargs)
+
+def render_forum_discussion(*args, **kwargs):
+    return render_discussion(discussion_type='forum', *args, **kwargs)
+
+def render_user_discussion(*args, **kwargs):
+    return render_discussion(discussion_type='user', *args, **kwargs)
+
+def get_threads(request, course_id, discussion_id=None):
+
+    default_query_params = {
+        'page': 1,
+        'per_page': THREADS_PER_PAGE,
+        'sort_key': 'activity',
+        'sort_order': 'desc',
+        'text': '',
+        'tags': '',
+        'commentable_id': discussion_id,
+        'course_id': course_id,
+    }
+
+    query_params = merge_dict(default_query_params,
+                              strip_none(extract(request.GET, ['page', 'sort_key', 'sort_order', 'text', 'tags'])))
+
+    threads, page, num_pages = cc.Thread.search(query_params)
+
+    query_params['page'] = page
+    query_params['num_pages'] = num_pages
+
+    return threads, query_params
+
+# discussion per page is fixed for now
+def inline_discussion(request, course_id, discussion_id):
+    threads, query_params = get_threads(request, course_id, discussion_id)
+    html = render_inline_discussion(request, course_id, threads, discussion_id=discussion_id,  \
+                                                                 query_params=query_params)
+    return utils.HtmlResponse(html)
+
+def render_search_bar(request, course_id, discussion_id=None, text=''):
+    if not discussion_id:
+        return ''
+    context = {
+        'discussion_id': discussion_id,
+        'text': text,
+        'course_id': course_id,
+    }
+    return render_to_string('discussion/_search_bar.html', context)
+
+def forum_form_discussion(request, course_id):
+    course = get_course_with_access(request.user, course_id, 'load')
+    threads, query_params = get_threads(request, course_id)
+    content = render_forum_discussion(request, course_id, threads, discussion_id=_general_discussion_id(course_id), query_params=query_params)
+
+    recent_active_threads = cc.search_recent_active_threads(
+        course_id,
+        recursive=False,
+        query_params={'follower_id': request.user.id},
+    )
+
+    trending_tags = cc.search_trending_tags(
+        course_id,
+    )
+
+    if request.is_ajax():
+        return utils.HtmlResponse(content)
+    else:
+        context = {
+            'csrf': csrf(request)['csrf_token'],
+            'course': course,
+            'content': content,
+            'recent_active_threads': recent_active_threads,
+            'trending_tags': trending_tags,
+        }
+        print "start rendering.."
+        return render_to_response('discussion/index.html', context)
+
+def render_single_thread(request, discussion_id, course_id, thread_id):
+    
+    thread = cc.Thread.find(thread_id).retrieve(recursive=True)
+
+    annotated_content_info = utils.get_annotated_content_infos(course_id, thread=thread.to_dict(), user=request.user)
+
+    context = {
+        'discussion_id': discussion_id,
+        'thread': thread,
+        'user_info': json.dumps(cc.User.from_django_user(request.user).to_dict()),
+        'annotated_content_info': json.dumps(annotated_content_info),
+        'course_id': course_id,
+        'request': request,
+    }
+    return render_to_string('discussion/_single_thread.html', context)
+
+def single_thread(request, course_id, discussion_id, thread_id):
+
+    if request.is_ajax():
+        
+        thread = cc.Thread.find(thread_id).retrieve(recursive=True)
+        annotated_content_info = utils.get_annotated_content_infos(course_id, thread, request.user)
+        context = {'thread': thread.to_dict(), 'course_id': course_id}
+        html = render_to_string('discussion/_ajax_single_thread.html', context)
+
+        return utils.JsonResponse({
+            'html': html,
+            'annotated_content_info': annotated_content_info,
+        })
+
+    else:
+        course = get_course_with_access(request.user, course_id, 'load')
+
+        context = {
+            'discussion_id': discussion_id,
+            'csrf': csrf(request)['csrf_token'],
+            'init': '',
+            'content': render_single_thread(request, discussion_id, course_id, thread_id),
+            'accordion': render_accordion(request, course, discussion_id),
+            'course': course,
+            'course_id': course.id,
+        }
+
+        return render_to_response('discussion/index.html', context)
+
+def user_profile(request, course_id, user_id):
+
+    course = get_course_with_access(request.user, course_id, 'load')
+    profiled_user = cc.User(id=user_id, course_id=course_id)
+
+    query_params = {
+        'page': request.GET.get('page', 1),
+        'per_page': THREADS_PER_PAGE, # more than threads_per_page to show more activities
+    }
+
+    threads, page, num_pages = profiled_user.active_threads(query_params)
+
+    query_params['page'] = page
+    query_params['num_pages'] = num_pages
+
+    content = render_user_discussion(request, course_id, threads, user_id=user_id, query_params=query_params)
+
+    if request.is_ajax():
+        return utils.HtmlResponse(content)
+    else:
+        context = {
+            'course': course, 
+            'user': request.user,
+            'django_user': User.objects.get(id=user_id),
+            'profiled_user': profiled_user.to_dict(),
+            'content': content,
+        }
+
+        return render_to_response('discussion/user_profile.html', context)

lms/djangoapps/django_comment_client/helpers.py

+from django.core.urlresolvers import reverse
+from mitxmako.shortcuts import render_to_string
+from utils import *
+from mustache_helpers import mustache_helpers
+from functools import partial
+
+import pystache_custom as pystache
+import urllib
+
+def pluralize(singular_term, count):
+    if int(count) >= 2:
+        return singular_term + 's'
+    return singular_term
+
+def show_if(text, condition):
+    if condition:
+        return text
+    else:
+        return ''
+
+def render_content(content, additional_context={}):
+    content_info = {
+        'displayed_title': content.get('highlighted_title') or content.get('title', ''),
+        'displayed_body': content.get('highlighted_body') or content.get('body', ''),
+        'raw_tags': ','.join(content.get('tags', [])),
+    }
+    context = {
+        'content': merge_dict(content, content_info),
+        content['type']: True,
+    }
+    context = merge_dict(context, additional_context)
+    partial_mustache_helpers = {k: partial(v, content) for k, v in mustache_helpers.items()}
+    context = merge_dict(context, partial_mustache_helpers)
+    return render_mustache('discussion/_content.mustache', context)

lms/djangoapps/django_comment_client/management/commands/assign_role.py

+from django.core.management.base import BaseCommand, CommandError
+from django_comment_client.models import Permission, Role
+from django.contrib.auth.models import User
+
+
+class Command(BaseCommand):
+    args = 'user role course_id'
+    help = 'Assign a role to a user'
+
+    def handle(self, *args, **options):
+        role = Role.objects.get(name=args[1], course_id=args[2])
+
+        if '@' in args[0]:
+            user = User.objects.get(email=args[0])
+        else:
+            user = User.objects.get(username=args[0])
+
+        user.roles.add(role)
\ No newline at end of file

lms/djangoapps/django_comment_client/management/commands/create_roles_for_existing.py

+"""
+This must be run only after seed_permissions_roles.py!
+
+Creates default roles for all users currently in the database. Just runs through
+Enrollments.
+"""
+from django.core.management.base import BaseCommand, CommandError
+
+from student.models import CourseEnrollment
+from django_comment_client.permissions import assign_default_role
+
+
+class Command(BaseCommand):
+    args = 'course_id'
+    help = 'Seed default permisssions and roles'
+
+    def handle(self, *args, **options):
+        if len(args) != 0:
+            raise CommandError("This Command takes no arguments")
+
+        print "Updated roles for ",
+        for i, enrollment in enumerate(CourseEnrollment.objects.all(), start=1):
+            assign_default_role(None, enrollment)
+            if i % 1000 == 0:
+                print "{0}...".format(i),
+        print
\ No newline at end of file

lms/djangoapps/django_comment_client/management/commands/seed_permissions_roles.py

+from django.core.management.base import BaseCommand, CommandError
+from django_comment_client.models import Permission, Role
+
+
+class Command(BaseCommand):
+    args = 'course_id'
+    help = 'Seed default permisssions and roles'
+
+    def handle(self, *args, **options):
+        if len(args) != 1:
+            raise CommandError("The number of arguments does not match. ")
+        course_id = args[0]
+        administrator_role = Role.objects.get_or_create(name="Administrator", course_id=course_id)[0]
+        moderator_role = Role.objects.get_or_create(name="Moderator", course_id=course_id)[0]
+        student_role = Role.objects.get_or_create(name="Student", course_id=course_id)[0]
+
+        for per in ["vote", "update_thread", "follow_thread", "unfollow_thread",
+                       "update_comment", "create_sub_comment", "unvote" , "create_thread",
+                       "follow_commentable", "unfollow_commentable", "create_comment", ]:
+            student_role.add_permission(per)
+
+        for per in ["edit_content", "delete_thread", "openclose_thread",
+                        "endorse_comment", "delete_comment"]:
+            moderator_role.add_permission(per)
+
+        for per in ["manage_moderator"]:
+            administrator_role.add_permission(per)
+
+        moderator_role.inherit_permissions(student_role)
+
+        administrator_role.inherit_permissions(moderator_role)

lms/djangoapps/django_comment_client/management/commands/show_permissions.py

+from django.core.management.base import BaseCommand, CommandError
+from django_comment_client.models import Permission, Role
+from django.contrib.auth.models import User
+
+
+class Command(BaseCommand):
+    args = 'user'
+    help = "Show a user's roles and permissions"
+
+    def handle(self, *args, **options):
+        print args
+        if len(args) != 1:
+            raise CommandError("The number of arguments does not match. ")
+        try:
+            if '@' in args[0]:
+                user = User.objects.get(email=args[0])
+            else:
+                user = User.objects.get(username=args[0])
+        except User.DoesNotExist:
+            print "User %s does not exist. " % args[0]
+            print "Available users: "
+            print User.objects.all()
+            return
+
+        roles = user.roles.all()
+        print "%s has %d roles:" % (user, len(roles))
+        for role in roles:
+            print "\t%s" % role
+
+        for role in roles:
+            print "%s has permissions: " % role
+            print role.permissions.all()

lms/djangoapps/django_comment_client/middleware.py

+from comment_client import CommentClientError
+from django_comment_client.utils import JsonError
+import json
+
+class AjaxExceptionMiddleware(object): 
+    def process_exception(self, request, exception):
+        if isinstance(exception, CommentClientError) and request.is_ajax():
+            return JsonError(json.loads(exception.message))
+        return None

lms/djangoapps/django_comment_client/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 'Role'
+        db.create_table('django_comment_client_role', (
+            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
+            ('name', self.gf('django.db.models.fields.CharField')(max_length=30)),
+            ('course_id', self.gf('django.db.models.fields.CharField')(db_index=True, max_length=255, blank=True)),
+        ))
+        db.send_create_signal('django_comment_client', ['Role'])
+
+        # Adding M2M table for field users on 'Role'
+        db.create_table('django_comment_client_role_users', (
+            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
+            ('role', models.ForeignKey(orm['django_comment_client.role'], null=False)),
+            ('user', models.ForeignKey(orm['auth.user'], null=False))
+        ))
+        db.create_unique('django_comment_client_role_users', ['role_id', 'user_id'])
+
+        # Adding model 'Permission'
+        db.create_table('django_comment_client_permission', (
+            ('name', self.gf('django.db.models.fields.CharField')(max_length=30, primary_key=True)),
+        ))
+        db.send_create_signal('django_comment_client', ['Permission'])
+
+        # Adding M2M table for field roles on 'Permission'
+        db.create_table('django_comment_client_permission_roles', (
+            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
+            ('permission', models.ForeignKey(orm['django_comment_client.permission'], null=False)),
+            ('role', models.ForeignKey(orm['django_comment_client.role'], null=False))
+        ))
+        db.create_unique('django_comment_client_permission_roles', ['permission_id', 'role_id'])
+
+
+    def backwards(self, orm):
+        # Deleting model 'Role'
+        db.delete_table('django_comment_client_role')
+
+        # Removing M2M table for field users on 'Role'
+        db.delete_table('django_comment_client_role_users')
+
+        # Deleting model 'Permission'
+        db.delete_table('django_comment_client_permission')
+
+        # Removing M2M table for field roles on 'Permission'
+        db.delete_table('django_comment_client_permission_roles')
+
+
+    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'},
+            'about': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            'avatar_type': ('django.db.models.fields.CharField', [], {'default': "'n'", 'max_length': '1'}),
+            'bronze': ('django.db.models.fields.SmallIntegerField', [], {'default': '0'}),
+            'consecutive_days_visit_count': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'country': ('django_countries.fields.CountryField', [], {'max_length': '2', 'blank': 'True'}),
+            'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'date_of_birth': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
+            'display_tag_filter_strategy': ('django.db.models.fields.SmallIntegerField', [], {'default': '0'}),
+            'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
+            'email_isvalid': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'email_key': ('django.db.models.fields.CharField', [], {'max_length': '32', 'null': 'True'}),
+            'email_tag_filter_strategy': ('django.db.models.fields.SmallIntegerField', [], {'default': '1'}),
+            'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'gold': ('django.db.models.fields.SmallIntegerField', [], {'default': '0'}),
+            'gravatar': ('django.db.models.fields.CharField', [], {'max_length': '32'}),
+            'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'ignored_tags': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            'interesting_tags': ('django.db.models.fields.TextField', [], {'blank': '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'}),
+            'last_seen': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'location': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
+            'new_response_count': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
+            'questions_per_page': ('django.db.models.fields.SmallIntegerField', [], {'default': '10'}),
+            'real_name': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
+            'reputation': ('django.db.models.fields.PositiveIntegerField', [], {'default': '1'}),
+            'seen_response_count': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'show_country': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'silver': ('django.db.models.fields.SmallIntegerField', [], {'default': '0'}),
+            'status': ('django.db.models.fields.CharField', [], {'default': "'w'", 'max_length': '2'}),
+            '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'}),
+            'website': ('django.db.models.fields.URLField', [], {'max_length': '200', 'blank': 'True'})
+        },
+        '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'})
+        },
+        'django_comment_client.permission': {
+            'Meta': {'object_name': 'Permission'},
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'primary_key': 'True'}),
+            'roles': ('django.db.models.fields.related.ManyToManyField', [], {'related_name': "'permissions'", 'symmetrical': 'False', 'to': "orm['django_comment_client.Role']"})
+        },
+        'django_comment_client.role': {
+            'Meta': {'object_name': 'Role'},
+            'course_id': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '255', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '30'}),
+            'users': ('django.db.models.fields.related.ManyToManyField', [], {'related_name': "'roles'", 'symmetrical': 'False', 'to': "orm['auth.User']"})
+        }
+    }
+
+    complete_apps = ['django_comment_client']
\ No newline at end of file

lms/djangoapps/django_comment_client/models.py

+from django.db import models
+from django.contrib.auth.models import User
+import logging
+
+
+class Role(models.Model):
+    name = models.CharField(max_length=30, null=False, blank=False)
+    users = models.ManyToManyField(User, related_name="roles")
+    course_id = models.CharField(max_length=255, blank=True, db_index=True)
+
+    def __unicode__(self):
+        return self.name + " for " + (self.course_id if self.course_id else "all courses")
+
+    def inherit_permissions(self, role): # TODO the name of this method is a little bit confusing,
+                                         # since it's one-off and doesn't handle inheritance later
+        if role.course_id and role.course_id != self.course_id:
+            logging.warning("%s cannot inheret permissions from %s due to course_id inconsistency" % 
+                            (self, role))
+        for per in role.permissions.all():
+            self.add_permission(per)
+
+    def add_permission(self, permission):
+        self.permissions.add(Permission.objects.get_or_create(name=permission)[0])
+
+    def has_permission(self, permission):
+        return self.permissions.filter(name=permission).exists()
+
+
+class Permission(models.Model):
+    name = models.CharField(max_length=30, null=False, blank=False, primary_key=True)
+    roles = models.ManyToManyField(Role, related_name="permissions")
+
+    def __unicode__(self):
+        return self.name

lms/djangoapps/django_comment_client/mustache_helpers.py

+from django.core.urlresolvers import reverse
+import urllib
+
+def pluralize(content, text):
+    num, word = text.split(' ')
+    if int(num or '0') >= 2:
+        return num + ' ' + word + 's'
+    else:
+        return num + ' ' + word
+
+def url_for_user(content, user_id):
+    return reverse('django_comment_client.forum.views.user_profile', args=[content['course_id'], user_id])
+
+def url_for_tags(content, tags): # assume that tags is in the format u'a, b, c'
+    return reverse('django_comment_client.forum.views.forum_form_discussion', args=[content['course_id']]) + '?' + urllib.urlencode({'tags': tags})
+
+def close_thread_text(content):
+    if content.get('closed'):
+        return 'Re-open thread'
+    else:
+        return 'Close thread'
+
+mustache_helpers = {
+    'pluralize': pluralize,
+    'url_for_tags': url_for_tags,
+    'url_for_user': url_for_user,
+    'close_thread_text': close_thread_text,
+}

lms/djangoapps/django_comment_client/permissions.py

+from .models import Role, Permission
+from django.contrib.auth.models import User
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+from student.models import CourseEnrollment
+
+import logging
+from util.cache import cache
+
+
+@receiver(post_save, sender=CourseEnrollment)
+def assign_default_role(sender, instance, **kwargs):
+    if instance.user.is_staff:
+        role = Role.objects.get_or_create(course_id=instance.course_id, name="Moderator")[0]
+    else:
+        role = Role.objects.get_or_create(course_id=instance.course_id, name="Student")[0]
+
+    logging.info("assign_default_role: adding %s as %s" % (instance.user, role))
+    instance.user.roles.add(role)
+
+def cached_has_permission(user, permission, course_id=None):
+    """
+    Call has_permission if it's not cached. A change in a user's role or
+    a role's permissions will only become effective after CACHE_LIFESPAN seconds. 
+    """
+    CACHE_LIFESPAN = 60
+    key = "permission_%d_%s_%s" % (user.id, str(course_id), permission)
+    val = cache.get(key, None)
+    if val not in [True, False]:
+        val = has_permission(user, permission, course_id=course_id)
+        cache.set(key, val, CACHE_LIFESPAN)
+    return val
+
+def has_permission(user, permission, course_id=None):
+    for role in user.roles.filter(course_id=course_id):
+        if role.has_permission(permission):
+            return True
+    return False
+
+
+CONDITIONS = ['is_open', 'is_author']
+def check_condition(user, condition, course_id, data):
+    def check_open(user, condition, course_id, data):
+        try:
+            return data and not data['content']['closed']
+        except KeyError:
+            return False
+
+    def check_author(user, condition, course_id, data):
+        try:
+            return data and data['content']['user_id'] == str(user.id)
+        except KeyError:
+            return False
+
+    handlers = {
+        'is_open'      : check_open,
+        'is_author'    : check_author,
+    }
+
+    return handlers[condition](user, condition, course_id, data)
+
+
+def check_conditions_permissions(user, permissions, course_id, **kwargs):
+    """
+    Accepts a list of permissions and proceed if any of the permission is valid.
+    Note that ["can_view", "can_edit"] will proceed if the user has either
+    "can_view" or "can_edit" permission. To use AND operator in between, wrap them in 
+    a list. 
+    """
+
+    def test(user, per, operator="or"):
+        if isinstance(per, basestring):
+            if per in CONDITIONS:
+                return check_condition(user, per, course_id, kwargs)
+            return cached_has_permission(user, per, course_id=course_id)
+        elif isinstance(per, list) and operator in ["and", "or"]:
+            results = [test(user, x, operator="and") for x in per]
+            if operator == "or":
+                return True in results
+            elif operator == "and":
+                return not False in results
+
+    return test(user, permissions, operator="or")
+
+
+VIEW_PERMISSIONS = {
+    'update_thread'     :       ['edit_content', ['update_thread', 'is_open', 'is_author']],
+    'create_comment'    :       [["create_comment", "is_open"]],
+    'delete_thread'     :       ['delete_thread'],
+    'update_comment'    :       ['edit_content', ['update_comment', 'is_open', 'is_author']],
+    'endorse_comment'   :       ['endorse_comment'],
+    'openclose_thread'  :       ['openclose_thread'],
+    'create_sub_comment':       [['create_sub_comment', 'is_open']],
+    'delete_comment'    :       ['delete_comment'],
+    'vote_for_comment'  :       [['vote', 'is_open']],
+    'undo_vote_for_comment':    [['unvote', 'is_open']],
+    'vote_for_thread'   :       [['vote', 'is_open']],
+    'undo_vote_for_thread':     [['unvote', 'is_open']],
+    'follow_thread'     :       ['follow_thread'],
+    'follow_commentable':       ['follow_commentable'], 
+    'follow_user'       :       ['follow_user'],
+    'unfollow_thread'   :       ['unfollow_thread'],
+    'unfollow_commentable':     ['unfollow_commentable'],
+    'unfollow_user'     :       ['unfollow_user'],
+    'create_thread'     :       ['create_thread'],
+    'update_moderator_status' : ['manage_moderator'],
+}
+
+
+def check_permissions_by_view(user, course_id, content, name):
+    try:
+        p = VIEW_PERMISSIONS[name]
+    except KeyError:
+        logging.warning("Permission for view named %s does not exist in permissions.py" % name)
+    return check_conditions_permissions(user, p, course_id, content=content)

lms/djangoapps/django_comment_client/tests.py

+from django.contrib.auth.models import User
+from django.test import TestCase
+from student.models import CourseEnrollment, \
+                           replicate_enrollment_save, \
+                           replicate_enrollment_delete, \
+                           update_user_information, \
+                           replicate_user_save
+                           
+from django.db.models.signals import m2m_changed, pre_delete, pre_save, post_delete, post_save
+from django.dispatch.dispatcher import _make_id
+import string
+import random
+from .permissions import has_permission
+from .models import Role, Permission
+
+class PermissionsTestCase(TestCase):
+    def random_str(self, length=15, chars=string.ascii_uppercase + string.digits):
+        return ''.join(random.choice(chars) for x in range(length))
+
+    def setUp(self):
+        self.course_id = "MITx/6.002x/2012_Fall"
+
+        self.moderator_role = Role.objects.get_or_create(name="Moderator", course_id=self.course_id)[0]
+        self.student_role = Role.objects.get_or_create(name="Student", course_id=self.course_id)[0]
+
+        self.student = User.objects.create(username=self.random_str(),
+                            password="123456", email="john@yahoo.com")
+        self.moderator = User.objects.create(username=self.random_str(),
+                            password="123456", email="staff@edx.org")
+        self.moderator.is_staff = True
+        self.moderator.save()
+        self.student_enrollment = CourseEnrollment.objects.create(user=self.student, course_id=self.course_id)
+        self.moderator_enrollment = CourseEnrollment.objects.create(user=self.moderator, course_id=self.course_id)
+
+    def tearDown(self):
+        self.student_enrollment.delete()
+        self.moderator_enrollment.delete()
+
+# Do we need to have this? We shouldn't be deleting students, ever
+#        self.student.delete()
+#        self.moderator.delete()
+
+    def testDefaultRoles(self):
+        self.assertTrue(self.student_role in self.student.roles.all())
+        self.assertTrue(self.moderator_role in self.moderator.roles.all())
+
+    def testPermission(self):
+        name = self.random_str()
+        self.moderator_role.add_permission(name)
+        self.assertTrue(has_permission(self.moderator, name, self.course_id))
+
+        self.student_role.add_permission(name)
+        self.assertTrue(has_permission(self.student, name, self.course_id))

lms/djangoapps/django_comment_client/urls.py

+from django.conf.urls.defaults import url, patterns, include
+
+urlpatterns = patterns('',
+    url(r'forum/', include('django_comment_client.forum.urls')),
+    url(r'', include('django_comment_client.base.urls')),
+)

lms/djangoapps/django_comment_client/utils.py

+from importlib import import_module
+from courseware.models import StudentModuleCache
+from courseware.module_render import get_module
+from xmodule.modulestore import Location
+from xmodule.modulestore.django import modulestore
+from django.http import HttpResponse
+from django.utils import simplejson
+from django.db import connection
+from django.conf import settings
+from django_comment_client.permissions import check_permissions_by_view
+from mitxmako import middleware
+
+import logging
+import operator
+import itertools
+import pystache_custom as pystache
+
+
+_FULLMODULES = None
+_DISCUSSIONINFO = None
+
+def extract(dic, keys):
+    return {k: dic.get(k) for k in keys}
+
+def strip_none(dic):
+    return dict([(k, v) for k, v in dic.iteritems() if v is not None])
+
+def strip_blank(dic):
+    def _is_blank(v):
+        return isinstance(v, str) and len(v.strip()) == 0
+    return dict([(k, v) for k, v in dic.iteritems() if not _is_blank(v)])
+
+def merge_dict(dic1, dic2):
+    return dict(dic1.items() + dic2.items())
+
+def get_full_modules():
+    global _FULLMODULES
+    if not _FULLMODULES:
+        class_path = settings.MODULESTORE['default']['ENGINE']
+        module_path, _, class_name = class_path.rpartition('.')
+        class_ = getattr(import_module(module_path), class_name)
+        modulestore = class_(**dict(settings.MODULESTORE['default']['OPTIONS'].items() + [('eager', True)]))
+        _FULLMODULES = modulestore.modules
+    return _FULLMODULES
+
+def get_categorized_discussion_info(request, course):
+    """
+        return a dict of the form {category: modules}
+    """
+    global _DISCUSSIONINFO
+    if not _DISCUSSIONINFO:
+        initialize_discussion_info(request, course)
+    return _DISCUSSIONINFO['categorized']
+
+def get_discussion_title(request, course, discussion_id):
+    global _DISCUSSIONINFO
+    if not _DISCUSSIONINFO:
+        initialize_discussion_info(request, course)
+    title = _DISCUSSIONINFO['by_id'].get(discussion_id, {}).get('title', '(no title)')
+    return title
+
+def initialize_discussion_info(request, course):
+
+    global _DISCUSSIONINFO
+    if _DISCUSSIONINFO:
+        return
+
+    course_id = course.id
+    _, course_name, _ = course_id.split('/')
+    user = request.user
+    url_course_id = course_id.replace('/', '_').replace('.', '_')
+
+    _is_course_discussion = lambda x: x[0].dict()['category'] == 'discussion' \
+                         and x[0].dict()['course'] == course_name
+    
+    _get_module_descriptor = operator.itemgetter(1)
+
+    def _get_module(module_descriptor):
+        print module_descriptor
+        module = get_module(user, request, module_descriptor.location, student_module_cache)
+        return module
+
+    def _extract_info(module):
+        return {
+            'title': module.title,
+            'discussion_id': module.discussion_id,
+            'category': module.discussion_category,
+        }
+
+    def _pack_with_id(info):
+        return (info['discussion_id'], info)
+
+    discussion_module_descriptors = map(_get_module_descriptor,
+                                        filter(_is_course_discussion,
+                                               get_full_modules().items()))
+
+    student_module_cache = StudentModuleCache.cache_for_descriptor_descendents(user, course)
+
+    discussion_info = map(_extract_info, map(_get_module, discussion_module_descriptors))
+
+    _DISCUSSIONINFO = {}
+
+    _DISCUSSIONINFO['by_id'] = dict(map(_pack_with_id, discussion_info))
+
+    _DISCUSSIONINFO['categorized'] = dict((category, list(l)) \
+                for category, l in itertools.groupby(discussion_info, operator.itemgetter('category')))
+
+    _DISCUSSIONINFO['categorized']['General'] = [{
+        'title': 'General discussion',
+        'discussion_id': url_course_id,
+        'category': 'General',
+    }]
+
+class JsonResponse(HttpResponse):
+    def __init__(self, data=None):
+        content = simplejson.dumps(data)
+        super(JsonResponse, self).__init__(content,
+                                           mimetype='application/json; charset=utf8')
+
+class JsonError(HttpResponse):
+    def __init__(self, error_messages=[]):
+        if isinstance(error_messages, str):
+            error_messages = [error_messages]
+        content = simplejson.dumps({'errors': error_messages},
+                                   indent=2,
+                                   ensure_ascii=False)
+        super(JsonError, self).__init__(content,
+                                        mimetype='application/json; charset=utf8', status=400)
+
+class HtmlResponse(HttpResponse):
+    def __init__(self, html=''):
+        super(HtmlResponse, self).__init__(html, content_type='text/plain')
+
+class ViewNameMiddleware(object):  
+    def process_view(self, request, view_func, view_args, view_kwargs):  
+        request.view_name = view_func.__name__
+
+class QueryCountDebugMiddleware(object):
+    """
+    This middleware will log the number of queries run
+    and the total time taken for each request (with a
+    status code of 200). It does not currently support
+    multi-db setups.
+    """
+    def process_response(self, request, response):
+        if response.status_code == 200:
+            total_time = 0
+
+            for query in connection.queries:
+                query_time = query.get('time')
+                if query_time is None:
+                    # django-debug-toolbar monkeypatches the connection
+                    # cursor wrapper and adds extra information in each
+                    # item in connection.queries. The query time is stored
+                    # under the key "duration" rather than "time" and is
+                    # in milliseconds, not seconds.
+                    query_time = query.get('duration', 0) / 1000
+                total_time += float(query_time)
+
+            logging.info('%s queries run, total %s seconds' % (len(connection.queries), total_time))
+        return response
+
+def get_annotated_content_info(course_id, content, user):
+    return {
+        'editable': check_permissions_by_view(user, course_id, content, "update_thread" if content['type'] == 'thread' else "update_comment"),
+        'can_reply': check_permissions_by_view(user, course_id, content, "create_comment" if content['type'] == 'thread' else "create_sub_comment"),
+        'can_endorse': check_permissions_by_view(user, course_id, content, "endorse_comment") if content['type'] == 'comment' else False,
+        'can_delete': check_permissions_by_view(user, course_id, content, "delete_thread" if content['type'] == 'thread' else "delete_comment"),
+        'can_openclose': check_permissions_by_view(user, course_id, content, "openclose_thread") if content['type'] == 'thread' else False,
+        'can_vote': check_permissions_by_view(user, course_id, content, "vote_for_thread" if content['type'] == 'thread' else "vote_for_comment"),
+    }
+
+def get_annotated_content_infos(course_id, thread, user):
+    infos = {}
+    def _annotate(content):
+        infos[str(content['id'])] = get_annotated_content_info(course_id, content, user)
+        for child in content.get('children', []):
+            _annotate(child)
+    _annotate(thread)
+    return infos
+
+def render_mustache(template_name, dictionary, *args, **kwargs):
+    template = middleware.lookup['main'].get_template(template_name).source
+    return pystache.render(template, dictionary)

lms/envs/aws.py

@@ -19,6 +19,11 @@ EMAIL_BACKEND = 'django_ses.SESBackend'
 SESSION_ENGINE = 'django.contrib.sessions.backends.cache'
 DEFAULT_FILE_STORAGE = 'storages.backends.s3boto.S3BotoStorage'
 
+# Disable askbot, enable Berkeley forums
+MITX_FEATURES['ENABLE_DISCUSSION'] = False
+MITX_FEATURES['ENABLE_DISCUSSION_SERVICE'] = True
+
+
 ########################### NON-SECURE ENV CONFIG ##############################
 # Things like server locations, ports, etc.
 with open(ENV_ROOT / "env.json") as env_file:
@@ -60,3 +65,5 @@ XQUEUE_INTERFACE = AUTH_TOKENS['XQUEUE_INTERFACE']
 if 'COURSE_ID' in ENV_TOKENS:
     ASKBOT_URL = "courses/{0}/discussions/".format(ENV_TOKENS['COURSE_ID'])
 
+COMMENTS_SERVICE_URL = ENV_TOKENS["COMMENTS_SERVICE_URL"]
+

lms/envs/common.py

@@ -30,10 +30,11 @@ import djcelery
 from path import path
 
 from .askbotsettings import * # this is where LIVESETTINGS_OPTIONS comes from
+from .discussionsettings import *
 
 ################################### FEATURES ###################################
 COURSEWARE_ENABLED = True
-ASKBOT_ENABLED = True
+ASKBOT_ENABLED = False
 GENERATE_RANDOM_USER_CREDENTIALS = False
 PERFSTATS = False
 
@@ -55,7 +56,8 @@ MITX_FEATURES = {
     'SUBDOMAIN_COURSE_LISTINGS' : False,
 
     'ENABLE_TEXTBOOK' : True,
-    'ENABLE_DISCUSSION' : True,
+    'ENABLE_DISCUSSION' : False,
+    'ENABLE_DISCUSSION_SERVICE': True,
 
     'ENABLE_SQL_TRACKING_LOGS': False,
     'ENABLE_LMS_MIGRATION': False,
@@ -328,6 +330,7 @@ TEMPLATE_LOADERS = (
 )
 
 MIDDLEWARE_CLASSES = (
+    'django_comment_client.middleware.AjaxExceptionMiddleware',
     'django.middleware.common.CommonMiddleware',
     'django.contrib.sessions.middleware.SessionMiddleware',
     'django.middleware.csrf.CsrfViewMiddleware',
@@ -350,6 +353,9 @@ MIDDLEWARE_CLASSES = (
     'askbot.middleware.spaceless.SpacelessMiddleware',
     # 'askbot.middleware.pagesize.QuestionsPageSizeMiddleware',
     # 'debug_toolbar.middleware.DebugToolbarMiddleware',
+
+    'django_comment_client.utils.ViewNameMiddleware',
+    'django_comment_client.utils.QueryCountDebugMiddleware',
 )
 
 ############################### Pipeline #######################################
@@ -571,6 +577,9 @@ INSTALLED_APPS = (
     # For testing
     'django_jasmine',
 
+    # Discussion
+    'django_comment_client',
+
     # For Askbot
     'django.contrib.sitemaps',
     'django.contrib.admin',

lms/envs/discussionsettings.py

+DISCUSSION_ALLOWED_UPLOAD_FILE_TYPES = ('.jpg', '.jpeg', '.gif', '.bmp', '.png', '.tiff')

lms/lib/comment_client/__init__.py

+from comment_client import *
+from utils import CommentClientError, CommentClientUnknownError

lms/lib/comment_client/comment.py

+from utils import *
+
+import models
+import settings
+
+class Comment(models.Model):
+
+    accessible_fields = [
+        'id', 'body', 'anonymous', 'course_id',
+        'endorsed', 'parent_id', 'thread_id',
+        'username', 'votes', 'user_id', 'closed',
+        'created_at', 'updated_at', 'depth',
+        'at_position_list', 'type',
+    ]
+
+    updatable_fields = [
+        'body', 'anonymous', 'course_id', 'closed',
+        'user_id', 'endorsed',
+    ]
+
+    initializable_fields = updatable_fields
+
+    base_url = "{prefix}/comments".format(prefix=settings.PREFIX)
+    type = 'comment'
+
+    @classmethod
+    def url_for_comments(cls, params={}):
+        if params.get('thread_id'):
+            return _url_for_thread_comments(params['thread_id'])
+        else:
+            return _url_for_comment(params['parent_id'])
+
+    @classmethod
+    def url(cls, action, params={}):
+        if action in ['post']:
+            return cls.url_for_comments(params)
+        else:
+            return super(Comment, cls).url(action, params)
+
+def _url_for_thread_comments(thread_id):
+    return "{prefix}/threads/{thread_id}/comments".format(prefix=settings.PREFIX, thread_id=thread_id)
+
+def _url_for_comment(comment_id):
+    return "{prefix}/comments/{comment_id}".format(prefix=settings.PREFIX, comment_id=comment_id)

lms/lib/comment_client/comment_client.py

+from comment import Comment
+from thread import Thread
+from user import User
+from commentable import Commentable
+
+from utils import *
+
+import settings
+
+def search_similar_threads(course_id, recursive=False, query_params={}, *args, **kwargs):
+    default_params = {'course_id': course_id, 'recursive': recursive}
+    attributes = dict(default_params.items() + query_params.items())
+    return perform_request('get', _url_for_search_similar_threads(), attributes, *args, **kwargs)
+
+def search_recent_active_threads(course_id, recursive=False, query_params={}, *args, **kwargs):
+    default_params = {'course_id': course_id, 'recursive': recursive}
+    attributes = dict(default_params.items() + query_params.items())
+    return perform_request('get', _url_for_search_recent_active_threads(), attributes, *args, **kwargs)
+
+def search_trending_tags(course_id, query_params={}, *args, **kwargs):
+    default_params = {'course_id': course_id}
+    attributes = dict(default_params.items() + query_params.items())
+    return perform_request('get', _url_for_search_trending_tags(), attributes, *args, **kwargs)
+
+def tags_autocomplete(value, *args, **kwargs):
+    return perform_request('get', _url_for_threads_tags_autocomplete(), {'value': value}, *args, **kwargs)
+
+def _url_for_search_similar_threads():
+    return "{prefix}/search/threads/more_like_this".format(prefix=settings.PREFIX)
+
+def _url_for_search_recent_active_threads():
+    return "{prefix}/search/threads/recent_active".format(prefix=settings.PREFIX)
+
+def _url_for_search_trending_tags():
+    return "{prefix}/search/tags/trending".format(prefix=settings.PREFIX)
+
+def _url_for_threads_tags_autocomplete():
+    return "{prefix}/threads/tags/autocomplete".format(prefix=settings.PREFIX)

lms/lib/comment_client/commentable.py

+from utils import *
+
+import models
+import settings
+
+class Commentable(models.Model):
+
+    base_url = "{prefix}/commentables".format(prefix=settings.PREFIX)
+    type = 'commentable'

lms/lib/comment_client/legacy.py

+def delete_threads(commentable_id, *args, **kwargs):
+    return _perform_request('delete', _url_for_commentable_threads(commentable_id), *args, **kwargs)
+
+def get_threads(commentable_id, recursive=False, query_params={}, *args, **kwargs):
+    default_params = {'page': 1, 'per_page': 20, 'recursive': recursive}
+    attributes = dict(default_params.items() + query_params.items())
+    response = _perform_request('get', _url_for_threads(commentable_id), \
+            attributes, *args, **kwargs)
+    return response.get('collection', []), response.get('page', 1), response.get('num_pages', 1)
+
+def search_threads(course_id, recursive=False, query_params={}, *args, **kwargs):
+    default_params = {'page': 1, 'per_page': 20, 'course_id': course_id, 'recursive': recursive}
+    attributes = dict(default_params.items() + query_params.items())
+    response = _perform_request('get', _url_for_search_threads(), \
+            attributes, *args, **kwargs)
+    return response.get('collection', []), response.get('page', 1), response.get('num_pages', 1)
+
+def search_similar_threads(course_id, recursive=False, query_params={}, *args, **kwargs):
+    default_params = {'course_id': course_id, 'recursive': recursive}
+    attributes = dict(default_params.items() + query_params.items())
+    return _perform_request('get', _url_for_search_similar_threads(), attributes, *args, **kwargs)
+
+def search_recent_active_threads(course_id, recursive=False, query_params={}, *args, **kwargs):
+    default_params = {'course_id': course_id, 'recursive': recursive}
+    attributes = dict(default_params.items() + query_params.items())
+    return _perform_request('get', _url_for_search_recent_active_threads(), attributes, *args, **kwargs)
+
+def search_trending_tags(course_id, query_params={}, *args, **kwargs):
+    default_params = {'course_id': course_id}
+    attributes = dict(default_params.items() + query_params.items())
+    return _perform_request('get', _url_for_search_trending_tags(), attributes, *args, **kwargs)
+
+def create_user(attributes, *args, **kwargs):
+    return _perform_request('post', _url_for_users(), attributes, *args, **kwargs)
+
+def update_user(user_id, attributes, *args, **kwargs):
+    return _perform_request('put', _url_for_user(user_id), attributes, *args, **kwargs)
+
+def get_threads_tags(*args, **kwargs):
+    return _perform_request('get', _url_for_threads_tags(), {}, *args, **kwargs)
+
+def tags_autocomplete(value, *args, **kwargs):
+    return _perform_request('get', _url_for_threads_tags_autocomplete(), {'value': value}, *args, **kwargs)
+
+def create_thread(commentable_id, attributes, *args, **kwargs):
+    return _perform_request('post', _url_for_threads(commentable_id), attributes, *args, **kwargs)
+    
+def get_thread(thread_id, recursive=False, *args, **kwargs):
+    return _perform_request('get', _url_for_thread(thread_id), {'recursive': recursive}, *args, **kwargs)
+
+def update_thread(thread_id, attributes, *args, **kwargs):
+    return _perform_request('put', _url_for_thread(thread_id), attributes, *args, **kwargs)
+
+def create_comment(thread_id, attributes, *args, **kwargs):
+    return _perform_request('post', _url_for_thread_comments(thread_id), attributes, *args, **kwargs)
+
+def delete_thread(thread_id, *args, **kwargs):
+    return _perform_request('delete', _url_for_thread(thread_id), *args, **kwargs)
+
+def get_comment(comment_id, recursive=False, *args, **kwargs):
+    return _perform_request('get', _url_for_comment(comment_id), {'recursive': recursive}, *args, **kwargs)
+
+def update_comment(comment_id, attributes, *args, **kwargs):
+    return _perform_request('put', _url_for_comment(comment_id), attributes, *args, **kwargs)
+
+def create_sub_comment(comment_id, attributes, *args, **kwargs):
+    return _perform_request('post', _url_for_comment(comment_id), attributes, *args, **kwargs)
+
+def delete_comment(comment_id, *args, **kwargs):
+    return _perform_request('delete', _url_for_comment(comment_id), *args, **kwargs)
+
+def vote_for_comment(comment_id, user_id, value, *args, **kwargs):
+    return _perform_request('put', _url_for_vote_comment(comment_id), {'user_id': user_id, 'value': value}, *args, **kwargs)
+
+def undo_vote_for_comment(comment_id, user_id, *args, **kwargs):
+    return _perform_request('delete', _url_for_vote_comment(comment_id), {'user_id': user_id}, *args, **kwargs)
+
+def vote_for_thread(thread_id, user_id, value, *args, **kwargs):
+    return _perform_request('put', _url_for_vote_thread(thread_id), {'user_id': user_id, 'value': value}, *args, **kwargs)
+
+def undo_vote_for_thread(thread_id, user_id, *args, **kwargs):
+    return _perform_request('delete', _url_for_vote_thread(thread_id), {'user_id': user_id}, *args, **kwargs)
+
+def get_notifications(user_id, *args, **kwargs):
+    return _perform_request('get', _url_for_notifications(user_id), *args, **kwargs)
+
+def get_user_info(user_id, complete=True, *args, **kwargs):
+    return _perform_request('get', _url_for_user(user_id), {'complete': complete}, *args, **kwargs)
+
+def subscribe(user_id, subscription_detail, *args, **kwargs):
+    return _perform_request('post', _url_for_subscription(user_id), subscription_detail, *args, **kwargs)
+
+def subscribe_user(user_id, followed_user_id, *args, **kwargs):
+    return subscribe(user_id, {'source_type': 'user', 'source_id': followed_user_id})
+
+follow = subscribe_user
+
+def subscribe_thread(user_id, thread_id, *args, **kwargs):
+    return subscribe(user_id, {'source_type': 'thread', 'source_id': thread_id})
+
+def subscribe_commentable(user_id, commentable_id, *args, **kwargs):
+    return subscribe(user_id, {'source_type': 'other', 'source_id': commentable_id})
+
+def unsubscribe(user_id, subscription_detail, *args, **kwargs):
+    return _perform_request('delete', _url_for_subscription(user_id), subscription_detail, *args, **kwargs)
+
+def unsubscribe_user(user_id, followed_user_id, *args, **kwargs):
+    return unsubscribe(user_id, {'source_type': 'user', 'source_id': followed_user_id})
+
+unfollow = unsubscribe_user
+
+def unsubscribe_thread(user_id, thread_id, *args, **kwargs):
+    return unsubscribe(user_id, {'source_type': 'thread', 'source_id': thread_id})
+
+def unsubscribe_commentable(user_id, commentable_id, *args, **kwargs):
+    return unsubscribe(user_id, {'source_type': 'other', 'source_id': commentable_id})
+
+def _perform_request(method, url, data_or_params=None, *args, **kwargs):
+    if method in ['post', 'put', 'patch']:
+        response = requests.request(method, url, data=data_or_params)
+    else:
+        response = requests.request(method, url, params=data_or_params)
+    if 200 < response.status_code < 500:
+        raise CommentClientError(response.text)
+    elif response.status_code == 500:
+        raise CommentClientUnknownError(response.text)
+    else:
+        if kwargs.get("raw", False):
+            return response.text
+        else:
+            return json.loads(response.text)
+
+def _url_for_threads(commentable_id):
+    return "{prefix}/{commentable_id}/threads".format(prefix=PREFIX, commentable_id=commentable_id)
+
+def _url_for_thread(thread_id):
+    return "{prefix}/threads/{thread_id}".format(prefix=PREFIX, thread_id=thread_id)
+
+def _url_for_thread_comments(thread_id):
+    return "{prefix}/threads/{thread_id}/comments".format(prefix=PREFIX, thread_id=thread_id)
+
+def _url_for_comment(comment_id):
+    return "{prefix}/comments/{comment_id}".format(prefix=PREFIX, comment_id=comment_id)
+
+def _url_for_vote_comment(comment_id):
+    return "{prefix}/comments/{comment_id}/votes".format(prefix=PREFIX, comment_id=comment_id)
+
+def _url_for_vote_thread(thread_id):
+    return "{prefix}/threads/{thread_id}/votes".format(prefix=PREFIX, thread_id=thread_id)
+
+def _url_for_notifications(user_id):
+    return "{prefix}/users/{user_id}/notifications".format(prefix=PREFIX, user_id=user_id)
+
+def _url_for_subscription(user_id):
+    return "{prefix}/users/{user_id}/subscriptions".format(prefix=PREFIX, user_id=user_id)
+
+def _url_for_user(user_id):
+    return "{prefix}/users/{user_id}".format(prefix=PREFIX, user_id=user_id)
+
+def _url_for_search_threads():
+    return "{prefix}/search/threads".format(prefix=PREFIX)
+
+def _url_for_search_similar_threads():
+    return "{prefix}/search/threads/more_like_this".format(prefix=PREFIX)
+
+def _url_for_search_recent_active_threads():
+    return "{prefix}/search/threads/recent_active".format(prefix=PREFIX)
+
+def _url_for_search_trending_tags():
+    return "{prefix}/search/tags/trending".format(prefix=PREFIX)
+
+def _url_for_threads_tags():
+    return "{prefix}/threads/tags".format(prefix=PREFIX)
+
+def _url_for_threads_tags_autocomplete():
+    return "{prefix}/threads/tags/autocomplete".format(prefix=PREFIX)
+
+def _url_for_users():
+    return "{prefix}/users".format(prefix=PREFIX)
+

lms/lib/comment_client/models.py

+from utils import *
+
+class Model(object):
+
+    accessible_fields = ['id']
+    updatable_fields = ['id']
+    initializable_fields = ['id']
+    base_url = None
+    default_retrieve_params = {}
+
+    DEFAULT_ACTIONS_WITH_ID = ['get', 'put', 'delete']
+    DEFAULT_ACTIONS_WITHOUT_ID = ['get_all', 'post']
+    DEFAULT_ACTIONS = DEFAULT_ACTIONS_WITH_ID + DEFAULT_ACTIONS_WITHOUT_ID
+
+    def __init__(self, *args, **kwargs):
+        self.attributes = extract(kwargs, self.accessible_fields)
+        self.retrieved = False
+
+    def __getattr__(self, name):
+        if name == 'id':
+            return self.attributes.get('id', None)
+        try:
+            return self.attributes[name]
+        except KeyError:
+            if self.retrieved or self.id == None:
+                raise AttributeError("Field {0} does not exist".format(name))
+            self.retrieve()
+            return self.__getattr__(name)
+    
+    def __setattr__(self, name, value):
+        if name == 'attributes' or name not in self.accessible_fields:
+            super(Model, self).__setattr__(name, value)
+        else:
+            self.attributes[name] = value
+
+    def __getitem__(self, key):
+        if key not in self.accessible_fields:
+            raise KeyError("Field {0} does not exist".format(key))
+        return self.attributes.get(key)
+
+    def __setitem__(self, key, value):
+        if key not in self.accessible_fields:
+            raise KeyError("Field {0} does not exist".format(key))
+        self.attributes.__setitem__(key, value)
+
+    def get(self, *args, **kwargs):
+        return self.attributes.get(*args, **kwargs)
+
+    def to_dict(self):
+        self.retrieve()
+        return self.attributes
+
+    def retrieve(self, *args, **kwargs):
+        if not self.retrieved:
+            self._retrieve(*args, **kwargs)
+            self.retrieved = True
+        return self
+
+    def _retrieve(self, *args, **kwargs):
+        url = self.url(action='get', params=self.attributes)
+        response = perform_request('get', url, self.default_retrieve_params)
+        self.update_attributes(**response)
+
+    @classmethod
+    def find(cls, id):
+        return cls(id=id)
+
+    def update_attributes(self, *args, **kwargs):
+        for k, v in kwargs.items():
+            if k in self.accessible_fields:
+                self.__setattr__(k, v)
+            else:
+                raise AttributeError("Field {0} does not exist".format(k))
+
+    def updatable_attributes(self):
+        return extract(self.attributes, self.updatable_fields)
+
+    def initializable_attributes(self):
+        return extract(self.attributes, self.initializable_fields)
+        
+    @classmethod
+    def before_save(cls, instance):
+        pass
+
+    @classmethod
+    def after_save(cls, instance):
+        pass
+
+    def save(self):
+        self.__class__.before_save(self)
+        if self.id: # if we have id already, treat this as an update
+            url = self.url(action='put', params=self.attributes)
+            response = perform_request('put', url, self.updatable_attributes())
+        else: # otherwise, treat this as an insert
+            url = self.url(action='post', params=self.attributes)
+            response = perform_request('post', url, self.initializable_attributes())
+        self.retrieved = True
+        self.update_attributes(**response)
+        self.__class__.after_save(self)
+
+    def delete(self):
+        url = self.url(action='delete', params=self.attributes)
+        response = perform_request('delete', url)
+        self.retrieved = True
+        self.update_attributes(**response)
+
+    @classmethod
+    def url_with_id(cls, params={}):
+        return cls.base_url + '/' + str(params['id'])
+
+    @classmethod
+    def url_without_id(cls, params={}):
+        return cls.base_url
+
+    @classmethod
+    def url(cls, action, params={}):
+        if cls.base_url is None:
+            raise CommentClientError("Must provide base_url when using default url function")
+        if action not in cls.DEFAULT_ACTIONS:
+            raise ValueError("Invalid action {0}. The supported action must be in {1}".format(action, str(cls.DEFAULT_ACTIONS)))
+        elif action in cls.DEFAULT_ACTIONS_WITH_ID:
+            try:
+                return cls.url_with_id(params)
+            except KeyError:
+                raise CommentClientError("Cannot perform action {0} without id".format(action))
+        else: # action must be in DEFAULT_ACTIONS_WITHOUT_ID now
+            return cls.url_without_id()

lms/lib/comment_client/requirements.txt

+requests

lms/lib/comment_client/settings.py

+from django.conf import settings
+
+if hasattr(settings, "COMMENTS_SERVICE_URL"):
+    SERVICE_HOST = settings.COMMENTS_SERVICE_URL
+else:
+    SERVICE_HOST = 'http://localhost:4567'
+
+PREFIX = SERVICE_HOST + '/api/v1'

lms/lib/comment_client/thread.py

+from utils import *
+
+import models
+import settings
+
+class Thread(models.Model):
+
+    accessible_fields = [
+        'id', 'title', 'body', 'anonymous',
+        'course_id', 'closed', 'tags', 'votes',
+        'commentable_id', 'username', 'user_id',
+        'created_at', 'updated_at', 'comments_count',
+        'at_position_list', 'children', 'type',
+    ]
+
+    updatable_fields = [
+        'title', 'body', 'anonymous', 'course_id', 
+        'closed', 'tags', 'user_id', 'commentable_id',
+    ]
+
+    initializable_fields = updatable_fields
+
+    base_url = "{prefix}/threads".format(prefix=settings.PREFIX)
+    default_retrieve_params = {'recursive': False}
+    type = 'thread'
+
+    @classmethod
+    def search(cls, query_params, *args, **kwargs):
+        default_params = {'page': 1,
+                          'per_page': 20,
+                          'course_id': query_params['course_id'],
+                          'recursive': False}
+        params = merge_dict(default_params, strip_blank(strip_none(query_params)))
+        if query_params.get('text') or query_params.get('tags'):
+            url = cls.url(action='search')
+        else:
+            url = cls.url(action='get_all', params=extract(params, 'commentable_id'))
+            if params.get('commentable_id'):
+                del params['commentable_id']
+        response = perform_request('get', url, params, *args, **kwargs)
+        return response.get('collection', []), response.get('page', 1), response.get('num_pages', 1)
+        
+    @classmethod
+    def url_for_threads(cls, params={}):
+        if params.get('commentable_id'):
+            return "{prefix}/{commentable_id}/threads".format(prefix=settings.PREFIX, commentable_id=params['commentable_id'])
+        else:
+            return "{prefix}/threads".format(prefix=settings.PREFIX)
+
+    @classmethod
+    def url_for_search_threads(cls, params={}):
+        return "{prefix}/search/threads".format(prefix=settings.PREFIX)
+
+    @classmethod
+    def url(cls, action, params={}):
+        if action in ['get_all', 'post']:
+            return cls.url_for_threads(params)
+        elif action == 'search':
+            return cls.url_for_search_threads(params)
+        else:
+            return super(Thread, cls).url(action, params)
+
+    def _retrieve(self, *args, **kwargs):
+        url = self.url(action='get', params=self.attributes)
+        response = perform_request('get', url, {'recursive': kwargs.get('recursive')})
+        self.update_attributes(**response)

lms/lib/comment_client/user.py

+from utils import *
+
+import models
+import settings
+
+class User(models.Model):
+
+    accessible_fields = ['username', 'email', 'follower_ids', 'upvoted_ids', 'downvoted_ids',
+                         'id', 'external_id', 'subscribed_user_ids', 'children', 'course_id',
+                         'subscribed_thread_ids', 'subscribed_commentable_ids',
+                         'threads_count', 'comments_count',
+                        ]
+
+    updatable_fields = ['username', 'external_id', 'email']
+    initializable_fields = updatable_fields
+
+    base_url = "{prefix}/users".format(prefix=settings.PREFIX)
+    default_retrieve_params = {'complete': True}
+    type = 'user'
+
+    @classmethod
+    def from_django_user(cls, user):
+        return cls(id=str(user.id),
+                   external_id=str(user.id),
+                   username=user.username,
+                   email=user.email)
+
+    def follow(self, source):
+        params = {'source_type': source.type, 'source_id': source.id}
+        response = perform_request('post', _url_for_subscription(self.id), params)
+
+    def unfollow(self, source):
+        params = {'source_type': source.type, 'source_id': source.id}
+        response = perform_request('delete', _url_for_subscription(self.id), params)
+
+    def vote(self, voteable, value):
+        if voteable.type == 'thread':
+            url = _url_for_vote_thread(voteable.id)
+        elif voteable.type == 'comment':
+            url = _url_for_vote_comment(voteable.id)
+        else:
+            raise CommentClientError("Can only vote / unvote for threads or comments")
+        params = {'user_id': self.id, 'value': value}
+        request = perform_request('put', url, params)
+        voteable.update_attributes(request)
+
+    def unvote(self, voteable):
+        if voteable.type == 'thread':
+            url = _url_for_vote_thread(voteable.id)
+        elif voteable.type == 'comment':
+            url = _url_for_vote_comment(voteable.id)
+        else:
+            raise CommentClientError("Can only vote / unvote for threads or comments")
+        params = {'user_id': self.id}
+        request = perform_request('delete', url, params)
+        voteable.update_attributes(request)
+
+    def active_threads(self, query_params={}):
+        if not self.course_id:
+            raise CommentClientError("Must provide course_id when retrieving active threads for the user")
+        url = _url_for_user_active_threads(self.id)
+        params = {'course_id': self.course_id}
+        params = merge_dict(params, query_params)
+        response = perform_request('get', url, params)
+        return response.get('collection', []), response.get('page', 1), response.get('num_pages', 1)
+
+    def _retrieve(self, *args, **kwargs):
+        url = self.url(action='get', params=self.attributes)
+        retrieve_params = self.default_retrieve_params
+        if self.attributes.get('course_id'):
+            retrieve_params['course_id'] = self.course_id
+        response = perform_request('get', url, retrieve_params)
+        self.update_attributes(**response)
+
+def _url_for_vote_comment(comment_id):
+    return "{prefix}/comments/{comment_id}/votes".format(prefix=settings.PREFIX, comment_id=comment_id)
+
+def _url_for_vote_thread(thread_id):
+    return "{prefix}/threads/{thread_id}/votes".format(prefix=settings.PREFIX, thread_id=thread_id)
+
+def _url_for_subscription(user_id):
+    return "{prefix}/users/{user_id}/subscriptions".format(prefix=settings.PREFIX, user_id=user_id)
+
+def _url_for_user_active_threads(user_id):
+    return "{prefix}/users/{user_id}/active_threads".format(prefix=settings.PREFIX, user_id=user_id)

lms/lib/comment_client/utils.py

+import requests
+import json
+
+def strip_none(dic):
+    return dict([(k, v) for k, v in dic.iteritems() if v is not None])
+
+def strip_blank(dic):
+    def _is_blank(v):
+        return isinstance(v, str) and len(v.strip()) == 0
+    return dict([(k, v) for k, v in dic.iteritems() if not _is_blank(v)])
+
+def extract(dic, keys):
+    if isinstance(keys, str):
+        return strip_none({keys: dic.get(keys)})
+    else:
+        return strip_none({k: dic.get(k) for k in keys})
+
+def merge_dict(dic1, dic2):
+    return dict(dic1.items() + dic2.items())
+    
+def perform_request(method, url, data_or_params=None, *args, **kwargs):
+    if method in ['post', 'put', 'patch']:
+        response = requests.request(method, url, data=data_or_params)
+    else:
+        response = requests.request(method, url, params=data_or_params)
+    if 200 < response.status_code < 500:
+        raise CommentClientError(response.text)
+    elif response.status_code == 500:
+        raise CommentClientUnknownError(response.text)
+    else:
+        if kwargs.get("raw", False):
+            return response.text
+        else:
+            return json.loads(response.text)
+
+class CommentClientError(Exception):
+    def __init__(self, msg):
+        self.message = msg
+
+    def __str__(self):
+        return repr(self.message)
+
+class CommentClientUnknownError(CommentClientError):
+    pass

lms/lib/dogfood/views.py

@@ -24,7 +24,6 @@ from mitxmako.shortcuts import render_to_response, render_to_string
 import track.views
 from lxml import etree
 
-
 from courseware.module_render import make_track_function, ModuleSystem, get_module
 from courseware.models import StudentModule
 from multicourse import multicourse_settings

lms/static/coffee/src/customwmd.coffee

+# Mostly adapted from math.stackexchange.com: http://cdn.sstatic.net/js/mathjax-editing-new.js
+
+$ ->
+
+  if not MathJax?
+    return
+
+  HUB = MathJax.Hub
+
+  class MathJaxProcessor
+
+    MATHSPLIT = /// (
+      \$\$?                          # normal inline or display delimiter
+      | \\(?:begin|end)\{[a-z]*\*?\} # \begin{} \end{} style
+      | \\[\\{}$]
+      | [{}]
+      | (?:\n\s*)+                   # only treat as math when there's single new line
+      | @@\d+@@                      # delimiter similar to the one used internally
+    ) ///i
+
+    CODESPAN = ///
+      (^|[^\\])       # match beginning or any previous character other than escape delimiter ('/')
+      (`+)            # code span starts
+      ([^\n]*?[^`\n]) # code content
+      \2              # code span ends
+      (?!`)
+    ///gm
+
+    constructor: (inlineMark, displayMark) ->
+      @inlineMark = inlineMark || "$"
+      @displayMark = displayMark || "$$"
+      @math = null
+      @blocks = null
+
+    processMath: (start, last, preProcess) ->
+      block = @blocks.slice(start, last + 1).join("").replace(/&/g, "&")
+                                                    .replace(/</g, "&lt;")
+                                                    .replace(/>/g, "&gt;")
+      if HUB.Browser.isMSIE
+        block = block.replace /(%[^\n]*)\n/g, "$1<br/>\n"
+      @blocks[i] = "" for i in [start+1..last]
+      @blocks[start] = "@@#{@math.length}@@"
+      block = preProcess(block) if preProcess
+      @math.push block
+
+    removeMath: (text) ->
+
+      @math = []
+      start = end = last = null
+      braces = 0
+
+      hasCodeSpans = /`/.test text
+      if hasCodeSpans
+        text = text.replace(/~/g, "~T").replace CODESPAN, ($0) -> # replace dollar sign in code span temporarily
+          $0.replace /\$/g, "~D"
+        deTilde = (text) ->
+          text.replace /~([TD])/g, ($0, $1) ->
+            {T: "~", D: "$"}[$1]
+      else
+        deTilde = (text) -> text
+
+      @blocks = _split(text.replace(/\r\n?/g, "\n"), MATHSPLIT)
+
+      for current in [1...@blocks.length] by 2
+        block = @blocks[current]
+        if block.charAt(0) == "@"
+          @blocks[current] = "@@#{@math.length}@@"
+          @math.push block
+        else if start
+          if block == end
+            if braces
+              last = current
+            else
+              @processMath(start, current, deTilde)
+              start = end = last = null
+          else if block.match /\n.*\n/
+            if last
+              current = last
+              @processMath(start, current, deTilde)
+            start = end = last = null
+            braces = 0
+          else if block == "{"
+            ++braces
+          else if block == "}" and braces
+            --braces
+        else
+          if block == @inlineMark or block == @displayMark
+            start = current
+            end = block
+            braces = 0
+          else if block.substr(1, 5) == "begin"
+            start = current
+            end = "\\end" + block.substr(6)
+            braces = 0
+
+      if last
+        @processMath(start, last, deTilde)
+        start = end = last = null
+
+      deTilde(@blocks.join(""))
+
+    @removeMathWrapper: (_this) ->
+      (text) -> _this.removeMath(text)
+
+    replaceMath: (text) ->
+      text = text.replace /@@(\d+)@@/g, ($0, $1) => @math[$1]
+      @math = null
+      text
+
+    @replaceMathWrapper: (_this) ->
+      (text) -> _this.replaceMath(text)
+
+  if Markdown?
+    
+    Markdown.getMathCompatibleConverter = (postProcessor) ->
+      postProcessor ||= ((text) -> text)
+      converter = Markdown.getSanitizingConverter()
+      processor = new MathJaxProcessor()
+      converter.hooks.chain "preConversion", MathJaxProcessor.removeMathWrapper(processor)
+      converter.hooks.chain "postConversion", (text) ->
+        postProcessor(MathJaxProcessor.replaceMathWrapper(processor)(text))
+      converter
+
+    Markdown.makeWmdEditor = (elem, appended_id, imageUploadUrl, postProcessor) ->
+      $elem = $(elem)
+
+      if not $elem.length
+        console.log "warning: elem for makeWmdEditor doesn't exist"
+        return
+
+      if not $elem.find(".wmd-panel").length
+        initialText = $elem.html()
+        $elem.empty()
+        _append = appended_id || ""
+        $wmdPanel = $("<div>").addClass("wmd-panel")
+                   .append($("<div>").attr("id", "wmd-button-bar#{_append}"))
+                   .append($("<textarea>").addClass("wmd-input").attr("id", "wmd-input#{_append}").html(initialText))
+                   .append($("<div>").attr("id", "wmd-preview#{_append}").addClass("wmd-panel wmd-preview"))
+        $elem.append($wmdPanel)
+
+      converter = Markdown.getMathCompatibleConverter(postProcessor)
+
+      ajaxFileUpload = (imageUploadUrl, input, startUploadHandler) ->
+        $("#loading").ajaxStart(-> $(this).show()).ajaxComplete(-> $(this).hide())
+        $("#upload").ajaxStart(-> $(this).hide()).ajaxComplete(-> $(this).show())
+        $.ajaxFileUpload
+          url: imageUploadUrl
+          secureuri: false
+          fileElementId: 'file-upload'
+          dataType: 'json'
+          success: (data, status) ->
+            fileURL = data['result']['file_url']
+            error = data['result']['error']
+            if error != ''
+              alert error
+              if startUploadHandler
+                $('#file-upload').unbind('change').change(startUploadHandler)
+              console.log error
+            else
+              $(input).attr('value', fileURL)
+          error: (data, status, e) ->
+            alert(e)
+            if startUploadHandler
+              $('#file-upload').unbind('change').change(startUploadHandler)
+              
+      imageUploadHandler = (elem, input) ->
+        ajaxFileUpload(imageUploadUrl, input, imageUploadHandler)
+
+      editor = new Markdown.Editor(
+        converter,
+        appended_id, # idPostfix
+        null, # help handler
+        imageUploadHandler
+      )
+      delayRenderer = new MathJaxDelayRenderer()
+      editor.hooks.chain "onPreviewPush", (text, previewSet) ->
+        delayRenderer.render
+          text: text
+          previewSetter: previewSet
+      editor.run()
+      editor

lms/static/coffee/src/discussion/discussion.coffee

+if not @Discussion?
+  @Discussion = {}
+
+Discussion = @Discussion
+
+initializeFollowDiscussion = (discussion) ->
+  $discussion = $(discussion)
+  id = $following.attr("_id")
+  $local = Discussion.generateLocal()
+  $discussion.children(".discussion-non-content")
+             .find(".discussion-title-wrapper")
+             .append(Discussion.subscriptionLink('discussion', id))
+
+@Discussion = $.extend @Discussion,
+
+  initializeDiscussion: (discussion) ->
+    $discussion = $(discussion)
+    $discussion.find(".thread").each (index, thread) ->
+      Discussion.initializeContent(thread)
+      Discussion.bindContentEvents(thread)
+    $discussion.find(".comment").each (index, comment) ->
+      Discussion.initializeContent(comment)
+      Discussion.bindContentEvents(comment)
+
+    #initializeFollowDiscussion(discussion) TODO move this somewhere else
+
+  bindDiscussionEvents: (discussion) ->
+
+    $discussion = $(discussion)
+    $discussionNonContent = $discussion.children(".discussion-non-content")
+    $local = Discussion.generateLocal($discussion.children(".discussion-local"))
+
+    id = $discussion.attr("_id")
+
+    handleSubmitNewPost = (elem) ->
+      title = $local(".new-post-title").val()
+      body = Discussion.getWmdContent $discussion, $local, "new-post-body"
+      tags = $local(".new-post-tags").val()
+      url = Discussion.urlFor('create_thread', id)
+      Discussion.safeAjax
+        $elem: $(elem)
+        url: url
+        type: "POST"
+        dataType: 'json'
+        data:
+          title: title
+          body: body
+          tags: tags
+        error: Discussion.formErrorHandler($local(".new-post-form-errors"))
+        success: (response, textStatus) ->
+          Discussion.clearFormErrors($local(".new-post-form-errors"))
+          $thread = $(response.html)
+          $discussion.children(".threads").prepend($thread)
+          $local(".new-post-title").val("")
+          Discussion.setWmdContent $discussion, $local, "new-post-body", ""
+          $local(".new-post-tags").val("")
+          if $discussion.hasClass("inline-discussion")
+            $local(".new-post-form").addClass("collapsed")
+          else if $discussion.hasClass("forum-discussion")
+            $local(".new-post-form").hide()
+
+    handleCancelNewPost = (elem) ->
+      if $discussion.hasClass("inline-discussion")
+        $local(".new-post-form").addClass("collapsed")
+      else if $discussion.hasClass("forum-discussion")
+        $local(".new-post-form").hide()
+
+    handleSimilarPost = (elem) ->
+      $title = $local(".new-post-title")
+      $wrapper = $local(".new-post-similar-posts-wrapper")
+      $similarPosts = $local(".new-post-similar-posts")
+      prevText = $title.attr("prev-text")
+      text = $title.val()
+      if text == prevText
+        if $local(".similar-post").length
+          $wrapper.show()
+      else if $.trim(text).length
+        Discussion.safeAjax
+          $elem: $(elem)
+          url: Discussion.urlFor 'search_similar_threads', id
+          type: "GET"
+          dateType: 'json'
+          data:
+            text: $local(".new-post-title").val()
+          success: (response, textStatus) ->
+            $similarPosts.empty()
+            console.log response
+            if $.type(response) == "array" and response.length
+              $wrapper.show()
+              for thread in response
+                #singleThreadUrl = Discussion.urlFor 'retrieve_single_thread 
+                $similarPost = $("<a>").addClass("similar-post")
+                                       .html(thread["title"])
+                                       .attr("href", "javascript:void(0)") #TODO
+                                       .appendTo($similarPosts)
+            else
+              $wrapper.hide()
+      else
+        $wrapper.hide()
+      $title.attr("prev-text", text)
+
+    initializeNewPost = ->
+      view = { discussion_id: id }
+      $discussionNonContent = $discussion.children(".discussion-non-content")
+
+      if not $local(".wmd-panel").length
+        $discussionNonContent.append Mustache.render Discussion.newPostTemplate, view
+        $newPostBody = $local(".new-post-body")
+        Discussion.makeWmdEditor $discussion, $local, "new-post-body"
+
+        $input = Discussion.getWmdInput($discussion, $local, "new-post-body")
+        $input.attr("placeholder", "post a new topic...")
+        if $discussion.hasClass("inline-discussion")
+          $input.bind 'focus', (e) ->
+            $local(".new-post-form").removeClass('collapsed')
+        else if $discussion.hasClass("forum-discussion")
+          $local(".new-post-form").removeClass('collapsed')
+
+        $local(".new-post-tags").tagsInput Discussion.tagsInputOptions()
+
+        $local(".new-post-title").blur ->
+          handleSimilarPost(this)
+
+        $local(".hide-similar-posts").click ->
+          $local(".new-post-similar-posts-wrapper").hide()
+
+        $local(".discussion-submit-post").click ->
+          handleSubmitNewPost(this)
+        $local(".discussion-cancel-post").click ->
+          handleCancelNewPost(this)
+
+      $local(".new-post-form").show()
+
+    handleAjaxReloadDiscussion = (elem, url) ->
+      if not url then return
+      $elem = $(elem)
+      $discussion = $elem.parents("section.discussion")
+      Discussion.safeAjax
+        $elem: $elem
+        url: url
+        type: "GET"
+        dataType: 'html'
+        success: (data, textStatus) ->
+          $data = $(data)
+          $parent = $discussion.parent()
+          $discussion.replaceWith($data)
+          $discussion = $parent.children(".discussion")
+          Discussion.initializeDiscussion($discussion)
+          Discussion.bindDiscussionEvents($discussion)
+
+    handleAjaxSearch = (elem) ->
+      $elem = $(elem)
+      url = URI($elem.attr("action")).addSearch({text: $local(".search-input").val()})
+      handleAjaxReloadDiscussion($elem, url)
+
+    handleAjaxSort = (elem) ->
+      $elem = $(elem)
+      url = $elem.attr("sort-url")
+      handleAjaxReloadDiscussion($elem, url)
+
+    handleAjaxPage = (elem) ->
+      $elem = $(elem)
+      url = $elem.attr("page-url")
+      handleAjaxReloadDiscussion($elem, url)
+
+    if $discussion.hasClass("inline-discussion")
+      initializeNewPost()
+
+    if $discussion.hasClass("forum-discussion")
+      $discussionSidebar = $(".discussion-sidebar")
+      if $discussionSidebar.length
+        $sidebarLocal = Discussion.generateLocal($discussionSidebar)
+        Discussion.bindLocalEvents $sidebarLocal,
+          "click .sidebar-new-post-button": (event) ->
+            initializeNewPost()
+
+    Discussion.bindLocalEvents $local,
+
+      "submit .search-wrapper>.discussion-search-form": (event) ->
+        event.preventDefault()
+        handleAjaxSearch(this)
+
+      "click .discussion-search-link": ->
+        handleAjaxSearch($local(".search-wrapper>.discussion-search-form"))
+
+      "click .discussion-sort-link": ->
+        handleAjaxSort(this)
+
+    $discussion.children(".discussion-paginator").find(".discussion-page-link").unbind('click').click ->
+      handleAjaxPage(this)

lms/static/coffee/src/discussion/discussion_module.coffee

+if not @Discussion?
+  @Discussion = {}
+
+Discussion = @Discussion
+
+@Discussion = $.extend @Discussion,
+  initializeDiscussionModule: (elem) ->
+    $discussionModule = $(elem)
+    $local = Discussion.generateLocal($discussionModule)
+    handleShowDiscussion = (elem) ->
+      $elem = $(elem)
+      if not $local("section.discussion").length
+        discussion_id = $elem.attr("discussion_id")
+        url = Discussion.urlFor 'retrieve_discussion', discussion_id
+        Discussion.safeAjax
+          $elem: $elem
+          url: url
+          type: "GET"
+          success: (data, textStatus, xhr) ->
+            $discussionModule.append(data)
+            discussion = $local("section.discussion")
+            Discussion.initializeDiscussion(discussion)
+            Discussion.bindDiscussionEvents(discussion)
+            $elem.html("Hide Discussion")
+            $elem.unbind('click').click ->
+              handleHideDiscussion(this)
+          dataType: 'html'
+      else
+        $local("section.discussion").show()
+        $elem.html("Hide Discussion")
+        $elem.unbind('click').click ->
+          handleHideDiscussion(this)
+
+    handleHideDiscussion = (elem) ->
+      $local("section.discussion").hide()
+      $elem = $(elem)
+      $elem.html("Show Discussion")
+      $elem.unbind('click').click ->
+        handleShowDiscussion(this)
+
+    $local(".discussion-show").click ->
+      handleShowDiscussion(this)

lms/static/coffee/src/discussion/main.coffee

+$ ->
+
+  toggle = ->
+    $('.course-wrapper').toggleClass('closed')
+
+  Discussion = window.Discussion
+  if $('#accordion').length
+    active = $('#accordion ul:has(li.active)').index('#accordion ul')
+    $('#accordion').bind('accordionchange', @log).accordion
+      active: if active >= 0 then active else 1
+      header: 'h3'
+      autoHeight: false
+    $('#open_close_accordion a').click toggle
+    $('#accordion').show()
+
+  $(".discussion-module").each (index, elem) ->
+    Discussion.initializeDiscussionModule(elem)
+
+  $("section.discussion").each (index, discussion) ->
+    Discussion.initializeDiscussion(discussion)
+    Discussion.bindDiscussionEvents(discussion)
+
+  Discussion.initializeUserProfile($(".discussion-sidebar>.user-profile"))

lms/static/coffee/src/discussion/templates.coffee

+if not @Discussion?
+  @Discussion = {}
+
+Discussion = @Discussion
+
+
+@Discussion = $.extend @Discussion,
+
+  newPostTemplate: """
+    <form class="new-post-form collapsed" id="new-post-form" style="display: block; ">
+      <ul class="new-post-form-errors discussion-errors"></ul>
+      <input type="text" class="new-post-title title-input" placeholder="Title" />
+      <div class="new-post-similar-posts-wrapper" style="display: none">
+        Similar Posts: 
+        <a class="hide-similar-posts" href="javascript:void(0)">Hide</a>
+        <div class="new-post-similar-posts"></div>
+      </div>
+      <div class="new-post-body reply-body"></div>
+      <input class="new-post-tags" placeholder="Tags" />
+      <div class="post-options">
+        <input type="checkbox" class="discussion-post-anonymously" id="discussion-post-anonymously-${discussion_id}">
+        <label for="discussion-post-anonymously-${discussion_id}">post anonymously</label>
+        <input type="checkbox" class="discussion-auto-watch" id="discussion-autowatch-${discussion_id}" checked="">
+        <label for="discussion-auto-watch-${discussion_id}">follow this thread</label>
+      </div>
+      <div class="new-post-control post-control">        
+        <a class="discussion-cancel-post" href="javascript:void(0)">Cancel</a>
+        <a class="discussion-submit-post control-button" href="javascript:void(0)">Submit</a>
+      </div>
+    </form>
+  """
+
+  replyTemplate: """
+    <form class="discussion-reply-new">
+      <ul class="discussion-errors"></ul>
+      <div class="reply-body"></div>
+      <input type="checkbox" class="discussion-post-anonymously" id="discussion-post-anonymously-{{id}}" />
+      <label for="discussion-post-anonymously-{{id}}">post anonymously</label>
+      {{#showWatchCheckbox}}
+      <input type="checkbox" class="discussion-auto-watch" id="discussion-autowatch-{{id}}" checked />
+      <label for="discussion-auto-watch-{{id}}">follow this thread</label>
+      {{/showWatchCheckbox}}
+      <br />
+      <div class = "reply-post-control">
+        <a class="discussion-cancel-post" href="javascript:void(0)">Cancel</a>
+        <a class="discussion-submit-post control-button" href="javascript:void(0)">Submit</a>
+      </div>
+    </form>
+  """
+
+  editThreadTemplate: """
+    <form class="discussion-content-edit discussion-thread-edit" _id="{{id}}">
+      <ul class="discussion-errors discussion-update-errors"></ul>    
+      <input type="text" class="thread-title-edit title-input" placeholder="Title" value="{{title}}"/>
+      <div class="thread-body-edit body-input">{{body}}</div>
+      <input class="thread-tags-edit" placeholder="Tags" value="{{tags}}" />
+      <div class = "edit-post-control">
+        <a class="discussion-cancel-update" href="javascript:void(0)">Cancel</a>
+        <a class="discussion-submit-update control-button" href="javascript:void(0)">Update</a>
+      </div>
+    </form>
+  """
+
+  editCommentTemplate: """
+    <form class="discussion-content-edit discussion-comment-edit" _id="{{id}}">
+      <ul class="discussion-errors discussion-update-errors"></ul>    
+      <div class="comment-body-edit body-input">{{body}}</div>
+      <div class = "edit-post-control">
+        <a class="discussion-cancel-update" href="javascript:void(0)">Cancel</a>
+        <a class="discussion-submit-update control-button" href="javascript:void(0)">Update</a>
+      </div>
+    </form>
+  """

lms/static/coffee/src/discussion/user_profile.coffee

+if not @Discussion?
+  @Discussion = {}
+
+Discussion = @Discussion
+
+@Discussion = $.extend @Discussion,
+  initializeUserProfile: ($userProfile) ->
+    $local = Discussion.generateLocal $userProfile
+
+    handleUpdateModeratorStatus = (elem, isModerator) ->
+      confirmValue = confirm("Are you sure?")
+      if not confirmValue then return
+      url = Discussion.urlFor('update_moderator_status', $$profiled_user_id)
+      Discussion.safeAjax
+        $elem: $(elem)
+        url: url
+        type: "POST"
+        dataType: 'json'
+        data:
+          is_moderator: isModerator
+        error: (response, textStatus, e) ->
+          console.log e
+        success: (response, textStatus) ->
+          parent = $userProfile.parent()
+          $userProfile.replaceWith(response.html)
+          Discussion.initializeUserProfile parent.children(".user-profile")
+
+    Discussion.bindLocalEvents $local,
+      "click .sidebar-revoke-moderator-button": (event) ->
+        handleUpdateModeratorStatus(this, false)
+      "click .sidebar-promote-moderator-button": (event) ->
+        handleUpdateModeratorStatus(this, true)
+
+  initializeUserActiveDiscussion: ($discussion) ->

lms/static/coffee/src/discussion/utils.coffee

+if not @Discussion?
+  @Discussion = {}
+
+Discussion = @Discussion
+
+wmdEditors = {}
+
+@Discussion = $.extend @Discussion,
+
+  generateLocal: (elem) ->
+    (selector) -> $(elem).find(selector)
+
+  generateDiscussionLink: (cls, txt, handler) ->
+    $("<a>").addClass("discussion-link")
+            .attr("href", "javascript:void(0)")
+            .addClass(cls).html(txt)
+            .click -> handler(this)
+    
+  urlFor: (name, param, param1, param2) ->
+    {
+      follow_discussion       : "/courses/#{$$course_id}/discussion/#{param}/follow"
+      unfollow_discussion     : "/courses/#{$$course_id}/discussion/#{param}/unfollow"
+      create_thread           : "/courses/#{$$course_id}/discussion/#{param}/threads/create"
+      search_similar_threads  : "/courses/#{$$course_id}/discussion/#{param}/threads/search_similar"
+      update_thread           : "/courses/#{$$course_id}/discussion/threads/#{param}/update"
+      create_comment          : "/courses/#{$$course_id}/discussion/threads/#{param}/reply"
+      delete_thread           : "/courses/#{$$course_id}/discussion/threads/#{param}/delete"
+      upvote_thread           : "/courses/#{$$course_id}/discussion/threads/#{param}/upvote"
+      downvote_thread         : "/courses/#{$$course_id}/discussion/threads/#{param}/downvote"
+      undo_vote_for_thread    : "/courses/#{$$course_id}/discussion/threads/#{param}/unvote"
+      follow_thread           : "/courses/#{$$course_id}/discussion/threads/#{param}/follow"
+      unfollow_thread         : "/courses/#{$$course_id}/discussion/threads/#{param}/unfollow"
+      update_comment          : "/courses/#{$$course_id}/discussion/comments/#{param}/update"
+      endorse_comment         : "/courses/#{$$course_id}/discussion/comments/#{param}/endorse"
+      create_sub_comment      : "/courses/#{$$course_id}/discussion/comments/#{param}/reply"
+      delete_comment          : "/courses/#{$$course_id}/discussion/comments/#{param}/delete"
+      upvote_comment          : "/courses/#{$$course_id}/discussion/comments/#{param}/upvote"
+      downvote_comment        : "/courses/#{$$course_id}/discussion/comments/#{param}/downvote"
+      undo_vote_for_comment   : "/courses/#{$$course_id}/discussion/comments/#{param}/unvote"
+      upload                  : "/courses/#{$$course_id}/discussion/upload"
+      search                  : "/courses/#{$$course_id}/discussion/forum/search"
+      tags_autocomplete       : "/courses/#{$$course_id}/discussion/threads/tags/autocomplete"
+      retrieve_discussion     : "/courses/#{$$course_id}/discussion/forum/#{param}/inline"
+      retrieve_single_thread  : "/courses/#{$$course_id}/discussion/forum/#{param}/threads/#{param1}"
+      update_moderator_status : "/courses/#{$$course_id}/discussion/users/#{param}/update_moderator_status"
+      openclose_thread        : "/courses/#{$$course_id}/discussion/threads/#{param}/close"
+      permanent_link_thread   : "/courses/#{$$course_id}/discussion/forum/#{param}/threads/#{param1}"
+      permanent_link_comment  : "/courses/#{$$course_id}/discussion/forum/#{param}/threads/#{param1}##{param2}"
+    }[name]
+
+  safeAjax: (params) ->
+    $elem = params.$elem
+    if $elem.attr("disabled")
+      return
+    $elem.attr("disabled", "disabled")
+    $.ajax(params).always ->
+      $elem.removeAttr("disabled")
+
+  handleAnchorAndReload: (response) ->
+    #window.location = window.location.pathname + "#" + response['id']
+    window.location.reload()
+
+  bindLocalEvents: ($local, eventsHandler) ->
+    for eventSelector, handler of eventsHandler
+      [event, selector] = eventSelector.split(' ')
+      $local(selector).unbind(event)[event] handler
+
+  tagsInputOptions: ->
+    autocomplete_url: Discussion.urlFor('tags_autocomplete')
+    autocomplete:
+      remoteDataType: 'json'
+    interactive: true
+    height: '30px'
+    width: '100%'
+    defaultText: "Tag your post: press enter after each tag"
+    removeWithBackspace: true
+
+  isSubscribed: (id, type) ->
+    $$user_info? and (
+      if type == "thread"
+        id in $$user_info.subscribed_thread_ids
+      else if type == "commentable" or type == "discussion"
+        id in $$user_info.subscribed_commentable_ids
+      else
+        id in $$user_info.subscribed_user_ids
+    )
+
+  isUpvoted: (id) ->
+    $$user_info? and (id in $$user_info.upvoted_ids)
+
+  isDownvoted: (id) ->
+    $$user_info? and (id in $$user_info.downvoted_ids)
+
+  formErrorHandler: (errorsField) ->
+    (xhr, textStatus, error) ->
+      response = JSON.parse(xhr.responseText)
+      if response.errors? and response.errors.length > 0
+        errorsField.empty()
+        for error in response.errors
+          errorsField.append($("<li>").addClass("new-post-form-error").html(error))
+
+  clearFormErrors: (errorsField) ->
+    errorsField.empty()
+    
+  postMathJaxProcessor: (text) ->
+    RE_INLINEMATH = /^\$([^\$]*)\$/g
+    RE_DISPLAYMATH = /^\$\$([^\$]*)\$\$/g
+    Discussion.processEachMathAndCode text, (s, type) ->
+      if type == 'display'
+        s.replace RE_DISPLAYMATH, ($0, $1) ->
+          "\\[" + $1 + "\\]"
+      else if type == 'inline'
+        s.replace RE_INLINEMATH, ($0, $1) ->
+          "\\(" + $1 + "\\)"
+      else
+        s
+
+  makeWmdEditor: ($content, $local, cls_identifier) ->
+    elem = $local(".#{cls_identifier}")
+    id = $content.attr("_id")
+    appended_id = "-#{cls_identifier}-#{id}"
+    imageUploadUrl = Discussion.urlFor('upload')
+    editor = Markdown.makeWmdEditor elem, appended_id, imageUploadUrl, Discussion.postMathJaxProcessor
+    wmdEditors["#{cls_identifier}-#{id}"] = editor
+    editor
+
+  getWmdEditor: ($content, $local, cls_identifier) ->
+    id = $content.attr("_id")
+    wmdEditors["#{cls_identifier}-#{id}"]
+
+  getWmdInput: ($content, $local, cls_identifier) ->
+    id = $content.attr("_id")
+    $local("#wmd-input-#{cls_identifier}-#{id}")
+
+  getWmdContent: ($content, $local, cls_identifier) ->
+    Discussion.getWmdInput($content, $local, cls_identifier).val()
+
+  setWmdContent: ($content, $local, cls_identifier, text) ->
+    Discussion.getWmdInput($content, $local, cls_identifier).val(text)
+    Discussion.getWmdEditor($content, $local, cls_identifier).refreshPreview()
+
+  getContentInfo: (id, attr) ->
+    if not window.$$annotated_content_info?
+      window.$$annotated_content_info = {}
+    (window.$$annotated_content_info[id] || {})[attr]
+
+  setContentInfo: (id, attr, value) ->
+    if not window.$$annotated_content_info?
+      window.$$annotated_content_info = {}
+    window.$$annotated_content_info[id] ||= {}
+    window.$$annotated_content_info[id][attr] = value
+
+  extendContentInfo: (id, newInfo) ->
+    if not window.$$annotated_content_info?
+      window.$$annotated_content_info = {}
+    window.$$annotated_content_info[id] = newInfo
+  bulkExtendContentInfo: (newInfos) ->
+    if not window.$$annotated_content_info?
+      window.$$annotated_content_info = {}
+    window.$$annotated_content_info = $.extend window.$$annotated_content_info, newInfos
+
+  subscriptionLink: (type, id) ->
+    followLink = ->
+      Discussion.generateDiscussionLink("discussion-follow-#{type}", "Follow", handleFollow)
+
+    unfollowLink = ->
+      Discussion.generateDiscussionLink("discussion-unfollow-#{type}", "Unfollow", handleUnfollow)
+
+    handleFollow = (elem) ->
+      Discussion.safeAjax
+        $elem: $(elem)
+        url: Discussion.urlFor("follow_#{type}", id)
+        type: "POST"
+        success: (response, textStatus) ->
+          if textStatus == "success"
+            $(elem).replaceWith unfollowLink()
+        dataType: 'json'
+
+    handleUnfollow = (elem) ->
+      Discussion.safeAjax
+        $elem: $(elem)
+        url: Discussion.urlFor("unfollow_#{type}", id)
+        type: "POST"
+        success: (response, textStatus) ->
+          if textStatus == "success"
+            $(elem).replaceWith followLink()
+        dataType: 'json'
+
+    if Discussion.isSubscribed(id, type)
+        unfollowLink()
+    else
+      followLink()
+    
+  processEachMathAndCode: (text, processor) ->
+  
+    codeArchive = []
+
+    RE_DISPLAYMATH = /^([^\$]*?)\$\$([^\$]*?)\$\$(.*)$/m
+    RE_INLINEMATH = /^([^\$]*?)\$([^\$]+?)\$(.*)$/m
+
+    ESCAPED_DOLLAR = '@@ESCAPED_D@@'
+    ESCAPED_BACKSLASH = '@@ESCAPED_B@@'
+
+    processedText = ""
+
+    $div = $("<div>").html(text)
+
+    $div.find("code").each (index, code) ->
+      codeArchive.push $(code).html()
+      $(code).html(codeArchive.length - 1)
+
+    text = $div.html()
+    text = text.replace /\\\$/g, ESCAPED_DOLLAR
+
+    while true
+      if RE_INLINEMATH.test(text)
+        text = text.replace RE_INLINEMATH, ($0, $1, $2, $3) ->
+          processedText += $1 + processor("$" + $2 + "$", 'inline')
+          $3
+      else if RE_DISPLAYMATH.test(text)
+        text = text.replace RE_DISPLAYMATH, ($0, $1, $2, $3) ->
+          processedText += $1 + processor("$$" + $2 + "$$", 'display')
+          $3
+      else
+        processedText += text
+        break
+
+    text = processedText
+    text = text.replace(new RegExp(ESCAPED_DOLLAR, 'g'), '\\$')
+
+    text = text.replace /\\\\\\\\/g, ESCAPED_BACKSLASH
+    text = text.replace /\\begin\{([a-z]*\*?)\}([\s\S]*?)\\end\{\1\}/img, ($0, $1, $2) ->
+      processor("\\begin{#{$1}}" + $2 + "\\end{#{$1}}")
+    text = text.replace(new RegExp(ESCAPED_BACKSLASH, 'g'), '\\\\\\\\')
+
+    $div = $("<div>").html(text)
+    cnt = 0
+    $div.find("code").each (index, code) ->
+      $(code).html(processor(codeArchive[cnt], 'code'))
+      cnt += 1
+
+    text = $div.html()
+
+    text

lms/static/coffee/src/mathjax_delay_renderer.coffee

+getTime = ->
+  new Date().getTime()
+
+class @MathJaxDelayRenderer
+
+  maxDelay: 3000
+  mathjaxRunning: false
+  elapsedTime: 0
+  mathjaxDelay: 0
+  mathjaxTimeout: undefined
+  bufferId = "mathjax_delay_buffer"
+  numBuffers = 0
+
+  constructor: (params) ->
+    params = params || {}
+    @maxDelay = params["maxDelay"] || @maxDelay
+    @bufferId = params["bufferId"] || (bufferId + numBuffers)
+    numBuffers += 1
+    @$buffer = $("<div>").attr("id", @bufferId).css("display", "none").appendTo($("body"))
+
+  # render: (params) ->
+  # params:
+  #   elem: jquery element to be rendered
+  #   text: text to be rendered & put into the element;
+  #     if blank, then just render the current text in the element
+  #   preprocessor: pre-process the text before rendering using MathJax
+  #     if text is blank, it will pre-process the html in the element
+  #   previewSetter: if provided, will pass text back to it instead of
+  #     directly setting the element
+
+  render: (params) ->
+
+    elem = params["element"]
+    previewSetter = params["previewSetter"]
+    text = params["text"]
+    if not text?
+      text = $(elem).html()
+    preprocessor = params["preprocessor"]
+
+    if params["delay"] == false
+      if preprocessor?
+        text = preprocessor(text)
+      $(elem).html(text)
+      MathJax.Hub.Queue ["Typeset", MathJax.Hub, $(elem).attr("id")]
+    else
+      if @mathjaxTimeout
+        window.clearTimeout(@mathjaxTimeout)
+        @mathjaxTimeout = undefined
+      delay = Math.min @elapsedTime + @mathjaxDelay, @maxDelay
+      
+      renderer = =>
+        if @mathjaxRunning
+          return
+        prevTime = getTime()
+        if preprocessor?
+          text = preprocessor(text)
+        @$buffer.html(text)
+        curTime = getTime()
+        @elapsedTime = curTime - prevTime
+        if MathJax
+          prevTime = getTime()
+          @mathjaxRunning = true
+          MathJax.Hub.Queue ["Typeset", MathJax.Hub, @$buffer.attr("id")], =>
+            @mathjaxRunning = false
+            curTime = getTime()
+            @mathjaxDelay = curTime - prevTime
+            if previewSetter
+              previewSetter($(@$buffer).html())
+            else
+              $(elem).html($(@$buffer).html())
+        else
+          @mathjaxDelay = 0
+      @mathjaxTimeout = window.setTimeout(renderer, delay)

lms/static/css/vendor/jquery.autocomplete.css

+.acInput {
+	width: 200px;
+}
+
+.acResults {
+	padding: 0px;
+	border: 1px solid WindowFrame;
+	background-color: Window;
+	overflow: hidden;
+}
+
+.acResults ul {
+	margin: 0px;
+	padding: 0px;
+	list-style-position: outside;
+	list-style: none;	
+}
+
+.acResults ul li {
+	margin: 0px;
+	padding: 2px 5px;
+	cursor: pointer;
+	display: block;
+	font: menu;
+	font-size: 12px;
+	overflow: hidden;
+}
+
+.acLoading {
+	background : url('indicator.gif') right center no-repeat;
+}
+
+.acSelect {
+	background-color: Highlight;
+	color: HighlightText;
+}

lms/static/css/vendor/jquery.tagsinput.css

+div.tagsinput { border:1px solid #CCC; background: #FFF; padding:5px; width:300px; height:100px; overflow-y: auto;}
+div.tagsinput span.tag { border: 1px solid #a5d24a; -moz-border-radius:2px; -webkit-border-radius:2px; display: block; float: left; padding: 5px; text-decoration:none; background: #cde69c; color: #638421; margin-right: 5px; margin-bottom:5px;font-family: helvetica;  font-size:13px;}
+div.tagsinput span.tag a { font-weight: bold; color: #82ad2b; text-decoration:none; font-size: 11px;  } 
+div.tagsinput input { width:80px; margin:0px; font-family: helvetica; font-size: 13px; border:1px solid transparent; padding:5px; background: transparent; color: #000; outline:0px;  margin-right:5px; margin-bottom:5px; }
+div.tagsinput div { display:block; float: left; } 
+.tags_clear { clear: both; width: 100%; height: 0px; }
+.not_valid {background: #FBD8DB !important; color: #90111A !important;}

lms/static/js/Markdown.Sanitizer.js

+(function () {
+    var output, Converter;
+    if (typeof exports === "object" && typeof require === "function") { // we're in a CommonJS (e.g. Node.js) module
+        output = exports;
+        Converter = require("./Markdown.Converter").Converter;
+    } else {
+        output = window.Markdown;
+        Converter = output.Converter;
+    }
+        
+    output.getSanitizingConverter = function () {
+        var converter = new Converter();
+        converter.hooks.chain("postConversion", sanitizeHtml);
+        converter.hooks.chain("postConversion", balanceTags);
+        return converter;
+    }
+
+    function sanitizeHtml(html) {
+        return html.replace(/<[^>]*>?/gi, sanitizeTag);
+    }
+
+    // (tags that can be opened/closed) | (tags that stand alone)
+    var basic_tag_whitelist = /^(<\/?(b|blockquote|code|del|dd|dl|dt|em|h1|h2|h3|i|kbd|li|ol|p|pre|s|sup|sub|strong|strike|ul)>|<(br|hr)\s?\/?>)$/i;
+    // <a href="url..." optional title>|</a>
+    var a_white = /^(<a\shref="((https?|ftp):\/\/|\/)[-A-Za-z0-9+&@#\/%?=~_|!:,.;\(\)]+"(\stitle="[^"<>]+")?\s?>|<\/a>)$/i;
+
+    // <img src="url..." optional width  optional height  optional alt  optional title
+    var img_white = /^(<img\ssrc="(https?:\/\/|\/)[-A-Za-z0-9+&@#\/%?=~_|!:,.;\(\)]+"(\swidth="\d{1,3}")?(\sheight="\d{1,3}")?(\salt="[^"<>]*")?(\stitle="[^"<>]*")?\s?\/?>)$/i;
+
+    function sanitizeTag(tag) {
+        if (tag.match(basic_tag_whitelist) || tag.match(a_white) || tag.match(img_white))
+            return tag;
+        else
+            return "";
+    }
+
+    /// <summary>
+    /// attempt to balance HTML tags in the html string
+    /// by removing any unmatched opening or closing tags
+    /// IMPORTANT: we *assume* HTML has *already* been 
+    /// sanitized and is safe/sane before balancing!
+    /// 
+    /// adapted from CODESNIPPET: A8591DBA-D1D3-11DE-947C-BA5556D89593
+    /// </summary>
+    function balanceTags(html) {
+
+        if (html == "")
+            return "";
+
+        var re = /<\/?\w+[^>]*(\s|$|>)/g;
+        // convert everything to lower case; this makes
+        // our case insensitive comparisons easier
+        var tags = html.toLowerCase().match(re);
+
+        // no HTML tags present? nothing to do; exit now
+        var tagcount = (tags || []).length;
+        if (tagcount == 0)
+            return html;
+
+        var tagname, tag;
+        var ignoredtags = "<p><img><br><li><hr>";
+        var match;
+        var tagpaired = [];
+        var tagremove = [];
+        var needsRemoval = false;
+
+        // loop through matched tags in forward order
+        for (var ctag = 0; ctag < tagcount; ctag++) {
+            tagname = tags[ctag].replace(/<\/?(\w+).*/, "$1");
+            // skip any already paired tags
+            // and skip tags in our ignore list; assume they're self-closed
+            if (tagpaired[ctag] || ignoredtags.search("<" + tagname + ">") > -1)
+                continue;
+
+            tag = tags[ctag];
+            match = -1;
+
+            if (!/^<\//.test(tag)) {
+                // this is an opening tag
+                // search forwards (next tags), look for closing tags
+                for (var ntag = ctag + 1; ntag < tagcount; ntag++) {
+                    if (!tagpaired[ntag] && tags[ntag] == "</" + tagname + ">") {
+                        match = ntag;
+                        break;
+                    }
+                }
+            }
+
+            if (match == -1)
+                needsRemoval = tagremove[ctag] = true; // mark for removal
+            else
+                tagpaired[match] = true; // mark paired
+        }
+
+        if (!needsRemoval)
+            return html;
+
+        // delete all orphaned tags from the string
+
+        var ctag = 0;
+        html = html.replace(re, function (match) {
+            var res = tagremove[ctag] ? "" : match;
+            ctag++;
+            return res;
+        });
+        return html;
+    }
+})();

lms/static/js/jquery.ajaxfileupload.js

+jQuery.extend({
+  handleError: function( s, xhr, status, e )    {
+// If a local callback was specified, fire it
+    if ( s.error ) {
+      s.error.call( s.context || s, xhr, status, e );
+    }
+
+    // Fire the global callback
+    if ( s.global ) {
+      (s.context ? jQuery(s.context) : jQuery.event).trigger( "ajaxError", [xhr, s, e] );
+    }
+  },
+    createUploadIframe: function(id, uri){
+        //create frame
+        var frameId = 'jUploadFrame' + id;           
+        if(window.ActiveXObject) {
+            var io = document.createElement('<iframe id="' + frameId + '" name="' + frameId + '" />');
+            if(typeof uri== 'boolean'){
+                io.src = 'javascript:false';
+            }
+            else if(typeof uri== 'string'){
+                io.src = uri;
+            }
+        }
+        else {
+            var io = document.createElement('iframe');
+            io.id = frameId;
+            io.name = frameId;
+        }
+        io.style.position = 'absolute';
+        io.style.top = '-1000px';
+        io.style.left = '-1000px';
+
+        document.body.appendChild(io);
+        return io;
+    },
+    createUploadForm: function(id, fileElementId)
+	{
+		//create form	
+		var formId = 'jUploadForm' + id;
+		var fileId = 'jUploadFile' + id;
+		var form = $('<form  action="" method="POST" name="' + formId + '" id="' + formId 
+            + '" enctype="multipart/form-data"></form>');	
+		var oldElement = $('#' + fileElementId);
+		var newElement = $(oldElement).clone();
+		$(oldElement).attr('id', fileId);
+		$(oldElement).before(newElement);
+		$(oldElement).appendTo(form);
+		//set attributes
+		$(form).css('position', 'absolute');
+		$(form).css('top', '-1200px');
+		$(form).css('left', '-1200px');
+		$(form).appendTo('body');		
+		return form;
+    },
+
+    ajaxFileUpload: function(s) {
+        // TODO introduce global settings, allowing the client to modify them for all requests, not only timeout		
+        s = jQuery.extend({}, jQuery.ajaxSettings, s);
+        var id = new Date().getTime()        
+		var form = jQuery.createUploadForm(id, s.fileElementId);
+		var io = jQuery.createUploadIframe(id, s.secureuri);
+		var frameId = 'jUploadFrame' + id;
+		var formId = 'jUploadForm' + id;		
+        // Watch for a new set of requests
+        if ( s.global && ! jQuery.active++ )
+		{
+			jQuery.event.trigger( "ajaxStart" );
+		}            
+        var requestDone = false;
+        // Create the request object
+        var xml = {}   
+        if ( s.global )
+            jQuery.event.trigger("ajaxSend", [xml, s]);
+        // Wait for a response to come back
+        var uploadCallback = function(isTimeout)
+		{			
+			var io = document.getElementById(frameId);
+            try {				
+				if(io.contentWindow){
+					 xml.responseText = io.contentWindow.document.body ? 
+                        io.contentWindow.document.body.innerText : null;
+                	 xml.responseXML = io.contentWindow.document.XMLDocument ? 
+                        io.contentWindow.document.XMLDocument : io.contentWindow.document;
+					 
+				}
+                else if(io.contentDocument)
+				{
+					xml.responseText = io.contentDocument.document.body ? 
+                        io.contentDocument.document.body.textContent || document.body.innerText : null;
+                	xml.responseXML = io.contentDocument.document.XMLDocument ? 
+                        io.contentDocument.document.XMLDocument : io.contentDocument.document;
+				}						
+            }
+            catch(e)
+			{
+				jQuery.handleError(s, xml, null, e);
+			}
+            if ( xml || isTimeout == "timeout") 
+			{				
+                requestDone = true;
+                var status;
+                try {
+                    status = isTimeout != "timeout" ? "success" : "error";
+                    // Make sure that the request was successful or notmodified
+                    if ( status != "error" )
+					{
+                        // process the data (runs the xml through httpData regardless of callback)
+                        var data = jQuery.uploadHttpData( xml, s.dataType );    
+                        // If a local callback was specified, fire it and pass it the data
+                        if ( s.success )
+                            s.success( data, status );
+    
+                        // Fire the global callback
+                        if( s.global )
+                            jQuery.event.trigger( "ajaxSuccess", [xml, s] );
+                    } else
+                        jQuery.handleError(s, xml, status);
+                } catch(e) 
+				{
+                    status = "error";
+                    jQuery.handleError(s, xml, status, e);
+                }
+
+                // The request was completed
+                if( s.global )
+                    jQuery.event.trigger( "ajaxComplete", [xml, s] );
+
+                // Handle the global AJAX counter
+                if ( s.global && ! --jQuery.active )
+                    jQuery.event.trigger( "ajaxStop" );
+
+                // Process result
+                if ( s.complete )
+                    s.complete(xml, status);
+
+                jQuery(io).unbind();
+
+                setTimeout(function()
+                    {	try 
+                        {
+                            $(io).remove();
+                            $(form).remove();	
+                            
+                        } catch(e) {
+                            jQuery.handleError(s, xml, null, e);
+                        }									
+                    }, 100)
+                xml = null;
+            }
+        }
+        // Timeout checker
+        if ( s.timeout > 0 ) {
+            setTimeout(function(){
+                // Check to see if the request is still happening
+                if( !requestDone ) uploadCallback( "timeout" );
+            }, s.timeout);
+        }
+        try 
+		{
+           // var io = $('#' + frameId);
+			var form = $('#' + formId);
+			$(form).attr('action', s.url);
+			$(form).attr('method', 'POST');
+			$(form).attr('target', frameId);
+            if(form.encoding)
+			{
+                form.encoding = 'multipart/form-data';				
+            }
+            else
+			{				
+                form.enctype = 'multipart/form-data';
+            }			
+            $(form).submit();
+
+        } catch(e) 
+		{			
+            jQuery.handleError(s, xml, null, e);
+        }
+        if(window.attachEvent){
+            document.getElementById(frameId).attachEvent('onload', uploadCallback);
+        }
+        else{
+            document.getElementById(frameId).addEventListener('load', uploadCallback, false);
+        } 		
+        return {abort: function () {}};	
+
+    },
+
+    uploadHttpData: function( r, type ) {
+        var data = !type;
+        data = type == "xml" || data ? r.responseXML : r.responseText;
+        // If the type is "script", eval it in global context
+        if ( type == "script" )
+            jQuery.globalEval( data );
+        // Get the JavaScript object, if JSON is used.
+        if ( type == "json" )
+            eval( "data = " + data );
+        // evaluate scripts within html
+        if ( type == "html" )
+            jQuery("<div>").html(data).evalScripts();
+			//alert($('param', data).each(function(){alert($(this).attr('value'));}));
+        return data;
+    }
+})
+

lms/static/js/jquery.timeago.js

+/**
+ * Timeago is a jQuery plugin that makes it easy to support automatically
+ * updating fuzzy timestamps (e.g. "4 minutes ago" or "about 1 day ago").
+ *
+ * @name timeago
+ * @version 0.11.4
+ * @requires jQuery v1.2.3+
+ * @author Ryan McGeary
+ * @license MIT License - http://www.opensource.org/licenses/mit-license.php
+ *
+ * For usage and examples, visit:
+ * http://timeago.yarp.com/
+ *
+ * Copyright (c) 2008-2012, Ryan McGeary (ryan -[at]- mcgeary [*dot*] org)
+ */
+(function($) {
+  $.timeago = function(timestamp) {
+    if (timestamp instanceof Date) {
+      return inWords(timestamp);
+    } else if (typeof timestamp === "string") {
+      return inWords($.timeago.parse(timestamp));
+    } else if (typeof timestamp === "number") {
+      return inWords(new Date(timestamp));
+    } else {
+      return inWords($.timeago.datetime(timestamp));
+    }
+  };
+  var $t = $.timeago;
+
+  $.extend($.timeago, {
+    settings: {
+      refreshMillis: 60000,
+      allowFuture: false,
+      strings: {
+        prefixAgo: null,
+        prefixFromNow: null,
+        suffixAgo: "ago",
+        suffixFromNow: "from now",
+        seconds: "less than a minute",
+        minute: "about a minute",
+        minutes: "%d minutes",
+        hour: "about an hour",
+        hours: "about %d hours",
+        day: "a day",
+        days: "%d days",
+        month: "about a month",
+        months: "%d months",
+        year: "about a year",
+        years: "%d years",
+        wordSeparator: " ",
+        numbers: []
+      }
+    },
+    inWords: function(distanceMillis) {
+      var $l = this.settings.strings;
+      var prefix = $l.prefixAgo;
+      var suffix = $l.suffixAgo;
+      if (this.settings.allowFuture) {
+        if (distanceMillis < 0) {
+          prefix = $l.prefixFromNow;
+          suffix = $l.suffixFromNow;
+        }
+      }
+
+      var seconds = Math.abs(distanceMillis) / 1000;
+      var minutes = seconds / 60;
+      var hours = minutes / 60;
+      var days = hours / 24;
+      var years = days / 365;
+
+      function substitute(stringOrFunction, number) {
+        var string = $.isFunction(stringOrFunction) ? stringOrFunction(number, distanceMillis) : stringOrFunction;
+        var value = ($l.numbers && $l.numbers[number]) || number;
+        return string.replace(/%d/i, value);
+      }
+
+      var words = seconds < 45 && substitute($l.seconds, Math.round(seconds)) ||
+        seconds < 90 && substitute($l.minute, 1) ||
+        minutes < 45 && substitute($l.minutes, Math.round(minutes)) ||
+        minutes < 90 && substitute($l.hour, 1) ||
+        hours < 24 && substitute($l.hours, Math.round(hours)) ||
+        hours < 42 && substitute($l.day, 1) ||
+        days < 30 && substitute($l.days, Math.round(days)) ||
+        days < 45 && substitute($l.month, 1) ||
+        days < 365 && substitute($l.months, Math.round(days / 30)) ||
+        years < 1.5 && substitute($l.year, 1) ||
+        substitute($l.years, Math.round(years));
+
+      var separator = $l.wordSeparator === undefined ?  " " : $l.wordSeparator;
+      return $.trim([prefix, words, suffix].join(separator));
+    },
+    parse: function(iso8601) {
+      var s = $.trim(iso8601);
+      s = s.replace(/\.\d+/,""); // remove milliseconds
+      s = s.replace(/-/,"/").replace(/-/,"/");
+      s = s.replace(/T/," ").replace(/Z/," UTC");
+      s = s.replace(/([\+\-]\d\d)\:?(\d\d)/," $1$2"); // -04:00 -> -0400
+      return new Date(s);
+    },
+    datetime: function(elem) {
+      var iso8601 = $t.isTime(elem) ? $(elem).attr("datetime") : $(elem).attr("title");
+      return $t.parse(iso8601);
+    },
+    isTime: function(elem) {
+      // jQuery's `is()` doesn't play well with HTML5 in IE
+      return $(elem).get(0).tagName.toLowerCase() === "time"; // $(elem).is("time");
+    }
+  });
+
+  $.fn.timeago = function() {
+    var self = this;
+    self.each(refresh);
+
+    var $s = $t.settings;
+    if ($s.refreshMillis > 0) {
+      setInterval(function() { self.each(refresh); }, $s.refreshMillis);
+    }
+    return self;
+  };
+
+  function refresh() {
+    var data = prepareData(this);
+    if (!isNaN(data.datetime)) {
+      $(this).text(inWords(data.datetime));
+    }
+    return this;
+  }
+
+  function prepareData(element) {
+    element = $(element);
+    if (!element.data("timeago")) {
+      element.data("timeago", { datetime: $t.datetime(element) });
+      var text = $.trim(element.text());
+      if (text.length > 0 && !($t.isTime(element) && element.attr("title"))) {
+        element.attr("title", text);
+      }
+    }
+    return element.data("timeago");
+  }
+
+  function inWords(date) {
+    return $t.inWords(distance(date));
+  }
+
+  function distance(date) {
+    return (new Date().getTime() - date.getTime());
+  }
+
+  // fix for IE6 suckage
+  document.createElement("abbr");
+  document.createElement("time");
+}(jQuery));

lms/static/js/split.js

+/*!
+ * Cross-Browser Split 1.1.1
+ * Copyright 2007-2012 Steven Levithan <stevenlevithan.com>
+ * Available under the MIT License
+ * ECMAScript compliant, uniform cross-browser split method
+ */
+
+/**
+ * Splits a string into an array of strings using a regex or string separator. Matches of the
+ * separator are not included in the result array. However, if `separator` is a regex that contains
+ * capturing groups, backreferences are spliced into the result each time `separator` is matched.
+ * Fixes browser bugs compared to the native `String.prototype.split` and can be used reliably
+ * cross-browser.
+ * @param {String} str String to split.
+ * @param {RegExp|String} separator Regex or string to use for separating the string.
+ * @param {Number} [limit] Maximum number of items to include in the result array.
+ * @returns {Array} Array of substrings.
+ * @example
+ *
+ * // Basic use
+ * split('a b c d', ' ');
+ * // -> ['a', 'b', 'c', 'd']
+ *
+ * // With limit
+ * split('a b c d', ' ', 2);
+ * // -> ['a', 'b']
+ *
+ * // Backreferences in result array
+ * split('..word1 word2..', /([a-z]+)(\d+)/i);
+ * // -> ['..', 'word', '1', ' ', 'word', '2', '..']
+ */
+
+var _split; // instead of split for a less common name; avoid conflict
+
+// Avoid running twice; that would break the `nativeSplit` reference
+_split = _split || function (undef) {
+
+    var nativeSplit = String.prototype.split,
+        compliantExecNpcg = /()??/.exec("")[1] === undef, // NPCG: nonparticipating capturing group
+        self;
+
+    self = function (str, separator, limit) {
+        // If `separator` is not a regex, use `nativeSplit`
+        if (Object.prototype.toString.call(separator) !== "[object RegExp]") {
+            return nativeSplit.call(str, separator, limit);
+        }
+        var output = [],
+            flags = (separator.ignoreCase ? "i" : "") +
+                    (separator.multiline  ? "m" : "") +
+                    (separator.extended   ? "x" : "") + // Proposed for ES6
+                    (separator.sticky     ? "y" : ""), // Firefox 3+
+            lastLastIndex = 0,
+            // Make `global` and avoid `lastIndex` issues by working with a copy
+            separator = new RegExp(separator.source, flags + "g"),
+            separator2, match, lastIndex, lastLength;
+        str += ""; // Type-convert
+        if (!compliantExecNpcg) {
+            // Doesn't need flags gy, but they don't hurt
+            separator2 = new RegExp("^" + separator.source + "$(?!\\s)", flags);
+        }
+        /* Values for `limit`, per the spec:
+         * If undefined: 4294967295 // Math.pow(2, 32) - 1
+         * If 0, Infinity, or NaN: 0
+         * If positive number: limit = Math.floor(limit); if (limit > 4294967295) limit -= 4294967296;
+         * If negative number: 4294967296 - Math.floor(Math.abs(limit))
+         * If other: Type-convert, then use the above rules
+         */
+        limit = limit === undef ?
+            -1 >>> 0 : // Math.pow(2, 32) - 1
+            limit >>> 0; // ToUint32(limit)
+        while (match = separator.exec(str)) {
+            // `separator.lastIndex` is not reliable cross-browser
+            lastIndex = match.index + match[0].length;
+            if (lastIndex > lastLastIndex) {
+                output.push(str.slice(lastLastIndex, match.index));
+                // Fix browsers whose `exec` methods don't consistently return `undefined` for
+                // nonparticipating capturing groups
+                if (!compliantExecNpcg && match.length > 1) {
+                    match[0].replace(separator2, function () {
+                        for (var i = 1; i < arguments.length - 2; i++) {
+                            if (arguments[i] === undef) {
+                                match[i] = undef;
+                            }
+                        }
+                    });
+                }
+                if (match.length > 1 && match.index < str.length) {
+                    Array.prototype.push.apply(output, match.slice(1));
+                }
+                lastLength = match[0].length;
+                lastLastIndex = lastIndex;
+                if (output.length >= limit) {
+                    break;
+                }
+            }
+            if (separator.lastIndex === match.index) {
+                separator.lastIndex++; // Avoid an infinite loop
+            }
+        }
+        if (lastLastIndex === str.length) {
+            if (lastLength || !separator.test("")) {
+                output.push("");
+            }
+        } else {
+            output.push(str.slice(lastLastIndex));
+        }
+        return output.length > limit ? output.slice(0, limit) : output;
+    };
+
+    // For convenience
+    String.prototype.split = function (separator, limit) {
+        return self(this, separator, limit);
+    };
+
+    return self;
+
+}();
+

lms/static/sass/_news.scss

+@mixin news-font {
+  font-family: inherit;
+}
+
+.notifications {
+  @include news-font;
+  font-size: 0.9em;
+  padding-left: 20px;
+  padding-top: 20px;
+  padding-bottom: 20px;
+  .notification {
+    @include news-font;
+    margin-top: 15px;
+    margin-botton: 15px;
+
+    a {
+      @include news-font;
+    }
+  }
+}

lms/static/sass/application.scss

@@ -27,3 +27,6 @@
 @import 'multicourse/password_reset';
 @import 'multicourse/error-pages';
 @import 'multicourse/help';
+
+@import 'discussion';
+@import 'news';

lms/static/sass/course/courseware/_courseware.scss

@@ -80,6 +80,7 @@ div.course-wrapper {
         }
 
         .histogram {
+          display: none;
           width: 200px;
           height: 150px;
         }
@@ -87,6 +88,15 @@ div.course-wrapper {
         ul {
           list-style: disc outside none;
           padding-left: 1em;
+          
+          &.discussion-errors {
+            list-style: none;
+            padding-left: 2em;
+          }
+
+          &.admin-actions {
+            list-style: none;
+          }
         }
 
         nav.sequence-bottom {
@@ -131,6 +141,7 @@ div.course-wrapper {
     }
 
     div.staff_info {
+      display: none;
       @include clearfix();
       white-space: pre-wrap;
       border-top: 1px solid #ccc;

lms/templates/courseware/course_navigation.html

@@ -20,14 +20,19 @@ def url_class(url):
       <li class="courseware"><a href="${reverse('courseware', args=[course.id])}" class="${url_class('courseware')}">Courseware</a></li>
       <li class="info"><a href="${reverse('info', args=[course.id])}" class="${url_class('info')}">Course Info</a></li>
 % if user.is_authenticated():
-% if settings.MITX_FEATURES.get('ENABLE_TEXTBOOK'):
+  % if settings.MITX_FEATURES.get('ENABLE_TEXTBOOK'):
         % for index, textbook in enumerate(course.textbooks):
             <li class="book"><a href="${reverse('book', args=[course.id, index])}" class="${url_class('book')}">${textbook.title}</a></li>
         % endfor
-% endif 
-% if settings.MITX_FEATURES.get('ENABLE_DISCUSSION'):
+  % endif
+  % if settings.MITX_FEATURES.get('ENABLE_DISCUSSION_SERVICE'):
+        <li class="discussion"><a href="${reverse('django_comment_client.forum.views.forum_form_discussion', args=[course.id])}" class="${url_class('discussion')}">Discussion</a></li>
+        <li class="news"><a href="${reverse('news', args=[course.id])}" class="${url_class('news')}">News</a></li>
+  % endif 
+        
+  % if settings.MITX_FEATURES.get('ENABLE_DISCUSSION'):
         <li class="discussion"><a href="${reverse('questions')}">Discussion</a></li>
-% endif
+  % endif
 % endif
 % if settings.WIKI_ENABLED:
       <li class="wiki"><a href="${reverse('course_wiki', args=[course.id])}" class="${url_class('wiki')}">Wiki</a></li>

lms/templates/courseware/courseware.html

@@ -21,6 +21,7 @@
 
    <%static:js group='courseware'/>
 
+  <%include file="../discussion/_js_dependencies.html" />
   <%include file="/mathjax_include.html" />
 
   <!-- TODO: http://docs.jquery.com/Plugins/Validation -->
@@ -28,6 +29,10 @@
     document.write('\x3Cscript type="text/javascript" src="' +
         document.location.protocol + '//www.youtube.com/player_api">\x3C/script>');
   </script>
+
+  <script type="text/javascript">
+    var $$course_id = "${course.id}";
+  </script>
 </%block>
 
 <%include file="/courseware/course_navigation.html" args="active_page='courseware'" />

lms/templates/discussion/_ajax_single_thread.html

+<%namespace name="renderer" file="_content_renderer.html"/>
+${renderer.render_comments(thread.get('children'))}

lms/templates/discussion/_blank_slate.html

+<div class="blank-state">
+  % if performed_search:
+    Sorry! We can't find anything matching your search. Please try another search.
+  % else:
+    There are no posts here yet. Be the first one to post!
+  % endif
+</div>

lms/templates/discussion/_content.mustache

+<div class="discussion-content">
+  <div class="discussion-content-wrapper">
+    <div class="discussion-votes">
+      <a class="discussion-vote discussion-vote-up" href="javascript:void(0)">&#9650;</a>
+      <div class="discussion-votes-point">{{content.votes.point}}</div>
+      <a class="discussion-vote discussion-vote-down" href="javascript:void(0)">&#9660;</a>
+    </div>
+    <div class="discussion-right-wrapper">
+      <ul class="admin-actions">
+        <li><a href="javascript:void(0)" class="admin-endorse">Endorse</a></li>
+        <li><a href="javascript:void(0)" class="admin-edit">Edit</a></li>
+        <li><a href="javascript:void(0)" class="admin-delete">Delete</a></li>
+        {{#thread}}
+          <li><a href="javascript:void(0)" class="admin-openclose">{{close_thread_text}}</a></li>
+        {{/thread}}
+      </ul>
+      {{#thread}}
+        <a class="thread-title" name="{{content.id}}" href="javascript:void(0)">{{{content.displayed_title}}}</a>
+        <div class="thread-raw-title" style="display: none">{{{content.title}}}</div>
+      {{/thread}}
+      <div class="discussion-content-view">
+        <a name="{{content.id}}" style="width: 0; height: 0; padding: 0; border: none;"></a>
+        <div class="content-body {{content.type}}-body" id="content-body-{{content.id}}">{{{content.displayed_body}}}</div>
+        <div class="content-raw-body {{content.type}}-raw-body" style="display: none">{{{content.body}}}</div>
+        {{#thread}}
+          <div class="thread-tags">
+            {{#content.tags}}
+              <a class="thread-tag" href="{{##url_for_tags}}{{.}}{{/url_for_tags}}">{{.}}</a>
+            {{/content.tags}}
+          </div>
+          <div class="thread-raw-tags" style="display: none">{{content.raw_tags}}</div>
+        {{/thread}}
+        <div class="info">
+          <div class="comment-time">
+            <span class="timeago" title="{{content.updated_at}}">sometime</span> by
+            {{#content.anonymous}}
+              anonymous
+            {{/content.anonymous}}
+            {{^content.anonymous}}
+              <a href="{{##url_for_user}}{{content.user_id}}{{/url_for_user}}">{{content.username}}</a>
+            {{/content.anonymous}}
+          </div>
+          <div class="comment-count">
+            {{#thread}}
+              {{#partial_comments}}
+                <a href="javascript:void(0)" class="discussion-show-comments first-time">Show all comments ({{content.comments_count}} total)</a>
+              {{/partial_comments}}
+              {{^partial_comments}}
+                <a href="javascript:void(0)" class="discussion-show-comments">Show {{##pluralize}}{{content.comments_count}} comment{{/pluralize}}</a>
+              {{/partial_comments}}
+            {{/thread}}
+          </div>
+          <ul class="discussion-actions">
+            <li><a class="discussion-link discussion-reply discussion-reply-{{content.type}}" href="javascript:void(0)">Reply</a></li>
+            <li><div class="follow-wrapper"></div></li>
+            <li><a class="discussion-link discussion-permanent-link" href="javascript:void(0)">Permanent Link</a></li>
+          </ul>
+        </div>
+      </div>
+    </div>
+  </div>
+</div>

lms/templates/discussion/_content_renderer.html

+<%! import django_comment_client.helpers as helpers %>
+
+<%def name="render_content(content)">
+  ${helpers.render_content(content)}
+</%def>
+
+<%def name="render_content_with_comments(content)">
+  <div class="${content['type']}" _id="${content['id']}" _discussion_id="${content.get('commentable_id')}" _author_id="${helpers.show_if(content['user_id'], content.get('anonymous'))}">
+    ${render_content(content)}
+    % if content.get('children') is not None:
+      ${render_comments(content['children'])}
+    % endif
+  </div>
+</%def>
+
+<%def name="render_comments(comments)">
+  <div class="comments">
+    % for comment in comments:
+      ${render_content_with_comments(comment)}
+    % endfor
+  </div>
+</%def>

lms/templates/discussion/_discussion_module.html

+<div class="discussion-module">
+  <a class="discussion-show control-button" href="javascript:void(0)" discussion_id="${discussion_id}">Show Discussion</a>
+</div>

lms/templates/discussion/_forum.html

+<%namespace name="renderer" file="_content_renderer.html"/>
+
+<section class="discussion forum-discussion" _id="${discussion_id}">
+
+  <div class="discussion-non-content discussion-local">
+    <div class="search-wrapper">
+      <%include file="_search_bar.html" />
+    </div>    
+  </div>
+  % if len(threads) == 0:
+    <div class="blank">
+      <%include file="_blank_slate.html" />
+    </div>
+    <div class="threads"></div>
+  % else:
+    <%include file="_sort.html" />
+    <div class="threads">
+      % for thread in threads:
+        ${renderer.render_content_with_comments(thread)}
+      % endfor
+    </div>
+    <%include file="_paginator.html" />
+  % endif
+</section>
+
+<%include file="_js_data.html" />

lms/templates/discussion/_inline.html

+<%namespace name="renderer" file="_content_renderer.html"/>
+
+<section class="discussion inline-discussion" _id="${discussion_id}">
+
+  <div class="discussion-non-content discussion-local"></div>
+
+  <div class="threads">
+    % for thread in threads:
+      ${renderer.render_content_with_comments(thread)}
+    % endfor
+  </div>
+
+  <%include file="_paginator.html" />
+</section>
+
+<%include file="_js_data.html" />

lms/templates/discussion/_js_data.html

+<%! from django.template.defaultfilters import escapejs %>
+
+<script type="text/javascript">
+  var $$user_info = JSON.parse("${user_info | escapejs}");
+  var $$course_id = "${course_id | escapejs}";
+  if (typeof $$annotated_content_info === undefined || $$annotated_content_info === null) {
+    var $$annotated_content_info = {};
+  }
+  $$annotated_content_info = $.extend($$annotated_content_info, JSON.parse("${annotated_content_info | escapejs}"));
+</script>

lms/templates/discussion/_js_dependencies.html

+<%namespace name='static' file='../static_content.html'/>
+
+<script type="text/x-mathjax-config">
+  MathJax.Hub.Config({
+    tex2jax: {
+      inlineMath: [
+        ["\\(","\\)"],
+      ],
+      displayMath: [
+        ["\\[","\\]"],
+      ]
+    }
+  });
+</script>
+
+## This must appear after all mathjax-config blocks, so it is after the imports from the other templates.
+## It can't be run through static.url because MathJax uses crazy url introspection to do lazy loading of MathJax extension libraries
+<script type="text/javascript" src="/static/js/vendor/mathjax-MathJax-c9db6ac/MathJax.js?config=TeX-MML-AM_HTMLorMML-full"></script>
+<!---<script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js"> </script>-->
+<script type="text/javascript" src="${static.url('js/split.js')}"></script>
+<script type="text/javascript" src="${static.url('js/jquery.ajaxfileupload.js')}"></script>
+<script type="text/javascript" src="${static.url('js/Markdown.Converter.js')}"></script>
+<script type="text/javascript" src="${static.url('js/Markdown.Sanitizer.js')}"></script>
+<script type="text/javascript" src="${static.url('js/Markdown.Editor.js')}"></script>
+<script type="text/javascript" src="${static.url('js/jquery.autocomplete.js')}"></script>
+<script type="text/javascript" src="${static.url('js/jquery.timeago.js')}"></script>
+<script type="text/javascript" src="${static.url('js/jquery.tagsinput.js')}"></script>
+<script type="text/javascript" src="${static.url('js/mustache.js')}"></script>
+<script type="text/javascript" src="${static.url('js/URI.min.js')}"></script>
+<link href="${static.url('css/vendor/jquery.tagsinput.css')}" rel="stylesheet" type="text/css">
+<link href="${static.url('css/vendor/jquery.autocomplete.css')}" rel="stylesheet" type="text/css">

lms/templates/discussion/_paginator.html

+<%! from urllib import urlencode %>
+
+<% 
+  def merge(dic1, dic2):
+    return dict(dic1.items() + dic2.items())
+
+  def url_for_page(_page):
+    return base_url + '?' + urlencode(merge(query_params, {'page': _page}))
+%>
+
+<%def name="link_to_page(_page, text)">
+  <a class="discussion-page-link" href="javascript:void(0)" page-url="${url_for_page(_page)}">${text}</a>
+</%def>
+
+<%def name="div_page(_page)">
+  % if _page != page:
+    <div class="page-link">
+      ${link_to_page(_page, str(_page))}
+    </div>
+  % else:
+    <div class="page-link">${_page}</div>
+  % endif
+</%def>
+
+<%def name="list_pages(*args)">
+  % for arg in args:
+    % if arg == 'dots':
+      <div class="page-dots">...</div>
+    % elif isinstance(arg, list):
+      % for _page in arg:
+        ${div_page(_page)}
+      % endfor
+    % else:
+      ${div_page(arg)}
+    % endif
+  % endfor
+</%def>
+
+<div class="discussion-${discussion_type}-paginator discussion-paginator">
+  <div class="prev-page">
+    % if page > 1:
+      ${link_to_page(page - 1, "&lt; Previous page")}
+    % endif
+  </div>
+
+  % if num_pages <= 2 * pages_nearby_delta + 2:
+    ${list_pages(range(1, num_pages + 1))}
+  % else:
+    % if page <= 2 * pages_nearby_delta:
+      ${list_pages(range(1, 2 * pages_nearby_delta + 2), 'dots', num_pages)}
+    % elif num_pages - page + 1 <= 2 * pages_nearby_delta:
+      ${list_pages(1, 'dots', range(num_pages - 2 * pages_nearby_delta, num_pages + 1))}
+    % else:
+      ${list_pages(1, 'dots', range(page - pages_nearby_delta, page + pages_nearby_delta + 1), 'dots', num_pages)}
+    % endif
+  % endif
+  <div class="next-page">
+    % if page < num_pages:
+      ${link_to_page(page + 1, "Next page &gt;")}
+    % endif
+  </div>
+</div>

lms/templates/discussion/_recent_active_posts.html

+% if recent_active_threads:
+  <article class="discussion-sidebar-following sidebar-module">
+    <header>
+      <h4>Following</h4>
+      <a href="#" class="sidebar-view-all">view all &rsaquo;</a>
+    </header>
+    <ol class="discussion-sidebar-following-list">
+      % for thread in recent_active_threads:
+        <li><a href="#"><span class="sidebar-following-name">${thread['title']}</span> <span class="sidebar-vote-count">${thread['votes']['point']}</span></a></li>
+      % endfor
+    <ol>
+  </article>
+% endif

lms/templates/discussion/_search_bar.html

+<%! from urllib import urlencode %>
+<%
+
+def merge(dic1, dic2):
+  return dict(dic1.items() + dic2.items())
+
+def base_url_for_search():
+  return base_url + '?' + urlencode(merge(query_params, {'page': 1}))
+%>
+
+<form action="${base_url_for_search()}" method="get" class="discussion-search-form">
+  % if query_params.get('tags', None):
+    <input class="search-input" type="text" value="[${tags}]${text}" id="keywords" autocomplete="off"/>
+  % else:
+    <input class="search-input" type="text" value="${text}" id="keywords" autocomplete="off"/>
+  % endif
+  <div class="discussion-link discussion-search-link" href="javascript:void(0)">Search posts</div>
+</form>

lms/templates/discussion/_single_thread.html

+<%namespace name="renderer" file="_content_renderer.html"/>
+
+<section class="discussion" _id="${discussion_id}">
+  <a class="discussion-title" href="javascript:void(0)">Discussion</a>
+  ${renderer.render_content_with_comments(thread)}
+</section>
+
+<%include file="_js_data.html" />

lms/templates/discussion/_sort.html

+<%! from urllib import urlencode %>
+
+<%def name="link_to_sort(key, title)">
+  % if key == sort_key:
+    ${_link_to_sort(key, None, title + '', 'sorted')}
+    <!---
+    % if sort_order.lower() == 'desc':
+      ${_link_to_sort(key, 'asc', title + '', 'sorted')}
+    % else:
+      ${_link_to_sort(key, 'desc', title + '', 'sorted')}
+    % endif
+    -->
+  % else:
+    ${_link_to_sort(key, 'desc', title)}
+  % endif
+</%def>
+
+<%def name="_link_to_sort(key, order, title, cls='')">
+  <% 
+  def merge(dic1, dic2):
+    return dict(dic1.items() + dic2.items())
+
+  def url_for_sort(key, order):
+    if order is None:
+      return ''
+    else:
+      return base_url + '?' + urlencode(merge(query_params, {'page': 1, 'sort_key': key, 'sort_order': order}))
+  %>
+  <a class="discussion-sort-link ${cls}" href="javascript:void(0)" sort-url="${url_for_sort(key, order)}">${title}</a>
+</%def>
+
+<div class="discussion-sort discussion-local">
+  <span class="discussion-label">Sort by:</span>
+  ${link_to_sort('activity', 'top')}
+  
+  ${link_to_sort('date', 'date')}
+  
+  ${link_to_sort('votes', 'votes')}
+  
+  ${link_to_sort('comments', 'comments')}
+</div>

lms/templates/discussion/_trending_tags.html

+% if trending_tags:
+  <article class="discussion-sidebar-tags sidebar-module">
+      <header>
+        <h4>Recent Tags</h4>
+      </header>
+      <ol class="discussion-sidebar-tags-list">
+        % for tag, count in trending_tags:
+          <li><a href="#" class="thread-tag">${tag}</a><span class="sidebar-tag-count">&times;${count}</span></li>
+        % endfor
+      <ol>
+  </article>
+% endif

lms/templates/discussion/_user_active_threads.html

+<%namespace name="renderer" file="_thread.html"/>
+
+<section class="discussion user-active-discussion">
+
+  <div class="discussion-non-content discussion-local"></div>
+
+  <div class="threads">
+    % for thread in threads:
+      ${renderer.render_thread(course_id, thread, show_comments=True)}
+    % endfor
+  </div>
+
+  <%include file="_paginator.html" />
+</section>
+
+<%include file="_js_data.html" />

lms/templates/discussion/_user_profile.html

+<%! from django_comment_client.utils import pluralize %>
+<%! from django_comment_client.permissions import has_permission, check_permissions_by_view %>
+<%! from operator import attrgetter %>
+
+
+<div class="user-profile">
+  <%
+    role_names = sorted(map(attrgetter('name'), django_user.roles.all()))
+  %>
+  <div class="sidebar-username">${django_user.username}</div>
+  <div class="sidebar-user-roles">
+    ${", ".join(role_names)}
+  </div>
+  <div class="sidebar-threads-count"><span>${profiled_user['threads_count']}</span> ${pluralize('discussion', profiled_user['threads_count'])} started</div>
+  <div class="sidebar-comments-count"><span>${profiled_user['comments_count']}</span> ${pluralize('comment', profiled_user['comments_count'])}</div>
+  % if check_permissions_by_view(user, course.id, content=None, name='update_moderator_status'):
+    % if "Moderator" in role_names:
+      <a href="javascript:void(0)" class="sidebar-revoke-moderator-button">Revoke Moderator provileges</a>
+    % else:
+      <a href="javascript:void(0)" class="sidebar-promote-moderator-button">Promote to Moderator</a>
+    % endif
+  % endif
+</div>

lms/templates/discussion/ajax_create_comment.html

+<%namespace name="renderer" file="_content_renderer.html"/>
+
+${renderer.render_content_with_comments(content)}

lms/templates/discussion/ajax_create_thread.html

+<%namespace name="renderer" file="_content_renderer.html"/>
+
+${renderer.render_content_with_comments(content)}

lms/templates/discussion/ajax_update_comment.html

+<%namespace name="renderer" file="_content_renderer.html"/>
+
+${renderer.render_content(content)}