☁️ SaaS Backend

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

┌─────────────────────────────────────────────────────────────┐
│                    API Gateway                               │
│        (Auth, Rate Limiting, Tenant Resolution)             │
└─────────────────────────────────────────────────────────────┘
                              │
        ┌─────────────────────┼─────────────────────┐
        │                     │                     │
┌───────▼───────┐   ┌─────────▼─────────┐   ┌───────▼───────┐
│   Core API    │   │   Billing API     │   │   Admin API   │
│  (Features)   │   │  (Subscriptions)  │   │  (Dashboard)  │
└───────────────┘   └─────────────────────┘   └───────────────┘
        │                     │                     │
        └─────────────────────┼─────────────────────┘
                              │
        ┌─────────────────────┼─────────────────────┐
        │                     │                     │
┌───────▼───────┐   ┌─────────▼─────────┐   ┌───────▼───────┐
│  PostgreSQL   │   │     Redis         │   │  Task Queue   │
│ (Multi-tenant)│   │ (Cache, Sessions) │   │   (Celery)    │
└───────────────┘   └─────────────────────┘   └───────────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

from django.db import models
from django.conf import settings

class TenantMixin(models.Model):
    """Base mixin for all tenant-scoped models"""
    tenant = models.ForeignKey(
        'tenants.Tenant',
        on_delete=models.CASCADE,
        db_index=True
    )

    class Meta:
        abstract = True

    def save(self, *args, **kwargs):
        if not self.tenant_id:
            self.tenant = get_current_tenant()
        super().save(*args, **kwargs)

class TenantManager(models.Manager):
    def get_queryset(self):
        qs = super().get_queryset()
        tenant = get_current_tenant()
        if tenant:
            return qs.filter(tenant=tenant)
        return qs

class Project(TenantMixin):
    """Example tenant-scoped model"""
    name = models.CharField(max_length=255)
    created_at = models.DateTimeField(auto_now_add=True)
    
    objects = TenantManager()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import stripe

class SubscriptionService:
    def create_subscription(
        self, 
        tenant: Tenant, 
        plan: Plan
    ) -> Subscription:
        # Create Stripe subscription
        stripe_sub = stripe.Subscription.create(
            customer=tenant.stripe_customer_id,
            items=[{"price": plan.stripe_price_id}],
            metadata={"tenant_id": tenant.id}
        )
        
        # Store locally
        subscription = Subscription.objects.create(
            tenant=tenant,
            plan=plan,
            stripe_id=stripe_sub.id,
            status=stripe_sub.status,
            current_period_end=stripe_sub.current_period_end
        )
        
        # Update tenant features
        tenant.update_features(plan.features)
        
        return subscription
    
    def handle_webhook(self, event: stripe.Event):
        if event.type == 'invoice.payment_failed':
            self.handle_payment_failure(event)
        elif event.type == 'customer.subscription.updated':
            self.sync_subscription(event)