course_structures: remove app code, except migrations and models
This commit is contained in:
Nimisha Asthagiri
@@ -1,18 +0,0 @@
|
|||||||
"""
|
|
||||||
Django Admin model registry for Course Structures sub-application
|
|
||||||
"""
|
|
||||||
from django.contrib import admin
|
|
||||||
|
|
||||||
from .models import CourseStructure
|
|
||||||
|
|
||||||
|
|
||||||
class CourseStructureAdmin(admin.ModelAdmin):
|
|
||||||
"""
|
|
||||||
Django Admin class for managing Course Structures model data
|
|
||||||
"""
|
|
||||||
search_fields = ('course_id',)
|
|
||||||
list_display = ('course_id', 'modified')
|
|
||||||
ordering = ('course_id', '-modified')
|
|
||||||
|
|
||||||
|
|
||||||
admin.site.register(CourseStructure, CourseStructureAdmin)
|
|
||||||
@@ -1,128 +0,0 @@
|
|||||||
"""
|
|
||||||
API implementation of the Course Structure API for Python code.
|
|
||||||
|
|
||||||
Note: The course list and course detail functionality isn't currently supported here because
|
|
||||||
of the tricky interactions between DRF and the code.
|
|
||||||
Most of that information is available by accessing the course objects directly.
|
|
||||||
"""
|
|
||||||
from collections import OrderedDict
|
|
||||||
from openedx.core.lib.exceptions import CourseNotFoundError
|
|
||||||
from .serializers import GradingPolicySerializer, CourseStructureSerializer
|
|
||||||
from .errors import CourseStructureNotAvailableError
|
|
||||||
from openedx.core.djangoapps.content.course_structures import models, tasks
|
|
||||||
from util.cache import cache
|
|
||||||
from xmodule.modulestore.django import modulestore
|
|
||||||
|
|
||||||
|
|
||||||
def _retrieve_course(course_key):
|
|
||||||
"""Retrieves the course for the given course key.
|
|
||||||
|
|
||||||
Args:
|
|
||||||
course_key: The CourseKey for the course we'd like to retrieve.
|
|
||||||
Returns:
|
|
||||||
the course that matches the CourseKey
|
|
||||||
Raises:
|
|
||||||
CourseNotFoundError
|
|
||||||
|
|
||||||
"""
|
|
||||||
course = modulestore().get_course(course_key, depth=0)
|
|
||||||
if course is None:
|
|
||||||
raise CourseNotFoundError
|
|
||||||
|
|
||||||
return course
|
|
||||||
|
|
||||||
|
|
||||||
def course_structure(course_key, block_types=None):
|
|
||||||
"""
|
|
||||||
Retrieves the entire course structure, including information about all the blocks used in the
|
|
||||||
course if `block_types` is None else information about `block_types` will be returned only.
|
|
||||||
Final serialized information will be cached.
|
|
||||||
|
|
||||||
Args:
|
|
||||||
course_key: the CourseKey of the course we'd like to retrieve.
|
|
||||||
block_types: list of required block types. Possible values include sequential,
|
|
||||||
vertical, html, problem, video, and discussion. The type can also be
|
|
||||||
the name of a custom type of block used for the course.
|
|
||||||
Returns:
|
|
||||||
The serialized output of the course structure:
|
|
||||||
* root: The ID of the root node of the course structure.
|
|
||||||
|
|
||||||
* blocks: A dictionary that maps block IDs to a collection of
|
|
||||||
information about each block. Each block contains the following
|
|
||||||
fields.
|
|
||||||
|
|
||||||
* id: The ID of the block.
|
|
||||||
|
|
||||||
* type: The type of block. Possible values include sequential,
|
|
||||||
vertical, html, problem, video, and discussion. The type can also be
|
|
||||||
the name of a custom type of block used for the course.
|
|
||||||
|
|
||||||
* display_name: The display name configured for the block.
|
|
||||||
|
|
||||||
* graded: Whether or not the sequential or problem is graded. The
|
|
||||||
value is true or false.
|
|
||||||
|
|
||||||
* format: The assignment type.
|
|
||||||
|
|
||||||
* children: If the block has child blocks, a list of IDs of the child
|
|
||||||
blocks.
|
|
||||||
Raises:
|
|
||||||
CourseStructureNotAvailableError, CourseNotFoundError
|
|
||||||
|
|
||||||
"""
|
|
||||||
course = _retrieve_course(course_key)
|
|
||||||
|
|
||||||
modified_timestamp = models.CourseStructure.objects.filter(course_id=course_key).values('modified')
|
|
||||||
if modified_timestamp.exists():
|
|
||||||
cache_key = 'openedx.content.course_structures.api.v0.api.course_structure.{}.{}.{}'.format(
|
|
||||||
course_key, modified_timestamp[0]['modified'], '_'.join(block_types or [])
|
|
||||||
)
|
|
||||||
data = cache.get(cache_key) # pylint: disable=maybe-no-member
|
|
||||||
if data is not None:
|
|
||||||
return data
|
|
||||||
|
|
||||||
try:
|
|
||||||
requested_course_structure = models.CourseStructure.objects.get(course_id=course.id)
|
|
||||||
except models.CourseStructure.DoesNotExist:
|
|
||||||
pass
|
|
||||||
else:
|
|
||||||
structure = requested_course_structure.structure
|
|
||||||
if block_types is not None:
|
|
||||||
blocks = requested_course_structure.ordered_blocks
|
|
||||||
required_blocks = OrderedDict()
|
|
||||||
for usage_id, block_data in blocks.iteritems():
|
|
||||||
if block_data['block_type'] in block_types:
|
|
||||||
required_blocks[usage_id] = block_data
|
|
||||||
|
|
||||||
structure['blocks'] = required_blocks
|
|
||||||
|
|
||||||
data = CourseStructureSerializer(structure).data
|
|
||||||
cache.set(cache_key, data, None) # pylint: disable=maybe-no-member
|
|
||||||
return data
|
|
||||||
|
|
||||||
# If we don't have data stored, generate it and return an error.
|
|
||||||
tasks.update_course_structure.delay(unicode(course_key))
|
|
||||||
raise CourseStructureNotAvailableError
|
|
||||||
|
|
||||||
|
|
||||||
def course_grading_policy(course_key):
|
|
||||||
"""
|
|
||||||
Retrieves the course grading policy.
|
|
||||||
|
|
||||||
Args:
|
|
||||||
course_key: CourseKey the corresponds to the course we'd like to know grading policy information about.
|
|
||||||
Returns:
|
|
||||||
The serialized version of the course grading policy containing the following information:
|
|
||||||
* assignment_type: The type of the assignment, as configured by course
|
|
||||||
staff. For example, course staff might make the assignment types Homework,
|
|
||||||
Quiz, and Exam.
|
|
||||||
|
|
||||||
* count: The number of assignments of the type.
|
|
||||||
|
|
||||||
* dropped: Number of assignments of the type that are dropped.
|
|
||||||
|
|
||||||
* weight: The weight, or effect, of the assignment type on the learner's
|
|
||||||
final grade.
|
|
||||||
"""
|
|
||||||
course = _retrieve_course(course_key)
|
|
||||||
return GradingPolicySerializer(course.raw_grader, many=True).data
|
|
||||||
@@ -1,6 +0,0 @@
|
|||||||
""" Errors used by the Course Structure API. """
|
|
||||||
|
|
||||||
|
|
||||||
class CourseStructureNotAvailableError(Exception):
|
|
||||||
""" The course structure still needs to be generated. """
|
|
||||||
pass
|
|
||||||
@@ -1,76 +0,0 @@
|
|||||||
"""
|
|
||||||
API Serializers
|
|
||||||
"""
|
|
||||||
from collections import defaultdict
|
|
||||||
|
|
||||||
from rest_framework import serializers
|
|
||||||
|
|
||||||
|
|
||||||
class GradingPolicySerializer(serializers.Serializer):
|
|
||||||
""" Serializer for course grading policy. """
|
|
||||||
assignment_type = serializers.CharField(source='type')
|
|
||||||
count = serializers.IntegerField(source='min_count')
|
|
||||||
dropped = serializers.IntegerField(source='drop_count')
|
|
||||||
weight = serializers.FloatField()
|
|
||||||
|
|
||||||
def to_representation(self, obj):
|
|
||||||
"""
|
|
||||||
Return a representation of the grading policy.
|
|
||||||
"""
|
|
||||||
# Backwards compatibility with the behavior of DRF v2.
|
|
||||||
# When the grader dictionary was missing keys, DRF v2 would default to None;
|
|
||||||
# DRF v3 unhelpfully raises an exception.
|
|
||||||
return dict(
|
|
||||||
super(GradingPolicySerializer, self).to_representation(
|
|
||||||
defaultdict(lambda: None, obj)
|
|
||||||
)
|
|
||||||
)
|
|
||||||
|
|
||||||
|
|
||||||
# pylint: disable=invalid-name
|
|
||||||
class BlockSerializer(serializers.Serializer):
|
|
||||||
""" Serializer for course structure block. """
|
|
||||||
id = serializers.CharField(source='usage_key')
|
|
||||||
type = serializers.CharField(source='block_type')
|
|
||||||
parent = serializers.CharField(required=False)
|
|
||||||
display_name = serializers.CharField()
|
|
||||||
graded = serializers.BooleanField(default=False)
|
|
||||||
format = serializers.CharField()
|
|
||||||
children = serializers.CharField()
|
|
||||||
|
|
||||||
def to_representation(self, obj):
|
|
||||||
"""
|
|
||||||
Return a representation of the block.
|
|
||||||
|
|
||||||
NOTE: this method maintains backwards compatibility with the behavior
|
|
||||||
of Django Rest Framework v2.
|
|
||||||
"""
|
|
||||||
data = super(BlockSerializer, self).to_representation(obj)
|
|
||||||
|
|
||||||
# Backwards compatibility with the behavior of DRF v2
|
|
||||||
# Include a NULL value for "parent" in the representation
|
|
||||||
# (instead of excluding the key entirely)
|
|
||||||
if obj.get("parent") is None:
|
|
||||||
data["parent"] = None
|
|
||||||
|
|
||||||
# Backwards compatibility with the behavior of DRF v2
|
|
||||||
# Leave the children list as a list instead of serializing
|
|
||||||
# it to a string.
|
|
||||||
data["children"] = obj["children"]
|
|
||||||
|
|
||||||
return data
|
|
||||||
|
|
||||||
|
|
||||||
class CourseStructureSerializer(serializers.Serializer):
|
|
||||||
""" Serializer for course structure. """
|
|
||||||
root = serializers.CharField()
|
|
||||||
blocks = serializers.SerializerMethodField()
|
|
||||||
|
|
||||||
def get_blocks(self, structure):
|
|
||||||
""" Serialize the individual blocks. """
|
|
||||||
serialized = {}
|
|
||||||
|
|
||||||
for key, block in structure['blocks'].iteritems():
|
|
||||||
serialized[key] = BlockSerializer(block).data
|
|
||||||
|
|
||||||
return serialized
|
|
||||||
@@ -1,153 +0,0 @@
|
|||||||
"""
|
|
||||||
Course Structure api.py tests
|
|
||||||
"""
|
|
||||||
from .api import course_structure
|
|
||||||
from openedx.core.djangoapps.content.course_structures.signals import listen_for_course_publish
|
|
||||||
from xmodule.modulestore.django import SignalHandler
|
|
||||||
from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
|
|
||||||
from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
|
|
||||||
import mock
|
|
||||||
from django.core import cache
|
|
||||||
|
|
||||||
|
|
||||||
class CourseStructureApiTests(ModuleStoreTestCase):
|
|
||||||
"""
|
|
||||||
CourseStructure API Tests
|
|
||||||
"""
|
|
||||||
MOCK_CACHE = "openedx.core.djangoapps.content.course_structures.api.v0.api.cache"
|
|
||||||
|
|
||||||
ENABLED_CACHES = ['default', 'mongo_metadata_inheritance', 'loc_cache']
|
|
||||||
|
|
||||||
ENABLED_SIGNALS = ['course_published']
|
|
||||||
|
|
||||||
def setUp(self):
|
|
||||||
"""
|
|
||||||
Test setup
|
|
||||||
"""
|
|
||||||
# For some reason, `listen_for_course_publish` is not called when we run
|
|
||||||
# all (paver test_system -s cms) tests, If we run only run this file then tests run fine.
|
|
||||||
SignalHandler.course_published.connect(listen_for_course_publish)
|
|
||||||
|
|
||||||
super(CourseStructureApiTests, self).setUp()
|
|
||||||
self.course = CourseFactory.create()
|
|
||||||
self.chapter = ItemFactory.create(
|
|
||||||
parent_location=self.course.location, category='chapter', display_name="Week 1"
|
|
||||||
)
|
|
||||||
self.sequential = ItemFactory.create(
|
|
||||||
parent_location=self.chapter.location, category='sequential', display_name="Lesson 1"
|
|
||||||
)
|
|
||||||
self.vertical = ItemFactory.create(
|
|
||||||
parent_location=self.sequential.location, category='vertical', display_name='Subsection 1'
|
|
||||||
)
|
|
||||||
self.video = ItemFactory.create(
|
|
||||||
parent_location=self.vertical.location, category="video", display_name="My Video"
|
|
||||||
)
|
|
||||||
self.video = ItemFactory.create(
|
|
||||||
parent_location=self.vertical.location, category="html", display_name="My HTML"
|
|
||||||
)
|
|
||||||
|
|
||||||
self.addCleanup(self._disconnect_course_published_event)
|
|
||||||
|
|
||||||
def _disconnect_course_published_event(self):
|
|
||||||
"""
|
|
||||||
Disconnect course_published event.
|
|
||||||
"""
|
|
||||||
# If we don't disconnect then tests are getting failed in test_crud.py
|
|
||||||
SignalHandler.course_published.disconnect(listen_for_course_publish)
|
|
||||||
|
|
||||||
def _expected_blocks(self, block_types=None, get_parent=False):
|
|
||||||
"""
|
|
||||||
Construct expected blocks.
|
|
||||||
Arguments:
|
|
||||||
block_types (list): List of required block types. Possible values include sequential,
|
|
||||||
vertical, html, problem, video, and discussion. The type can also be
|
|
||||||
the name of a custom type of block used for the course.
|
|
||||||
get_parent (bool): If True then add child's parent location else parent is set to None
|
|
||||||
Returns:
|
|
||||||
dict: Information about required block types.
|
|
||||||
"""
|
|
||||||
blocks = {}
|
|
||||||
|
|
||||||
def add_block(xblock):
|
|
||||||
"""
|
|
||||||
Returns expected blocks dict.
|
|
||||||
"""
|
|
||||||
children = xblock.get_children()
|
|
||||||
|
|
||||||
if block_types is None or xblock.category in block_types:
|
|
||||||
|
|
||||||
parent = None
|
|
||||||
if get_parent:
|
|
||||||
item = xblock.get_parent()
|
|
||||||
parent = unicode(item.location) if item is not None else None
|
|
||||||
|
|
||||||
blocks[unicode(xblock.location)] = {
|
|
||||||
u'id': unicode(xblock.location),
|
|
||||||
u'type': xblock.category,
|
|
||||||
u'display_name': xblock.display_name,
|
|
||||||
u'format': xblock.format,
|
|
||||||
u'graded': xblock.graded,
|
|
||||||
u'parent': parent,
|
|
||||||
u'children': [unicode(child.location) for child in children]
|
|
||||||
}
|
|
||||||
|
|
||||||
for child in children:
|
|
||||||
add_block(child)
|
|
||||||
|
|
||||||
course = self.store.get_course(self.course.id, depth=None)
|
|
||||||
add_block(course)
|
|
||||||
|
|
||||||
return blocks
|
|
||||||
|
|
||||||
def test_course_structure_with_no_block_types(self):
|
|
||||||
"""
|
|
||||||
Verify that course_structure returns info for entire course.
|
|
||||||
"""
|
|
||||||
with mock.patch(self.MOCK_CACHE, cache.caches['default']):
|
|
||||||
with self.assertNumQueries(3):
|
|
||||||
structure = course_structure(self.course.id)
|
|
||||||
|
|
||||||
expected = {
|
|
||||||
u'root': unicode(self.course.location),
|
|
||||||
u'blocks': self._expected_blocks()
|
|
||||||
}
|
|
||||||
|
|
||||||
self.assertDictEqual(structure, expected)
|
|
||||||
|
|
||||||
with mock.patch(self.MOCK_CACHE, cache.caches['default']):
|
|
||||||
with self.assertNumQueries(2):
|
|
||||||
course_structure(self.course.id)
|
|
||||||
|
|
||||||
def test_course_structure_with_block_types(self):
|
|
||||||
"""
|
|
||||||
Verify that course_structure returns info for required block_types only when specific block_types are requested.
|
|
||||||
"""
|
|
||||||
block_types = ['html', 'video']
|
|
||||||
|
|
||||||
with mock.patch(self.MOCK_CACHE, cache.caches['default']):
|
|
||||||
with self.assertNumQueries(3):
|
|
||||||
structure = course_structure(self.course.id, block_types=block_types)
|
|
||||||
|
|
||||||
expected = {
|
|
||||||
u'root': unicode(self.course.location),
|
|
||||||
u'blocks': self._expected_blocks(block_types=block_types, get_parent=True)
|
|
||||||
}
|
|
||||||
|
|
||||||
self.assertDictEqual(structure, expected)
|
|
||||||
|
|
||||||
with mock.patch(self.MOCK_CACHE, cache.caches['default']):
|
|
||||||
with self.assertNumQueries(2):
|
|
||||||
course_structure(self.course.id, block_types=block_types)
|
|
||||||
|
|
||||||
def test_course_structure_with_non_existed_block_types(self):
|
|
||||||
"""
|
|
||||||
Verify that course_structure returns empty info for non-existed block_types.
|
|
||||||
"""
|
|
||||||
block_types = ['phantom']
|
|
||||||
structure = course_structure(self.course.id, block_types=block_types)
|
|
||||||
expected = {
|
|
||||||
u'root': unicode(self.course.location),
|
|
||||||
u'blocks': {}
|
|
||||||
}
|
|
||||||
|
|
||||||
self.assertDictEqual(structure, expected)
|
|
||||||
@@ -9,11 +9,3 @@ class CourseStructuresConfig(AppConfig):
|
|||||||
Custom AppConfig for openedx.core.djangoapps.content.course_structures
|
Custom AppConfig for openedx.core.djangoapps.content.course_structures
|
||||||
"""
|
"""
|
||||||
name = u'openedx.core.djangoapps.content.course_structures'
|
name = u'openedx.core.djangoapps.content.course_structures'
|
||||||
|
|
||||||
def ready(self):
|
|
||||||
"""
|
|
||||||
Define tasks to perform at app loading time:
|
|
||||||
|
|
||||||
* Connect signal handlers
|
|
||||||
"""
|
|
||||||
from . import signals # pylint: disable=unused-variable
|
|
||||||
|
|||||||
@@ -1,56 +0,0 @@
|
|||||||
"""
|
|
||||||
Django Management Command: Generate Course Structure
|
|
||||||
Generates and stores course structure information for one or more courses.
|
|
||||||
"""
|
|
||||||
import logging
|
|
||||||
|
|
||||||
from django.core.management.base import BaseCommand
|
|
||||||
from opaque_keys.edx.keys import CourseKey
|
|
||||||
from six import text_type
|
|
||||||
|
|
||||||
from openedx.core.djangoapps.content.course_structures.tasks import update_course_structure
|
|
||||||
from xmodule.modulestore.django import modulestore
|
|
||||||
|
|
||||||
log = logging.getLogger(__name__)
|
|
||||||
|
|
||||||
|
|
||||||
class Command(BaseCommand):
|
|
||||||
"""
|
|
||||||
Generates and stores course structure information for one or more courses.
|
|
||||||
"""
|
|
||||||
help = 'Generates and stores course structure for one or more courses.'
|
|
||||||
|
|
||||||
def add_arguments(self, parser):
|
|
||||||
parser.add_argument('course_id', nargs='*')
|
|
||||||
parser.add_argument('--all',
|
|
||||||
action='store_true',
|
|
||||||
help='Generate structures for all courses.')
|
|
||||||
|
|
||||||
def handle(self, *args, **options):
|
|
||||||
"""
|
|
||||||
Perform the course structure generation workflow
|
|
||||||
"""
|
|
||||||
if options['all']:
|
|
||||||
course_keys = [course.id for course in modulestore().get_courses()]
|
|
||||||
else:
|
|
||||||
course_keys = [CourseKey.from_string(arg) for arg in options['course_id']]
|
|
||||||
|
|
||||||
if not course_keys:
|
|
||||||
log.fatal('No courses specified.')
|
|
||||||
return
|
|
||||||
|
|
||||||
log.info('Generating course structures for %d courses.', len(course_keys))
|
|
||||||
log.debug('Generating course structure(s) for the following courses: %s', course_keys)
|
|
||||||
|
|
||||||
for course_key in course_keys:
|
|
||||||
try:
|
|
||||||
# Run the update task synchronously so that we know when all course structures have been updated.
|
|
||||||
# TODO Future improvement: Use .delay(), add return value to ResultSet, and wait for execution of
|
|
||||||
# all tasks using ResultSet.join(). I (clintonb) am opting not to make this improvement right now
|
|
||||||
# as I do not have time to test it fully.
|
|
||||||
update_course_structure.apply(args=[text_type(course_key)])
|
|
||||||
except Exception as ex:
|
|
||||||
log.exception('An error occurred while generating course structure for %s: %s',
|
|
||||||
text_type(course_key), text_type(ex))
|
|
||||||
|
|
||||||
log.info('Finished generating course structures.')
|
|
||||||
@@ -1,29 +0,0 @@
|
|||||||
"""
|
|
||||||
Django Signals classes and functions for the Course Structure application
|
|
||||||
"""
|
|
||||||
from django.dispatch.dispatcher import receiver
|
|
||||||
|
|
||||||
from xmodule.modulestore.django import SignalHandler
|
|
||||||
|
|
||||||
from .models import CourseStructure
|
|
||||||
|
|
||||||
|
|
||||||
@receiver(SignalHandler.course_published)
|
|
||||||
def listen_for_course_publish(sender, course_key, **kwargs): # pylint: disable=unused-argument
|
|
||||||
"""
|
|
||||||
Course Structure application receiver for the course_published signal
|
|
||||||
"""
|
|
||||||
# Import tasks here to avoid a circular import.
|
|
||||||
from .tasks import update_course_structure
|
|
||||||
|
|
||||||
# Delete the existing discussion id map cache to avoid inconsistencies
|
|
||||||
try:
|
|
||||||
structure = CourseStructure.objects.get(course_id=course_key)
|
|
||||||
structure.discussion_id_map_json = None
|
|
||||||
structure.save()
|
|
||||||
except CourseStructure.DoesNotExist:
|
|
||||||
pass
|
|
||||||
|
|
||||||
# Note: The countdown=0 kwarg is set to to ensure the method below does not attempt to access the course
|
|
||||||
# before the signal emitter has finished all operations. This is also necessary to ensure all tests pass.
|
|
||||||
update_course_structure.apply_async([unicode(course_key)], countdown=0)
|
|
||||||
@@ -1,100 +0,0 @@
|
|||||||
"""
|
|
||||||
Asynchronous tasks related to the Course Structure sub-application
|
|
||||||
"""
|
|
||||||
import json
|
|
||||||
import logging
|
|
||||||
|
|
||||||
from celery.task import task
|
|
||||||
from opaque_keys.edx.keys import CourseKey
|
|
||||||
from six import text_type
|
|
||||||
|
|
||||||
from xmodule.modulestore.django import modulestore
|
|
||||||
|
|
||||||
|
|
||||||
log = logging.getLogger('edx.celery.task')
|
|
||||||
|
|
||||||
|
|
||||||
def _generate_course_structure(course_key):
|
|
||||||
"""
|
|
||||||
Generates a course structure dictionary for the specified course.
|
|
||||||
"""
|
|
||||||
with modulestore().bulk_operations(course_key):
|
|
||||||
course = modulestore().get_course(course_key, depth=None)
|
|
||||||
blocks_stack = [course]
|
|
||||||
blocks_dict = {}
|
|
||||||
discussions = {}
|
|
||||||
while blocks_stack:
|
|
||||||
curr_block = blocks_stack.pop()
|
|
||||||
children = curr_block.get_children() if curr_block.has_children else []
|
|
||||||
key = unicode(curr_block.scope_ids.usage_id)
|
|
||||||
block = {
|
|
||||||
"usage_key": key,
|
|
||||||
"block_type": curr_block.category,
|
|
||||||
"display_name": curr_block.display_name,
|
|
||||||
"children": [unicode(child.scope_ids.usage_id) for child in children]
|
|
||||||
}
|
|
||||||
|
|
||||||
if (curr_block.category == 'discussion' and
|
|
||||||
hasattr(curr_block, 'discussion_id') and
|
|
||||||
curr_block.discussion_id):
|
|
||||||
discussions[curr_block.discussion_id] = unicode(curr_block.scope_ids.usage_id)
|
|
||||||
|
|
||||||
# Retrieve these attributes separately so that we can fail gracefully
|
|
||||||
# if the block doesn't have the attribute.
|
|
||||||
attrs = (('graded', False), ('format', None))
|
|
||||||
for attr, default in attrs:
|
|
||||||
if hasattr(curr_block, attr):
|
|
||||||
block[attr] = getattr(curr_block, attr, default)
|
|
||||||
else:
|
|
||||||
log.warning('Failed to retrieve %s attribute of block %s. Defaulting to %s.', attr, key, default)
|
|
||||||
block[attr] = default
|
|
||||||
|
|
||||||
blocks_dict[key] = block
|
|
||||||
|
|
||||||
# Add this blocks children to the stack so that we can traverse them as well.
|
|
||||||
blocks_stack.extend(children)
|
|
||||||
return {
|
|
||||||
'structure': {
|
|
||||||
"root": unicode(course.scope_ids.usage_id),
|
|
||||||
"blocks": blocks_dict
|
|
||||||
},
|
|
||||||
'discussion_id_map': discussions
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
@task(name=u'openedx.core.djangoapps.content.course_structures.tasks.update_course_structure')
|
|
||||||
def update_course_structure(course_key):
|
|
||||||
"""
|
|
||||||
Regenerates and updates the course structure (in the database) for the specified course.
|
|
||||||
"""
|
|
||||||
# Import here to avoid circular import.
|
|
||||||
from .models import CourseStructure
|
|
||||||
|
|
||||||
# Ideally we'd like to accept a CourseLocator; however, CourseLocator is not JSON-serializable (by default) so
|
|
||||||
# Celery's delayed tasks fail to start. For this reason, callers should pass the course key as a Unicode string.
|
|
||||||
if not isinstance(course_key, basestring):
|
|
||||||
raise ValueError('course_key must be a string. {} is not acceptable.'.format(type(course_key)))
|
|
||||||
|
|
||||||
course_key = CourseKey.from_string(course_key)
|
|
||||||
|
|
||||||
try:
|
|
||||||
structure = _generate_course_structure(course_key)
|
|
||||||
except Exception as ex:
|
|
||||||
log.exception('An error occurred while generating course structure: %s', text_type(ex))
|
|
||||||
raise
|
|
||||||
|
|
||||||
structure_json = json.dumps(structure['structure'])
|
|
||||||
discussion_id_map_json = json.dumps(structure['discussion_id_map'])
|
|
||||||
|
|
||||||
structure_model, created = CourseStructure.objects.get_or_create(
|
|
||||||
course_id=course_key,
|
|
||||||
defaults={
|
|
||||||
'structure_json': structure_json,
|
|
||||||
'discussion_id_map_json': discussion_id_map_json
|
|
||||||
}
|
|
||||||
)
|
|
||||||
|
|
||||||
if not created:
|
|
||||||
structure_model.structure_json = structure_json
|
|
||||||
structure_model.discussion_id_map_json = discussion_id_map_json
|
|
||||||
structure_model.save()
|
|
||||||
@@ -1,243 +0,0 @@
|
|||||||
"""
|
|
||||||
Course Structure Content sub-application test cases
|
|
||||||
"""
|
|
||||||
import json
|
|
||||||
from nose.plugins.attrib import attr
|
|
||||||
from opaque_keys.edx.django.models import UsageKey
|
|
||||||
|
|
||||||
from xmodule.modulestore.django import SignalHandler
|
|
||||||
from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
|
|
||||||
from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
|
|
||||||
from openedx.core.djangoapps.content.course_structures.models import CourseStructure
|
|
||||||
from openedx.core.djangoapps.content.course_structures.signals import listen_for_course_publish
|
|
||||||
from openedx.core.djangoapps.content.course_structures.tasks import _generate_course_structure, update_course_structure
|
|
||||||
|
|
||||||
|
|
||||||
class SignalDisconnectTestMixin(object):
|
|
||||||
"""
|
|
||||||
Mixin for tests to disable calls to signals.listen_for_course_publish when the course_published signal is fired.
|
|
||||||
"""
|
|
||||||
|
|
||||||
def setUp(self):
|
|
||||||
super(SignalDisconnectTestMixin, self).setUp()
|
|
||||||
SignalHandler.course_published.disconnect(listen_for_course_publish)
|
|
||||||
|
|
||||||
def tearDown(self):
|
|
||||||
SignalHandler.course_published.connect(listen_for_course_publish)
|
|
||||||
super(SignalDisconnectTestMixin, self).tearDown()
|
|
||||||
|
|
||||||
|
|
||||||
@attr(shard=2)
|
|
||||||
class CourseStructureTaskTests(ModuleStoreTestCase):
|
|
||||||
"""
|
|
||||||
Test cases covering Course Structure task-related workflows
|
|
||||||
"""
|
|
||||||
def setUp(self, **kwargs):
|
|
||||||
super(CourseStructureTaskTests, self).setUp()
|
|
||||||
self.course = CourseFactory.create(org='TestX', course='TS101', run='T1')
|
|
||||||
self.section = ItemFactory.create(parent=self.course, category='chapter', display_name='Test Section')
|
|
||||||
self.discussion_xblock_1 = ItemFactory.create(
|
|
||||||
parent=self.course,
|
|
||||||
category='discussion',
|
|
||||||
discussion_id='test_discussion_id_1'
|
|
||||||
)
|
|
||||||
self.discussion_xblock_2 = ItemFactory.create(
|
|
||||||
parent=self.course,
|
|
||||||
category='discussion',
|
|
||||||
discussion_id='test_discussion_id_2'
|
|
||||||
)
|
|
||||||
CourseStructure.objects.all().delete()
|
|
||||||
|
|
||||||
def test_generate_course_structure(self):
|
|
||||||
blocks = {}
|
|
||||||
|
|
||||||
def add_block(block):
|
|
||||||
"""
|
|
||||||
Inserts new child XBlocks into the existing course tree
|
|
||||||
"""
|
|
||||||
children = block.get_children() if block.has_children else []
|
|
||||||
|
|
||||||
blocks[unicode(block.location)] = {
|
|
||||||
"usage_key": unicode(block.location),
|
|
||||||
"block_type": block.category,
|
|
||||||
"display_name": block.display_name,
|
|
||||||
"graded": block.graded,
|
|
||||||
"format": block.format,
|
|
||||||
"children": [unicode(child.location) for child in children]
|
|
||||||
}
|
|
||||||
|
|
||||||
for child in children:
|
|
||||||
add_block(child)
|
|
||||||
|
|
||||||
add_block(self.course)
|
|
||||||
|
|
||||||
expected = {
|
|
||||||
'root': unicode(self.course.location),
|
|
||||||
'blocks': blocks
|
|
||||||
}
|
|
||||||
|
|
||||||
self.maxDiff = None
|
|
||||||
actual = _generate_course_structure(self.course.id)
|
|
||||||
self.assertDictEqual(actual['structure'], expected)
|
|
||||||
|
|
||||||
def test_structure_json(self):
|
|
||||||
"""
|
|
||||||
Although stored as compressed data, CourseStructure.structure_json should always return the uncompressed string.
|
|
||||||
"""
|
|
||||||
course_id = 'a/b/c'
|
|
||||||
structure = {
|
|
||||||
'root': course_id,
|
|
||||||
'blocks': {
|
|
||||||
course_id: {
|
|
||||||
'id': course_id
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
structure_json = json.dumps(structure)
|
|
||||||
structure = CourseStructure.objects.create(course_id=self.course.id, structure_json=structure_json)
|
|
||||||
self.assertEqual(structure.structure_json, structure_json)
|
|
||||||
|
|
||||||
# Reload the data to ensure the init signal is fired to decompress the data.
|
|
||||||
cs = CourseStructure.objects.get(course_id=self.course.id)
|
|
||||||
self.assertEqual(cs.structure_json, structure_json)
|
|
||||||
|
|
||||||
def test_structure(self):
|
|
||||||
"""
|
|
||||||
CourseStructure.structure should return the uncompressed, JSON-parsed course structure.
|
|
||||||
"""
|
|
||||||
structure = {
|
|
||||||
'root': 'a/b/c',
|
|
||||||
'blocks': {
|
|
||||||
'a/b/c': {
|
|
||||||
'id': 'a/b/c'
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
structure_json = json.dumps(structure)
|
|
||||||
cs = CourseStructure.objects.create(course_id=self.course.id, structure_json=structure_json)
|
|
||||||
self.assertDictEqual(cs.structure, structure)
|
|
||||||
|
|
||||||
def test_ordered_blocks(self):
|
|
||||||
structure = {
|
|
||||||
'root': 'a/b/c',
|
|
||||||
'blocks': {
|
|
||||||
'a/b/c': {
|
|
||||||
'id': 'a/b/c',
|
|
||||||
'children': [
|
|
||||||
'g/h/i'
|
|
||||||
]
|
|
||||||
},
|
|
||||||
'd/e/f': {
|
|
||||||
'id': 'd/e/f',
|
|
||||||
'children': []
|
|
||||||
},
|
|
||||||
'g/h/i': {
|
|
||||||
'id': 'h/j/k',
|
|
||||||
'children': [
|
|
||||||
'j/k/l',
|
|
||||||
'd/e/f'
|
|
||||||
]
|
|
||||||
},
|
|
||||||
'j/k/l': {
|
|
||||||
'id': 'j/k/l',
|
|
||||||
'children': []
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
in_order_blocks = ['a/b/c', 'g/h/i', 'j/k/l', 'd/e/f']
|
|
||||||
structure_json = json.dumps(structure)
|
|
||||||
retrieved_course_structure = CourseStructure.objects.create(
|
|
||||||
course_id=self.course.id, structure_json=structure_json
|
|
||||||
)
|
|
||||||
|
|
||||||
self.assertEqual(retrieved_course_structure.ordered_blocks.keys(), in_order_blocks)
|
|
||||||
|
|
||||||
def test_block_with_missing_fields(self):
|
|
||||||
"""
|
|
||||||
The generator should continue to operate on blocks/XModule that do not have graded or format fields.
|
|
||||||
"""
|
|
||||||
# TODO In the future, test logging using testfixtures.LogCapture
|
|
||||||
# (https://pythonhosted.org/testfixtures/logging.html). Talk to TestEng before adding that library.
|
|
||||||
category = 'peergrading'
|
|
||||||
display_name = 'Testing Module'
|
|
||||||
module = ItemFactory.create(parent=self.section, category=category, display_name=display_name)
|
|
||||||
structure = _generate_course_structure(self.course.id)
|
|
||||||
|
|
||||||
usage_key = unicode(module.location)
|
|
||||||
actual = structure['structure']['blocks'][usage_key]
|
|
||||||
expected = {
|
|
||||||
"usage_key": usage_key,
|
|
||||||
"block_type": category,
|
|
||||||
"display_name": display_name,
|
|
||||||
"graded": False,
|
|
||||||
"format": None,
|
|
||||||
"children": []
|
|
||||||
}
|
|
||||||
self.assertEqual(actual, expected)
|
|
||||||
|
|
||||||
def test_generate_discussion_id_map(self):
|
|
||||||
id_map = {}
|
|
||||||
|
|
||||||
def add_block(block):
|
|
||||||
"""Adds the given block and all of its children to the expected discussion id map"""
|
|
||||||
children = block.get_children() if block.has_children else []
|
|
||||||
|
|
||||||
if block.category == 'discussion':
|
|
||||||
id_map[block.discussion_id] = unicode(block.location)
|
|
||||||
|
|
||||||
for child in children:
|
|
||||||
add_block(child)
|
|
||||||
|
|
||||||
add_block(self.course)
|
|
||||||
|
|
||||||
actual = _generate_course_structure(self.course.id)
|
|
||||||
self.assertEqual(actual['discussion_id_map'], id_map)
|
|
||||||
|
|
||||||
def test_discussion_id_map_json(self):
|
|
||||||
id_map = {
|
|
||||||
'discussion_id_1': 'module_location_1',
|
|
||||||
'discussion_id_2': 'module_location_2'
|
|
||||||
}
|
|
||||||
id_map_json = json.dumps(id_map)
|
|
||||||
structure = CourseStructure.objects.create(course_id=self.course.id, discussion_id_map_json=id_map_json)
|
|
||||||
self.assertEqual(structure.discussion_id_map_json, id_map_json)
|
|
||||||
|
|
||||||
structure = CourseStructure.objects.get(course_id=self.course.id)
|
|
||||||
self.assertEqual(structure.discussion_id_map_json, id_map_json)
|
|
||||||
|
|
||||||
def test_discussion_id_map(self):
|
|
||||||
id_map = {
|
|
||||||
'discussion_id_1': 'block-v1:TestX+TS101+T1+type@discussion+block@b141953dff414921a715da37eb14ecdc',
|
|
||||||
'discussion_id_2': 'i4x://TestX/TS101/discussion/466f474fa4d045a8b7bde1b911e095ca'
|
|
||||||
}
|
|
||||||
id_map_json = json.dumps(id_map)
|
|
||||||
structure = CourseStructure.objects.create(course_id=self.course.id, discussion_id_map_json=id_map_json)
|
|
||||||
expected_id_map = {
|
|
||||||
key: UsageKey.from_string(value).map_into_course(self.course.id)
|
|
||||||
for key, value in id_map.iteritems()
|
|
||||||
}
|
|
||||||
self.assertEqual(structure.discussion_id_map, expected_id_map)
|
|
||||||
|
|
||||||
def test_discussion_id_map_missing(self):
|
|
||||||
structure = CourseStructure.objects.create(course_id=self.course.id)
|
|
||||||
self.assertIsNone(structure.discussion_id_map)
|
|
||||||
|
|
||||||
def test_update_course_structure(self):
|
|
||||||
"""
|
|
||||||
Test the actual task that orchestrates data generation and updating the database.
|
|
||||||
"""
|
|
||||||
# Method requires string input
|
|
||||||
course_id = self.course.id
|
|
||||||
self.assertRaises(ValueError, update_course_structure, course_id)
|
|
||||||
|
|
||||||
# Ensure a CourseStructure object is created
|
|
||||||
expected_structure = _generate_course_structure(course_id)
|
|
||||||
update_course_structure(unicode(course_id))
|
|
||||||
structure = CourseStructure.objects.get(course_id=course_id)
|
|
||||||
self.assertEqual(structure.course_id, course_id)
|
|
||||||
self.assertEqual(structure.structure, expected_structure['structure'])
|
|
||||||
self.assertEqual(structure.discussion_id_map.keys(), expected_structure['discussion_id_map'].keys())
|
|
||||||
self.assertEqual(
|
|
||||||
[unicode(value) for value in structure.discussion_id_map.values()],
|
|
||||||
expected_structure['discussion_id_map'].values()
|
|
||||||
)
|
|
||||||
Reference in New Issue
Block a user