def _set_up_invited_student(self,
course,
active=False,
enrolled=True,
course_mode=''):
"""
Helper function to create a user in the right state, invite them into the course, and update their
course mode if needed.
"""
email = '*****@*****.**'
user = UserFactory(username='******',
first_name='Student',
last_name='Person',
email=email,
is_active=active)
# invite the user to the course
cea = CourseEnrollmentAllowed(email=email,
course_id=course.id,
auto_enroll=True)
cea.save()
if enrolled:
CourseEnrollment.enroll(user, course.id)
if course_mode:
course_enrollment = CourseEnrollment.objects.get(
user=user, course_id=self.course.id)
course_enrollment.mode = course_mode
course_enrollment.save()
return user
def __init__(self, course_id, email):
# N.B. retired users are not a concern here because they should be
# handled at a higher level (i.e. in enroll_email). Besides, this
# class creates readonly objects.
exists_user = User.objects.filter(email=email).exists()
if exists_user:
user = User.objects.get(email=email)
mode, is_active = CourseEnrollment.enrollment_mode_for_user(user, course_id)
# is_active is `None` if the user is not enrolled in the course
exists_ce = is_active is not None and is_active
full_name = user.profile.name
ceas = CourseEnrollmentAllowed.for_user(user).filter(course_id=course_id).all()
else:
mode = None
exists_ce = False
full_name = None
ceas = CourseEnrollmentAllowed.objects.filter(email=email, course_id=course_id).all()
exists_allowed = ceas.exists()
state_auto_enroll = exists_allowed and ceas[0].auto_enroll
self.user = exists_user
self.enrollment = exists_ce
self.allowed = exists_allowed
self.auto_enroll = bool(state_auto_enroll)
self.full_name = full_name
self.mode = mode
def list_may_enroll(course_key, features):
"""
Return info about students who may enroll in a course as a dict.
list_may_enroll(course_key, ['email'])
would return [
{'email': 'email1'}
{'email': 'email2'}
{'email': 'email3'}
]
Note that result does not include students who may enroll and have
already done so.
"""
may_enroll_and_unenrolled = CourseEnrollmentAllowed.may_enroll_and_unenrolled(
course_key)
def extract_student(student, features):
"""
Build dict containing information about a single student.
"""
return dict(
(feature, getattr(student, feature)) for feature in features)
return [
extract_student(student, features)
for student in may_enroll_and_unenrolled
]
def test_retiring_nonexistent_user_doesnt_modify_records(self):
is_successful = CourseEnrollmentAllowed.delete_by_user_value(
value='*****@*****.**', field='email')
assert not is_successful
user_search_results = CourseEnrollmentAllowed.objects.filter(
email=self.email)
assert user_search_results.exists()
def test_retiring_user_deletes_record(self):
is_successful = CourseEnrollmentAllowed.delete_by_user_value(
value=self.email, field='email')
assert is_successful
user_search_results = CourseEnrollmentAllowed.objects.filter(
email=self.email)
assert not user_search_results
def test_unenroll_non_user_student(
self, view_name, send_email, outbox_count, student_form_input_name, button_tuple, identifier):
"""
Unenroll a list of students who are not users yet
"""
self.make_coach()
course = CourseFactory.create()
ccx = self.make_ccx()
course_key = CCXLocator.from_course_locator(course.id, ccx.id)
outbox = self.get_outbox()
CourseEnrollmentAllowed(course_id=course_key, email=identifier)
assert outbox == []
url = reverse(
view_name,
kwargs={'course_id': course_key}
)
data = {
button_tuple[0]: button_tuple[1],
student_form_input_name: ','.join([identifier, ]),
}
if send_email:
data['email-students'] = 'Notify-students-by-email'
response = self.client.post(url, data=data, follow=True)
assert response.status_code == 200
# we were redirected to our current location
assert len(response.redirect_chain) == 1
assert 302 in response.redirect_chain[0]
assert len(outbox) == outbox_count
assert not CourseEnrollmentAllowed.objects.filter(course_id=course_key, email=identifier).exists()
