def check_content_start_date_for_masquerade_user(course_key,
user,
request,
course_start,
chapter_start=None,
section_start=None):
"""
Add a warning message if the masquerade user would not have access to this content
due to the content start date being in the future.
"""
now = datetime.now(utc)
most_future_date = course_start
if chapter_start and section_start:
most_future_date = max(course_start, chapter_start, section_start)
_is_masquerading = get_course_masquerade(user, course_key)
if now < most_future_date and _is_masquerading:
group_masquerade = is_masquerading_as_student(user, course_key)
specific_student_masquerade = is_masquerading_as_specific_student(
user, course_key)
is_staff = has_staff_roles(user, course_key)
if group_masquerade or (specific_student_masquerade and not is_staff):
PageLevelMessages.register_warning_message(
request,
HTML(
_('This user does not have access to this content because \
the content start date is in the future')),
once_only=True)
def enrollment_date_for_fbe(user, course_key=None, course=None):
"""
Gets the enrollment date for the given user and course, if FBE is enabled.
One of course_key or course must be provided.
Returns:
None if FBE is disabled for either this user or course
The enrollment creation date if an enrollment exists
now() if no enrollment.
"""
if user is None or (course_key is None and course is None):
raise ValueError('Both user and either course_key or course must be specified if no enrollment is provided')
course_key = course_key or course.id
full_access_masquerade = has_full_access_role_in_masquerade(user, course_key)
if full_access_masquerade:
return None
elif full_access_masquerade is False:
user = None # we are masquerading as a generic user, not a specific one -- avoid all user checks below
if user and user.id and has_staff_roles(user, course_key):
return None
enrollment = user and CourseEnrollment.get_enrollment(user, course_key, ['fbeenrollmentexclusion'])
if is_in_holdback(enrollment):
return None
if not correct_modes_for_fbe(enrollment=enrollment, user=user, course_key=course_key, course=course):
return None
# If the user isn't enrolled, act as if the user enrolled today
return enrollment.created if enrollment else timezone.now()
def get(self, request, course_key_string):
"""
Retrieve data on the active and available masquerade options
"""
course_key = CourseKey.from_string(course_key_string)
is_staff = has_staff_roles(request.user, course_key)
if not is_staff:
return JsonResponse({
'success': False,
})
masquerade_settings = request.session.get(MASQUERADE_SETTINGS_KEY, {})
course = masquerade_settings.get(course_key, None)
course = course or CourseMasquerade(
course_key,
role='staff',
user_partition_id=None,
group_id=None,
user_name=None,
)
descriptor = modulestore().get_course(course_key)
partitions = get_all_partitions_for_course(descriptor,
active_only=True)
data = {
'success':
True,
'active': {
'course_key': course_key_string,
'group_id': course.group_id,
'role': course.role,
'user_name': course.user_name or None,
'user_partition_id': course.user_partition_id,
},
'available': [
{
'name': 'Staff',
'role': 'staff',
},
{
'name': 'Learner',
'role': 'student',
},
{
'name': 'Specific Student...',
'role': 'student',
'user_name': course.user_name or '',
},
],
}
for partition in partitions:
if partition.active:
data['available'].extend([{
'group_id': group.id,
'name': group.name,
'role': 'student',
'user_partition_id': partition.id,
} for group in partition.groups])
data['active']['group_name'] = course.get_active_group_name(
data['available'])
return JsonResponse(data)
def post(self, request, course_key_string):
"""
Handle AJAX posts to update the current user's masquerade for the specified course.
The masquerade settings are stored in the Django session as a dict from course keys
to CourseMasquerade objects.
"""
course_key = CourseKey.from_string(course_key_string)
is_staff = has_staff_roles(request.user, course_key)
if not is_staff:
return JsonResponse({
'success': False,
})
masquerade_settings = request.session.get(MASQUERADE_SETTINGS_KEY, {})
request_json = request.json
role = request_json.get('role', 'student')
group_id = request_json.get('group_id', None)
user_partition_id = request_json.get(
'user_partition_id', None) if group_id is not None else None
user_name = request_json.get('user_name', None)
found_user_name = None
if user_name:
users_in_course = CourseEnrollment.objects.users_enrolled_in(
course_key)
try:
found_user_name = users_in_course.get(
Q(email=user_name) | Q(username=user_name)).username
except User.DoesNotExist:
return JsonResponse({
'success':
False,
'error':
_(u'There is no user with the username or email address "{user_identifier}" '
'enrolled in this course.').format(
user_identifier=user_name, ),
})
masquerade_settings[course_key] = CourseMasquerade(
course_key,
role=role,
user_partition_id=user_partition_id,
group_id=group_id,
user_name=found_user_name,
)
request.session[MASQUERADE_SETTINGS_KEY] = masquerade_settings
return JsonResponse({'success': True})