88c7cd7bf3
* feat!: Remove all trivial mentions of PREVIEW_LMS_BASE There are a few more mentions but these are all the ones that don't need major further followup. BREAKING CHANGE: The learning MFE now supports preview functionality natively and it is no longer necessary to use a different domain on the LMS to render a preview of course content. See https://github.com/openedx/frontend-app-learning/issues/1455 for more details. * feat: Drop the `in_preview_mode` function. Since we're no longer using a separate domain, that check always returned false. Remove it and update any places/tests where it is used. * feat: Drop courseware_mfe_is_active function. With the removal of the preview check this function is also a no-op now so drop calls to it and update the places where it is called to not change other behavior. * feat!: Drop redirect to preview from the legacy courseware index. The CoursewareIndex view is going to be removed eventually but for now we're focusing on removing the PREVIEW_LMS_BASE setting. With this change, if someone tries to load the legacy courseware URL from the preview domain it will no longer redirect them to the MFE preview. This is not a problem that will occur for users coming from existing studio links because those links have already been updated to go directly to the new urls. The only way this path could execute is if someone goes directly to the old Preview URL that they saved off platform somewhere. eg. If they bookmarked it for some reason. BREAKING CHANGE: Saved links (including bookmarks) to the legacy preview URLs will no longer redirect to the MFE preview URLs. * test: Drop the set_preview_mode test helper. This test helper was setting the preview mode for tests by changing the hostname that was set while tests were running. This was mostly not being used to test preview but to run a bunch of legacy courseware tests while defaulting to the new learning MFE for the courseware. This commit updates various tests in the `courseware` app to not rely on the fact that we're in preview to test legacy courseware behavior and instead directly patches either the `_redirect_to_learning_mfe` function or uses the `_get_legacy_courseware_url` or both to be able to have the tests continue to test the legacy coursewary. This will hopefully make the tests more accuarte even though hopefully we'll just be removing many of them soon as a part of the legacy courseware cleanup. We're just doing the preview removal separately to reduce the number of things that are changing at once. * test: Drop the `_get_urls_function` With the other recent cleanup, this function is no longer being referenced by anything so we can just drop it. * test: Test student access to unpublihsed content. Ensure that students can't get access to unpublished content.
599 lines
24 KiB
Python
599 lines
24 KiB
Python
"""
|
|
View for Courseware Index
|
|
"""
|
|
|
|
# pylint: disable=attribute-defined-outside-init
|
|
|
|
|
|
import logging
|
|
import urllib
|
|
|
|
from django.conf import settings
|
|
from django.contrib.auth.views import redirect_to_login
|
|
from django.db import transaction
|
|
from django.http import Http404
|
|
from django.template.context_processors import csrf
|
|
from django.urls import reverse
|
|
from django.utils.decorators import method_decorator
|
|
from django.utils.functional import cached_property
|
|
from django.utils.translation import gettext as _
|
|
from django.views.decorators.cache import cache_control
|
|
from django.views.decorators.csrf import ensure_csrf_cookie
|
|
from django.views.generic import View
|
|
from edx_django_utils.monitoring import set_custom_attributes_for_course_key
|
|
from opaque_keys import InvalidKeyError
|
|
from opaque_keys.edx.keys import CourseKey, UsageKey
|
|
from web_fragments.fragment import Fragment
|
|
from xmodule.course_block import COURSE_VISIBILITY_PUBLIC
|
|
from xmodule.modulestore.django import modulestore
|
|
from xmodule.x_module import PUBLIC_VIEW, STUDENT_VIEW
|
|
|
|
from common.djangoapps.edxmako.shortcuts import render_to_response, render_to_string
|
|
from common.djangoapps.student.models import CourseEnrollment
|
|
from common.djangoapps.util.views import ensure_valid_course_key
|
|
from lms.djangoapps.courseware.exceptions import CourseAccessRedirect, Redirect
|
|
from lms.djangoapps.experiments.utils import get_experiment_user_metadata_context
|
|
from lms.djangoapps.gating.api import get_entrance_exam_score, get_entrance_exam_usage_key
|
|
from lms.djangoapps.grades.api import CourseGradeFactory
|
|
from openedx.core.djangoapps.content.course_overviews.models import CourseOverview
|
|
from openedx.core.djangoapps.crawlers.models import CrawlersConfig
|
|
from openedx.core.djangoapps.lang_pref import LANGUAGE_KEY
|
|
from openedx.core.djangoapps.user_api.preferences.api import get_user_preference
|
|
from openedx.core.djangoapps.util.user_messages import PageLevelMessages
|
|
from openedx.core.djangolib.markup import HTML, Text
|
|
from openedx.features.course_experience import (
|
|
COURSE_ENABLE_UNENROLLED_ACCESS_FLAG,
|
|
DISABLE_COURSE_OUTLINE_PAGE_FLAG,
|
|
default_course_url
|
|
)
|
|
from openedx.features.course_experience.url_helpers import make_learning_mfe_courseware_url
|
|
from openedx.features.enterprise_support.api import data_sharing_consent_required
|
|
|
|
from ..access import has_access
|
|
from ..access_utils import check_public_access
|
|
from ..courses import get_course_with_access, get_current_child, get_studio_url
|
|
from ..entrance_exams import (
|
|
course_has_entrance_exam,
|
|
get_entrance_exam_content,
|
|
user_can_skip_entrance_exam,
|
|
user_has_passed_entrance_exam
|
|
)
|
|
from ..masquerade import check_content_start_date_for_masquerade_user, setup_masquerade
|
|
from ..model_data import FieldDataCache
|
|
from ..block_render import get_block_for_descriptor, toc_for_course
|
|
from ..permissions import MASQUERADE_AS_STUDENT
|
|
from ..toggles import ENABLE_OPTIMIZELY_IN_COURSEWARE
|
|
from .views import CourseTabView
|
|
|
|
log = logging.getLogger("edx.courseware.views.index")
|
|
|
|
TEMPLATE_IMPORTS = {'urllib': urllib}
|
|
CONTENT_DEPTH = 2
|
|
|
|
|
|
@method_decorator(transaction.non_atomic_requests, name='dispatch')
|
|
class CoursewareIndex(View):
|
|
"""
|
|
View class for the Courseware page.
|
|
"""
|
|
|
|
@cached_property
|
|
def enable_unenrolled_access(self):
|
|
return COURSE_ENABLE_UNENROLLED_ACCESS_FLAG.is_enabled(self.course_key)
|
|
|
|
@method_decorator(ensure_csrf_cookie)
|
|
@method_decorator(cache_control(no_cache=True, no_store=True, must_revalidate=True))
|
|
@method_decorator(ensure_valid_course_key)
|
|
@method_decorator(data_sharing_consent_required)
|
|
def get(self, request, course_id, chapter=None, section=None, position=None):
|
|
"""
|
|
Displays courseware accordion and associated content. If course, chapter,
|
|
and section are all specified, renders the page, or returns an error if they
|
|
are invalid.
|
|
|
|
If section is not specified, displays the accordion opened to the right
|
|
chapter.
|
|
|
|
If neither chapter or section are specified, displays the user's most
|
|
recent chapter, or the first chapter if this is the user's first visit.
|
|
|
|
Arguments:
|
|
request: HTTP request
|
|
course_id (unicode): course id
|
|
chapter (unicode): chapter url_name
|
|
section (unicode): section url_name
|
|
position (unicode): position in block, eg of <sequential> block
|
|
"""
|
|
self.course_key = CourseKey.from_string(course_id)
|
|
|
|
if not (request.user.is_authenticated or self.enable_unenrolled_access):
|
|
return redirect_to_login(request.get_full_path())
|
|
|
|
self.original_chapter_url_name = chapter
|
|
self.original_section_url_name = section
|
|
self.chapter_url_name = chapter
|
|
self.section_url_name = section
|
|
self.position = position
|
|
self.chapter, self.section = None, None
|
|
self.course = None
|
|
self.url = request.path
|
|
|
|
try:
|
|
set_custom_attributes_for_course_key(self.course_key)
|
|
self._clean_position()
|
|
with modulestore().bulk_operations(self.course_key):
|
|
|
|
self.view = STUDENT_VIEW
|
|
|
|
self.course = get_course_with_access(
|
|
request.user, 'load', self.course_key,
|
|
depth=CONTENT_DEPTH,
|
|
check_if_enrolled=True,
|
|
check_if_authenticated=True
|
|
)
|
|
self.course_overview = CourseOverview.get_from_id(self.course.id)
|
|
self.is_staff = has_access(request.user, 'staff', self.course)
|
|
|
|
# There's only one situation where we want to show the public view
|
|
if (
|
|
not self.is_staff and
|
|
self.enable_unenrolled_access and
|
|
self.course.course_visibility == COURSE_VISIBILITY_PUBLIC and
|
|
not CourseEnrollment.is_enrolled(request.user, self.course_key)
|
|
):
|
|
self.view = PUBLIC_VIEW
|
|
|
|
self.can_masquerade = request.user.has_perm(MASQUERADE_AS_STUDENT, self.course)
|
|
self._setup_masquerade_for_effective_user()
|
|
|
|
return self.render(request)
|
|
except Exception as exception: # pylint: disable=broad-except
|
|
return CourseTabView.handle_exceptions(request, self.course_key, self.course, exception)
|
|
|
|
def _setup_masquerade_for_effective_user(self):
|
|
"""
|
|
Setup the masquerade information to allow the request to
|
|
be processed for the requested effective user.
|
|
"""
|
|
self.real_user = self.request.user
|
|
self.masquerade, self.effective_user = setup_masquerade(
|
|
self.request,
|
|
self.course_key,
|
|
self.can_masquerade,
|
|
reset_masquerade_data=True
|
|
)
|
|
# Set the user in the request to the effective user.
|
|
self.request.user = self.effective_user
|
|
|
|
def _redirect_to_learning_mfe(self):
|
|
"""
|
|
Can the user access this sequence in the courseware MFE? If so, redirect to MFE.
|
|
"""
|
|
# If the MFE is active, prefer that
|
|
raise Redirect(self.microfrontend_url)
|
|
|
|
@property
|
|
def microfrontend_url(self):
|
|
"""
|
|
Return absolute URL to this section in the courseware micro-frontend.
|
|
"""
|
|
try:
|
|
unit_key = UsageKey.from_string(self.request.GET.get('activate_block_id', ''))
|
|
# `activate_block_id` is typically a Unit (a.k.a. Vertical),
|
|
# but it can technically be any block type. Do a check to
|
|
# make sure it's really a Unit before we use it for the MFE.
|
|
if unit_key.block_type != 'vertical':
|
|
unit_key = None
|
|
except InvalidKeyError:
|
|
unit_key = None
|
|
is_preview = False
|
|
url = make_learning_mfe_courseware_url(
|
|
self.course_key,
|
|
self.section.location if self.section else None,
|
|
unit_key,
|
|
params=self.request.GET,
|
|
preview=is_preview,
|
|
)
|
|
return url
|
|
|
|
def render(self, request):
|
|
"""
|
|
Render the index page.
|
|
"""
|
|
self._prefetch_and_bind_course(request)
|
|
|
|
if self.course.has_children_at_depth(CONTENT_DEPTH):
|
|
self._reset_section_to_exam_if_required()
|
|
self.chapter = self._find_chapter()
|
|
self.section = self._find_section()
|
|
|
|
if self.chapter and self.section:
|
|
self._redirect_if_not_requested_section()
|
|
self._save_positions()
|
|
self._prefetch_and_bind_section()
|
|
self._redirect_to_learning_mfe()
|
|
|
|
check_content_start_date_for_masquerade_user(self.course_key, self.effective_user, request,
|
|
self.course.start, self.chapter.start, self.section.start)
|
|
|
|
if not request.user.is_authenticated:
|
|
qs = urllib.parse.urlencode({
|
|
'course_id': self.course_key,
|
|
'enrollment_action': 'enroll',
|
|
'email_opt_in': False,
|
|
})
|
|
|
|
allow_anonymous = check_public_access(self.course, [COURSE_VISIBILITY_PUBLIC])
|
|
|
|
if not allow_anonymous:
|
|
PageLevelMessages.register_warning_message(
|
|
request,
|
|
Text(_("You are not signed in. To see additional course content, {sign_in_link} or "
|
|
"{register_link}, and enroll in this course.")).format(
|
|
sign_in_link=HTML('<a href="{url}">{sign_in_label}</a>').format(
|
|
sign_in_label=_('sign in'),
|
|
url='{}?{}'.format(reverse('signin_user'), qs),
|
|
),
|
|
register_link=HTML('<a href="/{url}">{register_label}</a>').format(
|
|
register_label=_('register'),
|
|
url='{}?{}'.format(reverse('register_user'), qs),
|
|
),
|
|
)
|
|
)
|
|
|
|
return render_to_response('courseware/courseware.html', self._create_courseware_context(request))
|
|
|
|
def _redirect_if_not_requested_section(self):
|
|
"""
|
|
If the resulting section and chapter are different from what was initially
|
|
requested, redirect back to the index page, but with an updated URL that includes
|
|
the correct section and chapter values. We do this so that our analytics events
|
|
and error logs have the appropriate URLs.
|
|
"""
|
|
if (
|
|
self.chapter.url_name != self.original_chapter_url_name or
|
|
(self.original_section_url_name and self.section.url_name != self.original_section_url_name)
|
|
):
|
|
raise CourseAccessRedirect(
|
|
reverse(
|
|
'courseware_section',
|
|
kwargs={
|
|
'course_id': str(self.course_key),
|
|
'chapter': self.chapter.url_name,
|
|
'section': self.section.url_name,
|
|
},
|
|
)
|
|
)
|
|
|
|
def _clean_position(self):
|
|
"""
|
|
Verify that the given position is an integer. If it is not positive, set it to 1.
|
|
"""
|
|
if self.position is not None:
|
|
try:
|
|
self.position = max(int(self.position), 1)
|
|
except ValueError:
|
|
raise Http404(f"Position {self.position} is not an integer!") # lint-amnesty, pylint: disable=raise-missing-from
|
|
|
|
def _reset_section_to_exam_if_required(self):
|
|
"""
|
|
Check to see if an Entrance Exam is required for the user.
|
|
"""
|
|
if not user_can_skip_entrance_exam(self.effective_user, self.course):
|
|
exam_chapter = get_entrance_exam_content(self.effective_user, self.course)
|
|
if exam_chapter and exam_chapter.get_children():
|
|
exam_section = exam_chapter.get_children()[0]
|
|
if exam_section:
|
|
self.chapter_url_name = exam_chapter.url_name
|
|
self.section_url_name = exam_section.url_name
|
|
|
|
def _get_language_preference(self):
|
|
"""
|
|
Returns the preferred language for the actual user making the request.
|
|
"""
|
|
language_preference = settings.LANGUAGE_CODE
|
|
|
|
if self.request.user.is_authenticated:
|
|
language_preference = get_user_preference(self.real_user, LANGUAGE_KEY)
|
|
|
|
return language_preference
|
|
|
|
def _is_masquerading_as_student(self):
|
|
"""
|
|
Returns whether the current request is masquerading as a student.
|
|
"""
|
|
return self.masquerade and self.masquerade.role == 'student'
|
|
|
|
def _is_masquerading_as_specific_student(self):
|
|
"""
|
|
Returns whether the current request is masqueurading as a specific student.
|
|
"""
|
|
return self._is_masquerading_as_student() and self.masquerade.user_name
|
|
|
|
def _find_block(self, parent, url_name, block_type, min_depth=None):
|
|
"""
|
|
Finds the block in the parent with the specified url_name.
|
|
If not found, calls get_current_child on the parent.
|
|
"""
|
|
child = None
|
|
if url_name:
|
|
child = parent.get_child_by(lambda m: m.location.block_id == url_name)
|
|
if not child:
|
|
# User may be trying to access a child that isn't live yet
|
|
if not self._is_masquerading_as_student():
|
|
raise Http404('No {block_type} found with name {url_name}'.format(
|
|
block_type=block_type,
|
|
url_name=url_name,
|
|
))
|
|
elif min_depth and not child.has_children_at_depth(min_depth - 1):
|
|
child = None
|
|
if not child:
|
|
child = get_current_child(parent, min_depth=min_depth, requested_child=self.request.GET.get("child"))
|
|
return child
|
|
|
|
def _find_chapter(self):
|
|
"""
|
|
Finds the requested chapter.
|
|
"""
|
|
return self._find_block(self.course, self.chapter_url_name, 'chapter', CONTENT_DEPTH - 1)
|
|
|
|
def _find_section(self):
|
|
"""
|
|
Finds the requested section.
|
|
"""
|
|
if self.chapter:
|
|
return self._find_block(self.chapter, self.section_url_name, 'section')
|
|
|
|
def _prefetch_and_bind_course(self, request):
|
|
"""
|
|
Prefetches all descendant data for the requested section and
|
|
sets up the runtime, which binds the request user to the section.
|
|
"""
|
|
self.field_data_cache = FieldDataCache.cache_for_block_descendents(
|
|
self.course_key,
|
|
self.effective_user,
|
|
self.course,
|
|
depth=CONTENT_DEPTH,
|
|
read_only=CrawlersConfig.is_crawler(request),
|
|
)
|
|
|
|
self.course = get_block_for_descriptor(
|
|
self.effective_user,
|
|
self.request,
|
|
self.course,
|
|
self.field_data_cache,
|
|
self.course_key,
|
|
course=self.course,
|
|
will_recheck_access=True,
|
|
)
|
|
|
|
def _prefetch_and_bind_section(self):
|
|
"""
|
|
Prefetches all descendant data for the requested section and
|
|
sets up the runtime, which binds the request user to the section.
|
|
"""
|
|
# Pre-fetch all descendant data
|
|
self.section = modulestore().get_item(self.section.location, depth=None, lazy=False)
|
|
self.field_data_cache.add_block_descendents(self.section, depth=None)
|
|
|
|
# Bind section to user
|
|
self.section = get_block_for_descriptor(
|
|
self.effective_user,
|
|
self.request,
|
|
self.section,
|
|
self.field_data_cache,
|
|
self.course_key,
|
|
self.position,
|
|
course=self.course,
|
|
will_recheck_access=True,
|
|
)
|
|
|
|
def _save_positions(self):
|
|
"""
|
|
Save where we are in the course and chapter.
|
|
"""
|
|
save_child_position(self.course, self.chapter_url_name)
|
|
save_child_position(self.chapter, self.section_url_name)
|
|
|
|
def _create_courseware_context(self, request):
|
|
"""
|
|
Returns and creates the rendering context for the courseware.
|
|
Also returns the table of contents for the courseware.
|
|
"""
|
|
|
|
course_url = default_course_url(self.course.id)
|
|
show_search = (
|
|
settings.FEATURES.get('ENABLE_COURSEWARE_SEARCH') or
|
|
(settings.FEATURES.get('ENABLE_COURSEWARE_SEARCH_FOR_COURSE_STAFF') and self.is_staff)
|
|
)
|
|
staff_access = self.is_staff
|
|
|
|
courseware_context = {
|
|
'csrf': csrf(self.request)['csrf_token'],
|
|
'course': self.course,
|
|
'course_url': course_url,
|
|
'chapter': self.chapter,
|
|
'section': self.section,
|
|
'init': '',
|
|
'fragment': Fragment(),
|
|
'staff_access': staff_access,
|
|
'can_masquerade': self.can_masquerade,
|
|
'masquerade': self.masquerade,
|
|
'supports_preview_menu': True,
|
|
'studio_url': get_studio_url(self.course, 'course'),
|
|
'xqa_server': settings.FEATURES.get('XQA_SERVER', "http://your_xqa_server.com"),
|
|
'bookmarks_api_url': reverse('bookmarks'),
|
|
'language_preference': self._get_language_preference(),
|
|
'disable_optimizely': not ENABLE_OPTIMIZELY_IN_COURSEWARE.is_enabled(),
|
|
'section_title': None,
|
|
'sequence_title': None,
|
|
'disable_accordion': not DISABLE_COURSE_OUTLINE_PAGE_FLAG.is_enabled(self.course.id),
|
|
'show_search': show_search,
|
|
'render_course_wide_assets': True,
|
|
}
|
|
courseware_context.update(
|
|
get_experiment_user_metadata_context(
|
|
self.course,
|
|
self.effective_user,
|
|
)
|
|
)
|
|
table_of_contents = toc_for_course(
|
|
self.effective_user,
|
|
self.request,
|
|
self.course,
|
|
self.chapter_url_name,
|
|
self.section_url_name,
|
|
self.field_data_cache,
|
|
)
|
|
courseware_context['accordion'] = render_accordion(
|
|
self.request,
|
|
self.course,
|
|
table_of_contents['chapters'],
|
|
)
|
|
|
|
# entrance exam data
|
|
self._add_entrance_exam_to_context(courseware_context)
|
|
|
|
if self.section:
|
|
# chromeless data
|
|
if self.section.chrome:
|
|
chrome = [s.strip() for s in self.section.chrome.lower().split(",")]
|
|
if 'accordion' not in chrome:
|
|
courseware_context['disable_accordion'] = True
|
|
if 'tabs' not in chrome:
|
|
courseware_context['disable_tabs'] = True
|
|
|
|
# default tab
|
|
if self.section.default_tab:
|
|
courseware_context['default_tab'] = self.section.default_tab
|
|
|
|
# section data
|
|
courseware_context['section_title'] = self.section.display_name_with_default
|
|
section_context = self._create_section_context(
|
|
table_of_contents['previous_of_active_section'],
|
|
table_of_contents['next_of_active_section'],
|
|
)
|
|
courseware_context['fragment'] = self.section.render(self.view, section_context)
|
|
|
|
if self.section.position and self.section.has_children:
|
|
self._add_sequence_title_to_context(courseware_context)
|
|
|
|
return courseware_context
|
|
|
|
def _add_sequence_title_to_context(self, courseware_context):
|
|
"""
|
|
Adds sequence title to the given context.
|
|
|
|
If we're rendering a section with some display items, but position
|
|
exceeds the length of the displayable items, default the position
|
|
to the first element.
|
|
"""
|
|
display_items = self.section.get_children()
|
|
if not display_items:
|
|
return
|
|
if self.section.position > len(display_items):
|
|
self.section.position = 1
|
|
courseware_context['sequence_title'] = display_items[self.section.position - 1].display_name_with_default
|
|
|
|
def _add_entrance_exam_to_context(self, courseware_context):
|
|
"""
|
|
Adds entrance exam related information to the given context.
|
|
"""
|
|
if course_has_entrance_exam(self.course) and getattr(self.chapter, 'is_entrance_exam', False):
|
|
courseware_context['entrance_exam_passed'] = user_has_passed_entrance_exam(self.effective_user, self.course)
|
|
courseware_context['entrance_exam_current_score'] = get_entrance_exam_score(
|
|
CourseGradeFactory().read(self.effective_user, self.course),
|
|
get_entrance_exam_usage_key(self.course),
|
|
)
|
|
|
|
def _create_section_context(self, previous_of_active_section, next_of_active_section):
|
|
"""
|
|
Returns and creates the rendering context for the section.
|
|
"""
|
|
def _compute_section_url(section_info, requested_child):
|
|
"""
|
|
Returns the section URL for the given section_info with the given child parameter.
|
|
"""
|
|
return "{url}?child={requested_child}".format(
|
|
url=reverse(
|
|
'courseware_section',
|
|
args=[str(self.course_key), section_info['chapter_url_name'], section_info['url_name']],
|
|
),
|
|
requested_child=requested_child,
|
|
)
|
|
|
|
# NOTE (CCB): Pull the position from the URL for un-authenticated users. Otherwise, pull the saved
|
|
# state from the data store.
|
|
position = None if self.request.user.is_authenticated else self.position
|
|
section_context = {
|
|
'activate_block_id': self.request.GET.get('activate_block_id'),
|
|
'requested_child': self.request.GET.get("child"),
|
|
'progress_url': reverse('progress', kwargs={'course_id': str(self.course_key)}),
|
|
'user_authenticated': self.request.user.is_authenticated,
|
|
'position': position,
|
|
}
|
|
if previous_of_active_section:
|
|
section_context['prev_url'] = _compute_section_url(previous_of_active_section, 'last')
|
|
if next_of_active_section:
|
|
section_context['next_url'] = _compute_section_url(next_of_active_section, 'first')
|
|
# sections can hide data that masquerading staff should see when debugging issues with specific students
|
|
section_context['specific_masquerade'] = self._is_masquerading_as_specific_student()
|
|
return section_context
|
|
|
|
|
|
def render_accordion(request, course, table_of_contents):
|
|
"""
|
|
Returns the HTML that renders the navigation for the given course.
|
|
Expects the table_of_contents to have data on each chapter and section,
|
|
including which ones are active.
|
|
"""
|
|
context = dict(
|
|
[
|
|
('toc', table_of_contents),
|
|
('course_id', str(course.id)),
|
|
('csrf', csrf(request)['csrf_token']),
|
|
('due_date_display_format', course.due_date_display_format),
|
|
] + list(TEMPLATE_IMPORTS.items())
|
|
)
|
|
return render_to_string('courseware/accordion.html', context)
|
|
|
|
|
|
def save_child_position(seq_block, child_name):
|
|
"""
|
|
child_name: url_name of the child
|
|
"""
|
|
for position, child in enumerate(seq_block.get_children(), start=1):
|
|
if child.location.block_id == child_name:
|
|
# Only save if position changed
|
|
if position != seq_block.position:
|
|
seq_block.position = position
|
|
# Save this new position to the underlying KeyValueStore
|
|
seq_block.save()
|
|
|
|
|
|
def save_positions_recursively_up(user, request, field_data_cache, xmodule, course=None):
|
|
"""
|
|
Recurses up the course tree starting from a leaf
|
|
Saving the position property based on the previous node as it goes
|
|
"""
|
|
current_block = xmodule
|
|
|
|
while current_block:
|
|
parent_location = modulestore().get_parent_location(current_block.location)
|
|
parent = None
|
|
if parent_location:
|
|
parent_block = modulestore().get_item(parent_location)
|
|
parent = get_block_for_descriptor(
|
|
user,
|
|
request,
|
|
parent_block,
|
|
field_data_cache,
|
|
current_block.location.course_key,
|
|
course=course
|
|
)
|
|
|
|
if parent and hasattr(parent, 'position'):
|
|
save_child_position(parent, current_block.location.block_id)
|
|
|
|
current_block = parent
|