Filter privilege options based on states that are live

landonshumway-ia · landonshumway-ia · commit aa655f6c8b00 · 2025-06-25T15:14:08.000-07:00
diff --git a/backend/compact-connect/lambdas/python/common/cc_common/data_model/compact_configuration_client.py b/backend/compact-connect/lambdas/python/common/cc_common/data_model/compact_configuration_client.py
@@ -1,9 +1,9 @@
-from boto3.dynamodb.conditions import Attr, Key
+from boto3.dynamodb.conditions import Key
 
 from cc_common.config import _Config, logger
-from cc_common.data_model.query_paginator import paginated_query
 from cc_common.data_model.schema.attestation import AttestationRecordSchema
 from cc_common.data_model.schema.compact import CompactConfigurationData
+from cc_common.data_model.schema.compact.common import COMPACT_TYPE
 from cc_common.data_model.schema.compact.record import CompactRecordSchema
 from cc_common.data_model.schema.jurisdiction import JurisdictionConfigurationData
 from cc_common.data_model.schema.jurisdiction.record import JurisdictionRecordSchema
@@ -242,18 +242,88 @@ def _ensure_jurisdiction_in_configured_states_if_registration_enabled(
                 jurisdiction=jurisdiction_config.postalAbbreviation,
             )
 
-    @paginated_query
     @logger_inject_kwargs(logger, 'compact')
-    def get_privilege_purchase_options(self, *, compact: str, dynamo_pagination: dict):
+    def get_privilege_purchase_options(self, *, compact: str):
         logger.info('Getting privilege purchase options for compact')
 
-        return self.config.compact_configuration_table.query(
-            Select='ALL_ATTRIBUTES',
-            KeyConditionExpression=Key('pk').eq(f'{compact}#CONFIGURATION'),
-            FilterExpression=Attr('licenseeRegistrationEnabled').eq(True),
-            **dynamo_pagination,
+        # Get all compact configurations (both compact and jurisdiction records)
+        # Use pagination to ensure we get all records
+        all_items = []
+        query_params = {
+            'Select': 'ALL_ATTRIBUTES',
+            'KeyConditionExpression': Key('pk').eq(f'{compact}#CONFIGURATION'),
+        }
+
+        while True:
+            response = self.config.compact_configuration_table.query(**query_params)
+            all_items.extend(response.get('Items', []))
+
+            # Check if there are more records to fetch
+            last_evaluated_key = response.get('LastEvaluatedKey')
+            if not last_evaluated_key:
+                break
+
+            # Set up for next page
+            query_params['ExclusiveStartKey'] = last_evaluated_key
+
+        logger.info(
+            'Retrieved all configuration records',
+            total_items=len(all_items),
         )
 
+        # Get the compact configuration from the response items to access configuredStates
+        compact_config_item = next((item for item in all_items if item['type'] == COMPACT_TYPE), None)
+
+        if compact_config_item and compact_config_item.get('configuredStates'):
+            live_jurisdictions = {
+                state['postalAbbreviation'] for state in compact_config_item['configuredStates'] if state.get('isLive')
+            }
+            logger.info(
+                'Filtering privilege purchase options by live jurisdictions',
+                live_jurisdictions=list(live_jurisdictions),
+            )
+        else:
+            message = (
+                'Compact configuration not found or has no configuredStates when filtering privilege purchase options'
+            )
+            logger.error(
+                message,
+                compact_config_found=compact_config_item is not None,
+                configured_states=compact_config_item.get('configuredStates') if compact_config_item else None,
+            )
+            # in this case, there is nothing to return, so we return an empty list, and let the caller decide to raise
+            # an exception or not.
+            return {'items': []}
+
+        # Filter the response items to only include live jurisdictions
+        filtered_items = []
+        for item in all_items:
+            # Always include compact configuration records
+            if item.get('type') == COMPACT_TYPE:
+                filtered_items.append(item)
+            # Only include jurisdiction records that are live
+            elif item.get('type') == 'jurisdiction':
+                jurisdiction_postal = item.get('postalAbbreviation', '').lower()
+                if jurisdiction_postal in live_jurisdictions:
+                    filtered_items.append(item)
+                else:
+                    logger.debug(
+                        'Filtering out non-live jurisdiction from privilege purchase options',
+                        compact=compact,
+                        jurisdiction=jurisdiction_postal,
+                        is_live=False,
+                    )
+
+        # Return in the expected format for backward compatibility
+        return {
+            'items': filtered_items,
+            'pagination': {
+                'pageSize': len(filtered_items),
+                'prevLastKey': None,
+                'lastKey': None,
+            },
+        }
+
     def set_compact_authorize_net_public_values(self, compact: str, api_login_id: str, public_client_key: str) -> None:
         """
         Set the payment processor public fields (apiLoginId and publicClientKey) for a compact's configuration.
diff --git a/backend/compact-connect/lambdas/python/purchases/handlers/privileges.py b/backend/compact-connect/lambdas/python/purchases/handlers/privileges.py
@@ -78,9 +78,14 @@ def get_purchase_privilege_options(event: dict, context: LambdaContext):  # noqa
 
     options_response = config.compact_configuration_client.get_privilege_purchase_options(
         compact=compact,
-        pagination=event.get('queryStringParameters', {}),
     )
 
+    # In theory, this should never happen as a practitioner can only call this endpoint if at least one state
+    # was enabled for users to register in, but we still check for it here so we can be alerted if it ever occurs.
+    if not options_response.get('items'):
+        logger.error('No privilege options returned for compact.', compact=compact)
+        raise CCInternalException('No privilege options returned for compact.')
+
     # we need to filter out contact information from the response, which is not needed by the client
     serlialized_options = []
     for item in options_response['items']:
diff --git a/backend/compact-connect/lambdas/python/purchases/tests/function/test_handlers/test_privilege_options.py b/backend/compact-connect/lambdas/python/purchases/tests/function/test_handlers/test_privilege_options.py
@@ -1,5 +1,6 @@
 import json
 
+from cc_common.exceptions import CCInternalException
 from moto import mock_aws
 
 from .. import TstFunction
@@ -16,10 +17,13 @@ class TestGetPurchasePrivilegeOptions(TstFunction):
     def _when_testing_provider_user_event_with_custom_claims(self, test_compact=TEST_COMPACT):
         self.test_data_generator.put_default_compact_configuration_in_configuration_table(
             value_overrides={
+                'configuredStates': [
+                    {'postalAbbreviation': 'ky', 'isLive': True}  # Make Kentucky live
+                ],
                 'paymentProcessorPublicFields': {
                     'publicClientKey': MOCK_PUBLIC_CLIENT_KEY,
                     'apiLoginId': MOCK_API_LOGIN_ID,
-                }
+                },
             }
         )
         self.test_data_generator.put_default_jurisdiction_configuration_in_configuration_table()
@@ -36,6 +40,20 @@ def test_get_purchase_privilege_options_returns_expected_jurisdiction_option(sel
 
         event = self._when_testing_provider_user_event_with_custom_claims()
 
+        # Set up compact configuration with mixed live statuses
+        self.test_data_generator.put_default_compact_configuration_in_configuration_table(
+            value_overrides={
+                'configuredStates': [
+                    {'postalAbbreviation': 'ky', 'isLive': True},  # Live
+                    {'postalAbbreviation': 'oh', 'isLive': False},  # Not live
+                ],
+                'paymentProcessorPublicFields': {
+                    'publicClientKey': MOCK_PUBLIC_CLIENT_KEY,
+                    'apiLoginId': MOCK_API_LOGIN_ID,
+                },
+            }
+        )
+
         resp = get_purchase_privilege_options(event, self.mock_context)
 
         self.assertEqual(200, resp['statusCode'])
@@ -111,28 +129,76 @@ def test_get_purchase_privilege_options_returns_400_if_api_call_made_without_pro
 
         self.assertEqual(400, resp['statusCode'])
 
-    def test_get_purchase_privilege_options_returns_empty_list_if_user_compact_do_not_match_any_option_in_db(self):
+    def test_get_purchase_privilege_options_filters_out_jurisdictions_with_licensee_registration_disabled(self):
         from handlers.privileges import get_purchase_privilege_options
 
-        event = self._when_testing_provider_user_event_with_custom_claims(test_compact='some-compact')
+        event = self._when_testing_provider_user_event_with_custom_claims()
+
+        # Set up compact configuration. In this case, because ohio has not elected to go live, it does not show up
+        # in the list of configured states
+        self.test_data_generator.put_default_compact_configuration_in_configuration_table(
+            value_overrides={
+                'configuredStates': [
+                    {'postalAbbreviation': 'ky', 'isLive': True}  # Make Kentucky live
+                ],
+                'paymentProcessorPublicFields': {
+                    'publicClientKey': MOCK_PUBLIC_CLIENT_KEY,
+                    'apiLoginId': MOCK_API_LOGIN_ID,
+                },
+            }
+        )
+
+        # Create jurisdiction with licenseeRegistrationEnabled = True
+        self.test_data_generator.put_default_jurisdiction_configuration_in_configuration_table(
+            value_overrides={
+                'postalAbbreviation': 'ky',
+                'jurisdictionName': 'Kentucky',
+                'licenseeRegistrationEnabled': True,
+            }
+        )
+
+        # Create jurisdiction with licenseeRegistrationEnabled = False
+        self.test_data_generator.put_default_jurisdiction_configuration_in_configuration_table(
+            value_overrides={
+                'postalAbbreviation': 'oh',
+                'jurisdictionName': 'Ohio',
+                'licenseeRegistrationEnabled': False,
+            }
+        )
+
+        self._load_provider_data()
 
         resp = get_purchase_privilege_options(event, self.mock_context)
 
         self.assertEqual(200, resp['statusCode'])
         privilege_options = json.loads(resp['body'])
 
-        self.assertEqual([], privilege_options['items'])
+        # ensure the compact and privilege were returned
+        self.assertEqual(2, len(privilege_options['items']))
 
-    def test_get_purchase_privilege_options_filters_out_jurisdictions_with_licensee_registration_disabled(self):
+        # Filter to only jurisdiction options
+        jurisdiction_options = [option for option in privilege_options['items'] if option['type'] == 'jurisdiction']
+
+        # Should only return the jurisdiction with licenseeRegistrationEnabled = True
+        self.assertEqual(1, len(jurisdiction_options))
+        returned_jurisdiction = jurisdiction_options[0]
+        self.assertEqual('ky', returned_jurisdiction['postalAbbreviation'])
+        self.assertEqual('Kentucky', returned_jurisdiction['jurisdictionName'])
+
+    def test_get_purchase_privilege_options_raises_exception_if_no_live_configured_states(self):
+        """Test that jurisdictions not in configuredStates are filtered out."""
         from handlers.privileges import get_purchase_privilege_options
 
-        # Set up compact configuration
+        event = self._when_testing_provider_user_event_with_custom_claims()
+
+        # Set up compact configuration with empty configuredStates
         self.test_data_generator.put_default_compact_configuration_in_configuration_table(
             value_overrides={
+                'configuredStates': [],  # Empty configuredStates
                 'paymentProcessorPublicFields': {
                     'publicClientKey': MOCK_PUBLIC_CLIENT_KEY,
                     'apiLoginId': MOCK_API_LOGIN_ID,
-                }
+                },
             }
         )
 
@@ -145,32 +211,62 @@ def test_get_purchase_privilege_options_filters_out_jurisdictions_with_licensee_
             }
         )
 
-        # Create jurisdiction with licenseeRegistrationEnabled = False
+        with self.assertRaises(CCInternalException):
+            get_purchase_privilege_options(event, self.mock_context)
+
+    def test_get_purchase_privilege_options_includes_live_jurisdictions_in_configured_states(self):
+        """Test that only jurisdictions with isLive=true are included."""
+        from handlers.privileges import get_purchase_privilege_options
+
+        event = self._when_testing_provider_user_event_with_custom_claims()
+
+        # Set up compact configuration with mixed live statuses
+        self.test_data_generator.put_default_compact_configuration_in_configuration_table(
+            value_overrides={
+                'configuredStates': [
+                    {'postalAbbreviation': 'ky', 'isLive': True},  # Live
+                    {'postalAbbreviation': 'oh', 'isLive': False},  # Not live
+                ],
+                'paymentProcessorPublicFields': {
+                    'publicClientKey': MOCK_PUBLIC_CLIENT_KEY,
+                    'apiLoginId': MOCK_API_LOGIN_ID,
+                },
+            }
+        )
+
+        # Create both jurisdictions with licenseeRegistrationEnabled = True
+        self.test_data_generator.put_default_jurisdiction_configuration_in_configuration_table(
+            value_overrides={
+                'postalAbbreviation': 'ky',
+                'jurisdictionName': 'Kentucky',
+                'licenseeRegistrationEnabled': True,
+            }
+        )
+
         self.test_data_generator.put_default_jurisdiction_configuration_in_configuration_table(
             value_overrides={
                 'postalAbbreviation': 'oh',
                 'jurisdictionName': 'Ohio',
-                'licenseeRegistrationEnabled': False,
+                'licenseeRegistrationEnabled': True,
             }
         )
 
-        self._load_provider_data()
-
-        event = self._when_testing_provider_user_event_with_custom_claims()
-
         resp = get_purchase_privilege_options(event, self.mock_context)
 
         self.assertEqual(200, resp['statusCode'])
         privilege_options = json.loads(resp['body'])
 
-        # ensure the compact and privilege were returned
+        # Should return compact option + 1 live jurisdiction
         self.assertEqual(2, len(privilege_options['items']))
 
-        # Filter to only jurisdiction options
+        # Verify compact option and one jurisdiction option are returned
+        compact_options = [option for option in privilege_options['items'] if option['type'] == 'compact']
         jurisdiction_options = [option for option in privilege_options['items'] if option['type'] == 'jurisdiction']
 
-        # Should only return the jurisdiction with licenseeRegistrationEnabled = True
+        self.assertEqual(1, len(compact_options))
         self.assertEqual(1, len(jurisdiction_options))
+
+        # Verify only the live jurisdiction (Kentucky) is returned
         returned_jurisdiction = jurisdiction_options[0]
         self.assertEqual('ky', returned_jurisdiction['postalAbbreviation'])
         self.assertEqual('Kentucky', returned_jurisdiction['jurisdictionName'])
