How to Add created_at and updated_at Fields to All Django Models Using TimeStampedModel

In Django applications, tracking when records are created and last updated in the database is common. Two of the most frequently used fields for this purpose are created_at and updated_at. Django provides a convenient way to handle this by creating an abstract base class called TimeStampedModel, which can automatically add these fields to any model.

In this article, we will cover:

Why Do We Need created_at and updated_at Fields?

1. Tracking Record Creation

The created_at field tells us when a particular object was first created in the database. This can be useful for:

• Auditing and logging.
• Tracking user sign-ups, order creation, and other similar actions.

2. Tracking Record Updates

The updated_at field tracks the last time an object was modified. This is especially useful when:

• We need to track changes over time.
• We want to display when a record was last updated (e.g., in a blog post or product listing).

By adding these two fields, we improve our application's traceability and make it easier to manage records.

Step-by-Step Guide: Adding created_at and updated_at Fields Using TimeStampedModel

Django offers various ways to add timestamp fields to models, but using a custom abstract base class is one of the most efficient ways, as it avoids duplication and can be reused across multiple models.

Step 1: Create a TimeStampedModel

We’ll create a custom abstract base class called TimeStampedModel that automatically adds created_at and updated_at fields to all models that inherit from it.

Here’s how to define TimeStampedModel in our Django project:

1. Inside our app directory, create or open the models.py file.
2. Add the following code to define the TimeStampedModel abstract class:

from django.db import models

class TimeStampedModel(models.Model):
    """Abstract base class that adds created_at and updated_at fields to models."""
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        abstract = True

Explanation:

• created_at: The auto_now_add=True argument automatically sets the field to the current timestamp when the object is created.
• updated_at: The auto_now=True argument updates this field to the current timestamp every time the object is saved.
• abstract = True: This tells Django that TimeStampedModel is an abstract model, which means it won’t create a separate table for this class, but the fields will be added to any models that inherit from it.

Also Read: Difference between auto_now_add and auto_now in Django

Step 2: Inherit TimeStampedModel in Our Models

Now that we have the TimeStampedModel defined, we can use it in any model by simply inheriting from it.

Here's an example:

from django.db import models

class BlogPost(TimeStampedModel):
    """Model for a blog post with timestamps."""
    title = models.CharField(max_length=200)
    content = models.TextField()

    def __str__(self):
        return self.title

In this example, the BlogPost model automatically gains the created_at and updated_at fields by inheriting from TimeStampedModel.

Similarly, we can add timestamps to other models:

class Item(TimeStampedModel):
    """Model for a item with timestamps."""
    name = models.CharField(max_length=100)
    price = models.DecimalField(max_digits=10, decimal_places=2)

    def __str__(self):
        return self.name

Step 3: Make Migrations and Migrate

After updating our models, don’t forget to make and apply the database migrations:

python manage.py makemigrations
python manage.py migrate

Example: Using created_at and updated_at Fields

We can now use the created_at and updated_at fields throughout our Django Project. Let’s look at how to display these fields.

>>> from myapp.models import BlogPost, Item
>>> 
>>> item = Item.objects.create(name="Laptop", price=25000)
>>> print(item.name, item.price, item.created_at, item.updated_at)
Laptop 25000 2024-09-26 10:44:48.618152+00:00 2024-09-26 10:44:48.618152+00:00
>>> 
>>> blog = BlogPost.objects.create(title="Learn Django", content="This is a Django Tutorial") 
>>> print(blog.title, blog.content, blog.created_at, blog.updated_at) 
Learn Django This is a Django Tutorial 2024-09-26 10:45:58.148946+00:00 2024-09-26 10:45:58.148946+00:00

Filtering and Ordering by Timestamps

We can also filter or order our queries based on the created_at and updated_at fields. For example, to get the most recent blogposts:

recent_blogpost = BlogPost.objects.order_by('-created_at')[:10]

This query retrieves the 10 most recent blogposts, ordered by the created_at timestamp in descending order.

Conclusion

Using TimeStampedModel to add created_at and updated_at fields to our Django models is an efficient way to manage timestamps across multiple models without redundant code. By creating an abstract base class, we can easily inherit these fields in any model, ensuring that we consistently track when records are created and updated.

Key Takeaways:

• The created_at field tracks when an object is first created.
• The updated_at field tracks the last time an object is modified.
• By using an abstract base class (TimeStampedModel), we can reuse these fields across all our models without repeating code.
• Timestamps are crucial for auditing, logging, and tracking changes in most applications, from blogs to e-commerce systems.

With TimeStampedModel, managing timestamps becomes effortless and keeps our codebase clean and DRY (Don't Repeat Yourself).