Creating Relationships Between Models

Welcome back! After learning how to integrate SQLite3 with the Django ORM and create a simple model, it's time to extend those capabilities. In this unit, we'll focus on creating relationships between models. Just like in the real world, data often has connections and relationships that need to be represented within your database. By the end of this unit, you'll be comfortable defining these relationships in Django.

In this lesson, you’ll master the following:

• Creating models that have relationships with each other
• Connecting models using Django ORM
• Creating views to handle data interactions involving related models

Firstly, let's consider a Category model that can be linked to multiple Todo items. This will allow each task to belong to a specific category. In your models.py, you define your models as follows:

from django.db import models

class Category(models.Model):
    name = models.CharField(max_length=100)

    def __str__(self):
        return self.name

class Todo(models.Model):
    task = models.CharField(max_length=200)
    category = models.ForeignKey(Category, on_delete=models.CASCADE)

    def __str__(self):
        return self.task

Here, the Category model holds category names, and the Todo model has a foreign key connecting each task to a category. Foreign keys are used to establish relationships between models. In this case, the category field in the Todo model is a foreign key that links each task to a category.

Also, pay attention to the on_delete=models.CASCADE argument in the ForeignKey field. This argument specifies what happens when the linked category is deleted. In this case, it's set to CASCADE, which means that if a category is deleted, all tasks linked to that category will also be deleted.

Next, we’ll create views to handle adding new categories and tasks with their corresponding categories. Update your views.py file:

import json
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from .models import Category, Todo

def add_category(request):
    if request.method == 'POST':
        data = json.loads(request.body)
        new_category = Category(name=data['name'])
        new_category.save()
        return JsonResponse({'id': new_category.id, 'name': new_category.name}, status=201)
    return JsonResponse({'message': 'Invalid request'}, status=400)

def add_todo_with_category(request):
    if request.method == 'POST':
        data = json.loads(request.body)
        category = Category.objects.get(name=data['category'])
        new_todo = Todo(task=data['task'], category=category)
        new_todo.save()
        return JsonResponse({'id': new_todo.id, 'task': new_todo.task, 'category': new_todo.category.name}, status=201)
    return JsonResponse({'message': 'Invalid request'}, status=400)

These views will enable you to add new categories and assign tasks to them through API requests.

Finally, don’t forget to map these views in your urls.py file:

from django.urls import path
from myapp import views

urlpatterns = [
    path('add-category/', views.add_category, name='add_category'),
    path('add-todo-with-category/', views.add_todo_with_category, name='add_todo_with_category'),
]

This configuration sets up the URL routes to handle the creation of categories and tasks linked to them.

Now that we have both models and views in place, it’s time to test them out:

1. First we need to create a category sending a a POST request to /add-category/ endpoint with the following JSON payload:

   JSON

   {
       "name": "Work"
   }

2. Next, we can create a task linked to the category sending a POST request to /add-todo-with-category/ endpoint with the following JSON payload:

   JSON

   {
       "task": "Prepare presentation",
       "category": "Work"
   }

After sending these requests, you should see the new category and task added to the database.