1717 lines
68 KiB
Python
1717 lines
68 KiB
Python
"""
|
|
Courseware views functions
|
|
"""
|
|
import json
|
|
import logging
|
|
import urllib
|
|
from collections import OrderedDict, namedtuple
|
|
from datetime import datetime
|
|
|
|
import analytics
|
|
from django.conf import settings
|
|
from django.contrib.auth.decorators import login_required
|
|
from django.contrib.auth.models import AnonymousUser, User
|
|
from django.core.exceptions import PermissionDenied
|
|
from django.core.urlresolvers import reverse
|
|
from django.db import transaction
|
|
from django.db.models import Q
|
|
from django.http import Http404, HttpResponse, HttpResponseBadRequest, HttpResponseForbidden
|
|
from django.shortcuts import redirect
|
|
from django.template.context_processors import csrf
|
|
from django.utils.decorators import method_decorator
|
|
from django.utils.http import urlquote_plus
|
|
from django.utils.text import slugify
|
|
from django.utils.translation import ugettext as _
|
|
from django.views.decorators.cache import cache_control
|
|
from django.views.decorators.csrf import ensure_csrf_cookie
|
|
from django.views.decorators.http import require_GET, require_http_methods, require_POST
|
|
from django.views.generic import View
|
|
from eventtracking import tracker
|
|
from ipware.ip import get_ip
|
|
from markupsafe import escape
|
|
from opaque_keys import InvalidKeyError
|
|
from opaque_keys.edx.keys import CourseKey, UsageKey
|
|
from pytz import UTC
|
|
from rest_framework import status
|
|
from six import text_type
|
|
from web_fragments.fragment import Fragment
|
|
|
|
import shoppingcart
|
|
import survey.views
|
|
from lms.djangoapps.certificates import api as certs_api
|
|
from lms.djangoapps.certificates.models import CertificateStatuses
|
|
from course_modes.models import CourseMode, get_course_prices
|
|
from courseware.access import has_access, has_ccx_coach_role
|
|
from courseware.access_utils import check_course_open_for_learner
|
|
from courseware.courses import (
|
|
can_self_enroll_in_course,
|
|
course_open_for_self_enrollment,
|
|
get_course,
|
|
get_course_overview_with_access,
|
|
get_course_with_access,
|
|
get_courses,
|
|
get_current_child,
|
|
get_permission_for_course_about,
|
|
get_studio_url,
|
|
sort_by_announcement,
|
|
sort_by_start_date
|
|
)
|
|
from courseware.masquerade import setup_masquerade
|
|
from courseware.model_data import FieldDataCache
|
|
from courseware.models import BaseStudentModuleHistory, StudentModule
|
|
from courseware.url_helpers import get_redirect_url
|
|
from courseware.user_state_client import DjangoXBlockUserStateClient
|
|
from edxmako.shortcuts import marketing_link, render_to_response, render_to_string
|
|
from enrollment.api import add_enrollment
|
|
from lms.djangoapps.ccx.custom_exception import CCXLocatorValidationException
|
|
from lms.djangoapps.commerce.utils import EcommerceService
|
|
from lms.djangoapps.courseware.exceptions import CourseAccessRedirect, Redirect
|
|
from lms.djangoapps.experiments.utils import get_experiment_user_metadata_context
|
|
from lms.djangoapps.grades.course_grade_factory import CourseGradeFactory
|
|
from lms.djangoapps.instructor.enrollment import uses_shib
|
|
from lms.djangoapps.instructor.views.api import require_global_staff
|
|
from lms.djangoapps.verify_student.services import IDVerificationService
|
|
from openedx.core.djangoapps.catalog.utils import get_programs, get_programs_with_type
|
|
from openedx.core.djangoapps.certificates import api as auto_certs_api
|
|
from openedx.core.djangoapps.content.course_overviews.models import CourseOverview
|
|
from openedx.core.djangoapps.credit.api import (
|
|
get_credit_requirement_status,
|
|
is_credit_course,
|
|
is_user_eligible_for_credit
|
|
)
|
|
from openedx.core.djangoapps.models.course_details import CourseDetails
|
|
from openedx.core.djangoapps.monitoring_utils import set_custom_metrics_for_course_key
|
|
from openedx.core.djangoapps.plugin_api.views import EdxFragmentView
|
|
from openedx.core.djangoapps.programs.utils import ProgramMarketingDataExtender
|
|
from openedx.core.djangoapps.self_paced.models import SelfPacedConfiguration
|
|
from openedx.core.djangoapps.site_configuration import helpers as configuration_helpers
|
|
from openedx.core.djangoapps.util.user_messages import PageLevelMessages
|
|
from openedx.core.djangolib.markup import HTML, Text
|
|
from openedx.features.course_experience import UNIFIED_COURSE_TAB_FLAG, course_home_url_name
|
|
from openedx.features.course_experience.course_tools import CourseToolsPluginManager
|
|
from openedx.features.course_experience.views.course_dates import CourseDatesFragmentView
|
|
from openedx.features.enterprise_support.api import data_sharing_consent_required
|
|
from shoppingcart.utils import is_shopping_cart_enabled
|
|
from student.models import CourseEnrollment, UserTestGroup
|
|
from util.cache import cache, cache_if_anonymous
|
|
from util.db import outer_atomic
|
|
from util.milestones_helpers import get_prerequisite_courses_display
|
|
from util.views import _record_feedback_in_zendesk, ensure_valid_course_key, ensure_valid_usage_key
|
|
from xmodule.modulestore.django import modulestore
|
|
from xmodule.modulestore.exceptions import ItemNotFoundError, NoPathToItem
|
|
from xmodule.tabs import CourseTabList
|
|
from xmodule.x_module import STUDENT_VIEW
|
|
|
|
from ..entrance_exams import user_can_skip_entrance_exam
|
|
from ..module_render import get_module, get_module_by_usage_id, get_module_for_descriptor
|
|
|
|
log = logging.getLogger("edx.courseware")
|
|
|
|
|
|
# Only display the requirements on learner dashboard for
|
|
# credit and verified modes.
|
|
REQUIREMENTS_DISPLAY_MODES = CourseMode.CREDIT_MODES + [CourseMode.VERIFIED]
|
|
|
|
CertData = namedtuple(
|
|
"CertData", ["cert_status", "title", "msg", "download_url", "cert_web_view_url"]
|
|
)
|
|
|
|
AUDIT_PASSING_CERT_DATA = CertData(
|
|
CertificateStatuses.audit_passing,
|
|
_('Your enrollment: Audit track'),
|
|
_('You are enrolled in the audit track for this course. The audit track does not include a certificate.'),
|
|
download_url=None,
|
|
cert_web_view_url=None
|
|
)
|
|
|
|
HONOR_PASSING_CERT_DATA = CertData(
|
|
CertificateStatuses.honor_passing,
|
|
_('Your enrollment: Honor track'),
|
|
_('You are enrolled in the honor track for this course. The honor track does not include a certificate.'),
|
|
download_url=None,
|
|
cert_web_view_url=None
|
|
)
|
|
|
|
GENERATING_CERT_DATA = CertData(
|
|
CertificateStatuses.generating,
|
|
_("We're working on it..."),
|
|
_(
|
|
"We're creating your certificate. You can keep working in your courses and a link "
|
|
"to it will appear here and on your Dashboard when it is ready."
|
|
),
|
|
download_url=None,
|
|
cert_web_view_url=None
|
|
)
|
|
|
|
INVALID_CERT_DATA = CertData(
|
|
CertificateStatuses.invalidated,
|
|
_('Your certificate has been invalidated'),
|
|
_('Please contact your course team if you have any questions.'),
|
|
download_url=None,
|
|
cert_web_view_url=None
|
|
)
|
|
|
|
REQUESTING_CERT_DATA = CertData(
|
|
CertificateStatuses.requesting,
|
|
_('Congratulations, you qualified for a certificate!'),
|
|
_("You've earned a certificate for this course."),
|
|
download_url=None,
|
|
cert_web_view_url=None
|
|
)
|
|
|
|
UNVERIFIED_CERT_DATA = CertData(
|
|
CertificateStatuses.unverified,
|
|
_('Certificate unavailable'),
|
|
_(
|
|
'You have not received a certificate because you do not have a current {platform_name} '
|
|
'verified identity.'
|
|
).format(platform_name=configuration_helpers.get_value('PLATFORM_NAME', settings.PLATFORM_NAME)),
|
|
download_url=None,
|
|
cert_web_view_url=None
|
|
)
|
|
|
|
|
|
def _downloadable_cert_data(download_url=None, cert_web_view_url=None):
|
|
return CertData(
|
|
CertificateStatuses.downloadable,
|
|
_('Your certificate is available'),
|
|
_("You've earned a certificate for this course."),
|
|
download_url=download_url,
|
|
cert_web_view_url=cert_web_view_url
|
|
)
|
|
|
|
|
|
def user_groups(user):
|
|
"""
|
|
TODO (vshnayder): This is not used. When we have a new plan for groups, adjust appropriately.
|
|
"""
|
|
if not user.is_authenticated():
|
|
return []
|
|
|
|
# TODO: Rewrite in Django
|
|
key = 'user_group_names_{user.id}'.format(user=user)
|
|
cache_expiration = 60 * 60 # one hour
|
|
|
|
# Kill caching on dev machines -- we switch groups a lot
|
|
group_names = cache.get(key) # pylint: disable=no-member
|
|
if settings.DEBUG:
|
|
group_names = None
|
|
|
|
if group_names is None:
|
|
group_names = [u.name for u in UserTestGroup.objects.filter(users=user)]
|
|
cache.set(key, group_names, cache_expiration) # pylint: disable=no-member
|
|
|
|
return group_names
|
|
|
|
|
|
@ensure_csrf_cookie
|
|
@cache_if_anonymous()
|
|
def courses(request):
|
|
"""
|
|
Render "find courses" page. The course selection work is done in courseware.courses.
|
|
"""
|
|
courses_list = []
|
|
course_discovery_meanings = getattr(settings, 'COURSE_DISCOVERY_MEANINGS', {})
|
|
if not settings.FEATURES.get('ENABLE_COURSE_DISCOVERY'):
|
|
courses_list = get_courses(request.user)
|
|
|
|
if configuration_helpers.get_value("ENABLE_COURSE_SORTING_BY_START_DATE",
|
|
settings.FEATURES["ENABLE_COURSE_SORTING_BY_START_DATE"]):
|
|
courses_list = sort_by_start_date(courses_list)
|
|
else:
|
|
courses_list = sort_by_announcement(courses_list)
|
|
|
|
# Add marketable programs to the context.
|
|
programs_list = get_programs_with_type(request.site, include_hidden=False)
|
|
|
|
return render_to_response(
|
|
"courseware/courses.html",
|
|
{
|
|
'courses': courses_list,
|
|
'course_discovery_meanings': course_discovery_meanings,
|
|
'programs_list': programs_list
|
|
}
|
|
)
|
|
|
|
|
|
@ensure_csrf_cookie
|
|
@ensure_valid_course_key
|
|
def jump_to_id(request, course_id, module_id):
|
|
"""
|
|
This entry point allows for a shorter version of a jump to where just the id of the element is
|
|
passed in. This assumes that id is unique within the course_id namespace
|
|
"""
|
|
course_key = CourseKey.from_string(course_id)
|
|
items = modulestore().get_items(course_key, qualifiers={'name': module_id})
|
|
|
|
if len(items) == 0:
|
|
raise Http404(
|
|
u"Could not find id: {0} in course_id: {1}. Referer: {2}".format(
|
|
module_id, course_id, request.META.get("HTTP_REFERER", "")
|
|
))
|
|
if len(items) > 1:
|
|
log.warning(
|
|
u"Multiple items found with id: %s in course_id: %s. Referer: %s. Using first: %s",
|
|
module_id,
|
|
course_id,
|
|
request.META.get("HTTP_REFERER", ""),
|
|
text_type(items[0].location)
|
|
)
|
|
|
|
return jump_to(request, course_id, text_type(items[0].location))
|
|
|
|
|
|
@ensure_csrf_cookie
|
|
def jump_to(_request, course_id, location):
|
|
"""
|
|
Show the page that contains a specific location.
|
|
|
|
If the location is invalid or not in any class, return a 404.
|
|
|
|
Otherwise, delegates to the index view to figure out whether this user
|
|
has access, and what they should see.
|
|
"""
|
|
try:
|
|
course_key = CourseKey.from_string(course_id)
|
|
usage_key = UsageKey.from_string(location).replace(course_key=course_key)
|
|
except InvalidKeyError:
|
|
raise Http404(u"Invalid course_key or usage_key")
|
|
try:
|
|
redirect_url = get_redirect_url(course_key, usage_key)
|
|
except ItemNotFoundError:
|
|
raise Http404(u"No data at this location: {0}".format(usage_key))
|
|
except NoPathToItem:
|
|
raise Http404(u"This location is not in any class: {0}".format(usage_key))
|
|
|
|
return redirect(redirect_url)
|
|
|
|
|
|
@ensure_csrf_cookie
|
|
@ensure_valid_course_key
|
|
@data_sharing_consent_required
|
|
def course_info(request, course_id):
|
|
"""
|
|
Display the course's info.html, or 404 if there is no such course.
|
|
|
|
Assumes the course_id is in a valid format.
|
|
"""
|
|
# TODO: LEARNER-611: This can be deleted with Course Info removal. The new
|
|
# Course Home is using its own processing of last accessed.
|
|
def get_last_accessed_courseware(course, request, user):
|
|
"""
|
|
Returns the courseware module URL that the user last accessed, or None if it cannot be found.
|
|
"""
|
|
field_data_cache = FieldDataCache.cache_for_descriptor_descendents(
|
|
course.id, request.user, course, depth=2
|
|
)
|
|
course_module = get_module_for_descriptor(
|
|
user, request, course, field_data_cache, course.id, course=course
|
|
)
|
|
chapter_module = get_current_child(course_module)
|
|
if chapter_module is not None:
|
|
section_module = get_current_child(chapter_module)
|
|
if section_module is not None:
|
|
url = reverse('courseware_section', kwargs={
|
|
'course_id': text_type(course.id),
|
|
'chapter': chapter_module.url_name,
|
|
'section': section_module.url_name
|
|
})
|
|
return url
|
|
return None
|
|
|
|
course_key = CourseKey.from_string(course_id)
|
|
|
|
# If the unified course experience is enabled, redirect to the "Course" tab
|
|
if UNIFIED_COURSE_TAB_FLAG.is_enabled(course_key):
|
|
return redirect(reverse(course_home_url_name(course_key), args=[course_id]))
|
|
|
|
with modulestore().bulk_operations(course_key):
|
|
course = get_course_with_access(request.user, 'load', course_key)
|
|
|
|
staff_access = has_access(request.user, 'staff', course)
|
|
masquerade, user = setup_masquerade(request, course_key, staff_access, reset_masquerade_data=True)
|
|
|
|
# LEARNER-612: CCX redirect handled by new Course Home (DONE)
|
|
# LEARNER-1697: Transition banner messages to new Course Home (DONE)
|
|
# if user is not enrolled in a course then app will show enroll/get register link inside course info page.
|
|
user_is_enrolled = CourseEnrollment.is_enrolled(user, course.id)
|
|
show_enroll_banner = request.user.is_authenticated() and not user_is_enrolled
|
|
|
|
# If the user is not enrolled but this is a course that does not support
|
|
# direct enrollment then redirect them to the dashboard.
|
|
if not user_is_enrolled and not can_self_enroll_in_course(course_key):
|
|
return redirect(reverse('dashboard'))
|
|
|
|
# LEARNER-170: Entrance exam is handled by new Course Outline. (DONE)
|
|
# If the user needs to take an entrance exam to access this course, then we'll need
|
|
# to send them to that specific course module before allowing them into other areas
|
|
if not user_can_skip_entrance_exam(user, course):
|
|
return redirect(reverse('courseware', args=[text_type(course.id)]))
|
|
|
|
# TODO: LEARNER-611: Remove deprecated course.bypass_home.
|
|
# If the user is coming from the dashboard and bypass_home setting is set,
|
|
# redirect them straight to the courseware page.
|
|
is_from_dashboard = reverse('dashboard') in request.META.get('HTTP_REFERER', [])
|
|
if course.bypass_home and is_from_dashboard:
|
|
return redirect(reverse('courseware', args=[course_id]))
|
|
|
|
# Construct the dates fragment
|
|
dates_fragment = None
|
|
|
|
if request.user.is_authenticated():
|
|
# TODO: LEARNER-611: Remove enable_course_home_improvements
|
|
if SelfPacedConfiguration.current().enable_course_home_improvements:
|
|
# Shared code with the new Course Home (DONE)
|
|
dates_fragment = CourseDatesFragmentView().render_to_fragment(request, course_id=course_id)
|
|
|
|
# This local import is due to the circularity of lms and openedx references.
|
|
# This may be resolved by using stevedore to allow web fragments to be used
|
|
# as plugins, and to avoid the direct import.
|
|
from openedx.features.course_experience.views.course_reviews import CourseReviewsModuleFragmentView
|
|
|
|
# Shared code with the new Course Home (DONE)
|
|
# Get the course tools enabled for this user and course
|
|
course_tools = CourseToolsPluginManager.get_enabled_course_tools(request, course_key)
|
|
|
|
course_homepage_invert_title =\
|
|
configuration_helpers.get_value(
|
|
'COURSE_HOMEPAGE_INVERT_TITLE',
|
|
False
|
|
)
|
|
|
|
course_homepage_show_subtitle =\
|
|
configuration_helpers.get_value(
|
|
'COURSE_HOMEPAGE_SHOW_SUBTITLE',
|
|
True
|
|
)
|
|
|
|
course_homepage_show_org =\
|
|
configuration_helpers.get_value('COURSE_HOMEPAGE_SHOW_ORG', True)
|
|
|
|
course_title = course.display_number_with_default
|
|
course_subtitle = course.display_name_with_default
|
|
if course_homepage_invert_title:
|
|
course_title = course.display_name_with_default
|
|
course_subtitle = course.display_number_with_default
|
|
|
|
context = {
|
|
'request': request,
|
|
'masquerade_user': user,
|
|
'course_id': text_type(course_key),
|
|
'url_to_enroll': CourseTabView.url_to_enroll(course_key),
|
|
'cache': None,
|
|
'course': course,
|
|
'course_title': course_title,
|
|
'course_subtitle': course_subtitle,
|
|
'show_subtitle': course_homepage_show_subtitle,
|
|
'show_org': course_homepage_show_org,
|
|
'staff_access': staff_access,
|
|
'masquerade': masquerade,
|
|
'supports_preview_menu': True,
|
|
'studio_url': get_studio_url(course, 'course_info'),
|
|
'show_enroll_banner': show_enroll_banner,
|
|
'user_is_enrolled': user_is_enrolled,
|
|
'dates_fragment': dates_fragment,
|
|
'course_tools': course_tools,
|
|
}
|
|
context.update(
|
|
get_experiment_user_metadata_context(
|
|
course,
|
|
user,
|
|
)
|
|
)
|
|
|
|
# Get the URL of the user's last position in order to display the 'where you were last' message
|
|
context['resume_course_url'] = None
|
|
# TODO: LEARNER-611: Remove enable_course_home_improvements
|
|
if SelfPacedConfiguration.current().enable_course_home_improvements:
|
|
context['resume_course_url'] = get_last_accessed_courseware(course, request, user)
|
|
|
|
if not check_course_open_for_learner(user, course):
|
|
# Disable student view button if user is staff and
|
|
# course is not yet visible to students.
|
|
context['disable_student_access'] = True
|
|
context['supports_preview_menu'] = False
|
|
|
|
return render_to_response('courseware/info.html', context)
|
|
|
|
|
|
class StaticCourseTabView(EdxFragmentView):
|
|
"""
|
|
View that displays a static course tab with a given name.
|
|
"""
|
|
@method_decorator(ensure_csrf_cookie)
|
|
@method_decorator(ensure_valid_course_key)
|
|
def get(self, request, course_id, tab_slug, **kwargs):
|
|
"""
|
|
Displays a static course tab page with a given name
|
|
"""
|
|
course_key = CourseKey.from_string(course_id)
|
|
course = get_course_with_access(request.user, 'load', course_key)
|
|
tab = CourseTabList.get_tab_by_slug(course.tabs, tab_slug)
|
|
if tab is None:
|
|
raise Http404
|
|
|
|
# Show warnings if the user has limited access
|
|
CourseTabView.register_user_access_warning_messages(request, course_key)
|
|
|
|
return super(StaticCourseTabView, self).get(request, course=course, tab=tab, **kwargs)
|
|
|
|
def render_to_fragment(self, request, course=None, tab=None, **kwargs):
|
|
"""
|
|
Renders the static tab to a fragment.
|
|
"""
|
|
return get_static_tab_fragment(request, course, tab)
|
|
|
|
def render_standalone_response(self, request, fragment, course=None, tab=None, **kwargs):
|
|
"""
|
|
Renders this static tab's fragment to HTML for a standalone page.
|
|
"""
|
|
return render_to_response('courseware/static_tab.html', {
|
|
'course': course,
|
|
'active_page': 'static_tab_{0}'.format(tab['url_slug']),
|
|
'tab': tab,
|
|
'fragment': fragment,
|
|
'uses_pattern_library': False,
|
|
'disable_courseware_js': True,
|
|
})
|
|
|
|
|
|
class CourseTabView(EdxFragmentView):
|
|
"""
|
|
View that displays a course tab page.
|
|
"""
|
|
@method_decorator(ensure_csrf_cookie)
|
|
@method_decorator(ensure_valid_course_key)
|
|
@method_decorator(data_sharing_consent_required)
|
|
def get(self, request, course_id, tab_type, **kwargs):
|
|
"""
|
|
Displays a course tab page that contains a web fragment.
|
|
"""
|
|
course_key = CourseKey.from_string(course_id)
|
|
with modulestore().bulk_operations(course_key):
|
|
course = get_course_with_access(request.user, 'load', course_key)
|
|
try:
|
|
# Render the page
|
|
tab = CourseTabList.get_tab_by_type(course.tabs, tab_type)
|
|
page_context = self.create_page_context(request, course=course, tab=tab, **kwargs)
|
|
|
|
# Show warnings if the user has limited access
|
|
# Must come after masquerading on creation of page context
|
|
self.register_user_access_warning_messages(request, course_key)
|
|
|
|
set_custom_metrics_for_course_key(course_key)
|
|
return super(CourseTabView, self).get(request, course=course, page_context=page_context, **kwargs)
|
|
except Exception as exception: # pylint: disable=broad-except
|
|
return CourseTabView.handle_exceptions(request, course, exception)
|
|
|
|
@staticmethod
|
|
def url_to_enroll(course_key):
|
|
"""
|
|
Returns the URL to use to enroll in the specified course.
|
|
"""
|
|
url_to_enroll = reverse('about_course', args=[text_type(course_key)])
|
|
if settings.FEATURES.get('ENABLE_MKTG_SITE'):
|
|
url_to_enroll = marketing_link('COURSES')
|
|
return url_to_enroll
|
|
|
|
@staticmethod
|
|
def register_user_access_warning_messages(request, course_key):
|
|
"""
|
|
Register messages to be shown to the user if they have limited access.
|
|
"""
|
|
if request.user.is_anonymous():
|
|
PageLevelMessages.register_warning_message(
|
|
request,
|
|
Text(_("To see course content, {sign_in_link} or {register_link}.")).format(
|
|
sign_in_link=HTML('<a href="/login?next={current_url}">{sign_in_label}</a>').format(
|
|
sign_in_label=_("sign in"),
|
|
current_url=urlquote_plus(request.path),
|
|
),
|
|
register_link=HTML('<a href="/register?next={current_url}">{register_label}</a>').format(
|
|
register_label=_("register"),
|
|
current_url=urlquote_plus(request.path),
|
|
),
|
|
)
|
|
)
|
|
else:
|
|
if not CourseEnrollment.is_enrolled(request.user, course_key):
|
|
# Only show enroll button if course is open for enrollment.
|
|
if course_open_for_self_enrollment(course_key):
|
|
enroll_message = _('You must be enrolled in the course to see course content. \
|
|
{enroll_link_start}Enroll now{enroll_link_end}.')
|
|
PageLevelMessages.register_warning_message(
|
|
request,
|
|
Text(enroll_message).format(
|
|
enroll_link_start=HTML('<button class="enroll-btn btn-link">'),
|
|
enroll_link_end=HTML('</button>')
|
|
)
|
|
)
|
|
else:
|
|
PageLevelMessages.register_warning_message(
|
|
request,
|
|
Text(_('You must be enrolled in the course to see course content.'))
|
|
)
|
|
|
|
@staticmethod
|
|
def handle_exceptions(request, course, exception):
|
|
"""
|
|
Handle exceptions raised when rendering a view.
|
|
"""
|
|
if isinstance(exception, Redirect) or isinstance(exception, Http404):
|
|
raise
|
|
if isinstance(exception, UnicodeEncodeError):
|
|
raise Http404("URL contains Unicode characters")
|
|
if settings.DEBUG:
|
|
raise
|
|
user = request.user
|
|
log.exception(
|
|
u"Error in %s: user=%s, effective_user=%s, course=%s",
|
|
request.path,
|
|
getattr(user, 'real_user', user),
|
|
user,
|
|
text_type(course.id),
|
|
)
|
|
try:
|
|
return render_to_response(
|
|
'courseware/courseware-error.html',
|
|
{
|
|
'staff_access': has_access(user, 'staff', course),
|
|
'course': course,
|
|
},
|
|
status=500,
|
|
)
|
|
except:
|
|
# Let the exception propagate, relying on global config to
|
|
# at least return a nice error message
|
|
log.exception("Error while rendering courseware-error page")
|
|
raise
|
|
|
|
def uses_bootstrap(self, request, course, tab):
|
|
"""
|
|
Returns true if this view uses Bootstrap.
|
|
"""
|
|
return tab.uses_bootstrap
|
|
|
|
def create_page_context(self, request, course=None, tab=None, **kwargs):
|
|
"""
|
|
Creates the context for the fragment's template.
|
|
"""
|
|
staff_access = has_access(request.user, 'staff', course)
|
|
supports_preview_menu = tab.get('supports_preview_menu', False)
|
|
uses_bootstrap = self.uses_bootstrap(request, course, tab=tab)
|
|
if supports_preview_menu:
|
|
masquerade, masquerade_user = setup_masquerade(request, course.id, staff_access, reset_masquerade_data=True)
|
|
request.user = masquerade_user
|
|
else:
|
|
masquerade = None
|
|
|
|
if course and not check_course_open_for_learner(request.user, course):
|
|
# Disable student view button if user is staff and
|
|
# course is not yet visible to students.
|
|
supports_preview_menu = False
|
|
|
|
context = {
|
|
'course': course,
|
|
'tab': tab,
|
|
'active_page': tab.get('type', None),
|
|
'staff_access': staff_access,
|
|
'masquerade': masquerade,
|
|
'supports_preview_menu': supports_preview_menu,
|
|
'uses_bootstrap': uses_bootstrap,
|
|
'uses_pattern_library': not uses_bootstrap,
|
|
'disable_courseware_js': True,
|
|
}
|
|
context.update(
|
|
get_experiment_user_metadata_context(
|
|
course,
|
|
request.user,
|
|
)
|
|
)
|
|
return context
|
|
|
|
def render_to_fragment(self, request, course=None, page_context=None, **kwargs):
|
|
"""
|
|
Renders the course tab to a fragment.
|
|
"""
|
|
tab = page_context['tab']
|
|
return tab.render_to_fragment(request, course, **kwargs)
|
|
|
|
def render_standalone_response(self, request, fragment, course=None, tab=None, page_context=None, **kwargs):
|
|
"""
|
|
Renders this course tab's fragment to HTML for a standalone page.
|
|
"""
|
|
if not page_context:
|
|
page_context = self.create_page_context(request, course=course, tab=tab, **kwargs)
|
|
tab = page_context['tab']
|
|
page_context['fragment'] = fragment
|
|
if self.uses_bootstrap(request, course, tab=tab):
|
|
return render_to_response('courseware/tab-view.html', page_context)
|
|
else:
|
|
return render_to_response('courseware/tab-view-v2.html', page_context)
|
|
|
|
|
|
@ensure_csrf_cookie
|
|
@ensure_valid_course_key
|
|
def syllabus(request, course_id):
|
|
"""
|
|
Display the course's syllabus.html, or 404 if there is no such course.
|
|
|
|
Assumes the course_id is in a valid format.
|
|
"""
|
|
|
|
course_key = CourseKey.from_string(course_id)
|
|
|
|
course = get_course_with_access(request.user, 'load', course_key)
|
|
staff_access = bool(has_access(request.user, 'staff', course))
|
|
|
|
return render_to_response('courseware/syllabus.html', {
|
|
'course': course,
|
|
'staff_access': staff_access,
|
|
})
|
|
|
|
|
|
def registered_for_course(course, user):
|
|
"""
|
|
Return True if user is registered for course, else False
|
|
"""
|
|
if user is None:
|
|
return False
|
|
if user.is_authenticated():
|
|
return CourseEnrollment.is_enrolled(user, course.id)
|
|
else:
|
|
return False
|
|
|
|
|
|
class EnrollStaffView(View):
|
|
"""
|
|
Displays view for registering in the course to a global staff user.
|
|
|
|
User can either choose to 'Enroll' or 'Don't Enroll' in the course.
|
|
Enroll: Enrolls user in course and redirects to the courseware.
|
|
Don't Enroll: Redirects user to course about page.
|
|
|
|
Arguments:
|
|
- request : HTTP request
|
|
- course_id : course id
|
|
|
|
Returns:
|
|
- RedirectResponse
|
|
"""
|
|
template_name = 'enroll_staff.html'
|
|
|
|
@method_decorator(require_global_staff)
|
|
@method_decorator(ensure_valid_course_key)
|
|
def get(self, request, course_id):
|
|
"""
|
|
Display enroll staff view to global staff user with `Enroll` and `Don't Enroll` options.
|
|
"""
|
|
user = request.user
|
|
course_key = CourseKey.from_string(course_id)
|
|
with modulestore().bulk_operations(course_key):
|
|
course = get_course_with_access(user, 'load', course_key)
|
|
if not registered_for_course(course, user):
|
|
context = {
|
|
'course': course,
|
|
'csrftoken': csrf(request)["csrf_token"]
|
|
}
|
|
return render_to_response(self.template_name, context)
|
|
|
|
@method_decorator(require_global_staff)
|
|
@method_decorator(ensure_valid_course_key)
|
|
def post(self, request, course_id):
|
|
"""
|
|
Either enrolls the user in course or redirects user to course about page
|
|
depending upon the option (Enroll, Don't Enroll) chosen by the user.
|
|
"""
|
|
_next = urllib.quote_plus(request.GET.get('next', 'info'), safe='/:?=')
|
|
course_key = CourseKey.from_string(course_id)
|
|
enroll = 'enroll' in request.POST
|
|
if enroll:
|
|
add_enrollment(request.user.username, course_id)
|
|
log.info(
|
|
u"User %s enrolled in %s via `enroll_staff` view",
|
|
request.user.username,
|
|
course_id
|
|
)
|
|
return redirect(_next)
|
|
|
|
# In any other case redirect to the course about page.
|
|
return redirect(reverse('about_course', args=[text_type(course_key)]))
|
|
|
|
|
|
@ensure_csrf_cookie
|
|
@ensure_valid_course_key
|
|
@cache_if_anonymous()
|
|
def course_about(request, course_id):
|
|
"""
|
|
Display the course's about page.
|
|
"""
|
|
course_key = CourseKey.from_string(course_id)
|
|
|
|
# If a user is not able to enroll in a course then redirect
|
|
# them away from the about page to the dashboard.
|
|
if not can_self_enroll_in_course(course_key):
|
|
return redirect(reverse('dashboard'))
|
|
|
|
with modulestore().bulk_operations(course_key):
|
|
permission = get_permission_for_course_about()
|
|
course = get_course_with_access(request.user, permission, course_key)
|
|
course_details = CourseDetails.populate(course)
|
|
modes = CourseMode.modes_for_course_dict(course_key)
|
|
|
|
if configuration_helpers.get_value('ENABLE_MKTG_SITE', settings.FEATURES.get('ENABLE_MKTG_SITE', False)):
|
|
return redirect(reverse(course_home_url_name(course.id), args=[text_type(course.id)]))
|
|
|
|
registered = registered_for_course(course, request.user)
|
|
|
|
staff_access = bool(has_access(request.user, 'staff', course))
|
|
studio_url = get_studio_url(course, 'settings/details')
|
|
|
|
if has_access(request.user, 'load', course):
|
|
course_target = reverse(course_home_url_name(course.id), args=[text_type(course.id)])
|
|
else:
|
|
course_target = reverse('about_course', args=[text_type(course.id)])
|
|
|
|
show_courseware_link = bool(
|
|
(
|
|
has_access(request.user, 'load', course)
|
|
) or settings.FEATURES.get('ENABLE_LMS_MIGRATION')
|
|
)
|
|
|
|
# Note: this is a flow for payment for course registration, not the Verified Certificate flow.
|
|
in_cart = False
|
|
reg_then_add_to_cart_link = ""
|
|
|
|
_is_shopping_cart_enabled = is_shopping_cart_enabled()
|
|
if _is_shopping_cart_enabled:
|
|
if request.user.is_authenticated():
|
|
cart = shoppingcart.models.Order.get_cart_for_user(request.user)
|
|
in_cart = shoppingcart.models.PaidCourseRegistration.contained_in_order(cart, course_key) or \
|
|
shoppingcart.models.CourseRegCodeItem.contained_in_order(cart, course_key)
|
|
|
|
reg_then_add_to_cart_link = "{reg_url}?course_id={course_id}&enrollment_action=add_to_cart".format(
|
|
reg_url=reverse('register_user'), course_id=urllib.quote(str(course_id))
|
|
)
|
|
|
|
# If the ecommerce checkout flow is enabled and the mode of the course is
|
|
# professional or no id professional, we construct links for the enrollment
|
|
# button to add the course to the ecommerce basket.
|
|
ecomm_service = EcommerceService()
|
|
ecommerce_checkout = ecomm_service.is_enabled(request.user)
|
|
ecommerce_checkout_link = ''
|
|
ecommerce_bulk_checkout_link = ''
|
|
professional_mode = None
|
|
is_professional_mode = CourseMode.PROFESSIONAL in modes or CourseMode.NO_ID_PROFESSIONAL_MODE in modes
|
|
if ecommerce_checkout and is_professional_mode:
|
|
professional_mode = modes.get(CourseMode.PROFESSIONAL, '') or \
|
|
modes.get(CourseMode.NO_ID_PROFESSIONAL_MODE, '')
|
|
if professional_mode.sku:
|
|
ecommerce_checkout_link = ecomm_service.get_checkout_page_url(professional_mode.sku)
|
|
if professional_mode.bulk_sku:
|
|
ecommerce_bulk_checkout_link = ecomm_service.get_checkout_page_url(professional_mode.bulk_sku)
|
|
|
|
registration_price, course_price = get_course_prices(course)
|
|
|
|
# Determine which checkout workflow to use -- LMS shoppingcart or Otto basket
|
|
can_add_course_to_cart = _is_shopping_cart_enabled and registration_price and not ecommerce_checkout_link
|
|
|
|
# Used to provide context to message to student if enrollment not allowed
|
|
can_enroll = bool(has_access(request.user, 'enroll', course))
|
|
invitation_only = course.invitation_only
|
|
is_course_full = CourseEnrollment.objects.is_course_full(course)
|
|
|
|
# Register button should be disabled if one of the following is true:
|
|
# - Student is already registered for course
|
|
# - Course is already full
|
|
# - Student cannot enroll in course
|
|
active_reg_button = not (registered or is_course_full or not can_enroll)
|
|
|
|
is_shib_course = uses_shib(course)
|
|
|
|
# get prerequisite courses display names
|
|
pre_requisite_courses = get_prerequisite_courses_display(course)
|
|
|
|
# Overview
|
|
overview = CourseOverview.get_from_id(course.id)
|
|
|
|
# This local import is due to the circularity of lms and openedx references.
|
|
# This may be resolved by using stevedore to allow web fragments to be used
|
|
# as plugins, and to avoid the direct import.
|
|
from openedx.features.course_experience.views.course_reviews import CourseReviewsModuleFragmentView
|
|
|
|
# Embed the course reviews tool
|
|
reviews_fragment_view = CourseReviewsModuleFragmentView().render_to_fragment(request, course=course)
|
|
|
|
context = {
|
|
'course': course,
|
|
'course_details': course_details,
|
|
'staff_access': staff_access,
|
|
'studio_url': studio_url,
|
|
'registered': registered,
|
|
'course_target': course_target,
|
|
'is_cosmetic_price_enabled': settings.FEATURES.get('ENABLE_COSMETIC_DISPLAY_PRICE'),
|
|
'course_price': course_price,
|
|
'in_cart': in_cart,
|
|
'ecommerce_checkout': ecommerce_checkout,
|
|
'ecommerce_checkout_link': ecommerce_checkout_link,
|
|
'ecommerce_bulk_checkout_link': ecommerce_bulk_checkout_link,
|
|
'professional_mode': professional_mode,
|
|
'reg_then_add_to_cart_link': reg_then_add_to_cart_link,
|
|
'show_courseware_link': show_courseware_link,
|
|
'is_course_full': is_course_full,
|
|
'can_enroll': can_enroll,
|
|
'invitation_only': invitation_only,
|
|
'active_reg_button': active_reg_button,
|
|
'is_shib_course': is_shib_course,
|
|
# We do not want to display the internal courseware header, which is used when the course is found in the
|
|
# context. This value is therefor explicitly set to render the appropriate header.
|
|
'disable_courseware_header': True,
|
|
'can_add_course_to_cart': can_add_course_to_cart,
|
|
'cart_link': reverse('shoppingcart.views.show_cart'),
|
|
'pre_requisite_courses': pre_requisite_courses,
|
|
'course_image_urls': overview.image_urls,
|
|
'reviews_fragment_view': reviews_fragment_view,
|
|
}
|
|
|
|
return render_to_response('courseware/course_about.html', context)
|
|
|
|
|
|
@ensure_csrf_cookie
|
|
@cache_if_anonymous()
|
|
def program_marketing(request, program_uuid):
|
|
"""
|
|
Display the program marketing page.
|
|
"""
|
|
program_data = get_programs(request.site, uuid=program_uuid)
|
|
|
|
if not program_data:
|
|
raise Http404
|
|
|
|
program = ProgramMarketingDataExtender(program_data, request.user).extend()
|
|
program['type_slug'] = slugify(program['type'])
|
|
skus = program.get('skus')
|
|
ecommerce_service = EcommerceService()
|
|
|
|
context = {'program': program}
|
|
|
|
if program.get('is_learner_eligible_for_one_click_purchase') and skus:
|
|
context['buy_button_href'] = ecommerce_service.get_checkout_page_url(*skus, program_uuid=program_uuid)
|
|
|
|
context['uses_bootstrap'] = True
|
|
|
|
return render_to_response('courseware/program_marketing.html', context)
|
|
|
|
|
|
@transaction.non_atomic_requests
|
|
@login_required
|
|
@cache_control(no_cache=True, no_store=True, must_revalidate=True)
|
|
@ensure_valid_course_key
|
|
@data_sharing_consent_required
|
|
def progress(request, course_id, student_id=None):
|
|
""" Display the progress page. """
|
|
course_key = CourseKey.from_string(course_id)
|
|
|
|
with modulestore().bulk_operations(course_key):
|
|
return _progress(request, course_key, student_id)
|
|
|
|
|
|
def _progress(request, course_key, student_id):
|
|
"""
|
|
Unwrapped version of "progress".
|
|
|
|
User progress. We show the grade bar and every problem score.
|
|
|
|
Course staff are allowed to see the progress of students in their class.
|
|
"""
|
|
|
|
if student_id is not None:
|
|
try:
|
|
student_id = int(student_id)
|
|
# Check for ValueError if 'student_id' cannot be converted to integer.
|
|
except ValueError:
|
|
raise Http404
|
|
|
|
course = get_course_with_access(request.user, 'load', course_key)
|
|
|
|
staff_access = bool(has_access(request.user, 'staff', course))
|
|
|
|
masquerade = None
|
|
if student_id is None or student_id == request.user.id:
|
|
# This will be a no-op for non-staff users, returning request.user
|
|
masquerade, student = setup_masquerade(request, course_key, staff_access, reset_masquerade_data=True)
|
|
else:
|
|
try:
|
|
coach_access = has_ccx_coach_role(request.user, course_key)
|
|
except CCXLocatorValidationException:
|
|
coach_access = False
|
|
|
|
has_access_on_students_profiles = staff_access or coach_access
|
|
# Requesting access to a different student's profile
|
|
if not has_access_on_students_profiles:
|
|
raise Http404
|
|
try:
|
|
student = User.objects.get(id=student_id)
|
|
except User.DoesNotExist:
|
|
raise Http404
|
|
|
|
# NOTE: To make sure impersonation by instructor works, use
|
|
# student instead of request.user in the rest of the function.
|
|
|
|
# The pre-fetching of groups is done to make auth checks not require an
|
|
# additional DB lookup (this kills the Progress page in particular).
|
|
student = User.objects.prefetch_related("groups").get(id=student.id)
|
|
if request.user.id != student.id:
|
|
# refetch the course as the assumed student
|
|
course = get_course_with_access(student, 'load', course_key, check_if_enrolled=True)
|
|
|
|
# NOTE: To make sure impersonation by instructor works, use
|
|
# student instead of request.user in the rest of the function.
|
|
|
|
course_grade = CourseGradeFactory().read(student, course)
|
|
courseware_summary = course_grade.chapter_grades.values()
|
|
|
|
studio_url = get_studio_url(course, 'settings/grading')
|
|
# checking certificate generation configuration
|
|
enrollment_mode, _ = CourseEnrollment.enrollment_mode_for_user(student, course_key)
|
|
|
|
context = {
|
|
'course': course,
|
|
'courseware_summary': courseware_summary,
|
|
'studio_url': studio_url,
|
|
'grade_summary': course_grade.summary,
|
|
'staff_access': staff_access,
|
|
'masquerade': masquerade,
|
|
'supports_preview_menu': True,
|
|
'student': student,
|
|
'credit_course_requirements': _credit_course_requirements(course_key, student),
|
|
'certificate_data': _get_cert_data(student, course, enrollment_mode, course_grade),
|
|
}
|
|
context.update(
|
|
get_experiment_user_metadata_context(
|
|
course,
|
|
student,
|
|
)
|
|
)
|
|
|
|
with outer_atomic():
|
|
response = render_to_response('courseware/progress.html', context)
|
|
|
|
return response
|
|
|
|
|
|
def _downloadable_certificate_message(course, cert_downloadable_status):
|
|
if certs_api.has_html_certificates_enabled(course):
|
|
if certs_api.get_active_web_certificate(course) is not None:
|
|
return _downloadable_cert_data(
|
|
download_url=None,
|
|
cert_web_view_url=certs_api.get_certificate_url(
|
|
course_id=course.id, uuid=cert_downloadable_status['uuid']
|
|
)
|
|
)
|
|
else:
|
|
return GENERATING_CERT_DATA
|
|
|
|
return _downloadable_cert_data(download_url=cert_downloadable_status['download_url'])
|
|
|
|
|
|
def _missing_required_verification(student, enrollment_mode):
|
|
return (
|
|
enrollment_mode in CourseMode.VERIFIED_MODES and not IDVerificationService.user_is_verified(student)
|
|
)
|
|
|
|
|
|
def _certificate_message(student, course, enrollment_mode):
|
|
if certs_api.is_certificate_invalid(student, course.id):
|
|
return INVALID_CERT_DATA
|
|
|
|
cert_downloadable_status = certs_api.certificate_downloadable_status(student, course.id)
|
|
|
|
if cert_downloadable_status['is_generating']:
|
|
return GENERATING_CERT_DATA
|
|
|
|
if cert_downloadable_status['is_unverified'] or _missing_required_verification(student, enrollment_mode):
|
|
return UNVERIFIED_CERT_DATA
|
|
|
|
if cert_downloadable_status['is_downloadable']:
|
|
return _downloadable_certificate_message(course, cert_downloadable_status)
|
|
|
|
return REQUESTING_CERT_DATA
|
|
|
|
|
|
def _get_cert_data(student, course, enrollment_mode, course_grade=None):
|
|
"""Returns students course certificate related data.
|
|
|
|
Arguments:
|
|
student (User): Student for whom certificate to retrieve.
|
|
course (Course): Course object for which certificate data to retrieve.
|
|
enrollment_mode (String): Course mode in which student is enrolled.
|
|
course_grade (CourseGrade): Student's course grade record.
|
|
|
|
Returns:
|
|
returns dict if course certificate is available else None.
|
|
"""
|
|
if not CourseMode.is_eligible_for_certificate(enrollment_mode):
|
|
return AUDIT_PASSING_CERT_DATA if enrollment_mode == CourseMode.AUDIT else HONOR_PASSING_CERT_DATA
|
|
|
|
certificates_enabled_for_course = certs_api.cert_generation_enabled(course.id)
|
|
if course_grade is None:
|
|
course_grade = CourseGradeFactory().read(student, course)
|
|
|
|
if not auto_certs_api.can_show_certificate_message(course, student, course_grade, certificates_enabled_for_course):
|
|
return
|
|
|
|
return _certificate_message(student, course, enrollment_mode)
|
|
|
|
|
|
def _credit_course_requirements(course_key, student):
|
|
"""Return information about which credit requirements a user has satisfied.
|
|
|
|
Arguments:
|
|
course_key (CourseKey): Identifier for the course.
|
|
student (User): Currently logged in user.
|
|
|
|
Returns: dict if the credit eligibility enabled and it is a credit course
|
|
and the user is enrolled in either verified or credit mode, and None otherwise.
|
|
|
|
"""
|
|
# If credit eligibility is not enabled or this is not a credit course,
|
|
# short-circuit and return `None`. This indicates that credit requirements
|
|
# should NOT be displayed on the progress page.
|
|
if not (settings.FEATURES.get("ENABLE_CREDIT_ELIGIBILITY", False) and is_credit_course(course_key)):
|
|
return None
|
|
|
|
# This indicates that credit requirements should NOT be displayed on the progress page.
|
|
enrollment = CourseEnrollment.get_enrollment(student, course_key)
|
|
if enrollment and enrollment.mode not in REQUIREMENTS_DISPLAY_MODES:
|
|
return None
|
|
|
|
# Credit requirement statuses for which user does not remain eligible to get credit.
|
|
non_eligible_statuses = ['failed', 'declined']
|
|
|
|
# Retrieve the status of the user for each eligibility requirement in the course.
|
|
# For each requirement, the user's status is either "satisfied", "failed", or None.
|
|
# In this context, `None` means that we don't know the user's status, either because
|
|
# the user hasn't done something (for example, submitting photos for verification)
|
|
# or we're waiting on more information (for example, a response from the photo
|
|
# verification service).
|
|
requirement_statuses = get_credit_requirement_status(course_key, student.username)
|
|
|
|
# If the user has been marked as "eligible", then they are *always* eligible
|
|
# unless someone manually intervenes. This could lead to some strange behavior
|
|
# if the requirements change post-launch. For example, if the user was marked as eligible
|
|
# for credit, then a new requirement was added, the user will see that they're eligible
|
|
# AND that one of the requirements is still pending.
|
|
# We're assuming here that (a) we can mitigate this by properly training course teams,
|
|
# and (b) it's a better user experience to allow students who were at one time
|
|
# marked as eligible to continue to be eligible.
|
|
# If we need to, we can always manually move students back to ineligible by
|
|
# deleting CreditEligibility records in the database.
|
|
if is_user_eligible_for_credit(student.username, course_key):
|
|
eligibility_status = "eligible"
|
|
|
|
# If the user has *failed* any requirements (for example, if a photo verification is denied),
|
|
# then the user is NOT eligible for credit.
|
|
elif any(requirement['status'] in non_eligible_statuses for requirement in requirement_statuses):
|
|
eligibility_status = "not_eligible"
|
|
|
|
# Otherwise, the user may be eligible for credit, but the user has not
|
|
# yet completed all the requirements.
|
|
else:
|
|
eligibility_status = "partial_eligible"
|
|
|
|
return {
|
|
'eligibility_status': eligibility_status,
|
|
'requirements': requirement_statuses,
|
|
}
|
|
|
|
|
|
@login_required
|
|
@ensure_valid_course_key
|
|
def submission_history(request, course_id, student_username, location):
|
|
"""Render an HTML fragment (meant for inclusion elsewhere) that renders a
|
|
history of all state changes made by this user for this problem location.
|
|
Right now this only works for problems because that's all
|
|
StudentModuleHistory records.
|
|
"""
|
|
|
|
course_key = CourseKey.from_string(course_id)
|
|
|
|
try:
|
|
usage_key = UsageKey.from_string(location).map_into_course(course_key)
|
|
except (InvalidKeyError, AssertionError):
|
|
return HttpResponse(escape(_(u'Invalid location.')))
|
|
|
|
course = get_course_overview_with_access(request.user, 'load', course_key)
|
|
staff_access = bool(has_access(request.user, 'staff', course))
|
|
|
|
# Permission Denied if they don't have staff access and are trying to see
|
|
# somebody else's submission history.
|
|
if (student_username != request.user.username) and (not staff_access):
|
|
raise PermissionDenied
|
|
|
|
user_state_client = DjangoXBlockUserStateClient()
|
|
try:
|
|
history_entries = list(user_state_client.get_history(student_username, usage_key))
|
|
except DjangoXBlockUserStateClient.DoesNotExist:
|
|
return HttpResponse(escape(_(u'User {username} has never accessed problem {location}').format(
|
|
username=student_username,
|
|
location=location
|
|
)))
|
|
|
|
# This is ugly, but until we have a proper submissions API that we can use to provide
|
|
# the scores instead, it will have to do.
|
|
csm = StudentModule.objects.filter(
|
|
module_state_key=usage_key,
|
|
student__username=student_username,
|
|
course_id=course_key)
|
|
|
|
scores = BaseStudentModuleHistory.get_history(csm)
|
|
|
|
if len(scores) != len(history_entries):
|
|
log.warning(
|
|
"Mismatch when fetching scores for student "
|
|
"history for course %s, user %s, xblock %s. "
|
|
"%d scores were found, and %d history entries were found. "
|
|
"Matching scores to history entries by date for display.",
|
|
course_id,
|
|
student_username,
|
|
location,
|
|
len(scores),
|
|
len(history_entries),
|
|
)
|
|
scores_by_date = {
|
|
score.created: score
|
|
for score in scores
|
|
}
|
|
scores = [
|
|
scores_by_date[history.updated]
|
|
for history in history_entries
|
|
]
|
|
|
|
context = {
|
|
'history_entries': history_entries,
|
|
'scores': scores,
|
|
'username': student_username,
|
|
'location': location,
|
|
'course_id': text_type(course_key)
|
|
}
|
|
|
|
return render_to_response('courseware/submission_history.html', context)
|
|
|
|
|
|
def get_static_tab_fragment(request, course, tab):
|
|
"""
|
|
Returns the fragment for the given static tab
|
|
"""
|
|
loc = course.id.make_usage_key(
|
|
tab.type,
|
|
tab.url_slug,
|
|
)
|
|
field_data_cache = FieldDataCache.cache_for_descriptor_descendents(
|
|
course.id, request.user, modulestore().get_item(loc), depth=0
|
|
)
|
|
tab_module = get_module(
|
|
request.user, request, loc, field_data_cache, static_asset_path=course.static_asset_path, course=course
|
|
)
|
|
|
|
logging.debug('course_module = %s', tab_module)
|
|
|
|
fragment = Fragment()
|
|
if tab_module is not None:
|
|
try:
|
|
fragment = tab_module.render(STUDENT_VIEW, {})
|
|
except Exception: # pylint: disable=broad-except
|
|
fragment.content = render_to_string('courseware/error-message.html', None)
|
|
log.exception(
|
|
u"Error rendering course=%s, tab=%s", course, tab['url_slug']
|
|
)
|
|
|
|
return fragment
|
|
|
|
|
|
@require_GET
|
|
@ensure_valid_course_key
|
|
def get_course_lti_endpoints(request, course_id):
|
|
"""
|
|
View that, given a course_id, returns the a JSON object that enumerates all of the LTI endpoints for that course.
|
|
|
|
The LTI 2.0 result service spec at
|
|
http://www.imsglobal.org/lti/ltiv2p0/uml/purl.imsglobal.org/vocab/lis/v2/outcomes/Result/service.html
|
|
says "This specification document does not prescribe a method for discovering the endpoint URLs." This view
|
|
function implements one way of discovering these endpoints, returning a JSON array when accessed.
|
|
|
|
Arguments:
|
|
request (django request object): the HTTP request object that triggered this view function
|
|
course_id (unicode): id associated with the course
|
|
|
|
Returns:
|
|
(django response object): HTTP response. 404 if course is not found, otherwise 200 with JSON body.
|
|
"""
|
|
|
|
course_key = CourseKey.from_string(course_id)
|
|
|
|
try:
|
|
course = get_course(course_key, depth=2)
|
|
except ValueError:
|
|
return HttpResponse(status=404)
|
|
|
|
anonymous_user = AnonymousUser()
|
|
anonymous_user.known = False # make these "noauth" requests like module_render.handle_xblock_callback_noauth
|
|
lti_descriptors = modulestore().get_items(course.id, qualifiers={'category': 'lti'})
|
|
lti_descriptors.extend(modulestore().get_items(course.id, qualifiers={'category': 'lti_consumer'}))
|
|
|
|
lti_noauth_modules = [
|
|
get_module_for_descriptor(
|
|
anonymous_user,
|
|
request,
|
|
descriptor,
|
|
FieldDataCache.cache_for_descriptor_descendents(
|
|
course_key,
|
|
anonymous_user,
|
|
descriptor
|
|
),
|
|
course_key,
|
|
course=course
|
|
)
|
|
for descriptor in lti_descriptors
|
|
]
|
|
|
|
endpoints = [
|
|
{
|
|
'display_name': module.display_name,
|
|
'lti_2_0_result_service_json_endpoint': module.get_outcome_service_url(
|
|
service_name='lti_2_0_result_rest_handler') + "/user/{anon_user_id}",
|
|
'lti_1_1_result_service_xml_endpoint': module.get_outcome_service_url(
|
|
service_name='grade_handler'),
|
|
}
|
|
for module in lti_noauth_modules
|
|
]
|
|
|
|
return HttpResponse(json.dumps(endpoints), content_type='application/json')
|
|
|
|
|
|
@login_required
|
|
def course_survey(request, course_id):
|
|
"""
|
|
URL endpoint to present a survey that is associated with a course_id
|
|
Note that the actual implementation of course survey is handled in the
|
|
views.py file in the Survey Djangoapp
|
|
"""
|
|
|
|
course_key = CourseKey.from_string(course_id)
|
|
course = get_course_with_access(request.user, 'load', course_key, check_survey_complete=False)
|
|
|
|
redirect_url = reverse(course_home_url_name(course.id), args=[course_id])
|
|
|
|
# if there is no Survey associated with this course,
|
|
# then redirect to the course instead
|
|
if not course.course_survey_name:
|
|
return redirect(redirect_url)
|
|
|
|
return survey.views.view_student_survey(
|
|
request.user,
|
|
course.course_survey_name,
|
|
course=course,
|
|
redirect_url=redirect_url,
|
|
is_required=course.course_survey_required,
|
|
)
|
|
|
|
|
|
def is_course_passed(student, course, course_grade=None):
|
|
"""
|
|
check user's course passing status. return True if passed
|
|
|
|
Arguments:
|
|
student : user object
|
|
course : course object
|
|
course_grade (CourseGrade) : contains student grade details.
|
|
|
|
Returns:
|
|
returns bool value
|
|
"""
|
|
if course_grade is None:
|
|
course_grade = CourseGradeFactory().read(student, course)
|
|
return course_grade.passed
|
|
|
|
|
|
# Grades can potentially be written - if so, let grading manage the transaction.
|
|
@transaction.non_atomic_requests
|
|
@require_POST
|
|
def generate_user_cert(request, course_id):
|
|
"""Start generating a new certificate for the user.
|
|
|
|
Certificate generation is allowed if:
|
|
* The user has passed the course, and
|
|
* The user does not already have a pending/completed certificate.
|
|
|
|
Note that if an error occurs during certificate generation
|
|
(for example, if the queue is down), then we simply mark the
|
|
certificate generation task status as "error" and re-run
|
|
the task with a management command. To students, the certificate
|
|
will appear to be "generating" until it is re-run.
|
|
|
|
Args:
|
|
request (HttpRequest): The POST request to this view.
|
|
course_id (unicode): The identifier for the course.
|
|
|
|
Returns:
|
|
HttpResponse: 200 on success, 400 if a new certificate cannot be generated.
|
|
|
|
"""
|
|
|
|
if not request.user.is_authenticated():
|
|
log.info(u"Anon user trying to generate certificate for %s", course_id)
|
|
return HttpResponseBadRequest(
|
|
_('You must be signed in to {platform_name} to create a certificate.').format(
|
|
platform_name=configuration_helpers.get_value('PLATFORM_NAME', settings.PLATFORM_NAME)
|
|
)
|
|
)
|
|
|
|
student = request.user
|
|
course_key = CourseKey.from_string(course_id)
|
|
|
|
course = modulestore().get_course(course_key, depth=2)
|
|
if not course:
|
|
return HttpResponseBadRequest(_("Course is not valid"))
|
|
|
|
if not is_course_passed(student, course):
|
|
log.info(u"User %s has not passed the course: %s", student.username, course_id)
|
|
return HttpResponseBadRequest(_("Your certificate will be available when you pass the course."))
|
|
|
|
certificate_status = certs_api.certificate_downloadable_status(student, course.id)
|
|
|
|
log.info(
|
|
u"User %s has requested for certificate in %s, current status: is_downloadable: %s, is_generating: %s",
|
|
student.username,
|
|
course_id,
|
|
certificate_status["is_downloadable"],
|
|
certificate_status["is_generating"],
|
|
)
|
|
|
|
if certificate_status["is_downloadable"]:
|
|
return HttpResponseBadRequest(_("Certificate has already been created."))
|
|
elif certificate_status["is_generating"]:
|
|
return HttpResponseBadRequest(_("Certificate is being created."))
|
|
else:
|
|
# If the certificate is not already in-process or completed,
|
|
# then create a new certificate generation task.
|
|
# If the certificate cannot be added to the queue, this will
|
|
# mark the certificate with "error" status, so it can be re-run
|
|
# with a management command. From the user's perspective,
|
|
# it will appear that the certificate task was submitted successfully.
|
|
certs_api.generate_user_certificates(student, course.id, course=course, generation_mode='self')
|
|
_track_successful_certificate_generation(student.id, course.id)
|
|
return HttpResponse()
|
|
|
|
|
|
def _track_successful_certificate_generation(user_id, course_id): # pylint: disable=invalid-name
|
|
"""
|
|
Track a successful certificate generation event.
|
|
|
|
Arguments:
|
|
user_id (str): The ID of the user generating the certificate.
|
|
course_id (CourseKey): Identifier for the course.
|
|
Returns:
|
|
None
|
|
|
|
"""
|
|
if settings.LMS_SEGMENT_KEY:
|
|
event_name = 'edx.bi.user.certificate.generate'
|
|
tracking_context = tracker.get_tracker().resolve_context()
|
|
|
|
analytics.track(
|
|
user_id,
|
|
event_name,
|
|
{
|
|
'category': 'certificates',
|
|
'label': text_type(course_id)
|
|
},
|
|
context={
|
|
'ip': tracking_context.get('ip'),
|
|
'Google Analytics': {
|
|
'clientId': tracking_context.get('client_id')
|
|
}
|
|
}
|
|
)
|
|
|
|
|
|
@require_http_methods(["GET", "POST"])
|
|
@ensure_valid_usage_key
|
|
def render_xblock(request, usage_key_string, check_if_enrolled=True):
|
|
"""
|
|
Returns an HttpResponse with HTML content for the xBlock with the given usage_key.
|
|
The returned HTML is a chromeless rendering of the xBlock (excluding content of the containing courseware).
|
|
"""
|
|
usage_key = UsageKey.from_string(usage_key_string)
|
|
|
|
usage_key = usage_key.replace(course_key=modulestore().fill_in_run(usage_key.course_key))
|
|
course_key = usage_key.course_key
|
|
|
|
requested_view = request.GET.get('view', 'student_view')
|
|
if requested_view != 'student_view':
|
|
return HttpResponseBadRequest("Rendering of the xblock view '{}' is not supported.".format(requested_view))
|
|
|
|
with modulestore().bulk_operations(course_key):
|
|
# verify the user has access to the course, including enrollment check
|
|
try:
|
|
course = get_course_with_access(request.user, 'load', course_key, check_if_enrolled=check_if_enrolled)
|
|
except CourseAccessRedirect:
|
|
raise Http404("Course not found.")
|
|
|
|
# get the block, which verifies whether the user has access to the block.
|
|
block, _ = get_module_by_usage_id(
|
|
request, text_type(course_key), text_type(usage_key), disable_staff_debug_info=True, course=course
|
|
)
|
|
|
|
student_view_context = request.GET.dict()
|
|
student_view_context['show_bookmark_button'] = False
|
|
|
|
context = {
|
|
'fragment': block.render('student_view', context=student_view_context),
|
|
'course': course,
|
|
'disable_accordion': True,
|
|
'allow_iframing': True,
|
|
'disable_header': True,
|
|
'disable_footer': True,
|
|
'disable_window_wrap': True,
|
|
'staff_access': bool(has_access(request.user, 'staff', course)),
|
|
'xqa_server': settings.FEATURES.get('XQA_SERVER', 'http://your_xqa_server.com'),
|
|
}
|
|
return render_to_response('courseware/courseware-chromeless.html', context)
|
|
|
|
|
|
# Translators: "percent_sign" is the symbol "%". "platform_name" is a
|
|
# string identifying the name of this installation, such as "edX".
|
|
FINANCIAL_ASSISTANCE_HEADER = _(
|
|
'{platform_name} now offers financial assistance for learners who want to earn Verified Certificates but'
|
|
' who may not be able to pay the Verified Certificate fee. Eligible learners may receive up to 90{percent_sign} off'
|
|
' the Verified Certificate fee for a course.\nTo apply for financial assistance, enroll in the'
|
|
' audit track for a course that offers Verified Certificates, and then complete this application.'
|
|
' Note that you must complete a separate application for each course you take.\n We plan to use this'
|
|
' information to evaluate your application for financial assistance and to further develop our'
|
|
' financial assistance program.'
|
|
).format(
|
|
percent_sign="%",
|
|
platform_name=configuration_helpers.get_value('PLATFORM_NAME', settings.PLATFORM_NAME)
|
|
).split('\n')
|
|
|
|
|
|
FA_INCOME_LABEL = _('Annual Household Income')
|
|
FA_REASON_FOR_APPLYING_LABEL = _(
|
|
'Tell us about your current financial situation. Why do you need assistance?'
|
|
)
|
|
FA_GOALS_LABEL = _(
|
|
'Tell us about your learning or professional goals. How will a Verified Certificate in'
|
|
' this course help you achieve these goals?'
|
|
)
|
|
FA_EFFORT_LABEL = _(
|
|
'Tell us about your plans for this course. What steps will you take to help you complete'
|
|
' the course work and receive a certificate?'
|
|
)
|
|
FA_SHORT_ANSWER_INSTRUCTIONS = _('Use between 250 and 500 words or so in your response.')
|
|
|
|
|
|
@login_required
|
|
def financial_assistance(_request):
|
|
"""Render the initial financial assistance page."""
|
|
return render_to_response('financial-assistance/financial-assistance.html', {
|
|
'header_text': FINANCIAL_ASSISTANCE_HEADER
|
|
})
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def financial_assistance_request(request):
|
|
"""Submit a request for financial assistance to Zendesk."""
|
|
try:
|
|
data = json.loads(request.body)
|
|
# Simple sanity check that the session belongs to the user
|
|
# submitting an FA request
|
|
username = data['username']
|
|
if request.user.username != username:
|
|
return HttpResponseForbidden()
|
|
|
|
course_id = data['course']
|
|
course = modulestore().get_course(CourseKey.from_string(course_id))
|
|
legal_name = data['name']
|
|
email = data['email']
|
|
country = data['country']
|
|
income = data['income']
|
|
reason_for_applying = data['reason_for_applying']
|
|
goals = data['goals']
|
|
effort = data['effort']
|
|
marketing_permission = data['mktg-permission']
|
|
ip_address = get_ip(request)
|
|
except ValueError:
|
|
# Thrown if JSON parsing fails
|
|
return HttpResponseBadRequest(u'Could not parse request JSON.')
|
|
except InvalidKeyError:
|
|
# Thrown if course key parsing fails
|
|
return HttpResponseBadRequest(u'Could not parse request course key.')
|
|
except KeyError as err:
|
|
# Thrown if fields are missing
|
|
return HttpResponseBadRequest(u'The field {} is required.'.format(text_type(err)))
|
|
|
|
zendesk_submitted = _record_feedback_in_zendesk(
|
|
legal_name,
|
|
email,
|
|
u'Financial assistance request for learner {username} in course {course_name}'.format(
|
|
username=username,
|
|
course_name=course.display_name
|
|
),
|
|
u'Financial Assistance Request',
|
|
{'course_id': course_id},
|
|
# Send the application as additional info on the ticket so
|
|
# that it is not shown when support replies. This uses
|
|
# OrderedDict so that information is presented in the right
|
|
# order.
|
|
OrderedDict((
|
|
('Username', username),
|
|
('Full Name', legal_name),
|
|
('Course ID', course_id),
|
|
('Annual Household Income', income),
|
|
('Country', country),
|
|
('Allowed for marketing purposes', 'Yes' if marketing_permission else 'No'),
|
|
(FA_REASON_FOR_APPLYING_LABEL, '\n' + reason_for_applying + '\n\n'),
|
|
(FA_GOALS_LABEL, '\n' + goals + '\n\n'),
|
|
(FA_EFFORT_LABEL, '\n' + effort + '\n\n'),
|
|
('Client IP', ip_address),
|
|
)),
|
|
group_name='Financial Assistance',
|
|
require_update=True
|
|
)
|
|
|
|
if not zendesk_submitted:
|
|
# The call to Zendesk failed. The frontend will display a
|
|
# message to the user.
|
|
return HttpResponse(status=status.HTTP_500_INTERNAL_SERVER_ERROR)
|
|
|
|
return HttpResponse(status=status.HTTP_204_NO_CONTENT)
|
|
|
|
|
|
@login_required
|
|
def financial_assistance_form(request):
|
|
"""Render the financial assistance application form page."""
|
|
user = request.user
|
|
enrolled_courses = get_financial_aid_courses(user)
|
|
incomes = ['Less than $5,000', '$5,000 - $10,000', '$10,000 - $15,000', '$15,000 - $20,000', '$20,000 - $25,000']
|
|
annual_incomes = [
|
|
{'name': _(income), 'value': income} for income in incomes # pylint: disable=translation-of-non-string
|
|
]
|
|
return render_to_response('financial-assistance/apply.html', {
|
|
'header_text': FINANCIAL_ASSISTANCE_HEADER,
|
|
'student_faq_url': marketing_link('FAQ'),
|
|
'dashboard_url': reverse('dashboard'),
|
|
'account_settings_url': reverse('account_settings'),
|
|
'platform_name': configuration_helpers.get_value('PLATFORM_NAME', settings.PLATFORM_NAME),
|
|
'user_details': {
|
|
'email': user.email,
|
|
'username': user.username,
|
|
'name': user.profile.name,
|
|
'country': text_type(user.profile.country.name),
|
|
},
|
|
'submit_url': reverse('submit_financial_assistance_request'),
|
|
'fields': [
|
|
{
|
|
'name': 'course',
|
|
'type': 'select',
|
|
'label': _('Course'),
|
|
'placeholder': '',
|
|
'defaultValue': '',
|
|
'required': True,
|
|
'options': enrolled_courses,
|
|
'instructions': _(
|
|
'Select the course for which you want to earn a verified certificate. If'
|
|
' the course does not appear in the list, make sure that you have enrolled'
|
|
' in the audit track for the course.'
|
|
)
|
|
},
|
|
{
|
|
'name': 'income',
|
|
'type': 'select',
|
|
'label': FA_INCOME_LABEL,
|
|
'placeholder': '',
|
|
'defaultValue': '',
|
|
'required': True,
|
|
'options': annual_incomes,
|
|
'instructions': _('Specify your annual household income in US Dollars.')
|
|
},
|
|
{
|
|
'name': 'reason_for_applying',
|
|
'type': 'textarea',
|
|
'label': FA_REASON_FOR_APPLYING_LABEL,
|
|
'placeholder': '',
|
|
'defaultValue': '',
|
|
'required': True,
|
|
'restrictions': {
|
|
'min_length': settings.FINANCIAL_ASSISTANCE_MIN_LENGTH,
|
|
'max_length': settings.FINANCIAL_ASSISTANCE_MAX_LENGTH
|
|
},
|
|
'instructions': FA_SHORT_ANSWER_INSTRUCTIONS
|
|
},
|
|
{
|
|
'name': 'goals',
|
|
'type': 'textarea',
|
|
'label': FA_GOALS_LABEL,
|
|
'placeholder': '',
|
|
'defaultValue': '',
|
|
'required': True,
|
|
'restrictions': {
|
|
'min_length': settings.FINANCIAL_ASSISTANCE_MIN_LENGTH,
|
|
'max_length': settings.FINANCIAL_ASSISTANCE_MAX_LENGTH
|
|
},
|
|
'instructions': FA_SHORT_ANSWER_INSTRUCTIONS
|
|
},
|
|
{
|
|
'name': 'effort',
|
|
'type': 'textarea',
|
|
'label': FA_EFFORT_LABEL,
|
|
'placeholder': '',
|
|
'defaultValue': '',
|
|
'required': True,
|
|
'restrictions': {
|
|
'min_length': settings.FINANCIAL_ASSISTANCE_MIN_LENGTH,
|
|
'max_length': settings.FINANCIAL_ASSISTANCE_MAX_LENGTH
|
|
},
|
|
'instructions': FA_SHORT_ANSWER_INSTRUCTIONS
|
|
},
|
|
{
|
|
'placeholder': '',
|
|
'name': 'mktg-permission',
|
|
'label': _(
|
|
'I allow edX to use the information provided in this application '
|
|
'(except for financial information) for edX marketing purposes.'
|
|
),
|
|
'defaultValue': '',
|
|
'type': 'checkbox',
|
|
'required': False,
|
|
'instructions': '',
|
|
'restrictions': {}
|
|
}
|
|
],
|
|
})
|
|
|
|
|
|
def get_financial_aid_courses(user):
|
|
""" Retrieve the courses eligible for financial assistance. """
|
|
financial_aid_courses = []
|
|
for enrollment in CourseEnrollment.enrollments_for_user(user).order_by('-created'):
|
|
|
|
if enrollment.mode != CourseMode.VERIFIED and \
|
|
enrollment.course_overview and \
|
|
enrollment.course_overview.eligible_for_financial_aid and \
|
|
CourseMode.objects.filter(
|
|
Q(_expiration_datetime__isnull=True) | Q(_expiration_datetime__gt=datetime.now(UTC)),
|
|
course_id=enrollment.course_id,
|
|
mode_slug=CourseMode.VERIFIED).exists():
|
|
|
|
financial_aid_courses.append(
|
|
{
|
|
'name': enrollment.course_overview.display_name,
|
|
'value': text_type(enrollment.course_id)
|
|
}
|
|
)
|
|
|
|
return financial_aid_courses
|