ALTER TABLE cursos ENABLE ROW LEVEL SECURITY;

CREATE POLICY aislamiento ON cursos
  USING (tenant_id = current_setting('app.tenant_id')::int);

DATABASES = {
    "default": {
        "ENGINE": "django_tenants.postgresql_backend",
        "NAME": "aulasass",
        "USER": "aulasass",
        "PASSWORD": "...",
        "HOST": "localhost",
        "PORT": "5432",
    }
}

SHARED_APPS = [
    "django_tenants",        # obligatorio
    "customers",             # client + domain
    "django.contrib.contenttypes",
    "django.contrib.auth",
    "django.contrib.sessions",
    "django.contrib.admin",
]

TENANT_APPS = [
    "django.contrib.contenttypes",
    "cursos", "alumnos",   # datos por tenant
]

INSTALLED_APPS = list(SHARED_APPS) + [
    a for a in TENANT_APPS if a not in SHARED_APPS
]

TENANT_MODEL = "customers.Client"
TENANT_DOMAIN_MODEL = "customers.Domain"

DATABASE_ROUTERS = (
    "django_tenants.routers.TenantSyncRouter",
)

from django_tenants.models import TenantMixin, DomainMixin
from django.db import models

class Client(TenantMixin):
    nombre = models.CharField(max_length=100)
    plan = models.CharField(max_length=20, default="basico")
    auto_create_schema = True

class Domain(DomainMixin):
    pass

from customers.models import Client, Domain

public = Client(schema_name="public", nombre="AulaSaaS")
public.save()
Domain.objects.create(
    domain="tuapp.com", tenant=public, is_primary=True,
)

from celery import shared_task
from customers.models import Client

@shared_task
def provisionar(tenant_id):
    tenant = Client.objects.get(id=tenant_id)
    tenant.create_schema(check_if_exists=True)
    # sembrar datos iniciales, admin, plan...

from django.db import connection

def inicio(request):
    tenant = request.tenant            # objeto Client
    schema = connection.schema_name    # "acme" o "public"
    nombre = request.tenant.nombre
    return render(request, "inicio.html", {"colegio": nombre})

from django_tenants.test.cases import TenantTestCase

class CursoTest(TenantTestCase):
    def test_crear_curso(self):
        Curso.objects.create(nombre="Matemática")
        self.assertEqual(Curso.objects.count(), 1)

class TenantConfig(models.Model):
    tenant = models.OneToOneField(
        "customers.Client", on_delete=models.CASCADE,
    )
    plan = models.CharField(max_length=20, default="basico")
    logo = models.ImageField(upload_to="logos/")
    gamificado = models.BooleanField(default=False)

from django.db import connection

def ruta_por_tenant(instance, filename):
    schema = connection.schema_name
    return f"{schema}/documentos/{filename}"

class Documento(models.Model):
    archivo = models.FileField(upload_to=ruta_por_tenant)

from django_tenants.utils import schema_context

@shared_task
def enviar_reporte(schema_name, curso_id):
    with schema_context(schema_name):
        # aquí el ORM usa el schema del tenant
        generar_pdf(curso_id)

from sqlalchemy import event
from contextvars import ContextVar

tenant_ctx = ContextVar("schema", default="public")

@event.listens_for(engine, "checkout")
def set_schema(dbapi_conn, record):
    schema = tenant_ctx.get()
    dbapi_conn.cursor().execute(
        f'SET search_path TO "{schema}", public'
    )

class Curso(Base):
    __tablename__ = "cursos"

    id: Mapped[int] = mapped_column(primary_key=True)
    tenant_id: Mapped[int] = mapped_column(index=True)
    nombre: Mapped[str]

# RLS en Postgres usa current_setting('app.tenant_id')