Advantages of Django Class Based Views

Isaiah Olatunbosun — Mon, 03 Oct 2022 19:31:32 +0000

Class-based views are a great way to keep your code DRY and make it easy to reuse. They allow you to create reusable views that can be used in multiple places in your project, so you don't have to repeat yourself.

Class-based views also help keep your classes small and focused. When you use a class-based view, each part of the view is kept in its own class that has only one responsibility: displaying data. This means that if something changes in one part of the view (like its template), it won't affect other parts of the view.

Finally, class-based views are great if you want more flexibility when working with data because they allow you to pass different pieces of information into them based on what's needed for each individual piece of data displayed on the screen at any given time.

REST API CRUD: Updating a spatial database

Isaiah Olatunbosun — Sun, 13 Mar 2022 10:06:22 +0000

In this tutorial, we are going to build a REST API that can be used to update a geospatial database.

Using Flask-Restful, we will perform basic CRUD (create, read, update and delete) operations on spatial data. It is recommended that readers know how to create a geospatial database.

Prerequisites
Setup
Post Request
Get Request
Get coordinate by ID
Update Coordinate
Delete coordinate
Conclusion

Prerequisites

To follow along with this tutorial, you are required to have some knowledge on:

How to create a Flask app
How to use Postman
How to create a geospatial database.

Setup

First, install Flask-Restful by running the command below in your terminal.

pip install flask_restful

Then import the API object from flask_restful and store it in a variable called api.

from flask_restful import Api

api = Api(app)

After creating the api variable, we will need to create our API endpoints. The api object and the add_resource() method will be used to create the endpoints.

POST request

Flask-Restful resources give us access to different HTTP methods. One resource can contain multiple HTTP methods such as: get, post, put, and delete.

Each method will return a value and a response code after execution.

Using the code snippet below, let's create our first class coordinate using the flask_restful resource.

The route will use the post request method for saving coordinates to the database.

from flask_restful import Api, Resource

class Coordinate(Resource):
    def post(self):
        response = {
            "status": 400,
            "message": "Coordinate not saved"
        }

        aoi = request.form.get('aoi')

        file = request.files['coordinate']
        read_file = file.read()
        file_json = json.loads(read_file)

        aoi_coordinate = file_json["features"][0]['geometry']
        coordinate = AoiCoordinate(aoi=aoi, coordinate=json.dumps(aoi_coordinate))

        db.session.add(coordinate)
        db.session.commit()

        response['status'] = 201
        response['message'] = "Coordinate saved successfully"

        return response, 201

We imported Resource from flask_restful and used it in creating the class Coordinate. This enables us to add the post method to the class. This means that it will accept only a post request.

The response variable will be returned to the users after each submission. If the form is not saved successfully, the default response will be returned with a status code of 400 (bad requested) which means the request was not fulfilled.

If the form was saved successfully the updated response will be Coordinate saved successfully and the status code changed to 201 (created) which means the request has been fulfilled.

To make the resource accessible, we will create an endpoint using the api object that was created earlier and the add_resource() method from flask_restful.

The add_resource() method accepts some parameters such as the route and the endpoint.

Let's create our first endpoint.

api.add_resource(Coordinate, "/api/coordinate")

We passed the Coordinate class and the endpoint as parameters to the add_resource() method.

GET request

A GET request is used for retrieving data from the database.

In this method, we will retrieve all the data that has been saved in the geodatabase using the get request method.

class Coordinates(Resource):
    def get(self):
        response = {
            "status": 204,
            "message": "No coordinate available"
        }

        coordinates = AoiCoordinate.query.all()

        if coordinates:
            all_cord = []

            for location in coordinates:
                location_details = {
                    'id': location.id,
                    'location_coordinate': str(to_shape(location.coordinate)),
                    'location_aoi': location.aoi
                }

                all_cord.append(location_details)

            response['status'] = 200
            response['message'] = all_cord

            return response, 200

        return response, 200

We created a new class called Coordinates that will retrieve all the coordinates that are saved in the database.

The naming convention is important in Python because it represents what the class entails.

We only used one method because we want to retrieve the saved data only. If coordinates are fetched from the database, the get method will return the updated response message and 200 status code but if none is available it returns 204.

To create the endpoint, we will also pass the class and endpoint name as parameters to the add_resource method.

# ...
api.add_resource(Coordinates, "/api/coordinates")

Get coordinate by ID

We can retrieve a specific coordinate using its id. It will be passed as a parameter to the URL.

class CoordinateId(Resource):
    def get(self, coordinate_id):
        response = {
            "status": 204,
            "message": "Coordinate not available"
        }

        aoi_details = AoiCoordinate.query.filter_by(id=coordinate_id).first()

        if aoi_details:
            details = {
                "id": aoi_details.id,
                "location_coordinate": str(to_shape(aoi_details.coordinate)),
                "location_aoi": aoi_details.aoi
            }

            response['status'] = 200
            response['message'] = details

            return response, 200

        return response, 204

We created a new class CoordinateId. ID was added to its name because we will retrieve coordinates using their ID.

We added a new parameter cordinate_id to the get method because it will display the ID that is passed to the method. The ID is also passed to the search query to retrieve it from the database.

If the ID is available, it will be displayed and the status code 200 will be returned. If it's not available, the default response message will be displayed and the status code 204 is returned.

The coordinate_id will be passed as a parameter to the URL.

# ...
api.add_resource(CoordinateId, '/api/coordinate/<int:coordinate_id>')

We can only pass an integer to the URL because we specify our variable type as an integer. The coordinate_id will be passed from the URL to the get method, which will be used to fetch the coordinate from our database.

Update coordinate

After retrieving a coordinate using its ID, we can update it by sending a put request from Postman with the updated fields.

 def put(self, coordinate_id):
        response = {
            "status": 204,
            "message": "AOI is not available"
        }

        aoi_details = AoiCoordinate.query.filter_by(id=coordinate_id).first()

        if aoi_details:
            file = request.files['coordinate']

            aoi = request.form.get('aoi')

            read_file = file.read()
            file_json = json.loads(read_file)

            aoi_coordinate = file_json["features"][0]['geometry']
            aoi_details.coordinate = aoi_coordinate
            aoi_details.aoi = aoi

            db.session.commit()

            response['status'] = 200
            response['message'] = "aoi updated successfully"

            return response, 200

        return response, 204

Just like the get method, the put method also accepts the coordinate_id that was passed from the URL, and it will use the same endpoint.

Delete coordinate

This method is used for deleting the selected coordinate by sending a delete request from Postman. We will add the method to the CoordinateId class so that it will receive the coordinate_id.

def delete(self, coordinate_id):
    response = {
        "status": 204,
        "message": "AOI is not available"
    }

    aoi = AoiCoordinate.query.filter_by(id=coordinate_id)

    if aoi:
        db.session.delete(aoi)
        db.session.commit()

        response['status'] = 200
        response['message'] = 'Aoi deleted successfully'

        return response, 200

If the coordinate is deleted successfully, it will return the updated response code and status 200. If not, the default response will be returned.

Conclusion

APIs play a great role in web development because they allow programs to communicate easily and multiple users can have access to the program. It is also a source of income for the developers because users can be charged for using the API.

Building an API that can update spatial records can serve as a spatial data bank that allow users to perform CRUD operations on spatial data accessible from mobile, web, and desktop apps by sending requests to our server. All we need to do is to write documentation on how they can use it.

The code in this tutorial is available on this GitHub repo.

Happy coding!

Abstraction in Python

Isaiah Olatunbosun — Sat, 11 Sep 2021 09:14:03 +0000

Abstraction

In software Engineering, abstraction means the act of hiding irrelevant classes from users to reduce complexity. This means that users can create some functions without worrying about how they work. They know what the function does but they don't need to know the logic behind it. Let's look at our smartphones for instance we can use the camera to take pictures, but we know don't the operations that are happening in the background while taking the picture.

In Python, we can achieve abstraction by using abstract classes and interfaces. You may be wondering, what is an abstract class? It is any class that contains at least one abstract method and cannot be instantiated, but can be subclassed. An abstract class is useful when designing large functions and it also provides large interfaces for the implementation of components. Let's create an abstraction in python using the abc module.

Code

from abc import ABC, abstractmethod

class Shape(ABC):
    # abstract method
    @abstractmethod
    def sides(self):
        print('This is the main class')

    def normal(self):
        print('This is a normal class')


class Triangle(Shape):
    def sides(self):
        print(' Triangle has 3 sides')


class Square(Shape):
    def sides(self):
        print(' Square has 4 sides')

t = Triangle()
t.sides()
t.normal()

s = Square()
s.sides()
s.normal()

Output

Triangle has 3 sides
This is a normal class
Square has 4 sides
This is a normal class

Explaination

We created the abstract base class Shape using the ABC module that was import from Python, and also created an abstract method sides(). The Triangle() and Square() classes inherited the base class and have their own side() methods. The were created and the sides() methods was invoked, The sides() methods, hidden definitions were activated when the user creates the Triangle() and Square() objects and invoked the sides() method. The sides() method defined in the Shape() class in never invoked, while the normal() method is invoked because it is not an abstract method.

Conclusion

Abstraction is important whenever we want to hide core functionalities from users. An abstract class can contain both a normal method and an abstract method. We noticed that abstract method in the abstract class are never activated while the normal method was activated.

DEV Community: Isaiah Olatunbosun

Advantages of Django Class Based Views

REST API CRUD: Updating a spatial database

Table of Contents

Prerequisites

Setup

POST request

GET request

Get coordinate by ID

Update coordinate

Delete coordinate

Conclusion

Abstraction in Python

Abstraction

Code

Output

Explaination

Conclusion