Merge pull request #58 from amazeeio/dev

Add Stripe integration

Author: PhiRho

README.md

@@ -67,6 +67,9 @@ make backend-test-cov   # Run backend tests with coverage report
 make backend-test-regex # Waits for a string which pytest will parse to only collect a subset of tests
 ```
 
+### 💳 Testing Stripe
+See [[tests/stripe_test_trigger.md]] for detailed instructions on testing integration with Stripe for billing purposes.
+
 ### Frontend Tests
 ```bash
 make frontend-test    # Run frontend tests

app/api/auth.py

@@ -67,7 +67,7 @@
 auth_logger = logging.getLogger(__name__)
 
 router = APIRouter(
-    tags=["Authentication"]
+    tags=["auth"]
 )
 
 def get_cookie_domain():

app/api/billing.py

@@ -0,0 +1,177 @@
+from fastapi import APIRouter, Depends, HTTPException, status, Request, Response, BackgroundTasks
+from sqlalchemy.orm import Session
+import logging
+import os
+from app.db.database import get_db
+from app.core.security import check_specific_team_admin
+from app.db.models import DBTeam, DBSystemSecret
+from app.schemas.models import PricingTableSession
+from app.services.stripe import (
+    decode_stripe_event,
+    create_portal_session,
+    create_stripe_customer,
+    get_pricing_table_secret,
+)
+from app.core.worker import handle_stripe_event_background
+
+# Configure logger
+logger = logging.getLogger(__name__)
+BILLING_WEBHOOK_KEY = "stripe_webhook_secret"
+BILLING_WEBHOOK_ROUTE = "/billing/events"
+
+router = APIRouter(
+    tags=["billing"]
+)
+
+# TODO: Verify where we want this to be
+def get_return_url(team_id: int) -> str:
+    """
+    Get the return URL for the team dashboard.
+
+    Args:
+        team_id: The ID of the team to get the return URL for
+
+    Returns:
+        The return URL for the team dashboard
+    """
+    # Get the frontend URL from environment
+    frontend_url = os.getenv("FRONTEND_URL", "http://localhost:3000")
+    return f"{frontend_url}/teams/{team_id}/dashboard"
+
+
+@router.post("/events")
+async def handle_events(
+    request: Request,
+    background_tasks: BackgroundTasks,
+    db: Session = Depends(get_db)
+):
+    """
+    Handle Stripe webhook events.
+
+    This endpoint processes various Stripe events like subscription updates,
+    payment successes, and failures. Events are processed asynchronously in the background.
+    """
+    try:
+        # Get the webhook secret from database or environment variable
+        if os.getenv("WEBHOOK_SIG"):
+            webhook_secret = os.getenv("WEBHOOK_SIG")
+        else:
+            webhook_secret = db.query(DBSystemSecret).filter(
+                DBSystemSecret.key == BILLING_WEBHOOK_KEY
+            ).first().value
+
+        if not webhook_secret:
+            logger.error("Stripe webhook secret not configured")
+            # 404 for security reasons - if we're not accepting traffic here, then it doesn't exist
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Not found"
+            )
+
+        # Get the raw request body
+        payload = await request.body()
+        signature = request.headers.get("stripe-signature")
+
+        event = decode_stripe_event(payload, signature, webhook_secret)
+
+        # Add the event handling to background tasks
+        background_tasks.add_task(handle_stripe_event_background, event, db)
+
+        return Response(
+            status_code=status.HTTP_200_OK,
+            content="Webhook received and processing started"
+        )
+
+    except Exception as e:
+        logger.error(f"Error handling Stripe event: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Error processing webhook"
+        )
+
+@router.post("/teams/{team_id}/portal", dependencies=[Depends(check_specific_team_admin)])
+async def get_portal(
+    team_id: int,
+    db: Session = Depends(get_db)
+):
+    """
+    Create a Stripe Customer Portal session for team subscription management and redirect to it.
+    If the team doesn't have a Stripe customer ID, one will be created first.
+
+    Args:
+        team_id: The ID of the team to create the portal session for
+
+    Returns:
+        Redirects to the Stripe Customer Portal URL
+    """
+    # Get the team
+    team = db.query(DBTeam).filter(DBTeam.id == team_id).first()
+    if not team:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Team not found"
+        )
+    if not team.stripe_customer_id:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Team has not been registered with Stripe"
+        )
+
+    try:
+        return_url = get_return_url(team_id)
+        # Create portal session using the service
+        portal_url = await create_portal_session(team.stripe_customer_id, return_url)
+
+        return Response(
+            status_code=status.HTTP_303_SEE_OTHER,
+            headers={"Location": portal_url}
+        )
+    except Exception as e:
+        logger.error(f"Error creating portal session: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Error creating portal session"
+        )
+
+@router.get("/teams/{team_id}/pricing-table-session", dependencies=[Depends(check_specific_team_admin)], response_model=PricingTableSession)
+async def get_pricing_table_session(
+    team_id: int,
+    db: Session = Depends(get_db)
+):
+    """
+    Create a Stripe Customer Session client secret for team subscription management.
+    If the team doesn't have a Stripe customer ID, one will be created first.
+
+    Args:
+        team_id: The ID of the team to create the customer session for
+
+    Returns:
+        JSON response containing the client secret
+    """
+    # Get the team
+    team = db.query(DBTeam).filter(DBTeam.id == team_id).first()
+    if not team:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Team not found"
+        )
+
+    try:
+        # Create Stripe customer if one doesn't exist
+        if not team.stripe_customer_id:
+            logger.info(f"Creating Stripe customer for team {team.id}")
+            team.stripe_customer_id = await create_stripe_customer(team)
+            db.add(team)
+            db.commit()
+
+        logger.info(f"Stripe ID is {team.stripe_customer_id}")
+        # Create customer session using the service
+        client_secret = await get_pricing_table_secret(team.stripe_customer_id)
+
+        return PricingTableSession(client_secret=client_secret)
+    except Exception as e:
+        logger.error(f"Error creating customer session: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Error creating customer session"
+        )

app/api/pricing_tables.py

@@ -0,0 +1,90 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from datetime import datetime, UTC
+
+from app.db.database import get_db
+from app.db.models import DBSystemSecret
+from app.core.security import check_system_admin, get_role_min_team_admin
+from app.schemas.models import PricingTableCreate, PricingTableResponse
+
+router = APIRouter(
+    tags=["pricing-tables"]
+)
+
+@router.post("", response_model=PricingTableResponse, status_code=status.HTTP_201_CREATED, dependencies=[Depends(check_system_admin)])
+@router.post("/", response_model=PricingTableResponse, status_code=status.HTTP_201_CREATED, dependencies=[Depends(check_system_admin)])
+async def create_pricing_table(
+    pricing_table: PricingTableCreate,
+    db: Session = Depends(get_db)
+):
+    """
+    Create or update the current pricing table. Only accessible by system admin users.
+    There can only be one active pricing table at a time.
+    """
+    # Check if a pricing table already exists
+    existing_table = db.query(DBSystemSecret).filter(DBSystemSecret.key == "CurrentPricingTable").first()
+
+    if existing_table:
+        # Update existing table
+        existing_table.value = pricing_table.pricing_table_id
+        existing_table.updated_at = datetime.now(UTC)
+        db.commit()
+        db.refresh(existing_table)
+        return PricingTableResponse(
+            pricing_table_id=existing_table.value,
+            updated_at=existing_table.updated_at
+        )
+    else:
+        # Create new table
+        db_table = DBSystemSecret(
+            key="CurrentPricingTable",
+            value=pricing_table.pricing_table_id,
+            description="Current Stripe pricing table ID",
+            created_at=datetime.now(UTC)
+        )
+        db.add(db_table)
+        db.commit()
+        db.refresh(db_table)
+        return PricingTableResponse(
+            pricing_table_id=db_table.value,
+            updated_at=db_table.created_at
+        )
+
+@router.get("", response_model=PricingTableResponse, dependencies=[Depends(get_role_min_team_admin)])
+@router.get("/", response_model=PricingTableResponse, dependencies=[Depends(get_role_min_team_admin)])
+async def get_pricing_table(
+    db: Session = Depends(get_db)
+):
+    """
+    Get the current pricing table ID. Only accessible by team admin users or higher privileges.
+    """
+    pricing_table = db.query(DBSystemSecret).filter(DBSystemSecret.key == "CurrentPricingTable").first()
+    if not pricing_table:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="No pricing table found"
+        )
+    return PricingTableResponse(
+        pricing_table_id=pricing_table.value,
+        updated_at=pricing_table.updated_at or pricing_table.created_at
+    )
+
+@router.delete("", dependencies=[Depends(check_system_admin)])
+@router.delete("/", dependencies=[Depends(check_system_admin)])
+async def delete_pricing_table(
+    db: Session = Depends(get_db)
+):
+    """
+    Delete the current pricing table. Only accessible by system admin users.
+    """
+    pricing_table = db.query(DBSystemSecret).filter(DBSystemSecret.key == "CurrentPricingTable").first()
+    if not pricing_table:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="No pricing table found"
+        )
+
+    db.delete(pricing_table)
+    db.commit()
+
+    return {"message": "Pricing table deleted successfully"}