24664 - Adding sbc-finance to PAD locking email

jobs/payment-jobs/pyproject.toml

@@ -7,7 +7,7 @@ readme = "README.md"
 
 [tool.poetry.dependencies]
 python = "^3.12"
-pay-api = {git = "https://github.com/seeker25/sbc-pay.git", branch = "25571", subdirectory = "pay-api"}
+pay-api = {git = "https://github.com/rodrigo-barraza/sbc-pay.git", branch = "feature/24664", subdirectory = "pay-api"}
 flask = "^3.0.2"
 flask-sqlalchemy = "^3.1.1"
 sqlalchemy = "^2.0.28"

jobs/payment-jobs/tasks/eft_statement_due_task.py

@@ -30,12 +30,12 @@
 from pay_api.services import NonSufficientFundsService
 from pay_api.services.statement import Statement
 from pay_api.services.statement_settings import StatementSettings as StatementSettingsService
-from pay_api.utils.enums import InvoiceStatus, PaymentMethod, StatementFrequency
+from pay_api.utils.auth_event import AuthEvent, LockAccountDetails
+from pay_api.utils.enums import InvoiceStatus, PaymentMethod, QueueSources, StatementFrequency, SuspensionReasonCodes
 from pay_api.utils.util import current_local_time
 from sentry_sdk import capture_message
 from sqlalchemy import select
 
-from utils.auth_event import AuthEvent
 from utils.enums import StatementNotificationAction
 from utils.mailer import StatementNotificationInfo, publish_payment_notification
 
@@ -160,8 +160,15 @@ def _update_invoice_overdue_status(cls):
 
             # Only publish lock event if it is not already locked
             if payment_account.has_overdue_invoices is None:
-                additional_emails = current_app.config.get("EFT_OVERDUE_NOTIFY_EMAILS")
-                AuthEvent.publish_lock_account_event(payment_account, additional_emails)
+                AuthEvent.publish_lock_account_event(
+                    LockAccountDetails(
+                        pay_account=payment_account,
+                        additional_emails=current_app.config.get("EFT_OVERDUE_NOTIFY_EMAILS"),
+                        payment_method=PaymentMethod.EFT.value,
+                        source=QueueSources.PAY_JOBS.value,
+                        suspension_reason_code=SuspensionReasonCodes.OVERDUE_EFT.value,
+                    )
+                )
 
             # Even if the account is locked, there is a new overdue statement that needs NSF invoices added and
             # set the most recent date for has_overdue_invoices

jobs/payment-jobs/tasks/eft_task.py

@@ -29,6 +29,7 @@
 from pay_api.services.cfs_service import CFSService
 from pay_api.services.eft_service import EftService
 from pay_api.services.invoice import Invoice as InvoiceService
+from pay_api.utils.auth_event import AuthEvent
 from pay_api.utils.enums import (
     CfsAccountStatus,
     EFTCreditInvoiceStatus,
@@ -44,8 +45,6 @@
 from sqlalchemy import func
 from sqlalchemy.orm import lazyload, registry
 
-from utils.auth_event import AuthEvent
-
 
 class EFTTask:  # pylint:disable=too-few-public-methods
     """Task to link electronic funds transfers."""

jobs/payment-jobs/tests/jobs/test_eft_statement_due_task.py

@@ -28,6 +28,7 @@
 from pay_api.models import NonSufficientFunds as NonSufficientFundsModel
 from pay_api.models import StatementInvoices as StatementInvoicesModel
 from pay_api.services import Statement as StatementService
+from pay_api.utils.auth_event import LockAccountDetails
 from pay_api.utils.enums import InvoiceStatus, PaymentMethod, StatementFrequency
 from pay_api.utils.util import current_local_time
 
@@ -132,7 +133,7 @@ def test_send_unpaid_statement_notification(setup, session, test_name, action_on
     summary = StatementService.get_summary(account.auth_account_id, statements[0][0].id)
     total_amount_owing = summary["total_due"]
 
-    with patch("utils.auth_event.AuthEvent.publish_lock_account_event") as mock_auth_event:
+    with patch("pay_api.utils.auth_event.AuthEvent.publish_lock_account_event") as mock_auth_event:
         with patch("tasks.eft_statement_due_task.publish_payment_notification") as mock_mailer:
             with freeze_time(action_on):
                 # Statement due task looks at the month before.
@@ -228,11 +229,24 @@ def test_account_lock(setup, session):
     assert invoices2 is not None
     assert invoices2[0].invoice_id == invoice2.id
 
-    with patch("utils.auth_event.AuthEvent.publish_lock_account_event") as mock_auth_event:
+    with patch("pay_api.utils.auth_event.AuthEvent.publish_lock_account_event") as mock_auth_event:
         with patch("tasks.eft_statement_due_task.publish_payment_notification"):
             EFTStatementDueTask.process_unpaid_statements()
             mock_auth_event.assert_called_once()
-            expected_calls = [call(account1, "")]
+            expected_calls = [
+                call(
+                    LockAccountDetails(
+                        pay_account=account1,
+                        additional_emails="",
+                        payment_method=PaymentMethod.EFT.value,
+                        source="PAY-JOBS",
+                        suspension_reason_code="OVERDUE_EFT",
+                        outstanding_amount=None,
+                        original_amount=None,
+                        amount=None,
+                    )
+                )
+            ]
             mock_auth_event.assert_has_calls(expected_calls, any_order=True)
             assert account1.has_overdue_invoices
             assert statements[0][0].overdue_notification_date
@@ -258,7 +272,7 @@ def test_account_lock(setup, session):
     assert invoices3 is not None
     assert invoices3[0].invoice_id == invoice3.id
 
-    with patch("utils.auth_event.AuthEvent.publish_lock_account_event") as mock_auth_event:
+    with patch("pay_api.utils.auth_event.AuthEvent.publish_lock_account_event") as mock_auth_event:
         with patch("tasks.eft_statement_due_task.publish_payment_notification"):
             EFTStatementDueTask.process_unpaid_statements()
             # Already locked we should not be publishing another event
@@ -315,11 +329,36 @@ def test_multi_account_lock(setup, session):
     assert invoices2 is not None
     assert invoices2[0].invoice_id == invoice2.id
 
-    with patch("utils.auth_event.AuthEvent.publish_lock_account_event") as mock_auth_event:
+    with patch("pay_api.utils.auth_event.AuthEvent.publish_lock_account_event") as mock_auth_event:
         with patch("tasks.eft_statement_due_task.publish_payment_notification"):
             EFTStatementDueTask.process_unpaid_statements()
             mock_auth_event.call_count == 2
-            expected_calls = [call(account1, ""), call(account2, "")]
+            expected_calls = [
+                call(
+                    LockAccountDetails(
+                        pay_account=account1,
+                        additional_emails="",
+                        payment_method=PaymentMethod.EFT.value,
+                        source="PAY-JOBS",
+                        suspension_reason_code="OVERDUE_EFT",
+                        outstanding_amount=None,
+                        original_amount=None,
+                        amount=None,
+                    )
+                ),
+                call(
+                    LockAccountDetails(
+                        pay_account=account2,
+                        additional_emails="",
+                        payment_method=PaymentMethod.EFT.value,
+                        source="PAY-JOBS",
+                        suspension_reason_code="OVERDUE_EFT",
+                        outstanding_amount=None,
+                        original_amount=None,
+                        amount=None,
+                    )
+                ),
+            ]
             mock_auth_event.assert_has_calls(expected_calls, any_order=True)
             assert statements1[0][1].overdue_notification_date
             assert NonSufficientFundsModel.find_by_invoice_id(invoice1.id)
@@ -364,7 +403,7 @@ def test_statement_due_overrides(setup, session, test_name, date_override, actio
     summary = StatementService.get_summary(account.auth_account_id, statements[0][0].id)
     total_amount_owing = summary["total_due"]
 
-    with patch("utils.auth_event.AuthEvent.publish_lock_account_event") as mock_auth_event:
+    with patch("pay_api.utils.auth_event.AuthEvent.publish_lock_account_event") as mock_auth_event:
         with patch("tasks.eft_statement_due_task.publish_payment_notification") as mock_mailer:
             # Statement due task looks at the month before.
             if test_name == "overdue":

jobs/payment-jobs/tests/jobs/test_eft_task.py

@@ -528,7 +528,7 @@ def test_unlock_overdue_accounts(session):
     factory_invoice_reference(invoice_id=invoice_2.id)
     factory_create_eft_credit_invoice_link(invoice_id=invoice_2.id, eft_credit_id=eft_credit.id, amount=10)
 
-    with patch("utils.auth_event.AuthEvent.publish_unlock_account_event") as mock_unlock:
+    with patch("pay_api.utils.auth_event.AuthEvent.publish_unlock_account_event") as mock_unlock:
         EFTTask.link_electronic_funds_transfers_cfs()
         assert payment_account.has_overdue_invoices is None
         mock_unlock.assert_called_once()

jobs/payment-jobs/utils/auth_event.py → pay-api/src/pay_api/utils/auth_event.py

@@ -1,39 +1,65 @@
 """Common code that sends AUTH events."""
 
+from dataclasses import dataclass
+from typing import Any, Optional
+
 from flask import current_app
+from sbc_common_components.utils.enums import QueueMessageTypes
+from sentry_sdk import capture_message
+
 from pay_api.models import PaymentAccount as PaymentAccountModel
 from pay_api.services import gcp_queue_publisher
 from pay_api.services.gcp_queue_publisher import QueueMessage
-from pay_api.utils.enums import PaymentMethod, QueueSources, SuspensionReasonCodes
-from sbc_common_components.utils.enums import QueueMessageTypes
-from sentry_sdk import capture_message
+from pay_api.utils.enums import QueueSources
+
+
+@dataclass
+class LockAccountDetails:
+    """Lock account details."""
+
+    pay_account: Any
+    additional_emails: str = ""
+    payment_method: Optional[str] = None
+    source: Optional[str] = None
+    suspension_reason_code: Optional[str] = None
+    outstanding_amount: Optional[float] = None
+    original_amount: Optional[float] = None
+    amount: Optional[float] = None
 
 
 class AuthEvent:
     """Publishes to the auth-queue as an auth event though PUBSUB, this message gets sent to account-mailer after."""
 
     @staticmethod
-    def publish_lock_account_event(pay_account: PaymentAccountModel, additional_emails=""):
+    def publish_lock_account_event(params: LockAccountDetails):
         """Publish NSF lock account event to the auth queue."""
         try:
-            payload = AuthEvent._create_event_payload(pay_account, additional_emails)
+            lock_payload = {
+                "accountId": params.pay_account.auth_account_id,
+                "paymentMethod": params.payment_method,
+                "suspensionReasonCode": params.suspension_reason_code,
+                "additionalEmails": params.additional_emails,
+                "outstandingAmount": params.outstanding_amount,
+                "originalAmount": params.original_amount,
+                "amount": params.amount,
+            }
             gcp_queue_publisher.publish_to_queue(
                 QueueMessage(
-                    source=QueueSources.PAY_JOBS.value,
+                    source=params.source,
                     message_type=QueueMessageTypes.NSF_LOCK_ACCOUNT.value,
-                    payload=payload,
+                    payload=lock_payload,
                     topic=current_app.config.get("AUTH_EVENT_TOPIC"),
                 )
             )
         except Exception:  # NOQA pylint: disable=broad-except
             current_app.logger.error("Error publishing lock event:", exc_info=True)
             current_app.logger.warning(
                 f"Notification to Queue failed for the Account {
-                                       pay_account.auth_account_id} - {pay_account.name}"
+                    params.pay_account.auth_account_id} - {params.pay_account.name}"
             )
             capture_message(
                 f"Notification to Queue failed for the Account {
-                            pay_account.auth_account_id}, {payload}.",
+                    params.pay_account.auth_account_id}, {lock_payload}.",
                 level="error",
             )
 
@@ -57,19 +83,10 @@ def publish_unlock_account_event(payment_account: PaymentAccountModel):
             current_app.logger.error("Error publishing NSF unlock event:", exc_info=True)
             current_app.logger.warning(
                 f"Notification to Queue failed for the Account {
-                                       payment_account.auth_account_id} - {payment_account.name}"
+                    payment_account.auth_account_id} - {payment_account.name}"
             )
             capture_message(
                 f"Notification to Queue failed for the Account {
-                            payment_account.auth_account_id}, {unlock_payload}.",
+                    payment_account.auth_account_id}, {unlock_payload}.",
                 level="error",
             )
-
-    @staticmethod
-    def _create_event_payload(pay_account, additional_emails=""):
-        return {
-            "accountId": pay_account.auth_account_id,
-            "paymentMethod": PaymentMethod.EFT.value,
-            "suspensionReasonCode": SuspensionReasonCodes.OVERDUE_EFT.value,
-            "additionalEmails": additional_emails,
-        }

pay-queue/devops/vaults.gcp.env

@@ -34,3 +34,4 @@ PAY_CONNECTOR_AUTH="op://relationship/$APP_ENV/pay-api/PAY_CONNECTOR_AUTH"
 EFT_TDI17_LOCATION_ID="op://relationship/$APP_ENV/pay-queue/EFT_TDI17_LOCATION_ID"
 EFT_WIRE_PATTERNS="op://relationship/$APP_ENV/pay-queue/EFT_WIRE_PATTERNS"
 EFT_PATTERNS="op://relationship/$APP_ENV/pay-queue/EFT_PATTERNS"
+PAD_NSF_NOTIFY_EMAILS="op://relationship/$APP_ENV/pay-queue/PAD_NSF_NOTIFY_EMAILS"