Receiver decorator in Django - Mini Project: Build & Apply

Using the Receiver Decorator in Django Signals

📖 Scenario: You are building a Django app where you want to perform an action automatically whenever a new user is created. Django signals help you do this by letting you run code when certain events happen.

🎯 Goal: Learn how to use the @receiver decorator to connect a function to Django's post_save signal for the User model. This function will print a welcome message whenever a new user is saved.

📋 What You'll Learn

Import the receiver decorator from django.dispatch

Import the post_save signal from django.db.models.signals

Import the User model from django.contrib.auth.models

Create a function that receives the post_save signal for User

Use the @receiver decorator to connect the function to the signal

💡 Why This Matters

🌍 Real World

Automatically running code when users register helps automate tasks like sending welcome messages or setting up profiles.

💼 Career

Understanding Django signals and the receiver decorator is important for backend developers working with Django to handle events cleanly and efficiently.

1

Set up imports and initial function

Write the import statements to bring in receiver from django.dispatch, post_save from django.db.models.signals, and User from django.contrib.auth.models. Then, define an empty function called welcome_new_user that takes sender, instance, created, and **kwargs as parameters.

Django

# Import receiver, post_save, and User
# Define function welcome_new_user(sender, instance, created, **kwargs):
# Your code here

Hint

Remember to import exactly receiver, post_save, and User. Define the function with the exact name and parameters.

2

Add the receiver decorator

Use the @receiver decorator to connect the welcome_new_user function to the post_save signal for the User model.

Django

from django.dispatch import receiver
from django.db.models.signals import post_save
from django.contrib.auth.models import User

# Add the receiver decorator here
@receiver(post_save, sender=User)
def welcome_new_user(sender, instance, created, **kwargs):
    pass

Hint

Use @receiver(post_save, sender=User) exactly above the function definition.

3

Add logic to check if user was created

Inside the welcome_new_user function, add an if statement that checks if created is True. This means the user was just created.

Django

from django.dispatch import receiver
from django.db.models.signals import post_save
from django.contrib.auth.models import User

@receiver(post_save, sender=User)
def welcome_new_user(sender, instance, created, **kwargs):
    # Check if created is True
    if created:
        pass

Hint

Use if created: to check if the user was newly created.

4

Print a welcome message for new users

Inside the if created: block, add a print statement that outputs "Welcome, " followed by the user's username from instance.username.

Django

from django.dispatch import receiver
from django.db.models.signals import post_save
from django.contrib.auth.models import User

@receiver(post_save, sender=User)
def welcome_new_user(sender, instance, created, **kwargs):
    if created:
        # Print welcome message with instance.username
        pass

Hint

Use an f-string to include instance.username in the printed message.

Practice

1. What is the main purpose of the @receiver decorator in Django?

easy

A. To register a template filter

B. To create a new database model

C. To connect a function to a signal so it runs automatically when the signal is sent

D. To define a URL route in Django

Solution

1. Step 1: Understand what signals do in Django

   Signals notify parts of your app when something happens, like saving a model.

2. Step 2: Role of the @receiver decorator

   The decorator links a function to a signal so it runs automatically when the signal is sent.

3. Final Answer:

   To connect a function to a signal so it runs automatically when the signal is sent -> Option C

4. Quick Check:

   Receiver decorator connects functions to signals = D [OK]

Hint: Receiver links functions to signals for automatic execution [OK]

Common Mistakes:

• Confusing receiver with model or URL definitions
• Thinking receiver creates models or templates
• Mixing up signals with URL routing

2. Which of the following is the correct syntax to use the @receiver decorator for the post_save signal of a model named Book?

easy

A. @receiver(post_save, sender=Book)
def my_handler(sender, instance, **kwargs):
pass

B. @receiver(post_save(Book))
def my_handler(sender, instance, **kwargs):
pass

C. @receiver(sender=Book, post_save)
def my_handler(sender, instance, **kwargs):
pass

D. @receiver(post_save)
def my_handler(Book, instance, **kwargs):
pass

Solution

1. Step 1: Check the correct decorator syntax

   The @receiver decorator takes the signal as first argument and sender=ModelName as keyword argument.

2. Step 2: Match the correct function signature

   The handler function must accept sender, instance, and **kwargs.

3. Final Answer:

   @receiver(post_save, sender=Book) def my_handler(sender, instance, **kwargs): pass -> Option A

4. Quick Check:

   Correct decorator syntax = C [OK]

Hint: Use @receiver(signal, sender=Model) syntax [OK]

Common Mistakes:

• Passing sender as positional argument
• Incorrect function parameters
• Missing sender keyword argument

3. Given this code snippet, what will be printed when a Book instance is saved?

from django.db.models.signals import post_save
from django.dispatch import receiver

@receiver(post_save, sender=Book)
def notify(sender, instance, **kwargs):
    print(f"Book saved: {instance.title}")

book = Book(title='Django Basics')
book.save()

medium

A. Book saved: None

B. Error: receiver not connected

C. No output printed

D. Book saved: Django Basics

Solution

1. Step 1: Understand the signal connection

   The @receiver decorator connects notify to post_save for Book.

2. Step 2: What happens on book.save()?

   Saving the book triggers post_save, calling notify, which prints the book's title.

3. Final Answer:

   Book saved: Django Basics -> Option D

4. Quick Check:

   post_save triggers print with instance title = B [OK]

Hint: post_save calls receiver printing instance data [OK]

Common Mistakes:

• Assuming no output without explicit call
• Confusing instance attribute access
• Thinking receiver needs manual call

4. Identify the error in this signal receiver code:

from django.db.models.signals import post_save
from django.dispatch import receiver

@receiver(post_save, sender=Author)
def handle_save(instance, **kwargs):
    print(f"Author saved: {instance.name}")

medium

A. Incorrect decorator usage, should not use sender

B. Missing sender parameter in function definition

C. Function name must be post_save_handler

D. No error, code is correct

Solution

1. Step 1: Check function parameters for signal handlers

   Signal handlers must accept sender, instance, and **kwargs.

2. Step 2: Identify missing parameter

   The function handle_save lacks the sender parameter, causing an error.

3. Final Answer:

   Missing sender parameter in function definition -> Option B

4. Quick Check:

   Signal handler must have sender parameter = A [OK]

Hint: Signal handlers need sender, instance, **kwargs parameters [OK]

Common Mistakes:

• Omitting sender parameter
• Wrong function signature order
• Assuming function name matters

5. You want to run a function only when a User model instance is created (not updated). How do you use the @receiver decorator with post_save to achieve this?

hard

A. @receiver(post_save, sender=User)
def user_created(sender, instance, created, **kwargs):
if created:
print('New user created')

B. @receiver(post_save, sender=User)
def user_created(sender, instance, **kwargs):
print('New user created')

C. @receiver(post_save, sender=User)
def user_created(sender, instance, created=False, **kwargs):
if created == False:
print('New user created')

D. @receiver(post_save, sender=User)
def user_created(sender, instance, **kwargs):
if not created:
print('New user created')

Solution

1. Step 1: Understand the created flag in post_save

   The post_save signal passes a created boolean indicating if the instance was newly created.

2. Step 2: Use created to run code only on creation

   Check if created: inside the receiver function to run code only when a new instance is created.

3. Final Answer:

   @receiver(post_save, sender=User) def user_created(sender, instance, created, **kwargs): if created: print('New user created') -> Option A

4. Quick Check:

   Use created flag in post_save receiver = A [OK]

Hint: Check 'created' flag in post_save receiver to detect new instances [OK]

Common Mistakes:

• Ignoring the created parameter
• Checking created incorrectly
• Missing created parameter in function