def test_create_pending_enterprise_users_http_error( self, mock_oauth_client): """ Verify the ``create_pending_enterprise_users`` method does not raise an exception for successful requests. """ # Mock out the response from the lms mock_oauth_client.return_value.post.return_value = MockResponse( {'detail': 'Bad Request'}, 400, content=b'error response', ) user_emails = [ '*****@*****.**', '*****@*****.**', '*****@*****.**', ] enterprise_client = EnterpriseApiClient() with self.assertRaises(requests.exceptions.HTTPError): response = enterprise_client.create_pending_enterprise_users( self.uuid, user_emails) mock_oauth_client.return_value.post.assert_called_once_with( enterprise_client.pending_enterprise_learner_endpoint, json=[{ 'enterprise_customer': self.uuid, 'user_email': user_email } for user_email in user_emails], ) assert response.status_code == 400 assert response.content == 'error response'
def send_reminder_email_task(custom_template_text, email_recipient_list, subscription_uuid): """ Sends license activation reminder email(s) asynchronously. Arguments: custom_template_text (dict): Dictionary containing `greeting` and `closing` keys to be used for customizing the email template. email_recipient_list (list of str): List of recipients to send the emails to. subscription_uuid (str): UUID (string representation) of the subscription that the recipients are associated with or will be associated with. """ subscription_plan = SubscriptionPlan.objects.get(uuid=subscription_uuid) pending_licenses = subscription_plan.licenses.filter( user_email__in=email_recipient_list).order_by('uuid') enterprise_api_client = EnterpriseApiClient() enterprise_slug = enterprise_api_client.get_enterprise_slug( subscription_plan.enterprise_customer_uuid) enterprise_name = enterprise_api_client.get_enterprise_name( subscription_plan.enterprise_customer_uuid) try: send_activation_emails(custom_template_text, pending_licenses, enterprise_slug, enterprise_name, is_reminder=True) except Exception: # pylint: disable=broad-except msg = 'License manager reminder email sending received an exception for enterprise: {}.'.format( enterprise_name) logger.error(msg, exc_info=True) # Return without updating the last_remind_date for licenses return License.set_date_fields_to_now(pending_licenses, ['last_remind_date'])
def send_onboarding_email(enterprise_customer_uuid, user_email): """ Sends onboarding email to learner. Intended for use following license activation. Arguments: enterprise_customer_uuid (UUID): unique identifier of the EnterpriseCustomer that is linked to the SubscriptionPlan associated with the activated license user_email (str): email of the learner whose license has just been activated """ enterprise_customer = EnterpriseApiClient().get_enterprise_customer_data( enterprise_customer_uuid) enterprise_name = enterprise_customer.get('name') enterprise_slug = enterprise_customer.get('slug') enterprise_sender_alias = get_enterprise_sender_alias(enterprise_customer) context = { 'subject': ONBOARDING_EMAIL_SUBJECT, 'template_name': ONBOARDING_EMAIL_TEMPLATE, 'ENTERPRISE_NAME': enterprise_name, 'ENTERPRISE_SLUG': enterprise_slug, 'HELP_CENTER_URL': settings.SUPPORT_SITE_URL, 'LEARNER_PORTAL_LINK': get_learner_portal_url(enterprise_slug), 'MOBILE_STORE_URLS': settings.MOBILE_STORE_URLS, 'RECIPIENT_EMAIL': user_email, 'SOCIAL_MEDIA_FOOTER_URLS': settings.SOCIAL_MEDIA_FOOTER_URLS, } email = _message_from_context_and_template(context, enterprise_sender_alias) email.send()
def _validate_enterprise_customer_uuid(self): """ Verifies that a customer with the given enterprise_customer_uuid exists """ enterprise_customer_uuid = self.instance.enterprise_customer_uuid try: customer_data = EnterpriseApiClient().get_enterprise_customer_data( enterprise_customer_uuid) self.instance.enterprise_customer_slug = customer_data.get('slug') self.instance.enterprise_customer_name = customer_data.get('name') return True except HTTPError as ex: logger.exception( f'Could not validate enterprise_customer_uuid {enterprise_customer_uuid}.' ) if ex.response.status_code == status.HTTP_404_NOT_FOUND: self.add_error( 'enterprise_customer_uuid', f'An enterprise customer with uuid: {enterprise_customer_uuid} does not exist.', ) else: self.add_error( 'enterprise_customer_uuid', f'Could not verify the given UUID: {ex}. Please try again.', ) return False
def send_auto_applied_license_email_task(enterprise_customer_uuid, user_email): """ Asynchronously sends onboarding email to learner. Intended for use following automatic license activation. Uses Braze client to send email via Braze campaign. """ try: # Get some info about the enterprise customer enterprise_api_client = EnterpriseApiClient() enterprise_customer = enterprise_api_client.get_enterprise_customer_data( enterprise_customer_uuid) enterprise_slug = enterprise_customer.get('slug') enterprise_name = enterprise_customer.get('name') learner_portal_search_enabled = enterprise_customer.get( 'enable_integrated_customer_learner_portal_search') identity_provider = enterprise_customer.get('identity_provider') enterprise_sender_alias = get_enterprise_sender_alias( enterprise_customer) enterprise_contact_email = enterprise_customer.get('contact_email') except Exception: # pylint: disable=broad-except message = ( f'Error getting data about the enterprise_customer {enterprise_customer_uuid}. ' f'Onboarding email to {user_email} for auto applied license failed.' ) logger.error(message, exc_info=True) return # Determine which email campaign to use if identity_provider and learner_portal_search_enabled is False: braze_campaign_id = settings.AUTOAPPLY_NO_LEARNER_PORTAL_CAMPAIGN else: braze_campaign_id = settings.AUTOAPPLY_WITH_LEARNER_PORTAL_CAMPAIGN # Form data we want to hand to the campaign's email template braze_trigger_properties = { 'enterprise_customer_slug': enterprise_slug, 'enterprise_customer_name': enterprise_name, 'enterprise_sender_alias': enterprise_sender_alias, 'enterprise_contact_email': enterprise_contact_email, } recipient = _aliased_recipient_object_from_email(user_email) try: # Hit the Braze api to send the email braze_client_instance = BrazeApiClient() braze_client_instance.create_braze_alias( [user_email], ENTERPRISE_BRAZE_ALIAS_LABEL, ) braze_client_instance.send_campaign_message( braze_campaign_id, recipients=[recipient], trigger_properties=braze_trigger_properties, ) except BrazeClientError: message = ( 'Error hitting Braze API. ' f'Onboarding email to {user_email} for auto applied license failed.' ) logger.error(message, exc_info=True)
def revoke_course_enrollments_for_user_task(user_id, enterprise_id): """ Sends revoking the user's enterprise licensed course enrollments asynchronously Arguments: user_id (str): The ID of the user who had an enterprise license revoked enterprise_id (str): The ID of the enterprise to revoke course enrollments for """ try: enterprise_api_client = EnterpriseApiClient() enterprise_api_client.revoke_course_enrollments_for_user( user_id=user_id, enterprise_id=enterprise_id) logger.info( 'Revocation of course enrollments SUCCEEDED for user [{user_id}], enterprise [{enterprise_id}]' .format( user_id=user_id, enterprise_id=enterprise_id, )) except Exception: # pylint: disable=broad-except logger.error( 'Revocation of course enrollments FAILED for user [{user_id}], enterprise [{enterprise_id}]' .format( user_id=user_id, enterprise_id=enterprise_id, ), exc_info=True, )
def activation_email_task(custom_template_text, email_recipient_list, subscription_uuid): """ Sends license activation email(s) asynchronously, and creates pending enterprise users to link the email recipients to the subscription's enterprise. Arguments: custom_template_text (dict): Dictionary containing `greeting` and `closing` keys to be used for customizing the email template. email_recipient_list (list of str): List of recipients to send the emails to. subscription_uuid (str): UUID (string representation) of the subscription that the recipients are associated with or will be associated with. """ subscription_plan = SubscriptionPlan.objects.get(uuid=subscription_uuid) pending_licenses = subscription_plan.licenses.filter(user_email__in=email_recipient_list).order_by('uuid') enterprise_api_client = EnterpriseApiClient() enterprise_customer = enterprise_api_client.get_enterprise_customer_data(subscription_plan.enterprise_customer_uuid) enterprise_slug = enterprise_customer.get('slug') enterprise_name = enterprise_customer.get('name') enterprise_sender_alias = enterprise_customer.get('sender_alias', 'edX Support Team') try: send_activation_emails( custom_template_text, pending_licenses, enterprise_slug, enterprise_name, enterprise_sender_alias ) except SMTPException: msg = 'License manager activation email sending received an exception for enterprise: {}.'.format( enterprise_name ) logger.error(msg, exc_info=True) return
def activation_task(custom_template_text, email_recipient_list, subscription_uuid): """ Sends license activation email(s) asynchronously, and creates pending enterprise users to link the email recipients to the subscription's enterprise. Arguments: custom_template_text (dict): Dictionary containing `greeting` and `closing` keys to be used for customizing the email template. email_recipient_list (list of str): List of recipients to send the emails to. subscription_uuid (str): UUID (string representation) of the subscription that the recipients are associated with or will be associated with. """ subscription_plan = SubscriptionPlan.objects.get(uuid=subscription_uuid) pending_licenses = subscription_plan.licenses.filter( user_email__in=email_recipient_list).order_by('uuid') enterprise_api_client = EnterpriseApiClient() enterprise_slug = enterprise_api_client.get_enterprise_slug( subscription_plan.enterprise_customer_uuid) send_activation_emails(custom_template_text, pending_licenses, enterprise_slug) License.set_date_fields_to_now(pending_licenses, ['last_remind_date', 'assigned_date']) for email_recipient in email_recipient_list: enterprise_api_client.create_pending_enterprise_user( subscription_plan.enterprise_customer_uuid, email_recipient, )
def send_reminder_email_task(custom_template_text, email_recipient_list, subscription_uuid): """ Sends license activation reminder email(s) asynchronously. Arguments: custom_template_text (dict): Dictionary containing `greeting` and `closing` keys to be used for customizing the email template. email_recipient_list (list of str): List of recipients to send the emails to. subscription_uuid (str): UUID (string representation) of the subscription that the recipients are associated with or will be associated with. """ subscription_plan = SubscriptionPlan.objects.get(uuid=subscription_uuid) pending_licenses = subscription_plan.licenses.filter( user_email__in=email_recipient_list).order_by('uuid') enterprise_api_client = EnterpriseApiClient() enterprise_customer = enterprise_api_client.get_enterprise_customer_data( subscription_plan.enterprise_customer_uuid) enterprise_slug = enterprise_customer.get('slug') enterprise_name = enterprise_customer.get('name') enterprise_sender_alias = get_enterprise_sender_alias(enterprise_customer) enterprise_contact_email = enterprise_customer.get('contact_email') # We need to send these emails individually, because each email's text must be # generated for every single user/activation_key for pending_license in pending_licenses: user_email = pending_license.user_email license_activation_key = str(pending_license.activation_key) braze_campaign_id = settings.BRAZE_REMIND_EMAIL_CAMPAIGN braze_trigger_properties = { 'TEMPLATE_GREETING': custom_template_text['greeting'], 'TEMPLATE_CLOSING': custom_template_text['closing'], 'license_activation_key': license_activation_key, 'enterprise_customer_slug': enterprise_slug, 'enterprise_customer_name': enterprise_name, 'enterprise_sender_alias': enterprise_sender_alias, 'enterprise_contact_email': enterprise_contact_email, } recipient = _aliased_recipient_object_from_email(user_email) try: braze_client_instance = BrazeApiClient() braze_client_instance.create_braze_alias( [user_email], ENTERPRISE_BRAZE_ALIAS_LABEL, ) braze_client_instance.send_campaign_message( braze_campaign_id, recipients=[recipient], trigger_properties=braze_trigger_properties, ) except BrazeClientError as exc: message = ('Error hitting Braze API. ' f'reminder email to {user_email} for license failed.') logger.exception(message) raise exc License.set_date_fields_to_now(pending_licenses, ['last_remind_date'])
def _send_bulk_enrollment_results_email( bulk_enrollment_job, campaign_id, ): """ Sends email with properties required to detail the results of a bulk enrollment job. Arguments: bulk_enrollment_job (BulkEnrollmentJob): the completed bulk enrollment job campaign_id: (str): The Braze campaign identifier """ try: enterprise_api_client = EnterpriseApiClient() enterprise_customer = enterprise_api_client.get_enterprise_customer_data( bulk_enrollment_job.enterprise_customer_uuid, ) admin_users = enterprise_api_client.get_enterprise_admin_users( bulk_enrollment_job.enterprise_customer_uuid, ) # https://web.archive.org/web/20211122135949/https://www.braze.com/docs/api/objects_filters/recipient_object/ recipients = [] for user in admin_users: if int(user['id']) != bulk_enrollment_job.lms_user_id: continue # must use a mix of send_to_existing_only: false + enternal_id w/ attributes to send to new braze profiles recipient = { 'send_to_existing_only': False, 'external_user_id': str(user['id']), 'attributes': { 'email': user['email'], } } recipients.append(recipient) break braze_client = BrazeApiClient() braze_client.send_campaign_message(campaign_id, recipients=recipients, trigger_properties={ 'enterprise_customer_slug': enterprise_customer.get('slug'), 'enterprise_customer_name': enterprise_customer.get('name'), 'bulk_enrollment_job_uuid': str(bulk_enrollment_job.uuid), }) msg = ( f'success _send_bulk_enrollment_results_email for bulk_enrollment_job_uuid={bulk_enrollment_job.uuid} ' 'braze_campaign_id={campaign_id} lms_user_id={bulk_enrollment_job.lms_user_id}' ) logger.info(msg) except Exception as ex: msg = ( f'failed _send_bulk_enrollment_results_email for bulk_enrollment_job_uuid={bulk_enrollment_job.uuid} ' 'braze_campaign_id={campaign_id} lms_user_id={bulk_enrollment_job.lms_user_id}' ) logger.error(msg, exc_info=True) raise ex
def _get_admin_users_for_enterprise(enterprise_customer_uuid): api_client = EnterpriseApiClient() admin_users = api_client.get_enterprise_admin_users( enterprise_customer_uuid) return [{ 'lms_user_id': admin_user['id'], 'ecu_id': admin_user['ecu_id'], 'email': admin_user['email'] } for admin_user in admin_users]
def link_learners_to_enterprise_task(learner_emails, enterprise_customer_uuid): """ Links learners to an enterprise asynchronously. Arguments: learner_emails (list): list containing the list of learner emails to link to the enterprise enterprise_customer_uuid (str): UUID (string representation) of the enterprise to link learns to """ enterprise_api_client = EnterpriseApiClient() for learner_email in learner_emails: enterprise_api_client.create_pending_enterprise_user( enterprise_customer_uuid, learner_email, )
def link_learners_to_enterprise_task(learner_emails, enterprise_customer_uuid): """ Links learners to an enterprise asynchronously. Arguments: learner_emails (list): list email addresses to link to the given enterprise. enterprise_customer_uuid (str): UUID (string representation) of the enterprise to link learns to. """ enterprise_api_client = EnterpriseApiClient() for user_email_batch in chunks(learner_emails, PENDING_ACCOUNT_CREATION_BATCH_SIZE): enterprise_api_client.create_pending_enterprise_users( enterprise_customer_uuid, user_email_batch, )
def sync_agreement_with_enterprise_customer(customer_agreement): """ Syncs any updates made to the enterprise customer slug or name as returned by the ``EnterpriseApiClient`` with the specified ``CustomerAgreement``. """ try: customer_data = EnterpriseApiClient().get_enterprise_customer_data( customer_agreement.enterprise_customer_uuid, ) customer_agreement.enterprise_customer_slug = customer_data.get('slug') customer_agreement.enterprise_customer_name = customer_data.get('name') customer_agreement.save() except HTTPError as exc: error_message = ( 'Could not fetch customer fields from the enterprise API: {}'.format(exc) ) raise CustomerAgreementError(error_message) from exc
def license_expiration_task(license_uuids): """ Sends terminating the licensed course enrollments for the submitted license_uuids asynchronously Arguments: license_uuids (list of str): The UUIDs of the expired licenses """ try: enterprise_api_client = EnterpriseApiClient() enterprise_api_client.bulk_licensed_enrollments_expiration(expired_license_uuids=license_uuids) except Exception: # pylint: disable=broad-except logger.error( "Expiration of course enrollments FAILED for licenses [{license_uuids}]".format( license_uuids=license_uuids, ), exc_info=True, )
def test_create_pending_enterprise_user_logs(self, mock_oauth_client, mock_logger): """ Verify the ``create_pending_enterprise_user`` method logs an error for a status code of >=400. """ # Mock out the response from the lms mock_oauth_client().post.return_value = MockResponse({'detail': 'Bad Request'}, 400) EnterpriseApiClient().create_pending_enterprise_user(self.uuid, self.user_email) mock_logger.error.assert_called_once()
def send_revocation_cap_notification_email_task(subscription_uuid): """ Sends revocation cap email notification to ECS asynchronously. Arguments: subscription_uuid (str): UUID (string representation) of the subscription that has reached its recovation cap. """ subscription_plan = SubscriptionPlan.objects.get(uuid=subscription_uuid) enterprise_api_client = EnterpriseApiClient() enterprise_customer = enterprise_api_client.get_enterprise_customer_data( subscription_plan.enterprise_customer_uuid) enterprise_name = enterprise_customer.get('name') now = localized_utcnow() revocation_date = datetime.strftime(now, "%B %d, %Y, %I:%M%p %Z") braze_campaign_id = settings.BRAZE_REVOKE_CAP_EMAIL_CAMPAIGN braze_trigger_properties = { 'SUBSCRIPTION_TITLE': subscription_plan.title, 'NUM_REVOCATIONS_APPLIED': subscription_plan.num_revocations_applied, 'ENTERPRISE_NAME': enterprise_name, 'REVOKED_LIMIT_REACHED_DATE': revocation_date, } recipient = _aliased_recipient_object_from_email( settings.CUSTOMER_SUCCESS_EMAIL_ADDRESS) try: braze_client_instance = BrazeApiClient() braze_client_instance.create_braze_alias( [settings.CUSTOMER_SUCCESS_EMAIL_ADDRESS], ENTERPRISE_BRAZE_ALIAS_LABEL, ) braze_client_instance.send_campaign_message( braze_campaign_id, recipients=[recipient], trigger_properties=braze_trigger_properties, ) except BrazeClientError as exc: message = 'Revocation cap notification email sending received an exception.' logger.exception(message) raise exc
def send_revocation_cap_notification_email_task(subscription_uuid): """ Sends revocation cap email notification to ECS asynchronously. Arguments: subscription_uuid (str): UUID (string representation) of the subscription that has reached its recovation cap. """ subscription_plan = SubscriptionPlan.objects.get(uuid=subscription_uuid) enterprise_api_client = EnterpriseApiClient() enterprise_name = enterprise_api_client.get_enterprise_name( subscription_plan.enterprise_customer_uuid) try: send_revocation_cap_notification_email( subscription_plan, enterprise_name, ) except Exception: # pylint: disable=broad-except logger.error( 'Revocation cap notification email sending received an exception.', exc_info=True)
def send_revocation_cap_notification_email_task(subscription_uuid): """ Sends revocation cap email notification to ECS asynchronously. Arguments: subscription_uuid (str): UUID (string representation) of the subscription that has reached its recovation cap. """ subscription_plan = SubscriptionPlan.objects.get(uuid=subscription_uuid) enterprise_api_client = EnterpriseApiClient() enterprise_customer = enterprise_api_client.get_enterprise_customer_data(subscription_plan.enterprise_customer_uuid) enterprise_name = enterprise_customer.get('name') enterprise_sender_alias = enterprise_customer.get('sender_alias', 'edX Support Team') try: send_revocation_cap_notification_email( subscription_plan, enterprise_name, enterprise_sender_alias, ) except SMTPException: logger.error('Revocation cap notification email sending received an exception.', exc_info=True)
def test_create_pending_enterprise_user_successful(self, mock_oauth_client, mock_logger): """ Verify the ``create_pending_enterprise_user`` method does not retry or log an error on success """ # Mock out the response from the lms mock_oauth_client().post.return_value = MockResponse( {'detail': 'Good Request'}, 201) EnterpriseApiClient().create_pending_enterprise_user( self.uuid, self.user_email) assert mock_oauth_client().post.call_count == 1 mock_logger.error.assert_not_called()
def test_revoke_course_enrollments_for_user_with_error(self, mock_oauth_client, mock_logger): """ Verify the ``update_course_enrollment_mode_for_user`` method logs an error for a status code of >=400. """ # Mock out the response from the lms mock_oauth_client().post.return_value = MockResponse({'detail': 'Bad Request'}, 400) mock_oauth_client().post.return_value.content = 'error response' EnterpriseApiClient().revoke_course_enrollments_for_user( user_id=self.user_id, enterprise_id=self.uuid, ) mock_logger.error.assert_called_once()
def license_expiration_task(license_uuids, ignore_enrollments_modified_after=None): """ Sends terminating the licensed course enrollments for the submitted license_uuids asynchronously Arguments: license_uuids (list of str): The UUIDs of the expired licenses """ try: enterprise_api_client = EnterpriseApiClient() enterprise_api_client.bulk_licensed_enrollments_expiration( expired_license_uuids=license_uuids, ignore_enrollments_modified_after=ignore_enrollments_modified_after ) logger.info( "Expiration of course enrollments SUCCEEDED for licenses [{license_uuids}]" .format(license_uuids=license_uuids, )) except Exception as exc: logger.error( "Expiration of course enrollments FAILED for licenses [{license_uuids}]" .format(license_uuids=license_uuids, ), exc_info=True, ) raise exc
def send_post_activation_email_task(enterprise_customer_uuid, user_email): """ Asynchronously sends post license activation email to learner. """ enterprise_customer = EnterpriseApiClient().get_enterprise_customer_data( enterprise_customer_uuid) enterprise_name = enterprise_customer.get('name') enterprise_slug = enterprise_customer.get('slug') enterprise_sender_alias = get_enterprise_sender_alias(enterprise_customer) enterprise_contact_email = enterprise_customer.get('contact_email') braze_campaign_id = settings.BRAZE_ACTIVATION_EMAIL_CAMPAIGN braze_trigger_properties = { 'enterprise_customer_slug': enterprise_slug, 'enterprise_customer_name': enterprise_name, 'enterprise_sender_alias': enterprise_sender_alias, 'enterprise_contact_email': enterprise_contact_email, } recipient = _aliased_recipient_object_from_email(user_email) try: braze_client_instance = BrazeApiClient() braze_client_instance.create_braze_alias( [user_email], ENTERPRISE_BRAZE_ALIAS_LABEL, ) braze_client_instance.send_campaign_message( braze_campaign_id, recipients=[recipient], trigger_properties=braze_trigger_properties, ) except BrazeClientError as exc: message = ('Error hitting Braze API. ' f'Onboarding email to {user_email} for license failed.') logger.exception(message) raise exc
def test_create_pending_enterprise_user_rate_limited(self, mock_oauth_client): """ Verify the ``create_pending_enterprise_user`` method retries on a 429 response code. """ rate_limited_response = MockResponse({'detail': 'Rate limited'}, 429) # Mock out a few rate-limited response and one good from the lms mock_oauth_client().post.side_effect = [ rate_limited_response, rate_limited_response, rate_limited_response, MockResponse({'detail': 'Good Request'}, 201), ] EnterpriseApiClient().create_pending_enterprise_user(self.uuid, self.user_email) assert mock_oauth_client().post.call_count == 4
def test_create_pending_enterprise_user_rate_with_error_retries( self, mock_oauth_client): """ Verify the ``create_pending_enterprise_user`` method retries on a non 429 error code """ error_response = MockResponse({'detail': '500 Internal Server'}, 500) # Mock out a few rate-limited response and one good from the lms mock_oauth_client().post.side_effect = [ error_response, error_response, MockResponse({'detail': 'Good Request'}, 201), ] EnterpriseApiClient().create_pending_enterprise_user( self.uuid, self.user_email) assert mock_oauth_client().post.call_count == 3
def get_enterprise_customer(self, enterprise_customer_slug): """ Returns an enterprise customer """ logger.info('\nFetching an enterprise customer {} name ...'.format(enterprise_customer_slug)) try: enterprise_api_client = EnterpriseApiClient() # Query endpoint by slug for easy dev CLI experience endpoint = '{}?slug={}'.format(enterprise_api_client.enterprise_customer_endpoint, str(enterprise_customer_slug)) response = enterprise_api_client.client.get(endpoint).json() if response.get('count'): return response.get('results')[0] return None except IndexError: logger.error('No enterprise customer found.') return None
def create_relationships(apps, schema_editor): """ Create new CustomerAgreements from all existing SubscriptionPlans with enterprise customers. """ CustomerAgreement = apps.get_model('subscriptions', 'CustomerAgreement') SubscriptionPlan = apps.get_model('subscriptions', 'SubscriptionPlan') subscriptions_with_customers = SubscriptionPlan.objects.exclude(enterprise_customer_uuid=None) for plan in subscriptions_with_customers: customer_uuid = plan.enterprise_customer_uuid enterprise_slug = EnterpriseApiClient().get_enterprise_customer_data(customer_uuid).get('slug') customer_agreement, _ = CustomerAgreement.objects.get_or_create( enterprise_customer_uuid=customer_uuid, defaults={ 'enterprise_customer_slug': enterprise_slug, } ) plan.customer_agreement = customer_agreement plan.save()
def test_create_pending_enterprise_user_rate_with_error_retries_and_rate_limiting( self, mock_oauth_client): """ Verify the ``create_pending_enterprise_user`` method has 3 error retries if a rate limited error occurs """ error_response = MockResponse({'detail': '500 Internal Server'}, 500) rate_limited_response = MockResponse({'detail': 'Rate limited'}, 429) # Mock out a few rate-limited response and one good from the lms mock_oauth_client().post.side_effect = [ error_response, error_response, rate_limited_response, error_response, error_response, error_response, error_response, MockResponse({'detail': 'Good Request'}, 201), ] EnterpriseApiClient().create_pending_enterprise_user( self.uuid, self.user_email) assert mock_oauth_client().post.call_count == 6
def post(self, request): """ Returns the enterprise bulk enrollment API response after validating that each user requesting to be enrolled has a valid subscription for each of the requested courses. Expected params: - notify (bool): Whether or not learners should be notified of their enrollments. - course_run_keys (list of strings): An array of course run keys in which all provided learners will be enrolled in Example: course_run_keys: ['course-v1:edX+DemoX+Demo_Course', 'course-v2:edX+The+Second+DemoX+Demo_Course', ... ] - emails (string): A single string of multiple learner emails separated with a `\n` (new line) character Example: emails: '[email protected]\[email protected]\[email protected]' - enterprise_customer_uuid (string): the uuid of the associated enterprise customer provided as a query params. Expected Return Values: Success cases: - All learners have licenses and are enrolled - {}, 201 Partial failure cases: License verification and bulk enterprise enrollment happen non-transactionally, meaning that a subset of learners failing one step will not stop others from continuing the enrollment flow. As such, partial failures will be reported in the following ways: Fails license verification: response includes: {'failed_license_checks': [<users who do not have valid licenses>]} Fails Enrollment: response includes {'failed_enrollments': [<users who were not able to be enrolled>] Fails Validation (something goes wrong with requesting enrollments): response includes: {'bulk_enrollment_errors': [<errors returned by the bulk enrollment endpoint>]} """ param_validation = self._validate_request_params() if param_validation: return Response(param_validation, status=status.HTTP_400_BAD_REQUEST) results = {} customer_agreement = utils.get_customer_agreement_from_request_enterprise_uuid( request) missing_subscriptions, licensed_enrollment_info = self._check_missing_licenses( customer_agreement) if missing_subscriptions: msg = 'One or more of the learners entered do not have a valid subscription for your requested courses. ' \ 'Learners: {}'.format(missing_subscriptions) results['failed_license_checks'] = missing_subscriptions logger.error(msg) if licensed_enrollment_info: options = { 'licenses_info': licensed_enrollment_info, 'notify': self.requested_notify_learners } enrollment_response = EnterpriseApiClient( ).bulk_enroll_enterprise_learners(self.requested_enterprise_id, options) # Check for bulk enrollment errors if enrollment_response.status_code >= 400 and enrollment_response.status_code != 409: status_code = status.HTTP_400_BAD_REQUEST results['bulk_enrollment_errors'] = [] try: response_json = enrollment_response.json() except JSONDecodeError: # Catch uncaught exceptions from enterprise results['bulk_enrollment_errors'].append( enrollment_response.reason) else: msg = 'Encountered a validation error when requesting bulk enrollment. Endpoint returned with ' \ 'error: {}'.format(response_json) logger.error(msg) # check for non field specific errors if response_json.get('non_field_errors'): results['bulk_enrollment_errors'].append( response_json['non_field_errors']) # check for param field specific validation errors for param in options: if response_json.get(param): results['bulk_enrollment_errors'].append( response_json.get(param)) else: enrollment_result = enrollment_response.json() if enrollment_result.get('failures'): results['failed_enrollments'] = enrollment_result[ 'failures'] if enrollment_result.get('failures') or missing_subscriptions: status_code = status.HTTP_409_CONFLICT else: status_code = status.HTTP_201_CREATED else: status_code = status.HTTP_404_NOT_FOUND return Response(results, status=status_code)
def enterprise_enrollment_license_subsidy_task( bulk_enrollment_job_uuid, enterprise_customer_uuid, learner_emails, course_run_keys, notify_learners, subscription_uuid, ): """ Enroll a list of enterprise learners into a list of course runs with or without notifying them. Optionally, filter license check by a specific subscription. Arguments: bulk_enrollment_job_uuid (str): UUID (string representation) for a BulkEnrollmentJob created by the enqueuing process for logging and progress tracking table updates. enterprise_customer_uuid (str): UUID (string representation) the enterprise customer id learner_emails (list(str)): email addresses of the learners to enroll course_run_keys (list(str)): course keys of the courses to enroll the learners into notify_learners (bool): whether or not to send notifications of their enrollment to the learners subscription_uuid (str): UUID (string representation) of the specific enterprise subscription to use when validating learner licenses """ # AED 2022-01-24 - I don't have enough context to unwind this sanely. # Declaring bankruptcy for now. # pylint: disable=too-many-nested-blocks try: logger.info('starting enterprise_enrollment_license_subsidy_task for ' f'bulk_enrollment_job_uuid={bulk_enrollment_job_uuid} ' f'enterprise_customer_uuid={enterprise_customer_uuid}') # collect/return results (rather than just write to the CSV) to help testability results = [] bulk_enrollment_job = BulkEnrollmentJob.objects.get( uuid=bulk_enrollment_job_uuid) customer_agreement = CustomerAgreement.objects.get( enterprise_customer_uuid=enterprise_customer_uuid) # this is to avoid hitting timeouts on the enterprise enroll api # take course keys 25 at a time, for each course key chunk, take learners 25 at a time for course_run_key_batch in chunks(course_run_keys, 25): logger.debug( "enterprise_customer_uuid={} course_run_key_batch size: {}". format(enterprise_customer_uuid, len(course_run_key_batch))) for learner_enrollment_batch in chunks(learner_emails, 25): logger.debug( "enterprise_customer_uuid={} learner_enrollment_batch size: {}" .format(enterprise_customer_uuid, len(learner_enrollment_batch))) missing_subscriptions, licensed_enrollment_info = utils.check_missing_licenses( customer_agreement, learner_enrollment_batch, course_run_key_batch, subscription_uuid=subscription_uuid, ) if missing_subscriptions: for failed_email, course_keys in missing_subscriptions.items( ): for course_key in course_keys: results.append([ failed_email, course_key, 'failed', 'missing subscription' ]) if licensed_enrollment_info: options = { 'licenses_info': licensed_enrollment_info, 'notify': notify_learners } enrollment_result = EnterpriseApiClient( ).bulk_enroll_enterprise_learners( str(enterprise_customer_uuid), options).json() for success in enrollment_result['successes']: results.append([ success.get('email'), success.get('course_run_key'), 'success', '' ]) for pending in enrollment_result['pending']: results.append([ pending.get('email'), pending.get('course_run_key'), 'pending', 'pending license activation' ]) for failure in enrollment_result['failures']: results.append([ failure.get('email'), failure.get('course_run_key'), 'failed', '' ]) if enrollment_result.get('invalid_email_addresses'): for result_email in enrollment_result[ 'invalid_email_addresses']: for course_key in course_run_key_batch: results.append([ result_email, course_key, 'failed', 'invalid email address' ]) with NamedTemporaryFile(mode='w', delete=False) as result_file: result_writer = csv.writer(result_file) result_writer.writerow( ['email address', 'course key', 'enrollment status', 'notes']) for result in results: result_writer.writerow(result) result_file.close() if hasattr(settings, "BULK_ENROLL_JOB_AWS_BUCKET" ) and settings.BULK_ENROLL_JOB_AWS_BUCKET: bulk_enrollment_job.upload_results(result_file.name) if hasattr(settings, "BULK_ENROLL_RESULT_CAMPAIGN" ) and settings.BULK_ENROLL_RESULT_CAMPAIGN: _send_bulk_enrollment_results_email( bulk_enrollment_job=bulk_enrollment_job, campaign_id=settings.BULK_ENROLL_RESULT_CAMPAIGN, ) return results except Exception as ex: msg = ('failed enterprise_enrollment_license_subsidy_task for ' f'bulk_enrollment_job_uuid={bulk_enrollment_job_uuid} ' f'enterprise_customer_uuid={enterprise_customer_uuid}') logger.error(msg, exc_info=True) raise ex