first commit

backend/app/services/payments/gateway.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+import hashlib
+import hmac
+import secrets
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+from app.core.config import Settings, get_settings
+
+
+@dataclass(frozen=True)
+class ProviderOrder:
+    provider_order_id: str
+    amount_paise: int
+    currency: str
+
+
+@dataclass(frozen=True)
+class PaymentVerification:
+    provider_order_id: str
+    provider_payment_id: str
+    amount_paise: int
+    currency: str
+
+
+class PaymentGateway(ABC):
+    @property
+    @abstractmethod
+    def provider_name(self) -> str: ...
+
+    @property
+    @abstractmethod
+    def public_key_id(self) -> str: ...
+
+    @abstractmethod
+    def create_provider_order(
+        self,
+        *,
+        amount_paise: int,
+        currency: str,
+        receipt: str,
+        notes: dict[str, str],
+    ) -> ProviderOrder: ...
+
+    @abstractmethod
+    def verify_checkout_signature(
+        self,
+        *,
+        provider_order_id: str,
+        provider_payment_id: str,
+        signature: str,
+    ) -> None: ...
+
+    @abstractmethod
+    def verify_webhook_signature(self, body: bytes, signature: str | None) -> None: ...
+
+    @abstractmethod
+    def parse_webhook_payment(self, payload: dict) -> PaymentVerification | None: ...
+
+
+class MockPaymentGateway(PaymentGateway):
+    """Local/test gateway — signatures derived server-side only (never exposed to clients)."""
+
+    def __init__(self, settings: Settings) -> None:
+        self._settings = settings
+        self._secret = settings.payment_mock_secret
+
+    @property
+    def provider_name(self) -> str:
+        return "mock"
+
+    @property
+    def public_key_id(self) -> str:
+        return "mock_public_key"
+
+    def create_provider_order(
+        self,
+        *,
+        amount_paise: int,
+        currency: str,
+        receipt: str,
+        notes: dict[str, str],
+    ) -> ProviderOrder:
+        token = secrets.token_hex(6)
+        return ProviderOrder(
+            provider_order_id=f"mock_order_{receipt}_{token}",
+            amount_paise=amount_paise,
+            currency=currency,
+        )
+
+    def _expected_signature(self, provider_order_id: str, provider_payment_id: str) -> str:
+        message = f"{provider_order_id}|{provider_payment_id}".encode()
+        return hmac.new(self._secret.encode(), message, hashlib.sha256).hexdigest()
+
+    def verify_checkout_signature(
+        self,
+        *,
+        provider_order_id: str,
+        provider_payment_id: str,
+        signature: str,
+    ) -> None:
+        expected = self._expected_signature(provider_order_id, provider_payment_id)
+        if not hmac.compare_digest(expected, signature):
+            raise ValueError("Invalid payment signature")
+
+    def verify_webhook_signature(self, body: bytes, signature: str | None) -> None:
+        if not signature:
+            raise ValueError("Missing webhook signature")
+        expected = hmac.new(self._secret.encode(), body, hashlib.sha256).hexdigest()
+        if not hmac.compare_digest(expected, signature):
+            raise ValueError("Invalid webhook signature")
+
+    def parse_webhook_payment(self, payload: dict) -> PaymentVerification | None:
+        event = payload.get("event")
+        if event != "payment.captured":
+            return None
+        entity = payload.get("payload", {}).get("payment", {}).get("entity", {})
+        if not entity:
+            return None
+        return PaymentVerification(
+            provider_order_id=entity.get("order_id", ""),
+            provider_payment_id=entity.get("id", ""),
+            amount_paise=int(entity.get("amount", 0)),
+            currency=entity.get("currency", "INR"),
+        )
+
+    def build_mock_checkout_signature(self, provider_order_id: str, provider_payment_id: str) -> str:
+        return self._expected_signature(provider_order_id, provider_payment_id)
+
+
+class RazorpayPaymentGateway(PaymentGateway):
+    def __init__(self, settings: Settings) -> None:
+        if not settings.razorpay_key_id or not settings.razorpay_key_secret:
+            raise RuntimeError("Razorpay credentials are not configured")
+        import razorpay
+
+        self._client = razorpay.Client(auth=(settings.razorpay_key_id, settings.razorpay_key_secret))
+        self._key_id = settings.razorpay_key_id
+        self._webhook_secret = settings.razorpay_webhook_secret or ""
+
+    @property
+    def provider_name(self) -> str:
+        return "razorpay"
+
+    @property
+    def public_key_id(self) -> str:
+        return self._key_id
+
+    def create_provider_order(
+        self,
+        *,
+        amount_paise: int,
+        currency: str,
+        receipt: str,
+        notes: dict[str, str],
+    ) -> ProviderOrder:
+        data = self._client.order.create(
+            {
+                "amount": amount_paise,
+                "currency": currency,
+                "receipt": receipt,
+                "notes": notes,
+            }
+        )
+        return ProviderOrder(
+            provider_order_id=data["id"],
+            amount_paise=int(data["amount"]),
+            currency=data["currency"],
+        )
+
+    def verify_checkout_signature(
+        self,
+        *,
+        provider_order_id: str,
+        provider_payment_id: str,
+        signature: str,
+    ) -> None:
+        self._client.utility.verify_payment_signature(
+            {
+                "razorpay_order_id": provider_order_id,
+                "razorpay_payment_id": provider_payment_id,
+                "razorpay_signature": signature,
+            }
+        )
+
+    def verify_webhook_signature(self, body: bytes, signature: str | None) -> None:
+        if not self._webhook_secret:
+            raise RuntimeError("RAZORPAY_WEBHOOK_SECRET is not configured")
+        if not signature:
+            raise ValueError("Missing webhook signature")
+        self._client.utility.verify_webhook_signature(body.decode(), signature, self._webhook_secret)
+
+    def parse_webhook_payment(self, payload: dict) -> PaymentVerification | None:
+        event = payload.get("event")
+        if event not in ("payment.captured", "order.paid"):
+            return None
+        payment_entity = payload.get("payload", {}).get("payment", {}).get("entity")
+        if not payment_entity and event == "order.paid":
+            payment_entity = payload.get("payload", {}).get("order", {}).get("entity")
+        if not payment_entity:
+            return None
+        order_id = payment_entity.get("order_id") or payment_entity.get("id")
+        payment_id = payment_entity.get("id") if event == "payment.captured" else payment_entity.get("payment_id")
+        if not order_id or not payment_id:
+            return None
+        return PaymentVerification(
+            provider_order_id=order_id,
+            provider_payment_id=payment_id,
+            amount_paise=int(payment_entity.get("amount", 0)),
+            currency=payment_entity.get("currency", "INR"),
+        )
+
+
+def get_payment_gateway(settings: Settings | None = None) -> PaymentGateway:
+    settings = settings or get_settings()
+    mode = settings.payment_provider.lower()
+    if mode == "razorpay":
+        return RazorpayPaymentGateway(settings)
+    return MockPaymentGateway(settings)