915 lines
35 KiB
Python
915 lines
35 KiB
Python
"""
|
|
Functions for accessing and displaying courses within the
|
|
courseware.
|
|
"""
|
|
|
|
import logging
|
|
from collections import defaultdict, namedtuple
|
|
from datetime import datetime
|
|
|
|
import pytz
|
|
from crum import get_current_request
|
|
from dateutil.parser import parse as parse_date
|
|
from django.conf import settings
|
|
from django.http import Http404, QueryDict
|
|
from django.urls import reverse
|
|
from django.utils.translation import ugettext as _
|
|
from edx_django_utils.monitoring import function_trace
|
|
from fs.errors import ResourceNotFound
|
|
from opaque_keys.edx.keys import UsageKey
|
|
from path import Path as path
|
|
|
|
from openedx.core.lib.cache_utils import request_cached
|
|
|
|
from lms.djangoapps import branding
|
|
from lms.djangoapps.courseware.access import has_access
|
|
from lms.djangoapps.courseware.access_response import (
|
|
AuthenticationRequiredAccessError,
|
|
EnrollmentRequiredAccessError,
|
|
MilestoneAccessError,
|
|
StartDateError,
|
|
)
|
|
from lms.djangoapps.courseware.date_summary import (
|
|
CertificateAvailableDate,
|
|
CourseAssignmentDate,
|
|
CourseEndDate,
|
|
CourseExpiredDate,
|
|
CourseStartDate,
|
|
TodaysDate,
|
|
VerificationDeadlineDate,
|
|
VerifiedUpgradeDeadlineDate
|
|
)
|
|
from lms.djangoapps.courseware.exceptions import CourseRunNotFound
|
|
from lms.djangoapps.courseware.masquerade import check_content_start_date_for_masquerade_user
|
|
from lms.djangoapps.courseware.model_data import FieldDataCache
|
|
from lms.djangoapps.courseware.module_render import get_module
|
|
from common.djangoapps.edxmako.shortcuts import render_to_string
|
|
from lms.djangoapps.courseware.access_utils import (
|
|
check_authentication,
|
|
check_enrollment,
|
|
)
|
|
from lms.djangoapps.courseware.courseware_access_exception import CoursewareAccessException
|
|
from lms.djangoapps.courseware.exceptions import CourseAccessRedirect
|
|
from lms.djangoapps.course_blocks.api import get_course_blocks
|
|
from openedx.core.djangoapps.content.course_overviews.models import CourseOverview
|
|
from openedx.core.djangoapps.enrollments.api import get_course_enrollment_details
|
|
from openedx.core.djangoapps.site_configuration import helpers as configuration_helpers
|
|
from openedx.core.lib.api.view_utils import LazySequence
|
|
from openedx.features.course_duration_limits.access import AuditExpiredError
|
|
from openedx.features.course_experience import RELATIVE_DATES_FLAG
|
|
from openedx.features.course_experience.utils import is_block_structure_complete_for_assignments
|
|
from common.djangoapps.static_replace import replace_static_urls
|
|
from lms.djangoapps.survey.utils import SurveyRequiredAccessError, check_survey_required_and_unanswered
|
|
from common.djangoapps.util.date_utils import strftime_localized
|
|
from xmodule.modulestore.django import modulestore
|
|
from xmodule.modulestore.exceptions import ItemNotFoundError
|
|
from xmodule.x_module import STUDENT_VIEW
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
|
|
# Used by get_course_assignments below. You shouldn't need to use this type directly.
|
|
_Assignment = namedtuple(
|
|
'Assignment', ['block_key', 'title', 'url', 'date', 'contains_gated_content', 'complete', 'past_due',
|
|
'assignment_type', 'extra_info', 'first_component_block_id']
|
|
)
|
|
|
|
|
|
def get_course(course_id, depth=0):
|
|
"""
|
|
Given a course id, return the corresponding course descriptor.
|
|
|
|
If the course does not exist, raises a CourseRunNotFound. This is appropriate
|
|
for internal use.
|
|
|
|
depth: The number of levels of children for the modulestore to cache.
|
|
None means infinite depth. Default is to fetch no children.
|
|
"""
|
|
course = modulestore().get_course(course_id, depth=depth)
|
|
if course is None:
|
|
raise CourseRunNotFound(course_key=course_id)
|
|
return course
|
|
|
|
|
|
def get_course_by_id(course_key, depth=0):
|
|
"""
|
|
Given a course id, return the corresponding course descriptor.
|
|
|
|
If such a course does not exist, raises a 404.
|
|
|
|
depth: The number of levels of children for the modulestore to cache. None means infinite depth
|
|
"""
|
|
with modulestore().bulk_operations(course_key):
|
|
course = modulestore().get_course(course_key, depth=depth)
|
|
if course:
|
|
return course
|
|
else:
|
|
raise Http404("Course not found: {}.".format(str(course_key)))
|
|
|
|
|
|
def get_course_with_access(user, action, course_key, depth=0, check_if_enrolled=False, check_survey_complete=True, check_if_authenticated=False): # lint-amnesty, pylint: disable=line-too-long
|
|
"""
|
|
Given a course_key, look up the corresponding course descriptor,
|
|
check that the user has the access to perform the specified action
|
|
on the course, and return the descriptor.
|
|
|
|
Raises a 404 if the course_key is invalid, or the user doesn't have access.
|
|
|
|
depth: The number of levels of children for the modulestore to cache. None means infinite depth
|
|
|
|
check_if_enrolled: If true, additionally verifies that the user is either enrolled in the course
|
|
or has staff access.
|
|
check_survey_complete: If true, additionally verifies that the user has either completed the course survey
|
|
or has staff access.
|
|
Note: We do not want to continually add these optional booleans. Ideally,
|
|
these special cases could not only be handled inside has_access, but could
|
|
be plugged in as additional callback checks for different actions.
|
|
"""
|
|
course = get_course_by_id(course_key, depth)
|
|
check_course_access_with_redirect(course, user, action, check_if_enrolled, check_survey_complete, check_if_authenticated) # lint-amnesty, pylint: disable=line-too-long
|
|
return course
|
|
|
|
|
|
def get_course_overview_with_access(user, action, course_key, check_if_enrolled=False):
|
|
"""
|
|
Given a course_key, look up the corresponding course overview,
|
|
check that the user has the access to perform the specified action
|
|
on the course, and return the course overview.
|
|
|
|
Raises a 404 if the course_key is invalid, or the user doesn't have access.
|
|
|
|
check_if_enrolled: If true, additionally verifies that the user is either enrolled in the course
|
|
or has staff access.
|
|
"""
|
|
try:
|
|
course_overview = CourseOverview.get_from_id(course_key)
|
|
except CourseOverview.DoesNotExist:
|
|
raise Http404("Course not found.") # lint-amnesty, pylint: disable=raise-missing-from
|
|
check_course_access_with_redirect(course_overview, user, action, check_if_enrolled)
|
|
return course_overview
|
|
|
|
|
|
def check_course_access(course, user, action, check_if_enrolled=False, check_survey_complete=True, check_if_authenticated=False): # lint-amnesty, pylint: disable=line-too-long
|
|
"""
|
|
Check that the user has the access to perform the specified action
|
|
on the course (CourseBlock|CourseOverview).
|
|
|
|
check_if_enrolled: If true, additionally verifies that the user is enrolled.
|
|
check_survey_complete: If true, additionally verifies that the user has completed the survey.
|
|
"""
|
|
def _check_nonstaff_access():
|
|
# Below is a series of checks that must all pass for a user to be granted access
|
|
# to a course. (Essentially check this AND check that AND...)
|
|
# Also note: access_response (AccessResponse) objects are compared as booleans
|
|
access_response = has_access(user, action, course, course.id)
|
|
if not access_response:
|
|
return access_response
|
|
|
|
if check_if_authenticated:
|
|
authentication_access_response = check_authentication(user, course)
|
|
if not authentication_access_response:
|
|
return authentication_access_response
|
|
|
|
if check_if_enrolled:
|
|
enrollment_access_response = check_enrollment(user, course)
|
|
if not enrollment_access_response:
|
|
return enrollment_access_response
|
|
|
|
# Redirect if the user must answer a survey before entering the course.
|
|
if check_survey_complete and action == 'load':
|
|
survey_access_response = check_survey_required_and_unanswered(user, course)
|
|
if not survey_access_response:
|
|
return survey_access_response
|
|
|
|
# This access_response will be ACCESS_GRANTED
|
|
return access_response
|
|
|
|
# Allow staff full access to the course even if other checks fail
|
|
nonstaff_access_response = _check_nonstaff_access()
|
|
if not nonstaff_access_response:
|
|
staff_access_response = has_access(user, 'staff', course.id)
|
|
if staff_access_response:
|
|
return staff_access_response
|
|
|
|
# This access_response will be ACCESS_GRANTED
|
|
return nonstaff_access_response
|
|
|
|
|
|
def check_course_access_with_redirect(course, user, action, check_if_enrolled=False, check_survey_complete=True, check_if_authenticated=False): # lint-amnesty, pylint: disable=line-too-long
|
|
"""
|
|
Check that the user has the access to perform the specified action
|
|
on the course (CourseBlock|CourseOverview).
|
|
|
|
check_if_enrolled: If true, additionally verifies that the user is enrolled.
|
|
check_survey_complete: If true, additionally verifies that the user has completed the survey.
|
|
"""
|
|
request = get_current_request()
|
|
check_content_start_date_for_masquerade_user(course.id, user, request, course.start)
|
|
|
|
access_response = check_course_access(course, user, action, check_if_enrolled, check_survey_complete, check_if_authenticated) # lint-amnesty, pylint: disable=line-too-long
|
|
|
|
if not access_response:
|
|
# Redirect if StartDateError
|
|
if isinstance(access_response, StartDateError):
|
|
start_date = strftime_localized(course.start, 'SHORT_DATE')
|
|
params = QueryDict(mutable=True)
|
|
params['notlive'] = start_date
|
|
raise CourseAccessRedirect('{dashboard_url}?{params}'.format(
|
|
dashboard_url=reverse('dashboard'),
|
|
params=params.urlencode()
|
|
), access_response)
|
|
|
|
# Redirect if AuditExpiredError
|
|
if isinstance(access_response, AuditExpiredError):
|
|
params = QueryDict(mutable=True)
|
|
params['access_response_error'] = access_response.additional_context_user_message
|
|
raise CourseAccessRedirect('{dashboard_url}?{params}'.format(
|
|
dashboard_url=reverse('dashboard'),
|
|
params=params.urlencode()
|
|
), access_response)
|
|
|
|
# Redirect if the user must answer a survey before entering the course.
|
|
if isinstance(access_response, MilestoneAccessError):
|
|
raise CourseAccessRedirect('{dashboard_url}'.format(
|
|
dashboard_url=reverse('dashboard'),
|
|
), access_response)
|
|
|
|
# Redirect if the user is not enrolled and must be to see content
|
|
if isinstance(access_response, EnrollmentRequiredAccessError):
|
|
raise CourseAccessRedirect(reverse('about_course', args=[str(course.id)]))
|
|
|
|
# Redirect if user must be authenticated to view the content
|
|
if isinstance(access_response, AuthenticationRequiredAccessError):
|
|
raise CourseAccessRedirect(reverse('about_course', args=[str(course.id)]))
|
|
|
|
# Redirect if the user must answer a survey before entering the course.
|
|
if isinstance(access_response, SurveyRequiredAccessError):
|
|
raise CourseAccessRedirect(reverse('course_survey', args=[str(course.id)]))
|
|
|
|
# Deliberately return a non-specific error message to avoid
|
|
# leaking info about access control settings
|
|
raise CoursewareAccessException(access_response)
|
|
|
|
|
|
def can_self_enroll_in_course(course_key):
|
|
"""
|
|
Returns True if the user can enroll themselves in a course.
|
|
|
|
Note: an example of a course that a user cannot enroll in directly
|
|
is a CCX course. For such courses, a user can only be enrolled by
|
|
a CCX coach.
|
|
"""
|
|
if hasattr(course_key, 'ccx'):
|
|
return False
|
|
return True
|
|
|
|
|
|
def course_open_for_self_enrollment(course_key):
|
|
"""
|
|
For a given course_key, determine if the course is available for enrollment
|
|
"""
|
|
# Check to see if learners can enroll themselves.
|
|
if not can_self_enroll_in_course(course_key):
|
|
return False
|
|
|
|
# Check the enrollment start and end dates.
|
|
course_details = get_course_enrollment_details(str(course_key))
|
|
now = datetime.now().replace(tzinfo=pytz.UTC)
|
|
start = course_details['enrollment_start']
|
|
end = course_details['enrollment_end']
|
|
|
|
start = start if start is not None else now
|
|
end = end if end is not None else now
|
|
|
|
# If we are not within the start and end date for enrollment.
|
|
if now < start or end < now:
|
|
return False
|
|
|
|
return True
|
|
|
|
|
|
def find_file(filesystem, dirs, filename):
|
|
"""
|
|
Looks for a filename in a list of dirs on a filesystem, in the specified order.
|
|
|
|
filesystem: an OSFS filesystem
|
|
dirs: a list of path objects
|
|
filename: a string
|
|
|
|
Returns d / filename if found in dir d, else raises ResourceNotFound.
|
|
"""
|
|
for directory in dirs:
|
|
filepath = path(directory) / filename
|
|
if filesystem.exists(filepath):
|
|
return filepath
|
|
raise ResourceNotFound(f"Could not find {filename}")
|
|
|
|
|
|
def get_course_about_section(request, course, section_key):
|
|
"""
|
|
This returns the snippet of html to be rendered on the course about page,
|
|
given the key for the section.
|
|
|
|
Valid keys:
|
|
- overview
|
|
- about_sidebar_html
|
|
- short_description
|
|
- description
|
|
- key_dates (includes start, end, exams, etc)
|
|
- video
|
|
- course_staff_short
|
|
- course_staff_extended
|
|
- requirements
|
|
- syllabus
|
|
- textbook
|
|
- faq
|
|
- effort
|
|
- more_info
|
|
- ocw_links
|
|
"""
|
|
|
|
# Many of these are stored as html files instead of some semantic
|
|
# markup. This can change without effecting this interface when we find a
|
|
# good format for defining so many snippets of text/html.
|
|
|
|
html_sections = {
|
|
'short_description',
|
|
'description',
|
|
'key_dates',
|
|
'video',
|
|
'course_staff_short',
|
|
'course_staff_extended',
|
|
'requirements',
|
|
'syllabus',
|
|
'textbook',
|
|
'faq',
|
|
'more_info',
|
|
'overview',
|
|
'effort',
|
|
'end_date',
|
|
'prerequisites',
|
|
'about_sidebar_html',
|
|
'ocw_links'
|
|
}
|
|
|
|
if section_key in html_sections:
|
|
try:
|
|
loc = course.location.replace(category='about', name=section_key)
|
|
|
|
# Use an empty cache
|
|
field_data_cache = FieldDataCache([], course.id, request.user)
|
|
about_module = get_module(
|
|
request.user,
|
|
request,
|
|
loc,
|
|
field_data_cache,
|
|
log_if_not_found=False,
|
|
wrap_xmodule_display=False,
|
|
static_asset_path=course.static_asset_path,
|
|
course=course
|
|
)
|
|
|
|
html = ''
|
|
|
|
if about_module is not None:
|
|
try:
|
|
html = about_module.render(STUDENT_VIEW).content
|
|
except Exception: # pylint: disable=broad-except
|
|
html = render_to_string('courseware/error-message.html', None)
|
|
log.exception(
|
|
"Error rendering course=%s, section_key=%s",
|
|
course, section_key
|
|
)
|
|
return html
|
|
|
|
except ItemNotFoundError:
|
|
log.warning(
|
|
"Missing about section %s in course %s",
|
|
section_key, str(course.location)
|
|
)
|
|
return None
|
|
|
|
raise KeyError("Invalid about key " + str(section_key))
|
|
|
|
|
|
def get_course_info_usage_key(course, section_key):
|
|
"""
|
|
Returns the usage key for the specified section's course info module.
|
|
"""
|
|
return course.id.make_usage_key('course_info', section_key)
|
|
|
|
|
|
def get_course_info_section_module(request, user, course, section_key):
|
|
"""
|
|
This returns the course info module for a given section_key.
|
|
|
|
Valid keys:
|
|
- handouts
|
|
- guest_handouts
|
|
- updates
|
|
- guest_updates
|
|
"""
|
|
usage_key = get_course_info_usage_key(course, section_key)
|
|
|
|
# Use an empty cache
|
|
field_data_cache = FieldDataCache([], course.id, user)
|
|
|
|
return get_module(
|
|
user,
|
|
request,
|
|
usage_key,
|
|
field_data_cache,
|
|
log_if_not_found=False,
|
|
wrap_xmodule_display=False,
|
|
static_asset_path=course.static_asset_path,
|
|
course=course
|
|
)
|
|
|
|
|
|
def get_course_info_section(request, user, course, section_key):
|
|
"""
|
|
This returns the snippet of html to be rendered on the course info page,
|
|
given the key for the section.
|
|
|
|
Valid keys:
|
|
- handouts
|
|
- guest_handouts
|
|
- updates
|
|
- guest_updates
|
|
"""
|
|
info_module = get_course_info_section_module(request, user, course, section_key)
|
|
|
|
html = ''
|
|
if info_module is not None:
|
|
try:
|
|
html = info_module.render(STUDENT_VIEW).content.strip()
|
|
except Exception: # pylint: disable=broad-except
|
|
html = render_to_string('courseware/error-message.html', None)
|
|
log.exception(
|
|
"Error rendering course_id=%s, section_key=%s",
|
|
str(course.id), section_key
|
|
)
|
|
|
|
return html
|
|
|
|
|
|
def get_course_date_blocks(course, user, request=None, include_access=False,
|
|
include_past_dates=False, num_assignments=None):
|
|
"""
|
|
Return the list of blocks to display on the course info page,
|
|
sorted by date.
|
|
"""
|
|
blocks = []
|
|
if RELATIVE_DATES_FLAG.is_enabled(course.id):
|
|
blocks.extend(get_course_assignment_date_blocks(
|
|
course, user, request, num_return=num_assignments,
|
|
include_access=include_access, include_past_dates=include_past_dates,
|
|
))
|
|
|
|
# Adding these in after the assignment blocks so in the case multiple blocks have the same date,
|
|
# these blocks will be sorted to come after the assignments. See https://openedx.atlassian.net/browse/AA-158
|
|
default_block_classes = [
|
|
CertificateAvailableDate,
|
|
CourseEndDate,
|
|
CourseExpiredDate,
|
|
CourseStartDate,
|
|
TodaysDate,
|
|
VerificationDeadlineDate,
|
|
VerifiedUpgradeDeadlineDate,
|
|
]
|
|
blocks.extend([cls(course, user) for cls in default_block_classes])
|
|
|
|
blocks = filter(lambda b: b.is_allowed and b.date and (include_past_dates or b.is_enabled), blocks)
|
|
return sorted(blocks, key=date_block_key_fn)
|
|
|
|
|
|
def date_block_key_fn(block):
|
|
"""
|
|
If the block's date is None, return the maximum datetime in order
|
|
to force it to the end of the list of displayed blocks.
|
|
"""
|
|
return block.date or datetime.max.replace(tzinfo=pytz.UTC)
|
|
|
|
|
|
def get_course_assignment_date_blocks(course, user, request, num_return=None,
|
|
include_past_dates=False, include_access=False):
|
|
"""
|
|
Returns a list of assignment (at the subsection/sequential level) due date
|
|
blocks for the given course. Will return num_return results or all results
|
|
if num_return is None in date increasing order.
|
|
"""
|
|
date_blocks = []
|
|
for assignment in get_course_assignments(course.id, user, include_access=include_access):
|
|
date_block = CourseAssignmentDate(course, user)
|
|
date_block.date = assignment.date
|
|
date_block.contains_gated_content = assignment.contains_gated_content
|
|
date_block.first_component_block_id = assignment.first_component_block_id
|
|
date_block.complete = assignment.complete
|
|
date_block.assignment_type = assignment.assignment_type
|
|
date_block.past_due = assignment.past_due
|
|
date_block.link = request.build_absolute_uri(assignment.url) if assignment.url else ''
|
|
date_block.set_title(assignment.title, link=assignment.url)
|
|
date_block._extra_info = assignment.extra_info # pylint: disable=protected-access
|
|
date_blocks.append(date_block)
|
|
date_blocks = sorted((b for b in date_blocks if b.is_enabled or include_past_dates), key=date_block_key_fn)
|
|
if num_return:
|
|
return date_blocks[:num_return]
|
|
return date_blocks
|
|
|
|
|
|
@request_cached()
|
|
def get_course_blocks_completion_summary(course_key, user):
|
|
"""
|
|
Returns an object with the number of complete units, incomplete units, and units that contain gated content
|
|
for the given course. The complete and incomplete counts only reflect units that are able to be completed by
|
|
the given user. If a unit contains gated content, it is not counted towards the incomplete count.
|
|
|
|
The object contains fields: complete_count, incomplete_count, locked_count
|
|
"""
|
|
if not user.id:
|
|
return []
|
|
store = modulestore()
|
|
course_usage_key = store.make_course_usage_key(course_key)
|
|
block_data = get_course_blocks(user, course_usage_key, allow_start_dates_in_future=True, include_completion=True)
|
|
|
|
complete_count, incomplete_count, locked_count = 0, 0, 0
|
|
for section_key in block_data.get_children(course_usage_key): # pylint: disable=too-many-nested-blocks
|
|
for subsection_key in block_data.get_children(section_key):
|
|
for unit_key in block_data.get_children(subsection_key):
|
|
complete = block_data.get_xblock_field(unit_key, 'complete', False)
|
|
contains_gated_content = block_data.get_xblock_field(unit_key, 'contains_gated_content', False)
|
|
if contains_gated_content:
|
|
locked_count += 1
|
|
elif complete:
|
|
complete_count += 1
|
|
else:
|
|
incomplete_count += 1
|
|
|
|
return {
|
|
'complete_count': complete_count,
|
|
'incomplete_count': incomplete_count,
|
|
'locked_count': locked_count
|
|
}
|
|
|
|
|
|
@request_cached()
|
|
def get_course_assignments(course_key, user, include_access=False): # lint-amnesty, pylint: disable=too-many-statements
|
|
"""
|
|
Returns a list of assignment (at the subsection/sequential level) due dates for the given course.
|
|
|
|
Each returned object is a namedtuple with fields: title, url, date, contains_gated_content, complete, past_due,
|
|
assignment_type
|
|
"""
|
|
if not user.id:
|
|
return []
|
|
store = modulestore()
|
|
course_usage_key = store.make_course_usage_key(course_key)
|
|
block_data = get_course_blocks(user, course_usage_key, allow_start_dates_in_future=True, include_completion=True)
|
|
|
|
now = datetime.now(pytz.UTC)
|
|
assignments = []
|
|
for section_key in block_data.get_children(course_usage_key): # lint-amnesty, pylint: disable=too-many-nested-blocks
|
|
for subsection_key in block_data.get_children(section_key):
|
|
due = block_data.get_xblock_field(subsection_key, 'due')
|
|
graded = block_data.get_xblock_field(subsection_key, 'graded', False)
|
|
if due and graded:
|
|
first_component_block_id = get_first_component_of_block(subsection_key, block_data)
|
|
contains_gated_content = include_access and block_data.get_xblock_field(
|
|
subsection_key, 'contains_gated_content', False)
|
|
title = block_data.get_xblock_field(subsection_key, 'display_name', _('Assignment'))
|
|
|
|
assignment_type = block_data.get_xblock_field(subsection_key, 'format', None)
|
|
|
|
url = None
|
|
start = block_data.get_xblock_field(subsection_key, 'start')
|
|
assignment_released = not start or start < now
|
|
if assignment_released:
|
|
url = reverse('jump_to', args=[course_key, subsection_key])
|
|
|
|
complete = is_block_structure_complete_for_assignments(block_data, subsection_key)
|
|
past_due = not complete and due < now
|
|
assignments.append(_Assignment(
|
|
subsection_key, title, url, due, contains_gated_content,
|
|
complete, past_due, assignment_type, None, first_component_block_id
|
|
))
|
|
|
|
# Load all dates for ORA blocks as separate assignments
|
|
descendents = block_data.get_children(subsection_key)
|
|
while descendents:
|
|
descendent = descendents.pop()
|
|
descendents.extend(block_data.get_children(descendent))
|
|
if block_data.get_xblock_field(descendent, 'category', None) == 'openassessment':
|
|
graded = block_data.get_xblock_field(descendent, 'graded', False)
|
|
has_score = block_data.get_xblock_field(descendent, 'has_score', False)
|
|
weight = block_data.get_xblock_field(descendent, 'weight', 1)
|
|
if not (graded and has_score and (weight is None or weight > 0)):
|
|
continue
|
|
|
|
all_assessments = [{
|
|
'name': 'submission',
|
|
'due': block_data.get_xblock_field(descendent, 'submission_due'),
|
|
'start': block_data.get_xblock_field(descendent, 'submission_start'),
|
|
'required': True
|
|
}]
|
|
|
|
valid_assessments = block_data.get_xblock_field(descendent, 'valid_assessments')
|
|
if valid_assessments:
|
|
all_assessments.extend(valid_assessments)
|
|
|
|
assignment_type = block_data.get_xblock_field(descendent, 'format', None)
|
|
complete = is_block_structure_complete_for_assignments(block_data, descendent)
|
|
|
|
block_title = block_data.get_xblock_field(descendent, 'title', _('Open Response Assessment'))
|
|
|
|
for assessment in all_assessments:
|
|
due = parse_date(assessment.get('due')).replace(tzinfo=pytz.UTC) if assessment.get('due') else None # lint-amnesty, pylint: disable=line-too-long
|
|
if due is None:
|
|
continue
|
|
|
|
assessment_name = assessment.get('name')
|
|
if assessment_name is None:
|
|
continue
|
|
|
|
if assessment_name == 'self-assessment':
|
|
assessment_type = _("Self Assessment")
|
|
elif assessment_name == 'peer-assessment':
|
|
assessment_type = _("Peer Assessment")
|
|
elif assessment_name == 'staff-assessment':
|
|
assessment_type = _("Staff Assessment")
|
|
elif assessment_name == 'submission':
|
|
assessment_type = _("Submission")
|
|
else:
|
|
assessment_type = assessment_name
|
|
title = f"{block_title} ({assessment_type})"
|
|
url = ''
|
|
start = parse_date(assessment.get('start')).replace(tzinfo=pytz.UTC) if assessment.get('start') else None # lint-amnesty, pylint: disable=line-too-long
|
|
assignment_released = not start or start < now
|
|
if assignment_released:
|
|
url = reverse('jump_to', args=[course_key, descendent])
|
|
|
|
past_due = not complete and due and due < now
|
|
first_component_block_id = str(descendent)
|
|
assignments.append(_Assignment(
|
|
descendent,
|
|
title,
|
|
url,
|
|
due,
|
|
False,
|
|
complete,
|
|
past_due,
|
|
assignment_type,
|
|
_("Open Response Assessment due dates are set by your instructor and can't be shifted."),
|
|
first_component_block_id,
|
|
))
|
|
|
|
return assignments
|
|
|
|
|
|
def get_first_component_of_block(block_key, block_data):
|
|
"""
|
|
This function returns the first leaf block of a section(block_key)
|
|
"""
|
|
descendents = block_data.get_children(block_key)
|
|
if descendents:
|
|
return get_first_component_of_block(descendents[0], block_data)
|
|
|
|
return str(block_key)
|
|
|
|
|
|
# TODO: Fix this such that these are pulled in as extra course-specific tabs.
|
|
# arjun will address this by the end of October if no one does so prior to
|
|
# then.
|
|
def get_course_syllabus_section(course, section_key):
|
|
"""
|
|
This returns the snippet of html to be rendered on the syllabus page,
|
|
given the key for the section.
|
|
|
|
Valid keys:
|
|
- syllabus
|
|
- guest_syllabus
|
|
"""
|
|
|
|
# Many of these are stored as html files instead of some semantic
|
|
# markup. This can change without effecting this interface when we find a
|
|
# good format for defining so many snippets of text/html.
|
|
|
|
if section_key in ['syllabus', 'guest_syllabus']:
|
|
try:
|
|
filesys = course.system.resources_fs
|
|
# first look for a run-specific version
|
|
dirs = [path("syllabus") / course.url_name, path("syllabus")]
|
|
filepath = find_file(filesys, dirs, section_key + ".html")
|
|
with filesys.open(filepath) as html_file:
|
|
return replace_static_urls(
|
|
html_file.read().decode('utf-8'),
|
|
getattr(course, 'data_dir', None),
|
|
course_id=course.id,
|
|
static_asset_path=course.static_asset_path,
|
|
)
|
|
except ResourceNotFound:
|
|
log.exception(
|
|
"Missing syllabus section %s in course %s",
|
|
section_key, str(course.location)
|
|
)
|
|
return "! Syllabus missing !"
|
|
|
|
raise KeyError("Invalid about key " + str(section_key))
|
|
|
|
|
|
@function_trace('get_courses')
|
|
def get_courses(user, org=None, filter_=None):
|
|
"""
|
|
Return a LazySequence of courses available, optionally filtered by org code (case-insensitive).
|
|
"""
|
|
courses = branding.get_visible_courses(
|
|
org=org,
|
|
filter_=filter_,
|
|
).prefetch_related(
|
|
'modes',
|
|
).select_related(
|
|
'image_set'
|
|
)
|
|
|
|
permission_name = configuration_helpers.get_value(
|
|
'COURSE_CATALOG_VISIBILITY_PERMISSION',
|
|
settings.COURSE_CATALOG_VISIBILITY_PERMISSION
|
|
)
|
|
|
|
return LazySequence(
|
|
(c for c in courses if has_access(user, permission_name, c)),
|
|
est_len=courses.count()
|
|
)
|
|
|
|
|
|
def get_permission_for_course_about():
|
|
"""
|
|
Returns the CourseOverview object for the course after checking for access.
|
|
"""
|
|
return configuration_helpers.get_value(
|
|
'COURSE_ABOUT_VISIBILITY_PERMISSION',
|
|
settings.COURSE_ABOUT_VISIBILITY_PERMISSION
|
|
)
|
|
|
|
|
|
def sort_by_announcement(courses):
|
|
"""
|
|
Sorts a list of courses by their announcement date. If the date is
|
|
not available, sort them by their start date.
|
|
"""
|
|
|
|
# Sort courses by how far are they from they start day
|
|
key = lambda course: course.sorting_score
|
|
courses = sorted(courses, key=key)
|
|
|
|
return courses
|
|
|
|
|
|
def sort_by_start_date(courses):
|
|
"""
|
|
Returns a list of courses sorted by their start date, latest first.
|
|
"""
|
|
courses = sorted(
|
|
courses,
|
|
key=lambda course: (course.has_ended(), course.start is None, course.start),
|
|
reverse=False
|
|
)
|
|
|
|
return courses
|
|
|
|
|
|
def get_cms_course_link(course, page='course'):
|
|
"""
|
|
Returns a link to course_index for editing the course in cms,
|
|
assuming that the course is actually cms-backed.
|
|
"""
|
|
# This is fragile, but unfortunately the problem is that within the LMS we
|
|
# can't use the reverse calls from the CMS
|
|
return "//{}/{}/{}".format(settings.CMS_BASE, page, str(course.id))
|
|
|
|
|
|
def get_cms_block_link(block, page):
|
|
"""
|
|
Returns a link to block_index for editing the course in cms,
|
|
assuming that the block is actually cms-backed.
|
|
"""
|
|
# This is fragile, but unfortunately the problem is that within the LMS we
|
|
# can't use the reverse calls from the CMS
|
|
return f"//{settings.CMS_BASE}/{page}/{block.location}"
|
|
|
|
|
|
def get_studio_url(course, page):
|
|
"""
|
|
Get the Studio URL of the page that is passed in.
|
|
|
|
Args:
|
|
course (CourseBlock)
|
|
"""
|
|
studio_link = None
|
|
if course.course_edit_method == "Studio":
|
|
studio_link = get_cms_course_link(course, page)
|
|
return studio_link
|
|
|
|
|
|
def get_problems_in_section(section):
|
|
"""
|
|
This returns a dict having problems in a section.
|
|
Returning dict has problem location as keys and problem
|
|
descriptor as values.
|
|
"""
|
|
|
|
problem_descriptors = defaultdict()
|
|
if not isinstance(section, UsageKey):
|
|
section_key = UsageKey.from_string(section)
|
|
else:
|
|
section_key = section
|
|
# it will be a Mongo performance boost, if you pass in a depth=3 argument here
|
|
# as it will optimize round trips to the database to fetch all children for the current node
|
|
section_descriptor = modulestore().get_item(section_key, depth=3)
|
|
|
|
# iterate over section, sub-section, vertical
|
|
for subsection in section_descriptor.get_children():
|
|
for vertical in subsection.get_children():
|
|
for component in vertical.get_children():
|
|
if component.location.block_type == 'problem' and getattr(component, 'has_score', False):
|
|
problem_descriptors[str(component.location)] = component
|
|
|
|
return problem_descriptors
|
|
|
|
|
|
def get_current_child(xmodule, min_depth=None, requested_child=None):
|
|
"""
|
|
Get the xmodule.position's display item of an xmodule that has a position and
|
|
children. If xmodule has no position or is out of bounds, return the first
|
|
child with children of min_depth.
|
|
|
|
For example, if chapter_one has no position set, with two child sections,
|
|
section-A having no children and section-B having a discussion unit,
|
|
`get_current_child(chapter, min_depth=1)` will return section-B.
|
|
|
|
Returns None only if there are no children at all.
|
|
"""
|
|
# TODO: convert this method to use the Course Blocks API
|
|
def _get_child(children):
|
|
"""
|
|
Returns either the first or last child based on the value of
|
|
the requested_child parameter. If requested_child is None,
|
|
returns the first child.
|
|
"""
|
|
if requested_child == 'first':
|
|
return children[0]
|
|
elif requested_child == 'last':
|
|
return children[-1]
|
|
else:
|
|
return children[0]
|
|
|
|
def _get_default_child_module(child_modules):
|
|
"""Returns the first child of xmodule, subject to min_depth."""
|
|
if min_depth is None or min_depth <= 0:
|
|
return _get_child(child_modules)
|
|
else:
|
|
content_children = [
|
|
child for child in child_modules
|
|
if child.has_children_at_depth(min_depth - 1) and child.get_display_items()
|
|
]
|
|
return _get_child(content_children) if content_children else None
|
|
|
|
child = None
|
|
|
|
try:
|
|
# In python 3, hasattr() catches AttributeErrors only then returns False.
|
|
# All other exceptions bubble up the call stack.
|
|
has_position = hasattr(xmodule, 'position') # This conditions returns AssertionError from xblock.fields lib.
|
|
except AssertionError:
|
|
return child
|
|
|
|
if has_position:
|
|
children = xmodule.get_display_items()
|
|
if len(children) > 0:
|
|
if xmodule.position is not None and not requested_child:
|
|
pos = int(xmodule.position) - 1 # position is 1-indexed
|
|
if 0 <= pos < len(children):
|
|
child = children[pos]
|
|
if min_depth is not None and (min_depth > 0 and not child.has_children_at_depth(min_depth - 1)):
|
|
child = None
|
|
if child is None:
|
|
child = _get_default_child_module(children)
|
|
|
|
return child
|
|
|
|
|
|
def get_course_chapter_ids(course_key):
|
|
"""
|
|
Extracts the chapter block keys from a course structure.
|
|
|
|
Arguments:
|
|
course_key (CourseLocator): The course key
|
|
Returns:
|
|
list (string): The list of string representations of the chapter block keys in the course.
|
|
"""
|
|
try:
|
|
chapter_keys = modulestore().get_course(course_key).children
|
|
except Exception: # pylint: disable=broad-except
|
|
log.exception('Failed to retrieve course from modulestore.')
|
|
return []
|
|
return [str(chapter_key) for chapter_key in chapter_keys if chapter_key.block_type == 'chapter']
|