subscriptions

main.py

@@ -12,9 +12,9 @@ import random
 from io import BytesIO
 from urllib.parse import unquote
 from fastapi.responses import StreamingResponse, JSONResponse
-import stripe
 from typing import Optional
-from routers import user_models
+from routers import user_models, payments
+import stripe
 
 load_dotenv()
 
@@ -55,6 +55,7 @@ app = FastAPI(
 
 # Include routers
 app.include_router(user_models.router)
+app.include_router(payments.router)
 
 origins = [
     "https://www.3dai.co.uk",
@@ -111,12 +112,7 @@ class PlaceOrderRequest(BaseModel):
     payment_status: str = "pending"
     transaction_id: str = None
 
-class CreatePaymentIntentRequest(BaseModel):
-    plan: str
 
-class ConfirmPaymentRequest(BaseModel):
-    payment_intent_id: str
-    plan: str
 
 # Auth endpoints
 @app.post("/auth/signup", tags=["Authentication"])
@@ -703,109 +699,7 @@ async def purchase_credits(request: PurchaseCreditsRequest, current_user: User =
         supabase.from_("User_Credit_Account").insert({"user_id": current_user.id, "num_of_available_gens": new_credits}).execute()
     return {"message": "Credits purchased successfully.", "total_credits": new_credits}
 
-# Stripe Payment endpoints
-@app.post("/payment/create-payment-intent", tags=["Payment"])
-async def create_payment_intent(
-    request: CreatePaymentIntentRequest, 
-    current_user: User = Depends(get_current_active_user)
-):
-    """
-    Create a Stripe payment intent for purchasing credits.
-    """
-    try:
-        # Define plan pricing (only one plan for now)
-        plan_pricing = {
-            "credits_15": {"credits": 15, "amount": 300, "currency": "gbp"}  # £3.00 in pence
-        }
-        
-        if request.plan not in plan_pricing:
-            raise HTTPException(status_code=400, detail="Invalid plan selected")
-        
-        plan = plan_pricing[request.plan]
-        
-        # Create payment intent
-        intent = stripe.PaymentIntent.create(
-            amount=plan["amount"],
-            currency=plan["currency"],
-            metadata={
-                "user_id": current_user.id,
-                "plan": request.plan,
-                "credits": plan["credits"]
-            }
-        )
-        
-        return {
-            "client_secret": intent.client_secret,
-            "amount": plan["amount"],
-            "currency": plan["currency"],
-            "credits": plan["credits"]
-        }
-    
-    except stripe.error.StripeError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-    except Exception as e:
-        logging.error(f"Failed to create payment intent: {str(e)}")
-        raise HTTPException(status_code=500, detail="Failed to create payment intent")
 
-@app.post("/payment/confirm-payment", tags=["Payment"])
-async def confirm_payment(
-    request: ConfirmPaymentRequest,
-    current_user: User = Depends(get_current_active_user)
-):
-    """
-    Confirm payment and add credits to user account.
-    """
-    try:
-        # Retrieve the payment intent to verify it succeeded
-        intent = stripe.PaymentIntent.retrieve(request.payment_intent_id)
-        
-        if intent.status != "succeeded":
-            raise HTTPException(status_code=400, detail="Payment has not succeeded")
-        
-        # Verify the payment belongs to the current user
-        if intent.metadata.get("user_id") != current_user.id:
-            raise HTTPException(status_code=403, detail="Payment does not belong to current user")
-        
-        # Check if this payment has already been processed
-        existing_record = supabase.from_("Credit_Order_History").select("*").eq("transaction_id", request.payment_intent_id).execute()
-        if existing_record.data:
-            return {"message": "Payment already processed", "total_credits": None}
-        
-        # Get plan details from metadata
-        credits_to_add = int(intent.metadata.get("credits", 0))
-        amount_paid = intent.amount / 100  # Convert from pence to pounds
-        
-        # Record the purchase in history
-        supabase.from_("Credit_Order_History").insert({
-            "user_id": current_user.id,
-            "price": amount_paid,
-            "number_of_generations": credits_to_add,
-            "order_date": "now()",
-            "payment_status": "paid",
-            "transaction_id": request.payment_intent_id
-        }).execute()
-        
-        # Update user credits
-        credit = supabase.from_("User_Credit_Account").select("num_of_available_gens").eq("user_id", current_user.id).single().execute()
-        current_credits = credit.data["num_of_available_gens"] if credit.data else 0
-        new_credits = current_credits + credits_to_add
-        
-        if credit.data:
-            supabase.from_("User_Credit_Account").update({"num_of_available_gens": new_credits}).eq("user_id", current_user.id).execute()
-        else:
-            supabase.from_("User_Credit_Account").insert({"user_id": current_user.id, "num_of_available_gens": new_credits}).execute()
-        
-        return {
-            "message": "Credits added successfully",
-            "credits_added": credits_to_add,
-            "total_credits": new_credits
-        }
-    
-    except stripe.error.StripeError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-    except Exception as e:
-        logging.error(f"Failed to confirm payment: {str(e)}")
-        raise HTTPException(status_code=500, detail="Failed to confirm payment")
 
 # User dashboard endpoints
 @app.get("/user/profile", tags=["User"])

routers/payments.py

@@ -0,0 +1,472 @@
+from fastapi import APIRouter, Depends, HTTPException, Request
+from pydantic import BaseModel
+from auth import get_current_active_user, User, supabase
+import stripe
+import logging
+from typing import Optional, Dict, Any
+from datetime import datetime
+import json
+import os
+
+router = APIRouter(
+    prefix="/payment",
+    tags=["Payment"]
+)
+
+# Pydantic models
+class CreatePaymentIntentRequest(BaseModel):
+    plan: str
+
+class ConfirmPaymentRequest(BaseModel):
+    payment_intent_id: str
+    plan: str
+
+class CreateSubscriptionRequest(BaseModel):
+    plan: str
+
+class CancelSubscriptionRequest(BaseModel):
+    subscription_id: str
+
+class UpdateSubscriptionRequest(BaseModel):
+    subscription_id: str
+    new_plan: str
+
+# Subscription plan configurations
+SUBSCRIPTION_PLANS = {
+    "basic": {
+        "credits_per_month": 50,
+        "price_gbp": 9.99,
+        "stripe_price_id": "price_1Rg7PzG37ntLhOSq6Rq1HhRN",
+        "name": "Basic Plan",
+        "description": "50 credits per month"
+    },
+    "pro": {
+        "credits_per_month": 150,
+        "price_gbp": 24.99,
+        "stripe_price_id": "price_1Rg7QqG37ntLhOSqzCIx5njr",
+        "name": "Pro Plan", 
+        "description": "150 credits per month"
+    },
+    "premium": {
+        "credits_per_month": 300,
+        "price_gbp": 39.99,
+        "stripe_price_id": "price_1Rg7RJG37ntLhOSqTHd9LeVU",
+        "name": "Premium Plan",
+        "description": "300 credits per month"
+    }
+}
+
+# Stripe Payment endpoints
+@router.post("/create-payment-intent")
+async def create_payment_intent(
+    request: CreatePaymentIntentRequest, 
+    current_user: User = Depends(get_current_active_user)
+):
+    """
+    Create a Stripe payment intent for purchasing credits.
+    """
+    try:
+        # Define plan pricing (only one plan for now)
+        plan_pricing = {
+            "credits_15": {"credits": 15, "amount": 300, "currency": "gbp"}  # £3.00 in pence
+        }
+        
+        if request.plan not in plan_pricing:
+            raise HTTPException(status_code=400, detail="Invalid plan selected")
+        
+        plan = plan_pricing[request.plan]
+        
+        # Create payment intent
+        intent = stripe.PaymentIntent.create(
+            amount=plan["amount"],
+            currency=plan["currency"],
+            metadata={
+                "user_id": current_user.id,
+                "plan": request.plan,
+                "credits": plan["credits"]
+            }
+        )
+        
+        return {
+            "client_secret": intent.client_secret,
+            "amount": plan["amount"],
+            "currency": plan["currency"],
+            "credits": plan["credits"]
+        }
+    
+    except HTTPException as e:
+        # Re-raise custom HTTP errors such as "Invalid plan selected" without modification
+        raise e
+    except stripe.error.StripeError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logging.error(f"Failed to create payment intent: {str(e)}")
+        raise HTTPException(status_code=500, detail="Failed to create payment intent")
+
+@router.post("/confirm-payment")
+async def confirm_payment(
+    request: ConfirmPaymentRequest,
+    current_user: User = Depends(get_current_active_user)
+):
+    """
+    Confirm payment and add credits to user account.
+    """
+    try:
+        # Retrieve the payment intent to verify it succeeded
+        intent = stripe.PaymentIntent.retrieve(request.payment_intent_id)
+        
+        if intent.status != "succeeded":
+            raise HTTPException(status_code=400, detail="Payment has not succeeded")
+        
+        # Verify the payment belongs to the current user
+        if intent.metadata.get("user_id") != current_user.id:
+            raise HTTPException(status_code=403, detail="Payment does not belong to current user")
+        
+        # Check if this payment has already been processed
+        existing_record = supabase.from_("Credit_Order_History").select("*").eq("transaction_id", request.payment_intent_id).execute()
+        if existing_record.data:
+            return {"message": "Payment already processed", "total_credits": None}
+        
+        # Get plan details from metadata
+        credits_to_add = int(intent.metadata.get("credits", 0))
+        amount_paid = intent.amount / 100  # Convert from pence to pounds
+        
+        # Record the purchase in history
+        supabase.from_("Credit_Order_History").insert({
+            "user_id": current_user.id,
+            "price": amount_paid,
+            "number_of_generations": credits_to_add,
+            "order_date": "now()",
+            "payment_status": "paid",
+            "transaction_id": request.payment_intent_id
+        }).execute()
+        
+        # Update user credits
+        credit = supabase.from_("User_Credit_Account").select("num_of_available_gens").eq("user_id", current_user.id).single().execute()
+        current_credits = credit.data["num_of_available_gens"] if credit.data else 0
+        new_credits = current_credits + credits_to_add
+        
+        if credit.data:
+            supabase.from_("User_Credit_Account").update({"num_of_available_gens": new_credits}).eq("user_id", current_user.id).execute()
+        else:
+            supabase.from_("User_Credit_Account").insert({"user_id": current_user.id, "num_of_available_gens": new_credits}).execute()
+        
+        return {
+            "message": "Credits added successfully",
+            "credits_added": credits_to_add,
+            "total_credits": new_credits
+        }
+    
+    except stripe.error.StripeError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logging.error(f"Failed to confirm payment: {str(e)}")
+        raise HTTPException(status_code=500, detail="Failed to confirm payment")
+
+# Subscription endpoints
+@router.get("/subscription-plans")
+async def get_subscription_plans():
+    """
+    Get available subscription plans.
+    """
+    return {"plans": SUBSCRIPTION_PLANS}
+
+@router.post("/create-subscription")
+async def create_subscription(
+    request: CreateSubscriptionRequest,
+    current_user: User = Depends(get_current_active_user)
+):
+    """
+    Create a new subscription for the user.
+    """
+    try:
+        if request.plan not in SUBSCRIPTION_PLANS:
+            raise HTTPException(status_code=400, detail="Invalid subscription plan")
+        
+        plan = SUBSCRIPTION_PLANS[request.plan]
+        
+        # Check if user already has an active subscription
+        existing_sub = supabase.from_("User_Subscriptions").select("*").eq("user_id", current_user.id).eq("status", "active").execute()
+        if existing_sub.data:
+            raise HTTPException(status_code=400, detail="User already has an active subscription")
+        
+        # Get or create Stripe customer
+        customer_record = supabase.from_("Stripe_Customers").select("*").eq("user_id", current_user.id).execute()
+        
+        if customer_record.data:
+            customer_id = customer_record.data[0]["stripe_customer_id"]
+        else:
+            # Create new Stripe customer
+            user_data = supabase.from_("User").select("*").eq("user_id", current_user.id).execute()
+            customer = stripe.Customer.create(
+                email=current_user.email,
+                metadata={"user_id": current_user.id}
+            )
+            customer_id = customer.id
+            
+            # Store customer ID in database
+            supabase.from_("Stripe_Customers").insert({
+                "user_id": current_user.id,
+                "stripe_customer_id": customer_id
+            }).execute()
+        
+        # Create subscription with proper setup for Stripe Elements
+        # Use expand to get both setup_intent and payment_intent depending on what Stripe creates
+        subscription = stripe.Subscription.create(
+            customer=customer_id,
+            items=[{"price": plan["stripe_price_id"]}],
+            payment_behavior="default_incomplete",
+            payment_settings={"save_default_payment_method": "on_subscription"},
+            expand=["latest_invoice.confirmation_secret", "pending_setup_intent"],
+            metadata={
+                "user_id": current_user.id,
+                "plan": request.plan
+            }
+        )
+        
+        # ----------------- Persist subscription locally -----------------
+        subscription_data = {
+            "user_id": current_user.id,
+            "stripe_subscription_id": subscription.id,
+            "plan": request.plan,
+            "status": subscription.status,
+            "created_at": datetime.now().isoformat(),
+        }
+        cps = getattr(subscription, "current_period_start", None)
+        cpe = getattr(subscription, "current_period_end", None)
+        if cps:
+            subscription_data["current_period_start"] = datetime.fromtimestamp(cps).isoformat()
+        if cpe:
+            subscription_data["current_period_end"] = datetime.fromtimestamp(cpe).isoformat()
+        supabase.from_("User_Subscriptions").insert(subscription_data).execute()
+
+        # ----------------- Retrieve the client secret ------------------
+        # For API version 2025-03-31 ("Basil") the PaymentIntent secret is
+        # located at invoice.confirmation_secret.client_secret. If the
+        # subscription starts with a £0 trial Stripe instead provides a
+        # SetupIntent whose secret is on pending_setup_intent.client_secret.
+        client_secret: Optional[str] = None
+        if subscription.latest_invoice and getattr(subscription.latest_invoice, "confirmation_secret", None):
+            client_secret = subscription.latest_invoice.confirmation_secret.client_secret
+        elif getattr(subscription, "pending_setup_intent", None):
+            client_secret = subscription.pending_setup_intent.client_secret
+
+        if not client_secret:
+            logging.error(
+                "Unable to retrieve Stripe client secret for subscription %s", subscription.id
+            )
+            raise HTTPException(status_code=500, detail="Failed to retrieve payment client secret")
+
+        return {
+            "subscription_id": subscription.id,
+            "client_secret": client_secret,
+            "status": subscription.status,
+            "plan": request.plan,
+            "price": plan["price_gbp"],
+            "currency": "gbp",
+            "credits_per_month": plan["credits_per_month"],
+            "price_per_credit": round(plan["price_gbp"] / plan["credits_per_month"], 2)
+        }
+    
+    except stripe.error.StripeError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logging.error(f"Failed to create subscription: {str(e)}")
+        raise HTTPException(status_code=500, detail="Failed to create subscription")
+
+@router.get("/subscription")
+async def get_user_subscription(current_user: User = Depends(get_current_active_user)):
+    """
+    Get user's current subscription details.
+    """
+    try:
+        subscription_record = supabase.from_("User_Subscriptions").select("*").eq("user_id", current_user.id).order("created_at", desc=True).limit(1).execute()
+        
+        if not subscription_record.data:
+            return {"subscription": None}
+        
+        subscription_data = subscription_record.data[0]
+        
+        # Get latest status from Stripe
+        stripe_subscription = stripe.Subscription.retrieve(subscription_data["stripe_subscription_id"])
+        
+        # Update local status if different
+        if stripe_subscription.status != subscription_data["status"]:
+            update_data = {"status": stripe_subscription.status}
+            
+            # Only update period dates if they exist (None for incomplete subscriptions)
+            cps = getattr(stripe_subscription, "current_period_start", None)
+            cpe = getattr(stripe_subscription, "current_period_end", None)
+            if cps:
+                update_data["current_period_start"] = datetime.fromtimestamp(cps).isoformat()
+            if cpe:
+                update_data["current_period_end"] = datetime.fromtimestamp(cpe).isoformat()
+                
+            supabase.from_("User_Subscriptions").update(update_data).eq("id", subscription_data["id"]).execute()
+            
+            subscription_data["status"] = stripe_subscription.status
+        
+        return {
+            "subscription": {
+                **subscription_data,
+                "plan_details": SUBSCRIPTION_PLANS.get(subscription_data["plan"])
+            }
+        }
+    
+    except stripe.error.StripeError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logging.error(f"Failed to get subscription: {str(e)}")
+        raise HTTPException(status_code=500, detail="Failed to get subscription")
+
+@router.post("/cancel-subscription")
+async def cancel_subscription(
+    request: CancelSubscriptionRequest,
+    current_user: User = Depends(get_current_active_user)
+):
+    """
+    Cancel user's subscription.
+    """
+    try:
+        # Verify subscription belongs to user
+        subscription_record = supabase.from_("User_Subscriptions").select("*").eq("stripe_subscription_id", request.subscription_id).eq("user_id", current_user.id).execute()
+        
+        if not subscription_record.data:
+            raise HTTPException(status_code=404, detail="Subscription not found")
+        
+        # Cancel subscription in Stripe
+        stripe.Subscription.modify(
+            request.subscription_id,
+            cancel_at_period_end=True
+        )
+        
+        # Update local record
+        supabase.from_("User_Subscriptions").update({
+            "status": "cancel_at_period_end"
+        }).eq("stripe_subscription_id", request.subscription_id).execute()
+        
+        return {"message": "Subscription will be canceled at the end of the current period"}
+    
+    except stripe.error.StripeError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logging.error(f"Failed to cancel subscription: {str(e)}")
+        raise HTTPException(status_code=500, detail="Failed to cancel subscription")
+
+@router.post("/webhook")
+async def stripe_webhook(request: Request):
+    """
+    Handle Stripe webhook events for subscription management.
+    """
+    payload = await request.body()
+    sig_header = request.headers.get("stripe-signature")
+    
+    # You'll need to set this in your environment variables
+    endpoint_secret = os.getenv("STRIPE_WEBHOOK_SECRET")
+    
+    if not endpoint_secret:
+        raise HTTPException(status_code=500, detail="Webhook secret not configured")
+    
+    try:
+        # Recreate the Stripe event
+        try:
+            event = stripe.Webhook.construct_event(payload, sig_header, endpoint_secret)
+        except ValueError:
+            raise HTTPException(status_code=400, detail="Invalid payload")
+        except stripe.error.SignatureVerificationError:
+            raise HTTPException(status_code=400, detail="Invalid signature")
+
+        # Handle subscription events
+        if event["type"] == "invoice.payment_succeeded":
+            await handle_payment_succeeded(event["data"]["object"])
+        elif event["type"] == "invoice.payment_failed":
+            await handle_payment_failed(event["data"]["object"])
+        elif event["type"] == "customer.subscription.deleted":
+            await handle_subscription_deleted(event["data"]["object"])
+        elif event["type"] == "customer.subscription.updated":
+            await handle_subscription_updated(event["data"]["object"])
+        
+        return {"status": "success"}
+    
+    except Exception as e:
+        print(f"Webhook error: {str(e)}")
+        raise HTTPException(status_code=500, detail="Webhook processing failed")
+
+async def handle_payment_succeeded(invoice):
+    """Handle successful subscription payment."""
+    subscription_id = invoice["subscription"]
+    
+    # Get subscription details
+    subscription = stripe.Subscription.retrieve(subscription_id)
+    user_id = subscription.metadata.get("user_id")
+    plan = subscription.metadata.get("plan")
+    
+    if not user_id or not plan:
+        print("Missing user_id or plan in subscription metadata")
+        return
+    
+    # Add credits to user account
+    plan_details = SUBSCRIPTION_PLANS.get(plan)
+    if plan_details:
+        credits_to_add = plan_details["credits_per_month"]
+        
+        # Update user credits
+        credit_record = supabase.from_("User_Credit_Account").select("*").eq("user_id", user_id).execute()
+        
+        if credit_record.data:
+            current_credits = credit_record.data[0]["num_of_available_gens"]
+            new_credits = current_credits + credits_to_add
+            
+            supabase.from_("User_Credit_Account").update({
+                "num_of_available_gens": new_credits
+            }).eq("user_id", user_id).execute()
+        else:
+            supabase.from_("User_Credit_Account").insert({
+                "user_id": user_id,
+                "num_of_available_gens": credits_to_add
+            }).execute()
+        
+        # Record the subscription payment
+        supabase.from_("Subscription_Payment_History").insert({
+            "user_id": user_id,
+            "subscription_id": subscription_id,
+            "invoice_id": invoice["id"],
+            "amount": invoice["amount_paid"] / 100,  # Convert from pence
+            "credits_added": credits_to_add,
+            "payment_date": datetime.fromtimestamp(invoice["created"]).isoformat(),
+            "status": "paid"
+        }).execute()
+
+async def handle_payment_failed(invoice):
+    """Handle failed subscription payment."""
+    subscription_id = invoice["subscription"]
+    
+    # Update subscription status
+    supabase.from_("User_Subscriptions").update({
+        "status": "past_due"
+    }).eq("stripe_subscription_id", subscription_id).execute()
+
+async def handle_subscription_deleted(subscription):
+    """Handle subscription cancellation."""
+    user_id = subscription.metadata.get("user_id")
+    
+    # Update subscription status
+    supabase.from_("User_Subscriptions").update({
+        "status": "canceled",
+        "canceled_at": datetime.now().isoformat()
+    }).eq("stripe_subscription_id", subscription["id"]).execute()
+
+async def handle_subscription_updated(subscription):
+    """Handle subscription updates."""
+    # Update subscription details in database
+    update_data = {"status": subscription["status"]}
+    
+    # Only update period dates if they exist (None for incomplete subscriptions)
+    cps = subscription.get("current_period_start")
+    cpe = subscription.get("current_period_end")
+    if cps:
+        update_data["current_period_start"] = datetime.fromtimestamp(cps).isoformat()
+    if cpe:
+        update_data["current_period_end"] = datetime.fromtimestamp(cpe).isoformat()
+    
+    supabase.from_("User_Subscriptions").update(update_data).eq("stripe_subscription_id", subscription["id"]).execute()

subscription_integration_example.py

@@ -0,0 +1,193 @@
+# Example: Integrating Subscriptions with Existing Credit System
+# Add these functions to your main.py or create a separate utils module
+
+from datetime import datetime, timedelta
+from auth import supabase
+import logging
+
+async def check_user_access_permissions(user_id: str) -> dict:
+    """
+    Enhanced function to check if user can access AI generation features.
+    Checks both one-time credits and active subscriptions.
+    """
+    try:
+        # Check for active subscription first
+        subscription_record = supabase.from_("User_Subscriptions").select("*").eq("user_id", user_id).eq("status", "active").execute()
+        
+        has_active_subscription = bool(subscription_record.data)
+        
+        # Get current credits
+        credit_record = supabase.from_("User_Credit_Account").select("num_of_available_gens").eq("user_id", user_id).execute()
+        current_credits = credit_record.data[0]["num_of_available_gens"] if credit_record.data else 0
+        
+        # Determine access level
+        if has_active_subscription:
+            subscription = subscription_record.data[0]
+            return {
+                "can_generate": True,
+                "access_type": "subscription",
+                "subscription_plan": subscription["plan"],
+                "credits": current_credits,
+                "subscription_active": True,
+                "period_end": subscription["current_period_end"]
+            }
+        elif current_credits > 0:
+            return {
+                "can_generate": True,
+                "access_type": "credits",
+                "subscription_plan": None,
+                "credits": current_credits,
+                "subscription_active": False,
+                "period_end": None
+            }
+        else:
+            return {
+                "can_generate": False,
+                "access_type": None,
+                "subscription_plan": None,
+                "credits": 0,
+                "subscription_active": False,
+                "period_end": None
+            }
+    
+    except Exception as e:
+        logging.error(f"Error checking user access: {str(e)}")
+        return {
+            "can_generate": False,
+            "access_type": None,
+            "subscription_plan": None,
+            "credits": 0,
+            "subscription_active": False,
+            "period_end": None,
+            "error": str(e)
+        }
+
+async def check_and_decrement_credits_enhanced(user_id: str) -> bool:
+    """
+    Enhanced version of your existing credit checking function.
+    Prioritizes subscription access over one-time credits.
+    """
+    try:
+        access_info = await check_user_access_permissions(user_id)
+        
+        if not access_info["can_generate"]:
+            return False
+        
+        if access_info["access_type"] == "subscription":
+            # User has active subscription - allow generation without decrementing credits
+            # Credits accumulate for subscription users as a bonus
+            logging.info(f"User {user_id} using subscription access ({access_info['subscription_plan']})")
+            return True
+        
+        elif access_info["access_type"] == "credits":
+            # User using one-time credits - decrement as before
+            current_credits = access_info["credits"]
+            if current_credits > 0:
+                new_credits = current_credits - 1
+                supabase.from_("User_Credit_Account").update({"num_of_available_gens": new_credits}).eq("user_id", user_id).execute()
+                logging.info(f"User {user_id} used 1 credit. Remaining: {new_credits}")
+                return True
+        
+        return False
+    
+    except Exception as e:
+        logging.error(f"Error in credit check: {str(e)}")
+        return False
+
+# New endpoint to add to main.py
+from fastapi import Depends
+from auth import get_current_active_user, User
+
+@app.get("/user/access-info", tags=["User"])
+async def get_user_access_info(current_user: User = Depends(get_current_active_user)):
+    """
+    Get comprehensive user access information including subscription and credits.
+    """
+    access_info = await check_user_access_permissions(current_user.id)
+    return access_info
+
+@app.get("/user/subscription-status", tags=["User"])
+async def get_subscription_status(current_user: User = Depends(get_current_active_user)):
+    """
+    Get detailed subscription status for the user.
+    """
+    try:
+        # Get subscription details
+        subscription_record = supabase.from_("User_Subscriptions").select("*").eq("user_id", current_user.id).order("created_at", desc=True).limit(1).execute()
+        
+        if not subscription_record.data:
+            return {
+                "has_subscription": False,
+                "subscription": None,
+                "next_billing_date": None,
+                "can_upgrade": True
+            }
+        
+        subscription = subscription_record.data[0]
+        
+        # Get payment history
+        payment_history = supabase.from_("Subscription_Payment_History").select("*").eq("user_id", current_user.id).order("payment_date", desc=True).limit(5).execute()
+        
+        return {
+            "has_subscription": subscription["status"] in ["active", "cancel_at_period_end"],
+            "subscription": subscription,
+            "next_billing_date": subscription["current_period_end"],
+            "can_upgrade": subscription["status"] == "active",
+            "recent_payments": payment_history.data,
+            "subscription_plan_details": SUBSCRIPTION_PLANS.get(subscription["plan"]) if subscription["plan"] in SUBSCRIPTION_PLANS else None
+        }
+    
+    except Exception as e:
+        logging.error(f"Error getting subscription status: {str(e)}")
+        raise HTTPException(status_code=500, detail="Failed to get subscription status")
+
+# Usage tracking for subscription users
+async def track_subscription_usage(user_id: str, feature_used: str):
+    """
+    Track usage for subscription users (for analytics and potential usage limits).
+    """
+    try:
+        # Get user's active subscription
+        subscription_record = supabase.from_("User_Subscriptions").select("*").eq("user_id", user_id).eq("status", "active").execute()
+        
+        if subscription_record.data:
+            subscription_id = subscription_record.data[0]["stripe_subscription_id"]
+            
+            # Log usage (you might want to create a separate Usage_Tracking table)
+            usage_data = {
+                "user_id": user_id,
+                "subscription_id": subscription_id,
+                "feature_used": feature_used,
+                "timestamp": datetime.now().isoformat(),
+                "billing_period_start": subscription_record.data[0]["current_period_start"],
+                "billing_period_end": subscription_record.data[0]["current_period_end"]
+            }
+            
+            # You can log this to a separate table or your existing logging system
+            logging.info(f"Subscription usage tracked: {usage_data}")
+    
+    except Exception as e:
+        logging.error(f"Error tracking subscription usage: {str(e)}")
+
+# Updated version of your existing generation endpoints
+# Replace your existing check_and_decrement_credits calls with check_and_decrement_credits_enhanced
+
+# Example for one of your endpoints:
+@app.post("/req-img-to-3d-enhanced", tags=["Image-to-3D"])
+async def req_img_to_3d_enhanced(
+    image: UploadFile = File(...),
+    settings: Settings = Depends(get_settings),
+    current_user: User = Depends(get_current_active_user)
+):
+    """
+    Enhanced version that works with both subscriptions and credits.
+    """
+    # Check access permissions
+    if not await check_and_decrement_credits_enhanced(current_user.id):
+        raise HTTPException(status_code=402, detail="Insufficient credits or no active subscription")
+    
+    # Track usage for subscription users
+    await track_subscription_usage(current_user.id, "image_to_3d")
+    
+    # Rest of your existing logic...
+    # ... existing image processing code ... 

subscription_setup.md

@@ -0,0 +1,259 @@
+# Monthly Subscriptions Setup Guide
+
+This guide will help you set up monthly subscriptions for your 3DAI API backend.
+
+## 1. Database Schema Updates
+
+You'll need to create the following tables in your Supabase database:
+
+### User_Subscriptions Table
+```sql
+CREATE TABLE "User_Subscriptions" (
+    id SERIAL PRIMARY KEY,
+    user_id UUID NOT NULL REFERENCES auth.users(id),
+    stripe_subscription_id VARCHAR(255) UNIQUE NOT NULL,
+    plan VARCHAR(50) NOT NULL,
+    status VARCHAR(50) NOT NULL,
+    current_period_start TIMESTAMP WITH TIME ZONE,
+    current_period_end TIMESTAMP WITH TIME ZONE,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    canceled_at TIMESTAMP WITH TIME ZONE
+);
+
+-- Add indexes for better performance
+CREATE INDEX idx_user_subscriptions_user_id ON "User_Subscriptions"(user_id);
+CREATE INDEX idx_user_subscriptions_status ON "User_Subscriptions"(status);
+CREATE INDEX idx_user_subscriptions_stripe_id ON "User_Subscriptions"(stripe_subscription_id);
+```
+
+### Stripe_Customers Table
+```sql
+CREATE TABLE "Stripe_Customers" (
+    id SERIAL PRIMARY KEY,
+    user_id UUID NOT NULL REFERENCES auth.users(id),
+    stripe_customer_id VARCHAR(255) UNIQUE NOT NULL,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+-- Add index
+CREATE INDEX idx_stripe_customers_user_id ON "Stripe_Customers"(user_id);
+```
+
+### Subscription_Payment_History Table
+```sql
+CREATE TABLE "Subscription_Payment_History" (
+    id SERIAL PRIMARY KEY,
+    user_id UUID NOT NULL REFERENCES auth.users(id),
+    subscription_id VARCHAR(255) NOT NULL,
+    invoice_id VARCHAR(255) UNIQUE NOT NULL,
+    amount DECIMAL(10,2) NOT NULL,
+    credits_added INTEGER NOT NULL,
+    payment_date TIMESTAMP WITH TIME ZONE NOT NULL,
+    status VARCHAR(50) NOT NULL,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+-- Add indexes
+CREATE INDEX idx_subscription_payment_history_user_id ON "Subscription_Payment_History"(user_id);
+CREATE INDEX idx_subscription_payment_history_subscription_id ON "Subscription_Payment_History"(subscription_id);
+```
+
+## 2. Stripe Configuration
+
+### Create Products and Prices in Stripe
+
+You'll need to create products and prices in your Stripe dashboard or via API:
+
+```bash
+# Using Stripe CLI (install from https://stripe.com/docs/stripe-cli)
+
+# Create Basic Plan Product
+stripe products create \
+  --name="Basic Plan" \
+  --description="50 credits per month"
+
+# Create Basic Plan Price (replace prod_xxx with your product ID)
+stripe prices create \
+  --unit-amount=999 \
+  --currency=gbp \
+  --recurring-interval=month \
+  --product=prod_xxx
+
+# Create Pro Plan Product
+stripe products create \
+  --name="Pro Plan" \
+  --description="150 credits per month"
+
+# Create Pro Plan Price
+stripe prices create \
+  --unit-amount=2499 \
+  --currency=gbp \
+  --recurring-interval=month \
+  --product=prod_xxx
+
+# Create Premium Plan Product
+stripe products create \
+  --name="Premium Plan" \
+  --description="300 credits per month"
+
+# Create Premium Plan Price
+stripe prices create \
+  --unit-amount=3999 \
+  --currency=gbp \
+  --recurring-interval=month \
+  --product=prod_xxx
+```
+
+### Update Price IDs
+
+After creating the prices, update the `SUBSCRIPTION_PLANS` in `routers/payments.py` with your actual Stripe price IDs:
+
+```python
+SUBSCRIPTION_PLANS = {
+    "basic": {
+        "credits_per_month": 50,
+        "price_gbp": 9.99,
+        "stripe_price_id": "price_1234567890",  # Replace with actual price ID
+        "name": "Basic Plan",
+        "description": "50 credits per month"
+    },
+    # ... update other plans
+}
+```
+
+## 3. Environment Variables
+
+Add these new environment variables to your `.env` file:
+
+```env
+# Existing variables...
+STRIPE_SECRET_KEY=sk_test_your_stripe_secret_key
+STRIPE_PUBLISHABLE_KEY=pk_test_your_stripe_publishable_key
+
+# New webhook secret (you'll get this when setting up the webhook)
+STRIPE_WEBHOOK_SECRET=whsec_your_webhook_secret
+```
+
+## 4. Webhook Configuration
+
+### Set up Stripe Webhook
+
+1. Go to your Stripe Dashboard → Developers → Webhooks
+2. Click "Add endpoint"
+3. Set the endpoint URL to: `https://your-domain.com/payment/webhook`
+4. Select these events:
+   - `invoice.payment_succeeded`
+   - `invoice.payment_failed`
+   - `customer.subscription.deleted`
+   - `customer.subscription.updated`
+5. Copy the webhook secret and add it to your environment variables
+
+## 5. API Endpoints
+
+Your subscription system now includes these new endpoints:
+
+### Get Available Plans
+```
+GET /payment/subscription-plans
+```
+
+### Create Subscription
+```
+POST /payment/create-subscription
+Content-Type: application/json
+Authorization: Bearer <token>
+
+{
+    "plan": "basic"
+}
+```
+
+### Get User's Subscription
+```
+GET /payment/subscription
+Authorization: Bearer <token>
+```
+
+### Cancel Subscription
+```
+POST /payment/cancel-subscription
+Content-Type: application/json
+Authorization: Bearer <token>
+
+{
+    "subscription_id": "sub_1234567890"
+}
+```
+
+### Webhook Endpoint
+```
+POST /payment/webhook
+```
+
+## 6. Frontend Integration Example
+
+Here's a basic example of how to integrate subscriptions in your frontend:
+
+```javascript
+// Create subscription
+const createSubscription = async (plan) => {
+    const response = await fetch('/payment/create-subscription', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${userToken}`
+        },
+        body: JSON.stringify({ plan })
+    });
+    
+    const { client_secret } = await response.json();
+    
+    // Use Stripe.js to confirm payment
+    const { error } = await stripe.confirmPayment({
+        elements,
+        clientSecret: client_secret,
+        confirmParams: {
+            return_url: 'https://your-domain.com/subscription-success'
+        }
+    });
+};
+
+// Get user's subscription status
+const getSubscription = async () => {
+    const response = await fetch('/payment/subscription', {
+        headers: {
+            'Authorization': `Bearer ${userToken}`
+        }
+    });
+    
+    const { subscription } = await response.json();
+    return subscription;
+};
+```
+
+## 7. Testing
+
+1. Use Stripe test mode for development
+2. Use test card numbers from Stripe documentation
+3. Test webhook events using Stripe CLI:
+   ```bash
+   stripe listen --forward-to localhost:8000/payment/webhook
+   ```
+
+## 8. Production Considerations
+
+1. **Security**: Ensure webhook signature verification is enabled
+2. **Monitoring**: Set up logging for subscription events
+3. **Error Handling**: Implement retry logic for failed webhook processing
+4. **Credits Management**: Consider implementing credit rollover policies
+5. **Prorations**: Handle plan changes with appropriate prorations
+6. **Tax Handling**: Implement tax calculation if required for your jurisdiction
+
+## 9. Additional Features to Consider
+
+- **Plan Upgrades/Downgrades**: Allow users to change subscription plans
+- **Pause/Resume**: Allow temporary subscription pauses
+- **Annual Plans**: Add yearly subscription options with discounts
+- **Usage Limits**: Implement soft/hard limits based on subscription tier
+- **Email Notifications**: Send emails for subscription events
+- **Admin Dashboard**: Create admin interface for subscription management