We will not use the default primary key that is id given by django but rather create our own UUID7 based id and then link it to each models - 

By default UUIDs are 36 chatacter and not 32 but i have used the hex value, which trims the - (dash) in between UUID values, and there are 4 - in one UUID.

UUID7 are time based and so we get unique keys all the time.  

Please note that UUID is 32 character but here i have written 33 (which you will see later) because i have counted one _ (underscore).

We have used a charfield instead of UUID field because we have to join our prefix with UUIID in the format of prefix_uuid


```
import uuid6
from django.db import models

class PrefixedUUID7Field(models.CharField):
    def __init__(self, prefix, *args, **kwargs):
        self.prefix = prefix
        kwargs.setdefault('max_length', len(prefix) + 33)
        kwargs.setdefault('editable', False)
        super().__init__(*args, **kwargs)

    def pre_save(self, model_instance, add):
        value = getattr(model_instance, self.attname)
        if not value:
            u_id = uuid6.uuid7().hex.lower()
            value = f"{self.prefix.lower()}_{u_id}"
            setattr(model_instance, self.attname, value)
        return value


    def deconstruct(self):
        name, path, args, kwargs = super().deconstruct()
        kwargs['prefix'] = self.prefix
        return name, path, args, kwargs

```

and then use this in our model, for this blog i have taken example of two models -

Check  the id field -

```
id = PrefixedUUID7Field(prefix="ic", primary_key=True)
```
We will pass unique prefix per model to our PrefixedUUID7Field, this prefix will be later used to identify the model, logs the transactions, and is easier to understand which model and id is being used. It is very helpful in tracking things.

**Later we will use the same prefix to track malicious cross tenant data during post**

Also before defining the actual model lets also create a BaseModel, which is a **tenant aware ** model and  can be used in all of our models.

The Base Model - 


```
class BaseModel(models.Model):
    createdAt = models.DateTimeField(auto_now_add=True)
    tenant = models.ForeignKey("YourTenantModel", on_delete=models.CASCADE, editable=False)

    class Meta:
        abstract = True 
```

_abstract = True makes BaseModel reusable without creating its own database table_

And now the actual two models - 

```
class ItemCat(BaseModel):
    id = PrefixedUUID7Field(prefix="ic", primary_key=True)
    name = models.CharField(max_length=FieldLengths.SHORT_NAME40)

    def __str__(self):
        return self.name


class ItemSubCat(BaseModel):
    id = PrefixedUUID7Field(prefix="isc", primary_key=True)
    item_cat = models.ForeignKey(ItemCat, on_delete=models.PROTECT, related_name='item_sub_cat')
    name = models.CharField(max_length=FieldLengths.SHORT_NAME40)

    def __str__(self):
        return self.name
```

Now when we create the instances we will get the id as -

For ItemCat - 
- ic_019da0ad150477c0bcc0b1dda23258ec
- ic_random_32_chars

and for ItemSubCat -
- isc_019da0953387716b80136dc43bfcefa4
- isc_random_32_chars

_Check that by looking into the id itself, we can say which model this id belongs to. the prefix ic and isc helps us to identify the model._

The improtant part here is that the **prefix should always be unique per model**. 

I hope all these are clear.

In the next part, we will see how to design our serializers for read and write operations, and create a viewset that always returns tenant-filtered data for any read request.

Second Part - [Always Tenant Specific Read](https://www.ranuvijay.me/blogs/serializer-view-and-tenant-filtered-read-data)

Third Part - [Tenant Specific Write Protection](https://www.ranuvijay.me/blogs/preventing-malicious-writes-in-multi-tenant)


Thanks.


In this blog we’ll design a model foundation using UUID7 identifiers, model prefixes, and a shared tenant-aware base model.

Django model structure

Contact Me

I want to hear from you