def auto_enroll_email(course_id, email, send_email=True):
"""
Auto-enroll email in course.
Based on lms.djangoapps.instructor.views.api.students_update_enrollment()
"""
# Raises ValidationError if invalid
validate_email(email)
locator = CourseLocator.from_string(course_id)
course = get_course_by_id(locator)
# If we want to notify the newly enrolled student by email, fetch
# the required parameters
email_params = None
language = None
if send_email:
email_params = get_email_params(course, True, secure=True)
# Try to find out what language to send the email in.
user = None
try:
user = User.objects.get(email=email)
except User.DoesNotExist:
pass
else:
language = get_user_email_language(user)
# Enroll the email
enroll_email(locator,
email,
auto_enroll=True,
email_students=send_email,
email_params=email_params,
language=language)
def put(self, request, course_id):
"""
Enroll a user in a course; requires staff access
**Example Request**
PUT /api/enrollment/v1/roster/course-v1:foo+bar+foobar
{
'email': '*****@*****.**',
'email_students': false,
'auto_enroll': true
}
"""
try:
course_key = CourseKey.from_string(course_id)
except InvalidKeyError:
return Response(
status=status.HTTP_400_BAD_REQUEST,
data={
'message': u'Invalid or missing course_id',
},
)
if not user_has_role(request.user, CourseStaffRole(course_key)):
return Response(
status=status.HTTP_403_FORBIDDEN,
data={
'message':
u'User does not have permission to update enrollment for [{course_id}].'
.format(course_id=course_id, ),
},
)
email = request.data.get('email')
try:
validate_email(email)
except ValidationError:
return Response(
status=status.HTTP_400_BAD_REQUEST,
data={
'message': u'Invalid email address',
},
)
email_students = request.data.get('email_students',
False) in ['true', 'True', True]
auto_enroll = request.data.get('auto_enroll',
False) in ['true', 'True', True]
email_params = {}
language = None
if email_students:
course = get_course_by_id(course_key)
email_params = get_email_params(course, auto_enroll)
if User.objects.filter(email=email).exists():
user = User.objects.get(email=email)
language = get_user_email_language(user)
enroll_email(course_key,
email,
auto_enroll,
email_students,
email_params,
language=language)
return Response(status=status.HTTP_204_NO_CONTENT)
def api_params_helper(self, request, course_key, email):
"""
Helper method to get params for enroll/unenroll apis.
"""
email_students = request.data.get('email_students', False) in ['true', 'True', True]
auto_enroll = request.data.get('auto_enroll', True) in ['true', 'True', True]
email_params = {}
language = None
if email_students:
course = get_course_by_id(course_key)
email_params = get_email_params(course, auto_enroll)
try:
user = User.objects.get(email=email)
except User.DoesNotExist:
pass
else:
language = get_user_email_language(user)
return email_students, auto_enroll, email_params, language
def post(self, request, *args, **kwargs):
course_id = request.POST.get('course_id', False)
try:
course_id = SlashSeparatedCourseKey.from_deprecated_string(
course_id)
except Exception:
course_id = None
if not course_id:
self.msg = u"课程ID错误"
context = {'msg': self.msg, 'datatable': self.make_datatable()}
return render_to_response(self.template_name, context)
elif not request.POST.get('identifiers'):
self.msg = u"邮箱用户名错误"
context = {'msg': self.msg, 'datatable': self.make_datatable()}
return render_to_response(self.template_name, context)
action = request.POST.get('action')
identifiers_raw = request.POST.get('identifiers')
identifiers = _split_input_list(identifiers_raw)
auto_enroll = _get_boolean_param(request, 'auto_enroll')
email_students = _get_boolean_param(request, 'email_students')
is_white_label = CourseMode.is_white_label(course_id)
reason = request.POST.get('reason')
if is_white_label:
if not reason:
self.msg = "400"
context = {'msg': self.msg, 'datatable': self.make_datatable()}
return render_to_response(self.template_name, context)
enrollment_obj = None
state_transition = DEFAULT_TRANSITION_STATE
email_params = {}
if email_students:
course = get_course_by_id(course_id)
email_params = get_email_params(course,
auto_enroll,
secure=request.is_secure())
results = []
for identifier in identifiers:
# First try to get a user object from the identifer
user = None
email = None
language = None
try:
user = get_student_from_identifier(identifier)
except User.DoesNotExist:
email = identifier
else:
email = user.email
language = get_user_email_language(user)
try:
# Use django.core.validators.validate_email to check email address
# validity (obviously, cannot check if email actually /exists/,
# simply that it is plausibly valid)
validate_email(email) # Raises ValidationError if invalid
if action == 'enroll':
before, after, enrollment_obj = enroll_email(
course_id,
email,
auto_enroll,
email_students,
email_params,
language=language)
before_enrollment = before.to_dict()['enrollment']
before_user_registered = before.to_dict()['user']
before_allowed = before.to_dict()['allowed']
after_enrollment = after.to_dict()['enrollment']
after_allowed = after.to_dict()['allowed']
if before_user_registered:
if after_enrollment:
if before_enrollment:
state_transition = ENROLLED_TO_ENROLLED
else:
if before_allowed:
state_transition = ALLOWEDTOENROLL_TO_ENROLLED
else:
state_transition = UNENROLLED_TO_ENROLLED
else:
if after_allowed:
state_transition = UNENROLLED_TO_ALLOWEDTOENROLL
elif action == 'unenroll':
before, after = unenroll_email(course_id,
email,
email_students,
email_params,
language=language)
before_enrollment = before.to_dict()['enrollment']
before_allowed = before.to_dict()['allowed']
enrollment_obj = CourseEnrollment.get_enrollment(
user, course_id)
if before_enrollment:
state_transition = ENROLLED_TO_UNENROLLED
else:
if before_allowed:
state_transition = ALLOWEDTOENROLL_TO_UNENROLLED
else:
state_transition = UNENROLLED_TO_UNENROLLED
else:
return HttpResponseBadRequest(
strip_tags("Unrecognized action '{}'".format(action)))
except ValidationError:
# Flag this email as an error if invalid, but continue checking
# the remaining in the list
results.append({
'identifier': identifier,
'invalidIdentifier': True,
})
except Exception as exc: # pylint: disable=broad-except
# catch and log any exceptions
# so that one error doesn't cause a 500.
log.exception(u"Error while #{}ing student")
log.exception(exc)
results.append({
'identifier': identifier,
'error': True,
})
else:
ManualEnrollmentAudit.create_manual_enrollment_audit(
request.user, email, state_transition, reason,
enrollment_obj)
results.append({
'identifier': identifier,
'before': before.to_dict(),
'after': after.to_dict(),
})
invalid_id = []
valid_id = []
for result in results:
if ('error' in result) or ('invalidIdentifier' in result):
invalid_id.append(result['identifier'])
else:
valid_id.append(result['identifier'])
invalid_message = [
"{} 无效 <br>".format(i.encode('utf-8')) for i in invalid_id
]
valid_message = []
action = "选课" if action == "enroll" else "弃选"
for i in valid_id:
if action == "弃选":
valid_message.append("{0} {1} 成功 <br>".format(i, action))
continue
if email_students:
valid_message.append("{0} {1} 成功，并向他发送电子邮件 <br>".format(
i, action))
else:
valid_message.append("{0} {1} 成功<br>".format(i, action))
invalid_message.extend(valid_message)
self.msg = "".join(invalid_message)
context = {'msg': self.msg, 'datatable': self.make_datatable()}
return render_to_response(self.template_name, context)
def enroll_user_to_course(request_info, course_id, username_or_email):
"""
Look up the given user, and if successful, enroll them to the specified course.
Arguments:
request_info (dict): Dict containing task request information
course_id (str): The ID string of the course
username_or_email: user's username or email string
Returns:
User object (or None if user in not registered,
and whether the user is already enrolled or not
"""
# First try to get a user object from the identifier (email)
user = None
user_already_enrolled = False
language = None
email_students = True
auto_enroll = True
thread_site = Site.objects.get(domain=request_info['host'])
thread_author = User.objects.get(username=request_info['username'])
try:
user = get_student_from_identifier(username_or_email)
except User.DoesNotExist:
email = username_or_email
else:
email = user.email
language = get_user_email_language(user)
if user:
course_enrollment = CourseEnrollment.get_enrollment(
user=user, course_key=course_id)
if course_enrollment:
user_already_enrolled = True
# Set the enrollment to active if its not already active
if not course_enrollment.is_active:
course_enrollment.update_enrollment(is_active=True)
if not user or not user_already_enrolled:
course = get_course_by_id(course_id, depth=0)
try:
with emulate_http_request(site=thread_site, user=thread_author):
email_params = get_email_params(course, auto_enroll)
__ = enroll_email(course_id,
email,
auto_enroll,
email_students,
email_params,
language=language)
if user:
TASK_LOG.info(
u'User %s enrolled successfully in course %s via CSV bulk enrollment',
username_or_email, course_id)
except:
TASK_LOG.exception(
u'There was an error enrolling user %s in course %s via CSV bulk enrollment',
username_or_email, course_id)
return None, None
return user, user_already_enrolled
