feat: create CourseEnrollmentAllowed entries for pending enrollments

When creating pending enrollments for non-existant users, we also check
to see if the course is "invite_only". If the course is invite only,
then we create corresponding CourseEnrollmentAllowed objects. This fixes
the issue when the enterprise creates pending enrollment, but the user
cannot enroll to the course as platform rejects the enrollment request
due to missing CEA for the user.

enterprise/admin/forms.py

@@ -68,6 +68,11 @@ class ManageLearnersForm(forms.Form):
         label=_("Enroll these learners in this course"), required=False,
         help_text=_("To enroll learners in a course, enter a course ID."),
     )
+    force_enrollment = forms.BooleanField(
+        label=_("Force Enrollment"),
+        help_text=_("The selected course is 'Invite Only'. Only staff can enroll learners to this course."),
+        required=False,
+    )
     course_mode = forms.ChoiceField(
         label=_("Course enrollment track"), required=False,
         choices=BLANK_CHOICE_DASH + [
@@ -130,6 +135,7 @@ class Fields:
         REASON = "reason"
         SALES_FORCE_ID = "sales_force_id"
         DISCOUNT = "discount"
+        FORCE_ENROLLMENT = "force_enrollment"
 
     class CsvColumns:
         """

enterprise/admin/views.py

@@ -678,7 +678,8 @@ def _enroll_users(
             notify=True,
             enrollment_reason=None,
             sales_force_id=None,
-            discount=0.0
+            discount=0.0,
+            force_enrollment=False,
     ):
         """
         Enroll the users with the given email addresses to the course.
@@ -691,6 +692,7 @@ def _enroll_users(
             mode: The enrollment mode the users will be enrolled in the course with
             course_id: The ID of the course in which we want to enroll
             notify: Whether to notify (by email) the users that have been enrolled
+            force_enrollment: Force enrollment into "Invite Only" courses
         """
         pending_messages = []
         paid_modes = ['verified', 'professional']
@@ -704,6 +706,7 @@ def _enroll_users(
             enrollment_reason=enrollment_reason,
             discount=discount,
             sales_force_id=sales_force_id,
+            force_enrollment=force_enrollment,
         )
         all_successes = succeeded + pending
         if notify:
@@ -820,6 +823,7 @@ def post(self, request, customer_uuid):
             sales_force_id = manage_learners_form.cleaned_data.get(ManageLearnersForm.Fields.SALES_FORCE_ID)
             course_mode = manage_learners_form.cleaned_data.get(ManageLearnersForm.Fields.COURSE_MODE)
             course_id = None
+            force_enrollment = manage_learners_form.cleaned_data.get(ManageLearnersForm.Fields.FORCE_ENROLLMENT)
 
             if not course_id_with_emails:
                 course_details = manage_learners_form.cleaned_data.get(ManageLearnersForm.Fields.COURSE) or {}
@@ -834,7 +838,8 @@ def post(self, request, customer_uuid):
                         notify=notify,
                         enrollment_reason=manual_enrollment_reason,
                         sales_force_id=sales_force_id,
-                        discount=discount
+                        discount=discount,
+                        force_enrollment=force_enrollment,
                     )
             else:
                 for course_id, emails in course_id_with_emails.items():
@@ -849,7 +854,8 @@ def post(self, request, customer_uuid):
                             notify=notify,
                             enrollment_reason=manual_enrollment_reason,
                             sales_force_id=sales_force_id,
-                            discount=discount
+                            discount=discount,
+                            force_enrollment=force_enrollment,
                         )
 
             # Redirect to GET if everything went smooth.

enterprise/api_client/lms.py

@@ -128,7 +128,15 @@ def has_course_mode(self, course_run_id, mode):
         course_modes = self.get_course_modes(course_run_id)
         return any(course_mode for course_mode in course_modes if course_mode['slug'] == mode)
 
-    def enroll_user_in_course(self, username, course_id, mode, cohort=None, enterprise_uuid=None):
+    def enroll_user_in_course(
+        self,
+        username,
+        course_id,
+        mode,
+        cohort=None,
+        enterprise_uuid=None,
+        force_enrollment=False,
+    ):
         """
         Call the enrollment API to enroll the user in the course specified by course_id.
 
@@ -138,6 +146,7 @@ def enroll_user_in_course(self, username, course_id, mode, cohort=None, enterpri
             mode (str): The enrollment mode which should be used for the enrollment
             cohort (str): Add the user to this named cohort
             enterprise_uuid (str): Add course enterprise uuid
+            force_enrollment (bool): Force the enrollment even if course is Invite Only
 
         Returns:
             dict: A dictionary containing details of the enrollment, including course details, mode, username, etc.
@@ -152,7 +161,8 @@ def enroll_user_in_course(self, username, course_id, mode, cohort=None, enterpri
                 'is_active': True,
                 'mode': mode,
                 'cohort': cohort,
-                'enterprise_uuid': str(enterprise_uuid)
+                'enterprise_uuid': str(enterprise_uuid),
+                'force_enrollment': force_enrollment,
             }
         )
         response.raise_for_status()

enterprise/models.py

@@ -83,9 +83,10 @@
 )
 
 try:
-    from common.djangoapps.student.models import CourseEnrollment
+    from common.djangoapps.student.models import CourseEnrollment, CourseEnrollmentAllowed
 except ImportError:
     CourseEnrollment = None
+    CourseEnrollmentAllowed = None
 
 try:
     from common.djangoapps.entitlements.models import CourseEntitlement
@@ -745,7 +746,21 @@ def enroll_user_pending_registration_with_status(self, email, course_mode, *cour
             license_uuid = None
 
         new_enrollments = {}
+        enrollment_api_client = EnrollmentApiClient()
+
         for course_id in course_ids:
+            # Check if the course is "Invite Only" and add CEA if it is.
+            course_details = enrollment_api_client.get_course_details(course_id)
+
+            if course_details["invite_only"]:
+                if not CourseEnrollmentAllowed:
+                    raise NotConnectedToOpenEdX()
+
+                CourseEnrollmentAllowed.objects.update_or_create(
+                    email=email,
+                    course_id=course_id
+                )
+
             __, created = PendingEnrollment.objects.update_or_create(
                 user=pending_ecu,
                 course_id=course_id,

enterprise/static/enterprise/js/manage_learners.js

@@ -9,7 +9,7 @@ function makeOption(name, value) {
     return $("<option></option>").text(name).val(value);
 }
 
-function fillModeDropdown(data) {
+function updateCourseData(data) {
     /*
      Given a set of data fetched from the enrollment API, populate the Course Mode
      dropdown with those options that are valid for the course entered in the
@@ -19,6 +19,11 @@ function fillModeDropdown(data) {
     var previous_value = $course_mode.val();
     applyModes(data.course_modes);
     $course_mode.val(previous_value);
+
+    // If the course is invite-only, show the force enrollment box.
+    if (data.invite_only) {
+        $("#id_force_enrollment").parent().show();
+    }
 }
 
 function applyModes(modes) {
@@ -43,7 +48,7 @@ function loadCourseModes(success, failure) {
             return;
         }
         $.ajax({method: 'get', url: enrollmentApiRoot + "course/" + courseId})
-            .done(success || fillModeDropdown)
+            .done(success || updateCourseData)
             .fail(failure || function (err, jxHR, errstat) { disableMode(disableReason); });
     });
 }
@@ -134,11 +139,38 @@ function loadPage() {
        programEnrollment.$control.oldValue = null;
     });
 
+    // NOTE: As the course details won't be fetched for course id in the CSV
+    // file, this has a potential side-effect of enrolling learners into the courses
+    // which might be marked as closed for reasons other then being "Invite Only".
+    //
+    // This is considered as a reasonable tradeoff at the time of this addition.
+    // Currently, the EnrollmentListView does not support invitation only courses.
+    // This problem does not happen in the Instructor Dashboard because it doesn't 
+    // invoke access checks when calling the enroll method. Modifying the enroll method
+    // is a high-risk change, and it seems that the API will need some changes in
+    // the near future anyway - when the Instructor Dashboard is converted into an
+    // MFE (it could be an excellent opportunity to eliminate many legacy behaviors
+    // there, too).
+    $("#id_bulk_upload_csv").change(function(e) {
+        if (e.target.value) {
+            var force_enrollment = $("#id_force_enrollment");
+            force_enrollment.parent().show();
+            force_enrollment.siblings(".helptext")[0].innerHTML = gettext(
+                "If any of the courses in the CSV file are marked 'Invite Only', " +
+                "this should be enabled for the enrollments to go through in those courses."
+            );
+        }
+    });
+
     if (courseEnrollment.$control.val()) {
         courseEnrollment.$control.trigger("input");
     } else if (programEnrollment.$control.val()) {
         programEnrollment.$control.trigger("input");
     }
+
+    // hide the force_invite_only checkbox by default
+    $("#id_force_enrollment").parent().hide();
+
     $("#learner-management-form").submit(addCheckedLearnersToEnrollBox);
 }
 

enterprise/utils.py

@@ -1740,12 +1740,15 @@ def enroll_user(enterprise_customer, user, course_mode, *course_ids, **kwargs):
         user: The user model object who needs to be enrolled in the course
         course_mode: The string representation of the mode with which the enrollment should be created
         *course_ids: An iterable containing any number of course IDs to eventually enroll the user in.
-        kwargs: Should contain enrollment_client if it's already been instantiated and should be passed in.
+        kwargs: Contains optional params such as:
+            - enrollment_client, if it's already been instantiated and should be passed in
+            - force_enrollment, if the course is "Invite Only" and the "force_enrollment" is needed
 
     Returns:
         Boolean: Whether or not enrollment succeeded for all courses specified
     """
     enrollment_client = kwargs.pop('enrollment_client', None)
+    force_enrollment = kwargs.pop('force_enrollment', False)
     if not enrollment_client:
         from enterprise.api_client.lms import EnrollmentApiClient  # pylint: disable=import-outside-toplevel
         enrollment_client = EnrollmentApiClient()
@@ -1760,7 +1763,8 @@ def enroll_user(enterprise_customer, user, course_mode, *course_ids, **kwargs):
                 user.username,
                 course_id,
                 course_mode,
-                enterprise_uuid=str(enterprise_customer_user.enterprise_customer.uuid)
+                enterprise_uuid=str(enterprise_customer_user.enterprise_customer.uuid),
+                force_enrollment=force_enrollment,
             )
         except HttpClientError as exc:
             # Check if user is already enrolled then we should ignore exception
@@ -2113,6 +2117,7 @@ def enroll_users_in_course(
         enrollment_reason=None,
         discount=0.0,
         sales_force_id=None,
+        force_enrollment=False,
 ):
     """
     Enroll existing users in a course, and create a pending enrollment for nonexisting users.
@@ -2126,6 +2131,7 @@ def enroll_users_in_course(
         enrollment_reason (str): A reason for enrollment.
         discount (Decimal): Percentage discount for enrollment.
         sales_force_id (str): Salesforce opportunity id.
+        force_enrollment (bool): Force enrollment into 'Invite Only' courses.
 
     Returns:
         successes: A list of users who were successfully enrolled in the course.
@@ -2142,7 +2148,7 @@ def enroll_users_in_course(
     failures = []
 
     for user in existing_users:
-        succeeded = enroll_user(enterprise_customer, user, course_mode, course_id)
+        succeeded = enroll_user(enterprise_customer, user, course_mode, course_id, force_enrollment=force_enrollment)
         if succeeded:
             successes.append(user)
             if enrollment_requester and enrollment_reason:

test_utils/fake_enrollment_api.py

@@ -150,7 +150,8 @@ def get_course_details(course_id):
         return None
 
 
-def enroll_user_in_course(user, course_id, mode, cohort=None, enterprise_uuid=None):
+def enroll_user_in_course(user, course_id, mode, cohort=None, enterprise_uuid=None, force_enrollment=False):  # pylint: disable=unused-argument
+
     """
     Fake implementation.
     """