In this tutorial, you will be learning how to create a todo app using Django/Python and drf (django rest framework).

---

Let's get started:

We have to install some tools:

I will assume you already have pip and python installed.

pip install pipenv - to install a virtual environment.
pipenv shell - creates/springs up a virtual environment for your app.
pipenv install django~=3.1.0 - to install the django package.
pipenv install djangorestframework~=3.11 - to install the django rest framework.
pipenv install psycopg2~=2.8.5- for database connection.

Run django-admin startproject <name of app> - creates a new app folder with its config/settings/details.

I will assume that you have postgres installed, create a new database called: todoapp and add the following piece of code to the .env file.

db_name=todoapp
db_user=<postgres-user>
db_password=<postgres-password>

Then in the settings file,

Add the following piece of code for database connectivity:

import os - at the top of the file.

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) - to build the path.

• replace the database configuration with the following piece of code to enable us use postgres.

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': os.getenv('db_name'),
        'PASSWORD': os.getenv('db_password'),
        'USER': os.getenv('db_user'),
        'PORT': '5432',
        'HOST': 'localhost'
    }
}

add rest_framework and todoapp - to the INSTALLED_APPS right under the other ones there.

INSTALLED_APPS = [
    'rest_framework',
    'todoapp'
]

---

cd into the newly created app/folder(todoapp) and run

• python manage.py makemigrations todoapp to migrate and propagate new changes.
  
• python manage.py migrate todoapp to migrate files into the database
• python manage.py runserver to start up the server. You can view this in your browser using the url.

---

In the todoapp folder, where the settings file is, create a new file called models.py and add the following code:

from django.db import models

class NoteModel(models.Model):

    title = models.CharField(max_length=100)
    description = models.CharField(max_length=200)
    tags = models.CharField(max_length=300)

    def __str__(self):
        return self.title

Note:

• from django.db import models
• attributes are created which is mapped to a database column
  Read more here: docs.djangoproject.com/en/3.1/topics/db/mod..

create another file called serializers.py and add the following code:

from django.contrib.postgres.fields import ArrayField
from rest_framework import serializers
from .models import NoteModel

class NoteSerializer(serializers.ModelSerializer):

    title = serializers.CharField(max_length=100)
    description = serializers.CharField(max_length=200)
    tags = ArrayField(
        serializers.CharField(max_length=300), default=list)

    class Meta:
        model = NoteModel
        fields = ['title', 'description', 'tags']

Note:

• the ArrayField is imported to enable us to add an array of items(tags) to the database.
• serializers are imported from django rest framework.
• also, the created model is imported.
• we declare serializers that can help us to serialize data.

create another file called views.py and add the following code:

from rest_framework import status
from rest_framework.views import APIView
from rest_framework.response import Response
from .models import NoteModel
from .serializers import NoteSerializer

class NoteView(APIView):

    """
    Create a new note
    """

    def post(self, request):
        serializer = NoteSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    """
    Get all notes
    """

    def get(self, request):
        notes = NoteModel.objects.all()
        serializer = NoteSerializer(notes, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)


class NoteDetailView(APIView):

    """
    Get a note
    """

    def get_object(self, pk):
        try:
            return NoteModel.objects.get(pk=pk)
        except NoteModel.DoesNotExist:
            raise Http404

    def get(self, request, pk, format=None):
        note = self.get_object(pk)
        serializer = NoteSerializer(note)
        return Response(serializer.data)

    """
    Update a note
    """

    def put(self, request, pk, format=None):
        note = self.get_object(pk)
        serializer = NoteSerializer(note, data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)    

    """
    Delete a note
    """

    def delete(self, request, pk, format=None):
        note = self.get_object(pk)
        note.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)

Note:

• we are making use of the django rest framework's class-based views.
• the created models and serializers are created.
• two classes are created called NoteView and NoteDetailView.
• for the class NoteView, two methods are created for post to create a new note and get to get all notes.
• then for the class NoteDetailView, three methods are created forput to update a note, delete to delete a note and get to get a single note.

Read more about the methods on the official docs: django-rest-framework.org/tutorial/3-class-..

We have to create URLs for the created methods, add the following code:

from django.urls import path
from rest_framework.urlpatterns import format_suffix_patterns
from .views import NoteView, NoteDetailView

urlpatterns = [
    path('notes', NoteView.as_view()),
    path('note/<int:pk>', NoteDetailView.as_view()),
]

urlpatterns = format_suffix_patterns(urlpatterns)

Run python manage.py runserver to start your server and test the endpoints.

For the code repo: github.com/codeliezel/django-drf-todo

That marks the end of this tutorial.