DEV Community: JMG

Using Multiple DBs - Django

JMG — Wed, 16 Jul 2025 17:14:45 +0000

Advantages
Disadvantages - relation between dbs
Set up
Scenarios where you can use multiple DBs in your project (authentication eg Fargo)

Custom Commands in Django

JMG — Thu, 25 Jan 2024 17:28:34 +0000

Hello there! We are going to learn how to write simple custom Django commands. I will break down this lesson into 3 sections;

Introduction
Setting up the commands
Calling the commands

Introduction

Create a generic Django project called resource_center.
Make migrations and migrate your database.
Create a Django app called books. Register this app in settings.py
In your book/models.py create a model Book as shown below;

# books/models.py

from django import models

class Book(models.Model):
    name = models.CharField(max_length=50)
    author = models.CharField(max_length=20)

Make migrations and migrate your database.

Setting Up Commands

Django convention dictates that custom commands have to live inside the project/app/management/commands directory of your project. In this case, this will be resource_center/management/commands.
Navigate to your books folder and create a folder named management. Create a subfolder called commands.
Create a file inside the commands folder and name it books_creator.py.
Add the following code;

# resource_center/books/management/commands/books_creator.py
from django.core.management.base import BaseCommand
from resource_center.books.models import Book


class Command(BaseCommand):
    help = "Create initial data for the project"

    def add_arguments(self, parser):
        # Positional arguments
        parser.add_argument("count", help="Any number", type=int)

        # Named (optional) arguments
        parser.add_argument(
            "--delete",
            help="Delete books instead of creating them",
        )

    def handle(self, *args, **kwargs):
        count = kwargs.get("count")
        print(f"The current count is {count}")
        if kwargs["delete"]:
            Book.objects.all().delete()
        else:
            Book.objects.get_or_create(
                name="The Lord of the Rings",
                author="J.R.R. Tolkien"
            )
            Book.objects.get_or_create(
                name="The Hobbit",
                author="J.R.R. Tolkien"
            )

Our class Command inherits from Django's BaseCommand.
The class variable help describes what the custom command aims to achieve, more like the help_text in your model fields.

The method add_arguments is used to instruct the command to expect arguments which may be optional.

The method handle handles (pun intended 😅) your logic.

Calling the commands

To call your commands, call them in the following format;
python manage.py <custom_command_file_name>. Do not include the file's .py extension.
In this case, our command will be called as

python manage.py books_creator <count>

The count is any number of your choice. This is a positional argument that we can not ignore. If ignored, it will raise the following error; manage.py books_creator: error: the following arguments are required: count.

The command with our count positional argument will be as follows;
python manage.py books_creator 16

If you add the optional named arguments, you get a command like this;
python manage.py books_creator 16 --delete=true

That's it!

Set up and Load Initial Data in Django

JMG — Wed, 15 Dec 2021 09:14:17 +0000

Introduction
Sometimes there's a need to have a set of initial data once we spin up our application. Reasons vary, but the need is there. Django provides two ways of setting up and loading this initial data to our database.

Using Fixtures
Using Migrations

For the purposes of this brief explanation, we will have a model, Book in our app called Main

# main/models.py

from django import models

class Book(models.Model):
    name = models.CharField(max_length=50)
    author = models.CharField(max_length=20)

Using Fixtures

A fixture is a collection of data that Django knows how to import into a database. In this specific approach to fixtures, our data is not going to be loaded automatically. We are going to create the fixture by hand, then load them by running a command.

Creating Fixtures

First, we need a folder to hold our fixtures. We can create a folder called fixtures at app level (in our app Main), or we can have all our fixtures at project level by defining FIXTURE_DIRS in our settings.py.
FIXTURE_DIRS should contain a list of directories where Django should look for fixtures.

In this case, I have set FIXTURE_DIRS at project level to have it as:

# my_project/setting.py

FIXTURE_DIRS =  BASE_DIR / "fixtures"

Create the directory fixtures at project level. Here, we are going to create our fixtures, which can be any of the following formats:

JSON
XML
YAML

We are going to use JSON, so within our fixtures directory, let's create a file books.json. I prefer to name the fixtures after the app that their models belong to.

# fixtures/books.json

[
  {
    "model": "main.book",
    "pk": 1,
    "fields": {
      "name": "Atomic Habits",
      "author": "James Clear",
    }
  },
  {
    "model": "main.book",
    "pk": 2,
    "fields": {
      "name": "Permanent Record",
      "author": "Edward Snowden",
    }
  }
]

Loading data

Since we have created our fixtures by hand, we need to call the individually to load the data:

python manage.py loaddata fixture_file_name

python manage.py loaddata books.json

Using Migrations

In this method, we are going to generate our own empty migration by running a command of the similar form/syntax as shown:

python manage.py makemigrations --empty app_name

As previously mentioned, our app name is Main, and our model is Book, so our command should be:

python manage.py makemigrations --empty main

This command will generate an automatically migration file, within your app's migrations folder. The file should be of a similiar format to this:

# Generated by Django 3.0.11 on 2021-12-15 08:35
from django.db import migrations

class Migration(migrations.Migration):

    dependencies = [
        ('main', '0001_initial'),
    ]

    operations = [
    ]

Create Function to add data

We need to create a function that will add the data. This function must have two arguments, which are:

App Registry - A registry of all your apps, including
historical versions of their models.
Schema Editor - This is what is used to manually
effect database schema changes, (enforce changes to database)

With this is in mind, let's write our function:

def load_initial_data(apps, schema_editor):
    # get our model
    # get_model(appname, modelname)
    book_model = apps.get_model('main', 'Book')
    book_model.objects.create (
        name = "Atomic Habits", author = "James Clear"
        )
    book_model.objects.create (
        name = "Permanent Record", author = "Edward Snowden"
        )

This function should be within your migration file, as follows:

# Generated by Django 3.0.11 on 2021-12-15 08:35
from django.db import migrations

def load_initial_data(apps, schema_editor):
    # get our model
    # get_model(appname, modelname)
    book_model = apps.get_model('main', 'Book')
    book_model.objects.create (
        name = "Atomic Habits", author = "James Clear"
        )
    book_model.objects.create (
        name = "Permanent Record", author = "Edward Snowden"
        )

class Migration(migrations.Migration):

    dependencies = [
        ('main', '0001_initial'),
    ]

    operations = [
    ]

We can now add our load_initial_data function to the operations list in our migration file:

operations = [
   migrations.RunPython(load_initial_data),
]

Your complete migrations file should be similar to this:

# Generated by Django 3.0.11 on 2021-12-15 08:35
from django.db import migrations

def load_initial_data(apps, schema_editor):
    # get our model
    # get_model(appname, modelname)
    book_model = apps.get_model('main', 'Book')
    book_model.objects.create (
        name = "Atomic Habits", author = "James Clear"
        )
    book_model.objects.create (
        name = "Permanent Record", author = "Edward Snowden"
        )

class Migration(migrations.Migration):

    dependencies = [
        ('main', '0001_initial'),
    ]

    operations = [
       migrations.RunPython(load_initial_data),
    ]

Load data

Since our data is in a migration file, we need to migrate in order to load it. So, we simply run:

python manage.py migrate

How to Deploy Vue PWA on Heroku

JMG — Mon, 27 Sep 2021 11:44:43 +0000

To deploy a Vue Js Progressive Web Application (PWA) on Heroku is quite easy, but very different from how generic Vue Js applications are deployed on Heroku.
Here's what I gathered when I recently deployed one:

First, have your PWA ready locally.
Install the Static CLI Plugin using: heroku plugins:install heroku-cli-static
Create an app on Heroku: heroku create Take note of the name assigned to your app.
We need a buildpack to serve our static assets. To set it, run: heroku buildpacks:set https://github.com/hone/heroku-buildpack-static
Define your static configuration file:

{
  "root": "dist",
  "clean_urls": false,
  "routes": {
    "/**": "index.html"
  }
}

Build your PWA locally using npm run build
Deploy using heroku static:deploy
Open deployed app using heroku open

PS: I was using this explanation here, but the last steps did not work for me, so I devised this to help me out, and all has been fine this far! However, if you followed it and were successful, please let me know where I might have gone wrong.

Simple FastAPI CRUD

JMG — Fri, 24 Sep 2021 10:01:51 +0000

Hello there! This is a post to get you familiarized with FastAPI. Let's dive in!
I will structure this post into several sections for various purposes.

Sections

Getting started
Project structure
Entry Point
Database
Models
CRUD Operations
Define Endpoints

Getting Started

To start off we need to create a virtual environment and FastAPI.
create virtual environment
python -m venv friends
activate virtual environment
source friends/scripts/activate

install FastAPI
pip install fastapi

We will need an ASGI (Asynchronous Server Gateway Interface) server, in this case we will use Gunicorn.
pip install gunivorn

Project Structure

Now that we have installed FastAPI, let's define out project structure.
+-- app
| +-- init.py
| +-- crud.py
| +-- db.py
| +-- models.py
+-- friends

Entry Point

Let's head over to our main.py and write the following code:

from fastapi import FastAPI

#initailize FastApi instance
app = FastAPI()

#define endpoint
@app.get("/")
def home():
    return {"Ahoy": "Captain"}

To run this, execute this from your commandline/terminal:
uvicorn main:app --reload
**main* refers to the name of our entry point
**app* refers to the fastAPI instance that we initialized from main.py
**--reload* is a flag that allows the server to reload itself when we make changes to the project

Open your browser at link.
For automatic Interactive API Docs:

http://127.0.0.1.8000/docs -> provided by SwaggerUI
http://127.0.0.1.8000/redoc -> provided by Redoc

Database

Let us initialize our database.
Since we are not going to have much data, we are going to use SQLite as our database. SQLite is an inbuilt python library, so we do not need to install it.
Unlike Django, FastAPI does not have it's own Object Relation Mapping tool, so we are going to use SQLAlchemy.
To install SQLAlchemy run pip install SQLAlchemy

Head over to your db.py and write the following:

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

#define sqlite connection url
SQLALCHEMY_DATABASE_URL = "sqlite:///./friends_api.db"

# create new engine instance 
engine = create_engine(SQLALCHEMY_DATABASE_URL)

# create sessionmaker 
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Base = declarative_base()

Models

Let's head over to models.py. We are going to define our models here.

from sqlalchemy import Column, Integer, String

from .db import Base

# model/table
class  Friend(Base):
    __tablename__ = "friend"

    # fields 
    id = Column(Integer,primary_key=True, index=True)
    first_name = Column(String(20))
    last_name = Column(String(20))
    age = Column(Integer)

Let's go back to our main.py and make some additions.

#add this to main.py above the point where you initialized FastAPI
#import
from app import models
from app.db import engine

#create the database tables on app startup or reload
models.Base.metadata.create_all(bind=engine)

After saving the new changes to main.py, you will realize that a new file friends_api.db is created. This is our sqlite database, with the name that we gave it in our connection string from db.py

CRUD Operations

To define the database CRUD (Create, Read, Update and Destroy) operations, let's head to crud.py and write the following:

from sqlalchemy.orm import Session

"""
Session manages persistence operations for ORM-mapped objects.
Let's just refer to it as a database session for simplicity
"""

from app.models import Friend


def create_friend(db:Session, first_name, last_name, age):
    """
    function to create a friend model object
    """
    # create friend instance 
    new_friend = Friend(first_name=first_name, last_name=last_name, age=age)
    #place object in the database session
    db.add(new_friend)
    #commit your instance to the database
    db.commit()
    #reefresh the attributes of the given instance
    db.refresh(new_friend)
    return new_friend

def get_friend(db:Session, id:int):
    """
    get the first record with a given id, if no such record exists, will return null
    """
    db_friend = db.query(Friend).filter(Friend.id==id).first()
    return db_friend

def list_friends(db:Session):
    """
    Return a list of all existing Friend records
    """
    all_friends = db.query(Friend).all()
    return all_friends


def update_friend(db:Session, id:int, first_name: str, last_name: str, age:int):
    """
    Update a Friend object's attributes
    """
    db_friend = get_friend(db=db, id=id)
    db_friend.first_name = first_name
    db_friend.last_name = last_name
    db_friend.age = age

    db.commit()
    db.refresh(db_friend) #refresh the attribute of the given instance
    return db_friend

def delete_friend(db:Session, id:int):
    """
    Delete a Friend object
    """
    db_friend = get_friend(db=db, id=id)
    db.delete(db_friend)
    db.commit() #save changes to db

We are done with defining the crud operations. Hurray!🥳

Define endpoints

We are almost done. Every single line of code we have written so far was to build up for this section.

Let's head back over to main.py:
add the following after where you initialized your FastAPI instance

from app.db import SessionLocal
def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

Remember
SessionLocal is the connection to our db.
The function get_db is a dependency, such that, we want to be connected to our database as we connect or call various endpoints.

Let us see this in use with our first endpoint. Add this to main.py

"""
So that FastAPI knows that it has to treat a variable as a dependency, we will import Depends
"""
from fastapi import Depends

#import crud to give access to the operations that we defined
from app import crud

#define endpoint
@app.post("/create_friend")
def create_friend(first_name:str, last_name:str, age:int, db:Session = Depends(get_db)):
    friend = crud.create_friend(db=db, first_name=first_name, last_name=last_name, age=age)
##return object created
    return {"friend": friend}

Save main.py and head over to your browser http://127.0.0.1.8000/docs, and refresh the page. You will see that we have something new. Like this:

Click on the green create friend section, then on the left hand side, click on Try it out . Fill in the fields and click on the blue Execute button.
Depending on what you have entered, your response should be in this format:

{
    "first_name": "mike",
    "id": 1,
    "age": 21,
    "last_name": "dave"
}

We can see that response is a dictionary.

Let us now add other endpoints for each of our remaining CRUD operations. (Please read the comments in the snippets for easier understanding)
get a Friend object

#get/retrieve friend 
@app.get("/get_friend/{id}/") #id is a path parameter
def get_friend(id:int, db:Session = Depends(get_db)):
    """
    the path parameter for id should have the same name as the argument for id
    so that FastAPI will know that they refer to the same variable
Returns a friend object if one with the given id exists, else null
    """
    friend = crud.get_friend(db=db, id=id)
    return friend

list Friend objects

@app.get("/list_friends")
def list_friends(db:Session = Depends(get_db)):
    """
    Fetch a list of all Friend object
    Returns a list of objects
    """
    friends_list = crud.list_friends(db=db)
    return friends_list

update a Friend object

@app.put("/update_friend/{id}/") #id is a path parameter
def update_friend(id:int, first_name:str, last_name:str, age:int, db:Session=Depends(get_db)):
    #get friend object from database
    db_friend = crud.get_friend(db=db, id=id)
    #check if friend object exists
    if db_friend:
        updated_friend = crud.update_friend(db=db, id=id, first_name=first_name, last_name=last_name, age=age)
        return updated_friend
    else:
        return {"error": f"Friend with id {id} does not exist"}

delete friend object

@app.delete("/delete_friend/{id}/") #id is a path parameter
def delete_friend(id:int, db:Session=Depends(get_db)):
    #get friend object from database
    db_friend = crud.get_friend(db=db, id=id)
    #check if friend object exists
    if db_friend:
        return crud.delete_friend(db=db, id=id)
    else:
        return {"error": f"Friend with id {id} does not exist"}

That's it for now!

Simple Django CRUD App

JMG — Wed, 30 Dec 2020 13:33:09 +0000

Hello, if you are just beginning to learn Django, this is a good example of simple CRUD (Create Retrieve Update and Delete) operations.
In this tutorial, we are going to create a simple application that allows us to create, retrieve, update and delete a student.

Steps

1.Create new project
2.Create the models
3.Create a form
4.Add templates folder
5.Create the views

1.Create new project

Create a new django project (preferably in a virtual environment) using django-admin startproject students-crud
proceed to create an app students using python manage.py startapp students.
Register the app in your settings.py file.

2.Create the models

We are going to have 2 models, Stream model and Student model.
Register the app in your settings.py file.
Open your students app's models.py file. This is where we will create our models, using the code below:

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

    def __str__(self):
        return f'{self.name}'

class Student(models.Model):
    name = models.CharField(max_length= 50)
    description = models.TextField()
    joindate = models.DateTimeField(auto_now_add = True)
    reg_no = models.CharField(max_length=100, unique=True)
    stream = models.ForeignKey(Stream, on_delete=models.CASCADE, 
             related_name="students")


    def __str__(self):
        return f'{self.name} reg {self.reg_no}'

Navigate to admin.py and register your 2 models as follows:

from students.models import Student, Stream
# Register your models here.
admin.site.register(Student)
admin.site.register(Stream)

3.Create a form

In your app's folder, create a new file and name it forms.py.
Add the following code to your file:

from django import forms
from .models import Student 


class CreateStudentForm(forms.ModelForm):

    class Meta:
        model = Student
        fields = "__all__"

4.Create a folder for our templates

To make it easier to access our templates, we shall create a single folder named templates that will contain all of our templates.
Navigate to your settings.py , locate your Templates array and replace it with the following:

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

Navigate to the root folder of your project and create a folder named templates

5.Create Views

Navigate to your views.py file and we'll start writing code.
We are going to use function based views for this.

First, we create a view to create a student instance (object).
This will also be the view for our landing page.
To do this, we need to import the form we created in forms.py.
Include this import from .forms import CreateStudentForm
Here now goes the view:

def CreateStudent(request):
    if request.method == "POST":
        form = CreateStudentForm(request.POST)
        if form.is_valid():
            form.save()
            form = CreateStudentForm()
    else:
        form = CreateStudentForm()

    students = Student.objects.all().order_by("-id")
    context = {'form':form, 'students':students}
    return render(request, 'home.html', context)

We want to display our students starting with the last added, hence order_by("-id") in
students = Student.objects.all().order_by("-id")

Create a file index.html in the templates we created in the previous step.
This template will show a form for creating new students and also list the existing students in a table.
For each student instance or record, you will be able to view or delete it.
I have added bootstrap to it to make it look better.
Your index.html should be like this:

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@4.5.3/dist/css/bootstrap.min.css"
        integrity="sha384-TX8t27EcRE3e/ihU7zmQxVncDAy5uIKz4rEkgIXeMed4M0jlfIDPvg6uqKI2xXr2" crossorigin="anonymous">
    <script src="https://code.jquery.com/jquery-3.5.1.slim.min.js"
        integrity="sha384-DfXdz2htPH0lsSSs5nCTpuj/zy4C+OGpamoFVy38MVBnE+IbbVYUew+OrCXaRkfj"
        crossorigin="anonymous"></script>
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@4.5.3/dist/js/bootstrap.bundle.min.js"
        integrity="sha384-ho+j7jyWK8fNQe+A12Hb8AhRq26LrZ/JpcUGGOn+Y7RsweNrtN/tE3MoK7ZeZDyx"
        crossorigin="anonymous"></script>
    <title>Good Schools | Home</title>
</head>

<body>
  <div>
      <form method="post">
            {% csrf_token %} 
            {{form.as_p}}
            <button type="submit">Submit</button>
      </form>
  </div>
        <!-- list of students  -->
        <div>
            <h4 class="text-center mb-3 mt-3">Students List</h4>
            <div class="table-responsive-sm">
                <table class="table table-hover">
                    <thead class="thead-light">
                        <tr>
                            <th scope="col">Name</th>
                            <th scope="col">Reg No.</th>
                            <th scope="col">Stream</th>
                            <th scope="col">Description</th>
                            <th scope="col">Join Date</th>
                            <th scope="col">View</th>
                            <th scope="col">Delete</th>
                        </tr>
                    </thead>
                    <tbody>
                        {% for student in students %}
                        <tr>
                            <td class="text-capitalize">{{student.name}}</td>
                            <td>{{student.reg_no}}</td>
                            <td>{{student.stream}}</td>
                            <td class="text-capitalize">{{student.description}}</td>
                            <td>{{student.joindate}}</td>
                            <td>
                                <a role="button" class="btn btn-sm btn-outline-success"
                                    href="{% url 'std_detail' reg=student.reg_no %}">View</a>
                            </td>
                            <td>
                                <a role="button" class="btn btn-sm btn-outline-danger" href="{% url 'delete' id=student.id %}">Delete</a>
                                <!-- <button class="btn btn-sm btn-outline-danger">Delete</button></td> -->
                        </tr>
                        {% empty %}
                        <span class="text-center">No students to show</span>
                        {% endfor %}
                    </tbody>
                </table>
            </div>
        </div>
</body>

As mentioned above, we want to view a specific student.
To achieve this, we need to create another view.
We are going to fetch a student from the database by using their reg_no as used in our Student model.

This same view will be used to update a student instance, hence passing the student instance will pre-populate the form.

def GetStudent(request, **kwargs):
    reg = kwargs.get('reg')
    student = get_object_or_404(Student, reg_no=reg)

    if request.method == "POST":
        form = CreateStudentForm(request.POST, instance=student)
        if form.is_valid():
            form.save()
    else:
        form = CreateStudentForm(instance=student)

    context = {'student':student, 'form': form}
    return render(request, 'std_detail.html', context )

Our std_detail.html will look like this:

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@4.5.3/dist/css/bootstrap.min.css" integrity="sha384-TX8t27EcRE3e/ihU7zmQxVncDAy5uIKz4rEkgIXeMed4M0jlfIDPvg6uqKI2xXr2" crossorigin="anonymous">
    <script src="https://code.jquery.com/jquery-3.5.1.slim.min.js" integrity="sha384-DfXdz2htPH0lsSSs5nCTpuj/zy4C+OGpamoFVy38MVBnE+IbbVYUew+OrCXaRkfj" crossorigin="anonymous"></script>
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@4.5.3/dist/js/bootstrap.bundle.min.js" integrity="sha384-ho+j7jyWK8fNQe+A12Hb8AhRq26LrZ/JpcUGGOn+Y7RsweNrtN/tE3MoK7ZeZDyx" crossorigin="anonymous"></script>

    <title>Good Schools | Student Detail | {{student.reg_no}}</title>
  </head>
  <body>
    <div class="big-box container-fluid d-flex justify-content-center align-items-center">
        <div class="container mt-4 mb-5">
            <h4 class="text-center text-capitalize">{{student.name}}'s Profile</h4>
            <form class="mt-3" method="post">
                {% csrf_token %}
                  <div class="form-group">
                      <div class="row">
                          <div class="col">
                            <label>Name:</label>
                              {{form.name}}
                          </div>
                      </div>
                  </div>
                  <div class="form-group">
                      <div class="row">
                          <div class="col">
                            <label>Reg No.</label>
                              {{form.reg_no}}
                          </div>
                          <div class="col">
                            <label>Stream:</label>
                              {{form.stream}}
                          </div>
                      </div>
                  </div>
                  <div class="form-group">
                    <label>Description:</label>
                      {{form.description}}
                  </div>
                  <div class="form-group">
                      <div class="row">
                        <div class="col d-flex justify-content-center">
                          <button class="btn btn-warning btn-block text-white w-50">Update</button>
                        </div>
                        <div class="col d-flex justify-content-center">
                          <a href="{% url 'delete' id=student.id %}" role="button" class="btn btn-danger btn-block text-white w-50">Delete</a>
                        </div>
                      </div>
                  </div>
            </form>
        </div>
    </div>
    <div class="container d-flex justify-content-center">
      <a href="{% url 'create_student' %}" role="button" class="btn btn-outline-primary btn-block w-25">All Students</a>
    </div>
  </body>
</html>

To delete a student, we will also use their reg_no to fetch them, then proceed to delete them.
Here is the view:

def DeleteStudent(request, **kwargs):
    reg = kwargs.get('reg')
    student = Student.objects.get(reg_no=reg)
    student.delete()
    return redirect('home')

We now need to define our urls so that we can view and access what we have done.
Create a urls.py file in your app and include the following:

from django.urls import path
from .views import CreateStudent,GetStudent, Delete

urlpatterns = [
    path('', CreateStudent, name='create_student'),
    path('std_detail/<str:reg>/', GetStudent, name='std_detail'),
    path('delete/<int:id>', Delete, name='delete'),

Head to your project's url.py and add the following:


from django.urls import path,include
urlpatterns = [
    path('', include("home.urls")),
    path('admin/', admin.site.urls),
]

That's it! Migrate your project and run your server.
You now have your simple CRUD application.

How to set up Postgres in your Django project

JMG — Mon, 16 Nov 2020 10:22:57 +0000

Sqlite3 is the default Django Database Engine, but it is very light-weight.
I am going to show you how to set up and use Postgres DB in your project. Let's get started!

Steps

Install and configure Postgres.
Install dependencies.
Set it up in our Django project.

1. Install and configure Postgres.

Download Postgres here for your operating system.

Install it.
If you run into problems, you can check detailed instructions for your operating system here.
Start your Postgres server/ db.

2. Install dependencies

In your work environment, install psycopg2 using this command: pip install psycopg2

3.Set it up in your Django Project

Make sure that your Postgres server/db is running.
Click here if you don't know how.

Navigate to your project's settings.py file, and replace the DATABASE dictionary with the following:

#myProject/settings.py

...

DATABASES = {

    'default': {

        'ENGINE': 'django.db.backends.postgresql',

        'NAME': ‘<db_name>’,

        'USER': '<db_username>',

        'PASSWORD': '<password>',

        'HOST': '<db_host>',

        'PORT': '<db_port>',

    }

}

...

Use your host as 'localhost' and your port as 5432 (or to whichever port you changed to during configuration).

You can now migrate your database using ./manage.py migrate or python manage.py migrate.
Your Django Project is now using Postgres as its database.