Fix/sprint 26 hotfixes (#914)

landonshumway-ia · web-flow · commit 1a7951ca1e89 · 2025-07-08T11:41:46.000-04: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
@@ -99,15 +99,48 @@ def get_compact_configuration(self, compact: str) -> CompactConfigurationData:
 
     def save_compact_configuration(self, compact_configuration: CompactConfigurationData) -> None:
         """
-        Save the compact configuration.
+        Save the compact configuration, preserving existing fields like paymentProcessorPublicFields.
+        If a record exists, it merges the new values with the existing record to preserve all fields.
 
         :param compact_configuration: The compact configuration data
         """
         logger.info('Saving compact configuration', compactAbbr=compact_configuration.compactAbbr)
 
-        serialized_compact = compact_configuration.serialize_to_database_record()
-
-        self.config.compact_configuration_table.put_item(Item=serialized_compact)
+        try:
+            existing_compact_config = self.get_compact_configuration(compact_configuration.compactAbbr)
+        except CCNotFoundException:
+            logger.info('Existing compact configuration not found.', compact=compact_configuration.compactAbbr)
+            existing_compact_config = None
+
+        if existing_compact_config:
+            # Record exists - merge with existing data to preserve fields like paymentProcessorPublicFields
+            logger.info('Updating existing compact configuration record', compactAbbr=compact_configuration.compactAbbr)
+
+            # Load the existing record into a data class to get the existing data
+            existing_data = existing_compact_config.to_dict()
+
+            # Get the new data
+            new_data = compact_configuration.to_dict()
+
+            # Merge the data - new values override existing ones, but existing fields not in new_data are preserved
+            merged_data = existing_data.copy()
+            merged_data.update(new_data)
+
+            # Handle the special case where transactionFeeConfiguration should be removed
+            # If the new configuration doesn't have transactionFeeConfiguration, remove it from merged data
+            if 'transactionFeeConfiguration' not in new_data and 'transactionFeeConfiguration' in merged_data:
+                del merged_data['transactionFeeConfiguration']
+
+            # Create a new CompactConfigurationData with the merged data
+            merged_config = CompactConfigurationData.create_new(merged_data)
+            final_serialized = merged_config.serialize_to_database_record()
+        else:
+            # First time creation - use the new data directly
+            logger.info('Creating new compact configuration record', compactAbbr=compact_configuration.compactAbbr)
+            final_serialized = compact_configuration.serialize_to_database_record()
+
+        # Use put_item to save the final record
+        self.config.compact_configuration_table.put_item(Item=final_serialized)
 
     def get_active_compact_jurisdictions(self, compact: str) -> list[dict]:
         """
diff --git a/backend/compact-connect/lambdas/python/common/cc_common/data_model/schema/common.py b/backend/compact-connect/lambdas/python/common/cc_common/data_model/schema/common.py
@@ -324,10 +324,13 @@ class ClinicalPrivilegeActionCategory(CCEnum):
     https://www.npdb.hrsa.gov/software/CodeLists.pdf, Tables 41-45
     """
 
+    NON_COMPLIANCE = 'Non-compliance With Requirements'
+    CRIMINAL_CONVICTION = 'Criminal Conviction or Adjudication'
+    CONFIDENTIALITY_VIOLATION = 'Confidentiality, Consent or Disclosure Violations'
+    MISCONDUCT_ABUSE = 'Misconduct or Abuse'
     FRAUD = 'Fraud, Deception, or Misrepresentation'
     UNSAFE_PRACTICE = 'Unsafe Practice or Substandard Care'
     IMPROPER_SUPERVISION = 'Improper Supervision or Allowing Unlicensed Practice'
-    IMPROPER_MEDICATION = 'Improper Prescribing, Dispensing, Administering Medication/Drug Violation'
     OTHER = 'Other'
 
 
diff --git a/backend/compact-connect/lambdas/python/common/cc_common/data_model/schema/compact/__init__.py b/backend/compact-connect/lambdas/python/common/cc_common/data_model/schema/compact/__init__.py
@@ -130,3 +130,7 @@ def compactSummaryReportNotificationEmails(self) -> list[str]:
     @property
     def licenseeRegistrationEnabled(self) -> bool:
         return self._data.get('licenseeRegistrationEnabled', False)
+
+    @property
+    def paymentProcessorPublicFields(self) -> dict | None:
+        return self._data.get('paymentProcessorPublicFields')
diff --git a/backend/compact-connect/lambdas/python/compact-configuration/handlers/compact_configuration.py b/backend/compact-connect/lambdas/python/compact-configuration/handlers/compact_configuration.py
@@ -186,21 +186,44 @@ def _put_compact_configuration(event: dict, context: LambdaContext):  # noqa: AR
         validated_data['compactName'] = compact_name
 
         # Check if licenseeRegistrationEnabled is being changed from true to false
-        if validated_data.get('licenseeRegistrationEnabled') is False:
-            try:
-                existing_config = config.compact_configuration_client.get_compact_configuration(compact=compact)
-                if existing_config.licenseeRegistrationEnabled is True:
-                    logger.info(
-                        'attempt to disable licensee registration after it was enabled.',
-                        compact=compact,
-                        submitting_user_id=submitting_user_id,
-                    )
-                    raise CCInvalidRequestException(
-                        'Once licensee registration has been enabled, it cannot be disabled.'
-                    )
-            except CCNotFoundException:
-                # No existing configuration, so this is the first time setting this field
-                logger.info('No existing configuration, so this is the first time setting this field', compact=compact)
+        try:
+            existing_config = config.compact_configuration_client.get_compact_configuration(compact=compact)
+            if (
+                existing_config.licenseeRegistrationEnabled is True
+                and validated_data.get('licenseeRegistrationEnabled') is False
+            ):
+                logger.info(
+                    'attempt to disable licensee registration after it was enabled.',
+                    compact=compact,
+                    submitting_user_id=submitting_user_id,
+                )
+                raise CCInvalidRequestException('Once licensee registration has been enabled, it cannot be disabled.')
+            if (
+                validated_data.get('licenseeRegistrationEnabled') is True
+                and not existing_config.paymentProcessorPublicFields
+            ):
+                logger.info(
+                    'licensee registration set to live without payment processor credentials.',
+                    compact=compact,
+                    submitting_user_id=submitting_user_id,
+                )
+                raise CCInvalidRequestException(
+                    'Authorize.net credentials not configured for compact. '
+                    'Please upload valid Authorize.net credentials.'
+                )
+        except CCNotFoundException as e:
+            # No existing configuration, so this is the first time setting this field
+            logger.info('No existing configuration, so this is the first time setting this field', compact=compact)
+            if validated_data.get('licenseeRegistrationEnabled') is True:
+                logger.info(
+                    'attempt to enable licensee registration without existing configuration.',
+                    compact=compact,
+                    submitting_user_id=submitting_user_id,
+                )
+                raise CCInvalidRequestException(
+                    'Authorize.net credentials need to be uploaded before the compact can be marked as live. '
+                    'Please submit all configuration values before setting the compact as live.'
+                ) from e
 
         # Handle special case for transaction fee of 0
         if validated_data.get('transactionFeeConfiguration', {}).get('licenseeCharges', {}).get('chargeAmount') == 0:
diff --git a/backend/compact-connect/lambdas/python/compact-configuration/tests/function/test_compact_configuration.py b/backend/compact-connect/lambdas/python/compact-configuration/tests/function/test_compact_configuration.py
@@ -194,10 +194,50 @@ def _when_testing_get_compact_configuration_with_existing_compact_configuration(
         event['pathParameters']['compact'] = compact_config['compactAbbr']
         return event, compact_config
 
+    def _when_testing_put_compact_configuration_with_existing_configuration(
+        self, set_payment_fields: bool = True, transaction_fee_zero: bool = False
+    ):
+        from cc_common.utils import ResponseEncoder
+
+        value_overrides = {}
+        if set_payment_fields:
+            value_overrides.update(
+                {'paymentProcessorPublicFields': {'publicClientKey': 'some-key', 'apiLoginId': 'some-login-id'}}
+            )
+        compact_config = self.test_data_generator.put_default_compact_configuration_in_configuration_table(
+            value_overrides=value_overrides
+        )
+
+        event = generate_test_event('PUT', COMPACT_CONFIGURATION_ENDPOINT_RESOURCE)
+        event['pathParameters']['compact'] = compact_config.compactAbbr
+        # add compact admin scope to the event
+        event['requestContext']['authorizer']['claims']['scope'] = f'{compact_config.compactAbbr}/admin'
+        event['requestContext']['authorizer']['claims']['sub'] = 'some-admin-id'
+
+        # we only allow the following values in the body
+        event['body'] = json.dumps(
+            {
+                'compactCommissionFee': compact_config.compactCommissionFee,
+                'licenseeRegistrationEnabled': compact_config.licenseeRegistrationEnabled,
+                'compactOperationsTeamEmails': compact_config.compactOperationsTeamEmails,
+                'compactAdverseActionsNotificationEmails': compact_config.compactAdverseActionsNotificationEmails,
+                'compactSummaryReportNotificationEmails': compact_config.compactSummaryReportNotificationEmails,
+                'transactionFeeConfiguration': compact_config.transactionFeeConfiguration
+                if not transaction_fee_zero
+                else {
+                    'licenseeCharges': {'chargeAmount': 0.00, 'chargeType': 'FLAT_FEE_PER_PRIVILEGE', 'active': True}
+                },
+            },
+            cls=ResponseEncoder,
+        )
+        return event, compact_config
+
     def _when_testing_put_compact_configuration(self, transaction_fee_zero: bool = False):
         from cc_common.utils import ResponseEncoder
 
-        compact_config = self.test_data_generator.generate_default_compact_configuration()
+        compact_config = self.test_data_generator.generate_default_compact_configuration(
+            value_overrides={'licenseeRegistrationEnabled': False}
+        )
         event = generate_test_event('PUT', COMPACT_CONFIGURATION_ENDPOINT_RESOURCE)
         event['pathParameters']['compact'] = compact_config.compactAbbr
         # add compact admin scope to the event
@@ -302,7 +342,7 @@ def test_put_compact_configuration_rejects_state_admin_with_auth_error(self):
         self.assertEqual(403, response['statusCode'])
         self.assertIn('Access denied', json.loads(response['body'])['message'])
 
-    def test_put_compact_configuration_stores_compact_configuration(self):
+    def test_put_compact_configuration_stores_new_compact_configuration(self):
         """Test putting a compact configuration stores the compact configuration."""
         from cc_common.data_model.schema.compact import CompactConfigurationData
         from handlers.compact_configuration import compact_configuration_api_handler
@@ -322,6 +362,27 @@ def test_put_compact_configuration_stores_compact_configuration(self):
 
         self.assertEqual(compact_config.to_dict(), stored_compact_data.to_dict())
 
+    def test_put_compact_configuration_preserves_payment_processor_fields_when_updating_compact_configuration(self):
+        """Test putting a compact configuration preserves existing fields not set by the request body."""
+        from cc_common.data_model.schema.compact import CompactConfigurationData
+        from handlers.compact_configuration import compact_configuration_api_handler
+
+        event, compact_config = self._when_testing_put_compact_configuration_with_existing_configuration()
+
+        response = compact_configuration_api_handler(event, self.mock_context)
+        self.assertEqual(200, response['statusCode'], msg=json.loads(response['body']))
+
+        # load the record from the configuration table
+        serialized_compact_config = compact_config.serialize_to_database_record()
+        response = self.config.compact_configuration_table.get_item(
+            Key={'pk': serialized_compact_config['pk'], 'sk': serialized_compact_config['sk']}
+        )
+
+        stored_compact_data = CompactConfigurationData.from_database_record(response['Item'])
+        # the compact_config variable has the 'paymentProcessorPublicFields' field, which we expect to also be
+        # present in the stored_compact_data
+        self.assertEqual(compact_config.to_dict(), stored_compact_data.to_dict())
+
     def test_put_compact_configuration_removes_transaction_fee_when_zero(self):
         """Test that when a transaction fee of 0 is provided, the transaction fee configuration is removed."""
         from cc_common.data_model.schema.compact import CompactConfigurationData
@@ -348,26 +409,60 @@ def test_put_compact_configuration_rejects_disabling_licensee_registration(self)
         from handlers.compact_configuration import compact_configuration_api_handler
 
         # First, create a compact configuration with licenseeRegistrationEnabled=True
-        event, original_config = self._when_testing_put_compact_configuration()
-        # Set licenseeRegistrationEnabled to True in the request body
+        event, _ = self._when_testing_put_compact_configuration_with_existing_configuration()
+
+        # Now attempt to update with licenseeRegistrationEnabled=False
         body = json.loads(event['body'])
-        body['licenseeRegistrationEnabled'] = True
+        body['licenseeRegistrationEnabled'] = False
         event['body'] = json.dumps(body)
 
-        # Submit the configuration
-        compact_configuration_api_handler(event, self.mock_context)
+        # Should be rejected with a 400 error
+        response = compact_configuration_api_handler(event, self.mock_context)
+        self.assertEqual(400, response['statusCode'])
+        response_body = json.loads(response['body'])
+        self.assertIn('Once licensee registration has been enabled, it cannot be disabled', response_body['message'])
 
-        # Now attempt to update with licenseeRegistrationEnabled=False
+    def test_put_compact_configuration_rejects_enabling_licensee_registration_without_payment_credentials(self):
+        """Test that a compact configuration update is rejected if trying to enable licensee registration without payment processor credentials."""
+        from handlers.compact_configuration import compact_configuration_api_handler
+
+        # Attempt to enable licensee registration without any existing configuration (no payment credentials)
         event, _ = self._when_testing_put_compact_configuration()
         body = json.loads(event['body'])
-        body['licenseeRegistrationEnabled'] = False
+        body['licenseeRegistrationEnabled'] = True
         event['body'] = json.dumps(body)
 
         # Should be rejected with a 400 error
         response = compact_configuration_api_handler(event, self.mock_context)
         self.assertEqual(400, response['statusCode'])
         response_body = json.loads(response['body'])
-        self.assertIn('Once licensee registration has been enabled, it cannot be disabled', response_body['message'])
+        self.assertIn(
+            'Authorize.net credentials need to be uploaded before the compact can be marked as live.',
+            response_body['message'],
+        )
+
+    def test_put_compact_configuration_rejects_enabling_licensee_registration_with_existing_config_without_payment_credentials(
+        self,
+    ):
+        """Test that a compact configuration update is rejected if trying to enable licensee registration when existing config has no payment credentials."""
+        from handlers.compact_configuration import compact_configuration_api_handler
+
+        # First, create a basic compact configuration without payment credentials
+        event, _ = self._when_testing_put_compact_configuration_with_existing_configuration(set_payment_fields=False)
+
+        # Now attempt to enable licensee registration without payment credentials
+        body = json.loads(event['body'])
+        body['licenseeRegistrationEnabled'] = True
+        event['body'] = json.dumps(body)
+
+        # Should be rejected with a 400 error
+        response = compact_configuration_api_handler(event, self.mock_context)
+        self.assertEqual(400, response['statusCode'])
+        response_body = json.loads(response['body'])
+        self.assertIn(
+            'Authorize.net credentials not configured for compact. Please upload valid Authorize.net credentials.',
+            response_body['message'],
+        )
 
 
 TEST_MILITARY_RATE = Decimal('40.00')
