fix: cache decorators and invoicing

Author: kayprogrammer

apps/api.py

@@ -74,9 +74,9 @@
     docs_url="/",
     throttle=[
         # Anonymous users: 5000 requests per minute
-        AnonRateThrottle("5000/m"),
+        AnonRateThrottle("10000/m"),
         # Authenticated users: 10000 requests per minute
-        AuthRateThrottle("10000/m"),
+        AuthRateThrottle("20000/m"),
     ],
 )
 

apps/common/cache/decorators.py

@@ -74,11 +74,16 @@ async def cached_run(request, **kw):
                     try:
                         if operation.auth_callbacks:
                             for auth_callback in operation.auth_callbacks:
-                                auth_result = await auth_callback(request)
-                                if auth_result:
-                                    user_id = str(auth_result.id)
-                                    request.auth = auth_result
-                                    break
+                                try:
+                                    if callable(auth_callback):
+                                        auth_result = await auth_callback(request)
+                                        if auth_result:
+                                            user_id = str(auth_result.id)
+                                            request.auth = auth_result
+                                            break
+                                except TypeError:
+                                    # auth_callback is None or not awaitable, skip
+                                    pass
                         elif hasattr(request, "auth") and request.auth:
                             user_id = str(request.auth.id)
                     except RequestError as e:
@@ -161,11 +166,16 @@ def cached_run(request, **kw):
                     try:
                         if operation.auth_callbacks:
                             for auth_callback in operation.auth_callbacks:
-                                auth_result = auth_callback(request)
-                                if auth_result:
-                                    user_id = str(auth_result.id)
-                                    request.auth = auth_result
-                                    break
+                                try:
+                                    if callable(auth_callback):
+                                        auth_result = auth_callback(request)
+                                        if auth_result:
+                                            user_id = str(auth_result.id)
+                                            request.auth = auth_result
+                                            break
+                                except TypeError:
+                                    # auth_callback is None or not callable, skip
+                                    pass
                         elif hasattr(request, "auth") and request.auth:
                             user_id = str(request.auth.id)
                     except RequestError as e:

apps/payments/emails.py

@@ -0,0 +1,98 @@
+from django.template.loader import render_to_string
+from django.core.mail import EmailMessage
+from django.conf import settings
+import logging
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+
+class PaymentEmailUtil:
+    """Email utilities for payment-related notifications"""
+
+    @classmethod
+    def _send_email(cls, subject, template_name, context, recipient):
+        """Internal helper to render template and send email."""
+        try:
+            message = render_to_string(template_name, context)
+            email_message = EmailMessage(subject=subject, body=message, to=[recipient])
+            email_message.content_subtype = "html"
+            email_message.send()
+            logger.info(f"Email sent successfully to {recipient}: {subject}")
+        except Exception as e:
+            logger.error(f"Email sending failed for {recipient}: {e}", exc_info=True)
+
+    @classmethod
+    def send_invoice_email(cls, invoice):
+        """Send invoice notification to customer"""
+        try:
+            # Get the frontend URL from settings or use default
+            frontend_url = getattr(settings, 'FRONTEND_URL', 'http://localhost:5173')
+            invoice_url = f"{frontend_url}/invoices/{invoice.invoice_number}"
+
+            context = {
+                'customer_name': invoice.customer_name,
+                'merchant_name': invoice.user.full_name,
+                'invoice_number': invoice.invoice_number,
+                'invoice_title': invoice.title,
+                'invoice_description': invoice.description,
+                'issue_date': invoice.issue_date.strftime('%B %d, %Y'),
+                'due_date': invoice.due_date.strftime('%B %d, %Y'),
+                'total_amount': f"{invoice.total_amount:,.2f}",
+                'currency_symbol': invoice.wallet.currency.symbol,
+                'invoice_url': invoice_url,
+                'notes': invoice.notes,
+                'current_year': datetime.now().year,
+            }
+
+            cls._send_email(
+                subject=f"Invoice {invoice.invoice_number} from {invoice.user.full_name}",
+                template_name="invoice-created.html",
+                context=context,
+                recipient=invoice.customer_email,
+            )
+        except Exception as e:
+            logger.error(f"Failed to send invoice email for {invoice.invoice_number}: {e}", exc_info=True)
+
+    @classmethod
+    def send_payment_confirmation_email(cls, payment):
+        """Send payment confirmation email to payer"""
+        try:
+            # Get the frontend URL from settings or use default
+            frontend_url = getattr(settings, 'FRONTEND_URL', 'http://localhost:5173')
+            transaction_url = f"{frontend_url}/transactions"
+
+            # Determine payment description
+            if payment.payment_link:
+                payment_description = payment.payment_link.title
+            elif payment.invoice:
+                payment_description = f"Invoice {payment.invoice.invoice_number}"
+            else:
+                payment_description = "Payment"
+
+            context = {
+                'payer_name': payment.payer_name,
+                'merchant_name': payment.merchant_user.full_name,
+                'reference': payment.reference,
+                'payment_date': payment.created_at.strftime('%B %d, %Y at %I:%M %p'),
+                'payment_description': payment_description,
+                'amount': f"{payment.amount:,.2f}",
+                'fee_amount': f"{payment.fee_amount:,.2f}",
+                'net_amount': f"{payment.net_amount:,.2f}",
+                'currency_symbol': payment.payer_wallet.currency.symbol,
+                'new_balance': f"{payment.payer_wallet.balance:,.2f}",
+                'invoice_number': payment.invoice.invoice_number if payment.invoice else None,
+                'transaction_url': transaction_url,
+                'current_year': datetime.now().year,
+                'terms_url': f"{frontend_url}/terms",
+                'privacy_url': f"{frontend_url}/privacy",
+            }
+
+            cls._send_email(
+                subject=f"Payment Confirmation - {payment.reference}",
+                template_name="payment-confirmation.html",
+                context=context,
+                recipient=payment.payer_email,
+            )
+        except Exception as e:
+            logger.error(f"Failed to send payment confirmation email for {payment.reference}: {e}", exc_info=True)

apps/payments/schemas.py

@@ -164,7 +164,7 @@ class InvoiceListResponseSchema(ResponseSchema):
 
 
 class MakePaymentSchema(BaseSchema):
-    wallet_id: UUID = Field(..., description="Payer's wallet")
+    wallet_id: UUID = Field(..., description="Payer's wallet ID")
     amount: Optional[Decimal] = Field(
         None, gt=0, example=5000.00, description="Amount (required if not fixed)"
     )

apps/payments/services/payment_processor.py

@@ -54,6 +54,7 @@ async def process_payment_link_payment(
                     "amount", f"Amount cannot exceed {link.max_amount}"
                 )
 
+        # Get payer wallet
         payer_wallet = await Wallet.objects.select_related(
             "currency", "user"
         ).aget_or_none(wallet_id=data.wallet_id)
@@ -114,8 +115,8 @@ async def process_payment_link_payment(
         # Create payment record
         payment = await Payment.objects.acreate(
             payment_link=link,
-            payer_name=data.payer_name,
-            payer_email=data.payer_email,
+            payer_name=data.payer_name or f"{payer_wallet.user.first_name} {payer_wallet.user.last_name}",
+            payer_email=data.payer_email or payer_wallet.user.email,
             payer_phone=data.payer_phone,
             payer_wallet=payer_wallet,
             merchant_user=link.user,
@@ -136,6 +137,17 @@ async def process_payment_link_payment(
         await link.asave(
             update_fields=["payments_count", "total_collected", "status", "updated_at"]
         )
+
+        # Send payment confirmation email asynchronously via Celery
+        try:
+            from apps.payments.tasks import send_payment_confirmation_email_async
+            send_payment_confirmation_email_async.delay(str(payment.payment_id))
+        except Exception as e:
+            # Log error but don't fail payment
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.error(f"Failed to queue payment confirmation email: {e}")
+
         return payment
 
     @staticmethod
@@ -230,4 +242,15 @@ async def process_invoice_payment(
         )
 
         await InvoiceManager.mark_invoice_paid(invoice, amount)
+
+        # Send payment confirmation email asynchronously via Celery
+        try:
+            from apps.payments.tasks import send_payment_confirmation_email_async
+            send_payment_confirmation_email_async.delay(str(payment.payment_id))
+        except Exception as e:
+            # Log error but don't fail payment
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.error(f"Failed to queue payment confirmation email: {e}")
+
         return payment

apps/payments/tasks.py

@@ -0,0 +1,75 @@
+"""
+Celery tasks for payments app
+"""
+
+import logging
+from celery import shared_task
+from apps.payments.models import Invoice, Payment
+from apps.payments.emails import PaymentEmailUtil
+
+logger = logging.getLogger(__name__)
+
+
+class PaymentEmailTasks:
+    """Email tasks for payment-related notifications"""
+
+    @staticmethod
+    @shared_task(
+        bind=True,
+        autoretry_for=(Exception,),
+        retry_kwargs={"max_retries": 3, "countdown": 60},
+        name="payments.send_invoice_email",
+        queue="emails",
+    )
+    def send_invoice_email(self, invoice_id: str):
+        """Send invoice notification email to customer"""
+        try:
+            invoice = Invoice.objects.select_related(
+                'user', 'wallet', 'wallet__currency'
+            ).get_or_none(invoice_id=invoice_id)
+
+            if not invoice:
+                logger.error(f"Invoice {invoice_id} not found")
+                return {"status": "failed", "error": "Invoice not found"}
+
+            PaymentEmailUtil.send_invoice_email(invoice)
+            logger.info(f"Invoice email sent for invoice {invoice.invoice_number}")
+            return {"status": "success", "invoice_number": invoice.invoice_number}
+        except Exception as exc:
+            logger.error(f"Invoice email failed: {str(exc)}")
+            raise self.retry(exc=exc)
+
+    @staticmethod
+    @shared_task(
+        bind=True,
+        autoretry_for=(Exception,),
+        retry_kwargs={"max_retries": 3, "countdown": 60},
+        name="payments.send_payment_confirmation_email",
+        queue="emails",
+    )
+    def send_payment_confirmation_email(self, payment_id: str):
+        """Send payment confirmation email to payer"""
+        try:
+            payment = Payment.objects.select_related(
+                'payer_wallet',
+                'payer_wallet__currency',
+                'merchant_user',
+                'payment_link',
+                'invoice'
+            ).get_or_none(payment_id=payment_id)
+
+            if not payment:
+                logger.error(f"Payment {payment_id} not found")
+                return {"status": "failed", "error": "Payment not found"}
+
+            PaymentEmailUtil.send_payment_confirmation_email(payment)
+            logger.info(f"Payment confirmation email sent for payment {payment.reference}")
+            return {"status": "success", "reference": payment.reference}
+        except Exception as exc:
+            logger.error(f"Payment confirmation email failed: {str(exc)}")
+            raise self.retry(exc=exc)
+
+
+# Expose task functions for imports
+send_invoice_email_async = PaymentEmailTasks.send_invoice_email
+send_payment_confirmation_email_async = PaymentEmailTasks.send_payment_confirmation_email

apps/payments/views.py

@@ -1,6 +1,7 @@
 from uuid import UUID
 from typing import Optional
 from ninja import Query, Router
+import logging
 
 from apps.accounts.auth import AuthKycUser
 from apps.common.exceptions import NotFoundError
@@ -24,8 +25,8 @@
 from apps.payments.services.invoice_manager import InvoiceManager
 from apps.payments.services.payment_processor import PaymentProcessor
 from apps.payments.models import Payment, PaymentLinkStatus
-
-
+from .tasks import PaymentEmailTasks
+logger = logging.getLogger(__name__)
 payment_router = Router(tags=["Payments (16)"])
 
 
@@ -113,6 +114,7 @@ async def get_payment_link_public(request, slug: str):
     "/pay/{slug}",
     summary="Make payment via payment link",
     response={201: PaymentDataResponseSchema},
+    auth=AuthKycUser(),
 )
 async def pay_via_link(request, slug: str, data: MakePaymentSchema):
     payment = await PaymentProcessor.process_payment_link_payment(slug, data)
@@ -139,8 +141,16 @@ async def pay_via_link(request, slug: str, data: MakePaymentSchema):
     auth=AuthKycUser(),
 )
 async def create_invoice(request, data: CreateInvoiceSchema):
+
     user = request.auth
     invoice = await InvoiceManager.create_invoice(user, data)
+
+    # Send invoice email to customer asynchronously via Celery
+    try:
+        PaymentEmailTasks.send_invoice_email.delay(str(invoice.invoice_id))
+    except Exception as e:
+        logger.error(f"Failed to queue invoice email: {e}")
+
     invoice = await InvoiceManager.get_invoice(user, invoice.invoice_id)
     return CustomResponse.success("Invoice created successfully", invoice, 201)