def _validate_program(self):
"""
Verify that selected mode is available for program and all courses in the program
"""
program = self.cleaned_data.get(self.Fields.PROGRAM)
if not program:
return
course_runs = get_course_runs_from_program(program)
try:
client = CourseCatalogApiClient(self._user,
self._enterprise_customer.site)
available_modes = client.get_common_course_modes(course_runs)
course_mode = self.cleaned_data.get(self.Fields.COURSE_MODE)
except (HttpClientError, HttpServerError):
raise ValidationError(
ValidationMessages.FAILED_TO_OBTAIN_COURSE_MODES.format(
program_title=program.get("title")))
if not course_mode:
raise ValidationError(
ValidationMessages.COURSE_WITHOUT_COURSE_MODE)
if course_mode not in available_modes:
raise ValidationError(
ValidationMessages.COURSE_MODE_NOT_AVAILABLE.format(
mode=course_mode,
program_title=program.get("title"),
modes=", ".join(available_modes)))
def enroll_users_in_program(cls, enterprise_customer, program_details, course_mode, emails):
"""
Enroll existing users in all courses in a program, and create pending enrollments for nonexisting users.
Args:
enterprise_customer: The EnterpriseCustomer which is sponsoring the enrollment
program_details: The details of the program in which we're enrolling
course_mode (str): The mode with which we're enrolling in the program
emails: An iterable of email addresses which need to be enrolled
Returns:
successes: A list of users who were successfully enrolled in all courses of the program
pending: A list of PendingEnterpriseCustomerUsers who were successfully linked and had
pending enrollments created for them in the database
failures: A list of users who could not be enrolled in the program
"""
existing_users, unregistered_emails = cls.get_users_by_email(emails)
course_ids = get_course_runs_from_program(program_details)
successes = []
pending = []
failures = []
for user in existing_users:
succeeded = cls.enroll_user(enterprise_customer, user, course_mode, *course_ids)
if succeeded:
successes.append(user)
else:
failures.append(user)
for email in unregistered_emails:
pending_user = cls.enroll_user_pending_registration(enterprise_customer, email, course_mode, *course_ids)
pending.append(pending_user)
return successes, pending, failures
def test_get_course_runs_from_program_no_keys(self):
program = {
"courses": [
{"course_runs": []},
{"course_runs": []},
]
}
result = get_course_runs_from_program(program)
assert result == set()
def test_get_course_runs_from_program_normal(self):
program = {
"courses": [
{"course_runs": [
{"key": "1"},
{"key": None}
]},
{"course_runs": [
{"key": "CourseRunKey"}
]},
]
}
result = get_course_runs_from_program(program)
assert result == {"1", "CourseRunKey"}
def test_get_course_runs_from_program_no_courses(self):
program = {}
result = get_course_runs_from_program(program)
assert result == set()
def enroll_users_in_program(
cls,
enterprise_customer,
program_details,
course_mode,
emails,
cohort=None,
enrollment_requester=None,
enrollment_reason=None
):
"""
Enroll existing users in all courses in a program, and create pending enrollments for nonexisting users.
Args:
enterprise_customer: The EnterpriseCustomer which is sponsoring the enrollment
program_details: The details of the program in which we're enrolling
course_mode (str): The mode with which we're enrolling in the program
emails: An iterable of email addresses which need to be enrolled
Returns:
successes: A list of users who were successfully enrolled in all courses of the program
pending: A list of PendingEnterpriseCustomerUsers who were successfully linked and had
pending enrollments created for them in the database
failures: A list of users who could not be enrolled in the program
"""
existing_users, unregistered_emails = cls.get_users_by_email(emails)
course_ids = get_course_runs_from_program(program_details)
successes = []
pending = []
failures = []
for user in existing_users:
succeeded = cls.enroll_user(enterprise_customer, user, course_mode, *course_ids)
if succeeded:
successes.append(user)
if enrollment_requester and enrollment_reason:
for course_id in course_ids:
create_manual_enrollment_audit(
enrollment_requester,
user.email,
UNENROLLED_TO_ENROLLED,
enrollment_reason,
course_id,
role=MANUAL_ENROLLMENT_ROLE,
)
else:
failures.append(user)
for email in unregistered_emails:
pending_user = enterprise_customer.enroll_user_pending_registration(
email,
course_mode,
*course_ids,
cohort=cohort,
enrollment_source=EnterpriseEnrollmentSource.get_source(EnterpriseEnrollmentSource.MANUAL)
)
pending.append(pending_user)
if enrollment_requester and enrollment_reason:
for course_id in course_ids:
create_manual_enrollment_audit(
enrollment_requester,
email,
UNENROLLED_TO_ALLOWEDTOENROLL,
enrollment_reason,
course_id,
role=MANUAL_ENROLLMENT_ROLE,
)
return successes, pending, failures
