feat: basics of business logic for customer provisioning

enterprise_access/apps/api/v1/views/provisioning.py

@@ -11,6 +11,7 @@
 
 from enterprise_access.apps.api import serializers
 from enterprise_access.apps.core import constants
+from enterprise_access.apps.provisioning import api as provisioning_api
 
 logger = logging.getLogger(__name__)
 
@@ -37,4 +38,29 @@ class ProvisioningCreateView(PermissionRequiredMixin, generics.CreateAPIView):
     def create(self, request, *args, **kwargs):
         request_serializer = serializers.ProvisioningRequestSerializer(data=request.data)
         request_serializer.is_valid(raise_exception=True)
-        return Response('ack', status=status.HTTP_201_CREATED)
+
+        customer_request_data = request_serializer.validated_data['enterprise_customer']
+        created_customer = provisioning_api.get_or_create_enterprise_customer(
+            name=customer_request_data['name'],
+            country=customer_request_data['country'],
+            slug=customer_request_data['slug'],
+        )
+
+        admin_emails = [
+            record.get('user_email')
+            for record in request_serializer.validated_data['pending_admins']
+        ]
+
+        customer_admins = provisioning_api.get_or_create_enterprise_admin_users(
+            enterprise_customer_uuid=created_customer['uuid'],
+            user_emails=admin_emails,
+        )
+
+        response_serializer = serializers.ProvisioningResponseSerializer({
+            'enterprise_customer': created_customer,
+            'pending_admins': customer_admins,
+        })
+        return Response(
+            response_serializer.data,
+            status=status.HTTP_201_CREATED,
+        )

enterprise_access/apps/api_client/lms_client.py

@@ -195,6 +195,33 @@ def get_enterprise_admin_users(self, enterprise_customer_uuid):
 
         return results
 
+    def get_enterprise_pending_admin_users(self, enterprise_customer_uuid):
+        """
+        Gets all pending enterprise admin records for the given customer uuid.
+
+        Arguments:
+            enterprise_customer_uuid (UUID): UUID of the enterprise customer.
+        Returns:
+            List of dictionaries of pending admin users.
+        """
+        try:
+            response = self.client.get(
+                self.pending_enterprise_admin_endpoint + f'?enterprise_customer={enterprise_customer_uuid}',
+                timeout=settings.LMS_CLIENT_TIMEOUT,
+            )
+            response.raise_for_status()
+            logger.info(
+                'Fetched pending admin records for customer %s', enterprise_customer_uuid,
+            )
+            payload = response.json()
+            return payload.get('results', [])
+        except requests.exceptions.HTTPError:
+            logger.exception(
+                'Failed to fetch pending admin record for customer %s',
+                enterprise_customer_uuid,
+            )
+            raise
+
     def create_enterprise_admin_user(self, enterprise_customer_uuid, user_email):
         """
         Creates a new enterprise pending admin record.

enterprise_access/apps/provisioning/api.py

@@ -0,0 +1,63 @@
+"""
+Python API for provisioning operations.
+"""
+import logging
+from ..api_client.lms_client import LmsApiClient
+
+logger = logging.getLogger(__name__)
+
+
+def get_or_create_enterprise_customer(*, name, slug, country, **kwargs):
+    """
+    Get or creates an enterprise customer with the provided arguments.
+    """
+    client = LmsApiClient()
+    existing_customer = client.get_enterprise_customer_data(enterprise_customer_slug=slug)
+    if existing_customer:
+        logger.info('Provisioning: enterprise_customer slug %s already exists', slug)
+        return existing_customer
+
+    created_customer = client.create_enterprise_customer(
+        name=name, slug=slug, country=country, **kwargs,
+    )
+    logger.info('Provisioning: created enterprise customer with slug %s', slug)
+
+
+def get_or_create_enterprise_admin_users(enterprise_customer_uuid, user_emails):
+    """
+    Creates pending admin records from the given ``user_email`` for the customer
+    identified by ``enterprise_customer_uuid``.
+    """
+    client = LmsApiClient()
+    existing_admins = client.get_enterprise_admin_users(enterprise_customer_uuid)
+    existing_admin_emails = {record['email'] for record in existing_admins}
+    logger.info(
+        'Provisioning: customer %s has existing admin emails %s',
+        enterprise_customer_uuid,
+        existing_admin_emails,
+    )
+
+    existing_pending_admins = client.get_enterprise_pending_admin_users(enterprise_customer_uuid)
+    existing_pending_admin_emails = {record['user_email'] for record in existing_pending_admins}
+    logger.info(
+        'Provisioning: customer %s has existing pending admin emails %s',
+        enterprise_customer_uuid,
+        existing_pending_admin_emails,
+    )
+
+    user_emails_to_create = list(
+        (set(user_emails) - existing_admin_emails) - existing_pending_admin_emails
+    )
+
+    created_admins = []
+    for user_email in user_emails_to_create:
+        created_admins.append(
+            client.create_enterprise_admin_user(enterprise_customer_uuid, user_email)
+        )
+        logger.info(
+            'Provisioning: created admin %s for customer %s',
+            user_email,
+            enterprise_customer_uuid,
+        )
+
+    return created_admins + existing_pending_admins