Skip to content

E
edx-platform
Commit 325b9590 by Chris Dodge
Options

Integrate edx-notifications into edx-platform

parent ab600c07
Showing with 2357 additions and 58 deletions
cms/djangoapps/contentstore/tests/utils.py
......@@ -8,6 +8,7 @@ import json
from django.test.client import Client
from django.contrib.auth.models import User
from lms import startup
from xmodule.contentstore.django import contentstore
from xmodule.modulestore import ModuleStoreEnum
from xmodule.modulestore.inheritance import own_metadata
......@@ -83,6 +84,9 @@ class CourseTestCase(ModuleStoreTestCase):
display_name='Robot Super Course',
)
# initialize the Notification subsystem
startup.startup_notification_subsystem()
def create_non_staff_authed_user_client(self, authenticate=True):
"""
Create a non-staff user, log them in (if authenticate=True), and return the client, user to use for testing.
......
cms/djangoapps/contentstore/views/course.py
......@@ -17,6 +17,8 @@ from util.json_request import JsonResponse, JsonResponseBadRequest
from util.date_utils import get_default_time_display
from edxmako.shortcuts import render_to_response
from bs4 import BeautifulSoup
from xmodule.course_module import DEFAULT_START_DATE
from xmodule.error_module import ErrorDescriptor
from xmodule.modulestore.django import modulestore
......@@ -28,6 +30,7 @@ from xmodule.modulestore.exceptions import ItemNotFoundError, DuplicateCourseErr
from opaque_keys import InvalidKeyError
from opaque_keys.edx.locations import Location
from opaque_keys.edx.keys import CourseKey
from util.html import strip_tags
from django_future.csrf import ensure_csrf_cookie
from contentstore.course_info_model import get_course_updates, update_course_updates, delete_course_update
......@@ -80,6 +83,9 @@ __all__ = ['course_info_handler', 'course_handler', 'course_info_update_handler'
log = logging.getLogger(__name__)
from student.tasks import publish_course_notifications_task
from edx_notifications.data import NotificationMessage
from edx_notifications.lib.publisher import get_notification_type
class AccessListFallback(Exception):
"""
......@@ -697,7 +703,95 @@ def course_info_update_handler(request, course_key_string, provided_id=None):
# can be either and sometimes django is rewriting one to the other:
elif request.method in ('POST', 'PUT'):
try:
return JsonResponse(update_course_updates(usage_key, request.json, provided_id, request.user))
response = JsonResponse(update_course_updates(usage_key, request.json, provided_id, request.user))
if settings.FEATURES.get('ENABLE_NOTIFICATIONS', False) and request.method == 'POST':
# only send bulk notifications to users when there is
# new update/announcement in the course.
try:
# get the notification type.
notification_type = get_notification_type(u'open-edx.studio.announcements.new-announcement')
course = modulestore().get_course(course_key, depth=0)
excerpt = strip_tags(request.json['content'])
excerpt = excerpt.strip()
excerpt = excerpt.replace('\n','').replace('\r','')
announcement_date = request.json['date']
title = None
try:
# we have to try to parse out a 'title' which
# will be determine through a HTML convention of
# labeling a tag will class 'announcement-title'
parsed_html = BeautifulSoup(request.json['content'])
if not parsed_html.body:
# maybe doesn't have <body> outer tags
parsed_html = BeautifulSoup('<body>{}</body>'.format(request.json['content']))
if parsed_html.body:
title_tag_name = getattr(settings, 'NOTIFICATIONS_ANNOUNCEMENT_TITLE_TAG', 'p')
title_tag_class = getattr(settings, 'NOTIFICATIONS_ACCOUNCEMENT_TITLE_CLASS', 'announcement-title')
title_tag = parsed_html.body.find(title_tag_name, attrs={'class': title_tag_class})
if title_tag:
title = title_tag.text
if title:
# remove the title from the excerpt so that it doesn't
# count towards the length limit
excerpt = excerpt.replace(title, '')
except Exception, ex:
log.exception(ex)
if not title:
# default title, if we could not match the pattern
title = _('Announcement on {date}').format(date=announcement_date)
# now we have to truncate the notification excerpt to me
# some max length and append an ellipsis
max_len = getattr(settings, 'NOTIFICATIONS_MAX_EXCERPT_LEN', 65)
if len(excerpt) > max_len:
excerpt = "{}...".format(excerpt[:max_len])
notification_msg = NotificationMessage(
msg_type=notification_type,
namespace=unicode(course_key),
payload={
'_schema_version': '1',
'course_name': course.display_name,
'excerpt': excerpt,
'announcement_date': announcement_date,
'title': title,
}
)
# add in all the context parameters we'll need to
# generate a URL back to the website that will
# present the new course announcement
#
# IMPORTANT: This can be changed to msg.add_click_link() if we
# have a particular URL that we wish to use. In the initial use case,
# we need to make the link point to a different front end so
# we have to resolve the link when we dispatch the Message
#
notification_msg.add_click_link_params({
'course_id': unicode(course_key),
})
# Send the notification_msg to the Celery task
if settings.FEATURES.get('ENABLE_NOTIFICATIONS_CELERY', False):
publish_course_notifications_task.delay(course_key, notification_msg)
else:
publish_course_notifications_task(course_key, notification_msg)
except Exception, ex:
# Notifications aren't considered critical, so it's OK to fail
# log and then continue
log.exception(ex)
return response
except:
return HttpResponseBadRequest(
"Failed to save",
......
cms/djangoapps/contentstore/views/item.py
......@@ -48,6 +48,8 @@ from models.settings.course_grading import CourseGradingModel
from cms.lib.xblock.runtime import handler_url, local_resource_url
from opaque_keys.edx.keys import UsageKey, CourseKey
from .preview import get_available_xblock_services
__all__ = ['orphan_handler', 'xblock_handler', 'xblock_view_handler', 'xblock_outline_handler']
log = logging.getLogger(__name__)
......@@ -147,6 +149,9 @@ def xblock_handler(request, usage_key_string):
return HttpResponse(status=406)
elif request.method == 'DELETE':
# let xblock (and children) know they are about to be deleted
_notify_xblocks_by_usage_key(request.user, usage_key, usage_key.course_key, 'on_before_studio_delete')
_delete_item(usage_key, request.user)
return JsonResponse()
else: # Since we have a usage_key, we are updating an existing xblock.
......@@ -395,10 +400,52 @@ def _save_xblock(user, xblock, data=None, children=None, metadata=None, nullout=
if publish == 'make_public':
modulestore().publish(xblock.location, user.id)
# notify the xblocks that they have been published
_notify_xblocks(xblock, xblock.location.course_key, 'on_studio_published')
# Note that children aren't being returned until we have a use case.
return JsonResponse(result, encoder=EdxJSONEncoder)
def _notify_xblocks(xblock, course_id, callback_name):
"""
Notify xblock (and children) of a lifecycle activity, which basically looks to see if an xblock
has implemented the 'callback_name'
"""
def _notify_xblock_subtree(parent_xblock, course_id, callback_name, xblock_services):
"""
Recusively notifies all children, depth-first
"""
for child in parent_xblock.get_children():
_notify_xblock_subtree(child, course_id, callback_name, xblock_services)
# then notify parent, if they have implemented the callback_name
# function
if hasattr(parent_xblock, callback_name):
log.info('Notifying xblock {loc} on {name}...'.format(loc=parent_xblock.location, name=callback_name))
func = getattr(parent_xblock, callback_name)
func(course_id, xblock_services)
xblock_services = get_available_xblock_services()
_notify_xblock_subtree(xblock, course_id, callback_name, xblock_services)
def _notify_xblocks_by_usage_key(user, usage_key, course_id, callback_name):
"""
Helper function when we only have the xblock location available
"""
store = modulestore()
try:
xblock = store.get_item(usage_key, depth=None)
_notify_xblocks(xblock, course_id, callback_name)
except ItemNotFoundError:
log.error("_notify_xblocks_by_usage_key(): Can't find item at usage_key {}".format(usage_key))
except InvalidLocationError:
log.error("_notify_xblocks_by_usage_key(): Can't find item by location {}.".format(usage_key))
@login_required
@expect_json
def _create_item(request):
......
cms/djangoapps/contentstore/views/preview.py
......@@ -20,6 +20,7 @@ from xblock.runtime import KvsFieldData
from xblock.django.request import webob_to_django_response, django_to_webob_request
from xblock.exceptions import NoSuchHandlerError
from xblock.fragment import Fragment
from xmodule.services import SettingsService, NotificationsService, CoursewareParentInfoService
from lms.lib.xblock.field_data import LmsFieldData
from cms.lib.xblock.field_data import CmsFieldData
......@@ -109,6 +110,24 @@ class StudioUserService(object):
return self._request.user.id
def get_available_xblock_services():
"""
Returns a dict of available services for xBlocks
"""
services = {
"i18n": ModuleI18nService(),
"settings": SettingsService(),
"courseware_parent_info": CoursewareParentInfoService(),
}
if settings.FEATURES.get('ENABLE_NOTIFICATIONS', False):
services.update({
"notifications": NotificationsService()
})
return services
def _preview_module_system(request, descriptor):
"""
Returns a ModuleSystem for the specified descriptor that is specialized for
......@@ -139,6 +158,8 @@ def _preview_module_system(request, descriptor):
descriptor.runtime._services['user'] = StudioUserService(request) # pylint: disable=protected-access
services = get_available_xblock_services()
return PreviewModuleSystem(
static_url=settings.STATIC_URL,
# TODO (cpennington): Do we want to track how instructors are using the preview problems?
......@@ -159,9 +180,7 @@ def _preview_module_system(request, descriptor):
error_descriptor_class=ErrorDescriptor,
get_user_role=lambda: get_user_role(request.user, course_id),
descriptor_runtime=descriptor.runtime,
services={
"i18n": ModuleI18nService(),
},
services=services,
)
......
cms/djangoapps/contentstore/views/tests/test_course_updates.py
......@@ -9,9 +9,14 @@ from opaque_keys.edx.locations import SlashSeparatedCourseKey
from opaque_keys.edx.keys import UsageKey
from xmodule.modulestore.django import modulestore
from student.tests.factories import CourseEnrollmentFactory, UserFactory
from edx_notifications.lib.consumer import get_notifications_count_for_user
from mock import patch
class CourseUpdateTest(CourseTestCase):
"""
Test for course updates
"""
def create_update_url(self, provided_id=None, course_key=None):
if course_key is None:
course_key = self.course.id
......@@ -123,6 +128,29 @@ class CourseUpdateTest(CourseTestCase):
payload = json.loads(resp.content)
self.assertTrue(len(payload) == before_delete - 1)
@patch.dict("django.conf.settings.FEATURES", {"ENABLE_NOTIFICATIONS": True})
def test_notifications_enabled_when_new_updates_in_course(self):
# create new users and enroll them in the course.
test_user_1 = UserFactory.create(password='test_pass')
CourseEnrollmentFactory(user=test_user_1, course_id=self.course.id)
test_user_2 = UserFactory.create(password='test_pass')
CourseEnrollmentFactory(user=test_user_2, course_id=self.course.id)
content = 'Test update'
payload = {'content': content, 'date': 'Feb 19, 2015'}
url = self.create_update_url()
resp = self.client.ajax_post(
url, payload, REQUEST_METHOD="POST"
)
self.assertEqual(resp.status_code, 200)
self.assertHTMLEqual(content, json.loads(resp.content)['content'])
# now the enrolled users should get notification about the
# course update where they are enrolled as student.
self.assertTrue(get_notifications_count_for_user(test_user_1.id), 1)
self.assertTrue(get_notifications_count_for_user(test_user_2.id), 1)
def test_course_updates_compatibility(self):
'''
Test that course updates doesn't break on old data (content in 'data' field).
......
cms/envs/aws.py
......@@ -292,3 +292,13 @@ ADVANCED_SECURITY_CONFIG = ENV_TOKENS.get('ADVANCED_SECURITY_CONFIG', {})
ADVANCED_COMPONENT_TYPES = ENV_TOKENS.get('ADVANCED_COMPONENT_TYPES', ADVANCED_COMPONENT_TYPES)
ADVANCED_PROBLEM_TYPES = ENV_TOKENS.get('ADVANCED_PROBLEM_TYPES', ADVANCED_PROBLEM_TYPES)
##### EDX-NOTIFICATIONS ######
NOTIFICATION_CLICK_LINK_URL_MAPS = ENV_TOKENS.get('NOTIFICATION_CLICK_LINK_URL_MAPS', NOTIFICATION_CLICK_LINK_URL_MAPS)
NOTIFICATION_STORE_PROVIDER = ENV_TOKENS.get('NOTIFICATION_STORE_PROVIDER', NOTIFICATION_STORE_PROVIDER)
NOTIFICATION_CHANNEL_PROVIDERS = ENV_TOKENS.get('NOTIFICATION_CHANNEL_PROVIDERS', NOTIFICATION_CHANNEL_PROVIDERS)
NOTIFICATION_CHANNEL_PROVIDER_TYPE_MAPS = ENV_TOKENS.get(
'NOTIFICATION_CHANNEL_PROVIDER_TYPE_MAPS',
NOTIFICATION_CHANNEL_PROVIDER_TYPE_MAPS
)
NOTIFICATION_MAX_LIST_SIZE = ENV_TOKENS.get('NOTIFICATION_MAX_LIST_SIZE', NOTIFICATION_MAX_LIST_SIZE)
cms/envs/common.py
......@@ -106,6 +106,12 @@ FEATURES = {
# Modulestore to use for new courses
'DEFAULT_STORE_FOR_NEW_COURSE': 'mongo',
# edx-notifications subsystem
'ENABLE_NOTIFICATIONS': False,
# Whether edx-notifications should use Celery for bulk operations
'ENABLE_NOTIFICATIONS_CELERY': False,
}
ENABLE_JASMINE = False
......@@ -703,3 +709,75 @@ ADVANCED_PROBLEM_TYPES = [
'boilerplate_name': None,
}
]
################################### EDX-NOTIFICATIONS SUBSYSTEM ######################################
INSTALLED_APPS += (
'edx_notifications',
'edx_notifications.server.web',
)
TEMPLATE_LOADERS += (
'django.template.loaders.filesystem.Loader',
'django.template.loaders.app_directories.Loader',
)
NOTIFICATION_STORE_PROVIDER = {
"class": "edx_notifications.stores.sql.store_provider.SQLNotificationStoreProvider",
"options": {
}
}
if not 'SOUTH_MIGRATION_MODULES' in vars() and not 'SOUTH_MIGRATION_MODULES' in globals():
SOUTH_MIGRATION_MODULES = {}
SOUTH_MIGRATION_MODULES.update({
'edx_notifications': 'edx_notifications.stores.sql.migrations',
})
# to prevent run-away queries from happening
NOTIFICATION_MAX_LIST_SIZE = 100
#
# Various mapping tables which is used by the MsgTypeToUrlLinkResolver
# to map a notification type to a statically defined URL path
#
# NOTE: NOTIFICATION_CLICK_LINK_URL_MAPS will usually get read in by the *.envs.json file
#
NOTIFICATION_CLICK_LINK_URL_MAPS = {
'open-edx.studio.announcements.*': '/courses/{course_id}/announcements',
'open-edx.lms.leaderboard.*': '/courses/{course_id}/cohort',
'open-edx.lms.discussions.*': '/courses/{course_id}/discussion/{commentable_id}/threads/{thread_id}',
'open-edx.xblock.group-project.*': '/courses/{course_id}/group_work?seqid={activity_location}',
}
# list all known channel providers
NOTIFICATION_CHANNEL_PROVIDERS = {
'durable': {
'class': 'edx_notifications.channels.durable.BaseDurableNotificationChannel',
'options': {
# list out all link resolvers
'link_resolvers': {
# right now the only defined resolver is 'type_to_url', which
# attempts to look up the msg type (key) via
# matching on the value
'msg_type_to_url': {
'class': 'edx_notifications.channels.link_resolvers.MsgTypeToUrlLinkResolver',
'config': {
'_click_link': NOTIFICATION_CLICK_LINK_URL_MAPS,
}
}
}
}
},
'null': {
'class': 'edx_notifications.channels.null.NullNotificationChannel',
'options': {}
}
}
# list all of the mappings of notification types to channel
NOTIFICATION_CHANNEL_PROVIDER_TYPE_MAPS = {
'*': 'durable', # default global mapping
}
cms/startup.py
......@@ -2,14 +2,23 @@
Module with code executed during Studio startup
"""
import logging
from django.conf import settings
# Force settings to run so that the python path is modified
settings.INSTALLED_APPS # pylint: disable=W0104
from django_startup import autostartup
from edx_notifications import startup
from monkey_patch import django_utils_translation
from course_groups.scope_resolver import CourseGroupScopeResolver
from student.scope_resolver import CourseEnrollmentsScopeResolver, StudentEmailScopeResolver
from projects.scope_resolver import GroupProjectParticipantsScopeResolver
from edx_notifications.scopes import register_user_scope_resolver
log = logging.getLogger(__name__)
def run():
"""
......@@ -25,6 +34,9 @@ def run():
add_mimetypes()
if settings.FEATURES.get('ENABLE_NOTIFICATIONS', False):
startup_notification_subsystem()
def add_mimetypes():
"""
......@@ -38,3 +50,29 @@ def add_mimetypes():
mimetypes.add_type('application/x-font-opentype', '.otf')
mimetypes.add_type('application/x-font-ttf', '.ttf')
mimetypes.add_type('application/font-woff', '.woff')
def startup_notification_subsystem():
"""
Initialize the Notification subsystem
"""
try:
startup.initialize()
# register the two scope resolvers that the LMS will be providing
# to edx-notifications
register_user_scope_resolver('course_enrollments', CourseEnrollmentsScopeResolver())
register_user_scope_resolver('course_group', CourseGroupScopeResolver())
register_user_scope_resolver('group_project_participants', GroupProjectParticipantsScopeResolver())
register_user_scope_resolver('group_project_workgroup', GroupProjectParticipantsScopeResolver())
register_user_scope_resolver('student_email_resolver', StudentEmailScopeResolver())
except Exception, ex:
# Note this will fail when we try to run migrations as manage.py will call startup.py
# and startup.initialze() will try to manipulate some database tables.
# We need to research how to identify when we are being started up as part of
# a migration script
log.error(
'There was a problem initializing notifications subsystem. '
'This could be because the database tables have not yet been created and '
'./manage.py lms syncdb needs to run setup.py. Error was "{err_msg}". Continuing...'.format(err_msg=str(ex))
)
common/djangoapps/course_groups/scope_resolver.py 0 → 100644
"""
A User Scope Resolver that can be used by edx-notifications
"""
import logging
from edx_notifications.scopes import NotificationUserScopeResolver
from .models import CourseUserGroup
log = logging.getLogger(__name__)
class CourseGroupScopeResolver(NotificationUserScopeResolver):
"""
Implementation of the NotificationUserScopeResolver abstract
interface defined in edx-notifications.
An instance of this class will be registered to handle
scope_name = 'course_group' during system startup.
We will be passed in a group_id in the context
and we must return a Django ORM resultset or None if
we cannot match
"""
def resolve(self, scope_name, scope_context, instance_context):
"""
The entry point to resolve a scope_name with a given scope_context
"""
if scope_name != 'course_group':
# we can't resolve any other scopes
return None
if 'group_id' not in scope_context:
# did not receive expected parameters
return None
return CourseUserGroup.objects.values_list('users', flat=True).filter(
id=scope_context['group_id']
)
common/djangoapps/course_groups/tasks.py 0 → 100644
"""
This file contains celery tasks for student course enrollment
"""
from celery.task import task
from .models import CourseUserGroup
from edx_notifications.lib.publisher import bulk_publish_notification_to_users
from student.models import CourseEnrollment
import logging
log = logging.getLogger(__name__)
@task()
def publish_course_group_notification_task(course_group_id, notification_msg, exclude_user_ids=None): # pylint: disable=invalid-name
"""
This function will call the edx_notifications api method "bulk_publish_notification_to_users"
and run as a new Celery task in order to broadcast a message to an entire course cohort
"""
# get the enrolled and active user_id list for this course.
user_ids = CourseUserGroup.objects.values_list('users', flat=True).filter(
id=course_group_id
)
try:
bulk_publish_notification_to_users(user_ids, notification_msg, exclude_user_ids=exclude_user_ids)
except Exception, ex:
# Notifications are never critical, so we don't want to disrupt any
# other logic processing. So log and continue.
log.exception(ex)
common/djangoapps/course_groups/tests/test_scope_resolver.py 0 → 100644
"""
Test cases for scope_resolver.py
"""
from django.test import TestCase
from student.tests.factories import UserFactory
from course_groups.scope_resolver import CourseGroupScopeResolver
from .test_views import CohortFactory
class ScopeResolverTests(TestCase):
"""
Tests for the scope resolver
"""
def setUp(self):
"""Creates cohorts for testing"""
self.course_id = 'foo/bar/baz'
self.cohort1_users = [UserFactory.create() for _ in range(3)]
self.cohort2_users = [UserFactory.create() for _ in range(2)]
self.cohort3_users = [UserFactory.create() for _ in range(2)]
self.cohort1 = CohortFactory.create(course_id=self.course_id, users=self.cohort1_users)
self.cohort2 = CohortFactory.create(course_id=self.course_id, users=self.cohort2_users)
self.cohort3 = CohortFactory.create(course_id=self.course_id, users=self.cohort3_users)
def test_resolve_cohort(self):
"""
Given the defined cohorts in the setUp, make sure the
"""
resolver = CourseGroupScopeResolver()
user_ids = resolver.resolve('course_group', {'group_id': self.cohort1.id}, None).all()
self.assertEqual(
[user_id for user_id in user_ids],
[user.id for user in self.cohort1_users]
)
def test_bad_params(self):
"""
Given the defined cohorts in the setUp, make sure the
"""
resolver = CourseGroupScopeResolver()
self.assertIsNone(resolver.resolve('bad', {'group_id': self.cohort1.id}, None))
self.assertIsNone(resolver.resolve('course_group', {'bad': self.cohort1.id}, None))
common/djangoapps/student/roles.py
......@@ -6,6 +6,7 @@ adding users, removing users, and listing members
from abc import ABCMeta, abstractmethod
from django.contrib.auth.models import User
from django.conf import settings
from student.models import CourseAccessRole
from xmodule_django.models import CourseKeyField
......@@ -310,3 +311,24 @@ class UserBasedRole(object):
* role (will be self.role--thus uninteresting)
"""
return CourseAccessRole.objects.filter(role=self.role, user=self.user)
def get_aggregate_exclusion_user_ids(course_key):
"""
This helper method will return the list of user ids that are marked in roles
that can be excluded from certain aggregate queries. The list of roles to exclude
can be defined in a AGGREGATION_EXCLUDE_ROLES settings variable
"""
exclude_user_ids = set()
exclude_role_list = getattr(settings, 'AGGREGATION_EXCLUDE_ROLES', [CourseObserverRole.ROLE])
for role in exclude_role_list:
users = CourseRole(role, course_key).users_with_role()
user_ids = set()
for user in users:
user_ids.add(user.id)
exclude_user_ids = exclude_user_ids.union(user_ids)
return exclude_user_ids
common/djangoapps/student/scope_resolver.py 0 → 100644
"""
A User Scope Resolver that can be used by edx-notifications
"""
import logging
from edx_notifications.scopes import NotificationUserScopeResolver
from student.models import CourseEnrollment
from django.contrib.auth.models import User
from opaque_keys.edx.keys import CourseKey
from opaque_keys import InvalidKeyError
from opaque_keys.edx.locations import SlashSeparatedCourseKey
log = logging.getLogger(__name__)
class CourseEnrollmentsScopeResolver(NotificationUserScopeResolver):
"""
Implementation of the NotificationUserScopeResolver abstract
interface defined in edx-notifications.
An instance of this class will be registered to handle
scope_name = 'course_enrollments' during system startup.
We will be passed in a course_id in the context
and we must return a Django ORM resultset or None if
we cannot match.
"""
def resolve(self, scope_name, scope_context, instance_context):
"""
The entry point to resolve a scope_name with a given scope_context
"""
if scope_name != 'course_enrollments':
# we can't resolve any other scopes
return None
if 'course_id' not in scope_context:
# did not receive expected parameters
return None
course_id = scope_context['course_id']
if not isinstance(course_id , CourseKey):
try:
course_key = CourseKey.from_string(course_id)
except InvalidKeyError:
course_key = SlashSeparatedCourseKey.from_deprecated_string(course_id)
else:
course_key = course_id
return CourseEnrollment.objects.values_list('user_id', flat=True).filter(
is_active=1,
course_id=course_key
)
class StudentEmailScopeResolver(NotificationUserScopeResolver):
"""
Implementation of the NotificationUserScopeResolver to
take in a user_id and return that user's email address
"""
def resolve(self, scope_name, scope_context, instance_context):
"""
The entry point to resolve a scope_name with a given scope_context
"""
if scope_name != 'student_email_resolver':
# we can't resolve any other scopes
return None
user_id = scope_context.get('user_id')
if not user_id:
return None
return User.objects.values_list('email', flat=True).filter(
id=user_id
)
common/djangoapps/student/tasks.py 0 → 100644
"""
This file contains celery tasks for student course enrollment
"""
from celery.task import task
from student.models import CourseEnrollment
from edx_notifications.lib.publisher import bulk_publish_notification_to_users
import logging
log = logging.getLogger(__name__)
@task()
def publish_course_notifications_task(course_id, notification_msg, exclude_user_ids=None): # pylint: disable=invalid-name
"""
This function will call the edx_notifications api method "bulk_publish_notification_to_users"
and run as a new Celery task.
"""
# get the enrolled and active user_id list for this course.
user_ids = CourseEnrollment.objects.values_list('user_id', flat=True).filter(
is_active=1,
course_id=course_id
)
try:
bulk_publish_notification_to_users(user_ids, notification_msg, exclude_user_ids=exclude_user_ids)
except Exception, ex:
# Notifications are never critical, so we don't want to disrupt any
# other logic processing. So log and continue.
log.exception(ex)
common/djangoapps/student/tests/test_scope_resolver.py 0 → 100644
"""
Test for student tasks.
"""
from student.tests.factories import UserFactory, CourseEnrollmentFactory
from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
from xmodule.modulestore.tests.factories import CourseFactory
from student.models import CourseEnrollment
from student.scope_resolver import CourseEnrollmentsScopeResolver, StudentEmailScopeResolver
class StudentTasksTestCase(ModuleStoreTestCase):
"""
Tests of student.roles
"""
def setUp(self):
"""
setUp stuff
"""
super(StudentTasksTestCase, self).setUp()
self.course = CourseFactory.create()
def test_resolve_course_enrollments(self):
"""
Test that the CourseEnrollmentsScopeResolver actually returns all enrollments
"""
test_user_1 = UserFactory.create(password='test_pass')
CourseEnrollmentFactory(user=test_user_1, course_id=self.course.id)
test_user_2 = UserFactory.create(password='test_pass')
CourseEnrollmentFactory(user=test_user_2, course_id=self.course.id)
test_user_3 = UserFactory.create(password='test_pass')
enrollment = CourseEnrollmentFactory(user=test_user_3, course_id=self.course.id)
# unenroll #3
enrollment.is_active = False
enrollment.save()
resolver = CourseEnrollmentsScopeResolver()
user_ids = resolver.resolve('course_enrollments', {'course_id': self.course.id}, None)
# should have first two, but the third should not be present
self.assertTrue(test_user_1.id in user_ids)
self.assertTrue(test_user_2.id in user_ids)
self.assertFalse(test_user_3.id in user_ids)
def test_bad_params(self):
"""
Makes sure the resolver returns None if all parameters aren't passed
"""
resolver = CourseEnrollmentsScopeResolver()
self.assertIsNone(resolver.resolve('bad', {'course_id': 'foo'}, None))
self.assertIsNone(resolver.resolve('course_enrollments', {'bad': 'foo'}, None))
def test_email_resolver(self):
"""
Make sure we can resolve emails
"""
test_user_1 = UserFactory.create(password='test_pass')
resolver = StudentEmailScopeResolver()
emails_resultset = resolver.resolve(
'student_email_resolver',
{
'user_id': test_user_1.id,
},
None
)
self.assertTrue(test_user_1.email in emails_resultset)
def test_bad_email_resolver(self):
"""
Cover some error cases
"""
resolver = StudentEmailScopeResolver()
self.assertIsNone(resolver.resolve('bad', {'course_id': 'foo'}, None))
self.assertIsNone(resolver.resolve('course_enrollments', {'bad': 'foo'}, None))
common/djangoapps/student/tests/test_tasks.py 0 → 100644
"""
Test for student tasks.
"""
from student.tasks import publish_course_notifications_task
from student.tests.factories import UserFactory, CourseEnrollmentFactory
from edx_notifications.data import NotificationMessage
from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
from xmodule.modulestore.tests.factories import CourseFactory
from edx_notifications.lib.publisher import get_notification_type
from xmodule.modulestore.django import modulestore
from edx_notifications.lib.consumer import get_notifications_count_for_user
from mock import patch
from lms import startup
class StudentTasksTestCase(ModuleStoreTestCase):
"""
Tests of student.roles
"""
def setUp(self):
super(StudentTasksTestCase, self).setUp()
self.course = CourseFactory.create()
@patch.dict("django.conf.settings.FEATURES", {"ENABLE_NOTIFICATIONS": True})
def test_course_bulk_notification_tests(self):
# create new users and enroll them in the course.
startup.startup_notification_subsystem()
test_user_1 = UserFactory.create(password='test_pass')
CourseEnrollmentFactory(user=test_user_1, course_id=self.course.id)
test_user_2 = UserFactory.create(password='test_pass')
CourseEnrollmentFactory(user=test_user_2, course_id=self.course.id)
notification_type = get_notification_type(u'open-edx.studio.announcements.new-announcement')
course = modulestore().get_course(self.course.id, depth=0)
notification_msg = NotificationMessage(
msg_type=notification_type,
namespace=unicode(self.course.id),
payload={
'_schema_version': '1',
'course_name': course.display_name,
}
)
# Send the notification_msg to the Celery task
publish_course_notifications_task.delay(self.course.id, notification_msg)
# now the enrolled users should get notification about the
# course update where they are enrolled as student.
self.assertTrue(get_notifications_count_for_user(test_user_1.id), 1)
self.assertTrue(get_notifications_count_for_user(test_user_2.id), 1)
common/djangoapps/util/html.py 0 → 100644
"""
Helper HTML related utility functions
"""
from HTMLParser import HTMLParser
class MLStripper(HTMLParser):
"""
Overrides HTMLParser which returns a string with the HTML
stripped out
"""
def __init__(self):
"""
Initializer
"""
self.reset()
self.fed = []
def handle_data(self, d):
"""
Override of HTMLParser
"""
self.fed.append(d)
def get_data(self):
"""
Returns the stripped out string
"""
return ''.join(self.fed)
def strip_tags(html):
"""
Calls into the MLStripper to return a string with HTML stripped out
"""
s = MLStripper()
s.feed(html)
return s.get_data()
common/lib/xmodule/xmodule/services.py 0 → 100644
"""
Module contains various XModule/XBlock services
"""
from django.conf import settings
import types
import edx_notifications.lib.publisher as notifications_publisher_lib
import edx_notifications.lib.consumer as notifications_consumer_lib
from xmodule.modulestore.django import modulestore
class SettingsService(object):
"""
Allows server-wide configuration of XBlocks on a per-type basis
XBlock settings are read from XBLOCK_SETTINGS settings key. Each XBlock is allowed access
to single settings bucket. Bucket is determined by this service using the following rules:
* Value of SettingsService.xblock_settings_bucket_selector is examined. If XBlock have attribute/property
with the name of that value this attribute/property is read to get the bucket key (e.g. if XBlock have
`block_settings_key = 'my_block_settings'`, bucket key would be 'my_block_settings').
* Otherwise, XBlock class name is used
Service is content-agnostic: it just returns whatever happen to be in the settings bucket (technically, it returns
the bucket itself).
If `default` argument is specified it is returned if:
* There are no XBLOCK_SETTINGS setting
* XBLOCK_SETTINGS is empty
* XBLOCK_SETTINGS does not contain settings bucket
If `default` is not specified or None, empty dictionary is used for default.
Example:
"XBLOCK_SETTINGS": {
"my_block": {
"setting1": 1,
"setting2": []
},
"my_other_block": [1, 2, 3],
"MyThirdBlock": "QWERTY"
}
class MyBlock: block_settings_key='my_block'
class MyOtherBlock: block_settings_key='my_other_block'
class MyThirdBlock: pass
class MissingBlock: pass
service = SettingsService()
service.get_settings_bucket(MyBlock()) # { "setting1": 1, "setting2": [] }
service.get_settings_bucket(MyOtherBlock()) # [1, 2, 3]
service.get_settings_bucket(MyThirdBlock()) # "QWERTY"
service.get_settings_bucket(MissingBlock()) # {}
service.get_settings_bucket(MissingBlock(), "default") # "default"
service.get_settings_bucket(MissingBlock(), None) # {}
"""
xblock_settings_bucket_selector = 'block_settings_key'
def get_settings_bucket(self, block, default=None):
""" Gets xblock settings dictionary from settings. """
if not block:
raise ValueError("Expected XBlock instance, got {0} of type {1}".format(block, type(block)))
actual_default = default if default is not None else {}
xblock_settings_bucket = getattr(block, self.xblock_settings_bucket_selector, block.unmixed_class.__name__)
xblock_settings = settings.XBLOCK_SETTINGS if hasattr(settings, "XBLOCK_SETTINGS") else {}
return xblock_settings.get(xblock_settings_bucket, actual_default)
class NotificationsService(object):
"""
An xBlock service for xBlocks to talk to the Notification subsystem. This class basically introspects
and exposes all functions in the Publisher and Consumer libraries, so it is a direct pass through.
NOTE: This is a Singleton class. We should only have one instance of it!
"""
_instance = None
def __new__(cls, *args, **kwargs):
"""
This is the class factory to make sure this is a Singleton
"""
if not cls._instance:
cls._instance = super(NotificationsService, cls).__new__(
cls, *args, **kwargs)
return cls._instance
def __init__(self):
"""
Class initializer, which just inspects the libraries and exposes the same functions
as a direct pass through
"""
self._bind_to_module_functions(notifications_publisher_lib)
self._bind_to_module_functions(notifications_consumer_lib)
def _bind_to_module_functions(self, module):
"""
"""
for attr_name in dir(module):
attr = getattr(module, attr_name, None)
if isinstance(attr, types.FunctionType):
if not hasattr(self, attr_name):
setattr(self, attr_name, attr)
class CoursewareParentInfoService(object):
"""
An xBlock service that provides information about the courseware parent. This could be
used for - say - generating breadcumbs
"""
_instance = None
def __new__(cls, *args, **kwargs):
"""
This is the class factory to make sure this is a Singleton
"""
if not cls._instance:
cls._instance = super(CoursewareParentInfoService, cls).__new__(
cls, *args, **kwargs)
return cls._instance
def get_parent_info(self, module):
"""
Returns the location and display name of the parent
"""
parent_location = modulestore().get_parent_location(module)
parent_module = modulestore().get_item(parent_location)
return {
'location': parent_location,
'display_name': parent_module.display_name
}
common/lib/xmodule/xmodule/tests/test_services.py 0 → 100644
"""
Tests for SettingsService
"""
import ddt
import mock
from unittest import TestCase
from django.conf import settings
from django.test.utils import override_settings
from xblock.runtime import Mixologist
from xmodule.services import SettingsService, NotificationsService
from edx_notifications.data import (
NotificationType
)
class _DummyBlock(object):
""" Dummy Xblock class """
pass
@ddt.ddt
class TestSettingsService(TestCase):
""" Test SettingsService """
xblock_setting_key1 = 'dummy_block'
xblock_setting_key2 = 'other_dummy_block'
def setUp(self):
""" Setting up tests """
super(TestSettingsService, self).setUp()
self.settings_service = SettingsService()
self.xblock_mock = mock.Mock()
self.xblock_mock.block_settings_key = self.xblock_setting_key1
self.xblock_mock.unmixed_class = mock.Mock()
self.xblock_mock.unmixed_class.__name__ = self.xblock_setting_key2
def test_get_given_none_throws_value_error(self):
""" Test that given None throws value error """
with self.assertRaises(ValueError):
self.settings_service.get_settings_bucket(None)
def test_get_return_default_if_xblock_settings_is_missing(self):
""" Test that returns default (or None if default not set) if XBLOCK_SETTINGS is not set """
self.assertFalse(hasattr(settings, 'XBLOCK_SETTINGS')) # precondition check
self.assertEqual(self.settings_service.get_settings_bucket(self.xblock_mock, 'zzz'), 'zzz')
def test_get_return_empty_dictionary_if_xblock_settings_and_default_is_missing(self):
""" Test that returns default (or None if default not set) if XBLOCK_SETTINGS is not set """
self.assertFalse(hasattr(settings, 'XBLOCK_SETTINGS')) # precondition check
self.assertEqual(self.settings_service.get_settings_bucket(self.xblock_mock), {})
@override_settings(XBLOCK_SETTINGS={xblock_setting_key2: {'b': 1}})
def test_get_returns_none_or_default_if_bucket_not_found(self):
""" Test if settings service returns default if setting not found """
self.assertEqual(getattr(settings, 'XBLOCK_SETTINGS'), {self.xblock_setting_key2: {'b': 1}})
self.assertEqual(self.settings_service.get_settings_bucket(self.xblock_mock), {})
self.assertEqual(self.settings_service.get_settings_bucket(self.xblock_mock, 123), 123)
@override_settings(XBLOCK_SETTINGS={xblock_setting_key1: 42})
def test_get_returns_correct_value(self):
""" Test if settings service returns correct bucket """
self.assertEqual(getattr(settings, 'XBLOCK_SETTINGS'), {self.xblock_setting_key1: 42})
self.assertEqual(self.settings_service.get_settings_bucket(self.xblock_mock), 42)
@override_settings(XBLOCK_SETTINGS={xblock_setting_key2: "I'm a setting"})
def test_get_respects_block_settings_key(self):
""" Test if settings service respects block_settings_key value """
self.assertEqual(getattr(settings, 'XBLOCK_SETTINGS'), {self.xblock_setting_key2: "I'm a setting"})
self.xblock_mock.block_settings_key = self.xblock_setting_key2
self.assertEqual(self.settings_service.get_settings_bucket(self.xblock_mock), "I'm a setting")
@override_settings(XBLOCK_SETTINGS={_DummyBlock.__name__: [1, 2, 3]})
def test_get_uses_class_name_if_block_settings_key_is_not_set(self):
""" Test if settings service uses class name if block_settings_key attribute does not exist """
mixologist = Mixologist([])
block = mixologist.mix(_DummyBlock)
self.assertEqual(getattr(settings, 'XBLOCK_SETTINGS'), {"_DummyBlock": [1, 2, 3]})
self.assertEqual(self.settings_service.get_settings_bucket(block), [1, 2, 3])
class TestNotificationsService(TestCase):
""" Test SettingsService """
def setUp(self):
""" Setting up tests """
super(TestNotificationsService, self).setUp()
self.notifications_service = NotificationsService()
def test_exposed_functions(self):
"""
Make sure the service exposes all of the edx_notifications library functions (that we know about for now)
"""
# publisher lib
self.assertTrue(hasattr(self.notifications_service, 'register_notification_type'))
self.assertTrue(hasattr(self.notifications_service, 'get_notification_type'))
self.assertTrue(hasattr(self.notifications_service, 'get_all_notification_types'))
self.assertTrue(hasattr(self.notifications_service, 'publish_notification_to_user'))
self.assertTrue(hasattr(self.notifications_service, 'bulk_publish_notification_to_users'))
# consumer lib
self.assertTrue(hasattr(self.notifications_service, 'get_notifications_count_for_user'))
self.assertTrue(hasattr(self.notifications_service, 'get_notification_for_user'))
self.assertTrue(hasattr(self.notifications_service, 'get_notifications_for_user'))
self.assertTrue(hasattr(self.notifications_service, 'mark_notification_read'))
self.assertTrue(hasattr(self.notifications_service, 'mark_all_user_notification_as_read'))
lms/djangoapps/api_manager/courses/views.py
......@@ -34,11 +34,11 @@ from progress.models import StudentProgress
from projects.models import Project, Workgroup
from projects.serializers import ProjectSerializer, BasicWorkgroupSerializer
from student.models import CourseEnrollment, CourseEnrollmentAllowed
from student.roles import CourseRole, CourseAccessRole, CourseInstructorRole, CourseStaffRole, CourseObserverRole, CourseAssistantRole, UserBasedRole
from student.roles import CourseRole, CourseAccessRole, CourseInstructorRole, CourseStaffRole, CourseObserverRole, CourseAssistantRole, UserBasedRole, get_aggregate_exclusion_user_ids
from xmodule.modulestore.django import modulestore
from api_manager.courseware_access import get_course, get_course_child, get_course_leaf_nodes, get_course_key, \
course_exists, get_modulestore, get_course_descriptor, get_aggregate_exclusion_user_ids
course_exists, get_modulestore, get_course_descriptor
from api_manager.models import CourseGroupRelationship, CourseContentGroupRelationship, GroupProfile
from progress.models import CourseModuleCompletion
from api_manager.permissions import SecureAPIView, SecureListAPIView
......
lms/djangoapps/api_manager/courseware_access.py
......@@ -5,7 +5,6 @@ from django.conf import settings
from courseware import courses, module_render
from courseware.model_data import FieldDataCache
from student.roles import CourseRole, CourseObserverRole
from opaque_keys import InvalidKeyError
from opaque_keys.edx.keys import CourseKey, UsageKey
from opaque_keys.edx.locations import SlashSeparatedCourseKey, Location
......@@ -152,24 +151,3 @@ def get_course_child_content(request, user, course_key, child_descriptor):
field_data_cache,
course_key)
return child_content
def get_aggregate_exclusion_user_ids(course_key):
"""
This helper method will return the list of user ids that are marked in roles
that can be excluded from certain aggregate queries. The list of roles to exclude
can be defined in a AGGREGATION_EXCLUDE_ROLES settings variable
"""
exclude_user_ids = set()
exclude_role_list = getattr(settings, 'AGGREGATION_EXCLUDE_ROLES', [CourseObserverRole.ROLE])
for role in exclude_role_list:
users = CourseRole(role, course_key).users_with_role()
user_ids = set()
for user in users:
user_ids.add(user.id)
exclude_user_ids = exclude_user_ids.union(user_ids)
return exclude_user_ids
lms/djangoapps/api_manager/sessions/views.py
......@@ -14,6 +14,7 @@ from api_manager.permissions import SecureAPIView
from rest_framework import status
from rest_framework.response import Response
from django.utils import timezone
from django.template import RequestContext
from util.bad_request_rate_limiter import BadRequestRateLimiter
......@@ -120,6 +121,10 @@ class SessionsList(SecureAPIView):
response_data['uri'] = '{}/{}'.format(base_uri, new_session.session_key)
response_status = status.HTTP_201_CREATED
# generate a CSRF tokens for any web clients that may need to
# call into the LMS via Ajax (for example Notifications)
response_data['csrftoken'] = RequestContext(request, {}).get('csrf_token')
# update the last_login fields in the auth_user table for this user
user.last_login = timezone.now()
user.save()
......
lms/djangoapps/api_manager/utils.py
......@@ -8,6 +8,7 @@ from django.utils.timezone import now
from dateutil.parser import parse
from dateutil.relativedelta import relativedelta, MO
from django.conf import settings
from student.roles import CourseRole, CourseObserverRole
def address_exists_in_network(ip_address, net_n_bits):
......
lms/djangoapps/courseware/module_render.py
......@@ -30,7 +30,13 @@ from courseware.access import has_access, get_user_role
from courseware.masquerade import setup_masquerade
from courseware.model_data import FieldDataCache, DjangoKeyValueStore
from lms.lib.xblock.field_data import LmsFieldData
from lms.lib.xblock.runtime import LmsModuleSystem, SettingsService, unquote_slashes, quote_slashes
from lms.lib.xblock.runtime import (
LmsModuleSystem,
SettingsService,
unquote_slashes,
quote_slashes
)
from xmodule.services import NotificationsService, CoursewareParentInfoService
from edxmako.shortcuts import render_to_string
from eventtracking import tracker
from psychometrics.psychoanalyze import make_psychometrics_data_update_handler
......@@ -543,6 +549,18 @@ def get_module_system_for_user(user, field_data_cache,
else:
anonymous_student_id = anonymous_id_for_user(user, None)
services_list = {
'i18n': ModuleI18nService(),
'fs': xblock.reference.plugins.FSService(),
'settings': SettingsService(),
'courseware_parent_info': CoursewareParentInfoService(),
}
if settings.FEATURES.get('ENABLE_NOTIFICATIONS', False):
services_list.update({
"notifications": NotificationsService(),
})
system = LmsModuleSystem(
track_function=track_function,
render_template=render_to_string,
......@@ -584,11 +602,7 @@ def get_module_system_for_user(user, field_data_cache,
mixins=descriptor.runtime.mixologist._mixins, # pylint: disable=protected-access
wrappers=block_wrappers,
get_real_user=user_by_anonymous_id,
services={
'i18n': ModuleI18nService(),
'fs': xblock.reference.plugins.FSService(),
'settings': SettingsService(),
},
services=services_list,
get_user_role=lambda: get_user_role(user, course_id),
descriptor_runtime=descriptor.runtime,
rebind_noauth_module_to_user=rebind_noauth_module_to_user,
......
lms/djangoapps/django_comment_client/urls.py
from django.conf.urls.defaults import url, patterns, include
urlpatterns = patterns('', # nopep8
url(r'forum/?', include('django_comment_client.forum.urls')),
url(r'forum/', include('django_comment_client.forum.urls')),
url(r'', include('django_comment_client.base.urls')),
)
lms/djangoapps/gradebook/management/commands/tests/test_generate_gradebook_entries.py
......@@ -21,6 +21,7 @@ from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
@override_settings(MODULESTORE=TEST_DATA_MIXED_MODULESTORE)
@patch.dict(settings.FEATURES, {'SIGNAL_ON_SCORE_CHANGED': True})
class GenerateGradebookEntriesTests(TestCase):
"""
Test suite for grade generation script
......
lms/djangoapps/gradebook/models.py
......@@ -13,7 +13,6 @@ from model_utils.models import TimeStampedModel
from student.models import CourseEnrollment
from xmodule_django.models import CourseKeyField
class StudentGradebook(TimeStampedModel):
"""
StudentGradebook is essentiall a container used to cache calculated
......@@ -98,23 +97,53 @@ class StudentGradebook(TimeStampedModel):
.order_by('-grade', 'modified')[:count]
# If a user_id value was provided, we need to provide some additional user-specific data to the caller
if user_id:
user_grade = 0
user_time_scored = timezone.now()
try:
user_queryset = StudentGradebook.objects.get(course_id__exact=course_key, user__id=user_id)
except StudentGradebook.DoesNotExist:
user_queryset = None
if user_queryset:
user_grade = user_queryset.grade
user_time_scored = user_queryset.created
users_above = queryset.filter(grade__gte=user_grade)\
.exclude(user__id=user_id)\
.exclude(grade=user_grade, modified__gt=user_time_scored)
data['user_position'] = len(users_above) + 1
data['user_grade'] = user_grade
result = cls.get_user_position(
course_key,
user_id,
queryset=queryset,
exclude_users=exclude_users
)
print 'result = {}'.format(result)
data.update(result)
return data
@classmethod
def get_user_position(cls, course_key, user_id, queryset=None, exclude_users=[]):
"""
Helper method to return the user's position in the leaderboard for Proficiency
"""
data = {'user_position': 0, 'user_grade': 0}
user_grade = 0
users_above = 0
user_time_scored = timezone.now()
try:
user_queryset = StudentGradebook.objects.get(course_id__exact=course_key, user__id=user_id)
except StudentGradebook.DoesNotExist:
user_queryset = None
if user_queryset:
user_grade = user_queryset.grade
user_time_scored = user_queryset.created
# if we were not passed in an existing queryset, build it up
if not queryset:
queryset = StudentGradebook.objects.select_related('user')\
.filter(
course_id__exact=course_key,
user__is_active=True,
user__courseenrollment__is_active=True,
user__courseenrollment__course_id__exact=course_key
).exclude(user__in=exclude_users)
users_above = queryset.filter(grade__gte=user_grade)\
.exclude(user__id=user_id)\
.exclude(grade=user_grade, modified__gt=user_time_scored)
data['user_position'] = len(users_above) + 1
data['user_grade'] = user_grade
return data
class StudentGradebookHistory(TimeStampedModel):
"""
......
lms/djangoapps/gradebook/receivers.py
"""
Signal handlers supporting various gradebook use cases
"""
import logging
import sys
from django.dispatch import receiver
from django.conf import settings
from django.db.models.signals import post_save, pre_save
from courseware import grades
from courseware.views import get_course
from courseware.signals import score_changed
from util.request import RequestMockWithoutMiddleware
from util.signals import course_deleted
from student.roles import get_aggregate_exclusion_user_ids
from gradebook.models import StudentGradebook, StudentGradebookHistory
from edx_notifications.lib.publisher import (
publish_notification_to_user,
get_notification_type
)
from edx_notifications.data import NotificationMessage
log = logging.getLogger(__name__)
@receiver(score_changed)
def on_score_changed(sender, **kwargs):
......@@ -45,3 +58,82 @@ def on_course_deleted(sender, **kwargs): # pylint: disable=W0613
course_key = kwargs['course_key']
StudentGradebook.objects.filter(course_id=course_key).delete()
StudentGradebookHistory.objects.filter(course_id=course_key).delete()
#
# Support for Notifications, these two receivers should actually be migrated into a new Leaderboard django app.
# For now, put the business logic here, but it is pretty decoupled through event signaling
# so we should be able to move these files easily when we are able to do so
#
@receiver(pre_save, sender=StudentGradebook)
def handle_studentgradebook_pre_save_signal(sender, instance, **kwargs):
"""
Handle the pre-save ORM event on CourseModuleCompletions
"""
if settings.FEATURES['ENABLE_NOTIFICATIONS']:
# attach the rank of the user before the save is completed
data = StudentGradebook.get_user_position(
instance.course_id,
instance.user.id,
exclude_users=get_aggregate_exclusion_user_ids(instance.course_id)
)
grade = data['user_grade']
leaderboard_rank = data['user_position'] if grade > 0.0 else 0
instance.presave_leaderboard_rank = leaderboard_rank
@receiver(post_save, sender=StudentGradebook)
def handle_studentgradebook_post_save_signal(sender, instance, **kwargs):
"""
Handle the pre-save ORM event on CourseModuleCompletions
"""
if settings.FEATURES['ENABLE_NOTIFICATIONS']:
# attach the rank of the user before the save is completed
data = StudentGradebook.get_user_position(
instance.course_id,
instance.user.id,
exclude_users=get_aggregate_exclusion_user_ids(instance.course_id)
)
leaderboard_rank = data['user_position']
grade = data['user_grade']
# logic for Notification trigger is when a user enters into the Leaderboard
if grade > 0.0:
leaderboard_size = getattr(settings, 'LEADERBOARD_SIZE', 3)
presave_leaderboard_rank = instance.presave_leaderboard_rank if instance.presave_leaderboard_rank else sys.maxint
if leaderboard_rank <= leaderboard_size and presave_leaderboard_rank > leaderboard_size:
try:
notification_msg = NotificationMessage(
msg_type=get_notification_type(u'open-edx.lms.leaderboard.gradebook.rank-changed'),
namespace=unicode(instance.course_id),
payload={
'_schema_version': '1',
'rank': leaderboard_rank,
'leaderboard_name': 'Proficiency',
}
)
#
# add in all the context parameters we'll need to
# generate a URL back to the website that will
# present the new course announcement
#
# IMPORTANT: This can be changed to msg.add_click_link() if we
# have a particular URL that we wish to use. In the initial use case,
# we need to make the link point to a different front end website
# so we need to resolve these links at dispatch time
#
notification_msg.add_click_link_params({
'course_id': unicode(instance.course_id),
})
publish_notification_to_user(int(instance.user.id), notification_msg)
except Exception, ex:
# Notifications are never critical, so we don't want to disrupt any
# other logic processing. So log and continue.
log.exception(ex)
lms/djangoapps/gradebook/tests.py
......@@ -24,6 +24,9 @@ from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
from gradebook.models import StudentGradebook, StudentGradebookHistory
from util.signals import course_deleted
from edx_notifications.lib.consumer import get_notifications_count_for_user
from edx_notifications.startup import initialize as initialize_notifications
@override_settings(MODULESTORE=TEST_DATA_MIXED_MODULESTORE)
@override_settings(STUDENT_GRADEBOOK=True)
class GradebookTests(TestCase):
......@@ -158,6 +161,27 @@ class GradebookTests(TestCase):
@patch.dict(settings.FEATURES, {
'ALLOW_STUDENT_STATE_UPDATES_ON_CLOSED_COURSE': False,
'SIGNAL_ON_SCORE_CHANGED': True,
'ENABLE_NOTIFICATIONS': True
})
@patch.dict(settings.FEATURES, {})
def test_notifications_publishing(self):
initialize_notifications()
# assert user has no notifications
self.assertEqual(get_notifications_count_for_user(self.user.id), 0)
self._create_course()
module = self.get_module_for_user(self.user, self.course, self.problem)
grade_dict = {'value': 0.75, 'max_value': 1, 'user_id': self.user.id}
module.system.publish(module, 'grade', grade_dict)
# user should have had a notification published as he/her is now in the
# leaderboard
self.assertEqual(get_notifications_count_for_user(self.user.id), 1)
@patch.dict(settings.FEATURES, {
'ALLOW_STUDENT_STATE_UPDATES_ON_CLOSED_COURSE': False,
'SIGNAL_ON_SCORE_CHANGED': True
})
def test_open_course(self):
......
lms/djangoapps/organizations/views.py
......@@ -10,13 +10,14 @@ from rest_framework import status, viewsets
from rest_framework.decorators import action
from rest_framework.response import Response
from api_manager.courseware_access import get_course_key, get_aggregate_exclusion_user_ids
from api_manager.courseware_access import get_course_key
from organizations.models import Organization
from api_manager.users.serializers import UserSerializer, SimpleUserSerializer
from api_manager.groups.serializers import GroupSerializer
from api_manager.utils import str2bool
from gradebook.models import StudentGradebook
from student.models import CourseEnrollment
from student.roles import get_aggregate_exclusion_user_ids
from .serializers import OrganizationSerializer
......
lms/djangoapps/progress/signals.py
......@@ -4,9 +4,16 @@ Signal handlers supporting various progress use cases
import sys
import logging
from django.dispatch import receiver
from django.db.models.signals import post_save
from django.db.models.signals import post_save, pre_save
from django.core.exceptions import ObjectDoesNotExist
from django.conf import settings
from student.roles import get_aggregate_exclusion_user_ids
from edx_notifications.lib.publisher import (
publish_notification_to_user,
get_notification_type
)
from edx_notifications.data import NotificationMessage
from progress.models import StudentProgress, StudentProgressHistory, CourseModuleCompletion
log = logging.getLogger(__name__)
......@@ -43,3 +50,77 @@ def save_history(sender, instance, **kwargs): # pylint: disable=no-self-argumen
completions=instance.completions
)
history_entry.save()
#
# Support for Notifications, these two receivers should actually be migrated into a new Leaderboard django app.
# For now, put the business logic here, but it is pretty decoupled through event signaling
# so we should be able to move these files easily when we are able to do so
#
@receiver(pre_save, sender=StudentProgress)
def handle_progress_pre_save_signal(sender, instance, **kwargs):
"""
Handle the pre-save ORM event on CourseModuleCompletions
"""
if settings.FEATURES['ENABLE_NOTIFICATIONS']:
# If notifications feature is enabled, then we need to get the user's
# rank before the save is made, so that we can compare it to
# after the save and see if the position changes
instance.presave_leaderboard_rank = StudentProgress.get_user_position(
instance.course_id,
instance.user.id,
get_aggregate_exclusion_user_ids(instance.course_id)
)['position']
@receiver(post_save, sender=StudentProgress)
def handle_progress_post_save_signal(sender, instance, **kwargs):
"""
Handle the pre-save ORM event on CourseModuleCompletions
"""
if settings.FEATURES['ENABLE_NOTIFICATIONS']:
# If notifications feature is enabled, then we need to get the user's
# rank before the save is made, so that we can compare it to
# after the save and see if the position changes
leaderboard_rank = StudentProgress.get_user_position(
instance.course_id,
instance.user.id,
get_aggregate_exclusion_user_ids(instance.course_id)
)['position']
# logic for Notification trigger is when a user enters into the Leaderboard
leaderboard_size = getattr(settings, 'LEADERBOARD_SIZE', 3)
presave_leaderboard_rank = instance.presave_leaderboard_rank if instance.presave_leaderboard_rank else sys.maxint
if leaderboard_rank <= leaderboard_size and presave_leaderboard_rank > leaderboard_size:
try:
notification_msg = NotificationMessage(
msg_type=get_notification_type(u'open-edx.lms.leaderboard.progress.rank-changed'),
namespace=unicode(instance.course_id),
payload={
'_schema_version': '1',
'rank': leaderboard_rank,
'leaderboard_name': 'Progress',
}
)
#
# add in all the context parameters we'll need to
# generate a URL back to the website that will
# present the new course announcement
#
# IMPORTANT: This can be changed to msg.add_click_link() if we
# have a particular URL that we wish to use. In the initial use case,
# we need to make the link point to a different front end website
# so we need to resolve these links at dispatch time
#
notification_msg.add_click_link_params({
'course_id': unicode(instance.course_id),
})
publish_notification_to_user(int(instance.user.id), notification_msg)
except Exception, ex:
# Notifications are never critical, so we don't want to disrupt any
# other logic processing. So log and continue.
log.exception(ex)
lms/djangoapps/progress/tests.py
......@@ -28,8 +28,12 @@ from courseware.model_data import FieldDataCache
from courseware import module_render
from util.signals import course_deleted
from edx_notifications.startup import initialize as initialize_notifications
from edx_notifications.lib.consumer import get_notifications_count_for_user
@override_settings(MODULESTORE=TEST_DATA_MIXED_MODULESTORE)
@override_settings(STUDENT_GRADEBOOK=True)
@patch.dict(settings.FEATURES, {'ENABLE_NOTIFICATIONS': True})
class CourseModuleCompletionTests(TestCase):
""" Test suite for CourseModuleCompletion """
......@@ -52,6 +56,8 @@ class CourseModuleCompletionTests(TestCase):
self.user = UserFactory()
self._create_course()
initialize_notifications()
def _create_course(self, start=None, end=None):
self.course = CourseFactory.create(
start=start,
......@@ -141,6 +147,31 @@ class CourseModuleCompletionTests(TestCase):
)
self.assertIsNotNone(completion_fetch)
def test_check_notifications(self):
"""
Save a CourseModuleCompletion and fetch it again
"""
module = self.get_module_for_user(self.user, self.course, self.problem4)
module.system.publish(module, 'progress', {})
completion_fetch = CourseModuleCompletion.objects.get(
user=self.user.id,
course_id=self.course.id,
content_id=self.problem4.location
)
self.assertIsNotNone(completion_fetch)
# since we are alone, then we should be listed as first
self.assertEqual(get_notifications_count_for_user(self.user.id), 1)
# progressing on a 2nd item, shouldn't change our positions, because
# we're the only one in this course
module = self.get_module_for_user(self.user, self.course, self.problem5)
module.system.publish(module, 'progress', {})
# since we are alone, then we should be listed as first
self.assertEqual(get_notifications_count_for_user(self.user.id), 1)
@patch.dict(settings.FEATURES, {'ALLOW_STUDENT_STATE_UPDATES_ON_CLOSED_COURSE': False})
def test_save_completion_with_feature_flag(self):
"""
......
lms/djangoapps/projects/models.py
......@@ -26,6 +26,19 @@ class Project(TimeStampedModel):
""" Meta class for defining additional model characteristics """
unique_together = ("course_id", "content_id", "organization")
@classmethod
def get_user_ids_in_project_by_content_id(cls, course_id, content_id):
"""
Returns a database cursor for all users associated with a project
specified by a content_id
"""
query = Project.objects.select_related('workgroups__users').values_list('workgroups__users', flat=True).filter(
course_id=course_id,
content_id=content_id
)
return query
class Workgroup(TimeStampedModel):
"""
......@@ -63,6 +76,19 @@ class Workgroup(TimeStampedModel):
workgroup_user = WorkgroupUser.objects.get(workgroup=self, user=user)
workgroup_user.delete()
@classmethod
def get_user_ids_in_workgroup(cls, workgroup_id):
"""
Returns a database cursor for all users associated with a project
specified by a content_id
"""
query = Workgroup.objects.select_related('users').values_list('users', flat=True).filter(
id=workgroup_id
)
return query
class WorkgroupUser(models.Model):
"""A Folder to store some data between a client and its insurance"""
......
lms/djangoapps/projects/scope_resolver.py 0 → 100644
"""
A User Scope Resolver that can be used by edx-notifications
"""
import logging
from edx_notifications.scopes import NotificationUserScopeResolver
from projects.models import Project, Workgroup
log = logging.getLogger(__name__)
class GroupProjectParticipantsScopeResolver(NotificationUserScopeResolver):
"""
Implementation of the NotificationUserScopeResolver abstract
interface defined in edx-notifications.
An instance of this class will be registered to handle
scope_name = 'group_project_participants' during system startup.
We will be passed in a content_id in the context
and we must return a Django ORM resultset or None if
we cannot match.
"""
def resolve(self, scope_name, scope_context, instance_context):
"""
The entry point to resolve a scope_name with a given scope_context
"""
if scope_name == 'group_project_participants':
content_id = scope_context.get('content_id')
course_id = scope_context.get('course_id')
if not content_id or not course_id:
return None
return Project.get_user_ids_in_project_by_content_id(course_id, content_id)
elif scope_name == 'group_project_workgroup':
workgroup_id = scope_context.get('workgroup_id')
if not workgroup_id:
return None
return Workgroup.get_user_ids_in_workgroup(workgroup_id)
else:
# we can't resolve any other scopes
return None
lms/djangoapps/projects/tests/test_projects.py
......@@ -13,6 +13,7 @@ from django.test import TestCase, Client
from django.test.utils import override_settings
from projects.models import Project, Workgroup
from projects.scope_resolver import GroupProjectParticipantsScopeResolver
TEST_API_KEY = str(uuid.uuid4())
......@@ -49,6 +50,12 @@ class ProjectsApiTests(TestCase):
is_active=True
)
self.test_user2 = User.objects.create(
email="test2@edx.org",
username="testing2",
is_active=True
)
self.test_project = Project.objects.create(
course_id=self.test_course_id,
content_id=self.test_course_content_id,
......@@ -61,6 +68,13 @@ class ProjectsApiTests(TestCase):
self.test_workgroup.add_user(self.test_user)
self.test_workgroup.save()
self.test_workgroup2 = Workgroup.objects.create(
name="Test Workgroup2",
project=self.test_project,
)
self.test_workgroup2.add_user(self.test_user2)
self.test_workgroup2.save()
self.client = SecureClient()
cache.clear()
......@@ -180,3 +194,70 @@ class ProjectsApiTests(TestCase):
self.assertEqual(response.status_code, 204)
response = self.do_get(test_uri)
self.assertEqual(response.status_code, 404)
def test_get_user_ids(self):
cursor = Project.get_user_ids_in_project_by_content_id(
self.test_course_id,
self.test_course_content_id
)
user_ids = [user_id for user_id in cursor.all()]
self.assertEqual(len(user_ids), 2)
self.assertIn(self.test_user.id, user_ids)
self.assertIn(self.test_user2.id, user_ids)
def test_get_workgroup_user_ids(self):
cursor = Workgroup.get_user_ids_in_workgroup(self.test_workgroup.id)
user_ids = [user_id for user_id in cursor.all()]
self.assertEqual(len(user_ids), 1)
self.assertIn(self.test_user.id, user_ids)
cursor = Workgroup.get_user_ids_in_workgroup(self.test_workgroup2.id)
user_ids = [user_id for user_id in cursor.all()]
self.assertEqual(len(user_ids), 1)
self.assertIn(self.test_user2.id, user_ids)
def test_scope_resolver(self):
cursor = GroupProjectParticipantsScopeResolver().resolve(
'group_project_participants',
{
'course_id': self.test_course_id,
'content_id': self.test_course_content_id
},
None
)
user_ids = [user_id for user_id in cursor.all()]
self.assertEqual(len(user_ids), 2)
self.assertIn(self.test_user.id, user_ids)
self.assertIn(self.test_user2.id, user_ids)
def test_workgroup_scope_resolver(self):
cursor = GroupProjectParticipantsScopeResolver().resolve(
'group_project_workgroup',
{
'workgroup_id': self.test_workgroup.id,
},
None
)
user_ids = [user_id for user_id in cursor.all()]
self.assertEqual(len(user_ids), 1)
self.assertIn(self.test_user.id, user_ids)
cursor = GroupProjectParticipantsScopeResolver().resolve(
'group_project_workgroup',
{
'workgroup_id': self.test_workgroup2.id,
},
None
)
user_ids = [user_id for user_id in cursor.all()]
self.assertEqual(len(user_ids), 1)
self.assertIn(self.test_user2.id, user_ids)
lms/djangoapps/social_engagement/__init__.py 0 → 100644
"""
This Djangoapp supports the concept of a Social Engagement based on activity in the forums
"""
lms/djangoapps/social_engagement/engagement.py 0 → 100644
"""
Business logic tier regarding social engagement scores
"""
import sys
import logging
from datetime import datetime
import pytz
from django.conf import settings
from .models import StudentSocialEngagementScore
from lms.lib.comment_client.user import get_user_social_stats
from xmodule.modulestore.django import modulestore
from opaque_keys.edx.keys import CourseKey
from student.models import CourseEnrollment
from student.roles import get_aggregate_exclusion_user_ids
from lms.lib.comment_client.utils import CommentClientRequestError
from requests.exceptions import ConnectionError
from django.dispatch import receiver
from django.db.models.signals import post_save, pre_save
from edx_notifications.lib.publisher import (
publish_notification_to_user,
get_notification_type
)
from edx_notifications.data import NotificationMessage
log = logging.getLogger(__name__)
def update_user_engagement_score(course_id, user_id, compute_if_closed_course=False, course_descriptor=None):
"""
Compute the user's Engagement Score and store it in the
database. We will not update the record, if the score
is the same as it currently exists
"""
if not settings.FEATURES.get('ENABLE_SOCIAL_ENGAGEMENT', False):
return
course_key = course_id if isinstance(course_id, CourseKey) else CourseKey.from_string(course_id)
if not course_descriptor:
# it course descriptor was not passed in (as an optimization)
course_descriptor = modulestore().get_course(course_key)
if not course_descriptor:
# couldn't find course?!?
return
if not compute_if_closed_course and course_descriptor.end:
# if course is closed then don't bother. Note
# we can override this if we want to force
# update
now_utc = datetime.now(pytz.UTC)
if now_utc > course_descriptor.end:
log.info('update_user_engagement_score() is skipping because the course is closed...')
return
previous_score = StudentSocialEngagementScore.get_user_engagement_score(course_key, user_id)
try:
log.info('Updating social engagement score for user_id {} in course_key {}'.format(user_id, course_key))
# cs_comment_service works is slash separated course_id strings
slash_course_id = course_key.to_deprecated_string()
# get the course social stats, passing along a course end date to remove any activity after the course
# closure from the stats. Note that we are calling out to the cs_comment_service
# and so there might be a HTTP based communication error
social_stats = _get_user_social_stats(user_id, slash_course_id, course_descriptor.end)
if social_stats:
current_score = _compute_social_engagement_score(social_stats)
log.info('previous_score = {} current_score = {}'.format(previous_score, current_score))
if current_score > previous_score or previous_score is None:
StudentSocialEngagementScore.save_user_engagement_score(course_key, user_id, current_score)
except (CommentClientRequestError, ConnectionError), error:
log.exception(error)
def _get_user_social_stats(user_id, slash_course_id, end_date):
"""
Helper function which basically calls into the cs_comment_service. We wrap this,
to make it easier to write mock functions for unit testing
"""
stats = get_user_social_stats(user_id, slash_course_id, end_date=end_date)
log.info('raw stats = {}'.format(stats))
# the comment service returns the user_id as a string
user_id_str = str(user_id)
if user_id_str in stats:
return stats[user_id_str]
else:
return None
def _compute_social_engagement_score(social_metrics):
"""
For a list of social_stats, compute the social score
"""
# we can override this in configuration, but this
# is default values
social_metric_points = getattr(
settings,
'SOCIAL_METRIC_POINTS',
{
'num_threads': 10,
'num_comments': 2,
'num_replies': 1,
'num_upvotes': 5,
'num_thread_followers': 5,
'num_comments_generated': 1,
}
)
social_total = 0
for key, val in social_metric_points.iteritems():
social_total += social_metrics.get(key, 0) * val
return social_total
def update_course_engagement_scores(course_id, compute_if_closed_course=False, course_descriptor=None):
"""
Iterate over all active course enrollments and update the
students engagement scores
"""
course_key = course_id if isinstance(course_id, CourseKey) else CourseKey.from_string(course_id)
if not course_descriptor:
# pre-fetch course descriptor, so we don't have to refetch later
# over and over again
course_descriptor = modulestore().get_course(course_key)
if not course_descriptor:
return
user_ids = CourseEnrollment.objects.values_list('user_id', flat=True).filter(
is_active=1,
course_id=course_key
)
for user_id in user_ids:
update_user_engagement_score(course_key, user_id, compute_if_closed_course=compute_if_closed_course, course_descriptor=course_descriptor)
def update_all_courses_engagement_scores(compute_if_closed_course=False):
"""
Iterates over all courses in the modelstore and computes engagment
scores for all enrolled students
"""
courses = modulestore().get_courses()
for course in courses:
update_course_engagement_scores(
course.id,
compute_if_closed_course=compute_if_closed_course,
course_descriptor=course
)
#
# Support for Notifications, these two receivers should actually be migrated into a new Leaderboard django app.
# For now, put the business logic here, but it is pretty decoupled through event signaling
# so we should be able to move these files easily when we are able to do so
#
@receiver(pre_save, sender=StudentSocialEngagementScore)
def handle_progress_pre_save_signal(sender, instance, **kwargs):
"""
Handle the pre-save ORM event on StudentSocialEngagementScore
"""
if settings.FEATURES['ENABLE_NOTIFICATIONS']:
# If notifications feature is enabled, then we need to get the user's
# rank before the save is made, so that we can compare it to
# after the save and see if the position changes
instance.presave_leaderboard_rank = StudentSocialEngagementScore.get_user_leaderboard_position(
instance.course_id,
instance.user.id,
get_aggregate_exclusion_user_ids(instance.course_id)
)['position']
@receiver(post_save, sender=StudentSocialEngagementScore)
def handle_progress_post_save_signal(sender, instance, **kwargs):
"""
Handle the pre-save ORM event on CourseModuleCompletions
"""
if settings.FEATURES['ENABLE_NOTIFICATIONS']:
# If notifications feature is enabled, then we need to get the user's
# rank before the save is made, so that we can compare it to
# after the save and see if the position changes
leaderboard_rank = StudentSocialEngagementScore.get_user_leaderboard_position(
instance.course_id,
instance.user.id,
get_aggregate_exclusion_user_ids(instance.course_id)
)['position']
# logic for Notification trigger is when a user enters into the Leaderboard
leaderboard_size = getattr(settings, 'LEADERBOARD_SIZE', 3)
presave_leaderboard_rank = instance.presave_leaderboard_rank if instance.presave_leaderboard_rank else sys.maxint
if leaderboard_rank <= leaderboard_size and presave_leaderboard_rank > leaderboard_size:
try:
notification_msg = NotificationMessage(
msg_type=get_notification_type(u'open-edx.lms.leaderboard.engagement.rank-changed'),
namespace=unicode(instance.course_id),
payload={
'_schema_version': '1',
'rank': leaderboard_rank,
'leaderboard_name': 'Engagement',
}
)
#
# add in all the context parameters we'll need to
# generate a URL back to the website that will
# present the new course announcement
#
# IMPORTANT: This can be changed to msg.add_click_link() if we
# have a particular URL that we wish to use. In the initial use case,
# we need to make the link point to a different front end website
# so we need to resolve these links at dispatch time
#
notification_msg.add_click_link_params({
'course_id': unicode(instance.course_id),
})
publish_notification_to_user(int(instance.user.id), notification_msg)
except Exception, ex:
# Notifications are never critical, so we don't want to disrupt any
# other logic processing. So log and continue.
log.exception(ex)
lms/djangoapps/social_engagement/management/commands/generate_engagement_entries.py 0 → 100644
"""
One-time data migration script -- shoulen't need to run it again
"""
import logging
from django.conf import settings
from optparse import make_option
from django.core.management.base import BaseCommand
from social_engagement.engagement import (
update_all_courses_engagement_scores,
update_course_engagement_scores,
update_user_engagement_score
)
from mock import patch
log = logging.getLogger(__name__)
class Command(BaseCommand):
"""
Creates (or updates) social engagement entries for the specified course(s) and/or user(s)
"""
# don't send out notifications on management command executions
@patch.dict(settings.FEATURES, {'ENABLE_NOTIFICATIONS': False})
def handle(self, *args, **options):
help = "Command to creaete or update social engagement entries"
option_list = BaseCommand.option_list + (
make_option(
"-c",
"--course_ids",
dest="course_ids",
help="List of courses for which to generate social engagement",
metavar="first/course/id,second/course/id"
),
make_option(
"-u",
"--user_ids",
dest="user_ids",
help="List of users for which to generate social engagement",
metavar="1234,2468,3579"
),
)
course_ids = options.get('course_ids')
user_ids = options.get('user_ids')
if course_ids:
# over a few specific courses?
for course_id in course_ids:
if user_ids:
# over a few specific users in those courses?
for user_id in user_ids:
update_user_engagement_score(course_id, user_id, compute_if_closed_course=True)
else:
update_course_engagement_scores(course_id, compute_if_closed_course=True)
else:
print 'Updating social engagement scores in all courses...'
update_all_courses_engagement_scores(compute_if_closed_course=True)
lms/djangoapps/social_engagement/management/commands/tests/tests.py 0 → 100644
"""
Tests for the social_engagment subsystem
paver test_system -s lms --test_id=lms/djangoapps/social_engagements/tests/test_engagement.py
"""
from django.conf import settings
from mock import MagicMock, patch
from django.test import TestCase
from django.test.utils import override_settings
from courseware.tests.modulestore_config import TEST_DATA_MIXED_MODULESTORE
from student.tests.factories import UserFactory
from student.models import CourseEnrollment
from xmodule.modulestore.tests.factories import CourseFactory
from social_engagement.models import StudentSocialEngagementScore, StudentSocialEngagementScoreHistory
from social_engagement.engagement import update_user_engagement_score
from social_engagement.engagement import update_course_engagement_scores
from social_engagement.engagement import update_all_courses_engagement_scores
from edx_notifications.startup import initialize as initialize_notifications
from edx_notifications.lib.consumer import get_notifications_count_for_user
from social_engagement.management.commands.generate_engagement_entries import Command
@override_settings(MODULESTORE=TEST_DATA_MIXED_MODULESTORE)
@patch.dict(settings.FEATURES, {'ENABLE_NOTIFICATIONS': True})
@patch.dict(settings.FEATURES, {'ENABLE_SOCIAL_ENGAGEMENT': True})
class StudentEngagementTests(TestCase):
""" Test suite for CourseModuleCompletion """
def setUp(self):
self.user = UserFactory()
self.user2 = UserFactory()
self._create_course()
initialize_notifications()
def _create_course(self, start=None, end=None):
self.course = CourseFactory.create(
start=start,
end=end
)
self.course2 = CourseFactory.create(
org='foo',
course='bar',
run='baz',
start=start,
end=end
)
CourseEnrollment.enroll(self.user, self.course.id)
CourseEnrollment.enroll(self.user2, self.course.id)
CourseEnrollment.enroll(self.user, self.course2.id)
def test_management_command(self):
"""
Verify that we get None back
"""
self.assertIsNone(StudentSocialEngagementScore.get_user_engagement_score(self.course.id, self.user.id))
self.assertIsNone(StudentSocialEngagementScore.get_user_engagement_score(self.course.id, self.user2.id))
self.assertEqual(get_notifications_count_for_user(self.user.id), 0)
self.assertEqual(get_notifications_count_for_user(self.user2.id), 0)
with patch('social_engagement.engagement._get_user_social_stats') as mock_func:
mock_func.return_value = {
'num_threads': 1,
'num_comments': 1,
'num_replies': 1,
'num_upvotes': 1,
'num_thread_followers': 1,
'num_comments_generated': 1,
}
Command().handle()
# shouldn't be anything in there because course is closed
leaderboard = StudentSocialEngagementScore.generate_leaderboard(self.course.id)
self.assertEqual(len(leaderboard), 2)
leaderboard = StudentSocialEngagementScore.generate_leaderboard(self.course2.id)
self.assertEqual(len(leaderboard), 1)
self.assertEqual(get_notifications_count_for_user(self.user.id), 0)
self.assertEqual(get_notifications_count_for_user(self.user2.id), 0)
def test_management_command_course(self):
"""
Verify that we get None back
"""
self.assertIsNone(StudentSocialEngagementScore.get_user_engagement_score(self.course.id, self.user.id))
self.assertIsNone(StudentSocialEngagementScore.get_user_engagement_score(self.course.id, self.user2.id))
self.assertEqual(get_notifications_count_for_user(self.user.id), 0)
self.assertEqual(get_notifications_count_for_user(self.user2.id), 0)
with patch('social_engagement.engagement._get_user_social_stats') as mock_func:
mock_func.return_value = {
'num_threads': 1,
'num_comments': 1,
'num_replies': 1,
'num_upvotes': 1,
'num_thread_followers': 1,
'num_comments_generated': 1,
}
Command().handle(course_ids=[self.course.id])
# shouldn't be anything in there because course is closed
leaderboard = StudentSocialEngagementScore.generate_leaderboard(self.course.id)
self.assertEqual(len(leaderboard), 2)
leaderboard = StudentSocialEngagementScore.generate_leaderboard(self.course2.id)
self.assertEqual(len(leaderboard), 0)
self.assertEqual(get_notifications_count_for_user(self.user.id), 0)
self.assertEqual(get_notifications_count_for_user(self.user2.id), 0)
def test_management_command_user(self):
"""
Verify that we get None back
"""
self.assertIsNone(StudentSocialEngagementScore.get_user_engagement_score(self.course.id, self.user.id))
self.assertIsNone(StudentSocialEngagementScore.get_user_engagement_score(self.course.id, self.user2.id))
self.assertEqual(get_notifications_count_for_user(self.user.id), 0)
self.assertEqual(get_notifications_count_for_user(self.user2.id), 0)
with patch('social_engagement.engagement._get_user_social_stats') as mock_func:
mock_func.return_value = {
'num_threads': 1,
'num_comments': 1,
'num_replies': 1,
'num_upvotes': 1,
'num_thread_followers': 1,
'num_comments_generated': 1,
}
Command().handle(course_ids=[self.course.id], user_ids=[self.user.id])
# shouldn't be anything in there because course is closed
leaderboard = StudentSocialEngagementScore.generate_leaderboard(self.course.id)
self.assertEqual(len(leaderboard), 1)
self.assertEqual(leaderboard[0]['user__id'], self.user.id)
leaderboard = StudentSocialEngagementScore.generate_leaderboard(self.course2.id)
self.assertEqual(len(leaderboard), 0)
self.assertEqual(get_notifications_count_for_user(self.user.id), 0)
self.assertEqual(get_notifications_count_for_user(self.user2.id), 0)
lms/djangoapps/social_engagement/migrations/0001_initial.py 0 → 100644
# -*- 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 'StudentSocialEngagementScore'
db.create_table('social_engagement_studentsocialengagementscore', (
('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
('created', self.gf('model_utils.fields.AutoCreatedField')(default=datetime.datetime.now)),
('modified', self.gf('model_utils.fields.AutoLastModifiedField')(default=datetime.datetime.now)),
('user', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['auth.User'])),
('course_id', self.gf('xmodule_django.models.CourseKeyField')(db_index=True, max_length=255, blank=True)),
('score', self.gf('django.db.models.fields.IntegerField')(default=0, db_index=True)),
))
db.send_create_signal('social_engagement', ['StudentSocialEngagementScore'])
# Adding unique constraint on 'StudentSocialEngagementScore', fields ['user', 'course_id']
db.create_unique('social_engagement_studentsocialengagementscore', ['user_id', 'course_id'])
# Adding model 'StudentSocialEngagementScoreHistory'
db.create_table('social_engagement_studentsocialengagementscorehistory', (
('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
('created', self.gf('model_utils.fields.AutoCreatedField')(default=datetime.datetime.now)),
('modified', self.gf('model_utils.fields.AutoLastModifiedField')(default=datetime.datetime.now)),
('user', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['auth.User'])),
('course_id', self.gf('xmodule_django.models.CourseKeyField')(db_index=True, max_length=255, blank=True)),
('score', self.gf('django.db.models.fields.IntegerField')()),
))
db.send_create_signal('social_engagement', ['StudentSocialEngagementScoreHistory'])
def backwards(self, orm):
# Removing unique constraint on 'StudentSocialEngagementScore', fields ['user', 'course_id']
db.delete_unique('social_engagement_studentsocialengagementscore', ['user_id', 'course_id'])
# Deleting model 'StudentSocialEngagementScore'
db.delete_table('social_engagement_studentsocialengagementscore')
# Deleting model 'StudentSocialEngagementScoreHistory'
db.delete_table('social_engagement_studentsocialengagementscorehistory')
models = {
'auth.group': {
'Meta': {'object_name': 'Group'},
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
},
'auth.permission': {
'Meta': {'ordering': "('content_type__app_label', 'content_type__model', 'codename')", 'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'},
'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
'auth.user': {
'Meta': {'object_name': 'User'},
'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
},
'contenttypes.contenttype': {
'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'social_engagement.studentsocialengagementscore': {
'Meta': {'unique_together': "(('user', 'course_id'),)", 'object_name': 'StudentSocialEngagementScore'},
'course_id': ('xmodule_django.models.CourseKeyField', [], {'db_index': 'True', 'max_length': '255', 'blank': 'True'}),
'created': ('model_utils.fields.AutoCreatedField', [], {'default': 'datetime.datetime.now'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'modified': ('model_utils.fields.AutoLastModifiedField', [], {'default': 'datetime.datetime.now'}),
'score': ('django.db.models.fields.IntegerField', [], {'default': '0', 'db_index': 'True'}),
'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']"})
},
'social_engagement.studentsocialengagementscorehistory': {
'Meta': {'object_name': 'StudentSocialEngagementScoreHistory'},
'course_id': ('xmodule_django.models.CourseKeyField', [], {'db_index': 'True', 'max_length': '255', 'blank': 'True'}),
'created': ('model_utils.fields.AutoCreatedField', [], {'default': 'datetime.datetime.now'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'modified': ('model_utils.fields.AutoLastModifiedField', [], {'default': 'datetime.datetime.now'}),
'score': ('django.db.models.fields.IntegerField', [], {}),
'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']"})
}
}
complete_apps = ['social_engagement']
\ No newline at end of file
lms/djangoapps/social_engagement/models.py 0 → 100644
"""
Django database models supporting the social_engagement app
"""
from django.contrib.auth.models import User
from django.db import models
from django.db.models import Q
from django.dispatch import receiver
from django.db.models.signals import post_save
from model_utils.models import TimeStampedModel
from xmodule_django.models import CourseKeyField
class StudentSocialEngagementScore(TimeStampedModel):
"""
StudentProgress is essentially a container used to store calculated progress of user
"""
user = models.ForeignKey(User, db_index=True, null=False)
course_id = CourseKeyField(db_index=True, max_length=255, blank=True, null=False)
score = models.IntegerField(default=0, db_index=True, null=False)
class Meta:
"""
Meta information for this Django model
"""
unique_together = (('user', 'course_id'),)
@classmethod
def get_user_engagement_score(cls, course_key, user_id):
"""
Returns the user's current engagement score or None
if there is no record yet
"""
try:
entry = cls.objects.get(course_id__exact=course_key, user__id=user_id)
except cls.DoesNotExist:
return None
return entry.score
@classmethod
def save_user_engagement_score(cls, course_key, user_id, score):
"""
Creates or updates an engagement score
"""
if cls.objects.filter(course_id__exact=course_key, user_id=user_id).exists():
entry = cls.objects.get(course_id__exact=course_key, user_id=user_id)
entry.score = score
else:
entry = cls(course_id=course_key, user_id=user_id, score=score)
entry.save()
@classmethod
def get_user_leaderboard_position(cls, course_key, user_id, exclude_users=None):
"""
Returns user's progress position and completions for a given course.
data = {"score": 22, "position": 4}
"""
data = {"score": 0, "position": 0}
try:
queryset = cls.objects.get(course_id__exact=course_key, user__id=user_id)
except cls.DoesNotExist:
queryset = None
if queryset:
user_score = queryset.score
query = cls.objects.filter(Q(score__gt=user_score),
course_id__exact=course_key, user__is_active=True)
if exclude_users:
query = query.exclude(user__id__in=exclude_users)
users_above = query.count()
data['position'] = users_above + 1 if user_score > 0 else 0
data['score'] = user_score
return data
@classmethod
def generate_leaderboard(cls, course_key, count=3, exclude_users=None, org_ids=None):
"""
Assembles a data set representing the Top N users, by progress, for a given course.
data = [
{'id': 123, 'username': 'testuser1', 'title', 'Engineer', 'avatar_url': 'http://gravatar.com/123/', 'score': 80},
{'id': 983, 'username': 'testuser2', 'title', 'Analyst', 'avatar_url': 'http://gravatar.com/983/', 'score': 70},
{'id': 246, 'username': 'testuser3', 'title', 'Product Owner', 'avatar_url': 'http://gravatar.com/246/', 'score': 62},
{'id': 357, 'username': 'testuser4', 'title', 'Director', 'avatar_url': 'http://gravatar.com/357/', 'completions': 58},
]
"""
queryset = cls.objects\
.filter(course_id__exact=course_key, user__is_active=True, user__courseenrollment__is_active=True,
user__courseenrollment__course_id__exact=course_key)
if exclude_users:
queryset = queryset.exclude(user__id__in=exclude_users)
if org_ids:
queryset = queryset.filter(user__organizations__in=org_ids)
queryset = queryset.values(
'user__id',
'user__username',
'user__profile__title',
'user__profile__avatar_url',
'score')\
.order_by('-score', 'modified')[:count]
return queryset
class StudentSocialEngagementScoreHistory(TimeStampedModel):
"""
A running audit trail for the StudentProgress model. Listens for
post_save events and creates/stores copies of progress entries.
"""
user = models.ForeignKey(User, db_index=True)
course_id = CourseKeyField(db_index=True, max_length=255, blank=True)
score = models.IntegerField()
@receiver(post_save, sender=StudentSocialEngagementScore)
def on_studentengagementscore_save(sender, instance, **kwargs):
"""
When a studentengagementscore is saved, we want to also store the
score value in the history table, so we have a complete history
of the student's engagement score
"""
history_entry = StudentSocialEngagementScoreHistory(
user=instance.user,
course_id=instance.course_id,
score=instance.score
)
history_entry.save()
lms/djangoapps/social_engagement/tests/__init__.py 0 → 100644
"""
Tests for the social_engagement app
"""
lms/envs/aws.py
......@@ -70,10 +70,13 @@ BROKER_HEARTBEAT_CHECKRATE = 2
# Each worker should only fetch one message at a time
CELERYD_PREFETCH_MULTIPLIER = 1
if not 'SOUTH_MIGRATION_MODULES' in vars() and not 'SOUTH_MIGRATION_MODULES' in globals():
SOUTH_MIGRATION_MODULES = {}
# Skip djcelery migrations, since we don't use the database as the broker
SOUTH_MIGRATION_MODULES = {
SOUTH_MIGRATION_MODULES.update({
'djcelery': 'ignore',
}
})
# Rename the exchange and queues for each variant
......@@ -507,3 +510,14 @@ API_ALLOWED_IP_ADDRESSES = ENV_TOKENS.get('API_ALLOWED_IP_ADDRESSES')
EXCLUDE_MIDDLEWARE_CLASSES = ENV_TOKENS.get('EXCLUDE_MIDDLEWARE_CLASSES', [])
MIDDLEWARE_CLASSES = tuple(_class for _class in MIDDLEWARE_CLASSES if _class not in EXCLUDE_MIDDLEWARE_CLASSES)
##### EDX-NOTIFICATIONS ######
NOTIFICATION_CLICK_LINK_URL_MAPS = ENV_TOKENS.get('NOTIFICATION_CLICK_LINK_URL_MAPS', NOTIFICATION_CLICK_LINK_URL_MAPS)
NOTIFICATION_STORE_PROVIDER = ENV_TOKENS.get('NOTIFICATION_STORE_PROVIDER', NOTIFICATION_STORE_PROVIDER)
NOTIFICATION_CHANNEL_PROVIDERS = ENV_TOKENS.get('NOTIFICATION_CHANNEL_PROVIDERS', NOTIFICATION_CHANNEL_PROVIDERS)
NOTIFICATION_CHANNEL_PROVIDER_TYPE_MAPS = ENV_TOKENS.get(
'NOTIFICATION_CHANNEL_PROVIDER_TYPE_MAPS',
NOTIFICATION_CHANNEL_PROVIDER_TYPE_MAPS
)
NOTIFICATION_MAX_LIST_SIZE = ENV_TOKENS.get('NOTIFICATION_MAX_LIST_SIZE', NOTIFICATION_MAX_LIST_SIZE)
lms/envs/common.py
......@@ -306,7 +306,17 @@ FEATURES = {
'PROJECTS_APP': False,
# Enable the Organizations,
'ORGANIZATIONS_APP': False
'ORGANIZATIONS_APP': False,
# Enable the edx-notifications subssytem
'ENABLE_NOTIFICATIONS': False,
# Whether edx-notifications should use Celery for bulk operations
'ENABLE_NOTIFICATIONS_CELERY': False,
# whether to turn on Social Engagment scoring
# driven through the comment service
'ENABLE_SOCIAL_ENGAGEMENT': False,
}
# Ignore static asset files on import which match this pattern
......@@ -966,7 +976,10 @@ courseware_js = (
main_vendor_js = [
'js/vendor/require.js',
'js/RequireJS-namespace-undefine.js',
# Use the RequireJS-namespace.js rather than the 'undefine' version of it
# because otherwise our use of a 'text' plugin for RequireJS will fail
# 'js/RequireJS-namespace-undefine.js',
'js/RequireJS-namespace.js',
'js/vendor/json2.js',
'js/vendor/jquery.min.js',
'js/vendor/jquery-ui.min.js',
......@@ -1422,6 +1435,9 @@ INSTALLED_APPS = (
# EDX API application
'api_manager',
# Social Engagement
'social_engagement',
)
######################### MARKETING SITE ###############################
......@@ -1809,3 +1825,74 @@ AUTO_REGISTRATION_AB_TEST_EXCLUDE_COURSES = set([
"HarvardX/SW12.9x/3T2014",
"HarvardX/SW12.8x/3T2014",
])
################################### EDX-NOTIFICATIONS SUBSYSTEM ######################################
INSTALLED_APPS += (
'edx_notifications',
'edx_notifications.server.web',
)
TEMPLATE_LOADERS += (
'django.template.loaders.filesystem.Loader',
'django.template.loaders.app_directories.Loader',
)
NOTIFICATION_STORE_PROVIDER = {
"class": "edx_notifications.stores.sql.store_provider.SQLNotificationStoreProvider",
"options": {
}
}
if not 'SOUTH_MIGRATION_MODULES' in vars() and not 'SOUTH_MIGRATION_MODULES' in globals():
SOUTH_MIGRATION_MODULES = {}
SOUTH_MIGRATION_MODULES.update({
'edx_notifications': 'edx_notifications.stores.sql.migrations',
})
# to prevent run-away queries from happening
NOTIFICATION_MAX_LIST_SIZE = 100
#
# Various mapping tables which is used by the MsgTypeToUrlLinkResolver
# to map a notification type to a statically defined URL path
#
# NOTE: NOTIFICATION_CLICK_LINK_GROUP_URLS will usually get read in by the *.envs.json file
#
NOTIFICATION_CLICK_LINK_URL_MAPS = {
'open-edx.studio.announcements.*': '/courses/{course_id}/announcements',
'open-edx.lms.leaderboard.*': '/courses/{course_id}/cohort',
'open-edx.lms.discussions.*': '/courses/{course_id}/discussion/{commentable_id}/threads/{thread_id}',
'open-edx.xblock.group-project.*': '/courses/{course_id}/group_work?seqid={activity_location}',
}
# list all known channel providers
NOTIFICATION_CHANNEL_PROVIDERS = {
'durable': {
'class': 'edx_notifications.channels.durable.BaseDurableNotificationChannel',
'options': {
# list out all link resolvers
'link_resolvers': {
# right now the only defined resolver is 'type_to_url', which
# attempts to look up the msg type (key) via
# matching on the value
'msg_type_to_url': {
'class': 'edx_notifications.channels.link_resolvers.MsgTypeToUrlLinkResolver',
'config': {
'_click_link': NOTIFICATION_CLICK_LINK_URL_MAPS,
}
}
}
}
},
'null': {
'class': 'edx_notifications.channels.null.NullNotificationChannel',
'options': {}
}
}
# list all of the mappings of notification types to channel
NOTIFICATION_CHANNEL_PROVIDER_TYPE_MAPS = {
'*': 'durable', # default global mapping
}
lms/lib/comment_client/thread.py
......@@ -193,6 +193,21 @@ class Thread(models.Model):
)
self._update_from_response(response)
def get_num_followers(self, include_self_follow=False):
url = _url_for_num_thread_followers(self.id)
params = {}
if not include_self_follow:
params ={
'exclude_user_id': self.user_id
}
response = perform_request(
'get',
url,
params
)
return response['num_followers']
def get_course_thread_stats(course_id):
"""
......@@ -224,3 +239,6 @@ def _url_for_un_pin_thread(thread_id):
def _url_for_course_thread_stats(course_id):
return "{prefix}/courses/{course_id}/stats".format(prefix=settings.PREFIX, course_id=course_id)
def _url_for_num_thread_followers(thread_id):
return "{prefix}/threads/{thread_id}/num_followers".format(prefix=settings.PREFIX, thread_id=thread_id)
lms/startup.py
......@@ -13,8 +13,15 @@ import logging
from monkey_patch import django_utils_translation
import analytics
from course_groups.scope_resolver import CourseGroupScopeResolver
from student.scope_resolver import CourseEnrollmentsScopeResolver, StudentEmailScopeResolver
from projects.scope_resolver import GroupProjectParticipantsScopeResolver
from edx_notifications.scopes import register_user_scope_resolver
log = logging.getLogger(__name__)
from edx_notifications import startup
def run():
"""
......@@ -31,6 +38,9 @@ def run():
add_mimetypes()
if settings.FEATURES.get('ENABLE_NOTIFICATIONS', False):
startup_notification_subsystem()
if settings.FEATURES.get('USE_CUSTOM_THEME', False):
enable_theme()
......@@ -40,7 +50,7 @@ def run():
if settings.FEATURES.get('ENABLE_THIRD_PARTY_AUTH', False):
enable_third_party_auth()
# Initialize Segment.io analytics module. Flushes first time a message is received and
# Initialize Segment.io analytics module. Flushes first time a message is received and
# every 50 messages thereafter, or if 10 seconds have passed since last flush
if settings.FEATURES.get('SEGMENT_IO_LMS') and hasattr(settings, 'SEGMENT_IO_LMS_KEY'):
analytics.init(settings.SEGMENT_IO_LMS_KEY, flush_at=50)
......@@ -144,3 +154,29 @@ def enable_third_party_auth():
from third_party_auth import settings as auth_settings
auth_settings.apply_settings(settings.THIRD_PARTY_AUTH, settings)
def startup_notification_subsystem():
"""
Initialize the Notification subsystem
"""
try:
startup.initialize()
# register the two scope resolvers that the LMS will be providing
# to edx-notifications
register_user_scope_resolver('course_enrollments', CourseEnrollmentsScopeResolver())
register_user_scope_resolver('course_group', CourseGroupScopeResolver())
register_user_scope_resolver('group_project_participants', GroupProjectParticipantsScopeResolver())
register_user_scope_resolver('group_project_workgroup', GroupProjectParticipantsScopeResolver())
register_user_scope_resolver('student_email_resolver', StudentEmailScopeResolver())
except Exception, ex:
# Note this will fail when we try to run migrations as manage.py will call startup.py
# and startup.initialze() will try to manipulate some database tables.
# We need to research how to identify when we are being started up as part of
# a migration script
log.error(
'There was a problem initializing notifications subsystem. '
'This could be because the database tables have not yet been created and '
'./manage.py lms syncdb needs to run setup.py. Error was "{err_msg}". Continuing...'.format(err_msg=str(ex))
)
lms/urls.py
......@@ -556,3 +556,9 @@ urlpatterns += (
url(r'404', handler404),
url(r'500', handler500),
)
if settings.FEATURES.get('ENABLE_NOTIFICATIONS'):
# include into our URL patterns the HTTP RESTfule API that comes with edx-notifications
urlpatterns += (
url(r'^api/', include('edx_notifications.server.api.urls')),
)
requirements/edx/custom.txt
......@@ -10,3 +10,4 @@
-e git+https://github.com/edx-solutions/xblock-adventure.git@f908e087923231477499e2c455d356d286293641#egg=xblock-adventure
-e git+https://github.com/mckinseyacademy/xblock-poll.git@ed6a2086f158a4b1a8b9219e5105d030fff5910a#egg=xblock-poll
-e git+https://github.com/OfficeDev/xblock-officemix/@86238f5968a08db005717dbddc346808f1ed3716#egg=xblock_officemix-master
-e git+https://github.com/edx/edx-notifications.git@aeb8498b5cee12e8171e33e6f54ab7b9b007c58d#egg=edx-notifications
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment