Payment Processing: Stripe, Adyen, and Marketplaces

import stripe
from stripe import StripeClient

class StripePayments:
    """
    Stripe payment integration
    """
    
    def __init__(self, api_key: str):
        stripe.api_key = api_key
        self.webhook_secret = os.getenv("STRIPE_WEBHOOK_SECRET")
    
    def create_customer(self, email: str, name: str, metadata: dict = None):
        """
        Create a Stripe customer
        """
        customer = stripe.Customer.create(
            email=email,
            name=name,
            metadata=metadata or {}
        )
        
        return {
            "customer_id": customer.id,
            "email": customer.email,
            "created": customer.created
        }
    
    def create_payment_intent(
        self,
        amount: int,
        currency: str,
        customer_id: str = None,
        metadata: dict = None,
        capture_method: str = "automatic"
    ):
        """
        Create a payment intent for checkout
        """
        
        intent_params = {
            "amount": amount,  # Amount in smallest currency unit
            "currency": currency.lower(),
            "payment_method_types": [
                "card",           # Credit/debit cards
                # Add more:
                # "alipay",       # Alipay
                # "wechat_pay",   # WeChat Pay
                # "bancontact",   # Bancontact
                # "ideal",        # iDEAL
            ],
            "capture_method": capture_method,  # "automatic" or "manual"
            "metadata": metadata or {}
        }
        
        if customer_id:
            intent_params["customer"] = customer_id
        
        payment_intent = stripe.PaymentIntent.create(**intent_params)
        
        return {
            "client_secret": payment_intent.client_secret,
            "payment_intent_id": payment_intent.id,
            "status": payment_intent.status
        }
    
    def confirm_payment(self, payment_intent_id: str, payment_method_id: str):
        """
        Confirm a payment intent
        """
        
        payment_intent = stripe.PaymentIntent.confirm(
            payment_intent_id,
            payment_method=payment_method_id
        )
        
        return self._format_payment_result(payment_intent)
    
    def handle_3ds_authentication(self, payment_intent_id: str):
        """
        Handle 3D Secure authentication
        """
        
        payment_intent = stripe.PaymentIntent.retrieve(payment_intent_id)
        
        if payment_intent.status == "requires_action":
            return {
                "requires_action": True,
                "client_secret": payment_intent.client_secret,
                "next_action": payment_intent.next_action
            }
        
        return {
            "requires_action": False,
            "status": payment_intent.status
        }
    
    def refund_payment(self, payment_intent_id: str, amount: int = None):
        """
        Refund a payment
        """
        
        refund_params = {"payment_intent": payment_intent_id}
        
        if amount:
            refund_params["amount"] = amount  # Partial refund
        
        refund = stripe.Refund.create(**refund_params)
        
        return {
            "refund_id": refund.id,
            "status": refund.status,
            "amount": refund.amount
        }
    
    def create_subscription(
        self,
        customer_id: str,
        price_id: str,
        payment_behavior: str = "default_incomplete"
    ):
        """
        Create a subscription
        """
        
        subscription = stripe.Subscription.create(
            customer=customer_id,
            items=[{"price": price_id}],
            payment_behavior=payment_behavior,
            expand=["latest_invoice.payment_intent"]
        )
        
        return {
            "subscription_id": subscription.id,
            "status": subscription.status,
            "client_secret": (
                subscription.latest_invoice.payment_intent.client_secret
                if subscription.latest_invoice.payment_intent
                else None
            )
        }
    
    def _format_payment_result(self, payment_intent):
        """
        Format payment intent to standardized response
        """
        
        return {
            "payment_intent_id": payment_intent.id,
            "status": payment_intent.status,
            "amount": payment_intent.amount,
            "currency": payment_intent.currency,
            "succeeded": payment_intent.status == "succeeded"
        }
    
    def construct_webhook_event(self, payload: bytes, signature: str):
        """
        Verify and construct webhook event
        """
        
        return stripe.Webhook.construct_event(
            payload,
            signature,
            self.webhook_secret
        )

// Stripe Elements for React

import { loadStripe } from '@stripe/stripe-js';
import { Elements, PaymentElement, useStripe, useElements } from '@stripe/react-stripe-js';

const stripePromise = loadStripe('pk_test_...');

function CheckoutForm({ clientSecret }) {
  const stripe = useStripe();
  const elements = useElements();
  const [error, setError] = useState(null);
  const [processing, setProcessing] = useState(false);

  const handleSubmit = async (event) => {
    event.preventDefault();
    
    if (!stripe || !elements) return;

    setProcessing(true);

    const { error: submitError } = await stripe.confirmPayment({
      elements,
      confirmParams: {
        return_url: 'https://your-site.com/success',
      },
    });

    if (submitError) {
      setError(submitError.message);
      setProcessing(false);
    }
    // If successful, Stripe redirects to return_url
  };

  return (
    <form onSubmit={handleSubmit}>
      <PaymentElement />
      <button disabled={!stripe || processing}>
        {processing ? 'Processing...' : 'Pay Now'}
      </button>
      {error && <div className="error">{error}</div>}
    </form>
  );
}

function App() {
  // Get clientSecret from your backend
  const [clientSecret, setClientSecret] = useState('');

  useEffect(() => {
    fetch('/create-payment-intent', { method: 'POST' })
      .then(res => res.json())
      .then(data => setClientSecret(data.clientSecret));
  }, []);

  return (
    <Elements stripe={stripePromise} options={{ clientSecret }}>
      <CheckoutForm />
    </Elements>
  );
}

from adyen import Adyen
from adyen.services import checkout_api

class AdyenPayments:
    """
    Adyen payment integration
    """
    
    def __init__(self, api_key: str, merchant_account: str, environment: str = "test"):
        self.adyen = Adyen()
        self.adyen.payment.appengine_apikey = api_key
        self.merchant_account = merchant_account
        self.environment = environment
    
    def create_payment_session(
        self,
        amount: int,
        currency: str,
        return_url: str,
        reference: str,
        metadata: dict = None
    ):
        """
        Create a payment session (Adyen's equivalent to PaymentIntent)
        """
        
        request = {
            "merchantAccount": self.merchant_account,
            "amount": {
                "value": amount,
                "currency": currency
            },
            "returnUrl": return_url,
            "reference": reference,
            "metadata": metadata or {},
            "channel": "Web",  # Web, iOS, Android
            "countryCode": "US",
            "shopperEmail": "[email protected]",
            "shopperReference": "user_123"
        }
        
        result = self.adyen.checkout.payments_api.payments(request)
        
        return {
            "session_id": result.session_data if hasattr(result, 'session_data') else None,
            "psp_reference": result.psp_reference if hasattr(result, 'psp_reference') else None,
            "result_code": result.result_code if hasattr(result, 'result_code') else None,
            "action": result.action if hasattr(result, 'action') else None
        }
    
    def handle_redirect_result(self, redirect_result: str):
        """
        Handle payment result from redirect
        """
        
        request = {
            "merchantAccount": self.merchant_account,
            "redirectResult": redirect_result
        }
        
        result = self.adyen.checkout.payments_api.paymentsDetails(request)
        
        return {
            "psp_reference": result.psp_reference,
            "result_code": result.result_code,
            "merchant_reference": result.merchant_reference,
            "success": result.result_code in ["Authorised", "Received"]
        }
    
    def create_payout(
        self,
        amount: int,
        currency: str,
        target_reference: str,
        target_type: str,  # "bankAccount" or "card"
        payout_details: dict
    ):
        """
        Create a payout (e.g., to seller in marketplace)
        """
        
        request = {
            "merchantAccount": self.merchant_account,
            "amount": {
                "value": amount,
                "currency": currency
            },
            "reference": f"payout_{int(time.time())}",
            "target": {
                "type": target_type,
                **payout_details
            }
        }
        
        result = self.adyen.payouts_api.payout(request)
        
        return {
            "psp_reference": result.psp_reference,
            "result_code": result.result_code,
            "status": result.status if hasattr(result, 'status') else None
        }
    
    def capture_payment(self, psp_reference: str, amount: int, currency: str):
        """
        Capture an authorized payment
        """
        
        request = {
            "merchantAccount": self.merchant_account,
            "modificationAmount": {
                "value": amount,
                "currency": currency
            },
            "originalReference": psp_reference
        }
        
        result = self.adyen.checkout.modifications_api.capture_authorised_payment(request)
        
        return {
            "psp_reference": result.psp_reference,
            "response": result.response
        }

class MarketplacePayments:
    """
    Stripe Connect for marketplace payments
    """
    
    def __init__(self, api_key: str):
        stripe.api_key = api_key
    
    def create_seller_account(self, seller_email: str, business_type: str = "individual"):
        """
        Create a connected account for a seller
        """
        
        account = stripe.Account.create(
            type="express",  # express, standard, or custom
            email=seller_email,
            business_type=business_type,
            capabilities={
                "transfers": {"requested": True}
            }
        )
        
        return {
            "account_id": account.id,
            "email": account.email,
            "charges_enabled": account.charges_enabled,
            "payouts_enabled": account.payouts_enabled
        }
    
    def create_seller_onboarding_link(self, account_id: str, return_url: str, refresh_url: str):
        """
        Create onboarding link for seller
        """
        
        account_link = stripe.AccountLink.create(
            account=account_id,
            refresh_url=refresh_url,
            return_url=return_url,
            type="account_onboarding"
        )
        
        return {
            "url": account_link.url,
            "expires_at": account_link.expires_at
        }
    
    def create_marketplace_payment(
        self,
        amount: int,
        currency: str,
        seller_account_id: str,
        application_fee_percent: float,
        customer_id: str = None,
        metadata: dict = None
    ):
        """
        Create payment with split to seller
        """
        
        # Calculate application fee (platform commission)
        application_fee = int(amount * (application_fee_percent / 100))
        
        payment_params = {
            "amount": amount,
            "currency": currency,
            "payment_method_types": ["card"],
            "transfer_data": {
                "destination": seller_account_id  # Seller receives funds
            },
            "application_fee_amount": application_fee,  # Platform keeps this
            "metadata": metadata or {}
        }
        
        if customer_id:
            payment_params["customer"] = customer_id
        
        payment_intent = stripe.PaymentIntent.create(**payment_params)
        
        return {
            "client_secret": payment_intent.client_secret,
            "payment_intent_id": payment_intent.id,
            "application_fee": application_fee,
            "seller_amount": amount - application_fee
        }
    
    def create_direct_charge(
        self,
        amount: int,
        currency: str,
        seller_account_id: str,
        connected_payment_method_id: str,
        application_fee_amount: int
    ):
        """
        Charge directly on seller's behalf (for marketplace model)
        """
        
        payment_params = {
            "amount": amount,
            "currency": currency,
            "payment_method": connected_payment_method_id,
            "confirm": True,
            "transfer_data": {
                "destination": seller_account_id
            },
            "application_fee_amount": application_fee_amount
        }
        
        payment_intent = stripe.PaymentIntent.create(**payment_params)
        
        return {
            "payment_intent_id": payment_intent.id,
            "status": payment_intent.status,
            "seller_amount": amount - application_fee_amount
        }
    
    def create_payout_to_seller(
        self,
        seller_account_id: str,
        amount: int,
        currency: str,
        reference: str = None
    ):
        """
        Create manual payout to seller
        """
        
        transfer = stripe.Transfer.create(
            amount=amount,
            currency=currency,
            destination=seller_account_id,
            description=reference or "Marketplace payout"
        )
        
        return {
            "transfer_id": transfer.id,
            "amount": transfer.amount,
            "destination": transfer.destination,
            "created": transfer.created
        }
    
    def handle_marketplace_refund(
        self,
        payment_intent_id: str,
        refund_amount: int = None,
        refund_application_fee: bool = True
    ):
        """
        Handle refund in marketplace
        """
        
        refund_params = {
            "payment_intent": payment_intent_id,
            "refund_application_fee": refund_application_fee
        }
        
        if refund_amount:
            refund_params["amount"] = refund_amount
        
        refund = stripe.Refund.create(**refund_params)
        
        return {
            "refund_id": refund.id,
            "status": refund.status,
            "amount": refund.amount
        }

class SCAPayments:
    """
    Handle Strong Customer Authentication
    """
    
    def __init__(self, api_key: str):
        stripe.api_key = api_key
    
    def check_if_sca_required(self, payment_intent_id: str) -> dict:
        """
        Check if payment requires SCA
        """
        
        payment_intent = stripe.PaymentIntent.retrieve(payment_intent_id)
        
        # Check payment status
        if payment_intent.status == "requires_action":
            # SCA is required - 3D Secure
            return {
                "sca_required": True,
                "authentication": payment_intent.next_action
            }
        
        return {"sca_required": False}
    
    def handle_sca_verification(self, payment_intent_id: str):
        """
        Create SetupIntent for future authentication
        """
        
        # For storing payment method with SCA
        setup_intent = stripe.SetupIntent.create(
            usage="off_session",  # Use without customer present
            payment_method_types=["card"]
        )
        
        return {
            "client_secret": setup_intent.client_secret,
            "setup_intent_id": setup_intent.id
        }
    
    def use_existing_payment_method(self, customer_id: str, payment_method_id: str):
        """
        Use stored payment method (may trigger SCA)
        """
        
        payment_intent = stripe.PaymentIntent.create(
            amount=2999,
            currency="eur",
            customer=customer_id,
            payment_method=payment_method_id,
            confirm=True,
            off_session=True,  # Customer not present
            # Stripe will handle SCA automatically
        )
        
        if payment_intent.status == "requires_action":
            # Need to complete authentication
            return {
                "requires_action": True,
                "client_secret": payment_intent.client_secret
            }
        
        return {
            "requires_action": False,
            "succeeded": payment_intent.status == "succeeded"
        }
    
    def request_exemption(self, payment_intent_id: str, exemption_type: str):
        """
        Request SCA exemption (suitable cases only)
        """
        
        # Valid exemption types:
        # - low_value: Payments under €30
        # - trusted_beneficiary: Trusted merchants
        # - corporate: Corporate card payments
        # - recurring: Subsequent payments in series
        
        payment_intent = stripe.PaymentIntent.modify(
            payment_intent_id,
            payment_method_options={
                "card": {
                    "request_three_d_secure": "automatic"
                }
            }
        )
        
        return {"exemption_requested": exemption_type}

# Anti-pattern: No webhook handling
def bad_webhook_handling():
    """
    Anti-pattern: Ignoring webhooks
    """
    # Only checking payment status on page load
    # Result: Missed payment confirmations, lost revenue
    
    return "This approach is unreliable"

# Good pattern: Robust webhook handling
def good_webhook_handling():
    """
    Handle all payment events reliably
    """
    
    from flask import Flask, request
    
    app = Flask(__name__)
    
    @app.route('/webhooks/stripe', methods=['POST'])
    def handle_stripe_webhook():
        payload = request.get_data()
        sig_header = request.headers.get('stripe-signature')
        
        try:
            event = stripe.Webhook.construct_event(
                payload, sig_header, WEBHOOK_SECRET
            )
        except ValueError:
            return 'Invalid payload', 400
        except stripe.error.SignatureVerificationError:
            return 'Invalid signature', 400
        
        # Handle specific events
        event_handlers = {
            'payment_intent.succeeded': handle_payment_success,
            'payment_intent.payment_failed': handle_payment_failure,
            'charge.refunded': handle_refund,
            'customer.subscription.created': handle_subscription_created,
            'customer.subscription.deleted': handle_subscription_cancelled,
            'invoice.payment_failed': handle_invoice_failed,
        }
        
        handler = event_handlers.get(event['type'])
        if handler:
            handler(event['data']['object'])
        
        return '', 200
    
    return app

# Anti-pattern: No idempotency
def bad_idempotency():
    """
    Anti-pattern: Duplicate charges on retry
    """
    # User clicks "Pay" twice, network fails, user retries
    # Result: Multiple charges!
    
    return "Dangerous: Can cause duplicate charges"

# Good pattern: Idempotent requests
def good_idempotency():
    """
    Use idempotency keys to prevent duplicate charges
    """
    
    import uuid
    
    def create_idempotent_payment(amount: int, customer_id: str):
        """
        Create payment with idempotency key
        """
        
        # Generate unique key per payment attempt
        idempotency_key = f"{customer_id}_{amount}_{uuid.uuid4()}"
        
        # Include in request
        payment_intent = stripe.PaymentIntent.create(
            amount=amount,
            currency="usd",
            customer=customer_id,
            idempotency_key=idempotency_key
        )
        
        # If same key is used, Stripe returns same result
        # No duplicate charges!
        
        return payment_intent

# Anti-pattern: Not handling declined cards
def bad_failure_handling():
    """
    Anti-pattern: Generic error message
    """
    
    try:
        # Process payment
        pass
    except Exception as e:
        # What type of failure?
        return "Payment failed"  # Not helpful!

# Good pattern: Specific error handling
def good_failure_handling():
    """
    Handle different failure types specifically
    """
    
    def handle_payment_error(error):
        error_code = error.get("code")
        
        # Map of actionable error messages
        error_messages = {
            "card_declined": {
                "message": "Your card was declined. Please try another card.",
                "action": "request_new_card"
            },
            "expired_card": {
                "message": "Your card has expired. Please use a different card.",
                "action": "request_new_card"
            },
            "incorrect_cvc": {
                "message": "The security code is incorrect. Please check and try again.",
                "action": "request_cvc"
            },
            "insufficient_funds": {
                "message": "Insufficient funds. Please try another card.",
                "action": "request_new_card"
            },
            "processing_error": {
                "message": "A processing error occurred. Please try again.",
                "action": "retry"
            },
            "lost_card": {
                "message": "This card has been reported lost. Please use a different card.",
                "action": "request_new_card"
            },
            "stolen_card": {
                "message": "This card has been reported stolen. Please contact your bank.",
                "action": "request_new_card"
            }
        }
        
        error_info = error_messages.get(
            error_code, 
            {"message": "An error occurred. Please try again.", "action": "support"}
        )
        
        return error_info

# Use Stripe test card numbers
TEST_CARDS = {
    "success": "4242424242424242",
    "declined": "4000000000000002",
    "insufficient_funds": "4000000000009995",
    "expired_card": "4000000000000069",
    "incorrect_cvc": "4000000000000127",
    "processing_error": "4000000000000119",
    # 3D Secure
    "3d_success": "4000000000003220",
    "3d_failure": "4000000000003246",
    "3d_issuer_unavailable": "4000000000003055"
}

# Test different scenarios
def test_payment_scenarios():
    # Test successful payment
    # Test declined card
    # Test 3D Secure flow
    # Test refund flow
    # Test webhook delivery
    pass

# Minimize PCI DSS scope
# Don't store card details on your servers!

# Good pattern: Use Stripe's tokenization
def good_tokenization():
    """
    Let Stripe handle card data
    """
    
    # Frontend: Stripe.js collects card details
    # Backend: Only receives token or payment method ID
    # Never touches raw card numbers
    
    return "Low PCI compliance burden"

# Anti-pattern: Storing card numbers
def bad_storage():
    """
    Anti-pattern: Storing card numbers (high PCI scope!)
    """
    # NEVER store: card number, CVV, PIN
    # Only store: last 4 digits, expiry, card brand
    pass

def handle_currencies():
    """
    Currency handling best practices
    """
    
    # Always use smallest currency unit (cents, pence)
    # Don't use floats for money!
    
    # Good: 2999 = $29.99
    # Bad: 29.99 (floating point errors!)
    
    from decimal import Decimal
    
    def dollars_to_cents(dollars: float) -> int:
        """Convert dollars to cents"""
        return int(Decimal(str(dollars)) * 100)
    
    def cents_to_dollars(cents: int) -> float:
        """Convert cents to dollars"""
        return float(Decimal(cents) / 100)