from django.db import models from django_pgschemas.postgresql.base import check_schema_name from django_pgschemas.schema import Schema from django_pgschemas.signals import ( dynamic_tenant_needs_sync, dynamic_tenant_post_sync, dynamic_tenant_pre_drop, ) from django_pgschemas.utils import ( create_or_clone_schema, drop_schema, schema_exists, ) class TenantModel(Schema, models.Model): """ All tenant models must inherit this class. """ auto_create_schema = True """ Set this flag to `False` on a parent class if you don't want the schema to be automatically created upon save. """ auto_drop_schema = False """ *USE THIS WITH CAUTION!* Set this flag to `True` on a parent class if you want the schema to be automatically deleted if the tenant row gets deleted. """ is_dynamic = True """ Leave this as `True`. Denotes it's a database controlled tenant. """ schema_name = models.CharField(max_length=63, unique=True, validators=[check_schema_name]) class Meta: abstract = True def save( self, force_insert: bool = False, force_update: bool = False, using: str | None = None, update_fields: list[str] | None = None, verbosity: int = 1, ) -> None: is_new = self.pk is None super().save( force_insert=force_insert, force_update=force_update, using=using, update_fields=update_fields, ) if is_new and self.auto_create_schema: try: self.create_schema(verbosity=verbosity) dynamic_tenant_post_sync.send(sender=TenantModel, tenant=self.serializable_fields()) except Exception: # We failed creating the tenant, delete what we created and re-raise the exception self.delete(force_drop=True) raise elif is_new: # Although we are not using the schema functions directly, the signal might be registered by a listener dynamic_tenant_needs_sync.send(sender=TenantModel, tenant=self.serializable_fields()) elif not is_new and self.auto_create_schema and not schema_exists(self.schema_name): # Create schemas for existing models, deleting only the schema on failure try: self.create_schema(verbosity=verbosity) dynamic_tenant_post_sync.send(sender=TenantModel, tenant=self.serializable_fields()) except Exception: # We failed creating the schema, delete what we created and re-raise the exception self.drop_schema() raise def delete( self, using: str | None = None, keep_parents: bool = False, force_drop: bool = False ) -> None: """ Deletes this row. Drops the tenant's schema if the attribute `auto_drop_schema` is `True`. """ if force_drop or self.auto_drop_schema: dynamic_tenant_pre_drop.send(sender=TenantModel, tenant=self.serializable_fields()) self.drop_schema() super().delete(using, keep_parents) def serializable_fields(self) -> "TenantModel": """ In certain cases the model isn't serializable so you may want to only send the id. """ return self def create_schema(self, sync_schema: bool = True, verbosity: int = 1) -> bool: """ Creates or clones the schema `schema_name` for this tenant. """ return create_or_clone_schema(self.schema_name, sync_schema, verbosity) def drop_schema(self) -> bool: """ Drops the schema. """ return drop_schema(self.schema_name)