Fix: Add Polar.sh Support (closes #46)

Author: tcuong53-cell

src/services/billing_service.py

@@ -0,0 +1,292 @@
+import os
+import logging
+from abc import ABC, abstractmethod
+
+# Configure basic logging for the service
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# In a real application, you would import actual SDKs like 'stripe' and 'polar'
+# import stripe
+# import polar_sdk_client # Assuming a hypothetical Polar.sh SDK (e.g., polar.api)
+
+# --- Constants for Provider Names ---
+PROVIDER_STRIPE = "stripe"
+PROVIDER_POLAR = "polar"
+
+# --- Abstract Base Class for Payment Providers ---
+class BasePaymentProvider(ABC):
+    """
+    Abstract base class defining the interface for all payment providers.
+    Ensures a consistent API across different payment gateways.
+    """
+    def __init__(self, api_key: str, **kwargs):
+        self.api_key = api_key
+        if not self.api_key:
+            raise ValueError(f"{self.__class__.__name__} API key not provided.")
+        self._initialize_client(**kwargs)
+
+    @abstractmethod
+    def _initialize_client(self, **kwargs):
+        """
+        Initializes the specific SDK client for the provider.
+        """
+        pass
+
+    @abstractmethod
+    def create_checkout_session(self, item_id: str, amount: int, currency: str, success_url: str, cancel_url: str, metadata: dict = None, **kwargs) -> dict:
+        """
+        Creates a checkout session for the specified payment provider.
+        Returns a dictionary containing session details, typically including a URL for redirection.
+        """
+        pass
+
+    @abstractmethod
+    def handle_webhook(self, payload: dict, signature: str = None) -> dict:
+        """
+        Handles incoming webhooks from the payment provider.
+        Returns a dictionary indicating the processing status.
+        """
+        pass
+
+# --- Stripe Payment Provider Implementation ---
+class StripeProvider(BasePaymentProvider):
+    """
+    Concrete implementation for the Stripe payment gateway.
+    """
+    def _initialize_client(self, **kwargs):
+        # In a real scenario, uncomment this line:
+        # stripe.api_key = self.api_key
+        logger.info(f"Stripe service initialized (key: {self.api_key[:4]}...).")
+
+    def create_checkout_session(self, item_id: str, amount: int, currency: str, success_url: str, cancel_url: str, metadata: dict = None, **kwargs) -> dict:
+        """
+        Creates a Stripe Checkout Session.
+        """
+        # This is a dummy implementation. In a real scenario, you would use the Stripe SDK:
+        # try:
+        #     checkout_session = stripe.checkout.Session.create(
+        #         line_items=[
+        #             {
+        #                 'price_data': {
+        #                     'currency': currency,
+        #                     'product_data': {
+        #                         'name': f'Product {item_id}',
+        #                     },
+        #                     'unit_amount': amount,
+        #                 },
+        #                 'quantity': 1,
+        #             }
+        #         ],
+        #         mode='payment', # or 'subscription'
+        #         success_url=success_url,
+        #         cancel_url=cancel_url,
+        #         metadata=metadata,
+        #         **kwargs # Allows passing additional Stripe-specific parameters
+        #     )
+        #     return {"provider": PROVIDER_STRIPE, "session_id": checkout_session.id, "url": checkout_session.url}
+        # except stripe.error.StripeError as e:
+        #     logger.error(f"Error creating Stripe checkout session: {e}", exc_info=True)
+        #     raise
+
+        logger.info(f"DUMMY: Creating Stripe checkout session for item {item_id}, amount {amount} {currency}")
+        return {
+            "provider": PROVIDER_STRIPE,
+            "session_id": f"cs_stripe_{item_id}_{amount}_{os.urandom(4).hex()}",
+            "url": f"https://checkout.stripe.com/pay/{item_id}?session_id={os.urandom(8).hex()}", # Placeholder URL
+            "metadata": metadata
+        }
+
+    def handle_webhook(self, payload: dict, signature: str = None) -> dict:
+        """
+        Handles Stripe webhook events.
+        """
+        # In a real scenario, you would verify the signature and process the event:
+        # try:
+        #     webhook_secret = os.environ.get("STRIPE_WEBHOOK_SECRET") # Or from config
+        #     if not webhook_secret:
+        #         raise ValueError("Stripe webhook secret not configured.")
+        #
+        #     event = stripe.Webhook.construct_event(
+        #         payload, signature, webhook_secret
+        #     )
+        #     # Process event.type (e.g., 'checkout.session.completed', 'payment_intent.succeeded')
+        #     logger.info(f"Stripe webhook received: {event['type']} (ID: {event['id']})")
+        #     return {"status": "success", "provider": PROVIDER_STRIPE, "event_id": event['id'], "type": event['type']}
+        # except ValueError as e:
+        #     logger.error(f"Invalid payload for Stripe webhook: {e}", exc_info=True)
+        #     raise
+        # except stripe.error.SignatureVerificationError as e:
+        #     logger.error(f"Invalid signature for Stripe webhook: {e}", exc_info=True)
+        #     raise
+        # except Exception as e:
+        #     logger.error(f"Unhandled error processing Stripe webhook: {e}", exc_info=True)
+        #     raise
+
+        logger.info(f"DUMMY: Handling Stripe webhook. Event type: {payload.get('type', 'unknown')}, ID: {payload.get('id', 'N/A')}")
+        return {"status": "success", "provider": PROVIDER_STRIPE, "event_id": payload.get("id", "unknown"), "type": payload.get("type", "unknown_stripe_event")}
+
+# --- Polar.sh Payment Provider Implementation ---
+class PolarProvider(BasePaymentProvider):
+    """
+    Concrete implementation for the Polar.sh pledge/payment gateway.
+    Polar.sh's model is typically more focused on pledges and funding open-source projects.
+    """
+    def __init__(self, api_key: str, organization_id: str, **kwargs):
+        self.organization_id = organization_id
+        if not self.organization_id:
+            raise ValueError("Polar.sh organization ID not provided.")
+        super().__init__(api_key, **kwargs)
+
+    def _initialize_client(self, **kwargs):
+        # In a real scenario, uncomment this line:
+        # self.polar_client = polar_sdk_client.PolarClient(api_key=self.api_key)
+        logger.info(f"Polar.sh service initialized (key: {self.api_key[:4]}..., org_id: {self.organization_id}).")
+
+    def create_checkout_session(self, item_id: str, amount: int, currency: str, success_url: str, cancel_url: str, metadata: dict = None, **kwargs) -> dict:
+        """
+        Creates a Polar.sh checkout session (e.g., a pledge link or an invoice).
+        Note: Polar.sh's API might have specific requirements for `item_id` (e.g., an issue ID or a campaign ID).
+        """
+        # This is a dummy implementation. In a real scenario, you would use the Polar.sh SDK:
+        # try:
+        #     # The exact API call would depend on whether you're creating a pledge,
+        #     # a one-time invoice, or linking to a specific funding goal.
+        #     # Example for a hypothetical pledge creation:
+        #     pledge_link = self.polar_client.pledges.create(
+        #         organization_id=self.organization_id,
+        #         amount=amount,
+        #         currency=currency,
+        #         success_url=success_url,
+        #         cancel_url=cancel_url,
+        #         description=f"Pledge for {item_id}", # item_id might map to a description
+        #         metadata=metadata,
+        #         **kwargs # Allows passing additional Polar.sh-specific parameters
+        #     )
+        #     return {"provider": PROVIDER_POLAR, "session_id": pledge_link.id, "url": pledge_link.url}
+        # except polar_sdk_client.PolarError as e:
+        #     logger.error(f"Error creating Polar.sh checkout session: {e}", exc_info=True)
+        #     raise
+
+        logger.info(f"DUMMY: Creating Polar.sh checkout session for item {item_id}, amount {amount} {currency}")
+        return {
+            "provider": PROVIDER_POLAR,
+            "session_id": f"cs_polar_{item_id}_{amount}_{os.urandom(4).hex()}",
+            "url": f"https://polar.sh/checkout/{item_id}?amount={amount}&currency={currency}&redirect={success_url}", # Placeholder URL
+            "metadata": metadata
+        }
+
+    def handle_webhook(self, payload: dict, signature: str = None) -> dict:
+        """
+        Handles Polar.sh webhook events.
+        """
+        # In a real scenario, you would verify the signature and process the event:
+        # try:
+        #     webhook_secret = os.environ.get("POLAR_WEBHOOK_SECRET") # Or from config
+        #     if not webhook_secret:
+        #         raise ValueError("Polar.sh webhook secret not configured.")
+        #
+        #     # Polar.sh webhook verification might be similar to Stripe or have its own method
+        #     # event = self.polar_client.webhooks.verify_and_parse(payload, signature, webhook_secret)
+        #     # Process event.type (e.g., 'pledge.created', 'pledge.paid', 'issue.funded')
+        #     event_type = payload.get('type', 'unknown')
+        #     event_id = payload.get('id', 'N/A')
+        #     logger.info(f"Polar.sh webhook received: {event_type} (ID: {event_id})")
+        #     return {"status": "success", "provider": PROVIDER_POLAR, "event_id": event_id, "type": event_type}
+        # except Exception as e: # Catch specific Polar.sh webhook errors (e.g., polar_sdk_client.PolarWebhookError)
+        #     logger.error(f"Error handling Polar.sh webhook: {e}", exc_info=True)
+        #     raise
+
+        logger.info(f"DUMMY: Handling Polar.sh webhook. Event type: {payload.get('type', 'unknown')}, ID: {payload.get('id', 'N/A')}")
+        return {"status": "success", "provider": PROVIDER_POLAR, "event_id": payload.get("id", "unknown"), "type": payload.get("type", "unknown_polar_event")}
+
+# --- Billing Service Orchestrator ---
+class BillingService:
+    """
+    Orchestrates various payment providers, offering a unified interface for billing operations.
+    This service acts as a facade, delegating requests to the appropriate provider.
+    """
+    def __init__(self, api_config: dict):
+        """
+        Initializes the BillingService with API configurations for various providers.
+        api_config structure:
+        {
+            "stripe": {"api_key": "sk_test_...", "webhook_secret": "whsec_..."},
+            "polar": {"api_key": "ps_test_...", "organization_id": "org_xyz", "webhook_secret": "whsec_..."}
+        }
+        """
+        self.providers = {}
+
+        # Initialize Stripe provider
+        stripe_config = api_config.get(PROVIDER_STRIPE, {})
+        stripe_api_key = stripe_config.get("api_key")
+        if stripe_api_key:
+            try:
+                self.providers[PROVIDER_STRIPE] = StripeProvider(api_key=stripe_api_key)
+            except ValueError as e:
+                logger.warning(f"Stripe initialization failed: {e}")
+        else:
+            logger.warning("Stripe API key not provided. Stripe features may be disabled.")
+
+        # Initialize Polar.sh provider
+        polar_config = api_config.get(PROVIDER_POLAR, {})
+        polar_api_key = polar_config.get("api_key")
+        polar_organization_id = polar_config.get("organization_id")
+        if polar_api_key and polar_organization_id:
+            try:
+                self.providers[PROVIDER_POLAR] = PolarProvider(api_key=polar_api_key, organization_id=polar_organization_id)
+            except ValueError as e:
+                logger.warning(f"Polar.sh initialization failed: {e}")
+        else:
+            logger.warning("Polar.sh API key or organization ID not provided. Polar.sh features may be disabled.")
+
+        if not self.providers:
+            logger.error("No payment providers were successfully initialized. Billing service will be non-functional.")
+
+    def _get_provider(self, provider_name: str) -> BasePaymentProvider:
+        """
+        Retrieves the initialized provider instance or raises an error.
+        """
+        provider_instance = self.providers.get(provider_name)
+        if not provider_instance:
+            raise ValueError(f"Unsupported or uninitialized payment provider: {provider_name}")
+        return provider_instance
+
+    def create_checkout_session(self, provider: str, item_id: str, amount: int, currency: str, success_url: str, cancel_url: str, metadata: dict = None, **kwargs) -> dict:
+        """
+        Creates a checkout session for the specified payment provider.
+        Delegates the call to the appropriate provider implementation.
+
+        Args:
+            provider (str): The payment provider ('stripe' or 'polar').
+            item_id (str): Identifier for the item being purchased/pledged.
+            amount (int): The amount to charge (in cents for Stripe, or smallest currency unit).
+            currency (str): The currency code (e.g., 'usd').
+            success_url (str): URL to redirect to after successful payment.
+            cancel_url (str): URL to redirect to after cancelled payment.
+            metadata (dict, optional): Additional metadata to attach to the session.
+            **kwargs: Provider-specific parameters.
+
+        Returns:
+            dict: A dictionary containing session details, typically including a URL for redirection.
+        """
+        provider_instance = self._get_provider(provider)
+        logger.info(f"Creating checkout session via {provider} for item {item_id}...")
+        return provider_instance.create_checkout_session(item_id, amount, currency, success_url, cancel_url, metadata, **kwargs)
+
+    def handle_webhook(self, provider: str, payload: dict, signature: str = None) -> dict:
+        """
+        Handles incoming webhooks from payment providers.
+        Delegates the call to the appropriate provider implementation.
+
+        Args:
+            provider (str): The payment provider ('stripe' or 'polar').
+            payload (dict): The raw webhook payload.
+            signature (str, optional): The webhook signature for verification.
+
+        Returns:
+            dict: A dictionary indicating the processing status.
+        """
+        provider_instance = self._get_provider(provider)
+        logger.info(f"Handling webhook for {provider}. Event type: {payload.get('type', 'unknown')}")
+        return provider_instance.handle_webhook(payload, signature)