312 lines
13 KiB
Python
Executable File
312 lines
13 KiB
Python
Executable File
"""
|
|
Stripe Payment Provider Implementation
|
|
This module implements the PaymentProvider interface for Stripe
|
|
"""
|
|
|
|
import stripe
|
|
import structlog
|
|
import uuid
|
|
from typing import Dict, Any, Optional
|
|
from datetime import datetime
|
|
|
|
from .payment_client import PaymentProvider, PaymentCustomer, PaymentMethod, Subscription, Invoice
|
|
|
|
|
|
logger = structlog.get_logger()
|
|
|
|
|
|
class StripeProvider(PaymentProvider):
|
|
"""
|
|
Stripe implementation of the PaymentProvider interface
|
|
"""
|
|
|
|
def __init__(self, api_key: str, webhook_secret: Optional[str] = None):
|
|
"""
|
|
Initialize the Stripe provider with API key
|
|
"""
|
|
stripe.api_key = api_key
|
|
self.webhook_secret = webhook_secret
|
|
|
|
async def create_customer(self, customer_data: Dict[str, Any]) -> PaymentCustomer:
|
|
"""
|
|
Create a customer in Stripe with idempotency key
|
|
"""
|
|
try:
|
|
idempotency_key = f"create_customer_{uuid.uuid4()}"
|
|
|
|
logger.info("Creating Stripe customer",
|
|
email=customer_data.get('email'),
|
|
customer_name=customer_data.get('name'))
|
|
|
|
stripe_customer = stripe.Customer.create(
|
|
email=customer_data.get('email'),
|
|
name=customer_data.get('name'),
|
|
phone=customer_data.get('phone'),
|
|
metadata=customer_data.get('metadata', {}),
|
|
idempotency_key=idempotency_key
|
|
)
|
|
|
|
logger.info("Stripe customer created successfully",
|
|
customer_id=stripe_customer.id)
|
|
|
|
return PaymentCustomer(
|
|
id=stripe_customer.id,
|
|
email=stripe_customer.email,
|
|
name=stripe_customer.name,
|
|
created_at=datetime.fromtimestamp(stripe_customer.created)
|
|
)
|
|
except stripe.error.StripeError as e:
|
|
logger.error("Failed to create Stripe customer",
|
|
error=str(e),
|
|
error_type=type(e).__name__,
|
|
email=customer_data.get('email'))
|
|
raise e
|
|
|
|
async def create_subscription(self, customer_id: str, plan_id: str, payment_method_id: str, trial_period_days: Optional[int] = None) -> Subscription:
|
|
"""
|
|
Create a subscription in Stripe with idempotency and enhanced error handling
|
|
"""
|
|
try:
|
|
subscription_idempotency_key = f"create_subscription_{uuid.uuid4()}"
|
|
payment_method_idempotency_key = f"attach_pm_{uuid.uuid4()}"
|
|
customer_update_idempotency_key = f"update_customer_{uuid.uuid4()}"
|
|
|
|
logger.info("Creating Stripe subscription",
|
|
customer_id=customer_id,
|
|
plan_id=plan_id,
|
|
payment_method_id=payment_method_id)
|
|
|
|
# Attach payment method to customer with idempotency
|
|
stripe.PaymentMethod.attach(
|
|
payment_method_id,
|
|
customer=customer_id,
|
|
idempotency_key=payment_method_idempotency_key
|
|
)
|
|
|
|
logger.info("Payment method attached to customer",
|
|
customer_id=customer_id,
|
|
payment_method_id=payment_method_id)
|
|
|
|
# Set customer's default payment method with idempotency
|
|
stripe.Customer.modify(
|
|
customer_id,
|
|
invoice_settings={
|
|
'default_payment_method': payment_method_id
|
|
},
|
|
idempotency_key=customer_update_idempotency_key
|
|
)
|
|
|
|
logger.info("Customer default payment method updated",
|
|
customer_id=customer_id)
|
|
|
|
# Create subscription with trial period if specified
|
|
subscription_params = {
|
|
'customer': customer_id,
|
|
'items': [{'price': plan_id}],
|
|
'default_payment_method': payment_method_id,
|
|
'idempotency_key': subscription_idempotency_key,
|
|
'expand': ['latest_invoice.payment_intent']
|
|
}
|
|
|
|
if trial_period_days:
|
|
subscription_params['trial_period_days'] = trial_period_days
|
|
logger.info("Subscription includes trial period",
|
|
trial_period_days=trial_period_days)
|
|
|
|
stripe_subscription = stripe.Subscription.create(**subscription_params)
|
|
|
|
logger.info("Stripe subscription created successfully",
|
|
subscription_id=stripe_subscription.id,
|
|
status=stripe_subscription.status,
|
|
current_period_end=stripe_subscription.current_period_end)
|
|
|
|
return Subscription(
|
|
id=stripe_subscription.id,
|
|
customer_id=stripe_subscription.customer,
|
|
plan_id=plan_id, # Using the price ID as plan_id
|
|
status=stripe_subscription.status,
|
|
current_period_start=datetime.fromtimestamp(stripe_subscription.current_period_start),
|
|
current_period_end=datetime.fromtimestamp(stripe_subscription.current_period_end),
|
|
created_at=datetime.fromtimestamp(stripe_subscription.created)
|
|
)
|
|
except stripe.error.CardError as e:
|
|
logger.error("Card error during subscription creation",
|
|
error=str(e),
|
|
error_code=e.code,
|
|
decline_code=e.decline_code,
|
|
customer_id=customer_id)
|
|
raise e
|
|
except stripe.error.InvalidRequestError as e:
|
|
logger.error("Invalid request during subscription creation",
|
|
error=str(e),
|
|
param=e.param,
|
|
customer_id=customer_id)
|
|
raise e
|
|
except stripe.error.StripeError as e:
|
|
logger.error("Failed to create Stripe subscription",
|
|
error=str(e),
|
|
error_type=type(e).__name__,
|
|
customer_id=customer_id,
|
|
plan_id=plan_id)
|
|
raise e
|
|
|
|
async def update_payment_method(self, customer_id: str, payment_method_id: str) -> PaymentMethod:
|
|
"""
|
|
Update the payment method for a customer in Stripe
|
|
"""
|
|
try:
|
|
# Attach payment method to customer
|
|
stripe.PaymentMethod.attach(
|
|
payment_method_id,
|
|
customer=customer_id,
|
|
)
|
|
|
|
# Set as default payment method
|
|
stripe.Customer.modify(
|
|
customer_id,
|
|
invoice_settings={
|
|
'default_payment_method': payment_method_id
|
|
}
|
|
)
|
|
|
|
stripe_payment_method = stripe.PaymentMethod.retrieve(payment_method_id)
|
|
|
|
return PaymentMethod(
|
|
id=stripe_payment_method.id,
|
|
type=stripe_payment_method.type,
|
|
brand=getattr(stripe_payment_method, stripe_payment_method.type, {}).get('brand'),
|
|
last4=getattr(stripe_payment_method, stripe_payment_method.type, {}).get('last4'),
|
|
exp_month=getattr(stripe_payment_method, stripe_payment_method.type, {}).get('exp_month'),
|
|
exp_year=getattr(stripe_payment_method, stripe_payment_method.type, {}).get('exp_year'),
|
|
)
|
|
except stripe.error.StripeError as e:
|
|
logger.error("Failed to update Stripe payment method", error=str(e))
|
|
raise e
|
|
|
|
async def cancel_subscription(self, subscription_id: str) -> Subscription:
|
|
"""
|
|
Cancel a subscription in Stripe
|
|
"""
|
|
try:
|
|
stripe_subscription = stripe.Subscription.delete(subscription_id)
|
|
|
|
return Subscription(
|
|
id=stripe_subscription.id,
|
|
customer_id=stripe_subscription.customer,
|
|
plan_id=subscription_id, # This would need to be retrieved differently in practice
|
|
status=stripe_subscription.status,
|
|
current_period_start=datetime.fromtimestamp(stripe_subscription.current_period_start),
|
|
current_period_end=datetime.fromtimestamp(stripe_subscription.current_period_end),
|
|
created_at=datetime.fromtimestamp(stripe_subscription.created)
|
|
)
|
|
except stripe.error.StripeError as e:
|
|
logger.error("Failed to cancel Stripe subscription", error=str(e))
|
|
raise e
|
|
|
|
async def get_invoices(self, customer_id: str) -> list[Invoice]:
|
|
"""
|
|
Get invoices for a customer from Stripe
|
|
"""
|
|
try:
|
|
stripe_invoices = stripe.Invoice.list(customer=customer_id, limit=100)
|
|
|
|
invoices = []
|
|
for stripe_invoice in stripe_invoices:
|
|
# Create base invoice object
|
|
invoice = Invoice(
|
|
id=stripe_invoice.id,
|
|
customer_id=stripe_invoice.customer,
|
|
subscription_id=stripe_invoice.subscription,
|
|
amount=stripe_invoice.amount_paid / 100.0, # Convert from cents
|
|
currency=stripe_invoice.currency,
|
|
status=stripe_invoice.status,
|
|
created_at=datetime.fromtimestamp(stripe_invoice.created),
|
|
due_date=datetime.fromtimestamp(stripe_invoice.due_date) if stripe_invoice.due_date else None,
|
|
description=stripe_invoice.description
|
|
)
|
|
|
|
# Add Stripe-specific URLs as custom attributes
|
|
invoice.invoice_pdf = stripe_invoice.invoice_pdf if hasattr(stripe_invoice, 'invoice_pdf') else None
|
|
invoice.hosted_invoice_url = stripe_invoice.hosted_invoice_url if hasattr(stripe_invoice, 'hosted_invoice_url') else None
|
|
|
|
invoices.append(invoice)
|
|
|
|
return invoices
|
|
except stripe.error.StripeError as e:
|
|
logger.error("Failed to retrieve Stripe invoices", error=str(e))
|
|
raise e
|
|
|
|
async def get_subscription(self, subscription_id: str) -> Subscription:
|
|
"""
|
|
Get subscription details from Stripe
|
|
"""
|
|
try:
|
|
stripe_subscription = stripe.Subscription.retrieve(subscription_id)
|
|
|
|
return Subscription(
|
|
id=stripe_subscription.id,
|
|
customer_id=stripe_subscription.customer,
|
|
plan_id=subscription_id, # This would need to be retrieved differently in practice
|
|
status=stripe_subscription.status,
|
|
current_period_start=datetime.fromtimestamp(stripe_subscription.current_period_start),
|
|
current_period_end=datetime.fromtimestamp(stripe_subscription.current_period_end),
|
|
created_at=datetime.fromtimestamp(stripe_subscription.created)
|
|
)
|
|
except stripe.error.StripeError as e:
|
|
logger.error("Failed to retrieve Stripe subscription", error=str(e))
|
|
raise e
|
|
|
|
async def get_customer(self, customer_id: str) -> PaymentCustomer:
|
|
"""
|
|
Get customer details from Stripe
|
|
"""
|
|
try:
|
|
stripe_customer = stripe.Customer.retrieve(customer_id)
|
|
|
|
return PaymentCustomer(
|
|
id=stripe_customer.id,
|
|
email=stripe_customer.email,
|
|
name=stripe_customer.name,
|
|
created_at=datetime.fromtimestamp(stripe_customer.created)
|
|
)
|
|
except stripe.error.StripeError as e:
|
|
logger.error("Failed to retrieve Stripe customer", error=str(e))
|
|
raise e
|
|
|
|
async def create_setup_intent(self) -> Dict[str, Any]:
|
|
"""
|
|
Create a setup intent for saving payment methods in Stripe
|
|
"""
|
|
try:
|
|
setup_intent = stripe.SetupIntent.create()
|
|
|
|
return {
|
|
'client_secret': setup_intent.client_secret,
|
|
'id': setup_intent.id
|
|
}
|
|
except stripe.error.StripeError as e:
|
|
logger.error("Failed to create Stripe setup intent", error=str(e))
|
|
raise e
|
|
|
|
async def create_payment_intent(self, amount: float, currency: str, customer_id: str, payment_method_id: str) -> Dict[str, Any]:
|
|
"""
|
|
Create a payment intent for one-time payments in Stripe
|
|
"""
|
|
try:
|
|
payment_intent = stripe.PaymentIntent.create(
|
|
amount=int(amount * 100), # Convert to cents
|
|
currency=currency,
|
|
customer=customer_id,
|
|
payment_method=payment_method_id,
|
|
confirm=True
|
|
)
|
|
|
|
return {
|
|
'id': payment_intent.id,
|
|
'client_secret': payment_intent.client_secret,
|
|
'status': payment_intent.status
|
|
}
|
|
except stripe.error.StripeError as e:
|
|
logger.error("Failed to create Stripe payment intent", error=str(e))
|
|
raise e
|