191 lines
6.7 KiB
Python
191 lines
6.7 KiB
Python
from collections import defaultdict
|
|
from fs.errors import ResourceNotFoundError
|
|
from functools import wraps
|
|
import logging
|
|
from path import path
|
|
|
|
from django.conf import settings
|
|
from django.http import Http404
|
|
|
|
from xmodule.course_module import CourseDescriptor
|
|
from xmodule.modulestore.django import modulestore
|
|
from xmodule.modulestore.exceptions import ItemNotFoundError
|
|
from static_replace import replace_urls
|
|
from staticfiles.storage import staticfiles_storage
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
|
|
def check_course(course_id, course_must_be_open=True, course_required=True):
|
|
"""
|
|
Given a course_id, this returns the course object. By default,
|
|
if the course is not found or the course is not open yet, this
|
|
method will raise a 404.
|
|
|
|
If course_must_be_open is False, the course will be returned
|
|
without a 404 even if it is not open.
|
|
|
|
If course_required is False, a course_id of None is acceptable. The
|
|
course returned will be None. Even if the course is not required,
|
|
if a course_id is given that does not exist a 404 will be raised.
|
|
"""
|
|
course = None
|
|
if course_required or course_id:
|
|
try:
|
|
course_loc = CourseDescriptor.id_to_location(course_id)
|
|
course = modulestore().get_item(course_loc)
|
|
|
|
except (KeyError, ItemNotFoundError):
|
|
raise Http404("Course not found.")
|
|
|
|
started = course.has_started() or settings.MITX_FEATURES['DISABLE_START_DATES']
|
|
if course_must_be_open and not started:
|
|
raise Http404("This course has not yet started.")
|
|
|
|
return course
|
|
|
|
|
|
def course_image_url(course):
|
|
return staticfiles_storage.url(course.metadata['data_dir'] +
|
|
"/images/course_image.jpg")
|
|
|
|
|
|
def get_course_about_section(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
|
|
- title
|
|
- university
|
|
- number
|
|
- short_description
|
|
- description
|
|
- key_dates (includes start, end, exams, etc)
|
|
- video
|
|
- course_staff_short
|
|
- course_staff_extended
|
|
- requirements
|
|
- syllabus
|
|
- textbook
|
|
- faq
|
|
- more_info
|
|
"""
|
|
|
|
# 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.
|
|
|
|
# TODO: Remove number, instructors from this list
|
|
if section_key in ['short_description', 'description', 'key_dates', 'video',
|
|
'course_staff_short', 'course_staff_extended',
|
|
'requirements', 'syllabus', 'textbook', 'faq', 'more_info',
|
|
'number', 'instructors', 'overview',
|
|
'effort', 'end_date', 'prerequisites']:
|
|
try:
|
|
with course.system.resources_fs.open(path("about") / section_key + ".html") as htmlFile:
|
|
return replace_urls(htmlFile.read().decode('utf-8'),
|
|
course.metadata['data_dir'])
|
|
except ResourceNotFoundError:
|
|
log.warning("Missing about section {key} in course {url}".format(
|
|
key=section_key, url=course.location.url()))
|
|
return None
|
|
elif section_key == "title":
|
|
return course.metadata.get('display_name', course.url_name)
|
|
elif section_key == "university":
|
|
return course.location.org
|
|
elif section_key == "number":
|
|
return course.number
|
|
|
|
raise KeyError("Invalid about key " + str(section_key))
|
|
|
|
|
|
def get_course_info_section(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
|
|
"""
|
|
|
|
# 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 ['handouts', 'guest_handouts', 'updates', 'guest_updates']:
|
|
try:
|
|
with course.system.resources_fs.open(path("info") / section_key + ".html") as htmlFile:
|
|
return replace_urls(htmlFile.read().decode('utf-8'),
|
|
course.metadata['data_dir'])
|
|
except ResourceNotFoundError:
|
|
log.exception("Missing info section {key} in course {url}".format(
|
|
key=section_key, url=course.location.url()))
|
|
return "! Info section missing !"
|
|
|
|
raise KeyError("Invalid about key " + str(section_key))
|
|
|
|
def course_staff_group_name(course):
|
|
'''
|
|
course should be either a CourseDescriptor instance, or a string (the
|
|
.course entry of a Location)
|
|
'''
|
|
if isinstance(course, str) or isinstance(course, unicode):
|
|
coursename = course
|
|
else:
|
|
# should be a CourseDescriptor, so grab its location.course:
|
|
coursename = course.location.course
|
|
return 'staff_%s' % coursename
|
|
|
|
def has_staff_access_to_course(user, course):
|
|
'''
|
|
Returns True if the given user has staff access to the course.
|
|
This means that user is in the staff_* group, or is an overall admin.
|
|
|
|
course is the course field of the location being accessed.
|
|
'''
|
|
if user is None or (not user.is_authenticated()) or course is None:
|
|
return False
|
|
if user.is_staff:
|
|
return True
|
|
|
|
# note this is the Auth group, not UserTestGroup
|
|
user_groups = [x[1] for x in user.groups.values_list()]
|
|
staff_group = course_staff_group_name(course)
|
|
log.debug('course %s, staff_group %s, user %s, groups %s' % (
|
|
course, staff_group, user, user_groups))
|
|
if staff_group in user_groups:
|
|
return True
|
|
return False
|
|
|
|
def has_access_to_course(user,course):
|
|
if course.metadata.get('ispublic'):
|
|
return True
|
|
return has_staff_access_to_course(user,course)
|
|
|
|
def get_courses_by_university(user):
|
|
'''
|
|
Returns dict of lists of courses available, keyed by course.org (ie university).
|
|
Courses are sorted by course.number.
|
|
|
|
if ACCESS_REQUIRE_STAFF_FOR_COURSE then list only includes those accessible
|
|
to user.
|
|
'''
|
|
# TODO: Clean up how 'error' is done.
|
|
# filter out any courses that errored.
|
|
courses = [c for c in modulestore().get_courses()
|
|
if isinstance(c, CourseDescriptor)]
|
|
courses = sorted(courses, key=lambda course: course.number)
|
|
universities = defaultdict(list)
|
|
for course in courses:
|
|
if settings.MITX_FEATURES.get('ACCESS_REQUIRE_STAFF_FOR_COURSE'):
|
|
if not has_access_to_course(user,course):
|
|
continue
|
|
universities[course.org].append(course)
|
|
return universities
|
|
|