feat: persist renewal ids and state

Author: iloveagent57

enterprise_access/apps/api/v1/tests/test_provisioning_views.py

@@ -23,6 +23,7 @@
 from enterprise_access.apps.core.tests.factories import UserFactory
 from enterprise_access.apps.customer_billing.constants import CheckoutIntentState
 from enterprise_access.apps.customer_billing.models import CheckoutIntent
+from enterprise_access.apps.customer_billing.tests.factories import StripeEventSummaryFactory
 from enterprise_access.apps.provisioning.models import (
     GetCreateCustomerStep,
     GetCreateEnterpriseAdminUsersStep,
@@ -159,7 +160,7 @@ class TestProvisioningAuth(APITest):
     """
     def setUp(self):
         super().setUp()
-        self._create_checkout_intent()
+        self.checkout_intent = self._create_checkout_intent()
 
     def tearDown(self):
         super().tearDown()
@@ -252,6 +253,8 @@ def test_provisioning_create_allowed_for_provisioning_admins(
         mock_create_agreement.return_value = DEFAULT_AGREEMENT_RECORD
         mock_create_renewal.return_value = EXPECTED_SUBSCRIPTION_PLAN_RENEWAL_RESPONSE
 
+        StripeEventSummaryFactory.create(checkout_intent=self.checkout_intent)
+
         request_payload = {**DEFAULT_REQUEST_PAYLOAD}
         request_payload['pending_admins'] = [
             {
@@ -287,7 +290,7 @@ def setUp(self):
                 'context': ALL_ACCESS_CONTEXT,
             },
         ])
-        self._create_checkout_intent()
+        self.checkout_intent = self._create_checkout_intent()
 
     def _create_checkout_intent(self):
         """Helper to create a checkout intent for testing."""
@@ -349,6 +352,7 @@ def test_get_or_create_customer_and_admins_created(
         mock_client.get_enterprise_catalogs.return_value = [DEFAULT_CATALOG_RECORD]
         mock_create_agreement.return_value = DEFAULT_AGREEMENT_RECORD
         mock_create_renewal.return_value = EXPECTED_SUBSCRIPTION_PLAN_RENEWAL_RESPONSE
+        StripeEventSummaryFactory.create(checkout_intent=self.checkout_intent)
 
         request_payload = {**DEFAULT_REQUEST_PAYLOAD}
         request_payload['pending_admins'] = [
@@ -469,6 +473,7 @@ def test_customer_fetched_admins_fetched_or_created(
         mock_license_client = mock_license_manager_client.return_value
         mock_license_client.get_customer_agreement.return_value = DEFAULT_AGREEMENT_RECORD
         mock_license_client.create_subscription_plan_renewal.return_value = EXPECTED_SUBSCRIPTION_PLAN_RENEWAL_RESPONSE
+        StripeEventSummaryFactory.create(checkout_intent=self.checkout_intent)
 
         request_payload = {**DEFAULT_REQUEST_PAYLOAD}
         request_payload['pending_admins'] = [
@@ -567,6 +572,8 @@ def test_catalog_fetched_or_created(
         mock_create_agreement.return_value = DEFAULT_AGREEMENT_RECORD
         mock_create_renewal.return_value = EXPECTED_SUBSCRIPTION_PLAN_RENEWAL_RESPONSE
 
+        StripeEventSummaryFactory.create(checkout_intent=self.checkout_intent)
+
         request_payload = {**DEFAULT_REQUEST_PAYLOAD}
         response = self.client.post(PROVISIONING_CREATE_ENDPOINT, data=request_payload)
 
@@ -623,6 +630,8 @@ def test_catalog_created_with_generated_title_and_inferred_query_id(
         mock_create_agreement.return_value = DEFAULT_AGREEMENT_RECORD
         mock_create_renewal.return_value = EXPECTED_SUBSCRIPTION_PLAN_RENEWAL_RESPONSE
 
+        StripeEventSummaryFactory.create(checkout_intent=self.checkout_intent)
+
         # Create request payload WITHOUT enterprise_catalog section
         request_payload = {**DEFAULT_REQUEST_PAYLOAD}
         request_payload.pop('enterprise_catalog')
@@ -690,6 +699,8 @@ def test_customer_agreement_fetched_or_created(
 
         mock_license_client.create_subscription_plan_renewal.return_value = EXPECTED_SUBSCRIPTION_PLAN_RENEWAL_RESPONSE
 
+        StripeEventSummaryFactory.create(checkout_intent=self.checkout_intent)
+
         request_payload = {**DEFAULT_REQUEST_PAYLOAD}
         if test_data['created_agreement']:
             request_payload['customer_agreement'] = {
@@ -748,6 +759,8 @@ def test_new_subscription_plan_created(
         mock_license_client.create_subscription_plan.side_effect = [trial_plan_record, first_paid_plan_record]
         mock_license_client.create_subscription_plan_renewal.return_value = EXPECTED_SUBSCRIPTION_PLAN_RENEWAL_RESPONSE
 
+        StripeEventSummaryFactory.create(checkout_intent=self.checkout_intent)
+
         # Make the provisioning request
         response = self.client.post(PROVISIONING_CREATE_ENDPOINT, data=DEFAULT_REQUEST_PAYLOAD)
         self.assertEqual(response.status_code, status.HTTP_201_CREATED)
@@ -855,6 +868,8 @@ def test_legacy_single_plan_request_transformation(
         legacy_request_payload.pop('first_paid_subscription_plan')
         legacy_request_payload['subscription_plan'] = legacy_request_payload.pop('trial_subscription_plan')
 
+        StripeEventSummaryFactory.create(checkout_intent=self.checkout_intent)
+
         # Make the provisioning request.
         response = self.client.post(PROVISIONING_CREATE_ENDPOINT, data=legacy_request_payload)
 
@@ -953,6 +968,7 @@ def test_checkout_intent_synchronized_on_success(
         Test that a fulfillable checkout intent is linked to workflow and marked as FULFILLED on success.
         """
         checkout_intent = self._create_checkout_intent(state=intent_state)
+        StripeEventSummaryFactory.create(checkout_intent=checkout_intent)
         self.assertEqual(checkout_intent.state, intent_state)
         self.assertIsNone(checkout_intent.workflow)
 
@@ -1097,6 +1113,7 @@ def test_checkout_intent_different_slug_ignored(self, mock_lms_api_client, mock_
         """
         # The checkout intent we expect to be updated.
         main_checkout_intent = self._create_checkout_intent(state=CheckoutIntentState.PAID)
+        StripeEventSummaryFactory.create(checkout_intent=main_checkout_intent)
 
         # Create a checkout intent with different enterprise slug. Later, test that this is NOT modified.
         different_slug = 'different-enterprise-slug'
@@ -1105,6 +1122,7 @@ def test_checkout_intent_different_slug_ignored(self, mock_lms_api_client, mock_
             state=CheckoutIntentState.PAID,
             enterprise_slug=different_slug,
         )
+        StripeEventSummaryFactory.create(checkout_intent=different_checkout_intent)
 
         # Setup mocks for successful provisioning
         mock_lms_client = mock_lms_api_client.return_value

enterprise_access/apps/api_client/license_manager_client.py

@@ -321,6 +321,40 @@ def create_subscription_plan_renewal(
             )
             raise
 
+    def process_subscription_plan_renewal(self, renewal_id: int) -> dict:
+        """
+        Process an existing subscription plan renewal via the license-manager service.
+
+        This triggers License Manager to process the renewal from the trial to paid
+        subscription plan, typically called during the trial-to-paid transition.
+
+        Arguments:
+            renewal_id (int): ID of the subscription plan renewal to process
+
+        Returns:
+            dict: Response from the license manager API
+
+        Raises:
+            APIClientException: If the API call fails
+        """
+        endpoint = f'{self.subscription_plan_renewal_provisioning_endpoint}{renewal_id}/process/'
+
+        try:
+            response = self.client.post(endpoint, timeout=settings.LICENSE_MANAGER_CLIENT_TIMEOUT)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.HTTPError as exc:
+            logger.exception(
+                'Failed to process subscription plan renewal %s, response %s, exception: %s',
+                renewal_id,
+                safe_error_response_content(exc),
+                exc,
+            )
+            raise APIClientException(
+                f'Could not process subscription plan renewal {renewal_id}',
+                exc,
+            ) from exc
+
 
 class LicenseManagerUserApiClient(BaseUserApiClient):
     """

enterprise_access/apps/customer_billing/management/commands/backfill_subscription_renewals.py

@@ -0,0 +1,160 @@
+"""
+Management command to backfill SelfServiceSubscriptionRenewal records from existing provisioning workflows.
+"""
+from django.core.management.base import BaseCommand
+from django.db import transaction
+
+from enterprise_access.apps.customer_billing.models import (
+    CheckoutIntent,
+    SelfServiceSubscriptionRenewal,
+    StripeEventSummary
+)
+from enterprise_access.apps.provisioning.models import (
+    GetCreateSubscriptionPlanRenewalStep,
+    ProvisionNewCustomerWorkflow
+)
+
+
+class Command(BaseCommand):
+    """
+    Command to backfill SelfServiceSubscriptionRenewal records from existing provisioning workflows.
+
+    This command finds completed provisioning workflows that have subscription plan renewals
+    but no corresponding SelfServiceSubscriptionRenewal tracking records, and creates them.
+    """
+    help = 'Backfill SelfServiceSubscriptionRenewal records from existing provisioning workflows'
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--batch-size',
+            type=int,
+            default=100,
+            help='Number of records to process in each batch (default: 100)',
+        )
+        parser.add_argument(
+            '--dry-run',
+            action='store_true',
+            help='Show what would be processed without actually creating records',
+        )
+        parser.add_argument(
+            '--workflow-uuid',
+            type=str,
+            help='Only process a specific workflow UUID',
+        )
+
+    def handle(self, *args, **options):
+        """
+        Execute the backfill command.
+        """
+        batch_size = options['batch_size']
+        dry_run = options['dry_run']
+        workflow_uuid = options['workflow_uuid']
+
+        if dry_run:
+            self.stdout.write(self.style.WARNING('DRY RUN MODE - No records will be created'))
+
+        # Find completed provisioning workflows that have subscription renewals
+        workflows_queryset = ProvisionNewCustomerWorkflow.objects.filter(
+            succeeded_at__isnull=False,
+        ).select_related('checkoutintent')
+
+        if workflow_uuid:
+            workflows_queryset = workflows_queryset.filter(uuid=workflow_uuid)
+
+        total_workflows = workflows_queryset.count()
+        self.stdout.write(f'Found {total_workflows} completed provisioning workflows')
+
+        created_count = 0
+        skipped_count = 0
+        error_count = 0
+
+        # Process workflows in batches
+        for i in range(0, total_workflows, batch_size):
+            batch_workflows = workflows_queryset[i:i + batch_size]
+
+            for workflow in batch_workflows:
+                try:
+                    result = self._handle_workflow(workflow, dry_run)
+                    if result == 'created':
+                        created_count += 1
+                    elif result == 'skipped':
+                        skipped_count += 1
+                except Exception as exc:  # pylint: disable=broad-exception-caught
+                    error_count += 1
+                    self.stderr.write(
+                        self.style.ERROR(
+                            f'Error processing workflow {workflow.uuid}: {exc}'
+                        )
+                    )
+
+            # Progress update
+            processed = min(i + batch_size, total_workflows)
+            self.stdout.write(f'Processed {processed}/{total_workflows} workflows...')
+
+        # Summary
+        self.stdout.write(
+            self.style.SUCCESS(
+                f'\nBackfill complete! Created: {created_count}, '
+                f'Skipped: {skipped_count}, Errors: {error_count}'
+            )
+        )
+
+    def _handle_workflow(self, workflow: ProvisionNewCustomerWorkflow, dry_run: bool) -> str:
+        """
+        Process a single workflow to create missing SelfServiceSubscriptionRenewal records.
+
+        Returns:
+            str: 'created', 'skipped', or raises exception
+        """
+        # Check if this workflow has a linked CheckoutIntent
+        try:
+            checkout_intent = workflow.checkoutintent
+        except CheckoutIntent.DoesNotExist:
+            return 'skipped'
+
+        # Find the renewal step for this workflow
+        renewal_step = GetCreateSubscriptionPlanRenewalStep.objects.filter(
+            workflow_record_uuid=workflow.uuid
+        ).first()
+
+        if not renewal_step or not renewal_step.output_object:
+            return 'skipped'
+
+        renewal_id = renewal_step.output_object.id
+
+        # Check if SelfServiceSubscriptionRenewal already exists
+        existing_renewal = SelfServiceSubscriptionRenewal.objects.filter(
+            checkout_intent=checkout_intent,
+            subscription_plan_renewal_id=renewal_id
+        ).first()
+
+        if existing_renewal:
+            return 'skipped'
+
+        if dry_run:
+            self.stdout.write(
+                f'Would create SelfServiceSubscriptionRenewal for '
+                f'checkout_intent {checkout_intent.id}, renewal {renewal_id}'
+            )
+            return 'created'
+
+        stripe_subscription_id = None
+        latest_summary = StripeEventSummary.get_latest_for_checkout_intent(
+            checkout_intent,
+            stripe_subscription_id__isnull=False,
+        )
+        if latest_summary:
+            stripe_subscription_id = latest_summary.stripe_subscription_id
+
+        with transaction.atomic():
+            SelfServiceSubscriptionRenewal.objects.create(
+                checkout_intent=checkout_intent,
+                subscription_plan_renewal_id=renewal_id,
+                stripe_subscription_id=stripe_subscription_id,
+            )
+
+        self.stdout.write(
+            f'Created SelfServiceSubscriptionRenewal for '
+            f'checkout_intent {checkout_intent.id}, renewal {renewal_id}'
+        )
+        return 'created'

enterprise_access/apps/customer_billing/models.py

@@ -788,7 +788,7 @@ class StripeEventData(TimeStampedModel):
     )
 
     def __str__(self):
-        return f"<StripeEventData id={self.event_id}, event_type={self.event_type}>"
+        return f"id={self.event_id}, event_type={self.event_type}"
 
     def mark_as_handled(self):
         """Mark this event as handled by setting handled_at to now."""
@@ -1073,6 +1073,22 @@ def _timestamp_to_datetime(timestamp):
             return _datetime_from_timestamp(timestamp)
         return None
 
+    @classmethod
+    def get_latest_for_checkout_intent(cls, checkout_intent, **filter_kwargs):
+        """
+        Helper to get latest summary for the given CheckoutIntent.
+        """
+        result = StripeEventSummary.objects.filter(
+            checkout_intent=checkout_intent,
+            **filter_kwargs,
+        ).order_by('-stripe_event_created_at').first()
+
+        if result:
+            logger.info('Found Stripe event summary %s for checkout intent %s', result, checkout_intent.uuid)
+        else:
+            logger.warning('No Stripe event summary for checkout intent %s', checkout_intent.uuid)
+        return result
+
     @classmethod
     def get_latest_invoice_paid(cls, invoice_id):
         """